aniani/vim
0
0
Fork 1
mirror of https://github.com/vim/vim.git synced 2025-09-23 03:43:49 -04:00
Code Activity

patch 9.0.1906: Vim9: Interfaces should not support class methods and variables

Browse Source 
Problem:  Vim9: Interfaces should not support class methods and
          variables
Solution: Make sure interface follow the interface specification

Vim9 interface changes to follow the new interface specification:

1) An interface can have only read-only and read-write instance
   variables.
2) An interface can have only public instance methods.
3) An interface cannot have class variables and class methods.
4) An interface cannot have private instance variables and private
   instance methods.
5) A interface can extend another interface using "extends". The
   sub-interface gets all the variables and methods in the super
   interface.

That means:
- Interfaces should not support class methods and variables.
- Adjust error numbers and add additional tests.
- Interface methods can be defined in one of the super classes.
- Interface variables can be defined in one of the super classes.
  and instance variables can be repeated in sub interfaces.
- Check the class variable types with the type in interface.

closes: #13100

Signed-off-by: Christian Brabandt <cb@256bit.org>
Co-authored-by: Yegappan Lakshmanan <yegappan@yahoo.com>
This commit is contained in:
Yegappan Lakshmanan
2023-09-17 17:03:19 +02:00
committed by Christian Brabandt
parent 0483e49f90
commit 92d9ee5f4c
6 changed files with 910 additions and 454 deletions
Download Patch File Download Diff File Expand all files Collapse all files

426
src/vim9class.c
View File

