Next version! #732

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!

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.

Accordingly, 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.

Also check that types referenced in `is` exist.

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 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`.

Apparently we don't need it anymore!

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.

Ensure is_abstract is always set for interface typetypes by using new_typetype constructor.

* `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.

Rename non-nominal-type use of names to declname, and rename Node.is_alias to Node.is_alias_node

Enable or disable the behavior of '?' argument annotations, providing backwards compatibility with existing codebases.

This will allow me to more easily run local tests with my hacked `lua-no-tailcalls` interpreter binary.

See #733.

...instead of the overkill of resolve_tuple_and_nominal everywhere. Only resolve tuples where needed (and we're still possibly overdoing it.)

Co-Authored-By: Hisham Muhammad <[email protected]>

This avoids resolve_nominal which needs state lookup. With this change, unite() should work looking at the given Type objects only.

it is now handled by the parts that deal with module names: `require` and the package loader.

@unresolved

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);

Fixes #736.

The unwanted difference between the types for `f` and `g` in the regression test from this commit was observed when fixing the issue #736.

Do not over-constrain types with `unknown`, let `assert_is_a` perform the check when t2 is `unresolved_emptytable_value`.

Fixes #747.

Fixes #749.

As in Lua, "A comparison a > b is translated to b < a and a >= b is translated to b <= a."

Using the plain 'function' type needs to define 'min_arity'.

Fixes #765.

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

Add another regression test to a bug fixed in f97625d Co-Authored-By: Victor Ilchev <[email protected]>

Add special cases for tuples of sizes up to 5.

Co-authored-by: Darren Jennings <[email protected]>

`local type MyType = require("module").MyType` is now valid. Closes #778.

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.

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.

This allows for a pattern where we can localize a record and load and alternative implementation on top of it. Fixes #759.

Fixes #757.

Closes #775.

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.

Fixes #777.

See #756.

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.

@svermeulen

Thanks @svermeulen for the report!

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.

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.

Proofreading by Thijs Schreijer Co-authored-by: Thijs Schreijer <[email protected]>

This might be too lax, but it does revert back to accepting assignments that were valid in Teal 0.15.

@bjornbm

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.

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).

This makes it easy to skip those tests when a faster busted run is desired in exchange of completeness.

See #801.

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).

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.

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.

Fixes #804.

This should also avoid inferring types as `{} | {}`.

@pdesaulniers

Also, strip typedecls from type report, and represent records in the "str" field by their declared name. Thanks @pdesaulniers for the report!

Commits on Sep 5, 2024

funcall: minor simplification

hishamhm committed Sep 5, 2024

Configuration menu

View commit details

Copy full SHA for 775ceda

Browse repository at this point

Copy the full SHA

775ceda View commit details

Browse the repository at this point in the history

Commits on Sep 8, 2024

find_type: narrow return type

hishamhm committed Sep 8, 2024

Configuration menu

View commit details

Copy full SHA for 373e06d

Browse repository at this point

Copy the full SHA

373e06d View commit details

Browse the repository at this point in the history

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Next version! #732

Next version! #732

Commits on Aug 31, 2024

Commits on Sep 2, 2024

Commits on Sep 3, 2024

Commits on Sep 4, 2024

Commits on Sep 5, 2024

Commits on Sep 6, 2024

Commits on Sep 8, 2024

Commits on Sep 9, 2024

Commits on Sep 10, 2024

Commits on Sep 18, 2024

Commits on Sep 19, 2024

Commits on Sep 21, 2024

Commits on Oct 3, 2024

Commits on Oct 7, 2024