mirror/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
Code Issues Projects Releases Wiki Activity

builtin: rename any_* -> *_literal - 2. part (#8032)

Browse Source
This commit is contained in:
Uwe Krüger 2021-01-11 22:58:15 +01:00 committed by GitHub
parent 77d2e82309
commit 5f95dd54bd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 194 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/tools/vdoc/html.v
View File

@ -342,7 +342,7 @@ fn get_src_link(repo_url string, file_name string, line_nr int) string {
fn html_highlight(code string, tb &table.Table) string {
builtin := ['bool', 'string', 'i8', 'i16', 'int', 'i64', 'i128', 'byte', 'u16', 'u32', 'u64',
'u128', 'rune', 'f32', 'f64', 'any_int', 'any_float', 'byteptr', 'voidptr', 'any']
'u128', 'rune', 'f32', 'f64', 'int_literal', 'float_literal', 'byteptr', 'voidptr', 'any']
highlight_code := fn (tok token.Token, typ HighlightTokenTyp) string {
lit := if typ in [.unone, .operator, .punctuation] {
tok.kind.str()

17
doc/docs.md
View File

@ -371,8 +371,6 @@ rune // represents a Unicode code point
f32 f64
any_int, any_float // internal intermediate types of number literals
byteptr, voidptr, charptr, size_t // these are mostly used for C interoperability
any // similar to C's void* and Go's interface{}
@ -400,6 +398,21 @@ or `i64` but not to `f32` or `u32`. (`f32` would mean precision
loss for large values and `u32` would mean loss of the sign for
negative values).
Literals like `123` or `4.56` are treated in a special way. They do
not lead to type promotions, however they default to `int` and `f64`
respectively, when their type has to be decided:
```v ignore
u := u16(12)
v := 13 + u // v is of type `u16` - no promotion
x := f32(45.6)
y := x + 3.14 // x is of type `f32` - no promotion
a := 75 // a is of type `int` - default for int literal
b := 14.7 // b is of type `f64` - default for float literal
c := u + a // c is of type `int` - automatic promotion of `u`'s value
d := b + x // d is of type `f64` - automatic promotion of `x`'s value
```
### Strings
```v

4
vlib/builtin/float.v
View File

@ -20,9 +20,9 @@ pub fn (x f64) str() string {
}
}
// str returns the value of the `any_float` as a `string`.
// str returns the value of the `float_literal` as a `string`.
[inline]
pub fn (d any_float) str() string {
pub fn (d float_literal) str() string {
return f64(d).str()
}

10
vlib/builtin/int.v
View File

@ -162,9 +162,9 @@ pub fn (nn u32) str() string {
// return tos(buf + index, (max-index))
}
// str returns the value of the `any_int` as a `string`.
// str returns the value of the `int_literal` as a `string`.
[inline]
pub fn (n any_int) str() string {
pub fn (n int_literal) str() string {
return i64(n).str()
}
@ -399,9 +399,9 @@ pub fn (nn i64) hex() string {
return u64(nn).hex()
}
// hex returns the value of the `any_int` as a hexadecimal `string`.
// hex returns the value of the `int_literal` as a hexadecimal `string`.
// Note that the output is ***not*** zero padded.
pub fn (nn any_int) hex() string {
pub fn (nn int_literal) hex() string {
return u64(nn).hex()
}
@ -434,7 +434,7 @@ pub fn (nn u64) hex_full() string {
/*
pub fn (nn i64) hex_full() string { return u64_to_hex(u64(nn), 16) }
pub fn (nn any_int) hex_full() string { return u64_to_hex(nn, 16) }
pub fn (nn int_literal) hex_full() string { return u64_to_hex(nn, 16) }
pub fn (nn voidptr) hex_full() string { return u64_to_hex(nn, 16) }
pub fn (nn byteptr) hex_full() string { return u64_to_hex(nn, 16) }
*/

16
vlib/v/checker/check_types.v
View File

@ -217,9 +217,9 @@ fn (c &Checker) promote_num(left_type table.Type, right_type table.Type) table.T
idx_hi := type_hi.idx()
idx_lo := type_lo.idx()
// the following comparisons rely on the order of the indices in atypes.v
if idx_hi == table.any_int_type_idx {
if idx_hi == table.int_literal_type_idx {
return type_lo
} else if idx_hi == table.any_flt_type_idx {
} else if idx_hi == table.float_literal_type_idx {
if idx_lo in table.float_type_idxs {
return type_lo
} else {
@ -232,7 +232,7 @@ fn (c &Checker) promote_num(left_type table.Type, right_type table.Type) table.T
} else {
return type_hi
}
} else { // f64, any_flt
} else { // f64, float_literal
return type_hi
}
} else if idx_lo >= table.byte_type_idx { // both operands are unsigned
@ -276,7 +276,7 @@ pub fn (mut c Checker) check_types(got table.Type, expected table.Type) bool {
// allow direct int-literal assignment for pointers for now
// maybe in the future optionals should be used for that
if expected.is_ptr() || expected.is_pointer() {
if got == table.any_int_type {
if got == table.int_literal_type {
return true
}
}
@ -320,13 +320,13 @@ pub fn (mut c Checker) symmetric_check(left table.Type, right table.Type) bool {
// allow direct int-literal assignment for pointers for now
// maybe in the future optionals should be used for that
if right.is_ptr() || right.is_pointer() {
if left == table.any_int_type {
if left == table.int_literal_type {
return true
}
}
// allow direct int-literal assignment for pointers for now
if left.is_ptr() || left.is_pointer() {
if right == table.any_int_type {
if right == table.int_literal_type {
return true
}
}
@ -338,7 +338,7 @@ pub fn (c &Checker) get_default_fmt(ftyp table.Type, typ table.Type) byte {
return `s`
} else if typ.is_float() {
return `g`
} else if typ.is_signed() || typ.is_any_int() {
} else if typ.is_signed() || typ.is_int_literal() {
return `d`
} else if typ.is_unsigned() {
return `u`
@ -399,7 +399,7 @@ pub fn (mut c Checker) string_inter_lit(mut node ast.StringInterLiteral) table.T
}
if (typ.is_unsigned() && fmt !in [`u`, `x`, `X`, `o`, `c`]) ||
(typ.is_signed() && fmt !in [`d`, `x`, `X`, `o`, `c`]) ||
(typ.is_any_int() && fmt !in [`d`, `c`, `x`, `X`, `o`, `u`, `x`, `X`, `o`]) ||
(typ.is_int_literal() && fmt !in [`d`, `c`, `x`, `X`, `o`, `u`, `x`, `X`, `o`]) ||
(typ.is_float() && fmt !in [`E`, `F`, `G`, `e`, `f`, `g`]) ||
(typ.is_pointer() && fmt !in [`p`, `x`, `X`]) ||
(typ.is_string() && fmt != `s`) ||

48
vlib/v/checker/checker.v
View File

@ -319,7 +319,7 @@ pub fn (mut c Checker) type_decl(node ast.TypeDecl) {
c.check_valid_pascal_case(node.name, 'type alias', node.pos)
}
typ_sym := c.table.get_type_symbol(node.parent_type)
if typ_sym.kind in [.placeholder, .any_int, .any_float] {
if typ_sym.kind in [.placeholder, .int_literal, .float_literal] {
c.error("type `$typ_sym.name` doesn't exist", node.pos)
} else if typ_sym.kind == .alias {
orig_sym := c.table.get_type_symbol((typ_sym.info as table.Alias).parent_type)
@ -356,7 +356,7 @@ pub fn (mut c Checker) type_decl(node ast.TypeDecl) {
if sym.name in names_used {
c.error('sum type $node.name cannot hold the type `$sym.name` more than once',
variant.pos)
} else if sym.kind in [.placeholder, .any_int, .any_float] {
} else if sym.kind in [.placeholder, .int_literal, .float_literal] {
c.error("type `$sym.name` doesn't exist", variant.pos)
} else if sym.kind == .interface_ {
c.error('sum type cannot hold an interface', variant.pos)
@ -400,10 +400,10 @@ pub fn (mut c Checker) struct_decl(mut decl ast.StructDecl) {
c.error(util.new_suggestion(sym.name, c.table.known_type_names()).say('unknown type `$sym.name`'),
field.type_pos)
}
// Separate error condition for `any_int` and `any_float` because `util.suggestion` may give different
// Separate error condition for `int_literal` and `float_literal` because `util.suggestion` may give different
// suggestions due to f32 comparision issue.
if sym.kind in [.any_int, .any_float] {
msg := if sym.kind == .any_int {
if sym.kind in [.int_literal, .float_literal] {
msg := if sym.kind == .int_literal {
'unknown type `$sym.name`.\nDid you mean `int`?'
} else {
'unknown type `$sym.name`.\nDid you mean `f64`?'
@ -2174,7 +2174,7 @@ pub fn (mut c Checker) return_stmt(mut return_stmt ast.Return) {
pos)
}
if (exp_type.is_ptr() || exp_type.is_pointer()) &&
(!got_typ.is_ptr() && !got_typ.is_pointer()) && got_typ != table.any_int_type {
(!got_typ.is_ptr() && !got_typ.is_pointer()) && got_typ != table.int_literal_type {
pos := return_stmt.exprs[i].position()
c.error('fn `$c.cur_fn.name` expects you to return a reference type `${c.table.type_to_str(exp_type)}`, but you are returning `${c.table.type_to_str(got_typ)}` instead',
pos)
@ -2608,7 +2608,7 @@ fn scope_register_ab(mut s ast.Scope, pos token.Position, typ table.Type) {
fn (mut c Checker) check_array_init_para_type(para string, expr ast.Expr, pos token.Position) {
sym := c.table.get_type_symbol(c.expr(expr))
if sym.kind !in [.int, .any_int] {
if sym.kind !in [.int, .int_literal] {
c.error('array $para needs to be an int', pos)
}
}
@ -3207,8 +3207,8 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
return c.chan_init(mut node)
}
ast.CharLiteral {
// return any_int, not rune, so that we can do "bytes << `A`" without a cast etc
// return table.any_int_type
// return int_literal, not rune, so that we can do "bytes << `A`" without a cast etc
// return table.int_literal_type
return table.rune_type
// return table.byte_type
}
@ -3264,7 +3264,7 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
return c.enum_val(mut node)
}
ast.FloatLiteral {
return table.any_flt_type
return table.float_literal_type
}
ast.Ident {
// c.checked_ident = node.name
@ -3289,7 +3289,7 @@ pub fn (mut c Checker) expr(node ast.Expr) table.Type {
return c.infix_expr(mut node)
}
ast.IntegerLiteral {
return table.any_int_type
return table.int_literal_type
}
ast.LockExpr {
return c.lock_expr(mut node)
@ -3390,8 +3390,8 @@ pub fn (mut c Checker) cast_expr(mut node ast.CastExpr) table.Type {
node.pos)
}
if to_type_sym.kind == .sum_type {
if node.expr_type in [table.any_int_type, table.any_flt_type] {
node.expr_type = c.promote_num(node.expr_type, if node.expr_type == table.any_int_type {
if node.expr_type in [table.int_literal_type, table.float_literal_type] {
node.expr_type = c.promote_num(node.expr_type, if node.expr_type == table.int_literal_type {
table.int_type
} else {
table.f64_type
@ -3407,7 +3407,7 @@ pub fn (mut c Checker) cast_expr(mut node ast.CastExpr) table.Type {
node.pos)
}
} else if node.typ == table.string_type &&
(from_type_sym.kind in [.any_int, .int, .byte, .byteptr, .bool] ||
(from_type_sym.kind in [.int_literal, .int, .byte, .byteptr, .bool] ||
(from_type_sym.kind == .array && from_type_sym.name == 'array_byte')) {
type_name := c.table.type_to_str(node.expr_type)
c.error('cannot cast type `$type_name` to string, use `x.str()` instead', node.pos)
@ -4318,25 +4318,25 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) table.Type {
node.is_expr = true
node.typ = last_expr.typ
continue
} else if node.typ in [table.any_flt_type, table.any_int_type] {
if node.typ == table.any_int_type {
} else if node.typ in [table.float_literal_type, table.int_literal_type] {
if node.typ == table.int_literal_type {
if last_expr.typ.is_int() || last_expr.typ.is_float() {
node.typ = last_expr.typ
continue
}
} else { // node.typ == any_float
} else { // node.typ == float_literal
if last_expr.typ.is_float() {
node.typ = last_expr.typ
continue
}
}
}
if last_expr.typ in [table.any_flt_type, table.any_int_type] {
if last_expr.typ == table.any_int_type {
if last_expr.typ in [table.float_literal_type, table.int_literal_type] {
if last_expr.typ == table.int_literal_type {
if node.typ.is_int() || node.typ.is_float() {
continue
}
} else { // expr_type == any_float
} else { // expr_type == float_literal
if node.typ.is_float() {
continue
}
@ -4378,9 +4378,9 @@ pub fn (mut c Checker) if_expr(mut node ast.IfExpr) table.Type {
}
}
// if only untyped literals were given default to int/f64
if node.typ == table.any_int_type {
if node.typ == table.int_literal_type {
node.typ = table.int_type
} else if node.typ == table.any_flt_type {
} else if node.typ == table.float_literal_type {
node.typ = table.f64_type
}
if expr_required && !node.has_else {
@ -5096,14 +5096,14 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) {
for arg in node.params {
sym := c.table.get_type_symbol(arg.typ)
if sym.kind == .placeholder ||
(sym.kind in [table.Kind.any_int, .any_float] && !c.is_builtin_mod) {
(sym.kind in [table.Kind.int_literal, .float_literal] && !c.is_builtin_mod) {
c.error('unknown type `$sym.name`', node.pos)
}
}
}
return_sym := c.table.get_type_symbol(node.return_type)
if node.language == .v &&
return_sym.kind in [.placeholder, .any_int, .any_float] && return_sym.language == .v {
return_sym.kind in [.placeholder, .int_literal, .float_literal] && return_sym.language == .v {
c.error('unknown type `$return_sym.name`', node.pos)
}
if node.language == .v && node.is_method && node.name == 'str' {

50
vlib/v/checker/tests/any_int_float_ban_err.out
View File

@ -1,47 +1,47 @@
vlib/v/checker/tests/any_int_float_ban_err.vv:1:12: error: type `any_int` doesn't exist
1 | type Foo = any_int | any_float
| ~~~~~~~
2 | type Fo2 = any_int
vlib/v/checker/tests/any_int_float_ban_err.vv:1:12: error: type `int_literal` doesn't exist
1 | type Foo = int_literal | float_literal
| ~~~~~~~~~~~
2 | type Fo2 = int_literal
3 |
vlib/v/checker/tests/any_int_float_ban_err.vv:2:1: error: type `any_int` doesn't exist
1 | type Foo = any_int | any_float
2 | type Fo2 = any_int
vlib/v/checker/tests/any_int_float_ban_err.vv:2:1: error: type `int_literal` doesn't exist
1 | type Foo = int_literal | float_literal
2 | type Fo2 = int_literal
| ~~~~~~~~
3 |
4 | struct Int {
vlib/v/checker/tests/any_int_float_ban_err.vv:5:7: error: unknown type `any_int`.
Did you mean `any_float`?
vlib/v/checker/tests/any_int_float_ban_err.vv:5:7: error: unknown type `int_literal`.
Did you mean `float_literal`?
3 |
4 | struct Int {
5 | i any_int
| ~~~~~~~
6 | f any_float
5 | i int_literal
| ~~~~~~~~~~~
6 | f float_literal
7 | }
vlib/v/checker/tests/any_int_float_ban_err.vv:6:7: error: unknown type `any_float`.
Did you mean `any_int`?
vlib/v/checker/tests/any_int_float_ban_err.vv:6:7: error: unknown type `float_literal`.
Did you mean `int_literal`?
4 | struct Int {
5 | i any_int
6 | f any_float
| ~~~~~~~~~
5 | i int_literal
6 | f float_literal
| ~~~~~~~~~~~~~
7 | }
8 |
vlib/v/checker/tests/any_int_float_ban_err.vv:9:1: error: unknown type `any_int`
vlib/v/checker/tests/any_int_float_ban_err.vv:9:1: error: unknown type `int_literal`
7 | }
8 |
9 | fn foo(i any_int) any_int {
| ~~~~~~~~~~~~~~~~~~~~~~~~~
9 | fn foo(i int_literal) int_literal {
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 | return i
11 | }
vlib/v/checker/tests/any_int_float_ban_err.vv:13:1: error: unknown type `any_int`
vlib/v/checker/tests/any_int_float_ban_err.vv:13:1: error: unknown type `int_literal`
11 | }
12 |
13 | fn foo2() any_int {
| ~~~~~~~~~~~~~~~~~
13 | fn foo2() int_literal {
| ~~~~~~~~~~~~~~~~~~~~~
14 | return 1
15 | }
vlib/v/checker/tests/any_int_float_ban_err.vv:14:12: error: cannot use `int literal` as type `any_int` in return argument
vlib/v/checker/tests/any_int_float_ban_err.vv:14:12: error: cannot use `int literal` as type `int_literal` in return argument
12 |
13 | fn foo2() any_int {
13 | fn foo2() int_literal {
14 | return 1
| ^
15 | }

12
vlib/v/checker/tests/any_int_float_ban_err.vv
View File

@ -1,15 +1,15 @@
type Foo = any_int | any_float
type Fo2 = any_int
type Foo = int_literal | float_literal
type Fo2 = int_literal
struct Int {
i any_int
f any_float
i int_literal
f float_literal
}
fn foo(i any_int) any_int {
fn foo(i int_literal) int_literal {
return i
}
fn foo2() any_int {
fn foo2() int_literal {
return 1
}

2
vlib/v/fmt/tests/expressions_expected.vv
View File

@ -23,7 +23,7 @@ fn string_inter_lit(mut c checker.Checker, mut node ast.StringInterLiteral) tabl
}
if (typ.is_unsigned() && fmt !in [`u`, `x`, `X`, `o`, `c`]) ||
(typ.is_signed() && fmt !in [`d`, `x`, `X`, `o`, `c`]) ||
(typ.is_any_int() && fmt !in [`d`, `c`, `x`, `X`, `o`, `u`, `x`, `X`, `o`]) ||
(typ.is_int_literal() && fmt !in [`d`, `c`, `x`, `X`, `o`, `u`, `x`, `X`, `o`]) ||
(typ.is_float() && fmt !in [`E`, `F`, `G`, `e`, `f`, `g`]) ||
(typ.is_pointer() && fmt !in [`p`, `x`, `X`]) ||
(typ.is_string() && fmt != `s`) ||

2
vlib/v/fmt/tests/expressions_input.vv
View File

@ -25,7 +25,7 @@ fn string_inter_lit(mut c checker.Checker, mut node ast.StringInterLiteral) tabl
c.error('plus prefix only allowd for numbers', node.fmt_poss[i])
}
if (typ.is_unsigned() && fmt !in [`u`, `x`, `X`, `o`, `c`]) || (typ.is_signed() &&
fmt !in [`d`, `x`, `X`, `o`, `c`]) || (typ.is_any_int()
fmt !in [`d`, `x`, `X`, `o`, `c`]) || (typ.is_int_literal()
&& fmt !in [`d`, `c`, `x`, `X`, `o`,
`u`, `x`, `X`, `o`]) || (typ.is_float() && fmt !in [`E`, `F`,
`G`, `e`, `f`, `g`]) || (typ.is_pointer() &&

2
vlib/v/gen/cgen.v
View File

@ -3235,7 +3235,7 @@ fn (mut g Gen) infix_expr(node ast.InfixExpr) {
d := !b &&
g.typ((left_sym.info as table.Alias).parent_type).split('__').last()[0].is_capital()
// Do not generate operator overloading with these `right_sym.kind`.
e := right_sym.kind !in [.voidptr, .any_int, .int]
e := right_sym.kind !in [.voidptr, .int_literal, .int]
if node.op in [.plus, .minus, .mul, .div, .mod, .lt, .gt, .eq, .ne, .le, .ge] &&
((a && b && e) || c || d) {
// Overloaded operators

4
vlib/v/gen/cheaders.v
View File

@ -439,8 +439,8 @@ typedef uint8_t byte;
typedef uint32_t rune;
typedef float f32;
typedef double f64;
typedef int64_t any_int;
typedef double any_float;
typedef int64_t int_literal;
typedef double float_literal;
typedef unsigned char* byteptr;
typedef void* voidptr;
typedef char* charptr;

14
vlib/v/gen/js/builtin_types.v
View File

@ -18,7 +18,7 @@ fn (mut g JsGen) to_js_typ_val(t table.Type) string {
mut styp := ''
mut prefix := if g.file.mod.name == 'builtin' { 'new ' } else { '' }
match sym.kind {
.i8, .i16, .int, .i64, .byte, .u16, .u32, .u64, .f32, .f64, .any_int, .any_float, .size_t {
.i8, .i16, .int, .i64, .byte, .u16, .u32, .u64, .f32, .f64, .int_literal, .float_literal, .size_t {
styp = '${prefix}${g.sym_to_js_typ(sym)}(0)'
}
.bool {
@ -57,8 +57,8 @@ fn (mut g JsGen) sym_to_js_typ(sym table.TypeSymbol) string {
.u64 { styp = 'u64' }
.f32 { styp = 'f32' }
.f64 { styp = 'f64' }
.any_int { styp = 'any_int' }
.any_float { styp = 'any_float' }
.int_literal { styp = 'int_literal' }
.float_literal { styp = 'float_literal' }
.size_t { styp = 'size_t' }
.bool { styp = 'bool' }
.string { styp = 'string' }
@ -90,7 +90,7 @@ pub fn (mut g JsGen) typ(t table.Type) string {
.byteptr, .charptr {
styp = '${g.sym_to_js_typ(sym)}'
}
.i8, .i16, .int, .i64, .byte, .u16, .u32, .u64, .f32, .f64, .any_int, .any_float, .size_t {
.i8, .i16, .int, .i64, .byte, .u16, .u32, .u64, .f32, .f64, .int_literal, .float_literal, .size_t {
styp = '${g.sym_to_js_typ(sym)}'
}
.bool {
@ -234,11 +234,11 @@ fn (mut g JsGen) gen_builtin_type_defs() {
for typ_name in v_types {
// TODO: JsDoc
match typ_name {
'i8', 'i16', 'int', 'i64', 'byte', 'u16', 'u32', 'u64', 'any_int', 'size_t' {
'i8', 'i16', 'int', 'i64', 'byte', 'u16', 'u32', 'u64', 'int_literal', 'size_t' {
// TODO: Bounds checking
g.gen_builtin_prototype(typ_name, 'val', 'new Number(0)', 'this.val = val | 0;', 'this.val | 0', '(this.val | 0).toString()', '')
}
'f32', 'f64', 'any_float' {
'f32', 'f64', 'float_literal' {
g.gen_builtin_prototype(typ_name, 'val', 'new Number(0)', 'this.val = val;', 'this.val', 'this.val.toString()', '')
}
'bool' {
@ -257,4 +257,4 @@ fn (mut g JsGen) gen_builtin_type_defs() {
}
}
g.dec_indent()
}
}

8
vlib/v/gen/js/js.v
View File

@ -16,8 +16,8 @@ const (
'public', 'return', 'static', 'super', 'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void',
'while', 'with', 'yield', 'Number', 'String', 'Boolean', 'Array', 'Map']
// used to generate type structs
v_types = ['i8', 'i16', 'int', 'i64', 'byte', 'u16', 'u32', 'u64', 'f32', 'f64', 'any_int',
'any_float', 'size_t', 'bool', 'string', 'map', 'array']
v_types = ['i8', 'i16', 'int', 'i64', 'byte', 'u16', 'u32', 'u64', 'f32', 'f64', 'int_literal',
'float_literal', 'size_t', 'bool', 'string', 'map', 'array']
tabs = ['', '\t', '\t\t', '\t\t\t', '\t\t\t\t', '\t\t\t\t\t', '\t\t\t\t\t\t', '\t\t\t\t\t\t\t',
'\t\t\t\t\t\t\t\t', '\t\t\t\t\t\t\t\t\t', '\t\t\t\t\t\t\t\t\t', '\t\t\t\t\t\t\t\t\t']
)
@ -1416,7 +1416,7 @@ fn (mut g JsGen) greater_typ(left table.Type, right table.Type) table.Type {
if table.f32_type_idx in lr {
return table.Type(table.f32_type_idx)
}
return table.Type(table.any_flt_type)
return table.Type(table.float_literal_type)
}
should_int := (l in table.integer_type_idxs && r in table.integer_type_idxs)
if should_int {
@ -1443,7 +1443,7 @@ fn (mut g JsGen) greater_typ(left table.Type, right table.Type) table.Type {
if table.i8_type_idx in lr {
return table.Type(table.i8_type_idx)
}
return table.Type(table.any_int_type_idx)
return table.Type(table.int_literal_type_idx)
}
return table.Type(l)
}

8
vlib/v/parser/parse_type.v
View File

@ -336,11 +336,11 @@ pub fn (mut p Parser) parse_any_type(language table.Language, is_ptr bool, check
'bool' {
return table.bool_type
}
'any_float', 'float_literal' {
return table.any_flt_type
'float_literal' {
return table.float_literal_type
}
'any_int', 'int_literal' {
return table.any_int_type
'int_literal' {
return table.int_literal_type
}
else {
if name.len == 1 && name[0].is_capital() {

8
vlib/v/table/table.v
View File

@ -680,8 +680,8 @@ pub fn (t &Table) value_type(typ Type) Type {
[inline]
pub fn (t &Table) mktyp(typ Type) Type {
match typ {
any_flt_type { return f64_type }
any_int_type { return int_type }
float_literal_type { return f64_type }
int_literal_type { return int_type }
else { return typ }
}
}
@ -732,8 +732,8 @@ pub fn (table &Table) sumtype_has_variant(parent Type, variant Type) bool {
pub fn (table &Table) known_type_names() []string {
mut res := []string{}
for _, idx in table.type_idxs {
// Skip `any_int_type_idx` and `any_flt_type_idx` because they shouldn't be visible to the User.
if idx in [0, any_int_type_idx, any_flt_type_idx] {
// Skip `int_literal_type_idx` and `float_literal_type_idx` because they shouldn't be visible to the User.
if idx in [0, int_literal_type_idx, float_literal_type_idx] {
continue
}
res << table.type_to_str(idx)

149
vlib/v/table/types.v
View File

@ -264,8 +264,8 @@ pub fn (typ Type) is_unsigned() bool {
}
[inline]
pub fn (typ Type) is_any_int() bool {
return typ.idx() == any_int_type_idx
pub fn (typ Type) is_int_literal() bool {
return typ.idx() == int_literal_type_idx
}
[inline]
@ -279,43 +279,43 @@ pub fn (typ Type) is_string() bool {
}
pub const (
void_type_idx = 1
voidptr_type_idx = 2
byteptr_type_idx = 3
charptr_type_idx = 4
i8_type_idx = 5
i16_type_idx = 6
int_type_idx = 7
i64_type_idx = 8
byte_type_idx = 9
u16_type_idx = 10
u32_type_idx = 11
u64_type_idx = 12
f32_type_idx = 13
f64_type_idx = 14
char_type_idx = 15
bool_type_idx = 16
none_type_idx = 17
string_type_idx = 18
ustring_type_idx = 19
rune_type_idx = 20
array_type_idx = 21
map_type_idx = 22
chan_type_idx = 23
sizet_type_idx = 24
any_type_idx = 25
any_flt_type_idx = 26
any_int_type_idx = 27
void_type_idx = 1
voidptr_type_idx = 2
byteptr_type_idx = 3
charptr_type_idx = 4
i8_type_idx = 5
i16_type_idx = 6
int_type_idx = 7
i64_type_idx = 8
byte_type_idx = 9
u16_type_idx = 10
u32_type_idx = 11
u64_type_idx = 12
f32_type_idx = 13
f64_type_idx = 14
char_type_idx = 15
bool_type_idx = 16
none_type_idx = 17
string_type_idx = 18
ustring_type_idx = 19
rune_type_idx = 20
array_type_idx = 21
map_type_idx = 22
chan_type_idx = 23
sizet_type_idx = 24
any_type_idx = 25
float_literal_type_idx = 26
int_literal_type_idx = 27
)
pub const (
integer_type_idxs = [i8_type_idx, i16_type_idx, int_type_idx, i64_type_idx, byte_type_idx,
u16_type_idx, u32_type_idx, u64_type_idx, any_int_type_idx, rune_type_idx]
u16_type_idx, u32_type_idx, u64_type_idx, int_literal_type_idx, rune_type_idx]
signed_integer_type_idxs = [i8_type_idx, i16_type_idx, int_type_idx, i64_type_idx]
unsigned_integer_type_idxs = [byte_type_idx, u16_type_idx, u32_type_idx, u64_type_idx]
float_type_idxs = [f32_type_idx, f64_type_idx, any_flt_type_idx]
float_type_idxs = [f32_type_idx, f64_type_idx, float_literal_type_idx]
number_type_idxs = [i8_type_idx, i16_type_idx, int_type_idx, i64_type_idx, byte_type_idx,
u16_type_idx, u32_type_idx, u64_type_idx, f32_type_idx, f64_type_idx, any_int_type_idx, any_flt_type_idx,
u16_type_idx, u32_type_idx, u64_type_idx, f32_type_idx, f64_type_idx, int_literal_type_idx, float_literal_type_idx,
rune_type_idx,
]
pointer_type_idxs = [voidptr_type_idx, byteptr_type_idx, charptr_type_idx]
@ -323,39 +323,39 @@ pub const (
)
pub const (
void_type = new_type(void_type_idx)
ovoid_type = new_type(void_type_idx).set_flag(.optional) // the return type of `fn () ?`
voidptr_type = new_type(voidptr_type_idx)
byteptr_type = new_type(byteptr_type_idx)
charptr_type = new_type(charptr_type_idx)
i8_type = new_type(i8_type_idx)
int_type = new_type(int_type_idx)
i16_type = new_type(i16_type_idx)
i64_type = new_type(i64_type_idx)
byte_type = new_type(byte_type_idx)
u16_type = new_type(u16_type_idx)
u32_type = new_type(u32_type_idx)
u64_type = new_type(u64_type_idx)
f32_type = new_type(f32_type_idx)
f64_type = new_type(f64_type_idx)
char_type = new_type(char_type_idx)
bool_type = new_type(bool_type_idx)
none_type = new_type(none_type_idx)
string_type = new_type(string_type_idx)
ustring_type = new_type(ustring_type_idx)
rune_type = new_type(rune_type_idx)
array_type = new_type(array_type_idx)
map_type = new_type(map_type_idx)
chan_type = new_type(chan_type_idx)
any_type = new_type(any_type_idx)
any_flt_type = new_type(any_flt_type_idx)
any_int_type = new_type(any_int_type_idx)
void_type = new_type(void_type_idx)
ovoid_type = new_type(void_type_idx).set_flag(.optional) // the return type of `fn () ?`
voidptr_type = new_type(voidptr_type_idx)
byteptr_type = new_type(byteptr_type_idx)
charptr_type = new_type(charptr_type_idx)
i8_type = new_type(i8_type_idx)
int_type = new_type(int_type_idx)
i16_type = new_type(i16_type_idx)
i64_type = new_type(i64_type_idx)
byte_type = new_type(byte_type_idx)
u16_type = new_type(u16_type_idx)
u32_type = new_type(u32_type_idx)
u64_type = new_type(u64_type_idx)
f32_type = new_type(f32_type_idx)
f64_type = new_type(f64_type_idx)
char_type = new_type(char_type_idx)
bool_type = new_type(bool_type_idx)
none_type = new_type(none_type_idx)
string_type = new_type(string_type_idx)
ustring_type = new_type(ustring_type_idx)
rune_type = new_type(rune_type_idx)
array_type = new_type(array_type_idx)
map_type = new_type(map_type_idx)
chan_type = new_type(chan_type_idx)
any_type = new_type(any_type_idx)
float_literal_type = new_type(float_literal_type_idx)
int_literal_type = new_type(int_literal_type_idx)
)
pub const (
builtin_type_names = ['void', 'voidptr', 'charptr', 'byteptr', 'i8', 'i16', 'int', 'i64', 'u16',
'u32', 'u64', 'any_int', 'f32', 'f64', 'any_float', 'string', 'ustring', 'char', 'byte', 'bool',
'none', 'array', 'array_fixed', 'map', 'chan', 'any', 'struct', 'mapnode', 'size_t', 'rune']
'u32', 'u64', 'int_literal', 'f32', 'f64', 'float_literal', 'string', 'ustring', 'char', 'byte',
'bool', 'none', 'array', 'array_fixed', 'map', 'chan', 'any', 'struct', 'mapnode', 'size_t', 'rune']
)
pub struct MultiReturn {
@ -414,8 +414,8 @@ pub enum Kind {
enum_
function
interface_
any_float
any_int
float_literal
int_literal
aggregate
}
@ -518,12 +518,17 @@ pub fn (mut t Table) register_builtin_type_symbols() {
t.register_type_symbol(kind: .size_t, name: 'size_t', cname: 'size_t', mod: 'builtin')
t.register_type_symbol(kind: .any, name: 'any', cname: 'any', mod: 'builtin')
t.register_type_symbol(
kind: .any_float
kind: .float_literal
name: 'float literal'
cname: 'any_float'
cname: 'float_literal'
mod: 'builtin'
)
t.register_type_symbol(
kind: .int_literal
name: 'int literal'
cname: 'int_literal'
mod: 'builtin'
)
t.register_type_symbol(kind: .any_int, name: 'int literal', cname: 'any_int', mod: 'builtin')
}
[inline]
@ -533,12 +538,12 @@ pub fn (t &TypeSymbol) is_pointer() bool {
[inline]
pub fn (t &TypeSymbol) is_int() bool {
return t.kind in [.i8, .i16, .int, .i64, .byte, .u16, .u32, .u64, .any_int]
return t.kind in [.i8, .i16, .int, .i64, .byte, .u16, .u32, .u64, .int_literal]
}
[inline]
pub fn (t &TypeSymbol) is_float() bool {
return t.kind in [.f32, .f64, .any_float]
return t.kind in [.f32, .f64, .float_literal]
}
[inline]
@ -563,10 +568,10 @@ pub fn (k Kind) str() string {
.u16 { 'u16' }
.u32 { 'u32' }
.u64 { 'u64' }
.any_int { 'any_int' }
.int_literal { 'int_literal' }
.f32 { 'f32' }
.f64 { 'f64' }
.any_float { 'any_float' }
.float_literal { 'float_literal' }
.string { 'string' }
.char { 'char' }
.bool { 'bool' }
@ -714,7 +719,7 @@ pub fn (table &Table) type_to_str(t Type) string {
// type name in code (for builtin)
pub fn (table &Table) type_to_code(t Type) string {
match t {
any_int_type, any_flt_type { return table.get_type_symbol(t).kind.str() }
int_literal_type, float_literal_type { return table.get_type_symbol(t).kind.str() }
else { return table.type_to_str_using_aliases(t, map[string]string{}) }
}
}
@ -724,7 +729,7 @@ pub fn (table &Table) type_to_str_using_aliases(t Type, import_aliases map[strin
sym := table.get_type_symbol(t)
mut res := sym.name
match sym.kind {
.any_int, .any_float {
.int_literal, .float_literal {
res = sym.name
}
.i8, .i16, .int, .i64, .byte, .u16, .u32, .u64, .f32, .f64, .char, .rune, .string, .bool, .none_, .byteptr, .voidptr, .charptr {

4
vlib/v/tests/typeof_simple_types_test.v
View File

@ -20,7 +20,7 @@ fn test_typeof_for_builtin_int_types() {
assert typeof(i8(1)) == 'i8'
assert typeof(i16(1)) == 'i16'
assert typeof(int(1)) == 'int'
// assert typeof(1) == 'any_int'
// assert typeof(1) == 'int_literal'
assert typeof(i64(1)) == 'i64'
assert typeof(byte(1)) == 'byte'
assert typeof(u16(1)) == 'u16'
@ -31,7 +31,7 @@ fn test_typeof_for_builtin_int_types() {
fn test_typeof_for_builtin_float_types() {
assert typeof(f32(1.0)) == 'f32'
assert typeof(f64(1.0)) == 'f64'
// assert typeof(1.0) == 'any_float'
// assert typeof(1.0) == 'float_literal'
}
fn test_typeof_for_builtin_string_type() {

10
vlib/v/tests/typeof_test.v
View File

@ -8,11 +8,11 @@ fn test_typeof_on_simple_expressions() {
assert typeof(a) == 'int'
assert typeof(a).name == 'int'
// a2 := 123
// assert typeof(a2) == 'any_int'
// assert typeof(42) == 'any_int'
// assert typeof(3.14) == 'any_float'
// assert typeof(2+2*10) == 'any_int'
// assert typeof(1.0 * 12.2) == 'any_float'
// assert typeof(a2) == 'int_literal'
// assert typeof(42) == 'int_literal'
// assert typeof(3.14) == 'float_literal'
// assert typeof(2+2*10) == 'int_literal'
// assert typeof(1.0 * 12.2) == 'float_literal'
}
fn test_arrays() {