bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

librustc: Remove "base types" from the language.

Browse source
This commit is contained in:
Patrick Walton 2013-03-12 17:33:54 -07:00
parent b85158e23a
commit a410652bc9
8 changed files with 141 additions and 148 deletions
Download patch file Download diff file Expand all files Collapse all files

78
src/librustc/driver/session.rs
View file

@ -163,50 +163,50 @@ pub struct Session_ {
pub type Session = @Session_; pub type Session = @Session_;
pub impl Session { pub impl Session_ {
fn span_fatal(&self, sp: span, msg: ~str) -> ! { fn span_fatal(@self, sp: span, msg: ~str) -> ! {
self.span_diagnostic.span_fatal(sp, msg) self.span_diagnostic.span_fatal(sp, msg)
} }
fn fatal(&self, msg: ~str) -> ! { fn fatal(@self, msg: ~str) -> ! {
self.span_diagnostic.handler().fatal(msg) self.span_diagnostic.handler().fatal(msg)
} }
fn span_err(&self, sp: span, msg: ~str) { fn span_err(@self, sp: span, msg: ~str) {
self.span_diagnostic.span_err(sp, msg) self.span_diagnostic.span_err(sp, msg)
} }
fn err(&self, msg: ~str) { fn err(@self, msg: ~str) {
self.span_diagnostic.handler().err(msg) self.span_diagnostic.handler().err(msg)
} }
fn has_errors(&self) -> bool { fn has_errors(@self) -> bool {
self.span_diagnostic.handler().has_errors() self.span_diagnostic.handler().has_errors()
} }
fn abort_if_errors(&self) { fn abort_if_errors(@self) {
self.span_diagnostic.handler().abort_if_errors() self.span_diagnostic.handler().abort_if_errors()
} }
fn span_warn(&self, sp: span, msg: ~str) { fn span_warn(@self, sp: span, msg: ~str) {
self.span_diagnostic.span_warn(sp, msg) self.span_diagnostic.span_warn(sp, msg)
} }
fn warn(&self, msg: ~str) { fn warn(@self, msg: ~str) {
self.span_diagnostic.handler().warn(msg) self.span_diagnostic.handler().warn(msg)
} }
fn span_note(&self, sp: span, msg: ~str) { fn span_note(@self, sp: span, msg: ~str) {
self.span_diagnostic.span_note(sp, msg) self.span_diagnostic.span_note(sp, msg)
} }
fn note(&self, msg: ~str) { fn note(@self, msg: ~str) {
self.span_diagnostic.handler().note(msg) self.span_diagnostic.handler().note(msg)
} }
fn span_bug(&self, sp: span, msg: ~str) -> ! { fn span_bug(@self, sp: span, msg: ~str) -> ! {
self.span_diagnostic.span_bug(sp, msg) self.span_diagnostic.span_bug(sp, msg)
} }
fn bug(&self, msg: ~str) -> ! { fn bug(@self, msg: ~str) -> ! {
self.span_diagnostic.handler().bug(msg) self.span_diagnostic.handler().bug(msg)
} }
fn span_unimpl(&self, sp: span, msg: ~str) -> ! { fn span_unimpl(@self, sp: span, msg: ~str) -> ! {
self.span_diagnostic.span_unimpl(sp, msg) self.span_diagnostic.span_unimpl(sp, msg)
} }
fn unimpl(&self, msg: ~str) -> ! { fn unimpl(@self, msg: ~str) -> ! {
self.span_diagnostic.handler().unimpl(msg) self.span_diagnostic.handler().unimpl(msg)
} }
fn span_lint_level(&self, level: lint::level, sp: span, +msg: ~str) { fn span_lint_level(@self, level: lint::level, sp: span, +msg: ~str) {
match level { match level {
lint::allow => { }, lint::allow => { },
lint::warn => self.span_warn(sp, msg), lint::warn => self.span_warn(sp, msg),
@ -215,7 +215,7 @@ pub impl Session {
} }
} }
} }
fn span_lint(&self, lint_mode: lint::lint, fn span_lint(@self, lint_mode: lint::lint,
expr_id: ast::node_id, expr_id: ast::node_id,
item_id: ast::node_id, item_id: ast::node_id,
span: span, span: span,
@ -224,55 +224,55 @@ pub impl Session {
self.lint_settings, lint_mode, expr_id, item_id); self.lint_settings, lint_mode, expr_id, item_id);
self.span_lint_level(level, span, msg); self.span_lint_level(level, span, msg);
} }
fn next_node_id(&self) -> ast::node_id { fn next_node_id(@self) -> ast::node_id {
return syntax::parse::next_node_id(self.parse_sess); return syntax::parse::next_node_id(self.parse_sess);
} }
fn diagnostic(&self) -> @diagnostic::span_handler { fn diagnostic(@self) -> @diagnostic::span_handler {
self.span_diagnostic self.span_diagnostic
} }
fn debugging_opt(&self, opt: uint) -> bool { fn debugging_opt(@self, opt: uint) -> bool {
(self.opts.debugging_opts & opt) != 0u (self.opts.debugging_opts & opt) != 0u
} }
// This exists to help with refactoring to eliminate impossible // This exists to help with refactoring to eliminate impossible
// cases later on // cases later on
fn impossible_case(&self, sp: span, msg: &str) -> ! { fn impossible_case(@self, sp: span, msg: &str) -> ! {
self.span_bug(sp, fmt!("Impossible case reached: %s", msg)); self.span_bug(sp, fmt!("Impossible case reached: %s", msg));
} }
fn verbose(&self) -> bool { self.debugging_opt(verbose) } fn verbose(@self) -> bool { self.debugging_opt(verbose) }
fn time_passes(&self) -> bool { self.debugging_opt(time_passes) } fn time_passes(@self) -> bool { self.debugging_opt(time_passes) }
fn count_llvm_insns(&self) -> bool { fn count_llvm_insns(@self) -> bool {
self.debugging_opt(count_llvm_insns) self.debugging_opt(count_llvm_insns)
} }
fn count_type_sizes(&self) -> bool { fn count_type_sizes(@self) -> bool {
self.debugging_opt(count_type_sizes) self.debugging_opt(count_type_sizes)
} }
fn time_llvm_passes(&self) -> bool { fn time_llvm_passes(@self) -> bool {
self.debugging_opt(time_llvm_passes) self.debugging_opt(time_llvm_passes)
} }
fn trans_stats(&self) -> bool { self.debugging_opt(trans_stats) } fn trans_stats(@self) -> bool { self.debugging_opt(trans_stats) }
fn meta_stats(&self) -> bool { self.debugging_opt(meta_stats) } fn meta_stats(@self) -> bool { self.debugging_opt(meta_stats) }
fn no_asm_comments(&self) -> bool { self.debugging_opt(no_asm_comments) } fn no_asm_comments(@self) -> bool { self.debugging_opt(no_asm_comments) }
fn no_verify(&self) -> bool { self.debugging_opt(no_verify) } fn no_verify(@self) -> bool { self.debugging_opt(no_verify) }
fn trace(&self) -> bool { self.debugging_opt(trace) } fn trace(@self) -> bool { self.debugging_opt(trace) }
fn coherence(&self) -> bool { self.debugging_opt(coherence) } fn coherence(@self) -> bool { self.debugging_opt(coherence) }
fn borrowck_stats(&self) -> bool { self.debugging_opt(borrowck_stats) } fn borrowck_stats(@self) -> bool { self.debugging_opt(borrowck_stats) }
fn borrowck_note_pure(&self) -> bool { fn borrowck_note_pure(@self) -> bool {
self.debugging_opt(borrowck_note_pure) self.debugging_opt(borrowck_note_pure)
} }
fn borrowck_note_loan(&self) -> bool { fn borrowck_note_loan(@self) -> bool {
self.debugging_opt(borrowck_note_loan) self.debugging_opt(borrowck_note_loan)
} }
fn no_monomorphic_collapse(&self) -> bool { fn no_monomorphic_collapse(@self) -> bool {
self.debugging_opt(no_monomorphic_collapse) self.debugging_opt(no_monomorphic_collapse)
} }
fn str_of(&self, id: ast::ident) -> @~str { fn str_of(@self, id: ast::ident) -> @~str {
self.parse_sess.interner.get(id) self.parse_sess.interner.get(id)
} }
fn ident_of(&self, +st: ~str) -> ast::ident { fn ident_of(@self, +st: ~str) -> ast::ident {
self.parse_sess.interner.intern(@st) self.parse_sess.interner.intern(@st)
} }
fn intr(&self) -> @syntax::parse::token::ident_interner { fn intr(@self) -> @syntax::parse::token::ident_interner {
self.parse_sess.interner self.parse_sess.interner
} }
} }

