test core with the next version of teal

8 files changed, 88 insertions, 68 deletions

diff --git a/src/luarocks/core/manif.tl b/src/luarocks/core/manif.tl
index a089b5d8..0713d293 100644
--- a/src/luarocks/core/manif.tl
+++ b/src/luarocks/core/manif.tl
@@ -57,7 +57,7 @@ end
 -- @param repo_url string: The repository identifier.
 -- @param lua_version string: Lua version in "5.x" format, defaults to installed version.
 -- @return table or nil: loaded manifest or nil if cache is empty.
-function manif.get_cached_manifest(repo_url: string, lua_version: string): Manifest
+function manif.get_cached_manifest(repo_url: string, lua_version?: string): Manifest
    lua_version = lua_version or cfg.lua_version
    return manifest_cache[repo_url] and manifest_cache[repo_url][lua_version]
 end
diff --git a/src/luarocks/core/persist.tl b/src/luarocks/core/persist.tl
index 31dfe289..89cac97e 100644
--- a/src/luarocks/core/persist.tl
+++ b/src/luarocks/core/persist.tl
@@ -21,7 +21,7 @@ function persist.run_file(filename: string, env: {string:any}): boolean, any | s
       return nil, read_err, "open"
    end
    str = str:gsub("^#![^\n]*\n", "")
-   local chunk, ran, err: function(any):(any), boolean, any
+   local chunk, ran, err: function(...: any):(any), boolean, any
    chunk, err = load(str, filename, "t", env)
    if chunk then
       ran, err = pcall(chunk)
@@ -45,7 +45,7 @@ end
 -- or nil, an error message and an error code ("open"; couldn't open the file,
 -- "load"; compile-time error, or "run"; run-time error)
 -- in case of errors.
-function persist.load_into_table(filename: string, tbl: {string:any}) : {any: any}, {any: any} | string, string
+function persist.load_into_table(filename: string, tbl?: {string:any}) : {any: any}, {any: any} | string, string
 
    local result: {string:any} = tbl or {}
    local globals = {}
diff --git a/src/luarocks/core/util.tl b/src/luarocks/core/util.tl
index e9c21dac..39862dcb 100644
--- a/src/luarocks/core/util.tl
+++ b/src/luarocks/core/util.tl
@@ -1,13 +1,18 @@
 
 local record util
-   type CompFn = function(any, any): boolean
+   record Ordering<K>
+      {K}
+      
+      sub_orders: {K: Ordering<K>}
+   end
 end
 
 --------------------------------------------------------------------------------
 
 local dir_sep = package.config:sub(1, 1)
 
-local type CompFn = util.CompFn
+local type SortBy<K> = table.SortFunction<K> | util.Ordering<K>
+
 
 --- Run a process and read a its output.
 -- Equivalent to io.popen(cmd):read("*l"), except that it
@@ -57,7 +62,7 @@ function util.show_table(t: {any:any}, tname: string, top_indent: string): strin
 
    local function basic_serialize(o: any): string
       local so = tostring(o)
-      if type(o) == "function" then
+      if o is function then
          local info = debug and debug.getinfo(o, "S")
          if not info then
             return ("%q"):format(so)
@@ -76,7 +81,7 @@ function util.show_table(t: {any:any}, tname: string, top_indent: string): strin
       end
    end
 
-   local function add_to_cart (value: any | {any:any}, name: string, indent: string, saved: {any: string}, field: string)
+   local function add_to_cart (value: any | {any:any}, name: string, indent: string, saved?: {any: string}, field?: string)
       indent = indent or ""
       saved = saved or {}
       field = field or name
@@ -172,7 +177,7 @@ end
 
 -- from http://lua-users.org/wiki/SplitJoin
 -- by Philippe Lhoste
-function util.split_string(str: string, delim: string, maxNb: number): {string}
+function util.split_string(str: string, delim: string, maxNb?: number): {string}
    -- Eliminate bad cases...
    if string.find(str, delim) == nil then
       return { str }
