writer

16 files changed, 1793 insertions, 185 deletions

diff --git a/.editorconfig b/.editorconfig
index dc5519a7..e927faee 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -10,6 +10,10 @@ charset                  = utf-8
 indent_style             = space
 indent_size              = 3
 
+[*.tl]
+indent_style             = space
+indent_size              = 3
+
 [Makefile]
 indent_style             = tab
 
diff --git a/src/luarocks/build.tl b/src/luarocks/build.tl
new file mode 100644
index 00000000..ccb894a4
--- /dev/null
+++ b/src/luarocks/build.tl
@@ -0,0 +1,496 @@
+
+local record build
+   record Op_b
+      build_only_deps: boolean
+      deps_mode: string
+      verify: boolean
+      minimal_mode: boolean
+      need_to_fetch: boolean
+      branch: string
+      no_install: boolean
+   end
+
+   record Builds
+      skip_lua_inc_lib_check: boolean
+      
+   end
+end
+
+local path = require("luarocks.path")
+local util = require("luarocks.util")
+local fun = require("luarocks.fun")
+local fetch = require("luarocks.fetch")
+local fs = require("luarocks.fs")
+local dir = require("luarocks.dir")
+local deps = require("luarocks.deps")
+local cfg = require("luarocks.core.cfg")
+local vers = require("luarocks.core.vers")
+local repos = require("luarocks.repos")
+local repo_writer = require("luarocks.repo_writer")
+local deplocks = require("luarocks.deplocks")
+
+local type r = require("luarocks.core.types.rockspec")
+local type Rockspec = r.Rockspec
+local type Installs = r.Installs
+local type Install = r.Install
+
+local type t = require("luarocks.core.types.tree")
+local type Tree = t.Tree
+
+local type Op_b = build.Op_b
+
+do
+   --- Write to the current directory the contents of a table,
+   -- where each key is a file name and its value is the file content.
+   -- @param files table: The table of files to be written.
+   local function extract_from_rockspec(files: {string: string})
+      for name, content in pairs(files) do
+         local fd = io.open(dir.path(fs.current_dir(), name), "w+")
+         fd:write(content)
+         fd:close()
+      end
+   end
+
+   --- Applies patches inlined in the build.patches section
+   -- and extracts files inlined in the build.extra_files section
+   -- of a rockspec.
+   -- @param rockspec table: A rockspec table.
+   -- @return boolean or (nil, string): True if succeeded or
+   -- nil and an error message.
+   function build.apply_patches(rockspec: Rockspec): boolean, string
+
+      if not (rockspec.build.extra_files or rockspec.build.patches) then
+         return true
+      end
+
+      local fd = io.open(fs.absolute_name(".luarocks.patches.applied"), "r")
+      if fd then
+         fd:close()
+         return true
+      end
+
+      if rockspec.build.extra_files then
+         extract_from_rockspec(rockspec.build.extra_files)
+      end
+      if rockspec.build.patches then
+         extract_from_rockspec(rockspec.build.patches)
+         for patch, patchdata in util.sortedpairs(rockspec.build.patches) do
+            util.printout("Applying patch "..patch.."...")
+            local create_delete = rockspec:format_is_at_least("3.0")
+            local ok, err = fs.apply_patch(tostring(patch), patchdata, create_delete)
+            if not ok then
+               return nil, "Failed applying patch "..patch
+            end
+         end
+      end
+
+      fd = io.open(fs.absolute_name(".luarocks.patches.applied"), "w")
+      if fd then
+         fd:close()
+      end
+      return true
+   end
+end
+
+local function check_macosx_deployment_target(rockspec: Rockspec): boolean, string
+   local target = rockspec.build.macosx_deployment_target
+   local function patch_variable(var: string)
+      local rockspec_variables = rockspec.variables as {string: string}
+      if rockspec_variables[var]:match("MACOSX_DEPLOYMENT_TARGET") then
+         rockspec_variables[var] = (rockspec_variables[var]):gsub("MACOSX_DEPLOYMENT_TARGET=[^ ]*", "MACOSX_DEPLOYMENT_TARGET="..target)
+      else
+         rockspec_variables[var] = "env MACOSX_DEPLOYMENT_TARGET="..target.." "..rockspec_variables[var]
+      end
+   end
+   if cfg.is_platform("macosx") and rockspec:format_is_at_least("3.0") and target then
+      local version = util.popen_read("sw_vers -productVersion")
+      if version:match("^%d+%.%d+%.%d+$") or version:match("^%d+%.%d+$") then
+         if vers.compare_versions(target, version) then
+            return nil, ("This rock requires Mac OSX %s, and you are running %s."):format(target, version)
+         end
+      end
+      patch_variable("CC")
+      patch_variable("LD")
+   end
+   return true
+end
+
+local function process_dependencies(rockspec: Rockspec, opts: Op_b, cwd: string): boolean, string, string
+   if not opts.build_only_deps then
+      local ok, err, errcode = deps.check_external_deps(rockspec, "build")
+      if err then
+         return nil, err, errcode
+      end
+   end
+
+   if opts.deps_mode == "none" then
+      return true
+   end
+
+   local deplock_dir = fs.exists(dir.path(cwd, "luarocks.lock")) and cwd or nil
+
+   if not opts.build_only_deps then
+      if next(rockspec.build_dependencies) ~= nil then
+
+         local user_lua_version = cfg.lua_version
+         local running_lua_version = _VERSION:sub(5)
+
+         if running_lua_version ~= user_lua_version then
+            -- Temporarily flip the user-selected Lua version,
+            -- so that we install build dependencies for the
+            -- Lua version on which the LuaRocks program is running.
+
+            -- HACK: we have to do this by flipping a bunch of
+            -- global config settings, and this list may not be complete.
+            cfg.lua_version = running_lua_version
+            cfg.lua_modules_path = cfg.lua_modules_path:gsub(user_lua_version:gsub("%.", "%%."), running_lua_version)
+            cfg.lib_modules_path = cfg.lib_modules_path:gsub(user_lua_version:gsub("%.", "%%."), running_lua_version)
+            cfg.rocks_subdir = cfg.rocks_subdir:gsub(user_lua_version:gsub("%.", "%%."), running_lua_version)
+            path.use_tree(cfg.root_dir as Tree)
+         end
+
+         local ok, err, errcode = deps.fulfill_dependencies(rockspec, "build_dependencies", "all", opts.verify, deplock_dir)
+
+         path.add_to_package_paths(cfg.root_dir)
+
+         if running_lua_version ~= user_lua_version then
+            -- flip the settings back
+            cfg.lua_version = user_lua_version
+            cfg.lua_modules_path = cfg.lua_modules_path:gsub(running_lua_version:gsub("%.", "%%."), user_lua_version)
+            cfg.lib_modules_path = cfg.lib_modules_path:gsub(running_lua_version:gsub("%.", "%%."), user_lua_version)
+            cfg.rocks_subdir = cfg.rocks_subdir:gsub(running_lua_version:gsub("%.", "%%."), user_lua_version)
+            path.use_tree(cfg.root_dir as Tree)
+         end
+
+         if err then
+            return nil, err, errcode
+         end
+      end
+   end
+
+   return deps.fulfill_dependencies(rockspec, "dependencies", opts.deps_mode, opts.verify, deplock_dir)
+end
+
+local function fetch_and_change_to_source_dir(rockspec: Rockspec, opts: Op_b): boolean, string, string
+   if opts.minimal_mode or opts.build_only_deps then
+      return true
+   end
+   if opts.need_to_fetch then
+      if opts.branch then
+         rockspec.source.branch = opts.branch
+      end
+      local oks, source_dir, errcode = fetch.fetch_sources(rockspec, true)
+      if not oks then
+         return nil, source_dir, errcode
+      end
+      local ok, err: boolean, string
+      ok, err = fs.change_dir(source_dir)
+      if not ok then
+         return nil, err
+      end
+   else
+      if rockspec.source.file then
+         local ok, err = fs.unpack_archive(rockspec.source.file)
+         if not ok then
+            return nil, err
+         end
+      end
+      local ok, err = fetch.find_rockspec_source_dir(rockspec, ".")
+      if not ok then
+         return nil, err
+      end
+   end
+   fs.change_dir(rockspec.source.dir)
+   return true
+end
+
+local function prepare_install_dirs(name: string, version: string): Installs, string
+   local dirs = {
+      lua = { name = path.lua_dir(name, version), is_module_path = true, perms = "read" },
+      lib = { name = path.lib_dir(name, version), is_module_path = true, perms = "exec" },
+      bin = { name = path.bin_dir(name, version), is_module_path = false, perms = "exec" },
+      conf = { name = path.conf_dir(name, version), is_module_path = false, perms = "read" },
+   }
+
+   for _, d in pairs(dirs as {string: Install}) do
+      local ok, err = fs.make_dir(d.name)
+      if not ok then
+         return nil, err
+      end
+   end
+
+   return dirs
+end
+
+local function run_build_driver(rockspec: Rockspec, no_install: boolean): boolean, string, string
+   local btype = rockspec.build.type
+   if btype == "none" then
+      return true
+   end
+   -- Temporary compatibility
+   if btype == "module" then
+      util.printout("Do not use 'module' as a build type. Use 'builtin' instead.")
+      btype = "builtin"
+      rockspec.build.type = btype
+   end
+   if cfg.accepted_build_types and not fun.contains(cfg.accepted_build_types, btype) then
+      return nil, "This rockspec uses the '"..btype.."' build type, which is blocked by the 'accepted_build_types' setting in your LuaRocks configuration."
+   end
+   local pok, driver = pcall(require, "luarocks.build." .. btype)
+   if not pok or type(driver) ~= "table" then
+      return nil, "Failed initializing build back-end for build type '"..btype.."': "..driver
+   end
+
+   if not driver.skip_lua_inc_lib_check then
+      local ok, err, errcode = deps.check_lua_incdir(rockspec.variables)
+      if not ok then
+         return nil, err, errcode
+      end
+
+      if cfg.link_lua_explicitly then
+         local ok, err, errcode = deps.check_lua_libdir(rockspec.variables)
+         if not ok then
+            return nil, err, errcode
+         end
+      end
+   end
+
+   local ok, err = driver.run(rockspec, no_install)
+   if not ok then
+      return nil, "Build error: " .. err
+   end
+   return true
+end
+
+local install_files
+do
+   --- Install files to a given location.
+   -- Takes a table where the array part is a list of filenames to be copied.
+   -- In the hash part, other keys, if is_module_path is set, are identifiers
+   -- in Lua module format, to indicate which subdirectory the file should be
+   -- copied to. For example, install_files({["foo.bar"] = "src/bar.lua"}, "boo")
+   -- will copy src/bar.lua to boo/foo.
+   -- @param files table or nil: A table containing a list of files to copy in
+   -- the format described above. If nil is passed, this function is a no-op.
+   -- Directories should be delimited by forward slashes as in internet URLs.
+   -- @param location string: The base directory files should be copied to.
+   -- @param is_module_path boolean: True if string keys in files should be
+   -- interpreted as dotted module paths.
+   -- @param perms string ("read" or "exec"): Permissions of the newly created
+   -- files installed.
+   -- Directories are always created with the default permissions.
+   -- @return boolean or (nil, string): True if succeeded or
+   -- nil and an error message.
+   local function install_to(files, location, is_module_path, perms)
+      assert(type(files) == "table" or not files)
+      assert(type(location) == "string")
+      if not files then
+         return true
+      end
+      for k, file in pairs(files) do
+         local dest = location
+         local filename = dir.base_name(file)
+         if type(k) == "string" then
+            local modname = k
+            if is_module_path then
+               dest = dir.path(location, path.module_to_path(modname))
+               local ok, err = fs.make_dir(dest)
+               if not ok then return nil, err end
+               if filename:match("%.lua$") then
+                  local basename = modname:match("([^.]+)$")
+                  filename = basename..".lua"
+               end
+            else
+               dest = dir.path(location, dir.dir_name(modname))
+               local ok, err = fs.make_dir(dest)
+               if not ok then return nil, err end
+               filename = dir.base_name(modname)
+            end
+         else
+            local ok, err = fs.make_dir(dest)
+            if not ok then return nil, err end
+         end
+         local ok = fs.copy(file, dir.path(dest, filename), perms)
+         if not ok then
+            return nil, "Failed copying "..file
+         end
+      end
+      return true
+   end
+
+   local function install_default_docs(name, version)
+      local patterns = { "readme", "license", "copying", ".*%.md" }
+      local dest = dir.path(path.install_dir(name, version), "doc")
+      local has_dir = false
+      for file in fs.dir() do
+         for _, pattern in ipairs(patterns) do
+            if file:lower():match("^"..pattern) then
+               if not has_dir then
+                  fs.make_dir(dest)
+                  has_dir = true
+               end
+               fs.copy(file, dest, "read")
+               break
+            end
+         end
+      end
+   end
+
+   install_files = function(rockspec, dirs)
+      local name, version = rockspec.name, rockspec.version
+
+      if rockspec.build.install then
+         for k, d in pairs(dirs) do
+            local ok, err = install_to(rockspec.build.install[k], d.name, d.is_module_path, d.perms)
+            if not ok then return nil, err end
+         end
+      end
+
+      local copy_directories = rockspec.build.copy_directories
+      local copying_default = false
+      if not copy_directories then
+         copy_directories = {"doc"}
+         copying_default = true
+      end
+
+      local any_docs = false
+      for _, copy_dir in pairs(copy_directories) do
+         if fs.is_dir(copy_dir) then
+            local dest = dir.path(path.install_dir(name, version), copy_dir)
+            fs.make_dir(dest)
+            fs.copy_contents(copy_dir, dest)
+            any_docs = true
+         else
+            if not copying_default then
+               return nil, "Directory '"..copy_dir.."' not found"
+            end
+         end
+      end
+      if not any_docs then
+         install_default_docs(name, version)
+      end
+
+      return true
+   end
+end
+
+--- Build and install a rock given a rockspec.
+-- @param rockspec rockspec: the rockspec to build
+-- @param opts table: build options table
+-- @param cwd string or nil: The current working directory
+-- @return (string, string) or (nil, string, [string]): Name and version of
+-- installed rock if succeeded or nil and an error message followed by an error code.
+function build.build_rockspec(rockspec, opts, cwd)
+   assert(rockspec:type() == "rockspec")
+
+   cwd = cwd or dir.path(".")
+
+   if not rockspec.build then
+      if rockspec:format_is_at_least("3.0") then
+         rockspec.build = {
+            type = "builtin"
+         }
+      else
+         return nil, "Rockspec error: build table not specified"
+      end
+   end
+
+   if not rockspec.build.type then
+      if rockspec:format_is_at_least("3.0") then
+         rockspec.build.type = "builtin"
+      else
+         return nil, "Rockspec error: build type not specified"
+      end
+   end
+
+   local ok, err = fetch_and_change_to_source_dir(rockspec, opts)
+   if not ok then return nil, err end
+
+   if opts.pin then
+      deplocks.init(rockspec.name, ".")
+   end
+
+   ok, err = process_dependencies(rockspec, opts, cwd)
+   if not ok then return nil, err end
+
+   local name, version = rockspec.name, rockspec.version
+   if opts.build_only_deps then
+      if opts.pin then
+         deplocks.write_file()
+      end
+      return name, version
+   end
+
+   local dirs, err
+   local rollback
+   if not opts.no_install then
+      if repos.is_installed(name, version) then
+         repo_writer.delete_version(name, version, opts.deps_mode)
+      end
+
+      dirs, err = prepare_install_dirs(name, version)
+      if not dirs then return nil, err end
+
+      rollback = util.schedule_function(function()
+         fs.delete(path.install_dir(name, version))
+         fs.remove_dir_if_empty(path.versions_dir(name))
+      end)
+   end
+
+   ok, err = build.apply_patches(rockspec)
+   if not ok then return nil, err end
+
+   ok, err = check_macosx_deployment_target(rockspec)
+   if not ok then return nil, err end
+
+   ok, err = run_build_driver(rockspec, opts.no_install)
+   if not ok then return nil, err end
+
+   if opts.no_install then
+      fs.pop_dir()
+      if opts.need_to_fetch then
+         fs.pop_dir()
+      end
+      return name, version
+   end
+
+   ok, err = install_files(rockspec, dirs)
+   if not ok then return nil, err end
+
+   for _, d in pairs(dirs) do
+      fs.remove_dir_if_empty(d.name)
+   end
+
+   fs.pop_dir()
+   if opts.need_to_fetch then
+      fs.pop_dir()
+   end
+
+   if opts.pin then
+      deplocks.write_file()
+   end
+
+   fs.copy(rockspec.local_abs_filename, path.rockspec_file(name, version), "read")
+
+   local deplock_file = deplocks.get_abs_filename(name)
+   if deplock_file then
+      fs.copy(deplock_file, dir.path(path.install_dir(name, version), "luarocks.lock"), "read")
+   end
+
+   ok, err = repo_writer.deploy_files(name, version, repos.should_wrap_bin_scripts(rockspec), opts.deps_mode, opts.namespace)
+   if not ok then return nil, err end
+
+   util.remove_scheduled_function(rollback)
+   rollback = util.schedule_function(function()
+      repo_writer.delete_version(name, version, opts.deps_mode)
+   end)
+
+   ok, err = repos.run_hook(rockspec, "post_install")
+   if not ok then return nil, err end
+
+   util.announce_install(rockspec)
+   util.remove_scheduled_function(rollback)
+   return name, version
+end
+
+return build
diff --git a/src/luarocks/build/builtin.tl b/src/luarocks/build/builtin.tl
new file mode 100644
index 00000000..c778c2bb
--- /dev/null
+++ b/src/luarocks/build/builtin.tl
@@ -0,0 +1,400 @@
+
+--- A builtin build system: back-end to provide a portable way of building C-based Lua modules.
+local record builtin
+   skip_lua_inc_lib_check: boolean
+end
+
+local type r = require("luarocks.core.types.rockspec")
+local type Rockspec = r.Rockspec
+local type Variables = r.Variables
+local type Installs = r.Installs
+
+-- This build driver checks LUA_INCDIR and LUA_LIBDIR on demand,
+-- so that pure-Lua rocks don't need to have development headers
+-- installed.
+builtin.skip_lua_inc_lib_check = true
+
+local dir_sep = package.config:sub(1, 1)
+
+local fs = require("luarocks.fs")
+local path = require("luarocks.path")
+local util = require("luarocks.util")
+local cfg = require("luarocks.core.cfg")
+local dir = require("luarocks.dir")
+local deps = require("luarocks.deps")
+
+local function autoextract_libs(external_dependencies: {string: {string: string}}, variables: Variables): {string}, {string}, {string}
+   if not external_dependencies then
+      return nil, nil, nil
+   end
+   local libs: {string} = {}
+   local incdirs: {string} = {}
+   local libdirs: {string} = {}
+   for name, data in pairs(external_dependencies) do
+      if data.library then
+         table.insert(libs, data.library)
+         table.insert(incdirs, (variables as {string: string})[name .. "_INCDIR"])
+         table.insert(libdirs, (variables as {string: string})[name .. "_LIBDIR"])
+      end
+   end
+   return libs, incdirs, libdirs
+end
+
+do
+   local function get_cmod_name(file: string): string
+      local fd = io.open(dir.path(fs.current_dir(), file), "r")
+      if not fd then return nil end
+      local data = fd:read("*a")
+      fd:close()
+      return (data:match("int%s+luaopen_([a-zA-Z0-9_]+)"))
+   end
+
+   local skiplist = {
+      ["spec"] = true,
+      [".luarocks"] = true,
+      ["lua_modules"] = true,
+      ["test.lua"] = true,
+      ["tests.lua"] = true,
+   }
+
+   function builtin.autodetect_modules(libs: {string}, incdirs: {string}, libdirs: {string})
+      local modules = {}
+      local install: Installs
+      local copy_directories: {string}
+
+      local prefix = ""
+      for _, parent in ipairs({"src", "lua", "lib"}) do
+         if fs.is_dir(parent) then
+            fs.change_dir(parent)
+            prefix = parent .. dir_sep
+            break
+         end
+      end
+
+      for _, file in ipairs(fs.find()) do
+         local base = file:match("^([^\\/]*)")
+         if not (skiplist as {string: boolean})[base] then
+            local luamod = file:match("(.*)%.lua$")
+            if luamod then
+               modules[path.path_to_module(file)] = prefix .. file
+            else
+               local cmod = file:match("(.*)%.c$")
+               if cmod then
+                  local modname = get_cmod_name(file) or path.path_to_module((file:gsub("%.c$", ".lua"))) --!
+                  modules[modname] = {
+                     sources = prefix..file,
+                     libraries = libs,
+                     incdirs = incdirs,
+                     libdirs = libdirs,
+                  }
+               end
+            end
+         end
+      end
+
+      if prefix ~= "" then
+         fs.pop_dir()
+      end
+
+      local bindir = (fs.is_dir(dir.path("src", "bin")) and dir.path("src", "bin"))
+                  or (fs.is_dir("bin") and "bin")
+      if bindir then
+         install = { bin = {} }
+         for _, file in ipairs(fs.list_dir(bindir)) do
+            table.insert(install.bin, dir.path(bindir, file)) --!
+         end
+      end
+
+      for _, directory in ipairs({ "doc", "docs", "samples", "tests" }) do
+         if fs.is_dir(directory) then
+            if not copy_directories then
+               copy_directories = {}
+            end
+            table.insert(copy_directories, directory)
+         end
+      end
+
+      return modules, install, copy_directories
+   end
+end
+
+--- Run a command displaying its execution on standard output.
+-- @return boolean: true if command succeeds (status code 0), false
+-- otherwise.
+local function execute(...: string): boolean, string, string
+   io.stdout:write(table.concat({...}, " ").."\n")
+   return fs.execute(...)
+end
+
+--- Driver function for the builtin build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors occurred,
+-- nil and an error message otherwise.
+function builtin.run(rockspec: Rockspec, no_install: boolean)
+   local compile_object, compile_library, compile_static_library
+
+   local build = rockspec.build
+   local variables = rockspec.variables as {string: string}
+   local checked_lua_h = false
+
+   for _, var in ipairs{ "CC", "CFLAGS", "LDFLAGS" } do
+      variables[var] = variables[var] or os.getenv(var) or ""
+   end
+
+   local function add_flags(extras: {string}, flag: string, flags: {string})
+      if flags then
+         if not flags is {string} then
+            flags = { tostring(flags) }
+         end
+         util.variable_substitutions(flags, variables)
+         for _, v in ipairs(flags) do
+            table.insert(extras, flag:format(v))
+         end
+      end
+   end
+
+   if cfg.is_platform("mingw32") then
+      compile_object = function(object: string, source: string, defines: {string}, incdirs: {string}): boolean, string, string
+         local extras = {}
+         add_flags(extras, "-D%s", defines)
+         add_flags(extras, "-I%s", incdirs)
+         return execute(variables.CC.." "..variables.CFLAGS, "-c", "-o", object, "-I"..variables.LUA_INCDIR, source, table.unpack(extras))
+      end
+      compile_library = function(library, objects, libraries, libdirs, name)
+         local extras = { table.unpack(objects) }
+         add_flags(extras, "-L%s", libdirs)
+         add_flags(extras, "-l%s", libraries)
+         extras[#extras+1] = dir.path(variables.LUA_LIBDIR, variables.LUALIB)
+
+         if variables.CC == "clang" or variables.CC == "clang-cl" then
+            local exported_name = name:gsub("%.", "_")
+            exported_name = exported_name:match('^[^%-]+%-(.+)$') or exported_name
+            extras[#extras+1] = string.format("-Wl,-export:luaopen_%s", exported_name)
+         else
+            extras[#extras+1] = "-l" .. (variables.MSVCRT or "m")
+         end
+
+         local ok = execute(variables.LD.." "..variables.LDFLAGS.." "..variables.LIBFLAG, "-o", library, table.unpack(extras))
+         return ok
+      end
+      --[[ TODO disable static libs until we fix the conflict in the manifest, which will take extending the manifest format.
+      compile_static_library = function(library, objects, libraries, libdirs, name)
+         local ok = execute(variables.AR, "rc", library, unpack(objects))
+         if ok then
+            ok = execute(variables.RANLIB, library)
+         end
+         return ok
+      end
+      ]]
+   elseif cfg.is_platform("win32") then
+      compile_object = function(object, source, defines, incdirs)
+         local extras = {}
+         add_flags(extras, "-D%s", defines)
+         add_flags(extras, "-I%s", incdirs)
+         return execute(variables.CC.." "..variables.CFLAGS, "-c", "-Fo"..object, "-I"..variables.LUA_INCDIR, source, table.unpack(extras))
+      end
+      compile_library = function(library, objects, libraries, libdirs, name)
+         local extras = { table.unpack(objects) }
+         add_flags(extras, "-libpath:%s", libdirs)
+         add_flags(extras, "%s.lib", libraries)
+         local basename = dir.base_name(library):gsub(".[^.]*$", "")
+         local deffile = basename .. ".def"
+         local def = io.open(dir.path(fs.current_dir(), deffile), "w+")
+         local exported_name = name:gsub("%.", "_")
+         exported_name = exported_name:match('^[^%-]+%-(.+)$') or exported_name
+         def:write("EXPORTS\n")
+         def:write("luaopen_"..exported_name.."\n")
+         def:close()
+         local ok = execute(variables.LD, "-dll", "-def:"..deffile, "-out:"..library, dir.path(variables.LUA_LIBDIR, variables.LUALIB), table.unpack(extras))
+         local basedir = ""
+         if name:find("%.") ~= nil then
+            basedir = name:gsub("%.%w+$", "\\")
+            basedir = basedir:gsub("%.", "\\")
+         end
+         local manifestfile = basedir .. basename..".dll.manifest"
+
+         if ok and fs.exists(manifestfile) then
+            ok = execute(variables.MT, "-manifest", manifestfile, "-outputresource:"..basedir..basename..".dll;2")
+         end
+         return ok
+      end
+      --[[ TODO disable static libs until we fix the conflict in the manifest, which will take extending the manifest format.
+      compile_static_library = function(library, objects, libraries, libdirs, name)
+         local ok = execute(variables.AR, "-out:"..library, unpack(objects))
+         return ok
+      end
+      ]]
+   else
+      compile_object = function(object, source, defines, incdirs)
+         local extras = {}
+         add_flags(extras, "-D%s", defines)
+         add_flags(extras, "-I%s", incdirs)
+         return execute(variables.CC.." "..variables.CFLAGS, "-I"..variables.LUA_INCDIR, "-c", source, "-o", object, table.unpack(extras))
+      end
+      compile_library = function (library, objects, libraries, libdirs)
+         local extras = { table.unpack(objects) }
+         add_flags(extras, "-L%s", libdirs)
+         if cfg.gcc_rpath then
+            add_flags(extras, "-Wl,-rpath,%s", libdirs)
+         end
+         add_flags(extras, "-l%s", libraries)
+         if cfg.link_lua_explicitly then
+            extras[#extras+1] = "-L"..variables.LUA_LIBDIR
+            extras[#extras+1] = "-llua"
+         end
+         return execute(variables.LD.." "..variables.LDFLAGS.." "..variables.LIBFLAG, "-o", library, table.unpack(extras))
+      end
+      compile_static_library = function(library, objects, libraries, libdirs, name)  -- luacheck: ignore 211
+         local ok = execute(variables.AR, "rc", library, table.unpack(objects))
+         if ok then
+            ok = execute(variables.RANLIB, library)
+         end
+         return ok
+      end
+   end
+
+   local ok, err
+   local lua_modules = {}
+   local lib_modules = {}
+   local luadir = path.lua_dir(rockspec.name, rockspec.version)
+   local libdir = path.lib_dir(rockspec.name, rockspec.version)
+
+   local autolibs, autoincdirs, autolibdirs = autoextract_libs(rockspec.external_dependencies, rockspec.variables)
+
+   if not build.modules then
+      if rockspec:format_is_at_least("3.0") then
+         local install, copy_directories
+         build.modules, install, copy_directories = builtin.autodetect_modules(autolibs, autoincdirs, autolibdirs)
+         build.install = build.install or install
+         build.copy_directories = build.copy_directories or copy_directories
+      else
+         return nil, "Missing build.modules table"
+      end
+   end
+
+   local compile_temp_dir
+
+   local mkdir_cache = {}
+   local function cached_make_dir(name)
+      if name == "" or mkdir_cache[name] then
+         return true
+      end
+      mkdir_cache[name] = true
+      return fs.make_dir(name)
+   end
+
+   for name, info in pairs(build.modules) do
+      local moddir = path.module_to_path(name)
+      if type(info) == "string" then
+         local ext = info:match("%.([^.]+)$")
+         if ext == "lua" then
+            local filename = dir.base_name(info)
+            if filename == "init.lua" and not name:match("%.init$") then
+               moddir = path.module_to_path(name..".init")
+            else
+               local basename = name:match("([^.]+)$")
+               filename = basename..".lua"
+            end
+            local dest = dir.path(luadir, moddir, filename)
+            lua_modules[info] = dest
+         else
+            info = {info}
+         end
+      end
+      if type(info) == "table" then
+         if not checked_lua_h then
+            local ok, err, errcode = deps.check_lua_incdir(rockspec.variables)
+            if not ok then
+               return nil, err, errcode
+            end
+
+            if cfg.link_lua_explicitly then
+               local ok, err, errcode = deps.check_lua_libdir(rockspec.variables)
+               if not ok then
+                  return nil, err, errcode
+               end
+            end
+            checked_lua_h = true
+         end
+         local objects = {}
+         local sources = info.sources
+         if info[1] then sources = info end
+         if type(sources) == "string" then sources = {sources} end
+         if type(sources) ~= "table" then
+            return nil, "error in rockspec: module '" .. name .. "' entry has no 'sources' list"
+         end
+         for _, source in ipairs(sources) do
+            if type(source) ~= "string" then
+               return nil, "error in rockspec: module '" .. name .. "' does not specify source correctly."
+            end
+            local object = source:gsub("%.[^.]*$", "."..cfg.obj_extension)
+            if not object then
+               object = source.."."..cfg.obj_extension
+            end
+            ok = compile_object(object, source, info.defines, info.incdirs or autoincdirs)
+            if not ok then
+               return nil, "Failed compiling object "..object
+            end
+            table.insert(objects, object)
+         end
+
+         if not compile_temp_dir then
+            compile_temp_dir = fs.make_temp_dir("build-" .. rockspec.package .. "-" .. rockspec.version)
+            util.schedule_function(fs.delete, compile_temp_dir)
+         end
+
+         local module_name = name:match("([^.]*)$").."."..util.matchquote(cfg.lib_extension)
+         if moddir ~= "" then
+            module_name = dir.path(moddir, module_name)
+         end
+
+         local build_name = dir.path(compile_temp_dir, module_name)
+         local build_dir = dir.dir_name(build_name)
+         cached_make_dir(build_dir)
+
+         lib_modules[build_name] = dir.path(libdir, module_name)
+         ok = compile_library(build_name, objects, info.libraries, info.libdirs or autolibdirs, name)
+         if not ok then
+            return nil, "Failed compiling module "..module_name
+         end
+
+         -- for backwards compatibility, try keeping a copy of the module
+         -- in the old location (luasec-1.3.2-1 rockspec breaks otherwise)
+         if cached_make_dir(dir.dir_name(module_name)) then
+            fs.copy(build_name, module_name)
+         end
+
+         --[[ TODO disable static libs until we fix the conflict in the manifest, which will take extending the manifest format.
+         module_name = name:match("([^.]*)$").."."..util.matchquote(cfg.static_lib_extension)
+         if moddir ~= "" then
+            module_name = dir.path(moddir, module_name)
+         end
+         lib_modules[module_name] = dir.path(libdir, module_name)
+         ok = compile_static_library(module_name, objects, info.libraries, info.libdirs, name)
+         if not ok then
+            return nil, "Failed compiling static library "..module_name
+         end
+         ]]
+      end
+   end
+   if not no_install then
+      for _, mods in ipairs({{ tbl = lua_modules, perms = "read" }, { tbl = lib_modules, perms = "exec" }}) do
+         for name, dest in pairs(mods.tbl) do
+            cached_make_dir(dir.dir_name(dest))
+            ok, err = fs.copy(name, dest, mods.perms)
+            if not ok then
+               return nil, "Failed installing "..name.." in "..dest..": "..err
+            end
+         end
+      end
+      if fs.is_dir("lua") then
+         ok, err = fs.copy_contents("lua", luadir)
+         if not ok then
+            return nil, "Failed copying contents of 'lua' directory: "..err
+         end
+      end
+   end
+   return true
+end
+
+return builtin
diff --git a/src/luarocks/build/cmake.tl b/src/luarocks/build/cmake.tl
new file mode 100644
index 00000000..b7a4786e
--- /dev/null
+++ b/src/luarocks/build/cmake.tl
@@ -0,0 +1,78 @@
+
+--- Build back-end for CMake-based modules.
+local cmake = {}
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local cfg = require("luarocks.core.cfg")
+
+--- Driver function for the "cmake" build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors occurred,
+-- nil and an error message otherwise.
+function cmake.run(rockspec, no_install)
+   assert(rockspec:type() == "rockspec")
+   local build = rockspec.build
+   local variables = build.variables or {}
+
+   -- Pass Env variables
+   variables.CMAKE_MODULE_PATH=os.getenv("CMAKE_MODULE_PATH")
+   variables.CMAKE_LIBRARY_PATH=os.getenv("CMAKE_LIBRARY_PATH")
+   variables.CMAKE_INCLUDE_PATH=os.getenv("CMAKE_INCLUDE_PATH")
+
+   util.variable_substitutions(variables, rockspec.variables)
+
+   local ok, err_msg = fs.is_tool_available(rockspec.variables.CMAKE, "CMake")
+   if not ok then
+      return nil, err_msg
+   end
+
+   -- If inline cmake is present create CMakeLists.txt from it.
+   if type(build.cmake) == "string" then
+      local cmake_handler = assert(io.open(fs.current_dir().."/CMakeLists.txt", "w"))
+      cmake_handler:write(build.cmake)
+      cmake_handler:close()
+   end
+
+   -- Execute cmake with variables.
+   local args = ""
+
+   -- Try to pick the best generator. With msvc and x64, CMake does not select it by default so we need to be explicit.
+   if cfg.cmake_generator then
+      args = args .. ' -G"'..cfg.cmake_generator.. '"'
+   elseif cfg.is_platform("windows") and cfg.target_cpu:match("x86_64$") then
+      args = args .. " -DCMAKE_GENERATOR_PLATFORM=x64"
+   end
+
+   for k,v in pairs(variables) do
+      args = args .. ' -D' ..k.. '="' ..tostring(v).. '"'
+   end
+
+   if not fs.execute_string(rockspec.variables.CMAKE.." -H. -Bbuild.luarocks "..args) then
+      return nil, "Failed cmake."
+   end
+
+   local do_build, do_install
+   if rockspec:format_is_at_least("3.0") then
+      do_build   = (build.build_pass   == nil) and true or build.build_pass
+      do_install = (build.install_pass == nil) and true or build.install_pass
+   else
+      do_build = true
+      do_install = true
+   end
+
+   if do_build then
+      if not fs.execute_string(rockspec.variables.CMAKE.." --build build.luarocks --config Release") then
+         return nil, "Failed building."
+      end
+   end
+   if do_install and not no_install then
+      if not fs.execute_string(rockspec.variables.CMAKE.." --build build.luarocks --target install --config Release") then
+         return nil, "Failed installing."
+      end
+   end
+
+   return true
+end
+
+return cmake
diff --git a/src/luarocks/build/command.tl b/src/luarocks/build/command.tl
new file mode 100644
index 00000000..b0c4aa79
--- /dev/null
+++ b/src/luarocks/build/command.tl
@@ -0,0 +1,41 @@
+
+--- Build back-end for raw listing of commands in rockspec files.
+local command = {}
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local cfg = require("luarocks.core.cfg")
+
+--- Driver function for the "command" build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors occurred,
+-- nil and an error message otherwise.
+function command.run(rockspec, not_install)
+   assert(rockspec:type() == "rockspec")
+
+   local build = rockspec.build
+
+   util.variable_substitutions(build, rockspec.variables)
+
+   local env = {
+      CC = cfg.variables.CC,
+      --LD = cfg.variables.LD,
+      --CFLAGS = cfg.variables.CFLAGS,
+   }
+
+   if build.build_command then
+      util.printout(build.build_command)
+      if not fs.execute_env(env, build.build_command) then
+         return nil, "Failed building."
+      end
+   end
+   if build.install_command and not not_install then
+      util.printout(build.install_command)
+      if not fs.execute_env(env, build.install_command) then
+         return nil, "Failed installing."
+      end
+   end
+   return true
+end
+
+return command
diff --git a/src/luarocks/build/make.tl b/src/luarocks/build/make.tl
new file mode 100644
index 00000000..4345ddff
--- /dev/null
+++ b/src/luarocks/build/make.tl
@@ -0,0 +1,98 @@
+
+--- Build back-end for using Makefile-based packages.
+local make = {}
+
+local unpack = unpack or table.unpack
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local cfg = require("luarocks.core.cfg")
+
+--- Call "make" with given target and variables
+-- @param make_cmd string: the make command to be used (typically
+-- configured through variables.MAKE in the config files, or
+-- the appropriate platform-specific default).
+-- @param pass boolean: If true, run make; if false, do nothing.
+-- @param target string: The make target; an empty string indicates
+-- the default target.
+-- @param variables table: A table containing string-string key-value
+-- pairs representing variable assignments to be passed to make.
+-- @return boolean: false if any errors occurred, true otherwise.
+local function make_pass(make_cmd, pass, target, variables)
+   assert(type(pass) == "boolean")
+   assert(type(target) == "string")
+   assert(type(variables) == "table")
+
+   local assignments = {}
+   for k,v in pairs(variables) do
+      table.insert(assignments, k.."="..v)
+   end
+   if pass then
+      return fs.execute(make_cmd.." "..target, unpack(assignments))
+   else
+      return true
+   end
+end
+
+--- Driver function for the "make" build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors occurred,
+-- nil and an error message otherwise.
+function make.run(rockspec, not_install)
+   assert(rockspec:type() == "rockspec")
+
+   local build = rockspec.build
+
+   if build.build_pass == nil then build.build_pass = true end
+   if build.install_pass == nil then build.install_pass = true end
+   build.build_variables = build.build_variables or {}
+   build.install_variables = build.install_variables or {}
+   build.build_target = build.build_target or ""
+   build.install_target = build.install_target or "install"
+   local makefile = build.makefile or cfg.makefile
+   if makefile then
+      -- Assumes all make's accept -f. True for POSIX make, GNU make and Microsoft nmake.
+      build.build_target = "-f "..makefile.." "..build.build_target
+      build.install_target = "-f "..makefile.." "..build.install_target
+   end
+
+   if build.variables then
+      for var, val in pairs(build.variables) do
+         build.build_variables[var] = val
+         build.install_variables[var] = val
+      end
+   end
+
+   util.warn_if_not_used(build.build_variables, { CFLAGS=true }, "variable %s was not passed in build_variables")
+
+   util.variable_substitutions(build.build_variables, rockspec.variables)
+   util.variable_substitutions(build.install_variables, rockspec.variables)
+
+   local auto_variables = { "CC" }
+
+   for _, variable in pairs(auto_variables) do
+      if not build.build_variables[variable] then
+         build.build_variables[variable] = rockspec.variables[variable]
+      end
+      if not build.install_variables[variable] then
+         build.install_variables[variable] = rockspec.variables[variable]
+      end
+   end
+
+   -- backwards compatibility
+   local make_cmd = cfg.make or rockspec.variables.MAKE
+
+   local ok = make_pass(make_cmd, build.build_pass, build.build_target, build.build_variables)
+   if not ok then
+      return nil, "Failed building."
+   end
+   if not not_install then
+      ok = make_pass(make_cmd, build.install_pass, build.install_target, build.install_variables)
+      if not ok then
+         return nil, "Failed installing."
+      end
+   end
+   return true
+end
+
+return make
diff --git a/src/luarocks/core/cfg.d.tl b/src/luarocks/core/cfg.d.tl
index 2c32569a..82b7c502 100644
--- a/src/luarocks/core/cfg.d.tl
+++ b/src/luarocks/core/cfg.d.tl
@@ -79,6 +79,7 @@ local record cfg
    wrapper_suffix: string
    -- writer
    no_manifest: boolean
+   accepted_build_types: {boolean}
 end
 
 return cfg
\ No newline at end of file
diff --git a/src/luarocks/core/types/manifest.d.tl b/src/luarocks/core/types/manifest.d.tl
index de1319d4..1e986867 100644
--- a/src/luarocks/core/types/manifest.d.tl
+++ b/src/luarocks/core/types/manifest.d.tl
@@ -4,19 +4,26 @@ local type Query = q.Query
 local type t = require("luarocks.core.types.tree")
 local type Tree = t.Tree
 
-local record manifest
-    record Manifest
-       arch: string
-       commands: {string: {string}}
-       dependencies: {string: {string: {Query}}}
-       modules: {string: {string}}
-       repository: {string: {string: {Manifest}}}
-    end
-    
-    record Tree_manifest
-       tree: Tree
-       manifest: Manifest
-    end
- end
+local record manifest      
+   record Manifest
+      record Entry
+         arch: string
+         commands: {string: string}
+         dependencies: {string: string}
+         modules: {string: string}
+      end
 
- return manifest
\ No newline at end of file
+      arch: string
+      commands: {string: {string}}
+      dependencies: {string: {string: {Query}}}
+      modules: {string: {string}}
+      repository: {string: {string: {Entry}}}
+   end
+
+   record Tree_manifest
+      tree: Tree
+      manifest: Manifest
+   end
+end
+
+return manifest
\ No newline at end of file
diff --git a/src/luarocks/core/types/rockspec.lua b/src/luarocks/core/types/rockspec.lua
index 9ee7de37..a13c3f58 100644
--- a/src/luarocks/core/types/rockspec.lua
+++ b/src/luarocks/core/types/rockspec.lua
@@ -1,7 +1,16 @@
 
 
 
-local rockspec = {Description = {}, Variables = {}, Source = {}, Test = {}, Install = {}, Build = {}, Dependencies = {}, Hooks = {}, Deploy = {}, Rockspec = {}, }
+local rockspec = {Description = {}, Variables = {}, Source = {}, Test = {}, Install = {}, Installs = {}, Build = {}, Dependencies = {}, Hooks = {}, Deploy = {}, Rockspec = {}, }
+
+
+
+
+
+
+
+
+
 
 
 
diff --git a/src/luarocks/core/types/rockspec.tl b/src/luarocks/core/types/rockspec.tl
index 2375b888..6cd708cf 100644
--- a/src/luarocks/core/types/rockspec.tl
+++ b/src/luarocks/core/types/rockspec.tl
@@ -60,19 +60,28 @@ local record rockspec
         busted_executable: string
         flags: {string}
     end
-  
+
     record Install
-        lua: any
-        lib: any
-        conf: any
-        bin: any
+        name: string
+        is_module_path: boolean
+        perms: string
+    end
+  
+    record Installs
+        lua: Install
+        lib: Install
+        conf: Install
+        bin: Install
     end
   
     record Build
         type: string
         modules: {string: {string: string | {string}}}
         copy_directories: string
-        install: Install
+        install: Installs
+        extra_files: {string : string}
+        patches: {string : string}
+        macosx_deployment_target: string
     end
   
     record Dependencies
diff --git a/src/luarocks/fs.d.tl b/src/luarocks/fs.d.tl
index 680369de..86499bee 100644
--- a/src/luarocks/fs.d.tl
+++ b/src/luarocks/fs.d.tl
@@ -33,7 +33,7 @@ local record fs
    set_time: function(string, number)
    set_time: function(string, os.DateTable)
    -- zip
-   find: function(string): {string}
+   find: function(?string): {string}
    filter_file: function(function, string, string): boolean, string
    -- fetch
    file_age: function(string): number
@@ -59,6 +59,8 @@ local record fs
    -- writer
    replace_file: function(string, string): boolean, string
    get_md5: function(string): string, string
+   -- build
+   apply_patch: function(string, string, boolean): boolean, string
 end
 
 return fs
diff --git a/src/luarocks/manif/writer-original.lua b/src/luarocks/manif/writer-original.lua
new file mode 100644
index 00000000..72d35754
--- /dev/null
+++ b/src/luarocks/manif/writer-original.lua
@@ -0,0 +1,469 @@
+
+local writer = {}
+
+local cfg = require("luarocks.core.cfg")
+local search = require("luarocks.search")
+local repos = require("luarocks.repos")
+local deps = require("luarocks.deps")
+local vers = require("luarocks.core.vers")
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local dir = require("luarocks.dir")
+local fetch = require("luarocks.fetch")
+local path = require("luarocks.path")
+local persist = require("luarocks.persist")
+local manif = require("luarocks.manif")
+local queries = require("luarocks.queries")
+
+--- Update storage table to account for items provided by a package.
+-- @param storage table: a table storing items in the following format:
+-- keys are item names and values are arrays of packages providing each item,
+-- where a package is specified as string `name/version`.
+-- @param items table: a table mapping item names to paths.
+-- @param name string: package name.
+-- @param version string: package version.
+local function store_package_items(storage, name, version, items)
+   assert(type(storage) == "table")
+   assert(type(items) == "table")
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+
+   local package_identifier = name.."/"..version
+
+   for item_name, path in pairs(items) do  -- luacheck: ignore 431
+      if not storage[item_name] then
+         storage[item_name] = {}
+      end
+
+      table.insert(storage[item_name], package_identifier)
+   end
+end
+
+--- Update storage table removing items provided by a package.
+-- @param storage table: a table storing items in the following format:
+-- keys are item names and values are arrays of packages providing each item,
+-- where a package is specified as string `name/version`.
+-- @param items table: a table mapping item names to paths.
+-- @param name string: package name.
+-- @param version string: package version.
+local function remove_package_items(storage, name, version, items)
+   assert(type(storage) == "table")
+   assert(type(items) == "table")
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+
+   local package_identifier = name.."/"..version
+
+   for item_name, path in pairs(items) do  -- luacheck: ignore 431
+      local key = item_name
+      local all_identifiers = storage[key]
+      if not all_identifiers then
+         key = key .. ".init"
+         all_identifiers = storage[key]
+      end
+
+      if all_identifiers then
+         for i, identifier in ipairs(all_identifiers) do
+            if identifier == package_identifier then
+               table.remove(all_identifiers, i)
+               break
+            end
+         end
+
+         if #all_identifiers == 0 then
+            storage[key] = nil
+         end
+      else
+         util.warning("Cannot find entry for " .. item_name .. " in manifest -- corrupted manifest?")
+      end
+   end
+end
+
+--- Process the dependencies of a manifest table to determine its dependency
+-- chains for loading modules. The manifest dependencies information is filled
+-- and any dependency inconsistencies or missing dependencies are reported to
+-- standard error.
+-- @param manifest table: a manifest table.
+-- @param deps_mode string: Dependency mode: "one" for the current default tree,
+-- "all" for all trees, "order" for all trees with priority >= the current default,
+-- "none" for no trees.
+local function update_dependencies(manifest, deps_mode)
+   assert(type(manifest) == "table")
+   assert(type(deps_mode) == "string")
+
+   if not manifest.dependencies then manifest.dependencies = {} end
+   local mdeps = manifest.dependencies
+
+   for pkg, versions in pairs(manifest.repository) do
+      for version, repositories in pairs(versions) do
+         for _, repo in ipairs(repositories) do
+            if repo.arch == "installed" then
+               local rd = {}
+               repo.dependencies = rd
+               deps.scan_deps(rd, mdeps, pkg, version, deps_mode)
+               rd[pkg] = nil
+            end
+         end
+      end
+   end
+end
+
+
+
+--- Sort function for ordering rock identifiers in a manifest's
+-- modules table. Rocks are ordered alphabetically by name, and then
+-- by version which greater first.
+-- @param a string: Version to compare.
+-- @param b string: Version to compare.
+-- @return boolean: The comparison result, according to the
+-- rule outlined above.
+local function sort_pkgs(a, b)
+   assert(type(a) == "string")
+   assert(type(b) == "string")
+
+   local na, va = a:match("(.*)/(.*)$")
+   local nb, vb = b:match("(.*)/(.*)$")
+
+   return (na == nb) and vers.compare_versions(va, vb) or na < nb
+end
+
+--- Sort items of a package matching table by version number (higher versions first).
+-- @param tbl table: the package matching table: keys should be strings
+-- and values arrays of strings with packages names in "name/version" format.
+local function sort_package_matching_table(tbl)
+   assert(type(tbl) == "table")
+
+   if next(tbl) then
+      for item, pkgs in pairs(tbl) do
+         if #pkgs > 1 then
+            table.sort(pkgs, sort_pkgs)
+            -- Remove duplicates from the sorted array.
+            local prev = nil
+            local i = 1
+            while pkgs[i] do
+               local curr = pkgs[i]
+               if curr == prev then
+                  table.remove(pkgs, i)
+               else
+                  prev = curr
+                  i = i + 1
+               end
+            end
+         end
+      end
+   end
+end
+
+--- Filter manifest table by Lua version, removing rockspecs whose Lua version
+-- does not match.
+-- @param manifest table: a manifest table.
+-- @param lua_version string or nil: filter by Lua version
+-- @param repodir string: directory of repository being scanned
+-- @param cache table: temporary rockspec cache table
+local function filter_by_lua_version(manifest, lua_version, repodir, cache)
+   assert(type(manifest) == "table")
+   assert(type(repodir) == "string")
+   assert((not cache) or type(cache) == "table")
+
+   cache = cache or {}
+   lua_version = vers.parse_version(lua_version)
+   for pkg, versions in pairs(manifest.repository) do
+      local to_remove = {}
+      for version, repositories in pairs(versions) do
+         for _, repo in ipairs(repositories) do
+            if repo.arch == "rockspec" then
+               local pathname = dir.path(repodir, pkg.."-"..version..".rockspec")
+               local rockspec, err = cache[pathname]
+               if not rockspec then
+                  rockspec, err = fetch.load_local_rockspec(pathname, true)
+               end
+               if rockspec then
+                  cache[pathname] = rockspec
+                  for _, dep in ipairs(rockspec.dependencies) do
+                     if dep.name == "lua" then
+                        if not vers.match_constraints(lua_version, dep.constraints) then
+                           table.insert(to_remove, version)
+                        end
+                        break
+                     end
+                  end
+               else
+                  util.printerr("Error loading rockspec for "..pkg.." "..version..": "..err)
+               end
+            end
+         end
+      end
+      if next(to_remove) then
+         for _, incompat in ipairs(to_remove) do
+            versions[incompat] = nil
+         end
+         if not next(versions) then
+            manifest.repository[pkg] = nil
+         end
+      end
+   end
+end
+
+--- Store search results in a manifest table.
+-- @param results table: The search results as returned by search.disk_search.
+-- @param manifest table: A manifest table (must contain repository, modules, commands tables).
+-- It will be altered to include the search results.
+-- @return boolean or (nil, string): true in case of success, or nil followed by an error message.
+local function store_results(results, manifest)
+   assert(type(results) == "table")
+   assert(type(manifest) == "table")
+
+   for name, versions in pairs(results) do
+      local pkgtable = manifest.repository[name] or {}
+      for version, entries in pairs(versions) do
+         local versiontable = {}
+         for _, entry in ipairs(entries) do
+            local entrytable = {}
+            entrytable.arch = entry.arch
+            if entry.arch == "installed" then
+               local rock_manifest, err = manif.load_rock_manifest(name, version)
+               if not rock_manifest then return nil, err end
+
+               entrytable.modules = repos.package_modules(name, version)
+               store_package_items(manifest.modules, name, version, entrytable.modules)
+               entrytable.commands = repos.package_commands(name, version)
+               store_package_items(manifest.commands, name, version, entrytable.commands)
+            end
+            table.insert(versiontable, entrytable)
+         end
+         pkgtable[version] = versiontable
+      end
+      manifest.repository[name] = pkgtable
+   end
+   sort_package_matching_table(manifest.modules)
+   sort_package_matching_table(manifest.commands)
+   return true
+end
+
+--- Commit a table to disk in given local path.
+-- @param where string: The directory where the table should be saved.
+-- @param name string: The filename.
+-- @param tbl table: The table to be saved.
+-- @return boolean or (nil, string): true if successful, or nil and a
+-- message in case of errors.
+local function save_table(where, name, tbl)
+   assert(type(where) == "string")
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(tbl) == "table")
+
+   local filename = dir.path(where, name)
+   local ok, err = persist.save_from_table(filename..".tmp", tbl)
+   if ok then
+      ok, err = fs.replace_file(filename, filename..".tmp")
+   end
+   return ok, err
+end
+
+function writer.make_rock_manifest(name, version)
+   local install_dir = path.install_dir(name, version)
+   local tree = {}
+   for _, file in ipairs(fs.find(install_dir)) do
+      local full_path = dir.path(install_dir, file)
+      local walk = tree
+      local last
+      local last_name
+      for filename in file:gmatch("[^\\/]+") do
+         local next = walk[filename]
+         if not next then
+            next = {}
+            walk[filename] = next
+         end
+         last = walk
+         last_name = filename
+         walk = next
+      end
+      if fs.is_file(full_path) then
+         local sum, err = fs.get_md5(full_path)
+         if not sum then
+            return nil, "Failed producing checksum: "..tostring(err)
+         end
+         last[last_name] = sum
+      end
+   end
+   local rock_manifest = { rock_manifest=tree }
+   manif.rock_manifest_cache[name.."/"..version] = rock_manifest
+   save_table(install_dir, "rock_manifest", rock_manifest )
+   return true
+end
+
+-- Writes a 'rock_namespace' file in a locally installed rock directory.
+-- @param name string: the rock name, without a namespace
+-- @param version string: the rock version
+-- @param namespace string?: the namespace
+-- @return true if successful (or unnecessary, if there is no namespace),
+-- or nil and an error message.
+function writer.make_namespace_file(name, version, namespace)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+   assert(type(namespace) == "string" or not namespace)
+   if not namespace then
+      return true
+   end
+   local fd, err = io.open(path.rock_namespace_file(name, version), "w")
+   if not fd then
+      return nil, err
+   end
+   local ok, err = fd:write(namespace)
+   if not ok then
+      return nil, err
+   end
+   fd:close()
+   return true
+end
+
+--- Scan a LuaRocks repository and output a manifest file.
+-- A file called 'manifest' will be written in the root of the given
+-- repository directory.
+-- @param repo A local repository directory.
+-- @param deps_mode string: Dependency mode: "one" for the current default tree,
+-- "all" for all trees, "order" for all trees with priority >= the current default,
+-- "none" for the default dependency mode from the configuration.
+-- @param remote boolean: 'true' if making a manifest for a rocks server.
+-- @return boolean or (nil, string): True if manifest was generated,
+-- or nil and an error message.
+function writer.make_manifest(repo, deps_mode, remote)
+   assert(type(repo) == "string")
+   assert(type(deps_mode) == "string")
+
+   if deps_mode == "none" then deps_mode = cfg.deps_mode end
+
+   if not fs.is_dir(repo) then
+      return nil, "Cannot access repository at "..repo
+   end
+
+   local query = queries.all("any")
+   local results = search.disk_search(repo, query)
+   local manifest = { repository = {}, modules = {}, commands = {} }
+
+   manif.cache_manifest(repo, nil, manifest)
+
+   local ok, err = store_results(results, manifest)
+   if not ok then return nil, err end
+
+   if remote then
+      local cache = {}
+      for luaver in util.lua_versions() do
+         local vmanifest = { repository = {}, modules = {}, commands = {} }
+         local ok, err = store_results(results, vmanifest)
+         filter_by_lua_version(vmanifest, luaver, repo, cache)
+         if not cfg.no_manifest then
+            save_table(repo, "manifest-"..luaver, vmanifest)
+         end
+      end
+   else
+      update_dependencies(manifest, deps_mode)
+   end
+
+   if cfg.no_manifest then
+      -- We want to have cache updated; but exit before save_table is called
+      return true
+   end
+   return save_table(repo, "manifest", manifest)
+end
+
+--- Update manifest file for a local repository
+-- adding information about a version of a package installed in that repository.
+-- @param name string: Name of a package from the repository.
+-- @param version string: Version of a package from the repository.
+-- @param repo string or nil: Pathname of a local repository. If not given,
+-- the default local repository is used.
+-- @param deps_mode string: Dependency mode: "one" for the current default tree,
+-- "all" for all trees, "order" for all trees with priority >= the current default,
+-- "none" for using the default dependency mode from the configuration.
+-- @return boolean or (nil, string): True if manifest was updated successfully,
+-- or nil and an error message.
+function writer.add_to_manifest(name, version, repo, deps_mode)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+   local rocks_dir = path.rocks_dir(repo or cfg.root_dir)
+   assert(type(deps_mode) == "string")
+
+   if deps_mode == "none" then deps_mode = cfg.deps_mode end
+
+   local manifest, err = manif.load_manifest(rocks_dir)
+   if not manifest then
+      util.printerr("No existing manifest. Attempting to rebuild...")
+      -- Manifest built by `writer.make_manifest` should already
+      -- include information about given name and version,
+      -- no need to update it.
+      return writer.make_manifest(rocks_dir, deps_mode)
+   end
+
+   local results = {[name] = {[version] = {{arch = "installed", repo = rocks_dir}}}}
+
+   local ok, err = store_results(results, manifest)
+   if not ok then return nil, err end
+
+   update_dependencies(manifest, deps_mode)
+
+   if cfg.no_manifest then
+      return true
+   end
+   return save_table(rocks_dir, "manifest", manifest)
+end
+
+--- Update manifest file for a local repository
+-- removing information about a version of a package.
+-- @param name string: Name of a package removed from the repository.
+-- @param version string: Version of a package removed from the repository.
+-- @param repo string or nil: Pathname of a local repository. If not given,
+-- the default local repository is used.
+-- @param deps_mode string: Dependency mode: "one" for the current default tree,
+-- "all" for all trees, "order" for all trees with priority >= the current default,
+-- "none" for using the default dependency mode from the configuration.
+-- @return boolean or (nil, string): True if manifest was updated successfully,
+-- or nil and an error message.
+function writer.remove_from_manifest(name, version, repo, deps_mode)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+   local rocks_dir = path.rocks_dir(repo or cfg.root_dir)
+   assert(type(deps_mode) == "string")
+
+   if deps_mode == "none" then deps_mode = cfg.deps_mode end
+
+   local manifest, err = manif.load_manifest(rocks_dir)
+   if not manifest then
+      util.printerr("No existing manifest. Attempting to rebuild...")
+      -- Manifest built by `writer.make_manifest` should already
+      -- include up-to-date information, no need to update it.
+      return writer.make_manifest(rocks_dir, deps_mode)
+   end
+
+   local package_entry = manifest.repository[name]
+   if package_entry == nil or package_entry[version] == nil then
+      -- entry is already missing from repository, no need to do anything
+      return true
+   end
+
+   local version_entry = package_entry[version][1]
+   if not version_entry then
+      -- manifest looks corrupted, rebuild
+      return writer.make_manifest(rocks_dir, deps_mode)
+   end
+
+   remove_package_items(manifest.modules, name, version, version_entry.modules)
+   remove_package_items(manifest.commands, name, version, version_entry.commands)
+
+   package_entry[version] = nil
+   manifest.dependencies[name][version] = nil
+
+   if not next(package_entry) then
+      -- No more versions of this package.
+      manifest.repository[name] = nil
+      manifest.dependencies[name] = nil
+   end
+
+   update_dependencies(manifest, deps_mode)
+
+   if cfg.no_manifest then
+      return true
+   end
+   return save_table(rocks_dir, "manifest", manifest)
+end
+
+return writer
diff --git a/src/luarocks/manif/writer.lua b/src/luarocks/manif/writer.lua
index 72d35754..10dd6743 100644
--- a/src/luarocks/manif/writer.lua
+++ b/src/luarocks/manif/writer.lua
@@ -1,6 +1,7 @@
-
+local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local assert = _tl_compat and _tl_compat.assert or assert; local io = _tl_compat and _tl_compat.io or io; local ipairs = _tl_compat and _tl_compat.ipairs or ipairs; local pairs = _tl_compat and _tl_compat.pairs or pairs; local string = _tl_compat and _tl_compat.string or string; local table = _tl_compat and _tl_compat.table or table
 local writer = {}
 
+
 local cfg = require("luarocks.core.cfg")
 local search = require("luarocks.search")
 local repos = require("luarocks.repos")
@@ -15,22 +16,35 @@ local persist = require("luarocks.persist")
 local manif = require("luarocks.manif")
 local queries = require("luarocks.queries")
 
---- Update storage table to account for items provided by a package.
--- @param storage table: a table storing items in the following format:
--- keys are item names and values are arrays of packages providing each item,
--- where a package is specified as string `name/version`.
--- @param items table: a table mapping item names to paths.
--- @param name string: package name.
--- @param version string: package version.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 local function store_package_items(storage, name, version, items)
-   assert(type(storage) == "table")
-   assert(type(items) == "table")
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(version) == "string")
+   assert(not name:match("/"))
 
-   local package_identifier = name.."/"..version
+   local package_identifier = name .. "/" .. version
 
-   for item_name, path in pairs(items) do  -- luacheck: ignore 431
+   for item_name, _ in pairs(items) do
       if not storage[item_name] then
          storage[item_name] = {}
       end
@@ -39,22 +53,19 @@ local function store_package_items(storage, name, version, items)
    end
 end
 
---- Update storage table removing items provided by a package.
--- @param storage table: a table storing items in the following format:
--- keys are item names and values are arrays of packages providing each item,
--- where a package is specified as string `name/version`.
--- @param items table: a table mapping item names to paths.
--- @param name string: package name.
--- @param version string: package version.
+
+
+
+
+
+
+
 local function remove_package_items(storage, name, version, items)
-   assert(type(storage) == "table")
-   assert(type(items) == "table")
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(version) == "string")
+   assert(not name:match("/"))
 
-   local package_identifier = name.."/"..version
+   local package_identifier = name .. "/" .. version
 
-   for item_name, path in pairs(items) do  -- luacheck: ignore 431
+   for item_name, _ in pairs(items) do
       local key = item_name
       local all_identifiers = storage[key]
       if not all_identifiers then
@@ -79,17 +90,15 @@ local function remove_package_items(storage, name, version, items)
    end
 end
 
---- Process the dependencies of a manifest table to determine its dependency
--- chains for loading modules. The manifest dependencies information is filled
--- and any dependency inconsistencies or missing dependencies are reported to
--- standard error.
--- @param manifest table: a manifest table.
--- @param deps_mode string: Dependency mode: "one" for the current default tree,
--- "all" for all trees, "order" for all trees with priority >= the current default,
--- "none" for no trees.
+
+
+
+
+
+
+
+
 local function update_dependencies(manifest, deps_mode)
-   assert(type(manifest) == "table")
-   assert(type(deps_mode) == "string")
 
    if not manifest.dependencies then manifest.dependencies = {} end
    local mdeps = manifest.dependencies
@@ -110,34 +119,30 @@ end
 
 
 
---- Sort function for ordering rock identifiers in a manifest's
--- modules table. Rocks are ordered alphabetically by name, and then
--- by version which greater first.
--- @param a string: Version to compare.
--- @param b string: Version to compare.
--- @return boolean: The comparison result, according to the
--- rule outlined above.
-local function sort_pkgs(a, b)
-   assert(type(a) == "string")
-   assert(type(b) == "string")
 
+
+
+
+
+
+
+local function sort_pkgs(a, b)
    local na, va = a:match("(.*)/(.*)$")
    local nb, vb = b:match("(.*)/(.*)$")
 
    return (na == nb) and vers.compare_versions(va, vb) or na < nb
 end
 
---- Sort items of a package matching table by version number (higher versions first).
--- @param tbl table: the package matching table: keys should be strings
--- and values arrays of strings with packages names in "name/version" format.
+
+
+
 local function sort_package_matching_table(tbl)
-   assert(type(tbl) == "table")
 
-   if next(tbl) then
+   if next(tbl) ~= nil then
       for item, pkgs in pairs(tbl) do
          if #pkgs > 1 then
             table.sort(pkgs, sort_pkgs)
-            -- Remove duplicates from the sorted array.
+
             local prev = nil
             local i = 1
             while pkgs[i] do
@@ -154,32 +159,30 @@ local function sort_package_matching_table(tbl)
    end
 end
 
---- Filter manifest table by Lua version, removing rockspecs whose Lua version
--- does not match.
--- @param manifest table: a manifest table.
--- @param lua_version string or nil: filter by Lua version
--- @param repodir string: directory of repository being scanned
--- @param cache table: temporary rockspec cache table
-local function filter_by_lua_version(manifest, lua_version, repodir, cache)
-   assert(type(manifest) == "table")
-   assert(type(repodir) == "string")
-   assert((not cache) or type(cache) == "table")
+
+
+
+
+
+
+local function filter_by_lua_version(manifest, lua_version_str, repodir, cache)
 
    cache = cache or {}
-   lua_version = vers.parse_version(lua_version)
+   local lua_version = vers.parse_version(lua_version_str)
    for pkg, versions in pairs(manifest.repository) do
       local to_remove = {}
       for version, repositories in pairs(versions) do
          for _, repo in ipairs(repositories) do
             if repo.arch == "rockspec" then
-               local pathname = dir.path(repodir, pkg.."-"..version..".rockspec")
-               local rockspec, err = cache[pathname]
+               local pathname = dir.path(repodir, pkg .. "-" .. version .. ".rockspec")
+               local rockspec = cache[pathname]
+               local err
                if not rockspec then
                   rockspec, err = fetch.load_local_rockspec(pathname, true)
                end
                if rockspec then
                   cache[pathname] = rockspec
-                  for _, dep in ipairs(rockspec.dependencies) do
+                  for _, dep in ipairs(rockspec.dependencies.queries) do
                      if dep.name == "lua" then
                         if not vers.match_constraints(lua_version, dep.constraints) then
                            table.insert(to_remove, version)
@@ -188,12 +191,12 @@ local function filter_by_lua_version(manifest, lua_version, repodir, cache)
                      end
                   end
                else
-                  util.printerr("Error loading rockspec for "..pkg.." "..version..": "..err)
+                  util.printerr("Error loading rockspec for " .. pkg .. " " .. version .. ": " .. err)
                end
             end
          end
       end
-      if next(to_remove) then
+      if next(to_remove) ~= nil then
          for _, incompat in ipairs(to_remove) do
             versions[incompat] = nil
          end
@@ -204,14 +207,12 @@ local function filter_by_lua_version(manifest, lua_version, repodir, cache)
    end
 end
 
---- Store search results in a manifest table.
--- @param results table: The search results as returned by search.disk_search.
--- @param manifest table: A manifest table (must contain repository, modules, commands tables).
--- It will be altered to include the search results.
--- @return boolean or (nil, string): true in case of success, or nil followed by an error message.
+
+
+
+
+
 local function store_results(results, manifest)
-   assert(type(results) == "table")
-   assert(type(manifest) == "table")
 
    for name, versions in pairs(results) do
       local pkgtable = manifest.repository[name] or {}
@@ -240,21 +241,19 @@ local function store_results(results, manifest)
    return true
 end
 
---- Commit a table to disk in given local path.
--- @param where string: The directory where the table should be saved.
--- @param name string: The filename.
--- @param tbl table: The table to be saved.
--- @return boolean or (nil, string): true if successful, or nil and a
--- message in case of errors.
+
+
+
+
+
+
 local function save_table(where, name, tbl)
-   assert(type(where) == "string")
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(tbl) == "table")
+   assert(not name:match("/"))
 
    local filename = dir.path(where, name)
-   local ok, err = persist.save_from_table(filename..".tmp", tbl)
+   local ok, err = persist.save_from_table(filename .. ".tmp", tbl)
    if ok then
-      ok, err = fs.replace_file(filename, filename..".tmp")
+      ok, err = fs.replace_file(filename, filename .. ".tmp")
    end
    return ok, err
 end
@@ -267,40 +266,44 @@ function writer.make_rock_manifest(name, version)
       local walk = tree
       local last
       local last_name
+      local next
       for filename in file:gmatch("[^\\/]+") do
-         local next = walk[filename]
+         next = walk[filename]
          if not next then
             next = {}
             walk[filename] = next
          end
          last = walk
          last_name = filename
-         walk = next
+         if not (type(next) == "string") then
+            walk = next
+         else
+            return nil, "Next was string, expected a table"
+         end
       end
       if fs.is_file(full_path) then
+
          local sum, err = fs.get_md5(full_path)
          if not sum then
-            return nil, "Failed producing checksum: "..tostring(err)
+            return nil, "Failed producing checksum: " .. tostring(err)
          end
          last[last_name] = sum
       end
    end
-   local rock_manifest = { rock_manifest=tree }
-   manif.rock_manifest_cache[name.."/"..version] = rock_manifest
-   save_table(install_dir, "rock_manifest", rock_manifest )
+   local rock_manifest = { rock_manifest = tree }
+   manif.rock_manifest_cache[name .. "/" .. version] = rock_manifest
+   save_table(install_dir, "rock_manifest", rock_manifest)
    return true
 end
 
--- Writes a 'rock_namespace' file in a locally installed rock directory.
--- @param name string: the rock name, without a namespace
--- @param version string: the rock version
--- @param namespace string?: the namespace
--- @return true if successful (or unnecessary, if there is no namespace),
--- or nil and an error message.
+
+
+
+
+
+
 function writer.make_namespace_file(name, version, namespace)
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(version) == "string")
-   assert(type(namespace) == "string" or not namespace)
+   assert(not name:match("/"))
    if not namespace then
       return true
    end
