Fix clippy warnings

src/args.rs

 
 
 pub fn parse<'a>() -> clap::ArgMatches<'a> {
-    let matches = clap::App::new("DeltaMap")
+    clap::App::new("DeltaMap")
         .version(crate_version!())
         .author(crate_authors!())
         .about(crate_description!())
             .long("sync")
             .help("Load tiles in a synchronous fashion. \
                 The UI is blocked while tiles are loading."))
-        .get_matches();
-
-    matches
+        .get_matches()
 }

src/buffer.rs

         }
 
         Buffer {
-            cx: cx,
-            buffer_obj: buffer_obj,
-            num_elements: num_elements,
+            cx,
+            buffer_obj,
+            num_elements,
         }
     }
 

src/config.rs

 
                 Ok(
                     Config {
-                        tile_cache_dir: tile_cache_dir,
+                        tile_cache_dir,
                         sources: vec![],
-                        fps: fps,
-                        use_network: use_network,
-                        async: async,
+                        fps,
+                        use_network,
+                        async,
                     }
                 )
             },

src/context.rs

 impl Context {
     pub fn from_gl_window(window: &glutin::GlWindow) -> Context {
         let gl = gl::Gl::load_with(|ptr| window.get_proc_address(ptr) as *const _);
-        let cx = Context { gl: gl };
+        let cx = Context { gl };
 
         // Initialize a vertex array object (VAO) if the current OpenGL context supports it. VAOs are
         // not OpenGL ES 2.0 compatible, but are required for rendering with a core context.

src/coord.rs

 
 impl MapCoord {
     pub fn new(x: f64, y: f64) -> MapCoord {
-        MapCoord {
-            x: x,
-            y: y,
-        }
+        MapCoord { x, y }
     }
 
     pub fn from_latlon(latitude: f64, longitude: f64) -> MapCoord {
         let pi_lat = latitude * (PI / 180.0);
         let y = f64::ln(f64::tan(pi_lat) + 1.0 / f64::cos(pi_lat)) * (-0.5 / PI) + 0.5;
 
-        MapCoord {
-            x: x,
-            y: y,
-        }
+        MapCoord { x, y }
     }
 
     //TODO differ between normalized and not normalized tiles
     pub fn on_tile_at_zoom(&self, zoom: u32) -> TileCoord {
         let zoom_factor = f64::powi(2.0, zoom as i32);
-        let ix = (self.x * zoom_factor).floor() as i32;
-        let iy = (self.y * zoom_factor).floor() as i32;
+        let x = (self.x * zoom_factor).floor() as i32;
+        let y = (self.y * zoom_factor).floor() as i32;
 
-        let x = ix;
-        let y = iy;
-
-        TileCoord {
-            zoom: zoom,
-            x: x,
-            y: y,
-        }
+        TileCoord { zoom, x, y }
     }
 
     pub fn normalize_x(&mut self) {
 
 impl ScreenCoord {
     pub fn new(x: f64, y: f64) -> Self {
-        ScreenCoord {
-            x: x,
-            y: y,
-        }
+        ScreenCoord { x, y }
     }
+
     pub fn snap_to_pixel(&mut self) {
         self.x = self.x.floor();
         self.y = self.y.floor();
 impl TileCoord {
     pub fn new(zoom: u32, x: i32, y: i32) -> TileCoord {
         TileCoord {
-            zoom: zoom,
+            zoom,
             x: Self::normalize_coord(x, zoom),
-            y: y,
+            y,
         }
     }
 

src/main.rs

         } else {
             Some(TileSources {
                 current_index: 0,
-                sources: sources,
+                sources,
             })
         }
     }

src/map_view.rs

     /// Constructs a new `MapView`.
     pub fn new(width: f64, height: f64, tile_size: u32, center: MapCoord, zoom: f64) -> MapView {
         MapView {
-            width: width,
-            height: height,
-            tile_size: tile_size,
-            center: center,
-            zoom: zoom,
+            width,
+            height,
+            tile_size,
+            center,
+            zoom,
             tile_zoom_offset: 0.0,
         }
     }
         let min_dimension = width.min(height);
         let zoom = (min_dimension / f64::from(tile_size)).log2().ceil();
         MapView {
-            width: width,
-            height: height,
-            tile_size: tile_size,
+            width,
+            height,
+            tile_size,
             center: MapCoord::new(0.5, 0.5),
-            zoom: zoom,
+            zoom,
             tile_zoom_offset: 0.0,
         }
     }

src/map_view_gl.rs

         let map_view = MapView::with_filling_zoom(f64::from(initial_size.0), f64::from(initial_size.1), tile_size);
 
         MapViewGl {
-            cx: cx,
-            program: program,
-            buf: buf,
+            cx,
+            program,
+            buf,
             viewport_size: initial_size,
-            map_view: map_view,
+            map_view,
             tile_cache: TileCache::new(move |_tile| update_func(), use_network),
             tile_atlas: TileAtlas::new(tex, 256, use_async),
         }

src/program.rs

             };
 
             Ok(Program {
-                cx: cx,
-                vert_obj: vert_obj,
-                frag_obj: frag_obj,
-                program_obj: program_obj,
+                cx,
+                vert_obj,
+                frag_obj,
+                program_obj,
                 tex_ids: vec![],
                 tex_locations: vec![],
             })

src/texture.rs

     }
 
     fn from_ptr(cx: &'a Context, width: u32, height: u32, format: TextureFormat, data_ptr: *const c_void) -> Texture<'a> {
-        let mut tex_obj = 0_u32;
+        let mut texture_obj = 0_u32;
         unsafe {
-            cx.gl.GenTextures(1, &mut tex_obj);
-            cx.gl.BindTexture(context::gl::TEXTURE_2D, tex_obj);
+            cx.gl.GenTextures(1, &mut texture_obj);
+            cx.gl.BindTexture(context::gl::TEXTURE_2D, texture_obj);
 
             cx.gl.TexParameteri(context::gl::TEXTURE_2D, context::gl::TEXTURE_MIN_FILTER, context::gl::LINEAR as i32);
             cx.gl.TexParameteri(context::gl::TEXTURE_2D, context::gl::TEXTURE_MAG_FILTER, context::gl::LINEAR as i32);
         }
 
         Texture {
-            cx: cx,
-            texture_obj: tex_obj,
-            width: width,
-            height: height,
-            format: format,
+            cx,
+            texture_obj,
+            width,
+            height,
+            format,
         }
     }
 

src/tile.rs

 impl Tile {
     pub fn new(coord: TileCoord, source_id: TileSourceId) -> Tile {
         Tile {
-            coord: coord,
-            source_id: source_id,
+            coord,
+            source_id,
         }
     }
 }

src/tile_atlas.rs

         self.slots_lru.reserve(num_slots);
         for x in 0..slots_x {
             for y in 0..slots_y {
-                let slot = CacheSlot { x: x, y: y };
+                let slot = CacheSlot { x, y };
                 self.slots_lru.insert(slot, None);
             }
         }
     pub fn new(tex: Texture<'a>, tile_size: u32, use_async: bool) -> Self {
         let mut atlas = TileAtlas {
             texture: tex,
-            tile_size: tile_size,
+            tile_size,
             slots_lru: LinkedHashMap::new(),
             tile_to_slot: HashMap::new(),
-            use_async: use_async,
+            use_async,
         };
 
         atlas.init();
                 tvt.push(
                     TexturedVisibleTile {
                         screen_rect: vt.rect,
-                        tex_rect: tex_rect,
+                        tex_rect,
                         tex_minmax: tex_rect.inset(inset_x, inset_y),
                     }
                 );
                         tvt.push(
                             TexturedVisibleTile {
                                 screen_rect: vt.rect.subdivide(&child_sub_coord),
-                                tex_rect: tex_rect,
+                                tex_rect,
                                 tex_minmax: tex_rect.inset(inset_x, inset_y),
                             }
                         );

src/tile_loader.rs

         TileLoader {
             client: None,
             join_handle: thread::spawn(move || Self::work(&request_rx, &result_tx, notice_func, use_network)),
-            request_tx: request_tx,
-            result_rx: result_rx,
+            request_tx,
+            result_rx,
             pending: HashSet::new(),
-            use_network: use_network,
+            use_network,
         }
     }
 
             if let Some(url) = source.remote_tile_url(tile_coord) {
                 if self.request_tx.send(LoaderMessage::GetTile(
                         TileRequest {
-                            tile: tile,
-                            url: url,
+                            tile,
+                            url,
                             path: source.local_tile_path(tile_coord),
-                            write_to_file: write_to_file,
+                            write_to_file,
                         }
                     )).is_ok()
                 {

src/tile_source.rs

         max_zoom: u32,
     ) -> Self {
         TileSource {
-            id: id,
+            id,
             url_template: url_template.into(),
             directory: directory.into(),
-            extension: extension,
-            min_zoom: min_zoom,
-            max_zoom: max_zoom,
+            extension,
+            min_zoom,
+            max_zoom,
         }
     }