remove math font from tick font dict

Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>

.github/workflows/SnoopCompile.yml

@@ -16,15 +16,17 @@ jobs:
     if: "!contains(github.event.head_commit.message, '[skip ci]')"
     env:
       GKS_ENCODING: "utf8"
-      GKSwstype: "100"
+      GKSwstype: "nul"
       PLOTS_TEST: "true"
     runs-on: ${{matrix.os}}
+    continue-on-error: ${{ matrix.version == '~1.8.0-0' }}
     strategy:
       fail-fast: false
       matrix:
         version:   # NOTE: the versions below should match those in your botconfig
           - '1.6'       # ⎤
           - '1.7'       # |
+          - '~1.8.0-0'  # |
           # - 'nightly'   # ⎦ <<< keep these versions in sync with deps/SnoopCompile/snoop_bot_config.jl
           # ^^^^^^^^^ for 'nightly', see github.com/JuliaPlots/Plots.jl/issues/4079
         os:        # NOTE: should match the os setting of your botconfig
@@ -38,8 +40,18 @@ jobs:
         with:
           version: ${{matrix.version}}
           
+      - name: Set Swap Space
+        uses: pierotofy/set-swap-space@master
+        with:
+          swap-size-gb: 10  # required (not enough memory on github actions virtual machine)
+
       - name: Install dependencies
         run: |
+          cat /proc/cpuinfo
+          cat /proc/meminfo
+          cat /proc/swaps
+          free
+          df -h
           julia --project -e 'using Pkg; Pkg.instantiate()'
           julia -e 'using Pkg; Pkg.add(PackageSpec(name="CompileBot", version="1")); Pkg.develop(PackageSpec(; path=pwd())); using CompileBot; CompileBot.addtestdep()'
 
@@ -88,7 +100,6 @@ jobs:
             no changelog
           branch: "Test_SnoopCompile_AutoPR_${{ github.ref }}"
 
-
   Skip:
     if: "contains(github.event.head_commit.message, '[skip ci]')"
     runs-on: ubuntu-latest

.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
     if: "!contains(github.event.head_commit.message, '[skip ci]')"
     env:
       GKS_ENCODING: "utf8"
-      GKSwstype: "100"
+      GKSwstype: "nul"
 
     name: Julia ${{ matrix.version }} - ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
@@ -55,19 +55,16 @@ jobs:
             ${{ runner.os }}-test-
             ${{ runner.os }}-
 
-      ## maybe required if we ever want to run graphical tests for plotly
-      # OS Dependencies
-      # - name: Ubuntu OS dependencies
-      #   if: startsWith(matrix.os,'ubuntu')
-      #   run: |
-      #    ./test/install_wkhtmltoimage.sh
-
       # TESTCMD
       - name: Default TESTCMD
         run: echo "TESTCMD=julia" >> $GITHUB_ENV
       - name: Ubuntu TESTCMD
         if: startsWith(matrix.os,'ubuntu')
-        run: echo "TESTCMD=xvfb-run --auto-servernum julia" >> $GITHUB_ENV
+        run: |
+          echo "TESTCMD=xvfb-run --auto-servernum julia" >> $GITHUB_ENV
+          sudo apt-get -y update
+          sudo apt-get -y install gnuplot poppler-utils texlive-{latex-base,latex-extra,luatex}
+          sudo fc-cache -vr
 
       # Julia Dependencies
       - name: Install Julia dependencies
@@ -82,7 +79,9 @@ jobs:
 
       # Codecov
       - uses: julia-actions/julia-processcoverage@v1
+        if: startsWith(matrix.os,'ubuntu')
       - uses: codecov/codecov-action@v2
+        if: startsWith(matrix.os,'ubuntu')
         with:
           file: lcov.info
 

.github/workflows/docs.yml

@@ -9,7 +9,7 @@ on:
  
 jobs:
   Build_docs:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
         with:
@@ -26,37 +26,9 @@ jobs:
             ${{runner.os}}-test-${{env.cache-name}}-
             ${{runner.os}}-test-
             ${{runner.os}}-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y qt5-default \
-            ttf-mscorefonts-installer \
-            poppler-utils \
-            pdf2svg \
-            texlive-latex-base \
-            texlive-binaries \
-            texlive-pictures \
-            texlive-latex-extra \
-            texlive-luatex \
-            ghostscript-x \
-            libgconf2-4 \
-            gnuplot
-          sudo fc-cache -vr
-            
-      - name: build documentation
+      - name: Build documentation
         env:
           PYTHON: ""
           DOCUMENTER_KEY: ${{secrets.DOCUMENTER_KEY}}
-        run: |
-          echo $GITHUB_REF
-          export JULIA_DEBUG=Documenter,DemoCards
-          export PLOTDOCS_ANSICOLOR=true
-          export GKSwstype=nul  # Plots.jl/issues/3664
-          export DOCUMENTER_DEBUG=true  # Democards.jl
-          # export UP_DEBUG_IO=$(mktemp)
-          xvfb-run julia --color=yes --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.add(PackageSpec(name="Plots", rev=split(ENV["GITHUB_REF"], "/", limit=3)[3])); Pkg.instantiate()'
-          # xvfb-run julia --color=yes --project=docs/ -e 'using Pkg; pkg"add Documenter#master"'
-          xvfb-run julia --color=yes --project=docs/ -e 'using Pkg; pkg"st -m"'
-          xvfb-run julia --color=yes --project=docs/ -e 'withenv("GITHUB_REPOSITORY" => "JuliaPlots/PlotDocs.jl") do; include("docs/make.jl"); end'
-          # cat $UP_DEBUG_IO | sed 's,\x1B,ESC,g'
-          # rm $UP_DEBUG_IO
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+        run: bash docs/ci_build.sh

.zenodo.json

@@ -142,6 +142,8 @@
         },
         {
             "name": "Anshul Singhvi",
+            "affiliation": "Columbia University",
+            "orcid": "0000-0001-6055-1291",
             "type": "Other"
         },
         {
@@ -706,6 +708,14 @@
         {
             "name": "Tom Gillam",
             "type": "Other"
+        },
+        {
+            "name": "Steve Leung",
+            "type": "Other"
+        },
+        {
+            "name": "Xu Zhi-Yuan",
+            "type": "Other"
         }
     ],
     "upload_type": "software"

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.27.3"
+version = "1.29.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -47,7 +47,7 @@ Latexify = "0.14 - 0.15"
 Measures = "0.3"
 NaNMath = "0.3, 1"
 PGFPlotsX = "1"
-PlotThemes = "2"
+PlotThemes = "2, 3"
 PlotUtils = "1"
 PlotlyBase = "0.7"
 PlotlyJS = "0.18"
@@ -68,10 +68,12 @@ julia = "1.6"
 Colors = "5ae59095-9a9b-59fe-a467-6f913c188581"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
+Gaston = "4b11ee91-296f-5714-9832-002c20994614"
 Gtk = "4c0ca9eb-093a-5379-98c5-f87ac0bbbf44"
 HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
 ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
 Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
+InspectDR = "d0351b0e-4b05-5898-87b3-e2a8edfddd1d"
 LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925"
@@ -88,4 +90,4 @@ UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"
 
 [targets]
-test = ["Colors", "Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "PlotlyJS", "PlotlyBase", "PyPlot", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]
+test = ["Colors", "Distributions", "FileIO", "Gaston", "Gtk", "ImageMagick", "Images", "InspectDR", "LibGit2", "OffsetArrays", "PGFPlotsX", "PlotlyJS", "PlotlyBase", "PyPlot", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]

deps/SnoopCompile/precompile/1.6/precompile_Plots.jl

@@ -66,24 +66,19 @@ end
 
 function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(areaplot)),Any,typeof(areaplot),Any,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:foreground_color_grid, :grid, :gridalpha, :gridstyle, :gridlinewidth), Tuple{RGBA{Float64}, Bool, Float64, Symbol, Int64}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
@@ -92,8 +87,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid,), Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
@@ -108,7 +101,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:rotation, :color), Tuple{Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
@@ -143,13 +135,12 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg), Tuple{Tuple{Int64, Float64, PlotText}, Bool}},typeof(plot),Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,), Tuple{Int64}},typeof(plot),Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bar_width, :alpha, :color, :fillto, :label, :seriestype), Tuple{Float64, Float64, Vector{Symbol}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, String, Symbol}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
@@ -201,6 +192,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriescolor, :fillalpha), Tuple{Matrix{Symbol}, Matrix{Float64}}},typeof(plot),AreaPlot})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{DateTime},UnitRange{Int64},Matrix{Float64}})
@@ -249,17 +241,17 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    Base.precompile(Tuple{typeof(_bin_centers),Vector{Float64}})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Float64},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Int64},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Nothing},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
-    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),UnitRange{Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Int64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Int64},UnitRange{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
     Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
@@ -278,6 +270,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
     Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
+    Base.precompile(Tuple{typeof(default),Symbol,Bool})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
@@ -305,16 +298,19 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Vector{Int64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
     Base.precompile(Tuple{typeof(gr_get_3d_axis_angle),Vector{Float64},Float64,Float64,Symbol})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
-    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Int64}, Vector{String}},Int64})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
@@ -330,7 +326,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
-    Base.precompile(Tuple{typeof(layout_args),Matrix{Any}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
     Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
@@ -355,7 +350,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Stroke})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
@@ -366,7 +360,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
-    Base.precompile(Tuple{typeof(reset_axis_defaults_byletter!)})
+    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Int64, Int64, Float64},Tuple{Int64, Int64, Float64}})
     Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
     Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
@@ -374,10 +368,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Symbol},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any, N} where N})
@@ -386,10 +377,10 @@ function _precompile_()
     Base.precompile(Tuple{typeof(warn_on_attr_dim_mismatch),Series,Vector{Float64},Vector{Float64},Nothing,Base.Iterators.Flatten{Vector{Tuple{SeriesSegment}}}})
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    isdefined(Plots, Symbol("#162#163")) && Base.precompile(Tuple{getfield(Plots, Symbol("#162#163")),Any})
+    isdefined(Plots, Symbol("#166#167")) && Base.precompile(Tuple{getfield(Plots, Symbol("#166#167")),Any})
     isdefined(Plots, Symbol("#2#6")) && Base.precompile(Tuple{getfield(Plots, Symbol("#2#6")),UnitRange{Int64}})
