Table: do not mark the result as fully evaluated; a literal element is fully evaluated

[tombouctou]

Table gave its result ElementsProperties(elements_fully_evaluated=True). A ListExpression with that flag never evaluates its elements again. So a table whose elements depend on a definition made later keeps its old value:

l = Table[x, {1}]; x = 1; l             (* Mathics3: {x};    WMA: {1} *)
l = Table[f[y], {1}]; f[y_] := 7; l     (* Mathics3: {f[y]}; WMA: {7} *)
t = Table[i + x, {i, 2}]; x = 1; t      (* Mathics3: {1 + x, 2 + x}; WMA: {2, 3} *)

Range with symbolic bounds and Array already behave like WMA. Only Table set the flag unconditionally.

With this PR, Table.get_result just builds a ListExpression from the elements and lets it work out its properties, as any other list does. A table of literals (numbers, strings) is still marked as fully evaluated, because that comes from the elements themselves.

Second commit: a literal element is fully evaluated. Building the list this way exposed a crash that is already on master. Map over an empty list gives {} with pessimistic properties (elements_fully_evaluated=False), although {} is literal. A list that holds such an element is itself literal, and _build_elements_properties then fails its assertion:

{f /@ {}}            (* master: AssertionError; WMA: {{}} *)
Table[f /@ {}, {2}]  (* with the first commit alone: AssertionError *)

_build_elements_properties and convert_expression_elements now treat a literal element as fully evaluated, whatever its own properties say.

Checks: test_table_is_evaluated_again in test/builtin/list/test_constructing.py (now including both cases above) fails on master and passes here. Full pytest and doctests pass.

🤖 Generated with Claude Code

[mmatera]

The property is_fully_evaluated should be set to True when Table produces a List of literal elements (like a list of numbers). This should be checked at creation time.

[tombouctou]

@mmatera thanks, done in the latest commit. When every element Table produces is literal (Table[i, {i, 3}], Table[{i, 2 i}, {i, 3}]), get_result now builds the properties right away, so the list is marked fully evaluated at creation. For any other table (Table[i x, {i, 3}], or l = Table[x, {1}] before x = 1), the properties are left to ListExpression, so the list is evaluated again later. A new test calls Table.get_result directly and checks both cases.

[rocky]

LGTM thanks @tombouctou and @mmatera