Remove TypingOracle::subtype

Summary: `TyName` now only intersect if they are equal.

Reviewed By: ianlevesque

Differential Revision: D48935199

fbshipit-source-id: 8cfb8a73ef66ec294d1210616fc507ddc2d7ca65

Author: stepancheg

starlark/src/eval/compiler/module.rs

@@ -174,7 +174,6 @@ impl<'v> Compiler<'v, '_, '_> {
         let oracle = TypingOracleCtx {
             oracle: &OracleAny,
             codemap: &self.codemap,
-            typecheck_mode: TypecheckMode::Compiler,
         };
         let module_var_types = self.mk_module_var_types();
         for top in stmts.iter_mut() {

starlark/src/typing/oracle/ctx.rs

@@ -31,7 +31,6 @@ use crate::typing::function::Arg;
 use crate::typing::function::Param;
 use crate::typing::function::ParamMode;
 use crate::typing::function::TyFunction;
-use crate::typing::mode::TypecheckMode;
 use crate::typing::starlark_value::TyStarlarkValue;
 use crate::typing::tuple::TyTuple;
 use crate::typing::Ty;
@@ -82,22 +81,9 @@ enum TypingOracleCtxError {
 pub struct TypingOracleCtx<'a> {
     pub(crate) oracle: &'a dyn TypingOracle,
     pub(crate) codemap: &'a CodeMap,
-    pub(crate) typecheck_mode: TypecheckMode,
 }
 
 impl<'a> TypingOracleCtx<'a> {
-    pub(crate) fn subtype(&self, require: &TyName, got: &TyName) -> bool {
-        match self.typecheck_mode {
-            TypecheckMode::Lint => self.oracle.subtype(require, got),
-            TypecheckMode::Compiler => {
-                // Compiler typechecker does not have oracle,
-                // so it does not know anything about opaque types.
-                // This code should go away when we get rid of `Ty::name`.
-                true
-            }
-        }
-    }
-
     pub(crate) fn mk_error(&self, span: Span, err: impl Into<anyhow::Error>) -> TypingError {
         TypingError::new(err.into(), span, self.codemap)
     }
@@ -833,10 +819,6 @@ impl<'a> TypingOracleCtx<'a> {
         false
     }
 
-    fn intersects_name(&self, x: &TyName, y: &TyName) -> bool {
-        x == y || self.subtype(x, y) || self.subtype(y, x)
-    }
-
     pub(crate) fn intersects_basic(&self, x: &TyBasic, y: &TyBasic) -> bool {
         x == y || self.intersects_one_side(x, y) || self.intersects_one_side(y, x)
     }
@@ -846,7 +828,7 @@ impl<'a> TypingOracleCtx<'a> {
     fn intersects_one_side(&self, x: &TyBasic, y: &TyBasic) -> bool {
         match (x, y) {
             (TyBasic::Any, _) => true,
-            (TyBasic::Name(x), TyBasic::Name(y)) => self.intersects_name(x, y),
+            (TyBasic::Name(x), TyBasic::Name(y)) => x == y,
             (TyBasic::Name(_), TyBasic::Custom(_)) => true,
             (TyBasic::Name(_), TyBasic::StarlarkValue(_)) => true,
             (TyBasic::Name(x), y) => Some(x.as_str()) == y.as_name(),

starlark/src/typing/oracle/traits.rs

@@ -100,12 +100,6 @@ pub trait TypingOracle {
     fn attribute(&self, _ty: &TyName, _attr: &str) -> Option<Result<Ty, ()>> {
         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 {
-        false
-    }
 }
 
 /// Declare that there are no attributes, usually used at the end of a [`Vec`].
@@ -128,10 +122,6 @@ impl<T: TypingOracle> TypingOracle for OracleSeq<T> {
     fn attribute(&self, ty: &TyName, attr: &str) -> Option<Result<Ty, ()>> {
         self.0.iter().find_map(|oracle| oracle.attribute(ty, attr))
     }
-
-    fn subtype(&self, require: &TyName, got: &TyName) -> bool {
-        self.0.iter().any(|oracle| oracle.subtype(require, got))
-    }
 }
 
 pub(crate) struct OracleAny;
@@ -144,18 +134,10 @@ impl<'a, T: TypingOracle + ?Sized> TypingOracle for &'a T {
     fn attribute(&self, ty: &TyName, attr: &str) -> Option<Result<Ty, ()>> {
         (*self).attribute(ty, attr)
     }
-
-    fn subtype(&self, require: &TyName, got: &TyName) -> bool {
-        (*self).subtype(require, got)
-    }
 }
 
 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 subtype(&self, require: &TyName, got: &TyName) -> bool {
-        self.as_ref().subtype(require, got)
-    }
 }

starlark/src/typing/typecheck.rs

@@ -214,7 +214,6 @@ impl AstModuleTypecheck for AstModule {
         let oracle = TypingOracleCtx {
             codemap: &codemap,
             oracle,
-            typecheck_mode: TypecheckMode::Lint,
         };
 
         let mut approximations = Vec::new();