vim-patch:7.4.941

Problem:    There is no way to ignore case only for tag searches.
Solution:   Add the 'tagcase' option. (Gary Johnson)

0f6562e903

runtime/doc/options.txt

@@ -3404,7 +3404,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 			global
 	Ignore case in search patterns.  Also used when searching in the tags
 	file.
-	Also see 'smartcase'.
+	Also see 'smartcase' and 'tagcase'.
 	Can be overruled by using "\c" or "\C" in the pattern, see
 	|/ignorecase|.
 
@@ -6303,19 +6303,22 @@ A jump table for the options with a short description can be found at |Q_op|.
 <	[The whitespace before and after the '0' must be a single <Tab>]
 
 	When a binary search was done and no match was found in any of the
-	files listed in 'tags', and 'ignorecase' is set or a pattern is used
+	files listed in 'tags', and case is ignored or a pattern is used
 	instead of a normal tag name, a retry is done with a linear search.
 	Tags in unsorted tags files, and matches with different case will only
 	be found in the retry.
 
 	If a tag file indicates that it is case-fold sorted, the second,
-	linear search can be avoided for the 'ignorecase' case.  Use a value
-	of '2' in the "!_TAG_FILE_SORTED" line for this.  A tag file can be
-	case-fold sorted with the -f switch to "sort" in most unices, as in
-	the command: "sort -f -o tags tags".  For "Exuberant ctags" version
-	5.x or higher (at least 5.5) the --sort=foldcase switch can be used
-	for this as well.  Note that case must be folded to uppercase for this
-	to work.
+	linear search can be avoided when case is ignored.  Use a value of '2'
+	in the "!_TAG_FILE_SORTED" line for this.  A tag file can be case-fold
+	sorted with the -f switch to "sort" in most unices, as in the command:
+	"sort -f -o tags tags".  For "Exuberant ctags" version 5.x or higher
+	(at least 5.5) the --sort=foldcase switch can be used for this as
+	well.  Note that case must be folded to uppercase for this to work.
+
+	By default, tag searches are case-sensitive.  Case is ignored when
+	'ignorecase' is set and 'tagcase' is "followic", or when 'tagcase' is
+	"ignore".
 
 	When 'tagbsearch' is off, tags searching is slower when a full match
 	exists, but faster when no full match exists.  Tags in unsorted tags
@@ -6326,6 +6329,16 @@ A jump table for the options with a short description can be found at |Q_op|.
 	This option doesn't affect commands that find all matching tags (e.g.,
 	command-line completion and ":help").
 
+							*'tagcase'* *'tc'*
+'tagcase' 'tc'		string	(default "followic")
+			global or local to buffer |global-local|
+			{not in Vi}
+	This option specifies how case is handled when searching the tags
+	file:
+	   followic	Follow the 'ignorecase' option
+	   ignore	Ignore case
+	   match	Match case
+
 						*'taglength'* *'tl'*
 'taglength' 'tl'	number	(default 0)
 			global

runtime/doc/quickref.txt

@@ -877,6 +877,7 @@ Short explanation of each option:		*option-list*
 'tabline'	  'tal'     custom format for the console tab pages line
 'tabpagemax'	  'tpm'     maximum number of tab pages for |-p| and "tab all"
 'tagbsearch'	  'tbs'     use binary searching in tags files
+'tagcase'	  'tc'      how to handle case when searching in tags files
 'taglength'	  'tl'	    number of significant characters for a tag
 'tagrelative'	  'tr'	    file names in tag file are relative
 'tags'		  'tag'     list of file names used by the tag command

runtime/doc/tagsrch.txt

@@ -84,11 +84,13 @@ changed, to avoid confusion when using ":tnext".  It is changed when using
 ":tag {ident}".
 
 The ignore-case matches are not found for a ":tag" command when the
