resolve clippy lints

src/builtin/selector.rs

@@ -1,5 +1,3 @@
-#![allow(unused_variables, unused_mut)]
-
 use super::{Builtin, GlobalFunctionMap};
 
 use crate::args::CallArgs;
@@ -107,11 +105,7 @@ fn selector_nest(args: CallArgs, scope: &Scope, super_selector: &Selector) -> Sa
         .into_value())
 }
 
-fn selector_append(
+fn selector_append(args: CallArgs, scope: &Scope, super_selector: &Selector) -> SassResult<Value> {
-    mut args: CallArgs,
-    scope: &Scope,
-    super_selector: &Selector,
-) -> SassResult<Value> {
     let span = args.span();
     let selectors = args.get_variadic(scope, super_selector)?;
     if selectors.is_empty() {

src/lib.rs

@@ -59,6 +59,9 @@ grass input.scss
     clippy::filter_map,
     clippy::else_if_without_else,
     clippy::new_ret_no_self,
+    renamed_and_removed_lints,
+    clippy::unknown_clippy_lints,
+    clippy::replace_consts,
 
     // temporarily allowed while under heavy development.
     // eventually these allows should be refactored away

src/selector/compound.rs

@@ -214,7 +214,7 @@ impl CompoundSelector {
 
                 Self { components }
             }
-            simple => {
+            _ => {
                 let mut components = vec![SimpleSelector::Parent(None)];
                 components.append(&mut self.components);
                 Self { components }

src/selector/extend/extension.rs

@@ -35,7 +35,7 @@ pub(super) struct Extension {
 impl Extension {
     pub fn one_off(extender: ComplexSelector, specificity: Option<i32>, is_original: bool) -> Self {
         Self {
-            specificity: specificity.unwrap_or(extender.max_specificity()),
+            specificity: specificity.unwrap_or_else(|| extender.max_specificity()),
             extender,
             target: None,
             span: None,

src/selector/extend/functions.rs

@@ -729,11 +729,11 @@ fn complex_is_parent_superselector(
 ///
 /// For example, given `[[1, 2], [3, 4], [5]]`, this returns:
 ///
-/// ```norun
+/// ```no_run
 /// [[1, 3, 5],
 ///  [2, 3, 5],
 ///  [1, 4, 5],
-///  [2, 4, 5]]
+///  [2, 4, 5]];
 /// ```
 pub(crate) fn paths<T: Clone>(choices: Vec<Vec<T>>) -> Vec<Vec<T>> {
     choices.into_iter().fold(vec![vec![]], |paths, choice| {

src/selector/extend/mod.rs

@@ -38,7 +38,13 @@ enum ExtendMode {
     AllTargets,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq)]
+impl Default for ExtendMode {
+    fn default() -> Self {
+        Self::Normal
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Default)]
 pub(crate) struct Extender {
     /// A map from all simple selectors in the stylesheet to the selector lists
     /// that contain them.
@@ -88,6 +94,7 @@ pub(crate) struct Extender {
 impl Extender {
     /// An `Extender` that contains no extensions and can have no extensions added.
     // TODO: empty extender
+    #[allow(dead_code)]
     const EMPTY: () = ();
 
     pub fn extend(
@@ -112,7 +119,7 @@ impl Extender {
         targets: SelectorList,
         mode: ExtendMode,
     ) -> SelectorList {
-        let mut extenders: IndexMap<ComplexSelector, Extension> = source
+        let extenders: IndexMap<ComplexSelector, Extension> = source
             .components
             .clone()
             .into_iter()
@@ -149,7 +156,7 @@ impl Extender {
                     .extend(selector.components.clone().into_iter());
             }
 
-            selector = extender.extend_list(selector, extensions, None);
+            selector = extender.extend_list(selector, &extensions, &None);
         }
 
         selector
@@ -158,12 +165,7 @@ impl Extender {
     fn with_mode(mode: ExtendMode) -> Self {
         Self {
             mode,
-            selectors: Default::default(),
+            ..Extender::default()
-            extensions: Default::default(),
-            extensions_by_extender: Default::default(),
-            media_contexts: Default::default(),
-            source_specificity: Default::default(),
-            originals: Default::default(),
         }
     }
 
@@ -171,8 +173,8 @@ impl Extender {
     fn extend_list(
         &mut self,
         list: SelectorList,
-        extensions: HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
+        extensions: &HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
-        media_query_context: Option<Vec<CssMediaQuery>>,
+        media_query_context: &Option<Vec<CssMediaQuery>>,
     ) -> SelectorList {
         // This could be written more simply using Vec<Vec<T>>, but we want to avoid
         // any allocations in the common case where no extends apply.
@@ -180,23 +182,17 @@ impl Extender {
         for i in 0..list.components.len() {
             let complex = list.components.get(i).unwrap().clone();
 
-            if let Some(result) = self.extend_complex(
+            if let Some(result) =
-                complex.clone(),
+                self.extend_complex(complex.clone(), extensions, media_query_context)
-                extensions.clone(),
+            {
-                media_query_context.clone(),
+                if extended.is_empty() && i != 0 {
-            ) {
-                if extended.is_empty() {
-                    if i != 0 {
                     extended = list.components[0..i].to_vec();
                 }
-                }
                 extended.extend(result.into_iter());
-            } else {
+            } else if !extended.is_empty() {
-                if !extended.is_empty() {
                 extended.push(complex);
             }
         }
-        }
 
         if extended.is_empty() {
             return list;
@@ -212,8 +208,8 @@ impl Extender {
     fn extend_complex(
         &mut self,
         complex: ComplexSelector,
-        extensions: HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
+        extensions: &HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
-        media_query_context: Option<Vec<CssMediaQuery>>,
+        media_query_context: &Option<Vec<CssMediaQuery>>,
     ) -> Option<Vec<ComplexSelector>> {
         // The complex selectors that each compound selector in `complex.components`
         // can expand to.
@@ -236,16 +232,11 @@ impl Extender {
 
         let complex_has_line_break = complex.line_break;
 
-        let is_original = self.originals.contains(&complex);
-
         for i in 0..complex.components.len() {
             if let Some(ComplexSelectorComponent::Compound(component)) = complex.components.get(i) {
-                if let Some(extended) = self.extend_compound(
+                if let Some(extended) =
-                    component.clone(),
+                    self.extend_compound(component, extensions, media_query_context)
-                    extensions.clone(),
+                {
-                    media_query_context.clone(),
-                    is_original,
-                ) {
                     if extended_not_expanded.is_empty() {
                         extended_not_expanded = complex
                             .components
@@ -311,15 +302,11 @@ impl Extender {
 
     /// Extends `compound` using `extensions`, and returns the contents of a
     /// `SelectorList`.
-    ///
-    /// The `in_original` parameter indicates whether this is in an original
-    /// complex selector, meaning that `compound` should not be trimmed out.
     fn extend_compound(
         &mut self,
-        compound: CompoundSelector,
+        compound: &CompoundSelector,
-        extensions: HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
+        extensions: &HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
-        media_query_context: Option<Vec<CssMediaQuery>>,
+        media_query_context: &Option<Vec<CssMediaQuery>>,
-        in_original: bool,
     ) -> Option<Vec<ComplexSelector>> {
         // If there's more than one target and they all need to match, we track
         // which targets are actually extended.
@@ -332,17 +319,15 @@ impl Extender {
 
             if let Some(extended) = self.extend_simple(
                 simple.clone(),
-                extensions.clone(),
+                extensions,
-                media_query_context.clone(),
+                media_query_context,
                 &mut targets_used,
             ) {
-                if options.is_empty() {
+                if options.is_empty() && i != 0 {
-                    if i != 0 {
                     options.push(vec![self.extension_for_compound(
                         compound.components.clone().into_iter().take(i).collect(),
                     )]);
                 }
-                }
 
                 options.extend(extended.into_iter());
             } else {
@@ -356,7 +341,7 @@ impl Extender {
 
         // If `self.mode` isn't `ExtendMode::Normal` and we didn't use all the targets in
         // `extensions`, extension fails for `compound`.
-        if targets_used.len() > 0 && targets_used.len() != extensions.len() {
+        if !targets_used.is_empty() && targets_used.len() != extensions.len() {
             return None;
         }
 
@@ -369,7 +354,7 @@ impl Extender {
                     .clone()
                     .into_iter()
                     .map(|state| {
-                        state.assert_compatible_media_context(&media_query_context);
+                        state.assert_compatible_media_context(media_query_context);
                         state.extender
                     })
                     .collect(),
@@ -405,15 +390,13 @@ impl Extender {
         let unified_paths: Vec<Option<Vec<ComplexSelector>>> = paths(options)
             .into_iter()
             .map(|path| {
-                let complexes: Vec<Vec<ComplexSelectorComponent>>;
+                let complexes: Vec<Vec<ComplexSelectorComponent>> = if first {
-
-                if first {
                     // The first path is always the original selector. We can't just
                     // return `compound` directly because pseudo selectors may be
                     // modified, but we don't have to do any unification.
                     first = false;
 
-                    complexes = vec![vec![ComplexSelectorComponent::Compound(CompoundSelector {
+                    vec![vec![ComplexSelectorComponent::Compound(CompoundSelector {
                         components: path
                             .clone()
                             .into_iter()
@@ -425,7 +408,7 @@ impl Extender {
                                 }
                             })
                             .collect(),
-                    })]];
+                    })]]
                 } else {
                     let mut to_unify: VecDeque<Vec<ComplexSelectorComponent>> = VecDeque::new();
                     let mut originals: Vec<SimpleSelector> = Vec::new();
@@ -448,13 +431,13 @@ impl Extender {
                         )]);
                     }
 
-                    complexes = unify_complex(Vec::from(to_unify))?;
+                    unify_complex(Vec::from(to_unify))?
-                }
+                };
 
                 let mut line_break = false;
 
                 for state in path {
-                    state.assert_compatible_media_context(&media_query_context);
+                    state.assert_compatible_media_context(media_query_context);
                     line_break = line_break || state.extender.line_break;
                 }
 
@@ -482,8 +465,8 @@ impl Extender {
     fn extend_simple(
         &mut self,
         simple: SimpleSelector,
-        extensions: HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
+        extensions: &HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
-        media_query_context: Option<Vec<CssMediaQuery>>,
+        media_query_context: &Option<Vec<CssMediaQuery>>,
         targets_used: &mut HashSet<SimpleSelector>,
     ) -> Option<Vec<Vec<Extension>>> {
         if let SimpleSelector::Pseudo(
@@ -492,16 +475,14 @@ impl Extender {
             },
         ) = simple.clone()
         {
-            if let Some(extended) =
+            if let Some(extended) = self.extend_pseudo(simple, extensions, media_query_context) {
-                self.extend_pseudo(simple, extensions.clone(), media_query_context)
-            {
                 return Some(
                     extended
                         .into_iter()
                         .map(move |pseudo| {
                             self.without_pseudo(
                                 SimpleSelector::Pseudo(pseudo.clone()),
-                                extensions.clone(),
+                                extensions,
                                 targets_used,
                                 self.mode,
                             )
@@ -523,14 +504,11 @@ impl Extender {
     fn extend_pseudo(
         &mut self,
         pseudo: Pseudo,
-        extensions: HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
+        extensions: &HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
-        media_query_context: Option<Vec<CssMediaQuery>>,
+        media_query_context: &Option<Vec<CssMediaQuery>>,
     ) -> Option<Vec<Pseudo>> {
         let extended = self.extend_list(
-            pseudo
+            pseudo.selector.clone().unwrap_or_else(SelectorList::new),
-                .selector
-                .clone()
-                .unwrap_or_else(|| SelectorList::new()),
             extensions,
             media_query_context,
         );
@@ -544,8 +522,7 @@ impl Extender {
         // writing. We can keep them if either the original selector had a complex
         // selector, or the result of extending has only complex selectors, because
         // either way we aren't breaking anything that isn't already broken.
-        let mut complexes = extended.components.clone();
+        let mut complexes = if pseudo.normalized_name == "not"
-        if pseudo.normalized_name == "not"
             && !pseudo
                 .selector
                 .clone()
@@ -558,13 +535,14 @@ impl Extender {
                 .iter()
                 .any(|complex| complex.components.len() == 1)
         {
-            complexes = extended
+            extended
                 .components
-                .clone()
                 .into_iter()
                 .filter(|complex| complex.components.len() <= 1)
-                .collect();
+                .collect()
-        }
+        } else {
+            extended.components
+        };
 
         complexes = complexes
             .into_iter()
@@ -598,10 +576,10 @@ impl Extender {
                         // become `.foo:not(.bar)`. However, this is a narrow edge case and
                         // supporting it properly would make this code and the code calling it
                         // a lot more complicated, so it's not supported for now.
-                        if inner_pseudo.normalized_name != "matches" {
+                        if inner_pseudo.normalized_name == "matches" {
-                            Vec::new()
-                        } else {
                             inner_pseudo.selector.clone().unwrap().components
+                        } else {
+                            Vec::new()
                         }
                     }
                     "matches" | "any" | "current" | "nth-child" | "nth-last-child" => {
@@ -657,7 +635,7 @@ impl Extender {
     fn without_pseudo(
         &self,
         simple: SimpleSelector,
-        extensions: HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
+        extensions: &HashMap<SimpleSelector, IndexMap<ComplexSelector, Extension>>,
         targets_used: &mut HashSet<SimpleSelector>,
         mode: ExtendMode,
     ) -> Option<Vec<Extension>> {
@@ -782,17 +760,19 @@ impl Extender {
                 // ensures that we aren't comparing against a selector that's already been
                 // trimmed, and thus that if there are two identical selectors only one is
                 // trimmed.
-                if result.iter().any(|complex2| {
+                let should_continue = result.iter().any(|complex2| {
                     complex2.min_specificity() >= max_specificity
                         && complex2.is_super_selector(complex1)
-                }) {
+                });
+                if should_continue {
                     continue;
                 }
 
-                if selectors.iter().take(i).any(|complex2| {
+                let should_continue = selectors.iter().take(i).any(|complex2| {
                     complex2.min_specificity() >= max_specificity
                         && complex2.is_super_selector(complex1)
-                }) {
+                });
+                if should_continue {
                     continue;
                 }
 
@@ -800,12 +780,11 @@ impl Extender {
             }
             if should_break_to_outer {
                 continue;
-            } else {
+            }
             break;
         }
-        }
 
-        return Vec::from(result);
+        Vec::from(result)
     }
 }
 

src/selector/mod.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code, unused_variables, unused_mut)]
-
 use std::fmt::{self, Display};
 
 use peekmore::{PeekMore, PeekMoreIterator};

src/selector/parse.rs

@@ -335,7 +335,7 @@ impl<'a, I: Iterator<Item = Token>> SelectorParser<'a, I> {
                 devour_whitespace(self.toks);
                 self.expect_closing_paren()?;
             } else {
-                argument = Some(self.declaration_value(true)?);
+                argument = Some(self.declaration_value()?);
             }
         } else if SELECTOR_PSEUDO_CLASSES.contains(&unvendored) {
             selector = Some(self.parse_selector_list()?);
@@ -358,7 +358,7 @@ impl<'a, I: Iterator<Item = Token>> SelectorParser<'a, I> {
             self.expect_closing_paren()?;
             argument = Some(this_arg);
         } else {
-            argument = Some(self.declaration_value(true)?.trim_end().to_string());
+            argument = Some(self.declaration_value()?.trim_end().to_string());
         }
 
         Ok(SimpleSelector::Pseudo(Pseudo {
@@ -533,7 +533,7 @@ impl<'a, I: Iterator<Item = Token>> SelectorParser<'a, I> {
         Ok(buf)
     }
 
-    fn declaration_value(&mut self, allow_empty: bool) -> SassResult<String> {
+    fn declaration_value(&mut self) -> SassResult<String> {
         // todo: this consumes the closing paren
         let mut tmp = read_until_closing_paren(self.toks)?;
         if let Some(Token { kind: ')', .. }) = tmp.pop() {

src/selector/simple.rs

@@ -567,6 +567,7 @@ impl Pseudo {
         }
     }
 
+    #[allow(clippy::missing_const_for_fn)]
     pub fn with_selector(self, selector: Option<SelectorList>) -> Self {
         Self { selector, ..self }
     }
@@ -601,7 +602,7 @@ impl Pseudo {
                 min = min.max(complex.min_specificity());
                 max = max.max(complex.max_specificity());
             }
-            return Specificity { min, max };
+            Specificity { min, max }
         } else {
             // This is higher than any selector's specificity can actually be.
             let mut min = BASE_SPECIFICITY.pow(3_u32);
@@ -610,7 +611,7 @@ impl Pseudo {
                 min = min.min(complex.min_specificity());
                 max = max.max(complex.max_specificity());
             }
-            return Specificity { min, max };
+            Specificity { min, max }
         }
     }
 }