// This code is actually correct
let nested: &&Vec<i32> = &&vec![1, 2, 3];
let iter = nested.into_iter();  // Necessary conversion
 
// But Clippy incorrectly suggested:
// help: consider removing `.into_iter()`: `nested`

// Simplified version of the fix
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
    if let ExprKind::MethodCall(path, receiver, ..) = expr.kind {
        if path.ident.name == sym::into_iter {
            // Get the receiver type
            let receiver_ty = cx.typeck_results().expr_ty(receiver);
            
            // Count reference levels
            let mut ref_count = 0;
            let mut current_ty = receiver_ty;
            
            while let ty::Ref(_, inner_ty, _) = current_ty.kind() {
                ref_count += 1;
                current_ty = *inner_ty;
            }
            
            // Only suggest removal if conversion is truly useless
            // (not just moving references around)
            if ref_count <= 1 && /* other checks */ {
                span_lint_and_sugg(/* suggest removal */);
            }
        }
    }
}

// Before: Sequential, simple
for file in files {
    let hash = compute_hash(&file)?;
    results.insert(file.path.clone(), hash);
}
 
// After: Parallel with proper ownership
use rayon::prelude::*;
 
let results: HashMap<PathBuf, Hash> = files
    .par_iter()
    .filter(|f| f.size >= MIN_SIZE)  // Skip tiny files
    .filter_map(|file| {
        compute_hash(file)
            .ok()
            .map(|hash| (file.path.clone(), hash))
    })
    .collect();

// Before: Generic errors
Err(anyhow!("Hashing failed"))
 
// After: Actionable errors
pub enum DedCoreError {
    #[error("Failed to hash file {path}: {reason}")]
    HashError {
        path: PathBuf,
        reason: String,
    },
    
    #[error("Permission denied: {path}\nTry running with elevated permissions")]
    PermissionDenied {
        path: PathBuf,
    },
    
    #[error("File too large: {size} bytes (limit: {limit})\nConsider using --skip-large")]
    FileTooLarge {
        size: u64,
        limit: u64,
    },
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::tempdir;
    
    #[test]
    fn test_deduplication_empty_files() {
        let dir = tempdir().unwrap();
        
        // Create empty files
        std::fs::write(dir.path().join("empty1.txt"), "").unwrap();
        std::fs::write(dir.path().join("empty2.txt"), "").unwrap();
        
        let scanner = Scanner::new(dir.path());
        let files = scanner.scan().unwrap();
        
        let detector = DuplicateDetector::new(files);
        let duplicates = detector.find_duplicates();
        
        // Empty files should be detected as duplicates
        assert_eq!(duplicates.len(), 1);
        assert_eq!(duplicates[0].files.len(), 2);
    }
    
    #[test]
    fn test_symbolic_links() {
        // Test symlink handling...
    }
    
    #[test]
    fn test_permission_errors() {
        // Test graceful permission failure...
    }
    
    #[test]
    fn test_circular_symlinks() {
        // Test infinite loop prevention...
    }
}

use std::io::{BufReader, Read};
use blake3::Hasher;
 
pub fn hash_file_streaming(path: &Path) -> Result<Hash> {
    let file = File::open(path)?;
    let mut reader = BufReader::with_capacity(8192, file);
    let mut hasher = Hasher::new();
    
    // Stream in chunks to avoid loading entire file
    let mut buffer = [0u8; 8192];
    loop {
        let bytes_read = reader.read(&mut buffer)?;
        if bytes_read == 0 {
            break;
        }
        hasher.update(&buffer[..bytes_read]);
    }
    
    Ok(Hash::from(hasher.finalize().as_bytes()))
}

pub struct FilterConfig {
    pub min_size: u64,
    pub max_size: Option<u64>,
    pub extensions: Option<HashSet<String>>,
    pub skip_hidden: bool,
}
 
impl Scanner {
    pub fn with_filter(mut self, config: FilterConfig) -> Self {
        self.filter = Some(config);
        self
    }
    
    fn should_scan(&self, entry: &DirEntry) -> bool {
        let Some(ref filter) = self.filter else {
            return true;
        };
        
        // Fast path: check file name
        if filter.skip_hidden {
            if let Some(name) = entry.file_name().to_str() {
                if name.starts_with('.') {
                    return false;
                }
            }
        }
        
        // Check metadata
        let Ok(metadata) = entry.metadata() else {
            return false;
        };
        
        let size = metadata.len();
        
        // Size filters
        if size < filter.min_size {
            return false;
        }
        
        if let Some(max) = filter.max_size {
            if size > max {
                return false;
            }
        }
        
        // Extension filter
        if let Some(ref exts) = filter.extensions {
            let path = entry.path();
            let ext = path.extension()
                .and_then(|e| e.to_str())
                .unwrap_or("");
            
            if !exts.contains(ext) {
                return false;
            }
        }
        
        true
    }
}