Fix bugs in floating point optimizations

This commit addresses correctness issues in float optimization:

1. Fix type of (/ 0.0): Changed the division type from
   (-> -NonPosReal -NonPosReal) to (-> -NegReal -NonPosReal) to
   correctly handle cases like (/ (min 0.0 0)) which returns +inf.0.

2. Avoid optimizing float exprs when conversion can change result:
   Added safe-to-convert? check to prevent converting large exact
   numbers to infinity before operations. For example,
   (- (expt 10 309) +inf.0) should yield -inf.0, but premature
   conversion to float would give +nan.0.

3. Added tests for these fixes plus a test for make-polar with NaN
   arguments to ensure complex NaN is preserved.

Based on PR racket#1381. Fixes racket#1042.

https://claude.ai/code/session_01UKyzYRFQ9Zm7KsDor34VoY

Author: claude

typed-racket-lib/typed-racket/base-env/base-env-numeric.rkt

@@ -1248,7 +1248,7 @@
     (varop-1+ -InexactReal)
     ;; reals
     (varop-1+ -PosReal -NonNegReal)
-    (-> -NonPosReal -NonPosReal)
+    (-> -NegReal -NonPosReal)
     (-> -NegReal -NegReal -NonNegReal) ; 0.0 is non-neg, but doesn't preserve sign
     (-> -NegReal -PosReal -NonPosReal) ; idem
     (-> -PosReal -NegReal -NonPosReal) ; idem

typed-racket-lib/typed-racket/optimizer/float.rkt

@@ -112,6 +112,14 @@
        (not (subtypeof? stx -SingleFlonum))
        (not (subtypeof? stx -Int))))
 
+;; Check whether an expression can be safely converted to flonum without
+;; changing the result (e.g., a large finite number becoming infinity)
+(define (safe-to-convert? a)
+  (or (subtypeof? a -Fixnum)
+      (syntax-parse a #:literals (quote)
+        [(quote n) #:when (flonum? (syntax-e #'n)) #t]
+        [(quote n) #:when (rational? (real->double-flonum (syntax-e #'n))) #t]
+        [_ #f])))
 
 (define-syntax-class float-opt-expr
   #:commit
@@ -144,8 +152,11 @@
                           (and (subtypeof? this-syntax -Flonum)
                                (for/and ([a (in-syntax #'(fs ...))])
                                  ;; flonum or provably non-zero
+                                 ;; also need to make sure that coercing to float won't change
+                                 ;; a large finite number to infinity, altering the result
                                  (or (subtypeof? a -Flonum)
-                                     (subtypeof? a (Un -PosReal -NegReal))))
+                                     (and (subtypeof? a (Un -PosReal -NegReal))
+                                          (safe-to-convert? a))))
                                (>= 1
                                    (for/sum ([a (in-syntax #'(fs ...))]
                                              #:when (not (subtypeof? a -Flonum)))

typed-racket-test/optimizer/known-bugs.rkt

@@ -19,7 +19,7 @@
 (define (mk-eval lang)
   (call-with-trusted-sandbox-configuration
    (λ ()
-     (parameterize ([sandbox-memory-limit 300])
+     (parameterize ([sandbox-memory-limit 3000])
        (make-evaluator lang)))))
 (define racket-eval (mk-eval 'racket))
 (define tr-eval     (mk-eval 'typed/racket))
@@ -99,7 +99,16 @@
     (good-opt (conjugate 0.0+0.0i))
 
     ;; Magnitude should always return positive results
-    (good-opt (magnitude -1.0-2i))))
+    (good-opt (magnitude -1.0-2i))
+
+    ;; Division of 0.0 should return correct sign
+    (good-opt (/ (min 0.0 0)))
+
+    ;; Subtraction should not convert large numbers to infinity prematurely
+    (good-opt (- (expt 10 309) +inf.0))
+
+    ;; make-polar with NaN should return complex NaN, not real NaN
+    (good-opt (+ 1.0 (make-polar +nan.0 1.0)))))
 
 (module+ main
   (require rackunit/text-ui)