core types definition

32 files changed, 1491 insertions, 242 deletions

diff --git a/src/luarocks/core/cfg.d.tl b/src/luarocks/core/cfg.d.tl
index 95d3aae7..bbb070f2 100644
--- a/src/luarocks/core/cfg.d.tl
+++ b/src/luarocks/core/cfg.d.tl
@@ -1,3 +1,9 @@
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
+local type Variables = rockspec.Variables
+local type tree = require("luarocks.core.types.tree")
+local type Tree = tree.Tree
+
 local record cfg
    detect_sysconfdir: function(): string
    make_platforms: function(system: string): {any: boolean}
@@ -18,136 +24,7 @@ local record cfg
    lib_extension: string
    local_cache: string
    only_sources_from: string
-   record Tree
-      root: string
-      rocks_dir: string
-      lua_dir: string
-      lib_dir: string
-   end
-   record Description
-      summary: string
-      detailed: string
-      homepage: string
-      issues_url: string
-      maintainer: string
-      license: string
-      labels: any --!
-   end
-
-   record Variables
-      HG: string
-      CVS: string
-      LUA: string
-      GPG: string
-      GIT: string
-      SVN: string
-      CURL: string
-      SSCM: string
-      PREFIX: string
-      LUADIR: string
-      LIBDIR: string
-      CONFDIR: string
-      BINDIR: string
-      DOCDIR: string
-      CURLNOCERTFLAG: string
-   end
-
-   record Source
-      url: string
-      module: string
-      pathname: string
-      tag: string
-      md5: string
-      file: string
-      dir: string
-      branch: string
-      cvs_tag: string
-      cvs_module: string
-      protocol: string --! not in the rockspec definition but used
-      dir_set: boolean
-      identifier: string
-      platforms: any --!
-   end
-
-   record Test
-      type: string
-      platforms: any --! {{string: any}}?
-   end
-
-   record Install
-      lua: any
-      lib: any
-      conf: any
-      bin: any
-   end
-
-   record Build
-      type: string
-      modules: string
-      copy_directories: string
-      platforms: any --!
-      install: Install
-   end
-
-   record Dependencie --!1 --? Query??
-      
-   end
 
-   record Dependencies
-      {Dependencie} --!1
-      platforms: any --!
-   end
-
-   record BuildDependencies
-      {Dependencie} --!1
-      platforms: any --!
-   end
-
-   record SupportedPlatforms
-   end
-
-   record ExternalDependencies
-      {Dependencie} --!1
-      platforms: any --!
-   end
-
-   record TestDependencies
-      {Dependencie} --!1
-      platforms: any --!
-   end
-
-   record Hooks
-      post_install: string
-      platforms: any --!
-   end
-
-   record Deploy
-      wrap_bin_scripts: boolean
-   end
-
-   record Rockspec
-      rockspec_format: string
-      name: string --! not in the rockspec definition but used
-      package: string
-      version: string
-      local_abs_filename: string
-      rocks_provided: {string : string}
-      source: Source
-      description: Description
-      build: Build
-      dependencies: Dependencies
-      build_dependencies: BuildDependencies
-      test_dependencies: TestDependencies
-      supported_platforms: SupportedPlatforms
-      external_dependencies: ExternalDependencies
-      variables: Variables
-      hooks: Hooks
-      test: Test
-      deploy: Deploy
-      type: function(Rockspec): string
-      format_is_at_least: function(Rockspec, string): boolean
-   end
-   
    record cache
       luajit_version_checked: boolean
       luajit_version: string
diff --git a/src/luarocks/core/manif.tl b/src/luarocks/core/manif.tl
index cfa53dd0..742e64b7 100644
--- a/src/luarocks/core/manif.tl
+++ b/src/luarocks/core/manif.tl
@@ -7,35 +7,20 @@ local util = require("luarocks.core.util")
 local vers = require("luarocks.core.vers")
 local path = require("luarocks.core.path")
 
-local type Constraint = vers.Constraint
+local type tree = require("luarocks.core.types.tree")
+local type Tree = tree.Tree
 
 --- Core functions for querying manifest files.
 local record manif
-   
-   record DependencyVersion
-      constraints: {Constraint}
-      name: string
-   end
-   
-   record Manifest
-      arch: string
-      commands: {string: {string}}
-      dependencies: {string: {string: {DependencyVersion}}}
-      modules: {string: {string}}
-      repository: {string: {string: Manifest}}
-   end
-   
-   record Tree_manifest
-      tree: cfg.Tree
-      manifest: Manifest
-   end
 end
 
 --------------------------------------------------------------------------------
- 
-local type DependencyVersion = manif.DependencyVersion
-local type Manifest = manif.Manifest
-local type Tree_manifest = manif.Tree_manifest
+local type query = require("luarocks.core.types.query")
+local type Query = query.Query
+
+local type manifest = require("luarocks.core.types.manifest")
+local type Manifest = manifest.Manifest
+local type Tree_manifest = manifest.Tree_manifest
 
 
 
@@ -98,7 +83,7 @@ end
 
 function manif.load_rocks_tree_manifests(deps_mode?: string): {Tree_manifest}
    local trees = {}
