Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
a583ba2f
R
Rust
项目概览
int
/
Rust
大约 1 年 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
a583ba2f
编写于
12月 03, 2014
作者:
N
Niko Matsakis
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Remove `McResult` from the mem-categorization interface.
上级
8f770f10
变更
8
隐藏空白更改
内联
并排
Showing
8 changed file
with
135 addition
and
202 deletion
+135
-202
src/librustc/middle/expr_use_visitor.rs
src/librustc/middle/expr_use_visitor.rs
+35
-65
src/librustc/middle/mem_categorization.rs
src/librustc/middle/mem_categorization.rs
+70
-85
src/librustc/middle/traits/select.rs
src/librustc/middle/traits/select.rs
+1
-2
src/librustc/middle/ty.rs
src/librustc/middle/ty.rs
+4
-4
src/librustc_borrowck/borrowck/mod.rs
src/librustc_borrowck/borrowck/mod.rs
+1
-6
src/librustc_trans/trans/common.rs
src/librustc_trans/trans/common.rs
+4
-4
src/librustc_typeck/check/mod.rs
src/librustc_typeck/check/mod.rs
+7
-7
src/librustc_typeck/check/regionck.rs
src/librustc_typeck/check/regionck.rs
+13
-29
未找到文件。
src/librustc/middle/expr_use_visitor.rs
浏览文件 @
a583ba2f
...
...
@@ -302,22 +302,6 @@ pub struct ExprUseVisitor<'d,'t,'tcx,TYPER:'t> {
param_env
:
ParameterEnvironment
<
'tcx
>
,
}
// If the TYPER results in an error, it's because the type check
// failed (or will fail, when the error is uncovered and reported
// during writeback). In this case, we just ignore this part of the
// code.
//
// Note that this macro appears similar to try!(), but, unlike try!(),
// it does not propagate the error.
macro_rules!
return_if_err
{
(
$inp
:
expr
)
=>
(
match
$inp
{
Ok
(
v
)
=>
v
,
Err
(())
=>
return
}
)
}
/// Whether the elements of an overloaded operation are passed by value or by reference
enum
PassArgs
{
ByValue
,
...
...
@@ -348,7 +332,7 @@ fn walk_arg_patterns(&mut self,
decl
:
&
ast
::
FnDecl
,
body
:
&
ast
::
Block
)
{
for
arg
in
decl
.inputs
.iter
()
{
let
arg_ty
=
return_if_err!
(
self
.typer
.node_ty
(
arg
.pat.id
)
);
let
arg_ty
=
self
.typer
.node_ty
(
arg
.pat.id
);
let
fn_body_scope
=
region
::
CodeExtent
::
from_node_id
(
body
.id
);
let
arg_cmt
=
self
.mc
.cat_rvalue
(
...
...
@@ -385,7 +369,7 @@ fn consume_exprs(&mut self, exprs: &Vec<P<ast::Expr>>) {
pub
fn
consume_expr
(
&
mut
self
,
expr
:
&
ast
::
Expr
)
{
debug!
(
"consume_expr(expr={})"
,
expr
.repr
(
self
.tcx
()));
let
cmt
=
return_if_err!
(
self
.mc
.cat_expr
(
expr
)
);
let
cmt
=
self
.mc
.cat_expr
(
expr
);
self
.delegate_consume
(
expr
.id
,
expr
.span
,
cmt
);
self
.walk_expr
(
expr
);
}
...
...
@@ -394,7 +378,7 @@ fn mutate_expr(&mut self,
assignment_expr
:
&
ast
::
Expr
,
expr
:
&
ast
::
Expr
,
mode
:
MutateMode
)
{
let
cmt
=
return_if_err!
(
self
.mc
.cat_expr
(
expr
)
);
let
cmt
=
self
.mc
.cat_expr
(
expr
);
self
.delegate
.mutate
(
assignment_expr
.id
,
assignment_expr
.span
,
cmt
,
mode
);
self
.walk_expr
(
expr
);
}
...
...
@@ -407,7 +391,7 @@ fn borrow_expr(&mut self,
debug!
(
"borrow_expr(expr={}, r={}, bk={})"
,
expr
.repr
(
self
.tcx
()),
r
.repr
(
self
.tcx
()),
bk
.repr
(
self
.tcx
()));
let
cmt
=
return_if_err!
(
self
.mc
.cat_expr
(
expr
)
);
let
cmt
=
self
.mc
.cat_expr
(
expr
);
self
.delegate
.borrow
(
expr
.id
,
expr
.span
,
cmt
,
r
,
bk
,
cause
);
// Note: Unlike consume, we can ignore ExprParen. cat_expr
...
...
@@ -500,7 +484,7 @@ pub fn walk_expr(&mut self, expr: &ast::Expr) {
}
ast
::
ExprMatch
(
ref
discr
,
ref
arms
,
_
)
=>
{
let
discr_cmt
=
return_if_err!
(
self
.mc
.cat_expr
(
&**
discr
)
);
let
discr_cmt
=
self
.mc
.cat_expr
(
&**
discr
);
self
.borrow_expr
(
&**
discr
,
ty
::
ReEmpty
,
ty
::
ImmBorrow
,
MatchDiscriminant
);
// treatment of the discriminant is handled while walking the arms.
...
...
@@ -559,7 +543,7 @@ pub fn walk_expr(&mut self, expr: &ast::Expr) {
// Fetch the type of the value that the iteration yields to
// produce the pattern's categorized mutable type.
let
pattern_type
=
return_if_err!
(
self
.typer
.node_ty
(
pat
.id
)
);
let
pattern_type
=
self
.typer
.node_ty
(
pat
.id
);
let
blk_scope
=
region
::
CodeExtent
::
from_node_id
(
blk
.id
);
let
pat_cmt
=
self
.mc
.cat_rvalue
(
pat
.id
,
pat
.span
,
...
...
@@ -647,7 +631,7 @@ pub fn walk_expr(&mut self, expr: &ast::Expr) {
}
fn
walk_callee
(
&
mut
self
,
call
:
&
ast
::
Expr
,
callee
:
&
ast
::
Expr
)
{
let
callee_ty
=
return_if_err!
(
self
.typer
.expr_ty_adjusted
(
callee
)
);
let
callee_ty
=
self
.typer
.expr_ty_adjusted
(
callee
);
debug!
(
"walk_callee: callee={} callee_ty={}"
,
callee
.repr
(
self
.tcx
()),
callee_ty
.repr
(
self
.tcx
()));
let
call_scope
=
region
::
CodeExtent
::
from_node_id
(
call
.id
);
...
...
@@ -747,7 +731,7 @@ fn walk_local(&mut self, local: &ast::Local) {
// "assigns", which is handled by
// `walk_pat`:
self
.walk_expr
(
&**
expr
);
let
init_cmt
=
return_if_err!
(
self
.mc
.cat_expr
(
&**
expr
)
);
let
init_cmt
=
self
.mc
.cat_expr
(
&**
expr
);
self
.walk_irrefutable_pat
(
init_cmt
,
&*
local
.pat
);
}
}
...
...
@@ -781,7 +765,7 @@ fn walk_struct_expr(&mut self,
None
=>
{
return
;
}
};
let
with_cmt
=
return_if_err!
(
self
.mc
.cat_expr
(
&*
with_expr
)
);
let
with_cmt
=
self
.mc
.cat_expr
(
&*
with_expr
);
// Select just those fields of the `with`
// expression that will actually be used
...
...
@@ -836,7 +820,7 @@ fn walk_adjustment(&mut self, expr: &ast::Expr) {
// rvalue.
debug!
(
"walk_adjustment(AutoAddEnv|AdjustReifyFnPointer)"
);
let
cmt_unadjusted
=
return_if_err!
(
self
.mc
.cat_expr_unadjusted
(
expr
)
);
self
.mc
.cat_expr_unadjusted
(
expr
);
self
.delegate_consume
(
expr
.id
,
expr
.span
,
cmt_unadjusted
);
}
ty
::
AdjustDerefRef
(
ty
::
AutoDerefRef
{
...
...
@@ -870,7 +854,7 @@ fn walk_autoderefs(&mut self,
match
self
.typer
.node_method_ty
(
deref_id
)
{
None
=>
{}
Some
(
method_ty
)
=>
{
let
cmt
=
return_if_err!
(
self
.mc
.cat_expr_autoderefd
(
expr
,
i
)
);
let
cmt
=
self
.mc
.cat_expr_autoderefd
(
expr
,
i
);
let
self_ty
=
ty
::
ty_fn_args
(
method_ty
)[
0
];
let
(
m
,
r
)
=
match
self_ty
.sty
{
ty
::
ty_rptr
(
r
,
ref
m
)
=>
(
m
.mutbl
,
r
),
...
...
@@ -900,15 +884,14 @@ fn walk_autoref(&mut self,
assert
!
(
n
==
1
,
format!
(
"Expected exactly 1 deref with Uniq
\
AutoRefs, found: {}"
,
n
));
let
cmt_unadjusted
=
return_if_err!
(
self
.mc
.cat_expr_unadjusted
(
expr
)
);
self
.mc
.cat_expr_unadjusted
(
expr
);
self
.delegate_consume
(
expr
.id
,
expr
.span
,
cmt_unadjusted
);
return
;
}
_
=>
{}
}
let
cmt_derefd
=
return_if_err!
(
self
.mc
.cat_expr_autoderefd
(
expr
,
n
));
let
cmt_derefd
=
self
.mc
.cat_expr_autoderefd
(
expr
,
n
);
debug!
(
"walk_adjustment: cmt_derefd={}"
,
cmt_derefd
.repr
(
self
.tcx
()));
...
...
@@ -1001,7 +984,7 @@ fn determine_pat_move_mode(&mut self,
mode
:
&
mut
TrackMatchMode
<
Span
>
)
{
debug!
(
"determine_pat_move_mode cmt_discr={} pat={}"
,
cmt_discr
.repr
(
self
.tcx
()),
pat
.repr
(
self
.tcx
()));
return_if_err!
(
self
.mc
.cat_pattern
(
cmt_discr
,
pat
,
|
_
mc
,
cmt_pat
,
pat
|
{
self
.mc
.cat_pattern
(
cmt_discr
,
pat
,
|
_
mc
,
cmt_pat
,
pat
|
{
let
tcx
=
self
.typer
.tcx
();
let
def_map
=
&
self
.typer
.tcx
()
.def_map
;
if
pat_util
::
pat_is_binding
(
def_map
,
pat
)
{
...
...
@@ -1024,7 +1007,7 @@ fn determine_pat_move_mode(&mut self,
}
}
}
})
)
;
});
}
/// The core driver for walking a pattern; `match_mode` must be
...
...
@@ -1039,11 +1022,11 @@ fn walk_pat(&mut self,
let
mc
=
&
self
.mc
;
let
typer
=
self
.typer
;
let
tcx
=
typer
.tcx
();
let
def_map
=
&
self
.typer
.tcx
()
.def_map
;
let
delegate
=
&
mut
self
.delegate
;
let
param_env
=
&
mut
self
.param_env
;
return_if_err!
(
mc
.cat_pattern
(
cmt_discr
.clone
(),
pat
,
|
mc
,
cmt_pat
,
pat
|
{
mc
.cat_pattern
(
cmt_discr
.clone
(),
pat
,
|
mc
,
cmt_pat
,
pat
|
{
if
pat_util
::
pat_is_binding
(
def_map
,
pat
)
{
let
tcx
=
typer
.tcx
();
...
...
@@ -1053,17 +1036,13 @@ fn walk_pat(&mut self,
match_mode
);
// pat_ty: the type of the binding being produced.
let
pat_ty
=
return_if_err!
(
typer
.node_ty
(
pat
.id
)
);
let
pat_ty
=
typer
.node_ty
(
pat
.id
);
// Each match binding is effectively an assignment to the
// binding being produced.
let
def
=
def_map
.borrow
()[
pat
.id
]
.clone
();
match
mc
.cat_def
(
pat
.id
,
pat
.span
,
pat_ty
,
def
)
{
Ok
(
binding_cmt
)
=>
{
delegate
.mutate
(
pat
.id
,
pat
.span
,
binding_cmt
,
Init
);
}
Err
(
_
)
=>
{
}
}
let
binding_cmt
=
mc
.cat_def
(
pat
.id
,
pat
.span
,
pat_ty
,
def
);
delegate
.mutate
(
pat
.id
,
pat
.span
,
binding_cmt
,
Init
);
// It is also a borrow or copy/move of the value being matched.
match
pat
.node
{
...
...
@@ -1097,15 +1076,8 @@ fn walk_pat(&mut self,
// borrow of the elements of the vector being
// matched.
let
(
slice_cmt
,
slice_mutbl
,
slice_r
)
=
{
match
mc
.cat_slice_pattern
(
cmt_pat
,
&**
slice_pat
)
{
Ok
(
v
)
=>
v
,
Err
(())
=>
{
tcx
.sess
.span_bug
(
slice_pat
.span
,
"Err from mc"
)
}
}
};
let
(
slice_cmt
,
slice_mutbl
,
slice_r
)
=
mc
.cat_slice_pattern
(
cmt_pat
,
&**
slice_pat
);
// Note: We declare here that the borrow
// occurs upon entering the `[...]`
...
...
@@ -1135,13 +1107,13 @@ fn walk_pat(&mut self,
_
=>
{
}
}
}
})
)
;
});
// Do a second pass over the pattern, calling `matched_pat` on
// the interior nodes (enum variants and structs), as opposed
// to the above loop's visit of than the bindings that form
// the leaves of the pattern tree structure.
return_if_err!
(
mc
.cat_pattern
(
cmt_discr
,
pat
,
|
mc
,
cmt_pat
,
pat
|
{
mc
.cat_pattern
(
cmt_discr
,
pat
,
|
mc
,
cmt_pat
,
pat
|
{
let
def_map
=
def_map
.borrow
();
let
tcx
=
typer
.tcx
();
...
...
@@ -1222,7 +1194,7 @@ fn walk_pat(&mut self,
// cases either.
}
}
})
)
;
});
}
fn
walk_captures
(
&
mut
self
,
closure_expr
:
&
ast
::
Expr
)
{
...
...
@@ -1246,9 +1218,9 @@ fn walk_by_ref_captures(&mut self,
freevars
:
&
[
ty
::
Freevar
])
{
for
freevar
in
freevars
.iter
()
{
let
id_var
=
freevar
.def
.def_id
()
.node
;
let
cmt_var
=
return_if_err!
(
self
.cat_captured_var
(
closure_expr
.id
,
closure_expr
.span
,
freevar
.def
)
);
let
cmt_var
=
self
.cat_captured_var
(
closure_expr
.id
,
closure_expr
.span
,
freevar
.def
);
// Lookup the kind of borrow the callee requires, as
// inferred by regionbk
...
...
@@ -1269,13 +1241,11 @@ fn walk_by_value_captures(&mut self,
closure_expr
:
&
ast
::
Expr
,
freevars
:
&
[
ty
::
Freevar
])
{
for
freevar
in
freevars
.iter
()
{
let
cmt_var
=
return_if_err!
(
self
.cat_captured_var
(
closure_expr
.id
,
closure_expr
.span
,
freevar
.def
));
let
mode
=
copy_or_move
(
self
.tcx
(),
cmt_var
.ty
,
&
self
.param_env
,
CaptureMove
);
let
cmt_var
=
self
.cat_captured_var
(
closure_expr
.id
,
closure_expr
.span
,
freevar
.def
);
let
mode
=
copy_or_move
(
self
.tcx
(),
cmt_var
.ty
,
&
self
.param_env
,
CaptureMove
);
self
.delegate
.consume
(
closure_expr
.id
,
freevar
.span
,
cmt_var
,
mode
);
}
}
...
...
@@ -1284,11 +1254,11 @@ fn cat_captured_var(&mut self,
closure_id
:
ast
::
NodeId
,
closure_span
:
Span
,
upvar_def
:
def
::
Def
)
->
mc
::
McResult
<
mc
::
cmt
<
'tcx
>
>
{
->
mc
::
cmt
<
'tcx
>
{
// Create the cmt for the variable being borrowed, from the
// caller's perspective
let
var_id
=
upvar_def
.def_id
()
.node
;
let
var_ty
=
try!
(
self
.typer
.node_ty
(
var_id
)
);
let
var_ty
=
self
.typer
.node_ty
(
var_id
);
self
.mc
.cat_def
(
closure_id
,
closure_span
,
var_ty
,
upvar_def
)
}
}
...
...
src/librustc/middle/mem_categorization.rs
浏览文件 @
a583ba2f
...
...
@@ -264,8 +264,6 @@ pub struct MemCategorizationContext<'t,TYPER:'t> {
impl
<
't
,
TYPER
:
't
>
Copy
for
MemCategorizationContext
<
't
,
TYPER
>
{}
pub
type
McResult
<
T
>
=
Result
<
T
,
()
>
;
/// The `Typer` trait provides the interface for the mem-categorization
/// module to the results of the type check. It can be used to query
/// the type assigned to an expression node, to inquire after adjustments,
...
...
@@ -284,8 +282,8 @@ impl<'t,TYPER:'t> Copy for MemCategorizationContext<'t,TYPER> {}
/// can be sure that only `Ok` results will occur.
pub
trait
Typer
<
'tcx
>
{
fn
tcx
<
'a
>
(
&
'a
self
)
->
&
'a
ty
::
ctxt
<
'tcx
>
;
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
McResult
<
Ty
<
'tcx
>
>
;
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
McResult
<
Ty
<
'tcx
>
>
;
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
Ty
<
'tcx
>
;
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
Ty
<
'tcx
>
;
fn
node_method_ty
(
&
self
,
method_call
:
ty
::
MethodCall
)
->
Option
<
Ty
<
'tcx
>>
;
fn
adjustments
<
'a
>
(
&
'a
self
)
->
&
'a
RefCell
<
NodeMap
<
ty
::
AutoAdjustment
<
'tcx
>>>
;
fn
is_method_call
(
&
self
,
id
:
ast
::
NodeId
)
->
bool
;
...
...
@@ -375,15 +373,6 @@ pub fn to_user_str(&self) -> &'static str {
}
}
macro_rules!
if_ok
{
(
$inp
:
expr
)
=>
(
match
$inp
{
Ok
(
v
)
=>
{
v
}
Err
(
e
)
=>
{
return
Err
(
e
);
}
}
)
}
impl
<
't
,
'tcx
,
TYPER
:
Typer
<
'tcx
>>
MemCategorizationContext
<
't
,
TYPER
>
{
pub
fn
new
(
typer
:
&
't
TYPER
)
->
MemCategorizationContext
<
't
,
TYPER
>
{
MemCategorizationContext
{
typer
:
typer
}
...
...
@@ -393,22 +382,22 @@ fn tcx(&self) -> &'t ty::ctxt<'tcx> {
self
.typer
.tcx
()
}
fn
expr_ty
(
&
self
,
expr
:
&
ast
::
Expr
)
->
McResult
<
Ty
<
'tcx
>
>
{
fn
expr_ty
(
&
self
,
expr
:
&
ast
::
Expr
)
->
Ty
<
'tcx
>
{
self
.typer
.node_ty
(
expr
.id
)
}
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
McResult
<
Ty
<
'tcx
>
>
{
let
unadjusted_ty
=
if_ok!
(
self
.expr_ty
(
expr
)
);
Ok
(
ty
::
adjust_ty
(
self
.tcx
(),
expr
.span
,
expr
.id
,
unadjusted_ty
,
self
.typer
.adjustments
()
.borrow
()
.get
(
&
expr
.id
),
|
method_call
|
self
.typer
.node_method_ty
(
method_call
)
))
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
Ty
<
'tcx
>
{
let
unadjusted_ty
=
self
.expr_ty
(
expr
);
ty
::
adjust_ty
(
self
.tcx
(),
expr
.span
,
expr
.id
,
unadjusted_ty
,
self
.typer
.adjustments
()
.borrow
()
.get
(
&
expr
.id
),
|
method_call
|
self
.typer
.node_method_ty
(
method_call
))
}
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
McResult
<
Ty
<
'tcx
>
>
{
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
Ty
<
'tcx
>
{
self
.typer
.node_ty
(
id
)
}
fn
pat_ty
(
&
self
,
pat
:
&
ast
::
Pat
)
->
McResult
<
Ty
<
'tcx
>
>
{
fn
pat_ty
(
&
self
,
pat
:
&
ast
::
Pat
)
->
Ty
<
'tcx
>
{
let
tcx
=
self
.typer
.tcx
();
let
base_ty
=
self
.typer
.node_ty
(
pat
.id
);
// FIXME (Issue #18207): This code detects whether we are
...
...
@@ -420,11 +409,9 @@ fn pat_ty(&self, pat: &ast::Pat) -> McResult<Ty<'tcx>> {
// a bind-by-ref means that the base_ty will be the type of the ident itself,
// but what we want here is the type of the underlying value being borrowed.
// So peel off one-level, turning the &T into T.
base_ty
.map
(|
t
|
{
ty
::
deref
(
t
,
false
)
.unwrap_or_else
(||
{
panic!
(
"encountered BindByRef with non &-type"
);
})
.ty
})
ty
::
deref
(
base_ty
,
false
)
.unwrap_or_else
(||
{
panic!
(
"encountered BindByRef with non &-type"
);
})
.ty
}
_
=>
base_ty
,
};
...
...
@@ -433,7 +420,7 @@ fn pat_ty(&self, pat: &ast::Pat) -> McResult<Ty<'tcx>> {
ret_ty
}
pub
fn
cat_expr
(
&
self
,
expr
:
&
ast
::
Expr
)
->
McResult
<
cmt
<
'tcx
>
>
{
pub
fn
cat_expr
(
&
self
,
expr
:
&
ast
::
Expr
)
->
cmt
<
'tcx
>
{
match
self
.typer
.adjustments
()
.borrow
()
.get
(
&
expr
.id
)
{
None
=>
{
// No adjustments.
...
...
@@ -447,8 +434,8 @@ pub fn cat_expr(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {
expr
.repr
(
self
.tcx
()));
// Convert a bare fn to a closure by adding NULL env.
// Result is an rvalue.
let
expr_ty
=
if_ok!
(
self
.expr_ty_adjusted
(
expr
)
);
Ok
(
self
.cat_rvalue_node
(
expr
.id
(),
expr
.span
(),
expr_ty
)
)
let
expr_ty
=
self
.expr_ty_adjusted
(
expr
);
self
.cat_rvalue_node
(
expr
.id
(),
expr
.span
(),
expr_ty
)
}
ty
::
AdjustDerefRef
(
...
...
@@ -458,8 +445,8 @@ pub fn cat_expr(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {
expr
.repr
(
self
.tcx
()));
// Equivalent to &*expr or something similar.
// Result is an rvalue.
let
expr_ty
=
if_ok!
(
self
.expr_ty_adjusted
(
expr
)
);
Ok
(
self
.cat_rvalue_node
(
expr
.id
(),
expr
.span
(),
expr_ty
)
)
let
expr_ty
=
self
.expr_ty_adjusted
(
expr
);
self
.cat_rvalue_node
(
expr
.id
(),
expr
.span
(),
expr_ty
)
}
ty
::
AdjustDerefRef
(
...
...
@@ -476,39 +463,39 @@ pub fn cat_expr(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {
pub
fn
cat_expr_autoderefd
(
&
self
,
expr
:
&
ast
::
Expr
,
autoderefs
:
uint
)
->
McResult
<
cmt
<
'tcx
>
>
{
let
mut
cmt
=
if_ok!
(
self
.cat_expr_unadjusted
(
expr
)
);
->
cmt
<
'tcx
>
{
let
mut
cmt
=
self
.cat_expr_unadjusted
(
expr
);
debug!
(
"cat_expr_autoderefd: autoderefs={}, cmt={}"
,
autoderefs
,
cmt
.repr
(
self
.tcx
()));
for
deref
in
range
(
1u
,
autoderefs
+
1
)
{
cmt
=
self
.cat_deref
(
expr
,
cmt
,
deref
,
false
);
}
return
Ok
(
cmt
)
;
return
cmt
;
}
pub
fn
cat_expr_unadjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
McResult
<
cmt
<
'tcx
>
>
{
pub
fn
cat_expr_unadjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
cmt
<
'tcx
>
{
debug!
(
"cat_expr: id={} expr={}"
,
expr
.id
,
expr
.repr
(
self
.tcx
()));
let
expr_ty
=
if_ok!
(
self
.expr_ty
(
expr
)
);
let
expr_ty
=
self
.expr_ty
(
expr
);
match
expr
.node
{
ast
::
ExprUnary
(
ast
::
UnDeref
,
ref
e_base
)
=>
{
let
base_cmt
=
if_ok!
(
self
.cat_expr
(
&**
e_base
)
);
Ok
(
self
.cat_deref
(
expr
,
base_cmt
,
0
,
false
)
)
let
base_cmt
=
self
.cat_expr
(
&**
e_base
);
self
.cat_deref
(
expr
,
base_cmt
,
0
,
false
)
}
ast
::
ExprField
(
ref
base
,
f_name
)
=>
{
let
base_cmt
=
if_ok!
(
self
.cat_expr
(
&**
base
)
);
let
base_cmt
=
self
.cat_expr
(
&**
base
);
debug!
(
"cat_expr(cat_field): id={} expr={} base={}"
,
expr
.id
,
expr
.repr
(
self
.tcx
()),
base_cmt
.repr
(
self
.tcx
()));
Ok
(
self
.cat_field
(
expr
,
base_cmt
,
f_name
.node.name
,
expr_ty
)
)
self
.cat_field
(
expr
,
base_cmt
,
f_name
.node.name
,
expr_ty
)
}
ast
::
ExprTupField
(
ref
base
,
idx
)
=>
{
let
base_cmt
=
if_ok!
(
self
.cat_expr
(
&**
base
)
);
Ok
(
self
.cat_tup_field
(
expr
,
base_cmt
,
idx
.node
,
expr_ty
)
)
let
base_cmt
=
self
.cat_expr
(
&**
base
);
self
.cat_tup_field
(
expr
,
base_cmt
,
idx
.node
,
expr_ty
)
}
ast
::
ExprIndex
(
ref
base
,
_
)
=>
{
...
...
@@ -518,14 +505,14 @@ pub fn cat_expr_unadjusted(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {
// If this is an index implemented by a method call, then it will
// include an implicit deref of the result.
let
ret_ty
=
ty
::
ty_fn_ret
(
method_ty
)
.unwrap
();
Ok
(
self
.cat_deref
(
expr
,
self
.cat_rvalue_node
(
expr
.id
(),
expr
.span
(),
ret_ty
),
1
,
true
)
)
self
.cat_deref
(
expr
,
self
.cat_rvalue_node
(
expr
.id
(),
expr
.span
(),
ret_ty
),
1
,
true
)
}
None
=>
{
let
base_cmt
=
if_ok!
(
self
.cat_expr
(
&**
base
)
);
Ok
(
self
.cat_index
(
expr
,
base_cmt
)
)
let
base_cmt
=
self
.cat_expr
(
&**
base
);
self
.cat_index
(
expr
,
base_cmt
)
}
}
}
...
...
@@ -551,7 +538,7 @@ pub fn cat_expr_unadjusted(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {
ast
::
ExprAgain
(
..
)
|
ast
::
ExprStruct
(
..
)
|
ast
::
ExprRepeat
(
..
)
|
ast
::
ExprInlineAsm
(
..
)
|
ast
::
ExprBox
(
..
)
|
ast
::
ExprForLoop
(
..
)
=>
{
Ok
(
self
.cat_rvalue_node
(
expr
.id
(),
expr
.span
(),
expr_ty
)
)
self
.cat_rvalue_node
(
expr
.id
(),
expr
.span
(),
expr_ty
)
}
ast
::
ExprIfLet
(
..
)
=>
{
...
...
@@ -568,43 +555,43 @@ pub fn cat_def(&self,
span
:
Span
,
expr_ty
:
Ty
<
'tcx
>
,
def
:
def
::
Def
)
->
McResult
<
cmt
<
'tcx
>
>
{
->
cmt
<
'tcx
>
{
debug!
(
"cat_def: id={} expr={} def={}"
,
id
,
expr_ty
.repr
(
self
.tcx
()),
def
);
match
def
{
def
::
DefStruct
(
..
)
|
def
::
DefVariant
(
..
)
|
def
::
DefFn
(
..
)
|
def
::
DefStaticMethod
(
..
)
|
def
::
DefConst
(
..
)
=>
{
Ok
(
self
.cat_rvalue_node
(
id
,
span
,
expr_ty
)
)
self
.cat_rvalue_node
(
id
,
span
,
expr_ty
)
}
def
::
DefMod
(
_
)
|
def
::
DefForeignMod
(
_
)
|
def
::
DefUse
(
_
)
|
def
::
DefTrait
(
_
)
|
def
::
DefTy
(
..
)
|
def
::
DefPrimTy
(
_
)
|
def
::
DefTyParam
(
..
)
|
def
::
DefTyParamBinder
(
..
)
|
def
::
DefRegion
(
_
)
|
def
::
DefLabel
(
_
)
|
def
::
DefSelfTy
(
..
)
|
def
::
DefMethod
(
..
)
|
def
::
DefAssociatedTy
(
..
)
|
def
::
DefAssociatedPath
(
..
)
=>
{
Ok
(
Rc
::
new
(
cmt_
{
Rc
::
new
(
cmt_
{
id
:
id
,
span
:
span
,
cat
:
cat_static_item
,
mutbl
:
McImmutable
,
ty
:
expr_ty
,
note
:
NoteNone
})
)
})
}
def
::
DefStatic
(
_
,
mutbl
)
=>
{
Ok
(
Rc
::
new
(
cmt_
{
Rc
::
new
(
cmt_
{
id
:
id
,
span
:
span
,
cat
:
cat_static_item
,
mutbl
:
if
mutbl
{
McDeclared
}
else
{
McImmutable
},
ty
:
expr_ty
,
note
:
NoteNone
})
)
})
}
def
::
DefUpvar
(
var_id
,
fn_node_id
,
_
)
=>
{
let
ty
=
if_ok!
(
self
.node_ty
(
fn_node_id
)
);
let
ty
=
self
.node_ty
(
fn_node_id
);
match
ty
.sty
{
ty
::
ty_closure
(
ref
closure_ty
)
=>
{
// Translate old closure type info into unboxed
...
...
@@ -642,14 +629,14 @@ pub fn cat_def(&self,
}
def
::
DefLocal
(
vid
)
=>
{
Ok
(
Rc
::
new
(
cmt_
{
Rc
::
new
(
cmt_
{
id
:
id
,
span
:
span
,
cat
:
cat_local
(
vid
),
mutbl
:
MutabilityCategory
::
from_local
(
self
.tcx
(),
vid
),
ty
:
expr_ty
,
note
:
NoteNone
})
)
})
}
}
}
...
...
@@ -664,7 +651,7 @@ fn cat_upvar(&self,
kind
:
ty
::
UnboxedClosureKind
,
mode
:
ast
::
CaptureClause
,
is_unboxed
:
bool
)
->
McResult
<
cmt
<
'tcx
>
>
{
->
cmt
<
'tcx
>
{
// An upvar can have up to 3 components. The base is a
// `cat_upvar`. Next, we add a deref through the implicit
// environment pointer with an anonymous free region 'env and
...
...
@@ -686,7 +673,7 @@ fn cat_upvar(&self,
// FnOnce | copied | upvar -> &'up bk
// old stack | N/A | upvar -> &'env mut -> &'up bk
// old proc/once | copied | N/A
let
var_ty
=
if_ok!
(
self
.node_ty
(
var_id
)
);
let
var_ty
=
self
.node_ty
(
var_id
);
let
upvar_id
=
ty
::
UpvarId
{
var_id
:
var_id
,
closure_expr_id
:
fn_node_id
};
...
...
@@ -734,7 +721,7 @@ fn cat_upvar(&self,
});
// First, switch by capture mode
Ok
(
match
mode
{
match
mode
{
ast
::
CaptureByValue
=>
{
let
mut
base
=
cmt_
{
id
:
id
,
...
...
@@ -816,7 +803,7 @@ fn cat_upvar(&self,
note
:
NoteUpvarRef
(
upvar_id
)
})
}
}
)
}
}
pub
fn
cat_rvalue_node
(
&
self
,
...
...
@@ -1065,13 +1052,13 @@ fn deref_vec<N:ast_node>(&self,
pub
fn
cat_slice_pattern
(
&
self
,
vec_cmt
:
cmt
<
'tcx
>
,
slice_pat
:
&
ast
::
Pat
)
->
McResult
<
(
cmt
<
'tcx
>
,
ast
::
Mutability
,
ty
::
Region
)
>
{
let
slice_ty
=
if_ok!
(
self
.node_ty
(
slice_pat
.id
)
);
->
(
cmt
<
'tcx
>
,
ast
::
Mutability
,
ty
::
Region
)
{
let
slice_ty
=
self
.node_ty
(
slice_pat
.id
);
let
(
slice_mutbl
,
slice_r
)
=
vec_slice_info
(
self
.tcx
(),
slice_pat
,
slice_ty
);
let
cmt_slice
=
self
.cat_index
(
slice_pat
,
self
.deref_vec
(
slice_pat
,
vec_cmt
));
return
Ok
((
cmt_slice
,
slice_mutbl
,
slice_r
)
);
return
(
cmt_slice
,
slice_mutbl
,
slice_r
);
/// In a pattern like [a, b, ..c], normally `c` has slice type, but if you have [a, b,
/// ..ref c], then the type of `ref c` will be `&&[]`, so to extract the slice details we
...
...
@@ -1131,7 +1118,7 @@ pub fn cat_pattern(&self,
cmt
:
cmt
<
'tcx
>
,
pat
:
&
ast
::
Pat
,
op
:
|
&
MemCategorizationContext
<
't
,
TYPER
>
,
cmt
<
'tcx
>
,
&
ast
::
Pat
|)
->
McResult
<
()
>
{
{
// Here, `cmt` is the categorization for the value being
// matched and pat is the pattern it is being matched against.
//
...
...
@@ -1211,30 +1198,30 @@ pub fn cat_pattern(&self,
Some
(
&
def
::
DefVariant
(
..
))
=>
{
// variant(x, y, z)
for
(
i
,
subpat
)
in
subpats
.iter
()
.enumerate
()
{
let
subpat_ty
=
if_ok!
(
self
.pat_ty
(
&**
subpat
)
);
// see (*2)
let
subpat_ty
=
self
.pat_ty
(
&**
subpat
);
// see (*2)
let
subcmt
=
self
.cat_imm_interior
(
pat
,
cmt
.clone
(),
subpat_ty
,
InteriorField
(
PositionalField
(
i
)));
if_ok!
(
self
.cat_pattern
(
subcmt
,
&**
subpat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
)
));
self
.cat_pattern
(
subcmt
,
&**
subpat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
));
}
}
Some
(
&
def
::
DefStruct
(
..
))
=>
{
for
(
i
,
subpat
)
in
subpats
.iter
()
.enumerate
()
{
let
subpat_ty
=
if_ok!
(
self
.pat_ty
(
&**
subpat
)
);
// see (*2)
let
subpat_ty
=
self
.pat_ty
(
&**
subpat
);
// see (*2)
let
cmt_field
=
self
.cat_imm_interior
(
pat
,
cmt
.clone
(),
subpat_ty
,
InteriorField
(
PositionalField
(
i
)));
if_ok!
(
self
.cat_pattern
(
cmt_field
,
&**
subpat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
)
));
self
.cat_pattern
(
cmt_field
,
&**
subpat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
));
}
}
Some
(
&
def
::
DefConst
(
..
))
=>
{
for
subpat
in
subpats
.iter
()
{
if_ok!
(
self
.cat_pattern
(
cmt
.clone
(),
&**
subpat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
)
));
self
.cat_pattern
(
cmt
.clone
(),
&**
subpat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
));
}
}
_
=>
{
...
...
@@ -1246,7 +1233,7 @@ pub fn cat_pattern(&self,
}
ast
::
PatIdent
(
_
,
_
,
Some
(
ref
subpat
))
=>
{
if_ok!
(
self
.cat_pattern
(
cmt
,
&**
subpat
,
op
)
);
self
.cat_pattern
(
cmt
,
&**
subpat
,
op
);
}
ast
::
PatIdent
(
_
,
_
,
None
)
=>
{
...
...
@@ -1256,43 +1243,43 @@ pub fn cat_pattern(&self,
ast
::
PatStruct
(
_
,
ref
field_pats
,
_
)
=>
{
// {f1: p1, ..., fN: pN}
for
fp
in
field_pats
.iter
()
{
let
field_ty
=
if_ok!
(
self
.pat_ty
(
&*
fp
.node.pat
)
);
// see (*2)
let
field_ty
=
self
.pat_ty
(
&*
fp
.node.pat
);
// see (*2)
let
cmt_field
=
self
.cat_field
(
pat
,
cmt
.clone
(),
fp
.node.ident.name
,
field_ty
);
if_ok!
(
self
.cat_pattern
(
cmt_field
,
&*
fp
.node.pat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
)
));
self
.cat_pattern
(
cmt_field
,
&*
fp
.node.pat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
));
}
}
ast
::
PatTup
(
ref
subpats
)
=>
{
// (p1, ..., pN)
for
(
i
,
subpat
)
in
subpats
.iter
()
.enumerate
()
{
let
subpat_ty
=
if_ok!
(
self
.pat_ty
(
&**
subpat
)
);
// see (*2)
let
subpat_ty
=
self
.pat_ty
(
&**
subpat
);
// see (*2)
let
subcmt
=
self
.cat_imm_interior
(
pat
,
cmt
.clone
(),
subpat_ty
,
InteriorField
(
PositionalField
(
i
)));
if_ok!
(
self
.cat_pattern
(
subcmt
,
&**
subpat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
)
));
self
.cat_pattern
(
subcmt
,
&**
subpat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
));
}
}
ast
::
PatBox
(
ref
subpat
)
|
ast
::
PatRegion
(
ref
subpat
)
=>
{
// @p1, ~p1, ref p1
let
subcmt
=
self
.cat_deref
(
pat
,
cmt
,
0
,
false
);
if_ok!
(
self
.cat_pattern
(
subcmt
,
&**
subpat
,
op
)
);
self
.cat_pattern
(
subcmt
,
&**
subpat
,
op
);
}
ast
::
PatVec
(
ref
before
,
ref
slice
,
ref
after
)
=>
{
let
elt_cmt
=
self
.cat_index
(
pat
,
self
.deref_vec
(
pat
,
cmt
));
for
before_pat
in
before
.iter
()
{
if_ok!
(
self
.cat_pattern
(
elt_cmt
.clone
(),
&**
before_pat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
)
));
self
.cat_pattern
(
elt_cmt
.clone
(),
&**
before_pat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
));
}
for
slice_pat
in
slice
.iter
()
{
let
slice_ty
=
if_ok!
(
self
.pat_ty
(
&**
slice_pat
)
);
let
slice_ty
=
self
.pat_ty
(
&**
slice_pat
);
let
slice_cmt
=
self
.cat_rvalue_node
(
pat
.id
(),
pat
.span
(),
slice_ty
);
if_ok!
(
self
.cat_pattern
(
slice_cmt
,
&**
slice_pat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
)
));
self
.cat_pattern
(
slice_cmt
,
&**
slice_pat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
));
}
for
after_pat
in
after
.iter
()
{
if_ok!
(
self
.cat_pattern
(
elt_cmt
.clone
(),
&**
after_pat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
)
));
self
.cat_pattern
(
elt_cmt
.clone
(),
&**
after_pat
,
|
x
,
y
,
z
|
op
(
x
,
y
,
z
));
}
}
...
...
@@ -1304,8 +1291,6 @@ pub fn cat_pattern(&self,
self
.tcx
()
.sess
.span_bug
(
pat
.span
,
"unexpanded macro"
);
}
}
Ok
(())
}
pub
fn
cmt_to_string
(
&
self
,
cmt
:
&
cmt_
<
'tcx
>
)
->
String
{
...
...
src/librustc/middle/traits/select.rs
浏览文件 @
a583ba2f
...
...
@@ -1228,8 +1228,7 @@ fn builtin_bound(&mut self,
.iter
()
.map
(|
freevar
|
{
let
freevar_def_id
=
freevar
.def
.def_id
();
self
.typer
.node_ty
(
freevar_def_id
.node
)
.unwrap_or
(
ty
::
mk_err
())
.subst
(
self
.tcx
(),
substs
)
self
.typer
.node_ty
(
freevar_def_id
.node
)
.subst
(
self
.tcx
(),
substs
)
})
.collect
();
Ok
(
If
(
tys
))
...
...
src/librustc/middle/ty.rs
浏览文件 @
a583ba2f
...
...
@@ -6165,12 +6165,12 @@ fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> {
self
}
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
mc
::
McResult
<
Ty
<
'tcx
>
>
{
Ok
(
ty
::
node_id_to_type
(
self
,
id
)
)
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
Ty
<
'tcx
>
{
ty
::
node_id_to_type
(
self
,
id
)
}
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
mc
::
McResult
<
Ty
<
'tcx
>
>
{
Ok
(
ty
::
expr_ty_adjusted
(
self
,
expr
)
)
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
Ty
<
'tcx
>
{
ty
::
expr_ty_adjusted
(
self
,
expr
)
}
fn
node_method_ty
(
&
self
,
method_call
:
ty
::
MethodCall
)
->
Option
<
Ty
<
'tcx
>>
{
...
...
src/librustc_borrowck/borrowck/mod.rs
浏览文件 @
a583ba2f
...
...
@@ -516,12 +516,7 @@ pub fn mc(&self) -> mc::MemCategorizationContext<'a, ty::ctxt<'tcx>> {
}
pub
fn
cat_expr
(
&
self
,
expr
:
&
ast
::
Expr
)
->
mc
::
cmt
<
'tcx
>
{
match
self
.mc
()
.cat_expr
(
expr
)
{
Ok
(
c
)
=>
c
,
Err
(())
=>
{
self
.tcx.sess
.span_bug
(
expr
.span
,
"error in mem categorization"
);
}
}
self
.mc
()
.cat_expr
(
expr
)
}
pub
fn
report
(
&
self
,
err
:
BckError
<
'tcx
>
)
{
...
...
src/librustc_trans/trans/common.rs
浏览文件 @
a583ba2f
...
...
@@ -463,12 +463,12 @@ fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> {
self
.tcx
()
}
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
mc
::
McResult
<
Ty
<
'tcx
>
>
{
Ok
(
node_id_type
(
self
,
id
)
)
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
Ty
<
'tcx
>
{
node_id_type
(
self
,
id
)
}
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
mc
::
McResult
<
Ty
<
'tcx
>
>
{
Ok
(
expr_ty_adjusted
(
self
,
expr
)
)
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
Ty
<
'tcx
>
{
expr_ty_adjusted
(
self
,
expr
)
}
fn
node_method_ty
(
&
self
,
method_call
:
ty
::
MethodCall
)
->
Option
<
Ty
<
'tcx
>>
{
...
...
src/librustc_typeck/check/mod.rs
浏览文件 @
a583ba2f
...
...
@@ -86,7 +86,7 @@
use
middle
::{
const_eval
,
def
};
use
middle
::
infer
;
use
middle
::
lang_items
::
IteratorItem
;
use
middle
::
mem_categorization
::{
mod
,
McResult
}
;
use
middle
::
mem_categorization
as
mc
;
use
middle
::
pat_util
::{
mod
,
pat_id_map
};
use
middle
::
region
::
CodeExtent
;
use
middle
::
subst
::{
mod
,
Subst
,
Substs
,
VecPerParamSpace
,
ParamSpace
};
...
...
@@ -282,24 +282,24 @@ pub struct FnCtxt<'a, 'tcx: 'a> {
ccx
:
&
'a
CrateCtxt
<
'a
,
'tcx
>
,
}
impl
<
'a
,
'tcx
>
m
em_categorization
::
Typer
<
'tcx
>
for
FnCtxt
<
'a
,
'tcx
>
{
impl
<
'a
,
'tcx
>
m
c
::
Typer
<
'tcx
>
for
FnCtxt
<
'a
,
'tcx
>
{
fn
tcx
(
&
self
)
->
&
ty
::
ctxt
<
'tcx
>
{
self
.ccx.tcx
}
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
McResult
<
Ty
<
'tcx
>
>
{
fn
node_ty
(
&
self
,
id
:
ast
::
NodeId
)
->
Ty
<
'tcx
>
{
let
ty
=
self
.node_ty
(
id
);
Ok
(
self
.infcx
()
.resolve_type_vars_if_possible
(
ty
)
)
self
.infcx
()
.resolve_type_vars_if_possible
(
&
ty
)
}
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
McResult
<
Ty
<
'tcx
>
>
{
fn
expr_ty_adjusted
(
&
self
,
expr
:
&
ast
::
Expr
)
->
Ty
<
'tcx
>
{
let
ty
=
self
.expr_ty_adjusted
(
expr
);
Ok
(
self
.infcx
()
.resolve_type_vars_if_possible
(
ty
)
)
self
.infcx
()
.resolve_type_vars_if_possible
(
&
ty
)
}
fn
node_method_ty
(
&
self
,
method_call
:
ty
::
MethodCall
)
->
Option
<
Ty
<
'tcx
>>
{
self
.inh.method_map
.borrow
()
.get
(
&
method_call
)
.map
(|
method
|
method
.ty
)
.map
(|
ty
|
self
.infcx
()
.resolve_type_vars_if_possible
(
ty
))
.map
(|
ty
|
self
.infcx
()
.resolve_type_vars_if_possible
(
&
ty
))
}
fn
adjustments
(
&
self
)
->
&
RefCell
<
NodeMap
<
ty
::
AutoAdjustment
<
'tcx
>>>
{
&
self
.inh.adjustments
...
...
src/librustc_typeck/check/regionck.rs
浏览文件 @
a583ba2f
...
...
@@ -193,19 +193,6 @@ pub fn regionck_ensure_component_tys_wf<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
///////////////////////////////////////////////////////////////////////////
// INTERNALS
// If mem categorization results in an error, it's because the type
// check failed (or will fail, when the error is uncovered and
// reported during writeback). In this case, we just ignore this part
// of the code and don't try to add any more region constraints.
macro_rules!
ignore_err
{
(
$inp
:
expr
)
=>
(
match
$inp
{
Ok
(
v
)
=>
v
,
Err
(())
=>
return
}
)
}
// Stores parameters for a potential call to link_region()
// to perform if an upvar reference is marked unique/mutable after
// it has already been processed before.
...
...
@@ -1040,7 +1027,7 @@ fn constrain_callee(rcx: &mut Rcx,
// While we're here, link the closure's region with a unique
// immutable borrow (gathered later in borrowck)
let
mc
=
mc
::
MemCategorizationContext
::
new
(
rcx
.fcx
);
let
expr_cmt
=
ignore_err!
(
mc
.cat_expr
(
callee_expr
)
);
let
expr_cmt
=
mc
.cat_expr
(
callee_expr
);
link_region
(
rcx
,
callee_expr
.span
,
call_region
,
ty
::
UniqueImmBorrow
,
expr_cmt
);
r
...
...
@@ -1149,7 +1136,7 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>,
};
{
let
mc
=
mc
::
MemCategorizationContext
::
new
(
rcx
.fcx
);
let
self_cmt
=
ignore_err!
(
mc
.cat_expr_autoderefd
(
deref_expr
,
i
)
);
let
self_cmt
=
mc
.cat_expr_autoderefd
(
deref_expr
,
i
);
link_region
(
rcx
,
deref_expr
.span
,
r
,
ty
::
BorrowKind
::
from_mutbl
(
m
),
self_cmt
);
}
...
...
@@ -1245,7 +1232,7 @@ fn link_addr_of(rcx: &mut Rcx, expr: &ast::Expr,
let
cmt
=
{
let
mc
=
mc
::
MemCategorizationContext
::
new
(
rcx
.fcx
);
ignore_err!
(
mc
.cat_expr
(
base
)
)
mc
.cat_expr
(
base
)
};
link_region_from_node_type
(
rcx
,
expr
.span
,
expr
.id
,
mutability
,
cmt
);
}
...
...
@@ -1260,7 +1247,7 @@ fn link_local(rcx: &Rcx, local: &ast::Local) {
Some
(
ref
expr
)
=>
&**
expr
,
};
let
mc
=
mc
::
MemCategorizationContext
::
new
(
rcx
.fcx
);
let
discr_cmt
=
ignore_err!
(
mc
.cat_expr
(
init_expr
)
);
let
discr_cmt
=
mc
.cat_expr
(
init_expr
);
link_pattern
(
rcx
,
mc
,
discr_cmt
,
&*
local
.pat
);
}
...
...
@@ -1270,7 +1257,7 @@ fn link_local(rcx: &Rcx, local: &ast::Local) {
fn
link_match
(
rcx
:
&
Rcx
,
discr
:
&
ast
::
Expr
,
arms
:
&
[
ast
::
Arm
])
{
debug!
(
"regionck::for_match()"
);
let
mc
=
mc
::
MemCategorizationContext
::
new
(
rcx
.fcx
);
let
discr_cmt
=
ignore_err!
(
mc
.cat_expr
(
discr
)
);
let
discr_cmt
=
mc
.cat_expr
(
discr
);
debug!
(
"discr_cmt={}"
,
discr_cmt
.repr
(
rcx
.tcx
()));
for
arm
in
arms
.iter
()
{
for
root_pat
in
arm
.pats
.iter
()
{
...
...
@@ -1316,14 +1303,11 @@ fn link_pattern<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
// `[_, ..slice, _]` pattern
ast
::
PatVec
(
_
,
Some
(
ref
slice_pat
),
_
)
=>
{
match
mc
.cat_slice_pattern
(
sub_cmt
,
&**
slice_pat
)
{
Ok
((
slice_cmt
,
slice_mutbl
,
slice_r
))
=>
{
link_region
(
rcx
,
sub_pat
.span
,
slice_r
,
ty
::
BorrowKind
::
from_mutbl
(
slice_mutbl
),
slice_cmt
);
}
Err
(())
=>
{}
}
let
(
slice_cmt
,
slice_mutbl
,
slice_r
)
=
mc
.cat_slice_pattern
(
sub_cmt
,
&**
slice_pat
);
link_region
(
rcx
,
sub_pat
.span
,
slice_r
,
ty
::
BorrowKind
::
from_mutbl
(
slice_mutbl
),
slice_cmt
);
}
_
=>
{}
}
...
...
@@ -1339,7 +1323,7 @@ fn link_autoref(rcx: &Rcx,
debug!
(
"link_autoref(autoref={})"
,
autoref
);
let
mc
=
mc
::
MemCategorizationContext
::
new
(
rcx
.fcx
);
let
expr_cmt
=
ignore_err!
(
mc
.cat_expr_autoderefd
(
expr
,
autoderefs
)
);
let
expr_cmt
=
mc
.cat_expr_autoderefd
(
expr
,
autoderefs
);
debug!
(
"expr_cmt={}"
,
expr_cmt
.repr
(
rcx
.tcx
()));
match
*
autoref
{
...
...
@@ -1361,7 +1345,7 @@ fn link_by_ref(rcx: &Rcx,
debug!
(
"link_by_ref(expr={}, callee_scope={})"
,
expr
.repr
(
tcx
),
callee_scope
);
let
mc
=
mc
::
MemCategorizationContext
::
new
(
rcx
.fcx
);
let
expr_cmt
=
ignore_err!
(
mc
.cat_expr
(
expr
)
);
let
expr_cmt
=
mc
.cat_expr
(
expr
);
let
borrow_region
=
ty
::
ReScope
(
callee_scope
);
link_region
(
rcx
,
expr
.span
,
borrow_region
,
ty
::
ImmBorrow
,
expr_cmt
);
}
...
...
@@ -1629,7 +1613,7 @@ fn link_reborrowed_region<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
fn
adjust_borrow_kind_for_assignment_lhs
(
rcx
:
&
Rcx
,
lhs
:
&
ast
::
Expr
)
{
let
mc
=
mc
::
MemCategorizationContext
::
new
(
rcx
.fcx
);
let
cmt
=
ignore_err!
(
mc
.cat_expr
(
lhs
)
);
let
cmt
=
mc
.cat_expr
(
lhs
);
adjust_upvar_borrow_kind_for_mut
(
rcx
,
cmt
);
}
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录