diff --git a/cmd/tools/vdoc/html.v b/cmd/tools/vdoc/html.v
index 6998edc2f2..fac8332a01 100644
--- a/cmd/tools/vdoc/html.v
+++ b/cmd/tools/vdoc/html.v
@@ -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()
diff --git a/doc/docs.md b/doc/docs.md
index ebad22fa1d..7d61d30c41 100644
--- a/doc/docs.md
+++ b/doc/docs.md
@@ -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
diff --git a/vlib/builtin/float.v b/vlib/builtin/float.v
index b584142864..12866858ab 100644
--- a/vlib/builtin/float.v
+++ b/vlib/builtin/float.v
@@ -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()
}
diff --git a/vlib/builtin/int.v b/vlib/builtin/int.v
index fbf0cef618..490cc34060 100644
--- a/vlib/builtin/int.v
+++ b/vlib/builtin/int.v
@@ -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) }
*/
diff --git a/vlib/v/checker/check_types.v b/vlib/v/checker/check_types.v
index 2c42cdebb7..7772fd30b3 100644
--- a/vlib/v/checker/check_types.v
+++ b/vlib/v/checker/check_types.v
@@ -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`) ||
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
index 20b0a9e91d..b9730b81d8 100644
--- a/vlib/v/checker/checker.v
+++ b/vlib/v/checker/checker.v
@@ -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' {
diff --git a/vlib/v/checker/tests/any_int_float_ban_err.out b/vlib/v/checker/tests/any_int_float_ban_err.out
index 023506ff49..eb29df358a 100644
--- a/vlib/v/checker/tests/any_int_float_ban_err.out
+++ b/vlib/v/checker/tests/any_int_float_ban_err.out
@@ -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 | }
diff --git a/vlib/v/checker/tests/any_int_float_ban_err.vv b/vlib/v/checker/tests/any_int_float_ban_err.vv
index b6706f2e13..15fab98ea1 100644
--- a/vlib/v/checker/tests/any_int_float_ban_err.vv
+++ b/vlib/v/checker/tests/any_int_float_ban_err.vv
@@ -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
}
diff --git a/vlib/v/fmt/tests/expressions_expected.vv b/vlib/v/fmt/tests/expressions_expected.vv
index 33eae8e82b..28507e418c 100644
--- a/vlib/v/fmt/tests/expressions_expected.vv
+++ b/vlib/v/fmt/tests/expressions_expected.vv
@@ -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`) ||
diff --git a/vlib/v/fmt/tests/expressions_input.vv b/vlib/v/fmt/tests/expressions_input.vv
index 75ca9820e7..37b6b982c8 100644
--- a/vlib/v/fmt/tests/expressions_input.vv
+++ b/vlib/v/fmt/tests/expressions_input.vv
@@ -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() &&
diff --git a/vlib/v/gen/cgen.v b/vlib/v/gen/cgen.v
index 63cf6070e1..5a9e0eb4d7 100644
--- a/vlib/v/gen/cgen.v
+++ b/vlib/v/gen/cgen.v
@@ -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
diff --git a/vlib/v/gen/cheaders.v b/vlib/v/gen/cheaders.v
index 5793bb9dcb..900c326861 100644
--- a/vlib/v/gen/cheaders.v
+++ b/vlib/v/gen/cheaders.v
@@ -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;
diff --git a/vlib/v/gen/js/builtin_types.v b/vlib/v/gen/js/builtin_types.v
index f7e0417ea8..b344c7285d 100644
--- a/vlib/v/gen/js/builtin_types.v
+++ b/vlib/v/gen/js/builtin_types.v
@@ -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()
-}
\ No newline at end of file
+}
diff --git a/vlib/v/gen/js/js.v b/vlib/v/gen/js/js.v
index b8d29b7e33..c1a53138f3 100644
--- a/vlib/v/gen/js/js.v
+++ b/vlib/v/gen/js/js.v
@@ -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)
}
diff --git a/vlib/v/parser/parse_type.v b/vlib/v/parser/parse_type.v
index fc8e0f4513..390f3c2f1f 100644
--- a/vlib/v/parser/parse_type.v
+++ b/vlib/v/parser/parse_type.v
@@ -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() {
diff --git a/vlib/v/table/table.v b/vlib/v/table/table.v
index c997ef2fe7..218213d9f4 100644
--- a/vlib/v/table/table.v
+++ b/vlib/v/table/table.v
@@ -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)
diff --git a/vlib/v/table/types.v b/vlib/v/table/types.v
index 7c0b029451..335edc0a33 100644
--- a/vlib/v/table/types.v
+++ b/vlib/v/table/types.v
@@ -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 {
diff --git a/vlib/v/tests/typeof_simple_types_test.v b/vlib/v/tests/typeof_simple_types_test.v
index c79474467f..07b0cd53ca 100644
--- a/vlib/v/tests/typeof_simple_types_test.v
+++ b/vlib/v/tests/typeof_simple_types_test.v
@@ -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() {
diff --git a/vlib/v/tests/typeof_test.v b/vlib/v/tests/typeof_test.v
index 109b764d60..d5cfb0796c 100644
--- a/vlib/v/tests/typeof_test.v
+++ b/vlib/v/tests/typeof_test.v
@@ -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() {