checker: split up checker.v: assign.v, orm.v, comptime.v; c2v fixes
Alexander Medvednikov
parent
ed4ecae57d
commit
eaf0f9b4c1
|
|
@ -0,0 +1,595 @@
|
||||||
|
// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
|
||||||
|
// Use of this source code is governed by an MIT license that can be found in the LICENSE file.
|
||||||
|
module checker
|
||||||
|
|
||||||
|
import v.ast
|
||||||
|
import v.pref
|
||||||
|
|
||||||
|
// TODO 600 line function
|
||||||
|
pub fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {
|
||||||
|
c.expected_type = ast.none_type // TODO a hack to make `x := if ... work`
|
||||||
|
defer {
|
||||||
|
c.expected_type = ast.void_type
|
||||||
|
}
|
||||||
|
right_first := node.right[0]
|
||||||
|
node.left_types = []
|
||||||
|
mut right_len := node.right.len
|
||||||
|
mut right_type0 := ast.void_type
|
||||||
|
for i, right in node.right {
|
||||||
|
if right in [ast.CallExpr, ast.IfExpr, ast.LockExpr, ast.MatchExpr] {
|
||||||
|
right_type := c.expr(right)
|
||||||
|
if i == 0 {
|
||||||
|
right_type0 = right_type
|
||||||
|
node.right_types = [
|
||||||
|
c.check_expr_opt_call(right, right_type0),
|
||||||
|
]
|
||||||
|
}
|
||||||
|
right_type_sym := c.table.get_type_symbol(right_type)
|
||||||
|
if right_type_sym.kind == .multi_return {
|
||||||
|
if node.right.len > 1 {
|
||||||
|
c.error('cannot use multi-value $right_type_sym.name in single-value context',
|
||||||
|
right.position())
|
||||||
|
}
|
||||||
|
node.right_types = right_type_sym.mr_info().types
|
||||||
|
right_len = node.right_types.len
|
||||||
|
} else if right_type == ast.void_type {
|
||||||
|
right_len = 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if right is ast.InfixExpr {
|
||||||
|
if right.op == .arrow {
|
||||||
|
c.error('cannot use `<-` on the right-hand side of an assignment, as it does not return any values',
|
||||||
|
right.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if right is ast.Ident {
|
||||||
|
if right.is_mut {
|
||||||
|
c.error('unexpected `mut` on right-hand side of assignment', right.mut_pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if node.left.len != right_len {
|
||||||
|
if right_first is ast.CallExpr {
|
||||||
|
if node.left_types.len > 0 && node.left_types[0] == ast.void_type {
|
||||||
|
// If it's a void type, it's an unknown variable, already had an error earlier.
|
||||||
|
return
|
||||||
|
}
|
||||||
|
c.error('assignment mismatch: $node.left.len variable(s) but `${right_first.name}()` returns $right_len value(s)',
|
||||||
|
node.pos)
|
||||||
|
} else {
|
||||||
|
c.error('assignment mismatch: $node.left.len variable(s) $right_len value(s)',
|
||||||
|
node.pos)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
is_decl := node.op == .decl_assign
|
||||||
|
for i, left in node.left {
|
||||||
|
if left is ast.CallExpr {
|
||||||
|
// ban `foo() = 10`
|
||||||
|
c.error('cannot call function `${left.name}()` on the left side of an assignment',
|
||||||
|
left.pos)
|
||||||
|
} else if left is ast.PrefixExpr {
|
||||||
|
// ban `*foo() = 10`
|
||||||
|
if left.right is ast.CallExpr && left.op == .mul {
|
||||||
|
c.error('cannot dereference a function call on the left side of an assignment, use a temporary variable',
|
||||||
|
left.pos)
|
||||||
|
}
|
||||||
|
} else if left is ast.IndexExpr {
|
||||||
|
if left.index is ast.RangeExpr {
|
||||||
|
c.error('cannot reassign using range expression on the left side of an assignment',
|
||||||
|
left.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
is_blank_ident := left.is_blank_ident()
|
||||||
|
mut left_type := ast.void_type
|
||||||
|
if !is_decl && !is_blank_ident {
|
||||||
|
if left in [ast.Ident, ast.SelectorExpr] {
|
||||||
|
c.prevent_sum_type_unwrapping_once = true
|
||||||
|
}
|
||||||
|
left_type = c.expr(left)
|
||||||
|
c.expected_type = c.unwrap_generic(left_type)
|
||||||
|
// `map = {}`
|
||||||
|
if left_type != 0 {
|
||||||
|
sym := c.table.get_type_symbol(left_type)
|
||||||
|
if sym.kind == .map {
|
||||||
|
if node.right.len <= i {
|
||||||
|
// `map_1, map_2, map_3 = f()`, where f returns (map[int]int, map[int]int, map[int]int)
|
||||||
|
// i.e. 3 left parts of the assignment, but just 1 right part
|
||||||
|
} else {
|
||||||
|
if node.right[i] is ast.StructInit {
|
||||||
|
c.warn('assigning a struct literal to a map is deprecated - use `map{}` instead',
|
||||||
|
node.right[i].position())
|
||||||
|
node.right[i] = ast.MapInit{}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if node.right_types.len < node.left.len { // first type or multi return types added above
|
||||||
|
old_inside_ref_lit := c.inside_ref_lit
|
||||||
|
if left is ast.Ident {
|
||||||
|
if left.info is ast.IdentVar {
|
||||||
|
c.inside_ref_lit = c.inside_ref_lit || left.info.share == .shared_t
|
||||||
|
}
|
||||||
|
}
|
||||||
|
c.inside_decl_rhs = is_decl
|
||||||
|
right_type := c.expr(node.right[i])
|
||||||
|
c.inside_decl_rhs = false
|
||||||
|
c.inside_ref_lit = old_inside_ref_lit
|
||||||
|
if node.right_types.len == i {
|
||||||
|
node.right_types << c.check_expr_opt_call(node.right[i], right_type)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
right := if i < node.right.len { node.right[i] } else { node.right[0] }
|
||||||
|
mut right_type := node.right_types[i]
|
||||||
|
if right is ast.Ident {
|
||||||
|
right_sym := c.table.get_type_symbol(right_type)
|
||||||
|
if right_sym.info is ast.Struct {
|
||||||
|
if right_sym.info.generic_types.len > 0 {
|
||||||
|
if obj := right.scope.find(right.name) {
|
||||||
|
right_type = obj.typ
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if is_decl {
|
||||||
|
// check generic struct init and return unwrap generic struct type
|
||||||
|
if right is ast.StructInit {
|
||||||
|
if right.typ.has_flag(.generic) {
|
||||||
|
c.expr(right)
|
||||||
|
right_type = right.typ
|
||||||
|
}
|
||||||
|
} else if right is ast.PrefixExpr {
|
||||||
|
if right.op == .amp && right.right is ast.StructInit {
|
||||||
|
right_type = c.expr(right)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if right.is_auto_deref_var() {
|
||||||
|
left_type = c.table.mktyp(right_type.deref())
|
||||||
|
} else {
|
||||||
|
left_type = c.table.mktyp(right_type)
|
||||||
|
}
|
||||||
|
if left_type == ast.int_type {
|
||||||
|
if right is ast.IntegerLiteral {
|
||||||
|
mut is_large := right.val.len > 13
|
||||||
|
if !is_large && right.val.len > 8 {
|
||||||
|
val := right.val.i64()
|
||||||
|
is_large = val > int_max || val < int_min
|
||||||
|
}
|
||||||
|
if is_large {
|
||||||
|
c.error('overflow in implicit type `int`, use explicit type casting instead',
|
||||||
|
right.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// Make sure the variable is mutable
|
||||||
|
c.fail_if_immutable(left)
|
||||||
|
// left_type = c.expr(left)
|
||||||
|
}
|
||||||
|
if right_type.is_ptr() && left_type.is_ptr() {
|
||||||
|
if mut right is ast.Ident {
|
||||||
|
if mut right.obj is ast.Var {
|
||||||
|
mut obj := unsafe { &right.obj }
|
||||||
|
if c.fn_scope != voidptr(0) {
|
||||||
|
obj = c.fn_scope.find_var(right.obj.name) or { obj }
|
||||||
|
}
|
||||||
|
if obj.is_stack_obj && !c.inside_unsafe {
|
||||||
|
type_sym := c.table.get_type_symbol(obj.typ.set_nr_muls(0))
|
||||||
|
if !type_sym.is_heap() && !c.pref.translated {
|
||||||
|
suggestion := if type_sym.kind == .struct_ {
|
||||||
|
'declaring `$type_sym.name` as `[heap]`'
|
||||||
|
} else {
|
||||||
|
'wrapping the `$type_sym.name` object in a `struct` declared as `[heap]`'
|
||||||
|
}
|
||||||
|
c.error('`$right.name` cannot be assigned outside `unsafe` blocks as it might refer to an object stored on stack. Consider ${suggestion}.',
|
||||||
|
right.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Do not allow `a := 0; b := 0; a = &b`
|
||||||
|
if !is_decl && left is ast.Ident && !is_blank_ident && !left_type.is_real_pointer()
|
||||||
|
&& right_type.is_real_pointer() {
|
||||||
|
left_sym := c.table.get_type_symbol(left_type)
|
||||||
|
if left_sym.kind != .function {
|
||||||
|
c.warn(
|
||||||
|
'cannot assign a reference to a value (this will be an error soon) left=${c.table.type_str(left_type)} $left_type.is_ptr() ' +
|
||||||
|
'right=${c.table.type_str(right_type)} $right_type.is_real_pointer() ptr=$right_type.is_ptr()',
|
||||||
|
node.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
node.left_types << left_type
|
||||||
|
match mut left {
|
||||||
|
ast.Ident {
|
||||||
|
if left.kind == .blank_ident {
|
||||||
|
left_type = right_type
|
||||||
|
node.left_types[i] = right_type
|
||||||
|
if node.op !in [.assign, .decl_assign] {
|
||||||
|
c.error('cannot modify blank `_` identifier', left.pos)
|
||||||
|
}
|
||||||
|
} else if left.info !is ast.IdentVar {
|
||||||
|
c.error('cannot assign to $left.kind `$left.name`', left.pos)
|
||||||
|
} else {
|
||||||
|
if is_decl {
|
||||||
|
c.check_valid_snake_case(left.name, 'variable name', left.pos)
|
||||||
|
if left.name in reserved_type_names {
|
||||||
|
c.error('invalid use of reserved type `$left.name` as a variable name',
|
||||||
|
left.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
mut ident_var_info := left.info as ast.IdentVar
|
||||||
|
if ident_var_info.share == .shared_t {
|
||||||
|
left_type = left_type.set_flag(.shared_f)
|
||||||
|
if is_decl {
|
||||||
|
if left_type.nr_muls() > 1 {
|
||||||
|
c.error('shared cannot be multi level reference', left.pos)
|
||||||
|
}
|
||||||
|
left_type = left_type.set_nr_muls(1)
|
||||||
|
}
|
||||||
|
} else if left_type.has_flag(.shared_f) {
|
||||||
|
left_type = left_type.clear_flag(.shared_f)
|
||||||
|
}
|
||||||
|
if ident_var_info.share == .atomic_t {
|
||||||
|
left_type = left_type.set_flag(.atomic_f)
|
||||||
|
}
|
||||||
|
node.left_types[i] = left_type
|
||||||
|
ident_var_info.typ = left_type
|
||||||
|
left.info = ident_var_info
|
||||||
|
if left_type != 0 {
|
||||||
|
match mut left.obj {
|
||||||
|
ast.Var {
|
||||||
|
left.obj.typ = left_type
|
||||||
|
if left.obj.is_auto_deref {
|
||||||
|
left.obj.is_used = true
|
||||||
|
}
|
||||||
|
if !left_type.is_ptr() {
|
||||||
|
if c.table.get_type_symbol(left_type).is_heap() {
|
||||||
|
left.obj.is_auto_heap = true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if left_type in ast.unsigned_integer_type_idxs {
|
||||||
|
if right is ast.IntegerLiteral {
|
||||||
|
if right.val[0] == `-` {
|
||||||
|
c.error('Cannot assign negative value to unsigned integer type',
|
||||||
|
right.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ast.GlobalField {
|
||||||
|
left.obj.typ = left_type
|
||||||
|
}
|
||||||
|
else {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if is_decl {
|
||||||
|
full_name := '${left.mod}.$left.name'
|
||||||
|
if obj := c.file.global_scope.find(full_name) {
|
||||||
|
if obj is ast.ConstField {
|
||||||
|
c.warn('duplicate of a const name `$full_name`', left.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ast.PrefixExpr {
|
||||||
|
// Do now allow `*x = y` outside `unsafe`
|
||||||
|
if left.op == .mul {
|
||||||
|
if !c.inside_unsafe && !c.pref.translated {
|
||||||
|
c.error('modifying variables via dereferencing can only be done in `unsafe` blocks',
|
||||||
|
node.pos)
|
||||||
|
} else {
|
||||||
|
// mark `p` in `*p = val` as used:
|
||||||
|
match mut left.right {
|
||||||
|
ast.Ident {
|
||||||
|
match mut left.right.obj {
|
||||||
|
ast.Var {
|
||||||
|
left.right.obj.is_used = true
|
||||||
|
}
|
||||||
|
else {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if is_decl {
|
||||||
|
c.error('non-name on the left side of `:=`', left.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
if mut left is ast.IndexExpr {
|
||||||
|
// eprintln('>>> left.is_setter: ${left.is_setter:10} | left.is_map: ${left.is_map:10} | left.is_array: ${left.is_array:10}')
|
||||||
|
if left.is_map && left.is_setter {
|
||||||
|
left.recursive_mapset_is_setter(true)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if is_decl {
|
||||||
|
c.error('non-name `$left` on left side of `:=`', left.position())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
left_type_unwrapped := c.unwrap_generic(left_type)
|
||||||
|
right_type_unwrapped := c.unwrap_generic(right_type)
|
||||||
|
if right_type_unwrapped == 0 {
|
||||||
|
// right type was a generic `T`
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if c.pref.translated {
|
||||||
|
// TODO fix this in C2V instead, for example cast enums to int before using `|` on them.
|
||||||
|
// TODO replace all c.pref.translated checks with `$if !translated` for performance
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if left_type_unwrapped == 0 {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
left_sym := c.table.get_type_symbol(left_type_unwrapped)
|
||||||
|
right_sym := c.table.get_type_symbol(right_type_unwrapped)
|
||||||
|
if left_sym.kind == .array && !c.inside_unsafe && node.op in [.assign, .decl_assign]
|
||||||
|
&& right_sym.kind == .array && (left is ast.Ident && !left.is_blank_ident())
|
||||||
|
&& right is ast.Ident {
|
||||||
|
// Do not allow `a = b`, only `a = b.clone()`
|
||||||
|
c.error('use `array2 $node.op.str() array1.clone()` instead of `array2 $node.op.str() array1` (or use `unsafe`)',
|
||||||
|
node.pos)
|
||||||
|
}
|
||||||
|
if left_sym.kind == .array_fixed && !c.inside_unsafe && node.op in [.assign, .decl_assign]
|
||||||
|
&& right_sym.kind == .array_fixed && (left is ast.Ident && !left.is_blank_ident())
|
||||||
|
&& right is ast.Ident {
|
||||||
|
if right_sym.info is ast.ArrayFixed {
|
||||||
|
if right_sym.info.elem_type.is_ptr() {
|
||||||
|
c.error('assignment from one fixed array to another with a pointer element type is prohibited outside of `unsafe`',
|
||||||
|
node.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if left_sym.kind == .map && node.op in [.assign, .decl_assign] && right_sym.kind == .map
|
||||||
|
&& ((right is ast.Ident && right.is_auto_deref_var())
|
||||||
|
|| !right_type.is_ptr()) && !left.is_blank_ident() && right.is_lvalue() {
|
||||||
|
// Do not allow `a = b`
|
||||||
|
c.error('cannot copy map: call `move` or `clone` method (or use a reference)',
|
||||||
|
right.position())
|
||||||
|
}
|
||||||
|
left_is_ptr := left_type.is_ptr() || left_sym.is_pointer()
|
||||||
|
if left_is_ptr && !left.is_auto_deref_var() {
|
||||||
|
if !c.inside_unsafe && node.op !in [.assign, .decl_assign] {
|
||||||
|
// ptr op=
|
||||||
|
c.warn('pointer arithmetic is only allowed in `unsafe` blocks', node.pos)
|
||||||
|
}
|
||||||
|
right_is_ptr := right_type.is_ptr() || right_sym.is_pointer()
|
||||||
|
if !right_is_ptr && node.op == .assign && right_type_unwrapped.is_number() {
|
||||||
|
c.error('cannot assign to `$left`: ' +
|
||||||
|
c.expected_msg(right_type_unwrapped, left_type_unwrapped), right.position())
|
||||||
|
}
|
||||||
|
if (right is ast.StructInit || !right_is_ptr) && !(right_sym.is_number()
|
||||||
|
|| left_type.has_flag(.shared_f)) {
|
||||||
|
left_name := c.table.type_to_str(left_type_unwrapped)
|
||||||
|
mut rtype := right_type_unwrapped
|
||||||
|
if rtype.is_ptr() {
|
||||||
|
rtype = rtype.deref()
|
||||||
|
}
|
||||||
|
right_name := c.table.type_to_str(rtype)
|
||||||
|
c.error('mismatched types `$left_name` and `$right_name`', node.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Single side check
|
||||||
|
match node.op {
|
||||||
|
.assign {} // No need to do single side check for =. But here put it first for speed.
|
||||||
|
.plus_assign, .minus_assign {
|
||||||
|
if left_type == ast.string_type {
|
||||||
|
if node.op != .plus_assign {
|
||||||
|
c.error('operator `$node.op` not defined on left operand type `$left_sym.name`',
|
||||||
|
left.position())
|
||||||
|
}
|
||||||
|
if right_type != ast.string_type {
|
||||||
|
c.error('invalid right operand: $left_sym.name $node.op $right_sym.name',
|
||||||
|
right.position())
|
||||||
|
}
|
||||||
|
} else if !left_sym.is_number()
|
||||||
|
&& left_sym.kind !in [.byteptr, .charptr, .struct_, .alias] {
|
||||||
|
c.error('operator `$node.op` not defined on left operand type `$left_sym.name`',
|
||||||
|
left.position())
|
||||||
|
} else if !right_sym.is_number()
|
||||||
|
&& left_sym.kind !in [.byteptr, .charptr, .struct_, .alias] {
|
||||||
|
c.error('invalid right operand: $left_sym.name $node.op $right_sym.name',
|
||||||
|
right.position())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
.mult_assign, .div_assign {
|
||||||
|
if !left_sym.is_number()
|
||||||
|
&& !c.table.get_final_type_symbol(left_type_unwrapped).is_int()
|
||||||
|
&& left_sym.kind !in [.struct_, .alias] {
|
||||||
|
c.error('operator $node.op.str() not defined on left operand type `$left_sym.name`',
|
||||||
|
left.position())
|
||||||
|
} else if !right_sym.is_number()
|
||||||
|
&& !c.table.get_final_type_symbol(left_type_unwrapped).is_int()
|
||||||
|
&& left_sym.kind !in [.struct_, .alias] {
|
||||||
|
c.error('operator $node.op.str() not defined on right operand type `$right_sym.name`',
|
||||||
|
right.position())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
.and_assign, .or_assign, .xor_assign, .mod_assign, .left_shift_assign,
|
||||||
|
.right_shift_assign {
|
||||||
|
if !left_sym.is_int()
|
||||||
|
&& !c.table.get_final_type_symbol(left_type_unwrapped).is_int() {
|
||||||
|
c.error('operator $node.op.str() not defined on left operand type `$left_sym.name`',
|
||||||
|
left.position())
|
||||||
|
} else if !right_sym.is_int()
|
||||||
|
&& !c.table.get_final_type_symbol(right_type_unwrapped).is_int() {
|
||||||
|
c.error('operator $node.op.str() not defined on right operand type `$right_sym.name`',
|
||||||
|
right.position())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
.unsigned_right_shift_assign {
|
||||||
|
if node.left.len != 1 || node.right.len != 1 {
|
||||||
|
c.error('unsupported operation: unable to lower expression for unsigned shift assignment.',
|
||||||
|
node.pos)
|
||||||
|
}
|
||||||
|
|
||||||
|
modified_left_type := if !left_type.is_int() {
|
||||||
|
c.error('invalid operation: shift on type `${c.table.get_type_symbol(left_type).name}`',
|
||||||
|
node.pos)
|
||||||
|
ast.void_type_idx
|
||||||
|
} else if left_type.is_int_literal() {
|
||||||
|
// int literal => i64
|
||||||
|
ast.u32_type_idx
|
||||||
|
} else if left_type.is_unsigned() {
|
||||||
|
left_type
|
||||||
|
} else {
|
||||||
|
// signed types' idx adds with 5 will get correct relative unsigned type
|
||||||
|
// i8 => byte
|
||||||
|
// i16 => u16
|
||||||
|
// int => u32
|
||||||
|
// i64 => u64
|
||||||
|
// isize => usize
|
||||||
|
// i128 => u128 NOT IMPLEMENTED YET
|
||||||
|
left_type.idx() + ast.u32_type_idx - ast.int_type_idx
|
||||||
|
}
|
||||||
|
|
||||||
|
node = ast.AssignStmt{
|
||||||
|
op: .assign
|
||||||
|
pos: node.pos
|
||||||
|
comments: node.comments
|
||||||
|
end_comments: node.end_comments
|
||||||
|
left: node.left
|
||||||
|
right: [
|
||||||
|
ast.Expr(ast.InfixExpr{
|
||||||
|
left: ast.CastExpr{
|
||||||
|
expr: node.left[0]
|
||||||
|
typ: modified_left_type
|
||||||
|
typname: c.table.type_str(modified_left_type)
|
||||||
|
pos: node.pos
|
||||||
|
}
|
||||||
|
op: .right_shift
|
||||||
|
right: node.right[0]
|
||||||
|
left_type: modified_left_type
|
||||||
|
right_type: right_type
|
||||||
|
pos: node.pos
|
||||||
|
}),
|
||||||
|
]
|
||||||
|
left_types: node.left_types
|
||||||
|
right_types: node.right_types
|
||||||
|
is_static: node.is_static
|
||||||
|
is_simple: node.is_simple
|
||||||
|
has_cross_var: node.has_cross_var
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {}
|
||||||
|
}
|
||||||
|
if node.op in [.plus_assign, .minus_assign, .mod_assign, .mult_assign, .div_assign]
|
||||||
|
&& ((left_sym.kind == .struct_ && right_sym.kind == .struct_)
|
||||||
|
|| left_sym.kind == .alias) {
|
||||||
|
left_name := c.table.type_to_str(left_type_unwrapped)
|
||||||
|
right_name := c.table.type_to_str(right_type_unwrapped)
|
||||||
|
parent_sym := c.table.get_final_type_symbol(left_type_unwrapped)
|
||||||
|
if left_sym.kind == .alias && right_sym.kind != .alias {
|
||||||
|
c.error('mismatched types `$left_name` and `$right_name`', node.pos)
|
||||||
|
}
|
||||||
|
extracted_op := match node.op {
|
||||||
|
.plus_assign { '+' }
|
||||||
|
.minus_assign { '-' }
|
||||||
|
.div_assign { '/' }
|
||||||
|
.mod_assign { '%' }
|
||||||
|
.mult_assign { '*' }
|
||||||
|
else { 'unknown op' }
|
||||||
|
}
|
||||||
|
if left_sym.kind == .struct_ && (left_sym.info as ast.Struct).generic_types.len > 0 {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if method := left_sym.find_method(extracted_op) {
|
||||||
|
if method.return_type != left_type_unwrapped {
|
||||||
|
c.error('operator `$extracted_op` must return `$left_name` to be used as an assignment operator',
|
||||||
|
node.pos)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if parent_sym.is_primitive() {
|
||||||
|
c.error('cannot use operator methods on type alias for `$parent_sym.name`',
|
||||||
|
node.pos)
|
||||||
|
}
|
||||||
|
if left_name == right_name {
|
||||||
|
c.error('undefined operation `$left_name` $extracted_op `$right_name`',
|
||||||
|
node.pos)
|
||||||
|
} else {
|
||||||
|
c.error('mismatched types `$left_name` and `$right_name`', node.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !is_blank_ident && !left.is_auto_deref_var() && !right.is_auto_deref_var()
|
||||||
|
&& right_sym.kind != .placeholder && left_sym.kind != .interface_
|
||||||
|
&& !right_type.has_flag(.generic) && !left_type.has_flag(.generic) {
|
||||||
|
// Dual sides check (compatibility check)
|
||||||
|
c.check_expected(right_type_unwrapped, left_type_unwrapped) or {
|
||||||
|
// allow for ptr += 2
|
||||||
|
if left_type_unwrapped.is_ptr() && right_type_unwrapped.is_int()
|
||||||
|
&& node.op in [.plus_assign, .minus_assign] {
|
||||||
|
if !c.inside_unsafe {
|
||||||
|
c.warn('pointer arithmetic is only allowed in `unsafe` blocks',
|
||||||
|
node.pos)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
c.error('cannot assign to `$left`: $err.msg', right.position())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if left_sym.kind == .interface_ {
|
||||||
|
if c.type_implements(right_type, left_type, right.position()) {
|
||||||
|
if !right_type.is_ptr() && !right_type.is_pointer() && right_sym.kind != .interface_
|
||||||
|
&& !c.inside_unsafe {
|
||||||
|
c.mark_as_referenced(mut &node.right[i], true)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// this needs to run after the assign stmt left exprs have been run through checker
|
||||||
|
// so that ident.obj is set
|
||||||
|
// Check `x := &y` and `mut x := <-ch`
|
||||||
|
if right_first is ast.PrefixExpr {
|
||||||
|
right_node := right_first
|
||||||
|
left_first := node.left[0]
|
||||||
|
if left_first is ast.Ident {
|
||||||
|
assigned_var := left_first
|
||||||
|
mut is_shared := false
|
||||||
|
if left_first.info is ast.IdentVar {
|
||||||
|
is_shared = left_first.info.share == .shared_t
|
||||||
|
}
|
||||||
|
old_inside_ref_lit := c.inside_ref_lit
|
||||||
|
c.inside_ref_lit = (c.inside_ref_lit || right_node.op == .amp || is_shared)
|
||||||
|
c.expr(right_node.right)
|
||||||
|
c.inside_ref_lit = old_inside_ref_lit
|
||||||
|
if right_node.op == .amp {
|
||||||
|
if right_node.right is ast.Ident {
|
||||||
|
if right_node.right.obj is ast.Var {
|
||||||
|
v := right_node.right.obj
|
||||||
|
right_type0 = v.typ
|
||||||
|
if !v.is_mut && assigned_var.is_mut && !c.inside_unsafe {
|
||||||
|
c.error('`$right_node.right.name` is immutable, cannot have a mutable reference to it',
|
||||||
|
right_node.pos)
|
||||||
|
}
|
||||||
|
} else if right_node.right.obj is ast.ConstField {
|
||||||
|
if assigned_var.is_mut && !c.inside_unsafe {
|
||||||
|
c.error('`$right_node.right.name` is immutable, cannot have a mutable reference to it',
|
||||||
|
right_node.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if right_node.op == .arrow {
|
||||||
|
if assigned_var.is_mut {
|
||||||
|
right_sym := c.table.get_type_symbol(right_type0)
|
||||||
|
if right_sym.kind == .chan {
|
||||||
|
chan_info := right_sym.chan_info()
|
||||||
|
if chan_info.elem_type.is_ptr() && !chan_info.is_mut {
|
||||||
|
c.error('cannot have a mutable reference to object from `$right_sym.name`',
|
||||||
|
right_node.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if node.left_types.len != node.left.len {
|
||||||
|
c.error('assign statement left type number mismatch', node.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -12,6 +12,21 @@ pub fn (mut c Checker) check_types(got ast.Type, expected ast.Type) bool {
|
||||||
if got == expected {
|
if got == expected {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
if c.pref.translated {
|
||||||
|
if expected == ast.byteptr_type {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
if expected.is_any_kind_of_pointer() { //&& !got.is_any_kind_of_pointer() {
|
||||||
|
// if true {
|
||||||
|
// return true
|
||||||
|
//}
|
||||||
|
deref := expected.deref()
|
||||||
|
got_sym := c.table.get_type_symbol(got)
|
||||||
|
if deref.is_number() && (got_sym.is_number() || got_sym.kind == .enum_) {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
got_is_ptr := got.is_ptr()
|
got_is_ptr := got.is_ptr()
|
||||||
exp_is_ptr := expected.is_ptr()
|
exp_is_ptr := expected.is_ptr()
|
||||||
if got_is_ptr && exp_is_ptr {
|
if got_is_ptr && exp_is_ptr {
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,570 @@
|
||||||
|
// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
|
||||||
|
// Use of this source code is governed by an MIT license that can be found in the LICENSE file.
|
||||||
|
module checker
|
||||||
|
|
||||||
|
import v.ast
|
||||||
|
import v.pref
|
||||||
|
import v.token
|
||||||
|
import v.util
|
||||||
|
import v.pkgconfig
|
||||||
|
|
||||||
|
fn (mut c Checker) comptime_call(mut node ast.ComptimeCall) ast.Type {
|
||||||
|
sym := c.table.get_type_symbol(c.unwrap_generic(c.expr(node.left)))
|
||||||
|
node.sym = *sym
|
||||||
|
if node.is_env {
|
||||||
|
env_value := util.resolve_env_value("\$env('$node.args_var')", false) or {
|
||||||
|
c.error(err.msg, node.env_pos)
|
||||||
|
return ast.string_type
|
||||||
|
}
|
||||||
|
node.env_value = env_value
|
||||||
|
return ast.string_type
|
||||||
|
}
|
||||||
|
if node.is_embed {
|
||||||
|
// c.file.embedded_files << node.embed_file
|
||||||
|
if node.embed_file.compression_type !in valid_comptime_compression_types {
|
||||||
|
supported := valid_comptime_compression_types.map('.$it').join(', ')
|
||||||
|
c.error('not supported compression type: .${node.embed_file.compression_type}. supported: $supported',
|
||||||
|
node.pos)
|
||||||
|
}
|
||||||
|
return c.table.find_type_idx('v.embed_file.EmbedFileData')
|
||||||
|
}
|
||||||
|
if node.is_vweb {
|
||||||
|
// TODO assoc parser bug
|
||||||
|
pref_ := *c.pref
|
||||||
|
pref2 := &pref.Preferences{
|
||||||
|
...pref_
|
||||||
|
is_vweb: true
|
||||||
|
}
|
||||||
|
mut c2 := new_checker(c.table, pref2)
|
||||||
|
c2.check(node.vweb_tmpl)
|
||||||
|
mut i := 0 // tmp counter var for skipping first three tmpl vars
|
||||||
|
for k, _ in c2.file.scope.children[0].objects {
|
||||||
|
if i < 2 {
|
||||||
|
// Skip first three because they are tmpl vars see vlib/vweb/tmpl/tmpl.v
|
||||||
|
i++
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if k in c.fn_scope.objects && unsafe { c.fn_scope.objects[k] } is ast.Var {
|
||||||
|
mut vsc := unsafe { c.fn_scope.objects[k] } as ast.Var
|
||||||
|
vsc.is_used = true
|
||||||
|
c.fn_scope.objects[k] = vsc
|
||||||
|
}
|
||||||
|
}
|
||||||
|
c.warnings << c2.warnings
|
||||||
|
c.errors << c2.errors
|
||||||
|
c.notices << c2.notices
|
||||||
|
c.nr_warnings += c2.nr_warnings
|
||||||
|
c.nr_errors += c2.nr_errors
|
||||||
|
c.nr_notices += c2.nr_notices
|
||||||
|
}
|
||||||
|
if node.method_name == 'html' {
|
||||||
|
rtyp := c.table.find_type_idx('vweb.Result')
|
||||||
|
node.result_type = rtyp
|
||||||
|
return rtyp
|
||||||
|
}
|
||||||
|
if node.method_name == 'method' {
|
||||||
|
for i, arg in node.args {
|
||||||
|
// check each arg expression
|
||||||
|
node.args[i].typ = c.expr(arg.expr)
|
||||||
|
}
|
||||||
|
// assume string for now
|
||||||
|
return ast.string_type
|
||||||
|
}
|
||||||
|
if node.is_vweb {
|
||||||
|
return ast.string_type
|
||||||
|
}
|
||||||
|
// s.$my_str()
|
||||||
|
v := node.scope.find_var(node.method_name) or {
|
||||||
|
c.error('unknown identifier `$node.method_name`', node.method_pos)
|
||||||
|
return ast.void_type
|
||||||
|
}
|
||||||
|
if v.typ != ast.string_type {
|
||||||
|
s := c.expected_msg(v.typ, ast.string_type)
|
||||||
|
c.error('invalid string method call: $s', node.method_pos)
|
||||||
|
return ast.void_type
|
||||||
|
}
|
||||||
|
// note: we should use a compile-time evaluation function rather than handle here
|
||||||
|
// mut variables will not work after init
|
||||||
|
mut method_name := ''
|
||||||
|
if v.expr is ast.StringLiteral {
|
||||||
|
method_name = v.expr.val
|
||||||
|
} else {
|
||||||
|
c.error('todo: not a string literal', node.method_pos)
|
||||||
|
}
|
||||||
|
f := node.sym.find_method(method_name) or {
|
||||||
|
c.error('could not find method `$method_name`', node.method_pos)
|
||||||
|
return ast.void_type
|
||||||
|
}
|
||||||
|
// println(f.name + ' ' + c.table.type_to_str(f.return_type))
|
||||||
|
node.result_type = f.return_type
|
||||||
|
return f.return_type
|
||||||
|
}
|
||||||
|
|
||||||
|
// comptime const eval
|
||||||
|
fn (mut c Checker) eval_comptime_const_expr(expr ast.Expr, nlevel int) ?ast.ComptTimeConstValue {
|
||||||
|
if nlevel > 100 {
|
||||||
|
// protect against a too deep comptime eval recursion
|
||||||
|
return none
|
||||||
|
}
|
||||||
|
match expr {
|
||||||
|
ast.ParExpr {
|
||||||
|
return c.eval_comptime_const_expr(expr.expr, nlevel + 1)
|
||||||
|
}
|
||||||
|
// ast.EnumVal {
|
||||||
|
// c.note('>>>>>>>> expr: $expr', expr.pos)
|
||||||
|
// return expr.val.i64()
|
||||||
|
// }
|
||||||
|
ast.SizeOf {
|
||||||
|
xtype := expr.typ
|
||||||
|
if xtype.is_real_pointer() {
|
||||||
|
if c.pref.m64 {
|
||||||
|
return 8 // 64bit platform
|
||||||
|
}
|
||||||
|
return 4 // 32bit platform
|
||||||
|
}
|
||||||
|
if int(xtype) == xtype.idx() {
|
||||||
|
match xtype {
|
||||||
|
ast.char_type { return 1 }
|
||||||
|
ast.i8_type { return 1 }
|
||||||
|
ast.i16_type { return 2 }
|
||||||
|
ast.int_type { return 4 }
|
||||||
|
ast.i64_type { return 8 }
|
||||||
|
//
|
||||||
|
ast.byte_type { return 1 }
|
||||||
|
ast.u8_type { return 1 }
|
||||||
|
ast.u16_type { return 2 }
|
||||||
|
ast.u32_type { return 4 }
|
||||||
|
ast.u64_type { return 8 }
|
||||||
|
else {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return none
|
||||||
|
}
|
||||||
|
ast.FloatLiteral {
|
||||||
|
x := expr.val.f64()
|
||||||
|
return x
|
||||||
|
}
|
||||||
|
ast.IntegerLiteral {
|
||||||
|
x := expr.val.u64()
|
||||||
|
if x > 9223372036854775807 {
|
||||||
|
return x
|
||||||
|
}
|
||||||
|
return expr.val.i64()
|
||||||
|
}
|
||||||
|
ast.StringLiteral {
|
||||||
|
return util.smart_quote(expr.val, expr.is_raw)
|
||||||
|
}
|
||||||
|
ast.CharLiteral {
|
||||||
|
runes := expr.val.runes()
|
||||||
|
if runes.len > 0 {
|
||||||
|
return runes[0]
|
||||||
|
}
|
||||||
|
return none
|
||||||
|
}
|
||||||
|
ast.Ident {
|
||||||
|
if expr.obj is ast.ConstField {
|
||||||
|
// an existing constant?
|
||||||
|
return c.eval_comptime_const_expr(expr.obj.expr, nlevel + 1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ast.CastExpr {
|
||||||
|
cast_expr_value := c.eval_comptime_const_expr(expr.expr, nlevel + 1) or { return none }
|
||||||
|
if expr.typ == ast.i8_type {
|
||||||
|
return cast_expr_value.i8() or { return none }
|
||||||
|
}
|
||||||
|
if expr.typ == ast.i16_type {
|
||||||
|
return cast_expr_value.i16() or { return none }
|
||||||
|
}
|
||||||
|
if expr.typ == ast.int_type {
|
||||||
|
return cast_expr_value.int() or { return none }
|
||||||
|
}
|
||||||
|
if expr.typ == ast.i64_type {
|
||||||
|
return cast_expr_value.i64() or { return none }
|
||||||
|
}
|
||||||
|
//
|
||||||
|
if expr.typ == ast.byte_type {
|
||||||
|
return cast_expr_value.byte() or { return none }
|
||||||
|
}
|
||||||
|
if expr.typ == ast.u16_type {
|
||||||
|
return cast_expr_value.u16() or { return none }
|
||||||
|
}
|
||||||
|
if expr.typ == ast.u32_type {
|
||||||
|
return cast_expr_value.u32() or { return none }
|
||||||
|
}
|
||||||
|
if expr.typ == ast.u64_type {
|
||||||
|
return cast_expr_value.u64() or { return none }
|
||||||
|
}
|
||||||
|
//
|
||||||
|
if expr.typ == ast.f32_type {
|
||||||
|
return cast_expr_value.f32() or { return none }
|
||||||
|
}
|
||||||
|
if expr.typ == ast.f64_type {
|
||||||
|
return cast_expr_value.f64() or { return none }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ast.InfixExpr {
|
||||||
|
left := c.eval_comptime_const_expr(expr.left, nlevel + 1) ?
|
||||||
|
right := c.eval_comptime_const_expr(expr.right, nlevel + 1) ?
|
||||||
|
if left is string && right is string {
|
||||||
|
match expr.op {
|
||||||
|
.plus {
|
||||||
|
return left + right
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
return none
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else if left is u64 && right is i64 {
|
||||||
|
match expr.op {
|
||||||
|
.plus { return i64(left) + i64(right) }
|
||||||
|
.minus { return i64(left) - i64(right) }
|
||||||
|
.mul { return i64(left) * i64(right) }
|
||||||
|
.div { return i64(left) / i64(right) }
|
||||||
|
.mod { return i64(left) % i64(right) }
|
||||||
|
.xor { return i64(left) ^ i64(right) }
|
||||||
|
.pipe { return i64(left) | i64(right) }
|
||||||
|
.amp { return i64(left) & i64(right) }
|
||||||
|
.left_shift { return i64(u64(left) << i64(right)) }
|
||||||
|
.right_shift { return i64(u64(left) >> i64(right)) }
|
||||||
|
.unsigned_right_shift { return i64(u64(left) >>> i64(right)) }
|
||||||
|
else { return none }
|
||||||
|
}
|
||||||
|
} else if left is i64 && right is u64 {
|
||||||
|
match expr.op {
|
||||||
|
.plus { return i64(left) + i64(right) }
|
||||||
|
.minus { return i64(left) - i64(right) }
|
||||||
|
.mul { return i64(left) * i64(right) }
|
||||||
|
.div { return i64(left) / i64(right) }
|
||||||
|
.mod { return i64(left) % i64(right) }
|
||||||
|
.xor { return i64(left) ^ i64(right) }
|
||||||
|
.pipe { return i64(left) | i64(right) }
|
||||||
|
.amp { return i64(left) & i64(right) }
|
||||||
|
.left_shift { return i64(u64(left) << i64(right)) }
|
||||||
|
.right_shift { return i64(u64(left) >> i64(right)) }
|
||||||
|
.unsigned_right_shift { return i64(u64(left) >>> i64(right)) }
|
||||||
|
else { return none }
|
||||||
|
}
|
||||||
|
} else if left is u64 && right is u64 {
|
||||||
|
match expr.op {
|
||||||
|
.plus { return left + right }
|
||||||
|
.minus { return left - right }
|
||||||
|
.mul { return left * right }
|
||||||
|
.div { return left / right }
|
||||||
|
.mod { return left % right }
|
||||||
|
.xor { return left ^ right }
|
||||||
|
.pipe { return left | right }
|
||||||
|
.amp { return left & right }
|
||||||
|
.left_shift { return left << right }
|
||||||
|
.right_shift { return left >> right }
|
||||||
|
.unsigned_right_shift { return left >>> right }
|
||||||
|
else { return none }
|
||||||
|
}
|
||||||
|
} else if left is i64 && right is i64 {
|
||||||
|
match expr.op {
|
||||||
|
.plus { return left + right }
|
||||||
|
.minus { return left - right }
|
||||||
|
.mul { return left * right }
|
||||||
|
.div { return left / right }
|
||||||
|
.mod { return left % right }
|
||||||
|
.xor { return left ^ right }
|
||||||
|
.pipe { return left | right }
|
||||||
|
.amp { return left & right }
|
||||||
|
.left_shift { return i64(u64(left) << right) }
|
||||||
|
.right_shift { return i64(u64(left) >> right) }
|
||||||
|
.unsigned_right_shift { return i64(u64(left) >>> right) }
|
||||||
|
else { return none }
|
||||||
|
}
|
||||||
|
} else if left is byte && right is byte {
|
||||||
|
match expr.op {
|
||||||
|
.plus { return left + right }
|
||||||
|
.minus { return left - right }
|
||||||
|
.mul { return left * right }
|
||||||
|
.div { return left / right }
|
||||||
|
.mod { return left % right }
|
||||||
|
.xor { return left ^ right }
|
||||||
|
.pipe { return left | right }
|
||||||
|
.amp { return left & right }
|
||||||
|
.left_shift { return left << right }
|
||||||
|
.right_shift { return left >> right }
|
||||||
|
.unsigned_right_shift { return left >>> right }
|
||||||
|
else { return none }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// ast.ArrayInit {}
|
||||||
|
// ast.PrefixExpr {
|
||||||
|
// c.note('prefixexpr: $expr', expr.pos)
|
||||||
|
// }
|
||||||
|
else {
|
||||||
|
// eprintln('>>> nlevel: $nlevel | another $expr.type_name() | $expr ')
|
||||||
|
return none
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return none
|
||||||
|
}
|
||||||
|
|
||||||
|
fn (mut c Checker) verify_vweb_params_for_method(node ast.Fn) (bool, int, int) {
|
||||||
|
margs := node.params.len - 1 // first arg is the receiver/this
|
||||||
|
if node.attrs.len == 0 {
|
||||||
|
// allow non custom routed methods, with 1:1 mapping
|
||||||
|
return true, -1, margs
|
||||||
|
}
|
||||||
|
if node.params.len > 1 {
|
||||||
|
for param in node.params[1..] {
|
||||||
|
param_sym := c.table.get_final_type_symbol(param.typ)
|
||||||
|
if !(param_sym.is_string() || param_sym.is_number() || param_sym.is_float()
|
||||||
|
|| param_sym.kind == .bool) {
|
||||||
|
c.error('invalid type `$param_sym.name` for parameter `$param.name` in vweb app method `$node.name`',
|
||||||
|
param.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
mut route_attributes := 0
|
||||||
|
for a in node.attrs {
|
||||||
|
if a.name.starts_with('/') {
|
||||||
|
route_attributes += a.name.count(':')
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return route_attributes == margs, route_attributes, margs
|
||||||
|
}
|
||||||
|
|
||||||
|
fn (mut c Checker) verify_all_vweb_routes() {
|
||||||
|
if c.vweb_gen_types.len == 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
c.table.used_vweb_types = c.vweb_gen_types
|
||||||
|
typ_vweb_result := c.table.find_type_idx('vweb.Result')
|
||||||
|
old_file := c.file
|
||||||
|
for vgt in c.vweb_gen_types {
|
||||||
|
sym_app := c.table.get_type_symbol(vgt)
|
||||||
|
for m in sym_app.methods {
|
||||||
|
if m.return_type == typ_vweb_result {
|
||||||
|
is_ok, nroute_attributes, nargs := c.verify_vweb_params_for_method(m)
|
||||||
|
if !is_ok {
|
||||||
|
f := &ast.FnDecl(m.source_fn)
|
||||||
|
if isnil(f) {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if f.return_type == typ_vweb_result && f.receiver.typ == m.params[0].typ
|
||||||
|
&& f.name == m.name && !f.attrs.contains('post') {
|
||||||
|
c.change_current_file(f.source_file) // setup of file path for the warning
|
||||||
|
c.warn('mismatched parameters count between vweb method `${sym_app.name}.$m.name` ($nargs) and route attribute $m.attrs ($nroute_attributes)',
|
||||||
|
f.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
c.change_current_file(old_file)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn (mut c Checker) evaluate_once_comptime_if_attribute(mut node ast.Attr) bool {
|
||||||
|
if node.ct_evaled {
|
||||||
|
return node.ct_skip
|
||||||
|
}
|
||||||
|
if node.ct_expr is ast.Ident {
|
||||||
|
if node.ct_opt {
|
||||||
|
if node.ct_expr.name in valid_comptime_not_user_defined {
|
||||||
|
c.error('optional `[if expression ?]` tags, can be used only for user defined identifiers',
|
||||||
|
node.pos)
|
||||||
|
node.ct_skip = true
|
||||||
|
} else {
|
||||||
|
node.ct_skip = node.ct_expr.name !in c.pref.compile_defines
|
||||||
|
}
|
||||||
|
node.ct_evaled = true
|
||||||
|
return node.ct_skip
|
||||||
|
} else {
|
||||||
|
if node.ct_expr.name !in valid_comptime_not_user_defined {
|
||||||
|
c.note('`[if $node.ct_expr.name]` is deprecated. Use `[if $node.ct_expr.name ?]` instead',
|
||||||
|
node.pos)
|
||||||
|
node.ct_skip = node.ct_expr.name !in c.pref.compile_defines
|
||||||
|
node.ct_evaled = true
|
||||||
|
return node.ct_skip
|
||||||
|
} else {
|
||||||
|
if node.ct_expr.name in c.pref.compile_defines {
|
||||||
|
// explicitly allow custom user overrides with `-d linux` for example, for easier testing:
|
||||||
|
node.ct_skip = false
|
||||||
|
node.ct_evaled = true
|
||||||
|
return node.ct_skip
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
c.inside_ct_attr = true
|
||||||
|
node.ct_skip = c.comptime_if_branch(node.ct_expr, node.pos)
|
||||||
|
c.inside_ct_attr = false
|
||||||
|
node.ct_evaled = true
|
||||||
|
return node.ct_skip
|
||||||
|
}
|
||||||
|
|
||||||
|
// comptime_if_branch checks the condition of a compile-time `if` branch. It returns `true`
|
||||||
|
// if that branch's contents should be skipped (targets a different os for example)
|
||||||
|
fn (mut c Checker) comptime_if_branch(cond ast.Expr, pos token.Position) bool {
|
||||||
|
// TODO: better error messages here
|
||||||
|
match cond {
|
||||||
|
ast.BoolLiteral {
|
||||||
|
return !cond.val
|
||||||
|
}
|
||||||
|
ast.ParExpr {
|
||||||
|
return c.comptime_if_branch(cond.expr, pos)
|
||||||
|
}
|
||||||
|
ast.PrefixExpr {
|
||||||
|
if cond.op != .not {
|
||||||
|
c.error('invalid `\$if` condition', cond.pos)
|
||||||
|
}
|
||||||
|
return !c.comptime_if_branch(cond.right, cond.pos)
|
||||||
|
}
|
||||||
|
ast.PostfixExpr {
|
||||||
|
if cond.op != .question {
|
||||||
|
c.error('invalid \$if postfix operator', cond.pos)
|
||||||
|
} else if cond.expr is ast.Ident {
|
||||||
|
return cond.expr.name !in c.pref.compile_defines_all
|
||||||
|
} else {
|
||||||
|
c.error('invalid `\$if` condition', cond.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ast.InfixExpr {
|
||||||
|
match cond.op {
|
||||||
|
.and {
|
||||||
|
l := c.comptime_if_branch(cond.left, cond.pos)
|
||||||
|
r := c.comptime_if_branch(cond.right, cond.pos)
|
||||||
|
return l || r // skip (return true) if at least one should be skipped
|
||||||
|
}
|
||||||
|
.logical_or {
|
||||||
|
l := c.comptime_if_branch(cond.left, cond.pos)
|
||||||
|
r := c.comptime_if_branch(cond.right, cond.pos)
|
||||||
|
return l && r // skip (return true) only if both should be skipped
|
||||||
|
}
|
||||||
|
.key_is, .not_is {
|
||||||
|
if cond.left is ast.TypeNode && cond.right is ast.TypeNode {
|
||||||
|
// `$if Foo is Interface {`
|
||||||
|
sym := c.table.get_type_symbol(cond.right.typ)
|
||||||
|
if sym.kind != .interface_ {
|
||||||
|
c.expr(cond.left)
|
||||||
|
// c.error('`$sym.name` is not an interface', cond.right.position())
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
} else if cond.left in [ast.SelectorExpr, ast.TypeNode] {
|
||||||
|
// `$if method.@type is string`
|
||||||
|
c.expr(cond.left)
|
||||||
|
return false
|
||||||
|
} else {
|
||||||
|
c.error('invalid `\$if` condition: expected a type or a selector expression or an interface check',
|
||||||
|
cond.left.position())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
.eq, .ne {
|
||||||
|
if cond.left is ast.SelectorExpr && cond.right is ast.IntegerLiteral {
|
||||||
|
// $if method.args.len == 1
|
||||||
|
} else if cond.left is ast.Ident {
|
||||||
|
// $if version == 2
|
||||||
|
left_type := c.expr(cond.left)
|
||||||
|
right_type := c.expr(cond.right)
|
||||||
|
expr := c.find_definition(cond.left) or {
|
||||||
|
c.error(err.msg, cond.left.pos)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !c.check_types(right_type, left_type) {
|
||||||
|
left_name := c.table.type_to_str(left_type)
|
||||||
|
right_name := c.table.type_to_str(right_type)
|
||||||
|
c.error('mismatched types `$left_name` and `$right_name`',
|
||||||
|
cond.pos)
|
||||||
|
}
|
||||||
|
// :)
|
||||||
|
// until `v.eval` is stable, I can't think of a better way to do this
|
||||||
|
different := expr.str() != cond.right.str()
|
||||||
|
return if cond.op == .eq { different } else { !different }
|
||||||
|
} else {
|
||||||
|
c.error('invalid `\$if` condition: ${cond.left.type_name()}1',
|
||||||
|
cond.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
c.error('invalid `\$if` condition', cond.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ast.Ident {
|
||||||
|
cname := cond.name
|
||||||
|
if cname in valid_comptime_if_os {
|
||||||
|
mut is_os_target_different := false
|
||||||
|
if !c.pref.output_cross_c {
|
||||||
|
target_os := c.pref.os.str().to_lower()
|
||||||
|
is_os_target_different = cname != target_os
|
||||||
|
}
|
||||||
|
return is_os_target_different
|
||||||
|
} else if cname in valid_comptime_if_compilers {
|
||||||
|
return pref.cc_from_string(cname) != c.pref.ccompiler_type
|
||||||
|
} else if cname in valid_comptime_if_platforms {
|
||||||
|
if cname == 'aarch64' {
|
||||||
|
c.note('use `arm64` instead of `aarch64`', pos)
|
||||||
|
}
|
||||||
|
match cname {
|
||||||
|
'amd64' { return c.pref.arch != .amd64 }
|
||||||
|
'i386' { return c.pref.arch != .i386 }
|
||||||
|
'aarch64' { return c.pref.arch != .arm64 }
|
||||||
|
'arm64' { return c.pref.arch != .arm64 }
|
||||||
|
'arm32' { return c.pref.arch != .arm32 }
|
||||||
|
'rv64' { return c.pref.arch != .rv64 }
|
||||||
|
'rv32' { return c.pref.arch != .rv32 }
|
||||||
|
else { return false }
|
||||||
|
}
|
||||||
|
} else if cname in valid_comptime_if_cpu_features {
|
||||||
|
return false
|
||||||
|
} else if cname in valid_comptime_if_other {
|
||||||
|
match cname {
|
||||||
|
'js' { return !c.pref.backend.is_js() }
|
||||||
|
'debug' { return !c.pref.is_debug }
|
||||||
|
'prod' { return !c.pref.is_prod }
|
||||||
|
'test' { return !c.pref.is_test }
|
||||||
|
'glibc' { return false } // TODO
|
||||||
|
'threads' { return c.table.gostmts == 0 }
|
||||||
|
'prealloc' { return !c.pref.prealloc }
|
||||||
|
'no_bounds_checking' { return cname !in c.pref.compile_defines_all }
|
||||||
|
'freestanding' { return !c.pref.is_bare || c.pref.output_cross_c }
|
||||||
|
'interpreter' { c.pref.backend != .interpret }
|
||||||
|
else { return false }
|
||||||
|
}
|
||||||
|
} else if cname !in c.pref.compile_defines_all {
|
||||||
|
if cname == 'linux_or_macos' {
|
||||||
|
c.error('linux_or_macos is deprecated, use `\$if linux || macos {` instead',
|
||||||
|
cond.pos)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
// `$if some_var {}`, or `[if user_defined_tag] fn abc(){}`
|
||||||
|
typ := c.expr(cond)
|
||||||
|
if cond.obj !is ast.Var && cond.obj !is ast.ConstField
|
||||||
|
&& cond.obj !is ast.GlobalField {
|
||||||
|
if !c.inside_ct_attr {
|
||||||
|
c.error('unknown var: `$cname`', pos)
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
expr := c.find_obj_definition(cond.obj) or {
|
||||||
|
c.error(err.msg, cond.pos)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if !c.check_types(typ, ast.bool_type) {
|
||||||
|
type_name := c.table.type_to_str(typ)
|
||||||
|
c.error('non-bool type `$type_name` used as \$if condition', cond.pos)
|
||||||
|
}
|
||||||
|
// :)
|
||||||
|
// until `v.eval` is stable, I can't think of a better way to do this
|
||||||
|
return !(expr as ast.BoolLiteral).val
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ast.ComptimeCall {
|
||||||
|
if cond.is_pkgconfig {
|
||||||
|
mut m := pkgconfig.main([cond.args_var]) or {
|
||||||
|
c.error(err.msg, cond.pos)
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
m.run() or { return true }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
c.error('invalid `\$if` condition', pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,192 @@
|
||||||
|
// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
|
||||||
|
// Use of this source code is governed by an MIT license that can be found in the LICENSE file.
|
||||||
|
module checker
|
||||||
|
|
||||||
|
import v.ast
|
||||||
|
import v.token
|
||||||
|
|
||||||
|
fn (mut c Checker) sql_expr(mut node ast.SqlExpr) ast.Type {
|
||||||
|
c.inside_sql = true
|
||||||
|
defer {
|
||||||
|
c.inside_sql = false
|
||||||
|
}
|
||||||
|
sym := c.table.get_type_symbol(node.table_expr.typ)
|
||||||
|
c.ensure_type_exists(node.table_expr.typ, node.pos) or { return ast.void_type }
|
||||||
|
c.cur_orm_ts = *sym
|
||||||
|
if sym.info !is ast.Struct {
|
||||||
|
c.error('The table symbol `$sym.name` has to be a struct', node.table_expr.pos)
|
||||||
|
return ast.void_type
|
||||||
|
}
|
||||||
|
info := sym.info as ast.Struct
|
||||||
|
fields := c.fetch_and_verify_orm_fields(info, node.table_expr.pos, sym.name)
|
||||||
|
mut sub_structs := map[int]ast.SqlExpr{}
|
||||||
|
for f in fields.filter((c.table.type_symbols[int(it.typ)].kind == .struct_
|
||||||
|
|| (c.table.get_type_symbol(it.typ).kind == .array
|
||||||
|
&& c.table.get_type_symbol(c.table.get_type_symbol(it.typ).array_info().elem_type).kind == .struct_))
|
||||||
|
&& c.table.get_type_name(it.typ) != 'time.Time') {
|
||||||
|
typ := if c.table.get_type_symbol(f.typ).kind == .struct_ {
|
||||||
|
f.typ
|
||||||
|
} else if c.table.get_type_symbol(f.typ).kind == .array {
|
||||||
|
c.table.get_type_symbol(f.typ).array_info().elem_type
|
||||||
|
} else {
|
||||||
|
ast.Type(0)
|
||||||
|
}
|
||||||
|
mut n := ast.SqlExpr{
|
||||||
|
pos: node.pos
|
||||||
|
has_where: true
|
||||||
|
typ: typ
|
||||||
|
db_expr: node.db_expr
|
||||||
|
table_expr: ast.TypeNode{
|
||||||
|
pos: node.table_expr.pos
|
||||||
|
typ: typ
|
||||||
|
}
|
||||||
|
}
|
||||||
|
tmp_inside_sql := c.inside_sql
|
||||||
|
c.sql_expr(mut n)
|
||||||
|
c.inside_sql = tmp_inside_sql
|
||||||
|
n.where_expr = ast.InfixExpr{
|
||||||
|
op: .eq
|
||||||
|
pos: n.pos
|
||||||
|
left: ast.Ident{
|
||||||
|
language: .v
|
||||||
|
tok_kind: .eq
|
||||||
|
scope: c.fn_scope
|
||||||
|
obj: ast.Var{}
|
||||||
|
mod: 'main'
|
||||||
|
name: 'id'
|
||||||
|
is_mut: false
|
||||||
|
kind: .unresolved
|
||||||
|
info: ast.IdentVar{}
|
||||||
|
}
|
||||||
|
right: ast.Ident{
|
||||||
|
language: .c
|
||||||
|
mod: 'main'
|
||||||
|
tok_kind: .eq
|
||||||
|
obj: ast.Var{}
|
||||||
|
is_mut: false
|
||||||
|
scope: c.fn_scope
|
||||||
|
info: ast.IdentVar{
|
||||||
|
typ: ast.int_type
|
||||||
|
}
|
||||||
|
}
|
||||||
|
left_type: ast.int_type
|
||||||
|
right_type: ast.int_type
|
||||||
|
auto_locked: ''
|
||||||
|
or_block: ast.OrExpr{}
|
||||||
|
}
|
||||||
|
|
||||||
|
sub_structs[int(typ)] = n
|
||||||
|
}
|
||||||
|
node.fields = fields
|
||||||
|
node.sub_structs = sub_structs.move()
|
||||||
|
if node.has_where {
|
||||||
|
c.expr(node.where_expr)
|
||||||
|
}
|
||||||
|
if node.has_offset {
|
||||||
|
c.expr(node.offset_expr)
|
||||||
|
}
|
||||||
|
if node.has_limit {
|
||||||
|
c.expr(node.limit_expr)
|
||||||
|
}
|
||||||
|
if node.has_order {
|
||||||
|
c.expr(node.order_expr)
|
||||||
|
}
|
||||||
|
c.expr(node.db_expr)
|
||||||
|
return node.typ
|
||||||
|
}
|
||||||
|
|
||||||
|
fn (mut c Checker) sql_stmt(mut node ast.SqlStmt) ast.Type {
|
||||||
|
c.expr(node.db_expr)
|
||||||
|
mut typ := ast.void_type
|
||||||
|
for mut line in node.lines {
|
||||||
|
a := c.sql_stmt_line(mut line)
|
||||||
|
if a != ast.void_type {
|
||||||
|
typ = a
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return typ
|
||||||
|
}
|
||||||
|
|
||||||
|
fn (mut c Checker) sql_stmt_line(mut node ast.SqlStmtLine) ast.Type {
|
||||||
|
c.inside_sql = true
|
||||||
|
defer {
|
||||||
|
c.inside_sql = false
|
||||||
|
}
|
||||||
|
c.ensure_type_exists(node.table_expr.typ, node.pos) or { return ast.void_type }
|
||||||
|
table_sym := c.table.get_type_symbol(node.table_expr.typ)
|
||||||
|
c.cur_orm_ts = *table_sym
|
||||||
|
if table_sym.info !is ast.Struct {
|
||||||
|
c.error('unknown type `$table_sym.name`', node.pos)
|
||||||
|
return ast.void_type
|
||||||
|
}
|
||||||
|
info := table_sym.info as ast.Struct
|
||||||
|
fields := c.fetch_and_verify_orm_fields(info, node.table_expr.pos, table_sym.name)
|
||||||
|
mut sub_structs := map[int]ast.SqlStmtLine{}
|
||||||
|
for f in fields.filter(((c.table.type_symbols[int(it.typ)].kind == .struct_)
|
||||||
|
|| (c.table.get_type_symbol(it.typ).kind == .array
|
||||||
|
&& c.table.get_type_symbol(c.table.get_type_symbol(it.typ).array_info().elem_type).kind == .struct_))
|
||||||
|
&& c.table.get_type_name(it.typ) != 'time.Time') {
|
||||||
|
typ := if c.table.get_type_symbol(f.typ).kind == .struct_ {
|
||||||
|
f.typ
|
||||||
|
} else if c.table.get_type_symbol(f.typ).kind == .array {
|
||||||
|
c.table.get_type_symbol(f.typ).array_info().elem_type
|
||||||
|
} else {
|
||||||
|
ast.Type(0)
|
||||||
|
}
|
||||||
|
mut object_var_name := '${node.object_var_name}.$f.name'
|
||||||
|
if typ != f.typ {
|
||||||
|
object_var_name = node.object_var_name
|
||||||
|
}
|
||||||
|
mut n := ast.SqlStmtLine{
|
||||||
|
pos: node.pos
|
||||||
|
kind: node.kind
|
||||||
|
table_expr: ast.TypeNode{
|
||||||
|
pos: node.table_expr.pos
|
||||||
|
typ: typ
|
||||||
|
}
|
||||||
|
object_var_name: object_var_name
|
||||||
|
}
|
||||||
|
tmp_inside_sql := c.inside_sql
|
||||||
|
c.sql_stmt_line(mut n)
|
||||||
|
c.inside_sql = tmp_inside_sql
|
||||||
|
sub_structs[typ] = n
|
||||||
|
}
|
||||||
|
node.fields = fields
|
||||||
|
node.sub_structs = sub_structs.move()
|
||||||
|
for i, column in node.updated_columns {
|
||||||
|
x := node.fields.filter(it.name == column)
|
||||||
|
if x.len == 0 {
|
||||||
|
c.error('type `$table_sym.name` has no field named `$column`', node.pos)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
field := x[0]
|
||||||
|
node.updated_columns[i] = c.fetch_field_name(field)
|
||||||
|
}
|
||||||
|
if node.kind == .update {
|
||||||
|
for expr in node.update_exprs {
|
||||||
|
c.expr(expr)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if node.where_expr !is ast.EmptyExpr {
|
||||||
|
c.expr(node.where_expr)
|
||||||
|
}
|
||||||
|
|
||||||
|
return ast.void_type
|
||||||
|
}
|
||||||
|
|
||||||
|
fn (mut c Checker) fetch_and_verify_orm_fields(info ast.Struct, pos token.Position, table_name string) []ast.StructField {
|
||||||
|
fields := info.fields.filter(
|
||||||
|
(it.typ in [ast.string_type, ast.bool_type] || int(it.typ) in ast.number_type_idxs
|
||||||
|
|| c.table.type_symbols[int(it.typ)].kind == .struct_
|
||||||
|
|| (c.table.get_type_symbol(it.typ).kind == .array
|
||||||
|
&& c.table.get_type_symbol(c.table.get_type_symbol(it.typ).array_info().elem_type).kind == .struct_))
|
||||||
|
&& !it.attrs.contains('skip'))
|
||||||
|
if fields.len == 0 {
|
||||||
|
c.error('V orm: select: empty fields in `$table_name`', pos)
|
||||||
|
return []ast.StructField{}
|
||||||
|
}
|
||||||
|
if fields[0].name != 'id' {
|
||||||
|
c.error('V orm: `id int` must be the first field in `$table_name`', pos)
|
||||||
|
}
|
||||||
|
return fields
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue