Fix word wrapping

doc/backends.rst

@@ -107,12 +107,13 @@ Nim code calling the backend
 
 Nim code can interface with the backend through the `Foreign function
 interface <manual.html#foreign-function-interface>`_ mainly through the
-`importc pragma <manual.html#foreign-function-interface-importc-pragma>`_. The ``importc`` pragma is the
+`importc pragma <manual.html#foreign-function-interface-importc-pragma>`_.
-*generic* way of making backend symbols available in Nim and is available
+The ``importc`` pragma is the *generic* way of making backend symbols available
-in all the target backends (JavaScript too).  The C++ or Objective-C backends
+in Nim and is available in all the target backends (JavaScript too).  The C++
-have their respective `ImportCpp <manual.html#implementation-specific-pragmas-importcpp-pragma>`_ and
+or Objective-C backends have their respective `ImportCpp
-`ImportObjC <manual.html#implementation-specific-pragmas-importobjc-pragma>`_ pragmas to call methods from
+<manual.html#implementation-specific-pragmas-importcpp-pragma>`_ and
-classes.
+`ImportObjC <manual.html#implementation-specific-pragmas-importobjc-pragma>`_
+pragmas to call methods from classes.
 
 Whenever you use any of these pragmas you need to integrate native code into
 your final binary. In the case of JavaScript this is no problem at all, the
@@ -124,16 +125,16 @@ statically or dynamically. The preferred way of integrating native code is to
 use dynamic linking because it allows you to compile Nim programs without
 the need for having the related development libraries installed. This is done
 through the `dynlib pragma for import
-<manual.html#foreign-function-interface-dynlib-pragma-for-import>`_, though more specific control can be
+<manual.html#foreign-function-interface-dynlib-pragma-for-import>`_, though
-gained using the `dynlib module <dynlib.html>`_.
+more specific control can be gained using the `dynlib module <dynlib.html>`_.
 
 The `dynlibOverride <nimc.html#dynliboverride>`_ command line switch allows
 to avoid dynamic linking if you need to statically link something instead.
 Nim wrappers designed to statically link source files can use the `compile
-pragma <manual.html#implementation-specific-pragmas-compile-pragma>`_ if there are few sources or providing
+pragma <manual.html#implementation-specific-pragmas-compile-pragma>`_ if
-them along the Nim code is easier than using a system library. Libraries
+there are few sources or providing them along the Nim code is easier than using
-installed on the host system can be linked in with the `PassL pragma
+a system library. Libraries installed on the host system can be linked in with
-<manual.html#implementation-specific-pragmas-passl-pragma>`_.
+the `PassL pragma <manual.html#implementation-specific-pragmas-passl-pragma>`_.
 
 To wrap native code, take a look at the `c2nim tool <https://nim-lang.org/docs/c2nim.html>`_ which helps
 with the process of scanning and transforming header files into a Nim
@@ -215,12 +216,12 @@ Backend code calling Nim
 ------------------------
 
 Backend code can interface with Nim code exposed through the `exportc
-pragma <manual.html#foreign-function-interface-exportc-pragma>`_. The ``exportc`` pragma is the *generic*
+pragma <manual.html#foreign-function-interface-exportc-pragma>`_. The
-way of making Nim symbols available to the backends. By default the Nim
+``exportc`` pragma is the *generic* way of making Nim symbols available to
-compiler will mangle all the Nim symbols to avoid any name collision, so
+the backends. By default the Nim compiler will mangle all the Nim symbols to
-the most significant thing the ``exportc`` pragma does is maintain the Nim
+avoid any name collision, so the most significant thing the ``exportc`` pragma
-symbol name, or if specified, use an alternative symbol for the backend in
+does is maintain the Nim symbol name, or if specified, use an alternative
-case the symbol rules don't match.
+symbol for the backend in case the symbol rules don't match.
 
 The JavaScript target doesn't have any further interfacing considerations
 since it also has garbage collection, but the C targets require you to
@@ -329,8 +330,8 @@ Nimcache naming logic
 The `nimcache`:idx: directory is generated during compilation and will hold
 either temporary or final files depending on your backend target. The default
 name for the directory depends on the used backend and on your OS but you can
-use the ``--nimcache`` `compiler switch <nimc.html#compiler-usage-command-line-switches>`_ to
+use the ``--nimcache`` `compiler switch
-change it.
+<nimc.html#compiler-usage-command-line-switches>`_ to change it.
 
 
 Memory management
