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 #1381. Fixes #1042.

Author: samth

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

@@ -1249,7 +1249,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,31 @@
        (not (subtypeof? stx -SingleFlonum))
        (not (subtypeof? stx -Int))))
 
+;; Check if an expression is a literal infinity
+(define (literal-infinity? a)
+  (syntax-parse a #:literal-sets (kernel-literals)
+    [(#%expression e) (literal-infinity? #'e)]
+    [(quote n) #:when (and (flonum? (syntax-e #'n))
+                           (not (rational? (syntax-e #'n))))
+     #t]
+    [_ #f]))
+
+;; Check whether an expression can be safely converted to flonum without
+;; changing the result (e.g., a large finite number becoming infinity).
+;; When there's an infinity operand, converting a huge exact number first
+;; can change semantics (e.g., huge - inf = -inf, but +inf - inf = nan).
+(define (safe-to-convert? a has-infinity-operand?)
+  (or (subtypeof? a -Fixnum)
+      (syntax-parse a #:literal-sets (kernel-literals)
+        [(#%expression e) (safe-to-convert? #'e has-infinity-operand?)]
+        ;; Quoted flonum - already a float, safe
+        [(quote n) #:when (flonum? (syntax-e #'n)) #t]
+        ;; Quoted real number - check if it converts to a finite float
+        [(quote n) #:when (real? (syntax-e #'n))
+         (rational? (real->double-flonum (syntax-e #'n)))]
+        ;; Non-literal expressions: if there's an infinity operand, be conservative
+        ;; because we can't prove the value won't overflow
+        [_ (not has-infinity-operand?)])))
 
 (define-syntax-class float-opt-expr
   #:commit
@@ -129,7 +154,11 @@
                         ;; for now, accept anything that can be coerced to float
                         ;; finer-grained checking is done below
                         (~between fs:float-arg-expr 2 +inf.0) ...)
-           #:when (let* ([safe-to-opt?
+           #:when (let* ([;; Check if any operand is a literal infinity
+                          has-infinity-operand?
+                          (for/or ([a (in-syntax #'(fs ...))])
+                            (literal-infinity? a))]
+                         [safe-to-opt?
                           ;; For it to be safe, we need:
                           ;; - the result to be a float, in which case coercing args to floats
                           ;;   won't change the result type
@@ -141,11 +170,16 @@
                           ;;   operations into float operations by accident.
                           ;;   (Note: could allow for more args, if not next to each other, but
                           ;;    probably not worth the trouble (most ops have 2 args anyway))
+                          ;; - when there's an infinity operand, be more careful about
+                          ;;   converting exact numbers that might overflow
                           (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 has-infinity-operand?))))
                                (>= 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)