duplicatecode 0.1.0__tar.gz → 0.2.0__tar.gz

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/Cargo.lock

@@ -198,7 +198,7 @@ dependencies = [
 
 [[package]]
 name = "duplicatecode"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -212,12 +212,13 @@ dependencies = [
 
 [[package]]
 name = "duplicatecode-engine"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "ignore",
  "serde",
  "serde_json",
  "tree-sitter",
+ "tree-sitter-c-sharp",
  "tree-sitter-python",
  "tree-sitter-typescript",
  "ureq",
@@ -763,6 +764,16 @@ dependencies = [
  "tree-sitter-language",
 ]
 
+[[package]]
+name = "tree-sitter-c-sharp"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1aac67f1ad71de1d6d39708d34811081c26dfa495658de6c14c34200849357c"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
+
 [[package]]
 name = "tree-sitter-language"
 version = "0.1.8"

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/Cargo.toml

@@ -3,6 +3,6 @@ resolver = "2"
 members = ["crates/duplicatecode-engine", "crates/duplicatecode-cli"]
 
 [workspace.package]
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "MIT"

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: duplicatecode
-Version: 0.1.0
+Version: 0.2.0
 Classifier: Programming Language :: Rust
 Classifier: Environment :: Console
-Summary: Static (LLM-free) detection of duplicate/similar code in Python and TypeScript
+Summary: Static (LLM-free) detection of duplicate/similar code in Python, TypeScript and C#
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
 # duplicatecode
 
-Static (LLM-free) detection of duplicate / similar code in Python and TypeScript (TSX),
+Static (LLM-free) detection of duplicate / similar code in Python, TypeScript (TSX) and C#,
 aimed at catching an LLM re-implementing something that already exists. Input can be a git diff
 checked against existing source.
 

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/README.md

@@ -1,6 +1,6 @@
 # duplicatecode
 
-Static (LLM-free) detection of duplicate / similar code in Python and TypeScript (TSX),
+Static (LLM-free) detection of duplicate / similar code in Python, TypeScript (TSX) and C#,
 aimed at catching an LLM re-implementing something that already exists. Input can be a git diff
 checked against existing source.
 

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/crates/duplicatecode-cli/src/main.rs

@@ -80,7 +80,7 @@ impl Profile {
 #[derive(Parser)]
 #[command(
     version,
-    about = "Detect duplicate/similar code in Python and TypeScript"
+    about = "Detect duplicate/similar code in Python, TypeScript and C#"
 )]
 struct Cli {
     #[command(subcommand)]

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/crates/duplicatecode-engine/Cargo.toml

@@ -3,13 +3,14 @@ name = "duplicatecode-engine"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
-description = "Static duplicate/similar code detection engine for Python and TypeScript"
+description = "Static duplicate/similar code detection engine for Python, TypeScript and C#"
 
 [dependencies]
 ignore = "0.4.33"
 serde = { version = "1.0.229", features = ["derive"] }
 serde_json = "1.0.151"
 tree-sitter = "0.27.0"
+tree-sitter-c-sharp = "0.23.5"
 tree-sitter-python = "0.25.0"
 tree-sitter-typescript = "0.23.2"
 ureq = { version = "2", features = ["json"] }

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/crates/duplicatecode-engine/src/index.rs

@@ -406,6 +406,9 @@ pub fn units_from_file(root: &std::path::Path, path: &std::path::Path) -> Vec<Un
 
 const SKIP_DIRS: &[&str] = &[
     "node_modules",
+    "bin",
+    "obj",
+    ".vs",
     "target",
     ".venv",
     "venv",

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/crates/duplicatecode-engine/src/lang.rs

@@ -6,6 +6,8 @@ pub enum Lang {
     Python,
     TypeScript,
     Tsx,
+    #[serde(rename = "csharp")]
+    CSharp,
 }
 
 impl Lang {
@@ -14,6 +16,7 @@ impl Lang {
             "py" => Some(Lang::Python),
             "ts" | "mts" | "cts" => Some(Lang::TypeScript),
             "tsx" => Some(Lang::Tsx),
+            "cs" => Some(Lang::CSharp),
             _ => None,
         }
     }
@@ -23,14 +26,16 @@ impl Lang {
             Lang::Python => tree_sitter_python::LANGUAGE.into(),
             Lang::TypeScript => tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into(),
             Lang::Tsx => tree_sitter_typescript::LANGUAGE_TSX.into(),
+            Lang::CSharp => tree_sitter_c_sharp::LANGUAGE.into(),
         }
     }
 
-    /// Python vs. the TypeScript family; units are only compared within a family.
+    /// Python, C# or the TypeScript family; units are only compared within a family.
     pub fn family(self) -> &'static str {
         match self {
             Lang::Python => "python",
             Lang::TypeScript | Lang::Tsx => "typescript",
+            Lang::CSharp => "csharp",
         }
     }
 }

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/crates/duplicatecode-engine/src/units.rs