@@ -316,24 +319,22 @@ function writer.make_namespace_file(name, version, namespace)
    return true
 end
 
---- Scan a LuaRocks repository and output a manifest file.
--- A file called 'manifest' will be written in the root of the given
--- repository directory.
--- @param repo A local repository directory.
--- @param deps_mode string: Dependency mode: "one" for the current default tree,
--- "all" for all trees, "order" for all trees with priority >= the current default,
--- "none" for the default dependency mode from the configuration.
--- @param remote boolean: 'true' if making a manifest for a rocks server.
--- @return boolean or (nil, string): True if manifest was generated,
--- or nil and an error message.
+
+
+
+
+
+
+
+
+
+
 function writer.make_manifest(repo, deps_mode, remote)
-   assert(type(repo) == "string")
-   assert(type(deps_mode) == "string")
 
    if deps_mode == "none" then deps_mode = cfg.deps_mode end
 
    if not fs.is_dir(repo) then
-      return nil, "Cannot access repository at "..repo
+      return nil, "Cannot access repository at " .. repo
    end
 
    local query = queries.all("any")
@@ -349,10 +350,10 @@ function writer.make_manifest(repo, deps_mode, remote)
       local cache = {}
       for luaver in util.lua_versions() do
          local vmanifest = { repository = {}, modules = {}, commands = {} }