@@ -384,8 +385,8 @@ the backend will need careful consideration of who controls who. If you want
 to hand a Nim reference to C code, you will need to use `GC_ref
 <system.html#GC_ref,ref.T>`_ to mark the reference as used, so it does not get
 freed. And for the C backend you will need to expose the `GC_unref
-<system.html#GC_unref,ref.T>`_ proc to clean up this memory when it is not required
+<system.html#GC_unref,ref.T>`_ proc to clean up this memory when it is not
-any more.
+required any more.
 
 Again, if you are wrapping a library which *mallocs* and *frees* data
 structures, you need to expose the appropriate *free* function to Nim so

doc/contributing.rst

@@ -213,8 +213,7 @@ as well as ``testament`` and guarantee they stay in sync.
       assert "baz".addBar == "bazBar"
     result = a & "Bar"
 
-See `parentDir <os.html#parentDir,string>`_
+See `parentDir <os.html#parentDir,string>`_ example.
-example.
 
 The RestructuredText Nim uses has a special syntax for including code snippets
 embedded in documentation; these are not run by ``nim doc`` and therefore are

doc/docgen.rst

@@ -307,7 +307,8 @@ symbols in the `system module <system.html>`_.
   `#len,seq[T] <system.html#len,seq[T]>`_
 * ``iterator pairs[T](a: seq[T]): tuple[key: int, val: T] {.inline.}`` **=>**
   `#pairs.i,seq[T] <system.html#pairs.i,seq[T]>`_
-* ``template newException[](exceptn: typedesc; message: string; parentException: ref Exception = nil): untyped`` **=>**
+* ``template newException[](exceptn: typedesc; message: string;
+    parentException: ref Exception = nil): untyped`` **=>**
   `#newException.t,typedesc,string,ref.Exception
   <system.html#newException.t,typedesc,string,ref.Exception>`_
 
@@ -316,14 +317,15 @@ Index (idx) file format
 =======================
 
 Files with the ``.idx`` extension are generated when you use the `Index
-switch <#related-options-index-switch>`_ along with commands to generate documentation from source or text
+switch <#related-options-index-switch>`_ along with commands to generate
-files. You can programatically generate indices with the `setIndexTerm()
+documentation from source or text files. You can programatically generate
-<rstgen.html#setIndexTerm,RstGenerator,string,string,string,string,string>`_ and `writeIndexFile()
+indices with the `setIndexTerm()
-<rstgen.html#writeIndexFile,RstGenerator,string>`_ procs. The purpose of ``idx`` files is to hold
+<rstgen.html#setIndexTerm,RstGenerator,string,string,string,string,string>`_
-the interesting symbols and their HTML references so they can be later
+and `writeIndexFile() <rstgen.html#writeIndexFile,RstGenerator,string>`_ procs.
-concatenated into a big index file with `mergeIndexes()
+The purpose of ``idx`` files is to hold the interesting symbols and their HTML
-<rstgen.html#mergeIndexes,string>`_.  This section documents the file format in
+references so they can be later concatenated into a big index file with
-detail.
+`mergeIndexes() <rstgen.html#mergeIndexes,string>`_.  This section documents
+the file format in detail.
 
 Index files are line oriented and tab separated (newline and tab characters
 have to be escaped). Each line represents a record with at least two fields,

doc/gc.rst

@@ -164,7 +164,8 @@ you can pass ``--gc:`` on the compile command with the choosed garbage collector
 
 The same Nim code can be compiled to use any of the garbage collectors;
 the Nim syntax generally will not change from one garbage collector to another.
-No garbage collector is used for `JavaScript and NodeJS <backends.html#backends-the-javascript-target>`_ compilation targets.
+No garbage collector is used for `JavaScript and NodeJS
+<backends.html#backends-the-javascript-target>`_ compilation targets.
 `NimScript <nims.html>`_ target uses Nim VM garbage collector.
 
 If you are new to Nim and just starting, the default garbage collector is balanced to fit most common use cases.

doc/idetools.rst

@@ -124,9 +124,9 @@ separators!).
 
 The typical usage scenario for this option is to call it after the
 user has typed the dot character for `the object oriented call
-syntax <tut2.html#object-oriented-programming-method-call-syntax>`_. Idetools will try to return
+syntax <tut2.html#object-oriented-programming-method-call-syntax>`_.
-the suggestions sorted first by scope (from innermost to outermost)
+Idetools will try to return the suggestions sorted first by scope
-and then by item name.
+(from innermost to outermost) and then by item name.
 
 
 Invocation context
