Merge pull request #182 from vim-denops/remove-obsolute-functions

Remove obsolute functions

Author: lambdalisue

denops_std/function/_generated.ts

@@ -4632,104 +4632,6 @@ export function match(denops: Denops, ...args: unknown[]): Promise<unknown> {
   return denops.call("match", ...args);
 }
 
-/**
- * 	:let sepidx = match(line, '[.,;: \t]')
- * Vim doesn't have a strcasestr() function.  But you can add
- * "\c" to the pattern to ignore case:
- * 	:let idx = match(haystack, '\cneedle')
- * If {start} is given, the search starts from byte index
- * {start} in a String or item {start} in a |List|.
- * The result, however, is still the index counted from the
- * first character/item.  Example:
- * 	:echo match("testing", "ing", 2)
- * result is again "4".
- * 	:echo match("testing", "ing", 4)
- * result is again "4".
- * 	:echo match("testing", "t", 2)
- * result is "3".
- * For a String, if {start} > 0 then it is like the string starts
- * {start} bytes later, thus "^" will match at {start}.  Except
- * when {count} is given, then it's like matches before the
- * {start} byte are ignored (this is a bit complicated to keep it
- * backwards compatible).
- * For a String, if {start} < 0, it will be set to 0.  For a list
- * the index is counted from the end.
- * If {start} is out of range ({start} > strlen({expr}) for a
- * String or {start} > len({expr}) for a |List|) -1 is returned.
- * When {count} is given use the {count}'th match.  When a match
- * is found in a String the search for the next one starts one
- * character further.  Thus this example results in 1:
- * 	echo match("testing", "..", 0, 2)
- * In a |List| the search continues in the next item.
- * Note that when {count} is added the way {start} works changes,
- * see above.
- * See |pattern| for the patterns that are accepted.
- * The 'ignorecase' option is used to set the ignore-caseness of
- * the pattern.  'smartcase' is NOT used.  The matching is always
- * done like 'magic' is set and 'cpoptions' is empty.
- * Note that a match at the start is preferred, thus when the
- * pattern is using "*" (any number of matches) it tends to find
- * zero matches at the start instead of a number of matches
- * further down in the text.
- * Can also be used as a |method|:
- * 	GetText()->match('word')
- * 	GetList()->match('word')
- */
-export function strpbrk(denops: Denops): Promise<unknown>;
-export function strpbrk(denops: Denops, ...args: unknown[]): Promise<unknown> {
-  return denops.call("strpbrk", ...args);
-}
-
-/**
- * Vim doesn't have a strcasestr() function.  But you can add
- * "\c" to the pattern to ignore case:
- * 	:let idx = match(haystack, '\cneedle')
- * If {start} is given, the search starts from byte index
- * {start} in a String or item {start} in a |List|.
- * The result, however, is still the index counted from the
- * first character/item.  Example:
- * 	:echo match("testing", "ing", 2)
- * result is again "4".
- * 	:echo match("testing", "ing", 4)
- * result is again "4".
- * 	:echo match("testing", "t", 2)
- * result is "3".
- * For a String, if {start} > 0 then it is like the string starts
- * {start} bytes later, thus "^" will match at {start}.  Except
- * when {count} is given, then it's like matches before the
- * {start} byte are ignored (this is a bit complicated to keep it
- * backwards compatible).
- * For a String, if {start} < 0, it will be set to 0.  For a list
- * the index is counted from the end.
- * If {start} is out of range ({start} > strlen({expr}) for a
- * String or {start} > len({expr}) for a |List|) -1 is returned.
- * When {count} is given use the {count}'th match.  When a match
- * is found in a String the search for the next one starts one
- * character further.  Thus this example results in 1:
- * 	echo match("testing", "..", 0, 2)
- * In a |List| the search continues in the next item.
- * Note that when {count} is added the way {start} works changes,
- * see above.
- * See |pattern| for the patterns that are accepted.
- * The 'ignorecase' option is used to set the ignore-caseness of
- * the pattern.  'smartcase' is NOT used.  The matching is always
- * done like 'magic' is set and 'cpoptions' is empty.
- * Note that a match at the start is preferred, thus when the
- * pattern is using "*" (any number of matches) it tends to find
- * zero matches at the start instead of a number of matches
- * further down in the text.
- * Can also be used as a |method|:
- * 	GetText()->match('word')
- * 	GetList()->match('word')
- */
-export function strcasestr(denops: Denops): Promise<unknown>;
-export function strcasestr(
-  denops: Denops,
-  ...args: unknown[]
-): Promise<unknown> {
-  return denops.call("strcasestr", ...args);
-}
-
 /**
  * Defines a pattern to be highlighted in the current window (a
  * "match").  It will be highlighted with {group}.  Returns an
@@ -4912,44 +4814,6 @@ export function matchend(denops: Denops, ...args: unknown[]): Promise<unknown> {
   return denops.call("matchend", ...args);
 }
 
-/**
- * do it with matchend():
- * 	:let span = matchend(line, '[a-zA-Z]')
- * 	:let span = matchend(line, '[^a-zA-Z]')
- * Except that -1 is returned when there are no matches.
- * The {start}, if given, has the same meaning as for |match()|.
- * 	:echo matchend("testing", "ing", 2)
- * results in "7".
- * 	:echo matchend("testing", "ing", 5)
- * result is "-1".
- * When {expr} is a |List| the result is equal to |match()|.
- * Can also be used as a |method|:
- * 	GetText()->matchend('word')
- */
-export function strspn(denops: Denops): Promise<unknown>;
-export function strspn(denops: Denops, ...args: unknown[]): Promise<unknown> {
-  return denops.call("strspn", ...args);
-}
-
-/**
- * do it with matchend():
- * 	:let span = matchend(line, '[a-zA-Z]')
- * 	:let span = matchend(line, '[^a-zA-Z]')
- * Except that -1 is returned when there are no matches.
- * The {start}, if given, has the same meaning as for |match()|.
- * 	:echo matchend("testing", "ing", 2)
- * results in "7".
- * 	:echo matchend("testing", "ing", 5)
- * result is "-1".
- * When {expr} is a |List| the result is equal to |match()|.
- * Can also be used as a |method|:
- * 	GetText()->matchend('word')
- */
-export function strcspn(denops: Denops): Promise<unknown>;
-export function strcspn(denops: Denops, ...args: unknown[]): Promise<unknown> {
-  return denops.call("strcspn", ...args);
-}
-
 /**
  * If {list} is a list of strings, then returns a |List| with all
  * the strings in {list} that fuzzy match {str}. The strings in
@@ -8011,28 +7875,6 @@ export function stridx(denops: Denops, ...args: unknown[]): Promise<unknown> {
   return denops.call("stridx", ...args);
 }
 
-/**
- * stridx() works similar to the C function strstr().  When used
- * with a single character it works similar to strchr().
- * Can also be used as a |method|:
- * 	GetHaystack()->stridx(needle)
- */
-export function strstr(denops: Denops): Promise<unknown>;
-export function strstr(denops: Denops, ...args: unknown[]): Promise<unknown> {
-  return denops.call("strstr", ...args);
-}
-
-/**
- * stridx() works similar to the C function strstr().  When used
- * with a single character it works similar to strchr().
- * Can also be used as a |method|:
- * 	GetHaystack()->stridx(needle)
- */
-export function strchr(denops: Denops): Promise<unknown>;
-export function strchr(denops: Denops, ...args: unknown[]): Promise<unknown> {
-  return denops.call("strchr", ...args);
-}
-
 /**
  * Return {expr} converted to a String.  If {expr} is a Number,
  * Float, String, Blob or a composition of them, then the result
@@ -8171,17 +8013,6 @@ export function strridx(denops: Denops, ...args: unknown[]): Promise<unknown> {
   return denops.call("strridx", ...args);
 }
 
-/**
- * When used with a single character it works similar to the C
- * function strrchr().
- * Can also be used as a |method|:
- * 	GetHaystack()->strridx(needle)
- */
-export function strrchr(denops: Denops): Promise<unknown>;
-export function strrchr(denops: Denops, ...args: unknown[]): Promise<unknown> {
-  return denops.call("strrchr", ...args);
-}
-
 /**
  * The result is a String, which is {string} with all unprintable
  * characters translated into printable characters |'isprint'|.

denops_std/function/vim/_generated.ts

@@ -253,46 +253,6 @@ export function blob2list(
   return denops.call("blob2list", ...args);
 }
 
-/** */
-export function buffer_exists(denops: Denops): Promise<unknown>;
-export function buffer_exists(
-  denops: Denops,
-  ...args: unknown[]
-): Promise<unknown> {
-  return denops.call("buffer_exists", ...args);
-}
-
-/**
- * Obsolete name: buffer_name().
- */
-export function buffer_name(denops: Denops): Promise<unknown>;
-export function buffer_name(
-  denops: Denops,
-  ...args: unknown[]
-): Promise<unknown> {
-  return denops.call("buffer_name", ...args);
-}
-
-/**
- * Obsolete name for bufnr("$"): last_buffer_nr().
- */
-export function buffer_number(denops: Denops): Promise<unknown>;
-export function buffer_number(
-  denops: Denops,
-  ...args: unknown[]
-): Promise<unknown> {
-  return denops.call("buffer_number", ...args);
-}
-
-/** */
-export function last_buffer_nr(denops: Denops): Promise<unknown>;
-export function last_buffer_nr(
-  denops: Denops,
-  ...args: unknown[]
-): Promise<unknown> {
-  return denops.call("last_buffer_nr", ...args);
-}
-
 /**
  * Output {string} as-is, including unprintable characters.
  * This can be used to output a terminal code. For example, to
@@ -350,17 +310,6 @@ export function extendnew(
   return denops.call("extendnew", ...args);
 }
 
-/**
- * Obsolete name: file_readable().
- */
-export function file_readable(denops: Denops): Promise<unknown>;
-export function file_readable(
-  denops: Denops,
-  ...args: unknown[]
-): Promise<unknown> {
-  return denops.call("file_readable", ...args);
-}
-
 /**
  * Like |flatten()| but first make a copy of {list}.
  */
