diff --git a/runtime/doc/autocmd.txt b/runtime/doc/autocmd.txt
index b0d7919..d56f211 100644
--- a/runtime/doc/autocmd.txt
+++ b/runtime/doc/autocmd.txt
@@ -1,4 +1,4 @@
-*autocmd.txt*   For Vim version 8.2.  Last change: 2020 Jun 10
+*autocmd.txt*   For Vim version 8.2.  Last change: 2020 Aug 02
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -1425,8 +1425,8 @@
 :aug[roup]! {name}		Delete the autocmd group {name}.  Don't use
 				this if there is still an autocommand using
 				this group!  You will get a warning if doing
-				it anyway. when the group is the current group
-				you will get error E936.
+				it anyway.  When the group is the current
+				group you will get error E936.
 
 To enter autocommands for a specific group, use this method:
 1. Select the group with ":augroup {name}".
diff --git a/runtime/doc/develop.txt b/runtime/doc/develop.txt
index 7ed251a..f139ebe 100644
--- a/runtime/doc/develop.txt
+++ b/runtime/doc/develop.txt
@@ -1,4 +1,4 @@
-*develop.txt*   For Vim version 8.2.  Last change: 2020 Apr 13
+*develop.txt*   For Vim version 8.2.  Last change: 2020 Jul 27
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -34,8 +34,8 @@
 VIM IS... VI COMPATIBLE					*design-compatible*
 
 First of all, it should be possible to use Vim as a drop-in replacement for
-Vi.  When the user wants to, he can use Vim in compatible mode and hardly
-notice any difference with the original Vi.
+Vi.  When the user wants to, Vim can be used in compatible mode and hardly
+any differences with the original Vi will be noticed.
 
 Exceptions:
 - We don't reproduce obvious Vi bugs in Vim.
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 8c6f7de..5bb763a 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -1,4 +1,4 @@
-*eval.txt*	For Vim version 8.2.  Last change: 2020 Aug 01
+*eval.txt*	For Vim version 8.2.  Last change: 2020 Aug 07
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -4895,31 +4895,32 @@
 
 		Each returned List item is a dictionary with the following
 		entries:
-			bufnr		buffer number.
+			bufnr		Buffer number.
 			changed		TRUE if the buffer is modified.
-			changedtick	number of changes made to the buffer.
+			changedtick	Number of changes made to the buffer.
 			hidden		TRUE if the buffer is hidden.
-			lastused	timestamp in seconds, like
+			lastused	Timestamp in seconds, like
 					|localtime()|, when the buffer was
 					last used.
 					{only with the |+viminfo| feature}
 			listed		TRUE if the buffer is listed.
