From fc4398b4e1d18142a5c428a7c90484071a81ab9c Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Tue, 4 Jul 2023 19:07:30 +0200
Subject: [PATCH 1/7] Filter: Better syntax for function return types

The C-style syntax does not really fit into rest of our syntax.
---
 conf/cf-lex.l    |  1 +
 conf/confbase.Y  |  4 ++--
 doc/bird.sgml    | 16 ++++++++--------
 filter/config.Y  | 30 +++++++++++++++---------------
 filter/f-inst.c  |  2 --
 filter/test.conf | 26 +++++++++++++-------------
 6 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index dcd54b81..cee0e63e 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -380,6 +380,7 @@ else: {
 \>\= return GEQ;
 \&\& return AND;
 \|\| return OR;
+\-\> return IMP;
 
 \[\= return PO;
 \=\] return PC;
diff --git a/conf/confbase.Y b/conf/confbase.Y
index 2efeb29f..7b368fc6 100644
--- a/conf/confbase.Y
+++ b/conf/confbase.Y
@@ -98,7 +98,7 @@ CF_DECLS
 }
 
 %token END CLI_MARKER INVALID_TOKEN ELSECOL DDOT
-%token GEQ LEQ NEQ AND OR
+%token GEQ LEQ NEQ AND OR IMP
 %token PO PC
 %token <i> NUM ENUM
 %token <ip4> IP4
@@ -125,7 +125,7 @@ CF_DECLS
 
 %nonassoc PREFIX_DUMMY
 %left AND OR
-%nonassoc '=' '<' '>' '~' GEQ LEQ NEQ NMA PO PC
+%nonassoc '=' '<' '>' '~' GEQ LEQ NEQ NMA IMP PO PC
 %left '+' '-'
 %left '*' '/' '%'
 %left '!'
diff --git a/doc/bird.sgml b/doc/bird.sgml
index 3fcf0025..3be266cb 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -539,7 +539,7 @@ include "tablename.conf";;
 	Define a filter. You can learn more about filters in the following
 	chapter.
 
-	<tag><label id="opt-function">function <m/type/ <m/name/ (<m/parameters/) <m/local variables/ { <m/commands/ }</tag>
+	<tag><label id="opt-function">function <m/name/ (<m/parameters/) [ -&gt; <m/return type/ ] <m/local variables/ { <m/commands/ }</tag>
 	Define a function. You can learn more about functions in the following chapter.
 
 	<tag><label id="opt-protocol">protocol rip|ospf|bgp|<m/.../ [<m/name/ [from <m/name2/]] { <m>protocol options</m> }</tag>
@@ -1294,21 +1294,21 @@ can group several statements to a single compound statement by using braces
 (<cf>{ <M>statements</M> }</cf>) which is useful if you want to make a bigger
 block of code conditional.
 
-<p>BIRD supports functions, so that you don't have to repeat the same blocks of
-code over and over. Functions can have zero or more parameters and they can have
-local variables. You should always specify the function return type and always
-return it. No-return functions and multiple-type returning functions are deprecated.
-Direct recursion is possible. Function definitions look like this:
+<p>BIRD supports functions, so that you don not have to repeat the same blocks
+of code over and over. Functions can have zero or more parameters and they can
+have local variables. If the function returns value, then you should always
+specify its return type. Direct recursion is possible. Function definitions look
+like this:
 
 <code>
-function int name ()
+function name() -> int
 {
 	int local_variable;
 	int another_variable = 5;
 	return 42;
 }
 
-function pair with_parameters (int parameter)
+function with_parameters(int parameter) -> pair
 {
 	print parameter;
 	return (1, 2);
diff --git a/filter/config.Y b/filter/config.Y
index 7cc6f882..f856924c 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -380,7 +380,7 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 %type <f> filter where_filter
 %type <fl> filter_body function_body
 %type <flv> lvalue
-%type <i> type maybe_type function_vars
+%type <i> type function_vars function_type
 %type <fa> function_argsn function_args
 %type <ecs> ec_kind
 %type <fret> break_command
@@ -513,6 +513,11 @@ function_vars:
    }
  ;
 
+function_type:
+   /* EMPTY */ { $$ = T_VOID; }
+ | IMP type { $$ = $2; }
+ ;
+
 filter_body: function_body ;
 
 filter:
@@ -547,28 +552,23 @@ function_body:
  ;
 
 conf: function_def ;
-maybe_type:
-   /* EMPTY */ { $$ = T_VOID; }
- | type { $$ = $1; }
- ;
 
 function_def:
