hl-valdemar/brolang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Wiki Activity

package-private visibility

Browse Source
This commit is contained in:
Valdemar Høgsvig Lorenzen
2026-08-01 22:55:35 +02:00
parent 304880a9aa
commit f267e8c3cb
11 changed files with 301 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/parser/parser.odin
+37 -37
View File
@@ -41,7 +41,7 @@ token_text :: proc(parser: ^Parser, tok: token.Token) -> string {
return parser.source_file.text[int(tok.span.start):int(tok.span.end)]
}
file_hidden_name :: proc(parser: ^Parser, name: symbol.Id) -> bool {
package_hidden_name :: proc(parser: ^Parser, name: symbol.Id) -> bool {
for hidden in parser.hidden_names {
if hidden == name {
return true
@@ -435,7 +435,7 @@ parse_type_atom :: proc(parser: ^Parser) -> ast.Type_Syntax {
u32(name.symbol),
u32(qualifier),
u32(parser.file),
!symbol.is_valid(qualifier) && file_hidden_name(parser, name.symbol),
!symbol.is_valid(qualifier) && package_hidden_name(parser, name.symbol),
)
if token_text(parser, name) == "struct_type" &&
current(parser).kind == .Bang && peek(parser).kind == .Left_Paren {
@@ -2559,7 +2559,7 @@ parse_while :: proc(parser: ^Parser) -> ast.Stmt_Id {
return id
}
parse_function :: proc(parser: ^Parser, name: token.Token, c_abi, file_hidden: bool) {
parse_function :: proc(parser: ^Parser, name: token.Token, c_abi, package_hidden: bool) {
advance(parser)
if _, ok := allow(parser, .Left_Paren); !ok {
source.add(parser.diagnostics, current(parser).span, "expected '(' after 'func'")
@@ -2590,7 +2590,7 @@ parse_function :: proc(parser: ^Parser, name: token.Token, c_abi, file_hidden: b
pkg=parser.pkg,
file=parser.file,
c_abi=c_abi,
file_hidden=file_hidden,
package_hidden=package_hidden,
has_body=false,
variadic=variadic,
params=params,
@@ -2609,7 +2609,7 @@ parse_function :: proc(parser: ^Parser, name: token.Token, c_abi, file_hidden: b
pkg=parser.pkg,
file=parser.file,
c_abi=c_abi,
file_hidden=file_hidden,
package_hidden=package_hidden,
has_body=true,
variadic=variadic,
params=params,
@@ -2795,9 +2795,9 @@ parse_inline_union_type :: proc(parser: ^Parser) -> types.Type {
return types.union_anonymous(&parser.module.type_store, fields[:], tag)
}
parse_struct :: proc(parser: ^Parser, name: token.Token, c_layout, file_hidden: bool, is_union := false) {
parse_struct :: proc(parser: ^Parser, name: token.Token, c_layout, package_hidden: bool, is_union := false) {
start := advance(parser)
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), file_hidden=file_hidden)
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), package_hidden=package_hidden)
// A tagged union spells its discriminant in parens: `union(Enum)` reuses an existing
// enum; `union(enum)` synthesizes one from the variant names after the body is parsed.
tag := types.INVALID
@@ -2831,7 +2831,7 @@ parse_struct :: proc(parser: ^Parser, name: token.Token, c_layout, file_hidden:
"native union declarations require a body" if is_union else "native struct declarations require a body",
)
}
if !types.define_record(&parser.module.type_store, id, nil, c_layout, true, is_union, tag=tag, declared_tag=declared_tag) {
if !types.define_record(&parser.module.type_store, id, nil, c_layout, true, is_union, tag=tag, declared_tag=declared_tag, package_hidden=package_hidden) {
source.addf(parser.diagnostics, name.span, "duplicate type declaration '%s'", token_text(parser, name))
}
if !ended_by_newline {
@@ -2868,7 +2868,7 @@ parse_struct :: proc(parser: ^Parser, name: token.Token, c_layout, file_hidden:
if is_union && (inferred_tag || types.is_valid(declared_tag)) {
tag = synthesize_union_tag(parser, fields[:])
}
if !types.define_record(&parser.module.type_store, id, fields[:], c_layout, false, is_union, tag=tag, declared_tag=declared_tag, tuple=tuple) {
if !types.define_record(&parser.module.type_store, id, fields[:], c_layout, false, is_union, tag=tag, declared_tag=declared_tag, tuple=tuple, package_hidden=package_hidden) {
source.addf(parser.diagnostics, name.span, "duplicate type declaration '%s'", token_text(parser, name))
} else if !c_layout && !is_union && !tuple {
for value, index in defaults {
@@ -2887,10 +2887,10 @@ parse_struct :: proc(parser: ^Parser, name: token.Token, c_layout, file_hidden:
_ = finish_statement(parser)
}
parse_opaque :: proc(parser: ^Parser, name: token.Token, file_hidden: bool) {
parse_opaque :: proc(parser: ^Parser, name: token.Token, package_hidden: bool) {
start := advance(parser)
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), file_hidden=file_hidden)
if !types.define_record(&parser.module.type_store, id, nil, false, true, false) {
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), package_hidden=package_hidden)
if !types.define_record(&parser.module.type_store, id, nil, false, true, false, package_hidden=package_hidden) {
source.addf(parser.diagnostics, name.span, "duplicate type declaration '%s'", token_text(parser, name))
}
if current(parser).kind == .Left_Brace {
@@ -2915,11 +2915,11 @@ synthesize_union_tag :: proc(parser: ^Parser, fields: []types.Field) -> types.Ty
return types.enum_anonymous(&parser.module.type_store, members, types.U16)
}
parse_distinct :: proc(parser: ^Parser, name: token.Token, file_hidden: bool) {
parse_distinct :: proc(parser: ^Parser, name: token.Token, package_hidden: bool) {
start := advance(parser)
child := parse_type(parser)
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), file_hidden=file_hidden)
if !types.define_distinct(&parser.module.type_store, id, child) {
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), package_hidden=package_hidden)
if !types.define_distinct(&parser.module.type_store, id, child, package_hidden) {
source.addf(parser.diagnostics, name.span, "duplicate type declaration '%s'", token_text(parser, name))
}
if !types.is_valid(child) {
@@ -2928,7 +2928,7 @@ parse_distinct :: proc(parser: ^Parser, name: token.Token, file_hidden: bool) {
_ = finish_statement(parser)
}
parse_alias :: proc(parser: ^Parser, name: token.Token, file_hidden: bool) {
parse_alias :: proc(parser: ^Parser, name: token.Token, package_hidden: bool) {
start := advance(parser)
saved := parser.cursor
if current(parser).kind == .Identifier && peek(parser).kind == .Dot {
@@ -2945,7 +2945,7 @@ parse_alias :: proc(parser: ^Parser, name: token.Token, file_hidden: bool) {
pkg=parser.pkg,
file=parser.file,
target_pkg=ast.INVALID_PACKAGE,
file_hidden=file_hidden,
package_hidden=package_hidden,
valid=true,
diagnostic=source.INVALID_DIAGNOSTIC,
})
@@ -2956,8 +2956,8 @@ parse_alias :: proc(parser: ^Parser, name: token.Token, file_hidden: bool) {
}
parser.cursor = saved
child := parse_type(parser)
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), file_hidden=file_hidden)
if !types.define_alias(&parser.module.type_store, id, child) {
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), package_hidden=package_hidden)
if !types.define_alias(&parser.module.type_store, id, child, package_hidden) {
source.addf(parser.diagnostics, name.span, "duplicate type declaration '%s'", token_text(parser, name))
}
if !types.is_valid(child) {
@@ -3100,7 +3100,7 @@ parse_inline_enum_type :: proc(parser: ^Parser) -> types.Type {
return types.enum_anonymous(&parser.module.type_store, members[:], backing)
}
parse_enum :: proc(parser: ^Parser, name: token.Token, file_hidden: bool) {
parse_enum :: proc(parser: ^Parser, name: token.Token, package_hidden: bool) {
start := advance(parser)
explicit_backing := false
backing := types.INVALID
@@ -3122,8 +3122,8 @@ parse_enum :: proc(parser: ^Parser, name: token.Token, file_hidden: bool) {
_ = finish_statement(parser)
return
}
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), file_hidden=file_hidden)
if !types.define_enum(&parser.module.type_store, id, backing, members[:], explicit_backing) {
id := types.named(&parser.module.type_store, u32(parser.pkg), u32(name.symbol), file=u32(parser.file), package_hidden=package_hidden)
if !types.define_enum(&parser.module.type_store, id, backing, members[:], explicit_backing, package_hidden) {
source.addf(parser.diagnostics, name.span, "duplicate type declaration '%s'", token_text(parser, name))
}
if explicit_backing && deferred {
@@ -3252,9 +3252,9 @@ parse_test :: proc(parser: ^Parser, name: token.Token) {
}
parse_top_level :: proc(parser: ^Parser) {
hide_token, file_hidden := allow(parser, .Keyword_Hide)
hide_token, package_hidden := allow(parser, .Keyword_Hide)
if current(parser).kind == .Keyword_Test && peek(parser).kind == .Keyword_Import {
if file_hidden {
if package_hidden {
source.add(parser.diagnostics, hide_token.span, "test imports cannot use 'hide'")
}
start := advance(parser)
@@ -3263,7 +3263,7 @@ parse_top_level :: proc(parser: ^Parser) {
return
}
if current(parser).kind == .Keyword_Import {
if file_hidden {
if package_hidden {
source.add(parser.diagnostics, hide_token.span, "imports are already file-local and cannot use 'hide'")
}
start := advance(parser)
@@ -3271,7 +3271,7 @@ parse_top_level :: proc(parser: ^Parser) {
return
}
if current(parser).kind != .Identifier {
message := "expected a declaration name after 'hide'" if file_hidden else "expected a top-level declaration"
message := "expected a declaration name after 'hide'" if package_hidden else "expected a top-level declaration"
source.add(parser.diagnostics, current(parser).span, message)
for current(parser).kind != .Newline && current(parser).kind != .Eof {
advance(parser)
@@ -3281,7 +3281,7 @@ parse_top_level :: proc(parser: ^Parser) {
}
name := advance(parser)
if current(parser).kind == .Keyword_Test {
if file_hidden {
if package_hidden {
source.add(parser.diagnostics, hide_token.span, "test declarations cannot use 'hide'")
}
parse_test(parser, name)
@@ -3292,7 +3292,7 @@ parse_top_level :: proc(parser: ^Parser) {
advance(parser)
skip_newlines(parser)
if current(parser).kind == .Keyword_Import {
if file_hidden {
if package_hidden {
source.add(parser.diagnostics, hide_token.span, "imports are already file-local and cannot use 'hide'")
}
start := advance(parser)
@@ -3303,7 +3303,7 @@ parse_top_level :: proc(parser: ^Parser) {
}
if current(parser).kind == .Keyword_Func || current(parser).kind == .Keyword_C_Func {
c_abi := current(parser).kind == .Keyword_C_Func
parse_function(parser, name, c_abi, file_hidden)
parse_function(parser, name, c_abi, package_hidden)
return
}
type_syntax := types.INVALID
@@ -3324,32 +3324,32 @@ parse_top_level :: proc(parser: ^Parser) {
source.add(parser.diagnostics, span_from(name.span, current(parser).span),
"function declarations do not use '::'; write 'name func(...)' or 'name c_func(...)'")
c_abi := current(parser).kind == .Keyword_C_Func
parse_function(parser, name, c_abi, file_hidden)
parse_function(parser, name, c_abi, package_hidden)
return
}
if operator.kind == .Colon_Colon &&
(current(parser).kind == .Keyword_Struct || current(parser).kind == .Keyword_C_Struct) {
parse_struct(parser, name, current(parser).kind == .Keyword_C_Struct, file_hidden)
parse_struct(parser, name, current(parser).kind == .Keyword_C_Struct, package_hidden)
return
}
if operator.kind == .Colon_Colon && current(parser).kind == .Keyword_Opaque {
parse_opaque(parser, name, file_hidden)
parse_opaque(parser, name, package_hidden)
return
}
if operator.kind == .Colon_Colon && current(parser).kind == .Keyword_Union {
parse_struct(parser, name, false, file_hidden, is_union=true)
parse_struct(parser, name, false, package_hidden, is_union=true)
return
}
if operator.kind == .Colon_Colon && current(parser).kind == .Keyword_Enum {
parse_enum(parser, name, file_hidden)
parse_enum(parser, name, package_hidden)
return
}
if operator.kind == .Colon_Colon && current(parser).kind == .Keyword_Distinct {
parse_distinct(parser, name, file_hidden)
parse_distinct(parser, name, package_hidden)
return
}
if operator.kind == .Colon_Colon && current(parser).kind == .Keyword_Alias {
parse_alias(parser, name, file_hidden)
parse_alias(parser, name, package_hidden)
return
}
@@ -3360,7 +3360,7 @@ parse_top_level :: proc(parser: ^Parser) {
name=name.symbol,
pkg=parser.pkg,
file=parser.file,
file_hidden=file_hidden,
package_hidden=package_hidden,
type=type_syntax,
immutable=operator.kind == .Colon_Colon,
expr=expr,