use std::collections::HashSet;
use tree_sitter::Node;
use super::{walk, Ancestor, Language};
use crate::unit::MAX_TREE_DEPTH;
pub(super) fn reads_whole(language: Language, code: &str) -> Option<bool> {
if has_odd_character(code) {
return None;
}
match language {
Language::Python => python(code, false),
Language::JavaScript => javascript(code).then_some(false),
}
}
pub(super) fn reads_whole_python2(code: &str) -> Option<bool> {
if has_odd_character(code) {
return None;
}
python(code, true)
}
fn shallow(above: &[Ancestor<'_>]) -> bool {
above.len() <= MAX_TREE_DEPTH
}
fn has_odd_character(code: &str) -> bool {
code.chars().any(|c| {
(c.is_control() && !matches!(c, '\n' | '\t')) || matches!(c, '\u{2028}' | '\u{2029}')
})
}
const PYTHON_CALLS: [&str; 40] = [
"print",
"len",
"str",
"int",
"float",
"bool",
"repr",
"abs",
"min",
"max",
"sum",
"round",
"sorted",
"reversed",
"list",
"tuple",
"dict",
"set",
"frozenset",
"range",
"enumerate",
"zip",
"any",
"all",
"ord",
"chr",
"hex",
"bin",
"oct",
"divmod",
"pow",
"bytes",
"bytearray",
"format",
"ascii",
"iter",
"next",
"open",
"complex",
"slice",
];
const PYTHON_MODULES: [&str; 4] = ["errno", "itertools", "sys", "time"];
const PYTHON2_MODULES: [&str; 2] = ["errno", "sys"];
fn python_modules(python2: bool) -> &'static [&'static str] {
if python2 {
&PYTHON2_MODULES
} else {
&PYTHON_MODULES
}
}
fn python_member(module: &str, name: &str, call: bool) -> bool {
match module {
"errno" => !call,
"sys" => !call && matches!(name, "stdin" | "argv" | "version"),
"time" => {
call && matches!(
name,
"time" | "time_ns" | "monotonic" | "monotonic_ns" | "perf_counter"
)
}
_ => false,
}
}
fn plain_name(name: &str) -> bool {
!name.is_empty()
&& name
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'$'))
}
fn text<'a>(node: Node<'_>, code: &'a str) -> &'a str {
code.get(node.byte_range()).unwrap_or_default()
}
fn has_statement(root: Node<'_>) -> bool {
let mut cursor = root.walk();
let found = root
.named_children(&mut cursor)
.any(|child| child.kind() != "comment");
found
}
fn python(code: &str, python2: bool) -> Option<bool> {
let mut parser = tree_sitter::Parser::new();
let tree = parser
.set_language(&tree_sitter_python::LANGUAGE.into())
.ok()
.and_then(|()| parser.parse(code, None))?;
let root = tree.root_node();
if root.has_error() || !has_statement(root) {
return None;
}
let mut assigned = HashSet::new();
let mut imported = HashSet::new();
let mut clean = true;
walk(root, |node, _, _| {
if node.kind() == "import_statement" {
let mut cursor = node.walk();
for name in node.named_children(&mut cursor) {
imported.insert(text(name, code).to_string());
}
}
let left = match node.kind() {
"assignment" | "augmented_assignment" => node.child_by_field_name("left"),
_ => None,
};
if let Some(left) = left {
walk(left, |name, _, _| {
if name.kind() == "identifier" {
let name = text(name, code);
clean &= plain_name(name)
&& !name.starts_with('_')
&& !PYTHON_CALLS.contains(&name)
&& !PYTHON_MODULES.contains(&name)
&& !matches!(name, "json" | "math" | "re");
assigned.insert(name.to_string());
}
true
});
}
clean
});
if !clean {
return None;
}
let mut whole = true;
walk(root, |node, field, above| {
whole =
shallow(above) && python_node(node, field, above, code, &assigned, &imported, python2);
whole
});
whole.then_some(true)
}
fn python_node(
node: Node<'_>,
field: Option<&str>,
above: &[Ancestor<'_>],
code: &str,
assigned: &HashSet<String>,
imported: &HashSet<String>,
python2: bool,
) -> bool {
if !node.is_named() {
return true;
}
let modules = python_modules(python2);
let parent = above.last().map(|ancestor| ancestor.node.kind());
match node.kind() {
"module"
| "comment"
| "expression_statement"
| "if_statement"
| "elif_clause"
| "else_clause"
| "integer"
| "float"
| "true"
| "false"
| "none"
| "string"
| "string_start"
| "string_content"
| "string_end"
| "escape_sequence"
| "escape_interpolation"
| "interpolation"
| "type_conversion"
| "format_specifier"
| "format_expression"
| "concatenated_string"
| "list"
| "tuple"
| "dictionary"
| "set"
| "pair"
| "binary_operator"
| "unary_operator"
| "boolean_operator"
| "comparison_operator"
| "not_operator"
| "parenthesized_expression"
| "subscript"
| "slice"
| "conditional_expression"
| "argument_list"
| "keyword_argument"
| "expression_list"
| "pattern_list"
| "tuple_pattern"
| "list_pattern" => true,
"block" => {
let mut cursor = node.walk();
let filled = node
.named_children(&mut cursor)
.any(|child| child.kind() != "comment");
filled
}
"assignment" => {
node.child_by_field_name("type").is_none()
&& node.child_by_field_name("right").is_some()
&& node.child_by_field_name("left").is_some_and(|left| {
matches!(
left.kind(),
"identifier" | "pattern_list" | "tuple_pattern" | "list_pattern"
)
})
}
"augmented_assignment" => node
.child_by_field_name("left")
.is_some_and(|left| left.kind() == "identifier"),
"import_statement" => {
let mut cursor = node.walk();
let all = node
.named_children(&mut cursor)
.all(|name| name.kind() == "dotted_name" && modules.contains(&text(name, code)));
all
}
"dotted_name" => parent == Some("import_statement"),
"identifier" => {
let name = text(node, code);
plain_name(name)
&& match (parent, field) {
(Some("dotted_name"), _) => true,
(Some("call"), Some("function")) => {
PYTHON_CALLS.contains(&name) && !assigned.contains(name)
}
(Some("attribute"), Some("object")) => {
imported.contains(name) || assigned.contains(name)
}
(Some("attribute"), Some("attribute")) => !name.starts_with('_'),
(Some("keyword_argument"), Some("name")) => true,
_ => assigned.contains(name),
}
}
"attribute" => {
let (Some(object), Some(attribute)) = (
node.child_by_field_name("object"),
node.child_by_field_name("attribute"),
) else {
return false;
};
let name = text(attribute, code);
let call = parent == Some("call") && field == Some("function");
if name.starts_with('_') {
return false;
}
if object.kind() == "identifier" && modules.contains(&text(object, code)) {
return python_member(text(object, code), name, call);
}
true
}
"call" => node
.child_by_field_name("function")
.is_some_and(|function| matches!(function.kind(), "identifier" | "attribute")),
_ => false,
}
}
const JAVASCRIPT_CALLS: [&str; 7] = [
"parseInt",
"parseFloat",
"String",
"Number",
"Boolean",
"isNaN",
"isFinite",
];
const JAVASCRIPT_MODULES: [&str; 3] = ["console", "JSON", "Math"];
const JAVASCRIPT_METHODS: [&str; 33] = [
"toString",
"toUpperCase",
"toLowerCase",
"trim",
"trimStart",
"trimEnd",
"split",
"join",
"slice",
"substring",
"indexOf",
"lastIndexOf",
"includes",
"startsWith",
"endsWith",
"replace",
"replaceAll",
"repeat",
"padStart",
"padEnd",
"concat",
"charAt",
"charCodeAt",
"push",
"pop",
"shift",
"unshift",
"reverse",
"sort",
"at",
"toFixed",
"test",
"match",
];
fn javascript_member(object: &str, name: &str, call: bool) -> bool {
match object {
"console" => call && matches!(name, "log" | "error" | "warn" | "info" | "debug"),
"JSON" => call && matches!(name, "stringify" | "parse"),
"Math" => matches!(
name,
"abs"
| "ceil"
| "floor"
| "round"
| "max"
| "min"
| "pow"
| "sqrt"
| "trunc"
| "sign"
| "cbrt"
| "hypot"
| "log"
| "log2"
| "log10"
| "exp"
| "sin"
| "cos"
| "tan"
| "atan"
| "atan2"
| "random"
| "PI"
| "E"
),
_ => false,
}
}
fn javascript(code: &str) -> bool {
let mut parser = tree_sitter::Parser::new();
let Some(tree) = parser
.set_language(&tree_sitter_javascript::LANGUAGE.into())
.ok()
.and_then(|()| parser.parse(code, None))
else {
return false;
};
let root = tree.root_node();
if root.has_error() || !has_statement(root) {
return false;
}
let mut assigned = HashSet::new();
let mut clean = true;
walk(root, |node, _, _| {
let name = match node.kind() {
"variable_declarator" => node.child_by_field_name("name"),
"assignment_expression" | "augmented_assignment_expression" => {
node.child_by_field_name("left")
}
"update_expression" => node.child_by_field_name("argument"),
_ => None,
};
if let Some(name) = name.filter(|name| name.kind() == "identifier") {
let name = text(name, code);
clean &= plain_name(name)
&& !name.starts_with('_')
&& !JAVASCRIPT_CALLS.contains(&name)
&& !JAVASCRIPT_MODULES.contains(&name);
assigned.insert(name.to_string());
}
clean
});
if !clean {
return false;
}
let mut whole = true;
walk(root, |node, field, above| {
whole = shallow(above) && javascript_node(node, field, above, code, &assigned);
whole
});
whole
}
fn javascript_node(
node: Node<'_>,
field: Option<&str>,
above: &[Ancestor<'_>],
code: &str,
assigned: &HashSet<String>,
) -> bool {
if !node.is_named() {
return true;
}
let parent = above.last().map(|ancestor| ancestor.node.kind());
match node.kind() {
"program"
| "comment"
| "expression_statement"
| "lexical_declaration"
| "variable_declaration"
| "if_statement"
| "else_clause"
| "parenthesized_expression"
| "sequence_expression"
| "ternary_expression"
| "binary_expression"
| "number"
| "string"
| "string_fragment"
| "escape_sequence"
| "template_string"
| "template_substitution"
| "regex"
| "regex_pattern"
| "regex_flags"
| "true"
| "false"
| "null"
| "undefined"
| "array"
| "object"
| "pair"
| "arguments"
| "optional_chain" => true,
"statement_block" => {
let mut cursor = node.walk();
let filled = node
.named_children(&mut cursor)
.any(|child| child.kind() != "comment");
filled && matches!(parent, Some("if_statement" | "else_clause"))
}
"variable_declarator" => node
.child_by_field_name("name")
.is_some_and(|name| name.kind() == "identifier"),
"assignment_expression" | "augmented_assignment_expression" => node
.child_by_field_name("left")
.is_some_and(|left| left.kind() == "identifier"),
"update_expression" => node
.child_by_field_name("argument")
.is_some_and(|argument| argument.kind() == "identifier"),
"unary_expression" => node
.child_by_field_name("operator")
.is_some_and(|operator| {
matches!(text(operator, code), "!" | "-" | "+" | "~" | "typeof")
}),
"property_identifier" => {
let name = text(node, code);
plain_name(name)
&& match (parent, field) {
(Some("member_expression"), Some("property")) => true,
(Some("pair"), Some("key")) => {
!name.starts_with('_') && !matches!(name, "constructor" | "prototype")
}
_ => false,
}
}
"shorthand_property_identifier" => {
let name = text(node, code);
plain_name(name) && assigned.contains(name)
}
"identifier" => {
let name = text(node, code);
plain_name(name)
&& match (parent, field) {
(Some("call_expression"), Some("function")) => {
JAVASCRIPT_CALLS.contains(&name) && !assigned.contains(name)
}
(Some("member_expression"), Some("object")) => {
JAVASCRIPT_MODULES.contains(&name) || assigned.contains(name)
}
(Some("variable_declarator"), Some("name")) => true,
_ => assigned.contains(name),
}
}
"member_expression" => {
let (Some(object), Some(property)) = (
node.child_by_field_name("object"),
node.child_by_field_name("property"),
) else {
return false;
};
let name = text(property, code);
let call = parent == Some("call_expression") && field == Some("function");
if property.kind() != "property_identifier" || name.starts_with('_') {
return false;
}
if object.kind() == "identifier" && JAVASCRIPT_MODULES.contains(&text(object, code)) {
return javascript_member(text(object, code), name, call);
}
if call {
JAVASCRIPT_METHODS.contains(&name)
} else {
name == "length"
}
}
"subscript_expression" => node
.child_by_field_name("index")
.is_some_and(|index| index.kind() == "number"),
"call_expression" => node
.child_by_field_name("function")
.is_some_and(|function| matches!(function.kind(), "identifier" | "member_expression")),
_ => false,
}
}