@@ -359,7 +359,8 @@ defined, since at that point in the file the parser hasn't processed
 the full line yet. The signature will be returned complete in
 posterior instances of the method.
 
-Methods imply `dynamic dispatch <tut2.html#object-oriented-programming-dynamic-dispatch>`_ and
+Methods imply `dynamic dispatch
+<tut2.html#object-oriented-programming-dynamic-dispatch>`_ and
 idetools performs a static analysis on the code. For this reason
 idetools may not return the definition of the correct method you
 are querying because it may be impossible to know until the code

doc/koch.rst

@@ -47,7 +47,8 @@ csource command
 ---------------
 
 The `csource`:idx: command builds the C sources for installation. It accepts
-the same options as you would pass to the `boot command <#commands-boot-command>`_.
+the same options as you would pass to the `boot command
+<#commands-boot-command>`_.
 
 temp command
 ------------

doc/manual.rst

@@ -1482,7 +1482,8 @@ order. The *names* of the fields also have to be identical.
 
 The assignment operator for tuples copies each component.
 The default assignment operator for objects copies each component. Overloading
-of the assignment operator is described `here <manual_experimental.html#type-bound-operations>`_.
+of the assignment operator is described `here
+<manual_experimental.html#type-bound-operations>`_.
 
 .. code-block:: nim
 
@@ -3484,8 +3485,8 @@ more argument in this case:
   assert x == y
 
 The command invocation syntax also can't have complex expressions as arguments.
-For example: (`anonymous procs <#procedures-anonymous-procs>`_), ``if``, ``case`` or ``try``.
+For example: (`anonymous procs <#procedures-anonymous-procs>`_), ``if``,
-Function calls with no arguments still needs () to
+``case`` or ``try``. Function calls with no arguments still needs () to
 distinguish between a call and the function itself as a first class value.
 
 
@@ -3505,8 +3506,8 @@ Creating closures in loops
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Since closures capture local variables by reference it is often not wanted
-behavior inside loop bodies. See `closureScope <system.html#closureScope.t,untyped>`_
+behavior inside loop bodies. See `closureScope
-for details on how to change this behavior.
+<system.html#closureScope.t,untyped>`_ for details on how to change this behavior.
 
 Anonymous Procs
 ---------------
@@ -5895,9 +5896,9 @@ or ``ref T`` or ``ptr T`` this means no locations are modified. It is a static
 error to mark a proc/iterator to have no side effect if the compiler cannot
 verify this.
 
-As a special semantic rule, the built-in `debugEcho <system.html#debugEcho,varargs[typed,]>`_
+As a special semantic rule, the built-in `debugEcho
-pretends to be free of side effects, so that it can be used for debugging
+<system.html#debugEcho,varargs[typed,]>`_ pretends to be free of side effects,
-routines marked as ``noSideEffect``.
+so that it can be used for debugging routines marked as ``noSideEffect``.
 
 ``func`` is syntactic sugar for a proc with no side effects:
 

doc/manual_experimental.rst

@@ -203,9 +203,10 @@ useful only when interfacing with imported types having such semantics.
 Automatic dereferencing
 =======================
 
-If the `experimental mode <manual.html#pragmas-experimental-pragma>`_ is active and no other match
+If the `experimental mode <manual.html#pragmas-experimental-pragma>`_ is active
-is found, the first argument ``a`` is dereferenced automatically if it's a
+and no other match is found, the first argument ``a`` is dereferenced
-pointer type and overloading resolution is tried with ``a[]`` instead.
+automatically if it's a pointer type and overloading resolution is tried
+with ``a[]`` instead.
 
 
 Automatic self insertions

doc/nimc.rst

@@ -114,7 +114,8 @@ Level  Description
 =====  ============================================
 0      Minimal output level for the compiler.
 1      Displays compilation of all the compiled files, including those imported
-       by other modules or through the `compile pragma<manual.html#implementation-specific-pragmas-compile-pragma>`_.
+       by other modules or through the `compile pragma
+       <manual.html#implementation-specific-pragmas-compile-pragma>`_.
        This is the default level.
 2      Displays compilation statistics, enumerates the dynamic
        libraries that will be loaded by the final binary and dumps to
@@ -130,9 +131,10 @@ Compile time symbols
 
 Through the ``-d:x`` or ``--define:x`` switch you can define compile time
 symbols for conditional compilation. The defined switches can be checked in