-			lnum		current line number in buffer.
-			linecount	number of lines in the buffer (only
+			lnum		Line number used for the buffer when
+					opened in the current window.
+			linecount	Number of lines in the buffer (only
 					valid when loaded)
 			loaded		TRUE if the buffer is loaded.
-			name		full path to the file in the buffer.
-			signs		list of signs placed in the buffer.
+			name		Full path to the file in the buffer.
+			signs		List of signs placed in the buffer.
 					Each list item is a dictionary with
 					the following fields:
 					    id	  sign identifier
 					    lnum  line number
 					    name  sign name
-			variables	a reference to the dictionary with
+			variables	A reference to the dictionary with
 					buffer-local variables.
-			windows		list of |window-ID|s that display this
+			windows		List of |window-ID|s that display this
 					buffer
-			popups		list of popup |window-ID|s that
+			popups		List of popup |window-ID|s that
 					display this buffer
 
 		Examples: >
@@ -5446,7 +5447,7 @@
 			:echo getloclist(5, {'filewinid': 0})
 
 
-getmarklist([{expr}]					*getmarklist()*
+getmarklist([{expr}])					*getmarklist()*
 		Without the {expr} argument returns a |List| with information
 		about all the global marks. |mark|
 
@@ -8709,7 +8710,8 @@
 		  pos		|List|		`[lnum, col, off]` value
 						when recomputing the result.
 						this changes "current" result
-						value. see |cursor()|, |getpos()
+						value. see |cursor()|,
+						|getpos()|
 						(default: cursor's position)
 
 
@@ -9111,7 +9113,7 @@
 		argument is ignored.  See below for the supported items in
 		{what}.
 							*setqflist-what*
-		When {what} is not present, the items in {list} or used.  Each
+		When {what} is not present, the items in {list} are used.  Each
 		item must be a dictionary.  Non-dictionary items in {list} are
 		ignored.  Each dictionary item can contain the following
 		entries:
@@ -9332,7 +9334,7 @@
 
 		Returns zero for success, -1 for failure.
 
-		Examples (for more examples see |tagstack-examples||):
+		Examples (for more examples see |tagstack-examples|):
 		    Empty the tag stack of window 3: >
 			call settagstack(3, {'items' : []})
 
@@ -10132,7 +10134,7 @@
 		The result is the swap file path of the buffer {expr}.
 		For the use of {expr}, see |bufname()| above.
 		If buffer {expr} is the current buffer, the result is equal to
-		|:swapname| (unless no swap file).
+		|:swapname| (unless there is no swap file).
 		If buffer {expr} has no swap file, returns an empty string.
 
 		Can also be used as a |method|: >
diff --git a/runtime/doc/gui_w32.txt b/runtime/doc/gui_w32.txt
index 30e2287..c0f8867 100644
--- a/runtime/doc/gui_w32.txt
+++ b/runtime/doc/gui_w32.txt
@@ -451,7 +451,7 @@
 
 XPM support						*w32-xpm-support*
 
-GVim can be build on MS-Windows with support for XPM files.  |+xpm_w32|
+GVim can be built on MS-Windows with support for XPM files.  |+xpm_w32|
 See the Make_mvc.mak file for instructions, search for XPM.
 
 To try out if XPM support works do this: >
diff --git a/runtime/doc/helphelp.txt b/runtime/doc/helphelp.txt
index 7771a50..8dcaa1f 100644
--- a/runtime/doc/helphelp.txt
+++ b/runtime/doc/helphelp.txt
@@ -1,4 +1,4 @@
-*helphelp.txt*	For Vim version 8.2.  Last change: 2020 Mar 01
+*helphelp.txt*	For Vim version 8.2.  Last change: 2020 Jul 27
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -369,14 +369,16 @@
 You can find the details in $VIMRUNTIME/syntax/help.vim
 
 							*inclusion*
-Some people make a big deal about using "his" when referring to the user,
-thinking it means we assume the user is male.  That is of course not the case,
-it's just a habit of writing help text, which quite often is many years old.
-Also, a lot of the text is written by contributors for who English is not
-their first language.  We do not make any assumptions about the gender of the
-user, no matter how the text is phrased.  And we do not want to waste time on
-this discussion.  The goal is that the reader understands how Vim works, the
-exact wording is secondary.
+Vim is for everybody, no matter race, gender or anything.  Some people make a
+big deal about using "he" or "his" when referring to the user, thinking it
+means we assume the user is male.  That is not the case, it's just a habit of
+writing help text, which quite often is many years old.  Also, a lot of the
+text is written by contributors for whom English is not their first language.
+We do not make any assumptions about the gender of the user, no matter how the
+text is phrased.  Some people have suggested using "they", but that is not
+regular English. We do not want to spend much time on this discussion.  The
+goal is that the reader understands how Vim works, the exact wording is
+secondary.
 
 
  vim:tw=78:ts=8:noet:ft=help:norl:
diff --git a/runtime/doc/if_lua.txt b/runtime/doc/if_lua.txt
index 65a2d60..b556996 100644
--- a/runtime/doc/if_lua.txt
+++ b/runtime/doc/if_lua.txt
@@ -199,8 +199,8 @@
 				returns it. Note that the buffer is not set as
 				current.
 
-	vim.call({name} [,{args}])
-				Proxy to call Vim function named {name} with 
+	vim.call({name} [, {args}])
+				Proxy to call Vim function named {name} with
 				arguments {args}.  Example: >
 					:lua print(vim.call('has', 'timers'))
 <
diff --git a/runtime/doc/if_tcl.txt b/runtime/doc/if_tcl.txt
index 60ac6bc..90dec9d 100644
--- a/runtime/doc/if_tcl.txt
+++ b/runtime/doc/if_tcl.txt
@@ -275,7 +275,7 @@
 	$win delcmd {cmd}				*tcl-window-delcmd*
 	Registers the Tcl command {cmd} as a deletion callback for the window.
 	This command is executed (in the global scope) just before the window
-	is closed.  Complex commands should be build with "list": >
+	is closed.  Complex commands should be built with "list": >
 		$win delcmd [list puts vimerr "window deleted"]
 <	See also |tcl-buffer-delcmd|.
 
@@ -357,7 +357,7 @@
 	$buf delcmd {cmd}				*tcl-buffer-delcmd*
 	Registers the Tcl command {cmd} as a deletion callback for the buffer.
 	This command is executed (in the global scope) just before the buffer
-	is deleted.  Complex commands should be build with "list": >
+	is deleted.  Complex commands should be built with "list": >
 		$buf delcmd [list puts vimerr "buffer [$buf number] gone"]
 <	See also |tcl-window-delcmd|.
 
diff --git a/runtime/doc/indent.txt b/runtime/doc/indent.txt
index c4785c4..87d5c0b 100644
--- a/runtime/doc/indent.txt
+++ b/runtime/doc/indent.txt
@@ -414,11 +414,11 @@
 <
 							*cino-(*
 	(N    When in unclosed parentheses, indent N characters from the line
-	      with the unclosed parentheses.  Add a 'shiftwidth' for every
+	      with the unclosed parenthesis.  Add a 'shiftwidth' for every
 	      extra unclosed parentheses.  When N is 0 or the unclosed
-	      parentheses is the first non-white character in its line, line
+	      parenthesis is the first non-white character in its line, line
 	      up with the next non-white character after the unclosed
-	      parentheses.  (default 'shiftwidth' * 2).
+	      parenthesis.  (default 'shiftwidth' * 2).
 
 		cino=			  cino=(0 >
 		  if (c1 && (c2 ||	    if (c1 && (c2 ||
@@ -439,7 +439,7 @@
 <
 							*cino-U*
 	UN    When N is non-zero, do not ignore the indenting specified by
-	      ( or u in case that the unclosed parentheses is the first
+	      ( or u in case that the unclosed parenthesis is the first
 	      non-white character in its line.  (default 0).
 
 		cino= or cino=(s	  cino=(s,U1 >
@@ -452,8 +452,8 @@
 							*cino-w*
 	wN    When in unclosed parentheses and N is non-zero and either
 	      using "(0" or "u0", respectively, or using "U0" and the unclosed
-	      parentheses is the first non-white character in its line, line
-	      up with the character immediately after the unclosed parentheses
+	      parenthesis is the first non-white character in its line, line
+	      up with the character immediately after the unclosed parenthesis
 	      rather than the first non-white character.  (default 0).
 
 		cino=(0			  cino=(0,w1 >
@@ -464,11 +464,11 @@
 <
 							*cino-W*
 	WN    When in unclosed parentheses and N is non-zero and either
-	      using "(0" or "u0", respectively and the unclosed parentheses is
+	      using "(0" or "u0", respectively and the unclosed parenthesis is
 	      the last non-white character in its line and it is not the
-	      closing parentheses, indent the following line N characters
+	      closing parenthesis, indent the following line N characters
 	      relative to the outer context (i.e. start of the line or the
-	      next unclosed parentheses).  (default: 0).
+	      next unclosed parenthesis).  (default: 0).
 
 		cino=(0			   cino=(0,W4 >
 		  a_long_line(		    a_long_line(
@@ -495,8 +495,8 @@
 <
 							*cino-m*
 	mN    When N is non-zero, line up a line starting with a closing
-	      parentheses with the first character of the line with the
-	      matching opening parentheses.  (default 0).
+	      parenthesis with the first character of the line with the
+	      matching opening parenthesis.  (default 0).
 
 		cino=(s			  cino=(s,m1 >
 		  c = c1 && (		    c = c1 && (
@@ -510,7 +510,7 @@
 <
 							*cino-M*
 	MN    When N is non-zero, line up a line starting with a closing
-	      parentheses with the first character of the previous line.
+	      parenthesis with the first character of the previous line.
 	      (default 0).
 
 		cino=			  cino=M1 >
@@ -569,7 +569,7 @@
 	      recognize preprocessor lines; right-shifting lines that start
 	      with "#" does not work.
 
-
+								*cino-P*
 	PN    When N is non-zero recognize C pragmas, and indent them like any
 	      other code; does not concern other preprocessor directives.
 	      When N is zero (default): don't recognize C pragmas, treating
@@ -996,7 +996,7 @@
 Indent for a continuation line: >
 	let g:pyindent_continue = 'shiftwidth() * 2'
 
-The method uses |searchpair()| to look back for unclosed parenthesis.  This
+The method uses |searchpair()| to look back for unclosed parentheses.  This
 can sometimes be slow, thus it timeouts after 150 msec.  If you notice the
 indenting isn't correct, you can set a larger timeout in msec: >
 	let g:pyindent_searchpair_timeout = 500
diff --git a/runtime/doc/map.txt b/runtime/doc/map.txt
index 79c46f7..78451a1 100644
--- a/runtime/doc/map.txt
+++ b/runtime/doc/map.txt
@@ -1,4 +1,4 @@
-*map.txt*       For Vim version 8.2.  Last change: 2020 Apr 23
+*map.txt*       For Vim version 8.2.  Last change: 2020 Aug 01
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index d98307e..102eb62 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*	For Vim version 8.2.  Last change: 2020 Jul 18
+*options.txt*	For Vim version 8.2.  Last change: 2020 Aug 07
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -2715,6 +2715,11 @@
 				 for Unix: ".,~/tmp,/var/tmp,/tmp")
 			global
 	List of directory names for the swap file, separated with commas.
+	Recommended value:  ".,~/vimswap//" - this will put the swap file next
+	to the edited file if possible, and in your personal swap directory
+	otherwise.  Make sure "~/vimswap//" is only readable for you.
+
+	Possible items:
 	- The swap file will be created in the first directory where this is
 	  possible.
 	- Empty means that no swap file will be used (recovery is
@@ -2749,9 +2754,10 @@
 	the same file twice will result in a warning.  Using "/tmp" on Unix is
 	discouraged: When the system crashes you lose the swap file.
 	"/var/tmp" is often not cleared when rebooting, thus is a better
-	choice than "/tmp".  But it can contain a lot of files, your swap
-	files get lost in the crowd.  That is why a "tmp" directory in your
-	home directory is tried first.
+	choice than "/tmp".  But others on the computer may be able to see the
+	files, and it can contain a lot of files, your swap files get lost in
+	the crowd.  That is why a "tmp" directory in your home directory is
+	tried first.
 	The use of |:set+=| and |:set-=| is preferred when adding or removing
 	directories from the list.  This avoids problems when a future version
 	uses another default.
@@ -8368,7 +8374,7 @@
 	>= 14	Anything pending in a ":finally" clause.
 	>= 15	Every executed Ex command from a script (truncated at 200
 		characters).
-	>= 16	Every executed Ex command
+	>= 16	Every executed Ex command.
 
 	This option can also be set with the "-V" argument.  See |-V|.
 	This option is also set by the |:verbose| command.
@@ -8907,7 +8913,7 @@
 			{only available when compiled with the |terminal|
 			feature on MS-Windows}
 	Specifies the name of the winpty shared library, used for the
-	|:terminal| command. The default depends on whether was build as a
+	|:terminal| command. The default depends on whether Vim was built as a
 	32-bit or 64-bit executable.  If not found, "winpty.dll" is tried as
 	a fallback.
 	Environment variables are expanded |:set_env|.
diff --git a/runtime/doc/os_vms.txt b/runtime/doc/os_vms.txt
index 1682327..b69f650 100644
--- a/runtime/doc/os_vms.txt
+++ b/runtime/doc/os_vms.txt
@@ -88,7 +88,7 @@
 semantics, therefore you have to use a converter program that will do the lion
 part of the job.  For detailed instructions read file INSTALLvms.txt
 
-MMS_VIM.EXE is build together with VIM.EXE, but for XXD.EXE you should
+MMS_VIM.EXE is built together with VIM.EXE, but for XXD.EXE you should
 change to a subdirectory and build it separately.
 
 CTAGS is not part of the Vim source distribution anymore, however the OpenVMS
diff --git a/runtime/doc/popup.txt b/runtime/doc/popup.txt
index ff99fce..8a0f2ba 100644
--- a/runtime/doc/popup.txt
+++ b/runtime/doc/popup.txt
@@ -1,4 +1,4 @@
-*popup.txt*  For Vim version 8.2.  Last change: 2020 May 18
+*popup.txt*  For Vim version 8.2.  Last change: 2020 Jul 27
 
 
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -74,9 +74,9 @@
 property.  You can use empty lines to increase the height or the "minheight"
 property.
 
-The width of the window is normally equal to the longest line in the buffer.
-It can be limited with the "maxwidth" property.  You can use spaces to
-increase the width or use the "minwidth" property.
+The width of the window is normally equal to the longest visible line in the
+buffer.  It can be limited with the "maxwidth" property.  You can use spaces
+to increase the width or use the "minwidth" property.
 
 By default the 'wrap' option is set, so that no text disappears.  Otherwise,
 if there is not enough space then the window is shifted left in order to
diff --git a/runtime/doc/remote.txt b/runtime/doc/remote.txt
index 53c98d0..c6dcb98 100644
--- a/runtime/doc/remote.txt
+++ b/runtime/doc/remote.txt
@@ -179,7 +179,7 @@
 
 A non GUI Vim with access to the X11 display (|xterm-clipboard| enabled), can
 also act as a command server if a server name is explicitly given with the
---servername argument, or when Vim was build with the |+autoservername|
+--servername argument, or when Vim was built with the |+autoservername|
 feature.
 
 An empty --servername argument will cause the command server to be disabled.
diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt
index 8effaf5..a7f648c 100644
--- a/runtime/doc/syntax.txt
+++ b/runtime/doc/syntax.txt
@@ -1,4 +1,4 @@
-*syntax.txt*	For Vim version 8.2.  Last change: 2020 Jul 08
+*syntax.txt*	For Vim version 8.2.  Last change: 2020 Jul 28
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -3648,7 +3648,7 @@
 	start:		Use level of item containing start of line.
 	minimum:	Use lowest local-minimum level of items on line.
 
-	The default is 'start'.  Use 'minimum' to search a line horizontally
+	The default is "start".  Use "minimum" to search a line horizontally
 	for the lowest level contained on the line that is followed by a
 	higher level.  This produces more natural folds when syntax items
 	may close and open horizontally within a line.
@@ -3795,9 +3795,9 @@
 		[keepend]
 		[extend]
 		[excludenl]
-		start={start_pattern} ..
-		[skip={skip_pattern}]
-		end={end_pattern} ..
+		start={start-pattern} ..
+		[skip={skip-pattern}]
+		end={end-pattern} ..
 		[{options}]
 
 	This defines one region.  It may span several lines.
@@ -3819,12 +3819,12 @@
 				extend a containing match or item.  Only
 				useful for end patterns.  Must be given before
 				the patterns it applies to. |:syn-excludenl|
-	start={start_pattern}	The search pattern that defines the start of
+	start={start-pattern}	The search pattern that defines the start of
 				the region.  See |:syn-pattern| below.
-	skip={skip_pattern}	The search pattern that defines text inside
+	skip={skip-pattern}	The search pattern that defines text inside
 				the region where not to look for the end
 				pattern.  See |:syn-pattern| below.
-	end={end_pattern}	The search pattern that defines the end of
+	end={end-pattern}	The search pattern that defines the end of
 				the region.  See |:syn-pattern| below.
 
 	Example: >
diff --git a/runtime/doc/tags b/runtime/doc/tags
index 243b25a..02bb541 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -5744,6 +5744,7 @@
 cino-L	indent.txt	/*cino-L*
 cino-M	indent.txt	/*cino-M*
 cino-N	indent.txt	/*cino-N*
+cino-P	indent.txt	/*cino-P*
 cino-U	indent.txt	/*cino-U*
 cino-W	indent.txt	/*cino-W*
 cino-^	indent.txt	/*cino-^*
diff --git a/runtime/doc/todo.txt b/runtime/doc/todo.txt
index f9ebf2d..0c8d124 100644
--- a/runtime/doc/todo.txt
+++ b/runtime/doc/todo.txt
@@ -1,4 +1,4 @@
-*todo.txt*      For Vim version 8.2.  Last change: 2020 Jul 26
+*todo.txt*      For Vim version 8.2.  Last change: 2020 Aug 05
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -39,10 +39,9 @@
 -------------------- Known bugs and current work -----------------------
 
 Making everything work:
-- more items in https://github.com/vim/vim/issues/6507
-- More "goto failed" with check for trylevel.
-- memory leak in test_vim9_script
 - Check that when sourcing a Vim9 script, only the global items can be used.
+- Make string indexes character indexes instead of byte indexes. (#6574)
+    explain how to use byte index when needed. Use blob?
 - :put with a "=" register argument doesn't work, need to find the expression
   and compile it. (#6397)
 - At the script level, keep script variables local to the block they are
@@ -51,6 +50,8 @@
 - Implement { } block at the script level.
 - need to check type when a declaration specifies a type: #6507
 	let nr: number = 'asdf'
+- Make sure that in vim9script a function call without namespace only finds
+  the script-local function, not a global one.
 - Make map() give an error if the resulting type is wrong.
   Add mapnew() to create a new List/Dict for the result, which can have a
   different value type.
@@ -169,7 +170,7 @@
 - Figure out the size and position better if wrapping inserts indent
 
 Text properties:
-- :goto does not go to the right place when test properties are present.
+- :goto does not go to the right place when text properties are present.
   (#5930)
 - "cc" does not call inserted_bytes(). (Axel Forsman, #5763)
 - Get E685 with a sequence of commands. (#5674)
@@ -200,7 +201,7 @@
   an already running program. (M. Kelly)
 - When only gdb window exists, on "quit" edit another buffer.
 - Use a sign group
-- Termdebug does not work when Vim was build with mzscheme: gdb hangs just
+- Termdebug does not work when Vim was built with mzscheme: gdb hangs just
   after "run".  Everything else works, including communication channel.  Not
   initializing mzscheme avoid the problem, thus it's not some #ifdef.
 - Add support for lldb?  issue #3565
@@ -255,10 +256,15 @@
 Error numbers available:
 E610, E611, E653
 
+Clean up empty entries in testdir/Make_all.mak
+
 Remove SPACE_IN_FILENAME ? It is only used for completion.
 
 Patch to use collaction based sorting. (Christian Brabandt, #6229)
 
+Add 'termguiattr' option, use "gui=" attributes in the terminal?  Would work
+with 'termguicolors'. #1740
+
 Can we detect true color support?  https://gist.github.com/XVilka/8346728
 Try setting a color then request the current color, like using t_u7.
 
@@ -333,6 +339,9 @@
 
 undo result wrong: Masato Nishihata, #4798
 
+After recovering from a swap file the undofile should not be used, it causes
+corruption.  (#6631)
+
 When 'lazyredraw' is set sometimes the title is not updated.
 (Jason Franklin, 2020 Feb 3)  Looks like a race condition.
 
@@ -1471,7 +1480,7 @@
 
 Add stronger encryption.  Could use libsodium (NaCl).
 https://github.com/jedisct1/libsodium/
-Possibly include the needed code so that it can be build everywhere.
+Possibly include the needed code so that it can be built everywhere.
 
 Add a way to restart a timer.  It's similar to timer_stop() and timer_start(),
 but the reference remains valid.
@@ -3833,8 +3842,6 @@
 8   When write_viminfo() is used while there are many orphaned viminfo
     tempfiles writing the viminfo file fails.  Give a clear error message so
     that the user knows he has to delete the files.
-7   It's possible to redefine a script-local function with ":func
-    <SNR>123_Test()". (Krishna)  Disallow this.
 
 
 I can't reproduce these (if you can, let me know how!):
@@ -5673,7 +5680,7 @@
     Also for other windows: ":inwin {winnr} {cmd}".  How to make sure that
     this works properly for all commands, and still be able to return to the
     current buffer/window?  E.g.: ":inbuf xxx only".
-8   Add File.{recent_files} menu entries: Recently edited files.
+8   Add File.{recent-files} menu entries: Recently edited files.
     Ron Aaron has a plugin for this: mru.vim.
 8   Unix: Check all uses of fnamecmp() and fnamencmp() if they should check
     inode too.
diff --git a/runtime/doc/usr_04.txt b/runtime/doc/usr_04.txt
index 6a6cbca..d2dc056 100644
--- a/runtime/doc/usr_04.txt
+++ b/runtime/doc/usr_04.txt
@@ -161,7 +161,7 @@
 ==============================================================================
 *04.3*	Repeating a change
 
-The "." command is one of the most simple yet powerful commands in Vim.  It
+The "." command is one of the simplest yet powerful commands in Vim.  It
 repeats the last change.  For instance, suppose you are editing an HTML file
 and want to delete all the <B> tags.  You position the cursor on the first <
 and delete the <B> with the command "df>".  You then go to the < of the next
diff --git a/runtime/doc/usr_05.txt b/runtime/doc/usr_05.txt
index 2cfff24..3a7438d 100644
--- a/runtime/doc/usr_05.txt
+++ b/runtime/doc/usr_05.txt
@@ -58,8 +58,8 @@
 |defaults.vim| for the details.
 
 The vimrc file can contain all the commands that you type after a colon.  The
-most simple ones are for setting options.  For example, if you want Vim to
-always start with the 'incsearch' option on, add this line your vimrc file: >
+simplest ones are for setting options.  For example, if you want Vim to always
+start with the 'incsearch' option on, add this line your vimrc file: >
 
 	set incsearch
 
diff --git a/runtime/doc/usr_20.txt b/runtime/doc/usr_20.txt
index f99ffb5..ebad3c5 100644
--- a/runtime/doc/usr_20.txt
+++ b/runtime/doc/usr_20.txt
@@ -327,10 +327,10 @@
 ==============================================================================
 *20.5*	Command line window
 
-Typing the text in the command line works different from typing text in Insert
-mode.  It doesn't allow many commands to change the text.  For most commands
-that's OK, but sometimes you have to type a complicated command.  That's where
-the command line window is useful.
+Typing the text in the command line works differently from typing text in
+Insert mode.  It doesn't allow many commands to change the text.  For most
+commands that's OK, but sometimes you have to type a complicated command.
+That's where the command line window is useful.
 
 Open the command line window with this command: >
 
diff --git a/runtime/doc/usr_30.txt b/runtime/doc/usr_30.txt
index 7363236..bcb7b59 100644
--- a/runtime/doc/usr_30.txt
+++ b/runtime/doc/usr_30.txt
@@ -336,7 +336,7 @@
 ==============================================================================
 *30.4*	Other indenting
 
-The most simple form of automatic indenting is with the 'autoindent' option.
+The simplest form of automatic indenting is with the 'autoindent' option.
 It uses the indent from the previous line.  A bit smarter is the 'smartindent'
 option.  This is useful for languages where no indent file is available.
 'smartindent' is not as smart as 'cindent', but smarter than 'autoindent'.
diff --git a/runtime/doc/usr_31.txt b/runtime/doc/usr_31.txt
index 0794b3a..afbc918 100644
--- a/runtime/doc/usr_31.txt
+++ b/runtime/doc/usr_31.txt
@@ -1,4 +1,4 @@
-*usr_31.txt*	For Vim version 8.2.  Last change: 2007 May 08
+*usr_31.txt*	For Vim version 8.2.  Last change: 2020 Jul 28
 
 		     VIM USER MANUAL - by Bram Moolenaar
 
@@ -198,9 +198,9 @@
 You can start the X-Windows version of gvim with an argument to specify the
 size and position of the window: >
 
-	gvim -geometry {width}x{height}+{x_offset}+{y_offset}
+	gvim -geometry {width}x{height}+{x-offset}+{y-offset}
 
-{width} and {height} are in characters, {x_offset} and {y_offset} are in
+{width} and {height} are in characters, {x-offset} and {y-offset} are in
 pixels.  Example: >
 
 	gvim -geometry 80x25+100+300
diff --git a/runtime/doc/usr_40.txt b/runtime/doc/usr_40.txt
index 85014c2..3456a76 100644
--- a/runtime/doc/usr_40.txt
+++ b/runtime/doc/usr_40.txt
@@ -1,4 +1,4 @@
-*usr_40.txt*	For Vim version 8.2.  Last change: 2013 Aug 05
+*usr_40.txt*	For Vim version 8.2.  Last change: 2020 Jul 28
 
 		     VIM USER MANUAL - by Bram Moolenaar
 
@@ -453,12 +453,12 @@
 performs the ":write".
    The general form of the :autocmd command is as follows: >
 
-	:autocmd [group] {events} {file_pattern} [nested] {command}
+	:autocmd [group] {events} {file-pattern} [nested] {command}
 
 The [group] name is optional.  It is used in managing and calling the commands
 (more on this later).  The {events} parameter is a list of events (comma
 separated) that trigger the command.
-   {file_pattern} is a filename, usually with wildcards.  For example, using
+   {file-pattern} is a filename, usually with wildcards.  For example, using
 "*.txt" makes the autocommand be used for all files whose name end in ".txt".
 The optional [nested] flag allows for nesting of autocommands (see below), and
 finally, {command} is the command to be executed.
@@ -489,7 +489,7 @@
 
 PATTERNS
 
-The {file_pattern} argument can actually be a comma-separated list of file
+The {file-pattern} argument can actually be a comma-separated list of file
 patterns.  For example: "*.c,*.h" matches files ending in ".c" and ".h".
    The usual file wildcards can be used.  Here is a summary of the most often
 used ones:
diff --git a/runtime/doc/usr_41.txt b/runtime/doc/usr_41.txt
index bde1dd1..45332e6 100644
--- a/runtime/doc/usr_41.txt
+++ b/runtime/doc/usr_41.txt
@@ -44,7 +44,7 @@
 	If you are familiar with Python, you can find a comparison between
 	Python and Vim script here, with pointers to other documents:
 	   https://gist.github.com/yegappan/16d964a37ead0979b05e655aa036cad0
-	And if you are familiar with Javascript:
+	And if you are familiar with JavaScript:
 	   https://w0rp.com/blog/post/vim-script-for-the-javascripter/
 
 Let's start with a simple example: >
@@ -2108,7 +2108,7 @@
 
 	\a  ->  <Plug>TypecorrAdd  ->  <SID>Add  ->  :call <SID>Add()
 
-If another script would also map <SID>Add, it would get another script ID and
+If another script was also map <SID>Add, it would get another script ID and
 thus define another mapping.
 
 Note that instead of s:Add() we use <SID>Add() here.  That is because the
diff --git a/runtime/doc/usr_42.txt b/runtime/doc/usr_42.txt
index 1a27482..1f3e4bb 100644
--- a/runtime/doc/usr_42.txt
+++ b/runtime/doc/usr_42.txt
@@ -210,8 +210,8 @@
 	:amenu <silent> Mine.Next\ File :call <SID>NextFile()<CR>
 
 Don't use "<silent>" too often.  It is not needed for short commands.  If you
-make a menu for someone else, being able the see the executed command will
-give him a hint about what he could have typed, instead of using the mouse.
+make a menu for someone else, being able to see the executed command will give
+him a hint about what he could have typed, instead of using the mouse.
 
 
 LISTING MENUS
diff --git a/runtime/doc/usr_46.txt b/runtime/doc/usr_46.txt
index b05a660..0986ba1 100644
--- a/runtime/doc/usr_46.txt
+++ b/runtime/doc/usr_46.txt
@@ -34,7 +34,7 @@
 Let's start with an example, a script that exports one function and has one
 private function: >
 
-	vim9script  " This indicates a Vim9 script file, 
+	vim9script  " This indicates a Vim9 script file.
 
 	export def GetMessage(): string
 	   let result = ''
diff --git a/runtime/doc/usr_toc.txt b/runtime/doc/usr_toc.txt
index b17a87d..816cf06 100644
--- a/runtime/doc/usr_toc.txt
+++ b/runtime/doc/usr_toc.txt
@@ -333,7 +333,7 @@
 		|44.11|	Installing a syntax file
 		|44.12|	Portable syntax file layout
 
-|usr_45.txt|  Select your language
+|usr_45.txt|  Select your language (locale)
 		|45.1|	Language for Messages
 		|45.2|	Language for Menus
 		|45.3|	Using another encoding
diff --git a/runtime/doc/vim9.txt b/runtime/doc/vim9.txt
index 2c4d1db..7f7b15b 100644
--- a/runtime/doc/vim9.txt
+++ b/runtime/doc/vim9.txt
@@ -1,4 +1,4 @@
-*vim9.txt*	For Vim version 8.2.  Last change: 2020 Jul 25
+*vim9.txt*	For Vim version 8.2.  Last change: 2020 Aug 01
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -14,7 +14,7 @@
 THIS IS STILL UNDER DEVELOPMENT - ANYTHING CAN BREAK - ANYTHING CAN CHANGE
 
 
-1   What is Vim9 script?		|vim9-script|
+1.  What is Vim9 script?		|vim9-script|
 2.  Differences				|vim9-differences|
 3.  New style functions			|fast-functions|
 4.  Types				|vim9-types|
@@ -119,11 +119,12 @@
 When using `:function` or `:def` to specify a new function at the script level
 in a Vim9 script, the function is local to the script, as if "s:" was
 prefixed.  Using the "s:" prefix is optional.  To define or use a global
-function or variable the "g:" prefix must be used.  For functions in an
+function or variable the "g:" prefix should be used.  For functions in an
 autoload script the "name#" prefix is sufficient. >
 	def ThisFunction()          # script-local
 	def s:ThisFunction()        # script-local
 	def g:ThatFunction()	    # global
+	def ThatFunction()	    # global if no local ThatFunction()
 	def scriptname#function()   # autoload
 
 When using `:function` or `:def` to specify a new function inside a function,
@@ -132,16 +133,14 @@
 function, using the "g:" prefix.
 
 When referring to a function and no "s:" or "g:" prefix is used, Vim will
-search for the function in this order:
-- Local to the current scope and outer scopes up to the function scope.
-- Local to the current script file.
-- Imported functions, see `:import`.
+prefer using a local function (in the function scope, script scope or
+imported) before looking for a global function.
 In all cases the function must be defined before used.  That is when it is
 first called or when `:defcompile` causes the call to be compiled.
 
-The result is that functions and variables without a namespace can always be
+The result is that functions and variables without a namespace can usually be
 found in the script, either defined there or imported.  Global functions and
-variables could be defined anywhere (good luck finding where!).
+variables could be defined anywhere (good luck finding out where!).
 
 Global functions can be still be defined and deleted at nearly any time.  In
 Vim9 script script-local functions are defined once when the script is sourced
@@ -193,7 +192,8 @@
 without `:let`, because they are not really declared, they can also be deleted
 with `:unlet`.
 
-Variables cannot shadow previously defined variables.
+Variables and functions cannot shadow previously defined or imported variables
+and functions.
 Variables may shadow Ex commands, rename the variable if needed.
 
 Global variables and user defined functions must be prefixed with "g:", also
@@ -232,11 +232,11 @@
 	'foobar'->Process()
 	('foobar')->Process()
 
-In rare case there is ambiguity between a function name and an Ex command, use
-":" to make clear you want to use the Ex command.  For example, there is both
-the `:substitute` command and the `substitute()` function.  When the line
-starts with `substitute(` this will use the function. Prepend a colon to use
-the command instead: >
+In rare case there is ambiguity between a function name and an Ex command,
+prepend ":" to make clear you want to use the Ex command.  For example, there
+is both the `:substitute` command and the `substitute()` function.  When the
+line starts with `substitute(` this will use the function. Prepend a colon to
+use the command instead: >
 	:substitute(pattern (replacement (
 
 Note that while variables need to be defined before they can be used,
@@ -261,8 +261,8 @@
 Automatic line continuation ~
 
 In many cases it is obvious that an expression continues on the next line.  In
-those cases there is no need to prefix the line with a backslash.  For
-example, when a list spans multiple lines: >
+those cases there is no need to prefix the line with a backslash
+|line-continuation|.  For example, when a list spans multiple lines: >
 	let mylist = [
 		'one',
 		'two',
@@ -452,6 +452,11 @@
 	'text'->func()	" Vim9: method call
 	:'t		" legacy Vim: jump to mark m
 
+Some Ex commands can be confused with assignments in Vim9 script: >
+	g:name = value  # assignment
+	g:pattern:cmd	# invalid command - ERROR
+	:g:pattern:cmd	# :global command
+
 Functions defined with `:def` compile the whole function.  Legacy functions
 can bail out, and the following lines are not parsed: >
 	func Maybe()
diff --git a/runtime/doc/visual.txt b/runtime/doc/visual.txt
index 626285e..4704067 100644
--- a/runtime/doc/visual.txt
+++ b/runtime/doc/visual.txt
@@ -125,7 +125,7 @@
 
 							*<LeftMouse>*
 <LeftMouse>		Set the current cursor position.  If Visual mode is
-			active it is stopped.  Only when 'mouse' option is
+			active it is stopped.  Only when 'mouse' option
 			contains 'n' or 'a'.  If the position is within 'so'
 			lines from the last line on the screen the text is
 			scrolled up.  If the position is within 'so' lines from
@@ -136,7 +136,7 @@
 <RightMouse>		Start Visual mode if it is not active.  The text from
 			the cursor position to the position of the click is
 			highlighted.  If Visual mode was already active move
-			the start or end of the highlighted text, which ever
+			the start or end of the highlighted text, whichever
 			is closest, to the position of the click.  Only when
 			'mouse' option contains 'n' or 'a'.
 
@@ -236,7 +236,7 @@
 	is	inner sentence					|v_is|
 	ap	a paragraph (with white space)			|v_ap|
 	ip	inner paragraph					|v_ip|
-	ab	a () block (with parenthesis)			|v_ab|
+	ab	a () block (with parentheses)			|v_ab|
 	ib	inner () block					|v_ib|
 	aB	a {} block (with braces)			|v_aB|
 	iB	inner {} block					|v_iB|
@@ -347,7 +347,7 @@
 The block is shifted by 'shiftwidth'.  The RHS of the block is irrelevant.  The
 LHS of the block determines the point from which to apply a right shift, and
 padding includes TABs optimally according to 'ts' and 'et'.  The LHS of the
-block determines the point upto which to shift left.
+block determines the point up to which to shift left.
 See |v_b_>_example|.
 See |v_b_<_example|.
 