-    isdefined(Plots, Symbol("#291#327")) && Base.precompile(Tuple{getfield(Plots, Symbol("#291#327"))})
-    isdefined(Plots, Symbol("#312#348")) && Base.precompile(Tuple{getfield(Plots, Symbol("#312#348"))})
+    isdefined(Plots, Symbol("#295#331")) && Base.precompile(Tuple{getfield(Plots, Symbol("#295#331"))})
+    isdefined(Plots, Symbol("#316#352")) && Base.precompile(Tuple{getfield(Plots, Symbol("#316#352"))})
     isdefined(Plots, Symbol("#add_major_or_minor_segments#100")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#100")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
     isdefined(Plots, Symbol("#add_major_or_minor_segments#101")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#101")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
     let fbody = try __lookup_kwbody__(which(font, (Font,Vararg{Any, N} where N,))) catch missing end
@@ -406,11 +397,6 @@ end
     if !ismissing(fbody)
         precompile(fbody, (Symbol,Symbol,RGBA{Float64},Float64,typeof(gr_set_font),Font,Subplot{GRBackend},))
     end
-end
-    let fbody = try __lookup_kwbody__(which(pie, (Any,Vararg{Any, N} where N,))) catch missing end
-    if !ismissing(fbody)
-        precompile(fbody, (Any,typeof(pie),Any,Vararg{Any, N} where N,))
-    end
 end
     let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
     if !ismissing(fbody)
@@ -461,10 +447,5 @@ end
     if !ismissing(fbody)
         precompile(fbody, (Any,typeof(title!),AbstractString,))
     end
-end
-    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any, N} where N,))) catch missing end
-    if !ismissing(fbody)
-        precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any, N} where N,))
-    end
 end
 end

deps/SnoopCompile/precompile/1.7/precompile_Plots.jl

@@ -74,7 +74,9 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(areaplot)),Any,typeof(areaplot),Any,Vararg{Any}})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:foreground_color_grid, :grid, :gridalpha, :gridstyle, :gridlinewidth), Tuple{RGBA{Float64}, Bool, Float64, Symbol, Int64}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
@@ -83,7 +85,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
@@ -146,7 +147,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
@@ -205,6 +205,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64, Int64}, LinRange{Float64, Int64}}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriescolor, :fillalpha), Tuple{Matrix{Symbol}, Matrix{Float64}}},typeof(plot),AreaPlot})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{DateTime},UnitRange{Int64},Matrix{Float64}})
@@ -221,6 +222,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w), Tuple{StepRange{Int64, Int64}, Tuple{Int64, Float64, Symbol, Stroke}, Bool, Bool, Int64}},typeof(plot),Vector{Float64},Vector{Float64},UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any}})
     Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any})
+    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip, :disp), Tuple{Vector{Int64}, Bool}},typeof(test_examples),Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,), Tuple{Vector{Int64}}},typeof(test_examples),Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(yaxis!)),Any,typeof(yaxis!),Any,Any})
     Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64}})
@@ -265,8 +267,12 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
     Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),UnitRange{Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Int64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Int64},UnitRange{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
     Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
@@ -287,6 +293,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
     Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64},Tuple{Int64, Float64}})
+    Base.precompile(Tuple{typeof(discrete_value!),Axis,Vector{Union{Missing, Float64}}})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}}})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
@@ -310,20 +317,24 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64},Int64,Int64})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,UnitRange{Int64},Vector{Float64},Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Vector{Int64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Int64},Vector{Int64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
@@ -338,6 +349,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_polyline),Vector{Float64},Vector{Float64},Function})
     Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
     Base.precompile(Tuple{typeof(gr_text),Float64,Float64,String})
+    Base.precompile(Tuple{typeof(gr_text_size),String})
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}}})
     Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
@@ -357,12 +369,14 @@ function _precompile_()
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),UnitRange{Int64},Tuple{Float64, Float64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(partialcircle),Float64,Float64,Int64})
     Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
+    Base.precompile(Tuple{typeof(plot!),Any})
+    Base.precompile(Tuple{typeof(plot!),Plot,Plot,Plot,Vararg{Plot}})
     Base.precompile(Tuple{typeof(plot),Any,Any})
     Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
     Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend}})
     Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}}})
     Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
-    Base.precompile(Tuple{typeof(plotarea!),EmptyLayout,BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}}})
     Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
@@ -370,6 +384,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Stroke})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
@@ -381,7 +396,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
     Base.precompile(Tuple{typeof(quiver_using_arrows),DefaultsDict})
-    Base.precompile(Tuple{typeof(quiver_using_hack),DefaultsDict})
     Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
     Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
@@ -392,6 +406,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Symbol},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any}})
@@ -402,11 +417,11 @@ function _precompile_()
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any}})
     Base.precompile(Tuple{typeof(xgrid!),Plot{PlotlyBackend},Symbol,Vararg{Any}})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    isdefined(Plots, Symbol("#164#165")) && Base.precompile(Tuple{getfield(Plots, Symbol("#164#165")),Any})
-    isdefined(Plots, Symbol("#166#167")) && Base.precompile(Tuple{getfield(Plots, Symbol("#166#167")),Any})
+    isdefined(Plots, Symbol("#168#169")) && Base.precompile(Tuple{getfield(Plots, Symbol("#168#169")),Any})
+    isdefined(Plots, Symbol("#170#171")) && Base.precompile(Tuple{getfield(Plots, Symbol("#170#171")),Any})
     isdefined(Plots, Symbol("#2#6")) && Base.precompile(Tuple{getfield(Plots, Symbol("#2#6")),UnitRange{Int64}})
-    isdefined(Plots, Symbol("#297#333")) && Base.precompile(Tuple{getfield(Plots, Symbol("#297#333"))})
-    isdefined(Plots, Symbol("#318#354")) && Base.precompile(Tuple{getfield(Plots, Symbol("#318#354"))})
+    isdefined(Plots, Symbol("#301#337")) && Base.precompile(Tuple{getfield(Plots, Symbol("#301#337"))})
+    isdefined(Plots, Symbol("#322#358")) && Base.precompile(Tuple{getfield(Plots, Symbol("#322#358"))})
     isdefined(Plots, Symbol("#add_major_or_minor_segments#102")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#102")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
     isdefined(Plots, Symbol("#add_major_or_minor_segments#103")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#103")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
     let fbody = try __lookup_kwbody__(which(annotate!, (AbstractVector{<:Tuple},))) catch missing end
@@ -423,11 +438,31 @@ end
     if !ismissing(fbody)
         precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Vector{Float64},Vector{Float64},typeof(GR.fillarea),))
     end
+end
+    let fbody = try __lookup_kwbody__(which(gr_set_font, (Font,Subplot{GRBackend},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Symbol,Symbol,RGBA{Float64},Float64,typeof(gr_set_font),Font,Subplot{GRBackend},))
+    end
 end
     let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any},))) catch missing end
     if !ismissing(fbody)
         precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Any,Vararg{Any},))
     end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,Plot,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Plot,Plot,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,Plot,Plot,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Plot,Plot,Plot,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,Plot,Plot,Vararg{Plot},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Plot,Plot,Plot,Vararg{Plot},))
+    end
 end
     let fbody = try __lookup_kwbody__(which(plot, (Any,))) catch missing end
     if !ismissing(fbody)

deps/SnoopCompile/precompile/1.8/precompile_Plots.jl

@@ -15,37 +15,22 @@ end
 
 function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
-    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRange{Int64, Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:rotation, :color), Tuple{Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
@@ -73,15 +58,15 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg), Tuple{Tuple{Int64, Float64, PlotText}, Bool}},typeof(plot),Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,), Tuple{Int64}},typeof(plot),Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bar_width, :alpha, :color, :fillto, :label, :seriestype), Tuple{Float64, Float64, Vector{Symbol}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, String, Symbol}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
@@ -141,6 +126,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:xaxis, :background_color, :leg), Tuple{Tuple{String, Tuple{Int64, Int64}, StepRange{Int64, Int64}, Symbol}, RGB{Float64}, Bool}},typeof(plot),Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w), Tuple{StepRange{Int64, Int64}, Tuple{Int64, Float64, Symbol, Stroke}, Bool, Bool, Int64}},typeof(plot),Vector{Float64},Vector{Float64},UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any}})
+    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip, :disp), Tuple{Vector{Int64}, Bool}},typeof(test_examples),Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,), Tuple{Vector{Int64}}},typeof(test_examples),Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(yaxis!)),Any,typeof(yaxis!),Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},AbstractVector{OHLC}})
@@ -151,9 +137,11 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:histogram2d}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hline}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hspan}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vspan}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:xerror}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Vector{ComplexF64}})
@@ -168,16 +156,13 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}},String})
-    Base.precompile(Tuple{typeof(_cycle),ColorPalette,Int64})
+    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
-    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
     Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Vector{Float64}})
     Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
-    Base.precompile(Tuple{typeof(_replace_markershape),Vector{Symbol}})
     Base.precompile(Tuple{typeof(_update_min_padding!),GridLayout})
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{GRBackend},Subplot{GRBackend},Dict{Symbol, Any},Int64,Bool})
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{PlotlyBackend},Subplot{PlotlyBackend},Dict{Symbol, Any},Int64,Bool})
@@ -191,12 +176,14 @@ function _precompile_()
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
     Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64},Tuple{Int64, Float64}})
+    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}}})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
     Base.precompile(Tuple{typeof(fakedata),Int64,Int64})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_series_color),SubArray{Symbol, 1, Vector{Symbol}, Tuple{UnitRange{Int64}}, true},Subplot{GRBackend},Int64,Symbol})
+    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
     Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{PlotlyBackend},Int64,Symbol})
     Base.precompile(Tuple{typeof(get_ticks),StepRange{Int64, Int64},Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any}})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any}})
@@ -211,9 +198,10 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64},Int64,Int64})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
@@ -221,7 +209,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
-    Base.precompile(Tuple{typeof(gr_get_3d_axis_angle),Vector{Float64},Float64,Float64,Symbol})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
@@ -229,20 +216,17 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
     Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
     Base.precompile(Tuple{typeof(gr_text),Float64,Float64,String})
+    Base.precompile(Tuple{typeof(gr_text_size),String})
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}}})
     Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
-    Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
     Base.precompile(Tuple{typeof(is_marker_supported),GRBackend,Vector{Symbol}})
-    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
-    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
+    Base.precompile(Tuple{typeof(layout_args),Matrix{Any}})
     Base.precompile(Tuple{typeof(link_axes!),GridLayout,Symbol})
-    Base.precompile(Tuple{typeof(make_steps),Vector{Float64},Symbol,Bool})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
@@ -252,13 +236,14 @@ function _precompile_()
     Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
     Base.precompile(Tuple{typeof(plot!),Plot,Plot,Plot,Vararg{Plot}})
     Base.precompile(Tuple{typeof(plot),Any,Any})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
     Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend}})
     Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
-    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Int64})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText,Font})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol},Font})
@@ -272,17 +257,15 @@ function _precompile_()
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String},Font})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
-    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},String,Symbol})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
-    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64}},Tuple{Int64, Int64},Tuple{Float64, Int64}})
+    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Float64, Int64, Int64},Tuple{Float64, Int64, Int64}})
     Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
