Repository: scalameta/scalameta
Pull request #2771 (2022-06-08 10:56:03)

chore: Update to Scala 2.12.16
Closes https://github.com/scalameta/scalameta/issues/2770


Patch:
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4bfddbfa2..512aeddc0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -18,9 +18,9 @@ jobs:
           - "++2.12.12 testsJVM/test"
           - "++2.12.13 testsJVM/test"
           - "++2.12.14 testsJVM/test"
-          - "++2.12.15 testsJVM/test"
-          - "++2.12.15 testsJS/test"
-          - "++2.12.15 testsNative/test"
+          - "++2.12.16 testsJVM/test"
+          - "++2.12.16 testsJS/test"
+          - "++2.12.16 testsNative/test"
           - "++2.13.1 testsJVM/test"
           - "++2.13.2 testsJVM/test"
           - "++2.13.3 testsJVM/test"
diff --git a/.github/workflows/cla.yml b/.github/workflows/cla.yml
new file mode 100644
index 000000000..07156da5d
--- /dev/null
+++ b/.github/workflows/cla.yml
@@ -0,0 +1,8 @@
+name: CLA
+on: [pull_request]
+jobs:
+  Check:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: ./bin/checkCLA.sh
diff --git a/.scalafmt.conf b/.scalafmt.conf
index 4ccca7fb2..26f401379 100644
--- a/.scalafmt.conf
+++ b/.scalafmt.conf
@@ -1,4 +1,4 @@
-version = 3.5.8
+version = 3.5.2
 runner.dialect = scala213
 align.preset = none
 align.stripMargin = true
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 22ec7d06b..401c5fda1 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -66,7 +66,8 @@ Tips to make your edit/test/debug worflow as productive as possible:
   least three lines were tried, committed, and reverted/refactored, and more
   than 10 were tried without committing.
 - **Feel free to send Proof-Of-Concept PRs** that you don't intend to get merged.
