From 06e798a881d80eb959a71da5ebbd164f056a4531 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Sun, 11 Jan 2015 13:52:40 -0500 Subject: [PATCH] Normalize the types of fields we project out of a struct or tuple struct. Fixes #20954. --- src/librustc_typeck/check/mod.rs | 60 ++++++++++--------- .../associated-types-struct-field-named.rs | 41 +++++++++++++ .../associated-types-struct-field-numbered.rs | 38 ++++++++++++ 3 files changed, 111 insertions(+), 28 deletions(-) create mode 100644 src/test/run-pass/associated-types-struct-field-named.rs create mode 100644 src/test/run-pass/associated-types-struct-field-numbered.rs diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 1d184131ded..a6c2c0942b8 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2239,6 +2239,34 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { obligations.map_move(|o| self.register_predicate(o)); } + + // Only for fields! Returns for methods> + // Indifferent to privacy flags + pub fn lookup_field_ty(&self, + span: Span, + class_id: ast::DefId, + items: &[ty::field_ty], + fieldname: ast::Name, + substs: &subst::Substs<'tcx>) + -> Option> + { + let o_field = items.iter().find(|f| f.name == fieldname); + o_field.map(|f| ty::lookup_field_type(self.tcx(), class_id, f.id, substs)) + .map(|t| self.normalize_associated_types_in(span, &t)) + } + + pub fn lookup_tup_field_ty(&self, + span: Span, + class_id: ast::DefId, + items: &[ty::field_ty], + idx: uint, + substs: &subst::Substs<'tcx>) + -> Option> + { + let o_field = if idx < items.len() { Some(&items[idx]) } else { None }; + o_field.map(|f| ty::lookup_field_type(self.tcx(), class_id, f.id, substs)) + .map(|t| self.normalize_associated_types_in(span, &t)) + } } impl<'a, 'tcx> RegionScope for FnCtxt<'a, 'tcx> { @@ -2953,30 +2981,6 @@ pub fn impl_self_ty<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, TypeAndSubsts { substs: substs, ty: substd_ty } } -// Only for fields! Returns for methods> -// Indifferent to privacy flags -pub fn lookup_field_ty<'tcx>(tcx: &ty::ctxt<'tcx>, - class_id: ast::DefId, - items: &[ty::field_ty], - fieldname: ast::Name, - substs: &subst::Substs<'tcx>) - -> Option> { - - let o_field = items.iter().find(|f| f.name == fieldname); - o_field.map(|f| ty::lookup_field_type(tcx, class_id, f.id, substs)) -} - -pub fn lookup_tup_field_ty<'tcx>(tcx: &ty::ctxt<'tcx>, - class_id: ast::DefId, - items: &[ty::field_ty], - idx: uint, - substs: &subst::Substs<'tcx>) - -> Option> { - - let o_field = if idx < items.len() { Some(&items[idx]) } else { None }; - o_field.map(|f| ty::lookup_field_type(tcx, class_id, f.id, substs)) -} - // Controls whether the arguments are automatically referenced. This is useful // for overloaded binary and unary operators. #[derive(Copy, PartialEq)] @@ -3398,8 +3402,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, ty::ty_struct(base_id, substs) => { debug!("struct named {}", ppaux::ty_to_string(tcx, base_t)); let fields = ty::lookup_struct_fields(tcx, base_id); - lookup_field_ty(tcx, base_id, &fields[], - field.node.name, &(*substs)) + fcx.lookup_field_ty(expr.span, base_id, &fields[], + field.node.name, &(*substs)) } _ => None } @@ -3461,8 +3465,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, if tuple_like { debug!("tuple struct named {}", ppaux::ty_to_string(tcx, base_t)); let fields = ty::lookup_struct_fields(tcx, base_id); - lookup_tup_field_ty(tcx, base_id, &fields[], - idx.node, &(*substs)) + fcx.lookup_tup_field_ty(expr.span, base_id, &fields[], + idx.node, &(*substs)) } else { None } diff --git a/src/test/run-pass/associated-types-struct-field-named.rs b/src/test/run-pass/associated-types-struct-field-named.rs new file mode 100644 index 00000000000..1ded34ff3ff --- /dev/null +++ b/src/test/run-pass/associated-types-struct-field-named.rs @@ -0,0 +1,41 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test that we correctly normalize the type of a struct field +// which has an associated type. + +pub trait UnifyKey { + type Value; +} + +pub struct Node { + pub key: K, + pub value: K::Value, +} + +fn foo>,V : Clone>(node: &Node) -> Option { + node.value.clone() +} + +impl UnifyKey for i32 { + type Value = Option; +} + +impl UnifyKey for u32 { + type Value = Option; +} + +pub fn main() { + let node: Node = Node { key: 1, value: Some(22) }; + assert_eq!(foo(&node), Some(22_u32)); + + let node: Node = Node { key: 1, value: Some(22) }; + assert_eq!(foo(&node), Some(22_i32)); +} diff --git a/src/test/run-pass/associated-types-struct-field-numbered.rs b/src/test/run-pass/associated-types-struct-field-numbered.rs new file mode 100644 index 00000000000..3669dec4fbd --- /dev/null +++ b/src/test/run-pass/associated-types-struct-field-numbered.rs @@ -0,0 +1,38 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test that we correctly normalize the type of a struct field +// which has an associated type. + +pub trait UnifyKey { + type Value; +} + +pub struct Node(K, K::Value); + +fn foo>,V : Clone>(node: &Node) -> Option { + node.1.clone() +} + +impl UnifyKey for i32 { + type Value = Option; +} + +impl UnifyKey for u32 { + type Value = Option; +} + +pub fn main() { + let node: Node = Node(1, Some(22)); + assert_eq!(foo(&node), Some(22_u32)); + + let node: Node = Node(1, Some(22)); + assert_eq!(foo(&node), Some(22_i32)); +}