Merge pull request #2540 from daschw/link

Fix link

.gitignore

@@ -9,3 +9,4 @@ deps/build.log
 deps/deps.jl
 Manifest.toml
 dev/
+test/tmpplotsave.hdf5

.travis.yml

@@ -4,8 +4,8 @@ os:
   - linux
   # - osx
 julia:
+  - 1.0
   - 1
-  - 1.3
   - nightly
 
 matrix:
@@ -20,6 +20,9 @@ addons:
       - xauth
       - xvfb
 
+env:
+  - GKS_ENCODING="utf8"
+
 cache:
   directories:
   - $HOME/.julia/artifacts
@@ -32,7 +35,10 @@ before_install:
 notifications:
   email: true
 
+after_success:
+  - julia -e 'using Pkg; Pkg.add("Coverage"); using Coverage; Codecov.submit(process_folder())'
+
 script:
   - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
   - if [[ `uname` = "Linux" ]]; then TESTCMD="xvfb-run julia"; else TESTCMD="julia"; fi
-  - $TESTCMD -e 'using Pkg; Pkg.pin(PackageSpec(name="FixedPointNumbers", version="0.7")); Pkg.build(); Pkg.test(coverage=true)'
+  - $TESTCMD -e 'using Pkg; Pkg.build(); Pkg.test(coverage=true)'

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "0.29.9"
+version = "1.0.2"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -41,12 +41,12 @@ Measures = "0.3"
 NaNMath = "0.3"
 PGFPlotsX = "1.2.0"
 PlotThemes = "1"
-PlotUtils = "0.6.1"
-RecipesBase = "0.8"
+PlotUtils = "0.6.5"
+RecipesBase = "1"
 Reexport = "0.2"
 Requires = "0.5, 1.0"
 Showoff = "0.3.1"
-StatsBase = "0.32, 0.33"
+StatsBase = "0.32"
 julia = "1"
 
 [extras]
@@ -56,7 +56,6 @@ Gtk = "4c0ca9eb-093a-5379-98c5-f87ac0bbbf44"
 HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
 ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
 Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
-LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
 LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925"
@@ -69,4 +68,4 @@ UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"
 
 [targets]
-test = ["FileIO", "GeometryTypes", "Gtk", "ImageMagick", "Images", "LaTeXStrings", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "Random", "RDatasets", "StaticArrays", "StatsPlots", "Test", "UnicodePlots", "VisualRegressionTests"]
+test = ["FileIO", "GeometryTypes", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "Random", "RDatasets", "StaticArrays", "StatsPlots", "Test", "UnicodePlots", "VisualRegressionTests"]

README.md

@@ -20,6 +20,7 @@
 [![][pkgeval-img]][pkgeval-url]
 [![][gitter-img]][gitter-url]
 [![][docs-img]][docs-url]
+[![Codecov](https://codecov.io/gh/JuliaPlots/Plots.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaPlots/Plots.jl)
 
 #### Created by Tom Breloff (@tbreloff)
 

appveyor.yml

@@ -1,8 +1,7 @@
 environment:
   matrix:
-  # - julia_version: 0.7
+  - julia_version: 1.0
   - julia_version: 1
-  - julia_version: 1.3
   - julia_version: nightly
 
 platform:
@@ -33,10 +32,9 @@ install:
   - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))
 
 build_script:
