2021-01-18 13:20:06 +01:00
|
|
|
// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
|
2020-01-06 16:13:12 +01:00
|
|
|
// Use of this source code is governed by an MIT license
|
|
|
|
// that can be found in the LICENSE file.
|
2020-06-06 18:14:00 +02:00
|
|
|
module parser
|
|
|
|
|
2021-01-18 06:03:03 +01:00
|
|
|
import v.ast
|
2021-04-02 00:57:09 +02:00
|
|
|
import v.util
|
2021-05-16 03:51:23 +02:00
|
|
|
import v.token
|
2020-01-22 21:34:38 +01:00
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_array_type() ast.Type {
|
2020-01-06 16:13:12 +01:00
|
|
|
p.check(.lsbr)
|
|
|
|
// fixed array
|
2021-01-18 06:03:03 +01:00
|
|
|
if p.tok.kind in [.number, .name] {
|
|
|
|
mut fixed_size := 0
|
|
|
|
size_expr := p.expr(0)
|
2021-06-13 22:53:38 +02:00
|
|
|
if p.pref.is_fmt {
|
|
|
|
fixed_size = 987654321
|
|
|
|
} else {
|
|
|
|
match size_expr {
|
|
|
|
ast.IntegerLiteral {
|
|
|
|
fixed_size = size_expr.val.int()
|
|
|
|
}
|
|
|
|
ast.Ident {
|
|
|
|
mut show_non_const_error := false
|
|
|
|
if const_field := p.global_scope.find_const('${p.mod}.$size_expr.name') {
|
|
|
|
if const_field.expr is ast.IntegerLiteral {
|
|
|
|
fixed_size = const_field.expr.val.int()
|
|
|
|
} else {
|
|
|
|
show_non_const_error = true
|
|
|
|
}
|
2021-01-18 06:03:03 +01:00
|
|
|
} else {
|
2021-06-13 22:53:38 +02:00
|
|
|
if p.pref.is_fmt {
|
|
|
|
// for vfmt purposes, pretend the constant does exist
|
|
|
|
// it may have been defined in another .v file:
|
|
|
|
fixed_size = 1
|
|
|
|
} else {
|
|
|
|
show_non_const_error = true
|
|
|
|
}
|
2021-01-18 06:03:03 +01:00
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
if show_non_const_error {
|
2021-05-22 15:42:38 +02:00
|
|
|
p.error_with_pos('non-constant array bound `$size_expr.name`',
|
|
|
|
size_expr.pos)
|
|
|
|
}
|
2021-01-18 06:03:03 +01:00
|
|
|
}
|
2021-06-13 22:53:38 +02:00
|
|
|
else {
|
|
|
|
p.error('expecting `int` for fixed size')
|
|
|
|
}
|
2021-01-18 06:03:03 +01:00
|
|
|
}
|
|
|
|
}
|
2020-02-04 12:50:58 +01:00
|
|
|
p.check(.rsbr)
|
2020-02-11 04:45:33 +01:00
|
|
|
elem_type := p.parse_type()
|
2020-12-12 04:06:09 +01:00
|
|
|
if elem_type.idx() == 0 {
|
|
|
|
// error is handled by parse_type
|
|
|
|
return 0
|
|
|
|
}
|
2021-01-20 22:17:49 +01:00
|
|
|
if fixed_size <= 0 {
|
|
|
|
p.error_with_pos('fixed size cannot be zero or negative', size_expr.position())
|
|
|
|
}
|
2020-07-17 19:13:22 +02:00
|
|
|
// sym := p.table.get_type_symbol(elem_type)
|
2021-04-28 21:11:15 +02:00
|
|
|
idx := p.table.find_or_register_array_fixed(elem_type, fixed_size, size_expr)
|
2021-04-15 01:44:11 +02:00
|
|
|
if elem_type.has_flag(.generic) {
|
|
|
|
return ast.new_type(idx).set_flag(.generic)
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
|
|
|
// array
|
2020-01-07 13:10:05 +01:00
|
|
|
p.check(.rsbr)
|
2020-02-10 14:43:17 +01:00
|
|
|
elem_type := p.parse_type()
|
2020-12-11 06:55:39 +01:00
|
|
|
if elem_type.idx() == 0 {
|
|
|
|
// error is set in parse_type
|
|
|
|
return 0
|
|
|
|
}
|
2020-04-23 01:16:58 +02:00
|
|
|
mut nr_dims := 1
|
2020-05-08 13:09:40 +02:00
|
|
|
// detect attr
|
2021-02-24 19:03:53 +01:00
|
|
|
not_attr := p.peek_tok.kind != .name && p.peek_token(2).kind !in [.semicolon, .rsbr]
|
2020-05-08 13:09:40 +02:00
|
|
|
for p.tok.kind == .lsbr && not_attr {
|
2020-05-07 06:51:36 +02:00
|
|
|
p.next()
|
2020-01-07 13:10:05 +01:00
|
|
|
p.check(.rsbr)
|
2020-01-06 16:13:12 +01:00
|
|
|
nr_dims++
|
|
|
|
}
|
2021-01-13 23:43:19 +01:00
|
|
|
idx := p.table.find_or_register_array_with_dims(elem_type, nr_dims)
|
2021-04-15 01:44:11 +02:00
|
|
|
if elem_type.has_flag(.generic) {
|
|
|
|
return ast.new_type(idx).set_flag(.generic)
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_map_type() ast.Type {
|
2020-02-08 16:59:57 +01:00
|
|
|
p.next()
|
2020-02-04 12:50:58 +01:00
|
|
|
if p.tok.kind != .lsbr {
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.map_type
|
2020-02-04 12:50:58 +01:00
|
|
|
}
|
2020-01-06 16:13:12 +01:00
|
|
|
p.check(.lsbr)
|
2020-02-08 16:59:57 +01:00
|
|
|
key_type := p.parse_type()
|
2021-02-20 18:39:25 +01:00
|
|
|
key_sym := p.table.get_type_symbol(key_type)
|
|
|
|
is_alias := key_sym.kind == .alias
|
2020-12-12 13:52:22 +01:00
|
|
|
if key_type.idx() == 0 {
|
|
|
|
// error is reported in parse_type
|
|
|
|
return 0
|
|
|
|
}
|
2021-04-28 06:45:21 +02:00
|
|
|
key_type_supported := key_type in [ast.string_type_idx, ast.voidptr_type_idx]
|
2021-05-28 19:09:03 +02:00
|
|
|
|| key_sym.kind == .enum_ || key_sym.kind == .placeholder
|
|
|
|
|| ((key_type.is_int() || key_type.is_float() || is_alias) && !key_type.is_ptr())
|
2021-04-28 06:45:21 +02:00
|
|
|
if !key_type_supported {
|
|
|
|
if is_alias {
|
|
|
|
p.error('cannot use the alias type as the parent type is unsupported')
|
|
|
|
return 0
|
|
|
|
}
|
2020-12-27 14:18:46 +01:00
|
|
|
s := p.table.type_to_str(key_type)
|
2021-02-20 18:39:25 +01:00
|
|
|
p.error_with_pos('maps only support string, integer, float, rune, enum or voidptr keys for now (not `$s`)',
|
2020-12-27 14:18:46 +01:00
|
|
|
p.tok.position())
|
2020-12-04 19:34:05 +01:00
|
|
|
return 0
|
2020-02-08 16:59:57 +01:00
|
|
|
}
|
2020-01-06 16:13:12 +01:00
|
|
|
p.check(.rsbr)
|
2020-02-08 16:59:57 +01:00
|
|
|
value_type := p.parse_type()
|
2020-12-12 13:52:22 +01:00
|
|
|
if value_type.idx() == 0 {
|
|
|
|
// error is reported in parse_type
|
|
|
|
return 0
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
if value_type.idx() == ast.void_type_idx {
|
2021-01-24 00:06:43 +01:00
|
|
|
p.error_with_pos('map value type cannot be void', p.tok.position())
|
|
|
|
return 0
|
|
|
|
}
|
2020-02-08 16:59:57 +01:00
|
|
|
idx := p.table.find_or_register_map(key_type, value_type)
|
2021-04-15 01:44:11 +02:00
|
|
|
if key_type.has_flag(.generic) || value_type.has_flag(.generic) {
|
|
|
|
return ast.new_type(idx).set_flag(.generic)
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_chan_type() ast.Type {
|
2021-02-22 14:08:52 +01:00
|
|
|
if p.peek_tok.kind != .name && p.peek_tok.kind != .key_mut && p.peek_tok.kind != .amp
|
|
|
|
&& p.peek_tok.kind != .lsbr {
|
2020-08-31 10:44:39 +02:00
|
|
|
p.next()
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.chan_type
|
2020-08-30 08:55:31 +02:00
|
|
|
}
|
2020-08-31 10:44:39 +02:00
|
|
|
p.register_auto_import('sync')
|
|
|
|
p.next()
|
2020-09-06 21:24:41 +02:00
|
|
|
is_mut := p.tok.kind == .key_mut
|
2020-08-14 21:18:42 +02:00
|
|
|
elem_type := p.parse_type()
|
2020-09-06 21:24:41 +02:00
|
|
|
idx := p.table.find_or_register_chan(elem_type, is_mut)
|
2021-04-15 01:44:11 +02:00
|
|
|
if elem_type.has_flag(.generic) {
|
|
|
|
return ast.new_type(idx).set_flag(.generic)
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2020-08-14 21:18:42 +02:00
|
|
|
}
|
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_thread_type() ast.Type {
|
2021-02-27 09:16:55 +01:00
|
|
|
is_opt := p.peek_tok.kind == .question
|
|
|
|
if is_opt {
|
|
|
|
p.next()
|
|
|
|
}
|
2021-02-22 14:08:52 +01:00
|
|
|
if p.peek_tok.kind != .name && p.peek_tok.kind != .key_mut && p.peek_tok.kind != .amp
|
|
|
|
&& p.peek_tok.kind != .lsbr {
|
|
|
|
p.next()
|
2021-02-27 09:16:55 +01:00
|
|
|
if is_opt {
|
2021-04-02 00:57:09 +02:00
|
|
|
mut ret_type := ast.void_type
|
2021-02-27 09:16:55 +01:00
|
|
|
ret_type = ret_type.set_flag(.optional)
|
|
|
|
idx := p.table.find_or_register_thread(ret_type)
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2021-02-27 09:16:55 +01:00
|
|
|
} else {
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.thread_type
|
2021-02-27 09:16:55 +01:00
|
|
|
}
|
2021-02-22 14:08:52 +01:00
|
|
|
}
|
2021-02-27 09:16:55 +01:00
|
|
|
if !is_opt {
|
|
|
|
p.next()
|
|
|
|
}
|
|
|
|
ret_type := p.parse_type()
|
|
|
|
idx := p.table.find_or_register_thread(ret_type)
|
2021-04-15 01:44:11 +02:00
|
|
|
if ret_type.has_flag(.generic) {
|
|
|
|
return ast.new_type(idx).set_flag(.generic)
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2021-02-22 14:08:52 +01:00
|
|
|
}
|
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_multi_return_type() ast.Type {
|
2020-01-06 16:13:12 +01:00
|
|
|
p.check(.lpar)
|
2021-04-02 00:57:09 +02:00
|
|
|
mut mr_types := []ast.Type{}
|
2021-04-15 01:44:11 +02:00
|
|
|
mut has_generic := false
|
2020-12-12 04:06:09 +01:00
|
|
|
for p.tok.kind != .eof {
|
2020-02-06 13:57:35 +01:00
|
|
|
mr_type := p.parse_type()
|
2020-12-12 13:52:22 +01:00
|
|
|
if mr_type.idx() == 0 {
|
|
|
|
break
|
|
|
|
}
|
2021-04-15 01:44:11 +02:00
|
|
|
if mr_type.has_flag(.generic) {
|
|
|
|
has_generic = true
|
|
|
|
}
|
2020-02-06 13:57:35 +01:00
|
|
|
mr_types << mr_type
|
2020-01-06 16:13:12 +01:00
|
|
|
if p.tok.kind == .comma {
|
2020-05-07 06:51:36 +02:00
|
|
|
p.next()
|
2020-04-16 15:40:21 +02:00
|
|
|
} else {
|
2020-01-06 16:13:12 +01:00
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
p.check(.rpar)
|
2021-01-23 22:41:32 +01:00
|
|
|
if mr_types.len == 1 {
|
|
|
|
// no multi return type needed
|
|
|
|
return mr_types[0]
|
|
|
|
}
|
2020-02-06 13:57:35 +01:00
|
|
|
idx := p.table.find_or_register_multi_return(mr_types)
|
2021-04-15 01:44:11 +02:00
|
|
|
if has_generic {
|
|
|
|
return ast.new_type(idx).set_flag(.generic)
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
|
|
|
|
2020-03-11 16:10:46 +01:00
|
|
|
// given anon name based off signature when `name` is blank
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_fn_type(name string) ast.Type {
|
2020-03-11 16:10:46 +01:00
|
|
|
// p.warn('parse fn')
|
2020-02-11 13:21:41 +01:00
|
|
|
p.check(.key_fn)
|
2021-04-30 12:40:36 +02:00
|
|
|
mut has_generic := false
|
2020-03-31 14:33:16 +02:00
|
|
|
line_nr := p.tok.line_nr
|
2020-06-29 09:21:01 +02:00
|
|
|
args, _, is_variadic := p.fn_args()
|
2021-04-30 12:40:36 +02:00
|
|
|
for arg in args {
|
|
|
|
if arg.typ.has_flag(.generic) {
|
|
|
|
has_generic = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
mut return_type := ast.void_type
|
2021-05-16 03:51:23 +02:00
|
|
|
mut return_type_pos := token.Position{}
|
2021-06-03 01:55:58 +02:00
|
|
|
if p.tok.line_nr == line_nr && p.tok.kind.is_start_of_type() && !p.is_attributes() {
|
2021-05-16 03:51:23 +02:00
|
|
|
return_type_pos = p.tok.position()
|
2020-03-11 16:10:46 +01:00
|
|
|
return_type = p.parse_type()
|
2021-04-30 12:40:36 +02:00
|
|
|
if return_type.has_flag(.generic) {
|
|
|
|
has_generic = true
|
|
|
|
}
|
2021-05-16 03:51:23 +02:00
|
|
|
return_type_pos = return_type_pos.extend(p.prev_tok.position())
|
2020-02-11 13:21:41 +01:00
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
func := ast.Fn{
|
2020-03-11 16:10:46 +01:00
|
|
|
name: name
|
2020-09-27 03:32:56 +02:00
|
|
|
params: args
|
2020-03-11 16:10:46 +01:00
|
|
|
is_variadic: is_variadic
|
|
|
|
return_type: return_type
|
2021-05-16 03:51:23 +02:00
|
|
|
return_type_pos: return_type_pos
|
2020-03-11 16:10:46 +01:00
|
|
|
}
|
2021-01-13 23:43:19 +01:00
|
|
|
// MapFooFn typedefs are manually added in cheaders.v
|
2020-12-27 14:18:46 +01:00
|
|
|
// because typedefs get generated after the map struct is generated
|
|
|
|
has_decl := p.builtin_mod && name.starts_with('Map') && name.ends_with('Fn')
|
|
|
|
idx := p.table.find_or_register_fn_type(p.mod, func, false, has_decl)
|
2021-04-30 12:40:36 +02:00
|
|
|
if has_generic {
|
|
|
|
return ast.new_type(idx).set_flag(.generic)
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2020-02-03 07:02:54 +01:00
|
|
|
}
|
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_type_with_mut(is_mut bool) ast.Type {
|
2020-04-16 15:40:21 +02:00
|
|
|
typ := p.parse_type()
|
|
|
|
if is_mut {
|
2020-04-25 09:54:32 +02:00
|
|
|
return typ.set_nr_muls(1)
|
2020-04-16 15:40:21 +02:00
|
|
|
}
|
|
|
|
return typ
|
|
|
|
}
|
|
|
|
|
2020-07-05 19:29:39 +02:00
|
|
|
// Parses any language indicators on a type.
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_language() ast.Language {
|
2020-07-05 19:29:39 +02:00
|
|
|
language := if p.tok.lit == 'C' {
|
2021-04-02 00:57:09 +02:00
|
|
|
ast.Language.c
|
2020-07-05 19:29:39 +02:00
|
|
|
} else if p.tok.lit == 'JS' {
|
2021-04-02 00:57:09 +02:00
|
|
|
ast.Language.js
|
2020-07-05 19:29:39 +02:00
|
|
|
} else {
|
2021-04-02 00:57:09 +02:00
|
|
|
ast.Language.v
|
2020-07-05 19:29:39 +02:00
|
|
|
}
|
|
|
|
if language != .v {
|
|
|
|
p.next()
|
|
|
|
p.check(.dot)
|
|
|
|
}
|
|
|
|
return language
|
|
|
|
}
|
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_type() ast.Type {
|
2020-02-15 13:37:48 +01:00
|
|
|
// optional
|
2020-04-23 01:16:58 +02:00
|
|
|
mut is_optional := false
|
2020-02-15 13:37:48 +01:00
|
|
|
if p.tok.kind == .question {
|
2020-07-05 19:29:39 +02:00
|
|
|
line_nr := p.tok.line_nr
|
2020-02-15 13:37:48 +01:00
|
|
|
p.next()
|
|
|
|
is_optional = true
|
2020-07-05 19:29:39 +02:00
|
|
|
if p.tok.line_nr > line_nr {
|
2021-04-02 00:57:09 +02:00
|
|
|
mut typ := ast.void_type
|
2020-07-05 19:29:39 +02:00
|
|
|
if is_optional {
|
|
|
|
typ = typ.set_flag(.optional)
|
|
|
|
}
|
|
|
|
return typ
|
|
|
|
}
|
2020-02-15 13:37:48 +01:00
|
|
|
}
|
2020-07-07 01:57:31 +02:00
|
|
|
is_shared := p.tok.kind == .key_shared
|
|
|
|
is_atomic := p.tok.kind == .key_atomic
|
2021-02-08 00:28:29 +01:00
|
|
|
if is_shared {
|
|
|
|
p.register_auto_import('sync')
|
|
|
|
}
|
2020-04-23 01:16:58 +02:00
|
|
|
mut nr_muls := 0
|
2020-07-07 01:57:31 +02:00
|
|
|
if p.tok.kind == .key_mut || is_shared || is_atomic {
|
2020-04-01 23:56:55 +02:00
|
|
|
nr_muls++
|
|
|
|
p.next()
|
|
|
|
}
|
2020-08-16 19:16:59 +02:00
|
|
|
if p.tok.kind == .mul {
|
|
|
|
p.error('use `&Type` instead of `*Type` when declaring references')
|
2020-12-04 19:34:05 +01:00
|
|
|
return 0
|
2020-08-16 19:16:59 +02:00
|
|
|
}
|
2020-10-06 08:38:07 +02:00
|
|
|
mut nr_amps := 0
|
2020-04-01 23:56:55 +02:00
|
|
|
// &Type
|
2020-06-13 00:01:44 +02:00
|
|
|
for p.tok.kind == .amp {
|
2020-10-06 08:38:07 +02:00
|
|
|
nr_amps++
|
2020-06-13 00:01:44 +02:00
|
|
|
nr_muls++
|
2020-03-28 15:15:10 +01:00
|
|
|
p.next()
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
2020-07-05 19:29:39 +02:00
|
|
|
language := p.parse_language()
|
2021-04-02 00:57:09 +02:00
|
|
|
mut typ := ast.void_type
|
2020-10-06 06:53:48 +02:00
|
|
|
is_array := p.tok.kind == .lsbr
|
2020-05-15 15:55:03 +02:00
|
|
|
if p.tok.kind != .lcbr {
|
2020-06-02 17:24:24 +02:00
|
|
|
pos := p.tok.position()
|
2020-07-25 00:02:44 +02:00
|
|
|
typ = p.parse_any_type(language, nr_muls > 0, true)
|
2020-12-11 06:55:39 +01:00
|
|
|
if typ.idx() == 0 {
|
|
|
|
// error is set in parse_type
|
|
|
|
return 0
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
if typ == ast.void_type {
|
2020-06-02 17:24:24 +02:00
|
|
|
p.error_with_pos('use `?` instead of `?void`', pos)
|
2020-12-04 19:34:05 +01:00
|
|
|
return 0
|
2020-06-02 17:24:24 +02:00
|
|
|
}
|
2020-05-15 15:55:03 +02:00
|
|
|
}
|
2020-02-21 11:44:06 +01:00
|
|
|
if is_optional {
|
2020-04-25 09:08:53 +02:00
|
|
|
typ = typ.set_flag(.optional)
|
2020-02-16 11:48:29 +01:00
|
|
|
}
|
2020-07-04 12:44:25 +02:00
|
|
|
if is_shared {
|
|
|
|
typ = typ.set_flag(.shared_f)
|
|
|
|
}
|
2020-07-07 01:57:31 +02:00
|
|
|
if is_atomic {
|
|
|
|
typ = typ.set_flag(.atomic_f)
|
2020-07-04 12:44:25 +02:00
|
|
|
}
|
2020-02-21 11:44:06 +01:00
|
|
|
if nr_muls > 0 {
|
2020-04-25 09:54:32 +02:00
|
|
|
typ = typ.set_nr_muls(nr_muls)
|
2020-10-06 08:38:07 +02:00
|
|
|
if is_array && nr_amps > 0 {
|
2020-10-06 06:53:48 +02:00
|
|
|
p.error('V arrays are already references behind the scenes,
|
|
|
|
there is no need to use a reference to an array (e.g. use `[]string` instead of `&[]string`).
|
|
|
|
If you need to modify an array in a function, use a mutable argument instead: `fn foo(mut s []string) {}`.')
|
2020-12-04 19:34:05 +01:00
|
|
|
return 0
|
2020-10-06 06:53:48 +02:00
|
|
|
}
|
2020-02-21 11:44:06 +01:00
|
|
|
}
|
|
|
|
return typ
|
|
|
|
}
|
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_any_type(language ast.Language, is_ptr bool, check_dot bool) ast.Type {
|
2020-04-23 01:16:58 +02:00
|
|
|
mut name := p.tok.lit
|
2020-05-19 17:12:47 +02:00
|
|
|
if language == .c {
|
2020-02-29 11:47:47 +01:00
|
|
|
name = 'C.$name'
|
2020-05-19 17:12:47 +02:00
|
|
|
} else if language == .js {
|
2020-04-15 23:16:49 +02:00
|
|
|
name = 'JS.$name'
|
2020-07-25 00:02:44 +02:00
|
|
|
} else if p.peek_tok.kind == .dot && check_dot {
|
2020-04-16 15:40:21 +02:00
|
|
|
// `module.Type`
|
2020-02-12 17:39:35 +01:00
|
|
|
// /if !(p.tok.lit in p.table.imports) {
|
2021-05-04 10:31:31 +02:00
|
|
|
mut mod := name
|
|
|
|
mut mod_pos := p.tok.position()
|
|
|
|
p.next()
|
|
|
|
p.check(.dot)
|
|
|
|
mut mod_last_part := mod
|
|
|
|
for p.peek_tok.kind == .dot {
|
|
|
|
mod_pos = mod_pos.extend(p.tok.position())
|
|
|
|
mod_last_part = p.tok.lit
|
|
|
|
mod += '.$mod_last_part'
|
|
|
|
p.next()
|
|
|
|
p.check(.dot)
|
|
|
|
}
|
2021-05-05 13:09:30 +02:00
|
|
|
if !p.known_import(mod) && !p.pref.is_fmt {
|
2021-05-04 10:31:31 +02:00
|
|
|
mut msg := 'unknown module `$mod`'
|
|
|
|
if mod.len > mod_last_part.len && p.known_import(mod_last_part) {
|
|
|
|
msg += '; did you mean `$mod_last_part`?'
|
|
|
|
}
|
|
|
|
p.error_with_pos(msg, mod_pos)
|
2020-12-04 19:34:05 +01:00
|
|
|
return 0
|
2020-02-12 01:16:38 +01:00
|
|
|
}
|
2021-05-04 10:31:31 +02:00
|
|
|
if mod in p.imports {
|
|
|
|
p.register_used_import(mod)
|
2021-05-05 13:09:30 +02:00
|
|
|
mod = p.imports[mod]
|
2020-05-14 17:14:24 +02:00
|
|
|
}
|
2020-02-20 11:13:18 +01:00
|
|
|
// prefix with full module
|
2021-05-05 13:09:30 +02:00
|
|
|
name = '${mod}.$p.tok.lit'
|
2020-12-12 04:06:09 +01:00
|
|
|
if p.tok.lit.len > 0 && !p.tok.lit[0].is_capital() {
|
2020-08-16 19:16:59 +02:00
|
|
|
p.error('imported types must start with a capital letter')
|
2020-12-04 19:34:05 +01:00
|
|
|
return 0
|
2020-08-16 19:16:59 +02:00
|
|
|
}
|
2020-11-23 23:21:11 +01:00
|
|
|
} else if p.expr_mod != '' && !p.in_generic_params { // p.expr_mod is from the struct and not from the generic parameter
|
2020-02-27 00:12:37 +01:00
|
|
|
name = p.expr_mod + '.' + name
|
2020-12-07 18:13:03 +01:00
|
|
|
} else if name in p.imported_symbols {
|
|
|
|
name = p.imported_symbols[name]
|
2021-01-17 05:31:41 +01:00
|
|
|
} else if !p.builtin_mod && name.len > 1 && name !in p.table.type_idxs {
|
2020-04-16 15:40:21 +02:00
|
|
|
// `Foo` in module `mod` means `mod.Foo`
|
2020-02-16 11:48:29 +01:00
|
|
|
name = p.mod + '.' + name
|
2020-02-12 01:16:38 +01:00
|
|
|
}
|
2020-02-16 11:48:29 +01:00
|
|
|
// p.warn('get type $name')
|
2020-01-06 16:13:12 +01:00
|
|
|
match p.tok.kind {
|
2020-02-03 07:02:54 +01:00
|
|
|
.key_fn {
|
2020-04-16 15:40:21 +02:00
|
|
|
// func
|
2020-03-11 16:10:46 +01:00
|
|
|
return p.parse_fn_type('')
|
2020-02-03 07:02:54 +01:00
|
|
|
}
|
2020-01-06 16:13:12 +01:00
|
|
|
.lsbr {
|
2020-04-16 15:40:21 +02:00
|
|
|
// array
|
2020-02-21 22:50:21 +01:00
|
|
|
return p.parse_array_type()
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
|
|
|
.lpar {
|
2020-04-16 15:40:21 +02:00
|
|
|
// multiple return
|
2020-02-21 22:50:21 +01:00
|
|
|
if is_ptr {
|
2020-02-10 08:32:08 +01:00
|
|
|
p.error('parse_type: unexpected `&` before multiple returns')
|
2020-12-04 19:34:05 +01:00
|
|
|
return 0
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
2020-02-10 08:32:08 +01:00
|
|
|
return p.parse_multi_return_type()
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
|
|
|
else {
|
2021-04-27 00:42:16 +02:00
|
|
|
// no p.next()
|
2020-02-08 16:59:57 +01:00
|
|
|
if name == 'map' {
|
2020-02-21 22:50:21 +01:00
|
|
|
return p.parse_map_type()
|
2020-02-08 16:59:57 +01:00
|
|
|
}
|
2020-08-14 21:18:42 +02:00
|
|
|
if name == 'chan' {
|
|
|
|
return p.parse_chan_type()
|
|
|
|
}
|
2021-02-22 14:08:52 +01:00
|
|
|
if name == 'thread' {
|
|
|
|
return p.parse_thread_type()
|
|
|
|
}
|
2021-04-27 00:42:16 +02:00
|
|
|
mut ret := ast.Type(0)
|
2020-08-16 19:16:59 +02:00
|
|
|
if name == '' {
|
|
|
|
// This means the developer is using some wrong syntax like `x: int` instead of `x int`
|
2020-12-10 10:56:08 +01:00
|
|
|
p.error('expecting type declaration')
|
2021-04-27 00:42:16 +02:00
|
|
|
} else {
|
|
|
|
match name {
|
|
|
|
'voidptr' {
|
|
|
|
ret = ast.voidptr_type
|
|
|
|
}
|
|
|
|
'byteptr' {
|
|
|
|
ret = ast.byteptr_type
|
|
|
|
}
|
|
|
|
'charptr' {
|
|
|
|
ret = ast.charptr_type
|
|
|
|
}
|
|
|
|
'i8' {
|
|
|
|
ret = ast.i8_type
|
|
|
|
}
|
|
|
|
'i16' {
|
|
|
|
ret = ast.i16_type
|
|
|
|
}
|
|
|
|
'int' {
|
|
|
|
ret = ast.int_type
|
|
|
|
}
|
|
|
|
'i64' {
|
|
|
|
ret = ast.i64_type
|
|
|
|
}
|
|
|
|
'byte' {
|
|
|
|
ret = ast.byte_type
|
|
|
|
}
|
|
|
|
'u16' {
|
|
|
|
ret = ast.u16_type
|
|
|
|
}
|
|
|
|
'u32' {
|
|
|
|
ret = ast.u32_type
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
2021-04-27 00:42:16 +02:00
|
|
|
'u64' {
|
|
|
|
ret = ast.u64_type
|
|
|
|
}
|
|
|
|
'f32' {
|
|
|
|
ret = ast.f32_type
|
|
|
|
}
|
|
|
|
'f64' {
|
|
|
|
ret = ast.f64_type
|
|
|
|
}
|
|
|
|
'string' {
|
|
|
|
ret = ast.string_type
|
|
|
|
}
|
|
|
|
'char' {
|
|
|
|
ret = ast.char_type
|
|
|
|
}
|
|
|
|
'bool' {
|
|
|
|
ret = ast.bool_type
|
|
|
|
}
|
|
|
|
'float_literal' {
|
|
|
|
ret = ast.float_literal_type
|
|
|
|
}
|
|
|
|
'int_literal' {
|
|
|
|
ret = ast.int_literal_type
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
p.next()
|
|
|
|
if name.len == 1 && name[0].is_capital() {
|
|
|
|
return p.parse_generic_template_type(name)
|
|
|
|
}
|
|
|
|
if p.tok.kind == .lt {
|
|
|
|
return p.parse_generic_struct_inst_type(name)
|
|
|
|
}
|
|
|
|
return p.parse_enum_or_struct_type(name, language)
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
2020-04-16 15:40:21 +02:00
|
|
|
}
|
2021-04-27 00:42:16 +02:00
|
|
|
p.next()
|
|
|
|
return ret
|
2020-01-06 16:13:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-06-29 20:09:09 +02:00
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_enum_or_struct_type(name string, language ast.Language) ast.Type {
|
2020-06-29 20:09:09 +02:00
|
|
|
// struct / enum / placeholder
|
|
|
|
// struct / enum
|
|
|
|
mut idx := p.table.find_type_idx(name)
|
|
|
|
if idx > 0 {
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|
|
|
|
// not found - add placeholder
|
2020-11-03 08:35:35 +01:00
|
|
|
idx = p.table.add_placeholder_type(name, language)
|
2020-06-29 20:09:09 +02:00
|
|
|
// println('NOT FOUND: $name - adding placeholder - $idx')
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_generic_template_type(name string) ast.Type {
|
2020-06-29 20:09:09 +02:00
|
|
|
mut idx := p.table.find_type_idx(name)
|
|
|
|
if idx > 0 {
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx).set_flag(.generic)
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
idx = p.table.register_type_symbol(ast.TypeSymbol{
|
2020-06-29 20:09:09 +02:00
|
|
|
name: name
|
2020-11-29 14:10:45 +01:00
|
|
|
cname: util.no_dots(name)
|
2020-10-08 07:02:04 +02:00
|
|
|
mod: p.mod
|
2020-06-29 20:09:09 +02:00
|
|
|
kind: .any
|
|
|
|
is_public: true
|
|
|
|
})
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx).set_flag(.generic)
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|
|
|
|
|
2021-04-02 00:57:09 +02:00
|
|
|
pub fn (mut p Parser) parse_generic_struct_inst_type(name string) ast.Type {
|
2020-06-29 20:09:09 +02:00
|
|
|
mut bs_name := name
|
2020-12-01 11:17:19 +01:00
|
|
|
mut bs_cname := name
|
2020-06-29 20:09:09 +02:00
|
|
|
p.next()
|
2020-11-23 23:21:11 +01:00
|
|
|
p.in_generic_params = true
|
2020-06-29 20:09:09 +02:00
|
|
|
bs_name += '<'
|
2020-12-01 11:17:19 +01:00
|
|
|
bs_cname += '_T_'
|
2021-04-22 17:21:01 +02:00
|
|
|
mut concrete_types := []ast.Type{}
|
2020-06-29 20:09:09 +02:00
|
|
|
mut is_instance := false
|
2020-12-12 14:20:38 +01:00
|
|
|
for p.tok.kind != .eof {
|
2020-06-29 20:09:09 +02:00
|
|
|
gt := p.parse_type()
|
|
|
|
if !gt.has_flag(.generic) {
|
|
|
|
is_instance = true
|
|
|
|
}
|
|
|
|
gts := p.table.get_type_symbol(gt)
|
|
|
|
bs_name += gts.name
|
2020-12-14 16:52:20 +01:00
|
|
|
bs_cname += gts.cname
|
2021-04-22 17:21:01 +02:00
|
|
|
concrete_types << gt
|
2020-06-29 20:09:09 +02:00
|
|
|
if p.tok.kind != .comma {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
p.next()
|
|
|
|
bs_name += ','
|
2020-12-01 11:17:19 +01:00
|
|
|
bs_cname += '_'
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|
|
|
|
p.check(.gt)
|
2020-11-23 23:21:11 +01:00
|
|
|
p.in_generic_params = false
|
2020-06-29 20:09:09 +02:00
|
|
|
bs_name += '>'
|
2021-05-19 20:25:02 +02:00
|
|
|
// fmt operates on a per-file basis, so is_instance might be not set correctly. Thus it's ignored.
|
|
|
|
if (is_instance || p.pref.is_fmt) && concrete_types.len > 0 {
|
2020-06-29 20:09:09 +02:00
|
|
|
mut gt_idx := p.table.find_type_idx(bs_name)
|
|
|
|
if gt_idx > 0 {
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(gt_idx)
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|
2020-11-03 08:35:35 +01:00
|
|
|
gt_idx = p.table.add_placeholder_type(bs_name, .v)
|
2020-11-23 23:21:11 +01:00
|
|
|
mut parent_idx := p.table.type_idxs[name]
|
|
|
|
if parent_idx == 0 {
|
|
|
|
parent_idx = p.table.add_placeholder_type(name, .v)
|
|
|
|
}
|
2021-04-02 00:57:09 +02:00
|
|
|
idx := p.table.register_type_symbol(ast.TypeSymbol{
|
2020-06-30 01:22:15 +02:00
|
|
|
kind: .generic_struct_inst
|
2020-06-29 20:09:09 +02:00
|
|
|
name: bs_name
|
2020-12-01 11:17:19 +01:00
|
|
|
cname: util.no_dots(bs_cname)
|
2020-10-08 07:02:04 +02:00
|
|
|
mod: p.mod
|
2021-04-02 00:57:09 +02:00
|
|
|
info: ast.GenericStructInst{
|
2020-11-23 23:21:11 +01:00
|
|
|
parent_idx: parent_idx
|
2021-04-22 17:21:01 +02:00
|
|
|
concrete_types: concrete_types
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|
|
|
|
})
|
2021-04-02 00:57:09 +02:00
|
|
|
return ast.new_type(idx)
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|
2021-04-19 13:47:39 +02:00
|
|
|
return p.parse_enum_or_struct_type(name, .v).set_flag(.generic)
|
2020-06-29 20:09:09 +02:00
|
|
|
}
|