-         local ok, err = store_results(results, vmanifest)
+         ok, err = store_results(results, vmanifest)
          filter_by_lua_version(vmanifest, luaver, repo, cache)
          if not cfg.no_manifest then
-            save_table(repo, "manifest-"..luaver, vmanifest)
+            save_table(repo, "manifest-" .. luaver, vmanifest)
          end
       end
    else
@@ -360,43 +361,42 @@ function writer.make_manifest(repo, deps_mode, remote)
    end
 
    if cfg.no_manifest then
-      -- We want to have cache updated; but exit before save_table is called
+
       return true
    end
    return save_table(repo, "manifest", manifest)
 end
 
---- Update manifest file for a local repository
--- adding information about a version of a package installed in that repository.
--- @param name string: Name of a package from the repository.
--- @param version string: Version of a package from the repository.
--- @param repo string or nil: Pathname of a local repository. If not given,
--- the default local repository is used.
--- @param deps_mode string: Dependency mode: "one" for the current default tree,
--- "all" for all trees, "order" for all trees with priority >= the current default,
--- "none" for using the default dependency mode from the configuration.
--- @return boolean or (nil, string): True if manifest was updated successfully,
--- or nil and an error message.
+
+
+
+
+
+
+
+
+
+
+
 function writer.add_to_manifest(name, version, repo, deps_mode)
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(version) == "string")
+   assert(not name:match("/"))
    local rocks_dir = path.rocks_dir(repo or cfg.root_dir)
