diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 9da8a482da69..9d0b40ce0e00 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -483,6 +483,10 @@ pub fn body(&self, db: &impl HirDatabase) -> Arc { db.body_hir(*self) } + pub fn ty(&self, db: &impl HirDatabase) -> Ty { + db.type_for_def((*self).into(), Namespace::Values) + } + pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSyntaxMapping { let scopes = db.expr_scopes(*self); let syntax_mapping = db.body_syntax_mapping(*self); diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index 34f9ccd07e43..e505c86e3876 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs @@ -1,171 +1,24 @@ -//! The type system. We currently use this to infer types for completion. -//! -//! For type inference, compare the implementations in rustc (the various -//! check_* methods in librustc_typeck/check/mod.rs are a good entry point) and -//! IntelliJ-Rust (org.rust.lang.core.types.infer). Our entry point for -//! inference here is the `infer` function, which infers the types of all -//! expressions in a given function. -//! -//! The central struct here is `Ty`, which represents a type. During inference, -//! it can contain type 'variables' which represent currently unknown types; as -//! we walk through the expressions, we might determine that certain variables -//! need to be equal to each other, or to certain types. To record this, we use -//! the union-find implementation from the `ena` crate, which is extracted from -//! rustc. +//! The type system. We currently use this to infer types for completion, hover +//! information and various assists. mod autoderef; pub(crate) mod primitive; #[cfg(test)] mod tests; pub(crate) mod method_resolution; +mod op; +mod lower; +mod infer; -use std::borrow::Cow; -use std::iter::repeat; -use std::ops::Index; use std::sync::Arc; use std::{fmt, mem}; -use ena::unify::{InPlaceUnificationTable, UnifyKey, UnifyValue, NoError}; -use ra_arena::map::ArenaMap; use join_to_string::join; -use rustc_hash::FxHashMap; -use test_utils::tested_by; +use crate::{Name, AdtDef, type_ref::Mutability}; -use crate::{ - Function, Struct, StructField, Enum, EnumVariant, Path, Name, - FnSignature, ModuleDef, AdtDef, - HirDatabase, - type_ref::{TypeRef, Mutability}, - name::{KnownName}, - expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat, self}, - generics::GenericParams, - path::{ GenericArgs, GenericArg}, - adt::VariantDef, - resolve::{Resolver, Resolution}, nameres::Namespace -}; - -/// The ID of a type variable. -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] -pub struct TypeVarId(u32); - -impl UnifyKey for TypeVarId { - type Value = TypeVarValue; - - fn index(&self) -> u32 { - self.0 - } - - fn from_index(i: u32) -> Self { - TypeVarId(i) - } - - fn tag() -> &'static str { - "TypeVarId" - } -} - -/// The value of a type variable: either we already know the type, or we don't -/// know it yet. -#[derive(Clone, PartialEq, Eq, Debug)] -pub enum TypeVarValue { - Known(Ty), - Unknown, -} - -impl TypeVarValue { - fn known(&self) -> Option<&Ty> { - match self { - TypeVarValue::Known(ty) => Some(ty), - TypeVarValue::Unknown => None, - } - } -} - -impl UnifyValue for TypeVarValue { - type Error = NoError; - - fn unify_values(value1: &Self, value2: &Self) -> Result { - match (value1, value2) { - // We should never equate two type variables, both of which have - // known types. Instead, we recursively equate those types. - (TypeVarValue::Known(t1), TypeVarValue::Known(t2)) => panic!( - "equating two type variables, both of which have known types: {:?} and {:?}", - t1, t2 - ), - - // If one side is known, prefer that one. - (TypeVarValue::Known(..), TypeVarValue::Unknown) => Ok(value1.clone()), - (TypeVarValue::Unknown, TypeVarValue::Known(..)) => Ok(value2.clone()), - - (TypeVarValue::Unknown, TypeVarValue::Unknown) => Ok(TypeVarValue::Unknown), - } - } -} - -/// The kinds of placeholders we need during type inference. There's separate -/// values for general types, and for integer and float variables. The latter -/// two are used for inference of literal values (e.g. `100` could be one of -/// several integer types). -#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] -pub enum InferTy { - TypeVar(TypeVarId), - IntVar(TypeVarId), - FloatVar(TypeVarId), -} - -impl InferTy { - fn to_inner(self) -> TypeVarId { - match self { - InferTy::TypeVar(ty) | InferTy::IntVar(ty) | InferTy::FloatVar(ty) => ty, - } - } - - fn fallback_value(self) -> Ty { - match self { - InferTy::TypeVar(..) => Ty::Unknown, - InferTy::IntVar(..) => { - Ty::Int(primitive::UncertainIntTy::Signed(primitive::IntTy::I32)) - } - InferTy::FloatVar(..) => { - Ty::Float(primitive::UncertainFloatTy::Known(primitive::FloatTy::F64)) - } - } - } -} - -/// When inferring an expression, we propagate downward whatever type hint we -/// are able in the form of an `Expectation`. -#[derive(Clone, PartialEq, Eq, Debug)] -struct Expectation { - ty: Ty, - // TODO: In some cases, we need to be aware whether the expectation is that - // the type match exactly what we passed, or whether it just needs to be - // coercible to the expected type. See Expectation::rvalue_hint in rustc. -} - -impl Expectation { - /// The expectation that the type of the expression needs to equal the given - /// type. - fn has_type(ty: Ty) -> Self { - Expectation { ty } - } - - /// This expresses no expectation on the type. - fn none() -> Self { - Expectation { ty: Ty::Unknown } - } -} - -/// A list of substitutions for generic parameters. -#[derive(Clone, PartialEq, Eq, Debug)] -pub struct Substs(Arc<[Ty]>); - -impl Substs { - pub fn empty() -> Substs { - Substs(Arc::new([])) - } -} +pub(crate) use lower::{TypableDef, CallableDef, type_for_def, type_for_field}; +pub(crate) use infer::{infer, InferenceResult, InferTy}; /// A type. This is based on the `TyKind` enum in rustc (librustc/ty/sty.rs). /// @@ -295,6 +148,16 @@ pub enum Ty { Unknown, } +/// A list of substitutions for generic parameters. +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct Substs(Arc<[Ty]>); + +impl Substs { + pub fn empty() -> Substs { + Substs(Arc::new([])) + } +} + /// A function signature. #[derive(Clone, PartialEq, Eq, Debug)] pub struct FnSig { @@ -303,150 +166,6 @@ pub struct FnSig { } impl Ty { - pub(crate) fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self { - match type_ref { - TypeRef::Never => Ty::Never, - TypeRef::Tuple(inner) => { - let inner_tys = - inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::>(); - Ty::Tuple(inner_tys.into()) - } - TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path), - TypeRef::RawPtr(inner, mutability) => { - let inner_ty = Ty::from_hir(db, resolver, inner); - Ty::RawPtr(Arc::new(inner_ty), *mutability) - } - TypeRef::Array(inner) => { - let inner_ty = Ty::from_hir(db, resolver, inner); - Ty::Array(Arc::new(inner_ty)) - } - TypeRef::Slice(inner) => { - let inner_ty = Ty::from_hir(db, resolver, inner); - Ty::Slice(Arc::new(inner_ty)) - } - TypeRef::Reference(inner, mutability) => { - let inner_ty = Ty::from_hir(db, resolver, inner); - Ty::Ref(Arc::new(inner_ty), *mutability) - } - TypeRef::Placeholder => Ty::Unknown, - TypeRef::Fn(params) => { - let mut inner_tys = - params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::>(); - let return_ty = - inner_tys.pop().expect("TypeRef::Fn should always have at least return type"); - let sig = FnSig { input: inner_tys, output: return_ty }; - Ty::FnPtr(Arc::new(sig)) - } - TypeRef::Error => Ty::Unknown, - } - } - - pub(crate) fn from_hir_path(db: &impl HirDatabase, resolver: &Resolver, path: &Path) -> Self { - if let Some(name) = path.as_ident() { - // TODO handle primitive type names in resolver as well? - if let Some(int_ty) = primitive::UncertainIntTy::from_name(name) { - return Ty::Int(int_ty); - } else if let Some(float_ty) = primitive::UncertainFloatTy::from_name(name) { - return Ty::Float(float_ty); - } else if let Some(known) = name.as_known_name() { - match known { - KnownName::Bool => return Ty::Bool, - KnownName::Char => return Ty::Char, - KnownName::Str => return Ty::Str, - _ => {} - } - } - } - - // Resolve the path (in type namespace) - let resolution = resolver.resolve_path(db, path).take_types(); - - let def = match resolution { - Some(Resolution::Def(def)) => def, - Some(Resolution::LocalBinding(..)) => { - // this should never happen - panic!("path resolved to local binding in type ns"); - } - Some(Resolution::GenericParam(idx)) => { - return Ty::Param { - idx, - // TODO: maybe return name in resolution? - name: path - .as_ident() - .expect("generic param should be single-segment path") - .clone(), - }; - } - Some(Resolution::SelfType(impl_block)) => { - return impl_block.target_ty(db); - } - None => return Ty::Unknown, - }; - - let typable: TypableDef = match def.into() { - None => return Ty::Unknown, - Some(it) => it, - }; - let ty = db.type_for_def(typable, Namespace::Types); - let substs = Ty::substs_from_path(db, resolver, path, typable); - ty.apply_substs(substs) - } - - /// Collect generic arguments from a path into a `Substs`. See also - /// `create_substs_for_ast_path` and `def_to_ty` in rustc. - fn substs_from_path( - db: &impl HirDatabase, - resolver: &Resolver, - path: &Path, - resolved: TypableDef, - ) -> Substs { - let mut substs = Vec::new(); - let last = path.segments.last().expect("path should have at least one segment"); - let (def_generics, segment) = match resolved { - TypableDef::Function(func) => (func.generic_params(db), last), - TypableDef::Struct(s) => (s.generic_params(db), last), - TypableDef::Enum(e) => (e.generic_params(db), last), - TypableDef::EnumVariant(var) => { - // the generic args for an enum variant may be either specified - // on the segment referring to the enum, or on the segment - // referring to the variant. So `Option::::None` and - // `Option::None::` are both allowed (though the former is - // preferred). See also `def_ids_for_path_segments` in rustc. - let len = path.segments.len(); - let segment = if len >= 2 && path.segments[len - 2].args_and_bindings.is_some() { - // Option::::None - &path.segments[len - 2] - } else { - // Option::None:: - last - }; - (var.parent_enum(db).generic_params(db), segment) - } - }; - let parent_param_count = def_generics.count_parent_params(); - substs.extend((0..parent_param_count).map(|_| Ty::Unknown)); - if let Some(generic_args) = &segment.args_and_bindings { - // if args are provided, it should be all of them, but we can't rely on that - let param_count = def_generics.params.len(); - for arg in generic_args.args.iter().take(param_count) { - match arg { - GenericArg::Type(type_ref) => { - let ty = Ty::from_hir(db, resolver, type_ref); - substs.push(ty); - } - } - } - } - // add placeholders for args that were not provided - // TODO: handle defaults - let supplied_params = substs.len(); - for _ in supplied_params..def_generics.count_params_including_parent() { - substs.push(Ty::Unknown); - } - assert_eq!(substs.len(), def_generics.count_params_including_parent()); - Substs(substs.into()) - } - pub fn unit() -> Self { Ty::Tuple(Arc::new([])) } @@ -652,1154 +371,3 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { } } } - -// Functions returning declared types for items - -/// Compute the declared type of a function. This should not need to look at the -/// function body. -fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { - let signature = def.signature(db); - let resolver = def.resolver(db); - let generics = def.generic_params(db); - let name = def.name(db); - let input = - signature.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::>(); - let output = Ty::from_hir(db, &resolver, signature.ret_type()); - let sig = Arc::new(FnSig { input, output }); - let substs = make_substs(&generics); - Ty::FnDef { def: def.into(), sig, name, substs } -} - -/// Compute the type of a tuple struct constructor. -fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty { - let var_data = def.variant_data(db); - let fields = match var_data.fields() { - Some(fields) => fields, - None => return type_for_struct(db, def), // Unit struct - }; - let resolver = def.resolver(db); - let generics = def.generic_params(db); - let name = def.name(db).unwrap_or_else(Name::missing); - let input = fields - .iter() - .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref)) - .collect::>(); - let output = type_for_struct(db, def); - let sig = Arc::new(FnSig { input, output }); - let substs = make_substs(&generics); - Ty::FnDef { def: def.into(), sig, name, substs } -} - -/// Compute the type of a tuple enum variant constructor. -fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty { - let var_data = def.variant_data(db); - let fields = match var_data.fields() { - Some(fields) => fields, - None => return type_for_enum(db, def.parent_enum(db)), // Unit variant - }; - let resolver = def.parent_enum(db).resolver(db); - let generics = def.parent_enum(db).generic_params(db); - let name = def.name(db).unwrap_or_else(Name::missing); - let input = fields - .iter() - .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref)) - .collect::>(); - let substs = make_substs(&generics); - let output = type_for_enum(db, def.parent_enum(db)).apply_substs(substs.clone()); - let sig = Arc::new(FnSig { input, output }); - Ty::FnDef { def: def.into(), sig, name, substs } -} - -fn make_substs(generics: &GenericParams) -> Substs { - Substs( - generics - .params_including_parent() - .into_iter() - .map(|p| Ty::Param { idx: p.idx, name: p.name.clone() }) - .collect::>() - .into(), - ) -} - -fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { - let generics = s.generic_params(db); - Ty::Adt { - def_id: s.into(), - name: s.name(db).unwrap_or_else(Name::missing), - substs: make_substs(&generics), - } -} - -fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty { - let generics = s.generic_params(db); - Ty::Adt { - def_id: s.into(), - name: s.name(db).unwrap_or_else(Name::missing), - substs: make_substs(&generics), - } -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] -pub enum TypableDef { - Function(Function), - Struct(Struct), - Enum(Enum), - EnumVariant(EnumVariant), -} -impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant); - -impl From for Option { - fn from(def: ModuleDef) -> Option { - let res = match def { - ModuleDef::Function(f) => f.into(), - ModuleDef::Struct(s) => s.into(), - ModuleDef::Enum(e) => e.into(), - ModuleDef::EnumVariant(v) => v.into(), - ModuleDef::Const(_) - | ModuleDef::Static(_) - | ModuleDef::Module(_) - | ModuleDef::Trait(_) - | ModuleDef::Type(_) => return None, - }; - Some(res) - } -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] -pub enum CallableDef { - Function(Function), - Struct(Struct), - EnumVariant(EnumVariant), -} -impl_froms!(CallableDef: Function, Struct, EnumVariant); - -pub(super) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace) -> Ty { - match (def, ns) { - (TypableDef::Function(f), Namespace::Values) => type_for_fn(db, f), - (TypableDef::Struct(s), Namespace::Types) => type_for_struct(db, s), - (TypableDef::Struct(s), Namespace::Values) => type_for_struct_constructor(db, s), - (TypableDef::Enum(e), Namespace::Types) => type_for_enum(db, e), - (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v), - - // 'error' cases: - (TypableDef::Function(_), Namespace::Types) => Ty::Unknown, - (TypableDef::Enum(_), Namespace::Values) => Ty::Unknown, - (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown, - } -} - -pub(super) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty { - let parent_def = field.parent_def(db); - let resolver = match parent_def { - VariantDef::Struct(it) => it.resolver(db), - VariantDef::EnumVariant(it) => it.parent_enum(db).resolver(db), - }; - let var_data = parent_def.variant_data(db); - let type_ref = &var_data.fields().unwrap()[field.id].type_ref; - Ty::from_hir(db, &resolver, type_ref) -} - -/// The result of type inference: A mapping from expressions and patterns to types. -#[derive(Clone, PartialEq, Eq, Debug)] -pub struct InferenceResult { - /// For each method call expr, records the function it resolves to. - method_resolutions: FxHashMap, - /// For each field access expr, records the field it resolves to. - field_resolutions: FxHashMap, - type_of_expr: ArenaMap, - type_of_pat: ArenaMap, -} - -impl InferenceResult { - pub fn method_resolution(&self, expr: ExprId) -> Option { - self.method_resolutions.get(&expr).map(|it| *it) - } - pub fn field_resolution(&self, expr: ExprId) -> Option { - self.field_resolutions.get(&expr).map(|it| *it) - } -} - -impl Index for InferenceResult { - type Output = Ty; - - fn index(&self, expr: ExprId) -> &Ty { - self.type_of_expr.get(expr).unwrap_or(&Ty::Unknown) - } -} - -impl Index for InferenceResult { - type Output = Ty; - - fn index(&self, pat: PatId) -> &Ty { - self.type_of_pat.get(pat).unwrap_or(&Ty::Unknown) - } -} - -/// The inference context contains all information needed during type inference. -#[derive(Clone, Debug)] -struct InferenceContext<'a, D: HirDatabase> { - db: &'a D, - body: Arc, - resolver: Resolver, - var_unification_table: InPlaceUnificationTable, - method_resolutions: FxHashMap, - field_resolutions: FxHashMap, - type_of_expr: ArenaMap, - type_of_pat: ArenaMap, - /// The return type of the function being inferred. - return_ty: Ty, -} - -fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty { - match op { - BinaryOp::BooleanOr - | BinaryOp::BooleanAnd - | BinaryOp::EqualityTest - | BinaryOp::NegatedEqualityTest - | BinaryOp::LesserEqualTest - | BinaryOp::GreaterEqualTest - | BinaryOp::LesserTest - | BinaryOp::GreaterTest => Ty::Bool, - BinaryOp::Assignment - | BinaryOp::AddAssign - | BinaryOp::SubAssign - | BinaryOp::DivAssign - | BinaryOp::MulAssign - | BinaryOp::RemAssign - | BinaryOp::ShrAssign - | BinaryOp::ShlAssign - | BinaryOp::BitAndAssign - | BinaryOp::BitOrAssign - | BinaryOp::BitXorAssign => Ty::unit(), - BinaryOp::Addition - | BinaryOp::Subtraction - | BinaryOp::Multiplication - | BinaryOp::Division - | BinaryOp::Remainder - | BinaryOp::LeftShift - | BinaryOp::RightShift - | BinaryOp::BitwiseAnd - | BinaryOp::BitwiseOr - | BinaryOp::BitwiseXor => match rhs_ty { - Ty::Int(..) - | Ty::Float(..) - | Ty::Infer(InferTy::IntVar(..)) - | Ty::Infer(InferTy::FloatVar(..)) => rhs_ty, - _ => Ty::Unknown, - }, - BinaryOp::RangeRightOpen | BinaryOp::RangeRightClosed => Ty::Unknown, - } -} - -fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty { - match op { - BinaryOp::BooleanAnd | BinaryOp::BooleanOr => Ty::Bool, - BinaryOp::Assignment | BinaryOp::EqualityTest => match lhs_ty { - Ty::Int(..) | Ty::Float(..) | Ty::Str | Ty::Char | Ty::Bool => lhs_ty, - _ => Ty::Unknown, - }, - BinaryOp::LesserEqualTest - | BinaryOp::GreaterEqualTest - | BinaryOp::LesserTest - | BinaryOp::GreaterTest - | BinaryOp::AddAssign - | BinaryOp::SubAssign - | BinaryOp::DivAssign - | BinaryOp::MulAssign - | BinaryOp::RemAssign - | BinaryOp::ShrAssign - | BinaryOp::ShlAssign - | BinaryOp::BitAndAssign - | BinaryOp::BitOrAssign - | BinaryOp::BitXorAssign - | BinaryOp::Addition - | BinaryOp::Subtraction - | BinaryOp::Multiplication - | BinaryOp::Division - | BinaryOp::Remainder - | BinaryOp::LeftShift - | BinaryOp::RightShift - | BinaryOp::BitwiseAnd - | BinaryOp::BitwiseOr - | BinaryOp::BitwiseXor => match lhs_ty { - Ty::Int(..) | Ty::Float(..) => lhs_ty, - _ => Ty::Unknown, - }, - _ => Ty::Unknown, - } -} - -impl<'a, D: HirDatabase> InferenceContext<'a, D> { - fn new(db: &'a D, body: Arc, resolver: Resolver) -> Self { - InferenceContext { - method_resolutions: FxHashMap::default(), - field_resolutions: FxHashMap::default(), - type_of_expr: ArenaMap::default(), - type_of_pat: ArenaMap::default(), - var_unification_table: InPlaceUnificationTable::new(), - return_ty: Ty::Unknown, // set in collect_fn_signature - db, - body, - resolver, - } - } - - fn resolve_all(mut self) -> InferenceResult { - let mut tv_stack = Vec::new(); - let mut expr_types = mem::replace(&mut self.type_of_expr, ArenaMap::default()); - for ty in expr_types.values_mut() { - let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown)); - *ty = resolved; - } - let mut pat_types = mem::replace(&mut self.type_of_pat, ArenaMap::default()); - for ty in pat_types.values_mut() { - let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown)); - *ty = resolved; - } - InferenceResult { - method_resolutions: self.method_resolutions, - field_resolutions: self.field_resolutions, - type_of_expr: expr_types, - type_of_pat: pat_types, - } - } - - fn write_expr_ty(&mut self, expr: ExprId, ty: Ty) { - self.type_of_expr.insert(expr, ty); - } - - fn write_method_resolution(&mut self, expr: ExprId, func: Function) { - self.method_resolutions.insert(expr, func); - } - - fn write_field_resolution(&mut self, expr: ExprId, field: StructField) { - self.field_resolutions.insert(expr, field); - } - - fn write_pat_ty(&mut self, pat: PatId, ty: Ty) { - self.type_of_pat.insert(pat, ty); - } - - fn make_ty(&mut self, type_ref: &TypeRef) -> Ty { - let ty = Ty::from_hir( - self.db, - // TODO use right resolver for block - &self.resolver, - type_ref, - ); - let ty = self.insert_type_vars(ty); - ty - } - - fn unify_substs(&mut self, substs1: &Substs, substs2: &Substs, depth: usize) -> bool { - substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth)) - } - - fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool { - self.unify_inner(ty1, ty2, 0) - } - - fn unify_inner(&mut self, ty1: &Ty, ty2: &Ty, depth: usize) -> bool { - if depth > 1000 { - // prevent stackoverflows - panic!("infinite recursion in unification"); - } - if ty1 == ty2 { - return true; - } - // try to resolve type vars first - let ty1 = self.resolve_ty_shallow(ty1); - let ty2 = self.resolve_ty_shallow(ty2); - match (&*ty1, &*ty2) { - (Ty::Unknown, ..) => true, - (.., Ty::Unknown) => true, - (Ty::Int(t1), Ty::Int(t2)) => match (t1, t2) { - (primitive::UncertainIntTy::Unknown, _) - | (_, primitive::UncertainIntTy::Unknown) => true, - _ => t1 == t2, - }, - (Ty::Float(t1), Ty::Float(t2)) => match (t1, t2) { - (primitive::UncertainFloatTy::Unknown, _) - | (_, primitive::UncertainFloatTy::Unknown) => true, - _ => t1 == t2, - }, - (Ty::Bool, _) | (Ty::Str, _) | (Ty::Never, _) | (Ty::Char, _) => ty1 == ty2, - ( - Ty::Adt { def_id: def_id1, substs: substs1, .. }, - Ty::Adt { def_id: def_id2, substs: substs2, .. }, - ) if def_id1 == def_id2 => self.unify_substs(substs1, substs2, depth + 1), - (Ty::Slice(t1), Ty::Slice(t2)) => self.unify_inner(t1, t2, depth + 1), - (Ty::RawPtr(t1, m1), Ty::RawPtr(t2, m2)) if m1 == m2 => { - self.unify_inner(t1, t2, depth + 1) - } - (Ty::Ref(t1, m1), Ty::Ref(t2, m2)) if m1 == m2 => self.unify_inner(t1, t2, depth + 1), - (Ty::FnPtr(sig1), Ty::FnPtr(sig2)) if sig1 == sig2 => true, - (Ty::Tuple(ts1), Ty::Tuple(ts2)) if ts1.len() == ts2.len() => { - ts1.iter().zip(ts2.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth + 1)) - } - (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2))) - | (Ty::Infer(InferTy::IntVar(tv1)), Ty::Infer(InferTy::IntVar(tv2))) - | (Ty::Infer(InferTy::FloatVar(tv1)), Ty::Infer(InferTy::FloatVar(tv2))) => { - // both type vars are unknown since we tried to resolve them - self.var_unification_table.union(*tv1, *tv2); - true - } - (Ty::Infer(InferTy::TypeVar(tv)), other) - | (other, Ty::Infer(InferTy::TypeVar(tv))) - | (Ty::Infer(InferTy::IntVar(tv)), other) - | (other, Ty::Infer(InferTy::IntVar(tv))) - | (Ty::Infer(InferTy::FloatVar(tv)), other) - | (other, Ty::Infer(InferTy::FloatVar(tv))) => { - // the type var is unknown since we tried to resolve it - self.var_unification_table.union_value(*tv, TypeVarValue::Known(other.clone())); - true - } - _ => false, - } - } - - fn new_type_var(&mut self) -> Ty { - Ty::Infer(InferTy::TypeVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) - } - - fn new_integer_var(&mut self) -> Ty { - Ty::Infer(InferTy::IntVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) - } - - fn new_float_var(&mut self) -> Ty { - Ty::Infer(InferTy::FloatVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) - } - - /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it. - fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty { - match ty { - Ty::Unknown => self.new_type_var(), - Ty::Int(primitive::UncertainIntTy::Unknown) => self.new_integer_var(), - Ty::Float(primitive::UncertainFloatTy::Unknown) => self.new_float_var(), - _ => ty, - } - } - - fn insert_type_vars(&mut self, ty: Ty) -> Ty { - ty.fold(&mut |ty| self.insert_type_vars_shallow(ty)) - } - - /// Resolves the type as far as currently possible, replacing type variables - /// by their known types. All types returned by the infer_* functions should - /// be resolved as far as possible, i.e. contain no type variables with - /// known type. - fn resolve_ty_as_possible(&mut self, tv_stack: &mut Vec, ty: Ty) -> Ty { - ty.fold(&mut |ty| match ty { - Ty::Infer(tv) => { - let inner = tv.to_inner(); - if tv_stack.contains(&inner) { - tested_by!(type_var_cycles_resolve_as_possible); - // recursive type - return tv.fallback_value(); - } - if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() { - // known_ty may contain other variables that are known by now - tv_stack.push(inner); - let result = self.resolve_ty_as_possible(tv_stack, known_ty.clone()); - tv_stack.pop(); - result - } else { - ty - } - } - _ => ty, - }) - } - - /// If `ty` is a type variable with known type, returns that type; - /// otherwise, return ty. - fn resolve_ty_shallow<'b>(&mut self, ty: &'b Ty) -> Cow<'b, Ty> { - let mut ty = Cow::Borrowed(ty); - // The type variable could resolve to a int/float variable. Hence try - // resolving up to three times; each type of variable shouldn't occur - // more than once - for i in 0..3 { - if i > 0 { - tested_by!(type_var_resolves_to_int_var); - } - match &*ty { - Ty::Infer(tv) => { - let inner = tv.to_inner(); - match self.var_unification_table.probe_value(inner).known() { - Some(known_ty) => { - // The known_ty can't be a type var itself - ty = Cow::Owned(known_ty.clone()); - } - _ => return ty, - } - } - _ => return ty, - } - } - log::error!("Inference variable still not resolved: {:?}", ty); - ty - } - - /// Resolves the type completely; type variables without known type are - /// replaced by Ty::Unknown. - fn resolve_ty_completely(&mut self, tv_stack: &mut Vec, ty: Ty) -> Ty { - ty.fold(&mut |ty| match ty { - Ty::Infer(tv) => { - let inner = tv.to_inner(); - if tv_stack.contains(&inner) { - tested_by!(type_var_cycles_resolve_completely); - // recursive type - return tv.fallback_value(); - } - if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() { - // known_ty may contain other variables that are known by now - tv_stack.push(inner); - let result = self.resolve_ty_completely(tv_stack, known_ty.clone()); - tv_stack.pop(); - result - } else { - tv.fallback_value() - } - } - _ => ty, - }) - } - - fn infer_path_expr(&mut self, resolver: &Resolver, path: &Path) -> Option { - let resolved = resolver.resolve_path_segments(self.db, &path); - - let (def, remaining_index) = resolved.into_inner(); - - log::debug!( - "path {:?} resolved to {:?} with remaining index {:?}", - path, - def, - remaining_index - ); - - // if the remaining_index is None, we expect the path - // to be fully resolved, in this case we continue with - // the default by attempting to `take_values´ from the resolution. - // Otherwise the path was partially resolved, which means - // we might have resolved into a type for which - // we may find some associated item starting at the - // path.segment pointed to by `remaining_index´ - let resolved = - if remaining_index.is_none() { def.take_values()? } else { def.take_types()? }; - - match resolved { - Resolution::Def(def) => { - let typable: Option = def.into(); - let typable = typable?; - - if let Some(remaining_index) = remaining_index { - let ty = self.db.type_for_def(typable, Namespace::Types); - // TODO: Keep resolving the segments - // if we have more segments to process - let segment = &path.segments[remaining_index]; - - log::debug!("looking for path segment: {:?}", segment); - - // Attempt to find an impl_item for the type which has a name matching - // the current segment - let ty = ty.iterate_impl_items(self.db, |item| match item { - crate::ImplItem::Method(func) => { - let sig = func.signature(self.db); - if segment.name == *sig.name() { - return Some(type_for_fn(self.db, func)); - } - None - } - - // TODO: Resolve associated const - crate::ImplItem::Const(_) => None, - - // TODO: Resolve associated types - crate::ImplItem::Type(_) => None, - }); - ty - } else { - let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable); - let ty = self.db.type_for_def(typable, Namespace::Values).apply_substs(substs); - let ty = self.insert_type_vars(ty); - Some(ty) - } - } - Resolution::LocalBinding(pat) => { - let ty = self.type_of_pat.get(pat)?; - let ty = self.resolve_ty_as_possible(&mut vec![], ty.clone()); - Some(ty) - } - Resolution::GenericParam(..) => { - // generic params can't refer to values... yet - None - } - Resolution::SelfType(_) => { - log::error!("path expr {:?} resolved to Self type in values ns", path); - None - } - } - } - - fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option) { - let path = match path { - Some(path) => path, - None => return (Ty::Unknown, None), - }; - let resolver = &self.resolver; - let typable: Option = match resolver.resolve_path(self.db, &path).take_types() { - Some(Resolution::Def(def)) => def.into(), - Some(Resolution::LocalBinding(..)) => { - // this cannot happen - log::error!("path resolved to local binding in type ns"); - return (Ty::Unknown, None); - } - Some(Resolution::GenericParam(..)) => { - // generic params can't be used in struct literals - return (Ty::Unknown, None); - } - Some(Resolution::SelfType(..)) => { - // TODO this is allowed in an impl for a struct, handle this - return (Ty::Unknown, None); - } - None => return (Ty::Unknown, None), - }; - let def = match typable { - None => return (Ty::Unknown, None), - Some(it) => it, - }; - // TODO remove the duplication between here and `Ty::from_path`? - let substs = Ty::substs_from_path(self.db, resolver, path, def); - match def { - TypableDef::Struct(s) => { - let ty = s.ty(self.db); - let ty = self.insert_type_vars(ty.apply_substs(substs)); - (ty, Some(s.into())) - } - TypableDef::EnumVariant(var) => { - let ty = var.parent_enum(self.db).ty(self.db); - let ty = self.insert_type_vars(ty.apply_substs(substs)); - (ty, Some(var.into())) - } - TypableDef::Function(_) | TypableDef::Enum(_) => (Ty::Unknown, None), - } - } - - fn infer_tuple_struct_pat( - &mut self, - path: Option<&Path>, - subpats: &[PatId], - expected: &Ty, - ) -> Ty { - let (ty, def) = self.resolve_variant(path); - - self.unify(&ty, expected); - - let substs = ty.substs().unwrap_or_else(Substs::empty); - - for (i, &subpat) in subpats.iter().enumerate() { - let expected_ty = def - .and_then(|d| d.field(self.db, &Name::tuple_field_name(i))) - .map_or(Ty::Unknown, |field| field.ty(self.db)) - .subst(&substs); - self.infer_pat(subpat, &expected_ty); - } - - ty - } - - fn infer_struct_pat(&mut self, path: Option<&Path>, subpats: &[FieldPat], expected: &Ty) -> Ty { - let (ty, def) = self.resolve_variant(path); - - self.unify(&ty, expected); - - let substs = ty.substs().unwrap_or_else(Substs::empty); - - for subpat in subpats { - let matching_field = def.and_then(|it| it.field(self.db, &subpat.name)); - let expected_ty = - matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs); - self.infer_pat(subpat.pat, &expected_ty); - } - - ty - } - - fn infer_pat(&mut self, pat: PatId, expected: &Ty) -> Ty { - let body = Arc::clone(&self.body); // avoid borrow checker problem - - let ty = match &body[pat] { - Pat::Tuple(ref args) => { - let expectations = match *expected { - Ty::Tuple(ref tuple_args) => &**tuple_args, - _ => &[], - }; - let expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown)); - - let inner_tys = args - .iter() - .zip(expectations_iter) - .map(|(&pat, ty)| self.infer_pat(pat, ty)) - .collect::>() - .into(); - - Ty::Tuple(inner_tys) - } - Pat::Ref { pat, mutability } => { - let expectation = match *expected { - Ty::Ref(ref sub_ty, exp_mut) => { - if *mutability != exp_mut { - // TODO: emit type error? - } - &**sub_ty - } - _ => &Ty::Unknown, - }; - let subty = self.infer_pat(*pat, expectation); - Ty::Ref(subty.into(), *mutability) - } - Pat::TupleStruct { path: ref p, args: ref subpats } => { - self.infer_tuple_struct_pat(p.as_ref(), subpats, expected) - } - Pat::Struct { path: ref p, args: ref fields } => { - self.infer_struct_pat(p.as_ref(), fields, expected) - } - Pat::Path(path) => { - // TODO use correct resolver for the surrounding expression - let resolver = self.resolver.clone(); - self.infer_path_expr(&resolver, &path).unwrap_or(Ty::Unknown) - } - Pat::Bind { mode, name: _name, subpat } => { - let inner_ty = if let Some(subpat) = subpat { - self.infer_pat(*subpat, expected) - } else { - expected.clone() - }; - let inner_ty = self.insert_type_vars_shallow(inner_ty); - - let bound_ty = match mode { - BindingAnnotation::Ref => Ty::Ref(inner_ty.clone().into(), Mutability::Shared), - BindingAnnotation::RefMut => Ty::Ref(inner_ty.clone().into(), Mutability::Mut), - BindingAnnotation::Mutable | BindingAnnotation::Unannotated => inner_ty.clone(), - }; - let bound_ty = self.resolve_ty_as_possible(&mut vec![], bound_ty); - self.write_pat_ty(pat, bound_ty); - return inner_ty; - } - _ => Ty::Unknown, - }; - // use a new type variable if we got Ty::Unknown here - let ty = self.insert_type_vars_shallow(ty); - self.unify(&ty, expected); - let ty = self.resolve_ty_as_possible(&mut vec![], ty); - self.write_pat_ty(pat, ty.clone()); - ty - } - - fn substs_for_method_call( - &mut self, - def_generics: Option>, - generic_args: &Option, - ) -> Substs { - let (parent_param_count, param_count) = - def_generics.map_or((0, 0), |g| (g.count_parent_params(), g.params.len())); - let mut substs = Vec::with_capacity(parent_param_count + param_count); - for _ in 0..parent_param_count { - substs.push(Ty::Unknown); - } - // handle provided type arguments - if let Some(generic_args) = generic_args { - // if args are provided, it should be all of them, but we can't rely on that - for arg in generic_args.args.iter().take(param_count) { - match arg { - GenericArg::Type(type_ref) => { - let ty = self.make_ty(type_ref); - substs.push(ty); - } - } - } - }; - let supplied_params = substs.len(); - for _ in supplied_params..parent_param_count + param_count { - substs.push(Ty::Unknown); - } - assert_eq!(substs.len(), parent_param_count + param_count); - Substs(substs.into()) - } - - fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty { - let body = Arc::clone(&self.body); // avoid borrow checker problem - let ty = match &body[tgt_expr] { - Expr::Missing => Ty::Unknown, - Expr::If { condition, then_branch, else_branch } => { - // if let is desugared to match, so this is always simple if - self.infer_expr(*condition, &Expectation::has_type(Ty::Bool)); - let then_ty = self.infer_expr(*then_branch, expected); - match else_branch { - Some(else_branch) => { - self.infer_expr(*else_branch, expected); - } - None => { - // no else branch -> unit - self.unify(&then_ty, &Ty::unit()); // actually coerce - } - }; - then_ty - } - Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected), - Expr::Loop { body } => { - self.infer_expr(*body, &Expectation::has_type(Ty::unit())); - // TODO handle break with value - Ty::Never - } - Expr::While { condition, body } => { - // while let is desugared to a match loop, so this is always simple while - self.infer_expr(*condition, &Expectation::has_type(Ty::Bool)); - self.infer_expr(*body, &Expectation::has_type(Ty::unit())); - Ty::unit() - } - Expr::For { iterable, body, pat } => { - let _iterable_ty = self.infer_expr(*iterable, &Expectation::none()); - self.infer_pat(*pat, &Ty::Unknown); - self.infer_expr(*body, &Expectation::has_type(Ty::unit())); - Ty::unit() - } - Expr::Lambda { body, args, arg_types } => { - assert_eq!(args.len(), arg_types.len()); - - for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) { - let expected = if let Some(type_ref) = arg_type { - let ty = self.make_ty(type_ref); - ty - } else { - Ty::Unknown - }; - self.infer_pat(*arg_pat, &expected); - } - - // TODO: infer lambda type etc. - let _body_ty = self.infer_expr(*body, &Expectation::none()); - Ty::Unknown - } - Expr::Call { callee, args } => { - let callee_ty = self.infer_expr(*callee, &Expectation::none()); - let (param_tys, ret_ty) = match &callee_ty { - Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()), - Ty::FnDef { substs, sig, .. } => { - let ret_ty = sig.output.clone().subst(&substs); - let param_tys = - sig.input.iter().map(|ty| ty.clone().subst(&substs)).collect(); - (param_tys, ret_ty) - } - _ => { - // not callable - // TODO report an error? - (Vec::new(), Ty::Unknown) - } - }; - let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown)); - for (arg, param) in args.iter().zip(param_iter) { - self.infer_expr(*arg, &Expectation::has_type(param)); - } - ret_ty - } - Expr::MethodCall { receiver, args, method_name, generic_args } => { - let receiver_ty = self.infer_expr(*receiver, &Expectation::none()); - let resolved = receiver_ty.clone().lookup_method(self.db, method_name); - let (derefed_receiver_ty, method_ty, def_generics) = match resolved { - Some((ty, func)) => { - self.write_method_resolution(tgt_expr, func); - ( - ty, - self.db.type_for_def(func.into(), Namespace::Values), - Some(func.generic_params(self.db)), - ) - } - None => (Ty::Unknown, receiver_ty, None), - }; - let substs = self.substs_for_method_call(def_generics, generic_args); - let method_ty = method_ty.apply_substs(substs); - let method_ty = self.insert_type_vars(method_ty); - let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty { - Ty::FnPtr(sig) => { - if !sig.input.is_empty() { - (sig.input[0].clone(), sig.input[1..].to_vec(), sig.output.clone()) - } else { - (Ty::Unknown, Vec::new(), sig.output.clone()) - } - } - Ty::FnDef { substs, sig, .. } => { - let ret_ty = sig.output.clone().subst(&substs); - - if !sig.input.is_empty() { - let mut arg_iter = sig.input.iter().map(|ty| ty.clone().subst(&substs)); - let receiver_ty = arg_iter.next().unwrap(); - (receiver_ty, arg_iter.collect(), ret_ty) - } else { - (Ty::Unknown, Vec::new(), ret_ty) - } - } - _ => (Ty::Unknown, Vec::new(), Ty::Unknown), - }; - // Apply autoref so the below unification works correctly - let actual_receiver_ty = match expected_receiver_ty { - Ty::Ref(_, mutability) => Ty::Ref(Arc::new(derefed_receiver_ty), mutability), - _ => derefed_receiver_ty, - }; - self.unify(&expected_receiver_ty, &actual_receiver_ty); - - let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown)); - for (arg, param) in args.iter().zip(param_iter) { - self.infer_expr(*arg, &Expectation::has_type(param)); - } - ret_ty - } - Expr::Match { expr, arms } => { - let expected = if expected.ty == Ty::Unknown { - Expectation::has_type(self.new_type_var()) - } else { - expected.clone() - }; - let input_ty = self.infer_expr(*expr, &Expectation::none()); - - for arm in arms { - for &pat in &arm.pats { - let _pat_ty = self.infer_pat(pat, &input_ty); - } - if let Some(guard_expr) = arm.guard { - self.infer_expr(guard_expr, &Expectation::has_type(Ty::Bool)); - } - self.infer_expr(arm.expr, &expected); - } - - expected.ty - } - Expr::Path(p) => { - // TODO this could be more efficient... - let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr); - self.infer_path_expr(&resolver, p).unwrap_or(Ty::Unknown) - } - Expr::Continue => Ty::Never, - Expr::Break { expr } => { - if let Some(expr) = expr { - // TODO handle break with value - self.infer_expr(*expr, &Expectation::none()); - } - Ty::Never - } - Expr::Return { expr } => { - if let Some(expr) = expr { - self.infer_expr(*expr, &Expectation::has_type(self.return_ty.clone())); - } - Ty::Never - } - Expr::StructLit { path, fields, spread } => { - let (ty, def_id) = self.resolve_variant(path.as_ref()); - let substs = ty.substs().unwrap_or_else(Substs::empty); - for field in fields { - let field_ty = def_id - .and_then(|it| it.field(self.db, &field.name)) - .map_or(Ty::Unknown, |field| field.ty(self.db)) - .subst(&substs); - self.infer_expr(field.expr, &Expectation::has_type(field_ty)); - } - if let Some(expr) = spread { - self.infer_expr(*expr, &Expectation::has_type(ty.clone())); - } - ty - } - Expr::Field { expr, name } => { - let receiver_ty = self.infer_expr(*expr, &Expectation::none()); - let ty = receiver_ty - .autoderef(self.db) - .find_map(|derefed_ty| match derefed_ty { - Ty::Tuple(fields) => { - let i = name.to_string().parse::().ok(); - i.and_then(|i| fields.get(i).cloned()) - } - Ty::Adt { def_id: AdtDef::Struct(s), ref substs, .. } => { - s.field(self.db, name).map(|field| { - self.write_field_resolution(tgt_expr, field); - field.ty(self.db).subst(substs) - }) - } - _ => None, - }) - .unwrap_or(Ty::Unknown); - self.insert_type_vars(ty) - } - Expr::Try { expr } => { - let _inner_ty = self.infer_expr(*expr, &Expectation::none()); - Ty::Unknown - } - Expr::Cast { expr, type_ref } => { - let _inner_ty = self.infer_expr(*expr, &Expectation::none()); - let cast_ty = self.make_ty(type_ref); - // TODO check the cast... - cast_ty - } - Expr::Ref { expr, mutability } => { - let expectation = if let Ty::Ref(ref subty, expected_mutability) = expected.ty { - if expected_mutability == Mutability::Mut && *mutability == Mutability::Shared { - // TODO: throw type error - expected mut reference but found shared ref, - // which cannot be coerced - } - Expectation::has_type((**subty).clone()) - } else { - Expectation::none() - }; - // TODO reference coercions etc. - let inner_ty = self.infer_expr(*expr, &expectation); - Ty::Ref(Arc::new(inner_ty), *mutability) - } - Expr::UnaryOp { expr, op } => { - let inner_ty = self.infer_expr(*expr, &Expectation::none()); - match op { - UnaryOp::Deref => { - if let Some(derefed_ty) = inner_ty.builtin_deref() { - derefed_ty - } else { - // TODO Deref::deref - Ty::Unknown - } - } - UnaryOp::Neg => { - match inner_ty { - Ty::Int(primitive::UncertainIntTy::Unknown) - | Ty::Int(primitive::UncertainIntTy::Signed(..)) - | Ty::Infer(InferTy::IntVar(..)) - | Ty::Infer(InferTy::FloatVar(..)) - | Ty::Float(..) => inner_ty, - // TODO: resolve ops::Neg trait - _ => Ty::Unknown, - } - } - UnaryOp::Not => { - match inner_ty { - Ty::Bool | Ty::Int(_) | Ty::Infer(InferTy::IntVar(..)) => inner_ty, - // TODO: resolve ops::Not trait for inner_ty - _ => Ty::Unknown, - } - } - } - } - Expr::BinaryOp { lhs, rhs, op } => match op { - Some(op) => { - let lhs_expectation = match op { - BinaryOp::BooleanAnd | BinaryOp::BooleanOr => { - Expectation::has_type(Ty::Bool) - } - _ => Expectation::none(), - }; - let lhs_ty = self.infer_expr(*lhs, &lhs_expectation); - // TODO: find implementation of trait corresponding to operation - // symbol and resolve associated `Output` type - let rhs_expectation = binary_op_rhs_expectation(*op, lhs_ty); - let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation)); - - // TODO: similar as above, return ty is often associated trait type - binary_op_return_ty(*op, rhs_ty) - } - _ => Ty::Unknown, - }, - Expr::Tuple { exprs } => { - let mut ty_vec = Vec::with_capacity(exprs.len()); - for arg in exprs.iter() { - ty_vec.push(self.infer_expr(*arg, &Expectation::none())); - } - - Ty::Tuple(Arc::from(ty_vec)) - } - Expr::Array { exprs } => { - let elem_ty = match &expected.ty { - Ty::Slice(inner) | Ty::Array(inner) => Ty::clone(&inner), - _ => self.new_type_var(), - }; - - for expr in exprs.iter() { - self.infer_expr(*expr, &Expectation::has_type(elem_ty.clone())); - } - - Ty::Array(Arc::new(elem_ty)) - } - Expr::Literal(lit) => match lit { - Literal::Bool(..) => Ty::Bool, - Literal::String(..) => Ty::Ref(Arc::new(Ty::Str), Mutability::Shared), - Literal::ByteString(..) => { - let byte_type = Arc::new(Ty::Int(primitive::UncertainIntTy::Unsigned( - primitive::UintTy::U8, - ))); - let slice_type = Arc::new(Ty::Slice(byte_type)); - Ty::Ref(slice_type, Mutability::Shared) - } - Literal::Char(..) => Ty::Char, - Literal::Int(_v, ty) => Ty::Int(*ty), - Literal::Float(_v, ty) => Ty::Float(*ty), - }, - }; - // use a new type variable if we got Ty::Unknown here - let ty = self.insert_type_vars_shallow(ty); - self.unify(&ty, &expected.ty); - let ty = self.resolve_ty_as_possible(&mut vec![], ty); - self.write_expr_ty(tgt_expr, ty.clone()); - ty - } - - fn infer_block( - &mut self, - statements: &[Statement], - tail: Option, - expected: &Expectation, - ) -> Ty { - for stmt in statements { - match stmt { - Statement::Let { pat, type_ref, initializer } => { - let decl_ty = - type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown); - let decl_ty = self.insert_type_vars(decl_ty); - let ty = if let Some(expr) = initializer { - let expr_ty = self.infer_expr(*expr, &Expectation::has_type(decl_ty)); - expr_ty - } else { - decl_ty - }; - - self.infer_pat(*pat, &ty); - } - Statement::Expr(expr) => { - self.infer_expr(*expr, &Expectation::none()); - } - } - } - let ty = if let Some(expr) = tail { self.infer_expr(expr, expected) } else { Ty::unit() }; - ty - } - - fn collect_fn_signature(&mut self, signature: &FnSignature) { - let body = Arc::clone(&self.body); // avoid borrow checker problem - for (type_ref, pat) in signature.params().iter().zip(body.params()) { - let ty = self.make_ty(type_ref); - - self.infer_pat(*pat, &ty); - } - self.return_ty = self.make_ty(signature.ret_type()); - } - - fn infer_body(&mut self) { - self.infer_expr(self.body.body_expr(), &Expectation::has_type(self.return_ty.clone())); - } -} - -pub fn infer(db: &impl HirDatabase, func: Function) -> Arc { - db.check_canceled(); - let body = func.body(db); - let resolver = func.resolver(db); - let mut ctx = InferenceContext::new(db, body, resolver); - - let signature = func.signature(db); - ctx.collect_fn_signature(&signature); - - ctx.infer_body(); - - Arc::new(ctx.resolve_all()) -} diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs new file mode 100644 index 000000000000..6ee9080d3838 --- /dev/null +++ b/crates/ra_hir/src/ty/infer.rs @@ -0,0 +1,1079 @@ +//! Type inference, i.e. the process of walking through the code and determining +//! the type of each expression and pattern. +//! +//! For type inference, compare the implementations in rustc (the various +//! check_* methods in librustc_typeck/check/mod.rs are a good entry point) and +//! IntelliJ-Rust (org.rust.lang.core.types.infer). Our entry point for +//! inference here is the `infer` function, which infers the types of all +//! expressions in a given function. +//! +//! During inference, types (i.e. the `Ty` struct) can contain type 'variables' +//! which represent currently unknown types; as we walk through the expressions, +//! we might determine that certain variables need to be equal to each other, or +//! to certain types. To record this, we use the union-find implementation from +//! the `ena` crate, which is extracted from rustc. + +use std::borrow::Cow; +use std::iter::repeat; +use std::ops::Index; +use std::sync::Arc; +use std::mem; + +use ena::unify::{InPlaceUnificationTable, UnifyKey, UnifyValue, NoError}; +use ra_arena::map::ArenaMap; +use rustc_hash::FxHashMap; + +use test_utils::tested_by; + +use crate::{ + Function, StructField, Path, Name, + FnSignature, AdtDef, + HirDatabase, + type_ref::{TypeRef, Mutability}, + expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat, self}, + generics::GenericParams, + path::{GenericArgs, GenericArg}, + adt::VariantDef, + resolve::{Resolver, Resolution}, + nameres::Namespace +}; +use super::{Ty, TypableDef, Substs, primitive, op}; + +/// The entry point of type inference. +pub fn infer(db: &impl HirDatabase, func: Function) -> Arc { + db.check_canceled(); + let body = func.body(db); + let resolver = func.resolver(db); + let mut ctx = InferenceContext::new(db, body, resolver); + + let signature = func.signature(db); + ctx.collect_fn_signature(&signature); + + ctx.infer_body(); + + Arc::new(ctx.resolve_all()) +} + +/// The result of type inference: A mapping from expressions and patterns to types. +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct InferenceResult { + /// For each method call expr, records the function it resolves to. + method_resolutions: FxHashMap, + /// For each field access expr, records the field it resolves to. + field_resolutions: FxHashMap, + pub(super) type_of_expr: ArenaMap, + pub(super) type_of_pat: ArenaMap, +} + +impl InferenceResult { + pub fn method_resolution(&self, expr: ExprId) -> Option { + self.method_resolutions.get(&expr).map(|it| *it) + } + pub fn field_resolution(&self, expr: ExprId) -> Option { + self.field_resolutions.get(&expr).map(|it| *it) + } +} + +impl Index for InferenceResult { + type Output = Ty; + + fn index(&self, expr: ExprId) -> &Ty { + self.type_of_expr.get(expr).unwrap_or(&Ty::Unknown) + } +} + +impl Index for InferenceResult { + type Output = Ty; + + fn index(&self, pat: PatId) -> &Ty { + self.type_of_pat.get(pat).unwrap_or(&Ty::Unknown) + } +} + +/// The inference context contains all information needed during type inference. +#[derive(Clone, Debug)] +struct InferenceContext<'a, D: HirDatabase> { + db: &'a D, + body: Arc, + resolver: Resolver, + var_unification_table: InPlaceUnificationTable, + method_resolutions: FxHashMap, + field_resolutions: FxHashMap, + type_of_expr: ArenaMap, + type_of_pat: ArenaMap, + /// The return type of the function being inferred. + return_ty: Ty, +} + +impl<'a, D: HirDatabase> InferenceContext<'a, D> { + fn new(db: &'a D, body: Arc, resolver: Resolver) -> Self { + InferenceContext { + method_resolutions: FxHashMap::default(), + field_resolutions: FxHashMap::default(), + type_of_expr: ArenaMap::default(), + type_of_pat: ArenaMap::default(), + var_unification_table: InPlaceUnificationTable::new(), + return_ty: Ty::Unknown, // set in collect_fn_signature + db, + body, + resolver, + } + } + + fn resolve_all(mut self) -> InferenceResult { + let mut tv_stack = Vec::new(); + let mut expr_types = mem::replace(&mut self.type_of_expr, ArenaMap::default()); + for ty in expr_types.values_mut() { + let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown)); + *ty = resolved; + } + let mut pat_types = mem::replace(&mut self.type_of_pat, ArenaMap::default()); + for ty in pat_types.values_mut() { + let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown)); + *ty = resolved; + } + InferenceResult { + method_resolutions: self.method_resolutions, + field_resolutions: self.field_resolutions, + type_of_expr: expr_types, + type_of_pat: pat_types, + } + } + + fn write_expr_ty(&mut self, expr: ExprId, ty: Ty) { + self.type_of_expr.insert(expr, ty); + } + + fn write_method_resolution(&mut self, expr: ExprId, func: Function) { + self.method_resolutions.insert(expr, func); + } + + fn write_field_resolution(&mut self, expr: ExprId, field: StructField) { + self.field_resolutions.insert(expr, field); + } + + fn write_pat_ty(&mut self, pat: PatId, ty: Ty) { + self.type_of_pat.insert(pat, ty); + } + + fn make_ty(&mut self, type_ref: &TypeRef) -> Ty { + let ty = Ty::from_hir( + self.db, + // TODO use right resolver for block + &self.resolver, + type_ref, + ); + let ty = self.insert_type_vars(ty); + ty + } + + fn unify_substs(&mut self, substs1: &Substs, substs2: &Substs, depth: usize) -> bool { + substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth)) + } + + fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool { + self.unify_inner(ty1, ty2, 0) + } + + fn unify_inner(&mut self, ty1: &Ty, ty2: &Ty, depth: usize) -> bool { + if depth > 1000 { + // prevent stackoverflows + panic!("infinite recursion in unification"); + } + if ty1 == ty2 { + return true; + } + // try to resolve type vars first + let ty1 = self.resolve_ty_shallow(ty1); + let ty2 = self.resolve_ty_shallow(ty2); + match (&*ty1, &*ty2) { + (Ty::Unknown, ..) => true, + (.., Ty::Unknown) => true, + (Ty::Int(t1), Ty::Int(t2)) => match (t1, t2) { + (primitive::UncertainIntTy::Unknown, _) + | (_, primitive::UncertainIntTy::Unknown) => true, + _ => t1 == t2, + }, + (Ty::Float(t1), Ty::Float(t2)) => match (t1, t2) { + (primitive::UncertainFloatTy::Unknown, _) + | (_, primitive::UncertainFloatTy::Unknown) => true, + _ => t1 == t2, + }, + (Ty::Bool, _) | (Ty::Str, _) | (Ty::Never, _) | (Ty::Char, _) => ty1 == ty2, + ( + Ty::Adt { def_id: def_id1, substs: substs1, .. }, + Ty::Adt { def_id: def_id2, substs: substs2, .. }, + ) if def_id1 == def_id2 => self.unify_substs(substs1, substs2, depth + 1), + (Ty::Slice(t1), Ty::Slice(t2)) => self.unify_inner(t1, t2, depth + 1), + (Ty::RawPtr(t1, m1), Ty::RawPtr(t2, m2)) if m1 == m2 => { + self.unify_inner(t1, t2, depth + 1) + } + (Ty::Ref(t1, m1), Ty::Ref(t2, m2)) if m1 == m2 => self.unify_inner(t1, t2, depth + 1), + (Ty::FnPtr(sig1), Ty::FnPtr(sig2)) if sig1 == sig2 => true, + (Ty::Tuple(ts1), Ty::Tuple(ts2)) if ts1.len() == ts2.len() => { + ts1.iter().zip(ts2.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth + 1)) + } + (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2))) + | (Ty::Infer(InferTy::IntVar(tv1)), Ty::Infer(InferTy::IntVar(tv2))) + | (Ty::Infer(InferTy::FloatVar(tv1)), Ty::Infer(InferTy::FloatVar(tv2))) => { + // both type vars are unknown since we tried to resolve them + self.var_unification_table.union(*tv1, *tv2); + true + } + (Ty::Infer(InferTy::TypeVar(tv)), other) + | (other, Ty::Infer(InferTy::TypeVar(tv))) + | (Ty::Infer(InferTy::IntVar(tv)), other) + | (other, Ty::Infer(InferTy::IntVar(tv))) + | (Ty::Infer(InferTy::FloatVar(tv)), other) + | (other, Ty::Infer(InferTy::FloatVar(tv))) => { + // the type var is unknown since we tried to resolve it + self.var_unification_table.union_value(*tv, TypeVarValue::Known(other.clone())); + true + } + _ => false, + } + } + + fn new_type_var(&mut self) -> Ty { + Ty::Infer(InferTy::TypeVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) + } + + fn new_integer_var(&mut self) -> Ty { + Ty::Infer(InferTy::IntVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) + } + + fn new_float_var(&mut self) -> Ty { + Ty::Infer(InferTy::FloatVar(self.var_unification_table.new_key(TypeVarValue::Unknown))) + } + + /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it. + fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty { + match ty { + Ty::Unknown => self.new_type_var(), + Ty::Int(primitive::UncertainIntTy::Unknown) => self.new_integer_var(), + Ty::Float(primitive::UncertainFloatTy::Unknown) => self.new_float_var(), + _ => ty, + } + } + + fn insert_type_vars(&mut self, ty: Ty) -> Ty { + ty.fold(&mut |ty| self.insert_type_vars_shallow(ty)) + } + + /// Resolves the type as far as currently possible, replacing type variables + /// by their known types. All types returned by the infer_* functions should + /// be resolved as far as possible, i.e. contain no type variables with + /// known type. + fn resolve_ty_as_possible(&mut self, tv_stack: &mut Vec, ty: Ty) -> Ty { + ty.fold(&mut |ty| match ty { + Ty::Infer(tv) => { + let inner = tv.to_inner(); + if tv_stack.contains(&inner) { + tested_by!(type_var_cycles_resolve_as_possible); + // recursive type + return tv.fallback_value(); + } + if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() { + // known_ty may contain other variables that are known by now + tv_stack.push(inner); + let result = self.resolve_ty_as_possible(tv_stack, known_ty.clone()); + tv_stack.pop(); + result + } else { + ty + } + } + _ => ty, + }) + } + + /// If `ty` is a type variable with known type, returns that type; + /// otherwise, return ty. + fn resolve_ty_shallow<'b>(&mut self, ty: &'b Ty) -> Cow<'b, Ty> { + let mut ty = Cow::Borrowed(ty); + // The type variable could resolve to a int/float variable. Hence try + // resolving up to three times; each type of variable shouldn't occur + // more than once + for i in 0..3 { + if i > 0 { + tested_by!(type_var_resolves_to_int_var); + } + match &*ty { + Ty::Infer(tv) => { + let inner = tv.to_inner(); + match self.var_unification_table.probe_value(inner).known() { + Some(known_ty) => { + // The known_ty can't be a type var itself + ty = Cow::Owned(known_ty.clone()); + } + _ => return ty, + } + } + _ => return ty, + } + } + log::error!("Inference variable still not resolved: {:?}", ty); + ty + } + + /// Resolves the type completely; type variables without known type are + /// replaced by Ty::Unknown. + fn resolve_ty_completely(&mut self, tv_stack: &mut Vec, ty: Ty) -> Ty { + ty.fold(&mut |ty| match ty { + Ty::Infer(tv) => { + let inner = tv.to_inner(); + if tv_stack.contains(&inner) { + tested_by!(type_var_cycles_resolve_completely); + // recursive type + return tv.fallback_value(); + } + if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() { + // known_ty may contain other variables that are known by now + tv_stack.push(inner); + let result = self.resolve_ty_completely(tv_stack, known_ty.clone()); + tv_stack.pop(); + result + } else { + tv.fallback_value() + } + } + _ => ty, + }) + } + + fn infer_path_expr(&mut self, resolver: &Resolver, path: &Path) -> Option { + let resolved = resolver.resolve_path_segments(self.db, &path); + + let (def, remaining_index) = resolved.into_inner(); + + log::debug!( + "path {:?} resolved to {:?} with remaining index {:?}", + path, + def, + remaining_index + ); + + // if the remaining_index is None, we expect the path + // to be fully resolved, in this case we continue with + // the default by attempting to `take_values´ from the resolution. + // Otherwise the path was partially resolved, which means + // we might have resolved into a type for which + // we may find some associated item starting at the + // path.segment pointed to by `remaining_index´ + let resolved = + if remaining_index.is_none() { def.take_values()? } else { def.take_types()? }; + + match resolved { + Resolution::Def(def) => { + let typable: Option = def.into(); + let typable = typable?; + + if let Some(remaining_index) = remaining_index { + let ty = self.db.type_for_def(typable, Namespace::Types); + // TODO: Keep resolving the segments + // if we have more segments to process + let segment = &path.segments[remaining_index]; + + log::debug!("looking for path segment: {:?}", segment); + + // Attempt to find an impl_item for the type which has a name matching + // the current segment + let ty = ty.iterate_impl_items(self.db, |item| match item { + crate::ImplItem::Method(func) => { + let sig = func.signature(self.db); + if segment.name == *sig.name() { + return Some(func.ty(self.db)); + } + None + } + + // TODO: Resolve associated const + crate::ImplItem::Const(_) => None, + + // TODO: Resolve associated types + crate::ImplItem::Type(_) => None, + }); + ty + } else { + let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable); + let ty = self.db.type_for_def(typable, Namespace::Values).apply_substs(substs); + let ty = self.insert_type_vars(ty); + Some(ty) + } + } + Resolution::LocalBinding(pat) => { + let ty = self.type_of_pat.get(pat)?; + let ty = self.resolve_ty_as_possible(&mut vec![], ty.clone()); + Some(ty) + } + Resolution::GenericParam(..) => { + // generic params can't refer to values... yet + None + } + Resolution::SelfType(_) => { + log::error!("path expr {:?} resolved to Self type in values ns", path); + None + } + } + } + + fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option) { + let path = match path { + Some(path) => path, + None => return (Ty::Unknown, None), + }; + let resolver = &self.resolver; + let typable: Option = match resolver.resolve_path(self.db, &path).take_types() { + Some(Resolution::Def(def)) => def.into(), + Some(Resolution::LocalBinding(..)) => { + // this cannot happen + log::error!("path resolved to local binding in type ns"); + return (Ty::Unknown, None); + } + Some(Resolution::GenericParam(..)) => { + // generic params can't be used in struct literals + return (Ty::Unknown, None); + } + Some(Resolution::SelfType(..)) => { + // TODO this is allowed in an impl for a struct, handle this + return (Ty::Unknown, None); + } + None => return (Ty::Unknown, None), + }; + let def = match typable { + None => return (Ty::Unknown, None), + Some(it) => it, + }; + // TODO remove the duplication between here and `Ty::from_path`? + let substs = Ty::substs_from_path(self.db, resolver, path, def); + match def { + TypableDef::Struct(s) => { + let ty = s.ty(self.db); + let ty = self.insert_type_vars(ty.apply_substs(substs)); + (ty, Some(s.into())) + } + TypableDef::EnumVariant(var) => { + let ty = var.parent_enum(self.db).ty(self.db); + let ty = self.insert_type_vars(ty.apply_substs(substs)); + (ty, Some(var.into())) + } + TypableDef::Function(_) | TypableDef::Enum(_) => (Ty::Unknown, None), + } + } + + fn infer_tuple_struct_pat( + &mut self, + path: Option<&Path>, + subpats: &[PatId], + expected: &Ty, + ) -> Ty { + let (ty, def) = self.resolve_variant(path); + + self.unify(&ty, expected); + + let substs = ty.substs().unwrap_or_else(Substs::empty); + + for (i, &subpat) in subpats.iter().enumerate() { + let expected_ty = def + .and_then(|d| d.field(self.db, &Name::tuple_field_name(i))) + .map_or(Ty::Unknown, |field| field.ty(self.db)) + .subst(&substs); + self.infer_pat(subpat, &expected_ty); + } + + ty + } + + fn infer_struct_pat(&mut self, path: Option<&Path>, subpats: &[FieldPat], expected: &Ty) -> Ty { + let (ty, def) = self.resolve_variant(path); + + self.unify(&ty, expected); + + let substs = ty.substs().unwrap_or_else(Substs::empty); + + for subpat in subpats { + let matching_field = def.and_then(|it| it.field(self.db, &subpat.name)); + let expected_ty = + matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs); + self.infer_pat(subpat.pat, &expected_ty); + } + + ty + } + + fn infer_pat(&mut self, pat: PatId, expected: &Ty) -> Ty { + let body = Arc::clone(&self.body); // avoid borrow checker problem + + let ty = match &body[pat] { + Pat::Tuple(ref args) => { + let expectations = match *expected { + Ty::Tuple(ref tuple_args) => &**tuple_args, + _ => &[], + }; + let expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown)); + + let inner_tys = args + .iter() + .zip(expectations_iter) + .map(|(&pat, ty)| self.infer_pat(pat, ty)) + .collect::>() + .into(); + + Ty::Tuple(inner_tys) + } + Pat::Ref { pat, mutability } => { + let expectation = match *expected { + Ty::Ref(ref sub_ty, exp_mut) => { + if *mutability != exp_mut { + // TODO: emit type error? + } + &**sub_ty + } + _ => &Ty::Unknown, + }; + let subty = self.infer_pat(*pat, expectation); + Ty::Ref(subty.into(), *mutability) + } + Pat::TupleStruct { path: ref p, args: ref subpats } => { + self.infer_tuple_struct_pat(p.as_ref(), subpats, expected) + } + Pat::Struct { path: ref p, args: ref fields } => { + self.infer_struct_pat(p.as_ref(), fields, expected) + } + Pat::Path(path) => { + // TODO use correct resolver for the surrounding expression + let resolver = self.resolver.clone(); + self.infer_path_expr(&resolver, &path).unwrap_or(Ty::Unknown) + } + Pat::Bind { mode, name: _name, subpat } => { + let inner_ty = if let Some(subpat) = subpat { + self.infer_pat(*subpat, expected) + } else { + expected.clone() + }; + let inner_ty = self.insert_type_vars_shallow(inner_ty); + + let bound_ty = match mode { + BindingAnnotation::Ref => Ty::Ref(inner_ty.clone().into(), Mutability::Shared), + BindingAnnotation::RefMut => Ty::Ref(inner_ty.clone().into(), Mutability::Mut), + BindingAnnotation::Mutable | BindingAnnotation::Unannotated => inner_ty.clone(), + }; + let bound_ty = self.resolve_ty_as_possible(&mut vec![], bound_ty); + self.write_pat_ty(pat, bound_ty); + return inner_ty; + } + _ => Ty::Unknown, + }; + // use a new type variable if we got Ty::Unknown here + let ty = self.insert_type_vars_shallow(ty); + self.unify(&ty, expected); + let ty = self.resolve_ty_as_possible(&mut vec![], ty); + self.write_pat_ty(pat, ty.clone()); + ty + } + + fn substs_for_method_call( + &mut self, + def_generics: Option>, + generic_args: &Option, + ) -> Substs { + let (parent_param_count, param_count) = + def_generics.map_or((0, 0), |g| (g.count_parent_params(), g.params.len())); + let mut substs = Vec::with_capacity(parent_param_count + param_count); + for _ in 0..parent_param_count { + substs.push(Ty::Unknown); + } + // handle provided type arguments + if let Some(generic_args) = generic_args { + // if args are provided, it should be all of them, but we can't rely on that + for arg in generic_args.args.iter().take(param_count) { + match arg { + GenericArg::Type(type_ref) => { + let ty = self.make_ty(type_ref); + substs.push(ty); + } + } + } + }; + let supplied_params = substs.len(); + for _ in supplied_params..parent_param_count + param_count { + substs.push(Ty::Unknown); + } + assert_eq!(substs.len(), parent_param_count + param_count); + Substs(substs.into()) + } + + fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty { + let body = Arc::clone(&self.body); // avoid borrow checker problem + let ty = match &body[tgt_expr] { + Expr::Missing => Ty::Unknown, + Expr::If { condition, then_branch, else_branch } => { + // if let is desugared to match, so this is always simple if + self.infer_expr(*condition, &Expectation::has_type(Ty::Bool)); + let then_ty = self.infer_expr(*then_branch, expected); + match else_branch { + Some(else_branch) => { + self.infer_expr(*else_branch, expected); + } + None => { + // no else branch -> unit + self.unify(&then_ty, &Ty::unit()); // actually coerce + } + }; + then_ty + } + Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected), + Expr::Loop { body } => { + self.infer_expr(*body, &Expectation::has_type(Ty::unit())); + // TODO handle break with value + Ty::Never + } + Expr::While { condition, body } => { + // while let is desugared to a match loop, so this is always simple while + self.infer_expr(*condition, &Expectation::has_type(Ty::Bool)); + self.infer_expr(*body, &Expectation::has_type(Ty::unit())); + Ty::unit() + } + Expr::For { iterable, body, pat } => { + let _iterable_ty = self.infer_expr(*iterable, &Expectation::none()); + self.infer_pat(*pat, &Ty::Unknown); + self.infer_expr(*body, &Expectation::has_type(Ty::unit())); + Ty::unit() + } + Expr::Lambda { body, args, arg_types } => { + assert_eq!(args.len(), arg_types.len()); + + for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) { + let expected = if let Some(type_ref) = arg_type { + let ty = self.make_ty(type_ref); + ty + } else { + Ty::Unknown + }; + self.infer_pat(*arg_pat, &expected); + } + + // TODO: infer lambda type etc. + let _body_ty = self.infer_expr(*body, &Expectation::none()); + Ty::Unknown + } + Expr::Call { callee, args } => { + let callee_ty = self.infer_expr(*callee, &Expectation::none()); + let (param_tys, ret_ty) = match &callee_ty { + Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()), + Ty::FnDef { substs, sig, .. } => { + let ret_ty = sig.output.clone().subst(&substs); + let param_tys = + sig.input.iter().map(|ty| ty.clone().subst(&substs)).collect(); + (param_tys, ret_ty) + } + _ => { + // not callable + // TODO report an error? + (Vec::new(), Ty::Unknown) + } + }; + let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown)); + for (arg, param) in args.iter().zip(param_iter) { + self.infer_expr(*arg, &Expectation::has_type(param)); + } + ret_ty + } + Expr::MethodCall { receiver, args, method_name, generic_args } => { + let receiver_ty = self.infer_expr(*receiver, &Expectation::none()); + let resolved = receiver_ty.clone().lookup_method(self.db, method_name); + let (derefed_receiver_ty, method_ty, def_generics) = match resolved { + Some((ty, func)) => { + self.write_method_resolution(tgt_expr, func); + ( + ty, + self.db.type_for_def(func.into(), Namespace::Values), + Some(func.generic_params(self.db)), + ) + } + None => (Ty::Unknown, receiver_ty, None), + }; + let substs = self.substs_for_method_call(def_generics, generic_args); + let method_ty = method_ty.apply_substs(substs); + let method_ty = self.insert_type_vars(method_ty); + let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty { + Ty::FnPtr(sig) => { + if !sig.input.is_empty() { + (sig.input[0].clone(), sig.input[1..].to_vec(), sig.output.clone()) + } else { + (Ty::Unknown, Vec::new(), sig.output.clone()) + } + } + Ty::FnDef { substs, sig, .. } => { + let ret_ty = sig.output.clone().subst(&substs); + + if !sig.input.is_empty() { + let mut arg_iter = sig.input.iter().map(|ty| ty.clone().subst(&substs)); + let receiver_ty = arg_iter.next().unwrap(); + (receiver_ty, arg_iter.collect(), ret_ty) + } else { + (Ty::Unknown, Vec::new(), ret_ty) + } + } + _ => (Ty::Unknown, Vec::new(), Ty::Unknown), + }; + // Apply autoref so the below unification works correctly + let actual_receiver_ty = match expected_receiver_ty { + Ty::Ref(_, mutability) => Ty::Ref(Arc::new(derefed_receiver_ty), mutability), + _ => derefed_receiver_ty, + }; + self.unify(&expected_receiver_ty, &actual_receiver_ty); + + let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown)); + for (arg, param) in args.iter().zip(param_iter) { + self.infer_expr(*arg, &Expectation::has_type(param)); + } + ret_ty + } + Expr::Match { expr, arms } => { + let expected = if expected.ty == Ty::Unknown { + Expectation::has_type(self.new_type_var()) + } else { + expected.clone() + }; + let input_ty = self.infer_expr(*expr, &Expectation::none()); + + for arm in arms { + for &pat in &arm.pats { + let _pat_ty = self.infer_pat(pat, &input_ty); + } + if let Some(guard_expr) = arm.guard { + self.infer_expr(guard_expr, &Expectation::has_type(Ty::Bool)); + } + self.infer_expr(arm.expr, &expected); + } + + expected.ty + } + Expr::Path(p) => { + // TODO this could be more efficient... + let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr); + self.infer_path_expr(&resolver, p).unwrap_or(Ty::Unknown) + } + Expr::Continue => Ty::Never, + Expr::Break { expr } => { + if let Some(expr) = expr { + // TODO handle break with value + self.infer_expr(*expr, &Expectation::none()); + } + Ty::Never + } + Expr::Return { expr } => { + if let Some(expr) = expr { + self.infer_expr(*expr, &Expectation::has_type(self.return_ty.clone())); + } + Ty::Never + } + Expr::StructLit { path, fields, spread } => { + let (ty, def_id) = self.resolve_variant(path.as_ref()); + let substs = ty.substs().unwrap_or_else(Substs::empty); + for field in fields { + let field_ty = def_id + .and_then(|it| it.field(self.db, &field.name)) + .map_or(Ty::Unknown, |field| field.ty(self.db)) + .subst(&substs); + self.infer_expr(field.expr, &Expectation::has_type(field_ty)); + } + if let Some(expr) = spread { + self.infer_expr(*expr, &Expectation::has_type(ty.clone())); + } + ty + } + Expr::Field { expr, name } => { + let receiver_ty = self.infer_expr(*expr, &Expectation::none()); + let ty = receiver_ty + .autoderef(self.db) + .find_map(|derefed_ty| match derefed_ty { + Ty::Tuple(fields) => { + let i = name.to_string().parse::().ok(); + i.and_then(|i| fields.get(i).cloned()) + } + Ty::Adt { def_id: AdtDef::Struct(s), ref substs, .. } => { + s.field(self.db, name).map(|field| { + self.write_field_resolution(tgt_expr, field); + field.ty(self.db).subst(substs) + }) + } + _ => None, + }) + .unwrap_or(Ty::Unknown); + self.insert_type_vars(ty) + } + Expr::Try { expr } => { + let _inner_ty = self.infer_expr(*expr, &Expectation::none()); + Ty::Unknown + } + Expr::Cast { expr, type_ref } => { + let _inner_ty = self.infer_expr(*expr, &Expectation::none()); + let cast_ty = self.make_ty(type_ref); + // TODO check the cast... + cast_ty + } + Expr::Ref { expr, mutability } => { + let expectation = if let Ty::Ref(ref subty, expected_mutability) = expected.ty { + if expected_mutability == Mutability::Mut && *mutability == Mutability::Shared { + // TODO: throw type error - expected mut reference but found shared ref, + // which cannot be coerced + } + Expectation::has_type((**subty).clone()) + } else { + Expectation::none() + }; + // TODO reference coercions etc. + let inner_ty = self.infer_expr(*expr, &expectation); + Ty::Ref(Arc::new(inner_ty), *mutability) + } + Expr::UnaryOp { expr, op } => { + let inner_ty = self.infer_expr(*expr, &Expectation::none()); + match op { + UnaryOp::Deref => { + if let Some(derefed_ty) = inner_ty.builtin_deref() { + derefed_ty + } else { + // TODO Deref::deref + Ty::Unknown + } + } + UnaryOp::Neg => { + match inner_ty { + Ty::Int(primitive::UncertainIntTy::Unknown) + | Ty::Int(primitive::UncertainIntTy::Signed(..)) + | Ty::Infer(InferTy::IntVar(..)) + | Ty::Infer(InferTy::FloatVar(..)) + | Ty::Float(..) => inner_ty, + // TODO: resolve ops::Neg trait + _ => Ty::Unknown, + } + } + UnaryOp::Not => { + match inner_ty { + Ty::Bool | Ty::Int(_) | Ty::Infer(InferTy::IntVar(..)) => inner_ty, + // TODO: resolve ops::Not trait for inner_ty + _ => Ty::Unknown, + } + } + } + } + Expr::BinaryOp { lhs, rhs, op } => match op { + Some(op) => { + let lhs_expectation = match op { + BinaryOp::BooleanAnd | BinaryOp::BooleanOr => { + Expectation::has_type(Ty::Bool) + } + _ => Expectation::none(), + }; + let lhs_ty = self.infer_expr(*lhs, &lhs_expectation); + // TODO: find implementation of trait corresponding to operation + // symbol and resolve associated `Output` type + let rhs_expectation = op::binary_op_rhs_expectation(*op, lhs_ty); + let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation)); + + // TODO: similar as above, return ty is often associated trait type + op::binary_op_return_ty(*op, rhs_ty) + } + _ => Ty::Unknown, + }, + Expr::Tuple { exprs } => { + let mut ty_vec = Vec::with_capacity(exprs.len()); + for arg in exprs.iter() { + ty_vec.push(self.infer_expr(*arg, &Expectation::none())); + } + + Ty::Tuple(Arc::from(ty_vec)) + } + Expr::Array { exprs } => { + let elem_ty = match &expected.ty { + Ty::Slice(inner) | Ty::Array(inner) => Ty::clone(&inner), + _ => self.new_type_var(), + }; + + for expr in exprs.iter() { + self.infer_expr(*expr, &Expectation::has_type(elem_ty.clone())); + } + + Ty::Array(Arc::new(elem_ty)) + } + Expr::Literal(lit) => match lit { + Literal::Bool(..) => Ty::Bool, + Literal::String(..) => Ty::Ref(Arc::new(Ty::Str), Mutability::Shared), + Literal::ByteString(..) => { + let byte_type = Arc::new(Ty::Int(primitive::UncertainIntTy::Unsigned( + primitive::UintTy::U8, + ))); + let slice_type = Arc::new(Ty::Slice(byte_type)); + Ty::Ref(slice_type, Mutability::Shared) + } + Literal::Char(..) => Ty::Char, + Literal::Int(_v, ty) => Ty::Int(*ty), + Literal::Float(_v, ty) => Ty::Float(*ty), + }, + }; + // use a new type variable if we got Ty::Unknown here + let ty = self.insert_type_vars_shallow(ty); + self.unify(&ty, &expected.ty); + let ty = self.resolve_ty_as_possible(&mut vec![], ty); + self.write_expr_ty(tgt_expr, ty.clone()); + ty + } + + fn infer_block( + &mut self, + statements: &[Statement], + tail: Option, + expected: &Expectation, + ) -> Ty { + for stmt in statements { + match stmt { + Statement::Let { pat, type_ref, initializer } => { + let decl_ty = + type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown); + let decl_ty = self.insert_type_vars(decl_ty); + let ty = if let Some(expr) = initializer { + let expr_ty = self.infer_expr(*expr, &Expectation::has_type(decl_ty)); + expr_ty + } else { + decl_ty + }; + + self.infer_pat(*pat, &ty); + } + Statement::Expr(expr) => { + self.infer_expr(*expr, &Expectation::none()); + } + } + } + let ty = if let Some(expr) = tail { self.infer_expr(expr, expected) } else { Ty::unit() }; + ty + } + + fn collect_fn_signature(&mut self, signature: &FnSignature) { + let body = Arc::clone(&self.body); // avoid borrow checker problem + for (type_ref, pat) in signature.params().iter().zip(body.params()) { + let ty = self.make_ty(type_ref); + + self.infer_pat(*pat, &ty); + } + self.return_ty = self.make_ty(signature.ret_type()); + } + + fn infer_body(&mut self) { + self.infer_expr(self.body.body_expr(), &Expectation::has_type(self.return_ty.clone())); + } +} + +/// The ID of a type variable. +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] +pub struct TypeVarId(u32); + +impl UnifyKey for TypeVarId { + type Value = TypeVarValue; + + fn index(&self) -> u32 { + self.0 + } + + fn from_index(i: u32) -> Self { + TypeVarId(i) + } + + fn tag() -> &'static str { + "TypeVarId" + } +} + +/// The value of a type variable: either we already know the type, or we don't +/// know it yet. +#[derive(Clone, PartialEq, Eq, Debug)] +pub enum TypeVarValue { + Known(Ty), + Unknown, +} + +impl TypeVarValue { + fn known(&self) -> Option<&Ty> { + match self { + TypeVarValue::Known(ty) => Some(ty), + TypeVarValue::Unknown => None, + } + } +} + +impl UnifyValue for TypeVarValue { + type Error = NoError; + + fn unify_values(value1: &Self, value2: &Self) -> Result { + match (value1, value2) { + // We should never equate two type variables, both of which have + // known types. Instead, we recursively equate those types. + (TypeVarValue::Known(t1), TypeVarValue::Known(t2)) => panic!( + "equating two type variables, both of which have known types: {:?} and {:?}", + t1, t2 + ), + + // If one side is known, prefer that one. + (TypeVarValue::Known(..), TypeVarValue::Unknown) => Ok(value1.clone()), + (TypeVarValue::Unknown, TypeVarValue::Known(..)) => Ok(value2.clone()), + + (TypeVarValue::Unknown, TypeVarValue::Unknown) => Ok(TypeVarValue::Unknown), + } + } +} + +/// The kinds of placeholders we need during type inference. There's separate +/// values for general types, and for integer and float variables. The latter +/// two are used for inference of literal values (e.g. `100` could be one of +/// several integer types). +#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] +pub enum InferTy { + TypeVar(TypeVarId), + IntVar(TypeVarId), + FloatVar(TypeVarId), +} + +impl InferTy { + fn to_inner(self) -> TypeVarId { + match self { + InferTy::TypeVar(ty) | InferTy::IntVar(ty) | InferTy::FloatVar(ty) => ty, + } + } + + fn fallback_value(self) -> Ty { + match self { + InferTy::TypeVar(..) => Ty::Unknown, + InferTy::IntVar(..) => { + Ty::Int(primitive::UncertainIntTy::Signed(primitive::IntTy::I32)) + } + InferTy::FloatVar(..) => { + Ty::Float(primitive::UncertainFloatTy::Known(primitive::FloatTy::F64)) + } + } + } +} + +/// When inferring an expression, we propagate downward whatever type hint we +/// are able in the form of an `Expectation`. +#[derive(Clone, PartialEq, Eq, Debug)] +struct Expectation { + ty: Ty, + // TODO: In some cases, we need to be aware whether the expectation is that + // the type match exactly what we passed, or whether it just needs to be + // coercible to the expected type. See Expectation::rvalue_hint in rustc. +} + +impl Expectation { + /// The expectation that the type of the expression needs to equal the given + /// type. + fn has_type(ty: Ty) -> Self { + Expectation { ty } + } + + /// This expresses no expectation on the type. + fn none() -> Self { + Expectation { ty: Ty::Unknown } + } +} diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs new file mode 100644 index 000000000000..cc9e0fd40e20 --- /dev/null +++ b/crates/ra_hir/src/ty/lower.rs @@ -0,0 +1,318 @@ +//! Methods for lowering the HIR to types. There are two main cases here: +//! +//! - Lowering a type reference like `&usize` or `Option` to a +//! type: The entry point for this is `Ty::from_hir`. +//! - Building the type for an item: This happens through the `type_for_def` query. +//! +//! This usually involves resolving names, collecting generic arguments etc. + +use std::sync::Arc; + +use crate::{ + Function, Struct, StructField, Enum, EnumVariant, Path, Name, + ModuleDef, + HirDatabase, + type_ref::TypeRef, + name::KnownName, + nameres::Namespace, + resolve::{Resolver, Resolution}, + path::GenericArg, + generics::GenericParams, + adt::VariantDef, +}; +use super::{Ty, primitive, FnSig, Substs}; + +impl Ty { + pub(crate) fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self { + match type_ref { + TypeRef::Never => Ty::Never, + TypeRef::Tuple(inner) => { + let inner_tys = + inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::>(); + Ty::Tuple(inner_tys.into()) + } + TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path), + TypeRef::RawPtr(inner, mutability) => { + let inner_ty = Ty::from_hir(db, resolver, inner); + Ty::RawPtr(Arc::new(inner_ty), *mutability) + } + TypeRef::Array(inner) => { + let inner_ty = Ty::from_hir(db, resolver, inner); + Ty::Array(Arc::new(inner_ty)) + } + TypeRef::Slice(inner) => { + let inner_ty = Ty::from_hir(db, resolver, inner); + Ty::Slice(Arc::new(inner_ty)) + } + TypeRef::Reference(inner, mutability) => { + let inner_ty = Ty::from_hir(db, resolver, inner); + Ty::Ref(Arc::new(inner_ty), *mutability) + } + TypeRef::Placeholder => Ty::Unknown, + TypeRef::Fn(params) => { + let mut inner_tys = + params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::>(); + let return_ty = + inner_tys.pop().expect("TypeRef::Fn should always have at least return type"); + let sig = FnSig { input: inner_tys, output: return_ty }; + Ty::FnPtr(Arc::new(sig)) + } + TypeRef::Error => Ty::Unknown, + } + } + + pub(crate) fn from_hir_path(db: &impl HirDatabase, resolver: &Resolver, path: &Path) -> Self { + if let Some(name) = path.as_ident() { + // TODO handle primitive type names in resolver as well? + if let Some(int_ty) = primitive::UncertainIntTy::from_name(name) { + return Ty::Int(int_ty); + } else if let Some(float_ty) = primitive::UncertainFloatTy::from_name(name) { + return Ty::Float(float_ty); + } else if let Some(known) = name.as_known_name() { + match known { + KnownName::Bool => return Ty::Bool, + KnownName::Char => return Ty::Char, + KnownName::Str => return Ty::Str, + _ => {} + } + } + } + + // Resolve the path (in type namespace) + let resolution = resolver.resolve_path(db, path).take_types(); + + let def = match resolution { + Some(Resolution::Def(def)) => def, + Some(Resolution::LocalBinding(..)) => { + // this should never happen + panic!("path resolved to local binding in type ns"); + } + Some(Resolution::GenericParam(idx)) => { + return Ty::Param { + idx, + // TODO: maybe return name in resolution? + name: path + .as_ident() + .expect("generic param should be single-segment path") + .clone(), + }; + } + Some(Resolution::SelfType(impl_block)) => { + return impl_block.target_ty(db); + } + None => return Ty::Unknown, + }; + + let typable: TypableDef = match def.into() { + None => return Ty::Unknown, + Some(it) => it, + }; + let ty = db.type_for_def(typable, Namespace::Types); + let substs = Ty::substs_from_path(db, resolver, path, typable); + ty.apply_substs(substs) + } + + /// Collect generic arguments from a path into a `Substs`. See also + /// `create_substs_for_ast_path` and `def_to_ty` in rustc. + pub(super) fn substs_from_path( + db: &impl HirDatabase, + resolver: &Resolver, + path: &Path, + resolved: TypableDef, + ) -> Substs { + let mut substs = Vec::new(); + let last = path.segments.last().expect("path should have at least one segment"); + let (def_generics, segment) = match resolved { + TypableDef::Function(func) => (func.generic_params(db), last), + TypableDef::Struct(s) => (s.generic_params(db), last), + TypableDef::Enum(e) => (e.generic_params(db), last), + TypableDef::EnumVariant(var) => { + // the generic args for an enum variant may be either specified + // on the segment referring to the enum, or on the segment + // referring to the variant. So `Option::::None` and + // `Option::None::` are both allowed (though the former is + // preferred). See also `def_ids_for_path_segments` in rustc. + let len = path.segments.len(); + let segment = if len >= 2 && path.segments[len - 2].args_and_bindings.is_some() { + // Option::::None + &path.segments[len - 2] + } else { + // Option::None:: + last + }; + (var.parent_enum(db).generic_params(db), segment) + } + }; + let parent_param_count = def_generics.count_parent_params(); + substs.extend((0..parent_param_count).map(|_| Ty::Unknown)); + if let Some(generic_args) = &segment.args_and_bindings { + // if args are provided, it should be all of them, but we can't rely on that + let param_count = def_generics.params.len(); + for arg in generic_args.args.iter().take(param_count) { + match arg { + GenericArg::Type(type_ref) => { + let ty = Ty::from_hir(db, resolver, type_ref); + substs.push(ty); + } + } + } + } + // add placeholders for args that were not provided + // TODO: handle defaults + let supplied_params = substs.len(); + for _ in supplied_params..def_generics.count_params_including_parent() { + substs.push(Ty::Unknown); + } + assert_eq!(substs.len(), def_generics.count_params_including_parent()); + Substs(substs.into()) + } +} + +/// Build the declared type of an item. This depends on the namespace; e.g. for +/// `struct Foo(usize)`, we have two types: The type of the struct itself, and +/// the constructor function `(usize) -> Foo` which lives in the values +/// namespace. +pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace) -> Ty { + match (def, ns) { + (TypableDef::Function(f), Namespace::Values) => type_for_fn(db, f), + (TypableDef::Struct(s), Namespace::Types) => type_for_struct(db, s), + (TypableDef::Struct(s), Namespace::Values) => type_for_struct_constructor(db, s), + (TypableDef::Enum(e), Namespace::Types) => type_for_enum(db, e), + (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v), + + // 'error' cases: + (TypableDef::Function(_), Namespace::Types) => Ty::Unknown, + (TypableDef::Enum(_), Namespace::Values) => Ty::Unknown, + (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown, + } +} + +/// Build the type of a specific field of a struct or enum variant. +pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty { + let parent_def = field.parent_def(db); + let resolver = match parent_def { + VariantDef::Struct(it) => it.resolver(db), + VariantDef::EnumVariant(it) => it.parent_enum(db).resolver(db), + }; + let var_data = parent_def.variant_data(db); + let type_ref = &var_data.fields().unwrap()[field.id].type_ref; + Ty::from_hir(db, &resolver, type_ref) +} + +/// Build the declared type of a function. This should not need to look at the +/// function body. +fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty { + let signature = def.signature(db); + let resolver = def.resolver(db); + let generics = def.generic_params(db); + let name = def.name(db); + let input = + signature.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::>(); + let output = Ty::from_hir(db, &resolver, signature.ret_type()); + let sig = Arc::new(FnSig { input, output }); + let substs = make_substs(&generics); + Ty::FnDef { def: def.into(), sig, name, substs } +} + +/// Build the type of a tuple struct constructor. +fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty { + let var_data = def.variant_data(db); + let fields = match var_data.fields() { + Some(fields) => fields, + None => return type_for_struct(db, def), // Unit struct + }; + let resolver = def.resolver(db); + let generics = def.generic_params(db); + let name = def.name(db).unwrap_or_else(Name::missing); + let input = fields + .iter() + .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref)) + .collect::>(); + let output = type_for_struct(db, def); + let sig = Arc::new(FnSig { input, output }); + let substs = make_substs(&generics); + Ty::FnDef { def: def.into(), sig, name, substs } +} + +/// Build the type of a tuple enum variant constructor. +fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty { + let var_data = def.variant_data(db); + let fields = match var_data.fields() { + Some(fields) => fields, + None => return type_for_enum(db, def.parent_enum(db)), // Unit variant + }; + let resolver = def.parent_enum(db).resolver(db); + let generics = def.parent_enum(db).generic_params(db); + let name = def.name(db).unwrap_or_else(Name::missing); + let input = fields + .iter() + .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref)) + .collect::>(); + let substs = make_substs(&generics); + let output = type_for_enum(db, def.parent_enum(db)).apply_substs(substs.clone()); + let sig = Arc::new(FnSig { input, output }); + Ty::FnDef { def: def.into(), sig, name, substs } +} + +fn make_substs(generics: &GenericParams) -> Substs { + Substs( + generics + .params_including_parent() + .into_iter() + .map(|p| Ty::Param { idx: p.idx, name: p.name.clone() }) + .collect::>() + .into(), + ) +} + +fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { + let generics = s.generic_params(db); + Ty::Adt { + def_id: s.into(), + name: s.name(db).unwrap_or_else(Name::missing), + substs: make_substs(&generics), + } +} + +fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty { + let generics = s.generic_params(db); + Ty::Adt { + def_id: s.into(), + name: s.name(db).unwrap_or_else(Name::missing), + substs: make_substs(&generics), + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum TypableDef { + Function(Function), + Struct(Struct), + Enum(Enum), + EnumVariant(EnumVariant), +} +impl_froms!(TypableDef: Function, Struct, Enum, EnumVariant); + +impl From for Option { + fn from(def: ModuleDef) -> Option { + let res = match def { + ModuleDef::Function(f) => f.into(), + ModuleDef::Struct(s) => s.into(), + ModuleDef::Enum(e) => e.into(), + ModuleDef::EnumVariant(v) => v.into(), + ModuleDef::Const(_) + | ModuleDef::Static(_) + | ModuleDef::Module(_) + | ModuleDef::Trait(_) + | ModuleDef::Type(_) => return None, + }; + Some(res) + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum CallableDef { + Function(Function), + Struct(Struct), + EnumVariant(EnumVariant), +} +impl_froms!(CallableDef: Function, Struct, EnumVariant); diff --git a/crates/ra_hir/src/ty/op.rs b/crates/ra_hir/src/ty/op.rs new file mode 100644 index 000000000000..8703cf2366bf --- /dev/null +++ b/crates/ra_hir/src/ty/op.rs @@ -0,0 +1,81 @@ +use crate::expr::BinaryOp; +use super::{Ty, InferTy}; + +pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty { + match op { + BinaryOp::BooleanOr + | BinaryOp::BooleanAnd + | BinaryOp::EqualityTest + | BinaryOp::NegatedEqualityTest + | BinaryOp::LesserEqualTest + | BinaryOp::GreaterEqualTest + | BinaryOp::LesserTest + | BinaryOp::GreaterTest => Ty::Bool, + BinaryOp::Assignment + | BinaryOp::AddAssign + | BinaryOp::SubAssign + | BinaryOp::DivAssign + | BinaryOp::MulAssign + | BinaryOp::RemAssign + | BinaryOp::ShrAssign + | BinaryOp::ShlAssign + | BinaryOp::BitAndAssign + | BinaryOp::BitOrAssign + | BinaryOp::BitXorAssign => Ty::unit(), + BinaryOp::Addition + | BinaryOp::Subtraction + | BinaryOp::Multiplication + | BinaryOp::Division + | BinaryOp::Remainder + | BinaryOp::LeftShift + | BinaryOp::RightShift + | BinaryOp::BitwiseAnd + | BinaryOp::BitwiseOr + | BinaryOp::BitwiseXor => match rhs_ty { + Ty::Int(..) + | Ty::Float(..) + | Ty::Infer(InferTy::IntVar(..)) + | Ty::Infer(InferTy::FloatVar(..)) => rhs_ty, + _ => Ty::Unknown, + }, + BinaryOp::RangeRightOpen | BinaryOp::RangeRightClosed => Ty::Unknown, + } +} + +pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty { + match op { + BinaryOp::BooleanAnd | BinaryOp::BooleanOr => Ty::Bool, + BinaryOp::Assignment | BinaryOp::EqualityTest => match lhs_ty { + Ty::Int(..) | Ty::Float(..) | Ty::Str | Ty::Char | Ty::Bool => lhs_ty, + _ => Ty::Unknown, + }, + BinaryOp::LesserEqualTest + | BinaryOp::GreaterEqualTest + | BinaryOp::LesserTest + | BinaryOp::GreaterTest + | BinaryOp::AddAssign + | BinaryOp::SubAssign + | BinaryOp::DivAssign + | BinaryOp::MulAssign + | BinaryOp::RemAssign + | BinaryOp::ShrAssign + | BinaryOp::ShlAssign + | BinaryOp::BitAndAssign + | BinaryOp::BitOrAssign + | BinaryOp::BitXorAssign + | BinaryOp::Addition + | BinaryOp::Subtraction + | BinaryOp::Multiplication + | BinaryOp::Division + | BinaryOp::Remainder + | BinaryOp::LeftShift + | BinaryOp::RightShift + | BinaryOp::BitwiseAnd + | BinaryOp::BitwiseOr + | BinaryOp::BitwiseXor => match lhs_ty { + Ty::Int(..) | Ty::Float(..) => lhs_ty, + _ => Ty::Unknown, + }, + _ => Ty::Unknown, + } +}