Scala support

Author: jkschneider

.claude/settings.json

@@ -53,7 +53,11 @@
       "Bash(../../gradlew dependencies --configuration runtimeClasspath)",
       "Bash(../../gradlew dependencies --configuration implementation)",
       "Bash(../../gradlew dependencies)",
-      "Bash(../../gradlew dependencies --configuration compileClasspath)"
+      "Bash(../../gradlew dependencies --configuration compileClasspath)",
+      "Bash(javac:*)",
+      "Bash(java:*)",
+      "Bash(scalac:*)",
+      "Bash(scala:*)"
     ],
     "deny": []
   }

CLAUDE.md

@@ -8,6 +8,22 @@ When you need to know something about OpenRewrite:
 - Refer to the rewrite-docs folder (if available)
 - Consult Architecture Decision Records in `doc/adr/` for design decisions
 
+## CRITICAL PRINCIPLES - NEVER VIOLATE THESE
+
+### Never Regress from Rich Types to J.Unknown
+**ABSOLUTE RULE**: Once a syntax element has been mapped to a rich type (J.* or S.*), NEVER revert it back to J.Unknown. This is a fundamental architectural principle. J.Unknown should only be used for:
+1. Syntax we haven't implemented yet
+2. Temporary placeholders during initial development
+3. Truly unparseable or corrupted code
+
+If you find yourself wanting to use J.Unknown for something already mapped, you're doing it wrong. Instead:
+- Create a new S.* type if needed
+- Use markers to preserve special behavior
+- Extend existing J.* types with Scala-specific markers
+- Find a way to map it to existing rich types
+
+Going back to J.Unknown breaks type safety, loses semantic information, and makes the AST less useful for recipes.
+
 ## Project Overview
 
 OpenRewrite is an automated refactoring ecosystem for source code that eliminates technical debt through AST-based transformations. The project uses a visitor pattern architecture where **Recipes** define transformations and **TreeVisitors** traverse and modify Abstract Syntax Trees (ASTs).

DebugAssignment.scala

@@ -0,0 +1,8 @@
+object Test {
+  var (a, b) = (1, 2)
+  println(s"a = $a, b = $b")
+  
+  // This is the problematic line
+  (a, b) = (3, 4)
+  println(s"After assignment: a = $a, b = $b")
+}

DebugSpans.class

@@ -0,0 +1,17 @@
+public class DebugSpans {
+    public static void main(String[] args) {
+        String code = "object Test {\n  var (a, b) = (1, 2)\n  (a, b) = (3, 4)\n}";
+        System.out.println("Source code:");
+        System.out.println(code);
+        System.out.println("\nLine 3: '(a, b) = (3, 4)'");
+        
+        // Find the position of the second tuple
+        int lineStart = code.indexOf("  (a, b)");
+        System.out.println("Start of line 3: position " + lineStart);
+        
+        for (int i = lineStart; i < lineStart + 20 && i < code.length(); i++) {
+            char c = code.charAt(i);
+            System.out.printf("  pos %2d: '%s'\n", i, c == '\n' ? "\\n" : String.valueOf(c));
+        }
+    }
+}

DebugSpans.java

@@ -0,0 +1,16 @@
+import org.openrewrite.scala.ScalaParser;
+import org.openrewrite.scala.tree.S;
+import org.openrewrite.java.tree.J;
+
+public class DebugTupleSpans {
+    public static void main(String[] args) {
+        String code = "object Test {\n  var (a, b) = (1, 2)\n  (a, b) = (3, 4)\n}";
+        System.out.println("Source code:");
+        System.out.println(code);
+        System.out.println("\nCharacter positions:");
+        for (int i = 0; i < code.length(); i++) {
+            char c = code.charAt(i);
+            System.out.printf("%2d: '%s'\n", i, c == '\n' ? "\\n" : String.valueOf(c));
+        }
+    }
+}

DebugTupleSpans.java

@@ -0,0 +1 @@
+class Test { def add(x: Int, y: Int): Int = x + y; val addFive = add(5, _) }

PartialTest.scala

@@ -0,0 +1,21 @@
+import org.openrewrite.java.tree.*;
+import org.openrewrite.marker.Markers;
+import java.util.Collections;
+
+public class TestComplexType {
+    public static void main(String[] args) {
+        // Create a simple identifier "Int"
+        J.Identifier intId = new J.Identifier(
+            Tree.randomId(),
+            Space.EMPTY,
+            Markers.EMPTY,
+            Collections.emptyList(),
+            "Int",
+            null,
+            null
+        );
+        
+        System.out.println("Identifier simpleName: " + intId.getSimpleName());
+        System.out.println("Identifier toString: " + intId);
+    }
+}

TestComplexType.java

@@ -0,0 +1,4 @@
+object Test {
+  var (a, b) = (1, 2)
+  (a, b) = (3, 4)
+}

TestDebugTuple.scala

@@ -0,0 +1,72 @@
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.core.Contexts.*
+import dotty.tools.dotc.parsing.Parsers.Parser
+import dotty.tools.dotc.util.SourceFile
+import dotty.tools.dotc.CompilationUnit
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.Driver
+import dotty.tools.dotc.config.Settings
+
+object TestSpanDebug {
+  def main(args: Array[String]): Unit = {
+    val code = """object Test {
+  var (a, b) = (1, 2)
+  (a, b) = (3, 4)
+}"""
+    
+    // Setup compiler context
+    val driver = new Driver
+    given Context = driver.initCtx.fresh
+    
+    val source = SourceFile.virtual("test.scala", code)
+    val unit = CompilationUnit(source)
+    val parser = Parser(source)
+    val tree = parser.parse()
+    
+    def showTree(t: untpd.Tree, indent: Int = 0): Unit = {
+      val prefix = "  " * indent
+      val span = t.span
+      val spanStr = if (span.exists) {
+        val start = span.start
+        val end = span.end
+        val content = if (start >= 0 && end <= code.length) {
+          code.substring(start, end).replace("\n", "\\n")
+        } else "???"
+        s"[${start}-${end}] '$content'"
+      } else "[no span]"
+      
+      println(s"${prefix}${t.getClass.getSimpleName}: $spanStr")
+      
+      t match {
+        case pkg: untpd.PackageDef =>
+          pkg.stats.foreach(showTree(_, indent + 1))
+        case mod: untpd.ModuleDef =>
+          mod.impl.body.foreach(showTree(_, indent + 1))
+        case vd: untpd.ValDef =>
+          println(s"${prefix}  name: ${vd.name}")
+          if (vd.tpt != null) showTree(vd.tpt, indent + 1)
+          if (vd.rhs != null) showTree(vd.rhs, indent + 1)
+        case asg: untpd.Assign =>
+          println(s"${prefix}  LHS:")
+          showTree(asg.lhs, indent + 2)
+          println(s"${prefix}  RHS:")
+          showTree(asg.rhs, indent + 2)
+        case tuple: untpd.Tuple =>
+          println(s"${prefix}  Elements:")
+          tuple.trees.foreach(showTree(_, indent + 2))
+        case _ =>
+          // Show children
+          t.productIterator.foreach {
+            case child: untpd.Tree => showTree(child, indent + 1)
+            case list: List[_] => list.foreach {
+              case tree: untpd.Tree => showTree(tree, indent + 1)
+              case _ =>
+            }
+            case _ =>
+          }
+      }
+    }
+    
+    showTree(tree)
+  }
+}