-   assert(type(deps_mode) == "string")
 
    if deps_mode == "none" then deps_mode = cfg.deps_mode end
 
    local manifest, err = manif.load_manifest(rocks_dir)
    if not manifest then
       util.printerr("No existing manifest. Attempting to rebuild...")
-      -- Manifest built by `writer.make_manifest` should already
-      -- include information about given name and version,
-      -- no need to update it.
+
+
+
       return writer.make_manifest(rocks_dir, deps_mode)
    end
 
-   local results = {[name] = {[version] = {{arch = "installed", repo = rocks_dir}}}}
+   local results = { [name] = { [version] = { { arch = "installed", repo = rocks_dir } } } }
 
-   local ok, err = store_results(results, manifest)
+   local ok
+   ok, err = store_results(results, manifest)
    if not ok then return nil, err end
 
    update_dependencies(manifest, deps_mode)
@@ -407,42 +407,40 @@ function writer.add_to_manifest(name, version, repo, deps_mode)
    return save_table(rocks_dir, "manifest", manifest)
 end
 
---- Update manifest file for a local repository
--- removing information about a version of a package.
--- @param name string: Name of a package removed from the repository.
--- @param version string: Version of a package removed from the repository.
--- @param repo string or nil: Pathname of a local repository. If not given,
--- the default local repository is used.
--- @param deps_mode string: Dependency mode: "one" for the current default tree,
--- "all" for all trees, "order" for all trees with priority >= the current default,
--- "none" for using the default dependency mode from the configuration.
--- @return boolean or (nil, string): True if manifest was updated successfully,
--- or nil and an error message.
+
+
+
+
+
+
+
+
+
+
+
 function writer.remove_from_manifest(name, version, repo, deps_mode)
