echo-python 0.1.0__tar.gz → 0.1.1__tar.gz

{echo_python-0.1.0 → echo_python-0.1.1}/Cargo.lock

@@ -169,7 +169,7 @@ dependencies = [
 
 [[package]]
 name = "echo-python"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "anyhow",
  "clap",

{echo_python-0.1.0 → echo_python-0.1.1}/Cargo.toml

@@ -7,7 +7,7 @@ license = "MIT"
 name = "echo-python"
 readme = "readme.txt"
 repository = "https://github.com/anyaagarenko/echo-python"
-version = "0.1.0"
+version = "0.1.1"
 
 [[bin]]
 name = "echo-python"

{echo_python-0.1.0 → echo_python-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: echo-python
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -35,11 +35,12 @@ cli:
 
 rules:
 
-  ECHO001 - calls with multiple args must use keywords (self/cls exempt)
-  ECHO002 - mixed lists: numbers by value, then words alphabetically
-  ECHO003 - numeric lists sorted by value
-  ECHO004 - word/name lists sorted alphabetically
-  ECHO005 - params one per line when more than one (self/cls not counted)
+  ECHO001 - use keyword arguments for calls with multiple positional args
+            https://github.com/anyaagarenko/echo-python/blob/main/docs/rules/echo-001.txt
+  ECHO002 - mixed list is not sorted (numbers then words)
+  ECHO003 - numbers list is not sorted
+  ECHO004 - words list is not sorted
+  ECHO005 - put each parameter on its own line when a function has more than one parameter
 
 
 configure in pyproject.toml:
@@ -59,6 +60,9 @@ development:
   see Makefile
 
 
+contributions welcome
+
+
 publishing:
 
   bump version in Cargo.toml on main

echo_python-0.1.1/docs/rules/echo-001.txt

@@ -0,0 +1,25 @@
+ECHO001 - use keyword arguments for calls with multiple positional args
+
+
+why:
+
+  multi-arg positional calls are hard to read and reorder safely.
+  keyword args make call sites explicit and ready to sort later.
+
+
+bad:
+
+  create_user("ada", "lovelace", True)
+  client.request("GET", url)
+
+
+good:
+
+  create_user(first="ada", last="lovelace", active=True)
+  client.request(method="GET", url=url)
+
+
+configure in pyproject.toml:
+
+  [tool.echo-python.echo001]
+  ignore = ["pytest.mark.parametrize", "pytest.param"]

{echo_python-0.1.0 → echo_python-0.1.1}/readme.txt

@@ -17,11 +17,12 @@ cli:
 
 rules:
 
-  ECHO001 - calls with multiple args must use keywords (self/cls exempt)
-  ECHO002 - mixed lists: numbers by value, then words alphabetically
-  ECHO003 - numeric lists sorted by value
-  ECHO004 - word/name lists sorted alphabetically
-  ECHO005 - params one per line when more than one (self/cls not counted)
+  ECHO001 - use keyword arguments for calls with multiple positional args
+            https://github.com/anyaagarenko/echo-python/blob/main/docs/rules/echo-001.txt
+  ECHO002 - mixed list is not sorted (numbers then words)
+  ECHO003 - numbers list is not sorted
+  ECHO004 - words list is not sorted
+  ECHO005 - put each parameter on its own line when a function has more than one parameter
 
 
 configure in pyproject.toml:
@@ -41,6 +42,9 @@ development:
   see Makefile
 
 
+contributions welcome
+
+
 publishing:
 
   bump version in Cargo.toml on main

echo_python-0.1.1/src/bindings.rs

@@ -0,0 +1,310 @@
+use std::collections::{HashMap, HashSet};
+
+use rustpython_parser::ast::{self, Visitor};
+use rustpython_parser::text_size::TextSize;
+
+#[derive(Debug)]
+struct Scope {
+    names: HashSet<String>,
+    parent: Option<usize>,
+}
+
+#[derive(Debug)]
+pub(crate) struct Bindings {
+    call_scopes: HashMap<TextSize, usize>,
+    scopes: Vec<Scope>,
+}
+
+impl Bindings {
+    pub(crate) fn from_module(module: &[ast::Stmt]) -> Self {
+        let mut collector = Collector::new();
+        for statement in module {
+            collector.visit_stmt(statement.clone());
+        }
+
+        collector.bindings
+    }
+
+    pub(crate) fn match_builtin_expr(&self, call: &ast::ExprCall, builtin: &str) -> bool {
+        let Some(scope) = self.call_scopes.get(&call.range.start()) else {
+            return bare_or_builtins_attr(call.func.as_ref(), builtin);
+        };
+        match_builtin_expr(call.func.as_ref(), builtin, *scope, self)
+    }
+
+    fn is_unbound(&self, name: &str, mut scope: usize) -> bool {
+        loop {
+            if self.scopes[scope].names.contains(name) {
+                return false;
+            }
+            scope = match self.scopes[scope].parent {
+                Some(parent) => parent,
+                None => return true,
+            };
+        }
+    }
+}
+
+struct Collector {
+    bindings: Bindings,
+    current_scope: usize,
+}
+
+impl Collector {
+    fn new() -> Self {
+        Self {
+            bindings: Bindings {
+                call_scopes: HashMap::new(),
+                scopes: vec![Scope {
+                    names: HashSet::new(),
+                    parent: None,
+                }],
+            },
+            current_scope: 0,
+        }
+    }
+
+    fn enter_scope(&mut self) -> usize {
+        let parent = self.current_scope;
+        self.bindings.scopes.push(Scope {
+            names: HashSet::new(),
+            parent: Some(parent),
+        });
+        self.current_scope = self.bindings.scopes.len() - 1;
+
+        parent
+    }
+
+    const fn leave_scope(&mut self, parent: usize) {
+        self.current_scope = parent;
+    }
+
+    fn bind(&mut self, name: &str) {
+        self.bindings.scopes[self.current_scope]
+            .names
+            .insert(name.to_string());
+    }
+
+    fn bind_arguments(&mut self, arguments: &ast::Arguments) {
+        for argument in arguments
+            .posonlyargs
+            .iter()
+            .chain(&arguments.args)
+            .chain(&arguments.kwonlyargs)
+        {
+            self.bind(argument.def.arg.as_str());
+        }
+        if let Some(argument) = &arguments.vararg {
+            self.bind(argument.arg.as_str());
+        }
+        if let Some(argument) = &arguments.kwarg {
+            self.bind(argument.arg.as_str());
+        }
+    }
+
+    fn visit_function_outer(
+        &mut self,
+        arguments: &ast::Arguments,
+        decorators: &[ast::Expr],
+        returns: Option<&ast::Expr>,
+        type_params: &[ast::TypeParam],
+    ) {
+        self.visit_arguments(arguments.clone());
+        for decorator in decorators {
+            self.visit_expr(decorator.clone());
+        }
+        if let Some(returns) = returns {
+            self.visit_expr(returns.clone());
+        }
+        for type_param in type_params {
+            self.visit_type_param(type_param.clone());
+        }
+    }
+}
+
+impl Visitor for Collector {
+    fn visit_expr_call(&mut self, node: ast::ExprCall) {
+        self.bindings
+            .call_scopes
+            .insert(node.range.start(), self.current_scope);
+        self.generic_visit_expr_call(node);
+    }
+
+    fn visit_stmt_ann_assign(&mut self, node: ast::StmtAnnAssign) {
+        if let ast::Expr::Name(target) = node.target.as_ref() {
+            self.bind(target.id.as_str());
+        }
+        self.generic_visit_stmt_ann_assign(node);
+    }
+
+    fn visit_stmt_assign(&mut self, node: ast::StmtAssign) {
+        for target in &node.targets {
+            if let ast::Expr::Name(name) = target {
+                self.bind(name.id.as_str());
+            }
+        }
+        self.generic_visit_stmt_assign(node);
+    }
+
+    fn visit_stmt_async_function_def(&mut self, node: ast::StmtAsyncFunctionDef) {
+        self.bind(node.name.as_str());
+        self.visit_function_outer(
+            &node.args,
+            &node.decorator_list,
+            node.returns.as_deref(),
+            &node.type_params,
+        );
+        let parent = self.enter_scope();
+        self.bind_arguments(&node.args);
+        for statement in node.body {
+            self.visit_stmt(statement);
+        }
+        self.leave_scope(parent);
+    }
+
+    fn visit_stmt_class_def(&mut self, node: ast::StmtClassDef) {
+        self.bind(node.name.as_str());
+        for base in &node.bases {
+            self.visit_expr(base.clone());
+        }
+        for keyword in &node.keywords {
+            self.visit_keyword(keyword.clone());
+        }
+        for decorator in &node.decorator_list {
+            self.visit_expr(decorator.clone());
+        }
+        for type_param in &node.type_params {
+            self.visit_type_param(type_param.clone());
+        }
+        let parent = self.enter_scope();
+        for statement in node.body {
+            self.visit_stmt(statement);
+        }
+        self.leave_scope(parent);
+    }
+
+    fn visit_stmt_function_def(&mut self, node: ast::StmtFunctionDef) {
+        self.bind(node.name.as_str());
+        self.visit_function_outer(
+            &node.args,
+            &node.decorator_list,
+            node.returns.as_deref(),
+            &node.type_params,
+        );
+        let parent = self.enter_scope();
+        self.bind_arguments(&node.args);
+        for statement in node.body {
+            self.visit_stmt(statement);
+        }
+        self.leave_scope(parent);
+    }
+
+    fn visit_stmt_import(&mut self, node: ast::StmtImport) {
+        for alias in &node.names {
+            self.bind(import_bound_name(alias));
+        }
+        self.generic_visit_stmt_import(node);
+    }
+
+    fn visit_stmt_import_from(&mut self, node: ast::StmtImportFrom) {
+        for alias in &node.names {
+            if alias.name.as_str() == "*" {
+                continue;
+            }
+            self.bind(import_bound_name(alias));
+        }
+        self.generic_visit_stmt_import_from(node);
+    }
+}
+
+fn match_builtin_expr(
+    expression: &ast::Expr,
+    builtin: &str,
+    scope: usize,
+    bindings: &Bindings,
+) -> bool {
+    match expression {
+        ast::Expr::Name(name) => {
+            name.id.as_str() == builtin && bindings.is_unbound(name.id.as_str(), scope)
+        }
+        ast::Expr::Attribute(_) => bare_or_builtins_attr(expression, builtin),
+        _ => false,
+    }
+}
+
+fn bare_or_builtins_attr(expression: &ast::Expr, builtin: &str) -> bool {
+    match expression {
+        ast::Expr::Name(name) => name.id.as_str() == builtin,
+        ast::Expr::Attribute(attribute) => {
+            attribute.attr.as_str() == builtin
+                && matches!(
+                    attribute.value.as_ref(),
+                    ast::Expr::Name(name) if name.id.as_str() == "builtins"
+                )
+        }
+        _ => false,
+    }
+}
+
+fn import_bound_name(alias: &ast::Alias) -> &str {
+    if let Some(name) = &alias.asname {
+        return name.as_str();
+    }
+    alias.name.split('.').next().unwrap_or(alias.name.as_str())
+}
+
+#[cfg(test)]
+mod tests {
+    use rustpython_parser::Parse;
+    use rustpython_parser::ast::{self, Visitor};
+
+    use super::Bindings;
+
+    fn match_builtin(source: &str, builtin: &str) -> bool {
+        let module = ast::Suite::parse(source, "<test>").expect("parse");
+        let bindings = Bindings::from_module(&module);
+        let mut calls = Calls::default();
+        for statement in module {
+            calls.visit_stmt(statement);
+        }
+        bindings.match_builtin_expr(calls.items.last().expect("call"), builtin)
+    }
+
+    #[derive(Default)]
+    struct Calls {
+        items: Vec<ast::ExprCall>,
+    }
+
+    impl Visitor for Calls {
+        fn visit_expr_call(&mut self, node: ast::ExprCall) {
+            self.items.push(node.clone());
+            self.generic_visit_expr_call(node);
+        }
+    }
+
+    #[test]
+    fn unbound_isinstance_matches_builtin() {
+        assert!(match_builtin("isinstance(1, int)\n", "isinstance"));
+    }
+
+    #[test]
+    fn builtins_attr_matches_builtin() {
+        assert!(match_builtin("builtins.isinstance(1, int)\n", "isinstance"));
+    }
+
+    #[test]
+    fn shadowed_isinstance_does_not_match_builtin() {
+        assert!(!match_builtin(
+            "isinstance = check\nisinstance(1, int)\n",
+            "isinstance"
+        ));
+    }
+
+    #[test]
+    fn imported_isinstance_does_not_match_builtin() {
+        assert!(!match_builtin(
+            "from helpers import isinstance\nisinstance(1, int)\n",
+            "isinstance"
+        ));
+    }
+}

{echo_python-0.1.0 → echo_python-0.1.1}/src/check/source.rs

@@ -4,6 +4,7 @@ use anyhow::{Context, Result};
 use rustpython_parser::Parse;
 use rustpython_parser::ast::{self, Visitor};
 
+use crate::bindings::Bindings;
 use crate::checker::Checker;
 use crate::diagnostic::Diagnostic;
 use crate::locator::Locator;
@@ -21,8 +22,17 @@ pub fn check_source(path: &Path, source: &str, options: &CheckOptions) -> Result
     let locator = Locator::new(source);
     let noqa = NoqaIndex::from_source(source);
     let settings = settings::load_for_path(path, options);
+    let bindings = Bindings::from_module(&module);
     let mut diagnostics = Vec::new();
-    visit_module(path, &locator, &noqa, &settings, module, &mut diagnostics);
+    visit_module(
+        path,
+        &bindings,
+        &locator,
+        &noqa,
+        &settings,
+        module,
+        &mut diagnostics,
+    );
     Ok(diagnostics)
 }
 
@@ -33,6 +43,7 @@ fn parse_module(path: &Path, source: &str) -> Result<ast::Suite> {
 
 fn visit_module(
     path: &Path,
+    bindings: &Bindings,
     locator: &Locator,
     noqa: &NoqaIndex,
     settings: &Settings,
@@ -40,11 +51,12 @@ fn visit_module(
     diagnostics: &mut Vec<Diagnostic>,
 ) {
     let mut checker = Checker {
+        bindings,
+        diagnostics,
         locator,
         noqa,
         path,
         settings,
-        diagnostics,
     };
     for stmt in module {
         checker.visit_stmt(stmt);

{echo_python-0.1.0 → echo_python-0.1.1}/src/checker/mod.rs

@@ -1,14 +1,16 @@
 mod visit;
 
+use crate::bindings::Bindings;
 use crate::diagnostic::Diagnostic;
 use crate::locator::Locator;
 use crate::noqa::NoqaIndex;
 use crate::settings::Settings;
 
 pub(crate) struct Checker<'a> {
+    pub(crate) bindings: &'a Bindings,
+    pub(crate) diagnostics: &'a mut Vec<Diagnostic>,
     pub(crate) locator: &'a Locator,
     pub(crate) noqa: &'a NoqaIndex,
     pub(crate) path: &'a std::path::Path,
     pub(crate) settings: &'a Settings,
-    pub(crate) diagnostics: &'a mut Vec<Diagnostic>,
 }

{echo_python-0.1.0 → echo_python-0.1.1}/src/checker/visit.rs

@@ -1,14 +1,13 @@
 use rustpython_parser::ast::{self, Visitor};
 
 use super::Checker;
-use crate::RULE_CALLS_USE_KWARGS;
+use crate::RULE_ECHO001;
 use crate::RULE_MIXED_LIST_SORTED;
 use crate::RULE_NUMBERS_LIST_SORTED;
 use crate::RULE_PARAMS_ONE_PER_LINE;
 use crate::RULE_WORDS_LIST_SORTED;
 use crate::rules::{
-    calls_use_kwargs, mixed_list_sorted, numbers_list_sorted, params_one_per_line,
-    words_list_sorted,
+    echo001, mixed_list_sorted, numbers_list_sorted, params_one_per_line, words_list_sorted,
 };
 
 impl Visitor for Checker<'_> {
@@ -26,8 +25,9 @@ impl Visitor for Checker<'_> {
     }
 
     fn visit_expr_call(&mut self, node: ast::ExprCall) {
-        if self.settings.is_enabled(RULE_CALLS_USE_KWARGS) {
-            calls_use_kwargs::check(
+        if self.settings.is_enabled(RULE_ECHO001) {
+            echo001::check(
+                self.bindings,
                 self.locator,
                 self.noqa,
                 self.path,

{echo_python-0.1.0 → echo_python-0.1.1}/src/lib.rs

@@ -1,3 +1,4 @@
+mod bindings;
 mod check;
 mod checker;
 mod common;
@@ -11,7 +12,7 @@ pub use check::{CheckResult, check_path, check_paths, check_source};
 pub use diagnostic::Diagnostic;
 pub use settings::CheckOptions;
 
-pub const RULE_CALLS_USE_KWARGS: &str = "ECHO001";
+pub const RULE_ECHO001: &str = "ECHO001";
 pub const RULE_MIXED_LIST_SORTED: &str = "ECHO002";
 pub const RULE_NUMBERS_LIST_SORTED: &str = "ECHO003";
 pub const RULE_WORDS_LIST_SORTED: &str = "ECHO004";