vim: src/vim9type.c annotate

annotate src/vim9type.c @ 30576:72e6073a2822 v9.0.0623

patch 9.0.0623: error for modifying a const is not detected at compile time Commit: https://github.com/vim/vim/commit/fa1039760e8c1a0c7a2a722160bd3d71a4736e61 Author: Bram Moolenaar <Bram@vim.org> Date: Thu Sep 29 19:14:42 2022 +0100 patch 9.0.0623: error for modifying a const is not detected at compile time Problem: Error for modifying a const is not detected at compile time. Solution: Add TTFLAG_CONST and check for it in add() and extend().

author	Bram Moolenaar <Bram@vim.org>
date	Thu, 29 Sep 2022 20:15:05 +0200
parents	029c59bf78f1
children	f1010a0e6226

rev	line source
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1 /* vi:set ts=8 sts=4 sw=4 noet:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	2 *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	3 * VIM - Vi IMproved by Bram Moolenaar
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	4 *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	5 * Do ":help uganda" in Vim to read copying and usage conditions.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	6 * Do ":help credits" in Vim to see a list of people who contributed.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	7 * See README.txt for an overview of the Vim source code.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	8 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	9
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	10 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	11 * vim9type.c: handling of types
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	12 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	13
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	14 #define USING_FLOAT_STUFF
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	15 #include "vim.h"
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	16
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	17 #if defined(FEAT_EVAL) \|\| defined(PROTO)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	18
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	19 #ifdef VMS
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	20 # include <float.h>
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	21 #endif
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	22
30283 d751e924cc29 patch 9.0.0477: missing dependency may cause crashes on incomplete build Bram Moolenaar <Bram@vim.org> parents: 29780 diff changeset	23 // When not generating protos this is included in proto.h
d751e924cc29 patch 9.0.0477: missing dependency may cause crashes on incomplete build Bram Moolenaar <Bram@vim.org> parents: 29780 diff changeset	24 #ifdef PROTO
d751e924cc29 patch 9.0.0477: missing dependency may cause crashes on incomplete build Bram Moolenaar <Bram@vim.org> parents: 29780 diff changeset	25 # include "vim9.h"
d751e924cc29 patch 9.0.0477: missing dependency may cause crashes on incomplete build Bram Moolenaar <Bram@vim.org> parents: 29780 diff changeset	26 #endif
d751e924cc29 patch 9.0.0477: missing dependency may cause crashes on incomplete build Bram Moolenaar <Bram@vim.org> parents: 29780 diff changeset	27
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	28 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	29 * Allocate memory for a type_T and add the pointer to type_gap, so that it can
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	30 * be easily freed later.
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	31 */
25567 0082503ff2ff patch 8.2.3320: some local functions are not static Bram Moolenaar <Bram@vim.org> parents: 25465 diff changeset	32 static type_T *
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	33 get_type_ptr(garray_T *type_gap)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	34 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	35 type_T *type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	36
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	37 if (ga_grow(type_gap, 1) == FAIL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	38 return NULL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	39 type = ALLOC_CLEAR_ONE(type_T);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	40 if (type != NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	41 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	42 ((type_T **)type_gap->ga_data)[type_gap->ga_len] = type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	43 ++type_gap->ga_len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	44 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	45 return type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	46 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	47
30576 72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	48 /*
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	49 * Make a shallow copy of "type".
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	50 * When allocation fails returns "type".
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	51 */
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	52 type_T *
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	53 copy_type(type_T type, garray_T type_gap)
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	54 {
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	55 type_T *copy = get_type_ptr(type_gap);
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	56
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	57 if (copy == NULL)
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	58 return type;
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	59 copy = type;
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	60
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	61 if (type->tt_args != NULL)
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	62 {
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	63 copy->tt_args = ALLOC_MULT(type_T *, type->tt_argcount);
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	64 if (copy->tt_args != NULL)
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	65 for (int i = 0; i < type->tt_argcount; ++i)
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	66 copy->tt_args[i] = type->tt_args[i];
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	67 }
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	68
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	69 return copy;
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	70 }
72e6073a2822 patch 9.0.0623: error for modifying a const is not detected at compile time Bram Moolenaar <Bram@vim.org> parents: 30310 diff changeset	71
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	72 void
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	73 clear_type_list(garray_T *gap)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	74 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	75 while (gap->ga_len > 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	76 vim_free(((type_T **)gap->ga_data)[--gap->ga_len]);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	77 ga_clear(gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	78 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	79
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	80 /*
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	81 * Take a type that is using entries in a growarray and turn it into a type
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	82 * with allocated entries.
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	83 */
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	84 type_T *
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	85 alloc_type(type_T *type)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	86 {
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	87 type_T *ret;
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	88
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	89 if (type == NULL)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	90 return NULL;
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	91
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	92 // A fixed type never contains allocated types, return as-is.
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	93 if (type->tt_flags & TTFLAG_STATIC)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	94 return type;
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	95
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	96 ret = ALLOC_ONE(type_T);
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	97 ret = type;
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	98
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	99 if (ret->tt_member != NULL)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	100 ret->tt_member = alloc_type(ret->tt_member);
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	101 if (type->tt_args != NULL)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	102 {
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	103 int i;
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	104
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	105 ret->tt_args = ALLOC_MULT(type_T *, type->tt_argcount);
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	106 if (ret->tt_args != NULL)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	107 for (i = 0; i < type->tt_argcount; ++i)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	108 ret->tt_args[i] = alloc_type(type->tt_args[i]);
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	109 }
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	110
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	111 return ret;
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	112 }
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	113
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	114 /*
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	115 * Free a type that was created with alloc_type().
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	116 */
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	117 void
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	118 free_type(type_T *type)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	119 {
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	120 int i;
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	121
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	122 if (type == NULL \|\| (type->tt_flags & TTFLAG_STATIC))
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	123 return;
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	124 if (type->tt_args != NULL)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	125 {
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	126 for (i = 0; i < type->tt_argcount; ++i)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	127 free_type(type->tt_args[i]);
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	128 vim_free(type->tt_args);
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	129 }
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	130 free_type(type->tt_member);
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	131 vim_free(type);
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	132 }
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	133
27517 f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	134 /*
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	135 * Return TRUE if "type" is to be recursed into for setting the type.
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	136 */
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	137 static int
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	138 set_tv_type_recurse(type_T *type)
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	139 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	140 return type->tt_member != NULL
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	141 && (type->tt_member->tt_type == VAR_DICT
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	142 \|\| type->tt_member->tt_type == VAR_LIST)
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	143 && type->tt_member->tt_member != NULL
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	144 && type->tt_member->tt_member != &t_any
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	145 && type->tt_member->tt_member != &t_unknown;
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	146 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	147
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	148 /*
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	149 * Set the type of "tv" to "type" if it is a list or dict.
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	150 */
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	151 void
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	152 set_tv_type(typval_T tv, type_T type)
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	153 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	154 if (tv->v_type == VAR_DICT && tv->vval.v_dict != NULL)
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	155 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	156 dict_T *d = tv->vval.v_dict;
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	157
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	158 if (d->dv_type != type)
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	159 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	160 free_type(d->dv_type);
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	161 d->dv_type = alloc_type(type);
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	162 if (set_tv_type_recurse(type))
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	163 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	164 int todo = (int)d->dv_hashtab.ht_used;
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	165 hashitem_T *hi;
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	166 dictitem_T *di;
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	167
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	168 for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	169 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	170 if (!HASHITEM_EMPTY(hi))
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	171 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	172 --todo;
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	173 di = HI2DI(hi);
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	174 set_tv_type(&di->di_tv, type->tt_member);
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	175 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	176 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	177 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	178 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	179 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	180 else if (tv->v_type == VAR_LIST && tv->vval.v_list != NULL)
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	181 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	182 list_T *l = tv->vval.v_list;
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	183
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	184 if (l->lv_type != type)
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	185 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	186 free_type(l->lv_type);
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	187 l->lv_type = alloc_type(type);
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	188 if (l->lv_first != &range_list_item && set_tv_type_recurse(type))
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	189 {
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	190 listitem_T *li;
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	191
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	192 FOR_ALL_LIST_ITEMS(l, li)
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	193 set_tv_type(&li->li_tv, type->tt_member);
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	194 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	195 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	196 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	197 }
f00a7a2bee21 patch 8.2.4286: Vim9: strict type checking after copy() and deepcopy() Bram Moolenaar <Bram@vim.org> parents: 27503 diff changeset	198
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	199 type_T *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	200 get_list_type(type_T member_type, garray_T type_gap)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	201 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	202 type_T *type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	203
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	204 // recognize commonly used types
22804 af26fadf333d patch 8.2.1950: Vim9: crash when compiling function fails when getting type Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	205 if (member_type == NULL \|\| member_type->tt_type == VAR_ANY)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	206 return &t_list_any;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	207 if (member_type->tt_type == VAR_VOID
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	208 \|\| member_type->tt_type == VAR_UNKNOWN)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	209 return &t_list_empty;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	210 if (member_type->tt_type == VAR_BOOL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	211 return &t_list_bool;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	212 if (member_type->tt_type == VAR_NUMBER)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	213 return &t_list_number;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	214 if (member_type->tt_type == VAR_STRING)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	215 return &t_list_string;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	216
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	217 // Not a common type, create a new entry.
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	218 type = get_type_ptr(type_gap);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	219 if (type == NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	220 return &t_any;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	221 type->tt_type = VAR_LIST;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	222 type->tt_member = member_type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	223 type->tt_argcount = 0;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	224 type->tt_args = NULL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	225 return type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	226 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	227
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	228 type_T *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	229 get_dict_type(type_T member_type, garray_T type_gap)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	230 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	231 type_T *type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	232
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	233 // recognize commonly used types
22804 af26fadf333d patch 8.2.1950: Vim9: crash when compiling function fails when getting type Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	234 if (member_type == NULL \|\| member_type->tt_type == VAR_ANY)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	235 return &t_dict_any;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	236 if (member_type->tt_type == VAR_VOID
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	237 \|\| member_type->tt_type == VAR_UNKNOWN)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	238 return &t_dict_empty;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	239 if (member_type->tt_type == VAR_BOOL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	240 return &t_dict_bool;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	241 if (member_type->tt_type == VAR_NUMBER)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	242 return &t_dict_number;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	243 if (member_type->tt_type == VAR_STRING)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	244 return &t_dict_string;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	245
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	246 // Not a common type, create a new entry.
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	247 type = get_type_ptr(type_gap);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	248 if (type == NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	249 return &t_any;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	250 type->tt_type = VAR_DICT;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	251 type->tt_member = member_type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	252 type->tt_argcount = 0;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	253 type->tt_args = NULL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	254 return type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	255 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	256
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	257 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	258 * Allocate a new type for a function.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	259 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	260 type_T *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	261 alloc_func_type(type_T ret_type, int argcount, garray_T type_gap)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	262 {
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	263 type_T *type = get_type_ptr(type_gap);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	264
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	265 if (type == NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	266 return &t_any;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	267 type->tt_type = VAR_FUNC;
24996 0136c6ee1961 patch 8.2.3035: Vim9: crash when calling :def function with partial Bram Moolenaar <Bram@vim.org> parents: 24895 diff changeset	268 type->tt_member = ret_type == NULL ? &t_unknown : ret_type;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	269 type->tt_argcount = argcount;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	270 type->tt_args = NULL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	271 return type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	272 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	273
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	274 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	275 * Get a function type, based on the return type "ret_type".
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	276 * "argcount" must be -1 or 0, a predefined type can be used.
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	277 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	278 type_T *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	279 get_func_type(type_T ret_type, int argcount, garray_T type_gap)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	280 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	281 // recognize commonly used types
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	282 if (ret_type == &t_unknown \|\| ret_type == NULL)
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	283 {
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	284 // (argcount == 0) is not possible
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	285 return &t_func_unknown;
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	286 }
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	287 if (ret_type == &t_void)
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	288 {
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	289 if (argcount == 0)
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	290 return &t_func_0_void;
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	291 else
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	292 return &t_func_void;
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	293 }
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	294 if (ret_type == &t_any)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	295 {
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	296 if (argcount == 0)
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	297 return &t_func_0_any;
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	298 else
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	299 return &t_func_any;
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	300 }
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	301 if (ret_type == &t_number)
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	302 {
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	303 if (argcount == 0)
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	304 return &t_func_0_number;
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	305 else
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	306 return &t_func_number;
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	307 }
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	308 if (ret_type == &t_string)
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	309 {
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	310 if (argcount == 0)
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	311 return &t_func_0_string;
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	312 else
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	313 return &t_func_string;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	314 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	315
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	316 return alloc_func_type(ret_type, argcount, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	317 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	318
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	319 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	320 * For a function type, reserve space for "argcount" argument types (including
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	321 * vararg).
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	322 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	323 int
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	324 func_type_add_arg_types(
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	325 type_T *functype,
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	326 int argcount,
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	327 garray_T *type_gap)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	328 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	329 // To make it easy to free the space needed for the argument types, add the
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	330 // pointer to type_gap.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	331 if (ga_grow(type_gap, 1) == FAIL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	332 return FAIL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	333 functype->tt_args = ALLOC_CLEAR_MULT(type_T *, argcount);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	334 if (functype->tt_args == NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	335 return FAIL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	336 ((type_T **)type_gap->ga_data)[type_gap->ga_len] =
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	337 (void *)functype->tt_args;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	338 ++type_gap->ga_len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	339 return OK;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	340 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	341
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	342 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	343 * Get a type_T for a typval_T.
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	344 * "type_gap" is used to temporarily create types in.
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	345 * When "flags" has TVTT_DO_MEMBER also get the member type, otherwise use
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	346 * "any".
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	347 * When "flags" has TVTT_MORE_SPECIFIC get the more specific member type if it
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	348 * is "any".
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	349 */
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	350 static type_T *
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	351 typval2type_int(typval_T tv, int copyID, garray_T type_gap, int flags)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	352 {
22190 da851f3b6a0b patch 8.2.1644: Vim9: cannot assign 1 and 0 to bool at script level Bram Moolenaar <Bram@vim.org> parents: 22184 diff changeset	353 type_T *type;
25788 b2c00659152a patch 8.2.3429: leaking memory when assigning to list or dict Bram Moolenaar <Bram@vim.org> parents: 25692 diff changeset	354 type_T *member_type = NULL;
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	355 int argcount = 0;
25126 b825efff9790 patch 8.2.3100: Vim9: no error when using type with unknown number of args Bram Moolenaar <Bram@vim.org> parents: 24996 diff changeset	356 int min_argcount = 0;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	357
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	358 if (tv->v_type == VAR_NUMBER)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	359 return &t_number;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	360 if (tv->v_type == VAR_BOOL)
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	361 return &t_bool;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	362 if (tv->v_type == VAR_STRING)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	363 return &t_string;
25788 b2c00659152a patch 8.2.3429: leaking memory when assigning to list or dict Bram Moolenaar <Bram@vim.org> parents: 25692 diff changeset	364 if (tv->v_type == VAR_BLOB)
28231 66b245d84f37 patch 8.2.4642: Vim9: in :def function script var cannot be null Bram Moolenaar <Bram@vim.org> parents: 28059 diff changeset	365 {
66b245d84f37 patch 8.2.4642: Vim9: in :def function script var cannot be null Bram Moolenaar <Bram@vim.org> parents: 28059 diff changeset	366 if (tv->vval.v_blob == NULL)
66b245d84f37 patch 8.2.4642: Vim9: in :def function script var cannot be null Bram Moolenaar <Bram@vim.org> parents: 28059 diff changeset	367 return &t_blob_null;
25788 b2c00659152a patch 8.2.3429: leaking memory when assigning to list or dict Bram Moolenaar <Bram@vim.org> parents: 25692 diff changeset	368 return &t_blob;
28231 66b245d84f37 patch 8.2.4642: Vim9: in :def function script var cannot be null Bram Moolenaar <Bram@vim.org> parents: 28059 diff changeset	369 }
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	370
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	371 if (tv->v_type == VAR_LIST)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	372 {
22419 6a9e5c087c86 patch 8.2.1758: Vim9: type of unmaterialized list is wrong Bram Moolenaar <Bram@vim.org> parents: 22347 diff changeset	373 list_T *l = tv->vval.v_list;
6a9e5c087c86 patch 8.2.1758: Vim9: type of unmaterialized list is wrong Bram Moolenaar <Bram@vim.org> parents: 22347 diff changeset	374 listitem_T *li;
21803 e591b448a670 patch 8.2.1451: Vim9: list type at script level only uses first item Bram Moolenaar <Bram@vim.org> parents: 21789 diff changeset	375
27519 7898c7847293 patch 8.2.4287: cannot assign empty list with type to variable with list type Bram Moolenaar <Bram@vim.org> parents: 27517 diff changeset	376 // An empty list has type list<unknown>, unless the type was specified
7898c7847293 patch 8.2.4287: cannot assign empty list with type to variable with list type Bram Moolenaar <Bram@vim.org> parents: 27517 diff changeset	377 // and is not list<any>. This matters when assigning to a variable
7898c7847293 patch 8.2.4287: cannot assign empty list with type to variable with list type Bram Moolenaar <Bram@vim.org> parents: 27517 diff changeset	378 // with a specific list type.
7898c7847293 patch 8.2.4287: cannot assign empty list with type to variable with list type Bram Moolenaar <Bram@vim.org> parents: 27517 diff changeset	379 if (l == NULL \|\| (l->lv_first == NULL
7898c7847293 patch 8.2.4287: cannot assign empty list with type to variable with list type Bram Moolenaar <Bram@vim.org> parents: 27517 diff changeset	380 && (l->lv_type == NULL \|\| l->lv_type->tt_member == &t_any)))
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	381 return &t_list_empty;
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	382 if ((flags & TVTT_DO_MEMBER) == 0)
24438 5c6ccab68d1e patch 8.2.2759: Vim9: for loop infers type of loop variable Bram Moolenaar <Bram@vim.org> parents: 24160 diff changeset	383 return &t_list_any;
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	384 // If the type is list<any> go through the members, it may end up a
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	385 // more specific type.
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	386 if (l->lv_type != NULL && (l->lv_first == NULL
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	387 \|\| (flags & TVTT_MORE_SPECIFIC) == 0
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	388 \|\| l->lv_type->tt_member != &t_any))
25571 951f3e04e238 patch 8.2.3322: Vim9: checking type of dict does not check member type Bram Moolenaar <Bram@vim.org> parents: 25567 diff changeset	389 return l->lv_type;
22419 6a9e5c087c86 patch 8.2.1758: Vim9: type of unmaterialized list is wrong Bram Moolenaar <Bram@vim.org> parents: 22347 diff changeset	390 if (l->lv_first == &range_list_item)
6a9e5c087c86 patch 8.2.1758: Vim9: type of unmaterialized list is wrong Bram Moolenaar <Bram@vim.org> parents: 22347 diff changeset	391 return &t_list_number;
24160 e695db9a5465 patch 8.2.2621: typval2type() cannot handle recursive structures Bram Moolenaar <Bram@vim.org> parents: 24118 diff changeset	392 if (l->lv_copyID == copyID)
e695db9a5465 patch 8.2.2621: typval2type() cannot handle recursive structures Bram Moolenaar <Bram@vim.org> parents: 24118 diff changeset	393 // avoid recursion
e695db9a5465 patch 8.2.2621: typval2type() cannot handle recursive structures Bram Moolenaar <Bram@vim.org> parents: 24118 diff changeset	394 return &t_list_any;
e695db9a5465 patch 8.2.2621: typval2type() cannot handle recursive structures Bram Moolenaar <Bram@vim.org> parents: 24118 diff changeset	395 l->lv_copyID = copyID;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	396
21803 e591b448a670 patch 8.2.1451: Vim9: list type at script level only uses first item Bram Moolenaar <Bram@vim.org> parents: 21789 diff changeset	397 // Use the common type of all members.
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	398 member_type = typval2type(&l->lv_first->li_tv, copyID, type_gap,
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	399 TVTT_DO_MEMBER);
22419 6a9e5c087c86 patch 8.2.1758: Vim9: type of unmaterialized list is wrong Bram Moolenaar <Bram@vim.org> parents: 22347 diff changeset	400 for (li = l->lv_first->li_next; li != NULL; li = li->li_next)
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	401 common_type(typval2type(&li->li_tv, copyID, type_gap,
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	402 TVTT_DO_MEMBER),
21803 e591b448a670 patch 8.2.1451: Vim9: list type at script level only uses first item Bram Moolenaar <Bram@vim.org> parents: 21789 diff changeset	403 member_type, &member_type, type_gap);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	404 return get_list_type(member_type, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	405 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	406
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	407 if (tv->v_type == VAR_DICT)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	408 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	409 dict_iterator_T iter;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	410 typval_T *value;
24160 e695db9a5465 patch 8.2.2621: typval2type() cannot handle recursive structures Bram Moolenaar <Bram@vim.org> parents: 24118 diff changeset	411 dict_T *d = tv->vval.v_dict;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	412
25571 951f3e04e238 patch 8.2.3322: Vim9: checking type of dict does not check member type Bram Moolenaar <Bram@vim.org> parents: 25567 diff changeset	413 if (d == NULL \|\| (d->dv_hashtab.ht_used == 0 && d->dv_type == NULL))
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	414 return &t_dict_empty;
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	415 if ((flags & TVTT_DO_MEMBER) == 0)
24438 5c6ccab68d1e patch 8.2.2759: Vim9: for loop infers type of loop variable Bram Moolenaar <Bram@vim.org> parents: 24160 diff changeset	416 return &t_dict_any;
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	417 // If the type is dict<any> go through the members, it may end up a
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	418 // more specific type.
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	419 if (d->dv_type != NULL && (d->dv_hashtab.ht_used == 0
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	420 \|\| (flags & TVTT_MORE_SPECIFIC) == 0
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	421 \|\| d->dv_type->tt_member != &t_any))
25571 951f3e04e238 patch 8.2.3322: Vim9: checking type of dict does not check member type Bram Moolenaar <Bram@vim.org> parents: 25567 diff changeset	422 return d->dv_type;
24160 e695db9a5465 patch 8.2.2621: typval2type() cannot handle recursive structures Bram Moolenaar <Bram@vim.org> parents: 24118 diff changeset	423 if (d->dv_copyID == copyID)
e695db9a5465 patch 8.2.2621: typval2type() cannot handle recursive structures Bram Moolenaar <Bram@vim.org> parents: 24118 diff changeset	424 // avoid recursion
e695db9a5465 patch 8.2.2621: typval2type() cannot handle recursive structures Bram Moolenaar <Bram@vim.org> parents: 24118 diff changeset	425 return &t_dict_any;
e695db9a5465 patch 8.2.2621: typval2type() cannot handle recursive structures Bram Moolenaar <Bram@vim.org> parents: 24118 diff changeset	426 d->dv_copyID = copyID;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	427
21803 e591b448a670 patch 8.2.1451: Vim9: list type at script level only uses first item Bram Moolenaar <Bram@vim.org> parents: 21789 diff changeset	428 // Use the common type of all values.
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	429 dict_iterate_start(tv, &iter);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	430 dict_iterate_next(&iter, &value);
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	431 member_type = typval2type(value, copyID, type_gap, TVTT_DO_MEMBER);
21803 e591b448a670 patch 8.2.1451: Vim9: list type at script level only uses first item Bram Moolenaar <Bram@vim.org> parents: 21789 diff changeset	432 while (dict_iterate_next(&iter, &value) != NULL)
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	433 common_type(typval2type(value, copyID, type_gap, TVTT_DO_MEMBER),
21803 e591b448a670 patch 8.2.1451: Vim9: list type at script level only uses first item Bram Moolenaar <Bram@vim.org> parents: 21789 diff changeset	434 member_type, &member_type, type_gap);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	435 return get_dict_type(member_type, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	436 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	437
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	438 if (tv->v_type == VAR_FUNC \|\| tv->v_type == VAR_PARTIAL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	439 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	440 char_u *name = NULL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	441 ufunc_T *ufunc = NULL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	442
25692 17830c066d4b patch 8.2.3382: crash when getting the type of a NULL partial Bram Moolenaar <Bram@vim.org> parents: 25646 diff changeset	443 if (tv->v_type == VAR_PARTIAL && tv->vval.v_partial != NULL)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	444 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	445 if (tv->vval.v_partial->pt_func != NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	446 ufunc = tv->vval.v_partial->pt_func;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	447 else
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	448 name = tv->vval.v_partial->pt_name;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	449 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	450 else
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	451 name = tv->vval.v_string;
28008 cc7d54a134e4 patch 8.2.4529: Vim9: comparing partial with function fails Bram Moolenaar <Bram@vim.org> parents: 28002 diff changeset	452 if (name == NULL && ufunc == NULL)
cc7d54a134e4 patch 8.2.4529: Vim9: comparing partial with function fails Bram Moolenaar <Bram@vim.org> parents: 28002 diff changeset	453 return &t_func_unknown;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	454 if (name != NULL)
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	455 {
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	456 int idx = find_internal_func(name);
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	457
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	458 if (idx >= 0)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	459 {
27503 4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	460 type_T *decl_type; // unused
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	461
25126 b825efff9790 patch 8.2.3100: Vim9: no error when using type with unknown number of args Bram Moolenaar <Bram@vim.org> parents: 24996 diff changeset	462 internal_func_get_argcount(idx, &argcount, &min_argcount);
27503 4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	463 member_type = internal_func_ret_type(idx, 0, NULL, &decl_type);
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	464 }
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	465 else
27114 98a01021e465 patch 8.2.4086: "cctx" argument of find_func_even_dead() is unused Bram Moolenaar <Bram@vim.org> parents: 27018 diff changeset	466 ufunc = find_func(name, FALSE);
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	467 }
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	468 if (ufunc != NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	469 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	470 // May need to get the argument types from default values by
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	471 // compiling the function.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	472 if (ufunc->uf_def_status == UF_TO_BE_COMPILED
24895 e61a2085c89b patch 8.2.2985: Vim9: a compiled function cannot be debugged Bram Moolenaar <Bram@vim.org> parents: 24606 diff changeset	473 && compile_def_function(ufunc, TRUE, CT_NONE, NULL)
23717 e3720756acdc patch 8.2.2400: Vim9: compiled functions are not profiled Bram Moolenaar <Bram@vim.org> parents: 23640 diff changeset	474 == FAIL)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	475 return NULL;
23338 9c5275b1c763 patch 8.2.2212: Vim9: lambda with => does not work at the script level Bram Moolenaar <Bram@vim.org> parents: 23334 diff changeset	476 if (ufunc->uf_func_type == NULL)
9c5275b1c763 patch 8.2.2212: Vim9: lambda with => does not work at the script level Bram Moolenaar <Bram@vim.org> parents: 23334 diff changeset	477 set_function_type(ufunc);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	478 if (ufunc->uf_func_type != NULL)
25137 34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	479 {
27010 b049c3b63a67 patch 8.2.4034: Coverity warns for possibly using a NULL pointer Bram Moolenaar <Bram@vim.org> parents: 26939 diff changeset	480 if (tv->v_type == VAR_PARTIAL && tv->vval.v_partial != NULL
25137 34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	481 && tv->vval.v_partial->pt_argc > 0)
34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	482 {
34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	483 type = get_type_ptr(type_gap);
34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	484 if (type == NULL)
34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	485 return NULL;
34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	486 type = ufunc->uf_func_type;
26839 eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	487 if (type->tt_argcount >= 0)
26833 434eaef2ac62 patch 8.2.3945: Vim9: partial variable argument types are wrong Bram Moolenaar <Bram@vim.org> parents: 26680 diff changeset	488 {
26839 eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	489 type->tt_argcount -= tv->vval.v_partial->pt_argc;
eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	490 type->tt_min_argcount -= tv->vval.v_partial->pt_argc;
27807 292a6bd86c30 patch 8.2.4429: using script-local function from the wrong script Bram Moolenaar <Bram@vim.org> parents: 27567 diff changeset	491 if (type->tt_argcount <= 0)
26839 eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	492 type->tt_args = NULL;
eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	493 else
eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	494 {
eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	495 int i;
26833 434eaef2ac62 patch 8.2.3945: Vim9: partial variable argument types are wrong Bram Moolenaar <Bram@vim.org> parents: 26680 diff changeset	496
26839 eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	497 func_type_add_arg_types(type, type->tt_argcount,
26833 434eaef2ac62 patch 8.2.3945: Vim9: partial variable argument types are wrong Bram Moolenaar <Bram@vim.org> parents: 26680 diff changeset	498 type_gap);
26839 eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	499 for (i = 0; i < type->tt_argcount; ++i)
eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	500 type->tt_args[i] = ufunc->uf_func_type->tt_args[
26833 434eaef2ac62 patch 8.2.3945: Vim9: partial variable argument types are wrong Bram Moolenaar <Bram@vim.org> parents: 26680 diff changeset	501 i + tv->vval.v_partial->pt_argc];
26839 eb6d56ab4858 patch 8.2.3948: Vim9: failure with partial with unknown argument count Bram Moolenaar <Bram@vim.org> parents: 26833 diff changeset	502 }
26833 434eaef2ac62 patch 8.2.3945: Vim9: partial variable argument types are wrong Bram Moolenaar <Bram@vim.org> parents: 26680 diff changeset	503 }
25137 34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	504 return type;
34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	505 }
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	506 return ufunc->uf_func_type;
25137 34f18d4081af patch 8.2.3105: Vim9: type of partial is wrong when it has arguments Bram Moolenaar <Bram@vim.org> parents: 25135 diff changeset	507 }
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	508 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	509 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	510
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	511 type = get_type_ptr(type_gap);
22190 da851f3b6a0b patch 8.2.1644: Vim9: cannot assign 1 and 0 to bool at script level Bram Moolenaar <Bram@vim.org> parents: 22184 diff changeset	512 if (type == NULL)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	513 return NULL;
22190 da851f3b6a0b patch 8.2.1644: Vim9: cannot assign 1 and 0 to bool at script level Bram Moolenaar <Bram@vim.org> parents: 22184 diff changeset	514 type->tt_type = tv->v_type;
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	515 type->tt_argcount = argcount;
25126 b825efff9790 patch 8.2.3100: Vim9: no error when using type with unknown number of args Bram Moolenaar <Bram@vim.org> parents: 24996 diff changeset	516 type->tt_min_argcount = min_argcount;
25692 17830c066d4b patch 8.2.3382: crash when getting the type of a NULL partial Bram Moolenaar <Bram@vim.org> parents: 25646 diff changeset	517 if (tv->v_type == VAR_PARTIAL && tv->vval.v_partial != NULL
17830c066d4b patch 8.2.3382: crash when getting the type of a NULL partial Bram Moolenaar <Bram@vim.org> parents: 25646 diff changeset	518 && tv->vval.v_partial->pt_argc > 0)
25465 b8a6a0007dc3 patch 8.2.3269: Vim9: wrong argument check for partial Bram Moolenaar <Bram@vim.org> parents: 25425 diff changeset	519 {
b8a6a0007dc3 patch 8.2.3269: Vim9: wrong argument check for partial Bram Moolenaar <Bram@vim.org> parents: 25425 diff changeset	520 type->tt_argcount -= tv->vval.v_partial->pt_argc;
b8a6a0007dc3 patch 8.2.3269: Vim9: wrong argument check for partial Bram Moolenaar <Bram@vim.org> parents: 25425 diff changeset	521 type->tt_min_argcount -= tv->vval.v_partial->pt_argc;
b8a6a0007dc3 patch 8.2.3269: Vim9: wrong argument check for partial Bram Moolenaar <Bram@vim.org> parents: 25425 diff changeset	522 }
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	523 type->tt_member = member_type;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	524
22190 da851f3b6a0b patch 8.2.1644: Vim9: cannot assign 1 and 0 to bool at script level Bram Moolenaar <Bram@vim.org> parents: 22184 diff changeset	525 return type;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	526 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	527
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	528 /*
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	529 * Return TRUE if "tv" is not a bool but should be converted to bool.
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	530 */
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	531 int
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	532 need_convert_to_bool(type_T type, typval_T tv)
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	533 {
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	534 return type != NULL && type == &t_bool && tv->v_type != VAR_BOOL
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22492 diff changeset	535 && (tv->v_type == VAR_NUMBER
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22492 diff changeset	536 && (tv->vval.v_number == 0 \|\| tv->vval.v_number == 1));
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	537 }
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	538
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	539 /*
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22492 diff changeset	540 * Get a type_T for a typval_T.
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	541 * "type_list" is used to temporarily create types in.
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	542 * When "flags" has TVTT_DO_MEMBER also get the member type, otherwise use
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	543 * "any".
4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	544 * When "flags" has TVTT_MORE_SPECIFIC get the most specific member type.
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	545 */
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	546 type_T *
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	547 typval2type(typval_T tv, int copyID, garray_T type_gap, int flags)
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	548 {
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	549 type_T *type = typval2type_int(tv, copyID, type_gap, flags);
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	550
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	551 if (type != NULL && type != &t_bool
22494 4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22492 diff changeset	552 && (tv->v_type == VAR_NUMBER
4c21f7f6f9e3 patch 8.2.1795: Vim9: operators && and \|\| have a confusing result Bram Moolenaar <Bram@vim.org> parents: 22492 diff changeset	553 && (tv->vval.v_number == 0 \|\| tv->vval.v_number == 1)))
23334 4b4f695e9cd1 patch 8.2.2210: Vim9: allocating a type to set TTFLAG_BOOL_OK Bram Moolenaar <Bram@vim.org> parents: 23332 diff changeset	554 // Number 0 and 1 and expression with "&&" or "\|\|" can also be used for
4b4f695e9cd1 patch 8.2.2210: Vim9: allocating a type to set TTFLAG_BOOL_OK Bram Moolenaar <Bram@vim.org> parents: 23332 diff changeset	555 // bool.
4b4f695e9cd1 patch 8.2.2210: Vim9: allocating a type to set TTFLAG_BOOL_OK Bram Moolenaar <Bram@vim.org> parents: 23332 diff changeset	556 type = &t_number_bool;
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	557 return type;
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	558 }
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	559
7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	560 /*
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	561 * Get a type_T for a typval_T, used for v: variables.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	562 * "type_list" is used to temporarily create types in.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	563 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	564 type_T *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	565 typval2type_vimvar(typval_T tv, garray_T type_gap)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	566 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	567 if (tv->v_type == VAR_LIST) // e.g. for v:oldfiles
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	568 return &t_list_string;
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	569 if (tv->v_type == VAR_DICT) // e.g. for v:event
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	570 return &t_dict_any;
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	571 return typval2type(tv, get_copyID(), type_gap, TVTT_DO_MEMBER);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	572 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	573
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	574 int
25326 cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	575 check_typval_arg_type(
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	576 type_T *expected,
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	577 typval_T *actual_tv,
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	578 char *func_name,
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	579 int arg_idx)
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	580 {
25326 cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	581 where_T where = WHERE_INIT;
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	582
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	583 where.wt_index = arg_idx;
25326 cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	584 where.wt_func_name = func_name;
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	585 return check_typval_type(expected, actual_tv, where);
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	586 }
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	587
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	588 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	589 * Return FAIL if "expected" and "actual" don't match.
22804 af26fadf333d patch 8.2.1950: Vim9: crash when compiling function fails when getting type Bram Moolenaar <Bram@vim.org> parents: 22494 diff changeset	590 * When "argidx" > 0 it is included in the error message.
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	591 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	592 int
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	593 check_typval_type(type_T expected, typval_T actual_tv, where_T where)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	594 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	595 garray_T type_list;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	596 type_T *actual_type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	597 int res = FAIL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	598
26833 434eaef2ac62 patch 8.2.3945: Vim9: partial variable argument types are wrong Bram Moolenaar <Bram@vim.org> parents: 26680 diff changeset	599 if (expected == NULL)
434eaef2ac62 patch 8.2.3945: Vim9: partial variable argument types are wrong Bram Moolenaar <Bram@vim.org> parents: 26680 diff changeset	600 return OK; // didn't expect anything.
28002 1012048eed26 patch 8.2.4526: Vim9: cannot set variables to a null value Bram Moolenaar <Bram@vim.org> parents: 27807 diff changeset	601 //
1012048eed26 patch 8.2.4526: Vim9: cannot set variables to a null value Bram Moolenaar <Bram@vim.org> parents: 27807 diff changeset	602 ga_init2(&type_list, sizeof(type_T *), 10);
26833 434eaef2ac62 patch 8.2.3945: Vim9: partial variable argument types are wrong Bram Moolenaar <Bram@vim.org> parents: 26680 diff changeset	603
28002 1012048eed26 patch 8.2.4526: Vim9: cannot set variables to a null value Bram Moolenaar <Bram@vim.org> parents: 27807 diff changeset	604 // A null_function and null_partial are special cases, they can be used to
1012048eed26 patch 8.2.4526: Vim9: cannot set variables to a null value Bram Moolenaar <Bram@vim.org> parents: 27807 diff changeset	605 // clear a variable.
25646 99fbffe75217 patch 8.2.3359: Vim9: error for type when variable is not set Bram Moolenaar <Bram@vim.org> parents: 25571 diff changeset	606 if ((actual_tv->v_type == VAR_FUNC && actual_tv->vval.v_string == NULL)
99fbffe75217 patch 8.2.3359: Vim9: error for type when variable is not set Bram Moolenaar <Bram@vim.org> parents: 25571 diff changeset	607 \|\| (actual_tv->v_type == VAR_PARTIAL
99fbffe75217 patch 8.2.3359: Vim9: error for type when variable is not set Bram Moolenaar <Bram@vim.org> parents: 25571 diff changeset	608 && actual_tv->vval.v_partial == NULL))
28002 1012048eed26 patch 8.2.4526: Vim9: cannot set variables to a null value Bram Moolenaar <Bram@vim.org> parents: 27807 diff changeset	609 actual_type = &t_func_unknown;
1012048eed26 patch 8.2.4526: Vim9: cannot set variables to a null value Bram Moolenaar <Bram@vim.org> parents: 27807 diff changeset	610 else
1012048eed26 patch 8.2.4526: Vim9: cannot set variables to a null value Bram Moolenaar <Bram@vim.org> parents: 27807 diff changeset	611 // When the actual type is list<any> or dict<any> go through the values
1012048eed26 patch 8.2.4526: Vim9: cannot set variables to a null value Bram Moolenaar <Bram@vim.org> parents: 27807 diff changeset	612 // to possibly get a more specific type.
1012048eed26 patch 8.2.4526: Vim9: cannot set variables to a null value Bram Moolenaar <Bram@vim.org> parents: 27807 diff changeset	613 actual_type = typval2type(actual_tv, get_copyID(), &type_list,
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	614 TVTT_DO_MEMBER \| TVTT_MORE_SPECIFIC);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	615 if (actual_type != NULL)
26680 1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	616 {
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	617 res = check_type_maybe(expected, actual_type, TRUE, where);
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	618 if (res == MAYBE && !(actual_type->tt_type == VAR_FUNC
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	619 && actual_type->tt_member == &t_unknown))
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	620 {
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	621 // If a type check is needed that means assigning "any" or
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	622 // "unknown" to a more specific type, which fails here.
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	623 // Execpt when it looks like a lambda, since they have an
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	624 // incomplete type.
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	625 type_mismatch_where(expected, actual_type, where);
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	626 res = FAIL;
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	627 }
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	628 }
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	629 clear_type_list(&type_list);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	630 return res;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	631 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	632
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	633 void
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	634 arg_type_mismatch(type_T expected, type_T actual, int arg_idx)
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	635 {
25326 cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	636 where_T where = WHERE_INIT;
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	637
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	638 where.wt_index = arg_idx;
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	639 type_mismatch_where(expected, actual, where);
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	640 }
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	641
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	642 void
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	643 type_mismatch_where(type_T expected, type_T actual, where_T where)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	644 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	645 char tofree1, tofree2;
22004 a9e60176dcd3 patch 8.2.1551: Vim9: error for argument type does not mention the number Bram Moolenaar <Bram@vim.org> parents: 21909 diff changeset	646 char *typename1 = type_name(expected, &tofree1);
a9e60176dcd3 patch 8.2.1551: Vim9: error for argument type does not mention the number Bram Moolenaar <Bram@vim.org> parents: 21909 diff changeset	647 char *typename2 = type_name(actual, &tofree2);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	648
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	649 if (where.wt_index > 0)
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	650 {
25326 cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	651 if (where.wt_func_name == NULL)
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	652 semsg(_(where.wt_variable
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	653 ? e_variable_nr_type_mismatch_expected_str_but_got_str
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	654 : e_argument_nr_type_mismatch_expected_str_but_got_str),
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	655 where.wt_index, typename1, typename2);
25326 cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	656 else
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	657 semsg(_(where.wt_variable
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	658 ? e_variable_nr_type_mismatch_expected_str_but_got_str_in_str
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	659 : e_argument_nr_type_mismatch_expected_str_but_got_str_in_str),
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	660 where.wt_index, typename1, typename2, where.wt_func_name);
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	661 }
25326 cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	662 else if (where.wt_func_name == NULL)
22004 a9e60176dcd3 patch 8.2.1551: Vim9: error for argument type does not mention the number Bram Moolenaar <Bram@vim.org> parents: 21909 diff changeset	663 semsg(_(e_type_mismatch_expected_str_but_got_str),
a9e60176dcd3 patch 8.2.1551: Vim9: error for argument type does not mention the number Bram Moolenaar <Bram@vim.org> parents: 21909 diff changeset	664 typename1, typename2);
25326 cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	665 else
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	666 semsg(_(e_type_mismatch_expected_str_but_got_str_in_str),
cfbf40f749b0 patch 8.2.3200: Vim9: hard to guess where a type error is given Bram Moolenaar <Bram@vim.org> parents: 25196 diff changeset	667 typename1, typename2, where.wt_func_name);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	668 vim_free(tofree1);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	669 vim_free(tofree2);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	670 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	671
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	672 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	673 * Check if the expected and actual types match.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	674 * Does not allow for assigning "any" to a specific type.
22004 a9e60176dcd3 patch 8.2.1551: Vim9: error for argument type does not mention the number Bram Moolenaar <Bram@vim.org> parents: 21909 diff changeset	675 * When "argidx" > 0 it is included in the error message.
26630 57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	676 * Return OK if types match.
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	677 * Return FAIL if types do not match.
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	678 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	679 int
26630 57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	680 check_type(
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	681 type_T *expected,
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	682 type_T *actual,
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	683 int give_msg,
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	684 where_T where)
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	685 {
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	686 int ret = check_type_maybe(expected, actual, give_msg, where);
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	687
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	688 return ret == MAYBE ? OK : ret;
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	689 }
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	690
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	691 /*
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	692 * As check_type() but return MAYBE when a runtime type check should be used
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	693 * when compiling.
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	694 */
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	695 int
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	696 check_type_maybe(
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	697 type_T *expected,
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	698 type_T *actual,
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	699 int give_msg,
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	700 where_T where)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	701 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	702 int ret = OK;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	703
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	704 // When expected is "unknown" we accept any actual type.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	705 // When expected is "any" we accept any actual type except "void".
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	706 if (expected->tt_type != VAR_UNKNOWN
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	707 && !(expected->tt_type == VAR_ANY && actual->tt_type != VAR_VOID))
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	708
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	709 {
22347 712bc35842aa patch 8.2.1722: Vim9: cannot assign a lambda to a variable of type function Bram Moolenaar <Bram@vim.org> parents: 22322 diff changeset	710 // tt_type should match, except that a "partial" can be assigned to a
712bc35842aa patch 8.2.1722: Vim9: cannot assign a lambda to a variable of type function Bram Moolenaar <Bram@vim.org> parents: 22322 diff changeset	711 // variable with type "func".
26680 1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	712 // And "unknown" (using global variable) and "any" need a runtime type
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	713 // check.
22347 712bc35842aa patch 8.2.1722: Vim9: cannot assign a lambda to a variable of type function Bram Moolenaar <Bram@vim.org> parents: 22322 diff changeset	714 if (!(expected->tt_type == actual->tt_type
26678 e16806237a70 patch 8.2.3868: Vim9: function test fails Bram Moolenaar <Bram@vim.org> parents: 26630 diff changeset	715 \|\| actual->tt_type == VAR_UNKNOWN
26680 1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	716 \|\| actual->tt_type == VAR_ANY
22347 712bc35842aa patch 8.2.1722: Vim9: cannot assign a lambda to a variable of type function Bram Moolenaar <Bram@vim.org> parents: 22322 diff changeset	717 \|\| (expected->tt_type == VAR_FUNC
712bc35842aa patch 8.2.1722: Vim9: cannot assign a lambda to a variable of type function Bram Moolenaar <Bram@vim.org> parents: 22322 diff changeset	718 && actual->tt_type == VAR_PARTIAL)))
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	719 {
22202 7899b4e2880c patch 8.2.1650: Vim9: result of && and \|\| expression is not bool in script Bram Moolenaar <Bram@vim.org> parents: 22190 diff changeset	720 if (expected->tt_type == VAR_BOOL
22184 2463b3d89ce2 patch 8.2.1641: Vim9: cannot use 0 or 1 where a bool is expected Bram Moolenaar <Bram@vim.org> parents: 22004 diff changeset	721 && (actual->tt_flags & TTFLAG_BOOL_OK))
2463b3d89ce2 patch 8.2.1641: Vim9: cannot use 0 or 1 where a bool is expected Bram Moolenaar <Bram@vim.org> parents: 22004 diff changeset	722 // Using number 0 or 1 for bool is OK.
2463b3d89ce2 patch 8.2.1641: Vim9: cannot use 0 or 1 where a bool is expected Bram Moolenaar <Bram@vim.org> parents: 22004 diff changeset	723 return OK;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	724 if (give_msg)
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	725 type_mismatch_where(expected, actual, where);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	726 return FAIL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	727 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	728 if (expected->tt_type == VAR_DICT \|\| expected->tt_type == VAR_LIST)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	729 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	730 // "unknown" is used for an empty list or dict
26678 e16806237a70 patch 8.2.3868: Vim9: function test fails Bram Moolenaar <Bram@vim.org> parents: 26630 diff changeset	731 if (actual->tt_member != NULL && actual->tt_member != &t_unknown)
26680 1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	732 ret = check_type_maybe(expected->tt_member, actual->tt_member,
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	733 FALSE, where);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	734 }
26680 1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	735 else if (expected->tt_type == VAR_FUNC && actual != &t_any)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	736 {
23418 681f042ae5ac patch 8.2.2252: Vim9: crash when using lambda without return type in dict Bram Moolenaar <Bram@vim.org> parents: 23362 diff changeset	737 // If the return type is unknown it can be anything, including
681f042ae5ac patch 8.2.2252: Vim9: crash when using lambda without return type in dict Bram Moolenaar <Bram@vim.org> parents: 23362 diff changeset	738 // nothing, thus there is no point in checking.
26630 57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	739 if (expected->tt_member != &t_unknown)
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	740 {
26678 e16806237a70 patch 8.2.3868: Vim9: function test fails Bram Moolenaar <Bram@vim.org> parents: 26630 diff changeset	741 if (actual->tt_member != NULL
e16806237a70 patch 8.2.3868: Vim9: function test fails Bram Moolenaar <Bram@vim.org> parents: 26630 diff changeset	742 && actual->tt_member != &t_unknown)
26680 1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	743 ret = check_type_maybe(expected->tt_member,
1b288eb2fcdc patch 8.2.3869: Vim9: type checking for "any" is inconsistent Bram Moolenaar <Bram@vim.org> parents: 26678 diff changeset	744 actual->tt_member, FALSE, where);
26630 57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	745 else
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	746 ret = MAYBE;
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	747 }
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	748 if (ret != FAIL && expected->tt_argcount != -1
25135 5731bcaaabcb patch 8.2.3104: Vim9: unspecified function type causes type error Bram Moolenaar <Bram@vim.org> parents: 25126 diff changeset	749 && actual->tt_min_argcount != -1
25126 b825efff9790 patch 8.2.3100: Vim9: no error when using type with unknown number of args Bram Moolenaar <Bram@vim.org> parents: 24996 diff changeset	750 && (actual->tt_argcount == -1
b825efff9790 patch 8.2.3100: Vim9: no error when using type with unknown number of args Bram Moolenaar <Bram@vim.org> parents: 24996 diff changeset	751 \|\| (actual->tt_argcount < expected->tt_min_argcount
b825efff9790 patch 8.2.3100: Vim9: no error when using type with unknown number of args Bram Moolenaar <Bram@vim.org> parents: 24996 diff changeset	752 \|\| actual->tt_argcount > expected->tt_argcount)))
23481 62fe9a7fd582 patch 8.2.2283: Vim9: crash when lambda has fewer arguments than expected Bram Moolenaar <Bram@vim.org> parents: 23418 diff changeset	753 ret = FAIL;
26630 57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	754 if (ret != FAIL && expected->tt_args != NULL
23481 62fe9a7fd582 patch 8.2.2283: Vim9: crash when lambda has fewer arguments than expected Bram Moolenaar <Bram@vim.org> parents: 23418 diff changeset	755 && actual->tt_args != NULL)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	756 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	757 int i;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	758
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	759 for (i = 0; i < expected->tt_argcount; ++i)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	760 // Allow for using "any" argument type, lambda's have them.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	761 if (actual->tt_args[i] != &t_any && check_type(
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	762 expected->tt_args[i], actual->tt_args[i], FALSE,
4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	763 where) == FAIL)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	764 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	765 ret = FAIL;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	766 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	767 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	768 }
26630 57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	769 if (ret == OK && expected->tt_argcount >= 0
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	770 && actual->tt_argcount == -1)
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	771 // check the argument count at runtime
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	772 ret = MAYBE;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	773 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	774 if (ret == FAIL && give_msg)
23917 4b417b776b95 patch 8.2.2501: not always clear where an error is reported Bram Moolenaar <Bram@vim.org> parents: 23888 diff changeset	775 type_mismatch_where(expected, actual, where);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	776 }
26630 57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	777
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	778 if (ret == OK && expected->tt_type != VAR_UNKNOWN
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	779 && expected->tt_type != VAR_ANY
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	780 && (actual->tt_type == VAR_UNKNOWN \|\| actual->tt_type == VAR_ANY))
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	781 // check the type at runtime
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	782 ret = MAYBE;
57bc1001160b patch 8.2.3844: Vim9: no type error if assigning func(number) to func(string) Bram Moolenaar <Bram@vim.org> parents: 26602 diff changeset	783
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	784 return ret;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	785 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	786
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	787 /*
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	788 * Check that the arguments of "type" match "argvars[argcount]".
27171 374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	789 * "base_tv" is from "expr->Func()".
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	790 * Return OK/FAIL.
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	791 */
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	792 int
23640 8dcb2255ff9a patch 8.2.2362: Vim9: check of builtin function argument type is incomplete Bram Moolenaar <Bram@vim.org> parents: 23594 diff changeset	793 check_argument_types(
8dcb2255ff9a patch 8.2.2362: Vim9: check of builtin function argument type is incomplete Bram Moolenaar <Bram@vim.org> parents: 23594 diff changeset	794 type_T *type,
8dcb2255ff9a patch 8.2.2362: Vim9: check of builtin function argument type is incomplete Bram Moolenaar <Bram@vim.org> parents: 23594 diff changeset	795 typval_T *argvars,
8dcb2255ff9a patch 8.2.2362: Vim9: check of builtin function argument type is incomplete Bram Moolenaar <Bram@vim.org> parents: 23594 diff changeset	796 int argcount,
27171 374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	797 typval_T *base_tv,
23640 8dcb2255ff9a patch 8.2.2362: Vim9: check of builtin function argument type is incomplete Bram Moolenaar <Bram@vim.org> parents: 23594 diff changeset	798 char_u *name)
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	799 {
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	800 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0;
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	801 int i;
27171 374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	802 int totcount = argcount + (base_tv == NULL ? 0 : 1);
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	803
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	804 if (type->tt_type != VAR_FUNC && type->tt_type != VAR_PARTIAL)
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	805 return OK; // just in case
27171 374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	806 if (totcount < type->tt_min_argcount - varargs)
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	807 {
28263 c446812efd60 patch 8.2.4657: errors for functions are sometimes hard to read Bram Moolenaar <Bram@vim.org> parents: 28231 diff changeset	808 emsg_funcname(e_not_enough_arguments_for_function_str, name);
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	809 return FAIL;
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	810 }
27171 374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	811 if (!varargs && type->tt_argcount >= 0 && totcount > type->tt_argcount)
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	812 {
28263 c446812efd60 patch 8.2.4657: errors for functions are sometimes hard to read Bram Moolenaar <Bram@vim.org> parents: 28231 diff changeset	813 emsg_funcname(e_too_many_arguments_for_function_str, name);
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	814 return FAIL;
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	815 }
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	816 if (type->tt_args == NULL)
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	817 return OK; // cannot check
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	818
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	819
27171 374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	820 for (i = 0; i < totcount; ++i)
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	821 {
27171 374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	822 type_T *expected;
374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	823 typval_T *tv;
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	824
27171 374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	825 if (base_tv != NULL)
374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	826 {
374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	827 if (i == 0)
374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	828 tv = base_tv;
374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	829 else
374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	830 tv = &argvars[i - 1];
374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	831 }
374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	832 else
374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	833 tv = &argvars[i];
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	834 if (varargs && i >= type->tt_argcount - 1)
28952 ba083decce5d patch 8.2.4998: Vim9: crash when using multiple funcref() Bram Moolenaar <Bram@vim.org> parents: 28263 diff changeset	835 {
ba083decce5d patch 8.2.4998: Vim9: crash when using multiple funcref() Bram Moolenaar <Bram@vim.org> parents: 28263 diff changeset	836 expected = type->tt_args[type->tt_argcount - 1];
ba083decce5d patch 8.2.4998: Vim9: crash when using multiple funcref() Bram Moolenaar <Bram@vim.org> parents: 28263 diff changeset	837 if (expected != NULL)
ba083decce5d patch 8.2.4998: Vim9: crash when using multiple funcref() Bram Moolenaar <Bram@vim.org> parents: 28263 diff changeset	838 expected = expected->tt_member;
ba083decce5d patch 8.2.4998: Vim9: crash when using multiple funcref() Bram Moolenaar <Bram@vim.org> parents: 28263 diff changeset	839 }
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	840 else
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	841 expected = type->tt_args[i];
27171 374c7d5a096a patch 8.2.4114: Vim9: type checking for a funcref does not work for method Bram Moolenaar <Bram@vim.org> parents: 27114 diff changeset	842 if (check_typval_arg_type(expected, tv, NULL, i + 1) == FAIL)
23527 27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	843 return FAIL;
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	844 }
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	845 return OK;
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	846 }
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	847
27ca5534a408 patch 8.2.2306: Vim9: when using function reference type is not checked Bram Moolenaar <Bram@vim.org> parents: 23481 diff changeset	848 /*
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	849 * Skip over a type definition and return a pointer to just after it.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	850 * When "optional" is TRUE then a leading "?" is accepted.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	851 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	852 char_u *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	853 skip_type(char_u *start, int optional)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	854 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	855 char_u *p = start;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	856
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	857 if (optional && *p == '?')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	858 ++p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	859 while (ASCII_ISALNUM(p) \|\| p == '_')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	860 ++p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	861
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	862 // Skip over "<type>"; this is permissive about white space.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	863 if (*skipwhite(p) == '<')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	864 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	865 p = skipwhite(p);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	866 p = skip_type(skipwhite(p + 1), FALSE);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	867 p = skipwhite(p);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	868 if (*p == '>')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	869 ++p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	870 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	871 else if ((p == '(' \|\| (p == ':' && VIM_ISWHITE(p[1])))
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	872 && STRNCMP("func", start, 4) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	873 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	874 if (*p == '(')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	875 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	876 // handle func(args): type
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	877 ++p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	878 while (p != ')' && p != NUL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	879 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	880 char_u *sp = p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	881
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	882 if (STRNCMP(p, "...", 3) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	883 p += 3;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	884 p = skip_type(p, TRUE);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	885 if (p == sp)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	886 return p; // syntax error
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	887 if (*p == ',')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	888 p = skipwhite(p + 1);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	889 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	890 if (*p == ')')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	891 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	892 if (p[1] == ':')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	893 p = skip_type(skipwhite(p + 2), FALSE);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	894 else
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	895 ++p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	896 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	897 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	898 else
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	899 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	900 // handle func: return_type
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	901 p = skip_type(skipwhite(p + 1), FALSE);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	902 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	903 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	904
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	905 return p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	906 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	907
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	908 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	909 * Parse the member type: "<type>" and return "type" with the member set.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	910 * Use "type_gap" if a new type needs to be added.
29780 9f8dd1b77563 patch 9.0.0229: Vim9: error message for missing type is not clear Bram Moolenaar <Bram@vim.org> parents: 29008 diff changeset	911 * "info" is extra information for an error message.
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	912 * Returns NULL in case of failure.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	913 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	914 static type_T *
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	915 parse_type_member(
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	916 char_u **arg,
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	917 type_T *type,
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	918 garray_T *type_gap,
29780 9f8dd1b77563 patch 9.0.0229: Vim9: error message for missing type is not clear Bram Moolenaar <Bram@vim.org> parents: 29008 diff changeset	919 int give_error,
9f8dd1b77563 patch 9.0.0229: Vim9: error message for missing type is not clear Bram Moolenaar <Bram@vim.org> parents: 29008 diff changeset	920 char *info)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	921 {
29780 9f8dd1b77563 patch 9.0.0229: Vim9: error message for missing type is not clear Bram Moolenaar <Bram@vim.org> parents: 29008 diff changeset	922 char_u arg_start = arg;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	923 type_T *member_type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	924 int prev_called_emsg = called_emsg;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	925
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	926 if (**arg != '<')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	927 {
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	928 if (give_error)
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	929 {
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	930 if (skipwhite(arg) == '<')
23888 d95403445b6b patch 8.2.2486: Vim9: some errors for white space do not show context Bram Moolenaar <Bram@vim.org> parents: 23877 diff changeset	931 semsg(_(e_no_white_space_allowed_before_str_str), "<", *arg);
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	932 else
29780 9f8dd1b77563 patch 9.0.0229: Vim9: error message for missing type is not clear Bram Moolenaar <Bram@vim.org> parents: 29008 diff changeset	933 semsg(_(e_missing_type_after_str), info);
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	934 }
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	935 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	936 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	937 arg = skipwhite(arg + 1);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	938
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	939 member_type = parse_type(arg, type_gap, give_error);
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	940 if (member_type == NULL)
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	941 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	942
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	943 arg = skipwhite(arg);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	944 if (**arg != '>' && called_emsg == prev_called_emsg)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	945 {
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	946 if (give_error)
29780 9f8dd1b77563 patch 9.0.0229: Vim9: error message for missing type is not clear Bram Moolenaar <Bram@vim.org> parents: 29008 diff changeset	947 semsg(_(e_missing_gt_after_type_str), arg_start);
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	948 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	949 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	950 ++*arg;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	951
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	952 if (type->tt_type == VAR_LIST)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	953 return get_list_type(member_type, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	954 return get_dict_type(member_type, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	955 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	956
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	957 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	958 * Parse a type at "arg" and advance over it.
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	959 * When "give_error" is TRUE give error messages, otherwise be quiet.
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	960 * Return NULL for failure.
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	961 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	962 type_T *
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	963 parse_type(char_u *arg, garray_T type_gap, int give_error)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	964 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	965 char_u p = arg;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	966 size_t len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	967
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	968 // skip over the first word
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	969 while (ASCII_ISALNUM(p) \|\| p == '_')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	970 ++p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	971 len = p - *arg;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	972
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	973 switch (**arg)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	974 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	975 case 'a':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	976 if (len == 3 && STRNCMP(*arg, "any", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	977 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	978 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	979 return &t_any;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	980 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	981 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	982 case 'b':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	983 if (len == 4 && STRNCMP(*arg, "bool", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	984 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	985 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	986 return &t_bool;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	987 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	988 if (len == 4 && STRNCMP(*arg, "blob", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	989 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	990 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	991 return &t_blob;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	992 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	993 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	994 case 'c':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	995 if (len == 7 && STRNCMP(*arg, "channel", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	996 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	997 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	998 return &t_channel;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	999 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1000 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1001 case 'd':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1002 if (len == 4 && STRNCMP(*arg, "dict", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1003 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1004 *arg += len;
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1005 return parse_type_member(arg, &t_dict_any,
29780 9f8dd1b77563 patch 9.0.0229: Vim9: error message for missing type is not clear Bram Moolenaar <Bram@vim.org> parents: 29008 diff changeset	1006 type_gap, give_error, "dict");
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1007 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1008 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1009 case 'f':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1010 if (len == 5 && STRNCMP(*arg, "float", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1011 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1012 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1013 return &t_float;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1014 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1015 if (len == 4 && STRNCMP(*arg, "func", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1016 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1017 type_T *type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1018 type_T *ret_type = &t_unknown;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1019 int argcount = -1;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1020 int flags = 0;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1021 int first_optional = -1;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1022 type_T *arg_type[MAX_FUNC_ARGS + 1];
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1023
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1024 // func({type}, ...{type}): {type}
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1025 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1026 if (**arg == '(')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1027 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1028 // "func" may or may not return a value, "func()" does
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1029 // not return a value.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1030 ret_type = &t_void;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1031
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1032 p = ++*arg;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1033 argcount = 0;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1034 while (p != NUL && p != ')')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1035 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1036 if (*p == '?')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1037 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1038 if (first_optional == -1)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1039 first_optional = argcount;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1040 ++p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1041 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1042 else if (STRNCMP(p, "...", 3) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1043 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1044 flags \|= TTFLAG_VARARGS;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1045 p += 3;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1046 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1047 else if (first_optional != -1)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1048 {
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1049 if (give_error)
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1050 emsg(_(e_mandatory_argument_after_optional_argument));
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1051 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1052 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1053
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1054 type = parse_type(&p, type_gap, give_error);
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1055 if (type == NULL)
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1056 return NULL;
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1057 arg_type[argcount++] = type;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1058
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1059 // Nothing comes after "...{type}".
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1060 if (flags & TTFLAG_VARARGS)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1061 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1062
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1063 if (p != ',' && skipwhite(p) == ',')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1064 {
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1065 if (give_error)
23888 d95403445b6b patch 8.2.2486: Vim9: some errors for white space do not show context Bram Moolenaar <Bram@vim.org> parents: 23877 diff changeset	1066 semsg(_(e_no_white_space_allowed_before_str_str),
d95403445b6b patch 8.2.2486: Vim9: some errors for white space do not show context Bram Moolenaar <Bram@vim.org> parents: 23877 diff changeset	1067 ",", p);
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1068 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1069 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1070 if (*p == ',')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1071 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1072 ++p;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1073 if (!VIM_ISWHITE(*p))
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1074 {
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1075 if (give_error)
23877 85cf06ddb2a8 patch 8.2.2480: Vim9: some errors for white space do not show context Bram Moolenaar <Bram@vim.org> parents: 23717 diff changeset	1076 semsg(_(e_white_space_required_after_str_str),
85cf06ddb2a8 patch 8.2.2480: Vim9: some errors for white space do not show context Bram Moolenaar <Bram@vim.org> parents: 23717 diff changeset	1077 ",", p - 1);
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1078 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1079 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1080 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1081 p = skipwhite(p);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1082 if (argcount == MAX_FUNC_ARGS)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1083 {
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1084 if (give_error)
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1085 emsg(_(e_too_many_argument_types));
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1086 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1087 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1088 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1089
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1090 p = skipwhite(p);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1091 if (*p != ')')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1092 {
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1093 if (give_error)
26602 fac6673086df patch 8.2.3830: error messages are spread out Bram Moolenaar <Bram@vim.org> parents: 25788 diff changeset	1094 emsg(_(e_missing_closing_paren));
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1095 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1096 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1097 *arg = p + 1;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1098 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1099 if (**arg == ':')
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1100 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1101 // parse return type
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1102 ++*arg;
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1103 if (!VIM_ISWHITE(**arg) && give_error)
23877 85cf06ddb2a8 patch 8.2.2480: Vim9: some errors for white space do not show context Bram Moolenaar <Bram@vim.org> parents: 23717 diff changeset	1104 semsg(_(e_white_space_required_after_str_str),
85cf06ddb2a8 patch 8.2.2480: Vim9: some errors for white space do not show context Bram Moolenaar <Bram@vim.org> parents: 23717 diff changeset	1105 ":", *arg - 1);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1106 arg = skipwhite(arg);
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1107 ret_type = parse_type(arg, type_gap, give_error);
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1108 if (ret_type == NULL)
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1109 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1110 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1111 if (flags == 0 && first_optional == -1 && argcount <= 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1112 type = get_func_type(ret_type, argcount, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1113 else
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1114 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1115 type = alloc_func_type(ret_type, argcount, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1116 type->tt_flags = flags;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1117 if (argcount > 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1118 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1119 type->tt_argcount = argcount;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1120 type->tt_min_argcount = first_optional == -1
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1121 ? argcount : first_optional;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1122 if (func_type_add_arg_types(type, argcount,
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1123 type_gap) == FAIL)
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1124 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1125 mch_memmove(type->tt_args, arg_type,
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1126 sizeof(type_T ) argcount);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1127 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1128 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1129 return type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1130 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1131 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1132 case 'j':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1133 if (len == 3 && STRNCMP(*arg, "job", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1134 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1135 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1136 return &t_job;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1137 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1138 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1139 case 'l':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1140 if (len == 4 && STRNCMP(*arg, "list", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1141 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1142 *arg += len;
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1143 return parse_type_member(arg, &t_list_any,
29780 9f8dd1b77563 patch 9.0.0229: Vim9: error message for missing type is not clear Bram Moolenaar <Bram@vim.org> parents: 29008 diff changeset	1144 type_gap, give_error, "list");
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1145 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1146 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1147 case 'n':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1148 if (len == 6 && STRNCMP(*arg, "number", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1149 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1150 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1151 return &t_number;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1152 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1153 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1154 case 's':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1155 if (len == 6 && STRNCMP(*arg, "string", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1156 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1157 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1158 return &t_string;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1159 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1160 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1161 case 'v':
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1162 if (len == 4 && STRNCMP(*arg, "void", len) == 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1163 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1164 *arg += len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1165 return &t_void;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1166 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1167 break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1168 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1169
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1170 if (give_error)
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1171 semsg(_(e_type_not_recognized_str), *arg);
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1172 return NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1173 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1174
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1175 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1176 * Check if "type1" and "type2" are exactly the same.
25425 effe5f2b4d01 patch 8.2.3249: Vim9: error for re-imported function with default argument Bram Moolenaar <Bram@vim.org> parents: 25326 diff changeset	1177 * "flags" can have ETYPE_ARG_UNKNOWN, which means that an unknown argument
effe5f2b4d01 patch 8.2.3249: Vim9: error for re-imported function with default argument Bram Moolenaar <Bram@vim.org> parents: 25326 diff changeset	1178 * type in "type1" is accepted.
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1179 */
23362 f181fe2150ab patch 8.2.2224: Vim9: crash if script reloaded with different variable type Bram Moolenaar <Bram@vim.org> parents: 23338 diff changeset	1180 int
25425 effe5f2b4d01 patch 8.2.3249: Vim9: error for re-imported function with default argument Bram Moolenaar <Bram@vim.org> parents: 25326 diff changeset	1181 equal_type(type_T type1, type_T type2, int flags)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1182 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1183 int i;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1184
24118 1027495445bc patch 8.2.2600: Vim9: crash when putting an unknown type in a dictionary Bram Moolenaar <Bram@vim.org> parents: 23917 diff changeset	1185 if (type1 == NULL \|\| type2 == NULL)
1027495445bc patch 8.2.2600: Vim9: crash when putting an unknown type in a dictionary Bram Moolenaar <Bram@vim.org> parents: 23917 diff changeset	1186 return FALSE;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1187 if (type1->tt_type != type2->tt_type)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1188 return FALSE;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1189 switch (type1->tt_type)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1190 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1191 case VAR_UNKNOWN:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1192 case VAR_ANY:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1193 case VAR_VOID:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1194 case VAR_SPECIAL:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1195 case VAR_BOOL:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1196 case VAR_NUMBER:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1197 case VAR_FLOAT:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1198 case VAR_STRING:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1199 case VAR_BLOB:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1200 case VAR_JOB:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1201 case VAR_CHANNEL:
24606 a4fda40e0bb9 patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled Bram Moolenaar <Bram@vim.org> parents: 24438 diff changeset	1202 case VAR_INSTR:
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1203 break; // not composite is always OK
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1204 case VAR_LIST:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1205 case VAR_DICT:
25425 effe5f2b4d01 patch 8.2.3249: Vim9: error for re-imported function with default argument Bram Moolenaar <Bram@vim.org> parents: 25326 diff changeset	1206 return equal_type(type1->tt_member, type2->tt_member, flags);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1207 case VAR_FUNC:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1208 case VAR_PARTIAL:
25425 effe5f2b4d01 patch 8.2.3249: Vim9: error for re-imported function with default argument Bram Moolenaar <Bram@vim.org> parents: 25326 diff changeset	1209 if (!equal_type(type1->tt_member, type2->tt_member, flags)
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1210 \|\| type1->tt_argcount != type2->tt_argcount)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1211 return FALSE;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1212 if (type1->tt_argcount < 0
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1213 \|\| type1->tt_args == NULL \|\| type2->tt_args == NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1214 return TRUE;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1215 for (i = 0; i < type1->tt_argcount; ++i)
25425 effe5f2b4d01 patch 8.2.3249: Vim9: error for re-imported function with default argument Bram Moolenaar <Bram@vim.org> parents: 25326 diff changeset	1216 if ((flags & ETYPE_ARG_UNKNOWN) == 0
effe5f2b4d01 patch 8.2.3249: Vim9: error for re-imported function with default argument Bram Moolenaar <Bram@vim.org> parents: 25326 diff changeset	1217 && !equal_type(type1->tt_args[i], type2->tt_args[i],
effe5f2b4d01 patch 8.2.3249: Vim9: error for re-imported function with default argument Bram Moolenaar <Bram@vim.org> parents: 25326 diff changeset	1218 flags))
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1219 return FALSE;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1220 return TRUE;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1221 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1222 return TRUE;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1223 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1224
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1225 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1226 * Find the common type of "type1" and "type2" and put it in "dest".
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1227 * "type2" and "dest" may be the same.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1228 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1229 void
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1230 common_type(type_T type1, type_T type2, type_T *dest, garray_T type_gap)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1231 {
25425 effe5f2b4d01 patch 8.2.3249: Vim9: error for re-imported function with default argument Bram Moolenaar <Bram@vim.org> parents: 25326 diff changeset	1232 if (equal_type(type1, type2, 0))
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1233 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1234 *dest = type1;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1235 return;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1236 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1237
22322 a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1238 // If either is VAR_UNKNOWN use the other type. An empty list/dict has no
a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1239 // specific type.
24118 1027495445bc patch 8.2.2600: Vim9: crash when putting an unknown type in a dictionary Bram Moolenaar <Bram@vim.org> parents: 23917 diff changeset	1240 if (type1 == NULL \|\| type1->tt_type == VAR_UNKNOWN)
22322 a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1241 {
a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1242 *dest = type2;
a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1243 return;
a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1244 }
24118 1027495445bc patch 8.2.2600: Vim9: crash when putting an unknown type in a dictionary Bram Moolenaar <Bram@vim.org> parents: 23917 diff changeset	1245 if (type2 == NULL \|\| type2->tt_type == VAR_UNKNOWN)
22322 a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1246 {
a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1247 *dest = type1;
a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1248 return;
a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1249 }
a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1250
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1251 if (type1->tt_type == type2->tt_type)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1252 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1253 if (type1->tt_type == VAR_LIST \|\| type2->tt_type == VAR_DICT)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1254 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1255 type_T *common;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1256
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1257 common_type(type1->tt_member, type2->tt_member, &common, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1258 if (type1->tt_type == VAR_LIST)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1259 *dest = get_list_type(common, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1260 else
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1261 *dest = get_dict_type(common, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1262 return;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1263 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1264 if (type1->tt_type == VAR_FUNC)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1265 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1266 type_T *common;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1267
28059 230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1268 // When one of the types is t_func_unknown return the other one.
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1269 // Useful if a list or dict item is null_func.
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1270 if (type1 == &t_func_unknown)
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1271 {
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1272 *dest = type2;
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1273 return;
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1274 }
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1275 if (type2 == &t_func_unknown)
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1276 {
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1277 *dest = type1;
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1278 return;
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1279 }
230115610b6a patch 8.2.4554: Vim9: using null values not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 28008 diff changeset	1280
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1281 common_type(type1->tt_member, type2->tt_member, &common, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1282 if (type1->tt_argcount == type2->tt_argcount
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1283 && type1->tt_argcount >= 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1284 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1285 int argcount = type1->tt_argcount;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1286 int i;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1287
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1288 *dest = alloc_func_type(common, argcount, type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1289 if (type1->tt_args != NULL && type2->tt_args != NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1290 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1291 if (func_type_add_arg_types(*dest, argcount,
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1292 type_gap) == OK)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1293 for (i = 0; i < argcount; ++i)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1294 common_type(type1->tt_args[i], type2->tt_args[i],
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1295 &(*dest)->tt_args[i], type_gap);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1296 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1297 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1298 else
25126 b825efff9790 patch 8.2.3100: Vim9: no error when using type with unknown number of args Bram Moolenaar <Bram@vim.org> parents: 24996 diff changeset	1299 // Use -1 for "tt_argcount" to indicate an unknown number of
b825efff9790 patch 8.2.3100: Vim9: no error when using type with unknown number of args Bram Moolenaar <Bram@vim.org> parents: 24996 diff changeset	1300 // arguments.
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1301 *dest = alloc_func_type(common, -1, type_gap);
25126 b825efff9790 patch 8.2.3100: Vim9: no error when using type with unknown number of args Bram Moolenaar <Bram@vim.org> parents: 24996 diff changeset	1302
22492 0e03ef68e738 patch 8.2.1794: no falsy Coalescing operator Bram Moolenaar <Bram@vim.org> parents: 22419 diff changeset	1303 // Use the minimum of min_argcount.
0e03ef68e738 patch 8.2.1794: no falsy Coalescing operator Bram Moolenaar <Bram@vim.org> parents: 22419 diff changeset	1304 (*dest)->tt_min_argcount =
0e03ef68e738 patch 8.2.1794: no falsy Coalescing operator Bram Moolenaar <Bram@vim.org> parents: 22419 diff changeset	1305 type1->tt_min_argcount < type2->tt_min_argcount
0e03ef68e738 patch 8.2.1794: no falsy Coalescing operator Bram Moolenaar <Bram@vim.org> parents: 22419 diff changeset	1306 ? type1->tt_min_argcount : type2->tt_min_argcount;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1307 return;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1308 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1309 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1310
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1311 *dest = &t_any;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1312 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1313
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1314 /*
26935 ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1315 * Push an entry onto the type stack. "type" used both for the current type
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1316 * and the declared type.
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1317 * Returns FAIL when out of memory.
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1318 */
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1319 int
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1320 push_type_stack(cctx_T cctx, type_T type)
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1321 {
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1322 return push_type_stack2(cctx, type, type);
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1323 }
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1324
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1325 /*
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1326 * Push an entry onto the type stack. "type" is the current type, "decl_type"
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1327 * is the declared type.
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1328 * Returns FAIL when out of memory.
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1329 */
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1330 int
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1331 push_type_stack2(cctx_T cctx, type_T type, type_T *decl_type)
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1332 {
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1333 garray_T *stack = &cctx->ctx_type_stack;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1334 type2_T *typep;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1335
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1336 if (GA_GROW_FAILS(stack, 1))
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1337 return FAIL;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1338 typep = ((type2_T *)stack->ga_data) + stack->ga_len;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1339 typep->type_curr = type;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1340 typep->type_decl = decl_type;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1341 ++stack->ga_len;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1342 return OK;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1343 }
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1344
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1345 /*
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1346 * Set the type of the top of the stack to "type".
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1347 */
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1348 void
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1349 set_type_on_stack(cctx_T cctx, type_T type, int offset)
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1350 {
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1351 garray_T *stack = &cctx->ctx_type_stack;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1352 type2_T typep = ((type2_T )stack->ga_data)
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1353 + stack->ga_len - 1 - offset;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1354
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1355 typep->type_curr = type;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1356 typep->type_decl = &t_any;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1357 }
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1358
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1359 /*
27503 4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1360 * Get the current type from the type stack. If "offset" is zero the one at
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1361 * the top,
26935 ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1362 * if "offset" is one the type above that, etc.
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1363 * Returns &t_unknown if there is no such stack entry.
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1364 */
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1365 type_T *
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1366 get_type_on_stack(cctx_T *cctx, int offset)
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1367 {
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1368 garray_T *stack = &cctx->ctx_type_stack;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1369
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1370 if (offset + 1 > stack->ga_len)
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1371 return &t_unknown;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1372 return (((type2_T *)stack->ga_data) + stack->ga_len - offset - 1)
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1373 ->type_curr;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1374 }
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1375
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1376 /*
27503 4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1377 * Get the declared type from the type stack. If "offset" is zero the one at
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1378 * the top,
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1379 * if "offset" is one the type above that, etc.
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1380 * Returns &t_unknown if there is no such stack entry.
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1381 */
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1382 type_T *
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1383 get_decl_type_on_stack(cctx_T *cctx, int offset)
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1384 {
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1385 garray_T *stack = &cctx->ctx_type_stack;
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1386
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1387 if (offset + 1 > stack->ga_len)
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1388 return &t_unknown;
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1389 return (((type2_T *)stack->ga_data) + stack->ga_len - offset - 1)
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1390 ->type_decl;
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1391 }
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1392
4cea92e99a5a patch 8.2.4279: Vim9: cannot change item type with map() after range() Bram Moolenaar <Bram@vim.org> parents: 27171 diff changeset	1393 /*
26935 ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1394 * Get the member type of a dict or list from the items on the stack of "cctx".
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1395 * The declared type is stored in "decl_type".
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1396 * For a list "skip" is 1, for a dict "skip" is 2, keys are skipped.
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1397 * Returns &t_void for an empty list or dict.
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1398 * Otherwise finds the common type of all items.
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1399 */
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1400 type_T *
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1401 get_member_type_from_stack(
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1402 int count,
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1403 int skip,
26935 ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1404 cctx_T *cctx)
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1405 {
26935 ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1406 garray_T *stack = &cctx->ctx_type_stack;
26939 ae2324aca26b patch 8.2.3998: asan error for adding zero to NULL Bram Moolenaar <Bram@vim.org> parents: 26935 diff changeset	1407 type2_T *typep;
26935 ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1408 garray_T *type_gap = cctx->ctx_type_list;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1409 int i;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1410 type_T *result;
ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1411 type_T *type;
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1412
26935 ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1413 // Use "unknown" for an empty list or dict.
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1414 if (count == 0)
22322 a5b16c9eee9d patch 8.2.1710: Vim9: list of list type can be wrong Bram Moolenaar <Bram@vim.org> parents: 22284 diff changeset	1415 return &t_unknown;
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1416
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1417 // Use the first value type for the list member type, then find the common
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1418 // type from following items.
26939 ae2324aca26b patch 8.2.3998: asan error for adding zero to NULL Bram Moolenaar <Bram@vim.org> parents: 26935 diff changeset	1419 typep = ((type2_T *)stack->ga_data) + stack->ga_len;
26935 ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1420 result = (typep -(count * skip) + skip - 1)->type_curr;
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1421 for (i = 1; i < count; ++i)
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1422 {
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1423 if (result == &t_any)
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1424 break; // won't get more common
26935 ccb9be1cdd71 patch 8.2.3996: Vim9: type checking lacks information about declared type Bram Moolenaar <Bram@vim.org> parents: 26925 diff changeset	1425 type = (typep -((count - i) * skip) + skip - 1)->type_curr;
21715 571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1426 common_type(type, result, &result, type_gap);
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1427 }
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1428
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1429 return result;
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1430 }
571832713efa patch 8.2.1407: Vim9: type of list and dict only depends on first item Bram Moolenaar <Bram@vim.org> parents: 21711 diff changeset	1431
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1432 char *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1433 vartype_name(vartype_T type)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1434 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1435 switch (type)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1436 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1437 case VAR_UNKNOWN: break;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1438 case VAR_ANY: return "any";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1439 case VAR_VOID: return "void";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1440 case VAR_SPECIAL: return "special";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1441 case VAR_BOOL: return "bool";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1442 case VAR_NUMBER: return "number";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1443 case VAR_FLOAT: return "float";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1444 case VAR_STRING: return "string";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1445 case VAR_BLOB: return "blob";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1446 case VAR_JOB: return "job";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1447 case VAR_CHANNEL: return "channel";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1448 case VAR_LIST: return "list";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1449 case VAR_DICT: return "dict";
24606 a4fda40e0bb9 patch 8.2.2842: Vim9: skip argument to searchpair() is not compiled Bram Moolenaar <Bram@vim.org> parents: 24438 diff changeset	1450 case VAR_INSTR: return "instr";
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1451
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1452 case VAR_FUNC:
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1453 case VAR_PARTIAL: return "func";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1454 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1455 return "unknown";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1456 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1457
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1458 /*
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1459 * Return the name of a type.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1460 * The result may be in allocated memory, in which case "tofree" is set.
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1461 */
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1462 char *
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1463 type_name(type_T type, char *tofree)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1464 {
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1465 char *name;
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1466 char *arg_free = NULL;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1467
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1468 *tofree = NULL;
23332 cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1469 if (type == NULL)
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1470 return "[unknown]";
cdb706d5c43d patch 8.2.2209: Vim9: return type of => lambda not parsed Bram Moolenaar <Bram@vim.org> parents: 22898 diff changeset	1471 name = vartype_name(type->tt_type);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1472 if (type->tt_type == VAR_LIST \|\| type->tt_type == VAR_DICT)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1473 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1474 char *member_free;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1475 char *member_name = type_name(type->tt_member, &member_free);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1476 size_t len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1477
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1478 len = STRLEN(name) + STRLEN(member_name) + 3;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1479 *tofree = alloc(len);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1480 if (*tofree != NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1481 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1482 vim_snprintf(*tofree, len, "%s<%s>", name, member_name);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1483 vim_free(member_free);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1484 return *tofree;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1485 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1486 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1487 if (type->tt_type == VAR_FUNC)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1488 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1489 garray_T ga;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1490 int i;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1491 int varargs = (type->tt_flags & TTFLAG_VARARGS) ? 1 : 0;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1492
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1493 ga_init2(&ga, 1, 100);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1494 if (ga_grow(&ga, 20) == FAIL)
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1495 goto failed;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1496 STRCPY(ga.ga_data, "func(");
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1497 ga.ga_len += 5;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1498
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1499 for (i = 0; i < type->tt_argcount; ++i)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1500 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1501 char *arg_type;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1502 int len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1503
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1504 if (type->tt_args == NULL)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1505 arg_type = "[unknown]";
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1506 else
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1507 arg_type = type_name(type->tt_args[i], &arg_free);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1508 if (i > 0)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1509 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1510 STRCPY((char *)ga.ga_data + ga.ga_len, ", ");
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1511 ga.ga_len += 2;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1512 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1513 len = (int)STRLEN(arg_type);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1514 if (ga_grow(&ga, len + 8) == FAIL)
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1515 goto failed;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1516 if (varargs && i == type->tt_argcount - 1)
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	1517 ga_concat(&ga, (char_u *)"...");
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1518 else if (i >= type->tt_min_argcount)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1519 ((char )ga.ga_data + ga.ga_len++) = '?';
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	1520 ga_concat(&ga, (char_u *)arg_type);
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1521 VIM_CLEAR(arg_free);
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1522 }
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	1523 if (type->tt_argcount < 0)
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	1524 // any number of arguments
6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	1525 ga_concat(&ga, (char_u *)"...");
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1526
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1527 if (type->tt_member == &t_void)
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1528 STRCPY((char *)ga.ga_data + ga.ga_len, ")");
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1529 else
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1530 {
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1531 char *ret_free;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1532 char *ret_name = type_name(type->tt_member, &ret_free);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1533 int len;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1534
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1535 len = (int)STRLEN(ret_name) + 4;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1536 if (ga_grow(&ga, len) == FAIL)
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1537 goto failed;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1538 STRCPY((char *)ga.ga_data + ga.ga_len, "): ");
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1539 STRCPY((char *)ga.ga_data + ga.ga_len + 3, ret_name);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1540 vim_free(ret_free);
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1541 }
22284 6b385c2b9ff5 patch 8.2.1691: Vim9: list<any> is not accepted where list<number> is expected Bram Moolenaar <Bram@vim.org> parents: 22202 diff changeset	1542 *tofree = ga.ga_data;
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1543 return ga.ga_data;
29008 49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1544
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1545 failed:
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1546 vim_free(arg_free);
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1547 ga_clear(&ga);
49d8b54802f3 patch 8.2.5026: Vim9: a few lines not covered by tests Bram Moolenaar <Bram@vim.org> parents: 28952 diff changeset	1548 return "[unknown]";
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1549 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1550
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1551 return name;
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1552 }
d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1553
23594 d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1554 /*
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1555 * "typename(expr)" function
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1556 */
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1557 void
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1558 f_typename(typval_T argvars, typval_T rettv)
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1559 {
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1560 garray_T type_list;
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1561 type_T *type;
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1562 char *tofree;
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1563 char *name;
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1564
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1565 rettv->v_type = VAR_STRING;
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1566 ga_init2(&type_list, sizeof(type_T *), 10);
26925 4e77f9961650 patch 8.2.3991: Vim9: error when extending dict<any> Bram Moolenaar <Bram@vim.org> parents: 26839 diff changeset	1567 type = typval2type(argvars, get_copyID(), &type_list, TVTT_DO_MEMBER);
23594 d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1568 name = type_name(type, &tofree);
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1569 if (tofree != NULL)
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1570 rettv->vval.v_string = (char_u *)tofree;
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1571 else
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1572 {
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1573 rettv->vval.v_string = vim_strsave((char_u *)name);
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1574 vim_free(tofree);
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1575 }
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1576 clear_type_list(&type_list);
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1577 }
d3e064f54890 patch 8.2.2339: cannot get the type of a value as a string Bram Moolenaar <Bram@vim.org> parents: 23527 diff changeset	1578
21711 d2dee69de7c7 patch 8.2.1405: Vim9: vim9compile.c is getting too big Bram Moolenaar <Bram@vim.org> parents: diff changeset	1579 #endif // FEAT_EVAL

Mercurial > vim

annotate src/vim9type.c @ 30576:72e6073a2822 v9.0.0623