@@ -293,7 +293,10 @@ object_index_from_itf_index(class_T *itf, int is_method, int idx, class_T *cl,
* Returns TRUE if the class name "extends_names" is a valid class.
*/
static int
validate_extends_class(char_u *extends_name, class_T **extends_clp)
validate_extends_class(
char_u *extends_name,
class_T **extends_clp,
int is_class)
{
typval_T tv;
int success = FALSE;
@@ -305,9 +308,13 @@ validate_extends_class(char_u *extends_name, class_T **extends_clp)
return success;
}
if (tv.v_type != VAR_CLASS
|| tv.vval.v_class == NULL
|| (tv.vval.v_class->class_flags & CLASS_INTERFACE) != 0)
if (tv.v_type != VAR_CLASS || tv.vval.v_class == NULL
|| (is_class
&& (tv.vval.v_class->class_flags & CLASS_INTERFACE) != 0)
|| (!is_class
&& (tv.vval.v_class->class_flags & CLASS_INTERFACE) == 0))
// a interface cannot extend a class and a class cannot extend an
// interface.
semsg(_(e_cannot_extend_str), extends_name);
else
{
@@ -352,6 +359,8 @@ validate_extends_methods(
if (extends_private)
pstr++;
// When comparing the method names, ignore the access type (public
// and private methods are considered the same).
for (int j = 0; j < method_count; j++)
{
char_u *qstr = cl_fp[j]->uf_name;
@@ -380,12 +389,10 @@ validate_extends_methods(
* are no duplicates.
*/
static int
validate_extends_members(
extends_check_dup_members(
garray_T *objmembers_gap,
class_T *extends_cl)
{
// loop == 1: check class members
// loop == 2: check object members
int member_count = objmembers_gap->ga_len;
if (member_count == 0)
return TRUE;
@@ -431,6 +438,68 @@ validate_extends_members(
return TRUE;
}
/*
* Compare the variable type of interface variables in "objmembers_gap" against
* the variable in any of the extended super interface lineage. Used to
* compare the variable types when extending interfaces. Returns TRUE if the
* variable types are the same.
*/
static int
extends_check_intf_var_type(
garray_T *objmembers_gap,
class_T *extends_cl)
{
int member_count = objmembers_gap->ga_len;
if (member_count == 0)
return TRUE;
ocmember_T *members = (ocmember_T *)(objmembers_gap->ga_data);
// Validate each member variable
for (int c_i = 0; c_i < member_count; c_i++)
{
class_T *p_cl = extends_cl;
ocmember_T *c_m = members + c_i;
int var_found = FALSE;
// Check in all the parent classes in the lineage
while (p_cl != NULL && !var_found)
{
int p_member_count = p_cl->class_obj_member_count;
if (p_member_count == 0)
{
p_cl = p_cl->class_extends;
continue;
}
ocmember_T *p_members = p_cl->class_obj_members;
// Compare against all the members in the parent class
for (int p_i = 0; p_i < p_member_count; p_i++)
{
where_T where = WHERE_INIT;
ocmember_T *p_m = p_members + p_i;
if (STRCMP(p_m->ocm_name, c_m->ocm_name) != 0)
continue;
// Ensure the type is matching.
where.wt_func_name = (char *)c_m->ocm_name;
where.wt_kind = WT_MEMBER;
if (check_type(p_m->ocm_type, c_m->ocm_type, TRUE,
where) == FAIL)
return FALSE;
var_found = TRUE;
}
p_cl = p_cl->class_extends;
}
}
return TRUE;
}
/*
* When extending an abstract class, check whether all the abstract methods in
* the parent class are implemented. Returns TRUE if all the methods are
@@ -491,60 +560,107 @@ validate_abstract_class_methods(
}
/*
* Check the members of the interface class "ifcl" match the class members
* ("classmembers_gap") and object members ("objmembers_gap") of a class.
* Returns TRUE if the class and object member names are valid.
* Returns TRUE if the interface variable "if_var" is present in the list of
* variables in "cl_mt" or in the parent lineage of one of the extended classes
* in "extends_cl". For a class variable, 'is_class_var' is TRUE.
*/
static int
validate_interface_members(
intf_variable_present(
char_u *intf_class_name,
ocmember_T *if_var,
int is_class_var,
ocmember_T *cl_mt,
int cl_member_count,
class_T *extends_cl)
{
int variable_present = FALSE;
for (int cl_i = 0; cl_i < cl_member_count; ++cl_i)
{
ocmember_T *m = &cl_mt[cl_i];
where_T where = WHERE_INIT;
if (STRCMP(if_var->ocm_name, m->ocm_name) != 0)
continue;
// Ensure the access type is same
if (if_var->ocm_access != m->ocm_access)
{
semsg(_(e_member_str_of_interface_str_has_different_access),
if_var->ocm_name, intf_class_name);
return FALSE;
}
// Ensure the type is matching.
if (m->ocm_type == &t_any)
{
// variable type is not specified. Use the variable type in the
// interface.
m->ocm_type = if_var->ocm_type;
}
else
{
where.wt_func_name = (char *)m->ocm_name;
where.wt_kind = WT_MEMBER;
if (check_type(if_var->ocm_type, m->ocm_type, TRUE,
where) == FAIL)
return FALSE;
}
variable_present = TRUE;
break;
}
if (!variable_present && extends_cl != NULL)
{
int ext_cl_count = is_class_var
? extends_cl->class_class_member_count
: extends_cl->class_obj_member_count;
ocmember_T *ext_cl_mt = is_class_var
? extends_cl->class_class_members
: extends_cl->class_obj_members;
return intf_variable_present(intf_class_name, if_var,
is_class_var, ext_cl_mt,
ext_cl_count,
extends_cl->class_extends);
}
return variable_present;
}
/*
* Check the variables of the interface class "ifcl" match the class variables
* ("classmembers_gap") and object variables ("objmembers_gap") of a class.
* Returns TRUE if the class and object variables names are valid.
*/
static int
validate_interface_variables(
char_u *intf_class_name,
class_T *ifcl,
garray_T *classmembers_gap,
garray_T *objmembers_gap)
garray_T *objmembers_gap,
class_T *extends_cl)
{
for (int loop = 1; loop <= 2; ++loop)
{
// loop == 1: check class members
// loop == 2: check object members
int if_count = loop == 1 ? ifcl->class_class_member_count
// loop == 1: check class variables
// loop == 2: check object variables
int is_class_var = (loop == 1);
int if_count = is_class_var ? ifcl->class_class_member_count
: ifcl->class_obj_member_count;
if (if_count == 0)
continue;
ocmember_T *if_ms = loop == 1 ? ifcl->class_class_members
ocmember_T *if_ms = is_class_var ? ifcl->class_class_members
: ifcl->class_obj_members;
ocmember_T *cl_ms = (ocmember_T *)(loop == 1
ocmember_T *cl_ms = (ocmember_T *)(is_class_var
? classmembers_gap->ga_data
: objmembers_gap->ga_data);
int cl_count = loop == 1 ? classmembers_gap->ga_len
int cl_count = is_class_var ? classmembers_gap->ga_len
: objmembers_gap->ga_len;
for (int if_i = 0; if_i < if_count; ++if_i)
{
int cl_i;
for (cl_i = 0; cl_i < cl_count; ++cl_i)
{
ocmember_T *m = &cl_ms[cl_i];
where_T where = WHERE_INIT;
if (STRCMP(if_ms[if_i].ocm_name, m->ocm_name) != 0)
continue;
// Ensure the type is matching.
where.wt_func_name = (char *)m->ocm_name;
where.wt_kind = WT_MEMBER;
if (check_type(if_ms[if_i].ocm_type, m->ocm_type, TRUE,
where) == FAIL)
return FALSE;
if (if_ms[if_i].ocm_access != m->ocm_access)
{
semsg(_(e_member_str_of_interface_str_has_different_access),
if_ms[if_i].ocm_name, intf_class_name);
return FALSE;
}
break;
}
if (cl_i == cl_count)
if (!intf_variable_present(intf_class_name, &if_ms[if_i],
is_class_var, cl_ms, cl_count, extends_cl))
{
semsg(_(e_member_str_of_interface_str_not_implemented),
if_ms[if_i].ocm_name, intf_class_name);
@@ -557,56 +673,107 @@ validate_interface_members(
}
/*
* Check the functions/methods of the interface class "ifcl" match the class
* methods ("classfunctions_gap") and object functions ("objmemthods_gap") of a
* class.
* Returns TRUE if the class and object member names are valid.
* Returns TRUE if the method signature of "if_method" and "cl_method" matches.
*/
static int
intf_method_type_matches(ufunc_T *if_method, ufunc_T *cl_method)
{
where_T where = WHERE_INIT;
// Ensure the type is matching.
where.wt_func_name = (char *)if_method->uf_name;
where.wt_kind = WT_METHOD;
if (check_type(if_method->uf_func_type, cl_method->uf_func_type, TRUE,
where) == FAIL)
return FALSE;
return TRUE;
}
/*
* Returns TRUE if the interface method "if_ufunc" is present in the list of
* methods in "cl_fp" or in the parent lineage of one of the extended classes
* in "extends_cl". For a class method, 'is_class_method' is TRUE.
*/
static int
intf_method_present(
ufunc_T *if_ufunc,
int is_class_method,
ufunc_T **cl_fp,
int cl_count,
class_T *extends_cl)
{
int method_present = FALSE;
for (int cl_i = 0; cl_i < cl_count; ++cl_i)
{
char_u *cl_name = cl_fp[cl_i]->uf_name;
if (STRCMP(if_ufunc->uf_name, cl_name) == 0)
{
// Ensure the type is matching.
if (!intf_method_type_matches(if_ufunc, cl_fp[cl_i]))
return FALSE;
method_present = TRUE;
break;
}
}
if (!method_present && extends_cl != NULL)
{
ufunc_T **ext_cl_fp = (ufunc_T **)(is_class_method
? extends_cl->class_class_functions
: extends_cl->class_obj_methods);
int ext_cl_count = is_class_method
? extends_cl->class_class_function_count
: extends_cl->class_obj_method_count;
return intf_method_present(if_ufunc, is_class_method, ext_cl_fp,
ext_cl_count,
extends_cl->class_extends);
}
return method_present;
}
/*
* Validate that a new class implements all the class/instance methods in the
* interface "ifcl". The new class methods are in "classfunctions_gap" and the
* new object methods are in "objmemthods_gap". Also validates the method
* types.
* Returns TRUE if all the interface class/object methods are implemented in
* the new class.
*/
static int
validate_interface_methods(
char_u *intf_class_name,
class_T *ifcl,
garray_T *classfunctions_gap,
garray_T *objmethods_gap)
garray_T *objmethods_gap,
class_T *extends_cl)
{
for (int loop = 1; loop <= 2; ++loop)
{
// loop == 1: check class functions
// loop == 1: check class methods
// loop == 2: check object methods
int if_count = loop == 1 ? ifcl->class_class_function_count
int is_class_method = (loop == 1);
int if_count = is_class_method ? ifcl->class_class_function_count
: ifcl->class_obj_method_count;
if (if_count == 0)
continue;
ufunc_T **if_fp = loop == 1 ? ifcl->class_class_functions
ufunc_T **if_fp = is_class_method ? ifcl->class_class_functions
: ifcl->class_obj_methods;
ufunc_T **cl_fp = (ufunc_T **)(loop == 1
ufunc_T **cl_fp = (ufunc_T **)(is_class_method
? classfunctions_gap->ga_data
: objmethods_gap->ga_data);
int cl_count = loop == 1 ? classfunctions_gap->ga_len
int cl_count = is_class_method ? classfunctions_gap->ga_len
: objmethods_gap->ga_len;
for (int if_i = 0; if_i < if_count; ++if_i)
{
char_u *if_name = if_fp[if_i]->uf_name;
int cl_i;
for (cl_i = 0; cl_i < cl_count; ++cl_i)
{
char_u *cl_name = cl_fp[cl_i]->uf_name;
if (STRCMP(if_name, cl_name) == 0)
{
where_T where = WHERE_INIT;
// Ensure the type is matching.
where.wt_func_name = (char *)if_name;
where.wt_kind = WT_METHOD;
if (check_type(if_fp[if_i]->uf_func_type,
cl_fp[cl_i]->uf_func_type, TRUE, where) == FAIL)
return FALSE;
break;
}
}
if (cl_i == cl_count)
if (!intf_method_present(if_fp[if_i], is_class_method, cl_fp,
cl_count, extends_cl))
{
semsg(_(e_function_str_of_interface_str_not_implemented),
semsg(_(e_method_str_of_interface_str_not_implemented),
if_name, intf_class_name);
return FALSE;
}
@@ -630,7 +797,8 @@ validate_implements_classes(
garray_T *classfunctions_gap,
garray_T *classmembers_gap,
garray_T *objmethods_gap,
garray_T *objmembers_gap)
garray_T *objmembers_gap,
class_T *extends_cl)
{
int success = TRUE;
@@ -660,15 +828,16 @@ validate_implements_classes(
intf_classes[i] = ifcl;
++ifcl->class_refcount;
// check the members of the interface match the members of the class
success = validate_interface_members(impl, ifcl, classmembers_gap,
objmembers_gap);
// check the variables of the interface match the members of the class
success = validate_interface_variables(impl, ifcl, classmembers_gap,
objmembers_gap, extends_cl);
// check the functions/methods of the interface match the
// functions/methods of the class
if (success)
success = validate_interface_methods(impl, ifcl,
classfunctions_gap, objmethods_gap);
classfunctions_gap, objmethods_gap,
extends_cl);
clear_tv(&tv);
}
@@ -820,8 +989,7 @@ update_member_method_lookup_table(
class_T *ifcl,
class_T *cl,
garray_T *objmethods,
int pobj_method_offset,
int is_interface)
int pobj_method_offset)
{
if (ifcl == NULL)
return OK;
@@ -876,7 +1044,7 @@ update_member_method_lookup_table(
// extended class object method is not overridden by the child class.
// Keep the method declared in one of the parent classes in the
// lineage.
if (!done && !is_interface)
if (!done)
{
// If "ifcl" is not the immediate parent of "cl", then search in
// the intermediate parent classes.
@@ -927,13 +1095,20 @@ update_member_method_lookup_table(
static int
add_lookup_tables(class_T *cl, class_T *extends_cl, garray_T *objmethods_gap)
{
// update the lookup table for all the implemented interfaces
for (int i = 0; i < cl->class_interface_count; ++i)
{
class_T *ifcl = cl->class_interfaces_cl[i];
if (update_member_method_lookup_table(ifcl, cl, objmethods_gap,
0, TRUE) == FAIL)
return FAIL;
// update the lookup table for this interface and all its super
// interfaces.
while (ifcl != NULL)
{
if (update_member_method_lookup_table(ifcl, cl, objmethods_gap,
0) == FAIL)
return FAIL;
ifcl = ifcl->class_extends;
}
}
// Update the lookup table for the extended class, if any
@@ -946,7 +1121,7 @@ add_lookup_tables(class_T *cl, class_T *extends_cl, garray_T *objmethods_gap)
while (pclass != NULL)
{
if (update_member_method_lookup_table(pclass, cl,
objmethods_gap, pobj_method_offset, FALSE) == FAIL)
objmethods_gap, pobj_method_offset) == FAIL)
return FAIL;
pobj_method_offset += pclass->class_obj_method_count_child;
@@ -1237,6 +1412,12 @@ ex_class(exarg_T *eap)
else if (STRNCMP(arg, "implements", 10) == 0
&& IS_WHITE_OR_NUL(arg[10]))
{
if (!is_class)
{
emsg(_(e_interface_cannot_use_implements));
goto early_ret;
}
if (ga_impl.ga_len > 0)
{
emsg(_(e_duplicate_implements));
@@ -1377,18 +1558,25 @@ early_ret:
break;
}
if (!is_abstract)
if (!is_class)
// ignore "abstract" in an interface (as all the methods in an
// interface are abstract.
p = skipwhite(pa + 8);
else
{
semsg(_(e_abstract_method_in_concrete_class), pa);
break;
}
if (!is_abstract)
{
semsg(_(e_abstract_method_in_concrete_class), pa);
break;
}
abstract_method = TRUE;
p = skipwhite(pa + 8);
if (STRNCMP(p, "def", 3) != 0 && STRNCMP(p, "static", 6) != 0)
{
emsg(_(e_abstract_must_be_followed_by_def_or_static));
break;
abstract_method = TRUE;
p = skipwhite(pa + 8);
if (STRNCMP(p, "def", 3) != 0 && STRNCMP(p, "static", 6) != 0)
{
emsg(_(e_abstract_must_be_followed_by_def_or_static));
break;
}
}
}
@@ -1401,6 +1589,12 @@ early_ret:
semsg(_(e_command_cannot_be_shortened_str), ps);
break;
}
if (!is_class)
{
emsg(_(e_static_cannot_be_used_in_interface));
break;
}
has_static = TRUE;
p = skipwhite(ps + 6);
}
@@ -1425,6 +1619,14 @@ early_ret:
char_u *varname_end = NULL;
type_T *type = NULL;
char_u *init_expr = NULL;
if (!is_class && *varname == '_')
{
// private variables are not supported in an interface
semsg(_(e_private_variable_str_in_interface), varname);
break;
}
if (parse_member(eap, line, varname, has_public,
&varname_end, &type_list, &type,
is_class ? &init_expr: NULL) == FAIL)
@@ -1484,6 +1686,13 @@ early_ret:
char_u *name = uf->uf_name;
int is_new = STRNCMP(name, "new", 3) == 0;
if (!is_class && *name == '_')
{
// private variables are not supported in an interface
semsg(_(e_private_method_str_in_interface), name);
func_clear_free(uf, FALSE);
break;
}
if (is_new && !is_valid_constructor(uf, is_abstract,
has_static))
{
@@ -1562,7 +1771,7 @@ early_ret:
// Check the "extends" class is valid.
if (success && extends != NULL)
success = validate_extends_class(extends, &extends_cl);
success = validate_extends_class(extends, &extends_cl, is_class);
VIM_CLEAR(extends);
// Check the new object methods to make sure their access (public or
@@ -1571,9 +1780,15 @@ early_ret:
success = validate_extends_methods(&objmethods, extends_cl);
// Check the new class and object variables are not duplicates of the
// variables in the extended class lineage.
// variables in the extended class lineage. If an interface is extending
// another interface, then it can duplicate the member variables.
if (success && extends_cl != NULL)
success = validate_extends_members(&objmembers, extends_cl);
{
if (is_class)
success = extends_check_dup_members(&objmembers, extends_cl);
else
success = extends_check_intf_var_type(&objmembers, extends_cl);
}
// When extending an abstract class, make sure all the abstract methods in
// the parent class are implemented. If the current class is an abstract
@@ -1592,7 +1807,8 @@ early_ret:
success = validate_implements_classes(&ga_impl, intf_classes,
&classfunctions, &classmembers,
&objmethods, &objmembers);
&objmethods, &objmembers,
extends_cl);
}
// Check no function argument name is used as a class member.
@@ -2637,10 +2853,18 @@ class_instance_of(class_T *cl, class_T *other_cl)
{
if (cl == other_cl)
return TRUE;
// Check the implemented interfaces.
// Check the implemented interfaces and the super interfaces
for (int i = cl->class_interface_count - 1; i >= 0; --i)
if (cl->class_interfaces_cl[i] == other_cl)
return TRUE;
{
class_T *intf = cl->class_interfaces_cl[i];
while (intf != NULL)
{
if (intf == other_cl)
return TRUE;
// check the super interfaces
intf = intf->class_extends;
}
}
}
return FALSE;