@@ -124,6 +124,12 @@ impl Ctx<'_> {
     }
 
     fn walk(&mut self, node: Node) {
+        // bodyless signatures (interfaces) and enums are not code units
+        if self.lang == Lang::CSharp
+            && matches!(node.kind(), "interface_declaration" | "enum_declaration")
+        {
+            return;
+        }
         if let Some((kind, name, unit_node)) = self.classify(node) {
             self.emit(kind, name, unit_node);
             // Only classes are searched for member units; nested functions belong to their parent.
@@ -170,6 +176,16 @@ impl Ctx<'_> {
                 Some(("class", field_name(node)?, node))
             }
             (_, "method_definition") => Some(("function", field_name(node)?, node)),
+            (
+                Lang::CSharp,
+                "struct_declaration" | "record_declaration" | "record_struct_declaration",
+            ) => Some(("class", field_name(node)?, node)),
+            (Lang::CSharp, "method_declaration" | "local_function_statement") => {
+                Some(("function", field_name(node)?, node))
+            }
+            (Lang::CSharp, "constructor_declaration") => {
+                Some(("function", "constructor".into(), node))
+            }
             // const foo = () => ... / const foo = function () {...}; also class fields
             (Lang::TypeScript | Lang::Tsx, "variable_declarator" | "public_field_definition") => {
                 let value = node.child_by_field_name("value")?;
@@ -281,6 +297,21 @@ impl Ctx<'_> {
                     }
                     _ => return false,
                 },