-    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(title!),AbstractString})
@@ -292,8 +275,8 @@ function _precompile_()
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any}})
     Base.precompile(Tuple{typeof(xgrid!),Plot{PlotlyBackend},Symbol,Vararg{Any}})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    isdefined(Plots, Symbol("#303#339")) && Base.precompile(Tuple{getfield(Plots, Symbol("#303#339"))})
-    isdefined(Plots, Symbol("#4#8")) && Base.precompile(Tuple{getfield(Plots, Symbol("#4#8")),UnitRange{Int64}})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#104")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#104")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#105")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#105")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#2#6")) && Base.precompile(Tuple{getfield(Plots, Symbol("#2#6")),UnitRange{Int64}})
+    isdefined(Plots, Symbol("#322#358")) && Base.precompile(Tuple{getfield(Plots, Symbol("#322#358"))})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#102")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#102")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#103")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#103")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
 end

deps/SnoopCompile/snoop_bot_config.jl

@@ -2,6 +2,6 @@ using CompileBot
 
 botconfig = BotConfig(
     "Plots",
-    version = ["1.6", "1.7", "nightly"],  # <<< keep these versions in sync with .github/workflows/SnoopCompile.yml
+    version = ["1.6", "1.7", "1.8", "nightly"],  # <<< keep these versions in sync with .github/workflows/SnoopCompile.yml
     # else_version = "nightly",
 )

src/arg_desc.jl

@@ -32,7 +32,8 @@ const _arg_desc = KW(
     :line_z             => "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series line segment, which correspond to the color to be used from a linecolor gradient.  Note that for N points, only the first N-1 values are used (one per line-segment).",
     :fill_z             => "Matrix{Float64} of the same size as z matrix, which specifies the color of the 3D surface; the default value is `nothing`.",
     :levels             => "Integer (number of contours) or AbstractVector (contour values). Determines contour levels for a contour type.",
-    :orientation        => "Symbol.  Horizontal or vertical orientation for bar types.  Values `:h`, `:hor`, `:horizontal` correspond to horizontal (sideways, anchored to y-axis), and `:v`, `:vert`, and `:vertical` correspond to vertical (the default).",
+    :permute            => "Tuple{Symbol,Symbol}. Permutes data and axis properties of the axes given in the tuple. E.g. (:x, :y).",
+    :orientation        => "Symbol. (deprecated) Horizontal or vertical orientation for bar types.  Values `:h`, `:hor`, `:horizontal` correspond to horizontal (sideways, anchored to y-axis), and `:v`, `:vert`, and `:vertical` correspond to vertical (the default).",
     :bar_position       => "Symbol.  Choose from `:overlay` (default), `:stack`.  (warning: May not be implemented fully)",
     :bar_width          => "nothing or Number. Width of bars in data coordinates. When nothing, chooses based on x (or y when `orientation = :h`).",
     :bar_edges          => "Bool.  Align bars to edges (true), or centers (the default)?",

src/args.jl

@@ -400,6 +400,7 @@ const _series_defaults = KW(
     :stride       => (1, 1),    # array stride for wireframe/surface, the first element is the row stride and the second is the column stride.
     :connections  => nothing,  # tuple of arrays to specifiy connectivity of a 3d mesh
     :z_order      => :front, # one of :front, :back or integer in 1:length(sp.series_list)
+    :permute      => :none, # tuple of two symbols to be permuted
     :extra_kwargs => Dict(),
 )
 
@@ -1611,7 +1612,7 @@ function warn_on_unsupported_args(pkg::AbstractBackend, plotattributes)
     already_warned = get!(_already_warned, bend, Set{Symbol}())
     extra_kwargs = Dict{Symbol,Any}()
     for k in keys(plotattributes)
-        is_attr_supported(pkg, k) && continue
+        is_attr_supported(pkg, k) && !(k in keys(_deprecated_attributes)) && continue
         k in _suppress_warnings && continue
         default_value = default(k)
         if ismissing(default_value)
@@ -1625,11 +1626,18 @@ function warn_on_unsupported_args(pkg::AbstractBackend, plotattributes)
        get(plotattributes, :warn_on_unsupported, should_warn_on_unsupported(pkg))
         for k in sort(collect(_to_warn))
             push!(already_warned, k)
+            if k in keys(_deprecated_attributes)
+                @warn("""
+                Keyword argument `$k` is deprecated.
+                Please use `$(_deprecated_attributes[k])` instead.
+                """)
+            else
                 @warn(
-                "Keyword argument $k not supported with $pkg.  Choose from: $(supported_attrs(pkg))"
+                    "Keyword argument $k not supported with $pkg.  Choose from: $(join(supported_attrs(pkg), ", "))"
                 )
             end
         end
+    end
     return extra_kwargs
 end
 

src/axes.jl

@@ -675,6 +675,15 @@ end
 # these methods track the discrete (categorical) values which correspond to axis continuous values (cv)
 # whenever we have discrete values, we automatically set the ticks to match.
 # we return (continuous_value, discrete_index)
+function discrete_value!(plotattributes, letter::Symbol, dv)
+    l = if plotattributes[:permute] !== :none
+        only(filter(!=(letter), plotattributes[:permute]))
+    else
+        letter
+    end
+    discrete_value!(plotattributes[:subplot][get_attr_symbol(l, :axis)], dv)
+end
+
 function discrete_value!(axis::Axis, dv)
     cv_idx = get(axis[:discrete_map], dv, -1)
     if cv_idx == -1

src/backends.jl

@@ -241,6 +241,7 @@ const _base_supported_args = [
     :projection,
     :show_empty_bins,
     :z_order,
+    :permute,
 ]
 
 function merge_with_base_supported(v::AVec)
@@ -285,7 +286,7 @@ for s in (:attr, :seriestype, :marker, :style, :scale)
         v = Symbol("_", bend, "_", s)
         @eval begin
             $f(::$bend_type, $s::Symbol) = $s in $v
-            $f2(::$bend_type) = $v
+            $f2(::$bend_type) = sort(collect($v))
         end
     end
 end
@@ -301,7 +302,7 @@ function _initialize_backend(pkg::AbstractBackend)
     @eval Main begin
         import $sym
         export $sym
-        Plots._check_compat($sym)
+        $(_check_compat)($sym)
     end
 end
 
@@ -348,6 +349,7 @@ const _gr_attr = merge_with_base_supported([
     :fillrange,
     :fillcolor,
     :fillalpha,
+    :fillstyle,
     :bins,
     :layout,
     :title,
@@ -948,6 +950,7 @@ const _unicodeplots_seriestype = [
     :heatmap,
     :contour,
     # :contour3d,
+    :permute,
     :spy,
     :surface,
     :wireframe,
@@ -1320,7 +1323,6 @@ const _pgfplotsx_marker = [
     :pentagon,
     :hline,
     :vline,
-    Shape,
 ]
 const _pgfplotsx_scale = [:identity, :ln, :log2, :log10]
 is_marker_supported(::PGFPlotsXBackend, shape::Shape) = true

src/backends/deprecated/pgfplots.jl

@@ -3,7 +3,7 @@
 # significant contributions by: @pkofod
 
 # --------------------------------------------------------------------------------------
-
+# COV_EXCL_START
 const _pgfplots_linestyles = KW(
     :solid => "solid",
     :dash => "dashed",
@@ -740,3 +740,5 @@ function _display(plt::Plot{PGFPlotsBackend})
     # cleanup
     PGFPlots.cleanup(plt.o)
 end
+
+# COV_EXCL_STOP

src/backends/gaston.jl

@@ -1,8 +1,6 @@
 # https://github.com/mbaz/Gaston.
 
-# --------------------------------------------
-# These functions are called by Plots
-# --------------------------------------------
+should_warn_on_unsupported(::GastonBackend) = false
 
 # Create the window/figure for this backend.
 function _create_backend_figure(plt::Plot{GastonBackend})
@@ -112,7 +110,7 @@ function gaston_saveopts(plt::Plot{GastonBackend})
 
     # Scale all plot elements to match Plots.jl DPI standard
     scaling = plt.attr[:dpi] / Plots.DPI
-    push!(saveopts, "fontscale $scaling lw $scaling dl $scaling ps $scaling")
+    push!(saveopts, "fontscale $scaling lw $scaling dl $scaling")  #  ps $scaling
 
     return join(saveopts, " ")
 end
@@ -246,10 +244,9 @@ function gaston_add_series(plt::Plot{GastonBackend}, series::Series)
                 if (lx = length(x)) == 2 && lx != nc
                     x = collect(range(x[1], x[2], length = nc))
                 end
-            elseif st == :heatmap
-                length(x) == size(z, 2) + 1 && (x = @view x[1:(end - 1)])
-                length(y) == size(z, 1) + 1 && (y = @view y[1:(end - 1)])
             end
+            length(x) == size(z, 2) + 1 && (x = (x[1:(end - 1)] + x[2:end]) / 2)
+            length(y) == size(z, 1) + 1 && (y = (y[1:(end - 1)] + y[2:end]) / 2)
         end
         if st == :mesh3d
             x, y, z = mesh3d_triangles(x, y, z, series[:connections])

src/backends/inspectdr.jl

@@ -13,7 +13,7 @@ Add in functionality to Plots.jl:
     :aspect_ratio,
 =#
 
-# ---------------------------------------------------------------------------
+should_warn_on_unsupported(::InspectDRBackend) = false
 
 is_marker_supported(::InspectDRBackend, shape::Shape) = true
 

src/backends/pgfplotsx.jl

@@ -206,8 +206,8 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
 
             if hascolorbar(sp)
                 cticks = get_colorbar_ticks(sp)[2]
-                colorbar_style = PGFPlotsX.Options("ylabel" => sp[:colorbar_title])
                 if sp[:colorbar] === :top
+                    colorbar_style = PGFPlotsX.Options("xlabel" => sp[:colorbar_title])
                     push!(
                         colorbar_style,
                         "at" => string((0.5, 1.05)),
@@ -217,6 +217,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                         "xticklabel style" => pgfx_get_colorbar_ticklabel_style(sp),
                     )
                 else
+                    colorbar_style = PGFPlotsX.Options("ylabel" => sp[:colorbar_title])
                     push!(
                         colorbar_style,
                         "ytick" => string("{", join(cticks, ","), "}"),
@@ -403,6 +404,9 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
                     ),
                 ),
             )
+            if opt[:label] == ""
+                push!(arrow_opt, "forget plot" => nothing)
+            end
             if arrow.side == :head
                 x_arrow = opt[:x][rng][(end - 1):end]
                 y_arrow = opt[:y][rng][(end - 1):end]
@@ -426,6 +430,7 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
                 :v => [y_arrow[i] - y_arrow[i - 1] for i in 2:2:lastindex(y_arrow)],
             ])
             arrow_plot = series_func(merge(series_opt, arrow_opt), coordinates)
+            push!(series_opt, "forget plot" => nothing)
             push!(axis, arrow_plot)
             coordinates = PGFPlotsX.Table(x_path, y_path)
             segment_plot = series_func(merge(series_opt, segment_opt), coordinates)

src/backends/plotly.jl

@@ -752,14 +752,14 @@ function plotly_series(plt::Plot, series::Series)
     end
 
     plotly_polar!(plotattributes_out, series)
-    plotly_hover!(plotattributes_out, series[:hover])
+    plotly_adjust_hover_label!(plotattributes_out, series[:hover])
 
-    return [plotattributes_out]
+    return [merge(plotattributes_out, series[:extra_kwargs])]
 end
 
 function plotly_series_shapes(plt::Plot, series::Series, clims)
     segments = series_segments(series; check = true)
-    plotattributes_outs = Vector{KW}(undef, length(segments))
+    plotattributes_outs = [KW() for _ in 1:length(segments)]
 
     # TODO: create a plotattributes_out for each polygon
     # x, y = series[:x], series[:y]
@@ -807,8 +807,8 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
         end
         plotattributes_out[:showlegend] = k == 1 ? should_add_to_legend(series) : false
         plotly_polar!(plotattributes_out, series)
-        plotly_hover!(plotattributes_out, _cycle(series[:hover], i))
-        plotattributes_outs[k] = plotattributes_out
+        plotly_adjust_hover_label!(plotattributes_out, _cycle(series[:hover], i))
+        plotattributes_outs[k] = merge(plotattributes_out, series[:extra_kwargs])
     end
     if series[:fill_z] !== nothing
         push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :fill))
