Fix bugs in floating point optimizations

1. Fix type of (/ 0.0): Changed from (-> -NonPosReal -NonPosReal) to
   (-> -NegReal -NonPosReal) to correctly handle (/ (min 0.0 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.

3. Fix float-complex multiplication crash with exact integer operands:
   The imaginary part calculation was using unsafe-fl* with exact
   integers when non-float optimization preserved exact arithmetic.

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

Author: samth

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-complex.rkt

@@ -208,16 +208,21 @@
                   (define new-imag-id (if both-real?
                                           (mark-as-real (car is))
                                           (car is)))
+                  ;; Helper to convert non-float values to flonum for unsafe ops
+                  (define (maybe-to-float v)
+                    (if (as-non-float v)
+                        #`(real->double-flonum #,v)
+                        v))
                   (loop (car rs) new-imag-id (cdr e1) (cdr e2) (cdr rs) (cdr is)
                         ;; complex multiplication, imag part, then real part (reverse)
                         ;; we eliminate operations on the imaginary parts of reals
                         (list* #`((#,new-imag-id)
                                   #,(cond ((and o-real? e-real?) #'0.0)
-                                          (o-real? #`(unsafe-fl* #,o1 #,(car e2)))
-                                          (e-real? #`(unsafe-fl* #,o2 #,(car e1)))
+                                          (o-real? #`(unsafe-fl* #,(maybe-to-float o1) #,(car e2)))
+                                          (e-real? #`(unsafe-fl* #,o2 #,(maybe-to-float (car e1))))
                                           (else
-                                           #`(unsafe-fl+ (unsafe-fl* #,o2 #,(car e1))
-                                                         (unsafe-fl* #,o1 #,(car e2))))))
+                                           #`(unsafe-fl+ (unsafe-fl* #,o2 #,(maybe-to-float (car e1)))
+                                                         (unsafe-fl* #,(maybe-to-float o1) #,(car e2))))))
                                #`((#,(car rs))
                                   #,(cond [(and o-nf e-nf both-real?)
                                            ;; we haven't seen float operands yet, so

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))
@@ -85,6 +85,9 @@
     ;; Multiplication of multiple args should keep exact semantics for exact args
     (good-opt (* (expt 10 500) (expt 10 -500) 1.0+1.0i))
 
+    ;; Multiplication with multiple exact reals and a float complex should not crash
+    (good-opt (* 2 3 1.0+1.0i))
+
     ;; Addition of multiple args should keep exact semantics for exact args
     (good-opt (+ (expt 10 501) (expt -10 501) 1.0+1.0i))
 
@@ -99,7 +102,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)