+                "field_declaration" | "property_declaration" if self.lang == Lang::CSharp => {
+                    if m.children(&mut m.walk())
+                        .any(|c| c.kind() == "arrow_expression_clause")
+                        || m.children(&mut m.walk()).any(|c| {
+                            c.kind() == "accessor_list"
+                                && c.children(&mut c.walk()).any(|a| {
+                                    a.kind() == "accessor_declaration"
+                                        && a.child_by_field_name("body").is_some()
+                                })
+                        })
+                    {
+                        return false;
+                    }
+                    fields += 1;
+                }
                 "public_field_definition" | "property_signature" => {
                     if m.child_by_field_name("value").is_some_and(|v| {
                         matches!(
@@ -312,6 +343,35 @@ impl Ctx<'_> {
     fn is_debug(&self, node: Node) -> bool {
         match node.kind() {
             "debugger_statement" => true,
+            "expression_statement" if self.lang == Lang::CSharp => {
+                // Console.WriteLine(..), Debug.WriteLine(..), _logger.LogInformation(..)
+                let Some(f) = node
+                    .named_child(0)
+                    .filter(|e| e.kind() == "invocation_expression")
+                    .and_then(|e| e.child_by_field_name("function"))
+                    .filter(|f| f.kind() == "member_access_expression")
+                else {
+                    return false;
+                };
+                let obj = f
+                    .child_by_field_name("expression")
+                    .map(|o| match o.kind() {
+                        "member_access_expression" => o
+                            .child_by_field_name("name")
+                            .map(|x| self.text(x))
+                            .unwrap_or_default(),
+                        _ => self.text(o),
+                    })
+                    .unwrap_or_default();
+                let method = f
+                    .child_by_field_name("name")
+                    .map(|x| self.text(x))
+                    .unwrap_or_default();
+                matches!(
+                    obj.to_lowercase().as_str(),
+                    "console" | "debug" | "trace" | "logger" | "_logger" | "log" | "_log"
+                ) && (method.starts_with("Write") || method.starts_with("Log"))
+            }
             "expression_statement" => {
                 let Some(e) = node.named_child(0) else {
                     return false;
@@ -354,7 +414,8 @@ impl Ctx<'_> {
 
     /// `x = expr` immediately followed by `return x`  ==>  the value expression of `return expr`.
     fn temp_return<'t>(&self, a: Node<'t>, b: Node<'t>) -> Option<Node<'t>> {
-        if b.kind() != "return_statement" || b.named_child_count() != 1 {
+        if self.lang == Lang::CSharp || b.kind() != "return_statement" || b.named_child_count() != 1
+        {
             return None;
         }
         let (name, value) = if self.lang == Lang::Python {
@@ -401,16 +462,23 @@ impl Ctx<'_> {
             return;
         }
         match kind {
-            "string" | "template_string" | "string_literal" | "concatenated_string" => {
-                out.push("STR".into())
+            "string"
+            | "template_string"
+            | "string_literal"
+            | "concatenated_string"
+            | "verbatim_string_literal"
+            | "raw_string_literal"
+            | "interpolated_string_expression" => out.push("STR".into()),
+            "integer" | "float" | "number" | "integer_literal" | "real_literal" => {
+                out.push("NUM".into())
             }
-            "integer" | "float" | "number" => out.push("NUM".into()),
             "identifier"
             | "property_identifier"
             | "shorthand_property_identifier"
             | "shorthand_property_identifier_pattern"
             | "type_identifier"
             | "private_property_identifier" => out.push("ID".into()),
+            "generic_name" if self.lang == Lang::CSharp => out.push("ID".into()),
             "list_comprehension"
             | "set_comprehension"
             | "dictionary_comprehension"
@@ -447,7 +515,7 @@ impl Ctx<'_> {
                     _ => self.norm_children(node, out, skip_blocks),
                 }
             }
-            "block" | "statement_block" | "module" | "program" => {
+            "block" | "statement_block" | "module" | "program" | "compilation_unit" => {
                 let n = node.child_count();
                 let mut i = 0;
                 while i < n {
@@ -543,7 +611,7 @@ impl Ctx<'_> {
     fn statements(&self, node: Node, out: &mut Vec<Stmt>) {
         let blockish = matches!(
             node.kind(),
-            "block" | "statement_block" | "module" | "program"
+            "block" | "statement_block" | "module" | "program" | "compilation_unit"
         );
         let n = node.child_count();
         let mut i = 0;
@@ -698,7 +766,7 @@ impl Ctx<'_> {
             return;
         }
         match kind {
-            "call" | "call_expression" => {
+            "call" | "call_expression" | "invocation_expression" => {
                 if let Some(func) = node.child_by_field_name("function") {
                     if let Some(n) = callee_name(func, self.src) {
                         let n = n.to_lowercase();
@@ -707,17 +775,22 @@ impl Ctx<'_> {
                     }
                 }
             }
-            "attribute" | "member_expression" => {
-                let field = if kind == "attribute" {
-                    "attribute"
-                } else {
-                    "property"
+            "attribute" | "member_expression" | "member_access_expression" => {
+                let field = match kind {
+                    "attribute" => "attribute",
+                    "member_access_expression" => "name",
+                    _ => "property",
                 };
                 if let Some(a) = node.child_by_field_name(field) {
                     f.api.insert(self.text(a).to_lowercase());
                 }
             }
-            "string" | "template_string" | "string_literal" | "concatenated_string" => {
+            "string"
+            | "template_string"
+            | "string_literal"
+            | "concatenated_string"
+            | "verbatim_string_literal"
+            | "raw_string_literal" => {
                 let t = self.text(node);
                 let t = t.trim_matches(|c| c == '"' || c == '\'' || c == '`');
                 if !t.is_empty() && t.len() <= 24 && !t.contains('{') {
@@ -725,7 +798,7 @@ impl Ctx<'_> {
                 }
                 return;
             }
-            "integer" | "float" | "number" => {
+            "integer" | "float" | "number" | "integer_literal" | "real_literal" => {
                 let t = self.text(node);
                 if !matches!(t.as_str(), "0" | "1" | "2" | "-1") {
                     f.literals.insert(t);
@@ -764,6 +837,13 @@ const TYPE_KINDS: &[&str] = &[
     "type_arguments",
     "type_predicate_annotation",
     "asserts_annotation",
+    // C# type-level syntax
+    "type_argument_list",
+    "type_parameter_list",
+    "type_parameter_constraints_clause",
+    "nullable_type",
+    "modifier",
+    "predefined_type",
     // Python annotations
     "type",
     "type_parameter",
@@ -845,8 +925,13 @@ fn is_module_level(declarator: Node) -> bool {
 fn is_test_path(file: &str) -> bool {
     let f = file.replace('\\', "/");
     let base = f.rsplit('/').next().unwrap_or(&f);
-    f.split('/')
-        .any(|c| matches!(c, "tests" | "test" | "__tests__" | "e2e" | "spec"))
+    f.split('/').any(|c| {
+        matches!(c, "tests" | "test" | "__tests__" | "e2e" | "spec")
+            || c.ends_with(".Tests")
+            || c.ends_with(".Test")
+    }) || base.ends_with("Tests.cs")
+        || base.ends_with("Test.cs")
+        || base.ends_with("Spec.cs")
         || base.starts_with("test_")
         || base == "conftest.py"
         || base.ends_with("_test.py")
@@ -866,6 +951,7 @@ fn callee_name(f: Node, src: &[u8]) -> Option<String> {
     match f.kind() {
         "identifier" | "property_identifier" => text(f),
         "attribute" => f.child_by_field_name("attribute").and_then(text),
+        "member_access_expression" => f.child_by_field_name("name").and_then(text),
         "member_expression" => f.child_by_field_name("property").and_then(text),
         _ => None,
     }
@@ -901,6 +987,39 @@ mod tests {
         assert_eq!(names, [("function", "f"), ("class", "K"), ("method", "m")]);
     }
 
+    #[test]
+    fn csharp_skips_interfaces_and_keeps_logic_properties() {
+        let src = "interface I { int Foo(int x); }\nenum E { A, B }\nclass P { public int X { get { return Compute(); } } }\nclass Q { public int X { get; set; } }\n";
+        let u = extract_units("p.cs", Lang::CSharp, src);
+        let n: Vec<_> = u.iter().map(|x| (x.name.as_str(), x.boilerplate)).collect();
+        assert_eq!(n, [("P", false), ("Q", true)]);
+    }
+
+    #[test]
+    fn csharp_classes_methods_and_normalization() {
+        let src = "namespace N {\n  public class Calc {\n    public int Add(int a, int b) {\n      Console.WriteLine(\"x\");\n      return Helper(a) + b;\n    }\n    public Calc() { }\n  }\n  public record Dto(int Id);\n}\n";
+        let u = extract_units("Calc.cs", Lang::CSharp, src);
+        let names: Vec<_> = u
+            .iter()
+            .map(|x| (x.kind.as_str(), x.name.as_str()))
+            .collect();
+        assert_eq!(
+            names,
+            [
+                ("class", "Calc"),
+                ("method", "Add"),
+                ("method", "constructor"),
+                ("class", "Dto")
+            ]
+        );
+        let add = &u[1];
+        assert!(add.callees.contains("helper") && !add.callees.contains("writeline"));
+        let renamed = "class Other {\n int Plus(int x, int y) {\n return Foo(x) + y;\n }\n}\n";
+        let b = extract_units("o.cs", Lang::CSharp, renamed);
+        assert_eq!(add.tokens, b[1].tokens);
+        assert!(u[2].boilerplate);
+    }
+
     fn toks(src: &str) -> Vec<String> {
         extract_units("x.py", Lang::Python, src).remove(0).tokens
     }

{duplicatecode-0.1.0 → duplicatecode-0.2.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 [project]
 name = "duplicatecode"
 dynamic = ["version"]
-description = "Static (LLM-free) detection of duplicate/similar code in Python and TypeScript"
+description = "Static (LLM-free) detection of duplicate/similar code in Python, TypeScript and C#"
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.9"