@@ -931,7 +931,7 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
         end
 
         plotly_polar!(plotattributes_out, series)
-        plotly_hover!(plotattributes_out, _cycle(series[:hover], rng))
+        plotly_adjust_hover_label!(plotattributes_out, _cycle(series[:hover], rng))
 
         if hasfillrange
             # if hasfillrange is true, return two dictionaries (one for original
@@ -969,6 +969,7 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
         else
             plotattributes_outs[k] = plotattributes_out
         end
+        plotattributes_outs[k] = merge(plotattributes_outs[k], series[:extra_kwargs])
     end
 
     if series[:line_z] !== nothing
@@ -1019,14 +1020,16 @@ function plotly_polar!(plotattributes_out::KW, series::Series)
     end
 end
 
-function plotly_hover!(plotattributes_out::KW, hover)
-    # hover text
-    if hover === nothing || all(in([:none, false]), hover)
+function plotly_adjust_hover_label!(plotattributes_out::KW, hover)
+    if hover === nothing
+        return nothing
+    elseif all(in([:none, false]), hover)
         plotattributes_out[:hoverinfo] = "none"
     elseif any(!isnothing, hover)
         plotattributes_out[:hoverinfo] = "text"
         plotattributes_out[:text] = hover
     end
+    return nothing
 end
 
 # get a list of dictionaries, each representing the series params

src/backends/pyplot.jl

@@ -1297,8 +1297,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             fontProperties = PyPlot.PyCall.PyDict(
                 Dict(
                     "family" => axis[:tickfontfamily],
-                    "math_fontfamily" =>
-                        py_get_matching_math_font(axis[:tickfontfamily]),
+                   # "math_fontfamily" =>
+                   #     py_get_matching_math_font(axis[:tickfontfamily]),
                     "size" => py_thickness_scale(plt, axis[:tickfontsize]),
                     "rotation" => axis[:tickfontrotation],
                 ),

src/backends/unicodeplots.jl

@@ -1,8 +1,5 @@
 # https://github.com/JuliaPlots/UnicodePlots.jl
 
-should_warn_on_unsupported(::UnicodePlotsBackend) = false
-
-# ------------------------------------------------------------------------------------------
 const _canvas_map = (
     braille = UnicodePlots.BrailleCanvas,
     density = UnicodePlots.DensityCanvas,
@@ -13,11 +10,10 @@ const _canvas_map = (
     dot = UnicodePlots.DotCanvas,
 )
 
-# do all the magic here... build it all at once,
-# since we need to know about all the series at the very beginning
-function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
-    plt.o = UnicodePlots.Plot[]
+should_warn_on_unsupported(::UnicodePlotsBackend) = false
 
+function _before_layout_calcs(plt::Plot{UnicodePlotsBackend})
+    plt.o = UnicodePlots.Plot[]
     up_width = UnicodePlots.DEFAULT_WIDTH[]
     up_height = UnicodePlots.DEFAULT_HEIGHT[]
 
@@ -162,6 +158,10 @@ function addUnicodeSeries!(
         series[:x], series[:y]
     end
 
+    if ispolar(sp) || ispolar(series)
+        return UnicodePlots.polarplot(x, y)
+    end
+
     # special handling (src/interface)
     fix_ar = get(se_kw, :fix_ar, true)
     if st === :histogram2d
@@ -254,8 +254,8 @@ end
 
 # ------------------------------------------------------------------------------------------
 
-function png(plt::Plot{UnicodePlotsBackend}, fn::AbstractString)
-    unicodeplots_rebuild(plt)
+function _show(io::IO, ::MIME"image/png", plt::Plot{UnicodePlotsBackend})
+    prepare_output(plt)
     nr, nc = size(plt.layout)
     s1 = zeros(Int, nr, nc)
     s2 = zeros(Int, nr, nc)
@@ -269,43 +269,41 @@ function png(plt::Plot{UnicodePlotsBackend}, fn::AbstractString)
             else
                 img = UnicodePlots.png_image(plt.o[sps += 1])
                 canvas_type = eltype(img)
-                sz = size(img)
-                s1[r, c] = sz[1]
-                s2[r, c] = sz[2]
+                h, w = size(img)
+                s1[r, c] = h
+                s2[r, c] = w
                 push!(imgs, img)
             end
         end
     end
     if canvas_type !== nothing
-        rows = maximum(sum(s1; dims = 1))
-        cols = maximum(sum(s2; dims = 2))
-        img = zeros(canvas_type, rows, cols)
         m1 = maximum(s1; dims = 2)
         m2 = maximum(s2; dims = 1)
+        img = zeros(canvas_type, sum(m1), sum(m2))
         sps = 0
         n1 = 1
         for r in 1:nr
             n2 = 1
             for c in 1:nc
                 sp = imgs[sps += 1]
-                sz = size(sp)
-                img[n1:(n1 + (sz[1] - 1)), n2:(n2 + (sz[2] - 1))] = sp
+                h, w = size(sp)
+                img[n1:(n1 + (h - 1)), n2:(n2 + (w - 1))] = sp
                 n2 += m2[c]
             end
             n1 += m1[r]
         end
-        UnicodePlots.FileIO.save(fn, img)
+        stream = UnicodePlots.FileIO.Stream{UnicodePlots.FileIO.format"PNG"}(io)
+        UnicodePlots.FileIO.save(stream, img)
     end
     nothing
 end
 
-# ------------------------------------------------------------------------------------------
 Base.show(plt::Plot{UnicodePlotsBackend}) = show(stdout, plt)
 Base.show(io::IO, plt::Plot{UnicodePlotsBackend}) = _show(io, MIME("text/plain"), plt)
 
 # NOTE: _show(...) must be kept for Base.showable (src/output.jl)
 function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
-    unicodeplots_rebuild(plt)
+    prepare_output(plt)
     nr, nc = size(plt.layout)
     if nr == 1 && nc == 1  # fast path
         n = length(plt.o)
@@ -337,7 +335,7 @@ function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
                         colored = read(buf, String)
                         lines_colored[r, c] = lu = lc = split(colored, '\n')
                         if have_color
-                            uncolored = UnicodePlots.nocolor_string(colored)
+                            uncolored = UnicodePlots.no_ansi_escape(colored)
                             lines_uncolored[r, c] = lu = split(uncolored, '\n')
                         end
                         lmax = max(length(lc), lmax)
@@ -369,4 +367,7 @@ function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
 end
 
 # we only support MIME"text/plain", hence display(...) falls back to plain-text on stdout
-_display(plt::Plot{UnicodePlotsBackend}) = (show(stdout, plt); println(stdout))
+function _display(plt::Plot{UnicodePlotsBackend})
+    show(stdout, plt)
+    println(stdout)
+end

src/components.jl

@@ -159,10 +159,15 @@ function scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
     shape
 end
 
+"""
+    scale(shape, x, y = x, c = center(shape))
+    scale!(shape, x, y = x, c = center(shape))
+
+Scale shape by a factor.
+"""
 scale(shape::Shape, x::Real, y::Real = x, c = center(shape)) =
     scale!(deepcopy(shape), x, y, c)
 
-"translate a Shape in space"
 function translate!(shape::Shape, x::Real, y::Real = x)
     sx, sy = coords(shape)
     for i in eachindex(sx)
@@ -172,22 +177,27 @@ function translate!(shape::Shape, x::Real, y::Real = x)
     shape
 end
 
+"""
+    translate(shape, x, y = x)
+    translate!(shape, x, y = x)
+
+Translate a Shape in space.
+"""
 translate(shape::Shape, x::Real, y::Real = x) = translate!(deepcopy(shape), x, y)
 
-rotate_x(x::Real, y::Real, Θ::Real, centerx::Real, centery::Real) =
-    ((x - centerx) * cos(Θ) - (y - centery) * sin(Θ) + centerx)
+rotate_x(x::Real, y::Real, θ::Real, centerx::Real, centery::Real) =
+    ((x - centerx) * cos(θ) - (y - centery) * sin(θ) + centerx)
 
-rotate_y(x::Real, y::Real, Θ::Real, centerx::Real, centery::Real) =
-    ((y - centery) * cos(Θ) + (x - centerx) * sin(Θ) + centery)
+rotate_y(x::Real, y::Real, θ::Real, centerx::Real, centery::Real) =
+    ((y - centery) * cos(θ) + (x - centerx) * sin(θ) + centery)
 
-rotate(x::Real, y::Real, θ::Real, c = center(shape)) =
-    (rotate_x(x, y, Θ, c...), rotate_y(x, y, Θ, c...))
+rotate(x::Real, y::Real, θ::Real, c) = (rotate_x(x, y, θ, c...), rotate_y(x, y, θ, c...))
 
-function rotate!(shape::Shape, Θ::Real, c = center(shape))
+function rotate!(shape::Shape, θ::Real, c = center(shape))
     x, y = coords(shape)
     for i in eachindex(x)
-        xi = rotate_x(x[i], y[i], Θ, c...)
-        yi = rotate_y(x[i], y[i], Θ, c...)
+        xi = rotate_x(x[i], y[i], θ, c...)
+        yi = rotate_y(x[i], y[i], θ, c...)
         x[i], y[i] = xi, yi
     end
     shape

src/consts.jl

@@ -1,4 +1,5 @@
 
+const _deprecated_attributes = Dict{Symbol,Symbol}(:orientation => :permute)
 const _all_defaults = KW[_series_defaults, _plot_defaults, _subplot_defaults]
 
 const _initial_defaults = deepcopy(_all_defaults)

src/examples.jl

@@ -1273,6 +1273,24 @@ const _examples = PlotExample[
             end
         )],
     ),
+    PlotExample( # 58
+        "Stacked area chart",
+        """
+        `areaplot` draws stacked area plots.
+        """,
+        [
+            :(
+                begin
+                    areaplot(
+                        1:3,
+                        [1 2 3; 7 8 9; 4 5 6],
+                        seriescolor = [:red :green :blue],
+                        fillalpha = [0.2 0.3 0.4],
+                    )
+                end
+            ),
+        ],
+    ),
 ]
 
 # Some constants for PlotDocs and PlotReferenceImages
