feat(check): static synthesis for list and map literals

Extend synth() to handle LitList and LitMap so every collection
literal carries a real element-type today, instead of falling
through to Dynamic. `[1, 2, 3]` synthesizes to int[],
`{"a": 1}` to {str: int}, and so on - exposed via ExprTypes
for hover, and ready to feed downstream type-checking once
collection-typed locals exist (Phase 6).

Element widening applies the one and only implicit numeric rule
the rest of the type system already enforces (int -> float). So
[1, 2.5] is float[], not int|float[]: matches what
IsAssignableFrom does at scalar slots, and avoids unions of
numeric types leaking into hover and diagnostics. Non-numeric
mixes do form unions ([1, "hi"] -> int|str[]), since there's
no implicit widening between unrelated types.

Empty literals stay at the unparameterized AnyList / AnyMap.
The plan calls for Pyright-style look-around (`xs = []` then
later `xs = [1, 2]` would refine to int[]), but that needs
multi-statement reasoning the binder doesn't expose yet. Until
then the over-approximation is correct: every existing program
type-checks, and we don't nag users to annotate empty literals.

ErrorType propagation: a poisoned element collapses the whole
literal to ErrorType, not List<ErrorType>. The invariant
collection assignability rule rejects List<X> against
List<ErrorType> for every X, so wrapping would cascade the
diagnostic into every downstream use of the literal. Returning
bare ErrorType is the cascade-suppression contract the type
system already follows.

Author: amterp

rts/check/type_check.go

@@ -184,6 +184,10 @@ func (tc *typeChecker) synth(n rl.Node) rl.TypingT {
 		return tc.synthFallback(v)
 	case *rl.CatchExpr:
 		return tc.synthCatchExpr(v)
+	case *rl.LitList:
+		return tc.synthLitList(v)
+	case *rl.LitMap:
+		return tc.synthLitMap(v)
 	}
 	for _, child := range n.Children() {
 		_ = tc.synth(child)
@@ -787,3 +791,103 @@ func (tc *typeChecker) addUnaryOpIssue(span rl.Span, op rl.Operator, operand rl.
 			operand.Name(), op.String()),
 	})
 }
+
+// --- Collection literals ---------------------------------------------
+//
+// List and map literals synthesize to a parameterized collection type
+// derived from their elements. Empty literals fall back to the
+// unparameterized AnyList/AnyMap rather than erroring: that's the
+// gradual-typing choice. A future "look-around" pass can refine
+// `xs = []` followed by `xs.append(1)` to `List<int>`, but the safe
+// over-approximation lets every existing program type-check today.
+
+func (tc *typeChecker) synthLitList(n *rl.LitList) rl.TypingT {
+	if len(n.Elements) == 0 {
+		return tc.record(n, rl.NewAnyListType())
+	}
+	elemTypes := make([]rl.TypingT, 0, len(n.Elements))
+	for _, e := range n.Elements {
+		elemTypes = append(elemTypes, tc.synth(e))
+	}
+	widened := widenElementTypes(elemTypes)
+	// Bare-ErrorType element poisons the whole literal. Wrapping it in
+	// List<ErrorType> would cascade: invariant collection assignability
+	// rejects List<X>.IsAssignableFrom(List<ErrorType>) for every X.
+	if isErrorType(widened) {
+		return tc.record(n, rl.NewErrorTypeType())
+	}
+	return tc.record(n, rl.NewListType(widened))
+}
+
+func (tc *typeChecker) synthLitMap(n *rl.LitMap) rl.TypingT {
+	if len(n.Entries) == 0 {
+		return tc.record(n, rl.NewAnyMapType())
+	}
+	keyTypes := make([]rl.TypingT, 0, len(n.Entries))
+	valTypes := make([]rl.TypingT, 0, len(n.Entries))
+	for _, e := range n.Entries {
+		keyTypes = append(keyTypes, tc.synth(e.Key))
+		valTypes = append(valTypes, tc.synth(e.Value))
+	}
+	keyT := widenElementTypes(keyTypes)
+	valT := widenElementTypes(valTypes)
+	if isErrorType(keyT) || isErrorType(valT) {
+		return tc.record(n, rl.NewErrorTypeType())
+	}
+	return tc.record(n, rl.NewMapType(keyT, valT))
+}
+
+// widenElementTypes computes the static element type for a collection
+// from its individual element types. The rules:
+//
+//   - If any element is ErrorType, return ErrorType so cascading
+//     diagnostics stay suppressed.
+//   - If any element is any/dynamic, return Dynamic - we can't pin a
+//     useful element type and AnyList/AnyMap is a more honest answer.
+//   - Apply the lone implicit numeric widening: a mix of int and float
+//     collapses to float (matching IsAssignableFrom), not int|float.
+//     Otherwise unique types form a union; identical types collapse.
+//
+// Returns Dynamic for an empty slice as a defensive fallback; callers
+// handle the truly-empty case (LitList{}, LitMap{}) before getting
+// here.
+func widenElementTypes(types []rl.TypingT) rl.TypingT {
+	if len(types) == 0 {
+		return rl.NewDynamicType()
+	}
+	allNumeric := true
+	hasFloat := false
+	for _, t := range types {
+		if isErrorType(t) {
+			return rl.NewErrorTypeType()
+		}
+		if isDynamicLike(t) {
+			return rl.NewDynamicType()
+		}
+		if !isNumeric(t) {
+			allNumeric = false
+		}
+		if isFloat(t) {
+			hasFloat = true
+		}
+	}
+	if allNumeric && hasFloat {
+		return rl.NewFloatType()
+	}
+	// Deduplicate by Name(). Order-preserving so a list literal of all
+	// `str` stays `List<str>` rather than getting reordered.
+	seen := map[string]bool{}
+	unique := make([]rl.TypingT, 0, len(types))
+	for _, t := range types {
+		name := t.Name()
+		if seen[name] {
+			continue
+		}
+		seen[name] = true
+		unique = append(unique, t)
+	}
+	if len(unique) == 1 {
+		return unique[0]
+	}
+	return rl.NewUnionType(unique...)
+}