-'ignorecase' option is off.  They are found when a pattern is used (starting
-with a "/") and for ":tselect", also when 'ignorecase' is off.  Note that
-using ignore-case tag searching disables binary searching in the tags file,
-which causes a slowdown.  This can be avoided by fold-case sorting the tag
-file.  See the 'tagbsearch' option for an explanation.
+'ignorecase' option is off and 'tagcase' is "followic" or when 'tagcase' is
+"match".  They are found when a pattern is used (starting with a "/") and for
+":tselect", also when 'ignorecase' is off and 'tagcase' is "followic" or when
+'tagcase' is "match".  Note that using ignore-case tag searching disables
+binary searching in the tags file, which causes a slowdown.  This can be
+avoided by fold-case sorting the tag file.  See the 'tagbsearch' option for an
+explanation.
 
 ==============================================================================
 2. Tag stack				*tag-stack* *tagstack* *E425*
@@ -418,12 +420,13 @@ file "tags".  It can also be used to access a common tags file.
 The next file in the list is not used when:
 - A matching static tag for the current buffer has been found.
 - A matching global tag has been found.
-This also depends on the 'ignorecase' option.  If it is off, and the tags file
-only has a match without matching case, the next tags file is searched for a
-match with matching case.  If no tag with matching case is found, the first
-match without matching case is used.  If 'ignorecase' is on, and a matching
-global tag with or without matching case is found, this one is used, no
-further tags files are searched.
+This also depends on whether case is ignored.  Case is ignored when
+'ignorecase' is set and 'tagcase' is "followic", or when 'tagcase' is
+"ignore".  If case is not ignored, and the tags file only has a match without
+matching case, the next tags file is searched for a match with matching case.
+If no tag with matching case is found, the first match without matching case
+is used.  If case is ignored, and a matching global tag with or without
+matching case is found, this one is used, no further tags files are searched.
 
 When a tag file name starts with "./", the '.' is replaced with the path of
 the current file.  This makes it possible to use a tags file in the directory
@@ -556,8 +559,10 @@ that indicates if the file was sorted.  When this line is found, Vim uses
 binary searching for the tags file:
 	!_TAG_FILE_SORTED<Tab>1<Tab>{anything} ~
 
-A tag file may be case-fold sorted to avoid a linear search when 'ignorecase'
-is on.  See 'tagbsearch' for details.  The value '2' should be used then:
+A tag file may be case-fold sorted to avoid a linear search when case is
+ignored.  (Case is ignored when 'ignorecase' is set and 'tagcase' is
+"followic", or when 'tagcase' is "ignore".)  See 'tagbsearch' for details.
+The value '2' should be used then:
 	!_TAG_FILE_SORTED<Tab>2<Tab>{anything} ~
 
 The other tag that Vim recognizes, but only when compiled with the

runtime/doc/usr_29.txt

@@ -255,7 +255,8 @@ function.
 
 RELATED ITEMS
 
-You can set 'ignorecase' to make case in tag names be ignored.
+To make case in tag names be ignored, you can set 'ignorecase' while leaving
+'tagcase' as "followic", or set 'tagcase' to "ignore".
 
 The 'tagbsearch' option tells if the tags file is sorted or not.  The default
 is to assume a sorted tags file, which makes a tags search a lot faster, but

runtime/optwin.vim

@@ -289,6 +289,10 @@ call append("$", " \tset tl=" . &tl)
 call append("$", "tags\tlist of file names to search for tags")
 call append("$", "\t(global or local to buffer)")
 call <SID>OptionG("tag", &tag)
+call append("$", "tagcase\thow to handle case when searching in tags files:")
+call append("$", "\t\"followic\" to follow 'ignorecase', \"ignore\" or \"match\"")
+call append("$", "\t(global or local to buffer)")
+call <SID>OptionG("tc", &tc)
 call append("$", "tagrelative\tfile names in a tags file are relative to the tags file")
 call <SID>BinOptionG("tr", &tr)
 call append("$", "tagstack\ta :tag command will use the tagstack")

src/nvim/buffer.c

@@ -1547,6 +1547,7 @@ void free_buf_options(buf_T *buf, int free_p_ff)
   clear_string_option(&buf->b_p_ep);
   clear_string_option(&buf->b_p_path);
   clear_string_option(&buf->b_p_tags);
+  clear_string_option(&buf->b_p_tc);
   clear_string_option(&buf->b_p_dict);
   clear_string_option(&buf->b_p_tsr);
   clear_string_option(&buf->b_p_qe);

