Python
/
ruff
mirror of https://github.com/astral-sh/ruff
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Battling allocator

This commit is contained in:
Charlie Marsh 2022-09-03 11:01:59 -04:00
parent d7412af996
commit d8bb0632c5
3 changed files with 89 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
src/check_cst.rs
View File

@ -1,22 +1,11 @@
use std::borrow::Borrow; use std::borrow::Borrow;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::sync::Arc;
use bat::PrettyPrinter; use bat::PrettyPrinter;
use bumpalo::Bump; use bumpalo::Bump;
use libcst_native::{ use libcst_native::{
AnnAssign, Annotation, Arg, AsName, Assert, Assign, AssignEqual, AssignTarget, Arg, ClassDef, Codegen, Expression, FormattedStringContent, If, Module, SimpleString,
AssignTargetExpression, Asynchronous, Attribute, AugAssign, Await, BinaryOp, BinaryOperation,
BooleanOp, BooleanOperation, Break, Call, ClassDef, Codegen, CompFor, CompIf, CompOp,
Comparison, ComparisonTarget, CompoundStatement, ConcatenatedString, Continue, Decorator, Del,
DelTargetExpression, Dict, DictComp, DictElement, Element, Ellipsis, Else, ExceptHandler,
ExceptStarHandler, Expr, Expression, Finally, Float, For, FormattedString,
FormattedStringContent, FormattedStringExpression, FormattedStringText, FunctionDef,
GeneratorExp, Global, If, IfExp, Imaginary, Import, ImportAlias, ImportFrom, ImportStar,
IndentedBlock, Index, Integer, Lambda, List, ListComp, Match, Module, Name, NameItem,
NamedExpr, Nonlocal, OrElse, Param, ParamStar, Parameters, Pass, Raise, Return, Set, SetComp,
SimpleStatementLine, SimpleStatementSuite, SimpleString, Slice, SmallStatement,
StarredDictElement, StarredElement, Statement, Subscript, SubscriptElement, Try, TryStar,
Tuple, UnaryOp, UnaryOperation, While, With, WithItem, Yield, YieldValue,
}; };
use rustpython_parser::ast::Location; use rustpython_parser::ast::Location;
@ -56,44 +45,32 @@ struct Binding {
} }
struct Checker<'a> { struct Checker<'a> {
bump: Bump,
settings: &'a Settings, settings: &'a Settings,
checks: Vec<Check>, checks: Vec<Check>,
arena: Vec<String>,
} }
impl Checker<'_> { impl Checker<'_> {
pub fn new(settings: &Settings) -> Checker { pub fn new(settings: &Settings) -> Checker {
Checker { Checker {
bump: Bump::new(),
settings, settings,
checks: vec![], checks: vec![],
arena: vec![],
} }
} }
} }
impl CSTVisitor for Checker<'_> { const QUOTE: &str = "\"";
fn visit_If(&mut self, node: &If) {
if let Expression::Tuple { .. } = node.test {
self.checks.push(Check {
kind: CheckKind::IfTuple,
location: Default::default(),
});
}
cst_visitor::walk_If(self, node);
}
fn visit_Expression<'a, 'b>(&'b mut self, node: &'a Expression<'a>) -> Expression<'a> impl<'b> CSTVisitor for Checker<'_> {
where fn visit_Expression<'a>(&mut self, node: &'a Expression<'a>) -> Expression<'a> {
'b: 'a,
{
match node { match node {
Expression::FormattedString(node) => match &node.parts[..] { Expression::FormattedString(node) => match &node.parts[..] {
[node] => match node { [node] => match node {
FormattedStringContent::Text(node) => { FormattedStringContent::Text(node) => {
let x = node.value.to_string(); self.arena.push(format!("\"{}\"", node.value));
println!("Found: {:?}", node);
return Expression::SimpleString(Box::new(SimpleString { return Expression::SimpleString(Box::new(SimpleString {
value: self.bump.alloc(format!("\"{}\"", x)), value: node.value,
lpar: vec![], lpar: vec![],
rpar: vec![], rpar: vec![],
})); }));
@ -133,6 +110,16 @@ impl CSTVisitor for Checker<'_> {
transformed.bases = bases; transformed.bases = bases;
transformed transformed
} }
fn visit_If(&mut self, node: &If) {
if let Expression::Tuple { .. } = node.test {
self.checks.push(Check {
kind: CheckKind::IfTuple,
location: Default::default(),
});
}
cst_visitor::walk_If(self, node);
}
} }
pub fn check_cst<'a>(python_cst: &'a Module<'a>, settings: &Settings) -> Vec<Check> { pub fn check_cst<'a>(python_cst: &'a Module<'a>, settings: &Settings) -> Vec<Check> {

163
src/cst_visitor.rs
View File

@ -1,5 +1,6 @@
#![allow(non_snake_case)] #![allow(non_snake_case)]
use bumpalo::Bump;
use libcst_native::{ use libcst_native::{
AnnAssign, Annotation, Arg, AsName, Assert, Assign, AssignEqual, AssignTarget, AnnAssign, Annotation, Arg, AsName, Assert, Assign, AssignEqual, AssignTarget,
AssignTargetExpression, Asynchronous, Attribute, AugAssign, Await, BaseSlice, BinaryOp, AssignTargetExpression, Asynchronous, Attribute, AugAssign, Await, BaseSlice, BinaryOp,
@ -18,55 +19,31 @@ use libcst_native::{
}; };
pub trait CSTVisitor { pub trait CSTVisitor {
fn visit_Module<'a, 'b>(&'b mut self, node: &'a Module<'a>) -> Module<'a> fn visit_Module<'a>(&mut self, node: &'a Module<'a>) -> Module<'a> {
where
'b: 'a,
{
walk_Module(self, node) walk_Module(self, node)
} }
fn visit_Statement<'a, 'b>(&'b mut self, node: &'a Statement<'a>) -> Option<Statement<'a>> fn visit_Statement<'a>(&mut self, node: &'a Statement<'a>) -> Option<Statement<'a>> {
where
'b: 'a,
{
walk_Statement(self, node) walk_Statement(self, node)
} }
fn visit_SimpleStatementLine<'a, 'b>( fn visit_SimpleStatementLine<'a>(
&'b mut self, &mut self,
node: &'a SimpleStatementLine<'a>, node: &'a SimpleStatementLine<'a>,
) -> Option<SimpleStatementLine<'a>> ) -> Option<SimpleStatementLine<'a>> {
where
'b: 'a,
{
walk_SimpleStatementLine(self, node) walk_SimpleStatementLine(self, node)
} }
fn visit_CompoundStatement<'a, 'b>( fn visit_CompoundStatement<'a>(
&'b mut self, &mut self,
node: &'a CompoundStatement<'a>, node: &'a CompoundStatement<'a>,
) -> Option<CompoundStatement<'a>> ) -> Option<CompoundStatement<'a>> {
where
'b: 'a,
{
walk_CompoundStatement(self, node) walk_CompoundStatement(self, node)
} }
fn visit_SmallStatement<'a, 'b>( fn visit_SmallStatement<'a>(&mut self, node: &'a SmallStatement<'a>) -> SmallStatement<'a> {
&'b mut self,
node: &'a SmallStatement<'a>,
) -> SmallStatement<'a>
where
'b: 'a,
{
walk_SmallStatement(self, node) walk_SmallStatement(self, node)
} }
fn visit_Expression<'a, 'b>(&'b mut self, node: &'a Expression<'a>) -> Expression<'a> fn visit_Expression<'a>(&mut self, node: &'a Expression<'a>) -> Expression<'a> {
where
'b: 'a,
{
walk_Expression(self, node) walk_Expression(self, node)
} }
fn visit_AnnAssign<'a, 'b>(&'b mut self, node: &'a AnnAssign<'a>) -> AnnAssign<'a> fn visit_AnnAssign<'a>(&mut self, node: &'a AnnAssign<'a>) -> AnnAssign<'a> {
where
'b: 'a,
{
walk_AnnAssign(self, node) walk_AnnAssign(self, node)
} }
fn visit_Annotation(&mut self, node: &Annotation) { fn visit_Annotation(&mut self, node: &Annotation) {
@ -105,20 +82,11 @@ pub trait CSTVisitor {
fn visit_Await(&mut self, node: &Await) { fn visit_Await(&mut self, node: &Await) {
walk_Await(self, node); walk_Await(self, node);
} }
fn visit_BinaryOperation<'a, 'b>( fn visit_BinaryOperation<'a>(&mut self, node: &'a BinaryOperation<'a>) -> BinaryOperation<'a> {
&'b mut self,
node: &'a BinaryOperation<'a>,
) -> BinaryOperation<'a>
where
'b: 'a,
{
walk_BinaryOperation(self, node) walk_BinaryOperation(self, node)
} }
fn visit_BinaryOp<'a, 'b>(&'b mut self, node: &'a BinaryOp<'a>) -> BinaryOp<'a> fn visit_BinaryOp(&mut self, node: &BinaryOp) {
where walk_BinaryOp(self, node);
'b: 'a,
{
walk_BinaryOp(self, node)
} }
fn visit_BooleanOperation(&mut self, node: &BooleanOperation) { fn visit_BooleanOperation(&mut self, node: &BooleanOperation) {
walk_BooleanOperation(self, node); walk_BooleanOperation(self, node);
@ -374,14 +342,11 @@ pub trait CSTVisitor {
} }
} }
pub fn walk_Module<'a, 'b, V: CSTVisitor + ?Sized>( pub fn walk_Module<'a, V: CSTVisitor + ?Sized>(
visitor: &'b mut V, visitor: &mut V,
node: &'a Module<'a>, node: &'a Module<'a>,
) -> Module<'a> ) -> Module<'a> {
where let mut body: Vec<Statement> = vec![];
'b: 'a,
{
let mut body: Vec<Statement<'a>> = vec![];
for node in &node.body { for node in &node.body {
if let Some(node) = visitor.visit_Statement(node) { if let Some(node) = visitor.visit_Statement(node) {
body.push(node) body.push(node)
@ -392,13 +357,10 @@ where
transformed.body = body; transformed.body = body;
transformed transformed
} }
pub fn walk_Statement<'a, 'b, V: CSTVisitor + ?Sized>( pub fn walk_Statement<'a, V: CSTVisitor + ?Sized>(
visitor: &'b mut V, visitor: &mut V,
node: &'a Statement<'a>, node: &'a Statement<'a>,
) -> Option<Statement<'a>> ) -> Option<Statement<'a>> {
where
'b: 'a,
{
match node { match node {
Statement::Simple(node) => visitor Statement::Simple(node) => visitor
.visit_SimpleStatementLine(node) .visit_SimpleStatementLine(node)
@ -408,14 +370,11 @@ where
.map(Statement::Compound), .map(Statement::Compound),
} }
} }
pub fn walk_SimpleStatementLine<'a, 'b, V: CSTVisitor + ?Sized>( pub fn walk_SimpleStatementLine<'a, V: CSTVisitor + ?Sized>(
visitor: &'b mut V, visitor: &mut V,
node: &'a SimpleStatementLine<'a>, node: &'a SimpleStatementLine<'a>,
) -> Option<SimpleStatementLine<'a>> ) -> Option<SimpleStatementLine<'a>> {
where // println!("{:?}", node);
'b: 'a,
{
println!("{:?}", node);
let mut body: Vec<SmallStatement> = vec![]; let mut body: Vec<SmallStatement> = vec![];
for node in &node.body { for node in &node.body {
body.push(visitor.visit_SmallStatement(node).clone()); body.push(visitor.visit_SmallStatement(node).clone());
@ -424,13 +383,10 @@ where
transformed.body = body; transformed.body = body;
Some(transformed) Some(transformed)
} }
pub fn walk_CompoundStatement<'a, 'b, V: CSTVisitor + ?Sized>( pub fn walk_CompoundStatement<'a, V: CSTVisitor + ?Sized>(
visitor: &'b mut V, visitor: &mut V,
node: &'a CompoundStatement<'a>, node: &'a CompoundStatement<'a>,
) -> Option<CompoundStatement<'a>> ) -> Option<CompoundStatement<'a>> {
where
'b: 'a,
{
match node { match node {
CompoundStatement::If(node) => { CompoundStatement::If(node) => {
visitor.visit_If(node); visitor.visit_If(node);
@ -450,13 +406,7 @@ where
Some(node.clone()) Some(node.clone())
} }
pub fn walk_SmallStatement<'a, 'b, V: CSTVisitor + ?Sized>( pub fn walk_SmallStatement<'a, V: CSTVisitor + ?Sized>(visitor: &mut V, node: &'a SmallStatement<'a>) -> SmallStatement<'a> {
visitor: &'b mut V,
node: &'a SmallStatement<'a>,
) -> SmallStatement<'a>
where
'b: 'a,
{
match node { match node {
SmallStatement::Pass(node) => visitor.visit_Pass(node), SmallStatement::Pass(node) => visitor.visit_Pass(node),
SmallStatement::Break(node) => visitor.visit_Break(node), SmallStatement::Break(node) => visitor.visit_Break(node),
@ -467,9 +417,7 @@ where
SmallStatement::Import(node) => visitor.visit_Import(node), SmallStatement::Import(node) => visitor.visit_Import(node),
SmallStatement::ImportFrom(node) => visitor.visit_ImportFrom(node), SmallStatement::ImportFrom(node) => visitor.visit_ImportFrom(node),
SmallStatement::Assign(node) => visitor.visit_Assign(node), SmallStatement::Assign(node) => visitor.visit_Assign(node),
SmallStatement::AnnAssign(node) => { SmallStatement::AnnAssign(node) => { return SmallStatement::AnnAssign(visitor.visit_AnnAssign(node)); },
return SmallStatement::AnnAssign(visitor.visit_AnnAssign(node));
}
SmallStatement::Raise(node) => visitor.visit_Raise(node), SmallStatement::Raise(node) => visitor.visit_Raise(node),
SmallStatement::Global(node) => visitor.visit_Global(node), SmallStatement::Global(node) => visitor.visit_Global(node),
SmallStatement::Nonlocal(node) => visitor.visit_Nonlocal(node), SmallStatement::Nonlocal(node) => visitor.visit_Nonlocal(node),
@ -479,8 +427,8 @@ where
node.clone() node.clone()
} }
pub fn walk_Expression<'a, 'b, V: CSTVisitor + ?Sized>( pub fn walk_Expression<'a, V: CSTVisitor + ?Sized>(
visitor: &'b mut V, visitor: &mut V,
node: &'a Expression<'a>, node: &'a Expression<'a>,
) -> Expression<'a> { ) -> Expression<'a> {
match node { match node {
@ -491,9 +439,7 @@ pub fn walk_Expression<'a, 'b, V: CSTVisitor + ?Sized>(
Expression::Imaginary(node) => visitor.visit_Imaginary(node), Expression::Imaginary(node) => visitor.visit_Imaginary(node),
Expression::Comparison(node) => visitor.visit_Comparison(node), Expression::Comparison(node) => visitor.visit_Comparison(node),
Expression::UnaryOperation(node) => visitor.visit_UnaryOperation(node), Expression::UnaryOperation(node) => visitor.visit_UnaryOperation(node),
Expression::BinaryOperation(node) => { Expression::BinaryOperation(node) => return Expression::BinaryOperation(Box::new(visitor.visit_BinaryOperation(node))),
return Expression::BinaryOperation(Box::new(visitor.visit_BinaryOperation(node)))
}
Expression::BooleanOperation(node) => visitor.visit_BooleanOperation(node), Expression::BooleanOperation(node) => visitor.visit_BooleanOperation(node),
Expression::Attribute(node) => visitor.visit_Attribute(node), Expression::Attribute(node) => visitor.visit_Attribute(node),
Expression::Tuple(node) => visitor.visit_Tuple(node), Expression::Tuple(node) => visitor.visit_Tuple(node),
@ -538,20 +484,14 @@ pub fn walk_AssignTargetExpression<V: CSTVisitor + ?Sized>(
AssignTargetExpression::Subscript(node) => visitor.visit_Subscript(node), AssignTargetExpression::Subscript(node) => visitor.visit_Subscript(node),
} }
} }
pub fn walk_AnnAssign<'a, 'b, V: CSTVisitor + ?Sized>( pub fn walk_AnnAssign<'a, V: CSTVisitor + ?Sized>(visitor: &mut V, node: &'a AnnAssign<'a>) -> AnnAssign<'a> {
visitor: &'b mut V, // println!("walk_AnnAssign");
node: &'a AnnAssign<'a>,
) -> AnnAssign<'a>
where
'b: 'a,
{
println!("walk_AnnAssign");
let mut transformed: AnnAssign<'a> = node.clone(); let mut transformed: AnnAssign<'a> = node.clone();
visitor.visit_AssignTargetExpression(&node.target); visitor.visit_AssignTargetExpression(&node.target);
if let Some(node) = &node.value { if let Some(node) = &node.value {
println!("Before: {:?}", node); // println!("Before: {:?}", node);
transformed.value = Some(visitor.visit_Expression(node)); transformed.value = Some(visitor.visit_Expression(node));
println!("After: {:?}", transformed.value); // println!("After: {:?}", transformed.value);
} }
transformed transformed
} }
@ -595,13 +535,7 @@ pub fn walk_AugAssign<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &AugAssign)
pub fn walk_Await<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &Await) { pub fn walk_Await<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &Await) {
visitor.visit_Expression(&node.expression); visitor.visit_Expression(&node.expression);
} }
pub fn walk_BinaryOperation<'a, 'b, V: CSTVisitor + ?Sized>( pub fn walk_BinaryOperation<'a, V: CSTVisitor + ?Sized>(visitor: &mut V, node: &'a BinaryOperation<'a>) -> BinaryOperation<'a> {
visitor: &'b mut V,
node: &'a BinaryOperation<'a>,
) -> BinaryOperation<'a>
where
'b: 'a,
{
let mut transformed: BinaryOperation = node.clone(); let mut transformed: BinaryOperation = node.clone();
transformed.left = Box::new(visitor.visit_Expression(&node.left)); transformed.left = Box::new(visitor.visit_Expression(&node.left));
@ -610,9 +544,8 @@ where
transformed transformed
} }
pub fn walk_BinaryOp<'a, 'b, V: CSTVisitor + ?Sized>(visitor: &'b mut V, node: &'a BinaryOp<'a>) -> BinaryOp<'a> { pub fn walk_BinaryOp<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &BinaryOp) {
// Nothing to do. // Nothing to do.
node.clone()
} }
pub fn walk_BooleanOperation<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &BooleanOperation) { pub fn walk_BooleanOperation<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &BooleanOperation) {
visitor.visit_Expression(&node.left); visitor.visit_Expression(&node.left);
@ -726,12 +659,8 @@ pub fn walk_DictElement<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &DictElem
} }
pub fn walk_Element<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &Element) { pub fn walk_Element<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &Element) {
match node { match node {
Element::Simple { value: node, .. } => { Element::Simple { value: node, .. } => { visitor.visit_Expression(node); },
visitor.visit_Expression(node); Element::Starred(node) => { visitor.visit_StarredElement(node); },
}
Element::Starred(node) => {
visitor.visit_StarredElement(node);
}
}; };
} }
pub fn walk_Ellipsis<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &Ellipsis) { pub fn walk_Ellipsis<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &Ellipsis) {
@ -1104,11 +1033,7 @@ pub fn walk_Yield<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &Yield) {
} }
pub fn walk_YieldValue<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &YieldValue) { pub fn walk_YieldValue<V: CSTVisitor + ?Sized>(visitor: &mut V, node: &YieldValue) {
match node { match node {
YieldValue::Expression(node) => { YieldValue::Expression(node) => { visitor.visit_Expression(node); }
visitor.visit_Expression(node); YieldValue::From(node) => { visitor.visit_From(node); }
}
YieldValue::From(node) => {
visitor.visit_From(node);
}
}; };
} }

48
src/linter.rs
View File

@ -10,11 +10,11 @@ use crate::settings::Settings;
use crate::{cache, fs}; use crate::{cache, fs};
pub fn check_path(path: &Path, settings: &Settings, mode: &cache::Mode) -> Result<Vec<Message>> { pub fn check_path(path: &Path, settings: &Settings, mode: &cache::Mode) -> Result<Vec<Message>> {
// Check the cache. // // Check the cache.
if let Some(messages) = cache::get(path, settings, mode) { // if let Some(messages) = cache::get(path, settings, mode) {
debug!("Cache hit for: {}", path.to_string_lossy()); // debug!("Cache hit for: {}", path.to_string_lossy());
return Ok(messages); // return Ok(messages);
} // }
// Read the file from disk. // Read the file from disk.
let contents = fs::read_file(path)?; let contents = fs::read_file(path)?;
@ -23,11 +23,15 @@ pub fn check_path(path: &Path, settings: &Settings, mode: &cache::Mode) -> Resul
let mut checks: Vec<Check> = vec![]; let mut checks: Vec<Check> = vec![];
// Run the CST-based checks. // Run the CST-based checks.
let python_cst = match libcst_native::parse_module(&contents, None) { let _ = match libcst_native::parse_module(&contents, None) {
Ok(m) => m, Ok(m) => m,
Err(e) => panic!("Failed to parse CST."), Err(e) => {
return Err(anyhow::anyhow!("Failed to parse"));
}
}; };
checks.extend(check_cst(&python_cst, settings));
Ok(vec![])
// checks.extend(check_cst(&python_cst, settings));
// // Run the AST-based checks. // // Run the AST-based checks.
// if settings // if settings
@ -42,20 +46,20 @@ pub fn check_path(path: &Path, settings: &Settings, mode: &cache::Mode) -> Resul
// //
// // Run the lines-based checks. // // Run the lines-based checks.
// check_lines(&mut checks, &contents, settings); // check_lines(&mut checks, &contents, settings);
//
// Convert to messages. // // Convert to messages.
let messages: Vec<Message> = checks // let messages: Vec<Message> = checks
.into_iter() // .into_iter()
.map(|check| Message { // .map(|check| Message {
kind: check.kind, // kind: check.kind,
location: check.location, // location: check.location,
filename: path.to_string_lossy().to_string(), // filename: path.to_string_lossy().to_string(),
}) // })
.collect(); // .collect();
//
cache::set(path, settings, &messages, mode); // cache::set(path, settings, &messages, mode);
//
Ok(messages) // Ok(messages)
} }
#[cfg(test)] #[cfg(test)]