From e5e84bb735bb9d7dd03168d182be008ff5cae495 Mon Sep 17 00:00:00 2001 From: Guillaume Marques Date: Fri, 20 Dec 2024 23:21:25 +0100 Subject: [PATCH 1/2] highlight field expression types --- languages/julia/highlights.scm | 22 +++++++++++++++++----- syntax-test-cases/edge-cases.jl | 30 +++++++++++++++++++++++++++--- 2 files changed, 44 insertions(+), 8 deletions(-) diff --git a/languages/julia/highlights.scm b/languages/julia/highlights.scm index 9309599..7ad8c3a 100644 --- a/languages/julia/highlights.scm +++ b/languages/julia/highlights.scm @@ -68,15 +68,27 @@ ; Type annotations (parametrized_type_expression [ - (identifier) @type - (field_expression - (identifier) @type .) + (identifier) @type + (field_expression (identifier) @type (identifier) @type) + (field_expression ((field_expression (identifier) @type (identifier) @type) (identifier) @type)) + (_) @type ] (curly_expression - (_) @type)) + [ + (identifier) @type + (field_expression (identifier) @type (identifier) @type) + (field_expression ((field_expression (identifier) @type (identifier) @type) (identifier) @type)) + (_) @type + ])) (typed_expression - (identifier) @type .) + (identifier) + [ + (identifier) @type ; x::T, it tags T as type + (field_expression (identifier) @type (identifier) @type) ; x::Module.T, it tags Module and T as type + (field_expression ((field_expression (identifier) @type (identifier) @type) (identifier) @type)) ; x::Module.SubModule.T + (_) @type ; should tag anything as type (but does not work because the most specific match seems to have priority) + ]) (unary_typed_expression (identifier) @type .) diff --git a/syntax-test-cases/edge-cases.jl b/syntax-test-cases/edge-cases.jl index 56275fd..c532ab0 100644 --- a/syntax-test-cases/edge-cases.jl +++ b/syntax-test-cases/edge-cases.jl @@ -8,7 +8,7 @@ begin # this is a block, not an index end -# ------------ +# ------------ # Zed specials # ------------ @@ -31,8 +31,30 @@ x = var .|> foo |> bar # Function definitions # (highlight the function name as @function.definition) function foo end -function foo(x) 2x end -function Base.foo(x) 2x end +function foo(x) + 2x +end +function Base.foo(x) + 2x +end + +# Types +struct Bar + a::T + b::Module.T # pass + c::Module.Submodule.T # pass + d::Module.Submodule.SubModule.SubSubModule.T # broken + e::Module.Submodule.T{Int} # pass + f::Module.Submodule.T{Module.Int} # pass + g::Module.Submodule.T{Module.SubModule.Int} # pass + h::Module.Submodule.T{Module.SubModule.SubSubModule.Int} # broken +end + +function bar(w::T) end +function bar(x::Module.T) nothing end +function bar(y::Module.Submodule.T) nothing end +function bar(z::Module.Submodule.T{Int}) nothing end + # Short function definitions # (highlight the function name as @function.definition @@ -89,3 +111,5 @@ Docstring with `markdown`. Docstring with `markdown`. """ function Base.foo18() end + +module A end From f67a6ddc3b395d011a78fa6c7dfe337cef200c8b Mon Sep 17 00:00:00 2001 From: Guillaume Marques Date: Sat, 21 Dec 2024 21:25:10 +0100 Subject: [PATCH 2/2] improve --- languages/julia/highlights.scm | 134 +++++++++++++++++++++++++++----- syntax-test-cases/edge-cases.jl | 38 ++++----- 2 files changed, 136 insertions(+), 36 deletions(-) diff --git a/languages/julia/highlights.scm b/languages/julia/highlights.scm index 7ad8c3a..2f033f4 100644 --- a/languages/julia/highlights.scm +++ b/languages/julia/highlights.scm @@ -68,27 +68,89 @@ ; Type annotations (parametrized_type_expression [ - (identifier) @type - (field_expression (identifier) @type (identifier) @type) - (field_expression ((field_expression (identifier) @type (identifier) @type) (identifier) @type)) - (_) @type + ((identifier) @type) ; match T + (field_expression + (identifier) @module + (identifier) @type + ) ; match MyModule.T + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @type) ; match MyModule.MySubModule.T + (field_expression + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @module) + (identifier) @type) ; match MyModule.MySubmodule.MySubSubModule.T) ] (curly_expression - [ - (identifier) @type - (field_expression (identifier) @type (identifier) @type) - (field_expression ((field_expression (identifier) @type (identifier) @type) (identifier) @type)) - (_) @type - ])) + [ + ((identifier) @type) ; match T + (_) @type + (field_expression + (identifier) @module + (identifier) @type + ) ; match MyModule.T + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @type) ; match MyModule.MySubModule.T + (field_expression + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @module) + (identifier) @type) ; match MyModule.MySubmodule.MySubSubModule.T + (unary_expression + (operator) @operator + [ + ((identifier) @type) ; match T + (field_expression + (identifier) @module + (identifier) @type + ) ; match MyModule.T + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @type) ; match MyModule.MySubModule.T + (field_expression + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @module) + (identifier) @type) ; match MyModule.MySubmodule.MySubSubModule.T + ] (#any-of? @operator "<:" ">:")) + ] + )) ; Zed - change to capture types prefixed with module names. (typed_expression (identifier) - [ - (identifier) @type ; x::T, it tags T as type - (field_expression (identifier) @type (identifier) @type) ; x::Module.T, it tags Module and T as type - (field_expression ((field_expression (identifier) @type (identifier) @type) (identifier) @type)) ; x::Module.SubModule.T - (_) @type ; should tag anything as type (but does not work because the most specific match seems to have priority) - ]) + [ + ((identifier) @type) ; match T + (field_expression + (identifier) @module + (identifier) @type + ) ; match MyModule.T + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @type) ; match MyModule.MySubModule.T + (field_expression + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @module) + (identifier) @type) ; match MyModule.MySubmodule.MySubSubModule.T + ]) ; Zed - change to capture types prefixed with module names. (unary_typed_expression (identifier) @type .) @@ -97,9 +159,45 @@ (_) @type .) (binary_expression - (_) @type + [ + ((identifier) @type) ; match T + (field_expression + (identifier) @module + (identifier) @type + ) ; match MyModule.T + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @type) ; match MyModule.MySubModule.T + (field_expression + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @module) + (identifier) @type) ; match MyModule.MySubmodule.MySubSubModule.T + ] (operator) @operator - (_) @type + [ + ((identifier) @type) ; match T + (field_expression + (identifier) @module + (identifier) @type + ) ; match MyModule.T + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @type) ; match MyModule.MySubModule.T + (field_expression + (field_expression + (field_expression + (identifier) @module + (identifier) @module) + (identifier) @module) + (identifier) @type) ; match MyModule.MySubmodule.MySubSubModule.T + ] (#any-of? @operator "<:" ">:")) ; Built-in types diff --git a/syntax-test-cases/edge-cases.jl b/syntax-test-cases/edge-cases.jl index c532ab0..9af703b 100644 --- a/syntax-test-cases/edge-cases.jl +++ b/syntax-test-cases/edge-cases.jl @@ -31,30 +31,34 @@ x = var .|> foo |> bar # Function definitions # (highlight the function name as @function.definition) function foo end -function foo(x) - 2x -end -function Base.foo(x) - 2x -end +function foo(x) 2x end +function Base.foo(x) 2x end # Types struct Bar a::T - b::Module.T # pass - c::Module.Submodule.T # pass - d::Module.Submodule.SubModule.SubSubModule.T # broken - e::Module.Submodule.T{Int} # pass - f::Module.Submodule.T{Module.Int} # pass - g::Module.Submodule.T{Module.SubModule.Int} # pass - h::Module.Submodule.T{Module.SubModule.SubSubModule.Int} # broken + b::MyModule.T # pass + c::MyModule.MySubModule.T # pass + d::MyModule.MySubModule.MySubSubModule.T # pass + d::MyModule.MySubModule.MySubSubModule.MySubSubSubModule.T # broken + e::MyModule.MySubModule.T{Int} # pass + f::MyModule.MySubModule.T{MyModule.Int} # pass + g::MyModule.MySubModule.T{MyModule.MySubModule.Int} # pass + h::MyModule.MySubModule.MySubSubModule.T{MyModule.MySubModule.MySubSubModule.Int} # pass + i::Array{<:MyModule.MySubModule.T} # pass + j::Array{>:MyModule.MySubModule.T} # pass + k::Tuple{MyModule.MySubModule.T,MyModule.MySubModule.U} # pass end function bar(w::T) end -function bar(x::Module.T) nothing end -function bar(y::Module.Submodule.T) nothing end -function bar(z::Module.Submodule.T{Int}) nothing end +function bar(x::MyModule.T, y::MyModule.T) nothing end +function bar(y::MyModule.MySubmodule.T) nothing end +function bar(z::MyModule.MySubmodule.T{MyModule.MySubModule.Int}) nothing end +function bar(z::T) where {T<:MyModule.MySubModule.MySubSubModule.U} nothing end +function bar(z::T) where {T>:MyModule.MySubModule.MySubSubModule.U} nothing end +bar(z::MyModule.MySubmodule.T{MyModule.MySubModule.Int}) where {T<:MyModule.MySubModule.MySubSubModule.U} = nothing +Base.bar(z::MyModule.MySubmodule.T{MyModule.MySubModule.Int}) where {T<:MyModule.MySubModule.MySubSubModule.U} = nothing # Short function definitions # (highlight the function name as @function.definition @@ -111,5 +115,3 @@ Docstring with `markdown`. Docstring with `markdown`. """ function Base.foo18() end - -module A end