Propagate a trivial expected type for recursive lambda if neccessary.

This does not apply an expected type to the actual function body,
it just gives a type to the function when referred to recursively.

This addresses a problem with inference for let loop in lambda as
the argument to `thread` now that `thread` is a keyword function and
therefore lifts its arguments to a `let` ahead of the function.

Fixing the relevant problem also requires improving the type of `thread`.

Author: samth

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

@@ -1601,7 +1601,7 @@
 ;; Section 11.1 (Threads)
 
 ;; Section 11.1.1
-[thread (->key (-> Univ) #:keep (Un (-val #f) (-val 'results)) #f #:pool Univ #f -Thread)]
+[thread (->key (-> ManyUniv) #:keep (Un (-val #f) (-val 'results)) #f #:pool Univ #f -Thread)]
 [thread? (unsafe-shallow:make-pred-ty -Thread)]
 [current-thread (-> -Thread)]
 [thread/suspend-to-kill (-> (-> Univ) -Thread)]

typed-racket-lib/typed-racket/typecheck/tc-app/tc-app-lambda.rkt

@@ -33,7 +33,6 @@
   #:literal-sets (kernel-literals)
   ;; let loop
   (pattern ((letrec-values ([(lp) (~and lam (#%plain-lambda (args ...) . body))]) lp*:id) . actuals)
-    #:when expected
     #:when (not (andmap type-annotation (syntax->list #'(lp args ...))))
     #:when (free-identifier=? #'lp #'lp*)
     (let-loop-check #'lam #'lp #'actuals #'(args ...) #'body expected))
@@ -75,6 +74,7 @@
     [((val acc ...)
       ((~and inner-body (if (#%plain-app (~or pair? null?) val*:id) thn els)))
       (actual actuals ...))
+     #:when expected
      #:when
      (and (free-identifier=? #'val #'val*)
           (ormap (lambda (a) (find-annotation #'inner-body a))
@@ -101,6 +101,7 @@
       ((~or (~and inner-body (if e1 e2 e3:id))
             (~and inner-body (let-values () (if e1 e2 e3:id)))))
       (null-exp actuals ...))
+     #:when expected
      #:when (free-identifier=? #'val #'e3)
      #:when (subtype (tc-expr/t #'null-exp) -Null)
      (let ([ts (for/list ([ac (in-syntax #'(actuals ...))]

typed-racket-lib/typed-racket/typecheck/tc-lambda-unit.rkt

@@ -797,7 +797,9 @@
 ;; Returns both the tc-results of the function and of the body
 (define (tc/rec-lambda/check formals* body name args return)
   (define formals (syntax->list formals*))
-  (define ft (t:->* args (tc-results->values return)))
+  (define ft (if return
+		 (t:->* args (tc-results->values return))
+		 (t:->* args ManyUniv)))
   (define names (cons name formals))
   (with-extended-lexical-env
     [#:identifiers (cons name formals)

typed-racket-test/succeed/events-with-async-channel.rkt

@@ -22,7 +22,7 @@
          (when l ; still something to read
            (intercept l) ; interceptor gets the whole vector
            (clear-events))))
-     (let: loop : Void ()
+     (let loop ()
        (let ([l : (U Log-Receiver-Sync-Result 'stop)
                (sync receiver stop-chan)])
          (cond [(eq? l 'stop)

typed-racket-test/succeed/events.rkt

@@ -21,7 +21,7 @@
          (when l ; still something to read
            (intercept l) ; interceptor gets the whole vector
            (clear-events))))
-     (let: loop : Void ()
+     (let loop ()
        (let: ([l : (U Log-Receiver-Sync-Result 'stop)
                (sync receiver stop-chan)])
          (cond [(eq? l 'stop)

typed-racket-test/unit-tests/typecheck-tests.rkt

@@ -5283,6 +5283,10 @@
           d0)
         (-lst* (-val 2) (-val "abc") (-ivec* (-val 1) (-val "b") (-val 'x)))]
 
+       
+
+       [tc-e (let loop () (loop)) #:ret (-tc-any-results -tt)]
+
        ;; comparisons must correctly account for if the
        ;; #false result was caused by a NaN (see TR Github issue #747)
        ;; less-than
@@ -5718,5 +5722,5 @@
      ([call-with-values (t:-> (t:-> (-values (list -String -String) (list -true-propset -true-propset) (list -empty-obj -empty-obj)))
                               (t:-> -String -String (-values -String -true-propset -empty-obj))
                               (-values -String -true-propset -empty-obj))]))
-   )
+)
   ))