@@ -183,11 +188,11 @@ function util.split_string(str: string, delim: string, maxNb: number): {string}
    local result = {}
    local pat = "(.-)" .. delim .. "()"
    local nb = 0
-   local lastPos: number
+   local lastPos: integer
    for part, pos in string.gmatch(str, pat) do
       nb = nb + 1
       result[nb] = part
-      lastPos = tonumber(pos)
+      lastPos = math.tointeger(pos)
       if nb == maxNb then break end
    end
    -- Handle the last field
@@ -288,51 +293,46 @@ 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, S>(tbl: {K: V}, sort_function: CompFn | {K | {K, S}}): function(): K, V, S
-   if not sort_function then
-      sort_function = default_sort
-   end
+function util.sortedpairs<K, V>(tbl: {K: V}, sort_by?: SortBy<K>): function(): K, V, util.Ordering<K>
    local keys = util.keys(tbl)
-   local sub_orders: {K: S} = {}
+   local sub_orders: {K: util.Ordering<K>} = nil
 
-   if sort_function is CompFn then
-      table.sort(keys, sort_function)
+   if sort_by == nil then
+      table.sort(keys, default_sort)
+   elseif sort_by is table.SortFunction<K> then
+      table.sort(keys, sort_by)
    else
-      local order = sort_function
-      local ordered_keys = {}
-      local all_keys = keys
-      keys = {}
-
-      for _, order_entry in ipairs(order) do
-         local key, sub_order: K, S
-
-         if not order_entry is {K, S} then --TEAL BUG
-            key = order_entry as K
-         else
-            key = order_entry[1]
-            sub_order = order_entry[2]
-         end
-
+      -- sort_by is Ordering<K>
+      
+      sub_orders = sort_by.sub_orders
+
+      local seen_ordered_key: {K: boolean} = {}
+      
+      local my_ordered_keys: {K} = {}
+      
+      for _, key in ipairs(sort_by) do
          if tbl[key] then
-            ordered_keys[key] = true
-            sub_orders[key] = sub_order
-            table.insert(keys, key)
+            seen_ordered_key[key] = true
+            table.insert(my_ordered_keys, key)
          end
       end
 
-      table.sort(all_keys, default_sort)
-      for _, key in ipairs(all_keys) do
-         if not ordered_keys[key] then
-            table.insert(keys, key)
+      table.sort(keys, default_sort)
+
+      for _, key in ipairs(keys) do
+         if not seen_ordered_key[key] then
+            table.insert(my_ordered_keys, key)
          end
       end
+      
+      keys = my_ordered_keys
    end
-
+   
    local i = 1
-   return function(): K, V, S
+   return function(): K, V, util.Ordering<K>
       local key = keys[i]
       i = i + 1
-      return key, tbl[key], sub_orders[key]
+      return key, tbl[key], sub_orders and sub_orders[key]
    end
 end
 
diff --git a/src/luarocks/persist-original.lua b/src/luarocks/persist.lua
index 4dcd930a..4dcd930a 100644
--- a/src/luarocks/persist-original.lua
+++ b/src/luarocks/persist.lua
diff --git a/src/luarocks/persist.tl b/src/luarocks/persist.tl
index 5611b684..f02fcfee 100644
--- a/src/luarocks/persist.tl
+++ b/src/luarocks/persist.tl
@@ -3,10 +3,11 @@
 -- saving tables into files.
 local record persist
    run_file: function(string, {string:any}): boolean, any | string, string
-   load_into_table: function(string, {string:any}) : {any: any}, {any: any} | string, string
+   load_into_table: function(string, ?{string:any}) : {any: any}, {any: any} | string, string
 end
 
 local core = require("luarocks.core.persist")
+local coreutil = require("luarocks.core.util")
 local util = require("luarocks.util")
 local dir = require("luarocks.dir")
 local fs = require("luarocks.fs")
@@ -14,7 +15,13 @@ local fs = require("luarocks.fs")
 persist.run_file = core.run_file
 persist.load_into_table = core.load_into_table
 