-   path.map_trees(deps_mode, function(tree: cfg.Tree)
+   path.map_trees(deps_mode, function(tree: Tree)
       local manifest= manif.fast_load_local_manifest(path.rocks_dir(tree))
       if manifest then
          table.insert(trees, {tree=tree, manifest=manifest})
@@ -116,7 +101,7 @@ function manif.scan_dependencies(name: string, version: string, tree_manifests:
    for _, tree in ipairs(tree_manifests) do
       local manifest = tree.manifest
 
-      local pkgdeps: {DependencyVersion}
+      local pkgdeps: {Query}
       if manifest.dependencies and manifest.dependencies[name] then
          pkgdeps = manifest.dependencies[name][version]
       end
diff --git a/src/luarocks/core/path.tl b/src/luarocks/core/path.tl
index 213c0d69..563a36ef 100644
--- a/src/luarocks/core/path.tl
+++ b/src/luarocks/core/path.tl
@@ -5,7 +5,8 @@ end
 local cfg = require("luarocks.core.cfg")
 local dir = require("luarocks.core.dir")
 
-local type Tree = cfg.Tree
+local type tree = require("luarocks.core.types.tree")
+local type Tree = tree.Tree
 
 local dir_sep = package.config:sub(1, 1)
 --------------------------------------------------------------------------------
diff --git a/src/luarocks/core/types/manifest.d.tl b/src/luarocks/core/types/manifest.d.tl
new file mode 100644
index 00000000..f24869b9
--- /dev/null
+++ b/src/luarocks/core/types/manifest.d.tl
@@ -0,0 +1,22 @@
+local type query = require("luarocks.core.types.query")
+local type Query = query.Query
+
+local type tree = require("luarocks.core.types.tree")
+local type Tree = tree.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
+
+ return manifest
\ No newline at end of file
diff --git a/src/luarocks/core/types/ordering.d.tl b/src/luarocks/core/types/ordering.d.tl
new file mode 100644
index 00000000..c16140f8
--- /dev/null
+++ b/src/luarocks/core/types/ordering.d.tl
@@ -0,0 +1,10 @@
+local record ordering
+    record Ordering<K>
+       is {K}
+       sub_orders: {K: Ordering<K>}
+    end
+ 
+    type SortBy<K> = table.SortFunction<K> | Ordering<K>
+ end
+
+ return ordering
\ No newline at end of file
diff --git a/src/luarocks/core/types/query.d.tl b/src/luarocks/core/types/query.d.tl
new file mode 100644
index 00000000..e1ef21b6
--- /dev/null
+++ b/src/luarocks/core/types/query.d.tl
@@ -0,0 +1,15 @@
+local type version = require("luarocks.core.types.version")
+local type Constraint = version.Constraint
+
+local record query
+    record Query
+        name: string
+        namespace: string
+        constraints: {Constraint}
+        substring: boolean
+        arch: {string: boolean}
+        type: function(): string
+     end
+end
+
+return query
\ No newline at end of file
diff --git a/src/luarocks/core/types/rockspec.d.tl b/src/luarocks/core/types/rockspec.d.tl
new file mode 100644
index 00000000..438391fa
--- /dev/null
+++ b/src/luarocks/core/types/rockspec.d.tl
@@ -0,0 +1,124 @@
+local type query = require("luarocks.core.types.query")
+local type Query = query.Query
+
+local record rockspec
+    record Description
+        summary: string
+        detailed: string
+        homepage: string
+        issues_url: string
+        maintainer: string
+        license: string
+        labels: any --!
+    end
+  
+    record Variables
+        HG: string
+        CVS: string
+        LUA: string
+        GPG: string
+        GIT: string
+        SVN: string
+        CURL: string
+        SSCM: string
+        PREFIX: string
+        LUADIR: string
+        LIBDIR: string
+        CONFDIR: string
+        BINDIR: string
+        DOCDIR: string
+        CURLNOCERTFLAG: string
+    end
+  
+    record Source
+        url: string
+        module: string
+        pathname: string
+        tag: string
+        md5: string
+        file: string
+        dir: string
+        branch: string
+        cvs_tag: string
+        cvs_module: string
+        protocol: string --! not in the rockspec definition but used
+        dir_set: boolean
+        identifier: string
+    end
+  
+    record Test
+        type: string
+    end
+  
+    record Install
+        lua: any
+        lib: any
+        conf: any
+        bin: any
+    end
+  
+    record Build
+        type: string
+        modules: string
+        copy_directories: string
+        install: Install
+    end
+  
+    record Dependencies
+        {string} 
+        -- when converted:
+        queries: {Query}
+    end
+  
+    record BuildDependencies
+        {string} 
+        queries: {Query}
+    end
+  
+    record SupportedPlatforms
+    end
+  
+    record ExternalDependencies
+        {string} 
+        queries: {Query}
+    end
+  
+    record TestDependencies
+        {string} 
+        queries: {Query}
+    end
+  
+    record Hooks
+        post_install: string
+        
+    end
+  
+    record Deploy
+        wrap_bin_scripts: boolean
+    end
+  
+    record Rockspec
+        rockspec_format: string
+        name: string --! not in the rockspec definition but used
+        package: string
+        version: string
+        local_abs_filename: string
+        rocks_provided: {string : string}
+        source: Source
+        description: Description
+        build: Build
+        dependencies: Dependencies
+        build_dependencies: BuildDependencies
+        test_dependencies: TestDependencies
+        supported_platforms: SupportedPlatforms
+        external_dependencies: ExternalDependencies
+        variables: Variables
+        hooks: Hooks
+        test: Test
+        deploy: Deploy
+        type: function(): string
+        format_is_at_least: function(Rockspec, string): boolean
+    end
+end
+
+return rockspec
\ No newline at end of file
diff --git a/src/luarocks/core/types/tree.d.tl b/src/luarocks/core/types/tree.d.tl
new file mode 100644
index 00000000..df54def9
--- /dev/null
+++ b/src/luarocks/core/types/tree.d.tl
@@ -0,0 +1,10 @@
+local record tree
+    record Tree
+        root: string
+        rocks_dir: string
+        lua_dir: string
+        lib_dir: string
+     end
+end
+
+return tree
\ No newline at end of file
diff --git a/src/luarocks/core/types/version.d.tl b/src/luarocks/core/types/version.d.tl
new file mode 100644
index 00000000..92a80996
--- /dev/null
+++ b/src/luarocks/core/types/version.d.tl
@@ -0,0 +1,18 @@
+local record version
+    record Version
+       is {number}
+       string: string
+       revision: number
+       metamethod __eq: function(Version, Version): boolean
+       metamethod __lt: function(Version, Version): boolean
+       metamethod __le: function(Version, Version): boolean
+    end
+ 
+    record Constraint
+       op: string
+       version: Version | string
+       no_upgrade: boolean
+    end
+ end
+ 
+ return version
\ No newline at end of file
diff --git a/src/luarocks/core/util.tl b/src/luarocks/core/util.tl
index 76d7b42e..ad6d8f9e 100644
--- a/src/luarocks/core/util.tl
+++ b/src/luarocks/core/util.tl
@@ -1,16 +1,13 @@
 
 local record util
-   record Ordering<K>
-      {K}
-      
-      sub_orders: {K: Ordering<K>}
-   end
-
-   type SortBy<K> = table.SortFunction<K> | util.Ordering<K>
 end
 
 --------------------------------------------------------------------------------
 
+local type ordering = require("luarocks.core.types.ordering")
+local type Ordering<K> = ordering.Ordering<K>
+local type SortBy<K> = ordering.SortBy<K>
+
 local dir_sep = package.config:sub(1, 1)
 
 --- Run a process and read a its output.
@@ -292,9 +289,9 @@ end
 -- for that key, which is returned by the iterator as the third value after the key
 -- and the value.
 -- @return function: the iterator function.
-function util.sortedpairs<K, V>(tbl: {K: V}, sort_by?: util.SortBy<K>): function(): K, V, util.Ordering<K>
+function util.sortedpairs<K, V>(tbl: {K: V}, sort_by?: SortBy<K>): function(): K, V, Ordering<K>
    local keys = util.keys(tbl)
-   local sub_orders: {K: util.Ordering<K>} = nil
+   local sub_orders: {K: Ordering<K>} = nil
 
    if sort_by == nil then
       table.sort(keys, default_sort)
@@ -328,7 +325,7 @@ function util.sortedpairs<K, V>(tbl: {K: V}, sort_by?: util.SortBy<K>): function
    end
    
    local i = 1
-   return function(): K, V, util.Ordering<K>
+   return function(): K, V, Ordering<K>
       local key = keys[i]
       i = i + 1
       return key, tbl[key], sub_orders and sub_orders[key]
diff --git a/src/luarocks/core/vers.tl b/src/luarocks/core/vers.tl
index eae6d3d5..ab1c6c5b 100644
--- a/src/luarocks/core/vers.tl
+++ b/src/luarocks/core/vers.tl
@@ -1,21 +1,10 @@
 local record vers
-   record Version
-      {number} -- next version of Teal: "is {number}"
-      string: string
-      revision: number
-      metamethod __eq: function(Version, Version): boolean
-      metamethod __lt: function(Version, Version): boolean
-      metamethod __le: function(Version, Version): boolean
-   end
-
-   record Constraint
-      op: string
-      version: Version | string
-      no_upgrade: boolean
-   end
 end
 
 local util = require("luarocks.core.util")
+local type version = require("luarocks.core.types.version")
+local type Version = version.Version
+local type Constraint = version.Constraint
 --------------------------------------------------------------------------------
 
 local deltas: {string: integer} = {
@@ -28,9 +17,6 @@ local deltas: {string: integer} = {
    alpha = -1000000
 }
 
-local type Version = vers.Version
-local type Constraint = vers.Constraint
-
 local version_mt: metatable<Version> = {
    --- Equality comparison for versions.
    -- All version numbers must be equal.
diff --git a/src/luarocks/deps.tl b/src/luarocks/deps.tl
new file mode 100644
index 00000000..8fe9feff
--- /dev/null
+++ b/src/luarocks/deps.tl
@@ -0,0 +1,836 @@
+
+--- High-level dependency related functions.
+local record deps
+end
+
+local cfg = require("luarocks.core.cfg")
+local manif = require("luarocks.manif")
+local path = require("luarocks.path")
+local dir = require("luarocks.dir")
+local fun = require("luarocks.fun")
+local util = require("luarocks.util")
+local vers = require("luarocks.core.vers")
+local queries = require("luarocks.queries")
+local deplocks = require("luarocks.deplocks")
+
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
+
+local type tree = require("luarocks.core.types.tree")
+local type Tree = tree.Tree
+
+local core = require("luarocks.core.manif")
+local type DependencyVersion = core.DependencyVersion
+local type version = require("luarocks.core.types.version")
+local type Version = version.Version
+
+--- Generate a function that matches dep queries against the manifest,
+-- taking into account rocks_provided, the list of versions to skip,
+-- and the lockfile.
+-- @param deps_mode "one", "none", "all" or "order"
+-- @param rocks_provided a one-level table mapping names to versions,
+-- listing rocks to consider provided by the VM
+-- @param rocks_provided table: A table of auto-provided dependencies.
+-- by this Lua implementation for the given dependency.
+-- @param depskey key to use when matching the lockfile ("dependencies",
+-- "build_dependencies", etc.)
+-- @param skip_set a two-level table mapping names to versions to
+-- boolean, listing rocks that should not be matched
+-- @return function(dep): {string}, {string:string}, string, boolean
+-- * array of matching versions
+-- * map of versions to locations
+-- * version matched via lockfile if any
+-- * true if rock matched via rocks_provided
+local function prepare_get_versions(deps_mode: string, rocks_provided: {string : string}, depskey: string, skip_set?): function(DependencyVersion): {string}, {string: string | Tree}, string, boolean
+
+   return function(dep: DependencyVersion): {string}, {string: string | Tree}, string, boolean
+      local versions, locations: {string}, {string: string | Tree}
+      local provided = rocks_provided[dep.name]
+      if provided then
+         -- Provided rocks have higher priority than manifest's rocks.
+         versions, locations = { provided }, {}
+      else
+         if deps_mode == "none" then
+            deps_mode = "one"
+         end
+         versions, locations = manif.get_versions(dep, deps_mode)
+      end
+
+      if skip_set and skip_set[dep.name] then
+         for i = #versions, 1, -1 do
+            local v = versions[i]
+            if skip_set[dep.name][v] then
+               table.remove(versions, i)
+            end
+         end
+      end
+
+      local lockversion = deplocks.get(depskey, dep.name) --! cast?
+
+      return versions, locations, lockversion, provided ~= nil
+   end
+end
+
+--- Attempt to match a dependency to an installed rock.
+-- @param get_versions a getter function obtained via prepare_get_versions
+-- @return (string, string, table) or (nil, nil, table):
+-- 1. latest installed version of the rock matching the dependency
+-- 2. location where the installed version is installed
+-- 3. the 'dep' query table
+-- 4. true if provided via VM
+-- or
+-- 1. nil
+-- 2. nil
+-- 3. either 'dep' or an alternative query to be used
+-- 4. false
+local function match_dep(dep: DependencyVersion, 
+   get_versions: function(DependencyVersion): {string}, {string: string | Tree}, string, boolean): string, string | Tree, DependencyVersion, boolean
+
+   local versions, locations, lockversion, provided = get_versions(dep)
+
+   local latest_version: Version
+   local latest_vstring: string
+   for _, vstring in ipairs(versions) do
+      local version = vers.parse_version(vstring)
+      if vers.match_constraints(version, dep.constraints) then
+         if not latest_version or version > latest_version then
+            latest_version = version
+            latest_vstring = vstring
+         end
+      end
+   end
+
+   if lockversion and not locations[lockversion] then
+      local latest_matching_msg = ""
+      if latest_vstring and latest_vstring ~= lockversion then
+         latest_matching_msg = " (latest matching is " .. latest_vstring .. ")"
+      end
+      util.printout("Forcing " .. dep.name .. " to pinned version " .. lockversion .. latest_matching_msg)
+      return nil, nil, queries.new(dep.name, dep.namespace, lockversion)
+   end
+
+   return latest_vstring, locations[latest_vstring], dep, provided
+end
+
+local function match_all_deps(dependencies: {DependencyVersion}, 
+   get_versions: function(DependencyVersion): {string}, {string: string | Tree}, string, boolean): {DependencyVersion: any}, {string}, {string}
+
+   local matched, missing, no_upgrade = {}, {}, {}
+
+   for _, dep in ipairs(dependencies) do
+      local found, _, provided: string, string | Tree, boolean
+      found, _, dep, provided = match_dep(dep, get_versions)
+      if found then
+         if not provided then
+            matched[dep] = {name = dep.name, version = found}
+         end
+      else
+         if dep.constraints[1] and dep.constraints[1].no_upgrade then
+            no_upgrade[dep.name] = dep
+         else
+            missing[dep.name] = dep
+         end
+      end
+   end
+   return matched, missing, no_upgrade
+end
+
+--- Attempt to match dependencies of a rockspec to installed rocks.
+-- @param dependencies table: The table of dependencies.
+-- @param rocks_provided table: The table of auto-provided dependencies.
+-- @param skip_set table or nil: Program versions to not use as valid matches.
+-- Table where keys are program names and values are tables where keys
+-- are program versions and values are 'true'.
+-- @param deps_mode string: Which trees to check dependencies for
+-- @return table, table, table: A table where keys are dependencies parsed
+-- in table format and values are tables containing fields 'name' and
+-- version' representing matches; a table of missing dependencies
+-- parsed as tables; and a table of "no-upgrade" missing dependencies
+-- (to be used in plugin modules so that a plugin does not force upgrade of
+-- its parent application).
+function deps.match_deps(dependencies, rocks_provided, skip_set, deps_mode)
+   assert(type(dependencies) == "table")
+   assert(type(rocks_provided) == "table")
+   assert(type(skip_set) == "table" or skip_set == nil)
+   assert(type(deps_mode) == "string")
+
+   local get_versions = prepare_get_versions(deps_mode, rocks_provided, "dependencies", skip_set)
+   return match_all_deps(dependencies, get_versions)
+end
+
+local function rock_status(dep, get_versions)
+   assert(dep:type() == "query")
+   assert(type(get_versions) == "function")
+
+   local installed, _, _, provided = match_dep(dep, get_versions)
+   local installation_type = provided and "provided by VM" or "installed"
+   return installed and installed.." "..installation_type..": success" or "not installed"
+end
+
+--- Check depenendencies of a package and report any missing ones.
+-- @param name string: package name.
+-- @param version string: package version.
+-- @param dependencies table: array of dependencies.
+-- @param deps_mode string: Which trees to check dependencies for
+-- @param rocks_provided table: A table of auto-dependencies provided
+-- by this Lua implementation for the given dependency.
+-- "one" for the current default tree, "all" for all trees,
+-- "order" for all trees with priority >= the current default, "none" for no trees.
+function deps.report_missing_dependencies(name, version, dependencies, deps_mode, rocks_provided)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(type(dependencies) == "table")
+   assert(type(deps_mode) == "string")
+   assert(type(rocks_provided) == "table")
+
+   if deps_mode == "none" then
+      return
+   end
+
+   local get_versions = prepare_get_versions(deps_mode, rocks_provided, "dependencies")
+
+   local first_missing_dep = true
+
+   for _, dep in ipairs(dependencies) do
+      local found, _
+      found, _, dep = match_dep(dep, get_versions)
+      if not found then
+         if first_missing_dep then
+            util.printout(("Missing dependencies for %s %s:"):format(name, version))
+            first_missing_dep = false
+         end
+
+         util.printout(("   %s (%s)"):format(tostring(dep), rock_status(dep, get_versions)))
+      end
+   end
+end
+
+function deps.fulfill_dependency(dep, deps_mode, rocks_provided, verify, depskey)
+   assert(dep:type() == "query")
+   assert(type(deps_mode) == "string" or deps_mode == nil)
+   assert(type(rocks_provided) == "table" or rocks_provided == nil)
+   assert(type(verify) == "boolean" or verify == nil)
+   assert(type(depskey) == "string")
+
+   deps_mode = deps_mode or "all"
+   rocks_provided = rocks_provided or {}
+
+   local get_versions = prepare_get_versions(deps_mode, rocks_provided, depskey)
+
+   local found, where
+   found, where, dep = match_dep(dep, get_versions)
+   if found then
+      local tree_manifests = manif.load_rocks_tree_manifests(deps_mode)
+      manif.scan_dependencies(dep.name, found, tree_manifests, deplocks.proxy(depskey))
+      return true, found, where
+   end
+
+   local search = require("luarocks.search")
+   local install = require("luarocks.cmd.install")
+
+   local url, search_err = search.find_suitable_rock(dep)
+   if not url then
+      return nil, "Could not satisfy dependency "..tostring(dep)..": "..search_err
+   end
+   util.printout("Installing "..url)
+   local install_args = {
+      rock = url,
+      deps_mode = deps_mode,
+      namespace = dep.namespace,
+      verify = verify,
+   }
+   local ok, install_err, errcode = install.command(install_args)
+   if not ok then
+      return nil, "Failed installing dependency: "..url.." - "..install_err, errcode
+   end
+
+   found, where = match_dep(dep, get_versions)
+   assert(found)
+   return true, found, where
+end
+
+local function check_supported_platforms(rockspec)
+   if rockspec.supported_platforms and next(rockspec.supported_platforms) then
+      local all_negative = true
+      local supported = false
+      for _, plat in pairs(rockspec.supported_platforms) do
+         local neg
+         neg, plat = plat:match("^(!?)(.*)")
+         if neg == "!" then
+            if cfg.is_platform(plat) then
+               return nil, "This rockspec for "..rockspec.package.." does not support "..plat.." platforms."
+            end
+         else
+            all_negative = false
+            if cfg.is_platform(plat) then
+               supported = true
+               break
+            end
+         end
+      end
+      if supported == false and not all_negative then
+         local plats = cfg.print_platforms()
+         return nil, "This rockspec for "..rockspec.package.." does not support "..plats.." platforms."
+      end
+   end
+
+   return true
+end
+
+--- Check dependencies of a rock and attempt to install any missing ones.
+-- Packages are installed using the LuaRocks "install" command.
+-- Aborts the program if a dependency could not be fulfilled.
+-- @param rockspec table: A rockspec in table format.
+-- @param depskey string: Rockspec key to fetch to get dependency table
+-- ("dependencies", "build_dependencies", etc.).
+-- @param deps_mode string
+-- @param verify boolean
+-- @param deplock_dir string: dirname of the deplock file
+-- @return boolean or (nil, string, [string]): True if no errors occurred, or
+-- nil and an error message if any test failed, followed by an optional
+-- error code.
+function deps.fulfill_dependencies(rockspec, depskey, deps_mode, verify, deplock_dir)
+   assert(type(rockspec) == "table")
+   assert(type(depskey) == "string")
+   assert(type(deps_mode) == "string")
+   assert(type(verify) == "boolean" or verify == nil)
+   assert(type(deplock_dir) == "string" or deplock_dir == nil)
+
+   local name = rockspec.name
+   local version = rockspec.version
+   local rocks_provided = rockspec.rocks_provided
+
+   local ok, filename, err = deplocks.load(name, deplock_dir or ".")
+   if filename then
+      util.printout("Using dependencies pinned in lockfile: " .. filename)
+
+      local get_versions = prepare_get_versions("none", rocks_provided, depskey)
+      for dnsname, dversion in deplocks.each(depskey) do
+         local dname, dnamespace = util.split_namespace(dnsname)
+         local dep = queries.new(dname, dnamespace, dversion)
+
+         util.printout(("%s %s is pinned to %s (%s)"):format(
+            name, version, tostring(dep), rock_status(dep, get_versions)))
+
+         local ok, err = deps.fulfill_dependency(dep, "none", rocks_provided, verify, depskey)
+         if not ok then
+            return nil, err
+         end
+      end
+      util.printout()
+      return true
+   elseif err then
+      util.warning(err)
+   end
+
+   ok, err = check_supported_platforms(rockspec)
+   if not ok then
+      return nil, err
+   end
+
+   deps.report_missing_dependencies(name, version, rockspec[depskey], deps_mode, rocks_provided)
+
+   util.printout()
+
+   local get_versions = prepare_get_versions(deps_mode, rocks_provided, depskey)
+   for _, dep in ipairs(rockspec[depskey]) do
+
+      util.printout(("%s %s depends on %s (%s)"):format(
+         name, version, tostring(dep), rock_status(dep, get_versions)))
+
+      local ok, found_or_err, _, no_upgrade = deps.fulfill_dependency(dep, deps_mode, rocks_provided, verify, depskey)
+      if ok then
+         deplocks.add(depskey, dep.name, found_or_err)
+      else
+         if no_upgrade then
+            util.printerr("This version of "..name.." is designed for use with")
+            util.printerr(tostring(dep)..", but is configured to avoid upgrading it")
+            util.printerr("automatically. Please upgrade "..dep.name.." with")
+            util.printerr("   luarocks install "..dep.name)
+            util.printerr("or look for a suitable version of "..name.." with")
+            util.printerr("   luarocks search "..name)
+         end
+         return nil, found_or_err
+      end
+   end
+
+   return true
+end
+
+--- If filename matches a pattern, return the capture.
+-- For example, given "libfoo.so" and "lib?.so" is a pattern,
+-- returns "foo" (which can then be used to build names
+-- based on other patterns.
+-- @param file string: a filename
+-- @param pattern string: a pattern, where ? is to be matched by the filename.
+-- @return string The pattern, if found, or nil.
+local function deconstruct_pattern(file, pattern)
+   local depattern = "^"..(pattern:gsub("%.", "%%."):gsub("%*", ".*"):gsub("?", "(.*)")).."$"
+   return (file:match(depattern))
+end
+
+--- Construct all possible patterns for a name and add to the files array.
+-- Run through the patterns array replacing all occurrences of "?"
+-- with the given file name and store them in the files array.
+-- @param file string A raw name (e.g. "foo")
+-- @param array of string An array of patterns with "?" as the wildcard
+-- (e.g. {"?.so", "lib?.so"})
+-- @param files The array of constructed names
+local function add_all_patterns(file, patterns, files)
+   for _, pattern in ipairs(patterns) do
+      table.insert(files, {#files + 1, (pattern:gsub("?", file))})
+   end
+end
+
+local function get_external_deps_dirs(mode)
+   local patterns = cfg.external_deps_patterns
+   local subdirs = cfg.external_deps_subdirs
+   if mode == "install" then
+      patterns = cfg.runtime_external_deps_patterns
+      subdirs = cfg.runtime_external_deps_subdirs
+   end
+   local dirs = {
+      BINDIR = { subdir = subdirs.bin, testfile = "program", pattern = patterns.bin },
+      INCDIR = { subdir = subdirs.include, testfile = "header", pattern = patterns.include },
+      LIBDIR = { subdir = subdirs.lib, testfile = "library", pattern = patterns.lib }
+   }
+   if mode == "install" then
+      dirs.INCDIR = nil
+   end
+   return dirs
+end
+
+local function resolve_prefix(prefix, dirs)
+   if type(prefix) == "string" then
+      return prefix
+   elseif type(prefix) == "table" then
+      if prefix.bin then
+         dirs.BINDIR.subdir = prefix.bin
+      end
+      if prefix.include then
+         if dirs.INCDIR then
+            dirs.INCDIR.subdir = prefix.include
+         end
+      end
+      if prefix.lib then
+         dirs.LIBDIR.subdir = prefix.lib
+      end
+      return prefix.prefix
+   end
+end
+
+local function add_patterns_for_file(files, file, patterns)
+   -- If it doesn't look like it contains a filename extension
+   if not (file:match("%.[a-z]+$") or file:match("%.[a-z]+%.")) then
+      add_all_patterns(file, patterns, files)
+   else
+      for _, pattern in ipairs(patterns) do
+         local matched = deconstruct_pattern(file, pattern)
+         if matched then
+            add_all_patterns(matched, patterns, files)
+         end
+      end
+      table.insert(files, {#files + 1, file})
+   end
+end
+
+local function check_external_dependency_at(prefix, name, ext_files, vars, dirs, err_files, cache)
+   local fs = require("luarocks.fs")
+   cache = cache or {}
+
+   for dirname, dirdata in util.sortedpairs(dirs) do
+      local paths
+      local path_var_value = vars[name.."_"..dirname]
+      if path_var_value then
+         paths = { path_var_value }
+      elseif type(dirdata.subdir) == "table" then
+         paths = {}
+         for i,v in ipairs(dirdata.subdir) do
+            paths[i] = dir.path(prefix, v)
+         end
+      else
+         paths = { dir.path(prefix, dirdata.subdir) }
+      end
+      local file_or_files = ext_files[dirdata.testfile]
+      if file_or_files then
+         local files = {}
+         if type(file_or_files) == "string" then
+            add_patterns_for_file(files, file_or_files, dirdata.pattern)
+         elseif type(file_or_files) == "table" then
+            for _, f in ipairs(file_or_files) do
+               add_patterns_for_file(files, f, dirdata.pattern)
+            end
+         end
+
+         local found = false
+         table.sort(files, function(a, b)
+            if (not a[2]:match("%*")) and b[2]:match("%*") then
+               return true
+            elseif a[2]:match("%*") and (not b[2]:match("%*")) then
+               return false
+            else
+               return a[1] < b[1]
+            end
+         end)
+         for _, fa in ipairs(files) do
+
+            local f = fa[2]
+            -- small convenience hack
+            if f:match("%.so$") or f:match("%.dylib$") or f:match("%.dll$") then
+               f = f:gsub("%.[^.]+$", "."..cfg.external_lib_extension)
+            end
+
+            local pattern
+            if f:match("%*") then
+               pattern = "^" .. f:gsub("([-.+])", "%%%1"):gsub("%*", ".*") .. "$"
+               f = "matching "..f
+            end
+
+            for _, d in ipairs(paths) do
+               if pattern then
+                  if not cache[d] then
+                     cache[d] = fs.list_dir(d)
+                  end
+                  local match = string.match
+                  for _, entry in ipairs(cache[d]) do
+                     if match(entry, pattern) then
+                        found = true
+                        break
+                     end
+                  end
+               else
+                  found = fs.is_file(dir.path(d, f))
+               end
+               if found then
+                  dirdata.dir = d
+                  dirdata.file = f
+                  break
+               else
+                  table.insert(err_files[dirdata.testfile], f.." in "..d)
+               end
+            end
+            if found then
+               break
+            end
+         end
+         if not found then
+            return nil, dirname, dirdata.testfile
+         end
+      else
+         -- When we have a set of subdir suffixes, look for one that exists.
+         -- For these reason, we now put "lib" ahead of "" on Windows in our
+         -- default set.
+         dirdata.dir = paths[1]
+         for _, p in ipairs(paths) do
+            if fs.exists(p) then
+               dirdata.dir = p
+               break
+            end
+         end
+      end
+   end
+
+   for dirname, dirdata in pairs(dirs) do
+      vars[name.."_"..dirname] = dirdata.dir
+      vars[name.."_"..dirname.."_FILE"] = dirdata.file
+   end
+   vars[name.."_DIR"] = prefix
+   return true
+end
+
+local function check_external_dependency(name, ext_files, vars, mode, cache)
+   local ok
+   local err_dirname
+   local err_testfile
+   local err_files = {program = {}, header = {}, library = {}}
+
+   local dirs = get_external_deps_dirs(mode)
+
+   local prefixes
+   if vars[name .. "_DIR"] then
+      prefixes = { vars[name .. "_DIR"] }
+   elseif vars.DEPS_DIR then
+      prefixes = { vars.DEPS_DIR }
+   else
+      prefixes = cfg.external_deps_dirs
+   end
+
+   for _, prefix in ipairs(prefixes) do
+      prefix = resolve_prefix(prefix, dirs)
+      if cfg.is_platform("mingw32") and name == "LUA" then
+         dirs.LIBDIR.pattern = fun.filter(util.deep_copy(dirs.LIBDIR.pattern), function(s)
+            return not s:match("%.a$")
+         end)
+      elseif cfg.is_platform("windows") and name == "LUA" then
+         dirs.LIBDIR.pattern = fun.filter(util.deep_copy(dirs.LIBDIR.pattern), function(s)
+            return not s:match("%.dll$")
+         end)
+      end
+      ok, err_dirname, err_testfile = check_external_dependency_at(prefix, name, ext_files, vars, dirs, err_files, cache)
+      if ok then
+         return true
+      end
+   end
+
+   return nil, err_dirname, err_testfile, err_files
+end
+
+function deps.autodetect_external_dependencies(build)
+   -- only applies to the 'builtin' build type
+   if not build or not build.modules then
+      return nil
+   end
+
+   local extdeps = {}
+   local any = false
+   for _, data in pairs(build.modules) do
+      if type(data) == "table" and data.libraries then
+         local libraries = data.libraries
+         if type(libraries) == "string" then
+            libraries = { libraries }
+         end
+         local incdirs = {}
+         local libdirs = {}
+         for _, lib in ipairs(libraries) do
+            local upper = lib:upper():gsub("%+", "P"):gsub("[^%w]", "_")
+            any = true
+            extdeps[upper] = { library = lib }
+            table.insert(incdirs, "$(" .. upper .. "_INCDIR)")
+            table.insert(libdirs, "$(" .. upper .. "_LIBDIR)")
+         end
+         if not data.incdirs then
+            data.incdirs = incdirs
+         end
+         if not data.libdirs then
+            data.libdirs = libdirs
+         end
+      end
+   end
+   return any and extdeps or nil
+end
+
+--- Set up path-related variables for external dependencies.
+-- For each key in the external_dependencies table in the
+-- rockspec file, four variables are created: <key>_DIR, <key>_BINDIR,
+-- <key>_INCDIR and <key>_LIBDIR. These are not overwritten
+-- if already set (e.g. by the LuaRocks config file or through the
+-- command-line). Values in the external_dependencies table
+-- are tables that may contain a "header" or a "library" field,
+-- with filenames to be tested for existence.
+-- @param rockspec table: The rockspec table.
+-- @param mode string: if "build" is given, checks all files;
+-- if "install" is given, do not scan for headers.
+-- @return boolean or (nil, string): True if no errors occurred, or
+-- nil and an error message if any test failed.
+function deps.check_external_deps(rockspec, mode)
+
+   if not rockspec.external_dependencies then
+      rockspec.external_dependencies = deps.autodetect_external_dependencies(rockspec.build)
+   end
+   if not rockspec.external_dependencies then
+      return true
+   end
+
+   for name, ext_files in util.sortedpairs(rockspec.external_dependencies) do
+      local ok, err_dirname, err_testfile, err_files = check_external_dependency(name, ext_files, rockspec.variables, mode)
+      if not ok then
+         local lines = {"Could not find "..err_testfile.." file for "..name}
+
+         local err_paths = {}
+         for _, err_file in ipairs(err_files[err_testfile]) do
+            if not err_paths[err_file] then
+               err_paths[err_file] = true
+               table.insert(lines, "  No file "..err_file)
+            end
+         end
+
+         table.insert(lines, "You may have to install "..name.." in your system and/or pass "..name.."_DIR or "..name.."_"..err_dirname.." to the luarocks command.")
+         table.insert(lines, "Example: luarocks install "..rockspec.name.." "..name.."_DIR=/usr/local")
+
+         return nil, table.concat(lines, "\n"), "dependency"
+      end
+   end
+   return true
+end
+
+--- Recursively add satisfied dependencies of a package to a table,
+-- to build a transitive closure of all dependent packages.
+-- Additionally ensures that `dependencies` table of the manifest is up-to-date.
+-- @param results table: The results table being built, maps package names to versions.
+-- @param mdeps table: The manifest dependencies table.
+-- @param name string: Package name.
+-- @param version string: Package version.
+function deps.scan_deps(results, mdeps, name, version, deps_mode)
+   assert(type(results) == "table")
+   assert(type(mdeps) == "table")
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+
+   local fetch = require("luarocks.fetch")
+
+   if results[name] then
+      return
+   end
+   if not mdeps[name] then mdeps[name] = {} end
+   local mdn = mdeps[name]
+   local dependencies = mdn[version]
+   local rocks_provided
+   if not dependencies then
+      local rockspec, err = fetch.load_local_rockspec(path.rockspec_file(name, version), false)
+      if not rockspec then
+         return
+      end
+      dependencies = rockspec.dependencies
+      rocks_provided = rockspec.rocks_provided
+      mdn[version] = dependencies
+   else
+      rocks_provided = util.get_rocks_provided()
+   end
+
+   local get_versions = prepare_get_versions(deps_mode, rocks_provided, "dependencies")
+
+   local matched = match_all_deps(dependencies, get_versions)
+   results[name] = version
+   for _, match in pairs(matched) do
+      deps.scan_deps(results, mdeps, match.name, match.version, deps_mode)
+   end
+end
+
+local function lua_h_exists(d, luaver)
+   local major, minor = luaver:match("(%d+)%.(%d+)")
+   local luanum = ("%s%02d"):format(major, tonumber(minor))
+
+   local lua_h = dir.path(d, "lua.h")
+   local fd = io.open(lua_h)
+   if fd then
+      local data = fd:read("*a")
+      fd:close()
+      if data:match("LUA_VERSION_NUM%s*" .. tostring(luanum)) then
+         return d
+      end
+      return nil, "Lua header lua.h found at " .. d .. " does not match Lua version " .. luaver .. ". You can use `luarocks config variables.LUA_INCDIR <path>` to set the correct location.", "dependency", 2
+   end
+
+   return nil, "Failed finding Lua header lua.h (searched at " .. d .. "). You may need to install Lua development headers. You can use `luarocks config variables.LUA_INCDIR <path>` to set the correct location.", "dependency", 1
+end
+
+local function find_lua_incdir(prefix, luaver, luajitver)
+   luajitver = luajitver and luajitver:gsub("%-.*", "")
+   local shortv = luaver:gsub("%.", "")
+   local incdirs = {
+      prefix .. "/include/lua/" .. luaver,
+      prefix .. "/include/lua" .. luaver,
+      prefix .. "/include/lua-" .. luaver,
+      prefix .. "/include/lua" .. shortv,
+      prefix .. "/include",
+      prefix,
+      luajitver and (prefix .. "/include/luajit-" .. (luajitver:match("^(%d+%.%d+)") or "")),
+   }
+   local errprio = 0
+   local mainerr
+   for _, d in ipairs(incdirs) do
+      local ok, err, _, prio = lua_h_exists(d, luaver)
+      if ok then
+         return d
+      end
+      if prio > errprio then
+         mainerr = err
+         errprio = prio
+      end
+   end
+
+   -- not found, will fallback to a default
+   return nil, mainerr
+end
+
+function deps.check_lua_incdir(vars)
+   if vars.LUA_INCDIR_OK == true
+      then return true
+   end
+
+   local ljv = util.get_luajit_version()
+
+   if vars.LUA_INCDIR then
+      local ok, err = lua_h_exists(vars.LUA_INCDIR, cfg.lua_version)
+      if ok then
+         vars.LUA_INCDIR_OK = true
+      end
+      return ok, err
+   end
+
+   if vars.LUA_DIR then
+      local d, err = find_lua_incdir(vars.LUA_DIR, cfg.lua_version, ljv)
+      if d then
+         vars.LUA_INCDIR = d
+         vars.LUA_INCDIR_OK = true
+         return true
+      end
+      return nil, err
+   end
+
+   return nil, "Failed finding Lua headers; neither LUA_DIR or LUA_INCDIR are set. You may need to install them or configure LUA_INCDIR.", "dependency"
+end
+
+function deps.check_lua_libdir(vars)
+   if vars.LUA_LIBDIR_OK == true
+      then return true
+   end
+
+   local fs = require("luarocks.fs")
+   local ljv = util.get_luajit_version()
+
+   if vars.LUA_LIBDIR and vars.LUALIB and fs.exists(dir.path(vars.LUA_LIBDIR, vars.LUALIB)) then
+      vars.LUA_LIBDIR_OK = true
+      return true
+   end
+
+   local shortv = cfg.lua_version:gsub("%.", "")
+   local libnames = {
+      "lua" .. cfg.lua_version,
+      "lua" .. shortv,
+      "lua-" .. cfg.lua_version,
+      "lua-" .. shortv,
+      "lua",
+   }
+   if ljv then
+      table.insert(libnames, 1, "luajit-" .. cfg.lua_version)
+      table.insert(libnames, 2, "luajit")
+   end
+   local cache = {}
+   local save_LUA_INCDIR = vars.LUA_INCDIR
+   local ok, _, _, errfiles = check_external_dependency("LUA", { library = libnames }, vars, "build", cache)
+   vars.LUA_INCDIR = save_LUA_INCDIR
+   local err
+   if ok then
+      local filename = dir.path(vars.LUA_LIBDIR, vars.LUA_LIBDIR_FILE)
+      local fd = io.open(filename, "r")
+      if fd then
+         if not vars.LUA_LIBDIR_FILE:match((cfg.lua_version:gsub("%.", "%%.?"))) then
+            -- if filename isn't versioned, check file contents
+            local txt = fd:read("*a")
+            ok = txt:match("Lua " .. cfg.lua_version, 1, true)
+                 or txt:match("lua" .. (cfg.lua_version:gsub("%.", "")), 1, true)
+            if not ok then
+               err = "Lua library at " .. filename .. " does not match Lua version " .. cfg.lua_version .. ". You can use `luarocks config variables.LUA_LIBDIR <path>` to set the correct location."
+            end
+         end
+
+         fd:close()
+      end
+   end
+
+   if ok then
+      vars.LUALIB = vars.LUA_LIBDIR_FILE
+      vars.LUA_LIBDIR_OK = true
+      return true
+   else
+      err = err or "Failed finding the Lua library. You can use `luarocks config variables.LUA_LIBDIR <path>` to set the correct location."
+      return nil, err, "dependency", errfiles
+   end
+end
+
+function deps.get_deps_mode(args)
+   return args.deps_mode or cfg.deps_mode
+end
+
+return deps
diff --git a/src/luarocks/fetch.tl b/src/luarocks/fetch.tl
index 6434edac..4c126575 100644
--- a/src/luarocks/fetch.tl
+++ b/src/luarocks/fetch.tl
@@ -13,7 +13,8 @@ local util = require("luarocks.util")
 local cfg = require("luarocks.core.cfg")
 
 local type Lock = fs.Lock --!
-local type Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 
 
 local function ensure_trailing_slash(url: string): string
@@ -517,7 +518,6 @@ end
 -- the fetched source tarball and the temporary directory created to
 -- store it; or nil and an error message and optional error code.
 function fetch.get_sources(rockspec: Rockspec, extract: boolean, dest_dir?: string): string, string, string
-   -- assert(rockspec:type() == "rockspec") --!
 
    local url = rockspec.source.url
    local name = rockspec.name.."-"..rockspec.version
@@ -563,7 +563,6 @@ end
 -- the fetched source tarball and the temporary directory created to
 -- store it; or nil and an error message.
 function fetch.fetch_sources(rockspec: Rockspec, extract: string, dest_dir?: string): string, string, string, string, string
-   assert(rockspec:type() == "rockspec") --!
 
    -- auto-convert git://github.com URLs to use git+https
    -- see https://github.blog/2021-09-01-improving-git-protocol-security-github/
diff --git a/src/luarocks/fetch/cvs.tl b/src/luarocks/fetch/cvs.tl
index 60f55957..f40d0991 100644
--- a/src/luarocks/fetch/cvs.tl
+++ b/src/luarocks/fetch/cvs.tl
@@ -6,9 +6,9 @@ end
 local fs = require("luarocks.fs")
 local dir = require("luarocks.dir")
 local util = require("luarocks.util")
-local cfg = require("luarocks.core.cfg") --! import for Rockspec
 
-local type Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 
 --- Download sources for building a rock, using CVS.
 -- @param rockspec table: The rockspec table
diff --git a/src/luarocks/fetch/git.tl b/src/luarocks/fetch/git.tl
index f9eed558..1a4438c9 100644
--- a/src/luarocks/fetch/git.tl
+++ b/src/luarocks/fetch/git.tl
@@ -8,10 +8,11 @@ local fs = require("luarocks.fs")
 local dir = require("luarocks.dir")
 local vers = require("luarocks.core.vers")
 local util = require("luarocks.util")
-local cfg = require("luarocks.core.cfg") --!
 
-local type Rockspec = cfg.Rockspec
-local type Version = vers.Version
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
+local type version = require("luarocks.core.types.version")
+local type Version = version.Version
 
 local cached_git_version: Version
 
diff --git a/src/luarocks/fetch/git_file.tl b/src/luarocks/fetch/git_file.tl
index cd2f3405..858e67a3 100644
--- a/src/luarocks/fetch/git_file.tl
+++ b/src/luarocks/fetch/git_file.tl
@@ -4,9 +4,9 @@ local record git_file
 end
 
 local git = require("luarocks.fetch.git")
-local cfg = require("luarocks.core.cfg") --!
 
-local type Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 
 --- Fetch sources for building a rock from a local Git repository.
 -- @param rockspec table: The rockspec table
diff --git a/src/luarocks/fetch/git_http.tl b/src/luarocks/fetch/git_http.tl
index b0164c1b..a7b3d692 100644
--- a/src/luarocks/fetch/git_http.tl
+++ b/src/luarocks/fetch/git_http.tl
@@ -11,9 +11,9 @@ local record git_http
 end
 
 local git = require("luarocks.fetch.git")
-local cfg = require("luarocks.core.cfg") --!
 
-local type Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 
 --- Fetch sources for building a rock from a local Git repository.
 -- @param rockspec table: The rockspec table
diff --git a/src/luarocks/fetch/git_ssh.tl b/src/luarocks/fetch/git_ssh.tl
index 7cb68be3..65954353 100644
--- a/src/luarocks/fetch/git_ssh.tl
+++ b/src/luarocks/fetch/git_ssh.tl
@@ -11,9 +11,9 @@ local record git_ssh
 end
 
 local git = require("luarocks.fetch.git")
-local cfg = require("luarocks.core.cfg") --!
 
-local type Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 
 --- Fetch sources for building a rock from a local Git repository.
 -- @param rockspec table: The rockspec table
diff --git a/src/luarocks/fetch/hg.tl b/src/luarocks/fetch/hg.tl
index 1acc2bea..0fbf5601 100644
--- a/src/luarocks/fetch/hg.tl
+++ b/src/luarocks/fetch/hg.tl
@@ -6,9 +6,9 @@ end
 local fs = require("luarocks.fs")
 local dir = require("luarocks.dir")
 local util = require("luarocks.util")
-local cfg = require("luarocks.core.cfg") --!
 
-local type Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 
 --- Download sources for building a rock, using hg.
 -- @param rockspec table: The rockspec table
diff --git a/src/luarocks/fetch/hg_http.tl b/src/luarocks/fetch/hg_http.tl
index b51bc1e9..f526d2d5 100644
--- a/src/luarocks/fetch/hg_http.tl
+++ b/src/luarocks/fetch/hg_http.tl
@@ -9,9 +9,9 @@ local record hg_http
 end
 
 local hg = require("luarocks.fetch.hg")
-local cfg = require("luarocks.core.cfg") --!
 
-local type Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 
 --- Download sources for building a rock, using hg over http.
 -- @param rockspec table: The rockspec table
diff --git a/src/luarocks/fetch/sscm.tl b/src/luarocks/fetch/sscm.tl
index f708267c..ad5a615e 100644
--- a/src/luarocks/fetch/sscm.tl
+++ b/src/luarocks/fetch/sscm.tl
@@ -5,9 +5,9 @@ end
 
 local fs = require("luarocks.fs")
 local dir = require("luarocks.dir")
-local cfg = require("luarocks.core.cfg") --!
 
-local Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 
 --- Download sources via Surround SCM Server for building a rock.
 -- @param rockspec table: The rockspec table
@@ -17,8 +17,6 @@ local Rockspec = cfg.Rockspec
 -- the fetched source tarball and the temporary directory created to
 -- store it; or nil and an error message.
 function sscm.get_sources(rockspec: Rockspec, extract: boolean, dest_dir?: string): string, string
-   assert(rockspec:type() == "rockspec")
-   assert(type(dest_dir) == "string" or not dest_dir)
 
    local sscm_cmd = rockspec.variables.SSCM
    local module = rockspec.source.module or dir.base_name(rockspec.source.url)
diff --git a/src/luarocks/fetch/svn.tl b/src/luarocks/fetch/svn.tl
index 43355e63..df3cdde9 100644
--- a/src/luarocks/fetch/svn.tl
+++ b/src/luarocks/fetch/svn.tl
@@ -6,9 +6,9 @@ end
 local fs = require("luarocks.fs")
 local dir = require("luarocks.dir")
 local util = require("luarocks.util")
-local cfg = require("luarocks.core.cfg") --!
 
-local Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 
 --- Download sources for building a rock, using Subversion.
 -- @param rockspec table: The rockspec table
@@ -18,8 +18,6 @@ local Rockspec = cfg.Rockspec
 -- the fetched source tarball and the temporary directory created to
 -- store it; or nil and an error message.
 function svn.get_sources(rockspec: Rockspec, extract: boolean, dest_dir?: string): string, string
-   assert(rockspec:type() == "rockspec")
-   assert(type(dest_dir) == "string" or not dest_dir)
 
    local svn_cmd = rockspec.variables.SVN
    local ok, err_msg = fs.is_tool_available(svn_cmd, "Subversion")
diff --git a/src/luarocks/loader.tl b/src/luarocks/loader.tl
new file mode 100644
index 00000000..896b7ce1
--- /dev/null
+++ b/src/luarocks/loader.tl
@@ -0,0 +1,270 @@
+--- A module which installs a Lua package loader that is LuaRocks-aware.
+-- This loader uses dependency information from the LuaRocks tree to load
+-- correct versions of modules. It does this by constructing a "context"
+-- table in the environment, which records which versions of packages were
+-- used to load previous modules, so that the loader chooses versions
+-- that are declared to be compatible with the ones loaded earlier.
+
+-- luacheck: globals luarocks
+
+local loaders = package.loaders or package.searchers
+local require, ipairs, table, type, next, tostring, error =
+      require, ipairs, table, type, next, tostring, error
+local unpack = unpack or table.unpack
+
+local record loader
+end
+
+local is_clean = not package.loaded["luarocks.core.cfg"]
+
+-- This loader module depends only on core modules.
+local cfg = require("luarocks.core.cfg")
+local cfg_ok, err = cfg.init()
+if cfg_ok then
+   cfg.init_package_paths()
+end
+
+local path = require("luarocks.core.path")
+local manif = require("luarocks.core.manif")
+local vers = require("luarocks.core.vers")
+local require = nil  -- luacheck: ignore 411
+--------------------------------------------------------------------------------
+
+-- Workaround for wrappers produced by older versions of LuaRocks
+local temporary_global = false
+local status, luarocks_value = pcall(function() return luarocks end)
+if status and luarocks_value then
+   -- The site_config.lua file generated by old versions uses module(),
+   -- so it produces a global `luarocks` table. Since we have the table,
+   -- add the `loader` field to make the old wrappers happy.
+   luarocks.loader = loader
+else
+   -- When a new version is installed on top of an old version,
+   -- site_config.lua may be replaced, and then it no longer creates
+   -- a global.
+   -- Detect when being called via -lluarocks.loader; this is
+   -- most likely a wrapper.
+   local info = debug and debug.getinfo(2, "nS")
+   if info and info.what == "C" and not info.name then
+      luarocks = { loader = loader }
+      temporary_global = true
+      -- For the other half of this hack,
+      -- see the next use of `temporary_global` below.
+   end
+end
+
+loader.context = {}
+
+--- Process the dependencies of a package to determine its dependency
+-- chain for loading modules.
+-- @param name string: The name of an installed rock.
+-- @param version string: The version of the rock, in string format
+function loader.add_context(name, version)
+   -- assert(type(name) == "string")
+   -- assert(type(version) == "string")
+
+   if temporary_global then
+      -- The first thing a wrapper does is to call add_context.
+      -- From here on, it's safe to clean the global environment.
+      luarocks = nil
+      temporary_global = false
+   end
+
+   local tree_manifests = manif.load_rocks_tree_manifests()
+   if not tree_manifests then
+      return nil
+   end
+
+   return manif.scan_dependencies(name, version, tree_manifests, loader.context)
+end
+
+--- Internal sorting function.
+-- @param a table: A provider table.
+-- @param b table: Another provider table.
+-- @return boolean: True if the version of a is greater than that of b.
+local function sort_versions(a,b)
+   return a.version > b.version
+end
+
+--- Request module to be loaded through other loaders,
+-- once the proper name of the module has been determined.
+-- For example, in case the module "socket.core" has been requested
+-- to the LuaRocks loader and it determined based on context that
+-- the version 2.0.2 needs to be loaded and it is not the current
+-- version, the module requested for the other loaders will be
+-- "socket.core_2_0_2".
+-- @param module The module name requested by the user, such as "socket.core"
+-- @param name The rock name, such as "luasocket"
+-- @param version The rock version, such as "2.0.2-1"
+-- @param module_name The actual module name, such as "socket.core" or "socket.core_2_0_2".
+-- @return table or (nil, string): The module table as returned by some other loader,
+-- or nil followed by an error message if no other loader managed to load the module.
+local function call_other_loaders(module, name, version, module_name)
+   for _, a_loader in ipairs(loaders) do
+      if a_loader ~= loader.luarocks_loader then
+         local results = { a_loader(module_name) }
+         if type(results[1]) == "function" then
+            return unpack(results)
+         end
+      end
+   end
+   return "Failed loading module "..module.." in LuaRocks rock "..name.." "..version
+end
+
+local function add_providers(providers, entries, tree, module, filter_file_name)
+   for i, entry in ipairs(entries) do
+      local name, version = entry:match("^([^/]*)/(.*)$")
+      local file_name = tree.manifest.repository[name][version][1].modules[module]
+      if type(file_name) ~= "string" then
+         error("Invalid data in manifest file for module "..tostring(module).." (invalid data for "..tostring(name).." "..tostring(version)..")")
+      end
+      file_name = filter_file_name(file_name, name, version, tree.tree, i)
+      if loader.context[name] == version then
+         return name, version, file_name
+      end
+      version = vers.parse_version(version)
+      table.insert(providers, {name = name, version = version, module_name = file_name, tree = tree})
+   end
+end
+
+--- Search for a module in the rocks trees
+-- @param module string: module name (eg. "socket.core")
+-- @param filter_file_name function(string, string, string, string, number):
+-- a function that takes the module file name (eg "socket/core.so"), the rock name
+-- (eg "luasocket"), the version (eg "2.0.2-1"), the path of the rocks tree
+-- (eg "/usr/local"), and the numeric index of the matching entry, so the
+-- filter function can know if the matching module was the first entry or not.
+-- @return string, string, string, (string or table):
+-- * name of the rock containing the module (eg. "luasocket")
+-- * version of the rock (eg. "2.0.2-1")
+-- * return value of filter_file_name
+-- * tree of the module (string or table in `tree_manifests` format)
+local function select_module(module, filter_file_name)
+   --assert(type(module) == "string")
+   --assert(type(filter_module_name) == "function")
+
+   local tree_manifests = manif.load_rocks_tree_manifests()
+   if not tree_manifests then
+      return nil
+   end
+
+   local providers = {}
+   local initmodule
+   for _, tree in ipairs(tree_manifests) do
+      local entries = tree.manifest.modules[module]
+      if entries then
+         local n, v, f = add_providers(providers, entries, tree, module, filter_file_name)
+         if n then
+            return n, v, f
+         end
+      else
+         initmodule = initmodule or module .. ".init"
+         entries = tree.manifest.modules[initmodule]
+         if entries then
+            local n, v, f = add_providers(providers, entries, tree, initmodule, filter_file_name)
+            if n then
+               return n, v, f
+            end
+         end
+      end
+   end
+
+   if next(providers) then
+      table.sort(providers, sort_versions)
+      local first = providers[1]
+      return first.name, first.version.string, first.module_name, first.tree
+   end
+end
+
+--- Search for a module
+-- @param module string: module name (eg. "socket.core")
+-- @return string, string, string, (string or table):
+-- * name of the rock containing the module (eg. "luasocket")
+-- * version of the rock (eg. "2.0.2-1")
+-- * name of the module (eg. "socket.core", or "socket.core_2_0_2" if file is stored versioned).
+-- * tree of the module (string or table in `tree_manifests` format)
+local function pick_module(module)
+   return
+      select_module(module, function(file_name, name, version, tree, i)
+         if i > 1 then
+            file_name = path.versioned_name(file_name, "", name, version)
+         end
+         return path.path_to_module(file_name)
+      end)
+end
+
+--- Return the pathname of the file that would be loaded for a module.
+-- @param module string: module name (eg. "socket.core")
+-- @param where string: places to look for the module. If `where` contains
+-- "l", it will search using the LuaRocks loader; if it contains "p",
+-- it will look in the filesystem using package.path and package.cpath.
+-- You can use both at the same time.
+-- @return If successful, it will return four values.
+-- * If found using the LuaRocks loader, it will return:
+--   * filename of the module (eg. "/usr/local/lib/lua/5.1/socket/core.so"),
+--   * rock name
+--   * rock version
+--   * "l" to indicate the match comes from the loader.
+-- * If found scanning package.path and package.cpath, it will return:
+--   * filename of the module (eg. "/usr/local/lib/lua/5.1/socket/core.so"),
+--   * "path" or "cpath"
+--   * nil
+--   * "p" to indicate the match comes from scanning package.path and cpath.
+-- If unsuccessful, nothing is returned.
+function loader.which(module, where)
+   where = where or "l"
+   if where:match("l") then
+      local rock_name, rock_version, file_name = select_module(module, path.which_i)
+      if rock_name then
+         local fd = io.open(file_name)
+         if fd then
+            fd:close()
+            return file_name, rock_name, rock_version, "l"
+         end
+      end
+   end
+   if where:match("p") then
+      local modpath = module:gsub("%.", "/")
+      for _, v in ipairs({"path", "cpath"}) do
+         for p in package[v]:gmatch("([^;]+)") do
+            local file_name = p:gsub("%?", modpath)  -- luacheck: ignore 421
+            local fd = io.open(file_name)
+            if fd then
+               fd:close()
+               return file_name, v, nil, "p"
+            end
+         end
+      end
+   end
+end
+
+--- Package loader for LuaRocks support.
+-- A module is searched in installed rocks that match the
+-- current LuaRocks context. If module is not part of the
+-- context, or if a context has not yet been set, the module
+-- in the package with the highest version is used.
+-- @param module string: The module name, like in plain require().
+-- @return table: The module table (typically), like in plain
+-- require(). See <a href="http://www.lua.org/manual/5.1/manual.html#pdf-require">require()</a>
+-- in the Lua reference manual for details.
+function loader.luarocks_loader(module)
+   local name, version, module_name = pick_module(module)
+   if not name then
+      return "No LuaRocks module found for "..module
+   else
+      loader.add_context(name, version)
+      return call_other_loaders(module, name, version, module_name)
+   end
+end
+
+table.insert(loaders, 1, loader.luarocks_loader)
+
+if is_clean then
+   for modname, _ in pairs(package.loaded) do
+      if modname:match("^luarocks%.") then
+         package.loaded[modname] = nil
+      end
+   end
+end
+
+return loader
diff --git a/src/luarocks/manif.tl b/src/luarocks/manif.tl
index a7949932..f0f838b8 100644
--- a/src/luarocks/manif.tl
+++ b/src/luarocks/manif.tl
@@ -19,9 +19,11 @@ local util = require("luarocks.util")
 local queries = require("luarocks.queries")
 local type_manifest = require("luarocks.type.manifest")
 
+local type tree = require("luarocks.core.types.tree")
+local type Tree = tree.Tree
 local type Manifest = core.Manifest
 local type Tree_manifest = core.Tree_manifest
-local type Tree = cfg.Tree
+local type DependencyVersion = core.DependencyVersion --!
 
 manif.cache_manifest = core.cache_manifest
 manif.load_rocks_tree_manifests = core.load_rocks_tree_manifests
@@ -190,14 +192,13 @@ end
 -- or "all", to use all trees.
 -- @return table: An array of strings listing installed
 -- versions of a package, and a table indicating where they are found.
-function manif.get_versions(dep, deps_mode: string): {string}, {string: string | Tree}
-   -- assert(type(dep) == "table") --!
+function manif.get_versions(dep: DependencyVersion, deps_mode: string): {string}, {string: string | Tree}
 
    local name: string = dep.name
    local namespace: string = dep.namespace
 
    local version_set = {}
-   path.map_trees(deps_mode, function(tree)
+   path.map_trees(deps_mode, function(tree: string | Tree)
       local manifest = manif.load_manifest(path.rocks_dir(tree))
 
       if manifest and manifest.repository[name] then
diff --git a/src/luarocks/path.tl b/src/luarocks/path.tl
index f350f80c..1dc77e86 100644
--- a/src/luarocks/path.tl
+++ b/src/luarocks/path.tl
@@ -8,7 +8,8 @@ local core = require("luarocks.core.path")
 local dir = require("luarocks.dir")
 local util = require("luarocks.core.util")
 
-local type Tree = cfg.Tree
+local type tree = require("luarocks.core.types.tree")
+local type Tree = tree.Tree
 
 local record path
    rocks_dir: function(string | Tree): string
diff --git a/src/luarocks/queries.tl b/src/luarocks/queries.tl
index 749cafe9..dec57585 100644
--- a/src/luarocks/queries.tl
+++ b/src/luarocks/queries.tl
@@ -1,31 +1,27 @@
 
 local record queries
-   record Query
-      name: string
-      namespace: string
-      constraints: {vers.Constraint}
-      substring: boolean
-      arch: {string: boolean}
-   end
 end
 
 local vers = require("luarocks.core.vers")
 local util = require("luarocks.util")
 local cfg = require("luarocks.core.cfg")
 
-local type Query = queries.Query
-local type Constraint = vers.Constraint
+local type query = require("luarocks.core.types.query")
+local type version = require("luarocks.core.types.version")
+local type Query = query.Query
+local type Version = version.Version
+local type Constraint = version.Constraint
 
 local query_mt: metatable<Query> = {}
 
-query_mt.__index = queries.Query
+query_mt.__index = query.Query
 
-function queries.Query.type(): string  --? remove later
+function query.Query.type(): string  --? remove later
    return "query"
 end
 
 -- Fallback default value for the `arch` field, if not explicitly set.
-queries.Query.arch = {
+query.Query.arch = {
    src = true,
    all = true,
    rockspec = true,
@@ -34,7 +30,7 @@ queries.Query.arch = {
 }
 
 -- Fallback default value for the `substring` field, if not explicitly set.
-queries.Query.substring = false
+query.Query.substring = false
 
 --- Convert the arch field of a query table to table format.
 -- @param input string, table or nil
@@ -79,7 +75,7 @@ function queries.new(name: string, namespace?: string, version?: string, substri
       table.insert(self.constraints, { op = operator, version = vers.parse_version(version)})
    end
 
-   queries.Query.arch[cfg.arch] = true
+   query.Query.arch[cfg.arch] = true
    return setmetatable(self, query_mt)
 end
 
@@ -183,13 +179,13 @@ do
          constraints = constraints,
       }
 
-      queries.Query.arch[cfg.arch] = true
+      query.Query.arch[cfg.arch] = true
       return setmetatable(self, query_mt)
    end
 end
 
 function queries.from_persisted_table(tbl: Query): Query
-   queries.Query.arch[cfg.arch] = true
+   query.Query.arch[cfg.arch] = true
    return setmetatable(tbl, query_mt)
 end
 
@@ -209,9 +205,9 @@ function query_mt.__tostring(self: Query): string
       local pretty = {}
       for _, c in ipairs(self.constraints) do
          local cv = c.version
-         -- local v = cv is vers.Version and cv.string or cv --TEAL BUG
+         -- local v = cv is Version and cv.string or cv --TEAL BUG
          local v: string
-         if cv is vers.Version then
+         if cv is Version then
             v = cv.string
          else 
             v = cv
diff --git a/src/luarocks/results.tl b/src/luarocks/results.tl
index cae6ead9..99f70ec4 100644
--- a/src/luarocks/results.tl
+++ b/src/luarocks/results.tl
@@ -10,10 +10,10 @@ end
 
 local vers = require("luarocks.core.vers")
 local util = require("luarocks.util")
-local queries = require("luarocks.queries")
+local type query = require("luarocks.core.types.query")
 
 local type Results = results.Results
-local type Query = queries.Query
+local type Query = query.Query
 
 local result_mt: metatable<Results> = {}
 
diff --git a/src/luarocks/rockspecs.tl b/src/luarocks/rockspecs.tl
index 390b4d5d..cdd0dcff 100644
--- a/src/luarocks/rockspecs.tl
+++ b/src/luarocks/rockspecs.tl
@@ -9,9 +9,9 @@ local type_rockspec = require("luarocks.type.rockspec")
 local util = require("luarocks.util")
 local vers = require("luarocks.core.vers")
 
-local type Rockspec = cfg.Rockspec
-local type Variables = cfg.Variables
-local type Dependencie = cfg.Dependencie
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
+local type Variables = rockspec.Variables
 
 local vendored_build_type_set: {string: boolean} = {
    ["builtin"] = true,
@@ -24,9 +24,9 @@ local vendored_build_type_set: {string: boolean} = {
 
 local rockspec_mt: metatable<Rockspec> = {}
 
-rockspec_mt.__index = cfg.Rockspec
+rockspec_mt.__index = rockspec.Rockspec
 
-function cfg.Rockspec:type(): string
+function rockspec.Rockspec.type(): string
    return "rockspec"
 end
 
@@ -103,7 +103,7 @@ function rockspecs.from_persisted_table(filename: string, rockspec: Rockspec, gl
    end
 
    if not quick then
-      local ok, err = type_rockspec.check(rockspec as {any: any}, globals or {})
+      local ok, err = type_rockspec.check(rockspec, globals or {})
       if not ok then
          return nil, err
       end
diff --git a/src/luarocks/test.tl b/src/luarocks/test.tl
new file mode 100644
index 00000000..58b055dd
--- /dev/null
+++ b/src/luarocks/test.tl
@@ -0,0 +1,100 @@
+local record test
+end
+
+local fetch = require("luarocks.fetch")
+local deps = require("luarocks.deps")
+local util = require("luarocks.util")
+
+local test_types = {
+   "busted",
+   "command",
+}
+
+local test_modules = {}
+
+for _, test_type in ipairs(test_types) do
+   local mod = require("luarocks.test." .. test_type)
+   table.insert(test_modules, mod)
+   test_modules[test_type] = mod
+   test_modules[mod] = test_type
+end
+
+local function get_test_type(rockspec)
+   if rockspec.test and rockspec.test.type then
+      return rockspec.test.type
+   end
+
+   for _, test_module in ipairs(test_modules) do
+      if test_module.detect_type() then
+         return test_modules[test_module]
+      end
+   end
+
+   return nil, "could not detect test type -- no test suite for " .. rockspec.package .. "?"
+end
+
+-- Run test suite as configured in rockspec in the current directory.
+function test.run_test_suite(rockspec_arg, test_type, args, prepare)
+   local rockspec
+   if type(rockspec_arg) == "string" then
+      local err, errcode
+      rockspec, err, errcode = fetch.load_rockspec(rockspec_arg)
+      if err then
+         return nil, err, errcode
+      end
+   else
+      assert(type(rockspec_arg) == "table")
+      rockspec = rockspec_arg
+   end
+
+   if not test_type then
+      local err
+      test_type, err = get_test_type(rockspec, test_type)
+      if not test_type then
+         return nil, err
+      end
+   end
+   assert(test_type)
+
+   local all_deps = {
+      "dependencies",
+      "build_dependencies",
+      "test_dependencies",
+   }
+   for _, dep_kind in ipairs(all_deps) do
+      if rockspec[dep_kind] and next(rockspec[dep_kind]) then
+         local ok, err, errcode = deps.fulfill_dependencies(rockspec, dep_kind, "all")
+         if err then
+            return nil, err, errcode
+         end
+      end
+   end
+
+   local mod_name = "luarocks.test." .. test_type
+   local pok, test_mod = pcall(require, mod_name)
+   if not pok then
+      return nil, "failed loading test execution module " .. mod_name
+   end
+
+   if prepare then
+      if test_type == "busted" then
+         return test_mod.run_tests(rockspec_arg, {"--version"})
+      else
+         return true
+      end
+   else
+      local flags = rockspec.test and rockspec.test.flags
+      if type(flags) == "table" then
+         util.variable_substitutions(flags, rockspec.variables)
+
+         -- insert any flags given in test.flags at the front of args
+         for i = 1, #flags do
+            table.insert(args, i, flags[i])
+         end
+      end
+
+      return test_mod.run_tests(rockspec.test, args)
+   end
+end
+
+return test
diff --git a/src/luarocks/type/manifest.tl b/src/luarocks/type/manifest.tl
index 0eca2f56..f379f1e0 100644
--- a/src/luarocks/type/manifest.tl
+++ b/src/luarocks/type/manifest.tl
@@ -80,7 +80,7 @@ local manifest_formats = type_check.declare_schemas({
 -- mismatches.
 -- @return boolean or (nil, string): true if type checking
 -- succeeded, or nil and an error message if it failed.
-function type_manifest.check(manifest: {any: any}, globals: {string: any}): boolean, string
+function type_manifest.check(manifest: {any: any}, globals: {string: any}): boolean, string --!
    local format = manifest_formats["3.0"]
    local ok, err = type_check.check_undeclared_globals(globals, format)
    if not ok then return nil, err end
diff --git a/src/luarocks/type/rockspec.tl b/src/luarocks/type/rockspec.tl
index 6f431bd9..1b03736d 100644
--- a/src/luarocks/type/rockspec.tl
+++ b/src/luarocks/type/rockspec.tl
@@ -1,8 +1,11 @@
 local record type_rockspec
-   order: util.Ordering<string>
+   order: Ordering<string>
    rockspec_format: string
 end
 
+local type ordering = require("luarocks.core.types.ordering")
+local type Ordering = ordering.Ordering
+
 local type_check = require("luarocks.type_check")
 local util = require("luarocks.core.util") --!
 
diff --git a/src/luarocks/util.tl b/src/luarocks/util.tl
index 80742419..d39c2198 100644
--- a/src/luarocks/util.tl
+++ b/src/luarocks/util.tl
@@ -49,7 +49,8 @@ util.keys = core.keys
 util.matchquote = core.matchquote
 
 local type Fn = util.Fn
-local type Rockspec = cfg.Rockspec
+local type rockspec = require("luarocks.core.types.rockspec")
+local type Rockspec = rockspec.Rockspec
 local type Parser = util.Parser