in_finally: bool,

in_funcdef: bool,

in_loop: bool,

contexts: &[ControlFlowInFinallyContext],

range: TextRange,

warn: &mut impl FnMut(TextRange, String) -> Result<(), E>,

) -> Result<(), E> {

if let Some(ctx) = contexts.last()

&& ctx.in_finally

&& !ctx.in_funcdef

{

warn(range, "'return' in a 'finally' block".to_owned())?;

}

Ok(())

contexts: &[ControlFlowInFinallyContext],

range: TextRange,

kw: &str,

warn: &mut impl FnMut(TextRange, String) -> Result<(), E>,

) -> Result<(), E> {

if let Some(ctx) = contexts.last()

&& ctx.in_finally

&& !ctx.in_loop

{

warn(range, format!("'{kw}' in a 'finally' block"))?;

}

Ok(())

body: &[ast::Stmt],

contexts: &mut Vec<ControlFlowInFinallyContext>,

warn: &mut impl FnMut(TextRange, String) -> Result<(), E>,

in_finally: bool,

in_funcdef: bool,

in_loop: bool,

) -> Result<(), E> {

contexts.push(ControlFlowInFinallyContext {

in_finally,

in_funcdef,

in_loop,

});

visit_body_for_control_flow_in_finally(body, contexts, warn)?;

contexts.pop();

Ok(())

body: &[ast::Stmt],

contexts: &mut Vec<ControlFlowInFinallyContext>,

warn: &mut impl FnMut(TextRange, String) -> Result<(), E>,

) -> Result<(), E> {

for stmt in body {

visit_stmt_for_control_flow_in_finally(stmt, contexts, warn)?;

}

Ok(())

stmt: &ast::Stmt,

contexts: &mut Vec<ControlFlowInFinallyContext>,

warn: &mut impl FnMut(TextRange, String) -> Result<(), E>,

) -> Result<(), E> {

match stmt {

ast::Stmt::FunctionDef(function) => {

visit_body_with_control_flow_context(

&function.body,

contexts,

warn,

false,

true,

false,

)?;

}

ast::Stmt::ClassDef(class) => {

visit_body_for_control_flow_in_finally(&class.body, contexts, warn)?;

}

ast::Stmt::Return(return_stmt) => {

before_return(contexts, return_stmt.range, warn)?;

}

ast::Stmt::For(for_stmt) => {

visit_body_with_control_flow_context(

&for_stmt.body,

contexts,

warn,

false,

false,

true,

)?;

visit_body_for_control_flow_in_finally(&for_stmt.orelse, contexts, warn)?;

}

ast::Stmt::While(while_stmt) => {

visit_body_with_control_flow_context(

&while_stmt.body,

contexts,

warn,

false,

false,

true,

)?;

visit_body_for_control_flow_in_finally(&while_stmt.orelse, contexts, warn)?;

}

ast::Stmt::If(if_stmt) => {

visit_body_for_control_flow_in_finally(&if_stmt.body, contexts, warn)?;

for clause in &if_stmt.elif_else_clauses {

visit_body_for_control_flow_in_finally(&clause.body, contexts, warn)?;

}

}

ast::Stmt::Try(try_stmt) => {

visit_body_for_control_flow_in_finally(&try_stmt.body, contexts, warn)?;

for handler in &try_stmt.handlers {

match handler {

ast::ExceptHandler::ExceptHandler(handler) => {

visit_body_for_control_flow_in_finally(&handler.body, contexts, warn)?;

}

}

}

visit_body_for_control_flow_in_finally(&try_stmt.orelse, contexts, warn)?;

visit_body_with_control_flow_context(

&try_stmt.finalbody,

contexts,

warn,

true,

false,

false,

)?;

}

ast::Stmt::With(with_stmt) => {

visit_body_for_control_flow_in_finally(&with_stmt.body, contexts, warn)?;

}

ast::Stmt::Match(match_stmt) => {

for case in &match_stmt.cases {

visit_body_for_control_flow_in_finally(&case.body, contexts, warn)?;

}

}

ast::Stmt::Break(break_stmt) => {

before_loop_exit(contexts, break_stmt.range, "break", warn)?;

}

ast::Stmt::Continue(continue_stmt) => {

before_loop_exit(contexts, continue_stmt.range, "continue", warn)?;

}

_ => {}

}

Ok(())

module: &ast::Mod,

mut warn: impl FnMut(TextRange, String) -> Result<(), E>,

) -> Result<(), E> {

let mut contexts = Vec::new();

match module {

ast::Mod::Module(module) => {

visit_body_for_control_flow_in_finally(&module.body, &mut contexts, &mut warn)?;

}

ast::Mod::Expression(_) => {}

}

Ok(())

pub features: bytecode::CodeFlags,

pub range: TextRange,

pub kind: FutureFeatureErrorKind,

module: &ast::Mod,

) -> Result<bytecode::CodeFlags, FutureFeatureError> {

let ast::Mod::Module(module) = module else {

return Ok(bytecode::CodeFlags::empty());

};

checked_future_features_in_body(&module.body)

body: &[ast::Stmt],

) -> Result<bytecode::CodeFlags, FutureFeatureError> {

let mut future_features = bytecode::CodeFlags::empty();

let mut statements = body.iter();

if let Some(ast::Stmt::Expr(ast::StmtExpr { value, .. })) = statements.clone().next()

&& string_literal_expr_value(value).is_some()

{

statements.next();

}

for statement in statements {

match statement {

ast::Stmt::ImportFrom(ast::StmtImportFrom {

module,

names,

level,

..

}) if *level == 0 && module.as_ref().map(|id| id.as_str()) == Some("__future__") => {

for alias in names {

let future_feature =

alias

.name

.as_str()

.try_into()

.map_err(|name| FutureFeatureError {

features: future_features,

range: alias.range,

kind: FutureFeatureErrorKind::InvalidFeature(name),

})?;

match future_feature {

FutureFeature::Braces => {

return Err(FutureFeatureError {

features: future_features,

range: alias.range,

kind: FutureFeatureErrorKind::InvalidBraces,

});

}

FutureFeature::Annotations => {

future_features.insert(bytecode::CodeFlags::FUTURE_ANNOTATIONS)

}

FutureFeature::BarryAsFLUFL => {

future_features.insert(bytecode::CodeFlags::FUTURE_BARRY_AS_BDFL)

}

FutureFeature::AbsoluteImport

| FutureFeature::Division

| FutureFeature::GeneratorStop

| FutureFeature::Generators

| FutureFeature::NestedScopes

| FutureFeature::PrintFunction

| FutureFeature::UnicodeLiterals

| FutureFeature::WithStatement => {

// Python 3 features. They are already implemented by default.

}

}

}

}

_ => return Ok(future_features),

}

}

Ok(future_features)

body: &mut [ast::Stmt],

optimize: u8,

future_annotations: bool,

syntax_check_only: bool,

) {

let preprocessor = AstPreprocessor {

optimize,

future_annotations,

constant_folding: !syntax_check_only,

locations: None,

location_error: None,

};

for stmt in body {

preprocessor.visit_stmt(stmt);

}

module: &mut ast::Mod,

optimize: u8,

future_annotations: bool,

syntax_check_only: bool,

) {

let preprocessor = AstPreprocessor {

optimize,

future_annotations,

constant_folding: !syntax_check_only,

locations: None,

location_error: None,

};

match module {

ast::Mod::Module(module) => preprocessor.visit_astfold_body(&mut module.body),

ast::Mod::Expression(expr) => preprocessor.visit_expr(&mut expr.body),

}

module: &mut ast::Mod,

optimize: u8,

future_annotations: bool,

syntax_check_only: bool,

locations: &mut AstLocations,

) -> Result<(), AstLocationError> {

let table = RefCell::new(core::mem::take(locations));

let error = Cell::new(None);

let preprocessor = AstPreprocessor {

optimize,

future_annotations,

constant_folding: !syntax_check_only,

locations: Some(&table),

location_error: Some(&error),

};

match module {

ast::Mod::Module(module) => preprocessor.visit_astfold_body(&mut module.body),

ast::Mod::Expression(expr) => preprocessor.visit_expr(&mut expr.body),

}

*locations = table.into_inner();

error.get().map_or(Ok(()), Err)

body: &mut [ast::Stmt],

optimize: u8,

future_annotations: bool,

syntax_check_only: bool,

locations: &mut AstLocations,

) -> Result<(), AstLocationError> {

let table = RefCell::new(core::mem::take(locations));

let error = Cell::new(None);

let preprocessor = AstPreprocessor {

optimize,

future_annotations,

constant_folding: !syntax_check_only,

locations: Some(&table),

location_error: Some(&error),

};

for stmt in body {

preprocessor.visit_stmt(stmt);

}

*locations = table.into_inner();

error.get().map_or(Ok(()), Err)

optimize: u8,

future_annotations: bool,

constant_folding: bool,

locations: Option<&'a RefCell<AstLocations>>,

location_error: Option<&'a Cell<Option<AstLocationError>>>,

fn record_location_error(&self, error: AstLocationError) {

if let Some(slot) = self.location_error

&& slot.get().is_none()

{

slot.set(Some(error));

}

}

fn location(&self, node: &impl HasNodeIndex) -> Option<SourceLocationRange> {

self.locations?

.borrow()

.get(node.node_index().load().as_u32()?)

}

fn fresh_location(&self, location: SourceLocationRange) -> AtomicNodeIndex {

let index = AtomicNodeIndex::NONE;

if let Some(locations) = self.locations {

match locations.borrow_mut().allocate(Some(location)) {

Ok(id) => index.set(ast::NodeIndex::from(id)),

Err(error) => self.record_location_error(error),

}

}

index

}

fn artificial_elements(&self, elements: &mut InterpolatedStringElements) {

if self.locations.is_none() {

return;

}

let artificial = SourceLocationRange {

line: -1,

end_line: -1,

col: -1,

end_col: -1,

};

for element in elements.iter_mut() {

match element {

InterpolatedStringElement::Literal(literal) => {

if literal.node_index.load().as_u32().is_none() {

literal.node_index = self.fresh_location(artificial);

}

}

InterpolatedStringElement::Interpolation(value) => {

if let Some(spec) = &mut value.format_spec {

if spec.node_index.load().as_u32().is_none() {

spec.node_index = self.fresh_location(artificial);

}

self.artificial_elements(&mut spec.elements);

// This visitor only runs on the result of optimize_format.

// final ast_preprocess.c constructs a Constant format spec,

// not a JoinedStr. Preserve that explicit shape in the

// existing runtime AST field rather than inferring it

// from the artificial coordinates during serialization.

if let [InterpolatedStringElement::Literal(literal)] = &spec.elements[..] {

value.runtime_formatted_value_format_spec =

Some(Box::new(Expr::Constant(ast::ExprConstant {

node_index: spec.node_index.clone(),

range: spec.range,

value: ast::ConstantValue::Str(literal.value.clone()),

kind: None,

invalid_type: None,

})));

}

}

}

}

}

}

fn visit_astfold_body(self, body: &mut ast::Suite) {

let mut docstring = body_starts_with_docstring(body);

if docstring && self.optimize >= 2 {

remove_docstring_from_body(body, &self);

docstring = false;

}

for stmt in body.iter_mut() {

self.visit_stmt(stmt);

}

if !docstring && body_starts_with_docstring(body) {

wrap_first_docstring_as_fstring(body, self.locations.is_some());

}

}

fn visit_stmt(&self, stmt: &mut ast::Stmt) {

match stmt {

ast::Stmt::FunctionDef(function) => {

if let Some(type_params) = &mut function.type_params {

self.visit_type_params(type_params);

}

self.visit_parameters(&mut function.parameters);

self.visit_astfold_body(&mut function.body);

for decorator in &mut function.decorator_list {

self.visit_decorator(decorator);

}

if let Some(returns) = &mut function.returns {

self.visit_annotation(returns);

}

}

ast::Stmt::ClassDef(class) => {

if let Some(type_params) = &mut class.type_params {

self.visit_type_params(type_params);

}

if let Some(arguments) = &mut class.arguments {

self.visit_arguments(arguments);

}

self.visit_astfold_body(&mut class.body);

for decorator in &mut class.decorator_list {

self.visit_decorator(decorator);

}

}

_ => transformer::walk_stmt(self, stmt),

}

}

fn visit_annotation(&self, expr: &mut Expr) {

if !self.future_annotations {

transformer::walk_annotation(self, expr);

}

}

fn visit_pattern(&self, pattern: &mut ast::Pattern) {

transformer::walk_pattern(self, pattern);

if !self.constant_folding {

return;

}

match pattern {

ast::Pattern::MatchValue(value) => fold_match_value_constant_expr(&mut value.value),

ast::Pattern::MatchMapping(mapping) => {

for key in &mut mapping.keys {

fold_match_value_constant_expr(key);

}

}

_ => {}

}

}

fn visit_expr(&self, expr: &mut Expr) {

transformer::walk_expr(self, expr);

widen_implicit_call_generator_range(expr);

if self.constant_folding {

if let Some(mut optimized) = optimize_format(expr) {

if let Expr::FString(fstring) = &mut optimized {

for part in &mut fstring.value {

if let ast::FStringPartMut::FString(part) = part {

self.artificial_elements(&mut part.elements);

}

}

}

*expr = optimized;

} else if let Some(optimized) = fold_debug_constant(expr, self.optimize) {

*expr = optimized;

}

}

}

let Expr::Call(call) = expr else {

return;

};

let [Expr::Generator(generator)] = &mut *call.arguments.args else {

return;

};

if !generator.parenthesized {

generator.range = call.arguments.range;

}

let Expr::Name(name) = expr else {

return None;

};

if !matches!(name.ctx, ast::ExprContext::Load) || name.id.as_str() != "__debug__" {

return None;

}

Some(Expr::BooleanLiteral(ast::ExprBooleanLiteral {

node_index: name.node_index.clone(),

range: name.range,

value: optimize == 0,

}))

let Expr::BinOp(binop) = expr else {

return None;

};

if !matches!(binop.op, Operator::Mod) {

return None;

}

let (format, _) = string_literal_expr_value(&binop.left)?;

let Expr::Tuple(tuple) = binop.right.as_ref() else {

return None;

};

if tuple

.elts

.iter()

.any(|expr| matches!(expr, Expr::Starred(_)))

{

return None;

}

let elements = parse_format(format, &tuple.elts)?;

Some(Expr::FString(ExprFString {

node_index: binop.node_index.clone(),

range: binop.range,

value: FStringValue::single(FString {

range: binop.range,

node_index: binop.node_index.clone(),

elements: InterpolatedStringElements::from(elements),

flags: FStringFlags::empty(),

}),

runtime_joined_str: None,

runtime_values: None,

}))

let chars: Vec<char> = format.chars().collect();

let mut elements = Vec::with_capacity(args.len().saturating_mul(2).saturating_add(1));

let mut pos = 0;

let mut arg_idx = 0;

loop {

if let Some(literal) = parse_literal(&chars, &mut pos) {

elements.push(literal.into());

}

if pos >= chars.len() {

break;

}

if arg_idx >= args.len() {

return None;

}

debug_assert_eq!(chars[pos], '%');

pos += 1;

let formatted = parse_format_arg(&chars, &mut pos, args[arg_idx].clone())?;

elements.push(formatted.into());

arg_idx += 1;

}

(arg_idx == args.len()).then_some(elements)

let start = *pos;

let mut has_percents = false;

while *pos < chars.len() {

if chars[*pos] != '%' {

*pos += 1;

} else if *pos + 1 < chars.len() && chars[*pos + 1] == '%' {

has_percents = true;

*pos += 2;

} else {

break;

}

}

if *pos == start {

return None;

}

let mut value = String::new();

let mut i = start;

while i < *pos {

if has_percents && chars[i] == '%' && i + 1 < *pos && chars[i + 1] == '%' {

value.push('%');

i += 2;

} else {

value.push(chars[i]);

i += 1;

}

}

Some(generated_literal(value))

let (spec, flags, width, precision) = simple_format_arg_parse(chars, pos)?;

let conversion = match spec {

's' => ConversionFlag::Str,

'r' => ConversionFlag::Repr,

'a' => ConversionFlag::Ascii,

_ => return None,

};

let mut format_spec = String::new();

if flags & F_LJUST == 0

&& let Some(width) = width

&& width > 0

{

format_spec.push('>');

}

if let Some(width) = width {

format_spec.push_str(&width.to_string());

}

if let Some(precision) = precision {

format_spec.push('.');

format_spec.push_str(&precision.to_string());

}

let range = arg.range();

let format_spec = (!format_spec.is_empty()).then(|| {

Box::new(InterpolatedStringFormatSpec {

range: TextRange::default(),

node_index: AtomicNodeIndex::NONE,

elements: InterpolatedStringElements::from(vec![generated_literal(format_spec).into()]),

})

});

Some(InterpolatedElement {

range,

node_index: arg.node_index().clone(),

expression: Box::new(arg),

debug_text: None,

conversion,

format_spec,

runtime_str: None,

runtime_interpolation_format_spec: None,

runtime_formatted_value_format_spec: None,

})

chars: &[char],

pos: &mut usize,

) -> Option<(char, u8, Option<u16>, Option<u16>)> {

let mut flags = 0;

let mut ch = next_char(chars, pos)?;

loop {

match ch {

'-' => flags |= F_LJUST,

'+' | ' ' | '#' | '0' => {}

_ => break,

}

ch = next_char(chars, pos)?;

}

let width = parse_digits(chars, pos, &mut ch)?;

let precision = if ch == '.' {

ch = next_char(chars, pos)?;

Some(parse_digits(chars, pos, &mut ch)?.unwrap_or(0))

} else {

None

};

Some((ch, flags, width, precision))

if !ch.is_ascii_digit() {

return Some(None);

}

let mut value = 0u16;

let mut digits = 0usize;

while ch.is_ascii_digit() {

value = value * 10 + (*ch as u16 - b'0' as u16);

*ch = next_char(chars, pos)?;

digits += 1;

if digits >= MAXDIGITS {

return None;

}

}

Some(Some(value))

let ch = chars.get(*pos).copied()?;

*pos += 1;

Some(ch)

InterpolatedStringLiteralElement {

range: TextRange::default(),

node_index: AtomicNodeIndex::NONE,

value: value.into_boxed_str(),

}

let statement_location = body.first().and_then(|node| preprocessor.location(node));

if let Some(range) = take_docstring(body) {

if !body.is_empty() {

return;

}

let start = range.start();

let pass_range = TextRange::new(start, start + ruff_text_size::TextSize::from(4));

let node_index = statement_location.map_or(AtomicNodeIndex::NONE, |location| {

let Some(end_col) = location.col.checked_add(4) else {

preprocessor.record_location_error(AstLocationError::CoordinateOverflow);

return AtomicNodeIndex::NONE;

};

preprocessor.fresh_location(SourceLocationRange {

end_line: location.line,

end_col,

..location

})

});

body.push(ast::Stmt::Pass(ast::StmtPass {

node_index,

range: pass_range,

}));

}

let ast::Stmt::Expr(expr_stmt) = body.first()? else {

return None;

};

if let Some((_, range)) = string_literal_expr_value(&expr_stmt.value) {

body.remove(0);

return Some(range);

}

None

let Some(ast::Stmt::Expr(expr_stmt)) = body.first() else {

return false;

};

string_literal_expr_value(&expr_stmt.value).is_some()

let Some(ast::Stmt::Expr(expr_stmt)) = body.first_mut() else {

return;

};

let Some((value, range)) = string_literal_expr_value(&expr_stmt.value) else {

return;

};

let value = value.to_string();

let literal_index = expr_stmt.value.node_index().clone();

let wrapper_range = if explicit_locations {

expr_stmt.range

} else {

range

};

let wrapper_index = if explicit_locations {

expr_stmt.node_index.clone()

} else {

AtomicNodeIndex::NONE

};

*expr_stmt.value = ast::Expr::FString(ast::ExprFString {

node_index: wrapper_index.clone(),

range: wrapper_range,

value: FStringValue::single(FString {

range: wrapper_range,

node_index: wrapper_index,