Fix types of variable arity functions to work with 0-argument return values.

Closes PR13218.

original commit: d994ba19146f284809f410962e682c7293c41d63

collects/tests/typed-racket/fail/pr13218.rkt

@@ -0,0 +1,6 @@
+#lang typed/racket
+
+(: sum ((Listof Flonum) -> Flonum))
+(define (sum ws) (apply + ws))
+
+(ann (sum '()) Flonum)

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

@@ -1012,7 +1012,8 @@
     (commutative-binop -NonPosRat -NonNegRat -NonPosRat)
     (-> -NegRat -NegRat -NegRat -NegRat)
     (-> -NonPosRat -NonPosRat -NonPosRat -NonPosRat)
-    (map varop (list -Rat -FlonumZero))
+    (varop -Rat)
+    (varop-1+ -FlonumZero)
     ; no pos * -> pos, possible underflow
     (varop-1+ -NonNegFlonum)
     (-> -NegFlonum -NegFlonum)
@@ -1024,8 +1025,7 @@
     ;; (* <float> 0) is exact 0 (i.e. not a float)
     (commutative-case -NonNegFlonum -PosReal) ; real args don't include 0
     (commutative-case -Flonum (Un -PosReal -NegReal) -Flonum)
-    (map varop (list -Flonum -SingleFlonumZero))
-    (varop-1+ -NonNegSingleFlonum)
+    (map varop-1+ (list -Flonum -SingleFlonumZero -NonNegSingleFlonum))
     ;; we could add contagion rules for negatives, but we haven't for now
     (-> -NegSingleFlonum -NegSingleFlonum)
     (-> -NonPosSingleFlonum -NonPosSingleFlonum)
@@ -1033,17 +1033,16 @@
     (-> -NegSingleFlonum -NegSingleFlonum -NegSingleFlonum -NonPosSingleFlonum)
     (commutative-case -NonNegSingleFlonum (Un -PosRat -NonNegSingleFlonum))
     (commutative-case -SingleFlonum (Un -PosRat -NegRat -SingleFlonum) -SingleFlonum)
-    (map varop (list -SingleFlonum -InexactRealZero))
-    (varop-1+ -NonNegInexactReal)
+    (map varop-1+ (list -SingleFlonum -InexactRealZero -NonNegInexactReal))
     (-> -NegInexactReal -NegInexactReal)
     (-> -NonPosInexactReal -NonPosInexactReal)
     (-> -NegInexactReal -NegInexactReal -NonNegInexactReal)
     (-> -NegInexactReal -NegInexactReal -NegInexactReal -NonPosInexactReal)
     (commutative-case -NonNegInexactReal (Un -PosRat -NonNegInexactReal))
     (commutative-case -InexactReal (Un -PosRat -NegRat -InexactReal) -InexactReal)
-    (varop -InexactReal)
+    (varop-1+ -InexactReal)
     ;; reals
-    (varop-1+ -NonNegReal) ; (* +inf.0 0.0) -> +nan.0
+    (varop -NonNegReal) ; (* +inf.0 0.0) -> +nan.0
     (-> -NegReal -NegReal)
     (-> -NonPosReal -NonPosReal)
     (-> -NegReal -NegReal -NonNegReal)
@@ -1087,7 +1086,7 @@
     (commutative-case -NonNegFlonum -NonNegReal -NonNegFlonum)
     (commutative-case -NonPosFlonum -NonPosReal -NonPosFlonum)
     (commutative-case -Flonum -Real -Flonum)
-    (varop -Flonum)
+    (varop-1+ -Flonum)
     ;; single-flonum + rat -> single-flonum
     (commutative-case -PosSingleFlonum (Un -NonNegRat -NonNegSingleFlonum) -PosSingleFlonum)
     (commutative-case (Un -PosRat -PosSingleFlonum) -NonNegSingleFlonum -PosSingleFlonum)
@@ -1096,7 +1095,7 @@
     (commutative-case -NonNegSingleFlonum (Un -NonNegRat -NonNegSingleFlonum) -NonNegSingleFlonum)
     (commutative-case -NonPosSingleFlonum (Un -NonPosRat -NonPosSingleFlonum) -NonPosSingleFlonum)
     (commutative-case -SingleFlonum (Un -Rat -SingleFlonum) -SingleFlonum)
-    (varop -SingleFlonum)
+    (varop-1+ -SingleFlonum)
     ;; inexact-real + real -> inexact-real
     (commutative-case -PosInexactReal -NonNegReal -PosInexactReal)
     (commutative-case -PosReal -NonNegInexactReal -PosInexactReal)
@@ -1230,7 +1229,7 @@
              (commutative-case -PosRat -Rat)
              (commutative-case -NonNegRat -Rat)
              (map varop (list -NegRat -NonPosRat -Rat
-                              -FlonumPosZero -FlonumNegZero -FlonumZero))
+                                 -FlonumPosZero -FlonumNegZero -FlonumZero))
              ;; inexactness is contagious: (max 3 2.3) => 3.0
              ;; we could add cases to encode that
              (commutative-case -PosFlonum -Flonum)
@@ -1415,7 +1414,7 @@
                ;; closed on negatives, but not closed if we mix with positives
                (map varop (list -NegFixnum -NonPosFixnum))
                (map mix-with-int (list -Fixnum -Nat))
-               (map varop (list  -NegInt -NonPosInt))
+               (map varop (list -NegInt -NonPosInt))
                (null -Int . ->* . -Int)))]
 [bitwise-ior
  (from-cases (varop -Zero)
@@ -1780,14 +1779,14 @@
                  (commutative-case -FlonumZero -Real -FlonumZero)
                  (commutative-case -SingleFlonumZero -Real -SingleFlonumZero)
                  (commutative-case -InexactRealZero -Real -InexactRealZero)
-                 (varop (Un -PosFlonum -NegFlonum) -PosFlonum)
-                 (varop -Flonum -NonNegFlonum)
+                 (varop-1+ (Un -PosFlonum -NegFlonum) -PosFlonum)
+                 (varop-1+ -Flonum -NonNegFlonum)
                  (commutative-case (Un -PosFlonum -NegFlonum) (Un -PosReal -NegReal) -PosFlonum)
                  (commutative-case -Flonum -Real -NonNegFlonum)
-                 (varop (Un -PosSingleFlonum -NegSingleFlonum) -PosSingleFlonum)
-                 (varop -SingleFlonum -NonNegSingleFlonum)
-                 (varop (Un -PosInexactReal -NegInexactReal) -PosInexactReal)
-                 (varop -InexactReal -NonNegInexactReal)
+                 (varop-1+ (Un -PosSingleFlonum -NegSingleFlonum) -PosSingleFlonum)
+                 (varop-1+ -SingleFlonum -NonNegSingleFlonum)
+                 (varop-1+ (Un -PosInexactReal -NegInexactReal) -PosInexactReal)
+                 (varop-1+ -InexactReal -NonNegInexactReal)
                  ;; Note: same as above.
                  (varop (Un -PosReal -NegReal) -PosReal)
                  (varop -Real -NonNegReal))]