-
+- **Sign the Scala CLA**. Signed [CLA](https://www.lightbend.com/contribute/cla/scala)
+  is necessary to merge your PR.
 
 ## Documentation Guidelines
 
diff --git a/RELEASING.md b/RELEASING.md
index 9b159b6ae..f1e429785 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -63,3 +63,21 @@
   * https://github.com/scalameta/metadoc
   * https://github.com/scalameta/metals
   * https://github.com/sbt/sbt (see `SemanticdbPlugin`)
+
+## Releasing for a specific version
+
+Realeasing for a specific existing version, which is needed for example in case of new Scala version, is more complicated. The flow is as follows:
+
+- set the needed secrets (https://github.com/sbt/sbt-ci-release#secrets)
+
+- run sbt console, check if the credentials are available using `show credentials`, you might need to run sbt from bash when having issues with other shells
+
+- run `set every version := "4.5.9"` - replace `4.5.9` with the specific version you are releasing for
+
+- run `++2.12.16` or anothe Scala version you need
+
+- run `semanticdbScalacCore/publishSigned`, `semanticdbScalacPlugin/publishSigned` and `metac/publishSigned`
+
+- make sure that everything is properly generated to `target/sonatype-staging` directory
+
+- run `sonatypeBundleRelease`
\ No newline at end of file
diff --git a/bin/checkCLA.sh b/bin/checkCLA.sh
new file mode 100755
index 000000000..54c947724
--- /dev/null
+++ b/bin/checkCLA.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -eux
+
+AUTHOR=$GITHUB_ACTOR
+echo "Pull request submitted by $AUTHOR";
+url_author=$(echo $AUTHOR | jq -Rr "@uri")
+signed=$(curl -s https://www.lightbend.com/contribute/cla/scala/check/$url_author | jq -r ".signed")
+if [ "$signed" = "true" ] ; then
+  echo "CLA check for $AUTHOR successful";
+else
+  echo "CLA check for $AUTHOR failed";
+  echo "Please sign the Scala CLA to contribute to Scalameta";
+  echo "Go to https://www.lightbend.com/contribute/cla/scala and then resubmit this pull request";
+  exit 1;
+fi;
diff --git a/build.sbt b/build.sbt
index 26b35b39d..9bbc562b6 100644
--- a/build.sbt
+++ b/build.sbt
@@ -155,7 +155,7 @@ lazy val common = crossProject(JSPlatform, JVMPlatform, NativePlatform)
   .in(file("scalameta/common"))
   .settings(
     publishableSettings,
-    libraryDependencies += "com.lihaoyi" %%% "sourcecode" % "0.2.8",
+    libraryDependencies += "com.lihaoyi" %%% "sourcecode" % "0.2.7",
     description := "Bag of private and public helpers used in scalameta APIs and implementations",
     enableMacros,
     protobufSettings
@@ -324,7 +324,7 @@ lazy val testkit = crossProject(JSPlatform, JVMPlatform, NativePlatform)
     hasLargeIntegrationTests,
     libraryDependencies ++= Seq(
       "org.scalameta" %%% "munit" % munitVersion,
-      "com.lihaoyi" %%% "geny" % "0.7.1"
+      "com.lihaoyi" %%% "geny" % "0.7.0"
     ),
     testFrameworks := List(new TestFramework("munit.Framework")),
     description := "Testing utilities for scalameta APIs"
diff --git a/project/Versions.scala b/project/Versions.scala
index 3d3f3e359..dbead9a80 100644
--- a/project/Versions.scala
+++ b/project/Versions.scala
@@ -3,7 +3,7 @@ package build
 
 object Versions {
   val LatestScala211 = "2.11.12"
-  val LatestScala212 = "2.12.15"
+  val LatestScala212 = "2.12.16"
   val LatestScala213 = "2.13.8"
   val LegacyScalaVersions =
     List(
@@ -14,13 +14,14 @@ object Versions {
       "2.12.12",
       "2.12.13",
       "2.12.14",
+      "2.12.15",
       "2.13.0",
       "2.13.1",
       "2.13.2",
       "2.13.3",
       "2.13.4",
       "2.13.5",
-      "2.13.7",
-      "2.13.6"
+      "2.13.6",
+      "2.13.7"
     )
 }
diff --git a/project/plugins.sbt b/project/plugins.sbt
index 421ed05f4..6480bf6a7 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,23 +1,23 @@
 addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "1.2.0")
 
-addSbtPlugin("com.eed3si9n" % "sbt-unidoc" % "0.4.3")
+addSbtPlugin("com.eed3si9n" % "sbt-unidoc" % "0.4.2")
 
 addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.4.3")
 
 addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.11.0")
 
 addSbtPlugin("com.thesamet" % "sbt-protoc" % "1.0.6")
-libraryDependencies += "com.thesamet.scalapb" %% "compilerplugin" % "0.11.11"
+libraryDependencies += "com.thesamet.scalapb" %% "compilerplugin" % "0.11.10"
 
 libraryDependencies += "org.scala-sbt" %% "scripted-plugin" % sbtVersion.value
 
 addSbtPlugin("com.github.sbt" % "sbt-ci-release" % "1.5.10")
 
-addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "1.1.0")
+addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "1.0.1")
 
-addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.2.0")
+addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.1.0")
 
-addSbtPlugin("org.portable-scala" % "sbt-scala-native-crossproject" % "1.2.0")
+addSbtPlugin("org.portable-scala" % "sbt-scala-native-crossproject" % "1.1.0")
 
 addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.8.0")
 
@@ -25,6 +25,6 @@ addSbtPlugin("org.scala-debugger" % "sbt-jdi-tools" % "1.1.1")
 
 addSbtPlugin("org.scalameta" % "sbt-munit" % "0.7.29")
 
-addSbtPlugin("org.scalameta" % "sbt-mdoc" % "2.3.2")
+addSbtPlugin("org.scalameta" % "sbt-mdoc" % "2.3.1")
 
 addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.4.4")
diff --git a/scalameta/dialects/shared/src/main/scala/scala/meta/Dialect.scala b/scalameta/dialects/shared/src/main/scala/scala/meta/Dialect.scala
index 4a1eeadb7..21b4c9b35 100644
--- a/scalameta/dialects/shared/src/main/scala/scala/meta/Dialect.scala
+++ b/scalameta/dialects/shared/src/main/scala/scala/meta/Dialect.scala
@@ -150,9 +150,7 @@ final class Dialect private (
     // import a.b.c.{ given, _} used for -X:source3
     val allowGivenImports: Boolean,
     // Scala 3 uses proper precedence rules for infix types, unlike Scala 2
-    val useInfixTypePrecedence: Boolean,
-    // Scala213Source3 and Scala3 allow infix operator being placed after nl
-    val allowInfixOperatorAfterNL: Boolean
+    val useInfixTypePrecedence: Boolean
 ) extends Product with Serializable {
 
   // NOTE(olafur) checklist for adding a new dialect field in a binary compatible way:
@@ -241,8 +239,7 @@ final class Dialect private (
       allowPlusMinusUnderscoreAsIdent = false,
       allowPlusMinusUnderscoreAsPlaceholder = false,
       allowGivenImports = false,
-      useInfixTypePrecedence = false,
-      allowInfixOperatorAfterNL = false
+      useInfixTypePrecedence = false
       // NOTE(olafur): declare the default value for new fields above this comment.
     )
   }
@@ -432,10 +429,6 @@ final class Dialect private (
     privateCopy(useInfixTypePrecedence = newValue)
   }
 
-  def withAllowInfixOperatorAfterNL(newValue: Boolean): Dialect = {
-    privateCopy(allowInfixOperatorAfterNL = newValue)
-  }
-
   // NOTE(olafur): add the next `withX()` method above this comment. Please try
   // to use consistent formatting, use `newValue` as the parameter name and wrap
   // the body inside curly braces.
@@ -498,8 +491,8 @@ final class Dialect private (
       allowPlusMinusUnderscoreAsIdent: Boolean = this.allowPlusMinusUnderscoreAsIdent,
       allowPlusMinusUnderscoreAsPlaceholder: Boolean = this.allowPlusMinusUnderscoreAsPlaceholder,
       allowGivenImports: Boolean = this.allowGivenImports,
-      useInfixTypePrecedence: Boolean = this.useInfixTypePrecedence,
-      allowInfixOperatorAfterNL: Boolean = this.allowInfixOperatorAfterNL
+      useInfixTypePrecedence: Boolean = this.useInfixTypePrecedence
+
       // NOTE(olafur): add the next parameter above this comment.
   ): Dialect = {
     new Dialect(
@@ -559,8 +552,7 @@ final class Dialect private (
       allowPlusMinusUnderscoreAsIdent,
       allowPlusMinusUnderscoreAsPlaceholder,
       allowGivenImports,
-      useInfixTypePrecedence,
-      allowInfixOperatorAfterNL
+      useInfixTypePrecedence
       // NOTE(olafur): add the next argument above this comment.
     )
   }
diff --git a/scalameta/dialects/shared/src/main/scala/scala/meta/dialects/package.scala b/scalameta/dialects/shared/src/main/scala/scala/meta/dialects/package.scala
index 485239891..ae60af29c 100644
--- a/scalameta/dialects/shared/src/main/scala/scala/meta/dialects/package.scala
+++ b/scalameta/dialects/shared/src/main/scala/scala/meta/dialects/package.scala
@@ -65,7 +65,6 @@ package object dialects {
     .withAllowPostfixStarVarargSplices(true)
     .withAllowPlusMinusUnderscoreAsIdent(true)
     .withAllowGivenImports(true)
-    .withAllowInfixOperatorAfterNL(true)
 
   /**
    * Dialect starting with Scala 2.12.14 for `-Xsource:3` option
@@ -146,7 +145,6 @@ package object dialects {
     .withAllowDoWhile(false)
     .withAllowPlusMinusUnderscoreAsPlaceholder(true)
     .withUseInfixTypePrecedence(true)
-    .withAllowInfixOperatorAfterNL(true)
 
   @deprecated("Use Scala3 instead", "4.4.2")
   implicit val Dotty = Scala3
diff --git a/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/LazyTokenIterator.scala b/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/LazyTokenIterator.scala
index 3f410211f..07ecf9098 100644
--- a/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/LazyTokenIterator.scala
+++ b/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/LazyTokenIterator.scala
@@ -360,7 +360,7 @@ private[parsers] class LazyTokenIterator private (
           case _: RegionIndent | _: RegionIndentEnum => true
           case x: RegionParen => x.canProduceLF
           case _ => false
-        } && !next.isLeadingInfixOperator
+        }
       }
 
       def getIfCanProduceLF =
diff --git a/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/ScalametaParser.scala b/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/ScalametaParser.scala
index 6d426f19e..b71f5c357 100644
--- a/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/ScalametaParser.scala
+++ b/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/ScalametaParser.scala
@@ -601,42 +601,48 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
   @inline final def commaSeparated[T <: Tree: AstInfo](part: => T): List[T] =
     tokenSeparated[Comma, T](sepFirst = false, part)
 
-  private def makeTuple[T <: Tree](lpPos: Int, body: List[T], zero: => T, tuple: List[T] => T): T =
-    body match {
-      case Nil => autoEndPos(lpPos)(zero)
-      case only :: Nil =>
-        only match {
-          case q: Quasi if q.rank == 1 => copyPos(q)(tuple(body))
-          case _ => only
-        }
-      case _ => autoEndPos(lpPos)(tuple(body))
-    }
+  private def makeTuple[T <: Tree](body: List[T], zero: => T, tuple: List[T] => T): T = body match {
+    case Nil => zero
+    case only :: Nil =>
+      only match {
+        case q: Quasi if q.rank == 1 => copyPos(q)(tuple(body))
+        case _ => only
+      }
+    case _ => tuple(body)
+  }
 
-  def makeTupleTerm(lpPos: Int, body: List[Term]): Term = {
-    makeTuple(lpPos, body, Lit.Unit(), Term.Tuple.apply)
+  def makeTupleTerm(body: List[Term]): Term = {
+    // NOTE: we can't make this autoPos
+    // see comments to makeTupleType for discussion
+    makeTuple(body, Lit.Unit(), Term.Tuple.apply)
   }
 
-  def makeTupleType(lpPos: Int, body: List[Type]): Type = {
+  def makeTupleType(body: List[Type]): Type = {
     def invalidLiteralUnitType =
       syntaxError("illegal literal type (), use Unit instead", at = token.pos)
-    makeTuple(lpPos, body, invalidLiteralUnitType, Type.Tuple.apply)
+    // NOTE: we can't make this autoPos
+    // because, by the time control reaches this method, we're already past the closing parenthesis
+    // therefore, we'll rely on our callers to assign positions to the tuple we return
+    // we can't do atPos(body.first, body.last) either, because that wouldn't account for parentheses
+    makeTuple(body, invalidLiteralUnitType, Type.Tuple.apply)
   }
 
   def inParensOrTupleOrUnitExpr(allowRepeated: Boolean): Term = {
-    val lpPos = auto.startTokenPos
+    // NOTE: we can't make this autoPos
+    // see comments to makeTupleType for discussion
     val maybeTupleArgs = inParens({
       if (token.is[RightParen]) Nil
       else commaSeparated(expr(location = PostfixStat, allowRepeated = allowRepeated))
     })
     maybeTupleArgs match {
       case singleArg :: Nil =>
-        makeTupleTerm(lpPos, maybeAnonymousFunction(singleArg) :: Nil)
+        makeTupleTerm(maybeAnonymousFunctionInParens(singleArg) :: Nil)
       case multipleArgs =>
         val repeatedArgs = multipleArgs.collect { case repeated: Term.Repeated => repeated }
         repeatedArgs.foreach(arg =>
           syntaxError("repeated argument not allowed here", at = arg.tokens.last.prev)
         )
-        makeTupleTerm(lpPos, multipleArgs)
+        makeTupleTerm(multipleArgs)
     }
   }
 
@@ -696,6 +702,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
         } while (acceptOpt[Comma] || token.is[Ellipsis])
       }
       else Nil
+      val closeParenPos = in.tokenPos
       accept[RightParen]
       // NOTE: can't have this, because otherwise we run into #312
       // newLineOptWhenFollowedBy[LeftParen]
@@ -712,12 +719,11 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
       } else if (allowFunctionType && acceptOpt[ContextArrow]) {
         Type.ContextFunction(ts, typeIndentedOpt())
       } else {
-        ts.foreach {
+        val tuple = atPos(openParenPos, closeParenPos)(makeTupleType(ts map {
           case t: Type.ByName => syntaxError("by name type not allowed here", at = t)
           case t: Type.Repeated => syntaxError("repeated type not allowed here", at = t)
-          case _ =>
-        }
-        val tuple = makeTupleType(openParenPos, ts)
+          case t: Type => t
+        }))
         infixTypeRest(compoundTypeRest(annotTypeRest(simpleTypeRest(tuple))))
       }
     }
@@ -844,10 +850,10 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
     private final def infixTypeRestWithPrecedence(t: Type): Type = {
       val ctx = TypeInfixContext
       val base = ctx.stack
-      @inline def reduce(rhs: ctx.Typ, op: Option[ctx.Op]): ctx.Typ =
+      @inline def reduce(rhs: ctx.Rhs, op: Option[ctx.Op]): ctx.Lhs =
         ctx.reduceStack(base, rhs, rhs, op)
       @tailrec
-      def loop(rhs: ctx.Typ): ctx.Typ = token match {
+      def loop(rhs: ctx.Rhs): ctx.Lhs = token match {
         case Ident("*") if ahead(token match {
               case _: RightParen | _: Comma | _: Equals | _: RightBrace | _: EOF => true
               case _ => false
@@ -894,9 +900,8 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
       dialect.allowPlusMinusUnderscoreAsIdent || dialect.allowPlusMinusUnderscoreAsPlaceholder
 
     def simpleType(): Type = {
-      val startPos = auto.startTokenPos
-      val res = token match {
-        case LeftParen() => makeTupleType(startPos, inParensOnOpen(types()))
+      simpleTypeRest(autoPos(token match {
+        case LeftParen() => makeTupleType(inParensOnOpen(types()))
         case Underscore() => next(); Type.Placeholder(typeBounds())
         case MacroSplicedIdent() =>
           Type.Macro(macroSplicedIdent())
@@ -944,8 +949,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
             accept[KwType]
             Type.Singleton(ref)
           }
-      }
-      simpleTypeRest(autoEndPos(startPos)(res), startPos)
+      }))
     }
 
     @inline
@@ -1123,10 +1127,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
     }
   }
 
-  def selector(t: Term, startPos: Int): Term.Select =
-    autoEndPos(startPos)(Term.Select(t, termName()))
-  @inline
-  def selector(t: Term): Term.Select = selector(t, t.startTokenPos)
+  def selector(t: Term): Term.Select = autoEndPos(t)(Term.Select(t, termName()))
   @tailrec
   private final def selectors(t: Term): Term.Ref = {
     val t1 = selector(t)
@@ -1755,16 +1756,20 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
   // See `postfixExpr` for an involved usage example.
   // Another, much less involved usage, lives in `pattern3`.
   sealed abstract class InfixContext {
+    // Lhs is the type of the left-hand side of an infix expression.
     // (Lhs, op and targs form UnfinishedInfix).
+    // Rhs if the type of the right-hand side.
     // FinishedInfix is the type of an infix expression.
     // The conversions are necessary to push the output of finishInfixExpr on stack.
-    type Typ
+    type Lhs
+    type Rhs
     type Op <: Name
     type UnfinishedInfix <: Unfinished
+    def toLhs(rhs: Rhs): Lhs
 
     // Represents an unfinished infix expression, e.g. [a * b +] in `a * b + c`.
     protected trait Unfinished {
-      def lhs: Typ
+      def lhs: Lhs
       def op: Op
       final def precedence = op.precedence
       override def toString = s"[$lhs $op]"
@@ -1782,10 +1787,10 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
 
     def reduceStack(
         stack: List[UnfinishedInfix],
-        curr: Typ,
+        curr: Rhs,
         currEnd: EndPos,
         op: Option[Op]
-    ): Typ = {
+    ): Lhs = {
       val opPrecedence = op.fold(0)(_.precedence)
       val leftAssoc = op.forall(_.isLeftAssoc)
 
@@ -1802,9 +1807,9 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
       // Then convert the result, so that it can become someone else's rhs.
       // Repeat while precedence and associativity allow.
       @tailrec
-      def loop(rhs: Typ): Typ = {
+      def loop(rhs: Rhs): Lhs = {
         if (!canReduce) {
-          rhs
+          toLhs(rhs)
         } else {
           val lhs = pop()
           val fin = finishInfixExpr(lhs, rhs, currEnd)
@@ -1819,7 +1824,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
     // then takes the right-hand side (which can have multiple args), e.g. ` (y, z)`,
     // and creates `x + (y, z)`.
     // We need to carry endPos explicitly because its extent may be bigger than rhs because of parent of whatnot.
-    protected def finishInfixExpr(unf: UnfinishedInfix, rhs: Typ, rhsEnd: EndPos): Typ
+    protected def finishInfixExpr(unf: UnfinishedInfix, rhs: Rhs, rhsEnd: EndPos): Rhs
   }
 
   // Infix syntax in terms is borderline crazy.
@@ -1827,17 +1832,25 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
   // For example, did you know that `a * b + (c, d) * (f, g: _*)` means:
   // a.$times(b).$plus(scala.Tuple2(c, d).$times(f, g: _*))?!
   //
+  // Therefore, Lhs = List[Term], Rhs = List[Term], FinishedInfix = Term.
+  //
   // Actually there's even crazier stuff in scala-compiler.jar.
   // Apparently you can parse and typecheck `a + (bs: _*) * c`,
   // however I'm going to error out on this.
   object termInfixContext extends InfixContext {
-    type Typ = Term
+    type Lhs = Term
+    type Rhs = Term
     type Op = Term.Name
 
+    def toLhs(rhs: Rhs): Lhs = rhs match {
+      case Term.Tuple((arg @ (_: Lit.Unit | _: Term.Tuple)) :: Nil) => arg
+      case _ => rhs
+    }
+
     // We need to carry lhsStart/lhsEnd separately from lhs.pos
     // because their extent may be bigger than lhs because of parentheses or whatnot.
     case class UnfinishedInfix(
-        lhs: Typ,
+        lhs: Lhs,
         op: Op,
         targs: List[Type]
     ) extends Unfinished {
@@ -1847,13 +1860,8 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
       }
     }
 
-    protected def finishInfixExpr(unf: UnfinishedInfix, rhs: Typ, rhsEnd: EndPos): Typ = {
-      val UnfinishedInfix(lhsExt, op, targs) = unf
-      val lhs = lhsExt match {
-        case Term.Tuple(arg :: Nil) => arg
-        case x => x
-      }
-
+    protected def finishInfixExpr(unf: UnfinishedInfix, rhs: Rhs, rhsEnd: EndPos): Rhs = {
+      val UnfinishedInfix(lhs, op, targs) = unf
       if (lhs.is[Term.Repeated])
         syntaxError("repeated argument not allowed here", at = lhs.tokens.last.prev)
 
@@ -1863,7 +1871,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
           case Term.Tuple(args) => args
           case _ => rhs :: Nil
         }
-        atPos(lhsExt, rhsEnd)(Term.ApplyInfix(lhs, op, targs, args))
+        atPos(lhs, rhsEnd)(Term.ApplyInfix(lhs, op, targs, args))
       }
 
       op match {
@@ -1876,7 +1884,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
 
           rhs match {
             case Term.PartialFunction(cases) =>
-              atPos(lhsExt, rhsEnd)(Term.Match(lhs, cases))
+              atPos(lhs, rhsEnd)(Term.Match(lhs, cases))
             case _ =>
               syntaxError("match statement requires cases", at = lhs.tokens.last.prev)
           }
@@ -1888,33 +1896,38 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
 
   // In comparison with terms, patterns are trivial.
   implicit object patInfixContext extends InfixContext {
-    type Typ = Pat
+    type Lhs = Pat
+    type Rhs = Pat
     type Op = Term.Name
 
-    case class UnfinishedInfix(lhs: Typ, op: Op) extends Unfinished
+    def toLhs(rhs: Rhs): Lhs = rhs match {
+      case Pat.Tuple((arg @ (_: Lit.Unit | _: Pat.Tuple)) :: Nil) => arg
+      case _ => rhs
+    }
+
+    case class UnfinishedInfix(lhs: Lhs, op: Op) extends Unfinished
 
-    protected def finishInfixExpr(unf: UnfinishedInfix, rhs: Typ, rhsEnd: EndPos): Typ = {
-      val UnfinishedInfix(lhsExt, op) = unf
-      val lhs = lhsExt match {
-        case Pat.Tuple(arg :: Nil) => arg
-        case x => x
-      }
+    protected def finishInfixExpr(unf: UnfinishedInfix, rhs: Rhs, rhsEnd: EndPos): Rhs = {
+      val UnfinishedInfix(lhs, op) = unf
       val args = rhs match {
         case _: Lit.Unit => Nil
         case Pat.Tuple(args) => args
         case _ => rhs :: Nil
       }
-      atPos(lhsExt, rhsEnd)(Pat.ExtractInfix(lhs, op, args))
+      atPos(lhs, rhsEnd)(Pat.ExtractInfix(lhs, op, args))
     }
   }
 
   private object TypeInfixContext extends InfixContext {
-    type Typ = Type
+    type Lhs = Type
+    type Rhs = Type
     type Op = Type.Name
 
-    case class UnfinishedInfix(lhs: Typ, op: Op) extends Unfinished
+    def toLhs(rhs: Rhs): Lhs = rhs
+
+    case class UnfinishedInfix(lhs: Lhs, op: Op) extends Unfinished
 
-    protected def finishInfixExpr(unf: UnfinishedInfix, rhs: Typ, rhsEnd: EndPos): Typ = {
+    protected def finishInfixExpr(unf: UnfinishedInfix, rhs: Rhs, rhsEnd: EndPos): Rhs = {
       val UnfinishedInfix(lhs, op) = unf
       atPos(lhs, rhsEnd)(Type.ApplyInfix(lhs, op, rhs))
     }
@@ -1938,7 +1951,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
     // rhsStartK/rhsEndK may be bigger than then extent of rhsK,
     // so we really have to track them separately.
     @tailrec
-    def loop(rhsK: ctx.Typ): ctx.Typ = {
+    def loop(rhsK: ctx.Rhs): ctx.Rhs = {
       if (!token.is[Ident] && !token.is[Unquote] &&
         !(token.is[KwMatch] && dialect.allowMatchAsOperator)) {
         // Infix chain has ended.
@@ -2145,7 +2158,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
           newLineOptWhenFollowedBy[Dot]
           simpleExprRest(clause, canApply = false, startPos = startPos)
         } else {
-          simpleExprRest(selector(t, startPos), canApply = true, startPos = startPos)
+          simpleExprRest(selector(t), canApply = true, startPos = startPos)
         }
       case LeftBracket() =>
         t match {
@@ -2175,9 +2188,8 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
     }
   }
 
-  private def argumentExprsOrPrefixExpr(location: Location): termInfixContext.Typ = {
-    val isBrace = token.is[LeftBrace]
-    if (!isBrace && token.isNot[LeftParen]) prefixExpr(allowRepeated = false)
+  private def argumentExprsOrPrefixExpr(location: Location): termInfixContext.Rhs = {
+    if (token.isNot[LeftBrace] && token.isNot[LeftParen]) prefixExpr(allowRepeated = false)
     else {
       def findRep(args: List[Term]): Option[Term.Repeated] = args.collectFirst {
         case Term.Assign(_, rep: Term.Repeated) => rep
@@ -2185,17 +2197,32 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
       }
       val lpPos = auto.startTokenPos
       val args = checkNoTripleDots(argumentExprs(location))
+      val rpPos = auto.endTokenPos
+      @inline def addPos(body: Term): Term = {
+        body match {
+          // For `Term.Ref`, avoid using autoPos to exclude parens tokens in Term.ApplyInfix.args.
+          // For `a f (b)`, autoPos include `(b)` for ApplyInfix.args position.
+          // https://github.com/scalacenter/scalafix/issues/1594
+          case _: Term.Ref =>
+            body
+          case _ =>
+            atPosWithBody(lpPos, body, rpPos)
+        }
+      }
       token match {
         case Dot() | LeftBracket() | LeftParen() | LeftBrace() | Underscore() =>
           findRep(args).foreach(x => syntaxError("repeated argument not allowed here", at = x))
-          simpleExprRest(makeTupleTerm(lpPos, args), canApply = true, startPos = lpPos)
+          simpleExprRest(addPos(makeTupleTerm(args)), canApply = true)
         case _ =>
-          args match {
+          addPos(args match {
             case arg :: Nil =>
-              val res = maybeAnonymousFunction(arg)
-              if (isBrace) res else autoEndPos(lpPos)(Term.Tuple(res :: Nil))
-            case _ => makeTupleTerm(lpPos, args)
-          }
+              maybeAnonymousFunctionInParens(arg) match {
+                case t: Lit.Unit => Term.Tuple(t :: Nil)
+                case t: Term.Tuple if t.args.lengthCompare(1) != 0 => Term.Tuple(t :: Nil)
+                case t => t
+              }
+            case _ => makeTupleTerm(args)
+          })
       }
     }
   }
@@ -2495,7 +2522,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
       val lhs = simplePattern(badPattern3, isForComprehension = isForComprehension)
       val base = ctx.stack
       @tailrec
-      def loop(rhs: ctx.Typ): ctx.Typ = {
+      def loop(rhs: ctx.Rhs): ctx.Rhs = {
         val op =
           if (isIdentExcept("|") || token.is[Unquote]) Some(termName())
           else None
@@ -2598,12 +2625,11 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
         case _: Xml.Start =>
           xmlPat()
         case _: LeftParen =>
-          val lpPos = auto.startTokenPos
           val patterns = inParensOnOpen(if (token.is[RightParen]) Nil else noSeq.patterns())
-          val tuple = makeTuple(lpPos, checkNoTripleDots(patterns), Lit.Unit(), Pat.Tuple.apply)
           patterns match {
-            case x :: Nil if isRhs && !x.is[Quasi] => Pat.Tuple(tuple :: Nil)
-            case _ => tuple
+            case (_: Lit.Unit) :: Nil if isRhs => Pat.Tuple(patterns)
+            case Pat.Tuple(x) :: Nil if isRhs && x.lengthCompare(1) != 0 => Pat.Tuple(patterns)
+            case _ => makeTuple(checkNoTripleDots(patterns), Lit.Unit(), Pat.Tuple.apply)
           }
         case _: MacroQuote =>
           QuotedPatternContext.within {
@@ -3332,9 +3358,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
 
     def parents() = {
       val parents = ListBuffer[Init](
-        autoEndPos(decltype)(
-          initRest(decltype, allowArgss = true, allowBraces = false, allowTypeSingleton = false)
-        )
+        autoEndPos(decltype)(initRest(decltype, allowArgss = true, allowBraces = false))
       )
       while (token.is[KwWith] && tryAhead[Ident]) parents += init()
       parents.toList
@@ -3753,20 +3777,15 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
       val t = autoPos(Term.This(autoPos { accept[KwThis]; Name.Anonymous() }))
       copyPos(t)(Type.Singleton(t))
     }
-    initRest(tpe, allowArgss = true, allowBraces = true, allowTypeSingleton = true)
+    initRest(tpe, allowArgss = true, allowBraces = true)
   }
 
   def initInsideAnnotation(allowArgss: Boolean): Init = {
-    initRest(
-      exprSimpleType(),
-      allowArgss = allowArgss,
-      allowBraces = false,
-      allowTypeSingleton = true
-    )
+    initRest(exprSimpleType(), allowArgss = allowArgss, allowBraces = false)
   }
 
   def initInsideTemplate(): Init = {
-    initRest(startModType(), allowArgss = true, allowBraces = false, allowTypeSingleton = false)
+    initRest(startModType(), allowArgss = true, allowBraces = false)
   }
 
   def quasiquoteInit(): Init = entrypointInit()
@@ -3778,12 +3797,7 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
     }
   }
 
-  def initRest(
-      typeParser: => Type,
-      allowArgss: Boolean,
-      allowBraces: Boolean,
-      allowTypeSingleton: Boolean
-  ): Init = autoPos {
+  def initRest(typeParser: => Type, allowArgss: Boolean, allowBraces: Boolean): Init = autoPos {
     def isPendingArglist = token.is[LeftParen] || (token.is[LeftBrace] && allowBraces)
     def newlineOpt() = {
       if (dialect.allowSignificantIndentation)
@@ -3795,8 +3809,6 @@ class ScalametaParser(input: Input)(implicit dialect: Dialect) { parser =>
         unquote[Init](t)
       case _ =>
         val tpe = typeParser
-        if (!allowTypeSingleton && tpe.is[Type.Singleton])
-          syntaxError(s"class type required but ${tpe.toString()} found", at = tpe.pos)
         val name = autoPos(Name.Anonymous())
         val argss = mutable.ListBuffer[List[Term]]()
         @inline def body() = {
@@ -4334,9 +4346,15 @@ object ScalametaParser {
   private def maybeAnonymousFunctionUnlessPostfix(expr: Term)(location: Location): Term =
     if (location == Location.PostfixStat) expr else maybeAnonymousFunction(expr)
 
-  private def maybeAnonymousFunction(t: Term): Term = {
-    val ok = PlaceholderChecks.hasPlaceholder(t, includeArg = false)
-    if (ok) copyPos(t)(Term.AnonymousFunction(t)) else t
+  @inline
+  private def maybeAnonymousFunctionInParens(expr: Term): Term = expr match {
+    case _: Term.Ascribe | _: Term.Repeated => expr
+    case _ => maybeAnonymousFunction(expr)
+  }
+
+  private def maybeAnonymousFunction(expr: Term): Term = expr match {
+    case _: Term.Placeholder | _: Term.AnonymousFunction | _: Term.Repeated => expr
+    case t => if (PlaceholderChecks.hasPlaceholder(t)) copyPos(t)(Term.AnonymousFunction(t)) else t
   }
 
 }
diff --git a/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/ScannerTokens.scala b/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/ScannerTokens.scala
index 0bf847247..efc972a6d 100644
--- a/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/ScannerTokens.scala
+++ b/scalameta/parsers/shared/src/main/scala/scala/meta/internal/parsers/ScannerTokens.scala
@@ -106,7 +106,7 @@ class ScannerTokens(tokens: Tokens, input: Input)(implicit dialect: Dialect) {
       @inline
       def strictNext: Token = getStrictAfterSafe(nextSafe)
 
-      def isLeadingInfixOperator: Boolean = dialect.allowInfixOperatorAfterNL && {
+      def isLeadingInfixOperator: Boolean = dialect.allowSignificantIndentation && {
         val text = token.text
         @tailrec
         def iter(idx: Int, nonEmpty: Boolean): Boolean = {
diff --git a/scalameta/trees/shared/src/main/scala/scala/meta/internal/prettyprinters/TreeSyntax.scala b/scalameta/trees/shared/src/main/scala/scala/meta/internal/prettyprinters/TreeSyntax.scala
index ecc2530b6..3f16814ca 100644
--- a/scalameta/trees/shared/src/main/scala/scala/meta/internal/prettyprinters/TreeSyntax.scala
+++ b/scalameta/trees/shared/src/main/scala/scala/meta/internal/prettyprinters/TreeSyntax.scala
@@ -15,13 +15,11 @@ import Show.{
 }
 import scala.meta.internal.trees.{root => _, branch => _, _}
 import scala.meta.internal.tokenizers.Chars._
-import scala.meta.internal.trees.Origin.Parsed
 import org.scalameta.adt._
 import org.scalameta.invariants._
 import org.scalameta.unreachable
 import scala.compat.Platform.EOL
 import scala.meta.inputs.Position
-import scala.meta.tokens.Token
 
 object TreeSyntax {
   private final object SyntaxInstances {
@@ -690,20 +688,7 @@ object TreeSyntax {
           s(p(AnyInfixTyp, t.tpe), " ", kw("match"), " {", r(t.cases.map(i(_)), ""), n("}"))
         )
       case t: Type.Placeholder =>
-        /* In order not to break existing tools `.syntax` should still return
-         * `_` instead `?` unless specifically used.
-         */
-        def isScala3Dialect = dialect.allowSignificantIndentation
-        def questionMarkUsed = t.origin match {
-          case _: Origin.Parsed =>
-            !t.tokens.exists {
-              case _: Token.Underscore => true
-              case _ => false
-            }
-          case _ => false
-        }
-        if (dialect.allowQuestionMarkPlaceholder && (isScala3Dialect || questionMarkUsed))
-          m(SimpleTyp, s(kw("?"), t.bounds))
+        if (dialect.allowQuestionMarkPlaceholder) m(SimpleTyp, s(kw("?"), t.bounds))
         else m(SimpleTyp, s(kw("_"), t.bounds))
       case t: Type.Bounds =>
         s(
diff --git a/scalameta/trees/shared/src/main/scala/scala/meta/internal/trees/PlaceholderChecks.scala b/scalameta/trees/shared/src/main/scala/scala/meta/internal/trees/PlaceholderChecks.scala
index 708ae3d15..cb2385bdb 100644
--- a/scalameta/trees/shared/src/main/scala/scala/meta/internal/trees/PlaceholderChecks.scala
+++ b/scalameta/trees/shared/src/main/scala/scala/meta/internal/trees/PlaceholderChecks.scala
@@ -18,12 +18,12 @@ object PlaceholderChecks {
     case _ => false
   }
 
-  def hasPlaceholder(tree: Tree, includeArg: => Boolean): Boolean = {
+  def hasPlaceholder(tree: Tree): Boolean = {
     val queue = new mutable.Queue[Tree]
     @tailrec
-    def iter: Boolean =
-      queue.dequeue() match {
-        case t if isPlaceholder(t) => t.ne(tree) || includeArg
+    def iter: Boolean = {
+      val term = queue.dequeue()
+      isPlaceholder(term) || (term match {
         case t: Term.Select => queue += t.qual; iter
         case t: Term.Tuple => t.args.exists(isPlaceholder)
         case t: Term.Apply =>
@@ -31,12 +31,11 @@ object PlaceholderChecks {
         case t: Term.ApplyInfix =>
           isBlockPlaceholder(t.args) || { queue += t.lhs; queue ++= t.args; iter }
         case t: Term.ApplyUnary => queue += t.arg; iter
-        case t: Term.ApplyType => queue += t.fun; iter
-        case t: Term.New => queue += t.init; iter
         case t: Term.Repeated => queue += t.expr; iter
-        case t: Term.AnonymousFunction => t.ne(tree) && queue.nonEmpty && iter
+        case _: Term.AnonymousFunction => queue.nonEmpty && iter
         case t => t.children.exists(isPlaceholder) || queue.nonEmpty && iter
-      }
+      })
+    }
     queue += tree
     iter
   }
diff --git a/semanticdb/integration/src/main/scala/example/MetacJava.scala b/semanticdb/integration/src/main/scala/example/MetacJava.scala
index 8a8f20336..3cb87e9f9 100644
--- a/semanticdb/integration/src/main/scala/example/MetacJava.scala
+++ b/semanticdb/integration/src/main/scala/example/MetacJava.scala
@@ -8,8 +8,9 @@ class MetacJava {
   val inner = new javacp.MetacJava()
   val overload1 = new inner.Overload1()
   val overload2 = new inner.Overload2()
-  inner.overload(new overload1.A())
-  inner.overload(new overload2.A())
+  // https://github.com/scala/bug/issues/12605
+  // inner.overload(new overload1.A())
+  // inner.overload(new overload2.A())
   val staticInner = new javacp.MetacJava.StaticInner()
   val nonStatic = new staticInner.NonStatic()
   nonStatic.method(nonStatic)
diff --git a/semanticdb/scalac/library/src/main/scala-2.12.16/scala/meta/internal/semanticdb/scalac/SemanticdbReporter.scala b/semanticdb/scalac/library/src/main/scala-2.12.16/scala/meta/internal/semanticdb/scalac/SemanticdbReporter.scala
new file mode 100644
index 000000000..cc47c10e1
--- /dev/null
+++ b/semanticdb/scalac/library/src/main/scala-2.12.16/scala/meta/internal/semanticdb/scalac/SemanticdbReporter.scala
@@ -0,0 +1,37 @@
+package scala.meta.internal.semanticdb.scalac
+
+import scala.reflect.internal.util.Position
+import scala.tools.nsc.Settings
+import scala.tools.nsc.reporters.{Reporter, StoreReporter}
+
+class SemanticdbReporter(underlying: Reporter)
+    extends StoreReporter(SemanticdbReporter.defaultSettings()) {
+  override protected def info0(
+      pos: Position,
+      msg: String,
+      severity: Severity,
+      force: Boolean
+  ): Unit = {
+    super.info0(pos, msg, severity, force)
+    severity.id match {
+      case 0 => underlying.info(pos, msg, force)
+      case 1 => underlying.warning(pos, msg)
+      case 2 => underlying.error(pos, msg)
+      case _ =>
+    }
+
+  }
+
+  override def hasErrors: Boolean = underlying.hasErrors
+
+  override def hasWarnings: Boolean = underlying.hasWarnings
+
+}
+
+object SemanticdbReporter {
+  def defaultSettings(): Settings = {
+    val s = new Settings()
+    s.processArguments(List("-Xmaxwarns", "-1", "-Xmaxerrs", "-1"), true)
+    s
+  }
+}
diff --git a/semanticdb/scalac/library/src/main/scala-2.12.16/scala/meta/internal/semanticdb/scalac/VersionCompilerOps.scala b/semanticdb/scalac/library/src/main/scala-2.12.16/scala/meta/internal/semanticdb/scalac/VersionCompilerOps.scala
new file mode 100644
index 000000000..280c292e1
--- /dev/null
+++ b/semanticdb/scalac/library/src/main/scala-2.12.16/scala/meta/internal/semanticdb/scalac/VersionCompilerOps.scala
@@ -0,0 +1,9 @@
+package scala.meta.internal.semanticdb.scalac
+
+import scala.tools.nsc.interactive.Global
+
+trait VersionCompilerOps {
+
+  def forceWarnings(global: Global) = {}
+
+}
diff --git a/semanticdb/scalac/library/src/main/scala/scala/meta/internal/semanticdb/scalac/TypeOps.scala b/semanticdb/scalac/library/src/main/scala/scala/meta/internal/semanticdb/scalac/TypeOps.scala
index b5cef04da..35109725d 100644
--- a/semanticdb/scalac/library/src/main/scala/scala/meta/internal/semanticdb/scalac/TypeOps.scala
+++ b/semanticdb/scalac/library/src/main/scala/scala/meta/internal/semanticdb/scalac/TypeOps.scala
@@ -76,8 +76,6 @@ trait TypeOps { self: SemanticdbOps =>
            */
           case g.WildcardType =>
             s.NoType
-          case _: g.BoundedWildcardType =>
-            s.NoType
           case gother =>
             sys.error(s"unsupported type ${gother}: ${g.showRaw(gother)}")
         }


Test patch:
diff --git a/bin/test-release.sh b/bin/test-release.sh
index d270452c9..f4c283ba9 100755
--- a/bin/test-release.sh
+++ b/bin/test-release.sh
@@ -10,7 +10,7 @@ coursier resolve \
   org.scalameta:scalameta_sjs1_2.13:$version \
   org.scalameta:scalameta_sjs1_2.12:$version \
   org.scalameta:metac_2.13.8:$version \
-  org.scalameta:metac_2.12.15:$version \
+  org.scalameta:metac_2.12.16:$version \
   org.scalameta:metac_2.11.12:$version \
   org.scalameta:semanticdb-scalac-core_2.13.8:$version \
   org.scalameta:semanticdb-scalac-core_2.13.7:$version \
@@ -27,6 +27,7 @@ coursier resolve \
   org.scalameta:semanticdb-scalac-core_2.12.13:$version \
   org.scalameta:semanticdb-scalac-core_2.12.14:$version \
   org.scalameta:semanticdb-scalac-core_2.12.15:$version \
+  org.scalameta:semanticdb-scalac-core_2.12.16:$version \
   org.scalameta:semanticdb-scalac-core_2.11.12:$version \
   org.scalameta:semanticdb-scalac_2.13.8:$version \
   org.scalameta:semanticdb-scalac_2.13.7:$version \
@@ -44,5 +45,6 @@ coursier resolve \
   org.scalameta:semanticdb-scalac_2.12.13:$version \
   org.scalameta:semanticdb-scalac_2.12.14:$version \
   org.scalameta:semanticdb-scalac_2.12.15:$version \
+  org.scalameta:semanticdb-scalac_2.12.16:$version \
   org.scalameta:semanticdb-scalac_2.11.12:$version \
   -r sonatype:staging
diff --git a/tests/jvm/src/test/resources/example/MetacJava.scala b/tests/jvm/src/test/resources/example/MetacJava.scala
index 789584c46..5167564b9 100644
--- a/tests/jvm/src/test/resources/example/MetacJava.scala
+++ b/tests/jvm/src/test/resources/example/MetacJava.scala
@@ -8,8 +8,9 @@ class MetacJava/*<=example.MetacJava#*/ {
   val inner/*<=example.MetacJava#inner.*/ = new javacp.MetacJava/*=>com.javacp.MetacJava#*//*=>com.javacp.MetacJava#`<init>`().*/()
   val overload1/*<=example.MetacJava#overload1.*/ = new inner/*=>example.MetacJava#inner.*/.Overload1/*=>com.javacp.MetacJava#Overload1#*//*=>com.javacp.MetacJava#Overload1#`<init>`().*/()
   val overload2/*<=example.MetacJava#overload2.*/ = new inner/*=>example.MetacJava#inner.*/.Overload2/*=>com.javacp.MetacJava#Overload2#*//*=>com.javacp.MetacJava#Overload2#`<init>`().*/()
-  inner/*=>example.MetacJava#inner.*/.overload/*=>com.javacp.MetacJava#overload().*/(new overload1/*=>example.MetacJava#overload1.*/.A/*=>com.javacp.MetacJava#Overload1#A#*//*=>com.javacp.MetacJava#Overload1#A#`<init>`().*/())
-  inner/*=>example.MetacJava#inner.*/.overload/*=>com.javacp.MetacJava#overload(+1).*/(new overload2/*=>example.MetacJava#overload2.*/.A/*=>com.javacp.MetacJava#Overload2#A#*//*=>com.javacp.MetacJava#Overload2#A#`<init>`().*/())
+  // https://github.com/scala/bug/issues/12605
+  // inner.overload(new overload1.A())
+  // inner.overload(new overload2.A())
   val staticInner/*<=example.MetacJava#staticInner.*/ = new javacp.MetacJava/*=>com.javacp.MetacJava#*/.StaticInner/*=>com.javacp.MetacJava#StaticInner#*//*=>com.javacp.MetacJava#StaticInner#`<init>`().*/()
   val nonStatic/*<=example.MetacJava#nonStatic.*/ = new staticInner/*=>example.MetacJava#staticInner.*/.NonStatic/*=>com.javacp.MetacJava#StaticInner#NonStatic#*//*=>com.javacp.MetacJava#StaticInner#NonStatic#`<init>`().*/()
   nonStatic/*=>example.MetacJava#nonStatic.*/.method/*=>com.javacp.MetacJava#StaticInner#NonStatic#method().*/(nonStatic/*=>example.MetacJava#nonStatic.*/)
diff --git a/tests/jvm/src/test/resources/metac.expect b/tests/jvm/src/test/resources/metac.expect
index d29f11c62..9d3d4fb8e 100644
--- a/tests/jvm/src/test/resources/metac.expect
+++ b/tests/jvm/src/test/resources/metac.expect
@@ -2424,7 +2424,7 @@ Uri => semanticdb/integration/src/main/scala/example/MetacJava.scala
 Text => non-empty
 Language => Scala
 Symbols => 10 entries
-Occurrences => 72 entries
+Occurrences => 62 entries
 
 Symbols:
 example/MetacJava# => class MetacJava extends AnyRef { +9 decls }
@@ -2478,52 +2478,42 @@ Occurrences:
 [9:22..9:27): inner => example/MetacJava#inner.
 [9:28..9:37): Overload2 => com/javacp/MetacJava#Overload2#
 [9:37..9:37):  => com/javacp/MetacJava#Overload2#`<init>`().
-[10:2..10:7): inner => example/MetacJava#inner.
-[10:8..10:16): overload => com/javacp/MetacJava#overload().
-[10:21..10:30): overload1 => example/MetacJava#overload1.
-[10:31..10:32): A => com/javacp/MetacJava#Overload1#A#
-[10:32..10:32):  => com/javacp/MetacJava#Overload1#A#`<init>`().
-[11:2..11:7): inner => example/MetacJava#inner.
-[11:8..11:16): overload => com/javacp/MetacJava#overload(+1).
-[11:21..11:30): overload2 => example/MetacJava#overload2.
-[11:31..11:32): A => com/javacp/MetacJava#Overload2#A#
-[11:32..11:32):  => com/javacp/MetacJava#Overload2#A#`<init>`().
-[12:6..12:17): staticInner <= example/MetacJava#staticInner.
-[12:24..12:30): javacp => com/javacp/
-[12:31..12:40): MetacJava => com/javacp/MetacJava#
-[12:41..12:52): StaticInner => com/javacp/MetacJava#StaticInner#
-[12:52..12:52):  => com/javacp/MetacJava#StaticInner#`<init>`().
-[13:6..13:15): nonStatic <= example/MetacJava#nonStatic.
-[13:22..13:33): staticInner => example/MetacJava#staticInner.
-[13:34..13:43): NonStatic => com/javacp/MetacJava#StaticInner#NonStatic#
-[13:43..13:43):  => com/javacp/MetacJava#StaticInner#NonStatic#`<init>`().
-[14:2..14:11): nonStatic => example/MetacJava#nonStatic.
-[14:12..14:18): method => com/javacp/MetacJava#StaticInner#NonStatic#method().
-[14:19..14:28): nonStatic => example/MetacJava#nonStatic.
-[15:2..15:8): javacp => com/javacp/
-[15:9..15:18): MetacJava => com/javacp/MetacJava#
-[15:19..15:27): overload => com/javacp/MetacJava#overload(+2).
-[15:32..15:38): javacp => com/javacp/
-[15:39..15:48): MetacJava => com/javacp/MetacJava#
-[15:49..15:58): Overload3 => com/javacp/MetacJava#Overload3#
-[15:59..15:60): A => com/javacp/MetacJava#Overload3#A#
-[15:60..15:60):  => com/javacp/MetacJava#Overload3#A#`<init>`().
-[16:6..16:15): interface <= example/MetacJava#interface.
-[16:17..16:23): javacp => com/javacp/
-[16:24..16:33): Interface => com/javacp/Interface#
-[17:6..17:10): coin <= example/MetacJava#coin.
-[17:12..17:18): javacp => com/javacp/
-[17:19..17:23): Coin => com/javacp/Coin#
-[17:26..17:32): javacp => com/javacp/
-[17:33..17:37): Coin => com/javacp/Coin#
-[17:38..17:43): PENNY => com/javacp/Coin#PENNY.
-[18:6..18:11): entry <= example/MetacJava#entry.
-[18:13..18:17): java => java/
-[18:18..18:22): util => java/util/
-[18:23..18:26): Map => java/util/Map#
-[18:27..18:32): Entry => java/util/Map#Entry#
-[18:33..18:36): Int => scala/Int#
-[18:38..18:41): Int => scala/Int#
+[13:6..13:17): staticInner <= example/MetacJava#staticInner.
+[13:24..13:30): javacp => com/javacp/
+[13:31..13:40): MetacJava => com/javacp/MetacJava#
+[13:41..13:52): StaticInner => com/javacp/MetacJava#StaticInner#
+[13:52..13:52):  => com/javacp/MetacJava#StaticInner#`<init>`().
+[14:6..14:15): nonStatic <= example/MetacJava#nonStatic.
+[14:22..14:33): staticInner => example/MetacJava#staticInner.
+[14:34..14:43): NonStatic => com/javacp/MetacJava#StaticInner#NonStatic#
+[14:43..14:43):  => com/javacp/MetacJava#StaticInner#NonStatic#`<init>`().
+[15:2..15:11): nonStatic => example/MetacJava#nonStatic.
+[15:12..15:18): method => com/javacp/MetacJava#StaticInner#NonStatic#method().
+[15:19..15:28): nonStatic => example/MetacJava#nonStatic.
+[16:2..16:8): javacp => com/javacp/
+[16:9..16:18): MetacJava => com/javacp/MetacJava#
+[16:19..16:27): overload => com/javacp/MetacJava#overload(+2).
+[16:32..16:38): javacp => com/javacp/
+[16:39..16:48): MetacJava => com/javacp/MetacJava#
+[16:49..16:58): Overload3 => com/javacp/MetacJava#Overload3#
+[16:59..16:60): A => com/javacp/MetacJava#Overload3#A#
+[16:60..16:60):  => com/javacp/MetacJava#Overload3#A#`<init>`().
+[17:6..17:15): interface <= example/MetacJava#interface.
+[17:17..17:23): javacp => com/javacp/
+[17:24..17:33): Interface => com/javacp/Interface#
+[18:6..18:10): coin <= example/MetacJava#coin.
+[18:12..18:18): javacp => com/javacp/
+[18:19..18:23): Coin => com/javacp/Coin#
+[18:26..18:32): javacp => com/javacp/
+[18:33..18:37): Coin => com/javacp/Coin#
+[18:38..18:43): PENNY => com/javacp/Coin#PENNY.
+[19:6..19:11): entry <= example/MetacJava#entry.
+[19:13..19:17): java => java/
+[19:18..19:22): util => java/util/
+[19:23..19:26): Map => java/util/Map#
+[19:27..19:32): Entry => java/util/Map#Entry#
+[19:33..19:36): Int => scala/Int#
+[19:38..19:41): Int => scala/Int#
 
 semanticdb/integration/src/main/scala/example/Methods.scala
 -----------------------------------------------------------
diff --git a/tests/jvm/src/test/scala/scala/meta/tests/prettyprinters/RegressionSyntaxSuite.scala b/tests/jvm/src/test/scala/scala/meta/tests/prettyprinters/RegressionSyntaxSuite.scala
deleted file mode 100644
index 5776ece33..000000000
--- a/tests/jvm/src/test/scala/scala/meta/tests/prettyprinters/RegressionSyntaxSuite.scala
+++ /dev/null
@@ -1,58 +0,0 @@
-package scala.meta.tests.prettyprinters
-
-import scala.meta.tests.parsers.ParseSuite
-
-import scala.meta._
-import munit.TestOptions
-
-class RegressionSyntaxSuite extends ParseSuite {
-
-  def check(
-      testOpts: TestOptions,
-      code: String,
-      expected: String,
-      newDialect: Option[Dialect] = None
-  )(implicit dialect: Dialect) = test(testOpts) {
-    val obtained = code.parse[Stat].get
-    val reprintedCode =
-      scala.meta.internal.prettyprinters.TreeSyntax
-        .reprint(obtained)(newDialect.getOrElse(dialects.Scala213))
-        .toString
-    assertEquals(reprintedCode, expected)
-  }
-
-  check("question-mark", "type T = List[?]", "type T = List[?]")
-  check("underscore", "type T = List[_]", "type T = List[_]")
-  check(
-    "new-dialect-scala3",
-    "type T = List[_]",
-    "type T = List[?]",
-    newDialect = Some(dialects.Scala3)
-  )(
-    dialects.Scala211
-  )
-
-  check(
-    "new-dialect-scala213",
-    "type T = List[_]",
-    "type T = List[_]",
-    newDialect = Some(dialects.Scala213)
-  )(
-    dialects.Scala211
-  )
-  check(
-    "new-dialect-scala213-from-scala3",
-    "type T = List[?]",
-    "type T = List[?]",
-    newDialect = Some(dialects.Scala213)
-  )(
-    dialects.Scala3
-  )
-
-  test("no-origin") {
-    assertEquals(
-      Type.Placeholder(Type.Bounds(None, None)).toString(),
-      "_"
-    )
-  }
-}
diff --git a/tests/jvm/src/test/scala/scala/meta/tests/semanticdb/Source3Suite.scala b/tests/jvm/src/test/scala/scala/meta/tests/semanticdb/Source3Suite.scala
index 253349442..f6ddb349f 100644
--- a/tests/jvm/src/test/scala/scala/meta/tests/semanticdb/Source3Suite.scala
+++ b/tests/jvm/src/test/scala/scala/meta/tests/semanticdb/Source3Suite.scala
@@ -87,7 +87,8 @@ class Source3Suite extends FunSuite {
     expected,
     compat = List(
       "2.12.14" -> expected.replace("scala/package.List.", "scala/collection/immutable/List."),
-      "2.12.15" -> expected.replace("scala/package.List.", "scala/collection/immutable/List.")
+      "2.12.15" -> expected.replace("scala/package.List.", "scala/collection/immutable/List."),
+      "2.12.16" -> expected.replace("scala/package.List.", "scala/collection/immutable/List.")
     )
   )
 
diff --git a/tests/shared/src/test/scala-2.13/scala/meta/tests/tokenizers/TokensPositionSuite.scala b/tests/shared/src/test/scala-2.13/scala/meta/tests/tokenizers/TokensPositionSuite.scala
index 7118d2519..de71f7527 100644
--- a/tests/shared/src/test/scala-2.13/scala/meta/tests/tokenizers/TokensPositionSuite.scala
+++ b/tests/shared/src/test/scala-2.13/scala/meta/tests/tokenizers/TokensPositionSuite.scala
@@ -37,7 +37,7 @@ class TokensPositionSuite extends BasePositionSuite(dialects.Scala213) {
   checkPositions[Case](
     "case _ op (a | b) =>",
     """|Pat.ExtractInfix _ op (a | b)
-       |Pat.Alternative a | b
+       |Pat.Alternative (a | b)
        |Term.Block case _ op (a | b) =>@@
        |""".stripMargin
   )
diff --git a/tests/shared/src/test/scala/scala/meta/tests/parsers/BasicPositionSuite.scala b/tests/shared/src/test/scala/scala/meta/tests/parsers/BasicPositionSuite.scala
index ae98e24c6..405a54458 100644
--- a/tests/shared/src/test/scala/scala/meta/tests/parsers/BasicPositionSuite.scala
+++ b/tests/shared/src/test/scala/scala/meta/tests/parsers/BasicPositionSuite.scala
@@ -9,20 +9,7 @@ class BasicPositionSuite extends BasePositionSuite(dialects.Scala213) {
   checkPositions[Term](
     "1 + (2 / 3) * 4",
     """|Term.ApplyInfix (2 / 3) * 4
-       |Term.ApplyInfix 2 / 3
-       |""".stripMargin
-  )
-
-  checkPositions[Term](
-    "1 + (()) * 4",
-    """|Term.ApplyInfix (()) * 4
-       |""".stripMargin
-  )
-
-  checkPositions[Term](
-    "1 + ((1, 2, 3)) * 4",
-    """|Term.ApplyInfix ((1, 2, 3)) * 4
-       |Term.Tuple (1, 2, 3)
+       |Term.ApplyInfix (2 / 3)
        |""".stripMargin
   )
 
@@ -30,63 +17,11 @@ class BasicPositionSuite extends BasePositionSuite(dialects.Scala213) {
     "a f (b)"
   )
 
-  checkPositions[Term](
-    "a f (123)"
-  )
-
-  checkPositions[Term](
-    "a f ()"
-  )
-
-  checkPositions[Term](
-    "a f (())"
-  )
-
-  checkPositions[Term](
-    "a f ((1, 2, 3))",
-    """|Term.Tuple (1, 2, 3)
-       |""".stripMargin
-  )
-
-  checkPositions[Term](
-    "a f (()).foo",
-    """|Term.Select (()).foo
-       |""".stripMargin
-  )
-
-  checkPositions[Term](
-    "a f (())(b)",
-    """|Term.Apply (())(b)
-       |""".stripMargin
-  )
-
-  checkPositions[Term](
-    "1 + { 2 / 3 } * 4",
-    """|Term.ApplyInfix { 2 / 3 } * 4
-       |Term.Block { 2 / 3 }
-       |Term.ApplyInfix 2 / 3
-       |""".stripMargin
-  )
-
-  checkPositions[Term](
-    "{ 2 / 3 } + 4",
-    """|Term.Block { 2 / 3 }
-       |Term.ApplyInfix 2 / 3
-       |""".stripMargin
-  )
-
   checkPositions[Term](
     "(1 + 2).foo",
     """|Term.ApplyInfix (1 + 2)
        |""".stripMargin
   )
-  checkPositions[Term](
-    "foo == (a + b).c(d)",
-    """|Term.Apply (a + b).c(d)
-       |Term.Select (a + b).c
-       |Term.ApplyInfix a + b
-       |""".stripMargin
-  )
   checkPositions[Stat](
     // Issue #333
     """def shortInfo: String = s"created=$x"""",
diff --git a/tests/shared/src/test/scala/scala/meta/tests/parsers/ImportSuite.scala b/tests/shared/src/test/scala/scala/meta/tests/parsers/ImportSuite.scala
index 1c001c19b..27d8a0a46 100644
--- a/tests/shared/src/test/scala/scala/meta/tests/parsers/ImportSuite.scala
+++ b/tests/shared/src/test/scala/scala/meta/tests/parsers/ImportSuite.scala
@@ -60,7 +60,7 @@ class ImportSuite extends ParseSuite {
 
   test("import foo.{bar, baz}") {
     val Import(
-      Importer(TermName("foo"), Name(Indeterminate("bar")) :: (Name(Indeterminate("baz"))) :: Nil)
+      Importer(TermName("foo"), Name(Indeterminate("bar")) ::(Name(Indeterminate("baz"))) :: Nil)
         :: Nil
     ) =
       templStat("import foo.{bar, baz}")
diff --git a/tests/shared/src/test/scala/scala/meta/tests/parsers/Scala213Suite.scala b/tests/shared/src/test/scala/scala/meta/tests/parsers/Scala213Suite.scala
index a761059f3..54db44d15 100644
--- a/tests/shared/src/test/scala/scala/meta/tests/parsers/Scala213Suite.scala
+++ b/tests/shared/src/test/scala/scala/meta/tests/parsers/Scala213Suite.scala
@@ -1,8 +1,6 @@
 package scala.meta.tests
 package parsers
 
-import scala.meta.Dialect
-import scala.meta.dialects
 import scala.meta.dialects.Scala213
 
 class Scala213Suite extends ParseSuite {
@@ -80,18 +78,9 @@ class Scala213Suite extends ParseSuite {
     runAssert("try ()", """Term.Try(Lit.Unit(()), Nil, None)""")
   }
 
-  test("infix-at-line-start") {
-    runAssert(
-      """|val x = "hello"
-         |  ++ "world"
-         |""".stripMargin,
-      """Defn.Val(Nil, List(Pat.Var(Term.Name("x"))), None, Term.ApplyInfix(Lit.String("hello"), Term.Name("++"), Nil, List(Lit.String("world"))))"""
-    )(dialects.Scala213Source3)
-  }
-
-  private def runAssert(code: String, expected: String)(implicit d: Dialect): Unit = {
+  private def runAssert(code: String, expected: String): Unit = {
     assertNoDiff(
-      templStat(code)(d).structure,
+      templStat(code).structure,
       expected
     )
   }
diff --git a/tests/shared/src/test/scala/scala/meta/tests/parsers/TemplateSuite.scala b/tests/shared/src/test/scala/scala/meta/tests/parsers/TemplateSuite.scala
index 3bebb3fb5..3222a51d7 100644
--- a/tests/shared/src/test/scala/scala/meta/tests/parsers/TemplateSuite.scala
+++ b/tests/shared/src/test/scala/scala/meta/tests/parsers/TemplateSuite.scala
@@ -337,12 +337,4 @@ class TemplateSuite extends ParseSuite {
     ) =
       templStat("object A { self: B => }")
   }
-
-  test("trait B extends A.type") {
-    val err = intercept[ParseException] {
-      templStat("trait B extends A.type")
-    }
-    assertNoDiff(err.shortMessage, "class type required but A.type found")
-  }
-
 }
diff --git a/tests/shared/src/test/scala/scala/meta/tests/parsers/TermSuite.scala b/tests/shared/src/test/scala/scala/meta/tests/parsers/TermSuite.scala
index 21655176a..dc98d6de2 100644
--- a/tests/shared/src/test/scala/scala/meta/tests/parsers/TermSuite.scala
+++ b/tests/shared/src/test/scala/scala/meta/tests/parsers/TermSuite.scala
@@ -368,7 +368,9 @@ class TermSuite extends ParseSuite {
 
   test("_: Int => x") {
     assertTerm("_: Int => x") {
-      Ascribe(Placeholder(), Type.Function(List(Type.Name("Int")), Type.Name("x")))
+      AnonymousFunction(
+        Ascribe(Placeholder(), Type.Function(List(Type.Name("Int")), Type.Name("x")))
+      )
     }
     val Term.Function(
       List(Term.Param(Nil, Name.Anonymous(), Some(Type.Name("Int")), None)),
@@ -1194,7 +1196,9 @@ class TermSuite extends ParseSuite {
   }
   test("anonymous-function-spec-3.2") {
     assertTerm("(_: Int)")(
-      Ascribe(Placeholder(), Type.Name("Int"))
+      AnonymousFunction(
+        Ascribe(Placeholder(), Type.Name("Int"))
+      )
     )
   }
   test("anonymous-function-spec-4") {
diff --git a/tests/shared/src/test/scala/scala/meta/tests/prettyprinters/SyntacticSuite.scala b/tests/shared/src/test/scala/scala/meta/tests/prettyprinters/SyntacticSuite.scala
index 05d9dbb3b..b18c47afc 100644
--- a/tests/shared/src/test/scala/scala/meta/tests/prettyprinters/SyntacticSuite.scala
+++ b/tests/shared/src/test/scala/scala/meta/tests/prettyprinters/SyntacticSuite.scala
@@ -1329,52 +1329,6 @@ class SyntacticSuite extends scala.meta.tests.parsers.ParseSuite {
       )
     }
   }
-
-  test("anonymous function with new") {
-    checkTree(q"foo map (new foo(_))") {
-      Term.ApplyInfix(
-        Term.Name("foo"),
-        Term.Name("map"),
-        Nil,
-        List(
-          Term.AnonymousFunction(
-            Term.New(Init(Type.Name("foo"), Name(""), List(List(Term.Placeholder()))))
-          )
-        )
-      )
-    }
-  }
-
-  test("anonymous function with select") {
-    checkTree(q"foo map (foo(_).bar)") {
-      Term.ApplyInfix(
-        Term.Name("foo"),
-        Term.Name("map"),
-        Nil,
-        List(
-          Term.AnonymousFunction(
-            Term.Select(Term.Apply(Term.Name("foo"), List(Term.Placeholder())), Term.Name("bar"))
-          )
-        )
-      )
-    }
-  }
-
-  test("anonymous function with apply type") {
-    checkTree(q"foo map (_.foo[A])") {
-      Term.ApplyInfix(
-        Term.Name("foo"),
-        Term.Name("map"),
-        Nil,
-        List(
-          Term.AnonymousFunction(
-            Term.ApplyType(Term.Select(Term.Placeholder(), Term.Name("foo")), List(Type.Name("A")))
-          )
-        )
-      )
-    }
-  }
-
   test("#2317 init block") {
     checkStat(
       """new Foo({
@@ -1713,110 +1667,4 @@ class SyntacticSuite extends scala.meta.tests.parsers.ParseSuite {
     }
   }
 
-  test("pat infix: _ op (a | b)") {
-    checkTree(p"_ op (a | b)", "_ op (a | b)") {
-      Pat.ExtractInfix(
-        Pat.Wildcard(),
-        Term.Name("op"),
-        List(Pat.Alternative(Pat.Var(Term.Name("a")), Pat.Var(Term.Name("b"))))
-      )
-    }
-  }
-
-  test("pat infix: _ * (a + b)") {
-    checkTree(p"_ * (a + b)", "_ * (a + b)") {
-      Pat.ExtractInfix(
-        Pat.Wildcard(),
-        Term.Name("*"),
-        List(
-          Pat.ExtractInfix(Pat.Var(Term.Name("a")), Term.Name("+"), List(Pat.Var(Term.Name("b"))))
-        )
-      )
-    }
-  }
-
-  test("term infix: _ * (a + b)") {
-    checkTree(q"_ * (a + b)", "_ * (a + b)") {
-      Term.AnonymousFunction(
-        Term.ApplyInfix(
-          Term.Placeholder(),
-          Term.Name("*"),
-          Nil,
-          List(Term.ApplyInfix(Term.Name("a"), Term.Name("+"), Nil, List(Term.Name("b"))))
-        )
-      )
-    }
-  }
-
-  test("term infix: 1 + (2 / 3) * 4") {
-    checkTree(q"1 + (2 / 3) * 4", "1 + 2 / 3 * 4") {
-      Term.ApplyInfix(
-        Lit.Int(1),
-        Term.Name("+"),
-        Nil,
-        List(
-          Term.ApplyInfix(
-            Term.ApplyInfix(Lit.Int(2), Term.Name("/"), Nil, List(Lit.Int(3))),
-            Term.Name("*"),
-            Nil,
-            List(Lit.Int(4))
-          )
-        )
-      )
-    }
-  }
-
-  test("term infix: 1 + { 2 / 3 } * 4") {
-    checkTree(
-      q"1 + { 2 / 3 } * 4",
-      """|1 + {
-         |  2 / 3
-         |} * 4""".stripMargin
-    ) {
-      Term.ApplyInfix(
-        Lit.Int(1),
-        Term.Name("+"),
-        Nil,
-        List(
-          Term.ApplyInfix(
-            Term.Block(List(Term.ApplyInfix(Lit.Int(2), Term.Name("/"), Nil, List(Lit.Int(3))))),
-            Term.Name("*"),
-            Nil,
-            List(Lit.Int(4))
-          )
-        )
-      )
-    }
-  }
-
-  test("term infix: { 2 / 3 } + 4") {
-    checkTree(
-      q"{ 2 / 3 } + 4",
-      """|{
-         |  2 / 3
-         |} + 4""".stripMargin
-    ) {
-      Term.ApplyInfix(
-        Term.Block(List(Term.ApplyInfix(Lit.Int(2), Term.Name("/"), Nil, List(Lit.Int(3))))),
-        Term.Name("+"),
-        Nil,
-        List(Lit.Int(4))
-      )
-    }
-  }
-
-  test("term anon func: foo.bar(_: Int, _: String)") {
-    checkTree(q"foo.bar(_: Int, _: String)", "foo.bar(_: Int, _: String)") {
-      Term.AnonymousFunction(
-        Term.Apply(
-          Term.Select(Term.Name("foo"), Term.Name("bar")),
-          List(
-            Term.Ascribe(Term.Placeholder(), Type.Name("Int")),
-            Term.Ascribe(Term.Placeholder(), Type.Name("String"))
-          )
-        )
-      )
-    }
-  }
-
 }