-source code with the `when statement <manual.html#statements-and-expressions-when-statement>`_ and
+source code with the `when statement
-`defined proc <system.html#defined,untyped>`_. The typical use of this switch is to
+<manual.html#statements-and-expressions-when-statement>`_ and
-enable builds in release mode (``-d:release``) where optimizations are
+`defined proc <system.html#defined,untyped>`_. The typical use of this switch is
+to enable builds in release mode (``-d:release``) where optimizations are
 enabled for better performance. Another common use is the ``-d:ssl`` switch to
 activate SSL sockets.
 

doc/nimsuggest.rst

@@ -105,9 +105,9 @@ completion symbols at some point in the file.
 
 The typical usage scenario for this option is to call it after the
 user has typed the dot character for `the object oriented call
-syntax <tut2.html#object-oriented-programming-method-call-syntax>`_. Nimsuggest will try to return
+syntax <tut2.html#object-oriented-programming-method-call-syntax>`_.
-the suggestions sorted first by scope (from innermost to outermost)
+Nimsuggest will try to return the suggestions sorted first by scope
-and then by item name.
+(from innermost to outermost) and then by item name.
 
 
 Invocation context

doc/tut1.rst

@@ -326,10 +326,11 @@ the compiler that for every other value nothing should be done:
   of 3, 8: echo "The number is 3 or 8"
   else: discard
 
-The empty `discard statement <#procedures-discard-statement>`_ is a *do nothing* statement. The compiler knows
+The empty `discard statement <#procedures-discard-statement>`_ is a *do
-that a case statement with an else part cannot fail and thus the error
+nothing* statement. The compiler knows that a case statement with an else part
-disappears. Note that it is impossible to cover all possible string values:
+cannot fail and thus the error disappears. Note that it is impossible to cover
-that is why string cases always need an ``else`` branch.
+all possible string values: that is why string cases always need an ``else``
+branch.
 
 In general the case statement is used for subrange types or enumerations where
 it is of great help that the compiler checks that you covered any possible
@@ -359,8 +360,8 @@ For statement
 -------------
 
 The ``for`` statement is a construct to loop over any element an *iterator*
-provides. The example uses the built-in `countup <system.html#countup.i,T,T,Positive>`_
+provides. The example uses the built-in `countup
-iterator:
+<system.html#countup.i,T,T,Positive>`_ iterator:
 
 .. code-block:: nim
     :test: "nim c $1"
@@ -371,8 +372,8 @@ iterator:
 
 The variable ``i`` is implicitly declared by the
 ``for`` loop and has the type ``int``, because that is what `countup
-<system.html#countup.i,T,T,Positive>`_ returns. ``i`` runs through the values 1, 2, .., 10.
+<system.html#countup.i,T,T,Positive>`_ returns. ``i`` runs through the values
-Each value is ``echo``-ed. This code does the same:
+1, 2, .., 10. Each value is ``echo``-ed. This code does the same:
 
 .. code-block:: nim
   echo "Counting to 10: "
@@ -570,10 +571,10 @@ an expression is allowed:
 Procedures
 ==========
 
-To define new commands like `echo <system.html#echo,varargs[typed,]>`_ and `readLine
+To define new commands like `echo <system.html#echo,varargs[typed,]>`_
-<io.html#readLine,File>`_ in the examples, the concept of a `procedure`
+and `readLine <io.html#readLine,File>`_ in the examples, the concept of a
-is needed. (Some languages call them *methods* or *functions*.) In Nim new
+`procedure` is needed. (Some languages call them *methods* or *functions*.)
-procedures are defined with the ``proc`` keyword:
+In Nim new procedures are defined with the ``proc`` keyword:
 
 .. code-block:: nim
     :test: "nim c $1"
@@ -845,8 +846,8 @@ Let's return to the simple counting example:
   for i in countup(1, 10):
     echo i
 
-Can a `countup <system.html#countup.i,T,T,Positive>`_ proc be written that supports this
+Can a `countup <system.html#countup.i,T,T,Positive>`_ proc be written that
-loop? Lets try:
+supports this loop? Lets try:
 
 .. code-block:: nim
   proc countup(a, b: int): int =
@@ -1010,8 +1011,8 @@ floats and follow the IEEE-754 standard.
 Automatic type conversion in expressions with different kinds of floating
 point types is performed: the smaller type is converted to the larger. Integer
 types are **not** converted to floating point types automatically, nor vice
