fix(pkg): versioning and reload specs when pkg-cache is dirty

lua/lazy/pkg/init.lua

@@ -2,6 +2,8 @@ local Config = require("lazy.core.config")
 local Util = require("lazy.util")
 
 local M = {}
+M.VERSION = 7
+M.dirty = false
 
 ---@alias LazyPkgSpec LazySpec | fun():LazySpec
 
@@ -10,10 +12,13 @@ local M = {}
 ---@field name string
 ---@field file string
 ---@field spec? LazySpec
----@field chunk? string|fun():LazySpec
+
+---@class LazyPkgInput: LazyPkg
+---@field spec? LazySpec|fun():LazySpec
+---@field code? string
 
 ---@class LazyPkgSource
----@field get fun(plugin:LazyPlugin):LazyPkg
+---@field get fun(plugin:LazyPlugin):LazyPkgInput?
 
 ---@type table<string, LazyPkg>?
 M.cache = nil
@@ -25,76 +30,78 @@ function M.update()
     sources[#sources + 1] = require("lazy.pkg." .. s)
   end
 
-  ---@type table<string, LazyPkg>
-  local ret = {}
+  M.cache = {}
   for _, plugin in pairs(Config.plugins) do
-    for _, source in ipairs(sources) do
-      local spec = source.get(plugin)
-      if spec then
-        spec.name = plugin.name
-        if type(spec.chunk) == "function" then
-          spec.chunk = string.dump(spec.chunk)
+    if plugin._.installed then
+      for _, source in ipairs(sources) do
+        local spec = source.get(plugin)
+        if spec then
+          spec.name = plugin.name
+          if type(spec.code) == "string" then
+            spec.spec = { _raw = spec.code }
+            spec.code = nil
+          end
+          M.cache[plugin.dir] = spec
+          break
         end
-        ret[plugin.dir] = spec
-        break
       end
     end
   end
-  local code = "return " .. Util.dump(ret)
+  local code = "return " .. Util.dump({ version = M.VERSION, specs = M.cache })
   Util.write_file(Config.options.pkg.cache, code)
+  M.dirty = false
   M.cache = nil
 end
 
 local function _load()
   Util.track("pkg")
-  M.cache = {}
+  M.cache = nil
   if vim.uv.fs_stat(Config.options.pkg.cache) then
     Util.try(function()
       local chunk, err = loadfile(Config.options.pkg.cache)
       if not chunk then
         error(err)
       end
-      M.cache = chunk()
+      local ret = chunk()
+      if ret and ret.version == M.VERSION then
+        M.cache = ret.specs
+      end
     end, "Error loading pkg:")
   end
+  if rawget(M, "cache") then
+    M.dirty = false
+  else
+    M.cache = {}
+    M.dirty = true
+  end
   Util.track()
 end
 
----@param plugin LazyPlugin
+---@param dir string
 ---@return LazyPkg?
-function M.get(plugin)
-  if not M.cache then
-    _load()
-  end
-
-  local ret = M.cache[plugin.dir]
+function M.get(dir)
+  local ret = M.cache[dir]
   if not ret then
     return
   end
 
-  if ret.chunk and not ret.spec then
-    if type(ret.chunk) == "string" then
-      ret.chunk = load(ret.chunk, "@" .. plugin.dir)
-    end
-    ret.spec = ret.chunk()
-    ret.chunk = nil
+  if type(ret.spec) == "function" then
+    ret.spec = ret.spec()
   end
 
   return ret
 end
 
 function M.spec()
-  if not M.cache then
-    _load()
-  end
   ---@type table<string,LazyPluginSpec>
   local ret = {}
 
   for dir in pairs(M.cache) do
-    local pkg = M.get({ dir = dir })
+    local pkg = M.get(dir)
     local spec = pkg and pkg.spec
     if pkg and spec then
       spec = type(spec) == "table" and vim.deepcopy(spec) or spec
+      ---@cast spec LazySpec
       ret[dir] = { pkg.name, specs = spec }
     end
   end
@@ -102,16 +109,11 @@ function M.spec()
   return ret
 end
 
----@param plugin LazyPlugin
----@return LazySpec?
-function M.get_spec(plugin)
-  local pkg = M.get(plugin)
-  local spec = pkg and pkg.spec
-  if not spec then
-    return
-  end
-  spec = type(spec) == "table" and vim.deepcopy(spec) or spec
-  return { plugin.name, specs = spec }
-end
-
-return M
+return setmetatable(M, {
+  __index = function(_, key)
+    if key == "cache" then
+      _load()
+      return M.cache
+    end
+  end,
+})