-  - C:\julia\bin\julia --project=C:\projects\plots-jl -e "using Pkg; Pkg.pin(PackageSpec(name="""FixedPointNumbers""", version="""0.7"""))"
-  - echo "%JL_BUILD_SCRIPT%"
+  - echo "%JL_TEST_SCRIPT%"
   - C:\julia\bin\julia -e "%JL_BUILD_SCRIPT%"
- 
+
 test_script:
   - echo "%JL_TEST_SCRIPT%"
   - C:\julia\bin\julia -e "%JL_TEST_SCRIPT%"

codecov.yml

@@ -0,0 +1,10 @@
+ignore:
+  - "src/backends/inspectdr.jl"
+  - "src/backends/orca.jl"
+  - "src/backends/pgfplots.jl"
+  - "src/backends/plotly.jl"
+  - "src/backends/plotlyjs.jl"
+  - "src/backends/pyplot.jl"
+  - "src/backends/web.jl"
+  - "src/fileio.jl"
+  - "src/ijulia.jl"

src/animation.jl

@@ -71,6 +71,7 @@ function buildanimation(anim::Animation, fn::AbstractString,
                         is_animated_gif::Bool=true;
                         fps::Real = 20, loop::Integer = 0,
                         variable_palette::Bool=false,
+                        verbose=false,
                         show_msg::Bool=true)
     if length(anim.frames) == 0
         throw(ArgumentError("Cannot build empty animations"))
@@ -79,20 +80,23 @@ function buildanimation(anim::Animation, fn::AbstractString,
     fn = abspath(expanduser(fn))
     animdir = anim.dir
     framerate = ffmpeg_framerate(fps)
+    verbose_level = (verbose isa Int ? verbose :
+                        verbose ? 32  # "info"
+                                : 16) # "error"
 
     if is_animated_gif
         if variable_palette
             # generate a colorpalette for each frame for highest quality, but larger filesize
             palette="palettegen=stats_mode=single[pal],[0:v][pal]paletteuse=new=1"
-            ffmpeg_exe(`-v 0 -framerate $framerate -loop $loop -i $(animdir)/%06d.png -lavfi "$palette" -y $fn`)
+            ffmpeg_exe(`-v $verbose_level -framerate $framerate -loop $loop -i $(animdir)/%06d.png -lavfi "$palette" -y $fn`)
         else
             # generate a colorpalette first so ffmpeg does not have to guess it
-            ffmpeg_exe(`-v 0 -i $(animdir)/%06d.png -vf "palettegen=stats_mode=diff" -y "$(animdir)/palette.bmp"`)
+            ffmpeg_exe(`-v $verbose_level -i $(animdir)/%06d.png -vf "palettegen=stats_mode=diff" -y "$(animdir)/palette.bmp"`)
             # then apply the palette to get better results
-            ffmpeg_exe(` -v 0 -framerate $framerate -loop $loop -i $(animdir)/%06d.png -i "$(animdir)/palette.bmp" -lavfi "paletteuse=dither=sierra2_4a" -y $fn`)
+            ffmpeg_exe(`-v $verbose_level -framerate $framerate -loop $loop -i $(animdir)/%06d.png -i "$(animdir)/palette.bmp" -lavfi "paletteuse=dither=sierra2_4a" -y $fn`)
         end
     else
-        ffmpeg_exe(`-v 0 -framerate $framerate -loop $loop -i $(animdir)/%06d.png -pix_fmt yuv420p -y $fn`)
+        ffmpeg_exe(`-v $verbose_level -framerate $framerate -loop $loop -i $(animdir)/%06d.png -pix_fmt yuv420p -y $fn`)
     end
 
     show_msg && @info("Saved animation to ", fn)

src/arg_desc.jl

@@ -89,7 +89,7 @@ const _arg_desc = KW(
 :foreground_color_legend  => "Color Type or `:match` (matches `:foreground_color_subplot`).  Foreground color of the legend.",
 :foreground_color_title   => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of subplot title.",
 :color_palette            => "Vector of colors (cycle through) or color gradient (generate list from gradient) or `:auto` (generate a color list using `Colors.distiguishable_colors` and custom seed colors chosen to contrast with the background).  The color palette is a color list from which series colors are automatically chosen.",
-:legend                   => "Bool (show the legend?) or Symbol (legend position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:inside`, `:legend`, `:topright`, `:topleft`, `:bottomleft`, `:bottomright` (note: only some may be supported in each backend)",
+:legend                   => "Bool (show the legend?) or Symbol (legend position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:inside`, `:legend`, `:topright`, `:topleft`, `:bottomleft`, `:bottomright` , `:inline` (note: only some may be supported in each backend)",
 :legendfontfamily         => "String or Symbol. Font family of legend entries.",
 :legendfontsize           => "Integer. Font pointsize of legend entries.",
 :legendfonthalign         => "Symbol. Font horizontal alignment of legend entries: :hcenter, :left, :right or :center",

src/args.jl

@@ -450,15 +450,33 @@ const _initial_fontsizes = Dict(:titlefontsize  => _subplot_defaults[:titlefonts
                                 :tickfontsize   => _axis_defaults[:tickfontsize],
                                 :guidefontsize  => _axis_defaults[:guidefontsize])
 
-const _all_args = sort(collect(union(map(keys, _all_defaults)...)))
+const _internal_args =
+    [:plot_object, :series_plotindex, :markershape_to_add, :letter, :idxfilter]
 
-is_subplot_attr(k) = haskey(_subplot_defaults, k)
-is_series_attr(k) = haskey(_series_defaults, k)
-#is_axis_attr(k) = haskey(_axis_defaults_byletter, k)
-is_axis_attr(k) = haskey(_axis_defaults, Symbol(chop(string(k); head=1, tail=0)))
-is_axis_attr_noletter(k) = haskey(_axis_defaults, k)
+const _axis_args = sort(union(collect(keys(_axis_defaults))))
+const _series_args = sort(union(collect(keys(_series_defaults))))
+const _subplot_args = sort(union(collect(keys(_subplot_defaults))))
+const _plot_args = sort(union(collect(keys(_plot_defaults))))
+
+const _magic_axis_args = [:axis, :tickfont, :guidefont, :grid, :minorgrid]
+const _magic_subplot_args = [:titlefont, :legendfont, :legendtitlefont, ]
+const _magic_series_args = [:line, :marker, :fill]
+
+const _all_axis_args = sort(union([_axis_args; _magic_axis_args]))
+const _all_subplot_args = sort(union([_subplot_args; _magic_subplot_args]))
+const _all_series_args = sort(union([_series_args; _magic_series_args]))
+const _all_plot_args = _plot_args
+
+const _all_args =
+    sort([_all_axis_args; _all_subplot_args; _all_series_args; _all_plot_args])
+
+is_subplot_attr(k) = k in _all_subplot_args
+is_series_attr(k) = k in _all_series_args
+is_axis_attr(k) = Symbol(chop(string(k); head=1, tail=0)) in _all_axis_args
+is_axis_attr_noletter(k) = k in _all_axis_args
 
 RecipesBase.is_key_supported(k::Symbol) = is_attr_supported(k)
+is_default_attribute(k) = k in _internal_args || k in _all_args || is_axis_attr_noletter(k)
 
 # -----------------------------------------------------------------------------
 
@@ -638,6 +656,7 @@ function default(k::Symbol)
         letter, key = axis_k
         return _axis_defaults_byletter[letter][key]
     end
+    k == :letter && return k # for type recipe processing
     k in _suppress_warnings || error("Unknown key: ", k)
 end
 
@@ -919,22 +938,6 @@ end
 function preprocessArgs!(plotattributes::AKW)
     replaceAliases!(plotattributes, _keyAliases)
 
-    # clear all axis stuff
-    # if haskey(plotattributes, :axis) && plotattributes[:axis] in (:none, nothing, false)
-    #     plotattributes[:ticks] = nothing
-    #     plotattributes[:foreground_color_border] = RGBA(0,0,0,0)
-    #     plotattributes[:foreground_color_axis] = RGBA(0,0,0,0)
-    #     plotattributes[:grid] = false
-    #     delete!(plotattributes, :axis)
-    # end
-    # for letter in (:x, :y, :z)
-    #     asym = Symbol(letter, :axis)
-    #     if haskey(plotattributes, asym) || plotattributes[asym] in (:none, nothing, false)
-    #         plotattributes[Symbol(letter, :ticks)] = nothing
-    #         plotattributes[Symbol(letter, :foreground_color_border)] = RGBA(0,0,0,0)
-    #     end
-    # end
-
     # handle axis args common to all axis
     args = pop_kw!(plotattributes, :axis, ())
     for arg in wraptuple(args)
@@ -992,13 +995,6 @@ function preprocessArgs!(plotattributes::AKW)
             processMinorGridArg!(plotattributes, arg, letter)
         end
     end
-    # fonts
-    for fontname in (:titlefont, :legendfont, :legendtitlefont)
-        args = pop_kw!(plotattributes, fontname, ())
-        for arg in wraptuple(args)
-            processFontArg!(plotattributes, fontname, arg)
-        end
-    end
     # handle font args common to all axes
     for fontname in (:tickfont, :guidefont)
         args = pop_kw!(plotattributes, fontname, ())
@@ -1017,6 +1013,26 @@ function preprocessArgs!(plotattributes::AKW)
             end
         end
     end
+    # handle axes args
+    for k in _axis_args
+        if haskey(plotattributes, k) && k !== :link
+            v = plotattributes[k]
+            for letter in (:x, :y, :z)
+                lk = Symbol(letter, k)
+                if !is_explicit(plotattributes, lk)
+                    plotattributes[lk] = v
+                end
+            end
+        end
+    end
+
+    # fonts
+    for fontname in (:titlefont, :legendfont, :legendtitlefont)
+        args = pop_kw!(plotattributes, fontname, ())
+        for arg in wraptuple(args)
+            processFontArg!(plotattributes, fontname, arg)
+        end
+    end
 
     # handle line args
     for arg in wraptuple(pop_kw!(plotattributes, :line, ()))
@@ -1219,7 +1235,7 @@ function convertLegendValue(val::Symbol)
         :best
     elseif val in (:no, :none)
         :none
-    elseif val in (:right, :left, :top, :bottom, :inside, :best, :legend, :topright, :topleft, :bottomleft, :bottomright, :outertopright, :outertopleft, :outertop, :outerright, :outerleft, :outerbottomright, :outerbottomleft, :outerbottom)
+    elseif val in (:right, :left, :top, :bottom, :inside, :best, :legend, :topright, :topleft, :bottomleft, :bottomright, :outertopright, :outertopleft, :outertop, :outerright, :outerleft, :outerbottomright, :outerbottomleft, :outerbottom, :inline)
         val
     else
         error("Invalid symbol for legend: $val")
@@ -1471,12 +1487,9 @@ function _update_axis(plt::Plot, sp::Subplot, plotattributes_in::AKW, letter::Sy
 end
 
 function _update_axis(axis::Axis, plotattributes_in::AKW, letter::Symbol, subplot_index::Int)
-    # grab magic args (for example `xaxis = (:flip, :log)`)
-    args = wraptuple(get(plotattributes_in, Symbol(letter, :axis), ()))
-
     # build the KW of arguments from the letter version (i.e. xticks --> ticks)
     kw = KW()
-    for k in keys(_axis_defaults)
+    for k in _all_axis_args
         # first get the args without the letter: `tickfont = font(10)`
         # note: we don't pop because we want this to apply to all axes! (delete after all have finished)
         if haskey(plotattributes_in, k)
@@ -1491,7 +1504,7 @@ function _update_axis(axis::Axis, plotattributes_in::AKW, letter::Symbol, subplo
     end
 
     # update the axis
-    attr!(axis, args...; kw...)
+    attr!(axis; kw...)
     return
 end
 

src/axes.jl

@@ -84,6 +84,9 @@ function attr!(axis::Axis, args...; kw...)
         process_axis_arg!(plotattributes, arg)
     end
 
+    # then preprocess keyword arguments
+    preprocessArgs!(KW(kw))
+
     # then override for any keywords... only those keywords that already exists in plotattributes
     for (k,v) in kw
         if haskey(plotattributes, k)

src/backends/gr.jl

@@ -1043,6 +1043,13 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             viewport_plotarea[3] += legendh + 0.04
         end
     end
+    if sp[:legend] == :inline
+        if sp[:yaxis][:mirror]
+            viewport_plotarea[1] += legendw
+        else
+            viewport_plotarea[2] -= legendw
+        end
+    end
 
     # fill in the plot area background
     bg = plot_color(sp[:background_color_inside])
@@ -1798,6 +1805,21 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             gr_text(GR.wctondc(xi, yi)..., str)
         end
 
+        if sp[:legend] == :inline && should_add_to_legend(series)
+            gr_set_font(legendfont(sp))
+            gr_set_textcolor(plot_color(sp[:legendfontcolor]))
+            if sp[:yaxis][:mirror] 
+                (_,i) = sp[:xaxis][:flip] ? findmax(x) : findmin(x)
+                GR.settextalign(GR.TEXT_HALIGN_RIGHT, GR.TEXT_VALIGN_HALF)
+                offset = -0.01
+            else
+                (_,i) = sp[:xaxis][:flip] ? findmin(x) : findmax(x)
+                GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
+                offset = 0.01
+            end
+            (x_l,y_l) = GR.wctondc(x[i],y[i])
+            gr_text(x_l+offset,y_l,series[:label])
+        end
         GR.restorestate()
     end
 
@@ -1805,7 +1827,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     hascolorbar(sp) && gr_draw_colorbar(cbar, sp, get_clims(sp))
 
     # add the legend
-    if sp[:legend] != :none
+    if !(sp[:legend] in(:none, :inline)) 
         GR.savestate()
         GR.selntran(0)
         GR.setscale(0)

src/backends/plotlyjs.jl

@@ -42,8 +42,8 @@ _display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))
 
 @require WebIO = "0f1e0344-ec1d-5b48-a673-e5cf874b6c29" begin
     function WebIO.render(plt::Plot{PlotlyJSBackend})
-        prepare_output(plt)
-        WebIO.render(plt.o)
+        plt_html = sprint(show, MIME("text/html"), plt)
+        return WebIO.render(dom"div"(innerHTML=plt_html))
     end
 end
 

src/components.jl

@@ -594,7 +594,9 @@ function process_annotation(sp::Subplot, xs, ys, labs, font = font())
     xlength = length(methods(length, (typeof(xs),))) == 0 ? 1 : length(xs)
     ylength = length(methods(length, (typeof(ys),))) == 0 ? 1 : length(ys)
     for i in 1:max(xlength, ylength, length(labs))
-        x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i)
+      x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i)
+        x = typeof(x) <: TimeType ? Dates.value(x) : x  
+        y = typeof(y) <: TimeType ? Dates.value(y) : y  
         if lab == :auto
             alphabet = "abcdefghijklmnopqrstuvwxyz"
             push!(anns, (x, y, text(string("(", alphabet[sp[:subplot_index]], ")"), font)))
@@ -661,8 +663,8 @@ Surface(f::Function, x, y) = Surface(Float64[f(xi,yi) for yi in y, xi in x])
 
 Base.Array(surf::Surface) = surf.surf
 
-for f in (:length, :size)
-  @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
+for f in (:length, :size, :axes)
+    @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
 end
 Base.copy(surf::Surface) = Surface(copy(surf.surf))
 Base.eltype(surf::Surface{T}) where {T} = eltype(T)

src/examples.jl

@@ -889,6 +889,63 @@ const _examples = PlotExample[
             end,
         ],
     ),
+    PlotExample(
+        "Setting defaults and font arguments",
+        "",
+        [
+            quote
+                begin
+                    using Plots
+                    default(
+                        titlefont = (20, "times"),
+                        legendfontsize = 18,
+                        guidefont = (18, :darkgreen),
+                        tickfont = (12, :orange),
+                        guide = "x",
+                        framestyle = :zerolines,
+                        yminorgrid = true
+                    )
+                    plot(
+                        [sin, cos],
+                        -2π,
+                        2π,
+                        label = ["sin(θ)" "cos(θ)"],
+                        title = "Trigonometric Functions",
+                        xlabel = "θ",
+                        linewidth = 2,
+                        legend = :outertopleft,
+                    )
+                end
+            end,
+        ],
+    ),
+    PlotExample(
+        "Heatmap with DateTime axis",
+        "",
+        [
+            quote
+                begin
+                    using Dates
+                    z = rand(5, 5)
+                    x = DateTime.(2016:2020)
+                    y = 1:5
+                    heatmap(x, y, z)
+                end
+            end,
+        ],
+    ),
+    PlotExample(
+        "Linked axes",
+        "",
+        [
+            quote
+                begin
+                    x = -5:0.1:5
+                    plot(plot(x, x->x^2), plot(x, x->sin(x)), layout = 2, link = :y)
+                end
+            end,
+        ],
+    ),
 ]
 
 # Some constants for PlotDocs and PlotReferenceImages

src/pipeline.jl

@@ -1,4 +1,28 @@
+# Error for aliases used in recipes
+function warn_on_recipe_aliases!(plotattributes, recipe_type, args...)
+    for k in keys(plotattributes)
+        if !is_default_attribute(k)
+            dk = get(_keyAliases, k, k)
+            if k !== dk
+                @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $(signature_string(Val{recipe_type}, args...)). To ensure expected behavior it is recommended to use the default attribute `$dk`."
+            end
+            plotattributes[dk] = pop_kw!(plotattributes, k)
+        end
+    end
+end
+function warn_on_recipe_aliases!(v::AbstractVector, recipe_type, args...)
+    foreach(x -> warn_on_recipe_aliases!(x, recipe_type, args...), v)
+end
+function warn_on_recipe_aliases!(rd::RecipeData, recipe_type, args...)
+    warn_on_recipe_aliases!(rd.plotattributes, recipe_type, args...)
+end
 
+function signature_string(::Type{Val{:user}}, args...)
+    return string("(::", join(string.(typeof.(args)), ", ::"), ")")
+end
+signature_string(::Type{Val{:type}}, T) = "(::Type{$T}, ::$T)"
+signature_string(::Type{Val{:plot}}, st) = "(::Type{Val{:$st}}, ::AbstractPlot)"
+signature_string(::Type{Val{:series}}, st) = "(::Type{Val{:$st}}, x, y, z)"
 
 # ------------------------------------------------------------------
 # preprocessing
@@ -40,14 +64,8 @@ function _preprocess_args(plotattributes::AKW, args, still_to_process::Vector{Re
     # remove subplot and axis args from plotattributes... they will be passed through in the kw_list
     if !isempty(args)
         for (k,v) in plotattributes
-            for defdict in (_subplot_defaults,
-                            _axis_defaults,
-                            _axis_defaults_byletter[:x],
-                            _axis_defaults_byletter[:y],
-                            _axis_defaults_byletter[:z])
-                if haskey(defdict, k)
-                    reset_kw!(plotattributes, k)
-                end
+            if k in _all_subplot_args || k in _all_axis_args
+                reset_kw!(plotattributes, k)
             end
         end
     end
@@ -82,7 +100,11 @@ function _process_userrecipes(plt::Plot, plotattributes::AKW, args)
         if isempty(next_series.args)
             _process_userrecipe(plt, kw_list, next_series)
         else
-            rd_list = RecipesBase.apply_recipe(next_series.plotattributes, next_series.args...)
+            rd_list = RecipesBase.apply_recipe(
+                next_series.plotattributes,
+                next_series.args...
+            )
+            warn_on_recipe_aliases!(rd_list, :user, next_series.args...)
             prepend!(still_to_process,rd_list)
         end
     end
@@ -184,6 +206,7 @@ function _process_plotrecipe(plt::Plot, kw::AKW, kw_list::Vector{KW}, still_to_p
         st = kw[:seriestype]
         st = kw[:seriestype] = get(_typeAliases, st, st)
         datalist = RecipesBase.apply_recipe(kw, Val{st}, plt)
+        warn_on_recipe_aliases!(datalist, :plot, st)
         for data in datalist
             preprocessArgs!(data.plotattributes)
             if data.plotattributes[:seriestype] == st
@@ -408,7 +431,9 @@ function _process_seriesrecipe(plt::Plot, plotattributes::AKW)
 
     else
         # get a sub list of series for this seriestype
-        datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, plotattributes[:x], plotattributes[:y], plotattributes[:z])
+        x, y, z = plotattributes[:x], plotattributes[:y], plotattributes[:z]
+        datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, x, y, z)
+        warn_on_recipe_aliases!(datalist, :series, st)
 
         # assuming there was no error, recursively apply the series recipes
         for data in datalist

src/precompile.jl

@@ -1,66 +1,67 @@
 function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
     isdefined(Plots, Symbol("#@layout")) && precompile(Tuple{getfield(Plots, Symbol("#@layout")), LineNumberNode, Module, Expr})
-    isdefined(Plots, Symbol("#kw##_make_hist")) && precompile(Tuple{getfield(Plots, Symbol("#kw##_make_hist")), NamedTuple{(:normed, :weights), Tuple{Bool, Array{Int64, 1}}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
-    isdefined(Plots, Symbol("#kw##_make_hist")) && precompile(Tuple{getfield(Plots, Symbol("#kw##_make_hist")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64})
-    isdefined(Plots, Symbol("#kw##_make_hist")) && precompile(Tuple{getfield(Plots, Symbol("#kw##_make_hist")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}})
-    isdefined(Plots, Symbol("#kw##_make_hist")) && precompile(Tuple{getfield(Plots, Symbol("#kw##_make_hist")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:foreground_color_grid, :grid, :gridalpha, :gridstyle, :gridlinewidth), Tuple{ColorTypes.RGBA{Float64}, Bool, Float64, Symbol, Int64}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:formatter,), Tuple{Symbol}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Int64, Int64}, Bool}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:grid, :ticks), Tuple{Bool, Nothing}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:grid,), Tuple{Bool}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:guide,), Tuple{String}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, Base.StepRange{Int64, Int64}, String}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:rotation,), Tuple{Int64}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:scale, :guide), Tuple{Symbol, String}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:ticks,), Tuple{Base.UnitRange{Int64}}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:ticks,), Tuple{Nothing}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##contour")) && precompile(Tuple{getfield(Plots, Symbol("#kw##contour")), NamedTuple{(:fill,), Tuple{Bool}}, typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
-    isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Int64, 1}, Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRange{Int64, Int64}, Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Base.UnitRange{Int64}})
-    isdefined(Plots, Symbol("#kw##gr_set_font")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_set_font")), NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}}, typeof(Plots.gr_set_font), Plots.Font})
-    isdefined(Plots, Symbol("#kw##heatmap")) && precompile(Tuple{getfield(Plots, Symbol("#kw##heatmap")), NamedTuple{(:aspect_ratio,), Tuple{Int64}}, typeof(Plots.heatmap), Array{String, 1}, Int})
-    isdefined(Plots, Symbol("#kw##histogram")) && precompile(Tuple{getfield(Plots, Symbol("#kw##histogram")), NamedTuple{(:bins, :weights), Tuple{Symbol, Array{Int64, 1}}}, typeof(Plots.histogram), Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##histogram2d")) && precompile(Tuple{getfield(Plots, Symbol("#kw##histogram2d")), NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio), Tuple{Tuple{Int64, Int64}, Bool, Bool, Int64}}, typeof(Plots.histogram2d), Array{Base.Complex{Float64}, 1}})
-    isdefined(Plots, Symbol("#kw##histogram2d")) && precompile(Tuple{getfield(Plots, Symbol("#kw##histogram2d")), NamedTuple{(:nbins,), Tuple{Int64}}, typeof(Plots.histogram2d), Array{Float64, 1}, Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##hline!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##hline!")), NamedTuple{(:line,), Tuple{Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}}}, typeof(Plots.hline!), Array{Float64, 2}})
-    isdefined(Plots, Symbol("#kw##lens!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##lens!")), NamedTuple{(:inset,), Tuple{Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}}}, typeof(Plots.lens!), Array{Int64, 1}, Int})
-    isdefined(Plots, Symbol("#kw##pie")) && precompile(Tuple{getfield(Plots, Symbol("#kw##pie")), NamedTuple{(:title, :l), Tuple{String, Float64}}, typeof(Plots.pie), Array{String, 1}, Int})
-    isdefined(Plots, Symbol("#kw##plotly_annotation_dict")) && precompile(Tuple{getfield(Plots, Symbol("#kw##plotly_annotation_dict")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, Plots.PlotText})
-    isdefined(Plots, Symbol("#kw##plotly_annotation_dict")) && precompile(Tuple{getfield(Plots, Symbol("#kw##plotly_annotation_dict")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, String})
-    isdefined(Plots, Symbol("#kw##plotly_annotation_dict")) && precompile(Tuple{getfield(Plots, Symbol("#kw##plotly_annotation_dict")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, Plots.PlotText})
-    isdefined(Plots, Symbol("#kw##plotly_annotation_dict")) && precompile(Tuple{getfield(Plots, Symbol("#kw##plotly_annotation_dict")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, String})
-    isdefined(Plots, Symbol("#kw##portfoliocomposition")) && precompile(Tuple{getfield(Plots, Symbol("#kw##portfoliocomposition")), NamedTuple{(:labels,), Tuple{Array{String, 2}}}, typeof(Plots.portfoliocomposition), Array{Float64, 2}, Int})
-    isdefined(Plots, Symbol("#kw##scatter!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter!")), NamedTuple{(:marker, :series_annotations), Tuple{Tuple{Int64, Float64, Symbol}, Array{Any, 1}}}, typeof(Plots.scatter!), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
-    isdefined(Plots, Symbol("#kw##scatter!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter!")), NamedTuple{(:markersize, :c), Tuple{Int64, Symbol}}, typeof(Plots.scatter!), Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##scatter!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter!")), NamedTuple{(:zcolor, :m, :ms, :lab), Tuple{Array{Float64, 1}, Tuple{Symbol, Float64, Plots.Stroke}, Array{Float64, 1}, String}}, typeof(Plots.scatter!), Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##scatter")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter")), NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks), Tuple{Array{Symbol, 2}, Array{String, 2}, Base.ReshapedArray{Int64, 2, Base.UnitRange{Int64}, Tuple{}}, Int64, String, Int64, Base.UnitRange{Int64}}}, typeof(Plots.scatter), Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
-    isdefined(Plots, Symbol("#kw##scatter")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter")), NamedTuple{(:m, :lab, :bg, :xlim, :ylim), Tuple{Tuple{Int64, Symbol}, Array{String, 2}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, typeof(Plots.scatter), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
-    isdefined(Plots, Symbol("#kw##scatter")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter")), NamedTuple{(:marker_z, :color, :legend), Tuple{typeof(Base.:+), Symbol, Bool}}, typeof(Plots.scatter), Array{Float64, 1}, Array{Float64, 1}})
-    isdefined(Plots, Symbol("#kw##standalone_html")) && precompile(Tuple{getfield(Plots, Symbol("#kw##standalone_html")), NamedTuple{(:title,), Tuple{String}}, typeof(Plots.standalone_html), Plots.Plot{Plots.PlotlyBackend}})
-    isdefined(Plots, Symbol("#kw##test_examples")) && precompile(Tuple{getfield(Plots, Symbol("#kw##test_examples")), NamedTuple{(:skip,), Tuple{Array{Int64, 1}}}, typeof(Plots.test_examples), Symbol})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Array{Int64, 1}}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{Symbol}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Int64, Int64}, Bool}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :ticks), Tuple{Bool, Nothing}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid,), Tuple{Bool}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, ColorTypes.RGBA{Float64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:guide,), Tuple{String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, Base.StepRange{Int64, Int64}, String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:rotation,), Tuple{Int64}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:scale, :guide), Tuple{Symbol, String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Base.UnitRange{Int64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Nothing}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#contour##kw")) && precompile(Tuple{getfield(Plots, Symbol("#contour##kw")), NamedTuple{(:fill,), Tuple{Bool}}, typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    isdefined(Plots, Symbol("#default##kw")) && precompile(Tuple{getfield(Plots, Symbol("#default##kw")), NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}}, typeof(Plots.default)})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Int64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRange{Int64, Int64}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Base.UnitRange{Int64}})
+    isdefined(Plots, Symbol("#gr_set_font##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_set_font##kw")), NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}}, typeof(Plots.gr_set_font), Plots.Font})
+    isdefined(Plots, Symbol("#heatmap##kw")) && precompile(Tuple{getfield(Plots, Symbol("#heatmap##kw")), NamedTuple{(:aspect_ratio,), Tuple{Int64}}, typeof(Plots.heatmap), Array{String, 1}, Int})
+    isdefined(Plots, Symbol("#histogram##kw")) && precompile(Tuple{getfield(Plots, Symbol("#histogram##kw")), NamedTuple{(:bins, :weights), Tuple{Symbol, Array{Int64, 1}}}, typeof(Plots.histogram), Array{Float64, 1}})
+    isdefined(Plots, Symbol("#histogram2d##kw")) && precompile(Tuple{getfield(Plots, Symbol("#histogram2d##kw")), NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio), Tuple{Tuple{Int64, Int64}, Bool, Bool, Int64}}, typeof(Plots.histogram2d), Array{Base.Complex{Float64}, 1}})
+    isdefined(Plots, Symbol("#histogram2d##kw")) && precompile(Tuple{getfield(Plots, Symbol("#histogram2d##kw")), NamedTuple{(:nbins,), Tuple{Int64}}, typeof(Plots.histogram2d), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#hline!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#hline!##kw")), NamedTuple{(:line,), Tuple{Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}}}, typeof(Plots.hline!), Array{Float64, 2}})
+    isdefined(Plots, Symbol("#lens!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#lens!##kw")), NamedTuple{(:inset,), Tuple{Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}}}, typeof(Plots.lens!), Array{Int64, 1}, Int})
+    isdefined(Plots, Symbol("#pie##kw")) && precompile(Tuple{getfield(Plots, Symbol("#pie##kw")), NamedTuple{(:title, :l), Tuple{String, Float64}}, typeof(Plots.pie), Array{String, 1}, Int})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, Plots.PlotText})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, String})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, Plots.PlotText})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, String})
+    isdefined(Plots, Symbol("#portfoliocomposition##kw")) && precompile(Tuple{getfield(Plots, Symbol("#portfoliocomposition##kw")), NamedTuple{(:labels,), Tuple{Array{String, 2}}}, typeof(Plots.portfoliocomposition), Array{Float64, 2}, Int})
+    isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), NamedTuple{(:marker, :series_annotations), Tuple{Tuple{Int64, Float64, Symbol}, Array{Any, 1}}}, typeof(Plots.scatter!), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), NamedTuple{(:markersize, :c), Tuple{Int64, Symbol}}, typeof(Plots.scatter!), Array{Float64, 1}})
+    isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), NamedTuple{(:zcolor, :m, :ms, :lab), Tuple{Array{Float64, 1}, Tuple{Symbol, Float64, Plots.Stroke}, Array{Float64, 1}, String}}, typeof(Plots.scatter!), Array{Float64, 1}})
+    isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks), Tuple{Array{Symbol, 2}, Array{String, 2}, Base.ReshapedArray{Int64, 2, Base.UnitRange{Int64}, Tuple{}}, Int64, String, Int64, Base.UnitRange{Int64}}}, typeof(Plots.scatter), Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
+    isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:m, :lab, :bg, :xlim, :ylim), Tuple{Tuple{Int64, Symbol}, Array{String, 2}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, typeof(Plots.scatter), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:marker_z, :color, :legend), Tuple{typeof(Base.:+), Symbol, Bool}}, typeof(Plots.scatter), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#standalone_html##kw")) && precompile(Tuple{getfield(Plots, Symbol("#standalone_html##kw")), NamedTuple{(:title,), Tuple{String}}, typeof(Plots.standalone_html), Plots.Plot{Plots.PlotlyBackend}})
+    isdefined(Plots, Symbol("#test_examples##kw")) && precompile(Tuple{getfield(Plots, Symbol("#test_examples##kw")), NamedTuple{(:skip,), Tuple{Array{Int64, 1}}}, typeof(Plots.test_examples), Symbol})
     precompile(Tuple{typeof(Plots.__init__)})
     precompile(Tuple{typeof(Plots._add_errorbar_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._add_markershape), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._add_smooth_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr})
     precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr})
-    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}})
-    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}})
-    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}})
-    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Real, 1}})
-    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{String, 1}})
-    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Union{Base.Missing, Int64}, 1}})
-    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity)})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Any, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.Surface{Array{Float64, 2}}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity), Symbol})
     precompile(Tuple{typeof(Plots._backend_instance), Symbol})
     precompile(Tuple{typeof(Plots._bin_centers), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots._binbarlike_baseline), Float64, Symbol})
@@ -106,6 +107,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
@@ -128,6 +130,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Function, 1}, Float64, Float64}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Function, 1}, Int64}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Int64, 1}}})
@@ -169,6 +172,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
@@ -193,6 +197,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
@@ -212,6 +217,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
     precompile(Tuple{typeof(Plots._plotly_framestyle), Symbol})
     precompile(Tuple{typeof(Plots._plots_defaults)})
+    precompile(Tuple{typeof(Plots._postprocess_axis_args!), Base.Dict{Symbol, Any}, Symbol})
     precompile(Tuple{typeof(Plots._prepare_annotations), Plots.Subplot{Plots.GRBackend}, Plots.Attr})
     precompile(Tuple{typeof(Plots._prepare_annotations), Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr})
     precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, Plots.Attr})
@@ -225,6 +231,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}, Array{RecipesBase.RecipeData, 1}})
@@ -242,6 +249,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Plots.Spy}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{}, Array{RecipesBase.RecipeData, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_axis_args!), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Array{Float64, 1}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Array{Int64, 1}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Base.OneTo{Int64}, Array{Float64, 1}})
@@ -262,6 +270,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
@@ -286,6 +295,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
@@ -305,6 +315,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._replace_markershape), Array{Symbol, 2}})
     precompile(Tuple{typeof(Plots._replace_markershape), Plots.Shape})
     precompile(Tuple{typeof(Plots._scale_adjusted_values), Type{Float64}, Array{Float64, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._scaled_adapted_grid), typeof(identity), Symbol, Symbol, Float64, Float64})
     precompile(Tuple{typeof(Plots._series_index), Plots.Attr, Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots._series_index), Plots.Attr, Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._show), Base.IOStream, Base.Multimedia.MIME{Symbol("image/png")}, Plots.Plot{Plots.GRBackend}})
@@ -357,7 +368,6 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.annotate!), Array{Tuple{Int64, Float64, Plots.PlotText}, 1}})
     precompile(Tuple{typeof(Plots.annotations), Array{Any, 1}})
     precompile(Tuple{typeof(Plots.arrow), Int64})
-    precompile(Tuple{typeof(Plots.attr!), Plots.Axis})
     precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol, Symbol})
     precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol})
     precompile(Tuple{typeof(Plots.autopick), Array{ColorTypes.RGBA{Float64}, 1}, Int64})
@@ -392,6 +402,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.color_or_nothing!), Plots.Attr, Symbol})
     precompile(Tuple{typeof(Plots.colorbar_style), Plots.Series})
     precompile(Tuple{typeof(Plots.compute_gridsize), Int64, Int64, Int64})
+    precompile(Tuple{typeof(Plots.compute_x), Nothing, Plots.Surface{Array{Float64, 2}}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, typeof(identity), Nothing})
@@ -399,21 +410,19 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.compute_xyz), Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRange{Int64, Int64}, Plots.Surface{Array{Float64, 2}}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Array{Float64, 1}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Array{Union{Base.Missing, Float64}, 1}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Base.UnitRange{Int64}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Nothing, Nothing})
+    precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Plots.Surface{Array{Float64, 2}}, Nothing})
     precompile(Tuple{typeof(Plots.concatenate_fillrange), Base.UnitRange{Int64}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
     precompile(Tuple{typeof(Plots.contour_levels), Plots.Series, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.convertLegendValue), Bool})
     precompile(Tuple{typeof(Plots.convertLegendValue), Symbol})
-    precompile(Tuple{typeof(Plots.convertToAnyVector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.convertToAnyVector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.convertToAnyVector), Array{Float64, 2}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.convertToAnyVector), Array{Function, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.convertToAnyVector), Int64, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.convert_sci_unicode), String})
     precompile(Tuple{typeof(Plots.convert_to_polar), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Tuple{Int64, Float64}})
     precompile(Tuple{typeof(Plots.copy_series!), Plots.Series, Symbol})
@@ -421,6 +430,10 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.create_grid), Symbol})
     precompile(Tuple{typeof(Plots.create_grid_curly), Expr})
     precompile(Tuple{typeof(Plots.create_grid_vcat), Expr})
+    precompile(Tuple{typeof(Plots.default), Symbol, Bool})
+    precompile(Tuple{typeof(Plots.default), Symbol, Int64})
+    precompile(Tuple{typeof(Plots.default), Symbol, String})
+    precompile(Tuple{typeof(Plots.default), Symbol, Symbol})
     precompile(Tuple{typeof(Plots.default), Symbol})
     precompile(Tuple{typeof(Plots.default_should_widen), Plots.Axis})
     precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Array{String, 1}})
@@ -603,6 +616,8 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Int64}})
     precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}})
     precompile(Tuple{typeof(Plots.is_axis_attr), Symbol})
+    precompile(Tuple{typeof(Plots.is_axis_attr_noletter), Symbol})
+    precompile(Tuple{typeof(Plots.is_default_attribute), Symbol})
     precompile(Tuple{typeof(Plots.is_marker_supported), Plots.GRBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_marker_supported), Plots.PlotlyBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_marker_supported), Plots.Shape})
@@ -610,11 +625,13 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.is_marker_supported), Symbol})
     precompile(Tuple{typeof(Plots.is_scale_supported), Plots.GRBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_scale_supported), Plots.PlotlyBackend, Symbol})
+    precompile(Tuple{typeof(Plots.is_series_attr), Symbol})
     precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.GRBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.PlotlyBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_seriestype_supported), Symbol})
     precompile(Tuple{typeof(Plots.is_style_supported), Plots.GRBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_style_supported), Plots.PlotlyBackend, Symbol})
+    precompile(Tuple{typeof(Plots.is_subplot_attr), Symbol})
     precompile(Tuple{typeof(Plots.is_uniformly_spaced), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.iscontour), Plots.Series})
     precompile(Tuple{typeof(Plots.isijulia)})
@@ -673,7 +690,6 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Nothing})
-    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Nothing})
     precompile(Tuple{typeof(Plots.parse_axis_kw), Symbol})
@@ -749,6 +765,9 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Bool})
     precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Int64})
     precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol})
+    precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, Int64})
+    precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, String})
+    precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Bool, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Float64, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Int64, Symbol})
@@ -766,6 +785,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Shape})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Stroke})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Symbol})
+    precompile(Tuple{typeof(Plots.processMinorGridArg!), Base.Dict{Symbol, Any}, Bool, Symbol})
     precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText, Plots.Font})
     precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText})
     precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText, Plots.Font})
@@ -796,6 +816,15 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.series_annotations), Plots.SeriesAnnotations})
     precompile(Tuple{typeof(Plots.series_annotations_shapes!), Plots.Series, Symbol})
     precompile(Tuple{typeof(Plots.series_idx), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Any, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Float64, 2}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Function, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Real, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Union{Base.Missing, Int64}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Union{Base.Missing, Number}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), typeof(identity), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.shape_data), Plots.Series, Int64})
     precompile(Tuple{typeof(Plots.should_add_to_legend), Plots.Series})
     precompile(Tuple{typeof(Plots.showaxis), Symbol, Symbol})
@@ -872,8 +901,184 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.warnOnUnsupported_args), Plots.PlotlyBackend, Plots.Attr})
     precompile(Tuple{typeof(Plots.warnOnUnsupported_scales), Plots.GRBackend, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.warnOnUnsupported_scales), Plots.PlotlyBackend, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Any, 1}, Array{Any, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Int64, 1}, Array{Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Any, 1}, Array{Any, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Array{T, 1} where T, 1}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Real, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{String, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRange{Int64, Int64}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Int64, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Int64, typeof(Base.log), Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Array{T, 1} where T, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Int64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Union{Base.Missing, Int64}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Base.UnitRange{Int64}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Int64, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Int64, typeof(Base.log)}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Plots.GroupBy, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Any, 1}, Array{Any, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Int64, 1}, Array{Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Any, 1}, Array{Any, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Array{T, 1} where T, 1}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Real, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{String, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRange{Int64, Int64}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Int64, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Int64, typeof(Base.log), Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Array{T, 1} where T, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Int64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Union{Base.Missing, Int64}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Base.UnitRange{Int64}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Int64, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Int64, typeof(Base.log)}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Plots.GroupBy, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Type{Int}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Plots.Attr, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Any, 1}, Array{Any, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Int64, 1}, Array{Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Any, 1}, Array{Any, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Array{T, 1} where T, 1}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Real, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{String, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRange{Int64, Int64}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Int64, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Int64, typeof(Base.log), Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Array{T, 1} where T, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Int64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Union{Base.Missing, Int64}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Base.UnitRange{Int64}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Int64, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Int64, typeof(Base.log)}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Plots.GroupBy, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{typeof(Base.log), Int64}})
     precompile(Tuple{typeof(Plots.widen), Float64, Float64, Symbol})
-    precompile(Tuple{typeof(Plots.wrap_surfaces), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.wrap_surfaces!), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.wraptuple), Array{Any, 1}})
     precompile(Tuple{typeof(Plots.wraptuple), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.wraptuple), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
@@ -888,6 +1093,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Array{Symbol, 2}}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol, Plots.Stroke}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, String}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Symbol}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol}})

src/recipes.jl

@@ -1261,8 +1261,8 @@ end
     yflip := true
     aspect_ratio := 1
     rs, cs, zs = findnz(z.surf)
-    xlim := ignorenan_extrema(cs)
-    ylim := ignorenan_extrema(rs)
+    xlims := ignorenan_extrema(cs)
+    ylims := ignorenan_extrema(rs)
     if plotattributes[:markershape] == :none
         markershape := :circle
     end

src/series.jl

@@ -20,37 +20,38 @@ function prepareSeriesData(a::AbstractArray{<:MaybeNumber})
     f = isimmutable(a) ? replace : replace!
     a = f(x -> ismissing(x) || isinf(x) ? NaN : x, map(float, a))
 end
+prepareSeriesData(a::AbstractArray{<:Missing}) = fill(NaN, axes(a))
 prepareSeriesData(a::AbstractArray{<:MaybeString}) = replace(x -> ismissing(x) ? "" : x, a)
 prepareSeriesData(s::Surface{<:AMat{<:MaybeNumber}}) = Surface(prepareSeriesData(s.surf))
 prepareSeriesData(s::Surface) = s  # non-numeric Surface, such as an image
 prepareSeriesData(v::Volume) = Volume(prepareSeriesData(v.v), v.x_extents, v.y_extents, v.z_extents)
 
 # default: assume x represents a single series
-convertToAnyVector(x, plotattributes) = Any[prepareSeriesData(x)]
+series_vector(x, plotattributes) = [prepareSeriesData(x)]
 
 # fixed number of blank series
-convertToAnyVector(n::Integer, plotattributes) = Any[zeros(0) for i in 1:n]
+series_vector(n::Integer, plotattributes) = [zeros(0) for i in 1:n]
 
 # vector of data points is a single series
-convertToAnyVector(v::AVec{<:DataPoint}, plotattributes) = Any[prepareSeriesData(v)]
+series_vector(v::AVec{<:DataPoint}, plotattributes) = [prepareSeriesData(v)]
 
 # list of things (maybe other vectors, functions, or something else)
-function convertToAnyVector(v::AVec, plotattributes)
+function series_vector(v::AVec, plotattributes)
     if all(x -> x isa MaybeNumber, v)
-        convertToAnyVector(Vector{MaybeNumber}(v), plotattributes)
+        series_vector(Vector{MaybeNumber}(v), plotattributes)
     elseif all(x -> x isa MaybeString, v)
-        convertToAnyVector(Vector{MaybeString}(v), plotattributes)
+        series_vector(Vector{MaybeString}(v), plotattributes)
     else
-        vcat((convertToAnyVector(vi, plotattributes) for vi in v)...)
+        vcat((series_vector(vi, plotattributes) for vi in v)...)
     end
 end
 
 # Matrix is split into columns
-function convertToAnyVector(v::AMat{<:DataPoint}, plotattributes)
+function series_vector(v::AMat{<:DataPoint}, plotattributes)
     if all3D(plotattributes)
-        Any[prepareSeriesData(Surface(v))]
+        [prepareSeriesData(Surface(v))]
     else
-        Any[prepareSeriesData(v[:, i]) for i in axes(v, 2)]
+        [prepareSeriesData(v[:, i]) for i in axes(v, 2)]
     end
 end
 
@@ -59,13 +60,15 @@ end
 
 
 process_fillrange(range::Number, plotattributes) = [range]
-process_fillrange(range, plotattributes) = convertToAnyVector(range, plotattributes)
+process_fillrange(range, plotattributes) = series_vector(range, plotattributes)
 
 process_ribbon(ribbon::Number, plotattributes) = [ribbon]
-process_ribbon(ribbon, plotattributes) = convertToAnyVector(ribbon, plotattributes)
+process_ribbon(ribbon, plotattributes) = series_vector(ribbon, plotattributes)
 # ribbon as a tuple: (lower_ribbons, upper_ribbons)
-process_ribbon(ribbon::Tuple{Any,Any}, plotattributes) = collect(zip(convertToAnyVector(ribbon[1], plotattributes),
-                                                     convertToAnyVector(ribbon[2], plotattributes)))
+process_ribbon(ribbon::Tuple{S, T}, plotattributes) where {S, T} = collect(zip(
+    series_vector(ribbon[1], plotattributes),
+    series_vector(ribbon[2], plotattributes),
+))
 
 
 # --------------------------------------------------------------------
@@ -105,10 +108,16 @@ compute_xyz(x::Nothing, y::Nothing, z::Nothing)        = error("x/y/z are all no
 
 # we are going to build recipes to do the processing and splitting of the args
 
+# --------------------------------------------------------------------
+# The catch-all SliceIt recipe
+# --------------------------------------------------------------------
+
 # ensure we dispatch to the slicer
 struct SliceIt end
 
-# the catch-all recipes
+# The `SliceIt` recipe finishes user and type recipe processing.
+# It splits processed data into individual series data, stores in copied `plotattributes`
+# for each series and returns no arguments.
 @recipe function f(::Type{SliceIt}, x, y, z)
 
     # handle data with formatting attached
@@ -125,10 +134,9 @@ struct SliceIt end
         z = z.data
     end
 
-    xs = convertToAnyVector(x, plotattributes)
-    ys = convertToAnyVector(y, plotattributes)
-    zs = convertToAnyVector(z, plotattributes)
-
+    xs = series_vector(x, plotattributes)
+    ys = series_vector(y, plotattributes)
+    zs = series_vector(z, plotattributes)
 
     fr = pop!(plotattributes, :fillrange, nothing)
     fillranges = process_fillrange(fr, plotattributes)
@@ -138,8 +146,6 @@ struct SliceIt end
     ribbons = process_ribbon(rib, plotattributes)
     mr = length(ribbons)
 
-    # @show zs
-
     mx = length(xs)
     my = length(ys)
     mz = length(zs)
@@ -164,16 +170,22 @@ struct SliceIt end
     nothing  # don't add a series for the main block
 end
 
+
+# --------------------------------------------------------------------
+# Apply type recipes
+# --------------------------------------------------------------------
+
 # this is the default "type recipe"... just pass the object through
-@recipe f(::Type{T}, v::T) where {T<:Any} = v
+@recipe f(::Type{T}, v::T) where T = v
 
 # this should catch unhandled "series recipes" and error with a nice message
 @recipe f(::Type{V}, x, y, z) where {V<:Val} = error("The backend must not support the series type $V, and there isn't a series recipe defined.")
 
 function _apply_type_recipe(plotattributes, v, letter)
-    _handle_axis_args!(plotattributes)
+    _preprocess_axis_args!(plotattributes, letter)
     rdvec = RecipesBase.apply_recipe(plotattributes, typeof(v), v)
-    _handle_axis_args!(plotattributes, letter)
+    warn_on_recipe_aliases!(plotattributes, :type, typeof(v))
+    _postprocess_axis_args!(plotattributes, letter)
     return rdvec[1].args[1]
 end
 
@@ -181,15 +193,17 @@ end
 # This sort of recipe should return a pair of functions... one to convert to number,
 # and one to format tick values.
 function _apply_type_recipe(plotattributes, v::AbstractArray, letter)
-    _handle_axis_args!(plotattributes)
+    _preprocess_axis_args!(plotattributes, letter)
     # First we try to apply an array type recipe.
     w = RecipesBase.apply_recipe(plotattributes, typeof(v), v)[1].args[1]
+    warn_on_recipe_aliases!(plotattributes, :type, typeof(v))
     # If the type did not change try it element-wise
     if typeof(v) == typeof(w)
         isempty(skipmissing(v)) && return Float64[]
         x = first(skipmissing(v))
         args = RecipesBase.apply_recipe(plotattributes, typeof(x), x)[1].args
-        _handle_axis_args!(plotattributes, letter)
+        warn_on_recipe_aliases!(plotattributes, :type, typeof(x))
+        _postprocess_axis_args!(plotattributes, letter)
         if length(args) == 2 && all(arg -> arg isa Function, args)
             numfunc, formatter = args
              return Formatted(map(numfunc, v), formatter)
@@ -197,35 +211,49 @@ function _apply_type_recipe(plotattributes, v::AbstractArray, letter)
              return v
         end
     end
-    _handle_axis_args!(plotattributes, letter)
+    _postprocess_axis_args!(plotattributes, letter)
     return w
 end
 
-# # special handling for Surface... need to properly unwrap and re-wrap
-# function _apply_type_recipe(plotattributes, v::Surface)
-#     T = eltype(v.surf)
-#     @show T
-#     if T <: Integer || T <: AbstractFloat
-#         v
-#     else
-#         ret = _apply_type_recipe(plotattributes, v.surf)
-#         if typeof(ret) <: Formatted
-#             Formatted(Surface(ret.data), ret.formatter)
-#         else
-#             v
-#         end
-#     end
-# end
+# special handling for Surface... need to properly unwrap and re-wrap
+_apply_type_recipe(plotattributes, v::Surface{<:AMat{<:DataPoint}}) = v
+function _apply_type_recipe(plotattributes, v::Surface)
+    ret = _apply_type_recipe(plotattributes, v.surf)
+    if typeof(ret) <: Formatted
+        Formatted(Surface(ret.data), ret.formatter)
+    else
+        Surface(ret.data)
+    end
+end
 
-# don't do anything for ints or floats
-_apply_type_recipe(plotattributes, v::AbstractArray{T}, letter) where {T<:Union{Integer,AbstractFloat}} = v
+# don't do anything vectors of datapoints and for nothing
+_apply_type_recipe(plotattributes, v::Nothing, letter) = v
+_apply_type_recipe(plotattributes, v::AbstractArray{<:MaybeString}, letter) = v
+_apply_type_recipe(plotattributes, v::AbstractArray{<:Union{Real, Nothing}}, letter) = v
+
+# axis args before type recipes should still be mapped to all axes
+function _preprocess_axis_args!(plotattributes)
+    for (k, v) in plotattributes
+        if is_axis_attr_noletter(k)
+            pop!(plotattributes, k)
+            for l in (:x, :y, :z)
+                lk = Symbol(l, k)
+                haskey(plotattributes, lk) || (plotattributes[lk] = v)
+            end
+        end
+    end
+end
+function _preprocess_axis_args!(plotattributes, letter)
+    plotattributes[:letter] = letter
+    _preprocess_axis_args!(plotattributes)
+end
 
 # axis args in type recipes should only be applied to the current axis
-function _handle_axis_args!(plotattributes, letter)
+function _postprocess_axis_args!(plotattributes, letter)
+    pop!(plotattributes, :letter)
     if letter in (:x, :y, :z)
-        replaceAliases!(plotattributes, _keyAliases)
         for (k, v) in plotattributes
-            if haskey(_axis_defaults, k)
+            if is_axis_attr_noletter(k)
                 pop!(plotattributes, k)
                 lk = Symbol(letter, k)
                 haskey(plotattributes, lk) || (plotattributes[lk] = v)
@@ -234,22 +262,14 @@ function _handle_axis_args!(plotattributes, letter)
     end
 end
 
-# axis args before type recipes should still be mapped to all axes
-function _handle_axis_args!(plotattributes)
-    replaceAliases!(plotattributes, _keyAliases)
-    for (k, v) in plotattributes
-        if haskey(_axis_defaults, k)
-            pop!(plotattributes, k)
-            for letter in (:x, :y, :z)
-                lk = Symbol(letter, k)
-                haskey(plotattributes, lk) || (plotattributes[lk] = v)
-            end
-        end
-    end
-end
+
+# --------------------------------------------------------------------
+# Fallback user recipes calling type recipes
+# --------------------------------------------------------------------
 
 # handle "type recipes" by converting inputs, and then either re-calling or slicing
 @recipe function f(x, y, z)
+    wrap_surfaces!(plotattributes, x, y, z)
     did_replace = false
     newx = _apply_type_recipe(plotattributes, x, :x)
     x === newx || (did_replace = true)
@@ -264,6 +284,7 @@ end
     end
 end
 @recipe function f(x, y)
+    wrap_surfaces!(plotattributes, x, y)
     did_replace = false
     newx = _apply_type_recipe(plotattributes, x, :x)
     x === newx || (did_replace = true)
@@ -276,6 +297,7 @@ end
     end
 end
 @recipe function f(y)
+    wrap_surfaces!(plotattributes, y)
     newy = _apply_type_recipe(plotattributes, y, :y)
     if y !== newy
         newy
@@ -302,12 +324,14 @@ end
 end
 
 
-# # --------------------------------------------------------------------
-# # 1 argument
-# # --------------------------------------------------------------------
-
 # helper function to ensure relevant attributes are wrapped by Surface
-function wrap_surfaces(plotattributes::AKW)
+function wrap_surfaces!(plotattributes, args...) end
+wrap_surfaces!(plotattributes, x::AMat, y::AMat, z::AMat) = wrap_surfaces!(plotattributes)
+wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::AMat) = wrap_surfaces!(plotattributes)
+function wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::Surface)
+    wrap_surfaces!(plotattributes)
+end
+function wrap_surfaces!(plotattributes)
     if haskey(plotattributes, :fill_z)
         v = plotattributes[:fill_z]
         if !isa(v, Surface)
@@ -316,42 +340,57 @@ function wrap_surfaces(plotattributes::AKW)
     end
 end
 
+
+# --------------------------------------------------------------------
+# 1 argument
+# --------------------------------------------------------------------
+
 @recipe f(n::Integer) = is3d(get(plotattributes,:seriestype,:path)) ? (SliceIt, n, n, n) : (SliceIt, n, n, nothing)
 
-all3D(plotattributes) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image, :plots_heatmap), get(plotattributes, :seriestype, :none))
+all3D(plotattributes) = trueOrAllTrue(
+    st -> st in (
+        :contour,
+        :contourf,
+        :heatmap,
+        :surface,
+        :wireframe,
+        :contour3d,
+        :image,
+        :plots_heatmap,
+    ),
+    get(plotattributes, :seriestype, :none),
+)
 
 # return a surface if this is a 3d plot, otherwise let it be sliced up
-@recipe function f(mat::AMat{T}) where T<:Union{Integer,AbstractFloat,Missing}
+@recipe function f(mat::AMat)
     if all3D(plotattributes)
-        n,m = axes(mat)
-        wrap_surfaces(plotattributes)
-        SliceIt, m, n, Surface(mat)
+        n, m = axes(mat)
+        m, n, Surface(mat)
     else
-        SliceIt, nothing, mat, nothing
+        nothing, mat, nothing
     end
 end
 
 # if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface
-@recipe function f(fmt::Formatted{T}) where T<:AbstractMatrix
+@recipe function f(fmt::Formatted{<:AMat})
     if all3D(plotattributes)
         mat = fmt.data
-        n,m = axes(mat)
-        wrap_surfaces(plotattributes)
-        SliceIt, m, n, Formatted(Surface(mat), fmt.formatter)
+        n, m = axes(mat)
+        m, n, Formatted(Surface(mat), fmt.formatter)
     else
-        SliceIt, nothing, fmt, nothing
+        nothing, fmt, nothing
     end
 end
 
 # assume this is a Volume, so construct one
-@recipe function f(vol::AbstractArray{T,3}, args...) where T<:Union{Number,Missing}
+@recipe function f(vol::AbstractArray{<:MaybeNumber, 3}, args...)
     seriestype := :volume
     SliceIt, nothing, Volume(vol, args...), nothing
 end
 
 
-# # images - grays
-function clamp_greys!(mat::AMat{T}) where T<:Gray
+# images - grays
+function clamp_greys!(mat::AMat{<:Gray})
     for i in eachindex(mat)
         mat[i].val < 0 && (mat[i] = Gray(0))
         mat[i].val > 1 && (mat[i] = Gray(1))
@@ -359,7 +398,7 @@ function clamp_greys!(mat::AMat{T}) where T<:Gray
     mat
 end
 
-@recipe function f(mat::AMat{T}) where T<:Gray
+@recipe function f(mat::AMat{<:Gray})
     n, m = axes(mat)
     if is_seriestype_supported(:image)
         seriestype := :image
@@ -374,8 +413,7 @@ end
     end
 end
 
-# # images - colors
-
+# images - colors
 @recipe function f(mat::AMat{T}) where T<:Colorant
 	n, m = axes(mat)
 
@@ -393,8 +431,7 @@ end
     end
 end
 
-#
-# # plotting arbitrary shapes/polygons
+# plotting arbitrary shapes/polygons
 
 @recipe function f(shape::Shape)
     seriestype --> :shape
@@ -428,40 +465,21 @@ end
             axis_limits(plt[1], :x)
         catch
             xinv = invscalefunc(get(plotattributes, :xscale, :identity))
-            xm = tryrange(f, xinv.([-5,-1,0,0.01]))
-            xm, tryrange(f, filter(x->x>xm, xinv.([5,1,0.99, 0, -0.01])))
+            xm = PlotUtils.tryrange(f, xinv.([-5,-1,0,0.01]))
+            xm, PlotUtils.tryrange(f, filter(x->x>xm, xinv.([5,1,0.99, 0, -0.01])))
         end
     end
 
     f, xmin, xmax
 end
 
-# try some intervals over which the function may be defined
-function tryrange(F::AbstractArray, vec)
-    rets = [tryrange(f, vec) for f in F] # get the preferred for each
-    maxind = maximum(indexin(rets, vec)) # get the last attempt that succeeded (most likely to fit all)
-    rets .= [tryrange(f, vec[maxind:maxind]) for f in F] # ensure that all functions compute there
-    rets[1]
-end
 
-function tryrange(F, vec)
-    for v in vec
-        try
-            tmp = F(v)
-            return v
-        catch
-        end
-    end
-    error("$F is not a Function, or is not defined at any of the values $vec")
-end
-#
-# # --------------------------------------------------------------------
-# # 2 arguments
-# # --------------------------------------------------------------------
-#
-#
-# # if functions come first, just swap the order (not to be confused with parametric functions...
-# # as there would be more than one function passed in)
+# --------------------------------------------------------------------
+# 2 arguments
+# --------------------------------------------------------------------
+
+# if functions come first, just swap the order (not to be confused with parametric
+# functions... as there would be more than one function passed in)
 
 @recipe function f(f::FuncOrFuncs{F}, x) where F<:Function
     F2 = typeof(x)
@@ -469,58 +487,25 @@ end
     x, f
 end
 
-#
-# # --------------------------------------------------------------------
-# # 3 arguments
-# # --------------------------------------------------------------------
-#
-#
-# # 3d line or scatter
 
-@recipe function f(x::AVec, y::AVec, z::AVec)
-    # st = get(plotattributes, :seriestype, :none)
-    # if st == :scatter
-    #     plotattributes[:seriestype] = :scatter3d
-    # elseif !is3d(st)
-    #     plotattributes[:seriestype] = :path3d
-    # end
-    SliceIt, x, y, z
-end
-
-@recipe function f(x::AMat, y::AMat, z::AMat)
-    # st = get(plotattributes, :seriestype, :none)
-    # if size(x) == size(y) == size(z)
-    #     if !is3d(st)
-    #         seriestype := :path3d
-    #     end
-    # end
-    wrap_surfaces(plotattributes)
-    SliceIt, x, y, z
-end
-
-#
-# # surface-like... function
+# --------------------------------------------------------------------
+# 3 arguments
+# --------------------------------------------------------------------
 
+# surface-like... function
 @recipe function f(x::AVec, y::AVec, zf::Function)
-    # x = X <: Number ? sort(x) : x
-    # y = Y <: Number ? sort(y) : y
-    wrap_surfaces(plotattributes)
-    SliceIt, x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
+    x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
 end
 
-#
-# # surface-like... matrix grid
-
+# surface-like... matrix grid
 @recipe function f(x::AVec, y::AVec, z::AMat)
     if !like_surface(get(plotattributes, :seriestype, :none))
         plotattributes[:seriestype] = :contour
     end
-    wrap_surfaces(plotattributes)
-    SliceIt, x, y, Surface(z)
+    x, y, Surface(z)
 end
 
-# # images - grays
-
+# images - grays
 @recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Gray
     if is_seriestype_supported(:image)
         seriestype := :image
@@ -535,8 +520,7 @@ end
     end
 end
 
-# # images - colors
-
+# images - colors
 @recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Colorant
     if is_seriestype_supported(:image)
         seriestype := :image
@@ -551,27 +535,19 @@ end
     end
 end
 
-#
-#
-# # --------------------------------------------------------------------
-# # Parametric functions
-# # --------------------------------------------------------------------
 
-#
-# # special handling... xmin/xmax with parametric function(s)
+# --------------------------------------------------------------------
+# Parametric functions
+# --------------------------------------------------------------------
+
+# special handling... xmin/xmax with parametric function(s)
 @recipe function f(f::Function, xmin::Number, xmax::Number)
     xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)]
     _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
 end
 @recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where F<:Function
     xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)]
-    xs = Array{Any}(undef, length(fs))
-    ys = Array{Any}(undef, length(fs))
-    for (i, (x, y)) in enumerate(_scaled_adapted_grid(f, xscale, yscale, xmin, xmax) for f in fs)
-        xs[i] = x
-    	ys[i] = y
-    end
-    xs, ys
+    unzip(_scaled_adapted_grid.(fs, xscale, yscale, xmin, xmax))
 end
 @recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, u::AVec) where {F<:Function,G<:Function}  = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u)
 @recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, umin::Number, umax::Number, n = 200) where {F<:Function,G<:Function} = fx, fy, range(umin, stop = umax, length = n)
@@ -582,8 +558,7 @@ function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
     xinv.(xs), yinv.(ys)
 end
 
-#
-# # special handling... 3D parametric function(s)
+# special handling... 3D parametric function(s)
 @recipe function f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, u::AVec) where {F<:Function,G<:Function,H<:Function}
     mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
 end
@@ -591,12 +566,10 @@ end
     fx, fy, fz, range(umin, stop = umax, length = numPoints)
 end
 
-#
-#
-# # --------------------------------------------------------------------
-# # Lists of tuples and GeometryTypes.Points
-# # --------------------------------------------------------------------
-#
+
+# --------------------------------------------------------------------
+# Lists of tuples and GeometryTypes.Points
+# --------------------------------------------------------------------
 
 @recipe f(v::AVec{<:Tuple})               = unzip(v)
 @recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v)
@@ -606,23 +579,10 @@ end
 # Special case for 4-tuples in :ohlc series
 @recipe f(xyuv::AVec{<:Tuple{R1,R2,R3,R4}}) where {R1,R2,R3,R4} = get(plotattributes,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)
 
-#
-# # --------------------------------------------------------------------
-# # handle grouping
-# # --------------------------------------------------------------------
 
-# @recipe function f(groupby::GroupBy, args...)
-#     for (i,glab) in enumerate(groupby.groupLabels)
-#         # create a new series, with the label of the group, and an idxfilter (to be applied in slice_and_dice)
-#         # TODO: use @series instead
-#         @show i, glab, groupby.groupIds[i]
-#         di = copy(plotattributes)
-#         get!(di, :label, string(glab))
-#         get!(di, :idxfilter, groupby.groupIds[i])
-#         push!(series_list, RecipeData(di, args))
-#     end
-#     nothing
-# end
+# --------------------------------------------------------------------
+# handle grouping
+# --------------------------------------------------------------------
 
 splittable_kw(key, val, lengthGroup) = false
 splittable_kw(key, val::AbstractArray, lengthGroup) = !(key in (:group, :color_palette)) && length(axes(val,1)) == lengthGroup

src/types.jl

@@ -26,8 +26,9 @@ struct Attr <: AbstractDict{Symbol,Any}
     defaults::KW
 end
 
-Base.getindex(attr::Attr, k) = haskey(attr.explicit,k) ?
-                                     attr.explicit[k] : attr.defaults[k]
+function Base.getindex(attr::Attr, k)
+    return haskey(attr.explicit, k) ? attr.explicit[k] : attr.defaults[k]
+end
 Base.haskey(attr::Attr, k) = haskey(attr.explicit,k) || haskey(attr.defaults,k)
 Base.get(attr::Attr, k, default) = haskey(attr, k) ? attr[k] : default
 function Base.get!(attr::Attr, k, default)
@@ -41,7 +42,7 @@ end
 function Base.delete!(attr::Attr, k)
     haskey(attr.explicit, k) && delete!(attr.explicit, k)
     haskey(attr.defaults, k) && delete!(attr.defaults, k)
-end 
+end
 Base.length(attr::Attr) = length(union(keys(attr.explicit), keys(attr.defaults)))
 function Base.iterate(attr::Attr)
     exp_keys = keys(attr.explicit)