[
  {
    "commitHash": "a1346ff4af9450fe23ebd3f838bb71f9f06fe1a7",
    "commitMessage": "HEAD - Fix for 306917\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:21:38.965124678Z",
    "commitDate": "2010-03-27T02:26:17Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 5,
    "codeImprovement": 6,
    "implementationEffort": 8,
    "trafficLight": "RED",
    "category": "API Modernization",
    "isNewCategory": false,
    "categoryReason": "The change involves modernizing exception handling by specifying a more precise exception type.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "misc.sandbox-hint",
    "languageChangeNeeded": "The TriggerPattern DSL currently supports expression replacements, annotation modifications, and specific declaration patterns. It does not directly support pattern matching and replacement for the *type* declared within a `catch` clause (e.g., `catch ($OldExceptionType $e) \u003d\u003e catch ($NewExceptionType $e)`). Implementing this would require extending the DSL\u0027s grammar to recognize and rewrite `CatchClause` exception types.",
    "dslRuleAfterChange": "catch (java.lang.RuntimeException $e)\n\u003d\u003e catch (java.lang.IllegalArgumentException $e)\n;;",
    "summary": "This commit changes the type of caught exception from `RuntimeException` to `IllegalArgumentException` within an internal JDT class (`ASTConverter`). While specifying a more precise exception type is a code improvement, the current TriggerPattern DSL focuses on expression-level transformations, method/constructor calls, and annotations. It does not support directly matching and rewriting the type declaration within a `catch` clause. Therefore, this transformation cannot be implemented with the current DSL capabilities."
  },
  {
    "commitHash": "fa6a9611391cd82599b293f23e547c97052d2713",
    "commitMessage": "HEAD - Fix for 306568\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:21:54.125292492Z",
    "commitDate": "2010-03-30T19:29:06Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 2,
    "codeImprovement": 7,
    "implementationEffort": 9,
    "trafficLight": "RED",
    "category": "JDT Internal Refactoring",
    "isNewCategory": false,
    "categoryReason": "The commit modifies internal logic within the JDT Core DOM\u0027s ImportRewriteAnalyzer.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "jdt-internal-refactoring.sandbox-hint",
    "languageChangeNeeded": "The current DSL does not support transformations that modify control flow statements (`if`, `else if`, `else`) or insert new multi-statement blocks (e.g., variable declarations, nested conditional logic) in the replacement. The change involves restructuring conditional statements and introducing new code blocks.",
    "summary": "This commit modifies the internal `ImportRewriteAnalyzer` in JDT Core DOM. The changes involve restructuring existing `if-else` conditional blocks, modifying their conditions, and adding new conditional logic with multiple statements, including variable declarations and nested `if` statements. These are complex structural changes to control flow and code insertion, which are explicitly not supported by the current TriggerPattern DSL for pattern-based transformations. Therefore, this change is classified as RED."
  },
  {
    "commitHash": "8cef9873b63abd6271de2eb41584ebd6f6cb2fa0",
    "commitMessage": "HEAD - Fix for 308754\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:23:03.028577566Z",
    "commitDate": "2010-04-12T15:39:12Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 1,
    "codeImprovement": 7,
    "implementationEffort": 9,
    "trafficLight": "RED",
    "category": "JDT Internal Refactoring",
    "isNewCategory": false,
    "categoryReason": "Internal refactoring of Eclipse JDT AST processing logic.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "",
    "languageChangeNeeded": "The DSL currently supports expression replacements and simple method/annotation modifications. This commit requires introducing local variables, conditional logic, list iteration, and arithmetic to calculate a new expression argument. This level of structural rewrite is beyond the current DSL capabilities.",
    "summary": "This commit modifies internal JDT AST rewriting logic to correctly calculate the starting position for parsing type keywords (class/interface), accounting for preceding modifiers in JLS3+. The change involves introducing a local variable, conditional logic, list access, and arithmetic, which are structural modifications beyond the current capabilities of the TriggerPattern DSL for pattern-based replacements. Thus, it is classified as RED."
  },
  {
    "commitHash": "29c65069abca990726d318e0e51a77345e02d507",
    "commitMessage": "HEAD - Fix for 308754\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:23:03.028664860Z",
    "commitDate": "2010-04-12T16:07:26Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 1,
    "codeImprovement": 7,
    "implementationEffort": 9,
    "trafficLight": "RED",
    "category": "JDT Internal Refactoring",
    "isNewCategory": false,
    "categoryReason": "Internal refactoring of Eclipse JDT AST processing logic.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "",
    "languageChangeNeeded": "The DSL does not support introducing new local variables (like `isJLS2`) and then using them in subsequent expressions. While the conditional logic changes are themselves expression replacements, the dependency on a newly introduced local variable makes them unexpressible.",
    "summary": "This commit refactors internal JDT AST rewriting logic by introducing a local boolean variable `isJLS2` to centralize checks against `apiLevel \u003d\u003d JLS2_INTERNAL`. It then replaces multiple occurrences of `apiLevel \u003d\u003d JLS2_INTERNAL` and `apiLevel \u003e\u003d AST.JLS3` with `isJLS2` or `!isJLS2`. The introduction of a new local variable and its propagation through complex conditional logic makes this a structural change beyond the current capabilities of the TriggerPattern DSL. Thus, it is classified as RED."
  },
  {
    "commitHash": "abe74916372d719b72419b47087d6b9f61b3cd7b",
    "commitMessage": "HEAD - Remove useless anonymous\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:23:03.028735873Z",
    "commitDate": "2010-04-12T18:24:55Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 2,
    "codeImprovement": 6,
    "implementationEffort": 8,
    "trafficLight": "RED",
    "category": "JDT Internal Refactoring",
    "isNewCategory": false,
    "categoryReason": "Internal refactoring within Eclipse JDT Core DOM API.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "",
    "languageChangeNeeded": "The DSL does not support adding new static fields to a class, which is required to define `TypeBinding.EXPRESSION`. While the subsequent usage of this field could be replaced, the definition itself is a structural class change.",
    "summary": "This commit refactors internal JDT code by replacing the repeated instantiation of an anonymous `Expression` inner class with a single static final instance of `StringLiteral` (a subclass of `Expression`). This improves performance by avoiding unnecessary object allocations. However, the transformation requires adding a new static field to the `TypeBinding` class, which is a structural modification beyond the current capabilities of the TriggerPattern DSL. Therefore, it is classified as RED."
  },
  {
    "commitHash": "e94dffdc8969b47ac87799c5977c68ba7cdd27e8",
    "commitMessage": "HEAD - Fix for 309022\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:23:13.263469164Z",
    "commitDate": "2010-04-13T18:53:21Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 2,
    "codeImprovement": 6,
    "implementationEffort": 9,
    "trafficLight": "RED",
    "category": "JDT Internal Bug Fix",
    "isNewCategory": false,
    "categoryReason": "The change is a bug fix within the internal Eclipse JDT Core DOM\u0027s import rewrite logic.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "jdt-internal-refactoring.sandbox-hint",
    "languageChangeNeeded": "The DSL needs significant extensions to support inserting arbitrary blocks of new code, including conditional statements (`if`/`else if`), nested logic, local variable declarations, and multiple method calls within newly inserted control flow structures. The current DSL focuses on expression-level replacements or simple statement structural rewrites (like adding annotations to method declarations, or simple variable declaration pattern matching).",
    "summary": "This commit fixes Bug 309022 by adding a new `else if` block with nested conditional logic and multiple statements (variable declarations, method calls, list additions) within JDT\u0027s `ImportRewriteAnalyzer`. This structural addition of complex control flow and multi-statement logic is beyond the current capabilities of the TriggerPattern DSL, which is designed for pattern-based expression and simple statement transformations. Therefore, it is classified as RED, indicating it cannot be implemented with the existing DSL."
  },
  {
    "commitHash": "90f475069422eaf687608d6a16c5ad551ef1d62a",
    "commitMessage": "HEAD - Fix copyrights\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:23:40.971358043Z",
    "commitDate": "2010-05-11T19:03:39Z",
    "relevant": false,
    "irrelevantReason": "This commit only updates copyright years in a file header comment. It does not involve any Java code transformations or patterns that can be generalized into a TriggerPattern DSL rule.",
    "isDuplicate": false,
    "reusability": 0,
    "codeImprovement": 0,
    "implementationEffort": 0,
    "trafficLight": "NOT_APPLICABLE",
    "isNewCategory": false,
    "canImplementInCurrentDsl": false,
    "languageChangeNeeded": "The DSL does not support matching and replacing arbitrary text within comments or file headers.",
    "summary": "This commit changes a copyright year in a comment. This is not a code transformation and is therefore not applicable for generating TriggerPattern DSL rules, which focus on Java code patterns."
  },
  {
    "commitHash": "f96991318e791c13e79f99def02545bf2f98612e",
    "commitMessage": "HEAD - Fix for 314836\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:23:54.816407962Z",
    "commitDate": "2010-05-31T16:33:44Z",
    "relevant": false,
    "irrelevantReason": "This commit only adds javadoc comments explaining how to configure compiler options for AST parsing. It is a documentation change, not a code transformation.",
    "isDuplicate": false,
    "reusability": 1,
    "codeImprovement": 1,
    "implementationEffort": 1,
    "trafficLight": "NOT_APPLICABLE",
    "isNewCategory": false,
    "canImplementInCurrentDsl": false,
    "summary": "This commit adds a Javadoc code example to `ASTParser.java` demonstrating how to set compiler options to parse Java 1.5 code correctly. This is a documentation change and does not represent a code transformation pattern suitable for the TriggerPattern DSL."
  },
  {
    "commitHash": "5c0cfb3641c8362936c7fe4eaf6b445685b35295",
    "commitMessage": "HEAD - Fix for 314836\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:23:54.816428100Z",
    "commitDate": "2010-05-31T16:37:54Z",
    "relevant": false,
    "irrelevantReason": "This commit only adds a javadoc comment block to the `setSource` method, providing further explanation on compiler options needed for parsing. It is a documentation change, not a code transformation.",
    "isDuplicate": false,
    "reusability": 1,
    "codeImprovement": 1,
    "implementationEffort": 1,
    "trafficLight": "NOT_APPLICABLE",
    "isNewCategory": false,
    "canImplementInCurrentDsl": false,
    "summary": "This commit adds a Javadoc paragraph to the `ASTParser.setSource()` method in `ASTParser.java`, explaining the need for explicit compiler options when parsing older Java versions. This is a documentation update and does not contain any code transformation patterns relevant for DSL mining."
  },
  {
    "commitHash": "9ef56e268a933491c63deb97771517601840bf6b",
    "commitMessage": "HEAD - Fixing Javadoc for ASTParser#setEnvironment\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:24:49.468206666Z",
    "commitDate": "2010-06-01T06:10:53Z",
    "relevant": false,
    "irrelevantReason": "The commit only contains Javadoc changes, which are not code transformations expressible as DSL rules.",
    "isDuplicate": false,
    "reusability": 0,
    "codeImprovement": 0,
    "implementationEffort": 0,
    "trafficLight": "NOT_APPLICABLE",
    "isNewCategory": false,
    "canImplementInCurrentDsl": false,
    "summary": "This commit exclusively updates Javadoc comments for the `ASTParser#setEnvironment` method. These changes are documentation-only and do not alter the underlying code logic or structure, making them irrelevant for generating code transformation DSL rules."
  },
  {
    "commitHash": "25be17e24d113dbd94082ea092a27701e47ebd01",
    "commitMessage": "HEAD - Fix for 314836\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:24:49.468321942Z",
    "commitDate": "2010-06-01T15:15:32Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 7,
    "codeImprovement": 6,
    "implementationEffort": 8,
    "trafficLight": "RED",
    "category": "Eclipse API Modernization",
    "isNewCategory": false,
    "categoryReason": "The change involves updating the recommended way to set compiler options in Eclipse JDT, which aligns with modernizing Eclipse-specific API usage.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "eclipse-api-modernization.sandbox-hint",
    "languageChangeNeeded": "The DSL needs to support multi-statement pattern matching and replacement, allowing a sequence of statements to be replaced by another sequence of statements. For instance, replacing several `options.put()` calls with a single `JavaCore.setComplianceOptions()` call. This would involve more advanced AST rewriting capabilities than current expression/single-statement focused transformations.",
    "dslRuleAfterChange": "{\n  \"pattern\": \"options.put(org.eclipse.jdt.core.JavaCore.COMPILER_COMPLIANCE, org.eclipse.jdt.core.JavaCore.VERSION_1_5);\\noptions.put(org.eclipse.jdt.core.JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, org.eclipse.jdt.core.JavaCore.VERSION_1_5);\\noptions.put(org.eclipse.jdt.core.JavaCore.COMPILER_SOURCE, org.eclipse.jdt.core.JavaCore.VERSION_1_5);\",\n  \"replacement\": \"org.eclipse.jdt.core.JavaCore.setComplianceOptions(org.eclipse.jdt.core.JavaCore.VERSION_1_5, options);\"\n}",
    "summary": "This commit refactors a Javadoc code example, replacing multiple manual `options.put()` calls for compiler compliance settings with a single `JavaCore.setComplianceOptions()` method call. While this is a good code modernization (more concise and less error-prone), the transformation involves replacing a sequence of three `options.put()` statements with a single `JavaCore.setComplianceOptions()` call. The current TriggerPattern DSL does not support such complex, multi-statement transformations, classifying it as RED. Additionally, Javadoc for `setEnvironment` and `@see` tag are updated."
  },
  {
    "commitHash": "44c1c470b0c8ef16ec270452a9bc7b0a267cf8d1",
    "commitMessage": "HEAD - Fix for 314898\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:25:04.535715691Z",
    "commitDate": "2010-06-17T16:18:23Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 8,
    "codeImprovement": 8,
    "implementationEffort": 2,
    "trafficLight": "GREEN",
    "category": "JDT Internal Refactoring",
    "isNewCategory": false,
    "categoryReason": "The change involves fixing a typo in internal Eclipse JDT API names, which is a type of internal refactoring to maintain code quality and correctness.",
    "canImplementInCurrentDsl": true,
    "dslRule": "/*!id: jdt.internal.typo.nameenviroment.to.nameenvironment*/\n/*!description: Fixes a typo in internal JDT API names, replacing \u0027Enviroment\u0027 with \u0027Environment\u0027 for both the interface and class. Improves code correctness and consistency.*/\n/*!severity: info*/\n/*!minJavaVersion: 8*/\n/*!tags: jdt, internal, refactoring, typo*/\norg.eclipse.jdt.internal.core.INameEnviromentWithProgress\n\u003d\u003e org.eclipse.jdt.internal.core.INameEnvironmentWithProgress\n;;\n\norg.eclipse.jdt.core.dom.NameEnviromentWithProgress\n\u003d\u003e org.eclipse.jdt.core.dom.NameEnvironmentWithProgress\n;;",
    "targetHintFile": "jdt-internal-refactoring.sandbox-hint",
    "summary": "This commit fixes a simple typo from \u0027Enviroment\u0027 to \u0027Environment\u0027 in the names of an internal JDT interface (`INameEnvironmentWithProgress`) and its corresponding class (`NameEnvironmentWithProgress`). The change affects import statements, variable declarations, and constructor invocations. This is a direct 1:1 replacement of fully qualified names and is fully implementable as a GREEN TriggerPattern DSL rule. The DSL implicitly handles updating all references (imports, type usages, `new` expressions) when the FQN is replaced. Two separate rules are provided for the interface and the class.",
    "dslValidationResult": "VALID"
  },
  {
    "commitHash": "3aecc549b2f7b1ddb2c2cf9712c8f70043311795",
    "commitMessage": "HEAD - Fix for 317972\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:25:48.633710027Z",
    "commitDate": "2010-06-25T14:58:52Z",
    "relevant": false,
    "irrelevantReason": "The commit only contains a spelling correction within Javadoc comments. The TriggerPattern DSL is designed for Java code transformations (expressions, statements, annotations, declarations) and explicitly states that comments are stripped before rule parsing. Therefore, this change cannot be expressed or detected by the DSL.",
    "isDuplicate": false,
    "reusability": 0,
    "codeImprovement": 0,
    "implementationEffort": 0,
    "trafficLight": "NOT_APPLICABLE",
    "isNewCategory": false,
    "canImplementInCurrentDsl": false,
    "summary": "This commit changes \u0027affect\u0027 to \u0027effect\u0027 within Javadoc comments in several JDT Core DOM classes. Since the TriggerPattern DSL operates on Java AST nodes and ignores comments, this type of textual change is outside its scope and cannot be generalized into a DSL rule."
  },
  {
    "commitHash": "19eef6f26c48016adc4a14301bf3da3ca0ccecb1",
    "commitMessage": "HEAD - Fix for 317468\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:25:59.730780912Z",
    "commitDate": "2010-06-28T18:52:15Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 2,
    "codeImprovement": 7,
    "implementationEffort": 9,
    "trafficLight": "RED",
    "category": "JDT Internal Refactoring",
    "isNewCategory": false,
    "categoryReason": "The change is an internal modification to how Eclipse JDT\u0027s ASTRewriteAnalyzer handles the formatting of enum constants, specifically regarding semicolon placement. It\u0027s a low-level fix within the JDT infrastructure itself.",
    "canImplementInCurrentDsl": false,
    "languageChangeNeeded": "The DSL would require capabilities to express complex conditional logic (if/else if), read and interpret AST tokens (TerminalTokens), check multiple rewrite events (RewriteEvent.REMOVED), and perform fine-grained text insertion/removal based on scanner offsets and token lookahead. These features are not supported by the current expression-based DSL.",
    "summary": "This commit fixes an internal bug in JDT\u0027s `ASTRewriteAnalyzer` related to the correct insertion or removal of semicolons after enum constants. The change introduces complex conditional logic, AST scanner interactions (e.g., `getScanner().readNext()`, `getCurrentEndOffset()`), and direct text manipulation (`doTextInsert`, `doTextRemove`) based on specific token types and rewrite events. This level of programmatic AST manipulation and control flow is beyond the capabilities of the current TriggerPattern DSL, which focuses on pattern matching and expression-level replacements. Therefore, this change is not implementable as a DSL rule."
  },
  {
    "commitHash": "b32bff89b335f9213e72a23b143872f67ac07452",
    "commitMessage": "HEAD - Fix for 317468\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:26:53.555723752Z",
    "commitDate": "2010-06-30T16:08:52Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 1,
    "codeImprovement": 7,
    "implementationEffort": 9,
    "trafficLight": "RED",
    "category": "JDT Internal Refactoring",
    "isNewCategory": false,
    "categoryReason": "The change fixes an internal logic error within Eclipse JDT\u0027s ASTRewriteAnalyzer, which is responsible for generating text edits for AST transformations.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "jdt-internal-refactoring.sandbox-hint",
    "languageChangeNeeded": "The DSL would need capabilities to express structural control flow refactorings, specifically moving statements out of conditional blocks or unifying duplicated statements into a single, unconditional statement after the conditional structure.",
    "summary": "The commit fixes an internal bug in JDT\u0027s `ASTRewriteAnalyzer` by moving the `pos \u003d endPos;` statement outside an `if-else` block, making it unconditionally executed. This ensures the position tracking variable `pos` is always updated, improving the correctness of subsequent text edits. This is a structural change to control flow logic that cannot be expressed by the current TriggerPattern DSL, which focuses on expression-level replacements rather than rearranging statements or control structures."
  },
  {
    "commitHash": "8597c894f19986d55bb5c18b9a06d2d0215ee70d",
    "commitMessage": "HEAD - Fix for 319900\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:27:05.725241198Z",
    "commitDate": "2010-07-15T14:52:30Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 5,
    "codeImprovement": 2,
    "implementationEffort": 8,
    "trafficLight": "RED",
    "category": "Code Style",
    "isNewCategory": false,
    "categoryReason": "The change improves internal code style by removing redundant escaping logic.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "jdt-internal-refactoring.sandbox-hint",
    "languageChangeNeeded": "The DSL would need to support structural modifications within switch statements, specifically the removal of a \u0027case\u0027 block.",
    "summary": "The commit removes a redundant \u0027case \u0027\\\u0027\u0027:` block from a switch statement in `StringLiteral.java`. This was an unnecessary escape sequence in the context of Java string literals. This change is a structural modification to a control flow statement (removing a case from a switch) and is not directly expressible using the current TriggerPattern DSL, which primarily focuses on expression-level replacements. Implementing this would require significant DSL extensions for structural switch statement manipulation."
  },
  {
    "commitHash": "200a72c26c52eaf559c601781ddfbb997711dd26",
    "commitMessage": "HEAD - Fix for 223225\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:27:40.591772213Z",
    "commitDate": "2010-07-22T13:24:34Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 1,
    "codeImprovement": 8,
    "implementationEffort": 10,
    "trafficLight": "RED",
    "category": "JDT Internal Bug Fix",
    "isNewCategory": true,
    "categoryReason": "The commit addresses an internal bug in JDT\u0027s DOM binding logic, specifically related to the handling and comparison of annotation member values, especially array types. This is a fix within JDT\u0027s core functionality, not a general application-level transformation.",
    "canImplementInCurrentDsl": false,
    "languageChangeNeeded": "The DSL would require significant extensions to support adding complex control flow statements (if/else blocks, for loops), declaring new local variables, performing explicit casts within the replacement, and handling multi-statement replacements with branching logic. The current DSL is limited to expression-level and simple statement-level pattern matching and replacement.",
    "summary": "This commit fixes an internal bug (223225) in JDT\u0027s `DefaultValuePairBinding` and `MemberValuePairBinding` classes, which handle annotation member value pairs. The changes involve adding logic to correctly wrap non-array default values into arrays when the annotation method\u0027s return type is an array, and significantly refactoring the `isEqualTo` method to perform a deep comparison for array values. These transformations introduce new `if` statements, `for` loops, local variable declarations, and complex conditional logic, which are not supported by the current TriggerPattern DSL capabilities for pattern-based transformations."
  },
  {
    "commitHash": "e0b71f0955015294aa51eae2753decb6574d6e98",
    "commitMessage": "HEAD- fix for 306524\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:27:54.092712603Z",
    "commitDate": "2010-07-29T07:41:12Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 1,
    "codeImprovement": 7,
    "implementationEffort": 10,
    "trafficLight": "RED",
    "category": "JDT Internal Bug Fix",
    "isNewCategory": true,
    "categoryReason": "The change fixes an internal bug within the JDT core\u0027s ASTRewrite mechanism, specifically related to comment preservation during node removal. This is not a general application-level modernization but an internal JDT infrastructure fix.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "jdt-internal-bug-fixes.sandbox-hint",
    "languageChangeNeeded": "The transformation involves adding complex control flow (try-catch, while loop, if-else), token scanning, and detailed manipulation of source offsets/ranges to handle comment preservation. The current TriggerPattern DSL is designed for expression/declaration-level pattern matching and replacement, not for programmatic AST traversal, token analysis, or inserting complex statement blocks with internal logic.",
    "summary": "This commit fixes an internal bug (Bug 306524) in JDT\u0027s `ASTRewriteAnalyzer`. It adds complex logic involving `TokenScanner` within `try-catch` blocks to prevent leading and trailing comments from being incorrectly removed during AST rewriting. This involves iterative token scanning, offset comparisons, and conditional adjustments to source ranges. This structural and algorithmic change is too complex for the current TriggerPattern DSL, which focuses on expression and declaration-level replacements. Therefore, it is classified as RED."
  },
  {
    "commitHash": "61350396ab95c541cebb2aa33b35ab02da9b054b",
    "commitMessage": "HEAD - Fix for 258905\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:28:43.024362780Z",
    "commitDate": "2010-08-31T20:09:04Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 1,
    "codeImprovement": 2,
    "implementationEffort": 9,
    "trafficLight": "RED",
    "category": "JDT Internal Bug Fix",
    "isNewCategory": false,
    "categoryReason": "The change is an internal fix within Eclipse JDT\u0027s binding resolution logic, specifically adding handling for java.lang.AssertionError.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "jdt-internal-refactoring.sandbox-hint",
    "languageChangeNeeded": "The DSL currently supports pattern matching and replacement of existing code structures (expressions, statements, method calls, constructors, annotations). It does not support inserting entirely new conditional blocks (like an \u0027else if\u0027 statement and its body) into an existing sequence of \u0027if-else if\u0027 statements, nor does it support complex structural additions to core internal JDT logic. This kind of change would require significant DSL extensions for structural code generation beyond simple replacements.",
    "summary": "This commit fixes Bug 258905 by adding specific handling for `java.lang.AssertionError` within JDT\u0027s internal `DefaultBindingResolver`. The change involves adding a new `else if` block to an existing conditional chain to resolve the `AssertionError` type. This is an internal JDT architectural modification to improve binding resolution, rather than a generalizable code transformation pattern for end-user code. The DSL is not capable of injecting entirely new conditional blocks into an existing code structure, nor is it designed for such low-level internal JDT logic manipulation. Therefore, it is classified as RED."
  },
  {
    "commitHash": "1df126b77b08d354ebfd5eda6a44830d9266b61e",
    "commitMessage": "HEAD - Fix for 48420\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:28:58.995250953Z",
    "commitDate": "2010-09-07T19:14:27Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 4,
    "codeImprovement": 7,
    "implementationEffort": 9,
    "trafficLight": "RED",
    "category": "JDT Internal Bug Fix",
    "isNewCategory": false,
    "categoryReason": "The commit addresses Bug 48420 by refactoring internal JDT Core DOM\u0027s VariableBinding to provide more complete information when creating LocalVariable objects, which is an internal bug fix and enhancement.",
    "canImplementInCurrentDsl": false,
    "targetHintFile": "jdt-internal-refactoring.sandbox-hint",
    "languageChangeNeeded": "Support for bitwise operators in replacement expressions (e.g., `(tagBits \u0026 TagBits.IsArgument) !\u003d 0`); ability to define and use temporary local variables (e.g., `localVariableBinding`, `modifiers`) within replacement logic; and capability to express complex multi-line control flow (e.g., switch statements) to compute argument values for method or constructor calls.",
    "summary": "This commit fixes Bug 48420 by enhancing the `LocalVariable` constructor call. It adds two new arguments: `modifiers` (computed via a `switch` statement based on the parent AST node\u0027s type) and a boolean indicating if it\u0027s an argument (`(localVariableBinding.tagBits \u0026 TagBits.IsArgument) !\u003d 0`). The computation of `modifiers` involves complex control flow, and the `isArgument` check uses a bitwise operator. Both bitwise operators in replacements and complex multi-line statement blocks for argument construction are explicitly unsupported by the current TriggerPattern DSL, classifying this as a RED transformation. The introduction of `localVariableBinding` is also a structural change (new local variable declaration) not directly supported."
  },
  {
    "commitHash": "874cc60b34062d184abafc157c764e3af128769a",
    "commitMessage": "HEAD - Fix for 325131\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:30:04.301626050Z",
    "commitDate": "2010-10-06T15:38:25Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 5,
    "codeImprovement": 6,
    "implementationEffort": 2,
    "trafficLight": "GREEN",
    "category": "JDT Internal Refactoring",
    "isNewCategory": false,
    "categoryReason": "The changes are specific to internal Eclipse JDT Core DOM API modernization and bug fixes.",
    "canImplementInCurrentDsl": true,
    "dslRule": "/*!id: jdt.internal.astnode.hashmap.capacity-and-type-update*/\n/*!description: Updates internal ASTNode property storage, changing HashMap constructor capacity and widening local variable type.*/\n/*!severity: info*/\n/*!minJavaVersion: 8*/\n/*!tags: jdt, internal, refactoring*/\njava.util.HashMap $m \u003d new java.util.HashMap(2)\n\u003d\u003e java.util.Map $m \u003d new java.util.HashMap(3)\n;;\n\n/*!id: jdt.internal.astnode.hashmap.cast-widening*/\n/*!description: Widens an internal cast from (HashMap) to (Map) for ASTNode properties.*/\n/*!severity: info*/\n/*!minJavaVersion: 8*/\n/*!tags: jdt, internal, refactoring*/\n(java.util.HashMap) $expr\n\u003d\u003e (java.util.Map) $expr\n;;",
    "targetHintFile": "jdt-internal-refactoring.sandbox-hint",
    "summary": "This commit fixes Bug 325131 by refactoring how `ASTNode` and `ASTRewrite` manage internal properties. The generalizable changes include: 1. Updating a specific `HashMap` constructor call to change its initial capacity from 2 to 3 and widening the declared type of the local variable from `HashMap` to `Map`. 2. Widening an internal cast from `(HashMap)` to `(Map)`. Other changes like Javadoc updates, adding new fields/methods, or complex `if-else` restructuring are not suitable for DSL rules. The two identified patterns are direct, 1:1 expression/type replacements, making them fully expressible as GREEN TriggerPattern DSL rules for internal JDT modernization.",
    "dslValidationResult": "VALID"
  },
  {
    "commitHash": "bce0dbd9dd489d3038652b337b4b76bb1f2246a4",
    "commitMessage": "HEAD - Fix for 328400\n",
    "repoUrl": "https://github.com/eclipse-jdt/eclipse.jdt.core",
    "evaluatedAt": "2026-04-04T04:30:20.230233026Z",
    "commitDate": "2010-10-22T20:15:04Z",
    "relevant": true,
    "isDuplicate": false,
    "reusability": 9,
    "codeImprovement": 8,
    "implementationEffort": 2,
    "trafficLight": "GREEN",
    "category": "JDT Internal Refactoring",
    "isNewCategory": false,
    "categoryReason": "This is an internal refactoring within Eclipse JDT Core DOM API, simplifying existing internal method calls.",
    "canImplementInCurrentDsl": true,
    "dslRule": "/*!id: jdt.internal.rewritemodifiers.packagenode-annotations*/\n/*!description: Updates internal JDT ASTRewriteAnalyzer to use rewriteModifiers2 for PackageDeclaration annotations, simplifying the rewriteNodeList call by removing redundant string arguments.*/\n/*!severity: info*/\n/*!minJavaVersion: 8*/\n/*!tags: jdt, internal, refactoring*/\nrewriteNodeList($node, org.eclipse.jdt.core.dom.PackageDeclaration.ANNOTATIONS_PROPERTY, $pos, \"\", \" \")\n\u003d\u003e rewriteModifiers2($node, org.eclipse.jdt.core.dom.PackageDeclaration.ANNOTATIONS_PROPERTY, $pos)\n;;",
    "targetHintFile": "jdt-internal-refactoring.sandbox-hint",
    "summary": "This commit refactors an internal JDT `ASTRewriteAnalyzer` method call. It replaces `rewriteNodeList(node, PackageDeclaration.ANNOTATIONS_PROPERTY, pos, \"\", \" \")` with a more concise `rewriteModifiers2(node, PackageDeclaration.ANNOTATIONS_PROPERTY, pos)`. This is a direct 1:1 method call replacement, removing redundant string literal arguments, which improves internal API usage and code clarity. It is fully expressible as a GREEN TriggerPattern DSL rule, targeting internal JDT refactoring.",
    "dslValidationResult": "VALID"
  }
]