Fixed warnings for struct deconstruction and with some lifetimes that shadowed

Author: Marwes

compiler.rs

@@ -74,12 +74,12 @@ enum Var<'a> {
     Newtype
 }
 
-static unary_primitives: &'static [(&'static str, Instruction)] = &[
+static UNARY_PRIMITIVES: &'static [(&'static str, Instruction)] = &[
     ("primIntToDouble", IntToDouble),
     ("primDoubleToInt", DoubleToInt),
 ];
 
-static binary_primitives: &'static [(&'static str, Instruction)] = &[
+static BINARY_PRIMITIVES: &'static [(&'static str, Instruction)] = &[
     ("primIntAdd", Add),
     ("primIntSubtract", Sub),
     ("primIntMultiply", Multiply),
@@ -392,10 +392,10 @@ impl <'a> Compiler<'a> {
         for (i, &(name, _)) in builtins().iter().enumerate() {
             variables.insert(Name { name: intern(name), uid: 0}, Var::Builtin(i));
         }
-        for &(name, instruction) in binary_primitives.iter() {
+        for &(name, instruction) in BINARY_PRIMITIVES.iter() {
             variables.insert(Name { name: intern(name), uid: 0 }, Var::Primitive(2, instruction));
         }
-        for &(name, instruction) in unary_primitives.iter() {
+        for &(name, instruction) in UNARY_PRIMITIVES.iter() {
             variables.insert(Name { name: intern(name), uid: 0 }, Var::Primitive(1, instruction));
         }
         Compiler { instance_dictionaries: Vec::new(),
@@ -552,7 +552,7 @@ impl <'a> Compiler<'a> {
         }
     }
 
-    fn find_class<'a>(&'a self, name: Name) -> Option<(&'a [Constraint<Name>], &'a TypeVariable, &'a [TypeDeclaration<Name>])> {
+    fn find_class(&self, name: Name) -> Option<(&[Constraint<Name>], &TypeVariable, &[TypeDeclaration<Name>])> {
         self.module.and_then(|m| m.find_class(name))
             .or_else(|| {
             for types in self.assemblies.iter() {
@@ -697,7 +697,7 @@ impl <'a> Compiler<'a> {
             &Lambda(_, _) => panic!("Error: Found non-lifted lambda when compiling expression")
         }
     }
-    fn compile_apply<'a>(&mut self, expr: &Expr<Id>, args: ArgList<'a>, instructions: &mut Vec<Instruction>, strict: bool) {
+    fn compile_apply(&mut self, expr: &Expr<Id>, args: ArgList, instructions: &mut Vec<Instruction>, strict: bool) {
         //Unroll the applications until the function is found
         match *expr {
             Apply(ref func, ref arg) => {
@@ -752,7 +752,7 @@ impl <'a> Compiler<'a> {
                             ArgList::Cons(_, _) => {
                                 //Do nothing
                             }
-                            Nil => {
+                            ArgList::Nil => {
                                 //translate into id application
                                 let x = self.find(Name { name: intern("id"), uid: 0 })
                                     .expect("Compiler error: Prelude.id must be in scope for compilation of newtype");
@@ -784,7 +784,7 @@ impl <'a> Compiler<'a> {
         }
     }
 
-    fn compile_args<'a>(&mut self, args: &ArgList<'a>, instructions: &mut Vec<Instruction>, strict: bool) -> uint {
+    fn compile_args(&mut self, args: &ArgList, instructions: &mut Vec<Instruction>, strict: bool) -> uint {
         match *args {
             ArgList::Cons(arg, rest) => {
                 let i = self.compile_args(rest, instructions, strict);

core.rs

@@ -350,7 +350,7 @@ pub mod result {
     }
 
     pub fn walk_binding<V: Visitor<Ident>, Ident>(visitor: &mut V, binding: Binding<Ident>) -> Binding<Ident> {
-        let Binding { name: name, expression: expression } = binding;
+        let Binding { name, expression } = binding;
         Binding {
             name: name,
             expression: visitor.visit_expr(expression)
@@ -383,7 +383,7 @@ pub mod result {
     }
 
     pub fn walk_alternative<V: Visitor<Ident>, Ident>(visitor: &mut V, alt: Alternative<Ident>) -> Alternative<Ident> {
-        let Alternative { pattern: pattern, expression: expression } = alt;
+        let Alternative { pattern, expression } = alt;
         Alternative { pattern: visitor.visit_pattern(pattern), expression: visitor.visit_expr(expression) }
     }
 }
@@ -434,51 +434,51 @@ pub mod translate {
     fn translate_module_<'a>(translator: &mut Translator<'a>, module: module::Module<Name>) -> Module<Id<Name>> {
         let module::Module { name : _name,
             imports : _imports,
-            bindings : bindings,
-            typeDeclarations : _typeDeclarations,
-            newtypes : newtypes,
-            classes : classes,
-            instances : instances,
-            dataDefinitions : dataDefinitions,
+            bindings,
+            type_declarations : _type_declarations,
+            newtypes,
+            classes,
+            instances,
+            data_definitions,
             fixity_declarations : _fixity_declarations
         } = module;
 
         let mut new_instances: Vec<Instance<Id<Name>>> = Vec::new();
 
         let classes2 : Vec<Class<Id>> = classes.into_iter().map(|class| {
             let module::Class {
-                constraints: cs,
-                name : name,
-                variable : var,
-                declarations : decls,
-                bindings: bindings
+                constraints,
+                name,
+                variable,
+                declarations,
+                bindings
             } = class;
             Class {
-                constraints: cs,
+                constraints: constraints,
                 name: name,
-                variable: var,
-                declarations: decls,
+                variable: variable,
+                declarations: declarations,
                 bindings: translator.translate_bindings(bindings)
             }
         }).collect();
 
         for instance in instances.into_iter() {
             let module::Instance {
-                classname: classname,
-                typ: instance_type,
-                constraints: constraints,
-                bindings: bindings
+                classname,
+                typ,
+                constraints,
+                bindings
             } = instance;
             let bs: Vec<Binding<Id<Name>>> = translator.translate_bindings(bindings).into_iter().collect();
             new_instances.push(Instance {
                 constraints: constraints,
-                typ: instance_type,
+                typ: typ,
                 classname: classname,
                 bindings: bs
             });
         }
         let bs: Vec<Binding<Id<Name>>> = translator.translate_bindings(bindings).into_iter().collect();
-        for data in dataDefinitions.iter() {
+        for data in data_definitions.iter() {
             generate_deriving(&mut new_instances, data);
         }
         for instance in new_instances.iter_mut() {
@@ -491,7 +491,7 @@ pub mod translate {
         }
         Module {
             classes: classes2,
-            data_definitions: dataDefinitions,
+            data_definitions: data_definitions,
             newtypes: newtypes,
             bindings: bs,
             instances: new_instances
@@ -516,7 +516,7 @@ pub mod translate {
                         .collect();
                     typ.constraints = vec_context;
                 }
-                let Qualified { value: typ, constraints: constraints } = typ;
+                let Qualified { value: typ, constraints } = typ;
                 let default_name = module::encode_binding_identifier(instance.classname.name, decl.name.name);
                 let typ_name = module::extract_applied_type(&instance.typ).ctor().name;
                 let instance_fn_name = module::encode_binding_identifier(typ_name, decl.name.name);
@@ -546,7 +546,7 @@ impl <'a> Translator<'a> {
             _ => false
         };
         if is_lambda {
-            let module::TypedExpr { typ: typ, expr: expr, ..} = input_expr;
+            let module::TypedExpr { typ, expr, ..} = input_expr;
             match expr {
                 module::Expr::Lambda(arg, body) => {
                     //TODO need to make unique names for the lambdas created here
@@ -569,7 +569,7 @@ impl <'a> Translator<'a> {
     }
 
     fn translate_expr_rest(&mut self, input_expr: module::TypedExpr<Name>) -> Expr<Id<Name>> {
-        let module::TypedExpr { typ: typ, expr: expr, ..} = input_expr;
+        let module::TypedExpr { typ, expr, ..} = input_expr;
         match expr {
             module::Expr::Identifier(s) => Identifier(Id::new(s, typ, vec![])),
             module::Expr::Apply(func, arg) => Apply(box self.translate_expr(*func), box self.translate_expr(*arg)),
@@ -744,7 +744,7 @@ impl <'a> Translator<'a> {
         let mut vec = Vec::new();
         let dummy_var = &[Id::new(self.name_supply.anonymous(), Type::new_var(intern("a")), vec![])];
         let uid = self.name_supply.next_id();
-        for module::Alternative { pattern: pattern, matches: matches, where_bindings: where_bindings } in alts.into_iter() {
+        for module::Alternative { pattern, matches, where_bindings } in alts.into_iter() {
             let bindings = where_bindings.map_or(Vec::new(), |bs| self.translate_bindings(bs));
             vec.push((self.unwrap_patterns(uid, dummy_var, &[pattern.node]), bindings, matches));
         }
@@ -765,10 +765,11 @@ impl <'a> Translator<'a> {
         //then we do a simple translation to preserve the names for the arguments.
         if bindings.len() == 1 && simple_binding(&bindings[0]) {
             let module::Binding {
-                name: name,
-                arguments: arguments, matches: matches,
-                typ: module::Qualified { constraints: constraints, value: typ, },
-                where_bindings: where_bindings
+                name,
+                arguments,
+                matches,
+                typ: module::Qualified { constraints, value: typ, },
+                where_bindings
             } = bindings.pop().unwrap();
             let arg_iterator = arguments.into_iter().map(|p| {
                 match p {
@@ -812,9 +813,9 @@ impl <'a> Translator<'a> {
         let uid = self.name_supply.next_id();
         let equations: Vec<_> = bindings.into_iter().map(|bind| {
             let module::Binding {
-                arguments: arguments,
-                matches: matches,
-                where_bindings: where_bindings,
+                arguments,
+                matches,
+                where_bindings,
                 ..
             } = bind;
             let where_bindings_binds = where_bindings.map_or(Vec::new(), |bs| self.translate_bindings(bs));

infix.rs

@@ -57,7 +57,7 @@ impl PrecedenceVisitor {
         let mut op_stack = Vec::new();
         loop {
             let box temp = input;
-            let TypedExpr { typ: typ, location:location, expr: expr } = temp;
+            let TypedExpr { typ, location, expr } = temp;
             match expr {
                 Expr::OpApply(l, op, r) => {
                     expr_stack.push(l);

interner.rs

@@ -53,7 +53,7 @@ pub fn intern(s: &str) -> InternedStr {
 impl Str for InternedStr {
     fn as_slice<'a>(&'a self) -> &'a str {
         let interner = get_local_interner();
-        let mut x = (*interner).borrow_mut();
+        let x = (*interner).borrow_mut();
         let r: &str = x.get_str(*self);
         //The interner is task local and will never remove a string so this is safe
         unsafe { ::std::mem::transmute(r) }

main.rs

@@ -1,6 +1,6 @@
-#![crate_id = "vm#0.0"]
 #![crate_type = "bin"]
 #![feature(box_syntax)]
+#![allow(unstable)]
 #[macro_use]
 extern crate log;
 extern crate collections;

module.rs

@@ -12,10 +12,10 @@ pub struct Module<Ident = InternedStr> {
     pub name : Ident,
     pub imports: Vec<Import<Ident>>,
     pub bindings : Vec<Binding<Ident>>,
-    pub typeDeclarations : Vec<TypeDeclaration<Ident>>,
+    pub type_declarations : Vec<TypeDeclaration<Ident>>,
     pub classes : Vec<Class<Ident>>,
     pub instances : Vec<Instance<Ident>>,
-    pub dataDefinitions : Vec<DataDefinition<Ident>>,
+    pub data_definitions : Vec<DataDefinition<Ident>>,
     pub newtypes : Vec<Newtype<Ident>>,
     pub fixity_declarations : Vec<FixityDeclaration<Ident>>
 }

parser.rs

@@ -127,10 +127,10 @@ pub fn module(&mut self) -> Module {
         name : modulename,
         imports : imports,
         bindings : bindings,
-        typeDeclarations : type_declarations,
+        type_declarations : type_declarations,
         classes : classes,
         instances : instances,
-        dataDefinitions : data_definitions,
+        data_definitions : data_definitions,
         newtypes: newtypes,
         fixity_declarations : fixity_declarations
     }
@@ -1373,7 +1373,7 @@ r"data Test = A | B
 dummy = 1
 ".chars());
     let module = parser.module();
-    let data = &module.dataDefinitions[0];
+    let data = &module.data_definitions[0];
     assert_eq!(data.typ, qualified(Vec::new(), Type::new_op(intern("Test"), Vec::new())));
     assert_eq!(data.deriving, [intern("Eq"), intern("Show")]);
 }