Fix constrained generic struct/variant type parameters

looksLikeGenericTypeParams (compiler.zig) — the lookahead that decides
whether Name[...] after a type name is a generic-parameter list — only
accepted .ident/.comma inside the brackets, so a constrained parameter
(type Box[T: numeric] struct {...}) fell through to `else => return
false` and the whole declaration was never recognized as generic at
all, despite docs/language.md documenting the same constraint syntax
generic functions already support (isNamedFuncDecl's sibling scanner
already allowed ':'). Fixed by bringing the two scanners in line.

Once recognized as generic, the constraint was still never enforced:
instantiateGenericType built the concrete type args but never checked
them against the declared constraints, unlike generic function calls
(which already run checkTypeArgConstraints). Fixed by calling the same
check during type instantiation.

Author: ganehag

src/compiler_test.zig

@@ -4018,6 +4018,44 @@ test "compiler: self-recursive generic function call with explicit type args" {
     try std.testing.expectEqual(@as(i64, 0), result.int);
 }
 
+// looksLikeGenericTypeParams (compiler.zig) — the lookahead that decides
+// whether `Name[...]` after a type name is a generic-parameter list — only
+// accepted .ident/.comma inside the brackets, so a `:` constraint (e.g.
+// `[T: numeric]`) fell through to `else => return false` and the whole
+// declaration was never even recognized as generic, despite the sibling
+// scanner for generic functions (isNamedFuncDecl) already allowing `:`, and
+// despite docs/language.md explicitly documenting the same constraint
+// syntax for generic types. Fixed by allowing .colon in the type-param
+// scan too, and by wiring checkTypeArgConstraints into
+// instantiateGenericType (compiler_decls.zig) — generic functions already
+// enforced constraints at call time, but generic types never did, even
+// once recognized as generic.
+test "compiler: constrained generic struct type parameter parses and instantiates" {
+    var rt = try setup();
+    defer rt.deinit();
+    try runSrc(&rt,
+        \\type Box[T: numeric] struct { val T }
+        \\func f() int {
+        \\    b := Box[int]{ val: 42 }
+        \\    return b.val
+        \\}
+    );
+    const result = try rt.callGlobal("f", &.{});
+    try std.testing.expectEqual(@as(i64, 42), result.int);
+}
+
+test "compiler: constrained generic struct type parameter rejects a non-conforming type arg" {
+    var rt = try setup();
+    defer rt.deinit();
+    try std.testing.expectError(error.ConstraintViolation, compile(&rt,
+        \\type Box[T: numeric] struct { val T }
+        \\func f() string {
+        \\    b := Box[string]{ val: "hi" }
+        \\    return b.val
+        \\}
+    ));
+}
+
 test "compiler: := infers struct type for dunder dispatch, same as an explicitly var-typed local" {
     // Struct literals previously left no ExprPrimInfo on their own result at
     // all, and := never inferred struct_type for a local either — both

src/lang/compiler.zig

@@ -1921,6 +1921,13 @@ pub const Compiler = struct {
                 .eof => return false,
                 .ident => {},
                 .comma => {},
+                // `[T: numeric]`-style constraint, matching the analogous
+                // scan for generic functions (compiler_decls.zig's
+                // isNamedFuncDecl) — a bare `.colon` here previously
+                // fell through to `else => return false`, so a
+                // constrained generic type was never even recognized as
+                // generic at all (docs/language.md claimed it worked).
+                .colon => {},
                 else => return false,
             }
             t = lx.next();

src/lang/compiler_decls.zig

@@ -1270,6 +1270,16 @@ pub fn instantiateGenericType(c: anytype, tname: []const u8, line: u32) anyerror
     const ginfo = c.registry.getGenericType(tname).?;
     var args: [ct.MaxTypeParams]FieldTypeSpec = undefined;
     const arg_count = try parseInstArgSpecs(c, tname, ginfo.param_count, &args);
+    // Generic functions have enforced type-parameter constraints (e.g.
+    // `[T: numeric]`) since checkTypeArgConstraints existed; generic
+    // struct/variant types parsed and stored the same constraint syntax
+    // (namedTypeDecl) but never checked it here — the parser's lookahead
+    // (looksLikeGenericTypeParams) didn't even recognize a `:` inside
+    // `[...]` as a generic-type declaration at all until this fix, so a
+    // constrained generic type silently failed to parse as generic in the
+    // first place; now that it does, the same enforcement generic
+    // functions already get must apply to instantiation too.
+    try checkTypeArgConstraints(c, ginfo.params[0..ginfo.param_count], args[0..arg_count], tname, line);
     return applyGenericInst(c, tname, args[0..arg_count], line);
 }