Make TyUser public

Summary: Following diff D48893103 uses it to implement proper `Provider` type.

Reviewed By: ianlevesque

Differential Revision: D48893454

fbshipit-source-id: 6144de8d3fdfaa65a086fdeb8cca00c0cfe385b3

Author: stepancheg

starlark/src/typing/mod.rs

@@ -57,9 +57,13 @@ pub use oracle::traits::OracleSeq;
 pub use oracle::traits::TypingBinOp;
 pub use oracle::traits::TypingOracle;
 pub use oracle::traits::TypingUnOp;
+pub use starlark_value::TyStarlarkValue;
 pub use structs::TyStruct;
 pub use ty::Approximation;
 pub use ty::Ty;
 pub use ty::TyName;
 pub use typecheck::AstModuleTypecheck;
 pub use typecheck::TypeMap;
+pub use user::TyUser;
+pub use user::TyUserFields;
+pub use user::TyUserIndex;

starlark/src/typing/starlark_value.rs

@@ -131,7 +131,8 @@ impl Ord for TyStarlarkValue {
 }
 
 impl TyStarlarkValue {
-    pub(crate) const fn new<'v, T: StarlarkValue<'v>>() -> TyStarlarkValue {
+    /// Create a type instance from an implementation of `StarlarkValue`.
+    pub const fn new<'v, T: StarlarkValue<'v>>() -> TyStarlarkValue {
         TyStarlarkValue {
             vtable: &TyStarlarkValueVTableGet::<T::Canonical>::VTABLE,
         }

starlark/src/typing/user.rs

@@ -56,7 +56,7 @@ enum TyUserError {
 
 /// Types of `[]` operator.
 #[derive(Allocative, Debug)]
-pub(crate) struct TyUserIndex {
+pub struct TyUserIndex {
     /// Type of index argument.
     pub(crate) index: Ty,
     /// Type of result.
@@ -65,27 +65,36 @@ pub(crate) struct TyUserIndex {
 
 /// Fields of the struct.
 #[derive(Allocative, Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub(crate) struct TyUserFields {
+pub struct TyUserFields {
     /// Known fields.
-    pub(crate) known: SortedMap<String, Ty>,
+    pub known: SortedMap<String, Ty>,
     /// Are there unknown fields?
     /// Unknown fields are possible if this type represents an abstract type like a provider.
-    pub(crate) unknown: bool,
+    pub unknown: bool,
 }
 
 impl TyUserFields {
-    pub(crate) fn no_fields() -> TyUserFields {
+    /// No fields.
+    pub fn no_fields() -> TyUserFields {
         TyUserFields {
             known: SortedMap::new(),
             unknown: false,
         }
     }
+
+    /// All fields are not known.
+    pub fn unknown() -> TyUserFields {
+        TyUserFields {
+            known: SortedMap::new(),
+            unknown: true,
+        }
+    }
 }
 
 /// Type description for arbitrary type.
 #[derive(Allocative, Debug, derive_more::Display)]
 #[display(fmt = "{}", name)]
-pub(crate) struct TyUser {
+pub struct TyUser {
     name: String,
     /// Base type for this custom type, e.g. generic record for record with known fields.
     base: TyStarlarkValue,
@@ -101,7 +110,8 @@ pub(crate) struct TyUser {
 }
 
 impl TyUser {
-    pub(crate) fn new(
+    /// Constructor.
+    pub fn new(
         name: String,
         base: TyStarlarkValue,
         matcher: Option<TypeMatcherFactory>,

starlark/src/values/types/type_instance_id.rs

@@ -28,10 +28,11 @@ use crate as starlark;
 #[derive(
     Debug, Copy, Clone, Dupe, Hash, Eq, PartialEq, Ord, PartialOrd, Allocative, Freeze
 )]
-pub(crate) struct TypeInstanceId(u64);
+pub struct TypeInstanceId(u64);
 
 impl TypeInstanceId {
-    pub(crate) fn gen() -> TypeInstanceId {
+    /// Generate a new unique identifier.
+    pub fn gen() -> TypeInstanceId {
         static LAST_ID: AtomicU64 = AtomicU64::new(0);
         TypeInstanceId(LAST_ID.fetch_add(1, atomic::Ordering::SeqCst) + 1)
     }

starlark/src/values/typing/mod.rs

@@ -25,6 +25,9 @@ pub mod macro_refs;
 pub(crate) mod never;
 pub(crate) mod type_compiled;
 
+pub use crate::values::types::type_instance_id::TypeInstanceId;
 pub use crate::values::typing::callable::StarlarkCallable;
 pub use crate::values::typing::iter::StarlarkIter;
 pub use crate::values::typing::never::StarlarkNever;
+pub use crate::values::typing::type_compiled::matcher::TypeMatcher;
+pub use crate::values::typing::type_compiled::type_matcher_factory::TypeMatcherFactory;

starlark/src/values/typing/type_compiled/matcher.rs

@@ -27,6 +27,7 @@ use crate::values::Value;
 /// Runtime type matcher. E.g. when `isinstance(1, int)` is called,
 /// implementation of `TypeMatcher` for `int` is used.
 pub trait TypeMatcher: Allocative + Debug + Clone + Sized + Send + Sync + 'static {
+    /// Check if the value matches the type.
     fn matches(&self, value: Value) -> bool;
     /// True if this matcher matches any value.
     fn is_wildcard(&self) -> bool {

starlark/src/values/typing/type_compiled/type_matcher_factory.rs

@@ -56,7 +56,8 @@ pub struct TypeMatcherFactory {
 }
 
 impl TypeMatcherFactory {
-    pub(crate) fn new(matcher: impl TypeMatcher) -> TypeMatcherFactory {
+    /// Create a new `TypeMatcherFactory` from a `TypeMatcher`.
+    pub fn new(matcher: impl TypeMatcher) -> TypeMatcherFactory {
         TypeMatcherFactory {
             factory: Arc::new(TypeMatcherFactoryImpl { matcher }),
         }