Next version! #732
Next version! #732
Commits on Aug 31, 2024
-
make type system more nominal, except for unions
Instead of treating nominal records nominally and all other nominal types structurally, with this commit we treat all nominal types nominally except for unions, which are treated structurally. Give this branch a try in your codebase and let me know your impressions!
-
don't infer table literal as the first table type of a union
Now that unions may contain multiple table types, only infer a table literal into the table type of a union if there's a single table type in a union.
-
-
-
-
-
__is: accept unions over multiple tables that declare
__ismetamethodAccordingly, accept `is` checks on table types that declare `__is`. We disallow unions mixing tables with and without `__is`. This is a limitation because to lift it we would have to implement code that transforms this ``` local u = R1 | R2 | {number} -- R1 and R2 have __is, {number} doesn't if u is {number} then -- ... end ``` into (effectively) ``` local u = R1 | R2 | {number} -- R1 and R2 have __is, {number} doesn't if not (u is R1 or u is R2) then -- ... end ``` In other words, "is" testing for the one table/userdata item without __is would have to be defined in terms of the negation of the disjunction of all the other cases. -
-
-
-
-
-
interfaces: add "is <interface_list>" to record syntax
Also check that types referenced in `is` exist.
-
-
-
-
interfaces/records: move arrayrecord to
is {...}This avoids a grammar ambiguity in the `where` clause, where a following `{T}` would be mistaken as being part of the `where` expression. We still support a `{T}` at the top of the record declaration if there is no `is` clause, but not in the middle of the field list anymore. -
-
interfaces: prevent assignment to interfaces and types
Interfaces are abstract, so they cannot be assigned to, unlike record fields, which are concrete values when records are used as prototypes. We already prevented assignment overwriting top-level records. This commit also extends the restriction to nested records, for consistency.
-
-
-
-
-
-
-
-
-
* Node objects no longer carry a `.type` attribute. This was redundant with the return values produced by the node visitors, which are then available in the traversal as the `children` array. The idea is that the logic of resolving types should follow the single-pass flow of traversal, instead of having to track the code of visitors that peek into the tree structure (or worse, modify it after the fact as they go). * Because of that, the collection of types for `tl types` has changed: instead of always collecting a symbol table during type checking, one needs to enable `report_types = true` in the `env`, which then performs the collection and summarization of the data reported by `tl types` in place. This makes the overall process more efficient for both `tl check` and `tl types`.
-
-
-
-
avoid setting (or updating!) typename directly
This is to ensure that there is always a consistent correspondence between a typeid and its typename (that is, if the typename changes, we update the typeid as well). With consistency between typeids and typenames, we would _almost_ be able to cache type comparison judgements based on typeids alone. We're not able to do it just because type comparisons such as is_a and same_type have one possible side-effect: inferring typevars. From my experiments, in the current state of the code there's no real performance gain by caching type comparisons, but it would be nice to be able to do it for better understandability -- intuitively, type comparisons should be a pure operation. In any case, the changes in this commit should make it easier to reason about and debug the code in the long term.
-
-
-
-
-
-
-
-
-
-
abstract checks for macroexp and interfaces
Ensure is_abstract is always set for interface typetypes by using new_typetype constructor.
-
-
refactor: reduce confusion in Type instances
* `Type` is no longer a `{Type}` - this was being used only for "tuple" types; now those have an explicit `.tuple` attribute. * Split `Node`'s `.decltype` into three different attributes: `.argtype` for "argument", `.itemtype` for "table_item" and `.decltuple` for variable lists. * Add `TupleType` alias; this is not enforced as a subtype at this point. It is only being used for documentation. * Type object constructors such as `a_function` are now stricter about expecting "tuple" entries. This caught a few mistakes. * More consistent tuple usage: function calls always return a "tuple" or an "invalid". Arguments and expected returns are always passed in as a "tuple". Special function handlers are adjusted accordingly. * Explicit assignments of `.y` and `.x` are replaced by `type_at` wrapper, which uses a `Where`. -
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
The implementation of the <total> attribute remains messy, but at least this restrict the is_total field to actual records and maps (and not nominals). The <total> feature for records should go away once we have nilable/non-nilable fields.
-
-
-
-
refactor: declname and is_alias_node
Rename non-nominal-type use of names to declname, and rename Node.is_alias to Node.is_alias_node
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
language flag: feat-arity=on/off
Enable or disable the behavior of '?' argument annotations, providing backwards compatibility with existing codebases.
-
-
-
Makefile: allow testing with different interpreter values
This will allow me to more easily run local tests with my hacked `lua-no-tailcalls` interpreter binary.
-
-
-
-
-
refactor: use to_structural to resolve nominals
...instead of the overkill of resolve_tuple_and_nominal everywhere. Only resolve tuples where needed (and we're still possibly overdoing it.)
-
-
-
more integer in stdlib signatures
Co-Authored-By: Hisham Muhammad <[email protected]>
-
-
-
-
-
-
unite: removing duplicates via t.found should be enough
This avoids resolve_nominal which needs state lookup. With this change, unite() should work looking at the given Type objects only.
-
move module_name logic out of type_check
it is now handled by the parts that deal with module names: `require` and the package loader.
-
-
-
-
big code reorganization: TypeChecker record
Several big changes, that were done in tandem, and which would be too troublesome to break into separate commits. The goal here is to ultimately be able to break tl.tl into multiple files (because its size started hitting limits in both Lua 5.1 (number of upvalues) and Lua 5.4 (number of locals). Here's a high-level summary of the changes: * new Errors record, encapsulating error-reporting concerns; * all Type occurrences have unique objects reporting their locations (no more singletons for base types such as BOOLEAN and INVALID); * some enums renamed for more consistency across Gen and Feat options; * TypeCheckOptions and EnvOptions tables reorganized for easier forwarding of options across them; * simplifications in the various function signatures of the public API; * all Types and Nodes store filename, line and column location (`f`, `y`, `x`); * Scope is now a record containing the variables map and unresolved items -- no more "@unresolved" pseudo-variable and `unresolved` pseudo-type for storing this data in the symbols table; * `type_check` now uses a TypeChecker object for storing all state, instead of relying on closures and function nesting (that's a bit sad is it ended up spreading `self:` and extra function arguments everywhere, but I guess state management will be more explicit for others reading the code now...); * all Fact objects have a Where location as well, and supressions of inference data in error messages for widened-back types is marked explicitly with `no_infer` instead of missing a `w` field; * general simplification of the sourcing of error locations (though I would still like to improve that further);
-
fix: lax arity of returns in function literals
The unwanted difference between the types for `f` and `g` in the regression test from this commit was observed when fixing the issue #736.
-
fix: let lax mode perform emptytable key-value inference as normal
Do not over-constrain types with `unknown`, let `assert_is_a` perform the check when t2 is `unresolved_emptytable_value`.
-
-
-
Accept __lt and __le for > and >= operators.
As in Lua, "A comparison a > b is translated to b < a and a >= b is translated to b <= a."
-
-
fix: do not crash when comparing type defined with 'function'
Using the plain 'function' type needs to define 'min_arity'.
-
-
add the code output to the io.open function (#769)
Updated definition for io.open function to expose the 3rd parameter containing the returning code as integer * Add the code output to the io.open function * generate the tl.lua
-
-
-
-
tests: add regression test to function call check crash
Add another regression test to a bug fixed in f97625d Co-Authored-By: Victor Ilchev <[email protected]>
-
standard library: special-case tuple support for table.unpack
Add special cases for tuples of sizes up to 5.
-
Co-authored-by: Darren Jennings <[email protected]>
-
-
local type require() accepts dot notation for nested record
`local type MyType = require("module").MyType` is now valid. Closes #778. -
fix: delay resolution of type arguments
Ideally we need to recurse type arguments and propagate those. But since they are arriving in typevar_resolver as nominal, we're just renaming the existing typeargs (see `HACK` in source), and test cases. This is most likely wrong, hope it doesn't break anything else! Closes #777.
-
stricter checks for shadowing of type arguments
Produces an error when using a base type as a type argument, and a warning when using another variable name. We can be stricter with type arguments because those exist only in Teal's type world. We can't be as strict with redeclarations in general because record types also exist as concrete Lua objects (example: the "string" table in the standard library). Fixes #764.
-
-
fix: localizing a record does not make the new local a type
This allows for a pattern where we can localize a record and load and alternative implementation on top of it. Fixes #759.
-
-
This makes me think if this should happen implicitly...
-
This triggered during debugging because show_type for two string with the same typeid didn't match.
-
-
-
-
-
-
-
-
-
-
fix: self heuristic: ensure that non-nominal types are detected
The heuristic was only comparing against nominal types; if a non-nominal type such as `(self: integer)` was used, it was silently accepted as a method and promoted to the `self` type.
-
-
tests: add regression test for #752.
Thanks @svermeulen for the report!
-
-
-
fix: tl types: never trigger ICE on bad files
This matches the behavior of master. Can't make a simple regression test for this one because that would be dependent on unspecified behaviors of the parser and type-checker. Fixes #795.
-
fix: do not infer type variables as boolean in boolean contexts
Introduces a special internal type, to be used only as the node.expected type in boolean contexts such as `if _ then`. It behaves exactly like boolean except that type variables do not infer to it. See #768.
-
-
-
Commits on Sep 2, 2024
-
Proofreading by Thijs Schreijer Co-authored-by: Thijs Schreijer <[email protected]>
-
-
-
-
optional arity: lax arg check in functions with feat-arity off
This might be too lax, but it does revert back to accepting assignments that were valid in Teal 0.15.
-
-
-
Commits on Sep 3, 2024
-
metatables: check metamethod types in metatable definition
Add special-case behavior to specialize a type `metatable<R>` using the definition of `metamethod` entries from `R` (and not just a type-variable application of `R` into the definition of `global record metatable<T>` from the standard library definition. See tests in spec/declaration/metatable_spec.lua for examples of the added checks. Fixes #633. (At least the extent of it that can be resolved at this time, without explicit `nil` support -- a good explanation as to why the second case isn't resolved is given by @bjornbm in #633 (comment) : "the record definition defines what keys/values are valid, but not that they are defined (or more generally perhaps the values may be nil, since nil is a valid value of every type). What is checked is that values for the defined keys have the right type, and that no other keys are added to the record.
-
-
-
Commits on Sep 4, 2024
-
-
-
-
-
-
-
-
refactor: remove TypeAliasType (unify with TypeDeclType)
The TypeAliasType is now a case of TypeDeclType, where `is_alias` is true, and `def` is always a NominalType (asserts are sprinkled in the code to check this).
-
Commits on Sep 5, 2024
Commits on Sep 6, 2024
Commits on Sep 8, 2024
Commits on Sep 10, 2024
-
-
tests: add #cli tag in spec/cli tests
This makes it easy to skip those tests when a faster busted run is desired in exchange of completeness.
-
Commits on Sep 18, 2024
-
-
fix: do not infer typevars on failed poly match
In `assert(f:read("a"))`, the return type of the failed poly match of `file:read` was matching the `A` typevar of `assert`. We now reset the temporary scope of a call typecheck fully when backtracking to test different poly entries (previously we were backtracking only the poly's own typeargs). -
string.gsub: accept functions with no returns
Note that we're doing a little hack here, but notating the return type as vararg, as a stand-in for something like a `?` in the return type. I guess we need `min_arity` calculations in the return types as well. Also fix the declaration of `gsub` because Lua does not accept functions that return booleans, but it does accept numbers.
-
improve inference of nested emptytables
See #732 (comment) > There is one remaining tricky error triggering in the day12 for which I > already found a workaround (but which would merit a nicer solution since this > uncovered the fact that my empty-table inference does not backpropagate > correctly in the case of map[c1][c2] = true). I'll try to code a solution > quickly, otherwise I'll document the edge case in the testsuite and go with > the workaround. This is the workaround, and the documentation of the edge case is in the test case included in this commit.
Commits on Sep 19, 2024
-
fix: can assign an emptytable to an emptytable
This should also avoid inferring types as `{} | {}`. -
-
Commits on Sep 21, 2024
-
types: reports record functions in record field list
Also, strip typedecls from type report, and represent records in the "str" field by their declared name. Thanks @pdesaulniers for the report!