@@ -1299,8 +1317,8 @@ _backend_skips = Dict(
         16,  # nested layout unsupported
         21,  # custom markers unsupported
         26,  # nested layout unsupported
-        27,  # polar plots unsupported
         29,  # nested layout unsupported
+        31,  # nested layout unsupported
         33,  # grid lines unsupported
         34,  # framestyle unsupported
         37,  # ribbons / filled unsupported

src/ijulia.jl

@@ -49,6 +49,9 @@ function _ijulia_display_dict(plt::Plot)
         mime = "text/html"
         out[mime] = sprint(show, MIME(mime), plt)
         _ijulia__extra_mime_info!(plt, out)
+    elseif output_type == :pdf
+        mime = "application/pdf"
+        out[mime] = base64encode(show, MIME(mime), plt)
     else
         error("Unsupported output type $output_type")
     end

src/legend.jl

@@ -4,8 +4,7 @@ legend_pos_from_angle(theta, xmin, xcenter, xmax, ymin, ycenter, ymax, inout)
 ```
 
 Return `(x,y)` at an angle `theta` degrees from
-`(xcenter,ycenter)` on a rectangle defined by (`xmin`,
-`xmax`, `ymin`, `ymax`).
+`(xcenter,ycenter)` on a rectangle defined by (`xmin`, `xmax`, `ymin`, `ymax`).
 """
 function legend_pos_from_angle(theta, xmin, xcenter, xmax, ymin, ycenter, ymax)
     (s, c) = sincosd(theta)

src/output.jl

@@ -79,6 +79,13 @@ const _savemap = Dict(
     "txt" => txt,
 )
 
+for out in Symbol.(unique(values(_savemap)))
+    @eval @doc """
+        $($out)([plot,], filename)
+    Save plot as $($out)-file.
+    """ $out
+end
+
 const _extension_map = Dict("tikz" => "tex")
 
 function addExtension(fn::AbstractString, ext::AbstractString)

src/pipeline.jl

@@ -68,6 +68,17 @@ end
 function _preprocess_userrecipe(kw::AKW)
     _add_markershape(kw)
 
+    if get(kw, :permute, default(:permute)) != :none
+        l1, l2 = kw[:permute]
+        for k in _axis_args
+            k1 = _attrsymbolcache[l1][k]
+            k2 = _attrsymbolcache[l2][k]
+            kwk = keys(kw)
+            if k1 in kwk || k2 in kwk
+                kw[k1], kw[k2] = get(kw, k2, default(k2)), get(kw, k1, default(k1))
+            end
+        end
+    end
     # map marker_z if it's a Function
     if isa(get(kw, :marker_z, default(:marker_z)), Function)
         # TODO: should this take y and/or z as arguments?
@@ -338,6 +349,19 @@ RecipesPipeline.is_seriestype_supported(plt::Plot, st) = is_seriestype_supported
 
 function RecipesPipeline.add_series!(plt::Plot, plotattributes)
     sp = _prepare_subplot(plt, plotattributes)
+    if plotattributes[:permute] != :none
+        letter1, letter2 = plotattributes[:permute]
+        if plotattributes[:markershape] == :hline &&
+           (plotattributes[:permute] == (:x, :y) || plotattributes[:permute] == (:y, :x))
+            plotattributes[:markershape] = :vline
+        elseif plotattributes[:markershape] == :vline && (
+            plotattributes[:permute] == (:x, :y) || plotattributes[:permute] == (:y, :x)
+        )
+            plotattributes[:markershape] = :hline
+        end
+        plotattributes[letter1], plotattributes[letter2] =
+            plotattributes[letter2], plotattributes[letter1]
+    end
     _expand_subplot_extrema(sp, plotattributes, plotattributes[:seriestype])
     _update_series_attributes!(plotattributes, plt, sp)
     _add_the_series(plt, sp, plotattributes)

src/plot.jl

@@ -247,6 +247,12 @@ function prepare_output(plt::Plot)
     _update_plot_object(plt)
 end
 
+"""
+    backend_object(plot)
+
+Returns the backend representation of a Plot object.
+Returns `nothing` if the backend does not support this.
+"""
 function backend_object(plt::Plot)
     prepare_output(plt)
     plt.o

src/precompile_includer.jl

@@ -24,6 +24,11 @@ elseif v"1.7.0-DEV" <= VERSION <= v"1.7.9"
         include("../deps/SnoopCompile/precompile//1.7/precompile_Plots.jl")
         _precompile_()
     end
+elseif v"1.8.0-DEV" <= VERSION <= v"1.8.9" 
+    @static if isfile(joinpath(@__DIR__, "../deps/SnoopCompile/precompile//1.8/precompile_Plots.jl"))
+        include("../deps/SnoopCompile/precompile//1.8/precompile_Plots.jl")
+        _precompile_()
+    end
 elseif v"1.9.0-DEV" <= VERSION <= v"1.9.9" 
     @static if isfile(joinpath(@__DIR__, "../deps/SnoopCompile/precompile//1.9/precompile_Plots.jl"))
         include("../deps/SnoopCompile/precompile//1.9/precompile_Plots.jl")

src/recipes.jl

@@ -438,7 +438,7 @@ end
     procx, procy, xscale, yscale, baseline = _preprocess_barlike(plotattributes, x, y)
     nx, ny = length(procx), length(procy)
     axis = plotattributes[:subplot][isvertical(plotattributes) ? :xaxis : :yaxis]
-    cv = [discrete_value!(axis, xi)[1] for xi in procx]
+    cv = [discrete_value!(plotattributes, :x, xi)[1] for xi in procx]
     procx = if nx == ny
         cv
     elseif nx == ny + 1
@@ -1140,6 +1140,13 @@ end
 # Error Bars
 
 function error_style!(plotattributes::AKW)
+    # errorbar color should soley determined by markerstrokecolor
+    if haskey(plotattributes, :marker_z)
+        reset_kw!(plotattributes, :marker_z)
+    end
+    if haskey(plotattributes, :line_z)
+        reset_kw!(plotattributes, :line_z)
+    end
     msc = plotattributes[:markerstrokecolor]
     msc = if msc === :match
         plotattributes[:subplot][:foreground_color_subplot]
@@ -1625,7 +1632,6 @@ end
 
 @nospecialize
 
-"Adds ax+b... straight line over the current plot, without changing the axis limits"
 abline!(plt::Plot, a, b; kw...) =
     plot!(plt, [0, 1], [b, b + a]; seriestype = :straightline, kw...)
 
@@ -1670,16 +1676,6 @@ end
     end
 end
 
-"""
-    areaplot([x,] y)
-    areaplot!([x,] y)
-
-Draw a stacked area plot of the matrix y.
-# Examples
-```julia-repl
-julia> areaplot(1:3, [1 2 3; 7 8 9; 4 5 6], seriescolor = [:red :green :blue], fillalpha = [0.2 0.3 0.4])
-```
-"""
 @userplot AreaPlot
 
 @recipe function f(a::AreaPlot)

src/shorthands.jl

@@ -472,10 +472,33 @@ yflip!(flip::Bool = true; kw...) = plot!(; yflip = flip, kw...)
 
 "Specify x axis attributes for an existing plot"
 xaxis!(args...; kw...) = plot!(; xaxis = args, kw...)
+xgrid!(args...; kw...) = plot!(; xgrid = args, kw...)
 
 "Specify y axis attributes for an existing plot"
 yaxis!(args...; kw...) = plot!(; yaxis = args, kw...)
-xgrid!(args...; kw...) = plot!(; xgrid = args, kw...)
 ygrid!(args...; kw...) = plot!(; ygrid = args, kw...)
 
+@doc """
+   abline!([plot,] a, b; kwargs...)
+
+Adds ax+b... straight line over the current plot, without changing the axis limits
+""" abline!
+
+@doc """
+    areaplot([x,] y)
+    areaplot!([x,] y)
+
+Draw a stacked area plot of the matrix y.
+# Examples
+```julia-repl
+julia> areaplot(1:3, [1 2 3; 7 8 9; 4 5 6], seriescolor = [:red :green :blue], fillalpha = [0.2 0.3 0.4])
+```
+""" areaplot
+
+@doc """
+    lens!([plot,] x, y, inset = (sp_index, bbox(x1, x2, y1, y2)))
+
+Magnify a region of a plot given by `x` and `y`.
+`sp_index` is the index of the subplot and `x1`, `x2`, `y1` and `y2` should be between `0` and `1`.
+""" lens!
 @specialize

src/utils.jl

@@ -377,8 +377,7 @@ nanappend!(a::AbstractVector, b) = (push!(a, NaN); append!(a, b))
 function nansplit(v::AVec)
     vs = Vector{eltype(v)}[]
     while true
-        idx = findfirst(isnan, v)
-        if idx <= 0
+        if (idx = findfirst(isnan, v)) === nothing
             # no nans
             push!(vs, v)
             break

test/runtests.jl

@@ -37,6 +37,276 @@ end
     Plots.use_local_dependencies[] = temp
 end
 
+@testset "Utils" begin
+    zipped = (
+        [(1, 2)],
+        [("a", "b")],
+        [(1, "a"), (2, "b")],
+        [(1, 2), (3, 4)],
+        [(1, 2, 3), (3, 4, 5)],
+        [(1, 2, 3, 4), (3, 4, 5, 6)],
+        [(1, 2.0), (missing, missing)],
+        [(1, missing), (missing, "a")],
+        [(missing, missing)],
+        [(missing, missing, missing), ("a", "b", "c")],
+    )
+    for z in zipped
+        @test isequal(collect(zip(Plots.RecipesPipeline.unzip(z)...)), z)
+        @test isequal(
+            collect(zip(Plots.RecipesPipeline.unzip(GeometryBasics.Point.(z))...)),
+            z,
+        )
+    end
+    op1 = Plots.process_clims((1.0, 2.0))
+    op2 = Plots.process_clims((1, 2.0))
+    data = randn(100, 100)
+    @test op1(data) == op2(data)
+    @test Plots.process_clims(nothing) ==
+          Plots.process_clims(missing) ==
+          Plots.process_clims(:auto)
+
+    @test (==)(
+        Plots.texmath2unicode(
+            raw"Equation $y = \alpha \cdot x + \beta$ and eqn $y = \sin(x)^2$",
+        ),
+        raw"Equation y = α ⋅ x + β and eqn y = sin(x)²",
+    )
+
+    @test Plots.isvector([1, 2])
+    @test !Plots.isvector(nothing)
+    @test Plots.ismatrix([1 2; 3 4])
+    @test !Plots.ismatrix(nothing)
+    @test Plots.isscalar(1.0)
+    @test !Plots.isscalar(nothing)
+    @test Plots.tovec([]) isa AbstractVector
+    @test Plots.tovec(nothing) isa AbstractVector
+    @test Plots.anynan(1, 3, (1, NaN, 3))
+    @test Plots.allnan(1, 2, (NaN, NaN, 1))
+    @test Plots.makevec([]) isa AbstractVector
+    @test Plots.makevec(1) isa AbstractVector
+    @test Plots.maketuple(1) == (1, 1)
+    @test Plots.maketuple((1, 1)) == (1, 1)
+    @test Plots.ok(1, 2)
+    @test !Plots.ok(1, 2, NaN)
+    @test Plots.ok((1, 2, 3))
+    @test !Plots.ok((1, 2, NaN))
+    @test Plots.nansplit([1, 2, NaN, 3, 4]) == [[1.0, 2.0], [3.0, 4.0]]
+    @test Plots.nanvcat([1, NaN]) |> length == 4
+
+    @test Plots.nop() === nothing
+    @test_throws ErrorException Plots.notimpl()
+
+    @test Plots.inch2px(1) isa AbstractFloat
+    @test Plots.px2inch(1) isa AbstractFloat
+    @test Plots.inch2mm(1) isa AbstractFloat
+    @test Plots.mm2inch(1) isa AbstractFloat
+    @test Plots.px2mm(1) isa AbstractFloat
+    @test Plots.mm2px(1) isa AbstractFloat
+
+    p = plot()
+    @test xlims() isa Tuple
+    @test ylims() isa Tuple
+    @test zlims() isa Tuple
+
+    Plots.makekw(foo = 1, bar = 2) isa Dict
+
+    @test_throws ErrorException Plots.inline()
+    @test_throws ErrorException Plots._do_plot_show(plot(), :inline)
+    @test_throws ErrorException Plots.dumpcallstack()
+
+    Plots.debugplots(true)
+    Plots.debugplots(false)
+    Plots.debugshow(devnull, nothing)
+    Plots.debugshow(devnull, [1])
+
+    p = plot(1)
+    push!(p, 1.5)
+    push!(p, 1, 1.5)
+    # append!(p, [1., 2.])
+    append!(p, 1, 2.5, 2.5)
+    push!(p, (1.5, 2.5))
+    push!(p, 1, (1.5, 2.5))
+    append!(p, (1.5, 2.5))
+    append!(p, 1, (1.5, 2.5))
+
+    p = plot([1, 2, 3], [4, 5, 6])
+    @test Plots.xmin(p) == 1
+    @test Plots.xmax(p) == 3
+    @test Plots.ignorenan_extrema(p) == (1, 3)
+
+    @test Plots.get_attr_symbol(:x, "lims") == :xlims
+    @test Plots.get_attr_symbol(:x, :lims) == :xlims
+
+    @testset "NaN-separated Segments" begin
+        segments(args...) = collect(iter_segments(args...))
+
+        nan10 = fill(NaN, 10)
+        @test segments(11:20) == [1:10]
+        @test segments([NaN]) == []
+        @test segments(nan10) == []
+        @test segments([nan10; 1:5]) == [11:15]
+        @test segments([1:5; nan10]) == [1:5]
+        @test segments([nan10; 1:5; nan10; 1:5; nan10]) == [11:15, 26:30]
+        @test segments([NaN; 1], 1:10) == [2:2, 4:4, 6:6, 8:8, 10:10]
+        @test segments([nan10; 1:15], [1:15; nan10]) == [11:15]
+    end
+end
+
+@testset "Axes" begin
+    p = plot()
+    axis = p.subplots[1][:xaxis]
+    @test typeof(axis) == Plots.Axis
+    @test Plots.discrete_value!(axis, "HI") == (0.5, 1)
+    @test Plots.discrete_value!(axis, :yo) == (1.5, 2)
+    @test Plots.ignorenan_extrema(axis) == (0.5, 1.5)
+    @test axis[:discrete_map] == Dict{Any,Any}(:yo => 2, "HI" => 1)
+
+    Plots.discrete_value!(axis, ["x$i" for i in 1:5])
+    Plots.discrete_value!(axis, ["x$i" for i in 0:2])
+    @test Plots.ignorenan_extrema(axis) == (0.5, 7.5)
+end
+
+@testset "NoFail" begin
+    # ensure backend with tested display
+    @test unicodeplots() == Plots.UnicodePlotsBackend()
+    @test backend() == Plots.UnicodePlotsBackend()
+
+    dsp = TextDisplay(IOContext(IOBuffer(), :color => true))
+
+    @testset "plot" begin
+        for plt in [
+            histogram([1, 0, 0, 0, 0, 0]),
+            plot([missing]),
+            plot([missing, missing]),
+            plot(fill(missing, 10)),
+            plot([missing; 1:4]),
+            plot([fill(missing, 10); 1:4]),
+            plot([1 1; 1 missing]),
+            plot(["a" "b"; missing "d"], [1 2; 3 4]),
+        ]
+            display(dsp, plt)
+        end
+        @test_nowarn plot(x -> x^2, 0, 2)
+    end
+
+    @testset "bar" begin
+        p = bar([3, 2, 1], [1, 2, 3])
+        @test p isa Plots.Plot
+        @test display(dsp, p) isa Nothing
+    end
+
+    @testset "gui" begin
+        open(tempname(), "w") do io
+            redirect_stdout(io) do
+                gui(plot())
+            end
+        end
+    end
+end
+
+@testset "Coverage" begin
+    @testset "themes" begin
+        p = showtheme(:dark)
+        @test p isa Plots.Plot
+    end
+
+    @testset "plotattr" begin
+        tmp = tempname()
+        open(tmp, "w") do io
+            redirect_stdout(io) do
+                plotattr("seriestype")
+                plotattr(:Plot)
+                plotattr()
+            end
+        end
+        str = join(readlines(tmp), "")
+        @test occursin("seriestype", str)
+        @test occursin("Plot attributes", str)
+    end
+
+    @testset "legend" begin
+        @test isa(
+            Plots.legend_pos_from_angle(20, 0.0, 0.5, 1.0, 0.0, 0.5, 1.0),
+            NTuple{2,<:AbstractFloat},
+        )
+        @test Plots.legend_anchor_index(-1) == 1
+        @test Plots.legend_anchor_index(+0) == 2
+        @test Plots.legend_anchor_index(+1) == 3
+
+        @test Plots.legend_angle(:foo_bar) == (45, :inner)
+        @test Plots.legend_angle(20.0) ==
+              Plots.legend_angle((20.0, :inner)) ==
+              (20.0, :inner)
+        @test Plots.legend_angle((20.0, 10.0)) == (20.0, 10.0)
+    end
+end
+
+@testset "Output" begin
+    @test Plots.defaultOutputFormat(plot()) == "png"
+    @test Plots.addExtension("foo", "bar") == "foo.bar"
+
+    fn = tempname()
+    gr()
+    let p = plot()
+        Plots.png(p, fn)
+        Plots.png(fn)
+        savefig(p, "$fn.png")
+        savefig("$fn.png")
+
+        Plots.pdf(p, fn)
+        Plots.pdf(fn)
+        savefig(p, "$fn.pdf")
+        savefig("$fn.pdf")
+
+        Plots.ps(p, fn)
+        Plots.ps(fn)
+        savefig(p, "$fn.ps")
+        savefig("$fn.ps")
+
+        Plots.svg(p, fn)
+        Plots.svg(fn)
+        savefig(p, "$fn.svg")
+        savefig("$fn.svg")
+    end
+
+    if Sys.islinux()
+        pgfplotsx()
+        let p = plot()
+            Plots.tex(p, fn)
+            Plots.tex(fn)
+            savefig(p, "$fn.tex")
+            savefig("$fn.tex")
+        end
+    end
+
+    unicodeplots()
+    let p = plot()
+        Plots.txt(p, fn)
+        Plots.txt(fn)
+        savefig(p, "$fn.txt")
+        savefig("$fn.txt")
+    end
+
+    plotlyjs()
+    let p = plot()
+        Plots.html(p, fn)
+        Plots.html(fn)
+        savefig(p, "$fn.html")
+        savefig("$fn.html")
+
+        if Sys.islinux()
+            Plots.eps(p, fn)
+            Plots.eps(fn)
+            savefig(p, "$fn.eps")
+            savefig("$fn.eps")
+        end
+    end
+
+    @test_throws ErrorException savefig("$fn.foo")
+end
+
+gr()  # reset to default backend
+
 for fn in (
     "test_args.jl",
     "test_defaults.jl",
@@ -52,6 +322,7 @@ for fn in (
     "test_hdf5plots.jl",
     "test_pgfplotsx.jl",
     "test_plotly.jl",
+    "test_animations.jl",
 )
     @testset "$fn" begin
         include(fn)
@@ -92,7 +363,10 @@ Random.seed!(PLOTS_SEED)
 default(show = false, reuse = true)  # don't actually show the plots
 
 is_ci() = get(ENV, "CI", "false") == "true"
-const PLOTS_IMG_TOL = parse(Float64, get(ENV, "PLOTS_IMG_TOL", is_ci() ? "1e-4" : "1e-5"))
+const PLOTS_IMG_TOL = parse(
+    Float64,
+    get(ENV, "PLOTS_IMG_TOL", is_ci() ? Sys.iswindows() ? "2e-4" : "1e-4" : "1e-5"),
+)
 
 ## Uncomment the following lines to update reference images for different backends
 
@@ -117,106 +391,29 @@ const PLOTS_IMG_TOL = parse(Float64, get(ENV, "PLOTS_IMG_TOL", is_ci() ? "1e-4"
 
 ##
 
-@testset "Axes" begin
-    p = plot()
-    axis = p.subplots[1][:xaxis]
-    @test typeof(axis) == Plots.Axis
-    @test Plots.discrete_value!(axis, "HI") == (0.5, 1)
-    @test Plots.discrete_value!(axis, :yo) == (1.5, 2)
-    @test Plots.ignorenan_extrema(axis) == (0.5, 1.5)
-    @test axis[:discrete_map] == Dict{Any,Any}(:yo => 2, "HI" => 1)
-
-    Plots.discrete_value!(axis, ["x$i" for i in 1:5])
-    Plots.discrete_value!(axis, ["x$i" for i in 0:2])
-    @test Plots.ignorenan_extrema(axis) == (0.5, 7.5)
-end
-
-@testset "NoFail" begin
-    # ensure backend with tested display
-    @test unicodeplots() == Plots.UnicodePlotsBackend()
-    @test backend() == Plots.UnicodePlotsBackend()
-
-    dsp = TextDisplay(IOContext(IOBuffer(), :color => true))
-
-    @testset "Plot" begin
-        plots = [
-            histogram([1, 0, 0, 0, 0, 0]),
-            plot([missing]),
-            plot([missing, missing]),
-            plot(fill(missing, 10)),
-            plot([missing; 1:4]),
-            plot([fill(missing, 10); 1:4]),
-            plot([1 1; 1 missing]),
-            plot(["a" "b"; missing "d"], [1 2; 3 4]),
-        ]
-        for plt in plots
-            display(dsp, plt)
-        end
-        @test_nowarn plot(x -> x^2, 0, 2)
-    end
-
-    @testset "Bar" begin
-        p = bar([3, 2, 1], [1, 2, 3])
-        @test p isa Plots.Plot
-        @test display(dsp, p) isa Nothing
-    end
-end
-
-@testset "EmptyAnim" begin
-    anim = @animate for i in []
-    end
-
-    @test_throws ArgumentError gif(anim)
-end
-
-@testset "NaN-separated Segments" begin
-    segments(args...) = collect(iter_segments(args...))
-
-    nan10 = fill(NaN, 10)
-    @test segments(11:20) == [1:10]
-    @test segments([NaN]) == []
-    @test segments(nan10) == []
-    @test segments([nan10; 1:5]) == [11:15]
-    @test segments([1:5; nan10]) == [1:5]
-    @test segments([nan10; 1:5; nan10; 1:5; nan10]) == [11:15, 26:30]
-    @test segments([NaN; 1], 1:10) == [2:2, 4:4, 6:6, 8:8, 10:10]
-    @test segments([nan10; 1:15], [1:15; nan10]) == [11:15]
-end
-
-@testset "Utils" begin
-    zipped = (
-        [(1, 2)],
-        [("a", "b")],
-        [(1, "a"), (2, "b")],
-        [(1, 2), (3, 4)],
-        [(1, 2, 3), (3, 4, 5)],
-        [(1, 2, 3, 4), (3, 4, 5, 6)],
-        [(1, 2.0), (missing, missing)],
-        [(1, missing), (missing, "a")],
-        [(missing, missing)],
-        [(missing, missing, missing), ("a", "b", "c")],
+@testset "Examples" begin
+    if Sys.islinux()
+        backends = (
+            :unicodeplots,
+            :pgfplotsx,
+            :inspectdr,
+            :plotlyjs,
+            :gaston,
+            # :pyplot,  # FIXME: fails with system matplotlib
         )
-    for z in zipped
-        @test isequal(collect(zip(Plots.RecipesPipeline.unzip(z)...)), z)
-        @test isequal(
-            collect(zip(Plots.RecipesPipeline.unzip(GeometryBasics.Point.(z))...)),
-            z,
+        only = setdiff(
+            1:length(Plots._examples),
+            (Plots._backend_skips[be] for be in backends)...,
         )
+        for be in backends
+            @info be
+            for (i, p) in Plots.test_examples(be, only = only, disp = false)
+                fn = tempname() * ".png"
+                png(p, fn)
+                @test filesize(fn) > 1_000
+            end
+        end
     end
-    op1 = Plots.process_clims((1.0, 2.0))
-    op2 = Plots.process_clims((1, 2.0))
-    data = randn(100, 100)
-    @test op1(data) == op2(data)
-    @test Plots.process_clims(nothing) ==
-          Plots.process_clims(missing) ==
-          Plots.process_clims(:auto)
-
-    @test (==)(
-        Plots.texmath2unicode(
-            raw"Equation $y = \alpha \cdot x + \beta$ and eqn $y = \sin(x)^2$",
-        ),
-        raw"Equation y = α ⋅ x + β and eqn y = sin(x)²",
-    )
 end
 
 @testset "Backends" begin
@@ -230,24 +427,32 @@ end
         p = plot(rand(10))
         @test p isa Plots.Plot
         @test show(io, p) isa Nothing
+
         p = bar(randn(10))
         @test p isa Plots.Plot
         @test show(io, p) isa Nothing
+
         p = plot([1, 2], [3, 4])
         annotate!(p, [(1.5, 3.2, Plots.text("Test", :red, :center))])
         hline!(p, [3.1])
         @test p isa Plots.Plot
         @test show(io, p) isa Nothing
+
         p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
         hline!(p, [3.1])
         annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, Plots.text("Test", :red, :center))])
         @test p isa Plots.Plot
         @test show(io, p) isa Nothing
+
         p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
         annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, :auto)])
         hline!(p, [3.1])
         @test p isa Plots.Plot
         @test show(io, p) isa Nothing
+
+        p = plot((plot(i) for i in 1:4)..., layout = (2, 2))
+        @test p isa Plots.Plot
+        @test show(io, p) isa Nothing
     end
 
     @testset "GR" begin

test/test_animations.jl

@@ -0,0 +1,61 @@
+
+@testset "Empty anim" begin
+    anim = @animate for i in []
+    end
+    @test_throws ArgumentError gif(anim)
+end
+
+@userplot CirclePlot
+@recipe function f(cp::CirclePlot)
+    x, y, i = cp.args
+    n = length(x)
+    inds = circshift(1:n, 1 - i)
+    linewidth --> range(0, 10, length = n)
+    seriesalpha --> range(0, 1, length = n)
+    aspect_ratio --> 1
+    label --> false
+    x[inds], y[inds]
+end
+
+@testset "Circle plot" begin
+    n = 10
+    t = range(0, 2π, length = n)
+    x = sin.(t)
+    y = cos.(t)
+
+    anim = @animate for i in 1:n
+        circleplot(x, y, i)
+    end
+    @test filesize(gif(anim).filename) > 10_000
+    @test filesize(mov(anim).filename) > 10_000
+    @test filesize(mp4(anim).filename) > 10_000
+    @test filesize(webm(anim).filename) > 10_000
+
+    @gif for i in 1:n
+        circleplot(x, y, i, line_z = 1:n, cbar = false, framestyle = :zerolines)
+    end every 5
+end
+
+@testset "html" begin
+    p = plot([sin, cos], zeros(0), leg = false, xlims = (0, 2π), ylims = (-1, 1))
+    anim = Animation()
+    for x in range(0, stop = 2π, length = 10)
+        push!(p, x, Float64[sin(x), cos(x)])
+        frame(anim)
+    end
+
+    agif = gif(anim)
+    html = tempname() * ".html"
+    open(html, "w") do io
+        show(io, MIME("text/html"), agif)
+    end
+    @test filesize(html) > 10_000
+    @test showable(MIME("image/gif"), agif)
+
+    agif = mp4(anim)
+    html = tempname() * ".html"
+    open(html, "w") do io
+        show(io, MIME("text/html"), agif)
+    end
+    @test filesize(html) > 10_000
+end

test/test_args.jl

@@ -16,3 +16,12 @@ end
         @test pl[1][axis][:tickfontfamily] == "Times"
     end
 end
+
+@testset "Permute recipes" begin
+    pl = bar(["a", "b", "c"], [1, 2, 3])
+    ppl = bar(["a", "b", "c"], [1, 2, 3], permute = (:x, :y))
+    @test xticks(ppl) == yticks(pl)
+    @test yticks(ppl) == xticks(pl)
+    @test filter(isfinite, pl[1][1][:x]) == filter(isfinite, ppl[1][1][:y])
+    @test filter(isfinite, pl[1][1][:y]) == filter(isfinite, ppl[1][1][:x])
+end

test/test_components.jl

@@ -3,6 +3,9 @@ using Plots, Test
 @testset "Shapes" begin
     @testset "Type" begin
         square = Shape([(0, 0.0), (1, 0.0), (1, 1.0), (0, 1.0)])
+        @test Plots.get_xs(square) == [0, 1, 1, 0]
+        @test Plots.get_ys(square) == [0, 0, 1, 1]
+        @test Plots.vertices(square) == [(0, 0), (1, 0), (1, 1), (0, 1)]
         @test isa(square, Shape{Int64,Float64})
         @test coords(square) isa Tuple{Vector{S},Vector{T}} where {T,S}
     end
@@ -58,6 +61,25 @@ using Plots, Test
         @test_nowarn p = plot(myshapes)
         @test p[1][1][:seriestype] == :shape
     end
+
+    @testset "Misc" begin
+        @test Plots.weave([1, 3], [2, 4]) == collect(1:4)
+        @test Plots.makeshape(3) isa Plots.Shape
+        @test Plots.makestar(3) isa Plots.Shape
+        @test Plots.makecross() isa Plots.Shape
+        @test Plots.makearrowhead(10.0) isa Plots.Shape
+
+        @test Plots.rotate(1.0, 2.0, 5.0, (0, 0)) isa Tuple
+
+        star = Plots.makestar(3)
+        star_scaled = Plots.scale(star, 0.5)
+
+        Plots.scale!(star, 0.5)
+        @test Plots.get_xs(star) == Plots.get_xs(star_scaled)
+        @test Plots.get_ys(star) == Plots.get_ys(star_scaled)
+
+        @test Plots.extrema_plus_buffer([1, 2], 0.1) == (0.9, 2.1)
+    end
 end
 
 @testset "Brush" begin
@@ -82,6 +104,39 @@ end
     end
 end
 
+@testset "Text" begin
+    t = Plots.PlotText("foo")
+    f = Plots.font()
+
+    @test Plots.PlotText(nothing).str == "nothing"
+    @test length(t) == 3
+    @test text(t).str == "foo"
+    @test text(t, f).str == "foo"
+    @test text("bar", f).str == "bar"
+    @test text(true).str == "true"
+end
+
+@testset "Annotations" begin
+    ann = Plots.series_annotations(missing)
+
+    @test Plots.series_annotations(["1" "2"; "3" "4"]) isa AbstractMatrix
+    @test Plots.series_annotations(10).strs[1].str == "10"
+    @test Plots.series_annotations(nothing) === nothing
+    @test Plots.series_annotations(ann) == ann
+
+    @test Plots.annotations(["1" "2"; "3" "4"]) isa AbstractMatrix
+    @test Plots.annotations(ann) == ann
+    @test Plots.annotations([ann]) == [ann]
+    @test Plots.annotations(nothing) == []
+
+    t = Plots.text("foo")
+    sp = plot(1)[1]
+    @test Plots.locate_annotation(sp, 1, 2, t) == (1, 2, t)
+    @test Plots.locate_annotation(sp, 1, 2, 3, t) == (1, 2, 3, t)
+    @test Plots.locate_annotation(sp, (0.1, 0.2), t) isa Tuple
+    @test Plots.locate_annotation(sp, (0.1, 0.2, 0.3), t) isa Tuple
+end
+
 @testset "Fonts" begin
     @testset "Scaling" begin
         sizesToCheck = [
@@ -158,3 +213,9 @@ end
     @test pos == (0.1, 0.5)
     @test txt.str == "(a)"
 end
+
+@testset "Bezier" begin
+    curve = Plots.BezierCurve([Plots.P2(0.0, 0.0), Plots.P2(0.5, 1.0), Plots.P2(1.0, 0.0)])
+    @test curve(0.75) == Plots.P2(0.75, 0.375)
+    @test length(coords(curve, 10)) == 10
+end

test/test_layouts.jl

@@ -32,3 +32,67 @@ end
     @test p[2][:framestyle] === :grid
     @test p[3][:framestyle] === :none
 end
+
+@testset "Coverage" begin
+    p = plot((plot(i) for i in 1:4)..., layout = (2, 2))
+
+    sp = p[end]
+    @test sp isa Plots.Subplot
+    @test size(sp) == (1, 1)
+    @test length(sp) == 1
+    @test sp[1, 1] == sp
+    @test Plots.get_subplot(p, UInt32(4)) == sp
+    @test Plots.series_list(sp) |> first |> Plots.get_subplot isa Plots.Subplot
+    @test Plots.get_subplot(p, keys(p.spmap) |> first) isa Plots.Subplot
+
+    gl = p[2, 2]
+    @test gl isa Plots.GridLayout
+    @test length(gl) == 1
+    @test size(gl) == (1, 1)
+    @test Plots.layout_args(gl) == (gl, 1)
+
+    @test size(p, 1) == 2
+    @test size(p, 2) == 2
+    @test size(p) === (2, 2)
+    @test ndims(p) == 2
+
+    @test p[1][end] isa Plots.Series
+    show(devnull, p[1])
+
+    @test Plots.getplot(p) == p
+    @test Plots.getattr(p) == p.attr
+    @test Plots.backend_object(p) == p.o
+    @test occursin("Plot", string(p))
+    print(devnull, p)
+
+    @test Plots.to_pixels(1Plots.mm) isa AbstractFloat
+    @test Plots.ispositive(1Plots.mm)
+    @test size(Plots.defaultbox) == (0Plots.mm, 0Plots.mm)
+    show(devnull, Plots.defaultbox)
+    show(devnull, p.layout)
+
+    @test Plots.make_measure_hor(1Plots.mm) == 1Plots.mm
+    @test Plots.make_measure_vert(1Plots.mm) == 1Plots.mm
+
+    @test Plots.parent(p.layout) isa Plots.RootLayout
+    show(devnull, Plots.parent_bbox(p.layout))
+
+    rl = Plots.RootLayout()
+    show(devnull, rl)
+    @test parent(rl) === nothing
+    @test Plots.parent_bbox(rl) == Plots.defaultbox
+    @test Plots.bbox(rl) == Plots.defaultbox
+
+    el = Plots.EmptyLayout()
+    @test Plots.update_position!(el) === nothing
+    @test size(el) == (0, 0)
+    @test length(el) == 0
+    @test el[1, 1] === nothing
+
+    @test Plots.left(el) == 0Plots.mm
+    @test Plots.top(el) == 0Plots.mm
+    @test Plots.right(el) == 0Plots.mm
+    @test Plots.bottom(el) == 0Plots.mm
+
+    @test_throws ErrorException Plots.layout_args(nothing)
+end

test/test_pgfplotsx.jl

@@ -21,16 +21,19 @@ end
     @test !haskey(axis.contents[1].options.dict, "fill")
 
     @testset "Legends" begin
-        legends_plot = plot(rand(5, 2), lab = ["1" ""])
+        legends_plot = plot(rand(5, 2), lab = ["1" ""], arrow = true)
         scatter!(legends_plot, rand(5))
         Plots._update_plot_object(legends_plot)
         axis_contents = Plots.pgfx_axes(legends_plot.o)[1].contents
         leg_entries = filter(x -> x isa PGFPlotsX.LegendEntry, axis_contents)
         series = filter(x -> x isa PGFPlotsX.Plot, axis_contents)
         @test length(leg_entries) == 2
+        @test length(series) == 5
         @test !haskey(series[1].options.dict, "forget plot")
         @test haskey(series[2].options.dict, "forget plot")
-        @test !haskey(series[3].options.dict, "forget plot")
+        @test haskey(series[3].options.dict, "forget plot")
+        @test haskey(series[4].options.dict, "forget plot")
+        @test !haskey(series[5].options.dict, "forget plot")
     end # testset
 
     @testset "3D docs example" begin

test/test_plotly.jl

@@ -55,4 +55,10 @@ using Plots, Test
             end
         end
     end
+    @testset "Extra kwargs" begin
+        pl = plot(1:5, test = "me")
+        @test Plots.plotly_series(pl)[1][:test] == "me"
+        pl = plot(1:5, test = "me", extra_kwargs = :plot)
+        @test Plots.plotly_layout(pl)[:test] == "me"
+    end
 end

test/test_shorthands.jl

@@ -7,42 +7,132 @@ using Plots, Test
         xlims!((1, 20))
         @test xlims(p) == (1, 20)
 
+        xlims!(p, (1, 21))
+        @test xlims(p) == (1, 21)
+
         ylims!((-1, 1))
         @test ylims(p) == (-1, 1)
 
+        ylims!(p, (-2, 2))
+        @test ylims(p) == (-2, 2)
+
         zlims!((-1, 1))
         @test zlims(p) == (-1, 1)
 
+        zlims!(p, (-2, 2))
+        @test zlims(p) == (-2, 2)
+
         xlims!(-1, 11)
         @test xlims(p) == (-1, 11)
 
+        xlims!(p, -2, 12)
+        @test xlims(p) == (-2, 12)
+
         ylims!((-10, 10))
         @test ylims(p) == (-10, 10)
 
+        ylims!(p, (-11, 9))
+        @test ylims(p) == (-11, 9)
+
         zlims!((-10, 10))
         @test zlims(p) == (-10, 10)
+
+        zlims!(p, (-9, 8))
+        @test zlims(p) == (-9, 8)
+    end
+
+    @testset "Set Title / Labels" begin
+        p = plot()
+        title!(p, "Foo")
+        sp = p[1]
+        @test sp[:title] == "Foo"
+        xlabel!(p, "xlabel")
+        @test sp[:xaxis][:guide] == "xlabel"
+        ylabel!(p, "ylabel")
+        @test sp[:yaxis][:guide] == "ylabel"
+    end
+
+    @testset "Misc" begin
+        p = plot()
+        sp = p[1]
+
+        xflip!(p)
+        @test sp[:xaxis][:flip]
+
+        yflip!(p)
+        @test sp[:yaxis][:flip]
+
+        xgrid!(p, true)
+        @test sp[:xaxis][:grid]
+
+        xgrid!(p, false)
+        @test !sp[:xaxis][:grid]
+
+        ygrid!(p, true)
+        @test sp[:yaxis][:grid]
+
+        ygrid!(p, false)
+        @test !sp[:yaxis][:grid]
+
+        ann = [(7, 3, "(7,3)"), (3, 7, text("hey", 14, :left, :top, :green))]
+        annotate!(p, ann)
+        annotate!(p, ann...)
+
+        xaxis!(p, true)
+        @test sp[:xaxis][:showaxis]
+
+        xaxis!(p, false)
+        @test !sp[:xaxis][:showaxis]
+
+        yaxis!(p, true)
+        @test sp[:yaxis][:showaxis]
+
+        yaxis!(p, false)
+        @test !sp[:yaxis][:showaxis]
+
+        p = plot3d([1, 2], [1, 2], [1, 2])
+        plot3d!(p, [3, 4], [3, 4], [3, 4])
+        @test Plots.series_list(p[1])[1][:seriestype] == :path3d
     end
 
     @testset "Set Ticks" begin
         p = plot([0, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+        sp = p[1]
 
         xticks = 2:6
         xticks!(xticks)
-        @test Plots.get_subplot(current(), 1).attr[:xaxis][:ticks] == xticks
+        @test sp.attr[:xaxis][:ticks] == xticks
+
+        xticks = 1:5
+        xticks!(p, xticks)
+        @test sp.attr[:xaxis][:ticks] == xticks
 
         yticks = 0.2:0.1:0.7
         yticks!(yticks)
-        @test Plots.get_subplot(current(), 1).attr[:yaxis][:ticks] == yticks
+        @test sp.attr[:yaxis][:ticks] == yticks
+
+        yticks = 0.1:0.5
+        yticks!(p, yticks)
+        @test sp.attr[:yaxis][:ticks] == yticks
 
         xticks = [5, 6, 7.5]
         xlabels = ["a", "b", "c"]
-
         xticks!(xticks, xlabels)
-        @test Plots.get_subplot(current(), 1).attr[:xaxis][:ticks] == (xticks, xlabels)
+        @test sp.attr[:xaxis][:ticks] == (xticks, xlabels)
+
+        xticks = [5, 2]
+        xlabels = ["b", "a"]
+        xticks!(p, xticks, xlabels)
+        @test sp.attr[:xaxis][:ticks] == (xticks, xlabels)
 
         yticks = [0.5, 0.6, 0.75]
         ylabels = ["z", "y", "x"]
         yticks!(yticks, ylabels)
-        @test Plots.get_subplot(current(), 1).attr[:yaxis][:ticks] == (yticks, ylabels)
+        @test sp.attr[:yaxis][:ticks] == (yticks, ylabels)
+
+        yticks = [0.5, 0.1]
+        ylabels = ["z", "y"]
+        yticks!(p, yticks, ylabels)
+        @test sp.attr[:yaxis][:ticks] == (yticks, ylabels)
     end
 end