From 60a607d33f1c50acd0a4218da32abe35b2941e38 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Thu, 24 Jan 2019 17:54:18 +0300 Subject: new struct id --- crates/ra_hir/src/adt.rs | 26 ++-- crates/ra_hir/src/code_model_api.rs | 33 +++-- crates/ra_hir/src/code_model_impl/module.rs | 2 +- crates/ra_hir/src/db.rs | 7 +- crates/ra_hir/src/generics.rs | 15 ++- crates/ra_hir/src/ids.rs | 7 +- crates/ra_hir/src/lib.rs | 2 +- crates/ra_hir/src/nameres/lower.rs | 11 +- crates/ra_hir/src/ty.rs | 150 +++++++++++++++------ crates/ra_hir/src/ty/method_resolution.rs | 8 +- .../src/ty/snapshots/tests__infer_struct.snap | 12 +- 11 files changed, 182 insertions(+), 91 deletions(-) (limited to 'crates/ra_hir') diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs index 4cca09351..3caf60ee6 100644 --- a/crates/ra_hir/src/adt.rs +++ b/crates/ra_hir/src/adt.rs @@ -9,19 +9,27 @@ use ra_syntax::{ }; use crate::{ - DefId, DefLoc, Name, AsName, Struct, Enum, EnumVariant, + DefId, DefLoc, Name, AsName, Struct, Enum, EnumVariant, Module, HirFileId, HirDatabase, DefKind, SourceItemId, type_ref::TypeRef, + ids::{StructLoc}, }; impl Struct { - pub(crate) fn new(def_id: DefId) -> Self { - Struct { def_id } + pub(crate) fn from_ast( + db: &impl HirDatabase, + module: Module, + file_id: HirFileId, + ast: &ast::StructDef, + ) -> Struct { + let loc: StructLoc = StructLoc::from_ast(db, module, file_id, ast); + let id = loc.id(db); + Struct { id } } pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Arc { - db.struct_data(self.def_id).variant_data.clone() + db.struct_data((*self).into()).variant_data.clone() } } @@ -39,13 +47,9 @@ impl StructData { StructData { name, variant_data } } - pub(crate) fn struct_data_query(db: &impl HirDatabase, def_id: DefId) -> Arc { - let def_loc = def_id.loc(db); - assert!(def_loc.kind == DefKind::Struct); - let syntax = db.file_item(def_loc.source_item_id); - let struct_def = - ast::StructDef::cast(&syntax).expect("struct def should point to StructDef node"); - Arc::new(StructData::new(struct_def)) + pub(crate) fn struct_data_query(db: &impl HirDatabase, struct_: Struct) -> Arc { + let (_, struct_def) = struct_.source(db); + Arc::new(StructData::new(&*struct_def)) } } diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 905615127..948718aa6 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -10,13 +10,13 @@ use crate::{ nameres::{ModuleScope, lower::ImportId}, db::HirDatabase, expr::BodySyntaxMapping, - ty::InferenceResult, + ty::{InferenceResult, VariantDef}, adt::VariantData, generics::GenericParams, code_model_impl::def_id_to_ast, docs::{Documentation, Docs, docs_from_ast}, module_tree::ModuleId, - ids::FunctionId, + ids::{FunctionId, StructId}, }; /// hir::Crate describes a single crate. It's the main interface with which @@ -68,6 +68,7 @@ pub struct Module { pub enum ModuleDef { Module(Module), Function(Function), + Struct(Struct), Def(DefId), } @@ -83,6 +84,12 @@ impl Into for Function { } } +impl Into for Struct { + fn into(self) -> ModuleDef { + ModuleDef::Struct(self) + } +} + impl Into for DefId { fn into(self) -> ModuleDef { ModuleDef::Def(self) @@ -187,7 +194,7 @@ impl Module { #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct StructField { - parent: DefId, + parent: VariantDef, name: Name, } @@ -201,38 +208,38 @@ impl StructField { } } -#[derive(Debug, Clone, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct Struct { - pub(crate) def_id: DefId, + pub(crate) id: StructId, } impl Struct { - pub fn def_id(&self) -> DefId { - self.def_id + pub fn module(&self, db: &impl HirDatabase) -> Module { + self.id.loc(db).module } pub fn name(&self, db: &impl HirDatabase) -> Option { - db.struct_data(self.def_id).name.clone() + db.struct_data(*self).name.clone() } pub fn fields(&self, db: &impl HirDatabase) -> Vec { - db.struct_data(self.def_id) + db.struct_data(*self) .variant_data .fields() .iter() .map(|it| StructField { - parent: self.def_id, + parent: (*self).into(), name: it.name.clone(), }) .collect() } pub fn source(&self, db: &impl HirDatabase) -> (HirFileId, TreeArc) { - def_id_to_ast(db, self.def_id) + self.id.loc(db).source(db) } pub fn generic_params(&self, db: &impl HirDatabase) -> Arc { - db.generic_params(self.def_id.into()) + db.generic_params((*self).into()) } } @@ -310,7 +317,7 @@ impl EnumVariant { .fields() .iter() .map(|it| StructField { - parent: self.def_id, + parent: self.def_id.into(), name: it.name.clone(), }) .collect() diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs index b2828c7be..42f10e941 100644 --- a/crates/ra_hir/src/code_model_impl/module.rs +++ b/crates/ra_hir/src/code_model_impl/module.rs @@ -135,7 +135,7 @@ impl Module { None => PerNs::none(), } } - ModuleDef::Function(_) => PerNs::none(), + ModuleDef::Function(_) | ModuleDef::Struct(_) => PerNs::none(), ModuleDef::Def(def) => { match def.resolve(db) { Def::Enum(e) => { diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 97de7da31..75935c30f 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -8,10 +8,11 @@ use crate::{ SourceFileItems, SourceItemId, Crate, Module, HirInterner, query_definitions, Function, FnSignature, FnScopes, + Struct, macros::MacroExpansion, module_tree::ModuleTree, nameres::{ItemMap, lower::{LoweredModule, ImportSourceMap}}, - ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef}, + ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef, VariantDef}, adt::{StructData, EnumData, EnumVariantData}, impl_block::ModuleImplBlocks, generics::{GenericParams, GenericDef}, @@ -29,7 +30,7 @@ pub trait HirDatabase: SyntaxDatabase + AsRef { fn fn_scopes(&self, func: Function) -> Arc; #[salsa::invoke(crate::adt::StructData::struct_data_query)] - fn struct_data(&self, def_id: DefId) -> Arc; + fn struct_data(&self, struct_: Struct) -> Arc; #[salsa::invoke(crate::adt::EnumData::enum_data_query)] fn enum_data(&self, def_id: DefId) -> Arc; @@ -44,7 +45,7 @@ pub trait HirDatabase: SyntaxDatabase + AsRef { fn type_for_def(&self, def: TypableDef) -> Ty; #[salsa::invoke(crate::ty::type_for_field)] - fn type_for_field(&self, def_id: DefId, field: Name) -> Option; + fn type_for_field(&self, def: VariantDef, field: Name) -> Option; #[salsa::invoke(query_definitions::file_items)] fn file_items(&self, file_id: HirFileId) -> Arc; diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs index 88c53705f..e10b85ec9 100644 --- a/crates/ra_hir/src/generics.rs +++ b/crates/ra_hir/src/generics.rs @@ -7,7 +7,7 @@ use std::sync::Arc; use ra_syntax::ast::{self, AstNode, NameOwner, TypeParamsOwner}; -use crate::{db::HirDatabase, DefId, Name, AsName, Function}; +use crate::{db::HirDatabase, DefId, Name, AsName, Function, Struct}; /// Data about a generic parameter (to a function, struct, impl, ...). #[derive(Clone, PartialEq, Eq, Debug)] @@ -25,6 +25,7 @@ pub struct GenericParams { #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)] pub enum GenericDef { Function(Function), + Struct(Struct), Def(DefId), } @@ -34,6 +35,12 @@ impl From for GenericDef { } } +impl From for GenericDef { + fn from(func: Struct) -> GenericDef { + GenericDef::Struct(func) + } +} + impl From for GenericDef { fn from(def_id: DefId) -> GenericDef { GenericDef::Def(def_id) @@ -53,6 +60,12 @@ impl GenericParams { generics.fill(type_param_list) } } + GenericDef::Struct(s) => { + let (_, struct_def) = s.source(db); + if let Some(type_param_list) = struct_def.type_param_list() { + generics.fill(type_param_list) + } + } GenericDef::Def(def_id) => { let (_file_id, node) = def_id.source(db); if let Some(type_param_list) = node.children().find_map(ast::TypeParamList::cast) { diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs index 51e3cfb81..2791149dd 100644 --- a/crates/ra_hir/src/ids.rs +++ b/crates/ra_hir/src/ids.rs @@ -5,7 +5,7 @@ use ra_syntax::{TreeArc, SyntaxNode, SourceFile, AstNode, ast}; use ra_arena::{Arena, RawId, impl_arena_id}; use crate::{ - HirDatabase, Def, Struct, Enum, EnumVariant, Crate, + HirDatabase, Def, Enum, EnumVariant, Crate, Module, Trait, Type, Static, Const, }; @@ -257,10 +257,7 @@ impl DefId { pub fn resolve(self, db: &impl HirDatabase) -> Def { let loc = self.loc(db); match loc.kind { - DefKind::Struct => { - let struct_def = Struct::new(self); - Def::Struct(struct_def) - } + DefKind::Struct => unreachable!(), DefKind::Enum => Def::Enum(Enum::new(self)), DefKind::EnumVariant => Def::EnumVariant(EnumVariant::new(self)), DefKind::Const => { diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index a6246a5e9..5d6371892 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -43,7 +43,7 @@ pub use self::{ ids::{HirFileId, DefId, DefLoc, MacroCallId, MacroCallLoc, HirInterner}, macros::{MacroDef, MacroInput, MacroExpansion}, nameres::{ItemMap, PerNs, Namespace, Resolution}, - ty::Ty, + ty::{Ty, AdtDef}, impl_block::{ImplBlock, ImplItem}, code_model_impl::function::{FnScopes, ScopesWithSyntaxMapping}, docs::{Docs, Documentation} diff --git a/crates/ra_hir/src/nameres/lower.rs b/crates/ra_hir/src/nameres/lower.rs index 1f8adc7eb..b0c4aa819 100644 --- a/crates/ra_hir/src/nameres/lower.rs +++ b/crates/ra_hir/src/nameres/lower.rs @@ -10,7 +10,7 @@ use rustc_hash::FxHashMap; use crate::{ SourceItemId, Path, ModuleSource, HirDatabase, Name, SourceFileItems, HirFileId, MacroCallLoc, AsName, PerNs, DefKind, DefLoc, Function, - ModuleDef, Module, + ModuleDef, Module, Struct, }; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] @@ -147,7 +147,14 @@ impl LoweredModule { item: &ast::ModuleItem, ) { let name = match item.kind() { - ast::ModuleItemKind::StructDef(it) => it.name(), + ast::ModuleItemKind::StructDef(it) => { + if let Some(name) = it.name() { + let s = Struct::from_ast(db, module, file_id, it); + let s: ModuleDef = s.into(); + self.declarations.insert(name.as_name(), PerNs::both(s, s)); + } + return; + } ast::ModuleItemKind::EnumDef(it) => it.name(), ast::ModuleItemKind::FnDef(it) => { if let Some(name) = it.name() { diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs index f9cdbcab3..fc699a2ae 100644 --- a/crates/ra_hir/src/ty.rs +++ b/crates/ra_hir/src/ty.rs @@ -32,7 +32,7 @@ use rustc_hash::FxHashMap; use crate::{ Def, DefId, Module, Function, Struct, StructField, Enum, EnumVariant, Path, Name, ImplBlock, - FnSignature, FnScopes, ModuleDef, + FnSignature, FnScopes, ModuleDef, Crate, db::HirDatabase, type_ref::{TypeRef, Mutability}, name::KnownName, @@ -163,6 +163,33 @@ impl Substs { } } +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum AdtDef { + Struct(Struct), + Def(DefId), // Enum +} + +impl From for AdtDef { + fn from(struct_: Struct) -> AdtDef { + AdtDef::Struct(struct_) + } +} + +impl From for AdtDef { + fn from(def_id: DefId) -> AdtDef { + AdtDef::Def(def_id) + } +} + +impl AdtDef { + fn krate(self, db: &impl HirDatabase) -> Option { + match self { + AdtDef::Struct(s) => s.module(db).krate(db), + AdtDef::Def(def_id) => def_id.krate(db), + } + } +} + /// A type. This is based on the `TyKind` enum in rustc (librustc/ty/sty.rs). /// /// This should be cheap to clone. @@ -184,7 +211,7 @@ pub enum Ty { /// Structures, enumerations and unions. Adt { /// The DefId of the struct/enum. - def_id: DefId, + def_id: AdtDef, /// The name, for displaying. name: Name, /// Substitutions for the generic parameters of the type. @@ -384,6 +411,7 @@ impl Ty { let resolved = match module.resolve_path(db, path).take_types() { Some(ModuleDef::Def(r)) => r.into(), Some(ModuleDef::Function(f)) => f.into(), + Some(ModuleDef::Struct(s)) => s.into(), None | Some(ModuleDef::Module(_)) => return Ty::Unknown, }; let ty = db.type_for_def(resolved); @@ -409,6 +437,7 @@ impl Ty { .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::Def(def_id) => match def_id.resolve(db) { Def::Struct(s) => (s.generic_params(db), last), Def::Enum(e) => (e.generic_params(db), last), @@ -642,7 +671,7 @@ fn make_substs(generics: &GenericParams) -> Substs { fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { let generics = s.generic_params(db); Ty::Adt { - def_id: s.def_id(), + def_id: s.into(), name: s.name(db).unwrap_or_else(Name::missing), substs: make_substs(&generics), } @@ -651,7 +680,7 @@ fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty { pub(crate) fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty { let generics = s.generic_params(db); Ty::Adt { - def_id: s.def_id(), + def_id: s.def_id().into(), name: s.name(db).unwrap_or_else(Name::missing), substs: make_substs(&generics), } @@ -666,6 +695,7 @@ pub(crate) fn type_for_enum_variant(db: &impl HirDatabase, ev: EnumVariant) -> T #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum TypableDef { Function(Function), + Struct(Struct), Def(DefId), } @@ -675,6 +705,12 @@ impl From for TypableDef { } } +impl From for TypableDef { + fn from(struct_: Struct) -> TypableDef { + TypableDef::Struct(struct_) + } +} + impl From for TypableDef { fn from(func: DefId) -> TypableDef { TypableDef::Def(func) @@ -684,8 +720,8 @@ impl From for TypableDef { pub(super) fn type_for_def(db: &impl HirDatabase, def: TypableDef) -> Ty { match def { TypableDef::Function(f) => type_for_fn(db, f), + TypableDef::Struct(s) => type_for_struct(db, s), TypableDef::Def(def_id) => match def_id.resolve(db) { - Def::Struct(s) => type_for_struct(db, s), Def::Enum(e) => type_for_enum(db, e), Def::EnumVariant(ev) => type_for_enum_variant(db, ev), _ => { @@ -700,22 +736,44 @@ pub(super) fn type_for_def(db: &impl HirDatabase, def: TypableDef) -> Ty { } } -pub(super) fn type_for_field(db: &impl HirDatabase, def_id: DefId, field: Name) -> Option { - let def = def_id.resolve(db); - let (variant_data, generics) = match def { - Def::Struct(s) => (s.variant_data(db), s.generic_params(db)), - Def::EnumVariant(ev) => (ev.variant_data(db), ev.parent_enum(db).generic_params(db)), - // TODO: unions - Def::Enum(_) => { - // this can happen in (invalid) code, but enums don't have fields themselves - return None; - } - _ => panic!( - "trying to get type for field {:?} in non-struct/variant {:?}", - field, def_id - ), +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum VariantDef { + Struct(Struct), + Def(DefId), // EnumVariant +} + +impl From for VariantDef { + fn from(struct_: Struct) -> VariantDef { + VariantDef::Struct(struct_) + } +} + +impl From for VariantDef { + fn from(def_id: DefId) -> VariantDef { + VariantDef::Def(def_id) + } +} + +pub(super) fn type_for_field(db: &impl HirDatabase, def: VariantDef, field: Name) -> Option { + let (variant_data, generics, module) = match def { + VariantDef::Struct(s) => (s.variant_data(db), s.generic_params(db), s.module(db)), + VariantDef::Def(def_id) => match def_id.resolve(db) { + Def::EnumVariant(ev) => ( + ev.variant_data(db), + ev.parent_enum(db).generic_params(db), + def_id.module(db), + ), + // TODO: unions + Def::Enum(_) => { + // this can happen in (invalid) code, but enums don't have fields themselves + return None; + } + _ => panic!( + "trying to get type for field {:?} in non-struct/variant {:?}", + field, def_id + ), + }, }; - let module = def_id.module(db); // We can't have an impl block ere, right? // let impl_block = def_id.impl_block(db); let type_ref = variant_data.get_field_type_ref(&field)?; @@ -1076,17 +1134,18 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { }; // resolve in module - let resolved = match self.module.resolve_path(self.db, &path).take_values()? { + let typable = match self.module.resolve_path(self.db, &path).take_values()? { ModuleDef::Def(it) => it.into(), ModuleDef::Function(func) => func.into(), + ModuleDef::Struct(s) => s.into(), ModuleDef::Module(_) => return None, }; - let ty = self.db.type_for_def(resolved); + let ty = self.db.type_for_def(typable); let ty = self.insert_type_vars(ty); Some(ty) } - fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option) { + fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option) { let path = match path { Some(path) => path, None => return (Ty::Unknown, None), @@ -1094,7 +1153,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let def = match self.module.resolve_path(self.db, &path).take_types() { Some(ModuleDef::Def(def_id)) => def_id.into(), Some(ModuleDef::Function(func)) => func.into(), - _ => return (Ty::Unknown, None), + Some(ModuleDef::Struct(s)) => s.into(), + None | Some(ModuleDef::Module(_)) => return (Ty::Unknown, None), }; // TODO remove the duplication between here and `Ty::from_path`? // TODO provide generics of function @@ -1109,37 +1169,36 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { ); match def { TypableDef::Def(def_id) => match def_id.resolve(self.db) { - Def::Struct(s) => { - let ty = type_for_struct(self.db, s); - let ty = self.insert_type_vars(ty.apply_substs(substs)); - (ty, Some(def_id)) - } Def::EnumVariant(ev) => { let ty = type_for_enum_variant(self.db, ev); let ty = self.insert_type_vars(ty.apply_substs(substs)); - (ty, Some(def_id)) + (ty, Some(def_id.into())) } _ => (Ty::Unknown, None), }, TypableDef::Function(_) => (Ty::Unknown, None), + TypableDef::Struct(s) => { + let ty = type_for_struct(self.db, s); + let ty = self.insert_type_vars(ty.apply_substs(substs)); + (ty, Some(s.into())) + } } } fn resolve_fields(&mut self, path: Option<&Path>) -> Option<(Ty, Vec)> { - let (ty, def_id) = self.resolve_variant(path); - let def_id = def_id?; - let def = def_id.resolve(self.db); - - match def { - Def::Struct(s) => { + let (ty, def) = self.resolve_variant(path); + match def? { + VariantDef::Struct(s) => { let fields = s.fields(self.db); Some((ty, fields)) } - Def::EnumVariant(ev) => { - let fields = ev.fields(self.db); - Some((ty, fields)) - } - _ => None, + VariantDef::Def(def_id) => match def_id.resolve(self.db) { + Def::EnumVariant(ev) => { + let fields = ev.fields(self.db); + Some((ty, fields)) + } + _ => None, + }, } } @@ -1240,6 +1299,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { .and_then(|module_def| match module_def { ModuleDef::Def(it) => Some(it.into()), ModuleDef::Function(func) => Some(func.into()), + ModuleDef::Struct(s) => Some(s.into()), ModuleDef::Module(_) => None, }) .map_or(Ty::Unknown, |resolved| self.db.type_for_def(resolved)), @@ -1433,7 +1493,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { for field in fields { let field_ty = if let Some(def_id) = def_id { self.db - .type_for_field(def_id, field.name.clone()) + .type_for_field(def_id.into(), field.name.clone()) .unwrap_or(Ty::Unknown) .subst(&substs) } else { @@ -1457,10 +1517,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { i.and_then(|i| fields.get(i).cloned()) } Ty::Adt { - def_id, ref substs, .. + def_id: AdtDef::Struct(s), + ref substs, + .. } => self .db - .type_for_field(def_id, name.clone()) + .type_for_field(s.into(), name.clone()) .map(|ty| ty.subst(substs)), _ => None, }) diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs index 0084b24dc..9a571c2aa 100644 --- a/crates/ra_hir/src/ty/method_resolution.rs +++ b/crates/ra_hir/src/ty/method_resolution.rs @@ -7,16 +7,16 @@ use std::sync::Arc; use rustc_hash::FxHashMap; use crate::{ - HirDatabase, DefId, module_tree::ModuleId, Module, Crate, Name, Function, + HirDatabase, module_tree::ModuleId, Module, Crate, Name, Function, impl_block::{ImplId, ImplBlock, ImplItem}, - generics::GenericParams + generics::GenericParams, + ty::{AdtDef, Ty} }; -use super::Ty; /// This is used as a key for indexing impls. #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum TyFingerprint { - Adt(DefId), + Adt(AdtDef), // we'll also want to index impls for primitive types etc. } diff --git a/crates/ra_hir/src/ty/snapshots/tests__infer_struct.snap b/crates/ra_hir/src/ty/snapshots/tests__infer_struct.snap index c4a2d5cf8..8747fae18 100644 --- a/crates/ra_hir/src/ty/snapshots/tests__infer_struct.snap +++ b/crates/ra_hir/src/ty/snapshots/tests__infer_struct.snap @@ -1,19 +1,19 @@ --- -created: "2019-01-22T14:45:00.058678600+00:00" -creator: insta@0.4.0 +created: "2019-01-24T14:51:32.808861856+00:00" +creator: insta@0.5.2 expression: "&result" -source: "crates\\ra_hir\\src\\ty\\tests.rs" +source: crates/ra_hir/src/ty/tests.rs --- [72; 154) '{ ...a.c; }': () [82; 83) 'c': [unknown] -[86; 87) 'C': [unknown] +[86; 87) 'C': C [86; 90) 'C(1)': [unknown] [88; 89) '1': i32 -[96; 97) 'B': [unknown] +[96; 97) 'B': B [107; 108) 'a': A [114; 133) 'A { b:...C(1) }': A [121; 122) 'B': B -[127; 128) 'C': [unknown] +[127; 128) 'C': C [127; 131) 'C(1)': C [129; 130) '1': i32 [139; 140) 'a': A -- cgit v1.2.3