From 9e932cd46ca652463b807e010350ab45ea43a215 Mon Sep 17 00:00:00 2001 From: Kristoffer Carlsson Date: Wed, 21 Feb 2018 21:15:42 +0100 Subject: [PATCH 1/4] add precompilation statements for Pkg3 fdfds --- src/GraphType.jl | 6 +- src/Operations.jl | 2 +- src/Pkg3.jl | 5 + src/Resolve.jl | 2 +- src/precompile.jl | 272 ++++++++++++++++++++++++++++++++++++++++++++++ test/resolve.jl | 4 +- 6 files changed, 284 insertions(+), 7 deletions(-) create mode 100644 src/precompile.jl diff --git a/src/GraphType.jl b/src/GraphType.jl index f04741ac2278c..c9cd85573b4d6 100644 --- a/src/GraphType.jl +++ b/src/GraphType.jl @@ -125,7 +125,7 @@ mutable struct GraphData versions::Dict{UUID,Set{VersionNumber}}, deps::Dict{UUID,Dict{VersionRange,Dict{String,UUID}}}, compat::Dict{UUID,Dict{VersionRange,Dict{String,VersionSpec}}}, - uuid_to_name::Dict{UUID,String}; + uuid_to_name::Dict{UUID,String}, verbose::Bool = false ) # generate pkgs @@ -246,7 +246,7 @@ mutable struct Graph compat::Dict{UUID,Dict{VersionRange,Dict{String,VersionSpec}}}, uuid_to_name::Dict{UUID,String}, reqs::Requires = Requires(), - fixed::Dict{UUID,Fixed} = Dict{UUID,Fixed}(uuid_julia=>Fixed(VERSION)); + fixed::Dict{UUID,Fixed} = Dict{UUID,Fixed}(uuid_julia=>Fixed(VERSION)), verbose::Bool = false ) @@ -254,7 +254,7 @@ mutable struct Graph extra_uuids ⊆ keys(versions) || error("unknown UUID found in reqs/fixed") # TODO? # Type assert below due to https://github.com/JuliaLang/julia/issues/25918 - data = GraphData(versions, deps, compat, uuid_to_name, verbose = verbose)::GraphData + data = GraphData(versions, deps, compat, uuid_to_name, verbose)::GraphData pkgs, np, spp, pdict, pvers, vdict, rlog = data.pkgs, data.np, data.spp, data.pdict, data.pvers, data.vdict, data.rlog local extended_deps diff --git a/src/Operations.jl b/src/Operations.jl index 0d54d2d63934e..2647630e61322 100644 --- a/src/Operations.jl +++ b/src/Operations.jl @@ -205,7 +205,7 @@ function deps_graph(ctx::Context, uuid_to_name::Dict{UUID,String}, reqs::Require uuid_to_name[UUID(info["uuid"])] = info["name"] end - return Graph(all_versions, all_deps, all_compat, uuid_to_name, reqs, fixed; verbose=ctx.graph_verbose) + return Graph(all_versions, all_deps, all_compat, uuid_to_name, reqs, fixed, #=verbose=# ctx.graph_verbose) end # Resolve a set of versions given package version specs diff --git a/src/Pkg3.jl b/src/Pkg3.jl index 4d6cede1dc8ee..c4a1d493d4565 100644 --- a/src/Pkg3.jl +++ b/src/Pkg3.jl @@ -38,4 +38,9 @@ function __init__() end end +using Pkg3.Types +using UUIDs +import LibGit2 +include("precompile.jl") + end # module diff --git a/src/Resolve.jl b/src/Resolve.jl index 4304cff8116a0..1d5227e98ef48 100644 --- a/src/Resolve.jl +++ b/src/Resolve.jl @@ -53,7 +53,7 @@ end Scan the graph for (explicit or implicit) contradictions. Returns a list of problematic (package,version) combinations. """ -function sanity_check(graph::Graph, sources::Set{UUID} = Set{UUID}(); verbose = true) +function sanity_check(graph::Graph, sources::Set{UUID} = Set{UUID}(), verbose::Bool = true) req_inds = graph.req_inds fix_inds = graph.fix_inds diff --git a/src/precompile.jl b/src/precompile.jl new file mode 100644 index 0000000000000..47cabb52db818 --- /dev/null +++ b/src/precompile.jl @@ -0,0 +1,272 @@ +precompile(Tuple{getfield(Base, Symbol("#kw##printstyled")), NamedTuple{(:bold, :color), Tuple{Bool, Symbol}}, typeof(Base.printstyled), Base.TTY,String}) +precompile(Tuple{typeof(Base.start), Tuple{Pkg3.Types.PackageSpec, Bool, String}}) +precompile(Tuple{typeof(Base.values), Base.Dict{String, String}}) +precompile(Tuple{typeof(Base.setindex!), Base.Dict{Base.UUID, Base.Dict{K, V} where V where K}, Base.Dict{String, Any}, Base.UUID}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Base.ValueIterator{Base.Dict{String, String}}, Type{Base.UUID}}}) +precompile(Tuple{typeof(Base.mapfoldl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}}) +precompile(Tuple{Type{NamedTuple{(:path,), Tuple{String}}}, Tuple{String}}) +precompile(Tuple{typeof(Base.getindex), Type{Any}, Type{Nothing}, Type{String}}) +precompile(Tuple{typeof(Base.map), Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, Any}}}) +precompile(Tuple{typeof(Base.merge_types), Tuple{Symbol, Symbol, Symbol, Symbol}, Type{NamedTuple{(:bare, :checkout_branch, :remote_cb), Tuple{Int32, Base.Cstring, Ptr{Nothing}}}}, Type{NamedTuple{(:fetch_opts,), Tuple{LibGit2.FetchOptionsStruct}}}}) +precompile(Tuple{typeof(Base.isempty), Base.Dict{String, Base.UUID}}) +precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Array{Array{Base.VersionNumber, 1}, 1}}) +precompile(Tuple{typeof(Base.get!), Base.Dict{Base.UUID, Array{String, 1}}, Base.UUID, Array{String, 1}}) +precompile(Tuple{typeof(Base.push!), Array{Union{Pkg3.Types.VersionRange, String, Pkg3.REPLMode.Command, Pkg3.REPLMode.Option}, 1}, String}) +precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Base.UUID, 1}, Base.UUID, Base.Generator{Base.ValueIterator{Base.Dict{String, Any}}, Type{Base.UUID}}, Int64}) +precompile(Tuple{Type{Pkg3.Types.PackageSpec}, Base.SubString{String}, Pkg3.Types.VersionSpec}) +precompile(Tuple{typeof(Base.show_method_candidates), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, MethodError, Tuple{}}) +precompile(Tuple{Type{Pkg3.Display.VerInfo}, Nothing, String, Base.VersionNumber, Bool}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Base.ValueIterator{Base.Dict{Any, Any}}, Type{Base.UUID}}}) +precompile(Tuple{Type{Pkg3.Pkg2.Reqs.Comment}, String}) +precompile(Tuple{typeof(Base.setindex!), Base.Dict{Base.VersionNumber, Base.SHA1}, Base.SHA1, Base.VersionNumber}) +precompile(Tuple{typeof(Base.map), Type{Base.UUID}, Base.ValueIterator{Base.Dict{Any, Any}}}) +precompile(Tuple{Type{NamedTuple{(:bare, :checkout_branch, :fetch_opts, :remote_cb), Tuple{Int32, Base.Cstring, LibGit2.FetchOptions, Ptr{Nothing}}}}, Tuple{Int32, Base.Cstring, LibGit2.FetchOptions, Ptr{Nothing}}}) +precompile(Tuple{Type{Expr}, Symbol, GlobalRef, String, Core.SSAValue, String, Core.SSAValue, String, Core.SlotNumber, String}) +precompile(Tuple{typeof(Base.arg_gen), Base.SubString{String}, Base.SubString{String}}) +precompile(Tuple{typeof(Base.start), Tuple{Nothing, String}}) +precompile(Tuple{typeof(Base.next), Tuple{Base.BitArray{1}}, Int64}) +precompile(Tuple{typeof(Base.length), Base.Dict{Base.UUID, Int64}}) +precompile(Tuple{Type{Pkg3.Types.VersionBound}, Int64, Int64}) +precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.IOStream}, Tuple{}}) +precompile(Tuple{typeof(Pkg3.TOML.insertpair), Pkg3.TOML.Parser{Base.IOStream}, Pkg3.TOML.Table, String, Array{String, 1}, Int64}) +precompile(Tuple{typeof(Base.in), String, Array{String, 1}}) +precompile(Tuple{typeof(Pkg3.TOML.SOME), Array{String, 1}}) +precompile(Tuple{typeof(Base.start), Base.Pair{String, Any}}) +precompile(Tuple{typeof(Base.union!), Base.Set{Base.UUID}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}) +precompile(Tuple{typeof(Base.run), Base.Cmd, Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}) +precompile(Tuple{Type{Pkg3.REPLMode.Command}, Pkg3.REPLMode.CommandKind, Base.SubString{String}}) +precompile(Tuple{typeof(Pkg3.Display.not_in_project), Base.Dict{String, Any}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, Type{Base.UUID}, Base.ValueIterator{Base.Dict{Any, Any}}}) +precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Array{Int64, 1}, 1}}) +precompile(Tuple{typeof(Base.get!), Base.Dict{String, Any}, String, Array{Base.Dict{String, Any}, 1}}) +precompile(Tuple{typeof(Base.values), Base.Dict{String, Any}}) +precompile(Tuple{getfield(Base, Symbol("#kw##with_output_color")), NamedTuple{(:bold,), Tuple{Bool}}, typeof(Base.with_output_color), typeof(Base.print), Symbol, Base.IOStream, String}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, String}}}) +precompile(Tuple{typeof(Pkg3.Display.print_diff), Base.TTY, Array{Pkg3.Display.DiffEntry, 1}}) +precompile(Tuple{typeof(Pkg3.Operations.install_archive), Array{String, 1}, Base.VersionNumber, String}) +precompile(Tuple{typeof(Base.start), Tuple{typeof(Base.getindex), Array{Any, 1}}}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Array{Any, 1}, typeof(Pkg3.TOML.table2dict)}}) +precompile(Tuple{typeof(Base.isempty), Base.Dict{String, Any}}) +precompile(Tuple{Type{NamedTuple{(:env,), Tuple{Pkg3.Types.EnvCache}}}, Tuple{Pkg3.Types.EnvCache}}) +precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}}) +precompile(Tuple{getfield(Core, Symbol("#kw#Type")), NamedTuple{(:bare, :checkout_branch, :fetch_opts, :remote_cb), Tuple{Int32, Base.Cstring, LibGit2.FetchOptions, Ptr{Nothing}}}, Type{LibGit2.CloneOptions}}) +precompile(Tuple{typeof(Base.getproperty), Pkg3.Pkg2.Pkg2Types.VersionSet, Symbol}) +precompile(Tuple{typeof(Pkg3.API.rm), String}) +precompile(Tuple{Type{NamedTuple{(:callbacks,), Tuple{LibGit2.RemoteCallbacks}}}, Tuple{LibGit2.RemoteCallbacks}}) +precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, TypeVar}) +precompile(Tuple{getfield(LibGit2, Symbol("#kw##clone")), NamedTuple{(:branch,), Tuple{String}}, typeof(LibGit2.clone), String, String}) +precompile(Tuple{typeof(Base.promote_eltype), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID,Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}) +precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Base.UUID, Pkg3.Types.VersionSpec}) +precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Pkg3.Types.VersionSpec}, String}) +precompile(Tuple{typeof(Base.start), Array{Base.UUID, 1}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.IOStream}, Type{Union{}}}) +precompile(Tuple{typeof(Base.next), Base.Channel{Any}, Base.ChannelIterState{Any}}) +precompile(Tuple{typeof(Base.merge_names), Tuple{Symbol, Symbol, Symbol}, Tuple{Symbol}}) +precompile(Tuple{typeof(Base.getindex), Base.Dict{Any, Any}, Char}) +precompile(Tuple{typeof(Base.next), Array{Base.Dict{String, Any}, 1}, Int64}) +precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Symbol, TypeVar}) +precompile(Tuple{Type{Pkg3.Types.PackageSpec}, Base.SubString{String}}) +precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Type{Base.LinRange{T} where T}}) +precompile(Tuple{typeof(Base.promote_eltype), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID,Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}) +precompile(Tuple{getfield(Core, Symbol("#kw#Type")), NamedTuple{(:prompt_prefix, :prompt_suffix, :sticky), Tuple{String, String, Bool}}, Type{REPL.LineEdit.Prompt}, String}) +precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##_print")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML._print), Base.IOStream, Base.Dict{String, Any}, Array{String, 1}}) +precompile(Tuple{getfield(Base, Symbol("#kw##printstyled")), NamedTuple{(:bold, :color), Tuple{Bool, Symbol}}, typeof(Base.printstyled), Base.IOStream, String}) +precompile(Tuple{typeof(Base.deepcopy), Base.Dict{String, Any}}) +precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol, Symbol, Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}}) +precompile(Tuple{typeof(Base.length), Array{Base.Dict{Base.VersionNumber, Int64}, 1}}) +precompile(Tuple{typeof(Base.show_tuple_as_call), Base.IOContext{Base.IOStream}, Symbol, Type{Tuple{typeof(Pkg3.Operations.build_versions), Pkg3.Types.Context, Array{Base.UUID, 1}}}}) +precompile(Tuple{typeof(Base.empty), Base.Dict{Union{}, Union{}}, Type{String}, Type{Base.UUID}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Type{Union{}}}) +precompile(Tuple{Type{Expr}, Symbol, GlobalRef, QuoteNode, QuoteNode, QuoteNode, QuoteNode, QuoteNode, QuoteNode, QuoteNode}) +precompile(Tuple{typeof(Base.isempty), Base.Dict{Base.UUID, Int64}}) +precompile(Tuple{typeof(Pkg3.TOML.insertpair), Pkg3.TOML.Parser{Base.IOStream}, Pkg3.TOML.Table, String, String, Int64}) +precompile(Tuple{typeof(Base.length), Base.Dict{String, String}}) +precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol}, Tuple{Symbol, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}}) +precompile(Tuple{typeof(Base.collect), Type{Any}, Base.Generator{Tuple{Nothing, String}, typeof(Core.Typeof)}}) +precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Pkg3.Types.PackageSpec, Bool, String}}) +precompile(Tuple{typeof(Base.getindex), Base.BitArray{2}, Base.BitArray{1}, Base.BitArray{1}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Core.TypeName}) +precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{UndefVarError, Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}}}) +precompile(Tuple{typeof(Base.union), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}) +precompile(Tuple{typeof(Base.length), Array{Array{Base.VersionNumber, 1}, 1}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Type{Union{Base.Slice{T} where T<:(Base.AbstractUnitRange{T} where T), Base.UnitRange{T} where T<:Real}}}) +precompile(Tuple{typeof(Base.in), String, Base.KeySet{String, Base.Dict{String, Any}}}) +precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Base.Dict{Base.UUID, Int64}}) +precompile(Tuple{typeof(Base.ident_cmp), Tuple{String}, Tuple{}}) +precompile(Tuple{typeof(Base.deepcopy_internal), Base.Dict{String, String}, Base.IdDict{Any, Any}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Core.Typeof), Tuple{Nothing, String}}) +precompile(Tuple{typeof(Base.map), Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, String}}}) +precompile(Tuple{typeof(Base.empty), Base.Dict{Union{}, Union{}}, Type{String}, Type{String}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Bool}) +precompile(Tuple{typeof(Pkg3.Display.name_ver_info), Base.Dict{String, Any}}) +precompile(Tuple{typeof(Base.empty), Base.Dict{Union{}, Union{}}, Type{Base.UUID}, Type{Int64}}) +precompile(Tuple{typeof(Base.getindex), Type{Pkg3.Types.VersionRange}, Pkg3.Pkg2.Pkg2Types.VersionInterval}) +precompile(Tuple{typeof(Base.start), Array{Base.Dict{String, Any}, 1}}) +precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Array{Base.UUID, 1}}) +precompile(Tuple{typeof(Base.promote_eltype), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}) +precompile(Tuple{typeof(Base.done), Base.Channel{Any}, Base.ChannelIterState{Any}}) +precompile(Tuple{getfield(Base, Symbol("#kw##printstyled")), NamedTuple{(:color,), Tuple{Symbol}}, typeof(Base.printstyled), Base.IOContext{Base.IOStream}, String}) +precompile(Tuple{typeof(Pkg3.Display.in_project), Base.Dict{String, Any}}) +precompile(Tuple{typeof(REPL.LineEdit.setup_search_keymap), REPL.REPLHistoryProvider}) +precompile(Tuple{typeof(Base.foldl), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}}) +precompile(Tuple{typeof(Base._array_for), Type{Base.BitArray{2}}, Base.UnitRange{Int64}, Base.HasShape{1}}) +precompile(Tuple{typeof(Base.close), LibGit2.GitRepo}) +precompile(Tuple{typeof(Base.promote_eltype), Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}) +precompile(Tuple{typeof(REPL.LineEdit.setup_prefix_keymap), REPL.REPLHistoryProvider, REPL.LineEdit.Prompt}) +precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Base.UUID, 1}, Base.UUID, Base.Generator{Base.ValueIterator{Base.Dict{Any, Any}}, Type{Base.UUID}}, Int64}) +precompile(Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), typeof(Base.union!), Base.Set{Base.UUID}, Tuple{Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.Fixed}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID,Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}, Base.KeySet{Base.UUID, Base.Dict{Base.UUID, Pkg3.Types.VersionSpec}}}, Int64}) +precompile(Tuple{typeof(Base.indexed_next), Tuple{typeof(Base.getindex), Array{Any, 1}}, Int64, Int64}) +precompile(Tuple{typeof(Base.keys), Base.Dict{String, Any}}) +precompile(Tuple{typeof(Base._array_for), Type{Base.UUID}, Base.ValueIterator{Base.Dict{Any, Any}}, Base.HasLength}) +precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Array{Any, 1}, String}) +precompile(Tuple{typeof(Base._compute_eltype), Type{Tuple{Int32, Base.Cstring, Ptr{Nothing}}}}) +precompile(Tuple{typeof(Base.hash), Tuple{String, UInt64}, UInt64}) +precompile(Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.IOStream, Base.Pair{Symbol, Bool}}) +precompile(Tuple{typeof(Pkg3.API.build)}) +precompile(Tuple{typeof(Base.merge_names), Tuple{Symbol}, Tuple{Symbol}}) +precompile(Tuple{getfield(Pkg3.API, Symbol("#kw##checkout")), NamedTuple{(:path,), Tuple{String}}, typeof(Pkg3.API.checkout), Pkg3.Types.Context, Array{Tuple{Pkg3.Types.PackageSpec, Union{Nothing, String}}, 1}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.IOStream}, Type{Union{Nothing, String}}}) +precompile(Tuple{typeof(Base.getindex), Array{Array{UInt64, 1}, 1}, Int64}) +precompile(Tuple{typeof(Base.merge!), Base.Dict{String, Base.UUID}, Base.Dict{Union{}, Union{}}}) +precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.ResolveLog, Symbol, Base.Dict{Base.UUID, Pkg3.GraphType.ResolveLogEntry}}) +precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, Type{Base.Pair{A, B} where B where A}}) +precompile(Tuple{typeof(Base.print), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String, Type{getfield(Pkg3.API, Symbol("#kw##checkout"))}, String}) +precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.IOStream}, Type{Pkg3.Types.Context}}) +precompile(Tuple{typeof(Base.merge!), Base.Dict{String, String}, Base.Dict{Union{}, Union{}}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Tuple{}}) +precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Array{Base.Dict{String, Any}, 1}, String}) +precompile(Tuple{typeof(Base.getindex), Base.Dict{String, Pkg3.REPLMode.CommandKind}, Base.SubString{String}}) +precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##print")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML.print), Base.IOStream, Base.Dict{String, Any}}) +precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Pkg3.Types.PackageSpec, String}}) +precompile(Tuple{typeof(Base.length), Array{Array{Base.BitArray{2}, 1}, 1}}) +precompile(Tuple{typeof(Base.identity), Char}) +precompile(Tuple{typeof(Base.promote_typejoin), Type{Int32}, Type{Base.Cstring}}) +precompile(Tuple{typeof(Base.length), Array{Array{Int64, 1}, 1}}) +precompile(Tuple{typeof(Base.indexed_next), Tuple{Pkg3.Types.PackageSpec, Bool, String}, Int64, Int64}) +precompile(Tuple{typeof(Base.values), Base.Dict{Any, Any}}) +precompile(Tuple{getfield(Base, Symbol("#kw##sort!")), NamedTuple{(:by,), Tuple{typeof(Base.Unicode.lowercase)}}, typeof(Base.sort!), Array{String, 1}}) +precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.Graph, Symbol, Array{Array{Base.BitArray{2}, 1}, 1}}) +precompile(Tuple{typeof(Base.typesof), Nothing, String}) +precompile(Tuple{Type{Pkg3.Types.PackageSpec}, String, Base.UUID}) +precompile(Tuple{typeof(Base.spawn_opts_inherit), Tuple{Base.DevNullStream, Base.DevNullStream, Base.DevNullStream}}) +precompile(Tuple{typeof(Pkg3.REPLMode.create_mode), REPL.LineEditREPL, REPL.LineEdit.Prompt}) +precompile(Tuple{typeof(Base.unescape_string), Base.SubString{String}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.IOStream}, Tuple{Symbol}}) +precompile(Tuple{typeof(Base.start), Tuple{UndefVarError, Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, Any}}}) +precompile(Tuple{typeof(Base.push!), Array{Pkg3.Pkg2.Reqs.Line, 1}, Pkg3.Pkg2.Reqs.Requirement}) +precompile(Tuple{typeof(Base._array_for), Type{Base.UUID}, Base.ValueIterator{Base.Dict{String, Any}}, Base.HasLength}) +precompile(Tuple{typeof(Base.start), Tuple{Pkg3.Types.PackageSpec, String}}) +precompile(Tuple{getfield(Base, Symbol("#kw##show_trace_entry")), NamedTuple{(:prefix,), Tuple{String}}, typeof(Base.show_trace_entry), Base.IOContext{Base.IOStream}, Base.StackTraces.StackFrame, Int64}) +precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Base.Dict{String, String}, String}) +precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##printvalue")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML.printvalue), Base.IOStream,Array{String, 1}}) +precompile(Tuple{typeof(Base.isempty), Array{Base.Dict{String, Any}, 1}}) +precompile(Tuple{typeof(Pkg3.Display.manifest_diff), Base.Dict{String, Any}, Base.Dict{String, Any}}) +precompile(Tuple{typeof(Base.length), Base.Dict{String, Any}}) +precompile(Tuple{typeof(Base.promote_typejoin), Type{Union{}}, Type{Int32}}) +precompile(Tuple{typeof(Base.push!), Array{Pkg3.Pkg2.Reqs.Line, 1}, Pkg3.Pkg2.Reqs.Comment}) +precompile(Tuple{typeof(Base.start), Tuple{Base.BitArray{1}}}) +precompile(Tuple{Type{Pkg3.Types.VersionSpec}, String}) +precompile(Tuple{typeof(Base.print), Base.IOContext{Base.IOStream}, String, Type{Pkg3.Types.Context}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.IOStream}, Int64}) +precompile(Tuple{typeof(Base.merge_types), Tuple{Symbol, Symbol}, Type{NamedTuple{(:credentials,), Tuple{Ptr{Nothing}}}}, Type{NamedTuple{(:payload,), Tuple{Ptr{Nothing}}}}}) +precompile(Tuple{typeof(Base.collect), Base.KeySet{String, Base.Dict{String, Any}}}) +precompile(Tuple{Type{NamedTuple{(:branch,), Tuple{String}}}, Tuple{String}}) +precompile(Tuple{Type{NamedTuple{(:prompt_prefix, :prompt_suffix, :sticky), Tuple{String, String, Bool}}}, Tuple{String, String, Bool}}) +precompile(Tuple{Pkg3.Display.InProject{Base.Dict{String, Any}}, String, Base.Dict{String, Any}}) +precompile(Tuple{Type{Pkg3.Display.VerInfo}, Base.SHA1, Nothing, Base.VersionNumber, Bool}) +precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{String}, Char}) +precompile(Tuple{Type{Pkg3.Pkg2.Reqs.Requirement}, String}) +precompile(Tuple{typeof(Base.ident_cmp), Tuple{}, Tuple{String}}) +precompile(Tuple{typeof(Base.length), Array{Base.Dict{Int64, Int64}, 1}}) +precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##_print")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML._print), Base.IOStream, Base.Dict{String, String}, Array{String, 1}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, TypeVar}) +precompile(Tuple{typeof(Base.cmd_gen), Tuple{Tuple{Base.Cmd}, Tuple{Base.SubString{String}}}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{REPL.Terminals.TTYTerminal}, Tuple{}}) +precompile(Tuple{typeof(Base.vcat), Base.BitArray{1}, Base.BitArray{1}}) +precompile(Tuple{typeof(Base.get!), Base.Dict{String, Array{Base.UUID, 1}}, String, Array{Base.UUID, 1}}) +precompile(Tuple{typeof(Base.show_datatype), Base.IOContext{Base.IOStream}, Type{Pkg3.Types.Context}}) +precompile(Tuple{typeof(Base.delete!), Base.Set{Any}, Char}) +precompile(Tuple{typeof(Base.vcat), Base.BitArray{1}}) +precompile(Tuple{typeof(Base.:(∉)), Base.UUID, Array{Base.UUID, 1}}) +precompile(Tuple{typeof(Pkg3.API.add), String}) +precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Base.UUID, String}) +precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Pkg3.REPLMode.CommandKind}, Base.SubString{String}}) +precompile(Tuple{typeof(Base.display_error), Base.IOStream, MethodError, Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}}) +precompile(Tuple{typeof(REPL.eval), Module, Symbol}) +precompile(Tuple{getfield(Pkg3.TOML, Symbol("#kw##printvalue")), NamedTuple{(:sorted,), Tuple{Bool}}, typeof(Pkg3.TOML.printvalue), Base.IOStream,String}) +precompile(Tuple{typeof(Base.promote_typejoin), Type{Any}, Type{Ptr{Nothing}}}) +precompile(Tuple{Type{Pkg3.Types.VersionBound}, Int64, Int64, Int64}) +precompile(Tuple{getfield(Base, Symbol("#kw##with_output_color")), NamedTuple{(:bold,), Tuple{Bool}}, typeof(Base.with_output_color), typeof(Base.print), Symbol, Base.IOContext{Base.IOStream}, String}) +precompile(Tuple{typeof(Base.vcat), Base.BitArray{1}, Base.BitArray{1}, Base.BitArray{1}}) +precompile(Tuple{Type{Base.SHA1}, String}) +precompile(Tuple{typeof(Base.ident_cmp), Tuple{String}, Tuple{String}}) +precompile(Tuple{typeof(Base.get!), Base.Dict{String, Array{String, 1}}, String, Array{String, 1}}) +precompile(Tuple{getfield(Core, Symbol("#kw#Type")), NamedTuple{(:env,), Tuple{Pkg3.Types.EnvCache}}, Type{Pkg3.Types.Context}}) +precompile(Tuple{typeof(Base.diff_names), Tuple{Symbol, Symbol, Symbol, Symbol}, Tuple{Symbol}}) +precompile(Tuple{typeof(Base.show), Base.IOContext{REPL.Terminals.TTYTerminal}, Type{Union{}}}) +precompile(Tuple{typeof(REPL.LineEdit.fixup_keymaps!), Base.Dict{Char, Any}, Int64, Char, Nothing}) +precompile(Tuple{typeof(Base.push!), Base.Set{Any}, Char}) +precompile(Tuple{typeof(Base.:(!=)), String, Bool}) +precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Any}, Base.Dict{Any, Any}, String}) +precompile(Tuple{typeof(Base.:(!=)), Base.SubString{String}, Nothing}) +precompile(Tuple{Type{Pkg3.Types.PackageSpec}, String}) +precompile(Tuple{typeof(Base.hash), Tuple{String}, UInt64}) +precompile(Tuple{typeof(Base.print), Base.IOContext{Base.IOStream}, Type{Pkg3.Types.Context}}) +precompile(Tuple{typeof(REPL.send_to_backend), Symbol, REPL.REPLBackendRef}) +precompile(Tuple{typeof(Base.promote_type), Type{Base.UUID}, Type{Base.UUID}}) +precompile(Tuple{Type{Pkg3.Types.VersionBound}, Base.SubString{String}}) +precompile(Tuple{getfield(Core, Symbol("#kw#Type")), NamedTuple{(:callbacks,), Tuple{LibGit2.RemoteCallbacks}}, Type{LibGit2.FetchOptions}}) +precompile(Tuple{typeof(Base.vcat), Base.BitArray{2}, Base.BitArray{2}}) +precompile(Tuple{typeof(Base.promote_typejoin), Type{Union{}}, Type{Base.UUID}}) +precompile(Tuple{typeof(Base.done), Array{Base.Dict{String, Any}, 1}, Int64}) +precompile(Tuple{typeof(Base.setproperty!), Pkg3.GraphType.GraphData, Symbol, Array{Base.Dict{Base.VersionNumber, Int64}, 1}}) +precompile(Tuple{typeof(Base.indexed_next), Tuple{UndefVarError, Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}}, Int64, Int64}) +precompile(Tuple{typeof(Base.merge), Base.Dict{String, Any}, Base.Dict{String, Any}}) +precompile(Tuple{Type{Base.Pair{A, B} where B where A}, Base.VersionNumber, Base.SHA1}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Base.ValueIterator{Base.Dict{String, Any}}, Type{Base.UUID}}}) +precompile(Tuple{typeof(Base.start), Base.Pair{Any, Any}}) +precompile(Tuple{typeof(Base.deepcopy_internal), Array{Base.Dict{String, Any}, 1}, Base.IdDict{Any, Any}}) +precompile(Tuple{typeof(REPL.send_to_backend), Symbol, Base.Channel{Any}, Base.Channel{Any}}) +precompile(Tuple{typeof(Base.merge), Base.Dict{String, Any}, Base.Dict{String, String}}) +precompile(Tuple{typeof(Base.deepcopy_internal), Base.Dict{Any, Any}, Base.IdDict{Any, Any}}) +precompile(Tuple{Type{Base.Pair{A, B} where B where A}, String, Base.UUID}) +precompile(Tuple{typeof(Base.start), Base.Channel{Any}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Pkg3.TOML.table2dict), Array{Any, 1}}) +precompile(Tuple{typeof(Base.Iterators.enumerate), Array{Base.UUID, 1}}) +precompile(Tuple{typeof(Base.similar), Array{Base.Dict{String, Any}, 1}}) +precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, String, Base.UUID, String}) +precompile(Tuple{typeof(Base.done), Tuple{Base.BitArray{1}}, Int64}) +precompile(Tuple{typeof(Base.merge!), Base.Dict{Base.UUID, Int64}, Base.Dict{Union{}, Union{}}}) +precompile(Tuple{typeof(Base.vcat), Base.BitArray{2}, Base.BitArray{2}, Base.BitArray{2}, Base.BitArray{2}}) +precompile(Tuple{typeof(Pkg3.Display.filter_manifest), Pkg3.Display.InProject{Base.Dict{String, Any}}, Base.Dict{String, Any}}) + +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_help!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}, REPL.LineEditREPL}) +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_status!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}}) +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_add!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}}) +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_rm!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}}) +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_up!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}}) +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_pin!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}}) +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_free!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}}) +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_checkout!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}}) +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_test!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}}) +@assert precompile(Tuple{typeof(Pkg3.REPLMode.do_build!), Pkg3.Types.Context, Vector{Pkg3.REPLMode.Token}}) + +@assert precompile(Tuple{Type{Pkg3.GraphType.GraphData}, Dict{UUID,Set{VersionNumber}}, + Dict{UUID,Dict{VersionRange,Dict{String,UUID}}}, + Dict{UUID,Dict{VersionRange,Dict{String,VersionSpec}}}, + Dict{UUID,String}}) + +@assert precompile(Tuple{Type{Pkg3.GraphType.Graph},Dict{UUID,Set{VersionNumber}}, + Dict{UUID,Dict{VersionRange,Dict{String,UUID}}}, + Dict{UUID,Dict{VersionRange,Dict{String,VersionSpec}}}, + Dict{UUID,String}, + Requires, + Dict{UUID,Pkg3.Types.Fixed}, + Bool}) + +@assert precompile(Tuple{typeof(Pkg3.Resolve.simplify_graph!), Pkg3.GraphType.Graph, Set{Int}}) + diff --git a/test/resolve.jl b/test/resolve.jl index 501df7204012b..8af36dd41ec1e 100644 --- a/test/resolve.jl +++ b/test/resolve.jl @@ -148,7 +148,7 @@ function graph_from_data(deps_data, uuid_to_name = Dict{UUID,String}(Types.uuid_ end end end - return Graph(all_versions, all_deps, all_compat, uuid_to_name, Requires(), fixed; verbose = VERBOSE) + return Graph(all_versions, all_deps, all_compat, uuid_to_name, Requires(), fixed, VERBOSE) end function reqs_from_data(reqs_data, graph::Graph) reqs = Dict{UUID,VersionSpec}() @@ -172,7 +172,7 @@ function sanity_tst(deps_data, expected_result; pkgs=[]) end graph = graph_from_data(deps_data) id(p) = pkgID(pkguuid(p), graph) - result = sanity_check(graph, Set(pkguuid(p) for p in pkgs), verbose = VERBOSE) + result = sanity_check(graph, Set(pkguuid(p) for p in pkgs), VERBOSE) length(result) == length(expected_result) || return false expected_result_uuid = [(id(p), vn) for (p,vn) in expected_result] From f359a08f2010ba2af716cb62c7e172300b0d5635 Mon Sep 17 00:00:00 2001 From: Kristoffer Carlsson Date: Fri, 23 Feb 2018 11:23:18 +0100 Subject: [PATCH 2/4] disable Pkg3 precompile unless opted into --- src/API.jl | 12 +++++++++++- src/Pkg3.jl | 27 ++++++++++++++++++++++++++- src/REPLMode.jl | 3 ++- 3 files changed, 39 insertions(+), 3 deletions(-) diff --git a/src/API.jl b/src/API.jl index 0db25dd55f345..e112ee5d20a97 100644 --- a/src/API.jl +++ b/src/API.jl @@ -7,7 +7,7 @@ import Dates import LibGit2 import Pkg3 -import Pkg3: depots, logdir, devdir +import Pkg3: depots, logdir, devdir, print_first_command_header using Pkg3.Types using Pkg3.TOML @@ -19,6 +19,7 @@ add(pkgs::Vector{String}; kwargs...) = add([PackageSpec(pkg) for pkg in pkg add(pkgs::Vector{PackageSpec}; kwargs...) = add(Context(), pkgs; kwargs...) function add(ctx::Context, pkgs::Vector{PackageSpec}; kwargs...) + print_first_command_header() Context!(ctx; kwargs...) ctx.preview && preview_info() project_resolve!(ctx.env, pkgs) @@ -33,6 +34,7 @@ rm(pkgs::Vector{String}; kwargs...) = rm([PackageSpec(pkg) for pkg in pkgs] rm(pkgs::Vector{PackageSpec}; kwargs...) = rm(Context(), pkgs; kwargs...) function rm(ctx::Context, pkgs::Vector{PackageSpec}; kwargs...) + print_first_command_header() Context!(ctx; kwargs...) ctx.preview && preview_info() project_resolve!(ctx.env, pkgs) @@ -48,6 +50,7 @@ up(pkgs::Vector{PackageSpec}; kwargs...) = up(Context(), pkgs; kwargs...) function up(ctx::Context, pkgs::Vector{PackageSpec}; level::UpgradeLevel=UPLEVEL_MAJOR, mode::PackageMode=PKGMODE_PROJECT, kwargs...) + print_first_command_header() Context!(ctx; kwargs...) ctx.preview && preview_info() @@ -126,6 +129,7 @@ pin(pkgs::Vector{String}; kwargs...) = pin([PackageSpec(pkg) for pkg pin(pkgs::Vector{PackageSpec}; kwargs...) = pin(Context(), pkgs; kwargs...) function pin(ctx::Context, pkgs::Vector{PackageSpec}; kwargs...) + print_first_command_header() Context!(ctx; kwargs...) ctx.preview && preview_info() project_resolve!(ctx.env, pkgs) @@ -139,6 +143,7 @@ free(pkgs::Vector{String}; kwargs...) = free([PackageSpec(pkg) for pk free(pkgs::Vector{PackageSpec}; kwargs...) = free(Context(), pkgs; kwargs...) function free(ctx::Context, pkgs::Vector{PackageSpec}; kwargs...) + print_first_command_header() Context!(ctx; kwargs...) ctx.preview && preview_info() project_resolve!(ctx.env, pkgs) @@ -155,6 +160,7 @@ checkout(pkgs::Vector{PackageSpec}; kwargs...) = checkout([(pkg, nothing) checkout(pkgs_branches::Vector; kwargs...) = checkout(Context(), pkgs_branches; kwargs...) function checkout(ctx::Context, pkgs_branches::Vector; path = devdir(), kwargs...) + print_first_command_header() Context!(ctx; kwargs...) ctx.preview && preview_info() pkgs = [p[1] for p in pkgs_branches] @@ -171,6 +177,7 @@ test(pkgs::Vector{String}; kwargs...) = test([PackageSpec(pkg) for p test(pkgs::Vector{PackageSpec}; kwargs...) = test(Context(), pkgs; kwargs...) function test(ctx::Context, pkgs::Vector{PackageSpec}; coverage=false, kwargs...) + print_first_command_header() Context!(ctx; kwargs...) ctx.preview && preview_info() project_resolve!(ctx.env, pkgs) @@ -192,6 +199,7 @@ end function gc(ctx::Context=Context(); period = Dates.Week(6), kwargs...) + print_first_command_header() function recursive_dir_size(path) sz = 0 for (root, dirs, files) in walkdir(path) @@ -310,6 +318,7 @@ build(pkg::PackageSpec) = build([pkg]) build(pkgs::Vector{PackageSpec}) = build(Context(), pkgs) function build(ctx::Context, pkgs::Vector{PackageSpec}; kwargs...) + print_first_command_header() Context!(ctx; kwargs...) if isempty(pkgs) for (name, infos) in ctx.env.manifest, info in infos @@ -329,6 +338,7 @@ function build(ctx::Context, pkgs::Vector{PackageSpec}; kwargs...) end function init(path::String) + print_first_command_header() ctx = Context(env = EnvCache(joinpath(path, "Project.toml"))) Pkg3.Operations.init(ctx) end diff --git a/src/Pkg3.jl b/src/Pkg3.jl index c4a1d493d4565..0b44d2fabda5e 100644 --- a/src/Pkg3.jl +++ b/src/Pkg3.jl @@ -9,6 +9,24 @@ depots() = Base.DEPOT_PATH logdir() = joinpath(depots()[1], "logs") devdir() = get(ENV, "JULIA_PKG_DEVDIR", joinpath(homedir(), ".julia", "dev")) +have_warned_session = false +function print_first_command_header() + global have_warned_session + have_warned_session && return + isinteractive() || return + @info """ + Pkg3 is still under development, please file issues at `https://github.com/JuliaLang/Pkg3.jl`. + """ + if !PKG3_IS_PRECOMPILED && !haskey(ENV, "JULIA_PKG3_DISABLE_PRECOMPILE_WARNING") + @info """ + Pkg3 is running without precompile statements, first action will be slow. + Rebuild julia with the environment variable `JULIA_PKG3_PRECOMPILE` set to enable precompilation of PKG3. + This message can be disabled by setting the env variable `JULIA_PKG3_DISABLE_PRECOMPILE_WARNING`. + """ + end + have_warned_session = true +end + # load snapshotted dependencies include("../ext/TOML/src/TOML.jl") @@ -41,6 +59,13 @@ end using Pkg3.Types using UUIDs import LibGit2 -include("precompile.jl") +# This crashes low memory systems and some of Julia's CI +# so keep it disabled by default for now. +if haskey(ENV, "JULIA_PKG3_PRECOMPILE") + const PKG3_IS_PRECOMPILED = true + include("precompile.jl") +else + const PKG3_IS_PRECOMPILED = false +end end # module diff --git a/src/REPLMode.jl b/src/REPLMode.jl index 2cf4f0891575d..84479f7ed971b 100644 --- a/src/REPLMode.jl +++ b/src/REPLMode.jl @@ -7,7 +7,7 @@ import REPL import REPL: LineEdit, REPLCompletions import Pkg3 -import Pkg3: devdir +import Pkg3: devdir, print_first_command_header using Pkg3.Types using Pkg3.Display using Pkg3.Operations @@ -151,6 +151,7 @@ const lex_re = r"^[\?\./\+\-](?!\-) | [^@\s]+\s*=\s*[^@\s]+ | @\s*[^@\s]* | [^@\ const Token = Union{Command, Option, VersionRange, String} function tokenize(cmd::String)::Vector{Token} + print_first_command_header() tokens = Token[] words = map(m->m.match, eachmatch(lex_re, cmd)) help_mode = false From 3420f26988528d7239584cf9cb0e7838e75e63b3 Mon Sep 17 00:00:00 2001 From: Kristoffer Carlsson Date: Fri, 23 Feb 2018 14:31:23 +0100 Subject: [PATCH 3/4] fix DevNull -> devnull --- ext/TOML/src/print.jl | 2 +- src/Display.jl | 4 ++-- src/GraphType.jl | 4 ++-- src/Operations.jl | 4 ++-- src/Types.jl | 4 ++-- 5 files changed, 9 insertions(+), 9 deletions(-) diff --git a/ext/TOML/src/print.jl b/ext/TOML/src/print.jl index efdb78645b235..ff30f5c0efc84 100644 --- a/ext/TOML/src/print.jl +++ b/ext/TOML/src/print.jl @@ -94,4 +94,4 @@ function _print(io::IO, a::AbstractDict, ks=String[]; sorted=false) end print(io::IO, a::AbstractDict; sorted=false) = _print(io, a, sorted=sorted) -print(a::AbstractDict; sorted=false) = print(STDOUT, a, sorted=sorted) +print(a::AbstractDict; sorted=false) = print(stdout, a, sorted=sorted) diff --git a/src/Display.jl b/src/Display.jl index e92ba069cb29b..cfda015a41550 100644 --- a/src/Display.jl +++ b/src/Display.jl @@ -22,7 +22,7 @@ function git_file_stream(repo::LibGit2.GitRepo, spec::String; fakeit::Bool=false blob = try LibGit2.GitBlob(repo, spec) catch err err isa LibGit2.GitError && err.code == LibGit2.Error.ENOTFOUND || rethrow(err) - fakeit && return DevNull + fakeit && return devnull end return IOBuffer(LibGit2.rawcontent(blob)) end @@ -154,7 +154,7 @@ function print_diff(io::IO, diff::Vector{DiffEntry}) printstyled(color = colors[verb], "$v $(x.name) $vstr\n") end end -print_diff(diff::Vector{DiffEntry}) = print_diff(STDOUT, diff) +print_diff(diff::Vector{DiffEntry}) = print_diff(stdout, diff) function manifest_by_uuid(manifest::Dict) entries = Dict{UUID,Dict}() diff --git a/src/GraphType.jl b/src/GraphType.jl index c9cd85573b4d6..ae0f29d1cec04 100644 --- a/src/GraphType.jl +++ b/src/GraphType.jl @@ -825,9 +825,9 @@ get_resolve_log(graph::Graph) = deepcopy(graph.data.rlog) const _logindent = " " -showlog(graph::Graph, args...; kw...) = showlog(STDOUT, graph, args...; kw...) +showlog(graph::Graph, args...; kw...) = showlog(stdout, graph, args...; kw...) showlog(io::IO, graph::Graph, args...; kw...) = showlog(io, graph.data.rlog, args...; kw...) -showlog(rlog::ResolveLog, args...; kw...) = showlog(STDOUT, rlog, args...; kw...) +showlog(rlog::ResolveLog, args...; kw...) = showlog(stdout, rlog, args...; kw...) """ Show the full resolution log. The `view` keyword controls how the events are displayed/grouped: diff --git a/src/Operations.jl b/src/Operations.jl index 2647630e61322..d0e59887be64a 100644 --- a/src/Operations.jl +++ b/src/Operations.jl @@ -318,7 +318,7 @@ function install_archive( url_success = true try cmd = BinaryProvider.gen_download_cmd(archive_url, path); - run(cmd, (DevNull, DevNull, DevNull)) + run(cmd, (devnull, devnull, devnull)) catch e e isa InterruptException && rethrow(e) url_success = false @@ -327,7 +327,7 @@ function install_archive( dir = joinpath(tempdir(), randstring(12)) mkpath(dir) cmd = BinaryProvider.gen_unpack_cmd(path, dir); - run(cmd, (DevNull, DevNull, DevNull)) + run(cmd, (devnull, devnull, devnull)) dirs = readdir(dir) # 7z on Win might create this spurious file filter!(x -> x != "pax_global_header", dirs) diff --git a/src/Types.jl b/src/Types.jl index e0a0df7b8034d..ac6cead608c20 100644 --- a/src/Types.jl +++ b/src/Types.jl @@ -516,7 +516,7 @@ function read_project(io::IO) return project end function read_project(file::String) - isfile(file) ? open(read_project, file) : read_project(DevNull) + isfile(file) ? open(read_project, file) : read_project(devnull) end function read_manifest(io::IO) @@ -537,7 +537,7 @@ function read_manifest(io::IO) return manifest end function read_manifest(file::String) - try isfile(file) ? open(read_manifest, file) : read_manifest(DevNull) + try isfile(file) ? open(read_manifest, file) : read_manifest(devnull) catch err err isa ErrorException && startswith(err.msg, "ambiguious dependency") || rethrow(err) err.msg *= "In manifest file: $file" From f8058e4ddc86ed5204a8cb4ef0107a29d68ecec8 Mon Sep 17 00:00:00 2001 From: Kristoffer Carlsson Date: Fri, 23 Feb 2018 15:33:09 +0100 Subject: [PATCH 4/4] fix removal of LOAD_CACHE_PATH --- src/Operations.jl | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/Operations.jl b/src/Operations.jl index d0e59887be64a..db2e8993b81db 100644 --- a/src/Operations.jl +++ b/src/Operations.jl @@ -621,8 +621,6 @@ function build_versions(ctx::Context, uuids::Vector{UUID}) append!(Base.LOAD_PATH, $(repr(Base.load_path()))) empty!(Base.DEPOT_PATH) append!(Base.DEPOT_PATH, $(repr(map(abspath, DEPOT_PATH)))) - empty!(Base.LOAD_CACHE_PATH) - append!(Base.LOAD_CACHE_PATH, $(repr(map(abspath, Base.LOAD_CACHE_PATH)))) empty!(Base.DL_LOAD_PATH) append!(Base.DL_LOAD_PATH, $(repr(map(abspath, Base.DL_LOAD_PATH)))) m = Base.require(Base.PkgId(Base.UUID($(repr(string(uuid)))), $(repr(name)))) @@ -871,15 +869,11 @@ function test(ctx::Context, pkgs::Vector{PackageSpec}; coverage=false) @info("In preview mode, skipping tests for $(pkg.name)") continue end - # TODO, cd to test folder (need to be careful with getting the same EnvCache - # as for this session in that case code = """ empty!(Base.LOAD_PATH) append!(Base.LOAD_PATH, $(repr(Base.load_path()))) empty!(Base.DEPOT_PATH) append!(Base.DEPOT_PATH, $(repr(map(abspath, DEPOT_PATH)))) - empty!(Base.LOAD_CACHE_PATH) - append!(Base.LOAD_CACHE_PATH, $(repr(map(abspath, Base.LOAD_CACHE_PATH)))) empty!(Base.DL_LOAD_PATH) append!(Base.DL_LOAD_PATH, $(repr(map(abspath, Base.DL_LOAD_PATH)))) m = Base.require(Base.PkgId(Base.UUID($(repr(string(pkg.uuid)))), $(repr(pkg.name))))