Rename classes and functions

src/best_practices.rs

@@ -2,33 +2,33 @@ use crate::rules::{register_rule, Category, Code, Method, Rule, Status};
 use std::collections::HashMap;
 
 pub mod floating_point;
-pub mod use_implicit_none;
-pub mod use_modules;
+pub mod implicit_none;
+pub mod modules_and_programs;
 
 pub fn add_best_practices_rules(registry: &mut HashMap<String, Rule>) {
     for rule in [
         Rule::new(
             Code::new(Category::BestPractices, 1),
-            Method::Tree(use_modules::use_modules),
-            use_modules::USE_MODULES,
+            Method::Tree(modules_and_programs::use_modules_and_programs),
+            modules_and_programs::USE_MODULES_AND_PROGRAMS,
             Status::Standard,
         ),
         Rule::new(
             Code::new(Category::BestPractices, 10),
-            Method::Tree(use_implicit_none::use_implicit_none),
-            use_implicit_none::USE_IMPLICIT_NONE,
+            Method::Tree(implicit_none::use_implicit_none_modules_and_programs),
+            implicit_none::USE_IMPLICIT_NONE_MODULES_AND_PROGRAMS,
             Status::Standard,
         ),
         Rule::new(
             Code::new(Category::BestPractices, 11),
-            Method::Tree(use_implicit_none::use_interface_implicit_none),
-            use_implicit_none::USE_INTERFACE_IMPLICIT_NONE,
+            Method::Tree(implicit_none::use_implicit_none_interfaces),
+            implicit_none::USE_IMPLICIT_NONE_INTERFACES,
             Status::Standard,
         ),
         Rule::new(
             Code::new(Category::BestPractices, 12),
-            Method::Tree(use_implicit_none::avoid_superfluous_implicit_none),
-            use_implicit_none::AVOID_SUPERFLUOUS_IMPLICIT_NONE,
+            Method::Tree(implicit_none::avoid_superfluous_implicit_none),
+            implicit_none::AVOID_SUPERFLUOUS_IMPLICIT_NONE,
             Status::Optional,
         ),
         Rule::new(

src/best_practices/use_implicit_none.rs → src/best_practices/implicit_none.rs

@@ -3,11 +3,15 @@ use crate::rules::{Code, Violation};
 /// Defines rules that raise errors if implicit typing is in use.
 use tree_sitter::{Node, Query};
 
-pub const USE_IMPLICIT_NONE: &str = "\
+pub const USE_IMPLICIT_NONE_MODULES_AND_PROGRAMS: &str = "\
     'implicit none' should be used in all modules and programs, as implicit typing
     reduces the readability of code and increases the chances of typing errors.";
 
-pub fn use_implicit_none(code: Code, root: &Node, src: &str) -> Vec<Violation> {
+pub fn use_implicit_none_modules_and_programs(
+    code: Code,
+    root: &Node,
+    src: &str,
+) -> Vec<Violation> {
     let mut violations = Vec::new();
     for query_type in ["module", "submodule", "program"] {
         // Search for a module, submodule or program, and optionally an 'implicit none'.
@@ -41,11 +45,11 @@ pub fn use_implicit_none(code: Code, root: &Node, src: &str) -> Vec<Violation> {
     violations
 }
 
-pub const USE_INTERFACE_IMPLICIT_NONE: &str = "\
+pub const USE_IMPLICIT_NONE_INTERFACES: &str = "\
     Interface functions and subroutines require 'implicit none', even if they are inside
     a module that uses 'implicit none'.";
 
-pub fn use_interface_implicit_none(code: Code, root: &Node, src: &str) -> Vec<Violation> {
+pub fn use_implicit_none_interfaces(code: Code, root: &Node, src: &str) -> Vec<Violation> {
     let mut violations = Vec::new();
     for query_type in ["function", "subroutine"] {
         let query_txt = format!(
@@ -120,7 +124,7 @@ mod tests {
     use crate::test_utils::test_utils::{test_tree_method, TEST_CODE};
 
     #[test]
-    fn test_missing_implicit_none() {
+    fn test_module_and_program_missing_implicit_none() {
         let source = "
             module my_module
                 parameter(N = 1)
@@ -141,11 +145,15 @@ mod tests {
                 )
             })
             .collect();
-        test_tree_method(use_implicit_none, source, Some(expected_violations));
+        test_tree_method(
+            use_implicit_none_modules_and_programs,
+            source,
+            Some(expected_violations),
+        );
     }
 
     #[test]
-    fn test_uses_implicit_none() {
+    fn test_module_and_program_uses_implicit_none() {
         let source = "
             module my_module
                 implicit none
@@ -162,7 +170,7 @@ mod tests {
                 write(*,*) x
             end program
             ";
-        test_tree_method(use_implicit_none, source, None);
+        test_tree_method(use_implicit_none_modules_and_programs, source, None);
     }
 
     #[test]
@@ -199,7 +207,7 @@ mod tests {
             })
             .collect();
         test_tree_method(
-            use_interface_implicit_none,
+            use_implicit_none_interfaces,
             source,
             Some(expected_violations),
         );
@@ -229,7 +237,7 @@ mod tests {
                 write(*,*) 42
             end program
             ";
-        test_tree_method(use_interface_implicit_none, source, None);
+        test_tree_method(use_implicit_none_interfaces, source, None);
     }
 
     #[test]

src/best_practices/use_modules.rs → src/best_practices/modules_and_programs.rs

@@ -4,12 +4,12 @@ use crate::rules::{Code, Violation};
 /// submodules, or interfaces. It is also acceptable to define nested functions or subroutines.
 use tree_sitter::{Node, Query};
 
-pub const USE_MODULES: &str = "\
-    Functions and subroutines should be contained within (sub)modules, program blocks,
-    or interfaces. Fortran compilers are unable to perform type checks and conversions
-    on functions defined outside of these scopes, and this is a common source of bugs.";
+pub const USE_MODULES_AND_PROGRAMS: &str = "\
+    Functions and subroutines should be contained within (sub)modules or programs.
+    Fortran compilers are unable to perform type checks and conversions on functions
+    defined outside of these scopes, and this is a common source of bugs.";
 
-pub fn use_modules(code: Code, root: &Node, src: &str) -> Vec<Violation> {
+pub fn use_modules_and_programs(code: Code, root: &Node, src: &str) -> Vec<Violation> {
     let mut violations = Vec::new();
     let query_txt = "(translation_unit [(function) @func (subroutine) @sub])";
     let query = Query::new(fortran_language(), query_txt).unwrap();
@@ -24,7 +24,7 @@ pub fn use_modules(code: Code, root: &Node, src: &str) -> Vec<Violation> {
                 &node,
                 code,
                 format!(
-                    "{} not contained within (sub)module, program, or interface",
+                    "{} not contained within (sub)module or program",
                     node.kind(),
                 )
                 .as_str(),
@@ -59,15 +59,11 @@ mod tests {
                 Violation::new(
                     *line,
                     TEST_CODE,
-                    format!(
-                        "{} not contained within (sub)module, program, or interface",
-                        kind
-                    )
-                    .as_str(),
+                    format!("{} not contained within (sub)module or program", kind).as_str(),
                 )
             })
             .collect();
-        test_tree_method(use_modules, source, Some(expected_violations));
+        test_tree_method(use_modules_and_programs, source, Some(expected_violations));
     }
 
     #[test]
@@ -87,6 +83,6 @@ mod tests {
                 end subroutine
             end module
             ";
-        test_tree_method(use_modules, source, None);
+        test_tree_method(use_modules_and_programs, source, None);
     }
 }

src/main.rs

@@ -21,6 +21,7 @@ fn main() {
     let mut parser = fortran_parser();
     let tree = parser.parse(&content, None).unwrap();
     let root = tree.root_node();
+    println!("{}", root.to_sexp());
 
     // Collect available rules
     // TODO Add feature to deselect rules, or add non-default ones.

test.f90

@@ -42,9 +42,8 @@ integer function quad(x)
   end function
 
   ! Should trigger for use of 'double precision'
-  function double_prec(x)
+  double precision function double_prec(x)
     double precision, intent(in) :: x
-    double precision :: double_prec
     double_prec = 2 * x
   end function
 end module