src/nvim/buffer_defs.h

@@ -674,6 +674,8 @@ struct file_buffer {
   char_u      *b_p_path;        /* 'path' local value */
   int b_p_ar;                   /* 'autoread' local value */
   char_u      *b_p_tags;        /* 'tags' local value */
+  char_u      *b_p_tc;          ///< 'tagcase' local value
+  unsigned    b_tc_flags;       ///< flags for 'tagcase'
   char_u      *b_p_dict;        /* 'dictionary' local value */
   char_u      *b_p_tsr;         /* 'thesaurus' local value */
   long b_p_ul;                  /* 'undolevels' local value */
@@ -953,9 +955,7 @@ struct window_S {
                                        time through cursupdate() to the
                                        current virtual column */
 
-  /*
-   * the next six are used to update the visual part
-   */
+  // the next seven are used to update the visual part
   char w_old_visual_mode;           /* last known VIsual_mode */
   linenr_T w_old_cursor_lnum;       /* last known end of visual part */
   colnr_T w_old_cursor_fcol;        /* first column for block visual part */

src/nvim/option.c

@@ -2058,6 +2058,7 @@ static void didset_options(void)
   (void)opt_strings_flags(p_vop, p_ssop_values, &vop_flags, true);
   (void)opt_strings_flags(p_fdo, p_fdo_values, &fdo_flags, true);
   (void)opt_strings_flags(p_dy, p_dy_values, &dy_flags, true);
+  (void)opt_strings_flags(p_tc, p_tc_values, &tc_flags, false);
   (void)opt_strings_flags(p_ve, p_ve_values, &ve_flags, true);
   (void)spell_check_msm();
   (void)spell_check_sps();
@@ -2145,6 +2146,7 @@ void check_buf_options(buf_T *buf)
   check_string_option(&buf->b_p_ep);
   check_string_option(&buf->b_p_path);
   check_string_option(&buf->b_p_tags);
+  check_string_option(&buf->b_p_tc);
   check_string_option(&buf->b_p_dict);
   check_string_option(&buf->b_p_tsr);
   check_string_option(&buf->b_p_lw);
@@ -2984,6 +2986,24 @@ did_set_string_option (
     if (opt_strings_flags(p_bo, p_bo_values, &bo_flags, true) != OK) {
       errmsg = e_invarg;
     }
+  } else if (gvarp == &p_tc) {  // 'tagcase'
+    unsigned int *flags;
+
+    if (opt_flags & OPT_LOCAL) {
+      p = curbuf->b_p_tc;
+      flags = &curbuf->b_tc_flags;
+    } else {
+      p = p_tc;
+      flags = &tc_flags;
+    }
+
+    if ((opt_flags & OPT_LOCAL) && *p == NUL) {
+      // make the local value empty: use the global value
+      *flags = 0;
+    } else if (*p == NUL
+               || opt_strings_flags(p, p_tc_values, flags, false) != OK) {
+      errmsg = e_invarg;
+    }
   } else if (varp == &p_cmp) {  // 'casemap'
     if (opt_strings_flags(p_cmp, p_cmp_values, &cmp_flags, true) != OK)
       errmsg = e_invarg;
@@ -5112,6 +5132,10 @@ void unset_global_local_option(char *name, void *from)
     case PV_TAGS:
       clear_string_option(&buf->b_p_tags);
       break;
+    case PV_TC:
+      clear_string_option(&buf->b_p_tc);
+      buf->b_tc_flags = 0;
+      break;
     case PV_DEF:
       clear_string_option(&buf->b_p_def);
       break;
@@ -5165,6 +5189,7 @@ static char_u *get_varp_scope(vimoption_T *p, int opt_flags)
     case PV_PATH: return (char_u *)&(curbuf->b_p_path);
     case PV_AR:   return (char_u *)&(curbuf->b_p_ar);
     case PV_TAGS: return (char_u *)&(curbuf->b_p_tags);
+    case PV_TC:   return (char_u *)&(curbuf->b_p_tc);
     case PV_DEF:  return (char_u *)&(curbuf->b_p_def);
     case PV_INC:  return (char_u *)&(curbuf->b_p_inc);
     case PV_DICT: return (char_u *)&(curbuf->b_p_dict);
@@ -5202,6 +5227,8 @@ static char_u *get_varp(vimoption_T *p)
            ? (char_u *)&(curbuf->b_p_ar) : p->var;
   case PV_TAGS:   return *curbuf->b_p_tags != NUL
            ? (char_u *)&(curbuf->b_p_tags) : p->var;
+  case PV_TC:     return *curbuf->b_p_tc != NUL
+           ? (char_u *)&(curbuf->b_p_tc) : p->var;
   case PV_BKC:    return *curbuf->b_p_bkc != NUL
            ? (char_u *)&(curbuf->b_p_bkc) : p->var;
   case PV_DEF:    return *curbuf->b_p_def != NUL
@@ -5581,6 +5608,8 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_kp = empty_option;
       buf->b_p_path = empty_option;
       buf->b_p_tags = empty_option;
+      buf->b_p_tc = empty_option;
+      buf->b_tc_flags = 0;
       buf->b_p_def = empty_option;
       buf->b_p_inc = empty_option;
       buf->b_p_inex = vim_strsave(p_inex);

src/nvim/option_defs.h

@@ -595,6 +595,14 @@ static char *(p_swb_values[]) =
 #define SWB_NEWTAB              0x008
 #define SWB_VSPLIT              0x010
 EXTERN int p_tbs;               ///< 'tagbsearch'
+EXTERN char_u *p_tc;            ///< 'tagcase'
+EXTERN unsigned tc_flags;       ///< flags from 'tagcase'
+#ifdef IN_OPTION_C
+static char *(p_tc_values[]) = { "followic", "ignore", "match", NULL };
+#endif
+#define TC_FOLLOWIC             0x01
+#define TC_IGNORE               0x02
+#define TC_MATCH                0x04
 EXTERN long p_tl;               ///< 'taglength'
 EXTERN int p_tr;                ///< 'tagrelative'
 EXTERN char_u *p_tags;          ///< 'tags'
@@ -735,6 +743,7 @@ enum {
   , BV_SW
   , BV_SWF
   , BV_TAGS
+  , BV_TC
   , BV_TS
   , BV_TW
   , BV_TX

src/nvim/options.lua

@@ -2331,6 +2331,13 @@ return {
       varname='p_tbs',
       defaults={if_true={vi=true}}
     },
+    {
+      full_name='tagcase', abbreviation='tc',
+      type='string', scope={'global', 'buffer'},
+      vim=true,
+      varname='p_tc',
+      defaults={if_true={vi="followic", vim="followic"}}
+    },
     {
       full_name='taglength', abbreviation='tl',
       type='number', scope={'global'},

src/nvim/tag.c

@@ -1147,6 +1147,22 @@ find_tags (
   int get_it_again = FALSE;
   int use_cscope = (flags & TAG_CSCOPE);
   int verbose = (flags & TAG_VERBOSE);
+  int save_p_ic = p_ic;
+
+  // Change the value of 'ignorecase' according to 'tagcase' for the
+  // duration of this function.
+  switch (curbuf->b_tc_flags ? curbuf->b_tc_flags : tc_flags) {
+    case TC_FOLLOWIC:
+      break;
+    case TC_IGNORE:
+      p_ic = true;
+      break;
+    case TC_MATCH:
+      p_ic = false;
+      break;
+    default:
+      assert(false);
+  }
 
   help_save = curbuf->b_help;
   orgpat.pat = pat;
@@ -1955,6 +1971,8 @@ findtag_end:
   curbuf->b_help = help_save;
   xfree(saved_pat);
 
+  p_ic = save_p_ic;
+
   return retval;
 }
 

src/nvim/testdir/Makefile

@@ -38,6 +38,7 @@ SCRIPTS := \
            test_close_count.out   \
            test_marks.out         \
            test_match_conceal.out \
+           test_tagcase.out       \
 
 NEW_TESTS =
 

src/nvim/testdir/test_tagcase.in

@@ -0,0 +1,55 @@
+Tests for 'tagcase' option
+
+STARTTEST
+:/^start text$/+1,/^end text$/w! Xtext
+:/^start tags$/+1,/^end tags$/-1w! Xtags
+:set tags=Xtags
+:e Xtext
+:"
+:" Verify default values.
+:set ic& | setg tc& | setl tc&
+:call append('$', "ic=".&ic." g:tc=".&g:tc." l:tc=".&l:tc." tc=".&tc)
+:"
+:" Verify that the local setting accepts <empty> but that the global setting
+:" does not.  The first of these (setting the local value to <empty>) should
+:" succeed; the other two should fail.
+:let v:errmsg = ""
+:setl tc=
+:call append('$', v:errmsg)
+:let v:errmsg = ""
+:setg tc=
+:call append('$', v:errmsg)
+:let v:errmsg = ""
+:set tc=
+:call append('$', v:errmsg)
+:"
+:" Verify that the correct number of matching tags is found for all values of
+:" 'ignorecase' and global and local values 'tagcase', in all combinations.
+:for &ic in [0, 1]
+:  for &g:tc in ["followic", "ignore", "match"]
+:    for &l:tc in ["", "followic", "ignore", "match"]
+:      call append('$', "ic=".&ic." g:tc=".&g:tc." l:tc=".&l:tc." tc=".&tc)
+:      call append('$', len(taglist("^foo$")))
+:      call append('$', len(taglist("^Foo$")))
+:    endfor
+:  endfor
+:endfor
+:"
+:1,/^end text$/d
+:w! test.out
+:qa!
+ENDTEST
+
+start text
+
+Foo
+Bar
+foo
+
+end text
+
+start tags
+Bar	Xtext	3
+Foo	Xtext	2
+foo	Xtext	4
+end tags

src/nvim/testdir/test_tagcase.ok

@@ -0,0 +1,76 @@
+ic=0 g:tc=followic l:tc=followic tc=followic
+
+E474: Invalid argument: tc=
+E474: Invalid argument: tc=
+ic=0 g:tc=followic l:tc= tc=followic
+1
+1
+ic=0 g:tc=followic l:tc=followic tc=followic
+1
+1
+ic=0 g:tc=followic l:tc=ignore tc=ignore
+2
+2
+ic=0 g:tc=followic l:tc=match tc=match
+1
+1
+ic=0 g:tc=ignore l:tc= tc=ignore
+2
+2
+ic=0 g:tc=ignore l:tc=followic tc=followic
+1
+1
+ic=0 g:tc=ignore l:tc=ignore tc=ignore
+2
+2
+ic=0 g:tc=ignore l:tc=match tc=match
+1
+1
+ic=0 g:tc=match l:tc= tc=match
+1
+1
+ic=0 g:tc=match l:tc=followic tc=followic
+1
+1
+ic=0 g:tc=match l:tc=ignore tc=ignore
+2
+2
+ic=0 g:tc=match l:tc=match tc=match
+1
+1
+ic=1 g:tc=followic l:tc= tc=followic
+2
+2
+ic=1 g:tc=followic l:tc=followic tc=followic
+2
+2
+ic=1 g:tc=followic l:tc=ignore tc=ignore
+2
+2
+ic=1 g:tc=followic l:tc=match tc=match
+1
+1
+ic=1 g:tc=ignore l:tc= tc=ignore
+2
+2
+ic=1 g:tc=ignore l:tc=followic tc=followic
+2
+2
+ic=1 g:tc=ignore l:tc=ignore tc=ignore
+2
+2
+ic=1 g:tc=ignore l:tc=match tc=match
+1
+1
+ic=1 g:tc=match l:tc= tc=match
+1
+1
+ic=1 g:tc=match l:tc=followic tc=followic
+2
+2
+ic=1 g:tc=match l:tc=ignore tc=ignore
+2
+2
+ic=1 g:tc=match l:tc=match tc=match
+1
+1

src/nvim/version.c

@@ -349,7 +349,7 @@ static int included_patches[] = {
   944,
   // 943 NA
   // 942,
-  // 941,
+  941,
   // 940 NA
   939,
   // 938 NA