-local write_table: function(out, tbl: {number | string: number| string}, level: integer, field_order: {(number | string): any})
+local type SortBy<K> = table.SortFunction<K> | coreutil.Ordering<K>
+
+local interface Writer
+   write: function(self: Writer, data: string)
+end
+
+local write_table: function(out: Writer, tbl: {number | string: number| string}, level: integer, field_order: SortBy<number | string>)
 
 --- Write a value as Lua code.
 -- This function handles only numbers and strings, invoking write_table
@@ -24,8 +31,8 @@ local write_table: function(out, tbl: {number | string: number| string}, level:
 -- @param level number: the indentation level
 -- @param sub_order table: optional prioritization table
 -- @see write_table
-function persist.write_value(out, v: any, level: integer, sub_order) --! out type
-   if v is {any: any} then
+function persist.write_value(out: Writer, v: any, level: integer, sub_order?: SortBy<number | string>)
+   if v is {number | string: number | string} then
       level = level or 0
       write_table(out, v, level + 1, sub_order)
    elseif v is string then
@@ -79,7 +86,7 @@ do
    end
 end
 
-local function write_table_key_assignment(out, k: string | number, level: integer)
+local function write_table_key_assignment(out: Writer, k: string | number, level: integer)
    if k is string and is_valid_plain_key(k) then
       out:write(k)
    else
@@ -98,7 +105,7 @@ end
 -- @param tbl table: the table to be written.
 -- @param level number: the indentation level
 -- @param field_order table: optional prioritization table
-write_table = function(out, tbl: {number | string: number| string}, level: integer, field_order: {(number | string): any}) --? suborrder type?
+write_table = function(out: Writer, tbl: {number | string: number| string}, level: integer, field_order: SortBy<number | string>)
    out:write("{")
    local sep = "\n"
    local indentation = "   "
@@ -137,9 +144,9 @@ end
 -- @param tbl table: the table to be written.
 -- @param field_order table: optional prioritization table
 -- @return true if successful; nil and error message if failed.
-local function write_table_as_assignments(out, tbl, field_order)
+local function write_table_as_assignments(out: Writer, tbl: {number | string: number| string}, field_order: SortBy<number | string>): boolean, string
    for k, v, sub_order in util.sortedpairs(tbl, field_order) do
-      if not is_valid_plain_key(k) then
+      if not is_valid_plain_key(k) then --? tostring
          return nil, "cannot store '"..tostring(k).."' as a plain key."
       end
       out:write(k.." = ")
@@ -152,9 +159,9 @@ end
 --- Write a table using Lua table syntax to a writer object.
 -- @param out table or userdata: a writer object supporting :write() method.
 -- @param tbl table: the table to be written.
-local function write_table_as_table(out, tbl)
+local function write_table_as_table(out: Writer, tbl: {number | string: number| string})
    out:write("return {\n")
-   for k, v, sub_order in util.sortedpairs(tbl) do
+   for k, v, sub_order in util.sortedpairs(tbl) do --! that has the right inputs and outputs yet it throws an error
       out:write("   ")
       write_table_key_assignment(out, k, 1)
       persist.write_value(out, v, 1, sub_order)
@@ -170,8 +177,8 @@ end
 -- @param tbl table: the table containing the data to be written
 -- @param field_order table: an optional array indicating the order of top-level fields.
 -- @return persisted data as string; or nil and an error message
-function persist.save_from_table_to_string(tbl, field_order)
-   local out = {buffer = {}}
+function persist.save_from_table_to_string(tbl: {number | string: number| string}, field_order: SortBy<number | string>): string
+   local out: Writer = {buffer = {}} --!
    function out:write(data) table.insert(self.buffer, data) end
    local ok, err = write_table_as_assignments(out, tbl, field_order)
    if not ok then
diff --git a/src/luarocks/type/rockspec.lua b/src/luarocks/type/rockspec.lua
index 0b4b5dcf..5ee944a4 100644
--- a/src/luarocks/type/rockspec.lua
+++ b/src/luarocks/type/rockspec.lua
@@ -135,13 +135,27 @@ local rockspec_formats, versions = type_check.declare_schemas({
    }
 })
 