rts/check/type_check_test.go

@@ -406,3 +406,68 @@ func TestTypeCheck_DynamicOperandDoesNotFireDiagnostic(t *testing.T) {
 	assert.False(t, hasOpIssue(info),
 		"dynamic operand should suppress the type-mismatch hint")
 }
+
+// --- Collection literal tests ----------------------------------------
+
+func TestTypeCheck_ListLiteralAllInt(t *testing.T) {
+	// Homogeneous int list synthesizes to int[].
+	file, info, _ := typeInfoFromSrc(t, "x = [1, 2, 3]\n")
+	assert.Equal(t, "int[]", exprTypeOf(t, file, info).Name())
+}
+
+func TestTypeCheck_ListLiteralIntAndFloatWidensToFloat(t *testing.T) {
+	// The plan's one and only implicit numeric widening: a mix of int
+	// and float collapses to List<float> rather than List<int|float>.
+	// Matches IsAssignableFrom (int flows into float at scalar slots).
+	file, info, _ := typeInfoFromSrc(t, "x = [1, 2.5, 3]\n")
+	assert.Equal(t, "float[]", exprTypeOf(t, file, info).Name())
+}
+
+func TestTypeCheck_ListLiteralMixedNonNumericProducesUnion(t *testing.T) {
+	// Non-numeric mixes don't widen - the element type is a union.
+	file, info, _ := typeInfoFromSrc(t, "x = [1, \"hi\"]\n")
+	assert.Equal(t, "int|str[]", exprTypeOf(t, file, info).Name())
+}
+
+func TestTypeCheck_ListLiteralEmptyIsAnyList(t *testing.T) {
+	// Empty literals fall back to the unparameterized form. No
+	// "annotation required" nagging - a future look-around pass can
+	// refine `xs = []` from later assignments / mutations.
+	file, info, _ := typeInfoFromSrc(t, "x = []\n")
+	assert.Equal(t, "list", exprTypeOf(t, file, info).Name())
+}
+
+func TestTypeCheck_MapLiteralStrIntEntries(t *testing.T) {
+	file, info, _ := typeInfoFromSrc(t, "x = {\"a\": 1, \"b\": 2}\n")
+	assert.Equal(t, "{ str: int }", exprTypeOf(t, file, info).Name())
+}
+
+func TestTypeCheck_MapLiteralMixedValueTypesProducesUnion(t *testing.T) {
+	// Non-widening mix on the value side: keys stay str, values
+	// become int|str.
+	file, info, _ := typeInfoFromSrc(t, "x = {\"a\": 1, \"b\": \"two\"}\n")
+	got := exprTypeOf(t, file, info).Name()
+	assert.Equal(t, "{ str: int|str }", got)
+}
+
+func TestTypeCheck_MapLiteralEmptyIsAnyMap(t *testing.T) {
+	file, info, _ := typeInfoFromSrc(t, "x = {}\n")
+	assert.Equal(t, "map", exprTypeOf(t, file, info).Name())
+}
+
+func TestTypeCheck_NestedListPreservesInnerType(t *testing.T) {
+	// `[[1, 2], [3]]` -> outer is List<List<int>>. Confirms that
+	// element type propagates through recursive synth.
+	file, info, _ := typeInfoFromSrc(t, "x = [[1, 2], [3]]\n")
+	assert.Equal(t, "int[][]", exprTypeOf(t, file, info).Name())
+}
+
+func TestTypeCheck_ListLiteralWithErrorElementPoisons(t *testing.T) {
+	// If any element is ErrorType (typically because its sub-expr
+	// already failed), the whole literal becomes ErrorType so we
+	// don't cascade diagnostics across the bad element's siblings.
+	// Construction: `-"hi"` produces ErrorType, putting it in a list
+	// poisons the list's element type.
+	file, info, _ := typeInfoFromSrc(t, "x = [1, -\"hi\", 3]\n")
+	assert.Equal(t, "<error>", exprTypeOf(t, file, info).Name())
+}