added undefined classes check

Author: Andcool-Systems

src/main.rs

@@ -8,7 +8,7 @@ use std::{
 use anyhow::Result;
 use config::get_compiler_options;
 use css_parser::{extract_classes, ClassName};
-use tsx_parser::{extract_default_css_imports, extract_used_classes};
+use tsx_parser::{extract_default_css_imports, extract_used_classes, UsedClassName};
 use utils::{process_relative_import, replace_aliases};
 
 mod config;
@@ -71,7 +71,7 @@ fn main() -> Result<()> {
 
     let dir = list_files_in_directory(Path::new(".").to_path_buf(), tsconfig.exclude);
 
-    let mut used_classnames: HashMap<String, HashSet<String>> = Default::default();
+    let mut used_classnames: HashMap<String, HashSet<UsedClassName>> = Default::default();
     let mut defined_classnames: HashMap<String, HashSet<ClassName>> = Default::default();
 
     for entry in &dir {
@@ -85,7 +85,7 @@ fn main() -> Result<()> {
                 process_relative_import(Path::new(entry), &mut style_path)?;
                 replace_aliases(&mut style_path, tsconfig.compiler_options.paths.clone());
 
-                let used_fields = extract_used_classes(&code, &class_names);
+                let used_fields = extract_used_classes(&code, &class_names, path.clone());
                 used_classnames
                     .entry(style_path)
                     .or_insert_with(HashSet::new)
@@ -104,20 +104,22 @@ fn main() -> Result<()> {
     let mut files_count = 0;
     let mut errors_count = 0;
 
-    for (css_file, mut classes) in defined_classnames {
+    for (css_file, mut classes_tsx) in defined_classnames.clone() {
         if let Some(used_css) = used_classnames.get(&css_file) {
-            classes.retain(|v| !used_css.contains(&v.class_name));
+            let used_css_flatten: Vec<String> =
+                used_css.iter().map(|v| v.class_name.clone()).collect();
+            classes_tsx.retain(|v| !used_css_flatten.contains(&v.class_name));
         }
 
-        if classes.is_empty() {
+        if classes_tsx.is_empty() {
             continue;
         }
 
         files_count += 1;
-        errors_count += classes.len();
+        errors_count += classes_tsx.len();
 
         println!("{}{}{}", COLOR_BLUE, css_file, COLOR_RESET);
-        for extra in classes {
+        for extra in classes_tsx {
             println!(
                 "{}{}:{}  {}Warn{}: Unused class `{}` found",
                 COLOR_YELLOW,
@@ -132,6 +134,47 @@ fn main() -> Result<()> {
         println!();
     }
 
+    let mut undefined_classes: HashMap<String, HashSet<UsedClassName>> = HashMap::new();
+
+    for (tsx_file, mut classes) in used_classnames {
+        if let Some(defined_css) = defined_classnames.get(&tsx_file) {
+            let defined_css: HashSet<String> =
+                defined_css.iter().map(|v| v.class_name.clone()).collect();
+            classes.retain(|v| !defined_css.contains(v.class_name.as_str()));
+        }
+
+        if classes.is_empty() {
+            continue;
+        }
+
+        files_count += 1;
+        errors_count += classes.len();
+
+        for extra in classes {
+            undefined_classes
+                .entry(extra.file_name.clone())
+                .or_insert_with(HashSet::new)
+                .insert(extra);
+        }
+    }
+
+    for undefined in undefined_classes {
+        println!("{}{}{}", COLOR_BLUE, undefined.0, COLOR_RESET);
+        for extra in undefined.1 {
+            println!(
+                "{}{}:{}  {}Warn{}: Undefined class `{}` used",
+                COLOR_YELLOW,
+                extra.line,
+                extra.column + 1,
+                COLOR_YELLOW,
+                COLOR_RESET,
+                extra.class_name
+            );
+        }
+
+        println!();
+    }
+
     if errors_count == 0 {
         println!("{}✔{} No CSS lint warnings found", COLOR_GREEN, COLOR_RESET);
     } else {

src/tsx_parser.rs

@@ -4,7 +4,7 @@ use swc_ecma_ast::{ImportSpecifier, Module, ModuleDecl};
 use swc_ecma_parser::{Parser, StringInput, Syntax, TsSyntax};
 use swc_ecma_visit::{Visit, VisitWith};
 
-pub fn module_parser(tsx_code: &str) -> Module {
+pub fn module_parser(tsx_code: &str) -> (Module, Lrc<SourceMap>) {
     let cm: Lrc<SourceMap> = Default::default();
     let fm = cm.new_source_file(FileName::Custom("input.tsx".into()).into(), tsx_code.into());
 
@@ -18,20 +18,36 @@ pub fn module_parser(tsx_code: &str) -> Module {
 
     let mut parser = Parser::new(syntax, StringInput::from(&*fm), None);
 
-    parser.parse_module().expect("Failed to parse")
+    (parser.parse_module().expect("Failed to parse"), cm)
+}
+
+#[derive(Eq, PartialEq, Hash, Debug)]
+pub struct UsedClassName {
+    pub class_name: String,
+    pub file_name: String,
+    pub line: usize,
+    pub column: usize,
 }
 
 struct PropertyFinder {
     variable_name: String,
-    properties: HashSet<String>,
+    file_name: String,
+    properties: HashSet<UsedClassName>,
+    source_map: Lrc<SourceMap>,
 }
 
 impl Visit for PropertyFinder {
     fn visit_member_expr(&mut self, node: &swc_ecma_ast::MemberExpr) {
         if let swc_ecma_ast::Expr::Ident(ref obj) = *node.obj {
             if obj.sym == self.variable_name {
                 if let swc_ecma_ast::MemberProp::Ident(ref prop) = node.prop {
-                    self.properties.insert(prop.sym.to_string());
+                    let loc = self.source_map.lookup_char_pos(node.span.lo());
+                    self.properties.insert(UsedClassName {
+                        class_name: prop.sym.to_string(),
+                        file_name: self.file_name.clone(),
+                        line: loc.line,
+                        column: loc.col.0,
+                    });
                 }
             }
         }
@@ -40,12 +56,18 @@ impl Visit for PropertyFinder {
     }
 }
 
-pub fn extract_used_classes(tsx_code: &str, variable_name: &str) -> HashSet<String> {
-    let module = module_parser(tsx_code);
+pub fn extract_used_classes(
+    tsx_code: &str,
+    variable_name: &str,
+    file_name: String,
+) -> HashSet<UsedClassName> {
+    let (module, source_map) = module_parser(tsx_code);
 
     let mut finder = PropertyFinder {
         variable_name: variable_name.to_string(),
+        file_name,
         properties: HashSet::new(),
+        source_map: source_map.clone(),
     };
 
     module.visit_with(&mut finder);
@@ -77,7 +99,7 @@ impl Visit for DefaultCssImportFinder {
 }
 
 pub fn extract_default_css_imports(tsx_code: &str) -> HashSet<(String, String)> {
-    let module = module_parser(tsx_code);
+    let (module, _) = module_parser(tsx_code);
 
     let mut finder = DefaultCssImportFinder {
         imported_variables: HashSet::new(),