encapsulate fns returning unforced types + reformat

frenchy64 · frenchy64 · commit a1b278057795 · 2024-08-12T14:33:09.000-05:00
diff --git a/typed/clj.checker/src/typed/cljc/checker/name_env.clj b/typed/clj.checker/src/typed/cljc/checker/name_env.clj
@@ -42,7 +42,7 @@
                                         symbol?)
                             (some-fn r/Type? #(isa? % temp-binding))))
 
-(t/ann ^:no-check name-env [-> NameEnv])
+(t/ann ^:no-check name-env [t/Any -> NameEnv])
 (defn name-env [checker]
   (get (env/deref-checker checker) impl/current-name-env-kw {}))
 
@@ -51,38 +51,42 @@
   (env/swap-checker! checker assoc impl/current-name-env-kw nme-env)
   nil)
 
-(t/ann ^:no-check find-type-name-entry [t/Sym t/Any -> (t/Nilable (t/MapEntry t/Sym (t/U t/Kw (t/Delay r/Type) [:-> r/Type])))])
+(t/ann ^:no-check find-type-name-entry [t/Sym t/Any -> (t/Nilable (t/MapEntry t/Sym (t/U t/Kw r/Type)))])
 (defn find-type-name-entry [sym opts]
-  (or (find (name-env (env/checker opts)) sym)
-      (when-some [sym-nsym ((requiring-resolve (impl/impl-case opts
-                                                 :clojure 'typed.clj.checker.parse-unparse/ns-rewrites-clj
-                                                 :cljs 'typed.clj.checker.parse-unparse/ns-rewrites-cljs))
-                            (some-> sym namespace symbol))]
-        (find (name-env (env/checker opts))
-              (symbol (name sym-nsym) (name sym))))))
-
-(t/ann ^:no-check find-type-name [t/Sym t/Any -> (t/Nilable (t/U t/Kw (t/Delay r/Type) [:-> r/Type]))])
-(defn find-type-name [sym opts]
-  (or ((name-env (env/checker opts)) sym)
-      (when-some [sym-nsym ((requiring-resolve (impl/impl-case opts
-                                                               :clojure 'typed.clj.checker.parse-unparse/ns-rewrites-clj
-                                                               :cljs 'typed.clj.checker.parse-unparse/ns-rewrites-cljs))
-                            (some-> sym namespace symbol))]
-        ((name-env (env/checker opts))
-         (symbol (name sym-nsym) (name sym))))))
+  (let [env (name-env (env/checker opts))]
+    (some->
+      (or (find env sym)
+          (when-some [sym-nsym (some-> (namespace sym) symbol
+                                       ((requiring-resolve
+                                          (impl/impl-case opts
+                                                          :clojure 'typed.clj.checker.parse-unparse/ns-rewrites-clj
+                                                          :cljs 'typed.clj.checker.parse-unparse/ns-rewrites-cljs))))]
+            (find env (symbol (name sym-nsym) (name sym)))))
+      (update 1 #(force-type % opts)))))
+
+(t/ann ^:no-check get-type-name* [t/Sym t/Any -> (t/Nilable (t/U t/Kw (t/Delay r/Type) [:-> r/Type]))])
+(defn- get-type-name*
+  "Does not resolve type."
+  [sym opts]
+  (let [env (name-env (env/checker opts))]
+    (or (env sym)
+        (when-some [sym-nsym (some-> (namespace sym) symbol
+                                     ((requiring-resolve
+                                        (impl/impl-case opts
+                                          :clojure 'typed.clj.checker.parse-unparse/ns-rewrites-clj
+                                          :cljs 'typed.clj.checker.parse-unparse/ns-rewrites-cljs))))]
+          (env (symbol (name sym-nsym) (name sym)))))))
 
 (t/ann ^:no-check get-type-name [t/Sym t/Any -> (t/U nil t/Kw r/Type)])
 (defn get-type-name
-  "Return the name with var symbol sym.
+  "Return the (forced) type mapped to var with symbol sym.
   Returns nil if not found."
   [sym opts]
   {:pre [(symbol? sym)]
-   :post [(or (assert (or (nil? %)
-                          (keyword? %)
-                          (r/Type? %))
-                      (pr-str %))
-              true)]}
-  (some-> (find-type-name sym opts) (force-type opts)))
+   :post [(or (nil? %)
+              (keyword? %)
+              (r/Type? %))]}
+  (some-> (get-type-name* sym opts) (force-type opts)))
 
 (t/ann ^:no-check add-type-name [t/Any t/Sym (t/U t/Kw r/Type) -> nil])
 (def add-type-name impl/add-tc-type-name)
@@ -117,14 +121,14 @@
     (or (dtenv/get-datatype checker sym opts)
         (prenv/get-protocol checker sym opts)
         (impl/impl-case opts
-                        :clojure (or (rcls/get-rclass checker sym opts)
-                                     (when (class? (resolve sym))
-                                       (c/RClass-of-with-unknown-params sym opts)))
-                        :cljs ((requiring-resolve 'typed.cljs.checker.jsnominal-env/get-jsnominal) sym opts))
-                                        ; during the definition of RClass's that reference
-                                        ; themselves in their definition, a temporary TFn is
-                                        ; added to the declared kind env which is enough to determine
-                                        ; type rank and variance.
+          :clojure (or (rcls/get-rclass checker sym opts)
+                       (when (class? (resolve sym))
+                         (c/RClass-of-with-unknown-params sym opts)))
+          :cljs ((requiring-resolve 'typed.cljs.checker.jsnominal-env/get-jsnominal) sym opts))
+        ; during the definition of RClass's that reference
+        ; themselves in their definition, a temporary TFn is
+        ; added to the declared kind env which is enough to determine
+        ; type rank and variance.
         (kinds/declared-kind-or-nil checker sym opts)
         (cond
           (= impl/protocol-name-type t) (prenv/resolve-protocol checker sym opts)
diff --git a/typed/clj.checker/src/typed/cljc/doc.clj b/typed/clj.checker/src/typed/cljc/doc.clj
@@ -299,14 +299,13 @@
                          (println doc)
                          (println "Forms:" forms))
                        (if-some [[alias-k alias-ty] (name-env/find-type-name-entry rsym opts)]
-                         (let [alias-ty (force-type alias-ty opts)]
-                           (with-out-str
-                             (println "Type alias" alias-k)
-                             (pp/pprint (if (keyword? alias-ty)
-                                          alias-ty
-                                          (prs/unparse-type alias-ty opts)))
-                             (println "Metadata:")
-                             (pp/pprint (meta alias-k))))
+                         (with-out-str
+                           (println "Type alias" alias-k)
+                           (pp/pprint (if (keyword? alias-ty)
+                                        alias-ty
+                                        (prs/unparse-type alias-ty opts)))
+                           (println "Metadata:")
+                           (pp/pprint (meta alias-k)))
                          (if-some [ty (impl/impl-case opts
                                         :clojure (rcls/get-rclass checker rsym opts)
                                         :cljs nil)]
