From 0ea2a20397497a33af4d5d602e51cc50a8e15b4f Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 20 Aug 2013 17:37:49 -0400 Subject: [PATCH 1/4] Add PointerKind to LpDeref --- .../borrowck/gather_loans/restrictions.rs | 12 +++++------ src/librustc/middle/borrowck/mod.rs | 12 +++++------ src/librustc/middle/mem_categorization.rs | 20 +++++++++---------- 3 files changed, 22 insertions(+), 22 deletions(-) diff --git a/src/librustc/middle/borrowck/gather_loans/restrictions.rs b/src/librustc/middle/borrowck/gather_loans/restrictions.rs index 46bb23e400ee5..3b518cb15904b 100644 --- a/src/librustc/middle/borrowck/gather_loans/restrictions.rs +++ b/src/librustc/middle/borrowck/gather_loans/restrictions.rs @@ -101,7 +101,7 @@ impl RestrictionsContext { self.extend(result, cmt.mutbl, LpInterior(i), restrictions) } - mc::cat_deref(cmt_base, _, mc::uniq_ptr) => { + mc::cat_deref(cmt_base, _, pk @ mc::uniq_ptr) => { // R-Deref-Send-Pointer // // When we borrow the interior of an owned pointer, we @@ -110,7 +110,7 @@ impl RestrictionsContext { let result = self.restrict( cmt_base, restrictions | RESTR_MUTATE | RESTR_CLAIM); - self.extend(result, cmt.mutbl, LpDeref, restrictions) + self.extend(result, cmt.mutbl, LpDeref(pk), restrictions) } mc::cat_copied_upvar(*) | // FIXME(#2152) allow mutation of upvars @@ -129,7 +129,7 @@ impl RestrictionsContext { Safe } - mc::cat_deref(cmt_base, _, mc::gc_ptr(m_mutbl)) => { + mc::cat_deref(cmt_base, _, pk @ mc::gc_ptr(m_mutbl)) => { // R-Deref-Managed-Borrowed // // Technically, no restrictions are *necessary* here. @@ -170,14 +170,14 @@ impl RestrictionsContext { match opt_loan_path(cmt_base) { None => Safe, Some(lp_base) => { - let lp = @LpExtend(lp_base, cmt.mutbl, LpDeref); + let lp = @LpExtend(lp_base, cmt.mutbl, LpDeref(pk)); SafeIf(lp, ~[Restriction {loan_path: lp, set: restrictions}]) } } } - mc::cat_deref(cmt_base, _, mc::region_ptr(m_mutbl, _)) => { + mc::cat_deref(cmt_base, _, pk @ mc::region_ptr(m_mutbl, _)) => { // Because an `&mut` pointer does not inherit its // mutability, we can only prevent mutation or prevent // freezing if it is not aliased. Therefore, in such @@ -187,7 +187,7 @@ impl RestrictionsContext { let result = self.restrict( cmt_base, RESTR_ALIAS | RESTR_MUTATE | RESTR_CLAIM); - self.extend(result, cmt.mutbl, LpDeref, restrictions) + self.extend(result, cmt.mutbl, LpDeref(pk), restrictions) } else { // R-Deref-Mut-Borrowed-2 Safe diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 95eae32922b7f..a84716bd73f8d 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -261,7 +261,7 @@ pub enum LoanPath { #[deriving(Eq, IterBytes)] pub enum LoanPathElem { - LpDeref, // `*LV` in doc.rs + LpDeref(mc::PointerKind), // `*LV` in doc.rs LpInterior(mc::InteriorKind) // `LV.f` in doc.rs } @@ -295,9 +295,9 @@ pub fn opt_loan_path(cmt: mc::cmt) -> Option<@LoanPath> { Some(@LpVar(id)) } - mc::cat_deref(cmt_base, _, _) => { + mc::cat_deref(cmt_base, _, pk) => { do opt_loan_path(cmt_base).map_move |lp| { - @LpExtend(lp, cmt.mutbl, LpDeref) + @LpExtend(lp, cmt.mutbl, LpDeref(pk)) } } @@ -728,7 +728,7 @@ impl BorrowckCtxt { loan_path: &LoanPath, out: &mut ~str) { match *loan_path { - LpExtend(_, _, LpDeref) => { + LpExtend(_, _, LpDeref(_)) => { out.push_char('('); self.append_loan_path_to_str(loan_path, out); out.push_char(')'); @@ -776,7 +776,7 @@ impl BorrowckCtxt { out.push_str("[]"); } - LpExtend(lp_base, _, LpDeref) => { + LpExtend(lp_base, _, LpDeref(_)) => { out.push_char('*'); self.append_loan_path_to_str(lp_base, out); } @@ -854,7 +854,7 @@ impl Repr for LoanPath { fmt!("$(%?)", id) } - &LpExtend(lp, _, LpDeref) => { + &LpExtend(lp, _, LpDeref(_)) => { fmt!("%s.*", lp.repr(tcx)) } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 283724447f831..2cd2d94b9daf8 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -59,18 +59,18 @@ use syntax::print::pprust; #[deriving(Eq)] pub enum categorization { - cat_rvalue(ast::NodeId), // temporary val, argument is its scope + cat_rvalue(ast::NodeId), // temporary val, argument is its scope cat_static_item, cat_implicit_self, cat_copied_upvar(CopiedUpvar), // upvar copied into @fn or ~fn env cat_stack_upvar(cmt), // by ref upvar from &fn - cat_local(ast::NodeId), // local variable - cat_arg(ast::NodeId), // formal argument - cat_deref(cmt, uint, ptr_kind), // deref of a ptr + cat_local(ast::NodeId), // local variable + cat_arg(ast::NodeId), // formal argument + cat_deref(cmt, uint, PointerKind), // deref of a ptr cat_interior(cmt, InteriorKind), // something interior: field, tuple, etc cat_downcast(cmt), // selects a particular enum variant (*) - cat_discr(cmt, ast::NodeId), // match discriminant (see preserve()) - cat_self(ast::NodeId), // explicit `self` + cat_discr(cmt, ast::NodeId), // match discriminant (see preserve()) + cat_self(ast::NodeId), // explicit `self` // (*) downcast is only required if the enum has more than one variant } @@ -82,8 +82,8 @@ pub struct CopiedUpvar { } // different kinds of pointers: -#[deriving(Eq)] -pub enum ptr_kind { +#[deriving(Eq, IterBytes)] +pub enum PointerKind { uniq_ptr, gc_ptr(ast::mutability), region_ptr(ast::mutability, ty::Region), @@ -147,7 +147,7 @@ pub type cmt = @cmt_; // We pun on *T to mean both actual deref of a ptr as well // as accessing of components: pub enum deref_kind { - deref_ptr(ptr_kind), + deref_ptr(PointerKind), deref_interior(InteriorKind), } @@ -1233,7 +1233,7 @@ impl Repr for categorization { } } -pub fn ptr_sigil(ptr: ptr_kind) -> ~str { +pub fn ptr_sigil(ptr: PointerKind) -> ~str { match ptr { uniq_ptr => ~"~", gc_ptr(_) => ~"@", From 6b23d20452ef7c2d2eb79baf074bcda04fad9a66 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 21 Aug 2013 11:39:17 -0400 Subject: [PATCH 2/4] Prohibit assignment to `&mut` pointers that are found in frozen or borrowed locations. Fixes #8625. --- src/librustc/middle/borrowck/check_loans.rs | 15 +++++++-- ...rrowck-assign-to-andmut-in-borrowed-loc.rs | 31 +++++++++++++++++++ 2 files changed, 43 insertions(+), 3 deletions(-) create mode 100644 src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 620a1e9efe33f..a2529261aafc3 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -496,6 +496,12 @@ impl<'self> CheckLoanCtxt<'self> { // path, and check that the super path was not lent out as // mutable or immutable (a const loan is ok). // + // Mutability of a path can be dependent on the super path + // in two ways. First, it might be inherited mutability. + // Second, the pointee of an `&mut` pointer can only be + // mutated if it is found in an unaliased location, so we + // have to check that the owner location is not borrowed. + // // Note that we are *not* checking for any and all // restrictions. We are only interested in the pointers // that the user created, whereas we add restrictions for @@ -513,9 +519,12 @@ impl<'self> CheckLoanCtxt<'self> { let mut loan_path = loan_path; loop { match *loan_path { - // Peel back one layer if `loan_path` has - // inherited mutability - LpExtend(lp_base, mc::McInherited, _) => { + // Peel back one layer if, for `loan_path` to be + // mutable, `lp_base` must be mutable. This occurs + // with inherited mutability and with `&mut` + // pointers. + LpExtend(lp_base, mc::McInherited, _) | + LpExtend(lp_base, _, LpDeref(mc::region_ptr(ast::m_mutbl, _))) => { loan_path = lp_base; } diff --git a/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs b/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs new file mode 100644 index 0000000000000..dcef74b6c2bc2 --- /dev/null +++ b/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs @@ -0,0 +1,31 @@ +// Copyright 2012 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 assignments to an `&mut` pointer which is found in a +// borrowed (but otherwise non-aliasable) location is illegal. + +struct S<'self> { + pointer: &'self mut int +} + +fn copy_borrowed_ptr<'a>(p: &'a mut S<'a>) -> S<'a> { + S { pointer: &mut *p.pointer } +} + +fn main() { + let mut x = 1; + + { + let mut y = S { pointer: &mut x }; + let z = copy_borrowed_ptr(&mut y); + *y.pointer += 1; //~ ERROR cannot assign + *z.pointer += 1; + } +} From 35a41775505b9c7bb7b5ad9bfe1b7b7a6afb27b8 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 27 Aug 2013 15:44:55 -0400 Subject: [PATCH 3/4] Extend aliasability check to uncover `& &mut &mut` and the like --- src/librustc/middle/borrowck/check_loans.rs | 56 ++++++++++++++++--- src/librustc/middle/mem_categorization.rs | 19 ++++--- ...rowck-assign-to-andmut-in-aliasable-loc.rs | 30 ++++++++++ 3 files changed, 87 insertions(+), 18 deletions(-) create mode 100644 src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index a2529261aafc3..70a71f8ad9f3e 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -391,15 +391,7 @@ impl<'self> CheckLoanCtxt<'self> { mc::cat_deref(b, _, mc::region_ptr(m_mutbl, _)) => { // Statically prohibit writes to `&mut` when aliasable - match b.freely_aliasable() { - None => {} - Some(cause) => { - this.bccx.report_aliasability_violation( - expr.span, - MutabilityViolation, - cause); - } - } + check_for_aliasability_violation(this, expr, b); } mc::cat_deref(_, deref_count, mc::gc_ptr(ast::m_mutbl)) => { @@ -419,6 +411,52 @@ impl<'self> CheckLoanCtxt<'self> { return true; // no errors reported } + fn check_for_aliasability_violation(this: &CheckLoanCtxt, + expr: @ast::expr, + cmt: mc::cmt) -> bool { + let mut cmt = cmt; + + loop { + match cmt.cat { + mc::cat_deref(b, _, mc::region_ptr(m_mutbl, _)) | + mc::cat_downcast(b) | + mc::cat_stack_upvar(b) | + mc::cat_deref(b, _, mc::uniq_ptr) | + mc::cat_interior(b, _) | + mc::cat_discr(b, _) => { + // Aliasability depends on base cmt + cmt = b; + } + + mc::cat_copied_upvar(_) | + mc::cat_rvalue(*) | + mc::cat_local(*) | + mc::cat_arg(_) | + mc::cat_self(*) | + mc::cat_deref(_, _, mc::unsafe_ptr(*)) | + mc::cat_static_item(*) | + mc::cat_implicit_self(*) | + mc::cat_deref(_, _, mc::gc_ptr(_)) | + mc::cat_deref(_, _, mc::region_ptr(m_const, _)) | + mc::cat_deref(_, _, mc::region_ptr(m_imm, _)) => { + // Aliasability is independent of base cmt + match cmt.freely_aliasable() { + None => { + return true; + } + Some(cause) => { + this.bccx.report_aliasability_violation( + expr.span, + MutabilityViolation, + cause); + return false; + } + } + } + } + } + } + fn check_for_assignment_to_restricted_or_frozen_location( this: &CheckLoanCtxt, expr: @ast::expr, diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 2cd2d94b9daf8..c38677adfbfa5 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -1146,9 +1146,10 @@ impl cmt_ { } pub fn freely_aliasable(&self) -> Option { - //! True if this lvalue resides in an area that is - //! freely aliasable, meaning that rustc cannot track - //! the alias//es with precision. + /*! + * Returns `Some(_)` if this lvalue represents a freely aliasable + * pointer type. + */ // Maybe non-obvious: copied upvars can only be considered // non-aliasable in once closures, since any other kind can be @@ -1180,12 +1181,12 @@ impl cmt_ { Some(AliasableBorrowed(m)) } - cat_downcast(b) | - cat_stack_upvar(b) | - cat_deref(b, _, uniq_ptr) | - cat_interior(b, _) | - cat_discr(b, _) => { - b.freely_aliasable() + cat_downcast(*) | + cat_stack_upvar(*) | + cat_deref(_, _, uniq_ptr) | + cat_interior(*) | + cat_discr(*) => { + None } } } diff --git a/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs b/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs new file mode 100644 index 0000000000000..e4a23e74a12f2 --- /dev/null +++ b/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs @@ -0,0 +1,30 @@ +// Copyright 2012 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 assignments to an `&mut` pointer which is found in a +// borrowed (but otherwise non-aliasable) location is illegal. + +struct S<'self> { + pointer: &'self mut int +} + +fn a(s: &S) { + *s.pointer += 1; //~ ERROR cannot assign +} + +fn b(s: &mut S) { + *s.pointer += 1; +} + +fn c(s: & &mut S) { + *s.pointer += 1; //~ ERROR cannot assign +} + +fn main() {} From 8c09865b66f5e2865037e6ce1396ba0a653136e0 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 27 Aug 2013 16:36:42 -0400 Subject: [PATCH 4/4] Remove remnants of implicit self --- src/librustc/middle/astencode.rs | 2 +- src/librustc/middle/borrowck/check_loans.rs | 2 -- .../borrowck/gather_loans/gather_moves.rs | 1 - .../middle/borrowck/gather_loans/lifetime.rs | 3 --- .../borrowck/gather_loans/restrictions.rs | 1 - src/librustc/middle/borrowck/mod.rs | 3 +-- src/librustc/middle/mem_categorization.rs | 19 +++---------------- src/librustc/middle/moves.rs | 2 +- src/librustc/middle/resolve.rs | 9 ++++----- src/librustc/middle/trans/expr.rs | 2 +- src/librustc/middle/typeck/check/mod.rs | 2 +- src/librustc/middle/typeck/check/regionck.rs | 2 +- src/libsyntax/ast.rs | 2 +- src/libsyntax/ast_util.rs | 2 +- 14 files changed, 15 insertions(+), 37 deletions(-) diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index bca1a811a1372..c9727db3f5bca 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -383,7 +383,7 @@ impl tr for ast::def { ast::def_method(did0.tr(xcx), did1.map(|did1| did1.tr(xcx))) } ast::def_self_ty(nid) => { ast::def_self_ty(xcx.tr_id(nid)) } - ast::def_self(nid, i) => { ast::def_self(xcx.tr_id(nid), i) } + ast::def_self(nid) => { ast::def_self(xcx.tr_id(nid)) } ast::def_mod(did) => { ast::def_mod(did.tr(xcx)) } ast::def_foreign_mod(did) => { ast::def_foreign_mod(did.tr(xcx)) } ast::def_static(did, m) => { ast::def_static(did.tr(xcx), m) } diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 70a71f8ad9f3e..df918caac373e 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -352,7 +352,6 @@ impl<'self> CheckLoanCtxt<'self> { mc::cat_rvalue(*) | mc::cat_static_item | - mc::cat_implicit_self | mc::cat_copied_upvar(*) | mc::cat_deref(_, _, mc::unsafe_ptr(*)) | mc::cat_deref(_, _, mc::gc_ptr(*)) | @@ -435,7 +434,6 @@ impl<'self> CheckLoanCtxt<'self> { mc::cat_self(*) | mc::cat_deref(_, _, mc::unsafe_ptr(*)) | mc::cat_static_item(*) | - mc::cat_implicit_self(*) | mc::cat_deref(_, _, mc::gc_ptr(_)) | mc::cat_deref(_, _, mc::region_ptr(m_const, _)) | mc::cat_deref(_, _, mc::region_ptr(m_imm, _)) => { diff --git a/src/librustc/middle/borrowck/gather_loans/gather_moves.rs b/src/librustc/middle/borrowck/gather_loans/gather_moves.rs index 24a6e5b6e0b2b..d6f9d1db7df88 100644 --- a/src/librustc/middle/borrowck/gather_loans/gather_moves.rs +++ b/src/librustc/middle/borrowck/gather_loans/gather_moves.rs @@ -100,7 +100,6 @@ fn check_is_legal_to_move_from(bccx: @BorrowckCtxt, cmt0: mc::cmt, cmt: mc::cmt) -> bool { match cmt.cat { - mc::cat_implicit_self(*) | mc::cat_deref(_, _, mc::region_ptr(*)) | mc::cat_deref(_, _, mc::gc_ptr(*)) | mc::cat_deref(_, _, mc::unsafe_ptr(*)) => { diff --git a/src/librustc/middle/borrowck/gather_loans/lifetime.rs b/src/librustc/middle/borrowck/gather_loans/lifetime.rs index b315a7a2e7290..1dcfc515139bb 100644 --- a/src/librustc/middle/borrowck/gather_loans/lifetime.rs +++ b/src/librustc/middle/borrowck/gather_loans/lifetime.rs @@ -68,7 +68,6 @@ impl GuaranteeLifetimeContext { match cmt.cat { mc::cat_rvalue(*) | - mc::cat_implicit_self | mc::cat_copied_upvar(*) | // L-Local mc::cat_local(*) | // L-Local mc::cat_arg(*) | // L-Local @@ -301,7 +300,6 @@ impl GuaranteeLifetimeContext { } mc::cat_rvalue(*) | mc::cat_static_item | - mc::cat_implicit_self | mc::cat_copied_upvar(*) | mc::cat_deref(*) => { false @@ -328,7 +326,6 @@ impl GuaranteeLifetimeContext { mc::cat_rvalue(cleanup_scope_id) => { ty::re_scope(cleanup_scope_id) } - mc::cat_implicit_self | mc::cat_copied_upvar(_) => { ty::re_scope(self.item_scope_id) } diff --git a/src/librustc/middle/borrowck/gather_loans/restrictions.rs b/src/librustc/middle/borrowck/gather_loans/restrictions.rs index 3b518cb15904b..ccfef63d9bcba 100644 --- a/src/librustc/middle/borrowck/gather_loans/restrictions.rs +++ b/src/librustc/middle/borrowck/gather_loans/restrictions.rs @@ -115,7 +115,6 @@ impl RestrictionsContext { mc::cat_copied_upvar(*) | // FIXME(#2152) allow mutation of upvars mc::cat_static_item(*) | - mc::cat_implicit_self(*) | mc::cat_deref(_, _, mc::region_ptr(m_imm, _)) | mc::cat_deref(_, _, mc::gc_ptr(m_imm)) => { // R-Deref-Imm-Borrowed diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index a84716bd73f8d..4490fe65d9181 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -284,8 +284,7 @@ pub fn opt_loan_path(cmt: mc::cmt) -> Option<@LoanPath> { match cmt.cat { mc::cat_rvalue(*) | mc::cat_static_item | - mc::cat_copied_upvar(_) | - mc::cat_implicit_self => { + mc::cat_copied_upvar(_) => { None } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index c38677adfbfa5..8be9a5db8bbbb 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -61,7 +61,6 @@ use syntax::print::pprust; pub enum categorization { cat_rvalue(ast::NodeId), // temporary val, argument is its scope cat_static_item, - cat_implicit_self, cat_copied_upvar(CopiedUpvar), // upvar copied into @fn or ~fn env cat_stack_upvar(cmt), // by ref upvar from &fn cat_local(ast::NodeId), // local variable @@ -493,17 +492,11 @@ impl mem_categorization_ctxt { } } - ast::def_self(self_id, is_implicit) => { - let cat = if is_implicit { - cat_implicit_self - } else { - cat_self(self_id) - }; - + ast::def_self(self_id) => { @cmt_ { id:id, span:span, - cat:cat, + cat:cat_self(self_id), mutbl: McImmutable, ty:expr_ty } @@ -1016,9 +1009,6 @@ impl mem_categorization_ctxt { cat_static_item => { ~"static item" } - cat_implicit_self => { - ~"self reference" - } cat_copied_upvar(_) => { ~"captured outer variable in a heap closure" } @@ -1121,7 +1111,6 @@ impl cmt_ { match self.cat { cat_rvalue(*) | cat_static_item | - cat_implicit_self | cat_copied_upvar(*) | cat_local(*) | cat_self(*) | @@ -1167,8 +1156,7 @@ impl cmt_ { } cat_copied_upvar(CopiedUpvar {onceness: ast::Many, _}) | - cat_static_item(*) | - cat_implicit_self(*) => { + cat_static_item(*) => { Some(AliasableOther) } @@ -1206,7 +1194,6 @@ impl Repr for categorization { fn repr(&self, tcx: ty::ctxt) -> ~str { match *self { cat_static_item | - cat_implicit_self | cat_rvalue(*) | cat_copied_upvar(*) | cat_local(*) | diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index 0c553843cd1b2..ebd9b2b222344 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -218,7 +218,7 @@ pub fn moved_variable_node_id_from_def(def: def) -> Option { def_binding(nid, _) | def_arg(nid, _) | def_local(nid, _) | - def_self(nid, _) => Some(nid), + def_self(nid) => Some(nid), _ => None } diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 9654bf3fc01fb..351f4f8277a02 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -125,7 +125,7 @@ pub enum Mutability { pub enum SelfBinding { NoSelfBinding, - HasSelfBinding(NodeId, bool /* is implicit */) + HasSelfBinding(NodeId) } struct ResolveVisitor { @@ -3769,9 +3769,8 @@ impl Resolver { NoSelfBinding => { // Nothing to do. } - HasSelfBinding(self_node_id, is_implicit) => { - let def_like = dl_def(def_self(self_node_id, - is_implicit)); + HasSelfBinding(self_node_id) => { + let def_like = dl_def(def_self(self_node_id)); *function_value_rib.self_binding = Some(def_like); } } @@ -3915,7 +3914,7 @@ impl Resolver { // we only have self ty if it is a non static method let self_binding = match method.explicit_self.node { sty_static => { NoSelfBinding } - _ => { HasSelfBinding(method.self_id, false) } + _ => { HasSelfBinding(method.self_id) } }; self.resolve_function(rib_kind, diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 2ce8756848fa8..4b31b9123532c 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -1088,7 +1088,7 @@ pub fn trans_local_var(bcx: @mut Block, def: ast::def) -> Datum { ast::def_local(nid, _) | ast::def_binding(nid, _) => { take_local(bcx, bcx.fcx.lllocals, nid) } - ast::def_self(nid, _) => { + ast::def_self(nid) => { let self_info: ValSelfData = match bcx.fcx.llself { Some(ref self_info) => *self_info, None => { diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index ad6bf69d55ad6..8f7d8ac186ee6 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -3094,7 +3094,7 @@ pub fn ty_param_bounds_and_ty_for_def(fcx: @mut FnCtxt, -> ty_param_bounds_and_ty { match defn { - ast::def_arg(nid, _) | ast::def_local(nid, _) | ast::def_self(nid, _) | + ast::def_arg(nid, _) | ast::def_local(nid, _) | ast::def_self(nid) | ast::def_binding(nid, _) => { let typ = fcx.local_ty(sp, nid); return no_params(typ); diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index 05f1323805b35..b25d81056b0c0 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -58,7 +58,7 @@ fn encl_region_of_def(fcx: @mut FnCtxt, def: ast::def) -> ty::Region { let tcx = fcx.tcx(); match def { def_local(node_id, _) | def_arg(node_id, _) | - def_self(node_id, _) | def_binding(node_id, _) => { + def_self(node_id) | def_binding(node_id, _) => { tcx.region_maps.encl_region(node_id) } def_upvar(_, subdef, closure_id, body_id) => { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index b01c19a59c186..f09c7427ecc7f 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -171,7 +171,7 @@ pub enum def { def_static_method(/* method */ def_id, /* trait */ Option, purity), - def_self(NodeId, bool /* is_implicit */), + def_self(NodeId), def_self_ty(/* trait id */ NodeId), def_mod(def_id), def_foreign_mod(def_id), diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index cfbe61ca65e68..a39da4301ba33 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -64,7 +64,7 @@ pub fn def_id_of_def(d: def) -> def_id { def_use(id) | def_struct(id) | def_trait(id) | def_method(id, _) => { id } - def_arg(id, _) | def_local(id, _) | def_self(id, _) | def_self_ty(id) + def_arg(id, _) | def_local(id, _) | def_self(id) | def_self_ty(id) | def_upvar(id, _, _, _) | def_binding(id, _) | def_region(id) | def_typaram_binder(id) | def_label(id) => { local_def(id)