7. Type definition *Vim9-type* *:type*
-{not implemented yet}
-
-A type definition is giving a name to a type specification. For Example: >
+A type definition is giving a name to a type specification. This also known
+type alias. For Example: >
- :type ListOfStrings list<string>
+ :type ListOfStrings = list<string>
+The type alias can be used wherever a built-in type can be used. The type
+alias name must start with an upper case character.
==============================================================================
EXTERN char e_not_valid_command_in_class_str[]
INIT(= N_("E1318: Not a valid command in a class: %s"));
EXTERN char e_using_class_as_number[]
- INIT(= N_("E1319: Using a class as a Number"));
+ INIT(= N_("E1319: Using a Class as a Number"));
EXTERN char e_using_object_as_number[]
- INIT(= N_("E1320: Using an object as a Number"));
+ INIT(= N_("E1320: Using an Object as a Number"));
EXTERN char e_using_class_as_float[]
- INIT(= N_("E1321: Using a class as a Float"));
+ INIT(= N_("E1321: Using a Class as a Float"));
EXTERN char e_using_object_as_float[]
- INIT(= N_("E1322: Using an object as a Float"));
+ INIT(= N_("E1322: Using an Object as a Float"));
EXTERN char e_using_class_as_string[]
- INIT(= N_("E1323: Using a class as a String"));
+ INIT(= N_("E1323: Using a Class as a String"));
EXTERN char e_using_object_as_string[]
- INIT(= N_("E1324: Using an object as a String"));
+ INIT(= N_("E1324: Using an Object as a String"));
EXTERN char e_method_not_found_on_class_str_str[]
INIT(= N_("E1325: Method \"%s\" not found in class \"%s\""));
EXTERN char e_variable_not_found_on_object_str_str[]
INIT(= N_("E1391: Cannot (un)lock variable \"%s\" in class \"%s\""));
EXTERN char e_cannot_lock_class_variable_str[]
INIT(= N_("E1392: Cannot (un)lock class variable \"%s\" in class \"%s\""));
-#endif
-// E1393 - E1499 unused (reserved for Vim9 class support)
+EXTERN char e_type_can_only_be_defined_in_vim9_script[]
+ INIT(= N_("E1393: Type can only be defined in Vim9 script"));
+EXTERN char e_type_name_must_start_with_uppercase_letter_str[]
+ INIT(= N_("E1394: Type name must start with an uppercase letter: %s"));
+EXTERN char e_using_typealias_as_variable[]
+ INIT(= N_("E1395: Type alias \"%s\" cannot be used as a variable"));
+EXTERN char e_typealias_already_exists_for_str[]
+ INIT(= N_("E1396: Type alias \"%s\" already exists"));
+EXTERN char e_missing_typealias_name[]
+ INIT(= N_("E1397: Missing type alias name"));
+EXTERN char e_missing_typealias_type[]
+ INIT(= N_("E1398: Missing type alias type"));
+EXTERN char e_type_can_only_be_used_in_script[]
+ INIT(= N_("E1399: Type can only be used in a script"));
+#endif
+// E1400 - E1499 unused (reserved for Vim9 class support)
EXTERN char e_cannot_mix_positional_and_non_positional_str[]
INIT(= N_("E1500: Cannot mix positional and non-positional arguments: %s"));
EXTERN char e_fmt_arg_nr_unused_str[]
if (eval_variable(lp->ll_name, (int)STRLEN(lp->ll_name),
lp->ll_sid, &tv, &di, EVAL_VAR_VERBOSE) == OK)
{
+ if (di != NULL && di->di_tv.v_type == VAR_TYPEALIAS)
+ {
+ semsg(_(e_using_typealias_as_variable),
+ di->di_tv.vval.v_typealias->ta_name);
+ clear_tv(&tv);
+ return;
+ }
+
if ((di == NULL
|| (!var_check_ro(di->di_flags, lp->ll_name, FALSE)
&& !tv_check_lock(&di->di_tv, lp->ll_name, FALSE)))
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
break;
case VAR_BLOB:
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
if (verbose)
emsg(_(e_cannot_index_special_variable));
return FAIL;
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
break; // not evaluating, skipping over subscript
case VAR_NUMBER:
case VAR_FLOAT:
case VAR_STRING:
case VAR_BLOB:
+ case VAR_TYPEALIAS:
case VAR_INSTR:
// Types that do not contain any other item
break;
*tofree = NULL;
r = (char_u *)get_var_special_name(tv->vval.v_number);
break;
+
+ case VAR_TYPEALIAS:
+ *tofree = vim_strsave(tv->vval.v_typealias->ta_name);
+ r = *tofree;
+ if (r == NULL)
+ r = (char_u *)"";
+ break;
}
if (--recurse == 0)
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
copy_tv(from, to);
break;
case VAR_LIST:
|| !channel_is_open(argvars[0].vval.v_channel);
break;
#endif
+ case VAR_TYPEALIAS:
+ n = argvars[0].vval.v_typealias == NULL
+ || argvars[0].vval.v_typealias->ta_name == NULL
+ || *argvars[0].vval.v_typealias->ta_name == NUL;
+ break;
+
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_VOID:
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
emsg(_(e_invalid_type_for_len));
break;
}
case VAR_INSTR: n = VAR_TYPE_INSTR; break;
case VAR_CLASS: n = VAR_TYPE_CLASS; break;
case VAR_OBJECT: n = VAR_TYPE_OBJECT; break;
+ case VAR_TYPEALIAS: n = VAR_TYPE_TYPEALIAS; break;
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_VOID:
{VV_NAME("sizeofpointer", VAR_NUMBER), NULL, VV_RO},
{VV_NAME("maxcol", VAR_NUMBER), NULL, VV_RO},
{VV_NAME("python3_version", VAR_NUMBER), NULL, VV_RO},
+ {VV_NAME("t_typealias", VAR_NUMBER), NULL, VV_RO},
};
// shorthand
set_vim_var_nr(VV_TYPE_BLOB, VAR_TYPE_BLOB);
set_vim_var_nr(VV_TYPE_CLASS, VAR_TYPE_CLASS);
set_vim_var_nr(VV_TYPE_OBJECT, VAR_TYPE_OBJECT);
+ set_vim_var_nr(VV_TYPE_TYPEALIAS, VAR_TYPE_TYPEALIAS);
set_vim_var_nr(VV_ECHOSPACE, sc_col - 1);
return NULL;
}
+ if (tv->v_type == VAR_TYPEALIAS)
+ {
+ semsg(_(e_using_typealias_as_variable), tv->vval.v_typealias->ta_name);
+ return NULL;
+ }
+
if (*arg == '$')
{
// ":let $VAR = expr": Set environment variable.
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
break;
case VAR_BLOB:
}
// Check for local variable when debugging.
- if ((tv = lookup_debug_var(name)) == NULL)
+ if ((sid == 0) && (tv = lookup_debug_var(name)) == NULL)
{
// Check for user-defined variables.
dictitem_T *v = find_var(name, &ht, flags & EVAL_VAR_NOAUTOLOAD);
}
}
+ if ((tv->v_type == VAR_TYPEALIAS || tv->v_type == VAR_CLASS)
+ && sid != 0)
+ {
+ // type alias or class imported from another script. Check
+ // whether it is exported from the other script.
+ sv = find_typval_in_script(tv, sid, TRUE);
+ if (sv == NULL)
+ {
+ ret = FAIL;
+ goto done;
+ }
+ if ((sv->sv_flags & SVFLAG_EXPORTED) == 0)
+ {
+ semsg(_(e_item_not_exported_in_script_str), name);
+ ret = FAIL;
+ goto done;
+ }
+ }
+
// If a list or dict variable wasn't initialized and has meaningful
// type, do it now. Not for global variables, they are not
// declared.
}
}
+done:
if (len > 0)
name[len] = cc;
goto failed;
}
+ if (di->di_tv.v_type == VAR_TYPEALIAS)
+ {
+ semsg(_(e_using_typealias_as_variable),
+ di->di_tv.vval.v_typealias->ta_name);
+ clear_tv(&di->di_tv);
+ goto failed;
+ }
+
if (var_in_vim9script && (flags & ASSIGN_FOR_LOOP) == 0)
{
where_T where = WHERE_INIT;
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
Py_INCREF(Py_None);
return Py_None;
case VAR_BOOL:
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
semsg(_(e_cannot_json_encode_str), vartype_name(val->v_type));
return FAIL;
type_T *oc_member_type(class_T *cl, int is_object, char_u *name, char_u *name_end, int *member_idx);
type_T *oc_member_type_by_idx(class_T *cl, int is_object, int member_idx);
void ex_enum(exarg_T *eap);
+void typealias_free(typealias_T *ta);
+void typealias_unref(typealias_T *ta);
void ex_type(exarg_T *eap);
int class_object_index(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int verbose);
ufunc_T *find_class_func(char_u **arg);
typedef struct instr_S instr_T;
typedef struct class_S class_T;
typedef struct object_S object_T;
+typedef struct typealias_S typealias_T;
typedef enum
{
VAR_INSTR, // "v_instr" is used
VAR_CLASS, // "v_class" is used (also used for interface)
VAR_OBJECT, // "v_object" is used
+ VAR_TYPEALIAS // "v_typealias" is used
} vartype_T;
// A type specification.
int obj_copyID; // used by garbage collection
};
+struct typealias_S
+{
+ int ta_refcount;
+ type_T *ta_type;
+ char_u *ta_name;
+};
+
/*
* Structure to hold an internal variable without a name.
*/
instr_T *v_instr; // instructions to execute
class_T *v_class; // class value (can be NULL)
object_T *v_object; // object value (can be NULL)
+ typealias_T *v_typealias; // user-defined type name
} vval;
};
if A
endif
END
- v9.CheckSourceFailure(lines, 'E1319: Using a class as a Number', 4)
+ v9.CheckSourceFailure(lines, 'E1319: Using a Class as a Number', 4)
# Test for using object as a bool
lines =<< trim END
if a
endif
END
- v9.CheckSourceFailure(lines, 'E1320: Using an object as a Number', 5)
+ v9.CheckSourceFailure(lines, 'E1320: Using an Object as a Number', 5)
# Test for using class as a float
lines =<< trim END
endclass
sort([1.1, A], 'f')
END
- v9.CheckSourceFailure(lines, 'E1321: Using a class as a Float', 4)
+ v9.CheckSourceFailure(lines, 'E1321: Using a Class as a Float', 4)
# Test for using object as a float
lines =<< trim END
var a = A.new()
sort([1.1, a], 'f')
END
- v9.CheckSourceFailure(lines, 'E1322: Using an object as a Float', 5)
+ v9.CheckSourceFailure(lines, 'E1322: Using an Object as a Float', 5)
# Test for using class as a string
lines =<< trim END
endclass
:exe 'call ' .. A
END
- v9.CheckSourceFailure(lines, 'E1323: Using a class as a String', 4)
+ v9.CheckSourceFailure(lines, 'E1323: Using a Class as a String', 4)
# Test for using object as a string
lines =<< trim END
var a = A.new()
:exe 'call ' .. a
END
- v9.CheckSourceFailure(lines, 'E1324: Using an object as a String', 5)
+ v9.CheckSourceFailure(lines, 'E1324: Using an Object as a String', 5)
# Test creating a class with member variables and methods, calling a object
# method. Check for using type() and typename() with a class and an object.
assert_equal([2, 3, 1, 4, 5, 6, 7], callTrace)
END
- v9.CheckScriptSuccess(lines)
+ v9.CheckSourceSuccess(lines)
enddef
" Test for multiple deferred function which throw exceptions.
assert_equal('E605: Exception not caught: InnerException', v:errmsg)
assert_equal([11, 9, 10, 7, 8, 5, 1, 3, 4, 12, 15, 16], callTrace)
END
+ v9.CheckSourceSuccess(lines)
+enddef
+
+" Test for :type command to create type aliases
+def Test_typealias()
+ var lines =<< trim END
+ vim9script
+ type ListOfStrings = list<string>
+ var a: ListOfStrings = ['a', 'b']
+ assert_equal(['a', 'b'], a)
+ def Foo(b: ListOfStrings): ListOfStrings
+ var c: ListOfStrings = ['c', 'd']
+ assert_equal(['c', 'd'], c)
+ return b
+ enddef
+ assert_equal(['e', 'f'], Foo(['e', 'f']))
+ assert_equal('typealias<list<string>>', typename(ListOfStrings))
+ assert_equal(v:t_typealias, type(ListOfStrings))
+ assert_equal('ListOfStrings', string(ListOfStrings))
+ assert_equal(false, null == ListOfStrings)
+ END
+ v9.CheckSourceSuccess(lines)
+
+ # Use :type outside a Vim9 script
+ lines =<< trim END
+ type Index = number
+ END
+ v9.CheckSourceFailure(lines, 'E1393: Type can only be defined in Vim9 script', 1)
+
+ # Use :type without any arguments
+ lines =<< trim END
+ vim9script
+ type
+ END
+ v9.CheckSourceFailure(lines, 'E1397: Missing type alias name', 2)
+
+ # Use :type with a name but no type
+ lines =<< trim END
+ vim9script
+ type MyType
+ END
+ v9.CheckSourceFailure(lines, "E398: Missing '=': ", 2)
+
+ # Use :type with a name but no type following "="
+ lines =<< trim END
+ vim9script
+ type MyType =
+ END
+ v9.CheckSourceFailure(lines, 'E1398: Missing type alias type', 2)
+
+ # No space before or after "="
+ lines =<< trim END
+ vim9script
+ type MyType=number
+ END
+ v9.CheckSourceFailure(lines, 'E1315: White space required after name: MyType=number', 2)
+
+ # No space after "="
+ lines =<< trim END
+ vim9script
+ type MyType =number
+ END
+ v9.CheckSourceFailure(lines, "E1069: White space required after '=': =number", 2)
+
+ # type alias without "="
+ lines =<< trim END
+ vim9script
+ type Index number
+ END
+ v9.CheckSourceFailure(lines, "E398: Missing '=': number", 2)
+
+ # type alias for a non-existing type
+ lines =<< trim END
+ vim9script
+ type Index = integer
+ END
+ v9.CheckSourceFailure(lines, 'E1010: Type not recognized: integer', 2)
+
+ # type alias starting with lower-case letter
+ lines =<< trim END
+ vim9script
+ type index number
+ END
+ v9.CheckSourceFailure(lines, 'E1394: Type name must start with an uppercase letter: index number', 2)
+
+ # No white space following the alias name
+ lines =<< trim END
+ vim9script
+ type Index:number
+ END
+ v9.CheckSourceFailure(lines, 'E1315: White space required after name: Index:number', 2)
+
+ # something following the type alias
+ lines =<< trim END
+ vim9script
+ type ListOfNums = list<number> string
+ END
+ v9.CheckSourceFailure(lines, 'E488: Trailing characters: string', 2)
+
+ # type alias name collides with a variable name
+ lines =<< trim END
+ vim9script
+ var ListOfNums: number = 10
+ type ListOfNums = list<number>
+ END
+ v9.CheckSourceFailure(lines, 'E1041: Redefining script item: "ListOfNums"', 3)
+
+ # duplicate type alias name
+ lines =<< trim END
+ vim9script
+ type MyList = list<number>
+ type MyList = list<string>
+ END
+ v9.CheckSourceFailure(lines, 'E1396: Type alias "MyList" already exists', 3)
+
+ # Sourcing a script twice (which will free script local variables)
+ lines =<< trim END
+ vim9script
+ class C
+ endclass
+ type AC = C
+ assert_equal('typealias<object<C>>', typename(AC))
+ END
+ new
+ setline(1, lines)
+ :source
+ :source
+ bw!
+
+ # Assigning to a type alias (script level)
+ lines =<< trim END
+ vim9script
+ type MyType = list<number>
+ MyType = [1, 2, 3]
+ END
+ v9.CheckSourceFailure(lines, 'E1395: Type alias "MyType" cannot be used as a variable', 3)
+
+ # Assigning a type alias (def function level)
+ lines =<< trim END
+ vim9script
+ type A = list<string>
+ def Foo()
+ var x = A
+ enddef
+ Foo()
+ END
+ v9.CheckSourceFailure(lines, 'E1395: Type alias "A" cannot be used as a variable', 1)
+
+ # Using type alias in an expression (script level)
+ lines =<< trim END
+ vim9script
+ type MyType = list<number>
+ assert_fails('var m = MyType', 'E1395: Type alias "MyType" cannot be used as a variable')
+ assert_fails('var i = MyType + 1', 'E1395: Type alias "MyType" cannot be used as a variable')
+ assert_fails('var f = 1.0 + MyType', 'E1395: Type alias "MyType" cannot be used as a variable')
+ assert_fails('MyType += 10', 'E1395: Type alias "MyType" cannot be used as a variable')
+ END
+ v9.CheckSourceSuccess(lines)
+
+ # Using type alias in an expression (def function level)
+ lines =<< trim END
+ vim9script
+ type MyType = list<number>
+ def Foo()
+ var x = MyType + 1
+ enddef
+ Foo()
+ END
+ v9.CheckSourceFailure(lines, 'E1395: Type alias "MyType" cannot be used as a variable', 1)
+
+ # Using type alias in an expression (def function level)
+ lines =<< trim END
+ vim9script
+ type MyType = list<number>
+ def Foo()
+ MyType = list<string>
+ enddef
+ Foo()
+ END
+ v9.CheckSourceFailure(lines, 'E46: Cannot change read-only variable "MyType"', 1)
+
+ # Using type alias in an expression (def function level)
+ lines =<< trim END
+ vim9script
+ type MyType = list<number>
+ def Foo()
+ MyType += 10
+ enddef
+ Foo()
+ END
+ v9.CheckSourceFailure(lines, 'E46: Cannot change read-only variable "MyType"', 1)
+
+ # Creating a typealias in a def function
+ lines =<< trim END
+ vim9script
+ def Foo()
+ var n: number = 10
+ type A = list<string>
+ enddef
+ defcompile
+ END
+ v9.CheckSourceFailure(lines, 'E1399: Type can only be used in a script', 2)
+
+ # json_encode should fail with a type alias
+ lines =<< trim END
+ vim9script
+ type A = list<string>
+ var x = json_encode(A)
+ END
+ v9.CheckSourceFailure(lines, 'E1161: Cannot json encode a typealias', 3)
+
+ # Comparing type alias with a number (script level)
+ lines =<< trim END
+ vim9script
+ type A = list<string>
+ var n: number
+ var x = A == n
+ END
+ v9.CheckSourceFailure(lines, 'E1072: Cannot compare typealias with number', 4)
+
+ # Comparing type alias with a number (def function level)
+ lines =<< trim END
+ vim9script
+ type A = list<string>
+ def Foo()
+ var n: number
+ var x = A == n
+ enddef
+ Foo()
+ END
+ v9.CheckSourceFailure(lines, 'E1395: Type alias "A" cannot be used as a variable', 2)
+enddef
+
+" Test for exporting and importing type aliases
+def Test_import_typealias()
+ var lines =<< trim END
+ vim9script
+ export type MyType = list<number>
+ END
+ writefile(lines, 'Xtypeexport.vim', 'D')
+
+ lines =<< trim END
+ vim9script
+ import './Xtypeexport.vim' as A
+
+ var myList: A.MyType = [1, 2, 3]
+ def Foo(l: A.MyType)
+ assert_equal([1, 2, 3], l)
+ enddef
+ Foo(myList)
+ END
+ v9.CheckScriptSuccess(lines)
+
+ # Use a non existing type alias
+ lines =<< trim END
+ vim9script
+ import './Xtypeexport.vim' as A
+
+ var myNum: A.SomeType = 10
+ END
+ v9.CheckScriptFailure(lines, 'E1010: Type not recognized: A.SomeType = 10', 4)
+
+ # Use a type alias that is not exported
+ lines =<< trim END
+ vim9script
+ type NewType = dict<string>
+ END
+ writefile(lines, 'Xtypeexport2.vim', 'D')
+ lines =<< trim END
+ vim9script
+ import './Xtypeexport2.vim' as A
+
+ var myDict: A.NewType = {}
+ END
+ v9.CheckScriptFailure(lines, 'E1049: Item not exported in script: NewType', 4)
+
+ # Using the same name as an imported type alias
+ lines =<< trim END
+ vim9script
+ export type MyType2 = list<number>
+ END
+ writefile(lines, 'Xtypeexport3.vim', 'D')
+ lines =<< trim END
+ vim9script
+ import './Xtypeexport3.vim' as A
+
+ type MyType2 = A.MyType2
+ var myList1: A.MyType2 = [1, 2, 3]
+ var myList2: MyType2 = [4, 5, 6]
+ assert_equal([1, 2, 3], myList1)
+ assert_equal([4, 5, 6], myList2)
+ END
+ v9.CheckScriptSuccess(lines)
+enddef
+
+" Test for using typealias as a def function argument and return type
+def Test_typealias_func_argument()
+ var lines =<< trim END
+ vim9script
+ type A = list<number>
+ def Foo(l: A): A
+ assert_equal([1, 2], l)
+ return l
+ enddef
+ var x: A = [1, 2]
+ assert_equal([1, 2], Foo(x))
+ END
+ v9.CheckScriptSuccess(lines)
+
+ # passing a type alias variable to a function expecting a specific type
+ lines =<< trim END
+ vim9script
+ type A = list<number>
+ def Foo(l: list<number>)
+ assert_equal([1, 2], l)
+ enddef
+ var x: A = [1, 2]
+ Foo(x)
+ END
+ v9.CheckScriptSuccess(lines)
+
+ # passing a type alias variable to a function expecting any
+ lines =<< trim END
+ vim9script
+ type A = list<number>
+ def Foo(l: any)
+ assert_equal([1, 2], l)
+ enddef
+ var x: A = [1, 2]
+ Foo(x)
+ END
+ v9.CheckScriptSuccess(lines)
+enddef
+
+" Using a type alias with a builtin function
+def Test_typealias_with_builtin_functions()
+ var lines =<< trim END
+ vim9script
+ type A = list<func>
+ assert_equal(0, empty(A))
+ END
+ v9.CheckScriptSuccess(lines)
+
+ # Using a type alias with len()
+ lines =<< trim END
+ vim9script
+ type A = list<func>
+ var x = len(A)
+ END
+ v9.CheckScriptFailure(lines, 'E701: Invalid type for len()', 3)
+
+ # Using a type alias with eval()
+ lines =<< trim END
+ vim9script
+ type A = number
+ def Foo()
+ var x = eval("A")
+ enddef
+ Foo()
+ END
+ v9.CheckScriptFailure(lines, 'E1395: Type alias "A" cannot be used as a variable', 1)
+enddef
+
+" Test for type alias refcount
+def Test_typealias_refcount()
+ var lines =<< trim END
+ vim9script
+ type A = list<func>
+ assert_equal(1, test_refcount(A))
+ END
+ v9.CheckScriptSuccess(lines)
+
+ lines =<< trim END
+ vim9script
+ type B = list<number>
+ var x: B = []
+ assert_equal(1, test_refcount(B))
+ END
v9.CheckScriptSuccess(lines)
enddef
if (argvars[0].vval.v_dict != NULL)
retval = argvars[0].vval.v_dict->dv_refcount - 1;
break;
+ case VAR_TYPEALIAS:
+ if (argvars[0].vval.v_typealias != NULL)
+ retval = argvars[0].vval.v_typealias->ta_refcount - 1;
+ break;
}
rettv->v_type = VAR_NUMBER;
object_unref(varp->vval.v_object);
break;
+ case VAR_TYPEALIAS:
+ typealias_unref(varp->vval.v_typealias);
+ break;
+
case VAR_NUMBER:
case VAR_FLOAT:
case VAR_ANY:
object_unref(varp->vval.v_object);
varp->vval.v_object = NULL;
break;
+ case VAR_TYPEALIAS:
+ typealias_unref(varp->vval.v_typealias);
+ varp->vval.v_typealias = NULL;
+ break;
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_VOID:
case VAR_VOID:
emsg(_(e_cannot_use_void_value));
break;
+ case VAR_TYPEALIAS:
+ semsg(_(e_using_typealias_as_variable),
+ varp->vval.v_typealias->ta_name);
+ break;
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_INSTR:
case VAR_VOID:
emsg(_(e_cannot_use_void_value));
break;
+ case VAR_TYPEALIAS:
+ semsg(_(e_using_typealias_as_variable),
+ varp->vval.v_typealias->ta_name);
+ break;
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_INSTR:
case VAR_VOID:
emsg(_(e_cannot_use_void_value));
break;
+ case VAR_TYPEALIAS:
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_INSTR:
++to->vval.v_dict->dv_refcount;
}
break;
+ case VAR_TYPEALIAS:
+ if (from->vval.v_typealias == NULL)
+ to->vval.v_typealias = NULL;
+ else
+ {
+ to->vval.v_typealias = from->vval.v_typealias;
+ ++to->vval.v_typealias->ta_refcount;
+ }
+ break;
case VAR_VOID:
emsg(_(e_cannot_use_void_value));
break;
case VAR_FLOAT: if (!in_vim9script())
return tv->vval.v_float == 0.0;
break;
+ case VAR_TYPEALIAS: return tv->vval.v_typealias == NULL;
default: break;
}
}
case VAR_FUNC:
return tv1->vval.v_string == tv2->vval.v_string;
+ case VAR_TYPEALIAS:
+ return tv1->vval.v_typealias == tv2->vval.v_typealias;
+
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_VOID:
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 2076,
/**/
2075,
/**/
#define VV_SIZEOFPOINTER 104
#define VV_MAXCOL 105
#define VV_PYTHON3_VERSION 106
-#define VV_LEN 107 // number of v: vars
+#define VV_TYPE_TYPEALIAS 107
+#define VV_LEN 108 // number of v: vars
// used for v_number in VAR_BOOL and VAR_SPECIAL
#define VVAL_FALSE 0L // VAR_BOOL
#define VAR_TYPE_INSTR 11
#define VAR_TYPE_CLASS 12
#define VAR_TYPE_OBJECT 13
+#define VAR_TYPE_TYPEALIAS 15
#define DICT_MAXNEST 100 // maximum nesting of lists and dicts
}
/*
- * Handle ":type".
+ * Type aliases (:type)
+ */
+
+ void
+typealias_free(typealias_T *ta)
+{
+ // ta->ta_type is freed in clear_type_list()
+ vim_free(ta->ta_name);
+ vim_free(ta);
+}
+
+ void
+typealias_unref(typealias_T *ta)
+{
+ if (ta != NULL && --ta->ta_refcount <= 0)
+ typealias_free(ta);
+}
+
+/*
+ * Handle ":type". Create an alias for a type specification.
*/
void
ex_type(exarg_T *eap UNUSED)
{
- // TODO
+ char_u *arg = eap->arg;
+
+ if (!current_script_is_vim9()
+ || (cmdmod.cmod_flags & CMOD_LEGACY)
+ || !getline_equal(eap->getline, eap->cookie, getsourceline))
+ {
+ emsg(_(e_type_can_only_be_defined_in_vim9_script));
+ return;
+ }
+
+ if (*arg == NUL)
+ {
+ emsg(_(e_missing_typealias_name));
+ return;
+ }
+
+ if (!ASCII_ISUPPER(*arg))
+ {
+ semsg(_(e_type_name_must_start_with_uppercase_letter_str), arg);
+ return;
+ }
+
+ char_u *name_end = find_name_end(arg, NULL, NULL, FNE_CHECK_START);
+ if (!IS_WHITE_OR_NUL(*name_end))
+ {
+ semsg(_(e_white_space_required_after_name_str), arg);
+ return;
+ }
+ char_u *name_start = arg;
+
+ arg = skipwhite(name_end);
+ if (*arg != '=')
+ {
+ semsg(_(e_missing_equal_str), arg);
+ return;
+ }
+ if (!IS_WHITE_OR_NUL(*(arg + 1)))
+ {
+ semsg(_(e_white_space_required_after_str_str), "=", arg);
+ return;
+ }
+ arg++;
+ arg = skipwhite(arg);
+
+ if (*arg == NUL)
+ {
+ emsg(_(e_missing_typealias_type));
+ return;
+ }
+
+ scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
+ type_T *type = parse_type(&arg, &si->sn_type_list, TRUE);
+ if (type == NULL)
+ return;
+
+ if (*arg != NUL)
+ {
+ // some text after the type
+ semsg(_(e_trailing_characters_str), arg);
+ return;
+ }
+
+ int cc = *name_end;
+ *name_end = NUL;
+
+ typval_T tv;
+ tv.v_type = VAR_UNKNOWN;
+ if (eval_variable_import(name_start, &tv) == OK)
+ {
+ if (tv.v_type == VAR_TYPEALIAS)
+ semsg(_(e_typealias_already_exists_for_str), name_start);
+ else
+ semsg(_(e_redefining_script_item_str), name_start);
+ clear_tv(&tv);
+ goto done;
+ }
+
+ // Add the user-defined type to the script-local variables.
+ tv.v_type = VAR_TYPEALIAS;
+ tv.v_lock = 0;
+ tv.vval.v_typealias = ALLOC_CLEAR_ONE(typealias_T);
+ ++tv.vval.v_typealias->ta_refcount;
+ tv.vval.v_typealias->ta_name = vim_strsave(name_start);
+ tv.vval.v_typealias->ta_type = type;
+ set_var_const(name_start, current_sctx.sc_sid, NULL, &tv, FALSE,
+ ASSIGN_CONST | ASSIGN_FINAL, 0);
+
+done:
+ *name_end = cc;
}
/*
/*
* Generate the load instruction for "name".
*/
- static void
+ static int
generate_loadvar(cctx_T *cctx, lhs_T *lhs)
{
char_u *name = lhs->lhs_name;
type_T *type = lhs->lhs_type;
+ int res = OK;
switch (lhs->lhs_dest)
{
generate_LOAD(cctx, ISN_LOADT, 0, name + 2, type);
break;
case dest_script:
- compile_load_scriptvar(cctx,
+ res = compile_load_scriptvar(cctx,
name + (name[1] == ':' ? 2 : 0), NULL, NULL);
break;
case dest_env:
// list or dict value should already be on the stack.
break;
}
+
+ return res;
}
/*
&& need_type(rhs_type, member_type, FALSE,
-3, 0, cctx, FALSE, FALSE) == FAIL)
return FAIL;
+
+ return OK;
}
- else
- generate_loadvar(cctx, lhs);
- return OK;
+
+ return generate_loadvar(cctx, lhs);
}
/*
return generate_CLASSMEMBER(cctx, TRUE, cl, lhs->lhs_member_idx);
}
- compile_load_lhs(lhs, var_start, NULL, cctx);
+ if (compile_load_lhs(lhs, var_start, NULL, cctx) == FAIL)
+ return FAIL;
if (lhs->lhs_has_index)
{
case VAR_VOID:
case VAR_INSTR:
case VAR_CLASS:
+ case VAR_TYPEALIAS:
case VAR_SPECIAL: // cannot happen
// This is skipped for local variables, they are always
// initialized to zero. But in a "for" or "while" loop
line = (char_u *)"";
break;
+ case CMD_type:
+ emsg(_(e_type_can_only_be_used_in_script));
+ goto erret;
+ break;
+
case CMD_global:
if (check_global_and_subst(ea.cmd, p) == FAIL)
goto erret;
case ISN_STORE:
--ectx->ec_stack.ga_len;
tv = STACK_TV_VAR(iptr->isn_arg.number);
+ if (STACK_TV_BOT(0)->v_type == VAR_TYPEALIAS)
+ {
+ semsg(_(e_using_typealias_as_variable),
+ STACK_TV_BOT(0)->vval.v_typealias->ta_name);
+ clear_tv(STACK_TV_BOT(0));
+ goto on_error;
+ }
clear_tv(tv);
*tv = *STACK_TV_BOT(0);
break;
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
break;
}
return FALSE;
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
case VAR_UNKNOWN:
case VAR_ANY:
case VAR_VOID:
{
svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + idx;
+ if (sv->sv_tv->v_type == VAR_TYPEALIAS)
+ {
+ semsg(_(e_using_typealias_as_variable),
+ sv->sv_tv->vval.v_typealias->ta_name);
+ return FAIL;
+ }
+
generate_VIM9SCRIPT(cctx, ISN_LOADSCRIPT,
current_sctx.sc_sid, idx, sv->sv_type);
return OK;
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
to_string_error(type->tt_type);
return FAIL;
}
}
// It can be a class or interface name, possibly imported.
- typval_T tv;
+ int did_emsg_before = did_emsg;
+ typval_T tv;
+
tv.v_type = VAR_UNKNOWN;
if (eval_variable_import(*arg, &tv) == OK)
{
return type;
}
}
+ else if (tv.v_type == VAR_TYPEALIAS)
+ {
+ // user defined type
+ type_T *type = copy_type(tv.vval.v_typealias->ta_type, type_gap);
+ *arg += len;
+ clear_tv(&tv);
+ // Skip over ".TypeName".
+ while (ASCII_ISALNUM(**arg) || **arg == '_' || **arg == '.')
+ ++*arg;
+ return type;
+ }
clear_tv(&tv);
}
- if (give_error)
+ if (give_error && (did_emsg == did_emsg_before))
semsg(_(e_type_not_recognized_str), *arg);
return NULL;
}
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
+ case VAR_TYPEALIAS:
break; // not composite is always OK
case VAR_LIST:
case VAR_DICT:
case VAR_INSTR: return "instr";
case VAR_CLASS: return "class";
case VAR_OBJECT: return "object";
+ case VAR_TYPEALIAS: return "typealias";
case VAR_FUNC:
case VAR_PARTIAL: return "func";
rettv->v_type = VAR_STRING;
ga_init2(&type_list, sizeof(type_T *), 10);
- type = typval2type(argvars, get_copyID(), &type_list, TVTT_DO_MEMBER);
+ if (argvars[0].v_type == VAR_TYPEALIAS)
+ type = argvars[0].vval.v_typealias->ta_type;
+ else
+ type = typval2type(argvars, get_copyID(), &type_list, TVTT_DO_MEMBER);
name = type_name(type, &tofree);
- if (tofree != NULL)
- rettv->vval.v_string = (char_u *)tofree;
+ if (argvars[0].v_type == VAR_TYPEALIAS)
+ {
+ vim_snprintf((char *)IObuff, IOSIZE, "typealias<%s>", name);
+ rettv->vval.v_string = vim_strsave((char_u *)IObuff);
+ if (tofree != NULL)
+ vim_free(tofree);
+ }
else
- rettv->vval.v_string = vim_strsave((char_u *)name);
+ {
+ if (tofree != NULL)
+ rettv->vval.v_string = (char_u *)tofree;
+ else
+ rettv->vval.v_string = vim_strsave((char_u *)name);
+ }
clear_type_list(&type_list);
}
case VAR_INSTR:
case VAR_CLASS:
case VAR_OBJECT:
- continue;
+ case VAR_TYPEALIAS:
+ continue;
}
fprintf(fp, "!%s\t%s\t", this_var->di_key, s);
if (this_var->di_tv.v_type == VAR_BOOL
projects / thirdparty / vim.git / commitdiff
