Remove TypingOracle::as_function

Summary: Treat any `TyName` as not callable.

Reviewed By: cjhopman

Differential Revision: D48932756

fbshipit-source-id: daa87413a646b79b3e21f18b8503d93fbb29ae88

Author: stepancheg

starlark/src/typing/golden/call_callable_or_unknown.golden

@@ -284,19 +284,12 @@ impl<'a> TypingOracleCtx<'a> {
         &self,
         span: Span,
         ty: &TyName,
-        args: &[Spanned<Arg>],
+        _args: &[Spanned<Arg>],
     ) -> Result<Ty, TypingOrInternalError> {
-        match self.oracle.as_function(ty) {
-            None => {
-                // Unknown type, may be callable.
-                Ok(Ty::any())
-            }
-            Some(Ok(f)) => self.validate_fn_call(span, &f, args),
-            Some(Err(())) => Err(self.mk_error_as_maybe_internal(
-                span,
-                TypingOracleCtxError::CallToNonCallable { ty: ty.to_string() },
-            )),
-        }
+        Err(self.mk_error_as_maybe_internal(
+            span,
+            TypingOracleCtxError::CallToNonCallable { ty: ty.to_string() },
+        ))
     }
 
     #[allow(clippy::collapsible_else_if)]

starlark/src/typing/golden/call_not_callable_or_unknown.golden

@@ -20,7 +20,6 @@
 
 use dupe::Dupe;
 
-use crate::typing::function::TyFunction;
 use crate::typing::ty::Ty;
 use crate::typing::ty::TyName;
 
@@ -102,11 +101,6 @@ pub trait TypingOracle {
         None
     }
 
-    /// If type is callable, return it as function signature.
-    fn as_function(&self, ty: &TyName) -> Option<Result<TyFunction, ()>> {
-        None
-    }
-
     /// If we require the first type, but got the second type, is that OK?
     /// Usually its OK if the requirement is a subtype of the one we got.
     fn subtype(&self, require: &TyName, got: &TyName) -> bool {
@@ -135,10 +129,6 @@ impl<T: TypingOracle> TypingOracle for OracleSeq<T> {
         self.0.iter().find_map(|oracle| oracle.attribute(ty, attr))
     }
 
-    fn as_function(&self, ty: &TyName) -> Option<Result<TyFunction, ()>> {
-        self.0.iter().find_map(|oracle| oracle.as_function(ty))
-    }
-
     fn subtype(&self, require: &TyName, got: &TyName) -> bool {
         self.0.iter().any(|oracle| oracle.subtype(require, got))
     }
@@ -154,9 +144,7 @@ impl<'a, T: TypingOracle + ?Sized> TypingOracle for &'a T {
     fn attribute(&self, ty: &TyName, attr: &str) -> Option<Result<Ty, ()>> {
         (*self).attribute(ty, attr)
     }
-    fn as_function(&self, ty: &TyName) -> Option<Result<TyFunction, ()>> {
-        (*self).as_function(ty)
-    }
+
     fn subtype(&self, require: &TyName, got: &TyName) -> bool {
         (*self).subtype(require, got)
     }
@@ -166,9 +154,7 @@ impl<T: TypingOracle + ?Sized> TypingOracle for Box<T> {
     fn attribute(&self, ty: &TyName, attr: &str) -> Option<Result<Ty, ()>> {
         self.as_ref().attribute(ty, attr)
     }
-    fn as_function(&self, ty: &TyName) -> Option<Result<TyFunction, ()>> {
-        self.as_ref().as_function(ty)
-    }
+
     fn subtype(&self, require: &TyName, got: &TyName) -> bool {
         self.as_ref().subtype(require, got)
     }

starlark/src/typing/golden/call_unknown.golden

@@ -327,19 +327,6 @@ def foo(x: list):
     );
 }
 
-#[test]
-fn test_call_unknown() {
-    TypeCheck::new().check(
-        "call_unknown",
-        r#"
-# @starlark-rust: allow_string_literals_in_type_expr
-
-def foo(x: "unknown"):
-    x()
-"#,
-    );
-}
-
 #[test]
 fn test_call_callable_or_not_callable() {
     TypeCheck::new().check(
@@ -352,34 +339,6 @@ def foo(x: [typing.Callable, str], y: [str, typing.Callable]):
     );
 }
 
-#[test]
-fn test_call_callable_or_unknown() {
-    TypeCheck::new().check(
-        "call_callable_or_unknown",
-        r#"
-# @starlark-rust: allow_string_literals_in_type_expr
-
-def foo(x: [typing.Callable, "unknown"], y: ["unknown", typing.Callable]):
-    x()
-    y()
-"#,
-    );
-}
-
-#[test]
-fn test_call_not_callable_or_unknown() {
-    TypeCheck::new().check(
-        "call_not_callable_or_unknown",
-        r#"
-# @starlark-rust: allow_string_literals_in_type_expr
-
-def foo(x: [str, "unknown"], y: ["unknown", str]):
-    x()
-    y()
-"#,
-    );
-}
-
 #[test]
 fn test_tuple() {
     TypeCheck::new().check(