Merge pull request #337 from julia-vscode/sp/mutable-struct-const-field

Support const fields in mutable structs

Author: pfitzseb

src/CSTParser.jl

@@ -38,7 +38,7 @@ Acceptable starting tokens are:
 + An `@`.
 
 """
-function parse_expression(ps::ParseState, esc_on_error = false)
+function parse_expression(ps::ParseState, esc_on_error = false; allow_const_field = false)
     if kindof(ps.nt) === Tokens.ENDMARKER
         ret = mErrorToken(ps, UnexpectedToken)
     elseif (esc_on_error && ps.nt.kind == Tokens.ERROR)
@@ -48,7 +48,7 @@ function parse_expression(ps::ParseState, esc_on_error = false)
     else
         next(ps)
         if iskeyword(kindof(ps.t)) && kindof(ps.t) != Tokens.DO
-            ret = parse_kw(ps)
+            ret = parse_kw(ps; allow_const_field = allow_const_field)
         elseif kindof(ps.t) === Tokens.LPAREN
             ret = parse_paren(ps)
         elseif kindof(ps.t) === Tokens.LSQUARE

src/components/internals.jl

@@ -4,7 +4,7 @@ const term_c = (Tokens.RPAREN, Tokens.RSQUARE, Tokens.RBRACE, Tokens.END, Tokens
 Continue parsing statements until an element of `closers` is hit (usually
 `end`). Statements are grouped in a `Block` EXPR.
 """
-function parse_block(ps::ParseState, ret::Vector{EXPR}=EXPR[], closers=(Tokens.END,), docable=false)
+function parse_block(ps::ParseState, ret::Vector{EXPR}=EXPR[], closers=(Tokens.END,), docable=false; allow_const_field = false)
     prevpos = position(ps)
     while kindof(ps.nt) ∉ closers # loop until an expected closer is hit
         if kindof(ps.nt) ∈ term_c # error handling if an unexpected closer is hit
@@ -17,7 +17,7 @@ function parse_block(ps::ParseState, ret::Vector{EXPR}=EXPR[], closers=(Tokens.E
             if docable
                 a = parse_doc(ps)
             else
-                a = parse_expression(ps)
+                a = parse_expression(ps; allow_const_field = allow_const_field)
             end
             push!(ret, a)
         end

src/components/keywords.jl

@@ -3,7 +3,7 @@
 
 Dispatch function for when the parser has reached a keyword.
 """
-function parse_kw(ps::ParseState)
+function parse_kw(ps::ParseState; allow_const_field = false)
     k = kindof(ps.t)
     if ps.closer.precedence == 20 && ps.lt.kind === Tokens.EX_OR && k !== Tokens.END
         return EXPR(:IDENTIFIER, ps)
@@ -52,7 +52,7 @@ function parse_kw(ps::ParseState)
     elseif k === Tokens.BAREMODULE
         return @default ps @closer ps :block parse_blockexpr(ps, :baremodule)
     elseif k === Tokens.CONST
-        return @default ps parse_const(ps)
+        return @default ps parse_const(ps; allow_const_field = allow_const_field)
     elseif k === Tokens.GLOBAL
         return @default ps parse_local_global(ps, false)
     elseif k === Tokens.LOCAL
@@ -85,10 +85,10 @@ function parse_kw(ps::ParseState)
     end
 end
 
-function parse_const(ps::ParseState)
+function parse_const(ps::ParseState; allow_const_field = false)
     kw = EXPR(ps)
     arg = parse_expression(ps)
-    if !(isassignment(unwrapbracket(arg)) || (headof(arg) === :global && length(arg.args) > 0 && isassignment(unwrapbracket(arg.args[1]))))
+    if !allow_const_field && !(isassignment(unwrapbracket(arg)) || (headof(arg) === :global && length(arg.args) > 0 && isassignment(unwrapbracket(arg.args[1]))))
         arg = mErrorToken(ps, arg, ExpectedAssignment)
     end
     ret = EXPR(:const, EXPR[arg], EXPR[kw])
@@ -154,7 +154,7 @@ function parse_mutable(ps::ParseState)
     if kindof(ps.nt) === Tokens.STRUCT
         kw = EXPR(ps)
         next(ps)
-        ret = parse_blockexpr(ps, :mutable)
+        ret = parse_blockexpr(ps, :mutable, allow_const_field = true)
         pushfirst!(ret.trivia, setparent!(kw, ret))
         update_span!(ret)
     else
@@ -300,15 +300,15 @@ function parse_do(ps::ParseState, pre::EXPR)
 end
 
 """
-    parse_blockexpr(ps::ParseState, head)
+    parse_blockexpr(ps::ParseState, head; allow_const_field = false)
 
 General function for parsing block expressions comprised of a series of statements
 terminated by an `end`.
 """
-function parse_blockexpr(ps::ParseState, head)
+function parse_blockexpr(ps::ParseState, head; allow_const_field = false)
     kw = EXPR(ps)
     sig = parse_blockexpr_sig(ps, head)
-    blockargs = parse_block(ps, EXPR[], (Tokens.END,), docable(head))
+    blockargs = parse_block(ps, EXPR[], (Tokens.END,), docable(head); allow_const_field = allow_const_field)
     if head === :begin
         EXPR(:block, blockargs, EXPR[kw, accept_end(ps)])
     elseif sig === nothing

test/parser.jl

@@ -334,25 +334,39 @@ end
             @test "struct a; end" |> test_expr
             @test "struct a; b;end" |> test_expr
             @test """struct a
-            arg1
-        end""" |> test_expr
+                arg1
+            end""" |> test_expr
             @test """struct a <: T
-            arg1::Int
-            arg2::Int
-        end""" |> test_expr
+                arg1::Int
+                arg2::Int
+            end""" |> test_expr
             @test """struct a
-            arg1::T
-        end""" |> test_expr
+                arg1::T
+            end""" |> test_expr
             @test """struct a{T}
-            arg1::T
-            a(args) = new(args)
-        end""" |> test_expr
+                arg1::T
+                a(args) = new(args)
+            end""" |> test_expr
             @test """struct a <: Int
-            arg1::Vector{Int}
-        end""" |> test_expr
+                arg1::Vector{Int}
+            end""" |> test_expr
             @test """mutable struct a <: Int
-            arg1::Vector{Int}
-        end""" |> test_expr
+                arg1::Vector{Int}
+            end""" |> test_expr
+            if VERSION > v"1.8-"
+                @test """mutable struct A
+                    const arg1::Vector{Int}
+                    arg2
+                end""" |> test_expr
+                @test """mutable struct A
+                    const arg1
+                    arg2
+                end""" |> test_expr
+                @test CSTParser.has_error(CSTParser.parse("""struct A
+                    const arg1
+                    arg2
+                end"""))
+            end
         end
     end