-   FUNCTION maybe_type symbol {
-     DBG( "Beginning of function %s\n", $3->name );
-     this_function = cf_define_symbol(new_config, $3, SYM_FUNCTION, function, NULL);
-/*   if ($2 == T_VOID) cf_warn("Support for functions without explicit return type will be removed soon" ); */
+   FUNCTION symbol {
+     DBG( "Beginning of function %s\n", $2->name );
+     this_function = cf_define_symbol(new_config, $2, SYM_FUNCTION, function, NULL);
      cf_push_scope(new_config, this_function);
-   } function_args {
+   } function_args function_type {
      /* Make dummy f_line for storing function prototype */
      struct f_line *dummy = cfg_allocz(sizeof(struct f_line));
      this_function->function = dummy;
 
-     dummy->return_type = $2;
+     dummy->return_type = $5;
 
      /* Revert the args */
-     while ($5) {
-       struct f_arg *tmp = $5;
-       $5 = $5->next;
+     while ($4) {
+       struct f_arg *tmp = $4;
+       $4 = $4->next;
 
        tmp->next = dummy->arg_list;
        dummy->arg_list = tmp;
@@ -578,7 +578,7 @@ function_def:
      $7->args = this_function->function->args;
      $7->arg_list = this_function->function->arg_list;
      $7->return_type = this_function->function->return_type;
-     $3->function = $7;
+     $2->function = $7;
      cf_pop_scope(new_config);
    }
  ;
diff --git a/filter/f-inst.c b/filter/f-inst.c
index a9de0960..be22accc 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -1127,8 +1127,6 @@
     NEVER_CONSTANT;
     VARARG;
     SYMBOL;
-
-    /* Fake result type declaration */
     RESULT_TYPE(sym->function->return_type);
 
     FID_NEW_BODY()
diff --git a/filter/test.conf b/filter/test.conf
index 90f5e694..62993898 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -21,17 +21,17 @@ attribute lclist mylclist;
 define one = 1;
 define ten = 10;
 
-function int onef(int a)
+function onef(int a) -> int
 {
 	return 1;
 }
 
-function int twof(int a)
+function twof(int a) -> int
 {
 	return 2;
 }
 
-function int oneg(int a)
+function oneg(int a) -> int
 {
 	return 1;
 }
@@ -274,7 +274,7 @@ bt_test_suite(t_bytestring, "Testing bytestrings");
  * 	-------------
  */
 
-function pair 'mkpair-a'(int a)
+function 'mkpair-a'(int a) -> pair
 {
 	return (1, a);
 }
@@ -749,7 +749,7 @@ bt_test_suite(t_flowspec, "Testing flowspec routes");
  * 	-------------
  */
 
-function bgpmask mkpath(int a; int b)
+function mkpath(int a; int b) -> bgpmask
 {
 	return [= a b 3 2 1 =];
 }
@@ -1432,7 +1432,7 @@ bt_test_suite(t_ec_set, "Testing sets of extended communities");
  * 	-------------------------
  */
 
-function lc mktrip(int a)
+function mktrip(int a) -> lc
 {
 	return (a, 2*a, 3*a);
 }
@@ -1747,7 +1747,7 @@ bt_test_suite(t_define, "Testing defined() function");
  *	 -------------------------
  */
 
-function int callme(int arg1; int arg2)
+function callme(int arg1; int arg2) -> int
 int i;
 {
 	case arg1 {
@@ -1758,12 +1758,12 @@ int i;
 	return 0;
 }
 
-function int callmeagain(int a; int b; int c)
+function callmeagain(int a; int b; int c) -> int
 {
 	return a + b + c;
 }
 
-function int fifteen()
+function fifteen() -> int
 {
 	return 15;
 }
@@ -1796,28 +1796,28 @@ function local_vars(int j)
 	bt_assert(j = 35 && k = 20 && m = 100);
 }
 
-function int factorial(int x)
+function factorial(int x) -> int
 {
 	if x = 0 then return 0;
 	if x = 1 then return 1;
 	else return x * factorial(x - 1);
 }
 
-function int fibonacci(int x)
+function fibonacci(int x) -> int
 {
 	if x = 0 then return 0;
 	if x = 1 then return 1;
 	else return fibonacci(x - 1) + fibonacci(x - 2);
 }
 
-function bgppath hanoi_init(int a; int b)
+function hanoi_init(int a; int b) -> bgppath
 {
 	if b = 0
 	then return +empty+;
 	else return prepend(hanoi_init(a + 1, b - 1), a);
 }
 
-function bgppath hanoi_solve(int n; bgppath h_src; bgppath h_dst; bgppath h_aux; bool x; bool y)
+function hanoi_solve(int n; bgppath h_src; bgppath h_dst; bgppath h_aux; bool x; bool y) -> bgppath
 {
 	# x -> return src or dst
 	# y -> print state

From e4ce88cc50a7af21e0b7042f60abd11e4288c6fe Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Wed, 12 Jul 2023 20:01:03 +0200
Subject: [PATCH 2/7] Filter: Move argument list reversal from function_call to
 var_list

List of arguments for function calls is constructed in reverse and then
reverted. This was done in function_call grammar rule. Do the reverse
directly in var_list grammar rule. This fixes reverse order of arguments
in method calls.
---
 filter/config.Y | 43 +++++++++++++++++++++++++------------------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/filter/config.Y b/filter/config.Y
index f856924c..da96d9e8 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -374,7 +374,7 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 %nonassoc ELSE
 
 %type <xp> cmds_int cmd_prep
-%type <x> term term_bs cmd cmd_var cmds cmds_scoped constant constructor var var_list function_call symbol_value bgp_path_expr bgp_path bgp_path_tail term_dot_method method_name_cont
+%type <x> term term_bs cmd cmd_var cmds cmds_scoped constant constructor var var_list var_list_r function_call symbol_value bgp_path_expr bgp_path bgp_path_tail term_dot_method method_name_cont
 %type <fda> dynamic_attr
 %type <fsa> static_attr
 %type <f> filter where_filter
@@ -807,10 +807,27 @@ constructor:
  ;
 
 
-/* This generates the function_call variable list backwards. */
-var_list: /* EMPTY */ { $$ = NULL; }
+/* This generates the function_call variable list backwards */
+var_list_r:
+   /* EMPTY */ { $$ = NULL; }
  | term { $$ = $1; }
- | var_list ',' term { $$ = $3; $$->next = $1; }
+ | var_list_r ',' term { $$ = $3; $$->next = $1; }
+ ;
+
+var_list: var_list_r
+   {
+     $$ = NULL;
+
+     /* Revert the var_list_r */
+     while ($1) {
+       struct f_inst *tmp = $1;
+       $1 = $1->next;
+
+       tmp->next = $$;
+       $$ = tmp;
+     }
+   }
+ ;
 
 function_call:
    symbol_known '(' var_list ')'
@@ -818,17 +835,7 @@ function_call:
      if ($1->class != SYM_FUNCTION)
        cf_error("You can't call something which is not a function. Really.");
 
-     /* Revert the var_list */
-     struct f_inst *args = NULL;
-     while ($3) {
-       struct f_inst *tmp = $3;
-       $3 = $3->next;
-
-       tmp->next = args;
-       args = tmp;
-     }
-
-     $$ = f_new_inst(FI_CALL, args, $1);
+     $$ = f_new_inst(FI_CALL, $3, $1);
    }
  ;
 
@@ -1020,13 +1027,13 @@ cmd:
  | UNSET '(' dynamic_attr ')' ';' {
      $$ = f_new_inst(FI_EA_UNSET, $3);
    }
- | break_command var_list ';' {
+ | break_command var_list_r ';' {
     $$ = f_print($2, !!$2, $1);
    }
- | PRINT var_list ';' {
+ | PRINT var_list_r ';' {
     $$ = f_print($2, 1, F_NOP);
    }
- | PRINTN var_list ';' {
+ | PRINTN var_list_r ';' {
     $$ = f_print($2, 0, F_NOP);
    }
  | function_call ';' { $$ = f_new_inst(FI_DROP_RESULT, $1); }

From e88695913148ae63e1f8c8ac64f7b039dd3fc286 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Wed, 12 Jul 2023 20:11:34 +0200
Subject: [PATCH 3/7] Filter: Print proper error response in multiple method
 dispatch

When no matching method is found, print an error response containing
position and type of infringing argument and a set of expected types.
---
 filter/data.c   |  1 +
 filter/data.h   |  2 ++
 filter/f-util.c | 86 +++++++++++++++++++++++++++++++++++++++++++++----
 3 files changed, 82 insertions(+), 7 deletions(-)

diff --git a/filter/data.c b/filter/data.c
index 581150a2..deca00e0 100644
--- a/filter/data.c
+++ b/filter/data.c
@@ -27,6 +27,7 @@
 
 static const char * const f_type_str[] = {
   [T_VOID]	= "void",
+  [T_NONE]	= "none",
 
   [T_INT]	= "int",
   [T_BOOL]	= "bool",
diff --git a/filter/data.h b/filter/data.h
index e136b65f..6420d373 100644
--- a/filter/data.h
+++ b/filter/data.h
@@ -20,6 +20,8 @@ enum f_type {
 /* Nothing. Simply nothing. */
   T_VOID = 0,
 
+  T_NONE = 1,		/* Special hack to represent missing arguments */
+
 /* User visible types, which fit in int */
   T_INT = 0x10,
   T_BOOL = 0x11,
diff --git a/filter/f-util.c b/filter/f-util.c
index 7ce3f9c8..e980cef5 100644
--- a/filter/f-util.c
+++ b/filter/f-util.c
@@ -45,25 +45,97 @@ f_new_where(struct f_inst *where)
 static inline int
 f_match_signature(const struct f_method *dsc, struct f_inst *args)
 {
-  uint i;
+  int i, arg_num = (int) dsc->arg_num;
 
-  for (i = 1; args && (i < dsc->arg_num); args = args->next, i++)
+  for (i = 1; args && (i < arg_num); args = args->next, i++)
     if (dsc->args_type[i] && (args->type != dsc->args_type[i]))
       return 0;
 
-  return !args && !(i < dsc->arg_num);
+  return !args && !(i < arg_num);
+}
+
+/* Variant of f_match_signature(), optimized for error reporting */
+static inline void
+f_match_signature_err(const struct f_method *dsc, struct f_inst *args, int *pos, int *want, int *got)
+{
+  int i, arg_num = (int) dsc->arg_num;
+
+  for (i = 1; args && (i < arg_num); args = args->next, i++)
+    if (dsc->args_type[i] && (args->type != dsc->args_type[i]))
+      break;
+
+  *pos = i;
+  *want = (i < arg_num) ? dsc->args_type[i] : T_NONE;
+  *got = args ? args->type : T_NONE;
 }
 
 struct f_inst *
 f_dispatch_method(struct symbol *sym, struct f_inst *obj, struct f_inst *args)
 {
-  /* Note! We should revert args */
-
+  /* Find match */
   for (const struct f_method *dsc = sym->method; dsc; dsc = dsc->next)
     if (f_match_signature(dsc, args))
       return dsc->new_inst(obj, args);
 
-  cf_error("Cannot dispatch method '%s'", sym->name);
+
+  /* No valid match - format error message */
+
+  int best_pos = -1;	/* Longest argument position with partial match */
+  int best_got = 0;	/* Received type at best partial match position */
+  int best_count = 0;	/* Number of partial matches at best position */
+  const int best_max = 8;	/* Max number of reported types */
+  int best_want[best_max];	/* Expected types at best position */
+
+  for (const struct f_method *dsc = sym->method; dsc; dsc = dsc->next)
+  {
+    int pos, want, got;
+    f_match_signature_err(dsc, args, &pos, &want, &got);
+
+    /* Ignore shorter match */
+    if (pos < best_pos)
+      continue;
+
+    /* Found longer match, reset existing results */
+    if (pos > best_pos)
+    {
+      best_pos = pos;
+      best_got = got;
+      best_count = 0;
+    }
+
+    /* Skip duplicates */
+    for (int i = 0; i < best_count; i++)
+      if (best_want[i] == want)
+	goto next;
+
+    /* Skip if we have enough types */
+    if (best_count >= best_max)
+      continue;
+
+    /* Add new expected type */
+    best_want[best_count] = want;
+    best_count++;
+  next:;
+  }
+
+  /* There is at least one method */
+  ASSERT(best_pos >= 0 && best_count > 0);
+
+  /* TODO: Here fix best_pos */
+
+  if (!best_got)
+    cf_error("Cannot infer type of argument %d of '%s', please assign it to a variable", best_pos, sym->name);
+
+  /* Format list of expected types */
+  buffer tbuf;
+  STACK_BUFFER_INIT(tbuf, 128);
+  for (int i = 0; i < best_count; i++)
+    buffer_print(&tbuf, " / %s", best_want[i] ? f_type_name(best_want[i]) : "any");
+  char *types = tbuf.start + 3;
+  char *dots = (best_count >= best_max) || (tbuf.pos == tbuf.end) ? " / ..." : "";
+
+  cf_error("Argument %d of '%s' expected %s%s, got %s",
+	   best_pos, sym->name, types, dots, f_type_name(best_got));
 }
 
 struct f_inst *
@@ -87,7 +159,7 @@ f_for_cycle(struct symbol *var, struct f_inst *term, struct f_inst *block)
 
   /* Static type check */
   if (term->type == T_VOID)
-    cf_error("Couldn't infer the type of FOR expression, please assign it to a variable.");
+    cf_error("Cannot infer type of FOR expression, please assign it to a variable");
 
   enum f_type el_type = f_type_element_type(term->type);
   struct sym_scope *scope = el_type ? f_type_method_scope(term->type) : NULL;

From f0d1396073dc7c3a6ab5f88baa07f2494cbd5328 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Tue, 25 Jul 2023 17:43:52 +0200
Subject: [PATCH 4/7] Filter: Implement constant promotion for multiple
 dispatch methods

---
 filter/decl.m4  | 19 +++++++++++--------
 filter/f-inst.h | 10 ++++++++++
 filter/f-util.c |  6 ++++--
 3 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/filter/decl.m4 b/filter/decl.m4
index 217488ec..57bf9454 100644
--- a/filter/decl.m4
+++ b/filter/decl.m4
@@ -379,7 +379,8 @@ m4_undivert(102)m4_dnl
 [[m4_dnl				 The one case in The Big Switch inside interpreter
   case INST_NAME():
   #define whati (&(what->i_]]INST_NAME()[[))
-  m4_ifelse(m4_eval(INST_INVAL() > 0), 1, [[if (fstk->vcnt < INST_INVAL()) runtime("Stack underflow"); fstk->vcnt -= INST_INVAL(); ]])
+  m4_ifelse(m4_eval(INST_INVAL() > 0), 1, [[if (fstk->vcnt < INST_INVAL()) runtime("Stack underflow");
+  fstk->vcnt -= INST_INVAL();]])
   m4_undivert(108)m4_dnl
   #undef whati
   break;
@@ -572,8 +573,8 @@ fi_constant(struct f_inst *what, struct f_val val)
   return what;
 }
 
-static int
-f_const_promotion(struct f_inst *arg, enum f_type want)
+int
+f_const_promotion_(struct f_inst *arg, enum f_type want, int update)
 {
   if (arg->fi_code != FI_CONSTANT)
     return 0;
@@ -581,15 +582,17 @@ f_const_promotion(struct f_inst *arg, enum f_type want)
   struct f_val *c = &arg->i_FI_CONSTANT.val;
 
   if ((c->type == T_IP) && ipa_is_ip4(c->val.ip) && (want == T_QUAD)) {
-    *c = (struct f_val) {
-      .type = T_QUAD,
-      .val.i = ipa_to_u32(c->val.ip),
-    };
+    if (update)
+      *c = (struct f_val) {
+        .type = T_QUAD,
+        .val.i = ipa_to_u32(c->val.ip),
+      };
     return 1;
   }
 
   else if ((c->type == T_SET) && (!c->val.t) && (want == T_PREFIX_SET)) {
-    *c = f_const_empty_prefix_set;
+    if (update)
+      *c = f_const_empty_prefix_set;
     return 1;
   }
 
diff --git a/filter/f-inst.h b/filter/f-inst.h
index f5dfcd20..e8147e26 100644
--- a/filter/f-inst.h
+++ b/filter/f-inst.h
@@ -36,6 +36,16 @@ const char *f_instruction_name_(enum f_instruction_code fi);
 static inline const char *f_instruction_name(enum f_instruction_code fi)
 { return f_instruction_name_(fi) + 3; }
 
+
+int f_const_promotion_(struct f_inst *arg, enum f_type want, int update);
+
+static inline int f_const_promotion(struct f_inst *arg, enum f_type want)
+{ return f_const_promotion_(arg, want, 1); }
+
+static inline int f_try_const_promotion(struct f_inst *arg, enum f_type want)
+{ return f_const_promotion_(arg, want, 0); }
+
+
 struct f_arg {
   struct symbol *arg;
   struct f_arg *next;
diff --git a/filter/f-util.c b/filter/f-util.c
index e980cef5..768ee83b 100644
--- a/filter/f-util.c
+++ b/filter/f-util.c
@@ -48,7 +48,8 @@ f_match_signature(const struct f_method *dsc, struct f_inst *args)
   int i, arg_num = (int) dsc->arg_num;
 
   for (i = 1; args && (i < arg_num); args = args->next, i++)
-    if (dsc->args_type[i] && (args->type != dsc->args_type[i]))
+    if (dsc->args_type[i] && (args->type != dsc->args_type[i]) &&
+	!f_try_const_promotion(args, dsc->args_type[i]))
       return 0;
 
   return !args && !(i < arg_num);
@@ -61,7 +62,8 @@ f_match_signature_err(const struct f_method *dsc, struct f_inst *args, int *pos,
   int i, arg_num = (int) dsc->arg_num;
 
   for (i = 1; args && (i < arg_num); args = args->next, i++)
-    if (dsc->args_type[i] && (args->type != dsc->args_type[i]))
+    if (dsc->args_type[i] && (args->type != dsc->args_type[i]) &&
+	!f_try_const_promotion(args, dsc->args_type[i]))
       break;
 
   *pos = i;

From 132f1edaf402aba79ae3983966795b2f1220afbb Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Tue, 25 Jul 2023 19:33:51 +0200
Subject: [PATCH 5/7] Filter: Split clist add/delete operations to multiple
 methods

---
 filter/f-inst.c  | 99 +++++++++++++++++++++++++++++++++++-------------
 filter/test.conf | 12 ++++++
 2 files changed, 84 insertions(+), 27 deletions(-)

diff --git a/filter/f-inst.c b/filter/f-inst.c
index be22accc..f24e6219 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -1245,22 +1245,39 @@
   }
 
   /* Community list add */
-  INST(FI_CLIST_ADD, 2, 1) {
+  INST(FI_CLIST_ADD_PAIR, 2, 1) {
     ARG(1, T_CLIST);
-    ARG_ANY(2);
+    ARG(2, T_PAIR);
     METHOD_CONSTRUCTOR("add");
-      struct f_val dummy;
-      if ((v2.type == T_PAIR) || (v2.type == T_QUAD))
-	RESULT(T_CLIST, ad, [[ int_set_add(fpool, v1.val.ad, v2.val.i) ]]);
-      /* IP->Quad implicit conversion */
-      else if (val_is_ip4(&v2))
-	RESULT(T_CLIST, ad, [[ int_set_add(fpool, v1.val.ad, ipa_to_u32(v2.val.ip)) ]]);
-      else if ((v2.type == T_SET) && clist_set_type(v2.val.t, &dummy))
-	runtime("Can't add set");
-      else if (v2.type == T_CLIST)
-	RESULT(T_CLIST, ad, [[ int_set_union(fpool, v1.val.ad, v2.val.ad) ]]);
-      else
-	runtime("Can't add non-pair");
+    RESULT(T_CLIST, ad, [[ int_set_add(fpool, v1.val.ad, v2.val.i) ]]);
+  }
+
+  INST(FI_CLIST_ADD_IP, 2, 1) {
+    ARG(1, T_CLIST);
+    ARG(2, T_IP);
+    METHOD_CONSTRUCTOR("add");
+
+    FID_NEW_BODY();
+    /* IP->Quad implicit conversion, must be before FI_CLIST_ADD_QUAD */
+    cf_warn("Method add(clist, ip) is deprecated, please use add(clist, quad)");
+
+    FID_INTERPRET_BODY();
+    if (!val_is_ip4(&v2)) runtime("Mismatched IP type");
+    RESULT(T_CLIST, ad, [[ int_set_add(fpool, v1.val.ad, ipa_to_u32(v2.val.ip)) ]]);
+  }
+
+  INST(FI_CLIST_ADD_QUAD, 2, 1) {
+    ARG(1, T_CLIST);
+    ARG(2, T_QUAD);
+    METHOD_CONSTRUCTOR("add");
+    RESULT(T_CLIST, ad, [[ int_set_add(fpool, v1.val.ad, v2.val.i) ]]);
+  }
+
+  INST(FI_CLIST_ADD_CLIST, 2, 1) {
+    ARG(1, T_CLIST);
+    ARG(2, T_CLIST);
+    METHOD_CONSTRUCTOR("add");
+    RESULT(T_CLIST, ad, [[ int_set_union(fpool, v1.val.ad, v2.val.ad) ]]);
   }
 
   INST(FI_ECLIST_ADD_EC, 2, 1) {
@@ -1310,22 +1327,50 @@
   }
 
   /* Community list delete */
-  INST(FI_CLIST_DELETE, 2, 1) {
+  INST(FI_CLIST_DELETE_PAIR, 2, 1) {
     ARG(1, T_CLIST);
-    ARG_ANY(2);
+    ARG(2, T_PAIR);
     METHOD_CONSTRUCTOR("delete");
-      /* Community (or cluster) list */
-      struct f_val dummy;
+    RESULT(T_CLIST, ad, [[ int_set_del(fpool, v1.val.ad, v2.val.i) ]]);
+  }
 
-      if ((v2.type == T_PAIR) || (v2.type == T_QUAD))
-	RESULT(T_CLIST, ad, [[ int_set_del(fpool, v1.val.ad, v2.val.i) ]]);
-      /* IP->Quad implicit conversion */
-      else if (val_is_ip4(&v2))
-	RESULT(T_CLIST, ad, [[ int_set_del(fpool, v1.val.ad, ipa_to_u32(v2.val.ip)) ]]);
-      else if ((v2.type == T_SET) && clist_set_type(v2.val.t, &dummy) || (v2.type == T_CLIST))
-	RESULT(T_CLIST, ad, [[ clist_filter(fpool, v1.val.ad, &v2, 0) ]]);
-      else
-	runtime("Can't delete non-pair");
+  INST(FI_CLIST_DELETE_IP, 2, 1) {
+    ARG(1, T_CLIST);
+    ARG(2, T_IP);
+    METHOD_CONSTRUCTOR("delete");
+
+    FID_NEW_BODY();
+    /* IP->Quad implicit conversion, must be before FI_CLIST_DELETE_QUAD */
+    cf_warn("Method delete(clist, ip) is deprecated, please use delete(clist, quad)");
+
+    FID_INTERPRET_BODY();
+    if (!val_is_ip4(&v2)) runtime("Mismatched IP type");
+    RESULT(T_CLIST, ad, [[ int_set_del(fpool, v1.val.ad, ipa_to_u32(v2.val.ip)) ]]);
+  }
+
+  INST(FI_CLIST_DELETE_QUAD, 2, 1) {
+    ARG(1, T_CLIST);
+    ARG(2, T_QUAD);
+    METHOD_CONSTRUCTOR("delete");
+    RESULT(T_CLIST, ad, [[ int_set_del(fpool, v1.val.ad, v2.val.i) ]]);
+  }
+
+  INST(FI_CLIST_DELETE_CLIST, 2, 1) {
+    ARG(1, T_CLIST);
+    ARG(2, T_CLIST);
+    METHOD_CONSTRUCTOR("delete");
+    RESULT(T_CLIST, ad, [[ clist_filter(fpool, v1.val.ad, &v2, 0) ]]);
+  }
+
+  INST(FI_CLIST_DELETE_SET, 2, 1) {
+    ARG(1, T_CLIST);
+    ARG(2, T_SET);
+    METHOD_CONSTRUCTOR("delete");
+
+    if (!clist_set_type(v2.val.t, &(struct f_val){}))
+      runtime("Mismatched set type");
+
+    RESULT(T_CLIST, ad, [[ clist_filter(fpool, v1.val.ad, &v2, 0) ]]);
   }
 
   INST(FI_ECLIST_DELETE_EC, 2, 1) {
diff --git a/filter/test.conf b/filter/test.conf
index 62993898..22b4984a 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -1010,6 +1010,12 @@ clist r;
 	l = filter(l2, [(3,1..4)]);
 	l2 = filter(l2, [(3,3..6)]);
 
+	quad q = 2.0.1.0;
+	clist ql = add(add(add(-empty-, 1.0.0.1), q), 3.1.0.0);
+	bt_assert(delete(ql, 1.0.0.1) = add(add(-empty-, 2.0.1.0), 3.1.0.0));
+	bt_assert(delete(ql, [2.0.0.0 .. 4.0.0.0]) = add(-empty-, 1.0.0.1));
+	bt_assert(filter(ql, [3.0.0.0 .. 4.0.0.0]) = add(-empty-, 3.1.0.0));
+
 	#  clist A (10,20,30)
 	bt_assert(l = add(add(add(add(-empty-, (3,1)), (3,2)), (3,3)), (3,4)));
 	bt_assert(format(l) = "(clist (3,1) (3,2) (3,3) (3,4))");
@@ -1132,6 +1138,12 @@ function t_clist_new()
 	l = l2.filter([(3,1..4)]);
 	l2.filter([(3,3..6)]);
 
+	quad q = 2.0.1.0;
+	clist ql = -empty-.add(1.0.0.1).add(q).add(3.1.0.0);
+	bt_assert(delete(ql, 1.0.0.1) = -empty-.add(2.0.1.0).add(3.1.0.0));
+	bt_assert(delete(ql, [2.0.0.0 .. 4.0.0.0]) = -empty-.add(1.0.0.1));
+	bt_assert(filter(ql, [3.0.0.0 .. 4.0.0.0]) = -empty-.add(3.1.0.0));
+
 	#  clist A (10,20,30)
 	bt_assert(l = -empty-.add((3,1)).add((3,2)).add((3,3)).add((3,4)));
 	bt_assert(format(l) = "(clist (3,1) (3,2) (3,3) (3,4))");

From 7395b97daf529cab1065f107c924bed310a8ad75 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Tue, 12 Sep 2023 18:44:20 +0200
Subject: [PATCH 6/7] Filter: Minor updates to methods

Remove warning when function-like syntax is used for calling
add/remove/... methods.

Fix argument offset in error messages for function-like syntax.
---
 filter/config.Y | 21 ++++++---------------
 filter/f-inst.h |  2 +-
 filter/f-util.c |  7 ++++---
 3 files changed, 11 insertions(+), 19 deletions(-)

diff --git a/filter/config.Y b/filter/config.Y
index da96d9e8..dc4d75ed 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -876,12 +876,12 @@ static_attr:
 term_dot_method: term '.' { f_method_call_start($1); } method_name_cont { f_method_call_end(); $$ = $4; };
 method_name_cont:
    CF_SYM_METHOD_BARE {
-     $$ = f_dispatch_method($1, FM.object, NULL);
+     $$ = f_dispatch_method($1, FM.object, NULL, 1);
    }
  | CF_SYM_METHOD_ARGS {
      f_method_call_args();
    } '(' var_list ')' {
-     $$ = f_dispatch_method($1, FM.object, $4);
+     $$ = f_dispatch_method($1, FM.object, $4, 1);
    }
  ;
 
@@ -918,19 +918,10 @@ term:
  | '-' EMPTY '-' { $$ = f_const_empty(T_CLIST); }
  | '-' '-' EMPTY '-' '-' { $$ = f_const_empty(T_ECLIST); }
  | '-' '-' '-' EMPTY '-' '-' '-' { $$ = f_const_empty(T_LCLIST); }
- | PREPEND '(' term ',' term ')' { $$ = f_new_inst(FI_PATH_PREPEND, $3, $5); }
- | ADD '(' term ',' term ')' {
-     $$ = f_dispatch_method_x("add", $3->type, $3, $5);
-     cf_warn("add(x,y) function is deprecated, please use x.add(y)");
-   }
- | DELETE '(' term ',' term ')' {
-     $$ = f_dispatch_method_x("delete", $3->type, $3, $5);
-     cf_warn("delete(x,y) function is deprecated, please use x.delete(y)");
-   }
- | FILTER '(' term ',' term ')' {
-     $$ = f_dispatch_method_x("filter", $3->type, $3, $5);
-     cf_warn("filter(x,y) function is deprecated, please use x.filter(y)");
-   }
+ | PREPEND '(' term ',' term ')' { $$ = f_dispatch_method_x("prepend", $3->type, $3, $5); }
+ | ADD '(' term ',' term ')' { $$ = f_dispatch_method_x("add", $3->type, $3, $5); }
+ | DELETE '(' term ',' term ')' { $$ = f_dispatch_method_x("delete", $3->type, $3, $5); }
+ | FILTER '(' term ',' term ')' { $$ = f_dispatch_method_x("filter", $3->type, $3, $5); }
 
  | ROA_CHECK '(' rtable ')' { $$ = f_new_inst(FI_ROA_CHECK_IMPLICIT, $3); }
  | ROA_CHECK '(' rtable ',' term ',' term ')' { $$ = f_new_inst(FI_ROA_CHECK_EXPLICIT, $5, $7, $3); }
diff --git a/filter/f-inst.h b/filter/f-inst.h
index e8147e26..2bde6378 100644
--- a/filter/f-inst.h
+++ b/filter/f-inst.h
@@ -106,7 +106,7 @@ void f_add_lines(const struct f_line_item *what, struct filter_iterator *fit);
 
 
 struct filter *f_new_where(struct f_inst *);
-struct f_inst *f_dispatch_method(struct symbol *sym, struct f_inst *obj, struct f_inst *args);
+struct f_inst *f_dispatch_method(struct symbol *sym, struct f_inst *obj, struct f_inst *args, int skip);
 struct f_inst *f_dispatch_method_x(const char *name, enum f_type t, struct f_inst *obj, struct f_inst *args);
 struct f_inst *f_for_cycle(struct symbol *var, struct f_inst *term, struct f_inst *block);
 struct f_inst *f_print(struct f_inst *vars, int flush, enum filter_return fret);
diff --git a/filter/f-util.c b/filter/f-util.c
index 768ee83b..d589927a 100644
--- a/filter/f-util.c
+++ b/filter/f-util.c
@@ -72,7 +72,7 @@ f_match_signature_err(const struct f_method *dsc, struct f_inst *args, int *pos,
 }
 
 struct f_inst *
-f_dispatch_method(struct symbol *sym, struct f_inst *obj, struct f_inst *args)
+f_dispatch_method(struct symbol *sym, struct f_inst *obj, struct f_inst *args, int skip)
 {
   /* Find match */
   for (const struct f_method *dsc = sym->method; dsc; dsc = dsc->next)
@@ -123,7 +123,8 @@ f_dispatch_method(struct symbol *sym, struct f_inst *obj, struct f_inst *args)
   /* There is at least one method */
   ASSERT(best_pos >= 0 && best_count > 0);
 
-  /* TODO: Here fix best_pos */
+  /* Update best_pos for printing */
+  best_pos = best_pos - skip + 1;
 
   if (!best_got)
     cf_error("Cannot infer type of argument %d of '%s', please assign it to a variable", best_pos, sym->name);
@@ -149,7 +150,7 @@ f_dispatch_method_x(const char *name, enum f_type t, struct f_inst *obj, struct
   if (!sym)
     cf_error("Cannot dispatch method '%s'", name);
 
-  return f_dispatch_method(sym, obj, args);
+  return f_dispatch_method(sym, obj, args, 0);
 }
 
 

From a3dc26455d125310ddf3c903208b0168dbbd81d4 Mon Sep 17 00:00:00 2001
From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Wed, 13 Sep 2023 06:21:26 +0200
Subject: [PATCH 7/7] Filter: Use common initializer for undefined variables
 and eattrs.

Undefined paths and clists should use typed f_val with empty adata
instead of just void f_val. Use common initializer to handle both
variables and eattrs.
---
 filter/config.Y | 28 ++++++----------------------
 filter/data.h   | 20 +++++++++++++++++++-
 filter/f-inst.c | 31 +++----------------------------
 3 files changed, 28 insertions(+), 51 deletions(-)

diff --git a/filter/config.Y b/filter/config.Y
index dc4d75ed..a87fb0e5 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -244,23 +244,6 @@ f_new_lc_item(u32 f1, u32 t1, u32 f2, u32 t2, u32 f3, u32 t3)
   return t;
 }
 
-static inline struct f_inst *
-f_const_empty(enum f_type t)
-{
-  switch (t) {
-    case T_PATH:
-    case T_CLIST:
-    case T_ECLIST:
-    case T_LCLIST:
-      return f_new_inst(FI_CONSTANT, (struct f_val) {
-	.type = t,
-	.val.ad = &null_adata,
-      });
-    default:
-      return f_new_inst(FI_CONSTANT, (struct f_val) {});
-  }
-}
-
 /*
  * Remove all new lines and doubled whitespaces
  * and convert all tabulators to spaces
@@ -914,11 +897,12 @@ term:
 
  | term_dot_method
 
- | '+' EMPTY '+' { $$ = f_const_empty(T_PATH); }
- | '-' EMPTY '-' { $$ = f_const_empty(T_CLIST); }
- | '-' '-' EMPTY '-' '-' { $$ = f_const_empty(T_ECLIST); }
- | '-' '-' '-' EMPTY '-' '-' '-' { $$ = f_const_empty(T_LCLIST); }
- | PREPEND '(' term ',' term ')' { $$ = f_dispatch_method_x("prepend", $3->type, $3, $5); }
+ | '+' EMPTY '+' { $$ = f_new_inst(FI_CONSTANT, val_empty(T_PATH)); }
+ | '-' EMPTY '-' { $$ = f_new_inst(FI_CONSTANT, val_empty(T_CLIST)); }
+ | '-' '-' EMPTY '-' '-' { $$ = f_new_inst(FI_CONSTANT, val_empty(T_ECLIST)); }
+ | '-' '-' '-' EMPTY '-' '-' '-' { $$ = f_new_inst(FI_CONSTANT, val_empty(T_LCLIST)); }
+
+| PREPEND '(' term ',' term ')' { $$ = f_dispatch_method_x("prepend", $3->type, $3, $5); }
  | ADD '(' term ',' term ')' { $$ = f_dispatch_method_x("add", $3->type, $3, $5); }
  | DELETE '(' term ',' term ')' { $$ = f_dispatch_method_x("delete", $3->type, $3, $5); }
  | FILTER '(' term ',' term ')' { $$ = f_dispatch_method_x("filter", $3->type, $3, $5); }
diff --git a/filter/data.h b/filter/data.h
index 6420d373..574b4a1b 100644
--- a/filter/data.h
+++ b/filter/data.h
@@ -318,14 +318,32 @@ const struct adata *lclist_filter(struct linpool *pool, const struct adata *list
 
 
 /* Special undef value for paths and clists */
+
 static inline int
-undef_value(struct f_val v)
+val_is_undefined(struct f_val v)
 {
   return ((v.type == T_PATH) || (v.type == T_CLIST) ||
 	  (v.type == T_ECLIST) || (v.type == T_LCLIST)) &&
     (v.val.ad == &null_adata);
 }
 
+static inline struct f_val
+val_empty(enum f_type t)
+{
+  switch (t)
+  {
+  case T_PATH:
+  case T_CLIST:
+  case T_ECLIST:
+  case T_LCLIST:
+    return (struct f_val) { .type = t, .val.ad = &null_adata };
+
+  default:
+    return (struct f_val) { };
+  }
+}
+
+
 extern const struct f_val f_const_empty_prefix_set;
 
 enum filter_return f_eval(const struct f_line *expr, struct linpool *tmp_pool, struct f_val *pres);
diff --git a/filter/f-inst.c b/filter/f-inst.c
index f24e6219..104a05f1 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -493,7 +493,7 @@
 
   INST(FI_DEFINED, 1, 1) {
     ARG_ANY(1);
-    RESULT(T_BOOL, i, (v1.type != T_VOID) && !undef_value(v1));
+    RESULT(T_BOOL, i, (v1.type != T_VOID) && !val_is_undefined(v1));
   }
 
   METHOD_R(T_NET, type, T_ENUM_NETTYPE, i, v1.val.net->type);
@@ -519,7 +519,7 @@
 
     /* New variable is always the last on stack */
     uint pos = curline.vbase + sym->offset;
-    fstk->vstk[pos] = (struct f_val) { };
+    fstk->vstk[pos] = val_empty(sym->class & 0xff);
     fstk->vcnt = pos + 1;
   }
 
@@ -806,32 +806,7 @@
       eattr *e = ea_find(*fs->eattrs, da.ea_code);
 
       if (!e) {
-	/* A special case: undefined as_path looks like empty as_path */
-	if (da.type == EAF_TYPE_AS_PATH) {
-	  RESULT_(T_PATH, ad, &null_adata);
-	  break;
-	}
-
-	/* The same special case for int_set */
-	if (da.type == EAF_TYPE_INT_SET) {
-	  RESULT_(T_CLIST, ad, &null_adata);
-	  break;
-	}
-
-	/* The same special case for ec_set */
-	if (da.type == EAF_TYPE_EC_SET) {
-	  RESULT_(T_ECLIST, ad, &null_adata);
-	  break;
-	}
-
-	/* The same special case for lc_set */
-	if (da.type == EAF_TYPE_LC_SET) {
-	  RESULT_(T_LCLIST, ad, &null_adata);
-	  break;
-	}
-
-	/* Undefined value */
-	RESULT_VOID;
+	RESULT_VAL(val_empty(da.f_type));
 	break;
       }