Fix racket#1146: Validate row type variable positions

Row type variables (declared with #:row) may only appear in
(Class #:row-var ...) positions, not directly as types. Previously,
code like (All (r #:row) (-> r r)) was accepted but caused internal
errors during type checking.

This fix adds validation in parse-type.rkt to reject row type variables
in invalid positions at parse time, providing a clear error message.

Also keeps defensive checks in check-below.rkt for Row types and void
values from error propagation.

Closes racket#1146

Author: samth

typed-racket-lib/typed-racket/private/parse-type.rkt

@@ -197,6 +197,26 @@
     [_ null]))
 
 
+;; Symbol Type -> Boolean
+;; Check if a row type variable appears in invalid positions (not as Class row-ext)
+;; Returns #t if there are invalid usages
+(define (row-var-in-invalid-position? var-name type)
+  (define found-invalid #f)
+  (let check! ([ty type] [in-row-ext? #f])
+    (match ty
+      [(F: (== var-name))
+       ;; Found the row variable - it's invalid unless we're in a row-ext position
+       (unless in-row-ext?
+         (set! found-invalid #t))]
+      [(Class: row-ext row _ _ _ _)
+       ;; For Class, check row-ext with the flag set
+       (when row-ext
+         (check! row-ext #t))
+       ;; Check the row itself and other parts normally
+       (check! row #f)]
+      [_ (Rep-for-each ty (lambda (t) (check! t #f)))]))
+  found-invalid)
+
 ;; Syntax -> Type
 ;; Parse a Forall type
 (define (parse-all-type stx do-parse)
@@ -227,6 +247,10 @@
      ;; should be no need to extend the constraint environment
      (define body-type
        (extend-tvars (list var*) (do-parse #'t.type)))
+     ;; Check that row variable only appears in valid positions (Class #:row-var)
+     (when (row-var-in-invalid-position? var* body-type)
+       (parse-error "row type variable used in invalid position; row type variables may only appear in (Class #:row-var ...)"
+                    "variable" var*))
      (make-PolyRow
       (list var*)
       ;; No constraints listed, so we need to infer the constraints
@@ -238,10 +262,15 @@
      (define constraints (attribute constr.constraints))
      (extend-row-constraints (list var*) (list constraints)
        (extend-tvars (list var*)
-         (make-PolyRow
-          (list var*)
-          (do-parse #'t.type)
-          constraints)))]
+         (let ([body-type (do-parse #'t.type)])
+           ;; Check that row variable only appears in valid positions (Class #:row-var)
+           (when (row-var-in-invalid-position? var* body-type)
+             (parse-error "row type variable used in invalid position; row type variables may only appear in (Class #:row-var ...)"
+                          "variable" var*))
+           (make-PolyRow
+            (list var*)
+            body-type
+            constraints))))]
     [(:All^ (_:id ...) _ _ _ ...) (parse-error "too many forms in body of All type")]
     [(:All^ . rest) (parse-error "bad syntax")]))
 

typed-racket-lib/typed-racket/typecheck/check-below.rkt

@@ -18,11 +18,11 @@
          "tc-envops.rkt")
 
 (provide/cond-contract
- [check-below (-->i ([s (t) (if (Type? t)
+ [check-below (-->i ([s (t) (if (or (Type? t) (Row? t))
                                 (-or/c full-tc-results/c Type?)
                                 full-tc-results/c)]
-                     [t (-or/c Type? tc-results/c)])
-                    [_ (t) (if (Type? t) Type? full-tc-results/c)])]
+                     [t (-or/c Type? Row? tc-results/c)])
+                    [_ (t) (if (or (Type? t) (Row? t)) Type? full-tc-results/c)])]
  [cond-check-below (-->i ([s (-or/c Type? full-tc-results/c)]
                           [t (s) (-or/c #f (if (Type? s) Type? tc-results/c))])
                          [_ (s) (-or/c #f (if (Type? s) Type? full-tc-results/c))])])
@@ -193,6 +193,17 @@
        (expected-but-got t2 t1))
      (upgrade-trusted-rng t1 expected)]
 
+    ;; Handle void or other invalid inputs from error propagation
+    [((? void?) expected) (fix-results expected)]
+    [(actual (? void?)) actual]
+
+    ;; Handle Row types from row-polymorphic instantiation
+    ;; Row is not a Type?, so it needs special handling
+    [((tc-result1: t1 _ _) (? Row?))
+     ;; For row polymorphism, just return the actual type
+     ;; The row constraint checking happens elsewhere
+     t1]
+
     [(a b) (int-err "unexpected input for check-below: ~a ~a" a b)]))
 
 ;; shallow: if the top-level arrow on t1 is reliable, then upgrade the top-level arrow in t2

typed-racket-test/fail/gh-issue-1146.rkt

@@ -0,0 +1,12 @@
+#;
+(exn-pred #rx"row type variable used in invalid position")
+#lang typed/racket
+
+;; Issue #1146: Row type variables should only appear in (Class #:row-var ...),
+;; not directly as types like (-> r r). Previously this caused internal errors;
+;; now it produces a proper type error.
+
+(: hi (All (r #:row)
+           (-> r r)))
+(define (hi a)
+  a)