41
src/librustc/middle/liveness.rs
View file

@ -1640,8 +1640,8 @@ enum ReadKind {
PartiallyMovedValue PartiallyMovedValue
} }
pub impl @Liveness { pub impl Liveness {
fn check_ret(&self, id: node_id, sp: span, _fk: &visit::fn_kind, fn check_ret(@self, id: node_id, sp: span, _fk: &visit::fn_kind,
entry_ln: LiveNode) { entry_ln: LiveNode) {
if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() { if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() {
// if no_ret_var is live, then we fall off the end of the // if no_ret_var is live, then we fall off the end of the
@ -1661,10 +1661,9 @@ pub impl @Liveness {
} }
} }
fn check_move_from_var(&self, ln: LiveNode, fn check_move_from_var(@self, ln: LiveNode,
var: Variable, var: Variable,
move_expr: @expr) move_expr: @expr) {
{
/*! /*!
* *
* Checks whether `var` is live on entry to any of the * Checks whether `var` is live on entry to any of the
@ -1686,7 +1685,7 @@ pub impl @Liveness {
} }
} }
fn consider_last_use(&self, expr: @expr, ln: LiveNode, var: Variable) { fn consider_last_use(@self, expr: @expr, ln: LiveNode, var: Variable) {
debug!("consider_last_use(expr.id=%?, ln=%s, var=%s)", debug!("consider_last_use(expr.id=%?, ln=%s, var=%s)",
expr.id, ln.to_str(), var.to_str()); expr.id, ln.to_str(), var.to_str());
@ -1696,7 +1695,7 @@ pub impl @Liveness {
} }
} }
fn check_lvalue(&self, expr: @expr, vt: vt<@Liveness>) { fn check_lvalue(@self, expr: @expr, vt: vt<@Liveness>) {
match expr.node { match expr.node {
expr_path(_) => { expr_path(_) => {
match self.tcx.def_map.get(&expr.id) { match self.tcx.def_map.get(&expr.id) {
@ -1724,18 +1723,18 @@ pub impl @Liveness {
_ => { _ => {
// For other kinds of lvalues, no checks are required, // For other kinds of lvalues, no checks are required,
// and any embedded expressions are actually rvalues // and any embedded expressions are actually rvalues
visit::visit_expr(expr, *self, vt); visit::visit_expr(expr, self, vt);
} }
} }
} }
fn check_for_reassignments_in_pat(&self, pat: @pat) { fn check_for_reassignments_in_pat(@self, pat: @pat) {
do self.pat_bindings(pat) |ln, var, sp| { do self.pat_bindings(pat) |ln, var, sp| {
self.check_for_reassignment(ln, var, sp); self.check_for_reassignment(ln, var, sp);
} }
} }
fn check_for_reassignment(&self, ln: LiveNode, var: Variable, fn check_for_reassignment(@self, ln: LiveNode, var: Variable,
orig_span: span) { orig_span: span) {
match self.assigned_on_exit(ln, var) { match self.assigned_on_exit(ln, var) {
Some(ExprNode(span)) => { Some(ExprNode(span)) => {
@ -1756,10 +1755,9 @@ pub impl @Liveness {
} }
} }
fn report_illegal_move(&self, lnk: LiveNodeKind, fn report_illegal_move(@self, lnk: LiveNodeKind,
var: Variable, var: Variable,
move_expr: @expr) move_expr: @expr) {
{
// the only time that it is possible to have a moved variable // the only time that it is possible to have a moved variable
// used by ExitNode would be arguments or fields in a ctor. // used by ExitNode would be arguments or fields in a ctor.
// we give a slightly different error message in those cases. // we give a slightly different error message in those cases.
@ -1822,11 +1820,10 @@ pub impl @Liveness {
}; };
} }
fn report_move_location(&self, move_expr: @expr, fn report_move_location(@self, move_expr: @expr,
var: Variable, var: Variable,
expr_descr: &str, expr_descr: &str,
pronoun: &str) pronoun: &str) {
{
let move_expr_ty = ty::expr_ty(self.tcx, move_expr); let move_expr_ty = ty::expr_ty(self.tcx, move_expr);
let name = self.ir.variable_name(var); let name = self.ir.variable_name(var);
self.tcx.sess.span_note( self.tcx.sess.span_note(
@ -1837,7 +1834,7 @@ pub impl @Liveness {
ty_to_str(self.tcx, move_expr_ty))); ty_to_str(self.tcx, move_expr_ty)));
} }
fn report_illegal_read(&self, chk_span: span, fn report_illegal_read(@self, chk_span: span,
lnk: LiveNodeKind, lnk: LiveNodeKind,
var: Variable, var: Variable,
rk: ReadKind) { rk: ReadKind) {
@ -1868,12 +1865,12 @@ pub impl @Liveness {
} }
} }
fn should_warn(&self, var: Variable) -> Option<@~str> { fn should_warn(@self, var: Variable) -> Option<@~str> {
let name = self.ir.variable_name(var); let name = self.ir.variable_name(var);
if name[0] == ('_' as u8) { None } else { Some(name) } if name[0] == ('_' as u8) { None } else { Some(name) }
} }
fn warn_about_unused_args(&self, decl: &fn_decl, entry_ln: LiveNode) { fn warn_about_unused_args(@self, decl: &fn_decl, entry_ln: LiveNode) {
for decl.inputs.each |arg| { for decl.inputs.each |arg| {
do pat_util::pat_bindings(self.tcx.def_map, arg.pat) do pat_util::pat_bindings(self.tcx.def_map, arg.pat)
|_bm, p_id, sp, _n| { |_bm, p_id, sp, _n| {
@ -1883,7 +1880,7 @@ pub impl @Liveness {
} }
} }
fn warn_about_unused_or_dead_vars_in_pat(&self, pat: @pat) { fn warn_about_unused_or_dead_vars_in_pat(@self, pat: @pat) {
do self.pat_bindings(pat) |ln, var, sp| { do self.pat_bindings(pat) |ln, var, sp| {
if !self.warn_about_unused(sp, ln, var) { if !self.warn_about_unused(sp, ln, var) {
self.warn_about_dead_assign(sp, ln, var); self.warn_about_dead_assign(sp, ln, var);
@ -1891,7 +1888,7 @@ pub impl @Liveness {
} }
} }
fn warn_about_unused(&self, sp: span, ln: LiveNode, var: Variable) fn warn_about_unused(@self, sp: span, ln: LiveNode, var: Variable)
-> bool { -> bool {
if !self.used_on_entry(ln, var) { if !self.used_on_entry(ln, var) {
for self.should_warn(var).each |name| { for self.should_warn(var).each |name| {
@ -1921,7 +1918,7 @@ pub impl @Liveness {
return false; return false;
} }
fn warn_about_dead_assign(&self, sp: span, ln: LiveNode, var: Variable) { fn warn_about_dead_assign(@self, sp: span, ln: LiveNode, var: Variable) {
if self.live_on_exit(ln, var).is_none() { if self.live_on_exit(ln, var).is_none() {
for self.should_warn(var).each |name| { for self.should_warn(var).each |name| {
// FIXME(#3266)--make liveness warnings lintable // FIXME(#3266)--make liveness warnings lintable

26
src/librustc/middle/trans/common.rs
View file

@ -677,28 +677,28 @@ pub fn block_parent(cx: block) -> block {
// Accessors // Accessors
pub impl block { pub impl block_ {
pure fn ccx(&self) -> @CrateContext { *self.fcx.ccx } pure fn ccx(@mut self) -> @CrateContext { *self.fcx.ccx }
pure fn tcx(&self) -> ty::ctxt { self.fcx.ccx.tcx } pure fn tcx(@mut self) -> ty::ctxt { self.fcx.ccx.tcx }
pure fn sess(&self) -> Session { self.fcx.ccx.sess } pure fn sess(@mut self) -> Session { self.fcx.ccx.sess }
fn node_id_to_str(&self, id: ast::node_id) -> ~str { fn node_id_to_str(@mut self, id: ast::node_id) -> ~str {
ast_map::node_id_to_str(self.tcx().items, id, self.sess().intr()) ast_map::node_id_to_str(self.tcx().items, id, self.sess().intr())
} }
fn expr_to_str(&self, e: @ast::expr) -> ~str { fn expr_to_str(@mut self, e: @ast::expr) -> ~str {
expr_repr(self.tcx(), e) expr_repr(self.tcx(), e)
} }
fn expr_is_lval(&self, e: @ast::expr) -> bool { fn expr_is_lval(@mut self, e: @ast::expr) -> bool {
ty::expr_is_lval(self.tcx(), self.ccx().maps.method_map, e) ty::expr_is_lval(self.tcx(), self.ccx().maps.method_map, e)
} }
fn expr_kind(&self, e: @ast::expr) -> ty::ExprKind { fn expr_kind(@mut self, e: @ast::expr) -> ty::ExprKind {
ty::expr_kind(self.tcx(), self.ccx().maps.method_map, e) ty::expr_kind(self.tcx(), self.ccx().maps.method_map, e)
} }
fn def(&self, nid: ast::node_id) -> ast::def { fn def(@mut self, nid: ast::node_id) -> ast::def {
match self.tcx().def_map.find(&nid) { match self.tcx().def_map.find(&nid) {
Some(v) => v, Some(v) => v,
None => { None => {
@ -708,18 +708,18 @@ pub impl block {
} }
} }
fn val_str(&self, val: ValueRef) -> @str { fn val_str(@mut self, val: ValueRef) -> @str {
val_str(self.ccx().tn, val) val_str(self.ccx().tn, val)
} }
fn llty_str(&self, llty: TypeRef) -> @str { fn llty_str(@mut self, llty: TypeRef) -> @str {
ty_str(self.ccx().tn, llty) ty_str(self.ccx().tn, llty)
} }
fn ty_to_str(&self, t: ty::t) -> ~str { fn ty_to_str(@mut self, t: ty::t) -> ~str {
ty_to_str(self.tcx(), t) ty_to_str(self.tcx(), t)
} }
fn to_str(&self) -> ~str { fn to_str(@mut self) -> ~str {
match self.node_info { match self.node_info {
Some(node_info) => { Some(node_info) => {
fmt!("[block %d]", node_info.id) fmt!("[block %d]", node_info.id)

16
src/librustc/middle/typeck/coherence.rs
View file

@ -72,8 +72,8 @@ pub fn get_base_type(inference_context: @mut InferCtxt,
-> Option<t> { -> Option<t> {
let resolved_type; let resolved_type;
match resolve_type(inference_context, match resolve_type(inference_context,
original_type, original_type,
resolve_ivar) { resolve_ivar) {
Ok(resulting_type) if !type_is_ty_var(resulting_type) => { Ok(resulting_type) if !type_is_ty_var(resulting_type) => {
resolved_type = resulting_type; resolved_type = resulting_type;
} }
@ -87,15 +87,6 @@ pub fn get_base_type(inference_context: @mut InferCtxt,
} }
match get(resolved_type).sty { match get(resolved_type).sty {
ty_box(base_mutability_and_type) |
ty_uniq(base_mutability_and_type) |
ty_ptr(base_mutability_and_type) |
ty_rptr(_, base_mutability_and_type) => {
debug!("(getting base type) recurring");
get_base_type(inference_context, span,
base_mutability_and_type.ty)
}
ty_enum(*) | ty_trait(*) | ty_struct(*) => { ty_enum(*) | ty_trait(*) | ty_struct(*) => {
debug!("(getting base type) found base type"); debug!("(getting base type) found base type");
Some(resolved_type) Some(resolved_type)
@ -104,7 +95,8 @@ pub fn get_base_type(inference_context: @mut InferCtxt,
ty_nil | ty_bot | ty_bool | ty_int(*) | ty_uint(*) | ty_float(*) | ty_nil | ty_bot | ty_bool | ty_int(*) | ty_uint(*) | ty_float(*) |
ty_estr(*) | ty_evec(*) | ty_bare_fn(*) | ty_closure(*) | ty_tup(*) | ty_estr(*) | ty_evec(*) | ty_bare_fn(*) | ty_closure(*) | ty_tup(*) |
ty_infer(*) | ty_param(*) | ty_self | ty_type | ty_opaque_box | ty_infer(*) | ty_param(*) | ty_self | ty_type | ty_opaque_box |
ty_opaque_closure_ptr(*) | ty_unboxed_vec(*) | ty_err => { ty_opaque_closure_ptr(*) | ty_unboxed_vec(*) | ty_err | ty_box(_) |
ty_uniq(_) | ty_ptr(_) | ty_rptr(_, _) => {
debug!("(getting base type) no base type; found %?", debug!("(getting base type) no base type; found %?",
get(original_type).sty); get(original_type).sty);
None None

58
src/librustc/middle/typeck/infer/mod.rs
View file

@ -542,23 +542,23 @@ struct Snapshot {
region_vars_snapshot: uint, region_vars_snapshot: uint,
} }
pub impl @mut InferCtxt { pub impl InferCtxt {
fn combine_fields(&self, a_is_expected: bool, fn combine_fields(@mut self, a_is_expected: bool,
span: span) -> CombineFields { span: span) -> CombineFields {
CombineFields {infcx: *self, CombineFields {infcx: self,
a_is_expected: a_is_expected, a_is_expected: a_is_expected,
span: span} span: span}
} }
fn sub(&self, a_is_expected: bool, span: span) -> Sub { fn sub(@mut self, a_is_expected: bool, span: span) -> Sub {
Sub(self.combine_fields(a_is_expected, span)) Sub(self.combine_fields(a_is_expected, span))
} }
fn in_snapshot(&self) -> bool { fn in_snapshot(@mut self) -> bool {
self.region_vars.in_snapshot() self.region_vars.in_snapshot()
} }
fn start_snapshot(&self) -> Snapshot { fn start_snapshot(@mut self) -> Snapshot {
Snapshot { Snapshot {
ty_var_bindings_len: ty_var_bindings_len:
self.ty_var_bindings.bindings.len(), self.ty_var_bindings.bindings.len(),
@ -571,7 +571,7 @@ pub impl @mut InferCtxt {
} }
} }
fn rollback_to(&self, snapshot: &Snapshot) { fn rollback_to(@mut self, snapshot: &Snapshot) {
debug!("rollback!"); debug!("rollback!");
rollback_to(&mut self.ty_var_bindings, snapshot.ty_var_bindings_len); rollback_to(&mut self.ty_var_bindings, snapshot.ty_var_bindings_len);
@ -584,7 +584,7 @@ pub impl @mut InferCtxt {
} }
/// Execute `f` and commit the bindings if successful /// Execute `f` and commit the bindings if successful
fn commit<T,E>(&self, f: &fn() -> Result<T,E>) -> Result<T,E> { fn commit<T,E>(@mut self, f: &fn() -> Result<T,E>) -> Result<T,E> {
fail_unless!(!self.in_snapshot()); fail_unless!(!self.in_snapshot());
debug!("commit()"); debug!("commit()");
@ -599,7 +599,7 @@ pub impl @mut InferCtxt {
} }
/// Execute `f`, unroll bindings on failure /// Execute `f`, unroll bindings on failure
fn try<T,E>(&self, f: &fn() -> Result<T,E>) -> Result<T,E> { fn try<T,E>(@mut self, f: &fn() -> Result<T,E>) -> Result<T,E> {
debug!("try()"); debug!("try()");
do indent { do indent {
let snapshot = self.start_snapshot(); let snapshot = self.start_snapshot();
@ -613,7 +613,7 @@ pub impl @mut InferCtxt {
} }
/// Execute `f` then unroll any bindings it creates /// Execute `f` then unroll any bindings it creates
fn probe<T,E>(&self, f: &fn() -> Result<T,E>) -> Result<T,E> { fn probe<T,E>(@mut self, f: &fn() -> Result<T,E>) -> Result<T,E> {
debug!("probe()"); debug!("probe()");
do indent { do indent {
let snapshot = self.start_snapshot(); let snapshot = self.start_snapshot();
@ -634,8 +634,8 @@ fn next_simple_var<V:Copy,T:Copy>(
return id; return id;
} }
pub impl @mut InferCtxt { pub impl InferCtxt {
fn next_ty_var_id(&self) -> TyVid { fn next_ty_var_id(@mut self) -> TyVid {
let id = self.ty_var_counter; let id = self.ty_var_counter;
self.ty_var_counter += 1; self.ty_var_counter += 1;
let vals = self.ty_var_bindings.vals; let vals = self.ty_var_bindings.vals;
@ -643,37 +643,37 @@ pub impl @mut InferCtxt {
return TyVid(id); return TyVid(id);
} }
fn next_ty_var(&self) -> ty::t { fn next_ty_var(@mut self) -> ty::t {
ty::mk_var(self.tcx, self.next_ty_var_id()) ty::mk_var(self.tcx, self.next_ty_var_id())
} }
fn next_ty_vars(&self, n: uint) -> ~[ty::t] { fn next_ty_vars(@mut self, n: uint) -> ~[ty::t] {
vec::from_fn(n, |_i| self.next_ty_var()) vec::from_fn(n, |_i| self.next_ty_var())
} }
fn next_int_var_id(&self) -> IntVid { fn next_int_var_id(@mut self) -> IntVid {
IntVid(next_simple_var(&mut self.int_var_counter, IntVid(next_simple_var(&mut self.int_var_counter,
&mut self.int_var_bindings)) &mut self.int_var_bindings))
} }
fn next_int_var(&self) -> ty::t { fn next_int_var(@mut self) -> ty::t {
ty::mk_int_var(self.tcx, self.next_int_var_id()) ty::mk_int_var(self.tcx, self.next_int_var_id())
} }
fn next_float_var_id(&self) -> FloatVid { fn next_float_var_id(@mut self) -> FloatVid {
FloatVid(next_simple_var(&mut self.float_var_counter, FloatVid(next_simple_var(&mut self.float_var_counter,
&mut self.float_var_bindings)) &mut self.float_var_bindings))
} }
fn next_float_var(&self) -> ty::t { fn next_float_var(@mut self) -> ty::t {
ty::mk_float_var(self.tcx, self.next_float_var_id()) ty::mk_float_var(self.tcx, self.next_float_var_id())
} }
fn next_region_var_nb(&self, span: span) -> ty::Region { fn next_region_var_nb(@mut self, span: span) -> ty::Region {
ty::re_infer(ty::ReVar(self.region_vars.new_region_var(span))) ty::re_infer(ty::ReVar(self.region_vars.new_region_var(span)))
} }
fn next_region_var_with_lb(&self, span: span, fn next_region_var_with_lb(@mut self, span: span,
lb_region: ty::Region) -> ty::Region { lb_region: ty::Region) -> ty::Region {
let region_var = self.next_region_var_nb(span); let region_var = self.next_region_var_nb(span);
@ -685,28 +685,28 @@ pub impl @mut InferCtxt {
return region_var; return region_var;
} }
fn next_region_var(&self, span: span, scope_id: ast::node_id) fn next_region_var(@mut self, span: span, scope_id: ast::node_id)
-> ty::Region { -> ty::Region {
self.next_region_var_with_lb(span, ty::re_scope(scope_id)) self.next_region_var_with_lb(span, ty::re_scope(scope_id))
} }
fn resolve_regions(&self) { fn resolve_regions(@mut self) {
self.region_vars.resolve_regions(); self.region_vars.resolve_regions();
} }
fn ty_to_str(&self, t: ty::t) -> ~str { fn ty_to_str(@mut self, t: ty::t) -> ~str {
ty_to_str(self.tcx, ty_to_str(self.tcx,
self.resolve_type_vars_if_possible(t)) self.resolve_type_vars_if_possible(t))
} }
fn resolve_type_vars_if_possible(&self, typ: ty::t) -> ty::t { fn resolve_type_vars_if_possible(@mut self, typ: ty::t) -> ty::t {
match resolve_type(*self, typ, resolve_nested_tvar | resolve_ivar) { match resolve_type(self, typ, resolve_nested_tvar | resolve_ivar) {
result::Ok(new_type) => new_type, result::Ok(new_type) => new_type,
result::Err(_) => typ result::Err(_) => typ
} }
} }
fn type_error_message(&self, sp: span, mk_msg: &fn(~str) -> ~str, fn type_error_message(@mut self, sp: span, mk_msg: &fn(~str) -> ~str,
actual_ty: ty::t, err: Option<&ty::type_err>) { actual_ty: ty::t, err: Option<&ty::type_err>) {
let actual_ty = self.resolve_type_vars_if_possible(actual_ty); let actual_ty = self.resolve_type_vars_if_possible(actual_ty);
@ -725,7 +725,7 @@ pub impl @mut InferCtxt {
} }
} }
fn report_mismatched_types(&self, sp: span, e: ty::t, a: ty::t, fn report_mismatched_types(@mut self, sp: span, e: ty::t, a: ty::t,
err: &ty::type_err) { err: &ty::type_err) {
let resolved_expected = let resolved_expected =
self.resolve_type_vars_if_possible(e); self.resolve_type_vars_if_possible(e);
@ -743,7 +743,7 @@ pub impl @mut InferCtxt {
self.type_error_message(sp, mk_msg, a, Some(err)); self.type_error_message(sp, mk_msg, a, Some(err));
} }
fn replace_bound_regions_with_fresh_regions(&self, fn replace_bound_regions_with_fresh_regions(@mut self,
span: span, span: span,
fsig: &ty::FnSig) fsig: &ty::FnSig)
-> (ty::FnSig, isr_alist) { -> (ty::FnSig, isr_alist) {
@ -763,7 +763,7 @@ pub impl @mut InferCtxt {
} }
fn fold_regions_in_sig( fn fold_regions_in_sig(
&self, @mut self,
fn_sig: &ty::FnSig, fn_sig: &ty::FnSig,
fldr: &fn(r: ty::Region, in_fn: bool) -> ty::Region) -> ty::FnSig fldr: &fn(r: ty::Region, in_fn: bool) -> ty::Region) -> ty::FnSig
{ {

48
src/libstd/oldmap.rs
View file

@ -73,7 +73,7 @@ pub mod chained {
FoundAfter(@Entry<K,V>, @Entry<K,V>) FoundAfter(@Entry<K,V>, @Entry<K,V>)
} }
priv impl<K:Eq + IterBytes + Hash,V> T<K, V> { priv impl<K:Eq + IterBytes + Hash,V> HashMap_<K, V> {
pure fn search_rem(&self, k: &K, h: uint, idx: uint, pure fn search_rem(&self, k: &K, h: uint, idx: uint,
e_root: @Entry<K,V>) -> SearchResult<K,V> { e_root: @Entry<K,V>) -> SearchResult<K,V> {
let mut e0 = e_root; let mut e0 = e_root;
@ -120,7 +120,7 @@ pub mod chained {
} }
} }
fn rehash(&self) { fn rehash(@self) {
let n_old_chains = self.chains.len(); let n_old_chains = self.chains.len();
let n_new_chains: uint = uint::next_power_of_two(n_old_chains+1u); let n_new_chains: uint = uint::next_power_of_two(n_old_chains+1u);
let mut new_chains = chains(n_new_chains); let mut new_chains = chains(n_new_chains);
@ -133,7 +133,7 @@ pub mod chained {
} }
} }
pub impl<K:Eq + IterBytes + Hash,V> T<K, V> { pub impl<K:Eq + IterBytes + Hash,V> HashMap_<K, V> {
pure fn each_entry(&self, blk: &fn(@Entry<K,V>) -> bool) { pure fn each_entry(&self, blk: &fn(@Entry<K,V>) -> bool) {
// n.b. we can't use vec::iter() here because self.chains // n.b. we can't use vec::iter() here because self.chains
// is stored in a mutable location. // is stored in a mutable location.
@ -153,22 +153,20 @@ pub mod chained {
i += 1u; i += 1u;
} }
} }
}
impl<K:Eq + IterBytes + Hash,V> Container for T<K, V> { fn clear(@self) {
pure fn len(&self) -> uint { self.count }
pure fn is_empty(&self) -> bool { self.count == 0 }
}
impl<K:Eq + IterBytes + Hash,V> Mutable for T<K, V> {
fn clear(&mut self) {
self.count = 0u; self.count = 0u;
self.chains = chains(initial_capacity); self.chains = chains(initial_capacity);
} }
} }
pub impl<K:Eq + IterBytes + Hash,V> T<K, V> { impl<K:Eq + IterBytes + Hash,V> Container for HashMap_<K, V> {
pure fn contains_key(&self, k: &K) -> bool { pure fn len(&self) -> uint { self.count }
pure fn is_empty(&self) -> bool { self.count == 0 }
}
pub impl<K:Eq + IterBytes + Hash,V> HashMap_<K, V> {
pure fn contains_key(@self, k: &K) -> bool {
let hash = k.hash_keyed(0,0) as uint; let hash = k.hash_keyed(0,0) as uint;
match self.search_tbl(k, hash) { match self.search_tbl(k, hash) {
NotFound => false, NotFound => false,
@ -176,7 +174,7 @@ pub mod chained {
} }
} }
fn insert(&self, k: K, v: V) -> bool { fn insert(@self, k: K, v: V) -> bool {
let hash = k.hash_keyed(0,0) as uint; let hash = k.hash_keyed(0,0) as uint;
match self.search_tbl(&k, hash) { match self.search_tbl(&k, hash) {
NotFound => { NotFound => {
@ -220,7 +218,7 @@ pub mod chained {
} }
} }
fn remove(&self, k: &K) -> bool { fn remove(@self, k: &K) -> bool {
match self.search_tbl(k, k.hash_keyed(0,0) as uint) { match self.search_tbl(k, k.hash_keyed(0,0) as uint) {
NotFound => false, NotFound => false,
FoundFirst(idx, entry) => { FoundFirst(idx, entry) => {
@ -236,22 +234,22 @@ pub mod chained {
} }
} }
pure fn each(&self, blk: &fn(key: &K, value: &V) -> bool) { pure fn each(@self, blk: &fn(key: &K, value: &V) -> bool) {
for self.each_entry |entry| { for self.each_entry |entry| {
if !blk(&entry.key, &entry.value) { break; } if !blk(&entry.key, &entry.value) { break; }
} }
} }
pure fn each_key(&self, blk: &fn(key: &K) -> bool) { pure fn each_key(@self, blk: &fn(key: &K) -> bool) {
self.each(|k, _v| blk(k)) self.each(|k, _v| blk(k))
} }
pure fn each_value(&self, blk: &fn(value: &V) -> bool) { pure fn each_value(@self, blk: &fn(value: &V) -> bool) {
self.each(|_k, v| blk(v)) self.each(|_k, v| blk(v))
} }
} }
pub impl<K:Eq + IterBytes + Hash + Copy,V:Copy> T<K, V> { pub impl<K:Eq + IterBytes + Hash + Copy,V:Copy> HashMap_<K, V> {
pure fn find(&self, k: &K) -> Option<V> { pure fn find(&self, k: &K) -> Option<V> {
match self.search_tbl(k, k.hash_keyed(0,0) as uint) { match self.search_tbl(k, k.hash_keyed(0,0) as uint) {
NotFound => None, NotFound => None,
@ -260,7 +258,7 @@ pub mod chained {
} }
} }
fn update_with_key(&self, key: K, newval: V, ff: &fn(K, V, V) -> V) fn update_with_key(@self, key: K, newval: V, ff: &fn(K, V, V) -> V)
-> bool { -> bool {
/* /*
match self.find(key) { match self.find(key) {
@ -312,7 +310,7 @@ pub mod chained {
} }
} }
fn update(&self, key: K, newval: V, ff: &fn(V, V) -> V) -> bool { fn update(@self, key: K, newval: V, ff: &fn(V, V) -> V) -> bool {
return self.update_with_key(key, newval, |_k, v, v1| ff(v,v1)); return self.update_with_key(key, newval, |_k, v, v1| ff(v,v1));
} }
@ -325,7 +323,8 @@ pub mod chained {
} }
} }
pub impl<K:Eq + IterBytes + Hash + Copy + ToStr,V:ToStr + Copy> T<K, V> { pub impl<K:Eq + IterBytes + Hash + Copy + ToStr,V:ToStr + Copy>
HashMap_<K, V> {
fn to_writer(&self, wr: @io::Writer) { fn to_writer(&self, wr: @io::Writer) {
if self.count == 0u { if self.count == 0u {
wr.write_str(~"{}"); wr.write_str(~"{}");
@ -348,7 +347,7 @@ pub mod chained {
} }
impl<K:Eq + IterBytes + Hash + Copy + ToStr,V:ToStr + Copy> ToStr impl<K:Eq + IterBytes + Hash + Copy + ToStr,V:ToStr + Copy> ToStr
for T<K, V> { for HashMap_<K, V> {
pure fn to_str(&self) -> ~str { pure fn to_str(&self) -> ~str {
unsafe { unsafe {
// Meh -- this should be safe // Meh -- this should be safe
@ -357,7 +356,8 @@ pub mod chained {
} }
} }
impl<K:Eq + IterBytes + Hash + Copy,V:Copy> ops::Index<K, V> for T<K, V> { impl<K:Eq + IterBytes + Hash + Copy,V:Copy> ops::Index<K, V>
for HashMap_<K, V> {
pure fn index(&self, k: K) -> V { pure fn index(&self, k: K) -> V {
self.get(&k) self.get(&k)
} }

10
src/libstd/sync.rs
View file

@ -99,7 +99,7 @@ fn new_sem_and_signal(count: int, num_condvars: uint)
} }
#[doc(hidden)] #[doc(hidden)]
pub impl<Q:Owned> &self/Sem<Q> { pub impl<Q:Owned> Sem<Q> {
fn acquire(&self) { fn acquire(&self) {
let mut waiter_nobe = None; let mut waiter_nobe = None;
unsafe { unsafe {
@ -135,26 +135,26 @@ pub impl<Q:Owned> &self/Sem<Q> {
} }
// FIXME(#3154) move both copies of this into Sem<Q>, and unify the 2 structs // FIXME(#3154) move both copies of this into Sem<Q>, and unify the 2 structs
#[doc(hidden)] #[doc(hidden)]
pub impl &self/Sem<()> { pub impl Sem<()> {
fn access<U>(&self, blk: &fn() -> U) -> U { fn access<U>(&self, blk: &fn() -> U) -> U {
let mut release = None; let mut release = None;
unsafe { unsafe {
do task::unkillable { do task::unkillable {
self.acquire(); self.acquire();
release = Some(SemRelease(*self)); release = Some(SemRelease(self));
} }
} }
blk() blk()
} }
} }
#[doc(hidden)] #[doc(hidden)]
pub impl &self/Sem<~[Waitqueue]> { pub impl Sem<~[Waitqueue]> {
fn access<U>(&self, blk: &fn() -> U) -> U { fn access<U>(&self, blk: &fn() -> U) -> U {
let mut release = None; let mut release = None;
unsafe { unsafe {
do task::unkillable { do task::unkillable {
self.acquire(); self.acquire();
release = Some(SemAndSignalRelease(*self)); release = Some(SemAndSignalRelease(self));
} }
} }
blk() blk()

12
src/libsyntax/ext/pipes/proto.rs
View file

@ -172,9 +172,13 @@ pub impl protocol_ {
} }
} }
pub impl protocol { pub impl protocol_ {
fn add_state_poly(&self, +name: ~str, ident: ast::ident, dir: direction, fn add_state_poly(@mut self,
+generics: ast::Generics) -> state { +name: ~str,
ident: ast::ident,
dir: direction,
+generics: ast::Generics)
-> state {
let messages = @mut ~[]; let messages = @mut ~[];
let state = @state_ { let state = @state_ {
@ -185,7 +189,7 @@ pub impl protocol {
dir: dir, dir: dir,
generics: generics, generics: generics,
messages: messages, messages: messages,
proto: *self proto: self
}; };
self.states.push(state); self.states.push(state);