-   assert(type(name) == "string" and not name:match("/"))
-   assert(type(version) == "string")
+   assert(not name:match("/"))
    local rocks_dir = path.rocks_dir(repo or cfg.root_dir)
-   assert(type(deps_mode) == "string")
 
    if deps_mode == "none" then deps_mode = cfg.deps_mode end
 
    local manifest, err = manif.load_manifest(rocks_dir)
    if not manifest then
       util.printerr("No existing manifest. Attempting to rebuild...")
-      -- Manifest built by `writer.make_manifest` should already
-      -- include up-to-date information, no need to update it.
+
+
       return writer.make_manifest(rocks_dir, deps_mode)
    end
 
    local package_entry = manifest.repository[name]
    if package_entry == nil or package_entry[version] == nil then
-      -- entry is already missing from repository, no need to do anything
+
       return true
    end
 
    local version_entry = package_entry[version][1]
    if not version_entry then
-      -- manifest looks corrupted, rebuild
+
       return writer.make_manifest(rocks_dir, deps_mode)
    end
 
@@ -453,7 +451,7 @@ function writer.remove_from_manifest(name, version, repo, deps_mode)
    manifest.dependencies[name][version] = nil
 
    if not next(package_entry) then
-      -- No more versions of this package.
+
       manifest.repository[name] = nil
       manifest.dependencies[name] = nil
    end
