feat(scala): Add Scala 3 language support module

Add rewrite-scala module with Scala 3 (Dotty) compiler integration for
parsing Scala source code into OpenRewrite's Lossless Semantic Tree (LST).

Key features:
- ScalaTreeVisitor: Core AST converter from Dotty untyped trees to LST
- ScalaPrinter: LST-to-source-code printer with Scala-specific syntax
- S.java: Scala-specific AST types (MatchExpression, CaseClause, TuplePattern,
  InterpolatedString, BlockExpression, Wildcard, TypeAlias, FunctionType,
  InfixType, Extension, ForComprehension, etc.)
- Marker system for Scala idioms: BlockArgument, InfixNotation,
  FunctionApplication, LambdaParameter, ScalaForLoop, OmitBraces,
  ColonToken (fewer braces), and more
- Support for selective/aliased/wildcard/given imports
- Comprehensive test suite covering expressions, statements, classes,
  traits, objects, pattern matching, control flow, lambdas, generics,
  string interpolation, and Scala 3 features

Author: jkschneider

Scala.md

@@ -0,0 +1,47 @@
+# rewrite-scala
+
+Scala language support for OpenRewrite, following the same pattern as rewrite-kotlin and rewrite-groovy.
+
+## Active Development Plans
+
+- **Scala Language Support**: See [Scala.md](../Scala.md) for the implementation plan and progress tracking.
+- **Language Support Documentation**: As we implement Scala support, we're documenting the process in [Contributing Additional Language Support](../rewrite-docs/docs/authoring-recipes/contributing-language-support.md). This guide should be continuously updated with lessons learned during implementation.
+
+## 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.
+
+## Architecture
+
+- `S` interface extends `J` (Java's LST interface)
+- Reuses common JVM constructs from the J model
+- Adds Scala-specific constructs (pattern matching, traits, implicits, etc.) to the S interface
+- Uses Scala 3 (Dotty) compiler for parsing
+- LST model classes are implemented in Java (not Scala), following the K.java / G.java pattern
+
+## Key Files
+
+- `src/main/java/org/openrewrite/scala/tree/S.java` - Scala-specific AST types
+- `src/main/java/org/openrewrite/scala/ScalaParserVisitor.java` - Bridges Scala compiler AST to LST
+- `src/main/java/org/openrewrite/scala/ScalaPrinter.java` - LST to source code
+- `src/main/java/org/openrewrite/scala/ScalaVisitor.java` - Base visitor
+- `src/main/scala/org/openrewrite/scala/ScalaTreeVisitor.scala` - Core tree traversal
+
+## Build Commands
+
+```bash
+./gradlew :rewrite-scala:assemble    # Compile only
+./gradlew :rewrite-scala:test        # Run tests
+```

rewrite-scala/CLAUDE.md

@@ -0,0 +1,54 @@
+plugins {
+    id("org.openrewrite.build.language-library")
+    scala
+}
+
+dependencies {
+    api(project(":rewrite-java"))
+
+    // Scala 3 compiler (dotty) and library
+    implementation("org.scala-lang:scala3-compiler_3:latest.release")
+    implementation("org.scala-lang:scala3-library_3:latest.release")
+
+    compileOnly(project(":rewrite-test"))
+    compileOnly("org.slf4j:slf4j-api:1.7.+")
+
+    api("io.micrometer:micrometer-core:1.9.+")
+
+    api("org.jetbrains:annotations:latest.release")
+
+    api("com.fasterxml.jackson.core:jackson-annotations")
+
+    testImplementation(project(":rewrite-test"))
+    testImplementation(project(":rewrite-java-test"))
+    testImplementation("org.assertj:assertj-core:latest.release")
+    testImplementation("org.junit.jupiter:junit-jupiter-api:latest.release")
+    testImplementation("org.junit.jupiter:junit-jupiter-params:latest.release")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:latest.release")
+}
+
+// Configure Scala source sets and compilation order
+sourceSets {
+    main {
+        scala {
+            srcDirs("src/main/scala")
+        }
+    }
+}
+
+// Configure mixed Java/Scala compilation
+// Scala needs to see Java classes from the same module
+tasks.named<ScalaCompile>("compileScala") {
+    // Include Java source files in Scala compilation
+    source(sourceSets.main.get().java)
+    // Scala compiler will compile both Java and Scala files together
+    classpath = sourceSets.main.get().compileClasspath
+}
+
+// Ensure Java compilation uses output from Scala compilation
+// Since Scala already compiled Java files, we just need to ensure the classpath is correct
+tasks.named<JavaCompile>("compileJava") {
+    dependsOn("compileScala")
+    // Exclude Java files from Java compilation since Scala already compiled them
+    exclude("**/*.java")
+}

rewrite-scala/build.gradle.kts

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.scala;
+
+import org.intellij.lang.annotations.Language;
+import org.jspecify.annotations.Nullable;
+import org.openrewrite.SourceFile;
+import org.openrewrite.java.JavaParser;
+import org.openrewrite.scala.tree.S;
+import org.openrewrite.test.SourceSpec;
+import org.openrewrite.test.SourceSpecs;
+
+import java.util.function.Consumer;
+
+import static org.openrewrite.java.Assertions.sourceSet;
+import static org.openrewrite.test.SourceSpecs.dir;
+
+public class Assertions {
+
+    private Assertions() {
+    }
+
+    private static ScalaParser.Builder scalaParser = ScalaParser.builder()
+            .classpath(JavaParser.runtimeClasspath())
+            .logCompilationWarningsAndErrors(true);
+
+    public static SourceSpecs scala(@Language("scala") @Nullable String before) {
+        return scala(before, s -> {
+        });
+    }
+
+    public static SourceSpecs scala(@Language("scala") @Nullable String before, Consumer<SourceSpec<S.CompilationUnit>> spec) {
+        SourceSpec<S.CompilationUnit> scala = new SourceSpec<>(S.CompilationUnit.class, null, scalaParser, before, null);
+        spec.accept(scala);
+        return scala;
+    }
+
+    public static SourceSpecs scala(@Language("scala") @Nullable String before, @Language("scala") @Nullable String after) {
+        return scala(before, after, s -> {
+        });
+    }
+
+    public static SourceSpecs scala(@Language("scala") @Nullable String before, @Language("scala") @Nullable String after,
+                                    Consumer<SourceSpec<S.CompilationUnit>> spec) {
+        SourceSpec<S.CompilationUnit> scala = new SourceSpec<>(S.CompilationUnit.class, null, scalaParser, before, s -> after);
+        spec.accept(scala);
+        return scala;
+    }
+
+    public static SourceSpecs srcMainScala(Consumer<SourceSpec<SourceFile>> spec, SourceSpecs... scalaSources) {
+        return dir("src/main/scala", spec, scalaSources);
+    }
+
+    public static SourceSpecs srcMainScala(SourceSpecs... scalaSources) {
+        return srcMainScala(spec -> sourceSet(spec, "main"), scalaSources);
+    }
+
+    public static SourceSpecs srcTestScala(Consumer<SourceSpec<SourceFile>> spec, SourceSpecs... scalaSources) {
+        return dir("src/test/scala", spec, scalaSources);
+    }
+
+    public static SourceSpecs srcTestScala(SourceSpecs... scalaSources) {
+        return srcTestScala(spec -> sourceSet(spec, "test"), scalaSources);
+    }
+}