Harden the Scala parser against a real-world corpus

rewrite-scala/src/main/java/org/openrewrite/scala/ScalaParserVisitor.java

@@ -73,16 +73,16 @@ public S.CompilationUnit visitCompilationUnit(ScalaParseResult parseResult) {
         CompilationUnitResult result = converter.convertToCompilationUnit(parseResult, source, typeFactory);
 
         J.Package packageDecl = result.getPackageDecl();
-        List<Statement> statements = result.getStatements();
+        List<JRightPadded<Statement>> statements = result.getStatements();
 
 
         // Filter out any Unknown statements that contain the entire source with package
         if (packageDecl != null) {
             final String packageName = packageDecl.getPackageName();
             statements = statements.stream()
-                .filter(stmt -> {
-                    if (stmt instanceof J.Unknown) {
-                        String text = ((J.Unknown) stmt).getSource().getText().trim();
+                .filter(rp -> {
+                    if (rp.getElement() instanceof J.Unknown) {
+                        String text = ((J.Unknown) rp.getElement()).getSource().getText().trim();
                         // Skip if this Unknown contains the same package declaration
                         boolean shouldFilter = text.startsWith("package " + packageName);
                         return !shouldFilter;
@@ -117,12 +117,14 @@ public S.CompilationUnit visitCompilationUnit(ScalaParseResult parseResult) {
                 unknownSource
             );
 
-            statements.add(unknown);
+            statements.add(JRightPadded.build(unknown));
         }
 
         // Get remaining source for EOF
         String remainingSource = converter.getRemainingSource(parseResult, source, result.getLastCursorPosition());
-        Space eof = remainingSource.isEmpty() ? EMPTY : Space.build(remainingSource, Collections.emptyList());
+        // Trailing source can hold comments, which belong in Space.comments rather than
+        // its whitespace
+        Space eof = remainingSource.isEmpty() ? EMPTY : ScalaSpace.format(remainingSource);
 
         // Build S.CompilationUnit
         return new S.CompilationUnit(
@@ -135,7 +137,7 @@ public S.CompilationUnit visitCompilationUnit(ScalaParseResult parseResult) {
             charsetBomMarked,              // boolean charsetBomMarked
             null,                          // Checksum checksum
             packageDecl == null ? null : JRightPadded.build(packageDecl),
-            JRightPadded.withElements(Collections.emptyList(), statements),
+            statements,
             eof                            // Space eof
         );
     }

rewrite-scala/src/main/java/org/openrewrite/scala/ScalaVisitor.java

@@ -246,6 +246,14 @@ public J visitConstructorInvocation(S.ConstructorInvocation constructorInvocatio
         return c;
     }
 
+    public J visitLiteralType(S.LiteralType literalType, P p) {
+        S.LiteralType l = literalType;
+        l = l.withPrefix(visitSpace(l.getPrefix(), Space.Location.LANGUAGE_EXTENSION, p));
+        l = l.withMarkers(visitMarkers(l.getMarkers(), p));
+        l = l.withLiteral(visitAndCast(l.getLiteral(), p));
+        return l;
+    }
+
     public J visitSingletonType(S.SingletonType singletonType, P p) {
         S.SingletonType s = singletonType;
         s = s.withPrefix(visitSpace(s.getPrefix(), Space.Location.LANGUAGE_EXTENSION, p));

rewrite-scala/src/main/java/org/openrewrite/scala/internal/ScalaSpace.java

@@ -109,8 +109,11 @@ public static Space format(String formatting, int beginIndex, int toIndex) {
                     } else if (last == '/' && blockDepth > 0) {
                         blockDepth++;
                         comment.append(c); // the '/' is already in the comment buffer
-                    } else {
+                    } else if (blockDepth > 0) {
                         comment.append(c);
+                    } else {
+                        // A bare `*` outside a comment, as in a `import a.*` wildcard
+                        prefix.append(c);
                     }
                     break;
                 default:

rewrite-scala/src/main/java/org/openrewrite/scala/tree/S.java

@@ -1742,6 +1742,51 @@ public S.ConstructorInvocation withArguments(JContainer<Expression> arguments) {
         }
     }
 
+    /**
+     * A Scala literal type: the {@code true} of {@code def f(): true}, or {@code "a"}, {@code -1}.
+     * The literal itself is the type; there is no {@code .type} suffix as in {@link SingletonType}.
+     */
+    @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+    @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true)
+    final class LiteralType implements S, TypeTree, Expression {
+
+        @With @Getter @EqualsAndHashCode.Include
+        UUID id;
+
+        @With @Getter
+        Space prefix;
+
+        @With @Getter
+        Markers markers;
+
+        // Not `J.Literal` so that negated literals like `-1` are captured too
+        @With @Getter
+        Expression literal;
+
+        @With @Getter
+        @Nullable
+        JavaType type;
+
+        public LiteralType(UUID id, Space prefix, Markers markers, Expression literal,
+                           @Nullable JavaType type) {
+            this.id = id;
+            this.prefix = prefix;
+            this.markers = markers;
+            this.literal = literal;
+            this.type = type;
+        }
+
+        @Override
+        public <P> J acceptScala(ScalaVisitor<P> v, P p) {
+            return v.visitLiteralType(this, p);
+        }
+
+        @Override
+        public CoordinateBuilder.Expression getCoordinates() {
+            return new CoordinateBuilder.Expression(this);
+        }
+    }
+
     /**
      * Represents a Scala singleton type: {@code foo.type}.
      * The qualifier is any expression, typically an object/module reference.