diff --git a/src/luarocks/manif/writer.tl b/src/luarocks/manif/writer.tl
index b803bff6..5af74e6a 100644
--- a/src/luarocks/manif/writer.tl
+++ b/src/luarocks/manif/writer.tl
@@ -60,7 +60,7 @@ end
 -- @param items table: a table mapping item names to paths.
 -- @param name string: package name.
 -- @param version string: package version.
-local function remove_package_items(storage: {string: {string}}, name: string, version: string, items: {string: {string}})
+local function remove_package_items(storage: {string: {string}}, name: string, version: string, items: {string: string})
    assert(not name:match("/"))
 
    local package_identifier = name.."/"..version
@@ -219,7 +219,7 @@ local function store_results(results: {string: {string: {Result}}}, manifest: Ma
       for version, entries in pairs(versions) do
          local versiontable = {}
          for _, entry in ipairs(entries) do
-            local entrytable: Manifest = {}
+            local entrytable: Manifest.Entry = {}
             entrytable.arch = entry.arch
             if entry.arch == "installed" then
                local rock_manifest, err = manif.load_rock_manifest(name, version)
diff --git a/src/luarocks/repos.lua b/src/luarocks/repos.lua
index 186bc1c1..c1d80fc8 100644
--- a/src/luarocks/repos.lua
+++ b/src/luarocks/repos.lua
@@ -78,8 +78,6 @@ function repos.is_installed(name, version)
 end
 
 function repos.recurse_rock_manifest_entry(entry, action)
-   assert(type(action) == "function")
-
    if entry == nil then
       return true
    end
diff --git a/src/luarocks/repos.tl b/src/luarocks/repos.tl
index e98ffedb..7b974221 100644
--- a/src/luarocks/repos.tl
+++ b/src/luarocks/repos.tl
@@ -78,8 +78,6 @@ function repos.is_installed(name: string, version: string): boolean
 end
 
 function repos.recurse_rock_manifest_entry(entry: Entry, action: (function(string): boolean, string)): boolean, string
-   assert(type(action) == "function")
-
    if entry == nil then
       return true
    end