Update syntax highlight tags for example code blocks (#967)

Mostly add `julia-repl` for more specific highlighting.

Author: abhro

docs/src/config.md

@@ -167,7 +167,7 @@ fs.inotify.max_user_watches = 524288
 ```
 
 For Revise usage, `max_user_watches >= 65536` is recommended, and more can be helpful; the value of 524288 above is common on modern systems. One can set higher values as needed, e.g.,
-```
+```sh
 $ sudo sysctl fs.inotify.max_user_instances=2048
 ```
 After changing these values, it is advised to run Revise's unit tests to see if they pass.

docs/src/cookbook.md

@@ -45,7 +45,7 @@ Both options are described below.
 
 Let's create a new package, `MyPkg`, to play with.
 
-```julia
+```julia-repl
 julia> using PkgTemplates
 
 julia> t = Template()
@@ -73,15 +73,15 @@ the directory `/home/tim/.julia/dev/MyPkg`.
 Press `]` to enter the [Pkg REPL](https://pkgdocs.julialang.org/v1/getting-started/#Basic-Usage).
 Then add the new package to your current environment with the `dev` command.
 
-```julia
+```julia-repl
 (<environment>) pkg> dev MyPkg   # the dev command will look in the ~/.julia/dev folder automatically
 ```
 
 Press the backspace key to return to the Julia REPL.
 
 Now let's try it out:
 
-```julia
+```julia-repl
 julia> using Revise   # you must do this before loading any revisable packages
 
 julia> using MyPkg
@@ -94,7 +94,7 @@ You'll note that Julia found your package without you having to take any extra s
 *Without* quitting this Julia session, open the `MyPkg.jl` file in an editor.
 You might be able to open it with
 
-```julia
+```julia-repl
 julia> edit(pathof(MyPkg))
 ```
 
@@ -124,7 +124,7 @@ end # module
 Now go back to that same Julia session, and try calling `greet`.
 After a pause (while Revise's internal code compiles), you should see
 
-```julia
+```julia-repl
 julia> MyPkg.greet()
 Hello World!
 ```
@@ -141,7 +141,7 @@ Let's create a blank `MyPkg` using `Pkg`. (If you tried the `PkgTemplates` versi
 above, you might first have to delete the package with `Pkg.rm("MyPkg")` following by
 a complete removal from your `dev` directory.)
 
-```julia
+```julia-repl
 julia> using Revise, Pkg
 
 julia> cd(Pkg.devdir())   # take us to the standard "development directory"
@@ -161,7 +161,7 @@ then type `generate MyPkg`.
 The next line, `dev MyPkg`, is necessary to tell `Pkg` about the existence of this new package.
 
 Now you can do the following:
-```julia
+```julia-repl
 julia> using MyPkg
 [ Info: Precompiling MyPkg [efe7ebfe-4313-4388-9b6c-3590daf47143]
 
@@ -193,7 +193,7 @@ Save it as `mygreet.jl` in some directory. Here we will assume it's being saved
 
 Now load the code with `includet`, which stands for "include and track":
 
-```julia
+```julia-repl
 julia> using Revise
 
 julia> includet("/tmp/mygreet.jl")
@@ -210,7 +210,7 @@ mygreeting() = "Hello, revised world!"
 
 and then try it in the same session:
 
-```julia
+```julia-repl
 julia> mygreeting()
 "Hello, revised world!"
 ```

docs/src/internals.md

@@ -8,7 +8,7 @@ Revise is based on the fact that you can change functions even when
 they are defined in other modules.
 Here's an example showing how you do that manually (without using Revise):
 
-```julia
+```julia-repl
 julia> convert(Float64, π)
 3.141592653589793
 
@@ -149,14 +149,14 @@ There are several reasons that make this an attractive approach, of which the mo
 - for methods generated by code, the only really reliable mechanism to compute all the signatures is to step through the code that generates the methods. That is performed using [JuliaInterpreter](https://github.com/JuliaDebug/JuliaInterpreter.jl).
 
 As an example, suppose the following code is part of your module definition:
-```
+```julia
 for T in (Float16, Float32, Float64)
     @eval sizefloat(x::$T) = sizeof($T)
 end
 ```
 !!! tip "clarification"
     This is equivalent to the following explicit definitions:
-    ```
+    ```julia
     sizefloat(x::Float16) = 2
     sizefloat(x::Float32) = 4
     sizefloat(x::Float64) = 8
@@ -166,7 +166,7 @@ If you replace the loop with `for T in (Float32, Float64)`, then Revise should d
 
 Because lowered code is far simpler than ordinary Julia code, it is much easier to interpret. Let's look briefly at a method definition:
 
-```
+```julia
 floatwins(x::AbstractFloat, y::Integer) = x
 ```
 
@@ -297,7 +297,7 @@ indent(::UInt8)  = 4
 If you create this as a mini-package and then say `using Revise, Items`, you can start
 examining internal variables in the following manner:
 
-```julia
+```julia-repl
 julia> id = Base.PkgId(Items)
 Items [b24a5932-55ed-11e9-2a88-e52f99e65a0d]
 
@@ -310,7 +310,7 @@ PkgData(Items [b24a5932-55ed-11e9-2a88-e52f99e65a0d]:
 (Your specific UUID may differ.)
 
 Path information is stored in `pkgdata.info`:
-```julia
+```julia-repl
 julia> pkgdata.info
 PkgFiles(Items [b24a5932-55ed-11e9-2a88-e52f99e65a0d]):
   basedir: "/tmp/pkgs/Items"
@@ -323,7 +323,7 @@ package manager.
 
 `src/indents.jl` is particularly simple:
 
-```julia
+```julia-repl
 julia> pkgdata.fileinfos[2]
 FileInfo(Items=>ExprsSigs with the following expressions:
   :(indent(::UInt16) = begin
@@ -336,7 +336,7 @@ FileInfo(Items=>ExprsSigs with the following expressions:
 
 This is just a summary; to see the actual `def=>mt_sigts` map, do the following:
 
-```julia
+```julia-repl
 julia> pkgdata.fileinfos[2].modexsigs[Items]
 OrderedCollections.OrderedDict{Module, OrderedCollections.OrderedDict{Revise.RelocatableExpr, Union{Nothing, Vector{Pair{Union{Nothing, Core.MethodTable}, Type}}}}} with 2 entries:
   :(indent(::UInt16) = begin…                       => Pair{Union{Nothing, MethodTable}, Type}[nothing => Tuple{typeof(indent),UInt16}]

docs/src/limitations.md

@@ -10,7 +10,7 @@ These kinds of changes require that you restart your Julia session.
 
 During early stages of development, it's quite common to want to change type definitions. You can work around Julia's/Revise's limitations by temporary renaming. We'll illustrate this below, using `write` to be explicit about when updates to the file happen. But in ordinary usage, these are changes you'd likely make with your editor.
 
-```julia
+```julia-repl
 julia> using Pkg, Revise
 
 julia> Pkg.generate("MyPkg")
@@ -83,7 +83,7 @@ This works as long as the new type name doesn't conflict with an existing name;
 
 Once your development has converged on a solution, it's best to switch to the "permanent" name: in the example above, `FooStruct` is a non-constant global variable, and if used internally in a function there will be consequent performance penalties. Switching to the permanent name will force you to restart your session.
 
-```julia
+```julia-repl
 julia> isconst(MyPkg, :FooStruct)
 true
 

docs/src/tricks.md

@@ -4,7 +4,7 @@
 
 Updating the code in Julia's REPL stdlib requires some extra trickery, because modified method definitions can't be deployed until you exit any currently-running REPL functions, like those handling the prompt that you're using to interact with Julia. A workaround is to create a sub-REPL that you can shut down, and then restart a new one whenever you want to test new code:
 
-```
+```julia
 using Revise
 using REPL
 Revise.track(REPL)

src/Revise.jl

@@ -2,7 +2,7 @@
 Revise.jl tracks source code changes and incorporates the changes to a running Julia session.
 
 Revise.jl works behind-the-scenes. To track a package, e.g. `Example`:
-```julia
+```julia-repl
 (@v1.6) pkg> dev Example        # make a development copy of the package
 [...pkg output omitted...]