" v9.CheckScriptSuccess(lines)
" enddef
+" Test for abstract methods
+def Test_abstract_method()
+ # Use two abstract methods
+ var lines =<< trim END
+ vim9script
+ abstract class A
+ def M1(): number
+ return 10
+ enddef
+ abstract def M2(): number
+ abstract def M3(): number
+ endclass
+ class B extends A
+ def M2(): number
+ return 20
+ enddef
+ def M3(): number
+ return 30
+ enddef
+ endclass
+ var b = B.new()
+ assert_equal([10, 20, 30], [b.M1(), b.M2(), b.M3()])
+ END
+ v9.CheckScriptSuccess(lines)
+
+ # Don't define an abstract method
+ lines =<< trim END
+ vim9script
+ abstract class A
+ abstract def Foo()
+ endclass
+ class B extends A
+ endclass
+ END
+ v9.CheckScriptFailure(lines, 'E1373: Abstract method "Foo" is not implemented')
+
+ # Use abstract method in a concrete class
+ lines =<< trim END
+ vim9script
+ class A
+ abstract def Foo()
+ endclass
+ class B extends A
+ endclass
+ END
+ v9.CheckScriptFailure(lines, 'E1372: Abstract method "abstract def Foo()" cannot be defined in a concrete class')
+
+ # Use abstract method in an interface
+ lines =<< trim END
+ vim9script
+ interface A
+ abstract def Foo()
+ endinterface
+ class B implements A
+ endclass
+ END
+ v9.CheckScriptFailure(lines, 'E1372: Abstract method "abstract def Foo()" cannot be defined in a concrete class')
+
+ # Abbreviate the "abstract" keyword
+ lines =<< trim END
+ vim9script
+ class A
+ abs def Foo()
+ endclass
+ END
+ v9.CheckScriptFailure(lines, 'E1065: Command cannot be shortened: abs def Foo()')
+
+ # Use "abstract" with a member variable
+ lines =<< trim END
+ vim9script
+ abstract class A
+ abstract this.val = 10
+ endclass
+ END
+ v9.CheckScriptFailure(lines, 'E1371: Abstract must be followed by "def" or "static"')
+
+ # Use a static abstract method
+ lines =<< trim END
+ vim9script
+ abstract class A
+ abstract static def Foo(): number
+ endclass
+ class B extends A
+ static def Foo(): number
+ return 4
+ enddef
+ endclass
+ assert_equal(4, B.Foo())
+ END
+ v9.CheckScriptSuccess(lines)
+
+ # Type mismatch between abstract method and concrete method
+ lines =<< trim END
+ vim9script
+ abstract class A
+ abstract def Foo(a: string, b: number): list<number>
+ endclass
+ class B extends A
+ def Foo(a: number, b: string): list<string>
+ return []
+ enddef
+ endclass
+ END
+ v9.CheckScriptFailure(lines, 'E1407: Member "Foo": type mismatch, expected func(string, number): list<number> but got func(number, string): list<string>')
+
+ # Use an abstract class to invoke an abstract method
+ # FIXME: This should fail
+ lines =<< trim END
+ vim9script
+ abstract class A
+ abstract static def Foo()
+ endclass
+ A.Foo()
+ END
+ v9.CheckScriptSuccess(lines)
+
+ # Invoke an abstract method from a def function
+ lines =<< trim END
+ vim9script
+ abstract class A
+ abstract def Foo(): list<number>
+ endclass
+ class B extends A
+ def Foo(): list<number>
+ return [3, 5]
+ enddef
+ endclass
+ def Bar(c: B)
+ assert_equal([3, 5], c.Foo())
+ enddef
+ var b = B.new()
+ Bar(b)
+ END
+ v9.CheckScriptSuccess(lines)
+enddef
+
" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker
semsg(_(e_class_name_not_found_str), extends_name);
return success;
}
+
+ if (tv.v_type != VAR_CLASS
+ || tv.vval.v_class == NULL
+ || (tv.vval.v_class->class_flags & CLASS_INTERFACE) != 0)
+ semsg(_(e_cannot_extend_str), extends_name);
else
{
- if (tv.v_type != VAR_CLASS
- || tv.vval.v_class == NULL
- || (tv.vval.v_class->class_flags & CLASS_INTERFACE) != 0)
- semsg(_(e_cannot_extend_str), extends_name);
- else
- {
- class_T *extends_cl = tv.vval.v_class;
- ++extends_cl->class_refcount;
- *extends_clp = extends_cl;
- success = TRUE;
- }
- clear_tv(&tv);
+ class_T *extends_cl = tv.vval.v_class;
+ ++extends_cl->class_refcount;
+ *extends_clp = extends_cl;
+ success = TRUE;
}
+ clear_tv(&tv);
return success;
}
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
+ * implemented.
+ */
+ static int
+validate_extends_methods(
+ garray_T *classmethods_gap,
+ garray_T *objmethods_gap,
+ class_T *extends_cl)
+{
+ for (int loop = 1; loop <= 2; ++loop)
+ {
+ // loop == 1: check class methods
+ // loop == 2: check object methods
+ int extends_method_count = loop == 1
+ ? extends_cl->class_class_function_count
+ : extends_cl->class_obj_method_count;
+ if (extends_method_count == 0)
+ continue;
+
+ ufunc_T **extends_methods = loop == 1
+ ? extends_cl->class_class_functions
+ : extends_cl->class_obj_methods;
+
+ int method_count = loop == 1 ? classmethods_gap->ga_len
+ : objmethods_gap->ga_len;
+ ufunc_T **cl_fp = (ufunc_T **)(loop == 1
+ ? classmethods_gap->ga_data
+ : objmethods_gap->ga_data);
+
+ for (int i = 0; i < extends_method_count; i++)
+ {
+ ufunc_T *uf = extends_methods[i];
+ if ((uf->uf_flags & FC_ABSTRACT) == 0)
+ continue;
+
+ int method_found = FALSE;
+
+ for (int j = 0; j < method_count; j++)
+ {
+ if (STRCMP(uf->uf_name, cl_fp[j]->uf_name) == 0)
+ {
+ method_found = TRUE;
+ break;
+ }
+ }
+
+ if (!method_found)
+ {
+ semsg(_(e_abstract_method_str_not_found), uf->uf_name);
+ return FALSE;
+ }
+ }
+ }
+
+ return TRUE;
+}
+
/*
* Check the members of the interface class "ifcl" match the class members
* ("classmembers_gap") and object members ("objmembers_gap") of a class.
}
}
+ int abstract_method = FALSE;
+ char_u *pa = p;
+ if (checkforcmd(&p, "abstract", 3))
+ {
+ if (STRNCMP(pa, "abstract", 8) != 0)
+ {
+ semsg(_(e_command_cannot_be_shortened_str), 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;
+ }
+ }
+
int has_static = FALSE;
char_u *ps = p;
if (checkforcmd(&p, "static", 4))
ea.cookie = eap->cookie;
ga_init2(&lines_to_free, sizeof(char_u *), 50);
+ int class_flags;
+ if (is_class)
+ class_flags = abstract_method ? CF_ABSTRACT_METHOD : CF_CLASS;
+ else
+ class_flags = CF_INTERFACE;
ufunc_T *uf = define_function(&ea, NULL, &lines_to_free,
- is_class ? CF_CLASS : CF_INTERFACE);
+ class_flags);
ga_clear_strings(&lines_to_free);
if (uf != NULL)
char_u *name = uf->uf_name;
int is_new = STRNCMP(name, "new", 3) == 0;
- if (is_new && !is_valid_constructor(uf, is_abstract, has_static))
+ if (is_new && !is_valid_constructor(uf, is_abstract,
+ has_static))
{
func_clear_free(uf, FALSE);
break;
if (is_new)
uf->uf_flags |= FC_NEW;
+ if (abstract_method)
+ uf->uf_flags |= FC_ABSTRACT;
+
((ufunc_T **)fgap->ga_data)[fgap->ga_len] = uf;
++fgap->ga_len;
}
success = validate_extends_class(extends, &extends_cl);
VIM_CLEAR(extends);
- // Check the new class members and object members doesn't duplicate the
+ // Check the new class members and object members are not duplicates of the
// members in the extended class lineage.
if (success && extends_cl != NULL)
success = validate_extends_members(&classmembers, &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
+ // class, then there is no need for this check.
+ if (success && !is_abstract && extends_cl != NULL
+ && (extends_cl->class_flags & CLASS_ABSTRACT))
+ success = validate_extends_methods(&classfunctions, &objmethods,
+ extends_cl);
+
class_T **intf_classes = NULL;
// Check all "implements" entries are valid.
goto cleanup;
if (!is_class)
cl->class_flags = CLASS_INTERFACE;
+ else if (is_abstract)
+ cl->class_flags = CLASS_ABSTRACT;
cl->class_refcount = 1;
cl->class_name = vim_strnsave(name_start, name_end - name_start);
projects / thirdparty / vim.git / commitdiff
