diff --git a/src/vim9compile.c b/src/vim9compile.c
index 999833b..fa7171c 100644
--- a/src/vim9compile.c
+++ b/src/vim9compile.c
@@ -478,22 +478,106 @@
 }
 
 /*
- * Return the type_T for a typval.  Only for primitive types.
+ * Get a type_T for a typval_T.
+ * "type_list" is used to temporarily create types in.
  */
     type_T *
-typval2type(typval_T *tv)
+typval2type(typval_T *tv, garray_T *type_gap)
 {
+    type_T  *actual;
+    type_T  *member_type;
+
     if (tv->v_type == VAR_NUMBER)
 	return &t_number;
     if (tv->v_type == VAR_BOOL)
 	return &t_bool;  // not used
     if (tv->v_type == VAR_STRING)
 	return &t_string;
+
+    if (tv->v_type == VAR_LIST
+	    && tv->vval.v_list != NULL
+	    && tv->vval.v_list->lv_first != NULL)
+    {
+	// Use the type of the first member, it is the most specific.
+	member_type = typval2type(&tv->vval.v_list->lv_first->li_tv, type_gap);
+	return get_list_type(member_type, type_gap);
+    }
+
+    if (tv->v_type == VAR_DICT
+	    && tv->vval.v_dict != NULL
+	    && tv->vval.v_dict->dv_hashtab.ht_used > 0)
+    {
+	dict_iterator_T iter;
+	typval_T	*value;
+
+	// Use the type of the first value, it is the most specific.
+	dict_iterate_start(tv, &iter);
+	dict_iterate_next(&iter, &value);
+	member_type = typval2type(value, type_gap);
+	return get_dict_type(member_type, type_gap);
+    }
+
+    if (tv->v_type == VAR_FUNC || tv->v_type == VAR_PARTIAL)
+    {
+	char_u	*name = NULL;
+	ufunc_T *ufunc = NULL;
+
+	if (tv->v_type == VAR_PARTIAL)
+	{
+	    if (tv->vval.v_partial->pt_func != NULL)
+		ufunc = tv->vval.v_partial->pt_func;
+	    else
+		name = tv->vval.v_partial->pt_name;
+	}
+	else
+	    name = tv->vval.v_string;
+	if (name != NULL)
+	    // TODO: how about a builtin function?
+	    ufunc = find_func(name, FALSE, NULL);
+	if (ufunc != NULL && ufunc->uf_func_type != NULL)
+	    return ufunc->uf_func_type;
+    }
+
+    actual = alloc_type(type_gap);
+    if (actual == NULL)
+	return NULL;
+    actual->tt_type = tv->v_type;
+    actual->tt_member = &t_any;
+
+    return actual;
+}
+
+/*
+ * Get a type_T for a typval_T, used for v: variables.
+ * "type_list" is used to temporarily create types in.
+ */
+    type_T *
+typval2type_vimvar(typval_T *tv, garray_T *type_gap)
+{
     if (tv->v_type == VAR_LIST)  // e.g. for v:oldfiles
 	return &t_list_string;
     if (tv->v_type == VAR_DICT)  // e.g. for v:completed_item
 	return &t_dict_any;
-    return &t_any;  // not used
+    return typval2type(tv, type_gap);
+}
+
+
+/*
+ * Return FAIL if "expected" and "actual" don't match.
+ */
+    int
+check_typval_type(type_T *expected, typval_T *actual_tv)
+{
+    garray_T	type_list;
+    type_T	*actual_type;
+    int		res = FAIL;
+
+    ga_init2(&type_list, sizeof(type_T *), 10);
+    actual_type = typval2type(actual_tv, &type_list);
+    if (actual_type != NULL)
+	res = check_type(expected, actual_type, TRUE);
+    clear_type_list(&type_list);
+    return res;
 }
 
     static void
@@ -561,71 +645,6 @@
     return ret;
 }
 
-/*
- * Return FAIl if "expected" and "actual" don't match.
- * TODO: better type comparison
- */
-    int
-check_argtype(type_T *expected, typval_T *actual_tv)
-{
-    type_T  actual;
-    type_T  member;
-
-    // TODO: should should be done with more levels
-    CLEAR_FIELD(actual);
-    actual.tt_type = actual_tv->v_type;
-    if (actual_tv->v_type == VAR_LIST
-	    && actual_tv->vval.v_list != NULL
-	    && actual_tv->vval.v_list->lv_first != NULL)
-    {
-	// Use the type of the first member, it is the most specific.
-	CLEAR_FIELD(member);
-	member.tt_type = actual_tv->vval.v_list->lv_first->li_tv.v_type;
-	member.tt_member = &t_any;
-	actual.tt_member = &member;
-    }
-    else if (actual_tv->v_type == VAR_DICT
-	    && actual_tv->vval.v_dict != NULL
-	    && actual_tv->vval.v_dict->dv_hashtab.ht_used > 0)
-    {
-	dict_iterator_T iter;
-	typval_T	*value;
-
-	// Use the type of the first value, it is the most specific.
-	dict_iterate_start(actual_tv, &iter);
-	dict_iterate_next(&iter, &value);
-	CLEAR_FIELD(member);
-	member.tt_type = value->v_type;
-	member.tt_member = &t_any;
-	actual.tt_member = &member;
-    }
-    else if (actual_tv->v_type == VAR_FUNC || actual_tv->v_type == VAR_PARTIAL)
-    {
-	char_u	*name = NULL;
-	ufunc_T *ufunc = NULL;
-
-	if (actual_tv->v_type == VAR_PARTIAL)
-	{
-	    if (actual_tv->vval.v_partial->pt_func != NULL)
-		ufunc = actual_tv->vval.v_partial->pt_func;
-	    else
-		name = actual_tv->vval.v_partial->pt_name;
-	}
-	else
-	    name = actual_tv->vval.v_string;
-	if (name != NULL)
-	    // TODO: how about a builtin function?
-	    ufunc = find_func(name, FALSE, NULL);
-	if (ufunc != NULL && ufunc->uf_func_type != NULL)
-	    actual = *ufunc->uf_func_type;
-	else
-	    actual.tt_member = &t_any;
-    }
-    else
-	actual.tt_member = &t_any;
-    return check_type(expected, &actual, TRUE);
-}
-
 
 /////////////////////////////////////////////////////////////////////
 // Following generate_ functions expect the caller to call ga_grow().
@@ -1314,7 +1333,7 @@
 	    semsg(_(e_var_notfound), name);
 	return FAIL;
     }
-    type = typval2type(get_vim_var_tv(vidx));
+    type = typval2type_vimvar(get_vim_var_tv(vidx), cctx->ctx_type_list);
 
     return generate_LOAD(cctx, ISN_LOADV, vidx, NULL, type);
 }
@@ -5235,7 +5254,7 @@
 		    goto theend;
 		dest = dest_vimvar;
 		vtv = get_vim_var_tv(vimvaridx);
-		type = typval2type(vtv);
+		type = typval2type_vimvar(vtv, cctx->ctx_type_list);
 		if (is_decl)
 		{
 		    vim9_declare_error(name);