#[warn(vecs_implicitly_copyable)];
#[deny(non_camel_case_types)];
#[allow(deprecated_mutable_fields)];
+#[deny(deprecated_self)];
// On Linux, link to the runtime with -lrt.
#[cfg(target_os = "linux")]
#[allow(non_camel_case_types)];
#[allow(deprecated_mode)];
#[allow(deprecated_pattern)];
+#[deny(deprecated_self)];
extern mod core(vers = "0.6");
extern mod std(vers = "0.6");
// XXX: Make commands run and test emit proper file endings on winds
// XXX: Make run only accept source that emits an executable
+#[deny(deprecated_self)];
+
#[link(name = "rust",
vers = "0.6",
uuid = "4a24da33-5cc8-4037-9352-2cbe9bd9d27c",
// Encoding and decoding the side tables
trait get_ty_str_ctxt {
- fn ty_str_ctxt() -> @tyencode::ctxt;
+ fn ty_str_ctxt(@self) -> @tyencode::ctxt;
}
-impl get_ty_str_ctxt for @e::EncodeContext {
+impl get_ty_str_ctxt for e::EncodeContext {
// IMPLICIT SELF WARNING: fix this!
- fn ty_str_ctxt() -> @tyencode::ctxt {
+ fn ty_str_ctxt(@self) -> @tyencode::ctxt {
@tyencode::ctxt {diag: self.tcx.sess.diagnostic(),
ds: e::def_to_str,
tcx: self.tcx,
}
}
- fn indices2(ln: LiveNode, succ_ln: LiveNode,
+ fn indices2(&self, ln: LiveNode, succ_ln: LiveNode,
op: fn(uint, uint)) {
let node_base_idx = self.idx(ln, Variable(0u));
let succ_base_idx = self.idx(succ_ln, Variable(0u));
}
/// Returns the module node if applicable.
- fn get_module_if_available() -> Option<@mut Module> {
+ fn get_module_if_available(&self) -> Option<@mut Module> {
match self.type_def {
Some(ref type_def) => (*type_def).module_def,
None => None
}
}
- fn defined_in_namespace(namespace: Namespace) -> bool {
+ fn defined_in_namespace(&self, namespace: Namespace) -> bool {
match namespace {
TypeNS => return self.type_def.is_some(),
ValueNS => return self.value_def.is_some()
}
}
- fn defined_in_public_namespace(namespace: Namespace) -> bool {
+ fn defined_in_public_namespace(&self, namespace: Namespace) -> bool {
match namespace {
TypeNS => match self.type_def {
Some(def) => def.privacy != Private,
}
}
- fn def_for_namespace(namespace: Namespace) -> Option<def> {
+ fn def_for_namespace(&self, namespace: Namespace) -> Option<def> {
match namespace {
TypeNS => {
match self.type_def {
}
}
- fn privacy_for_namespace(namespace: Namespace) -> Option<Privacy> {
+ fn privacy_for_namespace(&self, namespace: Namespace) -> Option<Privacy> {
match namespace {
TypeNS => {
match self.type_def {
}
}
- fn span_for_namespace(namespace: Namespace) -> Option<span> {
+ fn span_for_namespace(&self, namespace: Namespace) -> Option<span> {
if self.defined_in_namespace(namespace) {
match namespace {
TypeNS => self.type_span,
self.search_for_autosliced_method(self_ty, autoderefs)
}
- fn deref(ty: ty::t, enum_dids: &mut ~[ast::def_id]) -> Option<ty::t> {
+ fn deref(&self, ty: ty::t, enum_dids: &mut ~[ast::def_id])
+ -> Option<ty::t> {
match ty::get(ty).sty {
ty_enum(did, _) => {
// Watch out for newtype'd enums like "enum t = @T".
}
}
- fn push_inherent_impl_candidates_for_type(did: def_id) {
+ fn push_inherent_impl_candidates_for_type(&self, did: def_id) {
let opt_impl_infos =
self.fcx.ccx.coherence_info.inherent_methods.find(&did);
for opt_impl_infos.each |impl_infos| {
}
pub impl CoherenceChecker {
- // IMPLICIT SELF WARNING: fix this!
- fn check_coherence(crate: @crate) {
+ fn check_coherence(self, crate: @crate) {
// Check implementations and traits. This populates the tables
// containing the inherent methods and extension methods. It also
// builds up the trait inheritance table.
visit_crate(*crate, (), mk_simple_visitor(@SimpleVisitor {
visit_item: |item| {
- debug!("(checking coherence) item '%s'",
- *self.crate_context.tcx.sess.str_of(item.ident));
+// debug!("(checking coherence) item '%s'",
+// self.crate_context.tcx.sess.str_of(item.ident));
match item.node {
item_impl(_, opt_trait, _, _) => {
}
// Privileged scope checking
- // IMPLICIT SELF WARNING: fix this!
- fn check_privileged_scopes(crate: @crate) {
+ fn check_privileged_scopes(self, crate: @crate) {
visit_crate(*crate, (), mk_vt(@Visitor {
visit_item: |item, _context, visitor| {
match /*bad*/copy item.node {
}
/// Execute `f` and commit the bindings if successful
- fn commit<T,E>(f: fn() -> Result<T,E>) -> Result<T,E> {
+ fn commit<T,E>(&self, f: fn() -> Result<T,E>) -> Result<T,E> {
fail_unless!(!self.in_snapshot());
debug!("commit()");
}
/// Execute `f`, unroll bindings on failure
- fn try<T,E>(f: fn() -> Result<T,E>) -> Result<T,E> {
+ fn try<T,E>(&self, f: fn() -> Result<T,E>) -> Result<T,E> {
debug!("try()");
do indent {
let snapshot = self.start_snapshot();
}
/// Execute `f` then unroll any bindings it creates
- fn probe<T,E>(f: fn() -> Result<T,E>) -> Result<T,E> {
+ fn probe<T,E>(&self, f: fn() -> Result<T,E>) -> Result<T,E> {
debug!("probe()");
do indent {
let snapshot = self.start_snapshot();
#[allow(non_camel_case_types)];
#[allow(deprecated_mode)];
#[warn(deprecated_pattern)];
-#[allow(deprecated_self)];
+#[deny(deprecated_self)];
#[no_core];
#[no_core];
#[allow(non_implicitly_copyable_typarams)];
+#[deny(deprecated_self)];
extern mod core(vers = "0.6");
extern mod std(vers = "0.6");
#[allow(vecs_implicitly_copyable,
non_implicitly_copyable_typarams)];
+#[deny(deprecated_self)];
extern mod core(vers = "0.6");
extern mod std(vers = "0.6");
#[no_core];
#[allow(vecs_implicitly_copyable,
non_implicitly_copyable_typarams)];
+#[deny(deprecated_self)];
extern mod core(vers = "0.6");
extern mod std(vers = "0.6");