perf: removed partial spec caching. not worth the tiny performance boost

lua/lazy/core/cache.lua

@@ -68,27 +68,20 @@ function M.setup()
 end
 
 function M.autosave()
-  vim.api.nvim_create_autocmd("User", {
-    pattern = "LazyDone",
-    once = true,
+  vim.api.nvim_create_autocmd("VimLeavePre", {
     callback = function()
-      vim.api.nvim_create_autocmd("VimLeavePre", {
-        callback = function()
-          if M.dirty then
-            local hash = M.hash(cache_path)
-            -- abort when the file was changed in the meantime
-            if hash == nil or cache_hash == hash then
-              M.save()
-            end
-          end
-        end,
-      })
+      if M.dirty then
+        local hash = M.hash(cache_path)
+        -- abort when the file was changed in the meantime
+        if hash == nil or cache_hash == hash then
+          M.save()
+        end
+      end
     end,
   })
 end
 
 function M.save()
-  require("lazy.core.plugin").save()
   require("lazy.core.module").save()
 
   local f = assert(io.open(cache_path, "wb"))

lua/lazy/core/handler.lua

@@ -1,5 +1,6 @@
 local Util = require("lazy.core.util")
 local Loader = require("lazy.core.loader")
+local Config = require("lazy.core.config")
 
 ---@class LazyPluginHandlers
 ---@field event? string|string[]
@@ -12,34 +13,25 @@ local M = {}
 
 ---@alias LazyHandler fun(grouped:table<string, string[]>)
 
----@type table<string, table<string, string[]>>
-M._groups = nil
-
----@param plugins LazyPlugin[]
----@param rebuild? boolean
-function M.group(plugins, rebuild)
-  if M._groups == nil or rebuild then
-    M._groups = {}
-    local types = vim.tbl_keys(M.handlers) --[[@as string[] ]]
-    for _, key in ipairs(types) do
-      M._groups[key] = {}
-      for _, plugin in pairs(plugins) do
-        if plugin[key] then
-          ---@diagnostic disable-next-line: no-unknown
-          for _, value in pairs(type(plugin[key]) == "table" and plugin[key] or { plugin[key] }) do
-            M._groups[key][value] = M._groups[key][value] or {}
-            table.insert(M._groups[key][value], plugin.name)
-          end
+function M.setup()
+  for key, handler in pairs(M.handlers) do
+    ---@type table<string, string[]>
+    local group = {}
+    for _, plugin in pairs(Config.plugins) do
+      if plugin[key] then
+        ---@diagnostic disable-next-line: no-unknown
+        for _, value in pairs(type(plugin[key]) == "table" and plugin[key] or { plugin[key] }) do
+          group[value] = group[value] or {}
+          table.insert(group[value], plugin.name)
         end
       end
     end
+    handler(group)
   end
-  return M._groups
 end
 
 ---@type table<string, LazyHandler>
 M.handlers = {}
-
 function M.handlers.event(grouped)
   local group = vim.api.nvim_create_augroup("lazy_handler_event", { clear = true })
   for event, plugins in pairs(grouped) do

lua/lazy/core/loader.lua

@@ -6,18 +6,6 @@ local M = {}
 ---@type LazyPlugin[]
 M.loading = {}
 
-function M.setup()
-  local Handler = require("lazy.core.handler")
-  local groups = Handler.group(Config.plugins)
-  for t, handler in pairs(Handler.handlers) do
-    if groups[t] then
-      Util.track(t)
-      handler(groups[t])
-      Util.track()
-    end
-  end
-end
-
 function M.init_plugins()
   Util.track("plugin_init")
   for _, plugin in pairs(Config.plugins) do

lua/lazy/core/module.lua

@@ -5,13 +5,9 @@ local M = {}
 ---@type table<string, string>
 M.hashes = {}
 
-function M.is_dirty(modname, modpath)
-  return not (Cache.get(modname) and M.hashes[modname] and M.hashes[modname] == Cache.hash(modpath))
-end
-
 ---@param modname string
 ---@param modpath string
----@return any, boolean
+---@return any
 function M.load(modname, modpath)
   local err
   ---@type (string|fun())?
@@ -24,9 +20,7 @@ function M.load(modname, modpath)
     chunk = nil
   end
 
-  local cached = false
   if chunk then
-    cached = true
     chunk, err = load(chunk --[[@as string]], "@" .. modpath, "b")
   else
     vim.schedule(function()
@@ -39,7 +33,7 @@ function M.load(modname, modpath)
   end
 
   if chunk then
-    return chunk(), cached
+    return chunk()
   else
     error(err)
   end