-type_rockspec.order = {"rockspec_format", "package", "version",
-   { "source", { "url", "tag", "branch", "md5" } },
-   { "description", {"summary", "detailed", "homepage", "license" } },
-   "supported_platforms", "dependencies", "build_dependencies", "external_dependencies",
-   { "build", {"type", "modules", "copy_directories", "platforms"} },
-   "test_dependencies", { "test", {"type"} },
-   "hooks"}
+type_rockspec.order = {
+   "rockspec_format",
+   "package",
+   "version",
+   "source",
+   "description",
+   "supported_platforms",
+   "dependencies",
+   "build_dependencies",
+   "external_dependencies",
+   "build",
+   "test_dependencies",
+   "test",
+   "hooks",
+   sub_orders = {
+      ["source"] = { "url", "tag", "branch", "md5" },
+      ["description"] = {"summary", "detailed", "homepage", "license" },
+      ["build"] = { "type", "modules", "copy_directories", "platforms" },
+      ["test"] = { "type" }
+   }
+}
 
 local function check_rockspec_using_version(rockspec, globals, version)
    local schema = rockspec_formats[version]
diff --git a/src/luarocks/util-original.lua b/src/luarocks/util.lua
index de9157fc..de9157fc 100644
--- a/src/luarocks/util-original.lua
+++ b/src/luarocks/util.lua
diff --git a/src/luarocks/util.tl b/src/luarocks/util.tl
index 868e1552..f1447e60 100644
--- a/src/luarocks/util.tl
+++ b/src/luarocks/util.tl
@@ -7,12 +7,12 @@
 local core = require("luarocks.core.util")
 local cfg = require("luarocks.core.cfg")
 
-local type CompFn = core.CompFn
+local type SortBy<K> = table.SortFunction<K> | core.Ordering<K>
 
 local record util
    cleanup_path: function(string, string, string, boolean): string
    split_string: function(string, string, number): {string}
-   sortedpairs: function<K, V, S>({K : V}, CompFn | {K | {K, S}}): function(): K, V, S
+   sortedpairs: function<K, V>(tbl: {K: V}, sort_by: SortBy<K>): function(): K, V, core.Ordering<K>
    deep_merge: function({any : any}, {any : any})
    deep_merge_under: function({any : any}, {any : any})
    popen_read: function(string, ?string): string
@@ -27,19 +27,18 @@ local record util
       args: table.PackTable<any>
    end
 
-   record Parser --?
+   record Parser
       option: function(Parser, ...: string): Parser
       argname: function(Parser, string): Parser
       choices: function(Parser, {string}): Parser
       flag: function(Parser, string): Parser
       hidden: function(Parser, boolean): Parser
    end
-
 end
 
-util.cleanup_path = core.cleanup_path --tlcheck acting funny
+util.cleanup_path = core.cleanup_path
 util.split_string = core.split_string
--- util.sortedpairs = core.sortedpairs
+util.sortedpairs = core.sortedpairs
 util.deep_merge = core.deep_merge
 util.deep_merge_under = core.deep_merge_under
 util.popen_read = core.popen_read
@@ -53,6 +52,7 @@ local type Fn = util.Fn
 local type Rockspec = cfg.Rockspec
 local type Parser = util.Parser
 
+
 local scheduled_functions: {Fn} = {} --? infered from line 48-51
 
 --- Schedule a function to be executed upon program termination.
@@ -290,7 +290,6 @@ local function collect_rockspecs(versions: {string: string}, paths: {string: str
    local dir = require("luarocks.dir")
    local path = require("luarocks.path")
    local vers = require("luarocks.core.vers")
-
    if fs.is_dir(subdir) then
       for file in fs.dir(subdir) do
          file = dir.path(subdir, file)