@@ -468,18 +417,6 @@ export function gettext(denops: Denops, ...args: unknown[]): Promise<unknown> {
   return denops.call("gettext", ...args);
 }
 
-/**
- * Can also be used as a |method|:
- * 	GetName()->hlexists()
- */
-export function highlight_exists(denops: Denops): Promise<unknown>;
-export function highlight_exists(
-  denops: Denops,
-  ...args: unknown[]
-): Promise<unknown> {
-  return denops.call("highlight_exists", ...args);
-}
-
 /**
  * Returns a List of all the highlight group attributes.  If the
  * optional {name} is specified, then returns a List with only
@@ -583,19 +520,6 @@ export function hlset(denops: Denops, ...args: unknown[]): Promise<unknown> {
   return denops.call("hlset", ...args);
 }
 
-/**
- * Obsolete name: highlightID().
- * Can also be used as a |method|:
- * 	GetName()->hlID()
- */
-export function highlightID(denops: Denops): Promise<unknown>;
-export function highlightID(
-  denops: Denops,
-  ...args: unknown[]
-): Promise<unknown> {
-  return denops.call("highlightID", ...args);
-}
-
 /**
  * Returns the index of an item in {object} where {expr} is
  * v:true.  {object} must be a |List| or a |Blob|.

scripts/gen-function/parse.ts

@@ -19,18 +19,23 @@ export function parse(content: string): Definition[] {
   content = content.replace(/\n vim:[^\n]*\s*$/, "");
 
   const definitions: Definition[] = [];
+  let last = -1;
   for (const match of content.matchAll(/\*(\w+?)\(\)\*/g)) {
     const fn = match[1];
     const i = match.index ?? 0;
+    if (i < last) {
+      // It is contained previous block
+      continue;
+    }
     const s = content.lastIndexOf("\n", i);
     const ms = regexIndexOf(content, /\n[<>\s]|$/, i);
     const me = regexIndexOf(content, /\n[^<>\s]|$/, ms);
     const e = content.lastIndexOf("\n", me);
     const block = content
       .substring(s, e)
-      .replaceAll(/\*\S+?\*/g, "") // Remove tags
-      .replaceAll(/\s+\n/g, "\n") // Remove trailing '\s'
-      .trim();
+      .replace(/\n<?(?:\s+\*\S+?\*)+\s*$/, "") // Remove next block tag
+      .trimEnd();
+    last = s + block.length;
     definitions.push(parseBlock(fn, block));
   }
   return definitions;
@@ -51,6 +56,11 @@ export function parse(content: string): Definition[] {
  * This function parse content like above and return `Definition`.
  */
 function parseBlock(fn: string, body: string): Definition {
+  // Remove tags
+  body = body.replaceAll(/\*\S+?\*/g, "");
+  // Remove trailing spaces
+  body = body.split("\n").map((v) => v.trimEnd()).join("\n");
+
   // Remove '\n' in {variant} to make {variant} single line (ex. `searchpairpos`)
   body = body.replaceAll(new RegExp(`^(${fn}\\([^)]*?)\\n\\t*`, "gm"), "$1");
   // Append ')' for an invalid {variant}. (ex. `win_id2tabwin` in Neovim)