-versa. Use the `toInt <system.html#toInt,float>`_ and `toFloat <system.html#toFloat,int>`_
+versa. Use the `toInt <system.html#toInt,float>`_ and
-procs for these conversions.
+`toFloat <system.html#toFloat,int>`_ procs for these conversions.
 
 
 Type Conversion
@@ -1128,8 +1129,8 @@ Operation             Comment
 -----------------     --------------------------------------------------------
 
 The `inc <system.html#inc,T,int>`_, `dec <system.html#dec,T,int>`_, `succ
-<system.html#succ,T,int>`_ and `pred <system.html#pred,T,int>`_ operations can fail by
+<system.html#succ,T,int>`_ and `pred <system.html#pred,T,int>`_ operations can
-raising an `EOutOfRange` or `EOverflow` exception. (If the code has been
+fail by raising an `EOutOfRange` or `EOverflow` exception. (If the code has been
 compiled with the proper runtime checks turned on.)
 
 
@@ -1150,8 +1151,8 @@ compile-time or runtime error. Assignments from the base type to one of its
 subrange types (and vice versa) are allowed.
 
 The ``system`` module defines the important `Natural <system.html#Natural>`_
-type as ``range[0..high(int)]`` (`high <system.html#high,typedesc[T]>`_ returns the
+type as ``range[0..high(int)]`` (`high <system.html#high,typedesc[T]>`_ returns
-maximal value). Other programming languages may suggest the use of unsigned
+the maximal value). Other programming languages may suggest the use of unsigned
 integers for natural numbers. This is often **unwise**: you don't want unsigned
 arithmetic (which wraps around) just because the numbers cannot be negative.
 Nim's ``Natural`` type helps to avoid this common programming error.
@@ -1189,8 +1190,9 @@ Arrays are value types, like any other Nim type. The assignment operator
 copies the whole array contents.
 
 The built-in `len <system.html#len,TOpenArray>`_ proc returns the array's
-length. `low(a) <system.html#low,openArray[T]>`_ returns the lowest valid index for the
+length. `low(a) <system.html#low,openArray[T]>`_ returns the lowest valid index
-array `a` and `high(a) <system.html#high,openArray[T]>`_ the highest valid index.
+for the array `a` and `high(a) <system.html#high,openArray[T]>`_ the highest
+valid index.
 
 .. code-block:: nim
     :test: "nim c $1"
@@ -1266,8 +1268,8 @@ allocated on the heap and garbage collected.
 
 Sequences are always indexed with an ``int`` starting at position 0.  The `len
 <system.html#len,seq[T]>`_, `low <system.html#low,openArray[T]>`_ and `high
-<system.html#high,openArray[T]>`_ operations are available for sequences too.  The notation
+<system.html#high,openArray[T]>`_ operations are available for sequences too.
-``x[i]`` can be used to access the i-th element of ``x``.
+The notation ``x[i]`` can be used to access the i-th element of ``x``.
 
 Sequences can be constructed by the array constructor ``[]`` in conjunction
 with the array to sequence operator ``@``. Another way to allocate space for
@@ -1318,10 +1320,10 @@ Open arrays
 Often fixed size arrays turn out to be too inflexible; procedures should be
 able to deal with arrays of different sizes. The `openarray`:idx: type allows
 this. Openarrays are always indexed with an ``int`` starting at position 0.
-The `len <system.html#len,TOpenArray>`_, `low <system.html#low,openArray[T]>`_ and `high
+The `len <system.html#len,TOpenArray>`_, `low <system.html#low,openArray[T]>`_
-<system.html#high,openArray[T]>`_ operations are available for open arrays too.  Any array
+and `high <system.html#high,openArray[T]>`_ operations are available for open
-with a compatible base type can be passed to an openarray parameter, the index
+arrays too.  Any array with a compatible base type can be passed to an
-type does not matter.
+openarray parameter, the index type does not matter.
 
 .. code-block:: nim
     :test: "nim c $1"
@@ -1561,8 +1563,8 @@ having the same field types.
 
 Tuples can be *unpacked* during variable assignment (and only then!). This can
 be handy to assign directly the fields of the tuples to individually named
-variables. An example of this is the `splitFile <os.html#splitFile,string>`_ proc
+variables. An example of this is the `splitFile <os.html#splitFile,string>`_
-from the `os module <os.html>`_ which returns the directory, name and
+proc from the `os module <os.html>`_ which returns the directory, name and
 extension of a path at the same time. For tuple unpacking to work you must
 use parentheses around the values you want to assign the unpacking to,
 otherwise you will be assigning the same value to all the individual

lib/packages/docutils/rstgen.nim

@@ -154,7 +154,8 @@ proc writeIndexFile*(g: var RstGenerator, outfile: string) =
   ## Writes the current index buffer to the specified output file.
   ##
   ## You previously need to add entries to the index with the `setIndexTerm()
-  ## <#setIndexTerm,RstGenerator,string,string,string,string,string>`_ proc. If the index is empty the file won't be created.
+  ## <#setIndexTerm,RstGenerator,string,string,string,string,string>`_ proc.
+  ## If the index is empty the file won't be created.
   if g.theIndex.len > 0: writeFile(outfile, g.theIndex)
 
 proc addXmlChar(dest: var string, c: char) =
@@ -318,8 +319,9 @@ proc setIndexTerm*(d: var RstGenerator, htmlFile, id, term: string,
   ## columns with their contents will be added.
   ##
   ## The index won't be written to disk unless you call `writeIndexFile()
-  ## <#writeIndexFile,RstGenerator,string>`_. The purpose of the index is documented in the `docgen
+  ## <#writeIndexFile,RstGenerator,string>`_. The purpose of the index is
-  ## tools guide <docgen.html#related-options-index-switch>`_.
+  ## documented in the `docgen tools guide
+  ## <docgen.html#related-options-index-switch>`_.
   var
     entry = term
     isTitle = false
@@ -472,8 +474,8 @@ proc generateSymbolIndex(symbols: seq[IndexEntry]): string =
 proc isDocumentationTitle(hyperlink: string): bool =
   ## Returns true if the hyperlink is actually a documentation title.
   ##
-  ## Documentation titles lack the hash. See `mergeIndexes() <#mergeIndexes,string>`_
+  ## Documentation titles lack the hash. See `mergeIndexes()
-  ## for a more detailed explanation.
+  ## <#mergeIndexes,string>`_ for a more detailed explanation.
   result = hyperlink.find('#') < 0
 
 proc stripTocLevel(s: string): tuple[level: int, text: string] =
@@ -650,8 +652,10 @@ proc mergeIndexes*(dir: string): string =
   ## This proc will first scan `dir` for index files with the ``.idx``
   ## extension previously created by commands like ``nim doc|rst2html``
   ## which use the ``--index:on`` switch. These index files are the result of
-  ## calls to `setIndexTerm() <#setIndexTerm,RstGenerator,string,string,string,string,string>`_ and `writeIndexFile()
+  ## calls to `setIndexTerm()
-  ## <#writeIndexFile,RstGenerator,string>`_, so they are simple tab separated files.
+  ## <#setIndexTerm,RstGenerator,string,string,string,string,string>`_
+  ## and `writeIndexFile() <#writeIndexFile,RstGenerator,string>`_, so they are
+  ## simple tab separated files.
   ##
   ## As convention this proc will split index files into two categories:
   ## documentation and API. API indices will be all joined together into a

lib/pure/collections/sets.nim

@@ -99,8 +99,8 @@ proc init*[A](s: var HashSet[A], initialSize = defaultInitialSize) =
   ##
   ## The `initialSize` parameter needs to be a power of two (default: 64).
   ## If you need to accept runtime values for this, you can use
-  ## `math.nextPowerOfTwo proc <math.html#nextPowerOfTwo,int>`_ or `rightSize proc
+  ## `math.nextPowerOfTwo proc <math.html#nextPowerOfTwo,int>`_ or
-  ## <#rightSize,Natural>`_ from this module.
+  ## `rightSize proc <#rightSize,Natural>`_ from this module.
   ##
   ## Starting from Nim v0.20, sets are initialized by default and it is
   ## not necessary to call this function explicitly.
@@ -645,8 +645,8 @@ proc init*[A](s: var OrderedSet[A], initialSize = defaultInitialSize) =
   ##
   ## The `initialSize` parameter needs to be a power of two (default: 64).
   ## If you need to accept runtime values for this, you can use
-  ## `math.nextPowerOfTwo proc <math.html#nextPowerOfTwo,int>`_ or `rightSize proc
+  ## `math.nextPowerOfTwo proc <math.html#nextPowerOfTwo,int>`_ or
-  ## <#rightSize,Natural>`_ from this module.
+  ## `rightSize proc <#rightSize,Natural>`_ from this module.
   ##
   ## Starting from Nim v0.20, sets are initialized by default and it is
   ## not necessary to call this function explicitly.

lib/pure/collections/tables.nim

@@ -134,7 +134,8 @@
 ##   # 'a': 5, 'b': 2, 'c': 1, 'd': 1, 'r': 2}
 ##
 ## The same could have been achieved by manually iterating over a container
-## and increasing each key's value with `inc proc<#inc,CountTable[A],A,Positive>`_:
+## and increasing each key's value with `inc proc
+## <#inc,CountTable[A],A,Positive>`_:
 ##
 ## .. code-block::
 ##   import tables

lib/pure/memfiles.nim

@@ -432,8 +432,8 @@ iterator lines*(mfile: MemFile, buf: var TaintedString, delim = '\l',
     eat = '\r'): TaintedString {.inline.} =
   ## Replace contents of passed buffer with each new line, like
   ## `readLine(File) <io.html#readLine,File,TaintedString>`_.
-  ## `delim`, `eat`, and delimiting logic is exactly as for
+  ## `delim`, `eat`, and delimiting logic is exactly as for `memSlices
-  ## `memSlices <#memSlices.i,MemFile,char,char>`_, but Nim strings are returned.
+  ## <#memSlices.i,MemFile,char,char>`_, but Nim strings are returned.
   ##
   ## Example:
   ##
@@ -451,8 +451,8 @@ iterator lines*(mfile: MemFile, buf: var TaintedString, delim = '\l',
 iterator lines*(mfile: MemFile, delim = '\l', eat = '\r'): TaintedString {.inline.} =
   ## Return each line in a file as a Nim string, like
   ## `lines(File) <io.html#lines.i,File>`_.
-  ## `delim`, `eat`, and delimiting logic is exactly as for
+  ## `delim`, `eat`, and delimiting logic is exactly as for `memSlices
-  ## `memSlices <#memSlices.i,MemFile,char,char>`_, but Nim strings are returned.
+  ## <#memSlices.i,MemFile,char,char>`_, but Nim strings are returned.
   ##
   ## Example:
   ##

lib/pure/strutils.nim

@@ -631,10 +631,10 @@ iterator rsplit*(s: string, sep: string, maxsplit: int = -1,
 iterator splitLines*(s: string, keepEol = false): string =
   ## Splits the string `s` into its containing lines.
   ##
-  ## Every `character literal <manual.html#lexical-analysis-character-literals>`_ newline
+  ## Every `character literal <manual.html#lexical-analysis-character-literals>`_
-  ## combination (CR, LF, CR-LF) is supported. The result strings contain no
+  ## newline combination (CR, LF, CR-LF) is supported. The result strings
-  ## trailing end of line characters unless parameter ``keepEol`` is set to
+  ## contain no trailing end of line characters unless parameter ``keepEol``
-  ## ``true``.
+  ## is set to ``true``.
   ##
   ## Example:
   ##
@@ -2101,7 +2101,8 @@ proc replace*(s: string, sub, by: char): string {.noSideEffect,
   rtl, extern: "nsuReplaceChar".} =
   ## Replaces `sub` in `s` by the character `by`.
   ##
-  ## Optimized version of `replace <#replace,string,string,string>`_ for characters.
+  ## Optimized version of `replace <#replace,string,string,string>`_ for
+  ## characters.
   ##
   ## See also:
   ## * `find proc<#find,string,char,Natural,int>`_

lib/system.nim

@@ -112,8 +112,8 @@ proc defined*(x: untyped): bool {.magic: "Defined", noSideEffect, compileTime.}
   ## defined.
   ##
   ## `x` is an external symbol introduced through the compiler's
-  ## `-d:x switch <nimc.html#compiler-usage-compile-time-symbols>`_ to enable build time
+  ## `-d:x switch <nimc.html#compiler-usage-compile-time-symbols>`_ to enable
-  ## conditionals:
+  ## build time conditionals:
   ##
   ## .. code-block:: Nim
   ##   when not defined(release):
@@ -784,7 +784,8 @@ type
   AssertionError* = object of Defect ## \
     ## Raised when assertion is proved wrong.
     ##
-    ## Usually the result of using the `assert() template <assertions.html#assert.t,untyped,string>`_.
+    ## Usually the result of using the `assert() template
+    ## <assertions.html#assert.t,untyped,string>`_.
   ValueError* = object of CatchableError ## \
     ## Raised for string and object conversion errors.
   KeyError* = object of ValueError ## \
@@ -2017,8 +2018,8 @@ when defined(boehmgc):
 when taintMode:
   type TaintedString* = distinct string ## A distinct string type that
                                         ## is `tainted`:idx:, see `taint mode
-                                        ## <manual_experimental.html#taint-mode>`_ for
+                                        ## <manual_experimental.html#taint-mode>`_
-                                        ## details. It is an alias for
+                                        ## for details. It is an alias for
                                         ## ``string`` if the taint mode is not
                                         ## turned on.
 
@@ -2026,8 +2027,8 @@ when taintMode:
 else:
   type TaintedString* = string          ## A distinct string type that
                                         ## is `tainted`:idx:, see `taint mode
-                                        ## <manual_experimental.html#taint-mode>`_ for
+                                        ## <manual_experimental.html#taint-mode>`_
-                                        ## details. It is an alias for
+                                        ## for details. It is an alias for
                                         ## ``string`` if the taint mode is not
                                         ## turned on.
 
@@ -3460,14 +3461,15 @@ when defined(nimvarargstyped):
     ## Unlike other IO operations this is guaranteed to be thread-safe as
     ## ``echo`` is very often used for debugging convenience. If you want to use
     ## ``echo`` inside a `proc without side effects
-    ## <manual.html#pragmas-nosideeffect-pragma>`_ you can use `debugEcho <#debugEcho,varargs[typed,]>`_
+    ## <manual.html#pragmas-nosideeffect-pragma>`_ you can use `debugEcho
-    ## instead.
+    ## <#debugEcho,varargs[typed,]>`_ instead.
 
   proc debugEcho*(x: varargs[typed, `$`]) {.magic: "Echo", noSideEffect,
                                             tags: [], raises: [].}
-    ## Same as `echo <#echo,varargs[typed,]>`_, but as a special semantic rule, ``debugEcho``
+    ## Same as `echo <#echo,varargs[typed,]>`_, but as a special semantic rule,
-    ## pretends to be free of side effects, so that it can be used for debugging
+    ## ``debugEcho`` pretends to be free of side effects, so that it can be used
-    ## routines marked as `noSideEffect <manual.html#pragmas-nosideeffect-pragma>`_.
+    ## for debugging routines marked as `noSideEffect
+    ## <manual.html#pragmas-nosideeffect-pragma>`_.
 else:
   proc echo*(x: varargs[untyped, `$`]) {.magic: "Echo", tags: [WriteIOEffect],
     benign, sideEffect.}
@@ -4092,7 +4094,8 @@ proc staticExec*(command: string, input = "", cache = ""): string {.
   ## `gorge <#gorge,string,string,string>`_ is an alias for ``staticExec``.
   ##
   ## Note that you can use this proc inside a pragma like
-  ## `passc <manual.html#implementation-specific-pragmas-passc-pragma>`_ or `passl <manual.html#implementation-specific-pragmas-passl-pragma>`_.
+  ## `passc <manual.html#implementation-specific-pragmas-passc-pragma>`_ or
+  ## `passl <manual.html#implementation-specific-pragmas-passl-pragma>`_.
   ##
   ## If ``cache`` is not empty, the results of ``staticExec`` are cached within
   ## the ``nimcache`` directory. Use ``--forceBuild`` to get rid of this caching

lib/system/nimscript.nim

@@ -311,9 +311,9 @@ proc cd*(dir: string) {.raises: [OSError].} =
   ## Changes the current directory.
   ##
   ## The change is permanent for the rest of the execution, since this is just
-  ## a shortcut for `os.setCurrentDir()
+  ## a shortcut for `os.setCurrentDir() <os.html#setCurrentDir,string>`_ . Use
-  ## <os.html#setCurrentDir,string>`_ . Use the `withDir()
+  ## the `withDir() <#withDir.t,string,untyped>`_ template if you want to
-  ## <#withDir.t,string,untyped>`_ template if you want to perform a temporary change only.
+  ## perform a temporary change only.
   setCurrentDir(dir)
   checkOsError()
 
@@ -326,7 +326,8 @@ proc findExe*(bin: string): string =
 template withDir*(dir: string; body: untyped): untyped =
   ## Changes the current directory temporarily.
   ##
-  ## If you need a permanent change, use the `cd() <#cd,string>`_ proc. Usage example:
+  ## If you need a permanent change, use the `cd() <#cd,string>`_ proc.
+  ## Usage example:
   ##
   ## .. code-block:: nim
   ##   withDir "foo":