diff --git a/.github/ISSUE_TEMPLATE/bug.md b/.github/ISSUE_TEMPLATE/bug.md index 8feba58c44d7..4e57d5859540 100644 --- a/.github/ISSUE_TEMPLATE/bug.md +++ b/.github/ISSUE_TEMPLATE/bug.md @@ -1,6 +1,6 @@ --- name: "\U0001F41B Bug report" -about: Report a bug about the Dotty Compiler +about: Report a bug about the Scala 3 compiler title: '' labels: itype:bug, stat:needs triage assignees: '' diff --git a/.github/ISSUE_TEMPLATE/crash.md b/.github/ISSUE_TEMPLATE/crash.md index c742875616e2..f3a740878ef1 100644 --- a/.github/ISSUE_TEMPLATE/crash.md +++ b/.github/ISSUE_TEMPLATE/crash.md @@ -1,6 +1,6 @@ --- name: "\U0001F4A5 Crash report" -about: Report a Dotty compiler crash +about: Report a Scala 3 compiler crash title: '' labels: itype:bug, itype:crash, stat:needs triage assignees: '' diff --git a/.github/ISSUE_TEMPLATE/feature.md b/.github/ISSUE_TEMPLATE/feature.md index afbaa8020e07..460fe41b34d6 100644 --- a/.github/ISSUE_TEMPLATE/feature.md +++ b/.github/ISSUE_TEMPLATE/feature.md @@ -7,4 +7,4 @@ assignees: '' --- -Please create a feature request in the [Dotty Discussions](https://github.com/scala/scala3/discussions/new?category=feature-requests). +Please create a feature request in the [Scala 3 Discussions](https://github.com/scala/scala3/discussions/new?category=feature-requests). diff --git a/.github/ISSUE_TEMPLATE/other-issue.md b/.github/ISSUE_TEMPLATE/other-issue.md index 07a9fe77846a..521df16418a6 100644 --- a/.github/ISSUE_TEMPLATE/other-issue.md +++ b/.github/ISSUE_TEMPLATE/other-issue.md @@ -1,6 +1,6 @@ --- name: Other issue -about: Report an issue about the Dotty Compiler (not bug or crash) +about: Report an issue about the Scala 3 compiler (not a bug or a crash) title: '' labels: stat:needs triage assignees: '' diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 7e4d73690067..b7125326d008 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,42 +1,23 @@ - +Fixes #XYZ - - - - - - + ## How much have you relied on LLM-based tools in this contribution? - + - +Extensively, for ... +Moderately, for ... +Minimally, for ... +Not at all ## How was the solution tested? - - -## Additional notes - - + - +New automated tests (including the issue's reproducer, if applicable) +Covered by existing tests (this is a refactoring) +Non-code change, no tests needed +Manual tests because writing automated tests is impractical, described below (in detail) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index f329a6e2e598..84f1c8c5ed96 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -1,4 +1,4 @@ -name: Dotty +name: Scala 3 on: push: @@ -126,7 +126,7 @@ jobs: # Extract the release tag - name: Extract the release tag - run : echo "RELEASE_TAG='${GITHUB_REF#*refs/tags/}'" >> $GITHUB_ENV + run : echo "RELEASE_TAG=${GITHUB_REF#*refs/tags/}" >> $GITHUB_ENV - name: Check compiler version shell: bash @@ -276,5 +276,5 @@ jobs: with: fetch-depth: 0 - uses: coursier/cache-action@v8 - - uses: VirtusLab/scala-cli-setup@v1.12.5 + - uses: VirtusLab/scala-cli-setup@v1.14 - run: scala-cli format --check diff --git a/.github/workflows/lts-backport.yaml b/.github/workflows/lts-backport.yaml index f855f23175d1..14e18ba36194 100644 --- a/.github/workflows/lts-backport.yaml +++ b/.github/workflows/lts-backport.yaml @@ -24,7 +24,7 @@ jobs: with: fetch-depth: 0 - uses: coursier/cache-action@v8 - - uses: VirtusLab/scala-cli-setup@v1.12.3 + - uses: VirtusLab/scala-cli-setup@v1.14 - run: scala-cli ./project/scripts/addToBackportingProject.scala -- ${{ github.sha }} env: GRAPHQL_API_TOKEN: ${{ steps.app-token.outputs.token }} diff --git a/.github/workflows/scaladoc.yaml b/.github/workflows/scaladoc.yaml index 24d4282eae42..c3e3de19e887 100644 --- a/.github/workflows/scaladoc.yaml +++ b/.github/workflows/scaladoc.yaml @@ -73,7 +73,7 @@ jobs: uses: actions/checkout@v6 - uses: coursier/cache-action@v8 - - uses: VirtusLab/scala-cli-setup@v1.12.3 + - uses: VirtusLab/scala-cli-setup@v1.14 - name: Validate docs sidebars run: scala-cli ./project/scripts/checkSidebarDocs.scala @@ -148,7 +148,7 @@ jobs: steps: - uses: actions/checkout@v6 - uses: coursier/cache-action@v8 - - uses: VirtusLab/scala-cli-setup@v1.11 + - uses: VirtusLab/scala-cli-setup@v1.14 with: jvm: temurin:17 apps: sbt diff --git a/.github/workflows/spec.yml b/.github/workflows/spec.yml index 36d6641d60b9..37049cb202eb 100644 --- a/.github/workflows/spec.yml +++ b/.github/workflows/spec.yml @@ -49,7 +49,7 @@ jobs: env: USER_FOR_TEST: ${{ secrets.SPEC_DEPLOY_USER }} if: ${{ env.USER_FOR_TEST != '' }} - uses: burnett01/rsync-deployments@8.0.4 + uses: burnett01/rsync-deployments@8.0.5 with: switches: -rzv path: docs/_spec/_site/ diff --git a/.github/workflows/stdlib.yaml b/.github/workflows/stdlib.yaml index 80eaf619d8e2..67229b185109 100644 --- a/.github/workflows/stdlib.yaml +++ b/.github/workflows/stdlib.yaml @@ -167,10 +167,17 @@ jobs: distribution: 'temurin' java-version: 17 cache: 'sbt' + - uses: sbt/setup-sbt@v1 + - name: Test `scala3-compiler-nonbootstrapped` run: ./project/scripts/sbt scala3-compiler-nonbootstrapped/test + - name: Cmd Tests + run: | + ./project/scripts/sbt scala3-nonbootstrapped/publishLocal + ./project/scripts/cmdTests + test-scala3-compiler-bootstrapped: runs-on: ubuntu-latest steps: @@ -183,10 +190,17 @@ jobs: distribution: 'temurin' java-version: 17 cache: 'sbt' + - uses: sbt/setup-sbt@v1 + - name: Test `scala3-compiler-bootstrapped` run: ./project/scripts/sbt scala3-compiler-bootstrapped/test + - name: Cmd Tests + run: | + ./project/scripts/sbt scala3-bootstrapped/publishLocal + ./project/scripts/bootstrappedOnlyCmdTests + test-scala3-bootstrapped-compilation-coverage: runs-on: ubuntu-latest steps: diff --git a/.gitignore b/.gitignore index 3821ee531b65..d99ecd1bbaaf 100644 --- a/.gitignore +++ b/.gitignore @@ -69,6 +69,7 @@ testlogs/ before-pickling.txt after-pickling.txt +after-printing.txt bench/compile.txt community-build/scala3-bootstrapped.version @@ -104,4 +105,4 @@ docs/_spec/.jekyll-metadata scaladoc/output/ # only used in local development -.enable_bsp_all_projects \ No newline at end of file +.enable_bsp_all_projects diff --git a/README.md b/README.md index c8b3344fbb3d..0910010ca80a 100644 --- a/README.md +++ b/README.md @@ -4,12 +4,7 @@ Scala 3 [![Join the chat at https://discord.com/invite/scala](https://img.shields.io/discord/632150470000902164)](https://discord.com/invite/scala) This is the home of the [Scala 3](https://www.scala-lang.org) standard library, compiler, and language spec. - -* [Documentation](https://docs.scala-lang.org/scala3/) - -Try it out -========== -To try it in your project see also the [Getting Started User Guide](https://docs.scala-lang.org/scala3/getting-started.html). +More documentation [here](https://docs.scala-lang.org/scala3/). Building a Local Distribution ============================= @@ -18,16 +13,16 @@ Building a Local Distribution Code of Conduct =============== -Dotty uses the [Scala Code of Conduct](https://www.scala-lang.org/conduct.html) +Scala 3 uses the [Scala Code of Conduct](https://www.scala-lang.org/conduct.html) for all communication and discussion. This includes both GitHub, Discord and other more direct lines of communication such as email. How to Contribute ================= -* [Getting Started as Contributor](https://docs.scala-lang.org/scala3/guides/contribution/contribution-intro.html) -* [Issues](https://github.com/scala/scala3/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) -* [Policy regarding usage of LLM-based tools in contributions to the Scala project](LLM_POLICY.md) +* [Contributing guide](./CONTRIBUTING.md) +* [Issues where help is wanted](https://github.com/scala/scala3/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) +* [Policy regarding the use of LLM-based tools](LLM_POLICY.md) License ======= -Scala 3 is licensed under the [Apache License Version 2.0](https://www.apache.org/licenses/LICENSE-2.0) \ No newline at end of file +Scala 3 is licensed under the [Apache License Version 2.0](https://www.apache.org/licenses/LICENSE-2.0) diff --git a/bench-micro/src/main/scala/dotty/tools/benchmarks/SpecializedTraitsBenchmark.scala b/bench-micro/src/main/scala/dotty/tools/benchmarks/SpecializedTraitsBenchmark.scala new file mode 100644 index 000000000000..baf866c10e9a --- /dev/null +++ b/bench-micro/src/main/scala/dotty/tools/benchmarks/SpecializedTraitsBenchmark.scala @@ -0,0 +1,100 @@ +// Run with: scala-cli --power --jmh bench-micro/src/main/scala/dotty/tools/benchmarks/SpecializedTraitsBenchmark.scala +// May have to run it again / delete .scala-build and rerun if you get a class not found +// error from scala-cli first time - the --jmh flag is still experimental. +// Don't forget to publish the compiler first and check that the version below corresponds to the generated version, +// as well as to kill the bloop server if you are republishing the same version as before. +// scala-cli --power bloop exit + +//> using scala 3.9.0-RC1-bin-SNAPSHOT-nonbootstrapped +//> using options -language:experimental.specializedTraits + +package dotty.tools.benchmarks + +import org.openjdk.jmh.annotations.* +import java.util.concurrent.TimeUnit + +class VecManual(elems: Array[Int]): + private val num = summon[Numeric[Int]] + + def length = elems.length + + def apply(i: Int): Int = elems(i) + + def scalarProduct(other: VecManual): Int = + require(this.length == other.length) + var result = num.fromInt(0) + for i <- 0 until length do + result = num.plus(result, num.times(this(i), other(i))) + result + +class VecGeneric[T: Numeric](elems: Array[T]): + private val num = summon[Numeric[T]] + + def length = elems.length + + def apply(i: Int): T = elems(i) + + def scalarProduct(other: VecGeneric[T]): T = + require(this.length == other.length) + var result = num.fromInt(0) + for i <- 0 until length do + result = num.plus(result, num.times(this(i), other(i))) + result + +inline trait VecSpecialized[T: {Specialized, Numeric2}](elems: Array[T]): + private val num = summon[Numeric2[T]] + + def length = elems.length + + def apply(i: Int): T = elems(i) + + def scalarProduct(other: VecSpecialized[T]): T = + require(this.length == other.length) + var result = num.fromInt(0) + for i <- 0 until length do + result = num.plus(result, num.times(this(i), other(i))) + result + +@State(Scope.Benchmark) +class Arrays: + var arr1 = Array.fill(100_000_000) {math.round(math.random().floatValue * 4)} + var arr2 = Array.fill(100_000_000) {math.round(math.random().floatValue * 4)} + val target = arr1.zip(arr2).map((x, y) => x * y).fold(0)(_ + _) + +@State(Scope.Benchmark) +@BenchmarkMode(Array(Mode.AverageTime)) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Warmup(iterations = 5, time = 100, timeUnit = TimeUnit.MILLISECONDS) +@Measurement(iterations = 15, time = 100, timeUnit = TimeUnit.MILLISECONDS) +@Fork(1) +class VecBench: + @Benchmark + def manual(arr: Arrays) = + val x = VecManual(arr.arr1) + val y = VecManual(arr.arr2) + assert(x.scalarProduct(y) == arr.target) + + @Benchmark + def generic(arr: Arrays) = + val x = VecGeneric[Int](arr.arr1) + val y = VecGeneric[Int](arr.arr2) + assert(x.scalarProduct(y) == arr.target) + + @Benchmark + def specialized(arr: Arrays) = + val x = new VecSpecialized[Int](arr.arr1) {} + val y = new VecSpecialized[Int](arr.arr2) {} + assert(x.scalarProduct(y) == arr.target) + +// You can really see the impact of Specialized on the interface usage here +// Remove Specialized and see that the generated code gets much more boxing and unboxing +// which slows it down substantially. +inline trait Numeric2[T: Specialized]: + def fromInt(x: Int): T + def plus(x: T, y: T): T + def times(x: T, y: T): T + +implicit object IntIsIntegral extends Numeric2[Int]: + override def fromInt(x: Int): Int = x + override def plus(x: Int, y: Int): Int = x + y + override def times(x: Int, y: Int): Int = x * y diff --git a/community-build/community-projects/cats-effect-3 b/community-build/community-projects/cats-effect-3 index 1d425e6efdf8..505471ac040b 160000 --- a/community-build/community-projects/cats-effect-3 +++ b/community-build/community-projects/cats-effect-3 @@ -1 +1 @@ -Subproject commit 1d425e6efdf8aee619a4a906e950473c51f78161 +Subproject commit 505471ac040b7d357de624b85781aefecb24e98f diff --git a/community-build/src/scala/dotty/communitybuild/projects.scala b/community-build/src/scala/dotty/communitybuild/projects.scala index b300687d95e1..498356da724b 100644 --- a/community-build/src/scala/dotty/communitybuild/projects.scala +++ b/community-build/src/scala/dotty/communitybuild/projects.scala @@ -117,12 +117,14 @@ final case class SbtCommunityProject( val sbtProps = Option(System.getProperty("sbt.ivy.home")) match case Some(ivyHome) => List(s"-Dsbt.ivy.home=$ivyHome") case _ => Nil - extraSbtArgs ++ sbtProps ++ List("-sbt-version", "1.11.5", "-Dsbt.supershell=false", s"--addPluginSbtFile=$sbtPluginFilePath") + extraSbtArgs ++ sbtProps ++ List("-sbt-version", "1.12.1", "-Dsbt.supershell=false", s"--addPluginSbtFile=$sbtPluginFilePath") object SbtCommunityProject: def scalacOptions = List( "-Xcheck-macros", "-Wsafe-init", + "-Yexplicit-nulls", + "-language:unsafeNulls", ) object projects: @@ -134,7 +136,7 @@ object projects: private def removeRelease8(projects: String*): String = projects.map(project => - s"""set $project/Compile/scalacOptions := ($project/Compile/scalacOptions).value.filterNot(opt => opt == "-release" || opt == "8")""" + s"""set $project/Compile/scalacOptions := ($project/Compile/scalacOptions).value.filterNot(opt => opt == "-release" || opt == "-java-output-version" || opt == "8")""" ).mkString("; ") private def aggregateDoc(in: String)(projects: String*) = @@ -426,7 +428,14 @@ object projects: lazy val catsEffect3 = SbtCommunityProject( project = "cats-effect-3", - sbtTestCommand = "ciJVM", + sbtTestCommand = + List( + removeRelease8("core.jvm", "example.jvm", "kernel.jvm", "kernelTestkit.jvm", "laws.jvm", "std.jvm", "testkit.jvm", "tests.jvm", "rootJVM", "ioAppTestsJVM", "benchmarks", "graalVMExample"), + // repeats code from `removeRelease8`, but oh well, maybe generalize later + """set root/ScalaUnidoc/unidoc/scalacOptions := (root/ScalaUnidoc/unidoc/scalacOptions).value.filterNot(opt => opt == "-release" || opt == "-java-output-version" || opt == "8")""", + "set ThisBuild / tlFatalWarnings := false", + "ciJVM" + ).mkString("; "), sbtPublishCommand = "publishLocal", sbtDocCommand = ";coreJVM/doc ;lawsJVM/doc ;kernelJVM/doc", ) @@ -762,7 +771,6 @@ def allProjects = List( projects.libretto, projects.jacksonModuleScala, projects.specs2, - projects.coop, projects.spire, projects.http4s, projects.parboiled2, diff --git a/compiler/src/dotty/tools/MainGenericCompiler.scala b/compiler/src/dotty/tools/MainGenericCompiler.scala index de4682ab4380..38f5b00123f6 100644 --- a/compiler/src/dotty/tools/MainGenericCompiler.scala +++ b/compiler/src/dotty/tools/MainGenericCompiler.scala @@ -129,6 +129,6 @@ object MainGenericCompiler { properArgs ++ List("-script", settings.targetScript) ++ settings.scriptArgs - scripting.Main.main(properArgs.toArray) + scripting.Main.main(fullArgs.toArray) end main } diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeAsmCommon.scala b/compiler/src/dotty/tools/backend/jvm/BCodeAsmCommon.scala deleted file mode 100644 index 59ba2704f56c..000000000000 --- a/compiler/src/dotty/tools/backend/jvm/BCodeAsmCommon.scala +++ /dev/null @@ -1,117 +0,0 @@ -package dotty.tools -package backend -package jvm - -import dotty.tools.dotc.core.Contexts.Context -import dotty.tools.dotc.core.Flags.* -import dotty.tools.dotc.core.Symbols.* -import dotty.tools.dotc.report - -import SymbolUtils.given - -/** - * Code shared between GenBCode and GenASM that depends on types defined in - * the compiler cake (Global). - */ -object BCodeAsmCommon { - - /** - * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a - * member class. This method is used to decide if we should emit an EnclosingMethod attribute. - * It is also used to decide whether the "owner" field in the InnerClass attribute should be - * null. - */ - def isAnonymousOrLocalClass(classSym: Symbol)(using ctx: Context): Boolean = { - assert(classSym.isClass, s"not a class: $classSym") - // Here used to be an `assert(!classSym.isDelambdafyFunction)`: delambdafy lambda classes are - // always top-level. However, SI-8900 shows an example where the weak name-based implementation - // of isDelambdafyFunction failed (for a function declared in a package named "lambda"). - classSym.isAnonymousClass || { - val originalOwner = classSym.originalOwner - originalOwner != NoSymbol && !originalOwner.isClass - } - } - - /** - * Returns the enclosing method for non-member classes. In the following example - * - * class A { - * def f = { - * class B { - * class C - * } - * } - * } - * - * the method returns Some(f) for B, but None for C, because C is a member class. For non-member - * classes that are not enclosed by a method, it returns None: - * - * class A { - * { class B } - * } - * - * In this case, for B, we return None. - * - * The EnclosingMethod attribute needs to be added to non-member classes (see doc in BTypes). - * This is a source-level property, so we need to use the originalOwner chain to reconstruct it. - */ - private def enclosingMethodForEnclosingMethodAttribute(classSym: Symbol)(using ctx: Context): Option[Symbol] = { - assert(classSym.isClass, classSym) - def enclosingMethod(sym: Symbol): Option[Symbol] = { - if (sym.isClass || sym == NoSymbol) None - else if (sym.is(Method, butNot=Synthetic)) Some(sym) - else enclosingMethod(sym.originalOwner) - } - enclosingMethod(classSym.originalOwner) - } - - /** - * The enclosing class for emitting the EnclosingMethod attribute. Since this is a source-level - * property, this method looks at the originalOwner chain. See doc in BTypes. - */ - private def enclosingClassForEnclosingMethodAttribute(classSym: Symbol)(using ctx: Context): Symbol = { - assert(classSym.isClass, classSym) - def enclosingClass(sym: Symbol): Symbol = { - if (sym.isClass) sym - else enclosingClass(sym.originalOwner.originalLexicallyEnclosingClass) - } - enclosingClass(classSym.originalOwner.originalLexicallyEnclosingClass) - } - - final case class EnclosingMethodEntry(owner: String, name: String | Null, methodDescriptor: String | Null) - - /** - * Data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not - * an anonymous or local class). See doc in BTypes. - * - * The class is parametrized by two functions to obtain a bytecode class descriptor for a class - * symbol, and to obtain a method signature descriptor from a method symbol. These function depend - * on the implementation of GenASM / GenBCode, so they need to be passed in. - */ - def enclosingMethodAttribute(classSym: Symbol, classDesc: Symbol => String, methodDesc: Symbol => String)(using ctx: Context): Option[EnclosingMethodEntry] = { - if (isAnonymousOrLocalClass(classSym)) { - val methodOpt = enclosingMethodForEnclosingMethodAttribute(classSym) - report.debuglog(s"enclosing method for $classSym is $methodOpt (in ${methodOpt.map(_.enclosingClass)})") - Some(EnclosingMethodEntry( - classDesc(enclosingClassForEnclosingMethodAttribute(classSym)), - methodOpt.map(_.javaSimpleName).orNull, - methodOpt.map(methodDesc).orNull)) - } else { - None - } - } - - private def ubytesToCharArray(bytes: Array[Byte]): Array[Char] = { - val ca = new Array[Char](bytes.length) - var idx = 0 - while(idx < bytes.length) { - val b: Byte = bytes(idx) - assert((b & ~0x7f) == 0) - ca(idx) = b.asInstanceOf[Char] - idx += 1 - } - - ca - } - -} diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala index dcee8856f201..862ec9275bdd 100644 --- a/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala +++ b/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala @@ -9,7 +9,6 @@ import scala.tools.asm import scala.tools.asm.{Handle, Opcodes} import BCodeHelpers.InvokeStyle import dotty.tools.dotc.ast.tpd -import dotty.tools.dotc.CompilationUnit import dotty.tools.dotc.core.Constants.* import dotty.tools.dotc.core.Flags.{Label as LabelFlag, *} import dotty.tools.dotc.core.Types.* @@ -34,17 +33,16 @@ import dotty.tools.dotc.util.SrcPos * @version 1.0 * */ -trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) extends BCodeSkelBuilder { - +trait BCodeBodyBuilder(val primitives: ScalaPrimitives) extends BCodeSkelBuilder { /* * Functionality to build the body of ASM MethodNode, except for `synchronized` and `try` expressions. */ - abstract class PlainBodyBuilder(cunit: CompilationUnit) extends PlainSkelBuilder(cunit) { + abstract class PlainBodyBuilder extends PlainSkelBuilder { private object DesugaredSelect { private val desugared = new java.util.IdentityHashMap[Type, tpd.Select] - def cached(i: Ident): Option[tpd.Select] = { + def cached(i: Ident)(using Context): Option[tpd.Select] = { var found = desugared.get(i.tpe) if (found == null) { tpd.desugarIdent(i) match { @@ -57,7 +55,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte Option(found) } - def unapply(s: tpd.Tree): Option[(Tree, Name)] = { + def unapply(s: tpd.Tree)(using Context): Option[(Tree, Name)] = { s match { case t: tpd.Select => Some((t.qualifier, t.name)) case t: Ident => cached(t).map(c => (c.qualifier, c.name)) @@ -90,7 +88,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte * Two main cases: `tree` is an assignment, * otherwise an `adapt()` to UNIT is performed if needed. */ - def genStat(tree: Tree): Unit = { + def genStat(tree: Tree)(using Context): Unit = { lineNumber(tree) tree match { @@ -135,7 +133,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } /* Generate code for primitive arithmetic operations. */ - def genArithmeticOp(tree: Tree, code: Int): BType = tree match{ + def genArithmeticOp(tree: Tree, code: Int)(using Context): BType = tree match { case Apply(fun @ DesugaredSelect(larg, _), args) => var resKind = tpeTK(larg) @@ -152,13 +150,13 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte case POS => () // nothing case NEG => bc.neg(resKind) case NOT => bc.genPrimitiveNot(resKind) - case _ => abort(s"Unknown unary operation: ${fun.symbol.showFullName} code: $code") + case _ => throw new AssertionError(s"Unknown unary operation: ${fun.symbol.showFullName} code: $code") } // binary operation case rarg :: Nil => val isShift = isShiftOp(code) - resKind = tpeTK(larg).maxType(if (isShift) INT else tpeTK(rarg), ts) + resKind = tpeTK(larg).maxType(if (isShift) INT else tpeTK(rarg), bTypes) if (isShift || isBitwiseOp(code)) { assert(resKind.isIntegralType || (resKind == BOOL), @@ -181,24 +179,24 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte case LSL | LSR | ASR => bc.genPrimitiveShift(code, resKind) - case _ => abort(s"Unknown primitive: ${fun.symbol}[$code]") + case _ => throw new AssertionError(s"Unknown primitive: ${fun.symbol}[$code]") } case _ => - abort(s"Too many arguments for primitive function: $tree") + throw new AssertionError(s"Too many arguments for primitive function: $tree") } lineNumber(tree) resKind } /* Generate primitive array operations. */ - def genArrayOp(tree: Tree, code: Int, expectedType: BType): BType = tree match{ + def genArrayOp(tree: Tree, code: Int, expectedType: BType)(using Context): BType = tree match { case Apply(DesugaredSelect(arrayObj, _), args) => import ScalaPrimitivesOps.* val k = tpeTK(arrayObj) genLoad(arrayObj, k) - val elementType = ts.typeOfArrayOp.getOrElse[BType](code, abort(s"Unknown operation on arrays: $tree code: $code")) + val elementType = bTypes.typeOfArrayOp.getOrElse[BType](code, throw new AssertionError(s"Unknown operation on arrays: $tree code: $code")) var generatedType = expectedType @@ -229,7 +227,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte generatedType } - def genLoadIfTo(tree: If, expectedType: BType, dest: LoadDestination): BType = tree match{ + def genLoadIfTo(tree: If, expectedType: BType, dest: LoadDestination)(using Context): BType = tree match { case If(condp, thenp, elsep) => val success = new asm.Label @@ -270,7 +268,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte end if } - def genPrimitiveOp(tree: Apply, expectedType: BType): BType = (tree: @unchecked) match { + def genPrimitiveOp(tree: Apply, expectedType: BType)(using Context): BType = (tree: @unchecked) match { case Apply(fun @ DesugaredSelect(receiver, _), _) => val sym = tree.symbol @@ -303,23 +301,23 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte genCoercion(code) coercionTo(code) } - else abort( + else throw new AssertionError( s"Primitive operation not handled yet: ${sym.showFullName}(${fun.symbol.name}) at: ${tree.span}" ) } - def genLoad(tree: Tree): BType = { + def genLoad(tree: Tree)(using Context): BType = { val generatedType = tpeTK(tree) genLoad(tree, generatedType) generatedType } /* Generate code for trees that produce values on the stack */ - def genLoad(tree: Tree, expectedType: BType): Unit = + def genLoad(tree: Tree, expectedType: BType)(using Context): Unit = genLoadTo(tree, expectedType, LoadDestination.FallThrough) /* Generate code for trees that produce values, sent to a given `LoadDestination`. */ - def genLoadTo(tree: Tree, expectedType: BType, dest: LoadDestination): Unit = + def genLoadTo(tree: Tree, expectedType: BType, dest: LoadDestination)(using Context): Unit = var generatedType = expectedType var generatedDest = LoadDestination.FallThrough @@ -367,7 +365,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte generatedDest = LoadDestination.Throw case New(tpt) => - abort(s"Unexpected New(${tpt.tpe.showSummary()}/$tpt) reached GenBCode.\n" + + throw new AssertionError(s"Unexpected New(${tpt.tpe.showSummary()}/$tpt) reached GenBCode.\n" + " Call was genLoad" + ((tree, expectedType))) case t @ Closure(env, call, tpt) => @@ -393,7 +391,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte stack.push(prefixTK) } - genLoadArguments(env, fun.symbol.info.firstParamTypes map ts.toTypeKind) + genLoadArguments(env, fun.symbol.info.firstParamTypes.map(bTypeLoader.bTypeFromType)) stack.restoreSize(savedStackSize) generatedType = genInvokeDynamicLambda(NoSymbol, fun.symbol, env.size, functionalInterface) @@ -403,7 +401,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte case This(qual) => val symIsModuleClass = tree.symbol.is(ModuleClass) assert(tree.symbol == claszSymbol || symIsModuleClass, - s"Trying to access the this of another class: tree.symbol = ${tree.symbol}, class symbol = $claszSymbol compilation unit: $cunit") + s"Trying to access the this of another class: tree.symbol = ${tree.symbol}, class symbol = $claszSymbol compilation unit: ${ctx.compilationUnit}") if (symIsModuleClass && tree.symbol != claszSymbol) { generatedType = genLoadModule(tree) } @@ -414,7 +412,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte // the generatedType to `Array` below, the call to adapt at the end would fail. The situation is // similar for primitives (`I` vs `Int`). if (tree.symbol != defn.ArrayClass && !tree.symbol.isPrimitiveValueClass) { - generatedType = ts.classBTypeFromSymbol(claszSymbol) + generatedType = bTypeLoader.classBTypeFromSymbol(claszSymbol) } } @@ -456,7 +454,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte if (value.tag != UnitTag) (value.tag, expectedType) match { case (IntTag, LONG ) => bc.lconst(value.longValue); generatedType = LONG case (FloatTag, DOUBLE) => bc.dconst(value.doubleValue); generatedType = DOUBLE - case (NullTag, _ ) => bc.emit(asm.Opcodes.ACONST_NULL); generatedType = ts.srNullRef + case (NullTag, _ ) => bc.emit(asm.Opcodes.ACONST_NULL); generatedType = bTypes.srNullRef case _ => genConstant(value, l.srcPos); generatedType = tpeTK(tree) } @@ -492,7 +490,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte case t: TypeApply => // dotty specific generatedType = genTypeApply(t) - case _ => abort(s"Unexpected tree in genLoad: $tree/${tree.getClass} at: ${tree.span}") + case _ => throw new AssertionError(s"Unexpected tree in genLoad: $tree/${tree.getClass} at: ${tree.span}") } // emit conversion and send to the right destination @@ -500,7 +498,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte genAdaptAndSendToDest(generatedType, expectedType, dest) end genLoadTo - def genAdaptAndSendToDest(generatedType: BType, expectedType: BType, dest: LoadDestination): Unit = + def genAdaptAndSendToDest(generatedType: BType, expectedType: BType, dest: LoadDestination)(using Context): Unit = if generatedType != expectedType then adapt(generatedType, expectedType) @@ -525,7 +523,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte val thrownType = expectedType // `throw null` is valid although scala.Null (as defined in src/library-aux) isn't a subtype of Throwable. // Similarly for scala.Nothing (again, as defined in src/library-aux). - assert(thrownType.isNullType || thrownType.isNothingType || thrownType.asClassBType.isSubtypeOf(ts.jlThrowableRef)) + assert(thrownType == bTypes.srNullRef || thrownType == bTypes.srNothingRef || thrownType.asClassBType.isSubtypeOf(bTypes.jlThrowableRef)) emit(asm.Opcodes.ATHROW) end genAdaptAndSendToDest @@ -534,20 +532,22 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte /* * must-single-thread */ - def fieldLoad( field: Symbol, hostClass: Symbol = null): Unit = fieldOp(field, isLoad = true, hostClass) + def fieldLoad( field: Symbol, hostClass: Symbol | Null = null)(using Context): Unit = + fieldOp(field, isLoad = true, hostClass) /* * must-single-thread */ - def fieldStore(field: Symbol, hostClass: Symbol = null): Unit = fieldOp(field, isLoad = false, hostClass) + def fieldStore(field: Symbol, hostClass: Symbol | Null = null)(using Context): Unit = + fieldOp(field, isLoad = false, hostClass) /* * must-single-thread */ - private def fieldOp(field: Symbol, isLoad: Boolean, specificReceiver: Symbol): Unit = { + private def fieldOp(field: Symbol, isLoad: Boolean, specificReceiver: Symbol | Null)(using Context): Unit = { val useSpecificReceiver = specificReceiver != null && !field.isScalaStatic - val owner = ts.internalName(if (useSpecificReceiver) specificReceiver else field.owner) + val owner = bTypeLoader.classBTypeFromSymbol(if (useSpecificReceiver) specificReceiver else field.owner).internalName val fieldJName = field.javaSimpleName val fieldDescr = symInfoTK(field).descriptor val isStatic = field.isStaticMember @@ -565,7 +565,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte * must-single-thread * Otherwise it's safe to call from multiple threads. */ - private def genConstant(const: Constant, pos: SrcPos): Unit = { + private def genConstant(const: Constant, pos: SrcPos)(using Context): Unit = { (const.tag: @switch) match { case BooleanTag => bc.boolconst(const.booleanValue) @@ -593,14 +593,14 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte case NullTag => emit(asm.Opcodes.ACONST_NULL) case ClazzTag => - val tp = ts.toTypeKind(const.typeValue) + val tp = bTypeLoader.bTypeFromType(const.typeValue) if tp.isPrimitive then - val boxedClass = ts.boxedClassOfPrimitive(tp.asPrimitiveBType) + val boxedClass = bTypes.boxedClassOfPrimitive(tp.asPrimitiveBType) mnode.visitFieldInsn( asm.Opcodes.GETSTATIC, boxedClass.internalName, "TYPE", // field name - ts.jlClassRef.descriptor + bTypes.jlClassRef.descriptor ) else val toASM = tp.toASMType @@ -611,11 +611,11 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte mnode.visitLdcInsn("") report.error("Type name is too long for the JVM", pos) - case _ => abort(s"Unknown constant value: $const") + case _ => throw new AssertionError(s"Unknown constant value: $const") } } - private def genLabeledTo(tree: Labeled, expectedType: BType, dest: LoadDestination): BType = tree match { + private def genLabeledTo(tree: Labeled, expectedType: BType, dest: LoadDestination)(using Context): BType = tree match { case Labeled(bind, expr) => val labelSym = bind.symbol @@ -634,7 +634,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte end if } - private def genReturn(r: Return): Unit = { + private def genReturn(r: Return)(using Context): Unit = { val expr: Tree = r.expr val fromSym: Symbol = if (r.from.symbol.is(LabelFlag)) r.from.symbol else NoSymbol @@ -672,7 +672,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } } // end of genReturn() - def genWhileDo(tree: WhileDo): LoadDestination = tree match{ + def genWhileDo(tree: WhileDo)(using Context): LoadDestination = tree match { case WhileDo(cond, body) => val isInfinite = cond == tpd.EmptyTree @@ -702,14 +702,14 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte LoadDestination.FallThrough } - def genTypeApply(t: TypeApply): BType = (t: @unchecked) match { + def genTypeApply(t: TypeApply)(using Context): BType = (t: @unchecked) match { case TypeApply(fun@DesugaredSelect(obj, _), targs) => val sym = fun.symbol val cast = if (sym == defn.Any_isInstanceOf) false else if (sym == defn.Any_asInstanceOf) true - else abort(s"Unexpected type application $fun[sym: ${sym.showFullName}] in: $t") + else throw new AssertionError(s"Unexpected type application $fun[sym: ${sym.showFullName}] in: $t") val l = tpeTK(obj) val r = tpeTK(targs.head) genLoadQualifier(fun) @@ -720,18 +720,18 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte else if (l.isPrimitive) { bc.drop(l) if (cast) { - mnode.visitTypeInsn(asm.Opcodes.NEW, ts.jlClassCastExceptionRef.internalName) - bc.dup(ts.ObjectRef) + mnode.visitTypeInsn(asm.Opcodes.NEW, bTypes.jlClassCastExceptionRef.internalName) + bc.dup(bTypes.ObjectRef) emit(asm.Opcodes.ATHROW) } else { bc.boolconst(false) } } else if (r.isPrimitive && cast) { - abort(s"Erasure should have added an unboxing operation to prevent this cast. Tree: $t") + throw new AssertionError(s"Erasure should have added an unboxing operation to prevent this cast. Tree: $t") } else if (r.isPrimitive) { - bc.isInstance(ts.boxedClassOfPrimitive(r.asPrimitiveBType)) + bc.isInstance(bTypes.boxedClassOfPrimitive(r.asPrimitiveBType)) } else { assert(r.isRef, r) // ensure that it's not a method @@ -742,7 +742,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } // end of genTypeApply() - private def mkArrayConstructorCall(arr: ArrayBType, app: Apply, args: List[Tree]) = { + private def mkArrayConstructorCall(arr: ArrayBType, app: Apply, args: List[Tree])(using Context) = { val dims = arr.dimension var elemKind = arr.elementType val argsSize = args.length @@ -766,14 +766,14 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } - private def genApply(app: Apply, expectedType: BType): BType = { + private def genApply(app: Apply, expectedType: BType)(using Context): BType = { var generatedType = expectedType lineNumber(app) app match { case Apply(_, args) if app.symbol eq defn.newArrayMethod => val List(elemClaz, Literal(c: Constant), av: tpd.JavaSeqLiteral) = args: @unchecked - generatedType = ts.toTypeKind(c.typeValue) + generatedType = bTypeLoader.bTypeFromType(c.typeValue) mkArrayConstructorCall(generatedType.asArrayBType, app, av.elems) case Apply(t :TypeApply, _) => generatedType = @@ -816,7 +816,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte val ctor = fun.symbol assert(ctor.isClassConstructor, s"'new' call to non-constructor: ${ctor.name}") - generatedType = ts.toTypeKind(tpt.tpe) + generatedType = bTypeLoader.bTypeFromType(tpt.tpe) assert(generatedType.isRef, s"Non reference type cannot be instantiated: $generatedType") generatedType match { @@ -824,7 +824,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte mkArrayConstructorCall(arr, app, args) case rt: ClassBType => - assert(ts.classBTypeFromSymbol(ctor.owner) == rt, s"Symbol ${ctor.owner.showFullName} is different from $rt") + assert(bTypeLoader.classBTypeFromSymbol(ctor.owner) == rt, s"Symbol ${ctor.owner.showFullName} is different from $rt") mnode.visitTypeInsn(asm.Opcodes.NEW, rt.internalName) bc.dup(generatedType) stack.push(rt) @@ -834,22 +834,22 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte genCallMethod(ctor, InvokeStyle.Special, app) case _ => - abort(s"Cannot instantiate $tpt of kind: $generatedType") + throw new AssertionError(s"Cannot instantiate $tpt of kind: $generatedType") } case Apply(fun, List(expr)) if Erasure.Boxing.isBox(fun.symbol) && fun.symbol.denot.owner != defn.UnitModuleClass => val nativeKind = tpeTK(expr) genLoad(expr, nativeKind) - val MethodNameAndType(mname, methodType) = ts.asmBoxTo(nativeKind) - bc.invokestatic(ts.srBoxesRuntimeRef.internalName, mname, methodType.descriptor, itf = false, app) - generatedType = ts.boxResultType(fun.symbol) // was toTypeKind(fun.symbol.tpe.resultType) + val MethodNameAndType(mname, methodType) = bTypes.asmBoxTo(nativeKind) + bc.invokestatic(bTypes.srBoxesRuntimeRef.internalName, mname, methodType.descriptor, itf = false, app) + generatedType = bTypes.boxResultType(fun.symbol) // was toTypeKind(fun.symbol.tpe.resultType) case Apply(fun, List(expr)) if Erasure.Boxing.isUnbox(fun.symbol) && fun.symbol.denot.owner != defn.UnitModuleClass => genLoad(expr) - val boxType = ts.unboxResultType(fun.symbol) // was toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe) + val boxType = bTypes.unboxResultType(fun.symbol) // was toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe) generatedType = boxType - val MethodNameAndType(mname, methodType) = ts.asmUnboxTo(boxType) - bc.invokestatic(ts.srBoxesRuntimeRef.internalName, mname, methodType.descriptor, itf = false, app) + val MethodNameAndType(mname, methodType) = bTypes.asmUnboxTo(boxType) + bc.invokestatic(bTypes.srBoxesRuntimeRef.internalName, mname, methodType.descriptor, itf = false, app) case app @ Apply(fun, args) => val sym = fun.symbol @@ -886,7 +886,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte // Example: `class C { override def clone(): Object = "hi" }` // Emitting `def f(c: C) = c.clone()` as `Object.clone()` gives a VerifyError. val target: String = tpeTK(qual).asRefBType.classOrArrayType - val methodBType = ts.asmMethodType(sym) + val methodBType = bTypeLoader.methodBTypeFromSymbol(sym) bc.invokevirtual(target, sym.javaSimpleName, methodBType.descriptor, app) generatedType = methodBType.returnType } else { @@ -911,7 +911,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte generatedType } // end of genApply() - private def genArrayValue(av: tpd.JavaSeqLiteral): BType = { + private def genArrayValue(av: tpd.JavaSeqLiteral)(using Context): BType = { val tpt = av.tpe match { case JavaArrayType(elem) => elem case _ => @@ -923,8 +923,8 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte genArray(av.elems, tpt) } - private def genArray(elems: List[Tree], elemType: Type): BType = { - val elmKind = ts.toTypeKind(elemType) + private def genArray(elems: List[Tree], elemType: Type)(using Context): BType = { + val elmKind = bTypeLoader.bTypeFromType(elemType) val generatedType = ArrayBType(elmKind) bc.iconst(elems.length) @@ -955,7 +955,15 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte * Int/String values to use as keys, and a code block. The exception is the "default" case * clause which doesn't list any key (there is exactly one of these per match). */ - private def genMatchTo(tree: Match, expectedType: BType, dest: LoadDestination): BType = tree match { + private def emitThrowMatchError(): Unit = + bc.jmethod.visitTypeInsn(asm.Opcodes.NEW, "scala/MatchError") + bc.jmethod.visitInsn(asm.Opcodes.DUP) + bc.jmethod.visitInsn(asm.Opcodes.ACONST_NULL) + bc.jmethod.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, + "scala/MatchError", "", "(Ljava/lang/Object;)V", false) + bc.jmethod.visitInsn(asm.Opcodes.ATHROW) + + private def genMatchTo(tree: Match, expectedType: BType, dest: LoadDestination)(using Context): BType = tree match { case Match(selector, cases) => lineNumber(tree) @@ -1001,13 +1009,17 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte flatKeys ::= value.intValue targets ::= switchBlockPoint case _ => - abort(s"Invalid alternative in alternative pattern in Match node: $tree at: ${tree.span}") + throw new AssertionError(s"Invalid alternative in alternative pattern in Match node: $tree at: ${tree.span}") } case _ => - abort(s"Invalid pattern in Match node: $tree at: ${tree.span}") + throw new AssertionError(s"Invalid pattern in Match node: $tree at: ${tree.span}") } } + val hasDefault = default != null + if !hasDefault then + default = new asm.Label + bc.emitSWITCH(mkArrayReverse(flatKeys), mkArrayL(targets.reverse), default, MIN_SWITCH_DENSITY) // emit switch-blocks. @@ -1016,6 +1028,10 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte markProgramPoint(caseLabel) genLoadTo(caseBody, generatedType, postMatchDest) } + + if !hasDefault then + markProgramPoint(default) + emitThrowMatchError() } else { /* Since the JVM doesn't have a way to switch on a string, we switch @@ -1059,11 +1075,11 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte Some(newCase :: existingCasesOpt.getOrElse(Nil)) } case _ => - abort(s"Invalid alternative in alternative pattern in Match node: $tree at: ${tree.span}") + throw new AssertionError(s"Invalid alternative in alternative pattern in Match node: $tree at: ${tree.span}") } case _ => - abort(s"Invalid pattern in Match node: $tree at: ${tree.span}") + throw new AssertionError(s"Invalid pattern in Match node: $tree at: ${tree.span}") } } @@ -1078,6 +1094,11 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte targets ::= switchBlockPoint } + val hasDefault = default != null + if !hasDefault then + default = new asm.Label + indirectBlocks ::= (default, null) + // Push the hashCode of the string (or `0` it is `null`) onto the stack and switch on it genLoadIfTo( If( @@ -1115,7 +1136,10 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte // emit blocks for common patterns for ((caseLabel, caseBody) <- indirectBlocks.reverse) { markProgramPoint(caseLabel) - genLoadTo(caseBody, generatedType, postMatchDest) + if caseBody == null then + emitThrowMatchError() + else + genLoadTo(caseBody, generatedType, postMatchDest) } } @@ -1124,7 +1148,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte generatedType } - def genBlockTo(tree: Block, expectedType: BType, dest: LoadDestination): Unit = tree match { + def genBlockTo(tree: Block, expectedType: BType, dest: LoadDestination)(using Context): Unit = tree match { case Block(stats, expr) => val savedScope = varsInScope @@ -1147,9 +1171,9 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } end emitLocalVarScopes - def adapt(from: BType, to: BType): Unit = { - if (from.isNothingType) { - /* There are two possibilities for from.isNothingType: emitting a "throw e" expressions and + def adapt(from: BType, to: BType)(using Context): Unit = { + if (from == bTypes.srNothingRef) { + /* There are two possibilities for from being Nothing: emitting a "throw e" expressions and * loading a (phantom) value of type Nothing. * * The Nothing type in Scala's type system does not exist in the JVM. In bytecode, Nothing @@ -1195,7 +1219,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte */ if (lastInsn.getOpcode != asm.Opcodes.ATHROW) emit(asm.Opcodes.ATHROW) - } else if (from.isNullType) { + } else if (from == bTypes.srNullRef) { /* After loading an expression of type `scala.runtime.Null$`, introduce POP; ACONST_NULL. * This is required to pass the verifier: in Scala's type system, Null conforms to any * reference type. In bytecode, the type Null is represented by scala.runtime.Null$, which @@ -1223,7 +1247,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } /* Emit code to Load the qualifier of `tree` on top of the stack. */ - def genLoadQualifier(tree: Tree): BType = { + def genLoadQualifier(tree: Tree)(using Context): BType = { lineNumber(tree) tree match { case DesugaredSelect(qualifier, _) => genLoad(qualifier) @@ -1234,11 +1258,11 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte assert(t.symbol.owner == this.claszSymbol) UNIT } - case _ => abort(s"Unknown qualifier $tree") + case _ => throw new AssertionError(s"Unknown qualifier $tree") } } - def genLoadArguments(args: List[Tree], btpes: List[BType]): Unit = + def genLoadArguments(args: List[Tree], btpes: List[BType])(using Context): Unit = @tailrec def loop(args: List[Tree], btpes: List[BType]): Unit = args match case arg :: args1 => @@ -1255,12 +1279,12 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte stack.restoreSize(savedStackSize) end genLoadArguments - def genLoadModule(tree: Tree): BType = { + def genLoadModule(tree: Tree)(using Context): BType = { val module = ( if (!tree.symbol.is(PackageClass)) tree.symbol else tree.symbol.info.member(nme.PACKAGE).symbol match { - case NoSymbol => abort(s"SI-5604: Cannot use package as value: $tree") - case s => abort(s"SI-5604: found package class where package object expected: $tree") + case NoSymbol => throw new AssertionError(s"SI-5604: Cannot use package as value: $tree") + case s => throw new AssertionError(s"SI-5604: found package class where package object expected: $tree") } ) lineNumber(tree) @@ -1268,7 +1292,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte symInfoTK(module) } - def genLoadModule(module: Symbol): Unit = { + def genLoadModule(module: Symbol)(using Context): Unit = { def inStaticMethod = methSymbol != null && methSymbol.isStaticMember if (claszSymbol == module.moduleClass && jMethodName != "readResolve" && !inStaticMethod) { mnode.visitVarInsn(asm.Opcodes.ALOAD, 0) @@ -1317,12 +1341,12 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte * * use `invokedynamic` with `StringConcatFactory` */ - def genStringConcat(tree: Tree): BType = { + def genStringConcat(tree: Tree)(using Context): BType = { lineNumber(tree) liftStringConcat(tree) match { // Optimization for expressions of the form "" + x case List(Literal(Constant("")), arg) => - genLoad(arg, ts.ObjectRef) + genLoad(arg, bTypes.ObjectRef) genCallMethod(defn.String_valueOf_Object, InvokeStyle.Static) case concatenations => @@ -1363,8 +1387,8 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte if (totalArgSlots + elemSlots >= MaxIndySlots) { stack.restoreSize(savedStackSize) for _ <- 0 until countConcats do - stack.push(ts.StringRef) - bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result(), ts) + stack.push(bTypes.StringRef) + bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result(), bTypes) countConcats += 1 totalArgSlots = 0 recipe.setLength(0) @@ -1392,19 +1416,19 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } } stack.restoreSize(savedStackSize) - bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result(), ts) + bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result(), bTypes) // If we spilled, generate one final concat if (countConcats > 1) { bc.genIndyStringConcat( TagArg.toString * countConcats, - Seq.fill(countConcats)(ts.StringRef.toASMType), + Seq.fill(countConcats)(bTypes.StringRef.toASMType), Seq.empty, - ts + bTypes ) } } - ts.StringRef + bTypes.StringRef } /** @@ -1412,7 +1436,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte * invocation instruction, otherwise `method.owner`. A specific receiver class is needed to * prevent IllegalAccessError in some virtual and super calls (aladdin bug 455, i22628). */ - private def genCallMethod(method: Symbol, style: InvokeStyle, pos: Positioned | Null = null, specificReceiver: Symbol = null): BType = { + private def genCallMethod(method: Symbol, style: InvokeStyle, pos: Positioned | Null = null, specificReceiver: Symbol | Null = null)(using Context): BType = { val methodOwner = method.owner // the class used in the invocation's method descriptor in the classfile @@ -1450,16 +1474,16 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } receiverClass.info // ensure types the type is up to date; erasure may add lateINTERFACE to traits - val receiverName = ts.internalName(receiverClass) + val receiverName = bTypeLoader.classBTypeFromSymbol(receiverClass).internalName val jname = method.javaSimpleName - val bmType = ts.asmMethodType(method) + val bmType = bTypeLoader.methodBTypeFromSymbol(method) val mdescr = bmType.descriptor val isInterface = isEmittedInterface(receiverClass) import InvokeStyle.* if (style == Super) { - val ownerBType = ts.toTypeKind(method.owner.info) + val ownerBType = bTypeLoader.bTypeFromType(method.owner.info) if (isInterface && !method.is(JavaDefined)) { val staticDesc = MethodBType(ownerBType :: bmType.argumentTypes, bmType.returnType).descriptor val staticName = BackendUtils.traitSuperAccessorName(method) @@ -1485,8 +1509,8 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } // end of genCallMethod() /* Generate the scala ## method. */ - def genScalaHash(tree: Tree): BType = { - genLoad(tree, ts.ObjectRef) + def genScalaHash(tree: Tree)(using Context): BType = { + genLoad(tree, bTypes.ObjectRef) genCallMethod(NoSymbol, InvokeStyle.Static) // used to dispatch ## on primitives to ScalaRuntime.hash. Should be implemented by a miniphase } @@ -1494,7 +1518,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte * Returns a list of trees that each should be concatenated, from left to right. * It turns a chained call like "a".+("b").+("c") into a list of arguments. */ - def liftStringConcat(tree: Tree): List[Tree] = tree match { + def liftStringConcat(tree: Tree)(using Context): List[Tree] = tree match { case tree @ Apply(fun @ DesugaredSelect(larg, method), rarg) => if (isPrimitive(fun) && primitives.getPrimitive(tree, larg.tpe) == ScalaPrimitivesOps.CONCAT) @@ -1571,7 +1595,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte * Generate code for conditional expressions. * The jump targets success/failure of the test are `then-target` and `else-target` resp. */ - private def genCond(tree: Tree, success: asm.Label, failure: asm.Label, targetIfNoJump: asm.Label): Unit = { + private def genCond(tree: Tree, success: asm.Label, failure: asm.Label, targetIfNoJump: asm.Label)(using Context): Unit = { def genComparisonOp(l: Tree, r: Tree, code: Int): Unit = { val op = testOpForPrimitive(code) @@ -1583,10 +1607,10 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte val nonNullSide = if (ScalaPrimitivesOps.isReferenceEqualityOp(code)) ifOneIsNull(l, r) else null if (nonNullSide != null) { // special-case reference (in)equality test for null (null eq x, x eq null) - genLoad(nonNullSide, ts.ObjectRef) - genCZJUMP(success, failure, op, ts.ObjectRef, targetIfNoJump) + genLoad(nonNullSide, bTypes.ObjectRef) + genCZJUMP(success, failure, op, bTypes.ObjectRef, targetIfNoJump) } else { - val tk = tpeTK(l).maxType(tpeTK(r), ts) + val tk = tpeTK(l).maxType(tpeTK(r), bTypes) genLoad(l, tk) stack.push(tk) genLoad(r, tk) @@ -1668,7 +1692,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte * @param l left-hand-side of the '==' * @param r right-hand-side of the '==' */ - def genEqEqPrimitive(l: Tree, r: Tree, success: asm.Label, failure: asm.Label, targetIfNoJump: asm.Label): Unit = { + def genEqEqPrimitive(l: Tree, r: Tree, success: asm.Label, failure: asm.Label, targetIfNoJump: asm.Label)(using Context): Unit = { /* True if the equality comparison is between values that require the use of the rich equality * comparator (scala.runtime.Comparator.equals). This is the case when either side of the @@ -1704,9 +1728,9 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } else defn.BoxesRunTimeModule_externalEquals } - genLoad(l, ts.ObjectRef) - stack.push(ts.ObjectRef) - genLoad(r, ts.ObjectRef) + genLoad(l, bTypes.ObjectRef) + stack.push(bTypes.ObjectRef) + genLoad(r, bTypes.ObjectRef) stack.pop() genCallMethod(equalsMethod, InvokeStyle.Static) genCZJUMP(success, failure, TestOp.NE, BOOL, targetIfNoJump) @@ -1714,25 +1738,25 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte else { if (isNull(l)) { // null == expr -> expr eq null - genLoad(r, ts.ObjectRef) - genCZJUMP(success, failure, TestOp.EQ, ts.ObjectRef, targetIfNoJump) + genLoad(r, bTypes.ObjectRef) + genCZJUMP(success, failure, TestOp.EQ, bTypes.ObjectRef, targetIfNoJump) } else if (isNull(r)) { // expr == null -> expr eq null - genLoad(l, ts.ObjectRef) - genCZJUMP(success, failure, TestOp.EQ, ts.ObjectRef, targetIfNoJump) + genLoad(l, bTypes.ObjectRef) + genCZJUMP(success, failure, TestOp.EQ, bTypes.ObjectRef, targetIfNoJump) } else if (isNonNullExpr(l)) { // SI-7852 Avoid null check if L is statically non-null. - genLoad(l, ts.ObjectRef) - stack.push(ts.ObjectRef) - genLoad(r, ts.ObjectRef) + genLoad(l, bTypes.ObjectRef) + stack.push(bTypes.ObjectRef) + genLoad(r, bTypes.ObjectRef) stack.pop() genCallMethod(defn.Any_equals, InvokeStyle.Virtual) genCZJUMP(success, failure, TestOp.NE, BOOL, targetIfNoJump) } else { // l == r -> Objects.equals(l, r) - genLoad(l, ts.ObjectRef) - stack.push(ts.ObjectRef) - genLoad(r, ts.ObjectRef) + genLoad(l, bTypes.ObjectRef) + stack.push(bTypes.ObjectRef) + genLoad(r, bTypes.ObjectRef) stack.pop() genCallMethod(defn.Objects_equals, InvokeStyle.Static) genCZJUMP(success, failure, TestOp.NE, BOOL, targetIfNoJump) @@ -1741,14 +1765,14 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte } - def genSynchronized(tree: Apply, expectedType: BType): BType - def genLoadTry(tree: Try): BType + def genSynchronized(tree: Apply, expectedType: BType)(using Context): BType + def genLoadTry(tree: Try)(using Context): BType - def genInvokeDynamicLambda(ctor: Symbol, lambdaTarget: Symbol, environmentSize: Int, functionalInterface: Symbol): BType = { + def genInvokeDynamicLambda(ctor: Symbol, lambdaTarget: Symbol, environmentSize: Int, functionalInterface: Symbol)(using Context): BType = { import java.lang.invoke.LambdaMetafactory.{FLAG_BRIDGES, FLAG_SERIALIZABLE} report.debuglog(s"Using invokedynamic rather than `new ${ctor.owner}`") - val generatedType = ts.classBTypeFromSymbol(functionalInterface) + val generatedType = bTypeLoader.classBTypeFromSymbol(functionalInterface) // Lambdas should be serializable if they implement a SAM that extends Serializable or if they // implement a scala.Function* class. val isSerializable = functionalInterface.isSerializable || defn.isFunctionClass(functionalInterface) @@ -1761,9 +1785,9 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte val targetHandle = new asm.Handle(invokeStyle, - ts.classBTypeFromSymbol(lambdaTarget.owner).internalName, + bTypeLoader.classBTypeFromSymbol(lambdaTarget.owner).internalName, lambdaTarget.javaSimpleName, - ts.asmMethodType(lambdaTarget).descriptor, + bTypeLoader.methodBTypeFromSymbol(lambdaTarget).descriptor, /* itf = */ isInterface) val (a,b) = lambdaTarget.info.firstParamTypes.splitAt(environmentSize) @@ -1775,30 +1799,30 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte // Requires https://github.com/scala/scala-java8-compat on the runtime classpath val returnUnit = lambdaTarget.info.resultType.typeSymbol == defn.UnitClass val functionalInterfaceDesc: String = generatedType.descriptor - val desc = capturedParamsTypes.map(tpe => ts.toTypeKind(tpe)).mkString(("("), "", ")") + functionalInterfaceDesc + val desc = capturedParamsTypes.map(bTypeLoader.bTypeFromType).mkString(("("), "", ")") + functionalInterfaceDesc val samMethod = atPhase(erasurePhase) { val samMethods = toDenot(functionalInterface).info.possibleSamMethods.toList samMethods match { case x :: Nil => x.symbol - case Nil => abort(s"${functionalInterface.show} is not a functional interface. It doesn't have abstract methods") - case xs => abort(s"${functionalInterface.show} is not a functional interface. " + + case Nil => throw new AssertionError(s"${functionalInterface.show} is not a functional interface. It doesn't have abstract methods") + case xs => throw new AssertionError(s"${functionalInterface.show} is not a functional interface. " + s"It has the following abstract methods: ${xs.map(_.name).mkString(", ")}") } } val methodName = samMethod.javaSimpleName - val samMethodBType = ts.asmMethodType(samMethod) + val samMethodBType = bTypeLoader.methodBTypeFromSymbol(samMethod) val samMethodType = samMethodBType.toASMType def boxInstantiated(instantiatedType: BType, samType: BType): BType = if(!samType.isPrimitive && instantiatedType.isPrimitive) - ts.boxedClassOfPrimitive(instantiatedType.asPrimitiveBType) + bTypes.boxedClassOfPrimitive(instantiatedType.asPrimitiveBType) else instantiatedType // TODO specialization - val instantiatedMethodBType = new MethodBType( - lambdaParamTypes.map(p => ts.toTypeKind(p)), - boxInstantiated(ts.toTypeKind(lambdaTarget.info.resultType), samMethodBType.returnType) + val instantiatedMethodBType = MethodBType( + lambdaParamTypes.map(bTypeLoader.bTypeFromType), + boxInstantiated(bTypeLoader.bTypeFromType(lambdaTarget.info.resultType), samMethodBType.returnType) ) val instantiatedMethodType = instantiatedMethodBType.toASMType @@ -1809,7 +1833,7 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte val bridgeMethods = atPhase(erasurePhase){ samMethod.allOverriddenSymbols.toList } - val overriddenMethodTypes = bridgeMethods.map(b => ts.asmMethodType(b).toASMType) + val overriddenMethodTypes = bridgeMethods.map(b => bTypeLoader.methodBTypeFromSymbol(b).toASMType) // any methods which `samMethod` overrides need bridges made for them // this is done automatically during erasure for classes we generate, but LMF needs to have them explicitly mentioned @@ -1834,9 +1858,9 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte val metafactory = if (flags != 0) - ts.jliLambdaMetaFactoryAltMetafactoryHandle // altMetafactory required to be able to pass the flags and additional arguments if needed + bTypes.jliLambdaMetaFactoryAltMetafactoryHandle // altMetafactory required to be able to pass the flags and additional arguments if needed else - ts.jliLambdaMetaFactoryMetafactoryHandle + bTypes.jliLambdaMetaFactoryMetafactoryHandle bc.jmethod.visitInvokeDynamicInsn(methodName, desc, metafactory, bsmArgs*) @@ -1850,8 +1874,8 @@ trait BCodeBodyBuilder(val primitives: ScalaPrimitives)(using ctx: Context) exte * create for Java-defined classes as well as for Java annotations * which we represent as classes. */ - private def isEmittedInterface(sym: Symbol): Boolean = sym.is(Trait) || - sym.is(JavaDefined) && (toDenot(sym).isAnnotation || sym.is(ModuleClass) && (sym.companionClass.is(PureInterface)) || sym.companionClass.is(Trait)) - + private def isEmittedInterface(sym: Symbol)(using Context): Boolean = + sym.is(Trait) || + sym.is(JavaDefined) && (toDenot(sym).isAnnotation || sym.is(ModuleClass) && (sym.companionClass.is(PureInterface)) || sym.companionClass.is(Trait)) } diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala b/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala index e6ba882d7505..791e49cc682a 100644 --- a/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala +++ b/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala @@ -3,15 +3,9 @@ package backend package jvm import scala.language.unsafeNulls - -import scala.annotation.threadUnsafe import scala.tools.asm -import scala.tools.asm.AnnotationVisitor -import scala.tools.asm.ClassWriter +import scala.tools.asm.{AnnotationVisitor, ClassWriter, Opcodes} import scala.collection.mutable -import scala.compiletime.uninitialized - -import dotty.tools.dotc.CompilationUnit import dotty.tools.dotc.ast.tpd import dotty.tools.dotc.ast.Trees import dotty.tools.dotc.core.Annotations.* @@ -29,14 +23,11 @@ import dotty.tools.dotc.core.Symbols.* import dotty.tools.dotc.core.Types import dotty.tools.dotc.core.Types.* import dotty.tools.dotc.core.TypeErasure -import dotty.tools.dotc.transform.GenericSignatures import dotty.tools.dotc.transform.ElimErasedValueType import dotty.tools.dotc.transform.Mixin -import dotty.tools.io.AbstractFile import dotty.tools.dotc.report - import tpd.* -import SymbolUtils.given +import dotty.tools.dotc.config.ScalaSettingsProperties /* * Encapsulates functionality to convert Scala AST Trees into ASM ClassNodes. @@ -45,18 +36,24 @@ import SymbolUtils.given * @version 1.0 * */ -trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends BCodeIdiomatic { - - val ts: CoreBTypes - - private def ScalaATTRName: String = "Scala" - private def ScalaSignatureATTRName: String = "ScalaSig" - - @threadUnsafe private lazy val AnnotationRetentionAttr: ClassSymbol = requiredClass("java.lang.annotation.Retention") - @threadUnsafe private lazy val AnnotationRetentionSourceAttr: TermSymbol = requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE") - @threadUnsafe private lazy val AnnotationRetentionClassAttr: TermSymbol = requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("CLASS") - @threadUnsafe private lazy val AnnotationRetentionRuntimeAttr: TermSymbol = requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("RUNTIME") - +trait BCodeHelpers(val bTypeLoader: BTypeLoader, val bTypes: WellKnownBTypes) extends BCodeIdiomatic { + + // OK to cache because it won't change across Contexts + private var cachedClassfileVersion: Int | Null = null + protected def classfileVersion(using Context): Int = + if cachedClassfileVersion == null then + val releaseValue = Option(ctx.settings.javaOutputVersion.value).filter(_.nonEmpty) + val targetValue = Option(ctx.settings.XuncheckedJavaOutputVersion.value).filter(_.nonEmpty) + val target = (releaseValue, targetValue) match + case (Some(release), None) => release + case (None, Some(target)) => target + case (Some(release), Some(_)) => + report.warning(s"The value of ${ctx.settings.XuncheckedJavaOutputVersion.name} was overridden by ${ctx.settings.javaOutputVersion.name}") + release + case (None, None) => ScalaSettingsProperties.supportedTargetVersions.min // least supported version by default + // take advantage of the fact classfile versions are consecutive + cachedClassfileVersion = target.toInt + (Opcodes.V17 - 17) + cachedClassfileVersion.nn /* * can-multi-thread @@ -100,57 +97,83 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B /* * can-multi-thread */ - def pickleMarkerLocal = { - createJAttribute(ScalaSignatureATTRName, versionPickle.bytes, 0, versionPickle.writeIndex) + def pickleMarkerLocal(using Context) = { + createJAttribute(nme.ScalaSignatureATTR.toString, versionPickle.bytes, 0, versionPickle.writeIndex) } /* * can-multi-thread */ - def pickleMarkerForeign = { - createJAttribute(ScalaATTRName, new Array[Byte](0), 0, 0) + def pickleMarkerForeign(using Context) = { + createJAttribute(nme.ScalaATTR.toString, new Array[Byte](0), 0, 0) } } // end of trait BCPickles trait BCAnnotGen { + // OK to cache these across Contexts, what they refer to won't change + private var cachedAnnotationRetentionAttr: ClassSymbol | Null = null + private var cachedAnnotationRetentionSource: TermSymbol | Null = null + private var cachedAnnotationRetentionClass: TermSymbol | Null = null + private var cachedAnnotationRetentionRuntime: TermSymbol | Null = null + + private def annotationRetentionAttr(using Context): ClassSymbol = + if cachedAnnotationRetentionAttr eq null then + cachedAnnotationRetentionAttr = requiredClass("java.lang.annotation.Retention") + cachedAnnotationRetentionAttr.nn + + private def annotationRetentionSourceAttr(using Context): TermSymbol = + if cachedAnnotationRetentionSource eq null then + cachedAnnotationRetentionSource = requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE") + cachedAnnotationRetentionSource.nn + + private def annotationRetentionClassAttr(using Context): TermSymbol = + if cachedAnnotationRetentionClass eq null then + cachedAnnotationRetentionClass = requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("CLASS") + cachedAnnotationRetentionClass.nn + + private def annotationRetentionRuntimeAttr(using Context): TermSymbol = + if cachedAnnotationRetentionRuntime eq null then + cachedAnnotationRetentionRuntime = requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("RUNTIME") + cachedAnnotationRetentionRuntime.nn + /* * must-single-thread */ - def emitAnnotations(cw: asm.ClassVisitor, annotations: List[Annotation]): Unit = + def emitAnnotations(cw: asm.ClassVisitor, annotations: List[Annotation])(using Context): Unit = for(annot <- annotations; if shouldEmitAnnotation(annot)) { val typ = annot.tree.tpe val assocs = assocsFromApply(annot.tree) - val av = cw.visitAnnotation(ts.typeDescriptor(typ), isRuntimeVisible(annot)) + val av = cw.visitAnnotation(bTypeLoader.bTypeFromType(typ).descriptor, isRuntimeVisible(annot)) emitAssocs(av, assocs) } /* * must-single-thread */ - def emitAnnotations(mw: asm.MethodVisitor, annotations: List[Annotation]): Unit = + def emitAnnotations(mw: asm.MethodVisitor, annotations: List[Annotation])(using Context): Unit = for(annot <- annotations; if shouldEmitAnnotation(annot)) { val typ = annot.tree.tpe val assocs = assocsFromApply(annot.tree) - val av = mw.visitAnnotation(ts.typeDescriptor(typ), isRuntimeVisible(annot)) + val av = mw.visitAnnotation(bTypeLoader.bTypeFromType(typ).descriptor, isRuntimeVisible(annot)) emitAssocs(av, assocs) } /* * must-single-thread */ - def emitAnnotations(fw: asm.FieldVisitor, annotations: List[Annotation]): Unit = + def emitAnnotations(fw: asm.FieldVisitor, annotations: List[Annotation])(using Context): Unit = for(annot <- annotations; if shouldEmitAnnotation(annot)) { val typ = annot.tree.tpe val assocs = assocsFromApply(annot.tree) - val av = fw.visitAnnotation(ts.typeDescriptor(typ), isRuntimeVisible(annot)) + val av = fw.visitAnnotation(bTypeLoader.bTypeFromType(typ).descriptor, isRuntimeVisible(annot)) emitAssocs(av, assocs) } /* * must-single-thread */ - def emitParamNames(jmethod: asm.MethodVisitor, params: List[Symbol]): Unit = + def emitParamNames(jmethod: asm.MethodVisitor, params: List[Symbol])(using Context): Unit = for param <- params do var access = asm.Opcodes.ACC_FINAL if param.is(Artifact) then access |= asm.Opcodes.ACC_SYNTHETIC @@ -159,31 +182,31 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B /* * must-single-thread */ - def emitParamAnnotations(jmethod: asm.MethodVisitor, pannotss: List[List[Annotation]]): Unit = + def emitParamAnnotations(jmethod: asm.MethodVisitor, pannotss: List[List[Annotation]])(using Context): Unit = val annotationss = pannotss.map(_.filter(shouldEmitAnnotation)) if (annotationss.forall(_.isEmpty)) return for ((annots, idx) <- annotationss.zipWithIndex; annot <- annots) { val typ = annot.tree.tpe val assocs = assocsFromApply(annot.tree) - val pannVisitor: asm.AnnotationVisitor = jmethod.visitParameterAnnotation(idx, ts.typeDescriptor(typ), isRuntimeVisible(annot)) + val pannVisitor: asm.AnnotationVisitor = jmethod.visitParameterAnnotation(idx, bTypeLoader.bTypeFromType(typ).descriptor, isRuntimeVisible(annot)) emitAssocs(pannVisitor, assocs) } - private def shouldEmitAnnotation(annot: Annotation): Boolean = { + private def shouldEmitAnnotation(annot: Annotation)(using Context): Boolean = { annot.symbol.is(JavaDefined) && - retentionPolicyOf(annot) != AnnotationRetentionSourceAttr + retentionPolicyOf(annot) != annotationRetentionSourceAttr } - private def emitAssocs(av: asm.AnnotationVisitor, assocs: List[(Name, Object)]): Unit = { + private def emitAssocs(av: asm.AnnotationVisitor, assocs: List[(Name, Object)])(using Context): Unit = { for ((name, value) <- assocs) emitArgument(av, name.mangledString, value.asInstanceOf[Tree]) av.visitEnd() } private def emitArgument(av: AnnotationVisitor, - name: String, - arg: Tree): Unit = { + name: String, + arg: Tree)(using Context): Unit = { val narg = normalizeArgument(arg) // Transformation phases are not run on annotation trees, so we need to run // `constToLiteral` at this point. @@ -195,12 +218,12 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B case StringTag => assert(const.value != null, const) // TODO this invariant isn't documented in `case class Constant` av.visit(name, const.stringValue) // `stringValue` special-cases null, but that execution path isn't exercised for a const with StringTag - case ClazzTag => av.visit(name, ts.typeToTypeKind(TypeErasure.erasure(const.typeValue)).toASMType) + case ClazzTag => av.visit(name, bTypeLoader.bTypeFromType(TypeErasure.erasure(const.typeValue)).toASMType) } case Ident(nme.WILDCARD) => // An underscore argument indicates that we want to use the default value for this parameter, so do not emit anything case t: tpd.RefTree if t.symbol.owner.linkedClass.isAllOf(JavaEnum) => - val edesc = ts.typeDescriptor(t.tpe) // the class descriptor of the enumeration class. + val edesc = bTypeLoader.bTypeFromType(t.tpe).descriptor // the class descriptor of the enumeration class. val evalue = t.symbol.javaSimpleName // value the actual enumeration value. av.visitEnum(name, edesc, evalue) // Handle final val aliases to Java enum values. @@ -211,7 +234,7 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B case _ => false } => val enumRef = atPhase(erasurePhase)(t.symbol.info.finalResultType.asInstanceOf[TermRef]) - val edesc = ts.typeDescriptor(enumRef) + val edesc = bTypeLoader.bTypeFromType(enumRef).descriptor val evalue = enumRef.termSymbol.javaSimpleName av.visitEnum(name, edesc, evalue) case t: SeqLiteral => @@ -242,17 +265,17 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B // see http://www.scala-lang.org/sid/10 (Storage of pickled Scala signatures in class files) // also JVMS Sec. 4.7.16.1 The element_value structure and JVMS Sec. 4.4.7 The CONSTANT_Utf8_info Structure. if (sb.fitsInOneString) { - av.visit(name, BCodeAsmCommon.strEncode(sb)) + av.visit(name, BCodeUtils.strEncode(sb)) } else { val arrAnnotV: asm.AnnotationVisitor = av.visitArray(name) - for(arg <- BCodeAsmCommon.arrEncode(sb)) { arrAnnotV.visit(name, arg) } + for(arg <- BCodeUtils.arrEncode(sb)) { arrAnnotV.visit(name, arg) } arrAnnotV.visitEnd() } // for the lazy val in ScalaSigBytes to be GC'ed, the invoker of emitAnnotations() should hold the ScalaSigBytes in a method-local var that doesn't escape. */ case t @ Apply(constr, args) if t.tpe.classSymbol.is(JavaAnnotation) => val typ = t.tpe.classSymbol.denot.info val assocs = assocsFromApply(t) - val desc = ts.typeDescriptor(typ) // the class descriptor of the nested annotation class + val desc = bTypeLoader.bTypeFromType(typ).descriptor // the class descriptor of the nested annotation class val nestedVisitor = av.visitAnnotation(name, desc) emitAssocs(nestedVisitor, assocs) @@ -270,9 +293,9 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B case _ => arg } - private def isRuntimeVisible(annot: Annotation): Boolean = - if (toDenot(annot.tree.tpe.typeSymbol).hasAnnotation(AnnotationRetentionAttr)) - retentionPolicyOf(annot) == AnnotationRetentionRuntimeAttr + private def isRuntimeVisible(annot: Annotation)(using Context): Boolean = + if (toDenot(annot.tree.tpe.typeSymbol).hasAnnotation(annotationRetentionAttr)) + retentionPolicyOf(annot) == annotationRetentionRuntimeAttr else { // SI-8926: if the annotation class symbol doesn't have a @RetentionPolicy annotation, the // annotation is emitted with visibility `RUNTIME` @@ -280,11 +303,11 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B true } - private def retentionPolicyOf(annot: Annotation): Symbol = - annot.tree.tpe.typeSymbol.getAnnotation(AnnotationRetentionAttr). - flatMap(_.argument(0).map(_.tpe.termSymbol)).getOrElse(AnnotationRetentionClassAttr) + private def retentionPolicyOf(annot: Annotation)(using Context): Symbol = + annot.tree.tpe.typeSymbol.getAnnotation(annotationRetentionAttr). + flatMap(_.argument(0).map(_.tpe.termSymbol)).getOrElse(annotationRetentionClassAttr) - private def assocsFromApply(tree: Tree): List[(Name, Tree)] = { + private def assocsFromApply(tree: Tree)(using Context): List[(Name, Tree)] = { tree match { case Block(_, expr) => assocsFromApply(expr) case Apply(fun, args) => @@ -301,25 +324,24 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B trait BCJGenSigGen { - def getCurrentCUnit(): CompilationUnit - /** * Generates the generic signature for `sym` before erasure. * * @param sym The symbol for which to generate a signature. * @param owner The owner of `sym`. + * @param descriptor The descriptor of the symbol; the signature is unnecessary if they are equal. * @return The generic signature of `sym` before erasure, as specified in the Java Virtual * Machine Specification, §4.3.4, or `null` if `sym` doesn't need a generic signature. * @see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.4 */ - def getGenericSignature(sym: Symbol, owner: Symbol): String | Null = { + def getGenericSignature(sym: Symbol, owner: Symbol, descriptor: String | Null)(using Context): String | Null = { atPhase(erasurePhase) { // Finding the member's type is nontrivial because of erasure and how it interacts with other phases. def computeMemberType(): Type = { // Mixins are resolved _after_ erasure, so we cannot simply ask for "the information before erasure" for these, // since that information never existed. // Thus, we first check if the symbol was specifically marked as having generic information, - if sym.is(MixedIn) then mixinPhase.asInstanceOf[Mixin].mixinGenericInfos.get(sym) match + mixinPhase.asInstanceOf[Mixin].mixinGenericInfos.get(sym) match // and if so, we use it. case Some(genericInfo) => return genericInfo case _ => () @@ -337,15 +359,20 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B // there might be a getter created after erasure by the mixin phase, // and if so we must use the information that the mixin phase stored for it. + // However, we can't do this if the result is a primitive, since field generic signatures can only be reference types (JVMS §4.7.9.1) val mixinGetter = atPhase(mixinPhase.next) { sym.getter } if mixinGetter.exists then mixinPhase.asInstanceOf[Mixin].mixinGenericInfos.get(mixinGetter) match - case Some(ExprType(genericInfo)) => return genericInfo // since we're looking for the getter, we get an ExprType + case Some(ExprType(genericInfo)) if !genericInfo.isPrimitiveValueType => return genericInfo // since we're looking for the getter, we get an ExprType case _ => () owner.denot.thisType.memberInfo(sym) } - getGenericSignatureHelper(sym, owner, computeMemberType()).orNull + if ctx.base.settings.XnoGenericSig.value then null + else + val genSig = getGenericSignatureHelper(sym, owner, computeMemberType()) + if genSig == null || (descriptor != null && descriptor.contentEquals(genSig)) then null + else genSig.toString } } @@ -357,10 +384,10 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B * * must-single-thread */ - private def addForwarder(jclass: asm.ClassVisitor, module: Symbol, m: Symbol, isSynthetic: Boolean): Unit = { - val moduleName = ts.internalName(module) + private def addForwarder(jclass: asm.ClassVisitor, module: Symbol, m: Symbol, isSynthetic: Boolean)(using Context): Unit = { + val moduleName = bTypeLoader.classBTypeFromSymbol(module).internalName val methodInfo = module.thisType.memberInfo(m) - val paramJavaTypes: List[BType] = methodInfo.firstParamTypes.map(ts.toTypeKind) + val paramJavaTypes: List[BType] = methodInfo.firstParamTypes.map(bTypeLoader.bTypeFromType) // val paramNames = 0 until paramJavaTypes.length.map("x_" + _) /* Forwarders must not be marked final, @@ -375,12 +402,12 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B ) // TODO needed? for(ann <- m.annotations) { ann.symbol.initialize } - val jgensig = getStaticForwarderGenericSignature(m, module) + val jReturnType = bTypeLoader.bTypeFromType(methodInfo.resultType) + val mdesc = MethodBType(paramJavaTypes, jReturnType).descriptor + val jgensig = getStaticForwarderGenericSignature(m, module, mdesc) val (throws, others) = m.annotations.partition(_.symbol eq defn.ThrowsAnnot) val thrownExceptions: List[String] = getExceptions(throws) - val jReturnType = ts.toTypeKind(methodInfo.resultType) - val mdesc = MethodBType(paramJavaTypes, jReturnType).descriptor val mirrorMethodName = m.javaSimpleName val lengthOk = if jgensig ne null then BCodeUtils.checkConstantStringLength(jgensig) else BCodeUtils.checkConstantStringLength(mirrorMethodName, mdesc) @@ -405,7 +432,7 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B mirrorMethod.visitCode() - mirrorMethod.visitFieldInsn(asm.Opcodes.GETSTATIC, moduleName, str.MODULE_INSTANCE_FIELD, ts.symDescriptor(module)) + mirrorMethod.visitFieldInsn(asm.Opcodes.GETSTATIC, moduleName, str.MODULE_INSTANCE_FIELD, bTypeLoader.classBTypeFromSymbol(module).descriptor) var index = 0 for(jparamType <- paramJavaTypes) { @@ -414,7 +441,7 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B index += jparamType.size } - mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, ts.asmMethodType(m).descriptor, false) + mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, bTypeLoader.methodBTypeFromSymbol(m).descriptor, false) mirrorMethod.visitInsn(jReturnType.typedOpcode(asm.Opcodes.IRETURN)) mirrorMethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments @@ -429,7 +456,7 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B * * must-single-thread */ - def addForwarders(jclass: asm.ClassVisitor, jclassName: String, moduleClass: Symbol): Unit = { + def addForwarders(jclass: asm.ClassVisitor, jclassName: String, moduleClass: Symbol)(using Context): Unit = { assert(moduleClass.is(ModuleClass), moduleClass) report.debuglog(s"Dumping mirror class for object: $moduleClass") @@ -464,7 +491,7 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B /** The members of this type that have all of `required` flags but none of `excluded` flags set. * The members are sorted by name and signature to guarantee a stable ordering. */ - private def sortedMembersBasedOnFlags(tp: Type, required: Flag, excluded: FlagSet): List[Symbol] = { + private def sortedMembersBasedOnFlags(tp: Type, required: Flag, excluded: FlagSet)(using Context): List[Symbol] = { // The output of `memberNames` is a Set, sort it to guarantee a stable ordering. val names = tp.memberNames(takeAllFilter).toSeq.sorted val buffer = mutable.ListBuffer[Symbol]() @@ -485,9 +512,9 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B * * must-single-thread */ - def getExceptions(excs: List[Annotation]): List[String] = { + def getExceptions(excs: List[Annotation])(using Context): List[String] = { for (case ThrownException(exc) <- excs.distinct) - yield ts.internalName(TypeErasure.erasure(exc).classSymbol) + yield bTypeLoader.classBTypeFromSymbol(TypeErasure.erasure(exc).classSymbol).internalName } } // end of trait BCForwardersGen @@ -524,9 +551,6 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B /* builder of mirror classes */ class JMirrorBuilder extends JCommonBuilder { - private var cunit: CompilationUnit = uninitialized - def getCurrentCUnit(): CompilationUnit = cunit - /* Generate a mirror class for a top-level module. A mirror class is a class * containing only static methods that forward to the corresponding method * on the MODULE instance of the given Scala object. It will only be @@ -535,29 +559,27 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B * * must-single-thread */ - def genMirrorClass(moduleClass: Symbol, cunit: CompilationUnit): asm.tree.ClassNode = { + def genMirrorClass(moduleClass: Symbol)(using Context): asm.tree.ClassNode = { assert(moduleClass.is(ModuleClass)) assert(moduleClass.companionClass == NoSymbol, moduleClass) - this.cunit = cunit - val bType = ts.mirrorClassBTypeFromSymbol(moduleClass) - val moduleName = ts.internalName(moduleClass) // + "$" + val bType = bTypeLoader.mirrorClassBTypeFromSymbol(moduleClass) + val moduleName = bTypeLoader.classBTypeFromSymbol(moduleClass).internalName val mirrorName = bType.internalName val mirrorClass = new asm.tree.ClassNode if !BCodeUtils.checkConstantStringLength(mirrorName) then report.error("Mirror class name is too long for the JVM", moduleClass.srcPos) return mirrorClass // not filled, but we cannot create it, and we just reported an error mirrorClass.visit( - backendUtils.classfileVersion, + classfileVersion, bType.info.flags, mirrorName, null /* no java-generic-signature */, - ts.ObjectRef.internalName, + bTypes.ObjectRef.internalName, EMPTY_STRING_ARRAY ) if (BackendUtils.emitSource) { - mirrorClass.visitSource("" + cunit.source.file.name, - null /* SourceDebugExtension */) + mirrorClass.visitSource("" + ctx.compilationUnit.source.file.name, null /* SourceDebugExtension */) } val ssa = None // getAnnotPickle(mirrorName, if (moduleClass.is(Module)) moduleClass.companionClass else moduleClass.companionModule) @@ -574,87 +596,18 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B } // end of class JMirrorBuilder - trait JAndroidBuilder { - /* From the reference documentation of the Android SDK: - * The `Parcelable` interface identifies classes whose instances can be written to and restored from a `Parcel`. - * Classes implementing the `Parcelable` interface must also have a static field called `CREATOR`, - * which is an object implementing the `Parcelable.Creator` interface. - */ - val androidFieldName = "CREATOR".toTermName - - lazy val AndroidParcelableInterface : Symbol = NoSymbol // getClassIfDefined("android.os.Parcelable") - lazy val AndroidCreatorClass : Symbol = NoSymbol // getClassIfDefined("android.os.Parcelable$Creator") - - /* - * must-single-thread - */ - def isAndroidParcelableClass(sym: Symbol) = - (AndroidParcelableInterface != NoSymbol) && - (sym.info.parents.map(_.typeSymbol) contains AndroidParcelableInterface) - - /* - * must-single-thread - */ - def legacyAddCreatorCode(clinit: asm.MethodVisitor, cnode: asm.tree.ClassNode, thisName: String): Unit = { - val androidCreatorType = ts.getClassBType(AndroidCreatorClass) - val tdesc_creator = androidCreatorType.descriptor - - cnode.visitField( - asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL, - "CREATOR", - tdesc_creator, - null, // no java-generic-signature - null // no initial value - ).visitEnd() - - val moduleName = thisName + "$" - - // GETSTATIC `moduleName`.MODULE$ : `moduleName`; - clinit.visitFieldInsn( - asm.Opcodes.GETSTATIC, - moduleName, - str.MODULE_INSTANCE_FIELD, - "L" + moduleName + ";" - ) - - // INVOKEVIRTUAL `moduleName`.CREATOR() : android.os.Parcelable$Creator; - val bt = MethodBType(Nil, androidCreatorType) - clinit.visitMethodInsn( - asm.Opcodes.INVOKEVIRTUAL, - moduleName, - "CREATOR", - bt.descriptor, - false - ) - - // PUTSTATIC `thisName`.CREATOR; - clinit.visitFieldInsn( - asm.Opcodes.PUTSTATIC, - thisName, - "CREATOR", - tdesc_creator - ) - } - - } // end of trait JAndroidBuilder - - private def getGenericSignatureHelper(sym: Symbol, owner: Symbol, memberTpe: Type)(using Context): Option[String] = { - if (needsGenericSignature(sym)) { - val erasedTypeSym = TypeErasure.fullErasure(sym.denot.info).typeSymbol - if (erasedTypeSym.isPrimitiveValueClass) { - // Suppress signatures for symbols whose types erase in the end to primitive - // value types. This is needed to fix #7416. - None - } else { - val jsOpt = GenericSignatures.javaSig(sym, memberTpe) - if (ctx.settings.XverifySignatures.value) { - jsOpt.foreach(verifySignature(sym, _)) - } - - jsOpt - } + private def getGenericSignatureHelper(sym: Symbol, owner: Symbol, memberTpe: Type)(using Context): java.lang.StringBuilder | Null = { + val erasedTypeSym = TypeErasure.fullErasure(sym.denot.info).typeSymbol + if (erasedTypeSym.isPrimitiveValueClass) { + // Suppress signatures for symbols whose types erase in the end to primitive + // value types. This is needed to fix #7416. + null } else { - None + val jsOpt = GenericSignatures.javaSig(sym, memberTpe) + if (jsOpt != null && ctx.settings.XverifySignatures.value) { + verifySignature(sym, jsOpt.toString) + } + jsOpt } } @@ -662,15 +615,13 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B import scala.tools.asm.util.CheckClassAdapter def wrap(body: => Unit): Unit = { try body - catch { - case ex: Throwable => - report.error( - em"""|compiler bug: created invalid generic signature for $sym in ${sym.denot.owner.showFullName} - |signature: $sig - |if this is reproducible, please report bug at https://github.com/scala/scala3/issues - """, sym.sourcePos) - throw ex - } + catch case ex: Exception => + report.error( + em"""|compiler bug: created invalid generic signature for $sym in ${sym.denot.owner.showFullName} + |signature: $sig + |if this is reproducible, please report bug at https://github.com/scala/scala3/issues + """, sym.sourcePos) + throw ex } wrap { @@ -686,39 +637,23 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B } } - // @M don't generate java generics sigs for (members of) implementation - // classes, as they are monomorphic (TODO: ok?) - private final def needsGenericSignature(sym: Symbol): Boolean = !( - // pp: this condition used to include sym.hasexpandedname, but this leads - // to the total loss of generic information if a private member is - // accessed from a closure: both the field and the accessor were generated - // without it. This is particularly bad because the availability of - // generic information could disappear as a consequence of a seemingly - // unrelated change. - ctx.base.settings.XnoGenericSig.value - || sym.is(Artifact) - || sym.isAllOf(LiftedMethod) - || sym.is(Bridge) - ) - - private def getStaticForwarderGenericSignature(sym: Symbol, moduleClass: Symbol): String = { + private def getStaticForwarderGenericSignature(sym: Symbol, moduleClass: Symbol, descriptor: String | Null)(using Context): String | Null = { // scala/bug#3452 Static forwarder generation uses the same erased signature as the method if forwards to. // By rights, it should use the signature as-seen-from the module class, and add suitable // primitive and value-class boxing/unboxing. // But for now, just like we did in mixin, we just avoid writing a wrong generic signature // (one that doesn't erase to the actual signature). See run/t3452b for a test case. - val memberTpe = atPhase(erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) } - val erasedMemberType = ElimErasedValueType.elimEVT(TypeErasure.transformInfo(sym, memberTpe)) - if (erasedMemberType =:= sym.denot.info) - getGenericSignatureHelper(sym, moduleClass, memberTpe).orNull + if !ctx.base.settings.XnoGenericSig.value then + val memberTpe = atPhase(erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) } + val erasedMemberType = ElimErasedValueType.elimEVT(TypeErasure.transformInfo(sym, memberTpe)) + if (erasedMemberType =:= sym.denot.info) + val gensig = getGenericSignatureHelper(sym, moduleClass, memberTpe) + if gensig == null || descriptor.contentEquals(gensig) then null + else gensig.toString + else null else null } - - def abort(msg: String): Nothing = { - report.error(msg) - throw new RuntimeException(msg) - } } object BCodeHelpers { diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala b/compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala index 2699b013fb5c..dfe7da286239 100644 --- a/compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala +++ b/compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala @@ -3,13 +3,11 @@ package backend package jvm import scala.language.unsafeNulls - import scala.tools.asm import scala.annotation.switch import scala.tools.asm.tree.MethodInsnNode -import dotty.tools.dotc.core.Contexts.Context -import dotty.tools.dotc.report import dotty.tools.dotc.ast.Positioned +import dotty.tools.dotc.core.Contexts.Context /* * A high-level facade to the ASM API for bytecode generation. @@ -18,9 +16,9 @@ import dotty.tools.dotc.ast.Positioned * @version 1.0 * */ -trait BCodeIdiomatic(using Context) { +trait BCodeIdiomatic { - def recordCallsitePosition(m: MethodInsnNode, pos: Positioned | Null): Unit + def recordCallsitePosition(m: MethodInsnNode, pos: Positioned | Null)(using Context): Unit val CLASS_CONSTRUCTOR_NAME = "" val INSTANCE_CONSTRUCTOR_NAME = "" @@ -89,7 +87,7 @@ trait BCodeIdiomatic(using Context) { def jmethod: asm.tree.MethodNode - import asm.Opcodes; + import asm.Opcodes final def emit(opc: Int): Unit = { jmethod.visitInsn(opc) } @@ -104,7 +102,7 @@ trait BCodeIdiomatic(using Context) { jmethod.visitLdcInsn(java.lang.Long.valueOf(-1)) jmethod.visitInsn(Opcodes.LXOR) } else { - abort(s"Impossible to negate an $kind") + throw new AssertionError(s"Impossible to negate an $kind") } end genPrimitiveNot @@ -175,7 +173,7 @@ trait BCodeIdiomatic(using Context) { recipe: String, argTypes: Seq[asm.Type], constants: Seq[String], - ts: CoreBTypes + ts: WellKnownBTypes ): Unit = { jmethod.visitInvokeDynamicInsn( "makeConcatWithConstants", @@ -307,7 +305,6 @@ trait BCodeIdiomatic(using Context) { case _ => assert(elem.isNonVoidPrimitiveType) val rand = { - // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match" elem match { case BOOL => Opcodes.T_BOOLEAN case BYTE => Opcodes.T_BYTE @@ -340,23 +337,23 @@ trait BCodeIdiomatic(using Context) { final def rem(tk: BType): Unit = { emitPrimitive(JCodeMethodN.remOpcodes, tk) } // can-multi-thread // can-multi-thread - final def invokespecial(owner: String, name: String, desc: String, itf: Boolean, pos: Positioned | Null): Unit = { + final def invokespecial(owner: String, name: String, desc: String, itf: Boolean, pos: Positioned | Null)(using Context): Unit = { emitInvoke(Opcodes.INVOKESPECIAL, owner, name, desc, itf, pos) } // can-multi-thread - final def invokestatic(owner: String, name: String, desc: String, itf: Boolean, pos: Positioned | Null): Unit = { + final def invokestatic(owner: String, name: String, desc: String, itf: Boolean, pos: Positioned | Null)(using Context): Unit = { emitInvoke(Opcodes.INVOKESTATIC, owner, name, desc, itf, pos) } // can-multi-thread - final def invokeinterface(owner: String, name: String, desc: String, pos: Positioned | Null): Unit = { + final def invokeinterface(owner: String, name: String, desc: String, pos: Positioned | Null)(using Context): Unit = { emitInvoke(Opcodes.INVOKEINTERFACE, owner, name, desc, itf = true, pos) } // can-multi-thread - final def invokevirtual(owner: String, name: String, desc: String, pos: Positioned | Null): Unit = { + final def invokevirtual(owner: String, name: String, desc: String, pos: Positioned | Null)(using Context): Unit = { emitInvoke(Opcodes.INVOKEVIRTUAL, owner, name, desc, itf = false, pos) } - def emitInvoke(opcode: Int, owner: String, name: String, desc: String, itf: Boolean, pos: Positioned | Null): Unit = { + def emitInvoke(opcode: Int, owner: String, name: String, desc: String, itf: Boolean, pos: Positioned | Null)(using Context): Unit = { val node = new MethodInsnNode(opcode, owner, name, desc, itf) jmethod.instructions.add(node) recordCallsitePosition(node, pos) @@ -422,7 +419,7 @@ trait BCodeIdiomatic(using Context) { i = 1 while (i < keys.length) { if (keys(i-1) == keys(i)) { - abort("duplicate keys in SWITCH, can't pick arbitrarily one of them to evict, see SI-6011.") + throw new AssertionError("duplicate keys in SWITCH, can't pick arbitrarily one of them to evict, see SI-6011.") } i += 1 } @@ -541,11 +538,6 @@ trait BCodeIdiomatic(using Context) { jmethod.visitTypeInsn(Opcodes.CHECKCAST, tk.classOrArrayType) } - def abort(msg: String): Nothing = { - report.error(msg) - throw new RuntimeException(msg) - } - } // end of class JCodeMethodN /* Constant-valued val-members of JCodeMethodN at the companion object, so as to avoid re-initializing them multiple times. */ diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala index fb16b9d07253..b5dc3ba140c7 100644 --- a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala +++ b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala @@ -8,7 +8,6 @@ import scala.collection.{immutable, mutable} import scala.tools.asm import dotty.tools.dotc.ast.tpd import dotty.tools.dotc.ast.TreeTypeMap -import dotty.tools.dotc.CompilationUnit import dotty.tools.dotc.ast.Trees.SyntheticUnit import dotty.tools.dotc.core.Decorators.* import dotty.tools.dotc.core.Flags.* @@ -30,9 +29,7 @@ import tpd.* * @version 1.0 * */ -trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { - - lazy val NativeAttr: Symbol = requiredClass[scala.native] +trait BCodeSkelBuilder extends BCodeHelpers { final class BTypesStack: // Anecdotally, growing past 16 to 32 is common; growing past 32 is rare @@ -127,10 +124,9 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { * - `genSynchronized() * - `jumpDest` , `cleanups` , `labelDefsAtOrUnder` */ - abstract class PlainSkelBuilder(cunit: CompilationUnit) + abstract class PlainSkelBuilder extends BCClassGen with BCAnnotGen - with JAndroidBuilder with BCForwardersGen with BCPickles with BCJGenSigGen { @@ -143,7 +139,6 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { var thisName: String = null // the internal name of the class being emitted var claszSymbol: Symbol = null - var isCZParcelable = false var isCZStaticModule = false // keep track of interfaces that are used in super calls, as they need to be directly inherited even if they are also indirectly inherited @@ -151,30 +146,27 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { /* ---------------- idiomatic way to ask questions to typer ---------------- */ - def paramTKs(app: Apply, take: Int = -1): List[BType] = app match { + def paramTKs(app: Apply, take: Int = -1)(using Context): List[BType] = app match { case Apply(fun, _) => val funSym = fun.symbol - funSym.info.firstParamTypes.map(ts.toTypeKind) // this tracks mentioned inner classes (in innerClassBufferASM) + funSym.info.firstParamTypes.map(bTypeLoader.bTypeFromType) // this tracks mentioned inner classes (in innerClassBufferASM) } - def symInfoTK(sym: Symbol): BType = { - ts.toTypeKind(sym.info) // this tracks mentioned inner classes (in innerClassBufferASM) + def symInfoTK(sym: Symbol)(using Context): BType = { + bTypeLoader.bTypeFromType(sym.info) // this tracks mentioned inner classes (in innerClassBufferASM) } - def tpeTK(tree: Tree): BType = { ts.toTypeKind(tree.tpe) } - - override def getCurrentCUnit(): CompilationUnit = { cunit } + def tpeTK(tree: Tree)(using Context): BType = { bTypeLoader.bTypeFromType(tree.tpe) } /* ---------------- helper utils for generating classes and fields ---------------- */ - def genPlainClass(cd0: TypeDef) = (cd0: @unchecked) match { + def genPlainClass(cd0: TypeDef)(using Context) = (cd0: @unchecked) match { case TypeDef(_, impl: Template) => assert(cnode == null, "GenBCode detected nested methods.") claszSymbol = cd0.symbol - isCZParcelable = isAndroidParcelableClass(claszSymbol) isCZStaticModule = claszSymbol.isStaticModuleClass - thisName = ts.internalName(claszSymbol) + thisName = bTypeLoader.classBTypeFromSymbol(claszSymbol).internalName cnode = new ClassNode1() @@ -232,7 +224,11 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { claszSymbol.typeRef, privateWithin = NoSymbol, coord = claszSymbol.coord - ).entered + ) + // While we could use `.entered` on `moduleField` to have it handled like any other field later, + // this would require some compensating in the tree checker as we're adding a "magical" field + // that isn't defined in the AST. So instead, we emit it separately: + addClassField(moduleField) val thisMap = new TreeMap { override def transform(tree: Tree)(using Context) = { @@ -268,7 +264,6 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { } else cd0 val hasStaticCtor = isCZStaticModule || cd.symbol.info.decls.exists(_.name.isStaticConstructorName) - if (!hasStaticCtor && isCZParcelable) fabricateStaticInitAndroid() val optSerial: Option[Long] = claszSymbol.getAnnotation(defn.SerialVersionUIDAnnot).flatMap { annot => @@ -299,17 +294,18 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { /* * must-single-thread */ - private def initJClass(jclass: asm.ClassVisitor): Unit = { + private def initJClass(jclass: asm.ClassVisitor)(using Context): Unit = { val ps = claszSymbol.info.parents - val superClass: String = if (ps.isEmpty) ts.ObjectRef.internalName else ts.internalName(ps.head.typeSymbol) + val superClass: String = if ps.isEmpty then bTypes.ObjectRef.internalName + else bTypeLoader.classBTypeFromSymbol(ps.head.typeSymbol).internalName // We need to emit not only directly implemented interfaces, but also any indirectly implemented ones that are the target of super calls. // (This somewhat convoluted sequence of operations exists to maintain the exact order of inheritance from a previous version. // It could be cleaned up given some work to make sure changing the order isn't a problem.) val directInterfaces = claszSymbol.directlyInheritedTraits - val directInterfacesBTypes = directInterfaces.map(ts.classBTypeFromSymbol) - val baseClassesBTypes = directInterfaces.iterator.flatMap(_.asClass.baseClasses.drop(1)).map(ts.classBTypeFromSymbol).toSet + val directInterfacesBTypes = directInterfaces.map(bTypeLoader.classBTypeFromSymbol) + val baseClassesBTypes = directInterfaces.iterator.flatMap(_.asClass.baseClasses.drop(1)).map(bTypeLoader.classBTypeFromSymbol).toSet val additionalBTypes = superCallTargets.filter(!directInterfacesBTypes.contains(_)) val interfaces = directInterfacesBTypes.filter(t => !baseClassesBTypes(t) || superCallTargets(t)) ++ additionalBTypes @@ -336,22 +332,22 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { val flags = BCodeUtils.javaFlags(claszSymbol) - val thisSignature = getGenericSignature(claszSymbol, claszSymbol.owner) + val thisSignature = getGenericSignature(claszSymbol, claszSymbol.owner, null) val lengthOk = if thisSignature ne null then BCodeUtils.checkConstantStringLength(thisSignature) else BCodeUtils.checkConstantStringLength(thisName) if !lengthOk then report.error("Class name is too long for the JVM", claszSymbol.srcPos) return - cnode.visit(backendUtils.classfileVersion, flags, + cnode.visit(classfileVersion, flags, thisName, thisSignature, superClass, interfaceNames.toArray) if (BackendUtils.emitSource) { - cnode.visitSource(cunit.source.file.name, null /* SourceDebugExtension */) + cnode.visitSource(ctx.compilationUnit.source.file.name, null /* SourceDebugExtension */) } - BCodeAsmCommon.enclosingMethodAttribute(claszSymbol, ts.internalName, ts.asmMethodType(_).descriptor) match { - case Some(BCodeAsmCommon.EnclosingMethodEntry(className, methodName, methodDescriptor)) => + BCodeUtils.enclosingMethodAttribute(claszSymbol, bTypeLoader.classBTypeFromSymbol(_).internalName, bTypeLoader.methodBTypeFromSymbol(_).descriptor) match { + case Some(BCodeUtils.EnclosingMethodEntry(className, methodName, methodDescriptor)) => cnode.visitOuterClass(className, methodName, methodDescriptor) case _ => () } @@ -360,7 +356,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { cnode.visitAttribute(if (ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign) emitAnnotations(cnode, claszSymbol.annotations ++ ssa) - if (!isCZStaticModule && !isCZParcelable) { + if (!isCZStaticModule) { val skipStaticForwarders = (claszSymbol.is(Module) || ctx.settings.XnoForwarders.value) if (!skipStaticForwarders) { val lmoc = claszSymbol.companionModule @@ -381,40 +377,35 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { } // end of method initJClass - /* - * must-single-thread - */ - private def fabricateStaticInitAndroid(): Unit = { - - val clinit: asm.MethodVisitor = cnode.visitMethod( - asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC, // TODO confirm whether we really don't want ACC_SYNTHETIC nor ACC_DEPRECATED - CLASS_CONSTRUCTOR_NAME, - "()V", - null, // no java-generic-signature - null // no throwable exceptions - ) - clinit.visitCode() - - legacyAddCreatorCode(clinit, cnode, thisName) - - clinit.visitInsn(asm.Opcodes.RETURN) - clinit.visitMaxs(0, 0) // just to follow protocol, dummy arguments - clinit.visitEnd() - } - - private lazy val TransientAttr = requiredClass[scala.transient] - private lazy val VolatileAttr = requiredClass[scala.volatile] - - private def javaFieldFlags(sym: Symbol) = { + private def javaFieldFlags(sym: Symbol)(using Context) = { import asm.Opcodes.* import GenBCodeOps.addFlagIf BCodeUtils.javaFlags(sym) - .addFlagIf(sym.hasAnnotation(TransientAttr), ACC_TRANSIENT) - .addFlagIf(sym.hasAnnotation(VolatileAttr), ACC_VOLATILE) + .addFlagIf(sym.hasAnnotation(defn.TransientAnnot), ACC_TRANSIENT) + .addFlagIf(sym.hasAnnotation(defn.VolatileAnnot), ACC_VOLATILE) .addFlagIf(!sym.is(Mutable), ACC_FINAL) } - def addClassFields(): Unit = { + def addClassField(f: Symbol)(using Context): Unit = { + val descriptor = symInfoTK(f).descriptor + val javagensig = getGenericSignature(f, claszSymbol, descriptor) + val flags = javaFieldFlags(f) + + assert(!f.isStaticMember || !claszSymbol.is(Trait) || !f.is(Mutable), + s"interface $claszSymbol cannot have non-final static field $f") + + val jfield = new asm.tree.FieldNode( + flags, + f.javaSimpleName, + descriptor, + javagensig, + null // no initial value + ) + cnode.fields.add(jfield) + emitAnnotations(jfield, f.annotations) + } + + def addClassFields()(using Context): Unit = /* Non-method term members are fields, except for module members. Module * members can only happen on .NET (no flatten) for inner traits. There, * a module symbol is generated (transformInfo in mixin) which is used @@ -422,25 +413,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { * backend emits them as static). * No code is needed for this module symbol. */ - for (f <- claszSymbol.info.decls.filter(p => p.isTerm && !p.is(Method))) { - val javagensig = getGenericSignature(f, claszSymbol) - val flags = javaFieldFlags(f) - - assert(!f.isStaticMember || !claszSymbol.is(Trait) || !f.is(Mutable), - s"interface $claszSymbol cannot have non-final static field $f") - - val jfield = new asm.tree.FieldNode( - flags, - f.javaSimpleName, - symInfoTK(f).descriptor, - javagensig, - null // no initial value - ) - cnode.fields.add(jfield) - emitAnnotations(jfield, f.annotations) - } - - } // end of method addClassFields() + claszSymbol.info.decls.filter(p => p.isTerm && !p.is(Method)).foreach(addClassField) // current method var mnode: MethodNode1 = null @@ -468,16 +441,16 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { * corresponding expected type. The `LoadDestination` can never be `FallThrough` here. */ var jumpDest: immutable.Map[ /* Labeled */ Symbol, (BType, LoadDestination) ] = null - def registerJumpDest(labelSym: Symbol, expectedType: BType, dest: LoadDestination): Unit = { + def registerJumpDest(labelSym: Symbol, expectedType: BType, dest: LoadDestination)(using Context): Unit = { assert(labelSym.is(Label), s"trying to register a jump-dest for a non-label symbol, at: ${labelSym.span}") assert(dest != LoadDestination.FallThrough, s"trying to register a FallThrough dest for label, at: ${labelSym.span}") assert(!jumpDest.contains(labelSym), s"trying to register a second jump-dest for label, at: ${labelSym.span}") jumpDest += (labelSym -> (expectedType, dest)) } - def findJumpDest(labelSym: Symbol): (BType, LoadDestination) = { + def findJumpDest(labelSym: Symbol)(using Context): (BType, LoadDestination) = { assert(labelSym.is(Label), s"trying to map a non-label symbol to an asm.Label, at: ${labelSym.span}") jumpDest.getOrElse(labelSym, { - abort(s"unknown label symbol, for label at: ${labelSym.span}") + throw new AssertionError(s"unknown label symbol, for label at: ${labelSym.span}") }) } @@ -554,31 +527,31 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { /* Make a fresh local variable, ensuring a unique name. * The invoker must make sure inner classes are tracked for the sym's tpe. */ - def makeLocal(tk: BType, name: String, tpe: Type, pos: Span): Symbol = { + def makeLocal(tk: BType, name: String, tpe: Type, pos: Span)(using Context): Symbol = { val locSym = newSymbol(methSymbol, name.toTermName, Synthetic, tpe, NoSymbol, pos) makeLocal(locSym, tk) locSym } - def makeLocal(locSym: Symbol): Local = { + def makeLocal(locSym: Symbol)(using Context): Local = { makeLocal(locSym, symInfoTK(locSym)) } - def getOrMakeLocal(locSym: Symbol): Local = { + def getOrMakeLocal(locSym: Symbol)(using Context): Local = { // `getOrElse` below has the same effect as `getOrElseUpdate` because `makeLocal()` adds an entry to the `locals` map. slots.getOrElse(locSym, makeLocal(locSym)) } - def reuseLocal(sym: Symbol, loc: Local): Unit = + def reuseLocal(sym: Symbol, loc: Local)(using Context): Unit = val existing = slots.put(sym, loc) if (existing.isDefined) report.error("attempt to create duplicate local var.", ctx.source.atSpan(sym.span)) - def reuseThisSlot(sym: Symbol): Unit = + def reuseThisSlot(sym: Symbol)(using Context): Unit = reuseLocal(sym, Local(symInfoTK(sym), sym.javaSimpleName, 0, sym.is(Synthetic))) - private def makeLocal(sym: Symbol, tk: BType): Local = { + private def makeLocal(sym: Symbol, tk: BType)(using Context): Local = { assert(nxtIdx != -1, "not a valid start index") val loc = Local(tk, sym.javaSimpleName, nxtIdx, sym.is(Synthetic)) val existing = slots.put(sym, loc) @@ -638,7 +611,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { case labnode: asm.tree.LabelNode => (labnode.getLabel == lbl); case _ => false } ) } - def lineNumber(tree: Tree): Unit = { + def lineNumber(tree: Tree)(using Context): Unit = { @tailrec def getNonLabelNode(a: asm.tree.AbstractInsnNode): asm.tree.AbstractInsnNode = a match { case a: asm.tree.LabelNode => getNonLabelNode(a.getPrevious) @@ -667,7 +640,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { } // on entering a method - def resetMethodBookkeeping(dd: DefDef) = { + def resetMethodBookkeeping(dd: DefDef)(using Context) = { val rhs = dd.rhs locals.reset(isStaticMethod = methSymbol.isStaticMember) jumpDest = immutable.Map.empty @@ -686,7 +659,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { /* ---------------- top-down traversal invoking ASM Tree API along the way ---------------- */ - def gen(tree: Tree): Unit = { + def gen(tree: Tree)(using Context): Unit = { tree match { case tpd.EmptyTree => () @@ -722,21 +695,21 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { genDefDef(dd) case tree: Template => - val body = - if (tree.constr.rhs.isEmpty) tree.body - else tree.constr :: tree.body - body.foreach(gen) + if !tree.constr.rhs.isEmpty then + gen(tree.constr) + tree.body.foreach(gen) - case _ => abort(s"Illegal tree in gen: $tree") + case _ => throw new AssertionError(s"Illegal tree in gen: $tree") } } /* * must-single-thread */ - private def initJMethod(flags: Int, params: List[Symbol]): Unit = { + private def initJMethod(flags: Int, params: List[Symbol])(using Context): Unit = { - val jgensig = getGenericSignature(methSymbol, claszSymbol) + val mdesc = bTypeLoader.methodBTypeFromSymbol(methSymbol).descriptor + val jgensig = getGenericSignature(methSymbol, claszSymbol, mdesc) val (excs, others) = methSymbol.annotations.partition(_.symbol eq defn.ThrowsAnnot) val thrownExceptions: List[String] = getExceptions(excs) @@ -744,7 +717,6 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { if (isMethSymStaticCtor) CLASS_CONSTRUCTOR_NAME else jMethodName - val mdesc = ts.asmMethodType(methSymbol).descriptor val lengthOk = if jgensig ne null then BCodeUtils.checkConstantStringLength(jgensig) else BCodeUtils.checkConstantStringLength(bytecodeName, mdesc) if !lengthOk then @@ -766,7 +738,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { } // end of method initJMethod - private def genTraitConstructorDefDef(dd: DefDef): Unit = + private def genTraitConstructorDefDef(dd: DefDef)(using Context): Unit = val statifiedDef = makeStatifiedDefDef(dd) genDefDef(statifiedDef) @@ -784,7 +756,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { * static def foo($self: Enclosing, x: Int): String = $self.toString() + x * }}} */ - private def makeStatifiedDefDef(dd: DefDef): DefDef = + private def makeStatifiedDefDef(dd: DefDef)(using Context): DefDef = val origSym = dd.symbol.asTerm val newSym = BackendUtils.makeStatifiedDefSymbol(origSym, origSym.name) tpd.DefDef(newSym, { paramRefss => @@ -805,7 +777,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { ).transform(dd.rhs) }) - private def genStaticForwarderForDefDef(dd: DefDef): Unit = + private def genStaticForwarderForDefDef(dd: DefDef)(using Context): Unit = val forwarderDef = makeStaticForwarder(dd) genDefDef(forwarderDef) @@ -820,7 +792,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { * in subtraits and subclasses, since the whole point of this forward is to * encode super calls. */ - private def makeStaticForwarder(dd: DefDef): DefDef = + private def makeStaticForwarder(dd: DefDef)(using Context): DefDef = // !!! // This logic is somewhat duplicated in the inline info definition, which is not very clean, // but remember to change it there if you make changes here @@ -834,7 +806,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { .withAttachment(BCodeHelpers.UseInvokeSpecial, ()) }) - def genDefDef(dd: DefDef): Unit = { + def genDefDef(dd: DefDef)(using Context): Unit = { val rhs = dd.rhs val vparamss = dd.termParamss // the only method whose implementation is not emitted: getClass() @@ -843,7 +815,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { methSymbol = dd.symbol jMethodName = methSymbol.javaSimpleName - returnType = ts.asmMethodType(methSymbol).returnType + returnType = bTypeLoader.methodBTypeFromSymbol(methSymbol).returnType isMethSymStaticCtor = methSymbol.name.isStaticConstructorName resetMethodBookkeeping(dd) @@ -866,7 +838,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { return } - val isNative = methSymbol.hasAnnotation(NativeAttr) + val isNative = methSymbol.hasAnnotation(defn.NativeAnnot) val isAbstractMethod = (methSymbol.is(Deferred) || (methSymbol.owner.is(Trait) && ((methSymbol.is(Deferred)) || methSymbol.isClassConstructor))) val flags = import GenBCodeOps.addFlagIf @@ -941,8 +913,6 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { } for (p <- params) { emitLocalVarScope(p.symbol, veryFirstProgramPoint, onePastLastProgramPoint, force = true) } } - - if (isMethSymStaticCtor) { appendToStaticCtor() } } // end of emitNormalMethodBody() lineNumber(rhs) @@ -957,58 +927,6 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { mnode = null } // end of method genDefDef() - /* - * must-single-thread - * - * TODO document, explain interplay with `fabricateStaticInitAndroid()` - */ - private def appendToStaticCtor(): Unit = { - - def insertBefore( - location: asm.tree.AbstractInsnNode, - i0: asm.tree.AbstractInsnNode, - i1: asm.tree.AbstractInsnNode): Unit = { - if (i0 != null) { - mnode.instructions.insertBefore(location, i0.clone(null)) - mnode.instructions.insertBefore(location, i1.clone(null)) - } - } - - // collect all return instructions - var rets: List[asm.tree.AbstractInsnNode] = Nil - mnode foreachInsn { i => if (i.getOpcode() == asm.Opcodes.RETURN) { rets ::= i } } - if (rets.isEmpty) { return } - - var insnParcA: asm.tree.AbstractInsnNode = null - var insnParcB: asm.tree.AbstractInsnNode = null - // android creator code - if (isCZParcelable) { - // add a static field ("CREATOR") to this class to cache android.os.Parcelable$Creator - val andrFieldDescr = ts.classBTypeFromSymbol(AndroidCreatorClass).descriptor - cnode.visitField( - asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL, - "CREATOR", - andrFieldDescr, - null, - null - ) - // INVOKESTATIC CREATOR(): android.os.Parcelable$Creator; -- TODO where does this Android method come from? - val callee = claszSymbol.companionModule.info.member(androidFieldName).symbol - val jowner = ts.internalName(callee.owner) - val jname = callee.javaSimpleName - val jtype = ts.asmMethodType(callee).descriptor - insnParcA = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESTATIC, jowner, jname, jtype, false) - // PUTSTATIC `thisName`.CREATOR; - insnParcB = new asm.tree.FieldInsnNode(asm.Opcodes.PUTSTATIC, thisName, "CREATOR", andrFieldDescr) - } - - // insert a few instructions for initialization before each return instruction - for(r <- rets) { - insertBefore(r, insnParcA, insnParcB) - } - - } - def emitLocalVarScope(sym: Symbol, start: asm.Label, end: asm.Label, force: Boolean = false): Unit = { val Local(tk, name, idx, isSynth) = locals(sym) if (force || !isSynth) { @@ -1016,7 +934,7 @@ trait BCodeSkelBuilder(using ctx: Context) extends BCodeHelpers { } } - def genLoadTo(tree: Tree, expectedType: BType, dest: LoadDestination): Unit + def genLoadTo(tree: Tree, expectedType: BType, dest: LoadDestination)(using Context): Unit } // end of class PlainSkelBuilder diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeSyncAndTry.scala b/compiler/src/dotty/tools/backend/jvm/BCodeSyncAndTry.scala index dd783a4cb7fd..1df91692ee12 100644 --- a/compiler/src/dotty/tools/backend/jvm/BCodeSyncAndTry.scala +++ b/compiler/src/dotty/tools/backend/jvm/BCodeSyncAndTry.scala @@ -5,7 +5,6 @@ package jvm import scala.language.unsafeNulls import scala.collection.immutable import scala.tools.asm -import dotty.tools.dotc.CompilationUnit import dotty.tools.dotc.core.StdNames.nme import dotty.tools.dotc.core.Symbols.* import dotty.tools.dotc.ast.tpd @@ -18,15 +17,15 @@ import tpd.* * @version 1.0 * */ -trait BCodeSyncAndTry(using ctx: Context) extends BCodeBodyBuilder { +trait BCodeSyncAndTry extends BCodeBodyBuilder { /* * Functionality to lower `synchronized` and `try` expressions. */ - class SyncAndTryBuilder(cunit: CompilationUnit) extends PlainBodyBuilder(cunit) { + class SyncAndTryBuilder extends PlainBodyBuilder { - def genSynchronized(tree: Apply, expectedType: BType): BType = (tree: @unchecked) match { + def genSynchronized(tree: Apply, expectedType: BType)(using Context): BType = (tree: @unchecked) match { case Apply(TypeApply(fun, _), args) => - val monitor = locals.makeLocal(ts.ObjectRef, "monitor", defn.ObjectType, tree.span) + val monitor = locals.makeLocal(bTypes.ObjectRef, "monitor", defn.ObjectType, tree.span) val monCleanup = new asm.Label // if the synchronized block returns a result, store it in a local variable. @@ -36,7 +35,7 @@ trait BCodeSyncAndTry(using ctx: Context) extends BCodeBodyBuilder { /* ------ (1) pushing and entering the monitor, also keeping a reference to it in a local var. ------ */ genLoadQualifier(fun) - bc.dup(ts.ObjectRef) + bc.dup(bTypes.ObjectRef) locals.store(monitor) emit(asm.Opcodes.MONITORENTER) @@ -178,7 +177,7 @@ trait BCodeSyncAndTry(using ctx: Context) extends BCodeBodyBuilder { * - "exception-handler-version-of-finally-block" respectively. * */ - def genLoadTry(tree: Try): BType = tree match { + def genLoadTry(tree: Try)(using Context): BType = tree match { case Try(block, catches, finalizer) => val kind = tpeTK(tree) @@ -186,7 +185,7 @@ trait BCodeSyncAndTry(using ctx: Context) extends BCodeBodyBuilder { for (CaseDef(pat, _, caseBody) <- catches) yield { pat match { case Typed(Ident(nme.WILDCARD), tpt) => NamelessEH(tpeTK(tpt).asClassBType, caseBody) - case Ident(nme.WILDCARD) => NamelessEH(ts.jlThrowableRef, caseBody) + case Ident(nme.WILDCARD) => NamelessEH(bTypes.jlThrowableRef, caseBody) case Bind(_, _) => BoundEH (pat.symbol, caseBody) } } @@ -343,7 +342,7 @@ trait BCodeSyncAndTry(using ctx: Context) extends BCodeBodyBuilder { nopIfNeeded(startTryBody) val finalHandler = currProgramPoint() // version of the finally-clause reached via unhandled exception. protect(startTryBody, finalHandler, finalHandler, null) - val Local(eTK, _, eIdx, _) = locals(locals.makeLocal(ts.jlThrowableRef, "exc", defn.ThrowableType, finalizer.span)) + val Local(eTK, _, eIdx, _) = locals(locals.makeLocal(bTypes.jlThrowableRef, "exc", defn.ThrowableType, finalizer.span)) bc.store(eIdx, eTK) emitFinalizer(finalizer, null, isDuplicate = true) bc.load(eIdx, eTK) @@ -448,7 +447,7 @@ trait BCodeSyncAndTry(using ctx: Context) extends BCodeBodyBuilder { } /* `tmp` (if non-null) is the symbol of the local-var used to preserve the result of the try-body, see `guardResult` */ - private def emitFinalizer(finalizer: Tree, tmp: Symbol, isDuplicate: Boolean): Unit = { + private def emitFinalizer(finalizer: Tree, tmp: Symbol, isDuplicate: Boolean)(using Context): Unit = { var saved: immutable.Map[ /* Labeled */ Symbol, (BType, LoadDestination) ] = null if (isDuplicate) { saved = jumpDest @@ -463,7 +462,7 @@ trait BCodeSyncAndTry(using ctx: Context) extends BCodeBodyBuilder { } /* Does this tree have a try-catch block? */ - private def mayCleanStack(tree: Tree): Boolean = tree.find { // TODO: use existsSubTree + private def mayCleanStack(tree: Tree)(using Context): Boolean = tree.find { // TODO: use existsSubTree case Try(_, _, _) => true case _ => false }.isDefined diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeUtils.scala b/compiler/src/dotty/tools/backend/jvm/BCodeUtils.scala index a483e0b8d42e..43d5c4b693ee 100644 --- a/compiler/src/dotty/tools/backend/jvm/BCodeUtils.scala +++ b/compiler/src/dotty/tools/backend/jvm/BCodeUtils.scala @@ -13,9 +13,11 @@ package dotty.tools.backend.jvm import dotty.tools.backend.jvm.GenBCode.* +import dotty.tools.backend.jvm.SymbolUtils.symExtensions import dotty.tools.dotc.core.Contexts.Context -import dotty.tools.dotc.core.Flags.{AbstractOrTrait, Artifact, Bridge, Deferred, Enum, Final, JavaEnum, JavaVarargs, Mutable, Private, Synchronized, Trait} +import dotty.tools.dotc.core.Flags.{AbstractOrTrait, Artifact, Bridge, Deferred, Enum, Final, JavaEnum, JavaVarargs, Method, Mutable, Private, Synchronized, Synthetic, Trait} import dotty.tools.dotc.core.Symbols.* +import dotty.tools.dotc.report import scala.annotation.{switch, tailrec} import scala.collection.mutable @@ -462,7 +464,6 @@ object BCodeUtils { } } - /** * Return the Java modifiers for the given symbol. * Java modifiers for classes: @@ -482,8 +483,6 @@ object BCodeUtils { * and they would fail verification after lifted. */ final def javaFlags(sym: Symbol)(using Context): Int = { - import SymbolUtils.given - // Classes are always emitted as public. This matches the behavior of Scala 2 // and is necessary for object deserialization to work properly, otherwise // ModuleSerializationProxy may fail with an accessiblity error (see @@ -516,4 +515,93 @@ object BCodeUtils { .addFlagIf(sym.isDeprecated, ACC_DEPRECATED) .addFlagIf(sym.is(Enum), ACC_ENUM) } + + + /** + * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a + * member class. This method is used to decide if we should emit an EnclosingMethod attribute. + * It is also used to decide whether the "owner" field in the InnerClass attribute should be + * null. + */ + def isAnonymousOrLocalClass(classSym: Symbol)(using ctx: Context): Boolean = { + assert(classSym.isClass, s"not a class: $classSym") + // Here used to be an `assert(!classSym.isDelambdafyFunction)`: delambdafy lambda classes are + // always top-level. However, SI-8900 shows an example where the weak name-based implementation + // of isDelambdafyFunction failed (for a function declared in a package named "lambda"). + classSym.isAnonymousClass || { + val originalOwner = classSym.originalOwner + originalOwner != NoSymbol && !originalOwner.isClass + } + } + + /** + * Returns the enclosing method for non-member classes. In the following example + * + * class A { + * def f = { + * class B { + * class C + * } + * } + * } + * + * the method returns Some(f) for B, but None for C, because C is a member class. For non-member + * classes that are not enclosed by a method, it returns None: + * + * class A { + * { class B } + * } + * + * In this case, for B, we return None. + * + * The EnclosingMethod attribute needs to be added to non-member classes (see doc in BTypes). + * This is a source-level property, so we need to use the originalOwner chain to reconstruct it. + */ + private def enclosingMethodForEnclosingMethodAttribute(classSym: Symbol)(using ctx: Context): Option[Symbol] = { + assert(classSym.isClass, classSym) + @tailrec + def enclosingMethod(sym: Symbol): Option[Symbol] = { + if (sym.isClass || sym == NoSymbol) None + else if (sym.is(Method, butNot=Synthetic)) Some(sym) + else enclosingMethod(sym.originalOwner) + } + enclosingMethod(classSym.originalOwner) + } + + /** + * The enclosing class for emitting the EnclosingMethod attribute. Since this is a source-level + * property, this method looks at the originalOwner chain. See doc in BTypes. + */ + private def enclosingClassForEnclosingMethodAttribute(classSym: Symbol)(using ctx: Context): Symbol = { + assert(classSym.isClass, classSym) + @tailrec + def enclosingClass(sym: Symbol): Symbol = { + if (sym.isClass) sym + else enclosingClass(sym.originalOwner.originalLexicallyEnclosingClass) + } + enclosingClass(classSym.originalOwner.originalLexicallyEnclosingClass) + } + + final case class EnclosingMethodEntry(owner: String, name: String | Null, methodDescriptor: String | Null) + + /** + * Data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not + * an anonymous or local class). See doc in BTypes. + * + * The class is parametrized by two functions to obtain a bytecode class descriptor for a class + * symbol, and to obtain a method signature descriptor from a method symbol. These function depend + * on the implementation of GenASM / GenBCode, so they need to be passed in. + */ + def enclosingMethodAttribute(classSym: Symbol, classDesc: Symbol => String, methodDesc: Symbol => String)(using ctx: Context): Option[EnclosingMethodEntry] = { + if (isAnonymousOrLocalClass(classSym)) { + val methodOpt = enclosingMethodForEnclosingMethodAttribute(classSym) + report.debuglog(s"enclosing method for $classSym is $methodOpt (in ${methodOpt.map(_.enclosingClass)})") + Some(EnclosingMethodEntry( + classDesc(enclosingClassForEnclosingMethodAttribute(classSym)), + methodOpt.map(_.javaSimpleName).orNull, + methodOpt.map(methodDesc).orNull)) + } else { + None + } + } } diff --git a/compiler/src/dotty/tools/backend/jvm/BTypeLoader.scala b/compiler/src/dotty/tools/backend/jvm/BTypeLoader.scala new file mode 100644 index 000000000000..f06b2671fcf3 --- /dev/null +++ b/compiler/src/dotty/tools/backend/jvm/BTypeLoader.scala @@ -0,0 +1,398 @@ +package dotty.tools +package backend +package jvm + +import java.util.concurrent.ConcurrentHashMap +import BTypes.InternalName +import dotty.tools.backend.jvm.BCodeUtils.isAnonymousOrLocalClass +import dotty.tools.backend.jvm.SymbolUtils.symExtensions +import dotty.tools.dotc.core.Symbols.{ClassSymbol, NoSymbol, Symbol, defn} +import dotty.tools.dotc.core.Contexts.* +import dotty.tools.dotc.core.Decorators.toTermName +import dotty.tools.dotc.core.Flags.{Final, JavaDefined, Method, ModuleClass, ModuleVal, PackageClass, Trait} +import dotty.tools.dotc.core.Phases.{Phase, flattenPhase, lambdaLiftPhase, picklerPhase} +import dotty.tools.dotc.core.StdNames.nme +import dotty.tools.dotc.core.{StdNames, Types} +import dotty.tools.dotc.core.Types.{JavaArrayType, Type, TypeRef, abstractTermNameFilter} + +import scala.annotation.tailrec +import scala.tools.asm +import scala.tools.asm.tree.ClassNode + +final class BTypeLoader(primitives: ScalaPrimitives, inlineInfoLoader: () => Option[InlineInfoLoader]) { + // Concurrent map because stack map frames are computed when in the class writer, which + // might run on multiple classes concurrently. + private val classBTypeCache = new ConcurrentHashMap[InternalName, ClassBType] + + /** Maps special symbols, including primitive types, to their corresponding BType. */ + // It's OK to cache this because all Contexts that go through here share their defns. + // No locking, it's OK if this map gets initialized twice (though a little inefficient). + private var specialBTypes: Map[Symbol, BType] | Null = null + + + /** See doc of ClassBType.apply. This is where to use that method from. */ + def classBType[T](internalName: InternalName)(init: ClassBType => Either[T, ClassInfo]): Either[T, ClassBType] = + ClassBType(internalName, classBTypeCache)(init) + + /** See doc of ClassBType.apply. This is where to use that method from. Version that cannot fail. */ + def classBType(internalName: InternalName)(init: ClassBType => ClassInfo): ClassBType = + ClassBType(internalName, classBTypeCache)(ct => Right(init(ct))).fold(_ => assert(false), identity) + + /** Obtain a previously constructed ClassBType for a given internal name, or None if no such ClassBType was constructed. */ + def previouslyConstructedClassBType(internalName: InternalName): Option[ClassBType] = + Option(classBTypeCache.get(internalName)) + + def bTypeFromSymbol(sym: Symbol)(using Context): BType = { + if specialBTypes eq null then + specialBTypes = Map( + defn.UnitClass -> UNIT, + defn.BooleanClass -> BOOL, + defn.CharClass -> CHAR, + defn.ByteClass -> BYTE, + defn.ShortClass -> SHORT, + defn.IntClass -> INT, + defn.LongClass -> LONG, + defn.FloatClass -> FLOAT, + defn.DoubleClass -> DOUBLE, + defn.NothingClass -> classBTypeFromSymbol(defn.RuntimeNothingClass), + defn.NullClass -> classBTypeFromSymbol(defn.RuntimeNullClass) + ) + specialBTypes.nn.getOrElse(sym, classBTypeFromSymbol(sym)) + } + + /** + * The ClassBType for a class symbol `sym`. + */ + def classBTypeFromSymbol(classSym0: Symbol)(using Context): ClassBType = { + // For each java class, the scala compiler creates a class and a module (thus a module class). + // If the symbol is a java module class, we use the java class instead. This ensures that the + // ClassBType is created from the main class (instead of the module class). + // The two symbols have the same name, so the resulting internalName is the same. + val classSym = if classSym0.isAllOf(JavaDefined | ModuleClass, butNot = PackageClass) + then classSym0.linkedClass + else classSym0 + + assert(classSym.isClass, s"Cannot create ClassBType from non-class symbol $classSym") // also covers the NoSymbol case + assert( + classSym != defn.NothingClass && classSym != defn.NullClass, + s"Cannot create ClassBType for special class symbol ${classSym.showFullName}") + assert(classSym != defn.ArrayClass || BackendUtils.compilingArray, classSym) + assert(!classSym.isPrimitiveValueClass || BackendUtils.compilingPrimitive, s"Found $classSym while compiling ${ctx.compilationUnit.source.file.name}") + + classBType(classSym.javaBinaryName)(ct => createClassInfo(ct, classSym.asClass)) + } + + def mirrorClassBTypeFromSymbol(moduleClassSym: Symbol)(using Context): ClassBType = { + assert(moduleClassSym.isTopLevelModuleClass, s"not a top-level module class: $moduleClassSym") + val internalName = moduleClassSym.javaBinaryName.stripSuffix(StdNames.str.MODULE_SUFFIX) + classBType(internalName)(_ => + ClassInfo( + superClass = Some(classBTypeFromSymbol(defn.ObjectClass)), + interfaces = Nil, + flags = asm.Opcodes.ACC_SUPER | asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_FINAL, + nestedClasses = getMemberClasses(moduleClassSym).map(classBTypeFromSymbol), + nestedInfo = None, + inlineInfo = InlineInfo.empty + ) + ) + } + + /* + * must-single-thread + */ + def methodBTypeFromSymbol(msym: Symbol)(using Context): MethodBType = { + assert(msym.is(Method), s"not a method-symbol: $msym") + val resT: BType = + if (msym.isClassConstructor || msym.isConstructor) UNIT + else bTypeFromType(msym.info.resultType) + MethodBType(msym.info.firstParamTypes.map(bTypeFromType), resT) + } + + /** + * This method returns the BType for a type reference, for example a parameter type. + * + * If the result is a ClassBType for a nested class, it is added to the innerClassBufferASM. + * + * If `t` references a class, toTypeKind ensures that the class is not an implementation class. + * See also comment on getClassBTypeAndRegisterInnerClass, which is invoked for implementation + * classes. + */ + def bTypeFromType(tp: Type)(using Context): BType = { + tp.widenDealias match + case JavaArrayType(el) => ArrayBType(bTypeFromType(el)) // Array type such as Array[Int] (kept by erasure) + case t: TypeRef => bTypeFromSymbol(t.symbol) // Common reference to a type such as scala.Int or java.lang.String + case Types.ClassInfo(_, sym, _, _, _) => bTypeFromSymbol(sym) // We get here, for example, for genCallMethod, which invokes bTypeFromType(method.owner.info) + case tp => + throw new AssertionError(s"an unexpected type representation reached the compiler backend while compiling ${ctx.compilationUnit}: $tp.") + } + + /** + * Visit the class node and collect all referenced nested classes. + */ + def collectNestedClasses(classNode: ClassNode): (Iterable[ClassBType], Iterable[ClassBType]) = { + val c = new NestedClassesCollector[ClassBType](nestedOnly = true) { + def declaredNestedClasses(internalName: InternalName): List[ClassBType] = + previouslyConstructedClassBType(internalName).get.info.nestedClasses + + def getClassIfNested(internalName: InternalName): Option[ClassBType] = { + val c = previouslyConstructedClassBType(internalName).get + Option.when(c.isNestedClass)(c) + } + + def raiseError(msg: String, sig: String, e: Option[Throwable]): Unit = { + // don't crash on invalid generic signatures + } + } + c.visit(classNode) + (c.declaredInnerClasses, c.referredInnerClasses) + } + + private def createClassInfo(classBType: ClassBType, classSym: Symbol)(using Context): ClassInfo = { + val superClassSym: Symbol = { + val t = classSym.asClass.superClass + if (t.exists) t + else if (classSym.is(ModuleClass)) { + // workaround #371 + + println(s"Warning: mocking up superclass for $classSym") + defn.ObjectClass + } + else t + } + assert( + if (classSym == defn.ObjectClass) + superClassSym == NoSymbol + else if (classSym.is(Trait)) + superClassSym == defn.ObjectClass + else + // A ClassBType for a primitive class (scala.Boolean et al.) is only created when compiling these classes. + ((superClassSym != NoSymbol) && !superClassSym.is(Trait)) || classSym.isPrimitiveValueClass, + s"Bad superClass for $classSym: $superClassSym" + ) + val superClass = if (superClassSym == NoSymbol) None + else Some(classBTypeFromSymbol(superClassSym)) + + // List only directly inherited interfaces. + // This is not only a performance optimization (as the JVM needs to handle fewer inheritance declarations), + // but also required for correctness in the presence of sealed interfaces (see i23479): + // if `C` inherits from `non-sealed A` which itself inherits from `sealed B permits A`, then having `C` inherit from `B` directly is illegal. + val allBaseClasses = classSym.directlyInheritedTraits.iterator.flatMap(_.asClass.baseClasses.drop(1)).toSet + val interfaces = classSym.directlyInheritedTraits.filter(!allBaseClasses(_)).map(classBTypeFromSymbol) + + val flags = BCodeUtils.javaFlags(classSym) + + /* The InnerClass table of a class C must contain all nested classes of C, even if they are only + * declared but not otherwise referenced in C (from the bytecode or a method / field signature). + * We collect them here. + */ + val nestedClassSymbols = { + // The lambdalift phase lifts all nested classes to the enclosing class, so if we collect + // member classes right after lambdalift, we obtain all nested classes, including local and + // anonymous ones. + val nestedClasses = getNestedClasses(classSym) + + // If this is a top-level class, and it has a companion object, the member classes of the + // companion are added as members of the class. For example: + // class C { } + // object C { + // class D + // def f = { class E } + // } + // The class D is added as a member of class C. The reason is that the InnerClass attribute + // for D will contain class "C" and NOT the module class "C$" as the outer class of D. + // This is done by buildNestedInfo, the reason is Java compatibility, see comment in BTypes. + // For consistency, the InnerClass entry for D needs to be present in C - to Java it looks + // like D is a member of C, not C$. + val linkedClass = classSym.linkedClass + val companionModuleMembers = { + if (classSym.linkedClass.isTopLevelModuleClass) getMemberClasses(classSym.linkedClass) + else Nil + } + + nestedClasses ++ companionModuleMembers + } + + /** + * For nested java classes, the scala compiler creates both a class and a module (and therefore + * a module class) symbol. For example, in `class A { class B {} }`, the nestedClassSymbols + * for A contain both the class B and the module class B. + * Here we get rid of the module class B, making sure that the class B is present. + * + * (In Scala 2, we had an assertion that there must be exactly 2 nested class symbols with the same name and owner, + * but in Dotty there will be B & B$) + */ + val nestedClassSymbolsNoJavaModuleClasses = nestedClassSymbols.filter(s => !(s.is(JavaDefined) && s.is(ModuleClass))) + + val memberClasses = nestedClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol) + + val nestedInfo = buildNestedInfo(classSym) + + val inlineInfo = inlineInfoLoader() match { + case Some(loader) => buildInlineInfo(loader, classSym.asClass, classBType.internalName) + case None => InlineInfo.empty + } + + ClassInfo(superClass, interfaces, flags, memberClasses, nestedInfo, inlineInfo) + } + + /** For currently compiled classes: All locally defined classes including local classes. + * The empty list for classes that are not currently compiled. + */ + private def getNestedClasses(sym: Symbol)(using Context): List[Symbol] = definedClasses(sym, flattenPhase) + + /** For currently compiled classes: All classes that are declared as members of this class + * (but not inherited ones). The empty list for classes that are not currently compiled. + */ + private def getMemberClasses(sym: Symbol)(using Context): List[Symbol] = definedClasses(sym, lambdaLiftPhase) + + private def definedClasses(sym: Symbol, phase: Phase)(using Context) = + if (sym.isDefinedInCurrentRun) + atPhase(phase) { + sym.info.decls.filter(sym => sym.isClass && !sym.isEffectivelyErased) + } + else Nil + + private def buildNestedInfo(innerClassSym: Symbol)(using Context): Option[NestedInfo] = { + assert(innerClassSym.isClass, s"Cannot build NestedInfo for non-class symbol $innerClassSym") + + val isNested = !innerClassSym.originalOwner.originalLexicallyEnclosingClass.is(PackageClass) + if (!isNested) None + else { + // See comment in BTypes, when is a class marked static in the InnerClass table. + val isStaticNestedClass = innerClassSym.is(ModuleClass) || isOriginallyStaticOwner(innerClassSym.originalOwner.originalLexicallyEnclosingClass) + + // After lambdalift (which is where we are), the raw owner field contains the enclosing class. + val enclosingClassSym = { + if (innerClassSym.isClass) { + atPhase(flattenPhase.prev) { + innerClassSym.owner.enclosingClass + } + } + else atPhase(flattenPhase.prev)(innerClassSym.enclosingClass) + } //todo is handled specially for JavaDefined symbols in scalac + + val enclosingClass: ClassBType = classBTypeFromSymbol(enclosingClassSym) + + val outerName: Option[String] = { + if (isAnonymousOrLocalClass(innerClassSym)) { + None + } else { + val outerName = innerClassSym.originalOwner.originalLexicallyEnclosingClass.javaBinaryName + + def dropModule(str: String): String = + if (str.nonEmpty && str.last == '$') str.take(str.length - 1) else str + + // Java compatibility. See the big comment in BTypes that summarizes the InnerClass spec. + val outerNameModule = + if (innerClassSym.originalOwner.originalLexicallyEnclosingClass.isTopLevelModuleClass) dropModule(outerName) + else outerName + Some(outerNameModule) + } + } + + val innerName: Option[String] = { + if (innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction) None + else { + val original = innerClassSym.initial + Some(atPhase(original.validFor.lastPhaseId)(innerClassSym.targetName).mangledString) // moduleSuffix for module classes + } + } + + Some(NestedInfo(enclosingClass, outerName, innerName, isStaticNestedClass)) + } + } + + /* + * Note that the InlineInfo is only built from the symbolic information for classes that are being + * compiled. For all other classes we delegate to inlineInfoFromClassfile. The reason is that + * mixed-in methods are only added to class symbols being compiled, but not to other classes + * extending traits. Creating the InlineInfo from the symbol would prevent these mixins from being + * inlined. + * + * So for classes being compiled, the InlineInfo is created here and stored in the ScalaInlineInfo + * classfile attribute. + */ + private def buildInlineInfo(inlineInfoLoader: InlineInfoLoader, classSym: ClassSymbol, internalName: InternalName)(using Context): InlineInfo = { + // phase travel required (or at least it was in Scala 2). for nested classes, it checks if the + // enclosingTopLevelClass is being compiled. after flatten, all classes are considered top-level, + // so it would return `false`. + if atPhase(picklerPhase.next) { + classSym.isDefinedInCurrentRun + } then buildInlineInfoFromClassSymbol(classSym) // // InlineInfo required for classes being compiled, we have to create the classfile attribute + // For classes not being compiled, the InlineInfo is read from the classfile attribute. This + // fixes an issue with mixed-in methods: the mixin phase enters mixin methods only to class + // symbols being compiled. For non-compiled classes, we could not build MethodInlineInfos + // for those mixin members, which prevents inlining. + else inlineInfoLoader.loadInlineInfoFor(internalName) + } + + /** + * Build the [[InlineInfo]] for a class symbol. + */ + private def buildInlineInfoFromClassSymbol(classSym: ClassSymbol)(using Context): InlineInfo = { + // We only want an approximation of SAMs for inlining heuristics, no need to check FunctionalInterface annotations or such + val abstractMembers = classSym.memberNames(abstractTermNameFilter).iterator.map(classSym.classInfo.member).map(_.symbol).filter(_.is(Method)).toList + val sam = abstractMembers match + case List(single) => + val btype = methodBTypeFromSymbol(single) + Some(single.javaSimpleName + btype.descriptor) + case _ => None + + def keepMember(sym: Symbol) = sym.is(Method) && !primitives.isPrimitive(sym) + + val classMethods = classSym.info.decls.iterator.filter(keepMember) + val methods = if classSym.is(JavaDefined) then + // Phase travel important for nested classes (scala-dev#402). When a java class symbol A$B + // is compiled from source, this ensures that `companionModule` doesn't return the `A$B` + // symbol created for the `A$B.class` file on the classpath, which might be different. + val companion = atPhase(picklerPhase.next) { + classSym.companionModule + } + val staticMethods = companion.info.decls.iterator.filter(m => !m.isConstructor && keepMember(m)) + staticMethods ++ classMethods + else + val staticForwarders = if classSym.is(Trait) then + // !!! This logic duplicates PlainSkelBuilder::makeStaticForwarder, copy changes there !!! + classSym.info.decls.filter(s => s.isTerm && !s.isPrivate && !s.isStaticMember && s.name != nme.TRAIT_CONSTRUCTOR).map(s => { + BackendUtils.makeStatifiedDefSymbol(s.asTerm, BackendUtils.traitSuperAccessorName(s).toTermName) + }) + else Nil + classMethods ++ staticForwarders + + // Primitive methods cannot be inlined, so there's no point in building a MethodInlineInfo. Also, some + // primitive methods (e.g., `isInstanceOf`) have non-erased types, which confuses [[typeToBType]]. + val methodInlineInfos = new collection.mutable.TreeMap[(String, String), MethodInlineInfo]() + methods.foreach { + methodSym => + val name = methodSym.javaSimpleName // same as in genDefDef + val signature = (name, methodBTypeFromSymbol(methodSym).descriptor) + + // In a trait, accesses to "modules" like enums are translated by the frontend as final methods, + // even though they are logically not final since classes implementing the trait will also have that method, + // so we must explicitly consider them to be non-final. + // TODO: This feels like something fundamentally weird in trees that should not exist. + val info = MethodInlineInfo( + effectivelyFinal = methodSym.isEffectivelyFinal && !methodSym.is(ModuleVal), + annotatedInline = methodSym.hasAnnotation(defn.InlineAnnot), + annotatedNoInline = methodSym.hasAnnotation(defn.NoInlineAnnot)) + + methodInlineInfos(signature) = info + } + + // if we have a symbol, we're compiling the class, so we assume it's accessible + InlineInfo(classSym.is(Final), sam, methodInlineInfos, None, isAccessible = true) + } + + /** + * This is basically a re-implementation of sym.isStaticOwner, but using the originalOwner chain. + * + * The problem is that we are interested in a source-level property. Various phases changed the + * symbol's properties in the meantime, mostly lambdalift modified (destructively) the owner. + * Therefore, `sym.isStatic` is not what we want. For example, in + * object T { def f { object U } } + * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here. + */ + @tailrec + private def isOriginallyStaticOwner(sym: Symbol)(using Context): Boolean = + sym.is(PackageClass) || sym.is(ModuleClass) && isOriginallyStaticOwner(sym.originalOwner.originalLexicallyEnclosingClass) +} \ No newline at end of file diff --git a/compiler/src/dotty/tools/backend/jvm/BTypes.scala b/compiler/src/dotty/tools/backend/jvm/BTypes.scala index 3df3e791a164..584e97907759 100644 --- a/compiler/src/dotty/tools/backend/jvm/BTypes.scala +++ b/compiler/src/dotty/tools/backend/jvm/BTypes.scala @@ -69,13 +69,6 @@ sealed trait BType { final def isNonVoidPrimitiveType: Boolean = isPrimitive && this != UNIT - def isObjectType: Boolean - def isJlCloneableType: Boolean - def isJiSerializableType: Boolean - def isNullType: Boolean - def isNothingType: Boolean - def isBoxed: Boolean - final def isIntSizedType: Boolean = this == BOOL || this == CHAR || this == BYTE || this == SHORT || this == INT final def isIntegralType: Boolean = this == INT || this == BYTE || this == LONG || @@ -94,8 +87,9 @@ sealed trait BType { this match { case ArrayBType(component) => - if (other.isObjectType || other.isJlCloneableType || other.isJiSerializableType) true - else other match { + other match { + case ClassBType(name) => + name == "java/lang/Object" || name == "java/lang/Cloneable" || name == "java/io/Serializable" case ArrayBType(otherComponent) => // Array[Short]().isInstanceOf[Array[Int]] is false // but Array[String]().isInstanceOf[Array[Object]] is true @@ -106,10 +100,11 @@ sealed trait BType { case classType: ClassBType => // Quick test for Object to make a common case fast - other.isObjectType || (other match { + other match { + case ClassBType("java/lang/Object") => true case otherClassType: ClassBType => classType.isSubtypeOf(otherClassType) case _ => false - }) + } case _ => // there are no bool/byte/short/char primitives at runtime, they are represented as ints. @@ -130,13 +125,13 @@ sealed trait BType { * Compute the upper bound of two types. * Takes promotions of numeric primitives into account. */ - final def maxType(other: BType, ts: CoreBTypes): BType = this match { + final def maxType(other: BType, ts: WellKnownBTypes): BType = this match { case pt: PrimitiveBType => pt.maxValueType(other) case _: ArrayBType | _: ClassBType => - if isNothingType then return other - if other.isNothingType then return this - if this == other then return this + if this == ts.srNothingRef then return other + if other == ts.srNothingRef then return this + if this == other then return this assert(other.isRef, s"Cannot compute maxType: $this, $other") // Approximate `lub`. The common type of two references is always ObjectReference. @@ -224,14 +219,6 @@ sealed trait BType { sealed trait PrimitiveBType extends BType { - override def isObjectType: Boolean = false - override def isJlCloneableType: Boolean = false - override def isJiSerializableType: Boolean = false - override def isNullType: Boolean = false - override def isNothingType: Boolean = false - override def isBoxed: Boolean = false - - /** * The upper bound of two primitive types. The `other` type has to be either a primitive * type or Nothing. @@ -243,9 +230,12 @@ sealed trait PrimitiveBType extends BType { def uncomparable: Nothing = throw new AssertionError(s"Cannot compute maxValueType: $this, $other") - if !other.isPrimitive && !other.isNothingType then uncomparable + other match { + case ClassBType("scala/runtime/Nothing$") => return this + case _ => () + } - if other.isNothingType then return this + if !other.isPrimitive then uncomparable if this == other then return this this match { @@ -310,14 +300,6 @@ case object DOUBLE extends PrimitiveBType sealed trait RefBType extends BType { - override def isObjectType: Boolean = false - override def isJlCloneableType: Boolean = false - override def isJiSerializableType: Boolean = false - override def isNullType: Boolean = false - override def isNothingType: Boolean = false - override def isBoxed: Boolean = false - - /** * The class or array type of this reference type. Used for ANEWARRAY, MULTIANEWARRAY, * INSTANCEOF and CHECKCAST instructions. Also used for emitting invokevirtual calls to @@ -664,7 +646,7 @@ final case class MethodInlineInfo(effectivelyFinal: Boolean = false, /** * A ClassBType represents a class or interface type. */ -case class ClassBType private(val internalName: String, private val ts: CoreBTypes) extends RefBType { +case class ClassBType private(internalName: String) extends RefBType { /** * Write-once variable allows initializing a cyclic graph of infos. This is required for * nested classes. Example: for the definition `class A { class B }` we have @@ -685,13 +667,6 @@ case class ClassBType private(val internalName: String, private val ts: CoreBTyp checkInfoConsistency() } - override def isObjectType: Boolean = this == ts.ObjectRef - override def isJlCloneableType: Boolean = this == ts.jlCloneableRef - override def isJiSerializableType: Boolean = this == ts.jiSerializableRef - override def isNullType: Boolean = this == ts.srNullRef - override def isNothingType: Boolean = this == ts.srNothingRef - override def isBoxed: Boolean = this.isClass && ts.boxedClasses(this.asClassBType) - private def checkInfoConsistency(): Unit = { // we assert some properties. however, some of the linked ClassBType (members, superClass, // interfaces) may not yet have an `_info` (initialization of cyclic structures). so we do a @@ -768,7 +743,7 @@ case class ClassBType private(val internalName: String, private val ts: CoreBTyp def isSubtypeOf(other: ClassBType): Boolean = { if (this == other) return true if (isInterface) { - if (other == ts.ObjectRef) return true // interfaces conform to Object + if (other.internalName == "java/lang/Object") return true // interfaces conform to Object if (!other.isInterface) return false // this is an interface, the other is some class other than object. interfaces cannot extend classes, so the result is false. // else: this and other are both interfaces. continue to (*) } else { @@ -789,8 +764,8 @@ case class ClassBType private(val internalName: String, private val ts: CoreBTyp * http://comments.gmane.org/gmane.comp.java.vm.languages/2293 * https://issues.scala-lang.org/browse/SI-3872 */ - def jvmWiseLUB(other: ClassBType): ClassBType = { - def isNotNullOrNothing(c: ClassBType) = !c.isNullType && !c.isNothingType + def jvmWiseLUB(other: ClassBType, ts: WellKnownBTypes): ClassBType = { + def isNotNullOrNothing(c: ClassBType) = c != ts.srNullRef && c != ts.srNothingRef assert(isNotNullOrNothing(this) && isNotNullOrNothing(other), s"jvmWiseLUB for null or nothing: $this - $other") val res: ClassBType = (this.isInterface, other.isInterface) match { @@ -807,14 +782,14 @@ case class ClassBType private(val internalName: String, private val ts: CoreBTyp if (this.isSubtypeOf(other)) other else ts.ObjectRef case _ => - firstCommonSuffix(superClassesChain, other.superClassesChain) + firstCommonSuffix(superClassesChain, other.superClassesChain, ts) } assert(isNotNullOrNothing(res), s"jvmWiseLUB computed: $res") res } - private def firstCommonSuffix(as: List[ClassBType], bs: List[ClassBType]): ClassBType = { + private def firstCommonSuffix(as: List[ClassBType], bs: List[ClassBType], ts: WellKnownBTypes): ClassBType = { var chainA = as.tail var chainB = bs.tail var fcs = ts.ObjectRef @@ -834,7 +809,6 @@ object ClassBType { * already exist in the cache * * @param internalName The name of the class - * @param ts The core types associated with the compilation * @param cache The cache to use. If you're wondering what to pass here, you're in the wrong place and should not be directly calling this. * @param init Function to initialize the info of this `BType`. During execution of this function, * code _may_ reenter into `apply(internalName, ...)` and retrieve the initializing @@ -842,12 +816,12 @@ object ClassBType { * @tparam T The type of the error result. * @return The `ClassBType` */ - final def apply[T](internalName: InternalName, ts: CoreBTypes, cache: ConcurrentHashMap[InternalName, ClassBType]) + final def apply[T](internalName: InternalName, cache: ConcurrentHashMap[InternalName, ClassBType]) (init: ClassBType => Either[T, ClassInfo]): Either[T, ClassBType] = { val cached = cache.get(internalName) if cached ne null then Right(cached) else { - val newRes = new ClassBType(internalName, ts) + val newRes = new ClassBType(internalName) // synchronized is required to ensure proper initialization of info. // see comment on def info newRes.synchronized { @@ -887,14 +861,6 @@ object ClassBType { } case class ArrayBType(componentType: BType) extends RefBType { - - override def isObjectType: Boolean = false - override def isJlCloneableType: Boolean = false - override def isJiSerializableType: Boolean = false - override def isNullType: Boolean = false - override def isNothingType: Boolean = false - override def isBoxed: Boolean = false - def dimension: Int = componentType match { case a: ArrayBType => 1 + a.dimension case _ => 1 @@ -906,16 +872,7 @@ case class ArrayBType(componentType: BType) extends RefBType { } } -case class MethodBType(argumentTypes: List[BType], returnType: BType) extends BType { - - override def isObjectType: Boolean = false - override def isJlCloneableType: Boolean = false - override def isJiSerializableType: Boolean = false - override def isNullType: Boolean = false - override def isNothingType: Boolean = false - override def isBoxed: Boolean = false - -} +case class MethodBType(argumentTypes: List[BType], returnType: BType) extends BType object BTypes { /** diff --git a/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala b/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala index 6ee9bfdc87e5..47d7df6eb006 100644 --- a/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala +++ b/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala @@ -2,7 +2,6 @@ package dotty.tools package backend.jvm import dotty.tools.backend.jvm.BTypes.InternalName -import dotty.tools.backend.jvm.PostProcessorFrontendAccess.Lazy import dotty.tools.dotc.core.Contexts.{Context, ctx} import dotty.tools.dotc.core.Definitions import dotty.tools.dotc.core.Flags.{JavaStatic, Method} @@ -24,7 +23,7 @@ import scala.tools.asm.{Handle, Opcodes, Type} * This component hosts tools and utilities used in the backend that require access to a `CoreBTypes` * instance. */ -class BackendUtils(val ppa: PostProcessorFrontendAccess, val ts: CoreBTypes)(using Context) { +class BackendUtils(val ts: WellKnownBTypes) { /** * Classes with indyLambda closure instantiations where the SAM type is serializable (e.g. Scala's @@ -33,11 +32,8 @@ class BackendUtils(val ppa: PostProcessorFrontendAccess, val ts: CoreBTypes)(usi * inlining: when inlining an indyLambda instruction into a class, we need to make sure the class * has the method. */ - private val indyLambdaImplMethods: Lazy[ConcurrentHashMap[InternalName, mutable.Map[MethodNode, mutable.Map[InvokeDynamicInsnNode, asm.Handle]]]] = - ppa.perRunLazy(new ConcurrentHashMap) - - // take advantage of the fact classfile versions are consecutive - lazy val classfileVersion: Int = ppa.compilerSettings.target.toInt + (Opcodes.V17 - 17) + private val indyLambdaImplMethods: ConcurrentHashMap[InternalName, mutable.Map[MethodNode, mutable.Map[InvokeDynamicInsnNode, asm.Handle]]] = + new ConcurrentHashMap def collectSerializableLambdas(classNode: ClassNode): Array[Handle] = { val indyLambdaBodyMethods = new mutable.ArrayBuffer[Handle] @@ -128,27 +124,6 @@ class BackendUtils(val ppa: PostProcessorFrontendAccess, val ts: CoreBTypes)(usi MethodBType(ts.jliSerializedLambdaRef :: Nil, ts.ObjectRef).descriptor } - /** - * Visit the class node and collect all referenced nested classes. - */ - def collectNestedClasses(classNode: ClassNode): (Iterable[ClassBType], Iterable[ClassBType]) = { - val c = new NestedClassesCollector[ClassBType](nestedOnly = true) { - def declaredNestedClasses(internalName: InternalName): List[ClassBType] = - ts.classBTypeFromInternalName(internalName).get.info.nestedClasses - - def getClassIfNested(internalName: InternalName): Option[ClassBType] = { - val c = ts.classBTypeFromInternalName(internalName).get - Option.when(c.isNestedClass)(c) - } - - def raiseError(msg: String, sig: String, e: Option[Throwable]): Unit = { - // don't crash on invalid generic signatures - } - } - c.visit(classNode) - (c.declaredInnerClasses, c.referredInnerClasses) - } - /* * Populates the InnerClasses JVM attribute with `refedInnerClasses`. See also the doc on inner * classes in BTypes.scala. @@ -175,13 +150,13 @@ class BackendUtils(val ppa: PostProcessorFrontendAccess, val ts: CoreBTypes)(usi } def onIndyLambdaImplMethodIfPresent[T](hostClass: InternalName)(action: mutable.Map[MethodNode, mutable.Map[InvokeDynamicInsnNode, asm.Handle]] => T): Option[T] = - indyLambdaImplMethods.get.get(hostClass) match { + indyLambdaImplMethods.get(hostClass) match { case null => None case methods => Some(methods.synchronized(action(methods))) } def onIndyLambdaImplMethod[T](hostClass: InternalName)(action: mutable.Map[MethodNode, mutable.Map[InvokeDynamicInsnNode, asm.Handle]] => T): T = { - val methods = indyLambdaImplMethods.get.computeIfAbsent(hostClass, _ => mutable.Map.empty) + val methods = indyLambdaImplMethods.computeIfAbsent(hostClass, _ => mutable.Map.empty) methods.synchronized(action(methods)) } @@ -193,38 +168,6 @@ class BackendUtils(val ppa: PostProcessorFrontendAccess, val ts: CoreBTypes)(usi onIndyLambdaImplMethodIfPresent(hostClass)(_.get(method).foreach(_.remove(indy))) } - /** - * The methods used as lambda bodies for IndyLambda instructions within `hostClass`. Note that - * the methods are not necessarily defined within the `hostClass` (when an IndyLambda is inlined - * into a different class). - */ - def indyLambdaBodyMethods(hostClass: InternalName): mutable.SortedSet[Handle] = { - object handleOrdering extends Ordering[Handle] { - override def compare(x: Handle, y: Handle): Int = { - if (x eq y) return 0 - - val t = Ordering.Int.compare(x.getTag, y.getTag) - if (t != 0) return t - - val i = Ordering.Boolean.compare(x.isInterface, y.isInterface) - if (x.isInterface != y.isInterface) return i - - val o = x.getOwner.compareTo(y.getOwner) - if (o != 0) return o - - val n = x.getName.compareTo(y.getName) - if (n != 0) return n - - x.getDesc.compareTo(y.getDesc) - } - } - - given Ordering[Handle] = handleOrdering - val res = mutable.TreeSet.empty[Handle] - onIndyLambdaImplMethodIfPresent(hostClass)(methods => res.addAll(methods.valuesIterator.flatMap(_.valuesIterator))) - res - } - /** * The methods used as lambda bodies for IndyLambda instructions within `method` of `hostClass`. */ @@ -355,8 +298,7 @@ class BackendUtils(val ppa: PostProcessorFrontendAccess, val ts: CoreBTypes)(usi (ts.StringRef.internalName, MethodBType(List(ArrayBType(CHAR)), UNIT).descriptor)) lazy val modulesAllowSkipInitialization: Set[InternalName] = - if (!ppa.compilerSettings.optAllowSkipCoreModuleInit) Set.empty - else Set( + Set( "scala/Predef$", "scala/runtime/ScalaRunTime$", "scala/runtime/Scala3RunTime$", diff --git a/compiler/src/dotty/tools/backend/jvm/ClassfileWriters.scala b/compiler/src/dotty/tools/backend/jvm/ClassfileWriters.scala deleted file mode 100644 index 1a2c5274dd6b..000000000000 --- a/compiler/src/dotty/tools/backend/jvm/ClassfileWriters.scala +++ /dev/null @@ -1,296 +0,0 @@ -package dotty.tools.backend.jvm - -import java.io.{BufferedOutputStream, DataOutputStream, File, FileOutputStream, IOException} -import java.nio.ByteBuffer -import java.nio.channels.{ClosedByInterruptException, FileChannel} -import java.nio.charset.StandardCharsets.UTF_8 -import java.nio.file.* -import java.nio.file.attribute.FileAttribute -import java.util -import java.util.concurrent.ConcurrentHashMap -import java.util.zip.{CRC32, Deflater, ZipEntry, ZipOutputStream} -import dotty.tools.dotc.core.Contexts.* -import dotty.tools.dotc.core.Decorators.em -import dotty.tools.dotc.util.chaining.* -import dotty.tools.io.{AbstractFile, PlainFile, VirtualFile} -import dotty.tools.io.PlainFile.toPlainFile -import BTypes.InternalName -import dotty.tools.dotc.report -import dotty.tools.io.JarArchive - -/** !!! This file is now copied in `dotty.tools.io.FileWriters` in a more general way that does not rely upon - * `PostProcessorFrontendAccess`, this should probably be changed to wrap that class instead. - * - * Until then, any changes to this file should be copied to `dotty.tools.io.FileWriters` as well. - */ -class ClassfileWriters(frontendAccess: PostProcessorFrontendAccess)(using ctx: Context) { - import frontendAccess.compilerSettings - - sealed trait TastyWriter { - def writeTasty(name: InternalName, bytes: Array[Byte], sourceFile: AbstractFile): Unit - } - - /** - * The interface to writing classfiles. GeneratedClassHandler calls these methods to generate the - * directory and files that are created, and eventually calls `close` when the writing is complete. - * - * The companion object is responsible for constructing a appropriate and optimal implementation for - * the supplied settings. - * - * Operations are threadsafe. - */ - sealed trait ClassfileWriter extends TastyWriter { - /** - * Write a classfile - */ - def writeClass(name: InternalName, bytes: Array[Byte], sourceFile: AbstractFile): AbstractFile - - - /** - * Close the writer. Behavior is undefined after a call to `close`. - */ - def close(): Unit - - protected def classRelativePath(className: InternalName, suffix: String = ".class"): String = - className.replace('.', '/') + suffix - } - - object ClassfileWriter { - private def getDirectory(dir: String): Path = Paths.get(dir) - - def apply(): ClassfileWriter = { - val jarManifestMainClass: Option[String] = compilerSettings.mainClass.orElse { - frontendAccess.getEntryPoints match { - case List(name) => Some(name) - case es => - if es.isEmpty then report.log("No Main-Class designated or discovered.") - else report.log(s"No Main-Class due to multiple entry points:\n ${es.mkString("\n ")}") - None - } - } - - // In Scala 2 depenening on cardinality of distinct output dirs MultiClassWriter could have been used - // In Dotty we always use single output directory - val basicClassWriter = new SingleClassWriter( - FileWriter(compilerSettings.outputDirectory, jarManifestMainClass) - ) - - val withAdditionalFormats = - compilerSettings.dumpClassesDirectory - .map(getDirectory) - .filter{path => Files.exists(path).tap{ok => if !ok then report.error(em"Output dir does not exist: ${path.toString}")}} - .map(out => FileWriter(out.toPlainFile, None)) - .fold[ClassfileWriter](basicClassWriter)(new DebugClassWriter(basicClassWriter, _)) - - // val enableStats = settings.areStatisticsEnabled && settings.YaddBackendThreads.value == 1 - // if (enableStats) new WithStatsWriter(withAdditionalFormats) else - withAdditionalFormats - } - - private final class SingleClassWriter(underlying: FileWriter) extends ClassfileWriter { - override def writeClass(className: InternalName, bytes: Array[Byte], sourceFile: AbstractFile): AbstractFile = { - underlying.writeFile(classRelativePath(className), bytes) - } - override def writeTasty(className: InternalName, bytes: Array[Byte], sourceFile: AbstractFile): Unit = { - underlying.writeFile(classRelativePath(className, ".tasty"), bytes) - } - - - override def close(): Unit = underlying.close() - } - - private final class DebugClassWriter(basic: ClassfileWriter, dump: FileWriter) extends ClassfileWriter { - override def writeClass(className: InternalName, bytes: Array[Byte], sourceFile: AbstractFile): AbstractFile = { - val outFile = basic.writeClass(className, bytes, sourceFile) - dump.writeFile(classRelativePath(className), bytes) - outFile - } - - override def writeTasty(className: InternalName, bytes: Array[Byte], sourceFile: AbstractFile): Unit = { - basic.writeTasty(className, bytes, sourceFile) - } - - override def close(): Unit = { - basic.close() - dump.close() - } - } - } - - sealed trait FileWriter { - def writeFile(relativePath: String, bytes: Array[Byte]): AbstractFile - def close(): Unit - } - - object FileWriter { - def apply(file: AbstractFile, jarManifestMainClass: Option[String]): FileWriter = - if (file.isInstanceOf[JarArchive]) { - val jarCompressionLevel = compilerSettings.jarCompressionLevel - // Writing to non-empty JAR might be an undefined behaviour, e.g. in case if other files where - // created using `AbstractFile.bufferedOutputStream`instead of JarWriter - val jarFile = file.underlyingSource.getOrElse{ - throw new IllegalStateException("No underlying source for jar") - } - assert(file.isEmpty, s"Unsafe writing to non-empty JAR: $jarFile") - new JarEntryWriter(jarFile, jarManifestMainClass, jarCompressionLevel) - } - else if (file.isVirtual) new VirtualFileWriter(file) - else if (file.isDirectory) new DirEntryWriter(file.file.nn.toPath) - else throw new IllegalStateException(s"don't know how to handle an output of $file [${file.getClass}]") - } - - private final class JarEntryWriter(file: AbstractFile, mainClass: Option[String], compressionLevel: Int) extends FileWriter { - //keep these imports local - avoid confusion with scala naming - import java.util.jar.Attributes.Name.{MANIFEST_VERSION, MAIN_CLASS} - import java.util.jar.{JarOutputStream, Manifest} - - val storeOnly = compressionLevel == Deflater.NO_COMPRESSION - - val jarWriter: JarOutputStream = { - import scala.util.Properties.* - val manifest = new Manifest - val attrs = manifest.getMainAttributes - attrs.put(MANIFEST_VERSION, "1.0") - attrs.put(ScalaCompilerVersion, versionNumberString) - mainClass.foreach(c => attrs.put(MAIN_CLASS, c)) - - val jar = new JarOutputStream(new BufferedOutputStream(new FileOutputStream(file.file), 64000), manifest) - jar.setLevel(compressionLevel) - if (storeOnly) jar.setMethod(ZipOutputStream.STORED) - jar - } - - lazy val crc = new CRC32 - - override def writeFile(relativePath: String, bytes: Array[Byte]): AbstractFile = this.synchronized { - val entry = new ZipEntry(relativePath) - if (storeOnly) { - // When using compression method `STORED`, the ZIP spec requires the CRC and compressed/ - // uncompressed sizes to be written before the data. The JarOutputStream could compute the - // values while writing the data, but not patch them into the stream after the fact. So we - // need to pre-compute them here. The compressed size is taken from size. - // https://stackoverflow.com/questions/1206970/how-to-create-uncompressed-zip-archive-in-java/5868403 - // With compression method `DEFLATED` JarOutputStream computes and sets the values. - entry.setSize(bytes.length) - crc.reset() - crc.update(bytes) - entry.setCrc(crc.getValue) - } - jarWriter.putNextEntry(entry) - try jarWriter.write(bytes, 0, bytes.length) - finally jarWriter.flush() - // important detail here, even on Windows, Zinc expects the separator within the jar - // to be the system default, (even if in the actual jar file the entry always uses '/'). - // see https://github.com/sbt/zinc/blob/dcddc1f9cfe542d738582c43f4840e17c053ce81/internal/compiler-bridge/src/main/scala/xsbt/JarUtils.scala#L47 - val pathInJar = - if File.separatorChar == '/' then relativePath - else relativePath.replace('/', File.separatorChar) - PlainFile.toPlainFile(Paths.get(s"${file.absolutePath}!$pathInJar")) - } - - override def close(): Unit = this.synchronized(jarWriter.close()) - } - - private final class DirEntryWriter(base: Path) extends FileWriter { - val builtPaths = new ConcurrentHashMap[Path, java.lang.Boolean]() - val noAttributes = Array.empty[FileAttribute[?]] - private val isWindows = scala.util.Properties.isWin - - private def checkName(component: Path): Unit = if (isWindows) { - val specials = raw"(?i)CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9]".r - val name = component.toString - def warnSpecial(): Unit = report.warning(em"path component is special Windows device: ${name}") - specials.findPrefixOf(name).foreach(prefix => if (prefix.length == name.length || name(prefix.length) == '.') warnSpecial()) - } - - def ensureDirForPath(baseDir: Path, filePath: Path): Unit = { - import java.lang.Boolean.TRUE - val parent = filePath.getParent - if (!builtPaths.containsKey(parent)) { - parent.iterator.forEachRemaining(checkName) - try Files.createDirectories(parent, noAttributes*) - catch { - case e: FileAlreadyExistsException => - // `createDirectories` reports this exception if `parent` is an existing symlink to a directory - // but that's fine for us (and common enough, `scalac -d /tmp` on mac targets symlink). - if (!Files.isDirectory(parent)) - throw new FileConflictException(s"Can't create directory $parent; there is an existing (non-directory) file in its path", e) - } - builtPaths.put(baseDir, TRUE) - var current = parent - while ((current ne null) && (null ne builtPaths.put(current, TRUE))) { - current = current.getParent - } - } - checkName(filePath.getFileName()) - } - - // the common case is that we are are creating a new file, and on MS Windows the create and truncate is expensive - // because there is not an options in the windows API that corresponds to this so the truncate is applied as a separate call - // even if the file is new. - // as this is rare, its best to always try to create a new file, and it that fails, then open with truncate if that fails - - private val fastOpenOptions = util.EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE) - private val fallbackOpenOptions = util.EnumSet.of(StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING) - - override def writeFile(relativePath: String, bytes: Array[Byte]): AbstractFile = { - val path = base.resolve(relativePath) - try { - ensureDirForPath(base, path) - val os = if (isWindows) { - try FileChannel.open(path, fastOpenOptions) - catch { - case _: FileAlreadyExistsException => FileChannel.open(path, fallbackOpenOptions) - } - } else FileChannel.open(path, fallbackOpenOptions) - - try os.write(ByteBuffer.wrap(bytes), 0L) - catch { - case ex: ClosedByInterruptException => - try Files.deleteIfExists(path) // don't leave a empty of half-written classfile around after an interrupt - catch { case _: Throwable => () } - throw ex - } - os.close() - } catch { - case e: FileConflictException => - report.error(em"error writing ${path.toString}: ${e.getMessage}") - case e: java.nio.file.FileSystemException => - if (compilerSettings.debug) e.printStackTrace() - report.error(em"error writing ${path.toString}: ${e.getClass.getName} ${e.getMessage}") - } - AbstractFile.getFile(path) - } - - override def close(): Unit = () - } - - private final class VirtualFileWriter(base: AbstractFile) extends FileWriter { - private def getFile(base: AbstractFile, path: String): AbstractFile = { - def ensureDirectory(dir: AbstractFile): AbstractFile = - if (dir.isDirectory) dir - else throw new FileConflictException(s"${base.path}/${path}: ${dir.path} is not a directory") - val components = path.split('/') - var dir = base - for i <- 0 until components.length - 1 do - dir = ensureDirectory(dir).subdirectoryNamed(components(i).toString) - ensureDirectory(dir).fileNamed(components.last.toString) - } - - private def writeBytes(outFile: AbstractFile, bytes: Array[Byte]): Unit = { - val out = new DataOutputStream(outFile.bufferedOutput) - try out.write(bytes, 0, bytes.length) - finally out.close() - } - - override def writeFile(relativePath: String, bytes: Array[Byte]): AbstractFile = { - val outFile = getFile(base, relativePath) - writeBytes(outFile, bytes) - outFile - } - override def close(): Unit = () - } - - /** Can't output a file due to the state of the file system. */ - class FileConflictException(msg: String, cause: Throwable | Null = null) extends IOException(msg, cause) -} diff --git a/compiler/src/dotty/tools/backend/jvm/CodeGen.scala b/compiler/src/dotty/tools/backend/jvm/CodeGen.scala index 201dcae9e63d..1947e16a9313 100644 --- a/compiler/src/dotty/tools/backend/jvm/CodeGen.scala +++ b/compiler/src/dotty/tools/backend/jvm/CodeGen.scala @@ -1,15 +1,11 @@ package dotty.tools.backend.jvm -import dotty.tools.dotc.CompilationUnit import dotty.tools.dotc.ast.Trees.{PackageDef, ValDef} import dotty.tools.dotc.ast.tpd import scala.collection.mutable -import dotty.tools.dotc.interfaces -import dotty.tools.dotc.report - -import java.util.Optional +import dotty.tools.dotc.{CompilationUnit, interfaces, report, util} import dotty.tools.dotc.sbt.ExtractDependencies import dotty.tools.dotc.core.* import Contexts.* @@ -22,18 +18,18 @@ import dotty.tools.dotc.core.tasty.TastyUnpickler import scala.tools.asm.tree.* import tpd.* import dotty.tools.io.AbstractFile -import dotty.tools.dotc.util import dotty.tools.dotc.ast.Positioned import dotty.tools.dotc.util.NoSourcePosition import SymbolUtils.given import dotty.tools.backend.ScalaPrimitives +import dotty.tools.dotc.interfaces.CompilerCallback import opt.CallGraph -class CodeGen(val backendUtils: BackendUtils, val primitives: ScalaPrimitives, val frontendAccess: PostProcessorFrontendAccess, val callGraph: CallGraph, val ts: CoreBTypes)(using Context) { - private class Impl(using Context) extends BCodeHelpers(backendUtils), BCodeSkelBuilder, BCodeBodyBuilder(primitives), BCodeSyncAndTry { - val ts: CoreBTypes = CodeGen.this.ts - - def recordCallsitePosition(m: MethodInsnNode, pos: Positioned | Null): Unit = +class CodeGen(val backendUtils: BackendUtils, val primitives: ScalaPrimitives, val frontendAccess: PostProcessorFrontendAccess, + val callGraph: CallGraph, val bTypeLoader: BTypeLoader, val bTypes: WellKnownBTypes, + val generatedClassHandler: GeneratedClassHandler) { + private class Impl extends BCodeHelpers(bTypeLoader, bTypes), BCodeBodyBuilder(primitives), BCodeSyncAndTry { + def recordCallsitePosition(m: MethodInsnNode, pos: Positioned | Null)(using Context): Unit = callGraph.callsitePositions.get(m) = pos match { case p: Positioned => p.sourcePos case null => NoSourcePosition @@ -43,28 +39,22 @@ class CodeGen(val backendUtils: BackendUtils, val primitives: ScalaPrimitives, v private lazy val mirrorCodeGen = impl.JMirrorBuilder() - private def genBCode(using Context) = Phases.genBCodePhase.asInstanceOf[GenBCode] - private def postProcessor(using Context) = genBCode.postProcessor - private def generatedClassHandler(using Context) = genBCode.generatedClassHandler - /** - * Generate ASM ClassNodes for classes found in a compilation unit. The resulting classes are - * passed to the `GenBCode.generatedClassHandler`. + * Generate ASM ClassNodes for classes found in the context's compilation unit. The resulting classes are + * passed to the `generatedClassHandler`. */ - def genUnit(unit: CompilationUnit)(using ctx: Context): Unit = { + def genUnit()(using ctx: Context): Unit = { val generatedClasses = mutable.ListBuffer.empty[GeneratedClass] val generatedTasty = mutable.ListBuffer.empty[GeneratedTasty] def genClassDef(cd: TypeDef): Unit = try val sym = cd.symbol - val sourceFile = unit.source.file - - - val mainClassNode = genClass(cd, unit) + val sourceFile = ctx.compilationUnit.source.file + val mainClassNode = genClass(cd) val mirrorClassNode = if !sym.isTopLevelModuleClass then null - else if sym.companionClass == NoSymbol then genMirrorClass(sym, unit) + else if sym.companionClass == NoSymbol then mirrorCodeGen.genMirrorClass(sym) else report.log(s"No mirror class for module with linked class: ${sym.fullName}", NoSourcePosition) null @@ -79,21 +69,17 @@ class CodeGen(val backendUtils: BackendUtils, val primitives: ScalaPrimitives, v sourceClassName = sym.javaClassName, position = sym.srcPos.sourcePos, isArtifact = isArtifact, - onFileCreated = onFileCreated(classNode, sym, unit.source) + onFileCreated = onFileCreated(classNode, sym, ctx.compilationUnit.source) ) registerGeneratedClass(mainClassNode, isArtifact = false) registerGeneratedClass(mirrorClassNode, isArtifact = true) catch - case ex: InterruptedException => throw ex - case ex: CompilationUnit.SuspendException => throw ex - case ex: Throwable => - if !ex.isInstanceOf[TypeError] then ex.printStackTrace() - report.error(s"Error while emitting ${unit.source}\n${ex.getMessage}", cd.sourcePos) - + case ex: TypeError => + report.error(s"Error while emitting ${ctx.compilationUnit.source}\n${ex.getMessage}", cd.sourcePos) def genTastyAndSetAttributes(claszSymbol: Symbol, store: ClassNode): Unit = - for (binary <- unit.pickled.get(claszSymbol.asClass)) { + for (binary <- ctx.compilationUnit.pickled.get(claszSymbol.asClass)) { generatedTasty += GeneratedTasty(store, binary) val tasty = val uuid = new TastyHeaderUnpickler(TastyUnpickler.scala3CompilerConfig, binary()).readHeader() @@ -116,12 +102,12 @@ class CodeGen(val backendUtils: BackendUtils, val primitives: ScalaPrimitives, v case EmptyTree => () case PackageDef(_, stats) => stats.foreach(genClassDefs) case ValDef(_, _, _) => () // module val not emitted - case td: TypeDef => frontendAccess.frontendSynch(genClassDef(td)) + case td: TypeDef => genClassDef(td) } - genClassDefs(unit.tpdTree) + genClassDefs(ctx.compilationUnit.tpdTree) generatedClassHandler.process( - GeneratedCompilationUnit(unit.source.file, generatedClasses.toList, generatedTasty.toList) + GeneratedCompilationUnit(ctx.compilationUnit.source.file, generatedClasses.toList, generatedTasty.toList) ) } @@ -132,8 +118,9 @@ class CodeGen(val backendUtils: BackendUtils, val primitives: ScalaPrimitives, v } clsFile => { val className = cls.name.replace('/', '.') - if (ctx.compilerCallback ne null) - ctx.compilerCallback.onClassGenerated(sourceFile, convertAbstractFile(clsFile), className) + ctx.compilerCallback match + case cb: CompilerCallback => cb.onClassGenerated(sourceFile, clsFile, className) + case null => () ctx.withIncCallback: cb => if isLocal then @@ -147,24 +134,10 @@ class CodeGen(val backendUtils: BackendUtils, val primitives: ScalaPrimitives, v } } - /** Convert a `dotty.tools.io.AbstractFile` into a - * `dotty.tools.dotc.interfaces.AbstractFile`. - */ - private def convertAbstractFile(absfile: dotty.tools.io.AbstractFile): interfaces.AbstractFile = - new interfaces.AbstractFile { - override def name = absfile.name - override def path = absfile.path - override def jfile: Optional[java.io.File] = Optional.ofNullable(absfile.file) - } - - private def genClass(cd: TypeDef, unit: CompilationUnit): ClassNode = { - val b = new impl.SyncAndTryBuilder(unit) + private def genClass(cd: TypeDef)(using Context): ClassNode = { + val b = new impl.SyncAndTryBuilder b.genPlainClass(cd) b.cnode } - private def genMirrorClass(classSym: Symbol, unit: CompilationUnit): ClassNode = { - mirrorCodeGen.genMirrorClass(classSym, unit) - } - } diff --git a/compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala b/compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala deleted file mode 100644 index b34c6e30d002..000000000000 --- a/compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala +++ /dev/null @@ -1,230 +0,0 @@ -package dotty.tools -package backend -package jvm - -import java.util.concurrent.ConcurrentHashMap -import BTypes.InternalName -import dotty.tools.dotc.core.Symbols.{Symbol, defn} -import dotty.tools.dotc.core.Contexts.{Context, ctx} -import dotty.tools.backend.jvm.PostProcessorFrontendAccess.Lazy -import dotty.tools.dotc.core.Flags.{JavaDefined, Method, ModuleClass} -import dotty.tools.dotc.core.Types -import dotty.tools.dotc.core.Types.{AnnotatedType, JavaArrayType, RefinedType, SingletonType, ThisType, Type, TypeRef} -import dotty.tools.dotc.report - -import scala.tools.asm.Handle - -case class MethodNameAndType(name: String, methodType: MethodBType) - -abstract class CoreBTypes(private val frontendAccess: PostProcessorFrontendAccess)(using ctx: Context) { - def primitiveTypeMap: Map[Symbol, PrimitiveBType] - - def boxedClasses: Set[ClassBType] - - def boxedClassOfPrimitive: Map[PrimitiveBType, ClassBType] - - def boxResultType: Map[Symbol, ClassBType] - - def unboxResultType: Map[Symbol, PrimitiveBType] - - def srNothingRef : ClassBType - def srNullRef : ClassBType - - def ObjectRef : ClassBType - def StringRef : ClassBType - def PredefRef : ClassBType - def jlClassRef : ClassBType - def jlThrowableRef : ClassBType - def jlCloneableRef : ClassBType - def jiSerializableRef : ClassBType - def jlClassCastExceptionRef : ClassBType - def jlIllegalArgExceptionRef : ClassBType - def jliSerializedLambdaRef : ClassBType - def jliMethodHandleRef: ClassBType - - def srBoxesRuntimeRef : ClassBType - def srBoxedUnitRef : ClassBType - def srBoxesRuntimeBoxToMethods : Map[BType, MethodNameAndType] - def srBoxesRuntimeUnboxToMethods : Map[BType, MethodNameAndType] - - def javaBoxMethods : Map[InternalName, MethodNameAndType] - def javaUnboxMethods : Map[InternalName, MethodNameAndType] - - def predefAutoBoxMethods : Map[String, MethodBType] - def predefAutoUnboxMethods : Map[String, MethodBType] - - def srRefCreateMethods : Map[InternalName, MethodNameAndType] - def srRefZeroMethods : Map[InternalName, MethodNameAndType] - - def primitiveBoxConstructors : Map[InternalName, MethodNameAndType] - def srRefConstructors : Map[InternalName, MethodNameAndType] - def tupleClassConstructors : Map[InternalName, MethodNameAndType] - - def jliLambdaMetaFactoryMetafactoryHandle : Handle - def jliLambdaMetaFactoryAltMetafactoryHandle : Handle - def jliLambdaDeserializeBootstrapHandle : Handle - def jliStringConcatFactoryMakeConcatWithConstantsHandle: Handle - - def asmBoxTo : Map[BType, MethodNameAndType] - def asmUnboxTo: Map[BType, MethodNameAndType] - - def typeOfArrayOp: Map[Int, BType] - - // Concurrent maps because stack map frames are computed when in the class writer, which - // might run on multiple classes concurrently. - private val classBTypeCache: Lazy[ConcurrentHashMap[InternalName, ClassBType]] = - frontendAccess.perRunLazy(new ConcurrentHashMap[InternalName, ClassBType]) - - /** See doc of ClassBType.apply. This is where to use that method from. */ - def classBType[T](internalName: InternalName)(init: ClassBType => Either[T, ClassInfo]): Either[T, ClassBType] = - ClassBType(internalName, this, classBTypeCache.get)(init) - - /** See doc of ClassBType.apply. This is where to use that method from. Version that cannot fail. */ - def classBType(internalName: InternalName)(init: ClassBType => ClassInfo): ClassBType = - ClassBType(internalName, this, classBTypeCache.get)(ct => Right(init(ct))).fold(_ => assert(false), identity) - - /** Obtain a previously constructed ClassBType for a given internal name, or None if no such ClassBType was constructed. */ - def classBTypeFromInternalName(internalName: InternalName): Option[ClassBType] = - Option(classBTypeCache.get.get(internalName)) - - def classBTypeFromSymbol(classSym: Symbol): ClassBType - def mirrorClassBTypeFromSymbol(moduleClassSym: Symbol): ClassBType - - /** - * The class internal name for a given class symbol. - */ - final def internalName(sym: Symbol)(using Context): String = { - // For each java class, the scala compiler creates a class and a module (thus a module class). - // If the `sym` is a java module class, we use the java class instead. This ensures that the - // ClassBType is created from the main class (instead of the module class). - // The two symbols have the same name, so the resulting internalName is the same. - val classSym = if (sym.is(JavaDefined) && sym.is(ModuleClass)) sym.linkedClass else sym - getClassBType(classSym).internalName - } - - private def assertClassNotArray(sym: Symbol)(using Context): Unit = { - assert(sym.isClass, sym) - assert(sym != defn.ArrayClass || BackendUtils.compilingArray, sym) - } - - private def assertClassNotArrayNotPrimitive(sym: Symbol)(using Context): Unit = { - assertClassNotArray(sym) - assert(!primitiveTypeMap.contains(sym) || BackendUtils.compilingPrimitive, sym) - } - - /** - * The ClassBType for a class symbol. - * - * The class symbol scala.Nothing is mapped to the class scala.runtime.Nothing$. Similarly, - * scala.Null is mapped to scala.runtime.Null$. This is because there exist no class files - * for the Nothing / Null. If used for example as a parameter type, we use the runtime classes - * in the classfile method signature. - * - * Note that the referenced class symbol may be an implementation class. For example when - * compiling a mixed-in method that forwards to the static method in the implementation class, - * the class descriptor of the receiver (the implementation class) is obtained by creating the - * ClassBType. - */ - final def getClassBType(sym: Symbol)(using Context): ClassBType = { - assertClassNotArrayNotPrimitive(sym) - - if (sym == defn.NothingClass) srNothingRef - else if (sym == defn.NullClass) srNullRef - else classBTypeFromSymbol(sym) - } - - /* - * must-single-thread - */ - final def asmMethodType(msym: Symbol)(using Context): MethodBType = { - assert(msym.is(Method), s"not a method-symbol: $msym") - val resT: BType = - if (msym.isClassConstructor || msym.isConstructor) UNIT - else toTypeKind(msym.info.resultType) - MethodBType(msym.info.firstParamTypes.map(toTypeKind), resT) - } - - /** - * The jvm descriptor of a type. - */ - final def typeDescriptor(t: Type): String = { - toTypeKind(t).descriptor - } - - /** - * The jvm descriptor for a symbol. - */ - final def symDescriptor(sym: Symbol)(using Context): String = getClassBType(sym).descriptor - - final def toTypeKind(tp: Type)(using Context): BType = typeToTypeKind(tp) - - /** - * This method returns the BType for a type reference, for example a parameter type. - * - * If the result is a ClassBType for a nested class, it is added to the innerClassBufferASM. - * - * If `t` references a class, toTypeKind ensures that the class is not an implementation class. - * See also comment on getClassBTypeAndRegisterInnerClass, which is invoked for implementation - * classes. - */ - final def typeToTypeKind(tp: Type)(using Context): BType = { - val defn = ctx.definitions - - /** - * Primitive types are represented as TypeRefs to the class symbol of, for example, scala.Int. - * The `primitiveTypeMap` maps those class symbols to the corresponding PrimitiveBType. - */ - def primitiveOrClassToBType(sym: Symbol): BType = { - assert(sym.isClass, sym) - assert(sym != defn.ArrayClass || BackendUtils.compilingArray, sym) - primitiveTypeMap.getOrElse(sym, getClassBType(sym)) - } - - /** - * When compiling Array.scala, the type parameter T is not erased and shows up in method - * signatures, e.g. `def apply(i: Int): T`. A TyperRef to T is replaced by ObjectReference. - */ - def nonClassTypeRefToBType(sym: Symbol): ClassBType = { - assert(sym.isType && BackendUtils.compilingArray, sym) - ObjectRef - } - - tp.widenDealias match { - case JavaArrayType(el) => ArrayBType(typeToTypeKind(el)) // Array type such as Array[Int] (kept by erasure) - case t: TypeRef => - t.info match { - - case _ => - if (!t.symbol.isClass) nonClassTypeRefToBType(t.symbol) // See comment on nonClassTypeRefToBType - else primitiveOrClassToBType(t.symbol) // Common reference to a type such as scala.Int or java.lang.String - } - case Types.ClassInfo(_, sym, _, _, _) => primitiveOrClassToBType(sym) // We get here, for example, for genLoadModule, which invokes toTypeKind(moduleClassSymbol.info) - - /* AnnotatedType should (probably) be eliminated by erasure. However, we know it happens for - * meta-annotated annotations (@(ann @getter) val x = 0), so we don't emit a warning. - * The type in the AnnotationInfo is an AnnotatedTpe. Tested in jvm/annotations.scala. - */ - case a@AnnotatedType(t, _) => - report.debuglog(s"typeKind of annotated type $a") - typeToTypeKind(t) - - /* The cases below should probably never occur. They are kept for now to avoid introducing - * new compiler crashes, but we added a warning. The compiler / library bootstrap and the - * test suite don't produce any warning. - */ - - case tp => - report.warning( - s"an unexpected type representation reached the compiler backend while compiling ${ctx.compilationUnit}: $tp. " + - "If possible, please file a bug on https://github.com/scala/scala3/issues") - - tp match { - case tp: ThisType if tp.cls == defn.ArrayClass => ObjectRef // was introduced in 9b17332f11 to fix SI-999, but this code is not reached in its test, or any other test - case tp: ThisType => getClassBType(tp.cls) - // case t: SingletonType => primitiveOrClassToBType(t.classSymbol) - case t: SingletonType => typeToTypeKind(t.underlying) - case t: RefinedType => typeToTypeKind(t.parent) - } - } - } -} \ No newline at end of file diff --git a/compiler/src/dotty/tools/backend/jvm/CoreBTypesFromSymbols.scala b/compiler/src/dotty/tools/backend/jvm/CoreBTypesFromSymbols.scala deleted file mode 100644 index 2be3ac755353..000000000000 --- a/compiler/src/dotty/tools/backend/jvm/CoreBTypesFromSymbols.scala +++ /dev/null @@ -1,665 +0,0 @@ -package dotty.tools.backend.jvm - -import dotty.tools.dotc.core.Symbols.* -import dotty.tools.dotc.transform.Erasure - -import scala.tools.asm.{Handle, Opcodes} -import dotty.tools.dotc.core.{StdNames, Symbols} -import BTypes.* -import dotty.tools.dotc.core.Contexts.{Context, atPhase} -import dotty.tools.dotc.core.Names.* -import dotty.tools.dotc.core.StdNames.* -import BCodeAsmCommon.* -import dotty.tools.dotc.core.Flags.{Final, JavaDefined, Method, ModuleClass, ModuleVal, PackageClass, Trait} -import dotty.tools.dotc.core.Phases.{Phase, flattenPhase, lambdaLiftPhase, picklerPhase} -import SymbolUtils.given -import PostProcessorFrontendAccess.Lazy -import dotty.tools.backend.ScalaPrimitives -import dotty.tools.dotc.core.Decorators.toTermName -import dotty.tools.dotc.core.Types.abstractTermNameFilter - -import scala.tools.asm - -final class CoreBTypesFromSymbols(ppa: PostProcessorFrontendAccess, primitives: ScalaPrimitives, inlineInfoLoader: () => Option[InlineInfoLoader])(using val ctx: Context) extends CoreBTypes(ppa) { - /** - * The ClassBType for a class symbol `sym`. - */ - def classBTypeFromSymbol(classSym: Symbol): ClassBType = { - assert(classSym != NoSymbol, "Cannot create ClassBType from NoSymbol") - assert(classSym.isClass, s"Cannot create ClassBType from non-class symbol $classSym") - assert( - classSym != defn.NothingClass && classSym != defn.NullClass, - s"Cannot create ClassBType for special class symbol ${classSym.showFullName}") - - classBType(classSym.javaBinaryName)(ct => createClassInfo(ct, classSym.asClass)) - } - - def mirrorClassBTypeFromSymbol(moduleClassSym: Symbol): ClassBType = { - assert(moduleClassSym.isTopLevelModuleClass, s"not a top-level module class: $moduleClassSym") - val internalName = moduleClassSym.javaBinaryName.stripSuffix(StdNames.str.MODULE_SUFFIX) - classBType(internalName)(_ => - ClassInfo( - superClass = Some(ObjectRef), - interfaces = Nil, - flags = asm.Opcodes.ACC_SUPER | asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_FINAL, - nestedClasses = getMemberClasses(moduleClassSym).map(classBTypeFromSymbol), - nestedInfo = None, - inlineInfo = InlineInfo.empty - ) - ) - } - - private def createClassInfo(classBType: ClassBType, classSym: Symbol): ClassInfo = { - val superClassSym: Symbol = { - val t = classSym.asClass.superClass - if (t.exists) t - else if (classSym.is(ModuleClass)) { - // workaround #371 - - println(s"Warning: mocking up superclass for $classSym") - defn.ObjectClass - } - else t - } - assert( - if (classSym == defn.ObjectClass) - superClassSym == NoSymbol - else if (classSym.is(Trait)) - superClassSym == defn.ObjectClass - else - // A ClassBType for a primitive class (scala.Boolean et al.) is only created when compiling these classes. - ((superClassSym != NoSymbol) && !superClassSym.is(Trait)) || primitiveTypeMap.contains(classSym), - s"Bad superClass for $classSym: $superClassSym" - ) - val superClass = if (superClassSym == NoSymbol) None - else Some(classBTypeFromSymbol(superClassSym)) - - // List only directly inherited interfaces. - // This is not only a performance optimization (as the JVM needs to handle fewer inheritance declarations), - // but also required for correctness in the presence of sealed interfaces (see i23479): - // if `C` inherits from `non-sealed A` which itself inherits from `sealed B permits A`, then having `C` inherit from `B` directly is illegal. - val allBaseClasses = classSym.directlyInheritedTraits.iterator.flatMap(_.asClass.baseClasses.drop(1)).toSet - val interfaces = classSym.directlyInheritedTraits.filter(!allBaseClasses(_)).map(classBTypeFromSymbol) - - val flags = BCodeUtils.javaFlags(classSym) - - /* The InnerClass table of a class C must contain all nested classes of C, even if they are only - * declared but not otherwise referenced in C (from the bytecode or a method / field signature). - * We collect them here. - */ - val nestedClassSymbols = { - // The lambdalift phase lifts all nested classes to the enclosing class, so if we collect - // member classes right after lambdalift, we obtain all nested classes, including local and - // anonymous ones. - val nestedClasses = getNestedClasses(classSym) - - // If this is a top-level class, and it has a companion object, the member classes of the - // companion are added as members of the class. For example: - // class C { } - // object C { - // class D - // def f = { class E } - // } - // The class D is added as a member of class C. The reason is that the InnerClass attribute - // for D will containt class "C" and NOT the module class "C$" as the outer class of D. - // This is done by buildNestedInfo, the reason is Java compatibility, see comment in BTypes. - // For consistency, the InnerClass entry for D needs to be present in C - to Java it looks - // like D is a member of C, not C$. - val linkedClass = classSym.linkedClass - val companionModuleMembers = { - if (classSym.linkedClass.isTopLevelModuleClass) getMemberClasses(classSym.linkedClass) - else Nil - } - - nestedClasses ++ companionModuleMembers - } - - /** - * For nested java classes, the scala compiler creates both a class and a module (and therefore - * a module class) symbol. For example, in `class A { class B {} }`, the nestedClassSymbols - * for A contain both the class B and the module class B. - * Here we get rid of the module class B, making sure that the class B is present. - */ - val nestedClassSymbolsNoJavaModuleClasses = nestedClassSymbols.filter(s => { - if (s.is(JavaDefined) && s.is(ModuleClass)) { - // We could also search in nestedClassSymbols for s.linkedClassOfClass, but sometimes that - // returns NoSymbol, so it doesn't work. - val nb = nestedClassSymbols.count(mc => mc.name == s.name && mc.owner == s.owner) - // this assertion is specific to how ScalaC works. It doesn't apply to dotty, as n dotty there will be B & B$ - // assert(nb == 2, s"Java member module without member class: $s - $nestedClassSymbols") - false - } else true - }) - - val memberClasses = nestedClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol) - - val nestedInfo = buildNestedInfo(classSym) - - val inlineInfo = inlineInfoLoader() match { - case Some(loader) => buildInlineInfo(loader, classSym.asClass, classBType.internalName) - case None => InlineInfo.empty - } - - ClassInfo(superClass, interfaces, flags, memberClasses, nestedInfo, inlineInfo) - } - - /** For currently compiled classes: All locally defined classes including local classes. - * The empty list for classes that are not currently compiled. - */ - private def getNestedClasses(sym: Symbol): List[Symbol] = definedClasses(sym, flattenPhase) - - /** For currently compiled classes: All classes that are declared as members of this class - * (but not inherited ones). The empty list for classes that are not currently compiled. - */ - private def getMemberClasses(sym: Symbol): List[Symbol] = definedClasses(sym, lambdaLiftPhase) - - private def definedClasses(sym: Symbol, phase: Phase) = - if (sym.isDefinedInCurrentRun) - atPhase(phase) { - toDenot(sym).info.decls.filter(sym => sym.isClass && !sym.isEffectivelyErased) - } - else Nil - - private def buildNestedInfo(innerClassSym: Symbol): Option[NestedInfo] = { - assert(innerClassSym.isClass, s"Cannot build NestedInfo for non-class symbol $innerClassSym") - - val isNested = !innerClassSym.originalOwner.originalLexicallyEnclosingClass.is(PackageClass) - if (!isNested) None - else { - // See comment in BTypes, when is a class marked static in the InnerClass table. - val isStaticNestedClass = innerClassSym.originalOwner.originalLexicallyEnclosingClass.isOriginallyStaticOwner - - // After lambdalift (which is where we are), the rawowoner field contains the enclosing class. - val enclosingClassSym = { - if (innerClassSym.isClass) { - atPhase(flattenPhase.prev) { - toDenot(innerClassSym).owner.enclosingClass - } - } - else atPhase(flattenPhase.prev)(innerClassSym.enclosingClass) - } //todo is handled specially for JavaDefined symbols in scalac - - val enclosingClass: ClassBType = classBTypeFromSymbol(enclosingClassSym) - - val outerName: Option[String] = { - if (isAnonymousOrLocalClass(innerClassSym)) { - None - } else { - val outerName = innerClassSym.originalOwner.originalLexicallyEnclosingClass.javaBinaryName - - def dropModule(str: String): String = - if (str.nonEmpty && str.last == '$') str.take(str.length - 1) else str - - // Java compatibility. See the big comment in BTypes that summarizes the InnerClass spec. - val outerNameModule = - if (innerClassSym.originalOwner.originalLexicallyEnclosingClass.isTopLevelModuleClass) dropModule(outerName) - else outerName - Some(outerNameModule) - } - } - - val innerName: Option[String] = { - if (innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction) None - else { - val original = innerClassSym.initial - Some(atPhase(original.validFor.lastPhaseId)(innerClassSym.name).mangledString) // moduleSuffix for module classes - } - } - - Some(NestedInfo(enclosingClass, outerName, innerName, isStaticNestedClass)) - } - } - - /* - * Note that the InlineInfo is only built from the symbolic information for classes that are being - * compiled. For all other classes we delegate to inlineInfoFromClassfile. The reason is that - * mixed-in methods are only added to class symbols being compiled, but not to other classes - * extending traits. Creating the InlineInfo from the symbol would prevent these mixins from being - * inlined. - * - * So for classes being compiled, the InlineInfo is created here and stored in the ScalaInlineInfo - * classfile attribute. - */ - private def buildInlineInfo(inlineInfoLoader: InlineInfoLoader, classSym: ClassSymbol, internalName: InternalName): InlineInfo = { - // phase travel required (or at least it was in Scala 2). for nested classes, it checks if the - // enclosingTopLevelClass is being compiled. after flatten, all classes are considered top-level, - // so it would return `false`. - if atPhase(picklerPhase.next) { - classSym.isDefinedInCurrentRun - } then buildInlineInfoFromClassSymbol(classSym) // // InlineInfo required for classes being compiled, we have to create the classfile attribute - // For classes not being compiled, the InlineInfo is read from the classfile attribute. This - // fixes an issue with mixed-in methods: the mixin phase enters mixin methods only to class - // symbols being compiled. For non-compiled classes, we could not build MethodInlineInfos - // for those mixin members, which prevents inlining. - else inlineInfoLoader.loadInlineInfoFor(internalName) - } - - /** - * Build the [[InlineInfo]] for a class symbol. - */ - private def buildInlineInfoFromClassSymbol(classSym: ClassSymbol): InlineInfo = { - // We only want an approximation of SAMs for inlining heuristics, no need to check FunctionalInterface annotations or such - val abstractMembers = classSym.memberNames(abstractTermNameFilter).iterator.map(classSym.classInfo.member).map(_.symbol).filter(_.is(Method)).toList - val sam = abstractMembers match - case List(single) => - val btype = asmMethodType(single) - Some(single.javaSimpleName + btype.descriptor) - case _ => None - - def keepMember(sym: Symbol) = sym.is(Method) && !primitives.isPrimitive(sym) - - val classMethods = classSym.info.decls.iterator.filter(keepMember) - val methods = if classSym.is(JavaDefined) then - // Phase travel important for nested classes (scala-dev#402). When a java class symbol A$B - // is compiled from source, this ensures that `companionModule` doesn't return the `A$B` - // symbol created for the `A$B.class` file on the classpath, which might be different. - val companion = atPhase(picklerPhase.next) { - classSym.companionModule - } - val staticMethods = companion.info.decls.iterator.filter(m => !m.isConstructor && keepMember(m)) - staticMethods ++ classMethods - else - val staticForwarders = if classSym.is(Trait) then - // !!! This logic duplicates PlainSkelBuilder::makeStaticForwarder, copy changes there !!! - classSym.info.decls.filter(s => s.isTerm && !s.isPrivate && !s.isStaticMember && s.name != nme.TRAIT_CONSTRUCTOR).map(s => { - BackendUtils.makeStatifiedDefSymbol(s.asTerm, BackendUtils.traitSuperAccessorName(s).toTermName) - }) - else Nil - classMethods ++ staticForwarders - - // Primitive methods cannot be inlined, so there's no point in building a MethodInlineInfo. Also, some - // primitive methods (e.g., `isInstanceOf`) have non-erased types, which confuses [[typeToBType]]. - val methodInlineInfos = new collection.mutable.TreeMap[(String, String), MethodInlineInfo]() - methods.foreach { - methodSym => - val name = methodSym.javaSimpleName // same as in genDefDef - val signature = (name, asmMethodType(methodSym).descriptor) - - // In a trait, accesses to "modules" like enums are translated by the frontend as final methods, - // even though they are logically not final since classes implementing the trait will also have that method, - // so we must explicitly consider them to be non-final. - // TODO: This feels like something fundamentally weird in trees that should not exist. - val info = MethodInlineInfo( - effectivelyFinal = methodSym.isEffectivelyFinal && !methodSym.is(ModuleVal), - annotatedInline = methodSym.hasAnnotation(defn.InlineAnnot), - annotatedNoInline = methodSym.hasAnnotation(defn.NoInlineAnnot)) - - methodInlineInfos(signature) = info - } - - // if we have a symbol, we're compiling the class, so we assume it's accessible - InlineInfo(classSym.is(Final), sam, methodInlineInfos, None, isAccessible = true) - } - - /** - * This is basically a re-implementation of sym.isStaticOwner, but using the originalOwner chain. - * - * The problem is that we are interested in a source-level property. Various phases changed the - * symbol's properties in the meantime, mostly lambdalift modified (destructively) the owner. - * Therefore, `sym.isStatic` is not what we want. For example, in - * object T { def f { object U } } - * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here. - */ - extension (sym: Symbol) - private def isOriginallyStaticOwner: Boolean = - sym.is(PackageClass) || sym.is(ModuleClass) && sym.originalOwner.originalLexicallyEnclosingClass.isOriginallyStaticOwner - - - /** - * Maps primitive types to their corresponding PrimitiveBType. The map is defined lexically above - * the first use of `classBTypeFromSymbol` because that method looks at the map. - */ - override def primitiveTypeMap: Map[Symbol, PrimitiveBType] = _primitiveTypeMap.get - private lazy val _primitiveTypeMap: Lazy[Map[Symbol, PrimitiveBType]] = ppa.perRunLazy: - Map( - defn.UnitClass -> UNIT, - defn.BooleanClass -> BOOL, - defn.CharClass -> CHAR, - defn.ByteClass -> BYTE, - defn.ShortClass -> SHORT, - defn.IntClass -> INT, - defn.LongClass -> LONG, - defn.FloatClass -> FLOAT, - defn.DoubleClass -> DOUBLE - ) - - /** - * Map from primitive types to their boxed class type. Useful when pushing class literals onto the - * operand stack (ldc instruction taking a class literal), see genConstant. - */ - override def boxedClassOfPrimitive: Map[PrimitiveBType, ClassBType] = _boxedClassOfPrimitive.get - private lazy val _boxedClassOfPrimitive: Lazy[Map[PrimitiveBType, ClassBType]] = ppa.perRunLazy(Map( - UNIT -> classBTypeFromSymbol(requiredClass[java.lang.Void]), - BOOL -> classBTypeFromSymbol(requiredClass[java.lang.Boolean]), - BYTE -> classBTypeFromSymbol(requiredClass[java.lang.Byte]), - SHORT -> classBTypeFromSymbol(requiredClass[java.lang.Short]), - CHAR -> classBTypeFromSymbol(requiredClass[java.lang.Character]), - INT -> classBTypeFromSymbol(requiredClass[java.lang.Integer]), - LONG -> classBTypeFromSymbol(requiredClass[java.lang.Long]), - FLOAT -> classBTypeFromSymbol(requiredClass[java.lang.Float]), - DOUBLE -> classBTypeFromSymbol(requiredClass[java.lang.Double]) - )) - - lazy val boxedClasses: Set[ClassBType] = boxedClassOfPrimitive.values.toSet - - /** - * Maps the method symbol for a box method to the boxed type of the result. For example, the - * method symbol for `Byte.box()` is mapped to the ClassBType `java/lang/Byte`. - */ - override def boxResultType: Map[Symbol, ClassBType] = _boxResultType.get - private lazy val _boxResultType: Lazy[Map[Symbol, ClassBType]] = ppa.perRunLazy{ - val boxMethods = defn.ScalaValueClasses().map{x => - (x, Erasure.Boxing.boxMethod(x.asClass)) - }.toMap - for ((valueClassSym, boxMethodSym) <- boxMethods) - yield boxMethodSym -> boxedClassOfPrimitive(primitiveTypeMap(valueClassSym)) - } - - /** - * Maps the method symbol for an unbox method to the primitive type of the result. - * For example, the method symbol for `Byte.unbox()` is mapped to the PrimitiveBType BYTE. */ - override def unboxResultType: Map[Symbol, PrimitiveBType] = _unboxResultType.get - private lazy val _unboxResultType = ppa.perRunLazy[Map[Symbol, PrimitiveBType]]{ - val unboxMethods: Map[Symbol, Symbol] = - defn.ScalaValueClasses().map(x => (x, Erasure.Boxing.unboxMethod(x.asClass))).toMap - for ((valueClassSym, unboxMethodSym) <- unboxMethods) - yield unboxMethodSym -> primitiveTypeMap(valueClassSym) - } - - /* - * srNothingRef and srNullRef exist at run-time only. They are the bytecode-level manifestation (in - * method signatures only) of what shows up as NothingClass (scala.Nothing) resp. NullClass (scala.Null) in Scala ASTs. - * - * Therefore, when srNothingRef or srNullRef are to be emitted, a mapping is needed: the internal - * names of NothingClass and NullClass can't be emitted as-is. - * TODO @lry Once there's a 2.11.3 starr, use the commented argument list. The current starr crashes on the type literal `scala.runtime.Nothing$` - */ - override def srNothingRef: ClassBType = _srNothingRef.get - private lazy val _srNothingRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass("scala.runtime.Nothing$"))) - - override def srNullRef: ClassBType = _srNullRef.get - private lazy val _srNullRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass("scala.runtime.Null$"))) - - override def srBoxedUnitRef: ClassBType = _srBoxedUnitRef.get - private lazy val _srBoxedUnitRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass("scala.runtime.BoxedUnit"))) - - override def ObjectRef: ClassBType = _ObjectRef.get - private lazy val _ObjectRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(defn.ObjectClass)) - - override def StringRef: ClassBType = _StringRef.get - private lazy val _StringRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(defn.StringClass)) - - override def PredefRef: ClassBType = _PredefRef.get - private lazy val _PredefRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(defn.ScalaPredefModuleClass)) - - override def jlClassRef: ClassBType = _jlClassRef.get - private lazy val _jlClassRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[java.lang.Class[?]])) - - override def jlThrowableRef: ClassBType = _jlThrowableRef.get - private lazy val _jlThrowableRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(defn.ThrowableClass)) - - override def jlCloneableRef: ClassBType = _jlCloneableRef.get - private lazy val _jlCloneableRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(defn.JavaCloneableClass)) - - override def jiSerializableRef: ClassBType = _jiSerializableRef.get - private lazy val _jiSerializableRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[java.io.Serializable])) - - override def jlClassCastExceptionRef: ClassBType = _jlClassCastExceptionRef.get - private lazy val _jlClassCastExceptionRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[java.lang.ClassCastException])) - - override def jlIllegalArgExceptionRef: ClassBType = _jlIllegalArgExceptionRef.get - private lazy val _jlIllegalArgExceptionRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[java.lang.IllegalArgumentException])) - - override def jliSerializedLambdaRef: ClassBType = _jliSerializedLambdaRef.get - private lazy val _jliSerializedLambdaRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[java.lang.invoke.SerializedLambda])) - - override def srBoxesRuntimeRef: ClassBType = _srBoxesRuntimeRef.get - private lazy val _srBoxesRuntimeRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[scala.runtime.BoxesRunTime])) - - private def jliCallSiteRef: ClassBType = _jliCallSiteRef.get - private lazy val _jliCallSiteRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[java.lang.invoke.CallSite])) - - private def jliLambdaMetafactoryRef: ClassBType = _jliLambdaMetafactoryRef.get - private lazy val _jliLambdaMetafactoryRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[java.lang.invoke.LambdaMetafactory])) - - override def jliMethodHandleRef: ClassBType = _jliMethodHandleRef.get - private lazy val _jliMethodHandleRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(defn.MethodHandleClass)) - - private def jliMethodHandlesLookupRef: ClassBType = _jliMethodHandlesLookupRef.get - private lazy val _jliMethodHandlesLookupRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(defn.MethodHandlesLookupClass)) - - private def jliMethodTypeRef: ClassBType = _jliMethodTypeRef.get - private lazy val _jliMethodTypeRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[java.lang.invoke.MethodType])) - - // since JDK 9 - private def jliStringConcatFactoryRef: ClassBType = _jliStringConcatFactoryRef.get - private lazy val _jliStringConcatFactoryRef: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass("java.lang.invoke.StringConcatFactory"))) - - private def srLambdaDeserialize: ClassBType = _srLambdaDeserialize.get - private lazy val _srLambdaDeserialize: Lazy[ClassBType] = ppa.perRunLazy(classBTypeFromSymbol(requiredClass[scala.runtime.LambdaDeserialize])) - - - override def jliLambdaMetaFactoryMetafactoryHandle: Handle = _jliLambdaMetaFactoryMetafactoryHandle.get - private lazy val _jliLambdaMetaFactoryMetafactoryHandle: Lazy[Handle] = ppa.perRunLazy{new Handle( - Opcodes.H_INVOKESTATIC, - jliLambdaMetafactoryRef.internalName, - "metafactory", - MethodBType( - List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, jliMethodTypeRef, jliMethodHandleRef, jliMethodTypeRef), - jliCallSiteRef - ).descriptor, - /* itf = */ false)} - - override def jliLambdaMetaFactoryAltMetafactoryHandle: Handle = _jliLambdaMetaFactoryAltMetafactoryHandle.get - private lazy val _jliLambdaMetaFactoryAltMetafactoryHandle: Lazy[Handle] = ppa.perRunLazy{ new Handle( - Opcodes.H_INVOKESTATIC, - jliLambdaMetafactoryRef.internalName, - "altMetafactory", - MethodBType( - List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, ArrayBType(ObjectRef)), - jliCallSiteRef - ).descriptor, - /* itf = */ false)} - - override def jliLambdaDeserializeBootstrapHandle: Handle = _jliLambdaDeserializeBootstrapHandle.get - private lazy val _jliLambdaDeserializeBootstrapHandle: Lazy[Handle] = ppa.perRunLazy{ new Handle( - Opcodes.H_INVOKESTATIC, - srLambdaDeserialize.internalName, - "bootstrap", - MethodBType( - List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, ArrayBType(jliMethodHandleRef)), - jliCallSiteRef - ).descriptor, - /* itf = */ false)} - - override def jliStringConcatFactoryMakeConcatWithConstantsHandle: Handle = _jliStringConcatFactoryMakeConcatWithConstantsHandle.get - private lazy val _jliStringConcatFactoryMakeConcatWithConstantsHandle: Lazy[Handle] = ppa.perRunLazy{ new Handle( - Opcodes.H_INVOKESTATIC, - jliStringConcatFactoryRef.internalName, - "makeConcatWithConstants", - MethodBType( - List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, StringRef, ArrayBType(ObjectRef)), - jliCallSiteRef - ).descriptor, - /* itf = */ false)} - - /** - * Methods in scala.runtime.BoxesRuntime - * No need to wrap in Lazy to synchronize access, symbols won't change - */ - lazy val asmBoxTo : Map[BType, MethodNameAndType] = Map( - BOOL -> MethodNameAndType("boxToBoolean", MethodBType(List(BOOL), boxedClassOfPrimitive(BOOL))), - BYTE -> MethodNameAndType("boxToByte", MethodBType(List(BYTE), boxedClassOfPrimitive(BYTE))), - CHAR -> MethodNameAndType("boxToCharacter", MethodBType(List(CHAR), boxedClassOfPrimitive(CHAR))), - SHORT -> MethodNameAndType("boxToShort", MethodBType(List(SHORT), boxedClassOfPrimitive(SHORT))), - INT -> MethodNameAndType("boxToInteger", MethodBType(List(INT), boxedClassOfPrimitive(INT))), - LONG -> MethodNameAndType("boxToLong", MethodBType(List(LONG), boxedClassOfPrimitive(LONG))), - FLOAT -> MethodNameAndType("boxToFloat", MethodBType(List(FLOAT), boxedClassOfPrimitive(FLOAT))), - DOUBLE -> MethodNameAndType("boxToDouble", MethodBType(List(DOUBLE), boxedClassOfPrimitive(DOUBLE))) - ) - - lazy val asmUnboxTo: Map[BType, MethodNameAndType] = Map( - BOOL -> MethodNameAndType("unboxToBoolean", MethodBType(List(ObjectRef), BOOL)), - BYTE -> MethodNameAndType("unboxToByte", MethodBType(List(ObjectRef), BYTE)), - CHAR -> MethodNameAndType("unboxToChar", MethodBType(List(ObjectRef), CHAR)), - SHORT -> MethodNameAndType("unboxToShort", MethodBType(List(ObjectRef), SHORT)), - INT -> MethodNameAndType("unboxToInt", MethodBType(List(ObjectRef), INT)), - LONG -> MethodNameAndType("unboxToLong", MethodBType(List(ObjectRef), LONG)), - FLOAT -> MethodNameAndType("unboxToFloat", MethodBType(List(ObjectRef), FLOAT)), - DOUBLE -> MethodNameAndType("unboxToDouble", MethodBType(List(ObjectRef), DOUBLE)) - ) - - lazy val typeOfArrayOp: Map[Int, BType] = { - import dotty.tools.backend.ScalaPrimitivesOps.* - Map( - (List(ZARRAY_LENGTH, ZARRAY_GET, ZARRAY_SET) map (_ -> BOOL)) ++ - (List(BARRAY_LENGTH, BARRAY_GET, BARRAY_SET) map (_ -> BYTE)) ++ - (List(SARRAY_LENGTH, SARRAY_GET, SARRAY_SET) map (_ -> SHORT)) ++ - (List(CARRAY_LENGTH, CARRAY_GET, CARRAY_SET) map (_ -> CHAR)) ++ - (List(IARRAY_LENGTH, IARRAY_GET, IARRAY_SET) map (_ -> INT)) ++ - (List(LARRAY_LENGTH, LARRAY_GET, LARRAY_SET) map (_ -> LONG)) ++ - (List(FARRAY_LENGTH, FARRAY_GET, FARRAY_SET) map (_ -> FLOAT)) ++ - (List(DARRAY_LENGTH, DARRAY_GET, DARRAY_SET) map (_ -> DOUBLE)) ++ - (List(OARRAY_LENGTH, OARRAY_GET, OARRAY_SET) map (_ -> ObjectRef)) * - ) - } - - // java/lang/Boolean -> MethodNameAndType(valueOf,(Z)Ljava/lang/Boolean;) - def javaBoxMethods: Map[InternalName, MethodNameAndType] = _javaBoxMethods.get - private lazy val _javaBoxMethods: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { - Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { - val boxed = defn.boxedClass(primitive) - val unboxed = primitiveTypeMap(primitive) - val method = MethodNameAndType("valueOf", MethodBType(List(unboxed), boxedClassOfPrimitive(unboxed))) - (classBTypeFromSymbol(boxed).internalName, method) - })) - } - - // java/lang/Boolean -> MethodNameAndType(booleanValue,()Z) - def javaUnboxMethods: Map[InternalName, MethodNameAndType] = _javaUnboxMethods.get - private lazy val _javaUnboxMethods: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { - Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { - val boxed = defn.boxedClass(primitive) - val name = primitive.name.toString.toLowerCase + "Value" - (classBTypeFromSymbol(boxed).internalName, MethodNameAndType(name, MethodBType(Nil, primitiveTypeMap(primitive)))) - })) - } - - private def predefBoxingMethods(isBox: Boolean, getName: (String, String) => String): Map[String, MethodBType] = - Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { - val unboxed = primitiveTypeMap(primitive) - val boxed = boxedClassOfPrimitive(unboxed) - val name = getName(primitive.name.toString, defn.boxedClass(primitive).name.toString) - (name, MethodBType(List(if isBox then unboxed else boxed), if isBox then boxed else unboxed)) - })) - - // boolean2Boolean -> (Z)Ljava/lang/Boolean; - def predefAutoBoxMethods: Map[String, MethodBType] = _predefAutoBoxMethods.get - private lazy val _predefAutoBoxMethods: Lazy[Map[String, MethodBType]] = ppa.perRunLazy(predefBoxingMethods(true, (primitive, boxed) => primitive.toLowerCase + "2" + boxed)) - - // Boolean2boolean -> (Ljava/lang/Boolean;)Z - def predefAutoUnboxMethods: Map[String, MethodBType] = _predefAutoUnboxMethods.get - private lazy val _predefAutoUnboxMethods: Lazy[Map[String, MethodBType]] = ppa.perRunLazy(predefBoxingMethods(false, (primitive, boxed) => boxed + "2" + primitive.toLowerCase)) - - // scala/runtime/BooleanRef -> MethodNameAndType(create,(Z)Lscala/runtime/BooleanRef;) - def srRefCreateMethods: Map[InternalName, MethodNameAndType] = _srRefCreateMethods.get - private lazy val _srRefCreateMethods: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { - Map.from(defn.ScalaValueClassesNoUnit().union(Set(defn.ObjectClass)).flatMap(primitive => { - val boxed = if primitive == defn.ObjectClass then primitive else defn.boxedClass(primitive) - val unboxed = if primitive == defn.ObjectClass then ObjectRef else primitiveTypeMap(primitive) - val refClass = Symbols.requiredClass("scala.runtime." + primitive.name.toString + "Ref") - val volatileRefClass = Symbols.requiredClass("scala.runtime.Volatile" + primitive.name.toString + "Ref") - List( - (classBTypeFromSymbol(refClass).internalName, MethodNameAndType(nme.create.toString, MethodBType(List(unboxed), classBTypeFromSymbol(refClass)))), - (classBTypeFromSymbol(volatileRefClass).internalName, MethodNameAndType(nme.create.toString, MethodBType(List(unboxed), classBTypeFromSymbol(volatileRefClass)))) - ) - })) - } - - // scala/runtime/BooleanRef -> MethodNameAndType(zero,()Lscala/runtime/BooleanRef;) - def srRefZeroMethods: Map[InternalName, MethodNameAndType] = _srRefZeroMethods.get - private lazy val _srRefZeroMethods: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { - Map.from(defn.ScalaValueClassesNoUnit().union(Set(defn.ObjectClass)).flatMap(primitive => { - val boxed = if primitive == defn.ObjectClass then primitive else defn.boxedClass(primitive) - val refClass = Symbols.requiredClass("scala.runtime." + primitive.name.toString + "Ref") - val volatileRefClass = Symbols.requiredClass("scala.runtime.Volatile" + primitive.name.toString + "Ref") - List( - (classBTypeFromSymbol(refClass).internalName, MethodNameAndType(nme.zero.toString, MethodBType(List(), classBTypeFromSymbol(refClass)))), - (classBTypeFromSymbol(volatileRefClass).internalName, MethodNameAndType(nme.zero.toString, MethodBType(List(), classBTypeFromSymbol(volatileRefClass)))) - ) - })) - } - - // java/lang/Boolean -> MethodNameAndType(,(Z)V) - def primitiveBoxConstructors: Map[InternalName, MethodNameAndType] = _primitiveBoxConstructors.get - private lazy val _primitiveBoxConstructors: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { - Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { - val boxed = defn.boxedClass(primitive) - val unboxed = primitiveTypeMap(primitive) - (classBTypeFromSymbol(boxed).internalName, MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(unboxed), UNIT))) - })) - } - - // Z -> MethodNameAndType(boxToBoolean,(Z)Ljava/lang/Boolean;) - def srBoxesRuntimeBoxToMethods: Map[BType, MethodNameAndType] = _srBoxesRuntimeBoxToMethods.get - private lazy val _srBoxesRuntimeBoxToMethods: Lazy[Map[BType, MethodNameAndType]] = ppa.perRunLazy { - Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { - val bType = primitiveTypeMap(primitive) - val boxed = boxedClassOfPrimitive(bType) - val name = "boxTo" + defn.boxedClass(primitive).name.toString - (bType, MethodNameAndType(name, MethodBType(List(bType), boxed))) - })) - } - - // Z -> MethodNameAndType(unboxToBoolean,(Ljava/lang/Object;)Z) - def srBoxesRuntimeUnboxToMethods: Map[BType, MethodNameAndType] = _srBoxesRuntimeUnboxToMethods.get - private lazy val _srBoxesRuntimeUnboxToMethods: Lazy[Map[BType, MethodNameAndType]] = ppa.perRunLazy { - Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { - val bType = primitiveTypeMap(primitive) - val name = "unboxTo" + primitive.name.toString - (bType, MethodNameAndType(name, MethodBType(List(ObjectRef), bType))) - })) - } - - // scala/runtime/BooleanRef -> MethodNameAndType(,(Z)V) - def srRefConstructors: Map[InternalName, MethodNameAndType] = _srRefConstructors.get - private lazy val _srRefConstructors: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { - Map.from(defn.ScalaValueClassesNoUnit().union(Set(defn.ObjectClass)).flatMap(primitive => { - val boxed = if primitive == defn.ObjectClass then primitive else defn.boxedClass(primitive) - val unboxed = if primitive == defn.ObjectClass then ObjectRef else primitiveTypeMap(primitive) - val refClass = Symbols.requiredClass("scala.runtime." + primitive.name.toString + "Ref") - val volatileRefClass = Symbols.requiredClass("scala.runtime.Volatile" + primitive.name.toString + "Ref") - List( - (classBTypeFromSymbol(refClass).internalName, MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(unboxed), UNIT))), - (classBTypeFromSymbol(volatileRefClass).internalName, MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(unboxed), UNIT))) - ) - })) - } - - // scala/Tuple3 -> MethodNameAndType(,(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V) - // scala/Tuple2$mcZC$sp -> MethodNameAndType(,(ZC)V) - // ... this was easy in scala2, but now we don't specialize them so we have to know each name - // tuple1 is specialized for D, I, J - // tuple2 is specialized for C, D, I, J, Z in each parameter - def tupleClassConstructors: Map[InternalName, MethodNameAndType] = _tupleClassConstructors.get - private lazy val _tupleClassConstructors: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { - val spec1 = List(defn.DoubleClass, defn.IntClass, defn.LongClass) - val spec2 = List(defn.CharClass, defn.DoubleClass, defn.IntClass, defn.LongClass, defn.BooleanClass) - Map.from( - Iterator.concat( - (1 to 22).map { n => - ("scala/Tuple" + n, MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List.fill(n)(ObjectRef), UNIT))) - }, - spec1.map { sp1 => - val prim = primitiveTypeMap(sp1) - ("scala/Tuple1$mc" + prim.descriptor + "$sp", MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(), UNIT))) - }, - for sp2a <- spec2; sp2b <- spec2 yield { - val primA = primitiveTypeMap(sp2a) - val primB = primitiveTypeMap(sp2b) - ("scala/Tuple2$mc" + primA.descriptor + primB.descriptor + "$sp", MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(primA, primB), UNIT))) - } - ) - ) - } -} diff --git a/compiler/src/dotty/tools/backend/jvm/GenBCode.scala b/compiler/src/dotty/tools/backend/jvm/GenBCode.scala index 2d66551f3b4c..a071e53d7893 100644 --- a/compiler/src/dotty/tools/backend/jvm/GenBCode.scala +++ b/compiler/src/dotty/tools/backend/jvm/GenBCode.scala @@ -6,16 +6,12 @@ import dotty.tools.dotc.report import dotty.tools.dotc.core.* import dotty.tools.dotc.interfaces.CompilerCallback import Contexts.* -import Symbols.* import dotty.tools.backend.ScalaPrimitives -import dotty.tools.backend.jvm.opt.{BCodeRepository, BTypesFromClassfile} +import dotty.tools.backend.jvm.opt.{BCodeRepository, BTypesFromClassfile, CallGraph} +import dotty.tools.dotc.core.Decorators.em import dotty.tools.io.* import scala.collection.mutable -import scala.compiletime.uninitialized -import java.util.concurrent.TimeoutException -import scala.concurrent.duration.Duration -import scala.concurrent.Await /** * GenBCode has 3 parts: @@ -27,7 +23,7 @@ import scala.concurrent.Await * Parts 2 and 3 do not require a Context and can be parallelized. * * It is crucial that parts 2 and 3 do not accidentally depend on a Context, - * which is why we have a "post-processor frontend interface" that hides this Context. + * which is why we have abstractions to hide it such as OptimizerSettings. */ class GenBCode extends Phase { self => @@ -37,18 +33,18 @@ class GenBCode extends Phase { self => override def isRunnable(using Context): Boolean = super.isRunnable && !ctx.usedBestEffortTasty - private val entryPoints = new mutable.HashSet[String]() - def registerEntryPoint(s: String): Unit = entryPoints += s + private var _backendUtils: BackendUtils | Null = null + def backendUtils(using Context): BackendUtils = { + if _backendUtils eq null then + _backendUtils = BackendUtils(wellKnownBTypes) + _backendUtils.nn + } private var _frontendAccess: PostProcessorFrontendAccess | Null = null def frontendAccess(using Context): PostProcessorFrontendAccess = { if _frontendAccess eq null then - // Enforce usage of FreshContext so we would be able to modify compilation unit between runs - val context = ctx match - case fc: FreshContext => fc - case ctx => ctx.fresh - _frontendAccess = PostProcessorFrontendAccess.Impl(entryPoints)(context) + _frontendAccess = PostProcessorFrontendAccess(ctx) _frontendAccess.nn } @@ -62,87 +58,104 @@ class GenBCode extends Phase { self => private var _byteCodeRepository: BCodeRepository | Null = null def byteCodeRepository(using Context): BCodeRepository = { if _byteCodeRepository eq null then - _byteCodeRepository = BCodeRepository(frontendAccess, backendUtils, bTypes) + _byteCodeRepository = BCodeRepository(ctx.platform.classPath, backendUtils) _byteCodeRepository.nn } private var _bTypesFromClassfile: BTypesFromClassfile | Null = null def bTypesFromClassfile(using Context): BTypesFromClassfile = { if _bTypesFromClassfile eq null then - _bTypesFromClassfile = BTypesFromClassfile(byteCodeRepository, bTypes) + _bTypesFromClassfile = BTypesFromClassfile(byteCodeRepository, bTypeLoader) _bTypesFromClassfile.nn } - private var _bTypes: CoreBTypes | Null = null - def bTypes(using Context): CoreBTypes = { - if _bTypes eq null then + private var _bTypeLoader: BTypeLoader | Null = null + def bTypeLoader(using Context): BTypeLoader = { + if _bTypeLoader eq null then // lazy load to break the circular dependency - def inlineInfoLoader() = Option.when[InlineInfoLoader](frontendAccess.compilerSettings.optInlinerEnabled)(bTypesFromClassfile) - _bTypes = CoreBTypesFromSymbols(frontendAccess, primitives, inlineInfoLoader)(using ctx) - _bTypes.nn + def inlineInfoLoader() = Option.when[InlineInfoLoader](ctx.settings.optInlineEnabled)(bTypesFromClassfile) + _bTypeLoader = BTypeLoader(primitives, inlineInfoLoader) + _bTypeLoader.nn } - private var _backendUtils: BackendUtils | Null = null - def backendUtils(using Context): BackendUtils = { - if _backendUtils eq null then - _backendUtils = BackendUtils(frontendAccess, bTypes) - _backendUtils.nn + private var _wellKnownBTypes: WellKnownBTypes | Null = null + def wellKnownBTypes(using Context): WellKnownBTypes = { + if _wellKnownBTypes eq null then + // lazy load to break the circular dependency + def inlineInfoLoader() = Option.when[InlineInfoLoader](ctx.settings.optInlineEnabled)(bTypesFromClassfile) + _wellKnownBTypes = WellKnownBTypes(frontendAccess, bTypeLoader)(using ctx) + _wellKnownBTypes.nn + } + + private var _callGraph: CallGraph | Null = null + def callGraph(using Context): CallGraph = { + if _callGraph eq null then + _callGraph = new CallGraph(frontendAccess, byteCodeRepository, bTypesFromClassfile) + _callGraph.nn } private var _postProcessor: PostProcessor | Null = null def postProcessor(using Context): PostProcessor = { if _postProcessor eq null then - _postProcessor = new PostProcessor(frontendAccess, byteCodeRepository, bTypesFromClassfile, backendUtils, bTypes) + _postProcessor = new PostProcessor(frontendAccess, byteCodeRepository, bTypesFromClassfile, callGraph, backendUtils, bTypeLoader, wellKnownBTypes) _postProcessor.nn } + private var _generatedClassHandler: GeneratedClassHandler | Null = null + def generatedClassHandler(using Context): GeneratedClassHandler = { + if _generatedClassHandler eq null then { + val handler = ctx.settings.YbackendParallelism.value match { + case 1 => GeneratedClassHandler.serial(postProcessor) + case maxThreads => + // The thread pool queue is limited in size. When it's full, the `CallerRunsPolicy` causes + // a new task to be executed on the main thread, which provides back-pressure. + // The queue size is large enough to ensure that running a task on the main thread does + // not take longer than to exhaust the queue for the backend workers. + val queueSize = ctx.settings.YbackendWorkerQueue.valueSetByUser.getOrElse(maxThreads * 2) + GeneratedClassHandler.parallel(postProcessor, maxThreads, queueSize, this, ctx.profiler) + } + _generatedClassHandler = + if ctx.settings.optInlineEnabled || ctx.settings.optClosureInvocations + then GeneratedClassHandler.withGlobalOptimizations(handler) + else handler + } + _generatedClassHandler.nn + } + private var _codeGen: CodeGen | Null = null def codeGen(using Context): CodeGen = { if _codeGen eq null then - _codeGen = new CodeGen(backendUtils, primitives, frontendAccess, postProcessor.callGraph, bTypes) + _codeGen = new CodeGen(backendUtils, primitives, frontendAccess, callGraph, bTypeLoader, wellKnownBTypes, generatedClassHandler) _codeGen.nn } - private var _generatedClassHandler: GeneratedClassHandler | Null = null - def generatedClassHandler(using Context): GeneratedClassHandler = { - if _generatedClassHandler eq null then - _generatedClassHandler = GeneratedClassHandler(postProcessor) - _generatedClassHandler.nn - } - protected def run(using Context): Unit = - frontendAccess.frontendSynch { - frontendAccess - .ctx - .setCompilationUnit(ctx.compilationUnit) - } - codeGen.genUnit(ctx.compilationUnit) - (ctx.compilerCallback: CompilerCallback | Null) match { + codeGen.genUnit() + ctx.compilerCallback match case cb: CompilerCallback => cb.onSourceCompiled(ctx.source) case null => () - } override def runOn(units: List[CompilationUnit])(using ctx:Context): List[CompilationUnit] = { try val result = super.runOn(units) - generatedClassHandler.complete() + for (exn, f) <- generatedClassHandler.complete() do + report.error(em"unable to write $f $exn") + exn.printStackTrace() result finally - // frontendAccess and postProcessor are created lazily, clean them up only if they were initialized - if _frontendAccess ne null then - frontendAccess.compilerSettings.outputDirectory match { - case jar: JarArchive => - if (ctx.run.nn.suspendedUnits.nonEmpty) - // If we close the jar the next run will not be able to write on the jar. - // But if we do not close it we cannot use it as part of the macro classpath of the suspended files. - report.error("Can not suspend and output to a jar at the same time. See suspension with -Xprint-suspension.") - - jar.close() - case _ => () - } + ctx.settings.outputDir.value match + case jar: JarArchive => + if (ctx.run.nn.suspendedUnits.nonEmpty) + // If we close the jar the next run will not be able to write on the jar. + // But if we do not close it we cannot use it as part of the macro classpath of the suspended files. + report.error("Cannot suspend and output to a jar at the same time. See suspension with -Xprint-suspension.") + jar.close() + case _ => () + // created lazily, clean them up only if they were initialized if _postProcessor ne null then - postProcessor.classfileWriter.close() - generatedClassHandler.close() + postProcessor.close() + if _generatedClassHandler ne null then + generatedClassHandler.close() } } diff --git a/compiler/src/dotty/tools/backend/jvm/GeneratedClassHandler.scala b/compiler/src/dotty/tools/backend/jvm/GeneratedClassHandler.scala index 82b7aa7b282b..eefeca894576 100644 --- a/compiler/src/dotty/tools/backend/jvm/GeneratedClassHandler.scala +++ b/compiler/src/dotty/tools/backend/jvm/GeneratedClassHandler.scala @@ -1,20 +1,12 @@ package dotty.tools.backend.jvm import java.nio.channels.ClosedByInterruptException -import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy import java.util.concurrent.* import scala.collection.mutable.ListBuffer import scala.concurrent.duration.Duration import scala.concurrent.{Await, ExecutionContext, ExecutionContextExecutor, Future} -import dotty.tools.dotc.core.Contexts.* import dotty.tools.io.AbstractFile -import dotty.tools.dotc.profile.ThreadPoolFactory - -import scala.util.control.NonFatal -import dotty.tools.dotc.core.Phases -import dotty.tools.dotc.core.Decorators.em -import dotty.tools.dotc.core.Types.IdentityTypeMap.mapCtx -import dotty.tools.dotc.report +import dotty.tools.dotc.profile.{ProfiledThreadPool, Profiler} import scala.compiletime.uninitialized @@ -24,7 +16,6 @@ import scala.compiletime.uninitialized */ private[jvm] sealed trait GeneratedClassHandler { val postProcessor: PostProcessor - val ctx: Context /** * Pass the result of code generation for a compilation unit to this handler for post-processing @@ -32,9 +23,10 @@ private[jvm] sealed trait GeneratedClassHandler { def process(unit: GeneratedCompilationUnit): Unit /** - * If running in parallel, block until all generated classes are handled + * If running in parallel, block until all generated classes are handled. + * Returns any exceptions encountered during processing, with the corresponding file. */ - def complete(): Unit + def complete(): List[(Throwable, AbstractFile)] /** * Invoked at the end of the jvm phase @@ -43,45 +35,26 @@ private[jvm] sealed trait GeneratedClassHandler { } private[jvm] object GeneratedClassHandler { - def apply(postProcessor: PostProcessor)(using ictx: Context): GeneratedClassHandler = { - val compilerSettings = postProcessor.frontendAccess.compilerSettings - val handler = compilerSettings.backendParallelism match { - case 1 => new SyncWritingClassHandler(postProcessor, ictx) - - case maxThreads => - // if (settings.areStatisticsEnabled) - // runReporting.warning( - // NoPosition, - // "JVM statistics are not reliable with multi-threaded JVM class writing.\n" + - // "To collect compiler statistics remove the " + settings.YaddBackendThreads.name + " setting.", - // WarningCategory.Other, - // site = "" - // ) - val additionalThreads = maxThreads - 1 - // The thread pool queue is limited in size. When it's full, the `CallerRunsPolicy` causes - // a new task to be executed on the main thread, which provides back-pressure. - // The queue size is large enough to ensure that running a task on the main thread does - // not take longer than to exhaust the queue for the backend workers. - val queueSize = compilerSettings.backendMaxWorkerQueue.getOrElse(maxThreads * 2) - val threadPoolFactory = ThreadPoolFactory(Phases.genBCodePhase) - val javaExecutor = threadPoolFactory.newBoundedQueueFixedThreadPool(additionalThreads, queueSize, new CallerRunsPolicy, "non-ast") - new AsyncWritingClassHandler(postProcessor, ictx, javaExecutor) - } + def serial(postProcessor: PostProcessor): GeneratedClassHandler = + new SyncWritingClassHandler(postProcessor) - if compilerSettings.optInlinerEnabled || compilerSettings.optClosureInvocations then - new GlobalOptimisingGeneratedClassHandler(postProcessor, ictx, handler) - else - handler + def parallel(postProcessor: PostProcessor, maxThreads: Int, queueSize: Int, genBCode: GenBCode, profiler: Profiler): GeneratedClassHandler = { + val additionalThreads = maxThreads - 1 + val javaExecutor = ProfiledThreadPool.newExecutor(genBCode, profiler, additionalThreads, queueSize, "gen-class-handler") + new AsyncWritingClassHandler(postProcessor, javaExecutor) } - private class GlobalOptimisingGeneratedClassHandler(val postProcessor: PostProcessor, val ctx: Context, underlying: WritingClassHandler) - extends GeneratedClassHandler { + def withGlobalOptimizations(handler: GeneratedClassHandler): GeneratedClassHandler = + new GlobalOptimisingGeneratedClassHandler(handler) + + private class GlobalOptimisingGeneratedClassHandler(underlying: GeneratedClassHandler) extends GeneratedClassHandler { + override val postProcessor: PostProcessor = underlying.postProcessor private val generatedUnits = ListBuffer.empty[GeneratedCompilationUnit] def process(unit: GeneratedCompilationUnit): Unit = generatedUnits += unit - def complete(): Unit = { + def complete(): List[(Throwable, AbstractFile)] = { val allGeneratedUnits = generatedUnits.result() generatedUnits.clear() postProcessor.runGlobalOptimizations(allGeneratedUnits) @@ -94,38 +67,35 @@ private[jvm] object GeneratedClassHandler { override def toString: String = s"GloballyOptimising[$underlying]" } - sealed abstract class WritingClassHandler(val javaExecutor: Executor) extends GeneratedClassHandler { - import postProcessor.frontendAccess - + private sealed abstract class WritingClassHandler(val javaExecutor: Executor) extends GeneratedClassHandler { def tryStealing: Option[Runnable] private val processingUnits = ListBuffer.empty[CompilationUnitInPostProcess] def process(unit: GeneratedCompilationUnit): Unit = { - val unitInPostProcess = new CompilationUnitInPostProcess(unit.classes, unit.tasty, unit.sourceFile)(using unit.ctx) + val unitInPostProcess = new CompilationUnitInPostProcess(unit.classes, unit.tasty, unit.sourceFile) postProcessUnit(unitInPostProcess) processingUnits += unitInPostProcess } - protected implicit val executionContext: ExecutionContextExecutor = ExecutionContext.fromExecutor(javaExecutor) + private val executionContext: ExecutionContextExecutor = ExecutionContext.fromExecutor(javaExecutor) - final def postProcessUnit(unitInPostProcess: CompilationUnitInPostProcess): Unit = { + private def postProcessUnit(unitInPostProcess: CompilationUnitInPostProcess): Unit = { + given ExecutionContext = executionContext unitInPostProcess.task = Future: // we 'take' classes to reduce the memory pressure // as soon as the class is consumed and written, we release its data - unitInPostProcess.takeClasses().foreach: - postProcessor.sendToDisk(_, unitInPostProcess.sourceFile) - unitInPostProcess.takeTasty().foreach: - postProcessor.sendToDisk(_, unitInPostProcess.sourceFile) + unitInPostProcess.takeClasses().foreach(postProcessor.sendToDisk) + unitInPostProcess.takeTasty().foreach(postProcessor.sendToDisk) } - protected def takeProcessingUnits(): List[CompilationUnitInPostProcess] = { + private def takeProcessingUnits(): List[CompilationUnitInPostProcess] = { val result = processingUnits.result() processingUnits.clear() result } - final def complete(): Unit = { + final def complete(): List[(Exception, AbstractFile)] = { def stealWhileWaiting(unitInPostProcess: CompilationUnitInPostProcess): Unit = { val task = unitInPostProcess.task while (!task.isCompleted) @@ -148,22 +118,20 @@ private[jvm] object GeneratedClassHandler { * loss, due to the memory being retained longer for tasks than it might otherwise. * Most of the memory in the CompilationUnitInPostProcess is reclaimable anyway as the classes are dereferenced after use. */ - takeProcessingUnits().foreach { unitInPostProcess => + takeProcessingUnits().flatMap { unitInPostProcess => try stealWhileWaiting(unitInPostProcess) // We know the future is complete, throw the exception if it completed with a failure unitInPostProcess.task.value.get.get + Nil catch case _: ClosedByInterruptException => throw new InterruptedException() - case NonFatal(t) => - t.printStackTrace() - given Context = ctx - report.error(em"unable to write ${unitInPostProcess.sourceFile} $t") + case e: Exception => List((e, unitInPostProcess.sourceFile)) } } } - private final class SyncWritingClassHandler(val postProcessor: PostProcessor, val ctx: Context) + private final class SyncWritingClassHandler(val postProcessor: PostProcessor) extends WritingClassHandler(_.nn.run()) { override def toString: String = "SyncWriting" @@ -171,7 +139,7 @@ private[jvm] object GeneratedClassHandler { def tryStealing: Option[Runnable] = None } - private final class AsyncWritingClassHandler(val postProcessor: PostProcessor, val ctx: Context, override val javaExecutor: ThreadPoolExecutor) + private final class AsyncWritingClassHandler(val postProcessor: PostProcessor, override val javaExecutor: ThreadPoolExecutor) extends WritingClassHandler(javaExecutor) { override def toString: String = s"AsyncWriting[additional threads:${javaExecutor.getMaximumPoolSize}]" @@ -184,27 +152,26 @@ private[jvm] object GeneratedClassHandler { def tryStealing: Option[Runnable] = Option(javaExecutor.getQueue.poll()) } -} + /** + * State for a compilation unit being post-processed. + * - Holds the classes to post-process (released for GC when no longer used) + * - Keeps a reference to the future that runs the post-processor + * - Buffers messages reported during post-processing + */ + final private class CompilationUnitInPostProcess(private var classes: List[GeneratedClass], private var tasty: List[GeneratedTasty], val sourceFile: AbstractFile) { + def takeClasses(): List[GeneratedClass] = { + val c = classes + classes = Nil + c + } -/** - * State for a compilation unit being post-processed. - * - Holds the classes to post-process (released for GC when no longer used) - * - Keeps a reference to the future that runs the post-processor - * - Buffers messages reported during post-processing - */ -final private class CompilationUnitInPostProcess(private var classes: List[GeneratedClass], private var tasty: List[GeneratedTasty], val sourceFile: AbstractFile)(using Context) { - def takeClasses(): List[GeneratedClass] = { - val c = classes - classes = Nil - c - } + def takeTasty(): List[GeneratedTasty] = { + val v = tasty + tasty = Nil + v + } - def takeTasty(): List[GeneratedTasty] = { - val v = tasty - tasty = Nil - v + /** the main async task submitted onto the scheduler */ + var task: Future[Unit] = uninitialized } - - /** the main async task submitted onto the scheduler */ - var task: Future[Unit] = uninitialized } diff --git a/compiler/src/dotty/tools/backend/jvm/GenericSignatureVisitor.scala b/compiler/src/dotty/tools/backend/jvm/GenericSignatureVisitor.scala index 3648240171f8..dfca8cbecf1b 100644 --- a/compiler/src/dotty/tools/backend/jvm/GenericSignatureVisitor.scala +++ b/compiler/src/dotty/tools/backend/jvm/GenericSignatureVisitor.scala @@ -6,7 +6,7 @@ import scala.tools.asm.{ClassReader, Type, Handle } import scala.tools.asm.tree.* import scala.collection.mutable -import scala.util.control.{NoStackTrace, NonFatal} +import scala.util.control.NoStackTrace import scala.annotation.* import scala.jdk.CollectionConverters.* import BTypes.InternalName @@ -47,7 +47,7 @@ abstract class GenericSignatureVisitor(nestedOnly: Boolean) { @inline def safely(f: => Unit): Unit = try f catch { case Aborted => - case NonFatal(e) => raiseError(s"Exception thrown during signature parsing", sig, Some(e)) + case e: Exception => raiseError(s"Exception thrown during signature parsing", sig, Some(e)) } private def current = { diff --git a/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala b/compiler/src/dotty/tools/backend/jvm/GenericSignatures.scala similarity index 57% rename from compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala rename to compiler/src/dotty/tools/backend/jvm/GenericSignatures.scala index 65f47d962672..78fb17d188b4 100644 --- a/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala +++ b/compiler/src/dotty/tools/backend/jvm/GenericSignatures.scala @@ -1,24 +1,23 @@ package dotty.tools -package dotc -package transform - -import core.Annotations.* -import core.Contexts.* -import core.Phases.* -import core.Definitions -import core.Flags.* -import core.Names.Name -import core.NameOps.isContextFunction -import core.Symbols.* -import core.TypeApplications.{EtaExpansion, TypeParamInfo} -import core.TypeErasure.{erasedGlb, erasure, fullErasure, isGenericArrayElement, tupleArity} -import core.Types.* -import core.classfile.ClassfileConstants - -import config.Printers.transforms -import reporting.trace -import java.lang.StringBuilder +package backend +package jvm + +import dotty.tools.dotc.core.Annotations.* +import dotty.tools.dotc.core.Contexts.* +import dotty.tools.dotc.core.Phases.* +import dotty.tools.dotc.core.Definitions +import dotty.tools.dotc.core.Decorators.* +import dotty.tools.dotc.core.Flags.* +import dotty.tools.dotc.core.Names.Name +import dotty.tools.dotc.core.NameOps.* +import dotty.tools.dotc.core.Symbols.* +import dotty.tools.dotc.core.Types.* +import dotty.tools.dotc.core.TypeApplications.* +import dotty.tools.dotc.core.TypeErasure.* +import dotty.tools.dotc.core.classfile.ClassfileConstants +import dotty.tools.dotc.transform.ValueClasses +import java.lang.StringBuilder import scala.annotation.tailrec import scala.collection.mutable.ListBuffer @@ -32,22 +31,29 @@ object GenericSignatures { * * @param sym0 The symbol for which to define the signature * @param info The type of the symbol - * @return The signature if it could be generated, `None` otherwise. + * @return The signature if it could be generated, `null` otherwise. */ - def javaSig(sym0: Symbol, info: Type)(using Context): Option[String] = - // Avoid generating a signature for non-class local symbols. - if (sym0.isLocal && !sym0.isClass) None - else atPhase(erasurePhase)(javaSig0(sym0, info)) - - @noinline - private final def javaSig0(sym0: Symbol, info: Type)(using Context): Option[String] = { - // This works as long as mangled names are always valid valid Java identifiers, - // if we change our name encoding, we'll have to `throw new UnknownSig` here for - // names which are not valid Java identifiers (see git history of this method). + def javaSig(sym0: Symbol, info: Type)(using Context): StringBuilder | Null = + if mayNeedSignature(sym0, info) then atPhase(erasurePhase)(javaSig0(sym0, info)) + else null + + private def mayNeedSignature(sym0: Symbol, info: Type)(using Context) = { + def mayNeedSignature(t: Type): Boolean = t match + case ExprType(e) => mayNeedSignature(e) + case MethodTpe(_, ps, res) => (!sym0.isConstructor && mayNeedSignature(res)) || ps.exists(mayNeedSignature) + case _: TypeRef => !t.isAny && !t.isAnyRef && !t.isRef(defn.StringClass, skipRefined = false) && !t.isPrimitiveValueType + case _ => true + + // Non-class local symbols definitely don't need one, they're not observable + if sym0.isLocal && !sym0.isClass then false + else mayNeedSignature(info) + } + + private def javaSig0(sym0: Symbol, info: Type)(using Context): StringBuilder = { + // This works as long as mangled names are always valid Java identifiers (see git history of this method). def sanitizeName(name: Name): String = name.mangledString val builder = new StringBuilder(64) - val isTraitSignature = sym0.enclosingClass.is(Trait) // Track class type parameter names that are shadowed by method type parameters // Used to trigger renaming of method type parameters to avoid conflicts @@ -71,25 +77,22 @@ object GenericSignatures { def superSig(cls: Symbol, parents: List[Type]): Unit = { def isInterfaceOrTrait(sym: Symbol) = sym.is(PureInterface) || sym.is(Trait) - // a signature should always start with a class - def ensureClassAsFirstParent(tps: List[Type]) = tps match { - case Nil => defn.ObjectType :: Nil - case head :: tail if isInterfaceOrTrait(head.typeSymbol) => defn.ObjectType :: tps - case _ => tps - } - val minParents = minimizeParents(cls, parents) val validParents = - if (isTraitSignature) + if sym0.enclosingClass.is(Trait) then // java is unthrilled about seeing interfaces inherit from classes minParents filter (p => isInterfaceOrTrait(p.classSymbol)) else minParents - val ps = ensureClassAsFirstParent(validParents) - ps.foreach(boxedSig) + // a signature should always start with a class + validParents.headOption match + case None => boxedSig(defn.ObjectType) + case Some(head) if isInterfaceOrTrait(head.typeSymbol) => boxedSig(defn.ObjectType) + case _ => () + validParents.foreach(boxedSig) } - def boxedSig(tp: Type): Unit = jsig(tp.widenDealias, vcBoxing = ValueClassBoxing.Box) + inline def boxedSig(tp: Type): Unit = jsig(tp.widenDealias, vcBoxing = ValueClassBoxing.Box) /** The signature of the upper-bound of a type parameter. * @@ -124,7 +127,7 @@ object GenericSignatures { * that cannot appear in the signature have been replaced * by their upper-bound. */ - def flattenedIntersection(tp: AndType)(using Context): List[Type] = + def flattenedIntersection(tp: AndType)(using Context): Iterable[Type] = val parents = ListBuffer[Type]() def collect(parent: Type, parents: ListBuffer[Type]): Unit = parent.widenDealias match @@ -140,14 +143,14 @@ object GenericSignatures { parents += parent collect(tp, parents) - parents.toList + parents end flattenedIntersection /** Split the `parents` of an intersection into two subsets: * those whose individual erasure matches the overall erasure * of the intersection and the others. */ - def splitIntersection(parents: List[Type])(using Context): (List[Type], List[Type]) = + def splitIntersection(parents: Iterable[Type])(using Context): (Iterable[Type], Iterable[Type]) = val erasedParents = parents.map(erasure) val erasedTp = erasedGlb(erasedParents) parents.zip(erasedParents) @@ -163,7 +166,7 @@ object GenericSignatures { boundsSig(hiBounds(param.paramInfo.bounds)) } - def polyParamSig(tparams: List[TypeParamInfo]): Unit = + def polyParamSig(tparams: Iterable[TypeParamInfo]): Unit = if (tparams.nonEmpty) { builder.append('<') tparams.foreach(tparamSig) @@ -191,19 +194,9 @@ object GenericSignatures { jsig(finalType) } - // Anything which could conceivably be a module (i.e. isn't known to be - // a type parameter or similar) must go through here or the signature is - // likely to end up with Foo.Empty where it needs Foo.Empty$. - def fullNameInSig(sym: Symbol): Unit = { - assert(sym.isClass) - val name = atPhase(genBCodePhase) { sanitizeName(sym.fullName).replace('.', '/') } - builder.append('L').append(name) - } - def classSig(sym: Symbol, pre: Type = NoType, args: List[Type] = Nil): Unit = { - @tailrec def argSig(tp: Type): Unit = - tp match { + tp.dealias match { case bounds: TypeBounds => if (!(defn.AnyType <:< bounds.hi)) { builder.append('+') @@ -214,43 +207,46 @@ object GenericSignatures { boxedSig(bounds.lo) } else builder.append('*') - case EtaExpansion(tp) => - argSig(tp) - case _: HKTypeLambda => - builder.append('*') + case hkt: HKTypeLambda => + hkt.resultType match + case a: AppliedType => + if hkt.paramInfos.forall(i => i.lo.isNothingType && i.hi.isAny) then + // For unbounded arguments, instead of emitting `X`, + // emit just `X` as a raw type if it's a class; + // this helps with Java compat in cases where the exact generic arguments were erased + if a.tycon.dealias.typeSymbol.isClass then + jsig(a.tycon) + else + // but if it's an HKT, we cannot represent that in a Java generic signature, so emit a wildcard + builder.append("*") + else + // For bounded arguments, we can't translate it cleanly so emit an erased type + jsig(erasure(a.tycon)) + case res if res.isPrimitiveValueType => + // value classes cannot appear as generic arguments + jsig(defn.boxedType(res)) + case res => + jsig(res) case _ => boxedSig(tp.widenDealias.widenNullaryMethod) // `tp` might be a singleton type referring to a getter. // Hence the widenNullaryMethod. } - if (pre.exists) { - val preRebound = pre.baseType(sym.owner) // #2585 - if (needsJavaSig(preRebound, Nil)) { - val i = builder.length() - jsig(preRebound) - if (builder.charAt(i) == 'L') { - builder.delete(builder.length() - 1, builder.length())// delete ';' - // If the prefix is a module, drop the '$'. Classes (or modules) nested in modules - // are separated by a single '$' in the filename: `object o { object i }` is o$i$. - if (preRebound.typeSymbol.is(ModuleClass)) - builder.delete(builder.length() - 1, builder.length()) - - // Ensure every '.' in the generated signature immediately follows - // a close angle bracket '>'. Any which do not are replaced with '$'. - // This arises due to multiply nested classes in the face of the - // rewriting explained at rebindInnerClass. - - // TODO revisit this. Does it align with javac for code that can be expressed in both languages? - val delimiter = if (builder.charAt(builder.length() - 1) == '>') '.' else '$' - builder.append(delimiter).append(sanitizeName(sym.name)) - } - else fullNameInSig(sym) - } - else fullNameInSig(sym) + assert(sym.isClass) + pre.widen match { + // If the class is an inner class of a generic class, we must emit the outer generic class with its parameters + // (see test `inner-of-generic` for an example of Java compatibility) + case RefOrAppliedType(preSym, prePre, preArgs) if preArgs.nonEmpty => + classSig(preSym, prePre, preArgs) + builder.replace(builder.length() - 1, builder.length(), ".") // instead of ending the outer name with ';', we add an inner name + builder.append(sanitizeName(sym.targetName)) + // For the rest, we time-travel so we get the full name after inner classes have been lifted to package scope + case _ => + val name = atPhase(flattenPhase.next) { sanitizeName(sym.fullName).replace('.', '/') } + builder.append('L') + builder.append(name) } - else fullNameInSig(sym) - if (args.nonEmpty) { builder.append('<') args foreach argSig @@ -262,9 +258,18 @@ object GenericSignatures { enum ValueClassBoxing: case Box, Unbox, UnboxOnlyPrimitives - @noinline def jsig(tp0: Type, toplevel: Boolean = false, vcBoxing: ValueClassBoxing = ValueClassBoxing.Unbox): Unit = { - inline def jsig1(tp0: Type): Unit = jsig(tp0) + def arraySig(elemtp: Type): Unit = + if (isGenericArrayElement(elemtp, isScala2 = false)) + jsig(defn.ObjectType) + else + builder.append(ClassfileConstants.ARRAY_TAG) + elemtp match + case TypeBounds(lo, hi) => jsig(hi.widenDealias) + // derived VCs are not unboxed inside arrays, + // i.e., `Array[VC]` where `class VC(n: X) extends AnyVal` + // is `[LVC;`, not `[LX;` + case _ => jsig(elemtp, vcBoxing = ValueClassBoxing.UnboxOnlyPrimitives) val tp = tp0.dealias tp match { @@ -276,11 +281,10 @@ object GenericSignatures { // don't emit type param name if the param is upper-bounded by a primitive type (including via a value class) if erasedUnderlying.isPrimitiveValueType then jsig(erasedUnderlying, toplevel = toplevel, vcBoxing = vcBoxing) - else { + else val name = sanitizeName(ref.paramName.lastPart) val nameToUse = methodTypeParamRenaming.getOrElse(name, name) typeParamSigWithName(nameToUse) - } case ref: TermRef if ref.symbol.isGetter => // If the type of a val is a TermRef to another val, generating the generic signature @@ -299,72 +303,79 @@ object GenericSignatures { jsig(ref.underlying, toplevel = toplevel, vcBoxing = vcBoxing) case defn.ArrayOf(elemtp) => - if (isGenericArrayElement(elemtp, isScala2 = false)) - jsig1(defn.ObjectType) - else - builder.append(ClassfileConstants.ARRAY_TAG) - elemtp match - case TypeBounds(lo, hi) => jsig1(hi.widenDealias) - // derived VCs are not unboxed inside arrays, - // i.e., `Array[VC]` where `class VC(n: X) extends AnyVal` - // is `[LVC;`, not `[LX;` - case _ => jsig(elemtp, vcBoxing = ValueClassBoxing.UnboxOnlyPrimitives) + arraySig(elemtp) + + case JavaArrayType(elemtp) => + arraySig(elemtp) case RefOrAppliedType(sym, pre, args) => - if (sym == defn.PairClass && tupleArity(tp) > Definitions.MaxTupleArity) - jsig1(defn.TupleXXLClass.typeRef) - else if (isTypeParameterInSig(sym, sym0)) { + if isTypeParameterInSig(sym, sym0) then assert(!sym.isAliasType || sym.info.isLambdaSub, "Unexpected alias type: " + sym) - typeParamSig(sym.name.lastPart) - } - else if (defn.specialErasure.contains(sym)) - jsig1(defn.specialErasure(sym).typeRef) - else if (sym == defn.UnitClass || sym == defn.BoxedUnitModule) - jsig1(defn.BoxedUnitClass.typeRef) - else if (sym == defn.NothingClass) - builder.append("Lscala/runtime/Nothing$;") - else if (sym == defn.NullClass) - builder.append("Lscala/runtime/Null$;") - else if (sym.isPrimitiveValueClass) - // TODO, but a few tests need fixing / disabling until a newer scalac is ingested, - // replace the next 2 lines with: if (vcBoxing == ValueClassBoxing.Box || sym == defn.UnitClass) jsig1(defn.boxedClass(sym).typeRef) - if (vcBoxing == ValueClassBoxing.Box) jsig1(defn.ObjectType) - else if (sym == defn.UnitClass) jsig1(defn.BoxedUnitClass.typeRef) - else builder.append(defn.typeTag(sym.info)) - else if (sym.isDerivedValueClass) { - if (vcBoxing == ValueClassBoxing.Unbox) { - val erasedUnderlying = fullErasure(tp) - jsig(erasedUnderlying, toplevel = toplevel) - } else classSig(sym, pre, args) - } - else if (defn.isSyntheticFunctionClass(sym)) { - val erasedSym = defn.functionTypeErasure(sym).typeSymbol - classSig(erasedSym, pre, if (erasedSym.typeParams.isEmpty) Nil else args) - } - else if sym.isClass then - classSig(sym, pre, args) - else - jsig(erasure(tp), toplevel = toplevel, vcBoxing = vcBoxing) - - case ExprType(restpe) if toplevel => - builder.append("()") - methodResultSig(restpe) + typeParamSig(sym.targetName.lastPart) + else defn.specialErasure.get(sym) match + case Some(special) => + jsig(special.typeRef) + case None => + if (sym == defn.PairClass && tupleArity(tp) > Definitions.MaxTupleArity) + jsig(defn.TupleXXLClass.typeRef) + else if (sym == defn.UnitClass || sym == defn.BoxedUnitModule) + jsig(defn.BoxedUnitClass.typeRef) + else if (sym == defn.NothingClass) + builder.append("Lscala/runtime/Nothing$;") + else if (sym == defn.NullClass) + builder.append("Lscala/runtime/Null$;") + else if (sym.isPrimitiveValueClass) + // TODO, but a few tests need fixing / disabling until a newer scalac is ingested, + // replace the next 2 lines with: if (vcBoxing == ValueClassBoxing.Box || sym == defn.UnitClass) jsig(defn.boxedClass(sym).typeRef) + if (vcBoxing == ValueClassBoxing.Box) jsig(defn.ObjectType) + else if (sym == defn.UnitClass) jsig(defn.BoxedUnitClass.typeRef) + else builder.append(defn.typeTag(sym.info)) + else if (sym.isDerivedValueClass) { + if (vcBoxing == ValueClassBoxing.Unbox) { + val underlying = ValueClasses.underlyingOfValueClass(sym.asClass) + val seenUnderlying = underlying.asSeenFrom(tp, sym) + // For binary compatibility with Scala 2, as documented in TypeErasure, + // we need to special cases for polymorphic value classes: + // `Foo[X]` erases to `X` except that primitives use their boxed type, + // and `Bar[X]` for `class Bar[A](x: Array[A]) extends AnyVal` erases like the definition-site `Array[A]`. + // The end-to-end binary compatibility is checked by i8001 + // There are more targeted tests for generic signatures at i24276 and t6344 + val compatibleUnderlying = + if seenUnderlying.isPrimitiveValueType && !underlying.isPrimitiveValueType then defn.boxedType(seenUnderlying) + else if underlying.derivesFrom(defn.ArrayClass) then erasure(underlying) + else seenUnderlying + jsig(compatibleUnderlying, toplevel = toplevel) + } else classSig(sym, pre, args) + } + else if (defn.isSyntheticFunctionClass(sym)) { + val erasedSym = defn.functionTypeErasure(sym).typeSymbol + classSig(erasedSym, pre, if (erasedSym.typeParams.isEmpty) Nil else args) + } + else if sym.isClass then + classSig(sym, pre, args) + else + jsig(erasure(tp), toplevel = toplevel, vcBoxing = vcBoxing) case ExprType(restpe) => - jsig1(defn.FunctionType(0).appliedTo(restpe)) + if toplevel then + builder.append("()") + methodResultSig(restpe) + else + jsig(defn.FunctionType(0).appliedTo(restpe)) case mtd: MethodOrPoly => - val (tparams, vparams, rte) = collectMethodParams(mtd) - if (toplevel && !sym0.isConstructor) { + val collectTParams = toplevel && !sym0.isConstructor + val (tparams, vparams, rte) = collectMethodParams(mtd, collectTParams) + if (tparams != null) { if (sym0.is(Method)) { - val (usedMethodTypeParamNames, usedClassTypeParams) = collectUsedTypeParams(vparams :+ rte, sym0) + val (usedMethodTypeParamNames, usedClassTypeParams) = collectUsedTypeParams(vparams, rte, sym0) val methodTypeParamNames = tparams.map(tp => sanitizeName(tp.paramName.lastPart)).toSet // Only add class type parameters to shadowedClassTypeParamNames if they are: // 1. Referenced in the method signature, AND // 2. Shadowed by a method type parameter with the same name // This will trigger renaming of the method type parameter usedClassTypeParams.foreach { classTypeParam => - val classTypeParamName = sanitizeName(classTypeParam.name) + val classTypeParamName = sanitizeName(classTypeParam.targetName) if methodTypeParamNames.contains(classTypeParamName) then shadowedClassTypeParamNames += classTypeParamName } @@ -372,7 +383,7 @@ object GenericSignatures { polyParamSig(tparams) } builder.append('(') - for vparam <- vparams do jsig1(vparam) + for vparam <- vparams do jsig(vparam) builder.append(')') methodResultSig(rte) @@ -380,7 +391,7 @@ object GenericSignatures { // Special case for nullable union types whose underlying type is not a value class. // For example, `T | Null` where `T` is a type parameter becomes `T` in the signature; // `Int | Null` still becomes `Object`. - jsig1(tp1) + jsig(tp1) case tp: AndType => // Only intersections appearing as the upper-bound of a type parameter @@ -408,51 +419,43 @@ object GenericSignatures { case hktl: HKTypeLambda => jsig(hktl.finalResultType, toplevel, vcBoxing) + case ErasedValueType(tycon, underlying) => + if vcBoxing == ValueClassBoxing.Unbox || (vcBoxing == ValueClassBoxing.UnboxOnlyPrimitives && underlying.isPrimitiveValueType) + then jsig(underlying, toplevel, vcBoxing) + else jsig(tycon, toplevel, vcBoxing) + case _ => val etp = erasure(tp) - if (etp eq tp) throw new UnknownSig - else jsig(etp, toplevel, vcBoxing) + assert(etp ne tp, i"$tp erases to itself") + jsig(etp, toplevel, vcBoxing) } } - val throwsArgs = sym0.annotations flatMap ThrownException.unapply - if (needsJavaSig(info, throwsArgs)) - try { - jsig(info, toplevel = true) - throwsArgs.foreach { t => + jsig(info, toplevel = true) + for annot <- sym0.annotations do + annot match + case ThrownException(e) => builder.append('^') - jsig(t, toplevel = true) - } - Some(builder.toString) - } - catch { case _: UnknownSig => None } - else None + jsig(e, toplevel = true) + case _ => () + builder } - private class UnknownSig extends Exception - /* Drop redundant types (ones which are implemented by some other parent) from the immediate parents. * This is important on Android because there is otherwise an interface explosion. */ - private def minimizeParents(cls: Symbol, parents: List[Type])(using Context): List[Type] = if (parents.isEmpty) parents else { - // val requiredDirect: Symbol => Boolean = requiredDirectInterfaces.getOrElse(cls, Set.empty) - var rest = parents.tail - var leaves = collection.mutable.ListBuffer.empty[Type] += parents.head - while (rest.nonEmpty) { - val candidate = rest.head + private def minimizeParents(cls: Symbol, parents: Iterable[Type])(using Context): Iterable[Type] = if (parents.isEmpty) parents else { + var leaves = collection.mutable.ListBuffer.empty[Type] + for candidate <- parents do val candidateSym = candidate.typeSymbol - // val required = requiredDirect(candidateSym) || !leaves.exists(t => t.typeSymbol isSubClass candidateSym) val required = !leaves.exists(t => t.typeSymbol.isSubClass(candidateSym)) if (required) { leaves = leaves filter { t => val ts = t.typeSymbol !(ts.is(Trait) || ts.is(PureInterface)) || !candidateSym.isSubClass(ts) - // requiredDirect(ts) || !ts.isTraitOrInterface || !candidateSym.isSubClass(ts) } leaves += candidate } - rest = rest.tail - } - leaves.toList + leaves } private def hiBounds(bounds: TypeBounds)(using Context): List[Type] = bounds.hi.widenDealias match { @@ -486,55 +489,49 @@ object GenericSignatures { } private object RefOrAppliedType { - def unapply(tp: Type)(using Context): Option[(Symbol, Type, List[Type])] = tp match { + private enum ResolvedAppliedType: + case Resolved(t: Type) + case NotResolved + case Bail + // In the special case where we see a type parameter applied to type parameters, + // such as `K[X, Y]` given `[X, Y, K <: Iterable[(X, Y)]]`, we must find its bound + // and instantiate it, otherwise in our example we end up with `Iterable[X, Y]` which is nonsensical. + private def resolveAppliedType(a: AppliedType)(using Context): ResolvedAppliedType = + a.tycon match + case TypeParamRef(binder, paramNum) => + binder.paramInfos(paramNum).hi match + case hkt @ HKTypeLambda(_, _) => + val instantiated = hkt.instantiate(a.args).dealias + // However, since Java doesn't have a way to refer to HKTs in generic signatures, + // we must trade precision for termination by only resolving one level, + // otherwise we end up in infinite loops, + // e.g., in `X[A] <: Thing[X[A]]` or `X[A] <: X[Thing[A]]` we keep resolving `X`. + // In that case we must completely give up on the genericity, i.e., + // in `X[A] <: Y[X[Z[A]]]` it would not be correct to use `Y[A]` as a type signature! + if instantiated.existsPart(_ == a.tycon) then ResolvedAppliedType.Bail + else ResolvedAppliedType.Resolved(instantiated) + case _ => ResolvedAppliedType.NotResolved + case _ => ResolvedAppliedType.NotResolved + + @tailrec + def unapply(tp: Type)(using Context): Option[(Symbol, Type, List[Type])] = tp match + case TypeRef(pre, _) if !tp.typeSymbol.isAliasType => + Some((tp.typeSymbol, pre, Nil)) case TypeParamRef(_, _) => Some((tp.typeSymbol, tp, Nil)) case TermParamRef(_, _) => Some((tp.termSymbol, tp, Nil)) - case TypeRef(pre, _) if !tp.typeSymbol.isAliasType => - val sym = tp.typeSymbol - Some((sym, pre, Nil)) - case AppliedType(pre, args) => - Some((pre.typeSymbol, pre, args)) + case a @ AppliedType(pre, args) => + resolveAppliedType(a) match + case ResolvedAppliedType.Resolved(resolved) => unapply(resolved) + case ResolvedAppliedType.NotResolved => Some((pre.typeSymbol, pre, args)) + case ResolvedAppliedType.Bail => None case _ => None - } - } - - private def needsJavaSig(tp: Type, throwsArgs: List[Type])(using Context): Boolean = !ctx.settings.XnoGenericSig.value && { - def needs(tp: Type) = (new NeedsSigCollector).apply(false, tp) - needs(tp) || throwsArgs.exists(needs) - } - - private class NeedsSigCollector(using Context) extends TypeAccumulator[Boolean] { - override def apply(x: Boolean, tp: Type): Boolean = - if (!x) - tp.dealias match { - case RefinedType(parent, refinedName, refinedInfo) => - val sym = parent.typeSymbol - if (sym == defn.ArrayClass) foldOver(x, refinedInfo) - else true - case tref @ TypeRef(pre, name) => - val sym = tref.typeSymbol - if (sym.is(TypeParam) || sym.typeParams.nonEmpty) true - else if (sym.isClass) foldOver(x, rebindInnerClass(pre, sym)) // #2585 - else foldOver(x, pre) - case PolyType(_, _) => - true - case ClassInfo(_, _, parents, _, _) => - foldOver(tp.typeParams.nonEmpty, parents) - case AnnotatedType(tpe, _) => - foldOver(x, tpe) - case ExprType(tpe) => - true - case tp => - foldOver(x, tp) - } - else x } - private def collectMethodParams(mtd: MethodOrPoly)(using Context): (List[TypeParamInfo], List[Type], Type) = - val tparams = ListBuffer.empty[TypeParamInfo] + private def collectMethodParams(mtd: MethodOrPoly, collectTParams: Boolean)(using Context): (Iterable[TypeParamInfo] | Null, Iterable[Type], Type) = + val tparams = if collectTParams then ListBuffer.empty[TypeParamInfo] else null val vparams = ListBuffer.empty[Type] @tailrec def recur(tpe: Type): Type = tpe match @@ -552,19 +549,18 @@ object GenericSignatures { case _ => recur(mtd.resType) case PolyType(tps, tpe) => - tparams ++= tps + if tparams != null then tparams ++= tps recur(tpe) case _ => tpe end recur val rte = recur(mtd) - (tparams.toList, vparams.toList, rte) + (tparams, vparams, rte) end collectMethodParams /** Collect type parameters that are actually used in the given types. */ - private def collectUsedTypeParams(types: List[Type], initialSymbol: Symbol)(using Context): (Set[Name], Set[Symbol]) = - assert(initialSymbol.is(Method)) + private def collectUsedTypeParams(types: Iterable[Type], resType: Type, initialSymbol: Symbol)(using Context): (Set[Name], Set[Symbol]) = def isTypeParameterInMethSig(sym: Symbol, initialSymbol: Symbol)(using Context) = !sym.maybeOwner.isTypeParam && // check if it's not higher order type param sym.isTypeParam && sym.owner == initialSymbol @@ -582,6 +578,7 @@ object GenericSignatures { case _ => types.foreach(collect) + collect(resType) (usedMethodTypeParamNames.toSet, usedClassTypeParams.toSet) end collectUsedTypeParams } diff --git a/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala b/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala index 7bb8a8c66c18..4ab198ecc084 100644 --- a/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala +++ b/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala @@ -1,9 +1,9 @@ package dotty.tools.backend.jvm import java.util.concurrent.ConcurrentHashMap -import scala.collection.mutable.ListBuffer -import dotty.tools.dotc.util.{NoSourcePosition, SourcePosition} +import dotty.tools.dotc.util.SourcePosition import dotty.tools.io.AbstractFile +import dotty.tools.io.FileWriters import dotty.tools.dotc.core.Contexts.* import dotty.tools.dotc.core.Decorators.em @@ -11,30 +11,42 @@ import scala.tools.asm.ClassWriter import scala.tools.asm.tree.ClassNode import dotty.tools.backend.jvm.opt.* import dotty.tools.dotc.report +import dotty.tools.io.PlainFile.toPlainFile +import java.nio.file.{Files, Paths} import scala.tools.asm +import scala.util.chaining.scalaUtilChainingOps /** * Implements late stages of the backend, i.e., * optimizations, post-processing and classfile serialization and writing. */ -class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, - private val byteCodeRepository: BCodeRepository, private val bTypesFromClassfile: BTypesFromClassfile, - private val backendUtils: BackendUtils, private val ts: CoreBTypes)(using Context) { - - val callGraph = new CallGraph(frontendAccess, byteCodeRepository, bTypesFromClassfile, ts) - private val closureOptimizer = new ClosureOptimizer(frontendAccess, backendUtils, byteCodeRepository, callGraph, ts, bTypesFromClassfile) - private val heuristics = new InlinerHeuristics(frontendAccess, backendUtils, byteCodeRepository, callGraph, ts) - private val inliner = new Inliner(frontendAccess, backendUtils, callGraph, ts, bTypesFromClassfile, byteCodeRepository, heuristics, closureOptimizer) - private val localOpt = new LocalOpt(backendUtils, frontendAccess, callGraph, inliner, ts, bTypesFromClassfile) - val classfileWriters = new ClassfileWriters(frontendAccess) - val classfileWriter = classfileWriters.ClassfileWriter() - +class PostProcessor(frontendAccess: PostProcessorFrontendAccess, + byteCodeRepository: BCodeRepository, bTypesFromClassfile: BTypesFromClassfile, + callGraph: CallGraph, backendUtils: BackendUtils, + bTypeLoader: BTypeLoader, bTypes: WellKnownBTypes)(using Context) { + + private val optSettings = new OptimizerSettings() + private val closureOptimizer = new ClosureOptimizer(frontendAccess, backendUtils, byteCodeRepository, callGraph, bTypes, bTypesFromClassfile, optSettings) + private val heuristics = new InlinerHeuristics(frontendAccess, backendUtils, byteCodeRepository, callGraph, bTypes, optSettings) + private val inliner = new Inliner(frontendAccess, backendUtils, callGraph, bTypeLoader, bTypesFromClassfile, byteCodeRepository, heuristics, closureOptimizer, optSettings) + private val localOpt = new LocalOpt(backendUtils, callGraph, inliner, bTypes, bTypesFromClassfile, optSettings) + + given FileWriters.ReadOnlyContext = FileWriters.ReadOnlyContext.eager + private val classfileWriter: FileWriters.ClassfileWriter = { + val dumpClassesPath = + ctx.settings.Xdumpclasses.valueSetByUser + .map(p => Paths.get(p)) + .filter(path => Files.exists(path).tap(ok => if !ok then report.error(em"Output dir does not exist: ${path.toString}"))) + .map(_.toPlainFile) + + FileWriters.ClassfileWriter(ctx.settings.outputDir.value, ctx.settings.XmainClass.valueSetByUser, dumpClassesPath) + } private type ClassnamePosition = (String, SourcePosition) private val caseInsensitively = new ConcurrentHashMap[String, ClassnamePosition] - def sendToDisk(clazz: GeneratedClass, sourceFile: AbstractFile): Unit = if !frontendAccess.compilerSettings.outputOnlyTasty then { + def sendToDisk(clazz: GeneratedClass): Unit = { val classNode = clazz.classNode val internalName = classNode.name.nn val bytes = @@ -49,21 +61,21 @@ class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, case e: java.lang.RuntimeException if e.getMessage != null && e.getMessage.contains("too large!") => report.error(em"Could not write class $internalName because it exceeds JVM code size limits. ${e.getMessage}") null - case ex: Throwable => - if frontendAccess.compilerSettings.debug then ex.printStackTrace() + case ex: Exception => + if ctx.debug then ex.printStackTrace() report.error(em"Error while emitting $internalName\n${ex.getMessage}") null if bytes != null then TraceUtils.traceSerializedClassIfRequested(internalName, bytes) - val clsFile = classfileWriter.writeClass(internalName, bytes, sourceFile) + val clsFile = classfileWriter.writeClass(internalName, bytes) clazz.onFileCreated(clsFile) } - def sendToDisk(tasty: GeneratedTasty, sourceFile: AbstractFile): Unit = { + def sendToDisk(tasty: GeneratedTasty): Unit = { val GeneratedTasty(classNode, tastyGenerator) = tasty val internalName = classNode.name.nn - classfileWriter.writeTasty(classNode.name.nn, tastyGenerator(), sourceFile) + classfileWriter.writeTasty(classNode.name.nn, tastyGenerator()) } def runGlobalOptimizations(generatedUnits: Iterable[GeneratedCompilationUnit]): Unit = { @@ -78,12 +90,15 @@ class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, if !c.isArtifact // skip call graph for mirror / bean: we don't inline into them, and they are not referenced from other classes do callGraph.addClass(c.classNode) - if frontendAccess.compilerSettings.optInlinerEnabled then + if ctx.settings.optInlineEnabled then inliner.runInlinerAndClosureOptimizer() - else if frontendAccess.compilerSettings.optClosureInvocations then + else if ctx.settings.optClosureInvocations then closureOptimizer.rewriteClosureApplyInvocations(None, scala.collection.mutable.Map.empty) } + def close(): Unit = + classfileWriter.close() + private def warnCaseInsensitiveOverwrite(clazz: GeneratedClass): Unit = { val name = clazz.classNode.name val lowerCaseJavaName = name.toLowerCase @@ -117,10 +132,9 @@ class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, } private def setInnerClasses(classNode: ClassNode): Unit = { - import backendUtils.{collectNestedClasses, addInnerClasses} classNode.innerClasses.nn.clear() - val (declared, referred) = collectNestedClasses(classNode) - addInnerClasses(classNode, declared, referred) + val (declared, referred) = bTypeLoader.collectNestedClasses(classNode) + backendUtils.addInnerClasses(classNode, declared, referred) } private def serializeClass(classNode: ClassNode): Array[Byte] = { @@ -147,10 +161,11 @@ class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, * This method is used by asm when computing stack map frames. */ override def getCommonSuperClass(inameA: String, inameB: String): String = { - // All types that appear in a class node need to have their ClassBType cached, see [[cachedClassBType]]. - val a = ts.classBTypeFromInternalName(inameA).get - val b = ts.classBTypeFromInternalName(inameB).get - val lub = a.jvmWiseLUB(b) + // All types that appear in a class node need to have their ClassBType cached, + // i.e., have been loaded either from symbols or from class files. + val a = bTypeLoader.previouslyConstructedClassBType(inameA).get + val b = bTypeLoader.previouslyConstructedClassBType(inameB).get + val lub = a.jvmWiseLUB(b, bTypes) val lubName = lub.internalName assert(lubName != "scala/Any") lubName // ASM caches the answer during the lifetime of a ClassWriter. We outlive that. Not sure whether caching on our side would improve things. @@ -168,5 +183,5 @@ case class GeneratedClass( isArtifact: Boolean, onFileCreated: AbstractFile => Unit) case class GeneratedTasty(classNode: ClassNode, tastyGen: () => Array[Byte]) -case class GeneratedCompilationUnit(sourceFile: AbstractFile, classes: List[GeneratedClass], tasty: List[GeneratedTasty])(using val ctx: Context) +case class GeneratedCompilationUnit(sourceFile: AbstractFile, classes: List[GeneratedClass], tasty: List[GeneratedTasty]) diff --git a/compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala b/compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala index b0f836004c1d..c9dce10f98f4 100644 --- a/compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala +++ b/compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala @@ -1,36 +1,25 @@ package dotty.tools package backend.jvm -import scala.collection.mutable.HashSet -import dotty.tools.io.AbstractFile -import dotty.tools.dotc.core.Contexts.* -import dotty.tools.dotc.classpath.* +import dotty.tools.dotc.core.Contexts.Context import dotty.tools.dotc.report -import dotty.tools.dotc.config.ScalaSettings import dotty.tools.dotc.reporting.Message import dotty.tools.dotc.util.SrcPos -import scala.collection.mutable import scala.compiletime.uninitialized /** * Abstracts the frontend data structures, specially the Context, that need to be accessed in a single-threaded manner. */ -sealed abstract class PostProcessorFrontendAccess(val ctx: FreshContext) { +final class PostProcessorFrontendAccess(val ctx: Context) { import PostProcessorFrontendAccess.* - def compilerSettings: CompilerSettings - - def getEntryPoints: List[String] - - def findClassFileAndModuleFile(name: String): Option[(io.AbstractFile, Option[io.AbstractFile])] - def optimizerWarning(msg: Context ?=> Message, site: String, pos: SrcPos): Unit = report.optimizerWarning(msg(using ctx), site, pos)(using ctx) private val frontendLock: AnyRef = new Object() - inline final def frontendSynch[T](inline x: T): T = frontendLock.synchronized(x) + private[PostProcessorFrontendAccess] def frontendSynch[T](x: => T): T = frontendLock.synchronized(x) def perRunLazy[T](init: => T): Lazy[T] = new SynchronizedLazy(this, init) } @@ -56,119 +45,4 @@ object PostProcessorFrontendAccess { v } } - - sealed trait CompilerSettings { - def debug: Boolean - def target: String // javaOutputVersion - - def dumpClassesDirectory: Option[String] - def outputDirectory: AbstractFile - - def mainClass: Option[String] - - def jarCompressionLevel: Int - def backendParallelism: Int - def backendMaxWorkerQueue: Option[Int] - def outputOnlyTasty: Boolean - - def optUnreachableCode: Boolean - def optNullnessTracking: Boolean - def optBoxUnbox: Boolean - def optCopyPropagation: Boolean - def optRedundantCasts: Boolean - def optSimplifyJumps: Boolean - def optCompactLocals: Boolean - def optClosureInvocations: Boolean - def optAllowSkipCoreModuleInit: Boolean - def optAssumeModulesNonNull: Boolean - def optAllowSkipClassLoading: Boolean - - def optInlinerEnabled: Boolean - def optInlineFrom: List[String] - def optInlineHeuristics: String - - def optWarningNoInlineMixed: Boolean - def optWarningNoInlineMissingBytecode: Boolean - def optWarningNoInlineMissingScalaInlineInfoAttr: Boolean - def optWarningEmitAtInlineFailed: Boolean - def optWarningEmitAnyInlineFailed: Boolean - - def optLogInline: Option[String] - def optTrace: Option[String] - - } - - class Impl(entryPoints: mutable.HashSet[String])(ctx: FreshContext) extends PostProcessorFrontendAccess(ctx) { - override def compilerSettings: CompilerSettings = _compilerSettings.get - private lazy val _compilerSettings: Lazy[CompilerSettings] = perRunLazy(buildCompilerSettings(using ctx)) - - private def buildCompilerSettings(using ctx: Context): CompilerSettings = new CompilerSettings { - extension [T](s: dotty.tools.dotc.config.Settings.Setting[T]) - def valueSetByUser: Option[T] = Option(s.value).filter(_ != s.default) - - inline def s: ScalaSettings = ctx.settings - - override val target: String = - val releaseValue = Option(s.javaOutputVersion.value).filter(_.nonEmpty) - val targetValue = Option(s.XuncheckedJavaOutputVersion.value).filter(_.nonEmpty) - (releaseValue, targetValue) match - case (Some(release), None) => release - case (None, Some(target)) => target - case (Some(release), Some(_)) => - report.warning(s"The value of ${s.XuncheckedJavaOutputVersion.name} was overridden by ${ctx.settings.javaOutputVersion.name}") - release - case (None, None) => "17" // least supported version by default - - override val debug: Boolean = ctx.debug - override val dumpClassesDirectory: Option[String] = s.Xdumpclasses.valueSetByUser - override val outputDirectory: AbstractFile = s.outputDir.value - override val mainClass: Option[String] = s.XmainClass.valueSetByUser - override val jarCompressionLevel: Int = s.XjarCompressionLevel.value - override val backendParallelism: Int = s.YbackendParallelism.value - override val backendMaxWorkerQueue: Option[Int] = s.YbackendWorkerQueue.valueSetByUser - - @annotation.nowarn("cat=deprecation") - override val outputOnlyTasty: Boolean = s.YoutputOnlyTasty.value - - override def optUnreachableCode: Boolean = s.optUnreachableCode - override def optNullnessTracking: Boolean = s.optNullnessTracking - override def optBoxUnbox: Boolean = s.optBoxUnbox - override def optCopyPropagation: Boolean = s.optCopyPropagation - override def optRedundantCasts: Boolean = s.optRedundantCasts - override def optSimplifyJumps: Boolean = s.optSimplifyJumps - override def optCompactLocals: Boolean = s.optCompactLocals - override def optClosureInvocations: Boolean = s.optClosureInvocations - override def optAllowSkipCoreModuleInit: Boolean = s.optAllowSkipCoreModuleInit - override def optAssumeModulesNonNull: Boolean = s.optAssumeModulesNonNull - override def optAllowSkipClassLoading: Boolean = s.optAllowSkipClassLoading - override def optInlinerEnabled: Boolean = s.optInline.value.nonEmpty - override def optInlineFrom: List[String] = s.optInline.value - override def optInlineHeuristics: String = s.YoptInlineHeuristics.value - override def optWarningNoInlineMixed: Boolean = s.optWarningNoInlineMixed - override def optWarningNoInlineMissingBytecode: Boolean = s.optWarningNoInlineMissingBytecode - override def optWarningNoInlineMissingScalaInlineInfoAttr: Boolean = s.optWarningNoInlineMissingScalaInlineInfoAttr - override def optWarningEmitAtInlineFailed: Boolean = s.optWarningEmitAtInlineFailed - override def optWarningEmitAnyInlineFailed: Boolean = s.optWarningEmitAnyInlineFailed - override def optLogInline: Option[String] = s.YoptLogInline.valueSetByUser - override def optTrace: Option[String] = s.YoptTrace.valueSetByUser - } - - override def getEntryPoints: List[String] = entryPoints.toList - - /* Create a class path for the backend, based on the given class path. - * Used to make classes available to the inliner's bytecode repository. - * In particular, if ct.sym is used for compilation, replace it with jrt. - */ - private lazy val optimizerClassPath = ctx.platform.classPath(using ctx) match { - case cp @ AggregateClassPath(entries) if entries.head.isInstanceOf[CtSymClassPath] => - JrtClassPath(release = None) match { - case Some(jrt) => AggregateClassPath(entries.drop(1).prepended(jrt)) - case _ => cp - } - case cp => cp - } - - override def findClassFileAndModuleFile(name: String): Option[(io.AbstractFile, Option[io.AbstractFile])] = - optimizerClassPath.findClassFileAndModuleFile(name) - } } diff --git a/compiler/src/dotty/tools/backend/jvm/WellKnownBTypes.scala b/compiler/src/dotty/tools/backend/jvm/WellKnownBTypes.scala new file mode 100644 index 000000000000..1059f29ce150 --- /dev/null +++ b/compiler/src/dotty/tools/backend/jvm/WellKnownBTypes.scala @@ -0,0 +1,348 @@ +package dotty.tools.backend.jvm + +import dotty.tools.dotc.core.Symbols.* +import dotty.tools.dotc.transform.Erasure + +import scala.tools.asm.{Handle, Opcodes} +import dotty.tools.dotc.core.Symbols +import BTypes.* +import dotty.tools.dotc.core.Contexts.Context +import dotty.tools.dotc.core.StdNames.* +import PostProcessorFrontendAccess.Lazy + + +case class MethodNameAndType(name: String, methodType: MethodBType) + +final class WellKnownBTypes(ppa: PostProcessorFrontendAccess, ts: BTypeLoader)(using Context) { + + def ObjectRef: ClassBType = _ObjectRef.get + private lazy val _ObjectRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(defn.ObjectClass)) + + def srNothingRef: ClassBType = _srNothingRef.get + private lazy val _srNothingRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(defn.RuntimeNothingClass)) + + def srNullRef: ClassBType = _srNullRef.get + private lazy val _srNullRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(defn.RuntimeNullClass)) + + /** + * Map from primitive types to their boxed class type. Useful when pushing class literals onto the + * operand stack (ldc instruction taking a class literal), see genConstant. + */ + def boxedClassOfPrimitive: Map[BType, ClassBType] = _boxedClassOfPrimitive.get + private lazy val _boxedClassOfPrimitive: Lazy[Map[BType, ClassBType]] = ppa.perRunLazy(Map( + UNIT -> ts.classBTypeFromSymbol(requiredClass[java.lang.Void]), + BOOL -> ts.classBTypeFromSymbol(requiredClass[java.lang.Boolean]), + BYTE -> ts.classBTypeFromSymbol(requiredClass[java.lang.Byte]), + SHORT -> ts.classBTypeFromSymbol(requiredClass[java.lang.Short]), + CHAR -> ts.classBTypeFromSymbol(requiredClass[java.lang.Character]), + INT -> ts.classBTypeFromSymbol(requiredClass[java.lang.Integer]), + LONG -> ts.classBTypeFromSymbol(requiredClass[java.lang.Long]), + FLOAT -> ts.classBTypeFromSymbol(requiredClass[java.lang.Float]), + DOUBLE -> ts.classBTypeFromSymbol(requiredClass[java.lang.Double]) + )) + + lazy val boxedClasses: Set[ClassBType] = boxedClassOfPrimitive.values.toSet + + /** + * Maps the method symbol for a box method to the boxed type of the result. For example, the + * method symbol for `Byte.box()` is mapped to the ClassBType `java/lang/Byte`. + */ + def boxResultType: Map[Symbol, ClassBType] = _boxResultType.get + private lazy val _boxResultType: Lazy[Map[Symbol, ClassBType]] = ppa.perRunLazy{ + val boxMethods = defn.ScalaValueClasses().map{x => + (x, Erasure.Boxing.boxMethod(x.asClass)) + }.toMap + for ((valueClassSym, boxMethodSym) <- boxMethods) + yield boxMethodSym -> boxedClassOfPrimitive(ts.bTypeFromSymbol(valueClassSym)) + } + + /** + * Maps the method symbol for an unbox method to the primitive type of the result. + * For example, the method symbol for `Byte.unbox()` is mapped to the PrimitiveBType BYTE. */ + def unboxResultType: Map[Symbol, BType] = _unboxResultType.get + private lazy val _unboxResultType = ppa.perRunLazy[Map[Symbol, BType]]{ + val unboxMethods: Map[Symbol, Symbol] = + defn.ScalaValueClasses().map(x => (x, Erasure.Boxing.unboxMethod(x.asClass))).toMap + for ((valueClassSym, unboxMethodSym) <- unboxMethods) + yield unboxMethodSym -> ts.bTypeFromSymbol(valueClassSym) + } + + def srBoxedUnitRef: ClassBType = _srBoxedUnitRef.get + private lazy val _srBoxedUnitRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[scala.runtime.BoxedUnit])) + + def StringRef: ClassBType = _StringRef.get + private lazy val _StringRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(defn.StringClass)) + + def PredefRef: ClassBType = _PredefRef.get + private lazy val _PredefRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(defn.ScalaPredefModuleClass)) + + def jlClassRef: ClassBType = _jlClassRef.get + private lazy val _jlClassRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[java.lang.Class[?]])) + + def jlThrowableRef: ClassBType = _jlThrowableRef.get + private lazy val _jlThrowableRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(defn.ThrowableClass)) + + def jlCloneableRef: ClassBType = _jlCloneableRef.get + private lazy val _jlCloneableRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(defn.JavaCloneableClass)) + + def jiSerializableRef: ClassBType = _jiSerializableRef.get + private lazy val _jiSerializableRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[java.io.Serializable])) + + def jlClassCastExceptionRef: ClassBType = _jlClassCastExceptionRef.get + private lazy val _jlClassCastExceptionRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[java.lang.ClassCastException])) + + def jlIllegalArgExceptionRef: ClassBType = _jlIllegalArgExceptionRef.get + private lazy val _jlIllegalArgExceptionRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[java.lang.IllegalArgumentException])) + + def jliSerializedLambdaRef: ClassBType = _jliSerializedLambdaRef.get + private lazy val _jliSerializedLambdaRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[java.lang.invoke.SerializedLambda])) + + def srBoxesRuntimeRef: ClassBType = _srBoxesRuntimeRef.get + private lazy val _srBoxesRuntimeRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[scala.runtime.BoxesRunTime])) + + private def jliCallSiteRef: ClassBType = _jliCallSiteRef.get + private lazy val _jliCallSiteRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[java.lang.invoke.CallSite])) + + private def jliLambdaMetafactoryRef: ClassBType = _jliLambdaMetafactoryRef.get + private lazy val _jliLambdaMetafactoryRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[java.lang.invoke.LambdaMetafactory])) + + private def jliMethodHandleRef: ClassBType = _jliMethodHandleRef.get + private lazy val _jliMethodHandleRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(defn.MethodHandleClass)) + + private def jliMethodHandlesLookupRef: ClassBType = _jliMethodHandlesLookupRef.get + private lazy val _jliMethodHandlesLookupRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(defn.MethodHandlesLookupClass)) + + private def jliMethodTypeRef: ClassBType = _jliMethodTypeRef.get + private lazy val _jliMethodTypeRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[java.lang.invoke.MethodType])) + + private def jliStringConcatFactoryRef: ClassBType = _jliStringConcatFactoryRef.get + private lazy val _jliStringConcatFactoryRef: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[java.lang.invoke.StringConcatFactory])) + + private def srLambdaDeserialize: ClassBType = _srLambdaDeserialize.get + private lazy val _srLambdaDeserialize: Lazy[ClassBType] = ppa.perRunLazy(ts.classBTypeFromSymbol(requiredClass[scala.runtime.LambdaDeserialize])) + + + def jliLambdaMetaFactoryMetafactoryHandle: Handle = _jliLambdaMetaFactoryMetafactoryHandle.get + private lazy val _jliLambdaMetaFactoryMetafactoryHandle: Lazy[Handle] = ppa.perRunLazy{new Handle( + Opcodes.H_INVOKESTATIC, + jliLambdaMetafactoryRef.internalName, + "metafactory", + MethodBType( + List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, jliMethodTypeRef, jliMethodHandleRef, jliMethodTypeRef), + jliCallSiteRef + ).descriptor, + /* itf = */ false)} + + def jliLambdaMetaFactoryAltMetafactoryHandle: Handle = _jliLambdaMetaFactoryAltMetafactoryHandle.get + private lazy val _jliLambdaMetaFactoryAltMetafactoryHandle: Lazy[Handle] = ppa.perRunLazy{ new Handle( + Opcodes.H_INVOKESTATIC, + jliLambdaMetafactoryRef.internalName, + "altMetafactory", + MethodBType( + List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, ArrayBType(ObjectRef)), + jliCallSiteRef + ).descriptor, + /* itf = */ false)} + + def jliLambdaDeserializeBootstrapHandle: Handle = _jliLambdaDeserializeBootstrapHandle.get + private lazy val _jliLambdaDeserializeBootstrapHandle: Lazy[Handle] = ppa.perRunLazy{ new Handle( + Opcodes.H_INVOKESTATIC, + srLambdaDeserialize.internalName, + "bootstrap", + MethodBType( + List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, ArrayBType(jliMethodHandleRef)), + jliCallSiteRef + ).descriptor, + /* itf = */ false)} + + def jliStringConcatFactoryMakeConcatWithConstantsHandle: Handle = _jliStringConcatFactoryMakeConcatWithConstantsHandle.get + private lazy val _jliStringConcatFactoryMakeConcatWithConstantsHandle: Lazy[Handle] = ppa.perRunLazy{ new Handle( + Opcodes.H_INVOKESTATIC, + jliStringConcatFactoryRef.internalName, + "makeConcatWithConstants", + MethodBType( + List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, StringRef, ArrayBType(ObjectRef)), + jliCallSiteRef + ).descriptor, + /* itf = */ false)} + + /** + * Methods in scala.runtime.BoxesRuntime + * No need to wrap in Lazy to synchronize access, symbols won't change + */ + lazy val asmBoxTo : Map[BType, MethodNameAndType] = Map( + BOOL -> MethodNameAndType("boxToBoolean", MethodBType(List(BOOL), boxedClassOfPrimitive(BOOL))), + BYTE -> MethodNameAndType("boxToByte", MethodBType(List(BYTE), boxedClassOfPrimitive(BYTE))), + CHAR -> MethodNameAndType("boxToCharacter", MethodBType(List(CHAR), boxedClassOfPrimitive(CHAR))), + SHORT -> MethodNameAndType("boxToShort", MethodBType(List(SHORT), boxedClassOfPrimitive(SHORT))), + INT -> MethodNameAndType("boxToInteger", MethodBType(List(INT), boxedClassOfPrimitive(INT))), + LONG -> MethodNameAndType("boxToLong", MethodBType(List(LONG), boxedClassOfPrimitive(LONG))), + FLOAT -> MethodNameAndType("boxToFloat", MethodBType(List(FLOAT), boxedClassOfPrimitive(FLOAT))), + DOUBLE -> MethodNameAndType("boxToDouble", MethodBType(List(DOUBLE), boxedClassOfPrimitive(DOUBLE))) + ) + + lazy val asmUnboxTo: Map[BType, MethodNameAndType] = Map( + BOOL -> MethodNameAndType("unboxToBoolean", MethodBType(List(ObjectRef), BOOL)), + BYTE -> MethodNameAndType("unboxToByte", MethodBType(List(ObjectRef), BYTE)), + CHAR -> MethodNameAndType("unboxToChar", MethodBType(List(ObjectRef), CHAR)), + SHORT -> MethodNameAndType("unboxToShort", MethodBType(List(ObjectRef), SHORT)), + INT -> MethodNameAndType("unboxToInt", MethodBType(List(ObjectRef), INT)), + LONG -> MethodNameAndType("unboxToLong", MethodBType(List(ObjectRef), LONG)), + FLOAT -> MethodNameAndType("unboxToFloat", MethodBType(List(ObjectRef), FLOAT)), + DOUBLE -> MethodNameAndType("unboxToDouble", MethodBType(List(ObjectRef), DOUBLE)) + ) + + lazy val typeOfArrayOp: Map[Int, BType] = { + import dotty.tools.backend.ScalaPrimitivesOps.* + Map( + (List(ZARRAY_LENGTH, ZARRAY_GET, ZARRAY_SET) map (_ -> BOOL)) ++ + (List(BARRAY_LENGTH, BARRAY_GET, BARRAY_SET) map (_ -> BYTE)) ++ + (List(SARRAY_LENGTH, SARRAY_GET, SARRAY_SET) map (_ -> SHORT)) ++ + (List(CARRAY_LENGTH, CARRAY_GET, CARRAY_SET) map (_ -> CHAR)) ++ + (List(IARRAY_LENGTH, IARRAY_GET, IARRAY_SET) map (_ -> INT)) ++ + (List(LARRAY_LENGTH, LARRAY_GET, LARRAY_SET) map (_ -> LONG)) ++ + (List(FARRAY_LENGTH, FARRAY_GET, FARRAY_SET) map (_ -> FLOAT)) ++ + (List(DARRAY_LENGTH, DARRAY_GET, DARRAY_SET) map (_ -> DOUBLE)) ++ + (List(OARRAY_LENGTH, OARRAY_GET, OARRAY_SET) map (_ -> ObjectRef)) * + ) + } + + // java/lang/Boolean -> MethodNameAndType(valueOf,(Z)Ljava/lang/Boolean;) + def javaBoxMethods: Map[InternalName, MethodNameAndType] = _javaBoxMethods.get + private lazy val _javaBoxMethods: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { + Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { + val boxed = defn.boxedClass(primitive) + val unboxed = ts.bTypeFromSymbol(primitive) + val method = MethodNameAndType("valueOf", MethodBType(List(unboxed), boxedClassOfPrimitive(unboxed))) + (ts.classBTypeFromSymbol(boxed).internalName, method) + })) + } + + // java/lang/Boolean -> MethodNameAndType(booleanValue,()Z) + def javaUnboxMethods: Map[InternalName, MethodNameAndType] = _javaUnboxMethods.get + private lazy val _javaUnboxMethods: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { + Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { + val boxed = defn.boxedClass(primitive) + val name = primitive.name.toString.toLowerCase + "Value" + (ts.classBTypeFromSymbol(boxed).internalName, MethodNameAndType(name, MethodBType(Nil, ts.bTypeFromSymbol(primitive)))) + })) + } + + private def predefBoxingMethods(isBox: Boolean, getName: (String, String) => String): Map[String, MethodBType] = + Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { + val unboxed = ts.bTypeFromSymbol(primitive) + val boxed = boxedClassOfPrimitive(unboxed) + val name = getName(primitive.name.toString, defn.boxedClass(primitive).name.toString) + (name, MethodBType(List(if isBox then unboxed else boxed), if isBox then boxed else unboxed)) + })) + + // boolean2Boolean -> (Z)Ljava/lang/Boolean; + def predefAutoBoxMethods: Map[String, MethodBType] = _predefAutoBoxMethods.get + private lazy val _predefAutoBoxMethods: Lazy[Map[String, MethodBType]] = ppa.perRunLazy(predefBoxingMethods(true, (primitive, boxed) => primitive.toLowerCase + "2" + boxed)) + + // Boolean2boolean -> (Ljava/lang/Boolean;)Z + def predefAutoUnboxMethods: Map[String, MethodBType] = _predefAutoUnboxMethods.get + private lazy val _predefAutoUnboxMethods: Lazy[Map[String, MethodBType]] = ppa.perRunLazy(predefBoxingMethods(false, (primitive, boxed) => boxed + "2" + primitive.toLowerCase)) + + // scala/runtime/BooleanRef -> MethodNameAndType(create,(Z)Lscala/runtime/BooleanRef;) + def srRefCreateMethods: Map[InternalName, MethodNameAndType] = _srRefCreateMethods.get + private lazy val _srRefCreateMethods: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { + Map.from(defn.ScalaValueClassesNoUnit().union(Set(defn.ObjectClass)).flatMap(primitive => { + val boxed = if primitive == defn.ObjectClass then primitive else defn.boxedClass(primitive) + val unboxed = if primitive == defn.ObjectClass then ObjectRef else ts.bTypeFromSymbol(primitive) + val refClass = Symbols.requiredClass("scala.runtime." + primitive.name.toString + "Ref") + val volatileRefClass = Symbols.requiredClass("scala.runtime.Volatile" + primitive.name.toString + "Ref") + List( + (ts.classBTypeFromSymbol(refClass).internalName, MethodNameAndType(nme.create.toString, MethodBType(List(unboxed), ts.bTypeFromSymbol(refClass)))), + (ts.classBTypeFromSymbol(volatileRefClass).internalName, MethodNameAndType(nme.create.toString, MethodBType(List(unboxed), ts.bTypeFromSymbol(volatileRefClass)))) + ) + })) + } + + // scala/runtime/BooleanRef -> MethodNameAndType(zero,()Lscala/runtime/BooleanRef;) + def srRefZeroMethods: Map[InternalName, MethodNameAndType] = _srRefZeroMethods.get + private lazy val _srRefZeroMethods: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { + Map.from(defn.ScalaValueClassesNoUnit().union(Set(defn.ObjectClass)).flatMap(primitive => { + val boxed = if primitive == defn.ObjectClass then primitive else defn.boxedClass(primitive) + val refClass = Symbols.requiredClass("scala.runtime." + primitive.name.toString + "Ref") + val volatileRefClass = Symbols.requiredClass("scala.runtime.Volatile" + primitive.name.toString + "Ref") + List( + (ts.classBTypeFromSymbol(refClass).internalName, MethodNameAndType(nme.zero.toString, MethodBType(List(), ts.bTypeFromSymbol(refClass)))), + (ts.classBTypeFromSymbol(volatileRefClass).internalName, MethodNameAndType(nme.zero.toString, MethodBType(List(), ts.bTypeFromSymbol(volatileRefClass)))) + ) + })) + } + + // java/lang/Boolean -> MethodNameAndType(,(Z)V) + def primitiveBoxConstructors: Map[InternalName, MethodNameAndType] = _primitiveBoxConstructors.get + private lazy val _primitiveBoxConstructors: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { + Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { + val boxed = defn.boxedClass(primitive) + val unboxed = ts.bTypeFromSymbol(primitive) + (ts.classBTypeFromSymbol(boxed).internalName, MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(unboxed), UNIT))) + })) + } + + // Z -> MethodNameAndType(boxToBoolean,(Z)Ljava/lang/Boolean;) + def srBoxesRuntimeBoxToMethods: Map[BType, MethodNameAndType] = _srBoxesRuntimeBoxToMethods.get + private lazy val _srBoxesRuntimeBoxToMethods: Lazy[Map[BType, MethodNameAndType]] = ppa.perRunLazy { + Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { + val bType = ts.bTypeFromSymbol(primitive) + val boxed = boxedClassOfPrimitive(bType) + val name = "boxTo" + defn.boxedClass(primitive).name.toString + (bType, MethodNameAndType(name, MethodBType(List(bType), boxed))) + })) + } + + // Z -> MethodNameAndType(unboxToBoolean,(Ljava/lang/Object;)Z) + def srBoxesRuntimeUnboxToMethods: Map[BType, MethodNameAndType] = _srBoxesRuntimeUnboxToMethods.get + private lazy val _srBoxesRuntimeUnboxToMethods: Lazy[Map[BType, MethodNameAndType]] = ppa.perRunLazy { + Map.from(defn.ScalaValueClassesNoUnit().map(primitive => { + val bType = ts.bTypeFromSymbol(primitive) + val name = "unboxTo" + primitive.name.toString + (bType, MethodNameAndType(name, MethodBType(List(ObjectRef), bType))) + })) + } + + // scala/runtime/BooleanRef -> MethodNameAndType(,(Z)V) + def srRefConstructors: Map[InternalName, MethodNameAndType] = _srRefConstructors.get + private lazy val _srRefConstructors: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { + Map.from(defn.ScalaValueClassesNoUnit().union(Set(defn.ObjectClass)).flatMap(primitive => { + val boxed = if primitive == defn.ObjectClass then primitive else defn.boxedClass(primitive) + val unboxed = if primitive == defn.ObjectClass then ObjectRef else ts.bTypeFromSymbol(primitive) + val refClass = Symbols.requiredClass("scala.runtime." + primitive.name.toString + "Ref") + val volatileRefClass = Symbols.requiredClass("scala.runtime.Volatile" + primitive.name.toString + "Ref") + List( + (ts.classBTypeFromSymbol(refClass).internalName, MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(unboxed), UNIT))), + (ts.classBTypeFromSymbol(volatileRefClass).internalName, MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(unboxed), UNIT))) + ) + })) + } + + // scala/Tuple3 -> MethodNameAndType(,(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V) + // scala/Tuple2$mcZC$sp -> MethodNameAndType(,(ZC)V) + // ... this was easy in scala2, but now we don't specialize them so we have to know each name + // tuple1 is specialized for D, I, J + // tuple2 is specialized for C, D, I, J, Z in each parameter + def tupleClassConstructors: Map[InternalName, MethodNameAndType] = _tupleClassConstructors.get + private lazy val _tupleClassConstructors: Lazy[Map[InternalName, MethodNameAndType]] = ppa.perRunLazy { + val spec1 = List(defn.DoubleClass, defn.IntClass, defn.LongClass) + val spec2 = List(defn.CharClass, defn.DoubleClass, defn.IntClass, defn.LongClass, defn.BooleanClass) + Map.from( + Iterator.concat( + (1 to 22).map { n => + ("scala/Tuple" + n, MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List.fill(n)(ObjectRef), UNIT))) + }, + spec1.map { sp1 => + val prim = ts.bTypeFromSymbol(sp1) + ("scala/Tuple1$mc" + prim.descriptor + "$sp", MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(), UNIT))) + }, + for sp2a <- spec2; sp2b <- spec2 yield { + val primA = ts.bTypeFromSymbol(sp2a) + val primB = ts.bTypeFromSymbol(sp2b) + ("scala/Tuple2$mc" + primA.descriptor + primB.descriptor + "$sp", MethodNameAndType(nme.CONSTRUCTOR.toString, MethodBType(List(primA, primB), UNIT))) + } + ) + ) + } +} diff --git a/compiler/src/dotty/tools/backend/jvm/analysis/AliasingAnalyzer.scala b/compiler/src/dotty/tools/backend/jvm/analysis/AliasingAnalyzer.scala index 3cb707a49b42..5b694eda68c4 100644 --- a/compiler/src/dotty/tools/backend/jvm/analysis/AliasingAnalyzer.scala +++ b/compiler/src/dotty/tools/backend/jvm/analysis/AliasingAnalyzer.scala @@ -52,7 +52,7 @@ class AliasingFrame[V <: Value](nLocals: Int, nStack: Int) extends Frame[V](nLoc * - If `aliases(i) contains j` then `aliases(i) eq aliases(j)`, i.e., they are references to the * same (mutable) AliasSet. */ - val aliases: Array[AliasSet | Null] = new Array[AliasSet | Null](getLocals + getMaxStackSize) + val aliases: Array[AliasSet | Null] = new Array[AliasSet | Null](nLocals + nStack) /** * The set of aliased values for a given entry in the `values` array. diff --git a/compiler/src/dotty/tools/backend/jvm/opt/BCodeRepository.scala b/compiler/src/dotty/tools/backend/jvm/opt/BCodeRepository.scala index 6f625619e589..59a4b453e10b 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/BCodeRepository.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/BCodeRepository.scala @@ -15,11 +15,11 @@ package dotty.tools.backend.jvm.opt import dotty.tools.backend.jvm.BCodeUtils.* import dotty.tools.backend.jvm.BTypes.InternalName import dotty.tools.backend.jvm.BackendUtils.LambdaMetaFactoryCall -import dotty.tools.backend.jvm.PostProcessorFrontendAccess.Lazy import dotty.tools.backend.jvm.opt.* -import dotty.tools.backend.jvm.{BackendUtils, ClassNode1, CoreBTypes, PostProcessorFrontendAccess} -import dotty.tools.dotc.core.Decorators.em -import dotty.tools.dotc.util.NoSourcePosition +import dotty.tools.backend.jvm.{BackendUtils, ClassNode1} +import dotty.tools.dotc.classpath.{AggregateClassPath, CtSymClassPath, JrtClassPath} +import dotty.tools.io +import dotty.tools.io.ClassPath import scala.collection.{concurrent, mutable} import scala.jdk.CollectionConverters.* @@ -31,7 +31,7 @@ import scala.tools.asm.{Attribute, ClassReader, Type} * The BCodeRepository provides utilities to read the bytecode of classfiles from the compilation * classpath. Parsed classes are cached in the `classes` map. */ -class BCodeRepository(frontendAccess: PostProcessorFrontendAccess, backendUtils: BackendUtils, ts: CoreBTypes) { +class BCodeRepository(classPath: ClassPath, backendUtils: BackendUtils) { type ClassAndModuleNodes = (ClassNode, Option[ModuleNode]) @@ -39,7 +39,7 @@ class BCodeRepository(frontendAccess: PostProcessorFrontendAccess, backendUtils: * Contains ClassNodes and the canonical path of the source file path of classes being compiled in * the current compilation run. */ - val compilingClasses: Lazy[concurrent.Map[InternalName, (ClassAndModuleNodes, String)]] = frontendAccess.perRunLazy(concurrent.TrieMap.empty) + val compilingClasses: concurrent.Map[InternalName, (ClassAndModuleNodes, String)] = concurrent.TrieMap.empty /** * Prevent the code repository from growing too large. Profiling reveals that the average size @@ -54,16 +54,16 @@ class BCodeRepository(frontendAccess: PostProcessorFrontendAccess, backendUtils: * Note - although this is typed a mutable.Map, individual simple get and put operations are threadsafe as the * underlying data structure is synchronized. */ - private val parsedClasses: Lazy[mutable.Map[InternalName, Either[ClassNotFound, ClassAndModuleNodes]]] = - frontendAccess.perRunLazy(FifoCache[InternalName, Either[ClassNotFound, ClassAndModuleNodes]](maxCacheSize, threadsafe = true)) + private val parsedClasses: mutable.Map[InternalName, Either[ClassNotFound, ClassAndModuleNodes]] = + FifoCache[InternalName, Either[ClassNotFound, ClassAndModuleNodes]](maxCacheSize, threadsafe = true) def add(classNode: ClassNode, sourceFilePath: Option[String]): Unit = sourceFilePath match { - case Some(path) if path != "" => compilingClasses.get(classNode.name) = ((classNode, None), path) - case _ => parsedClasses.get(classNode.name) = Right(classNode, None) + case Some(path) if path != "" => compilingClasses(classNode.name) = ((classNode, None), path) + case _ => parsedClasses(classNode.name) = Right(classNode, None) } private def parsedClassNode(internalName: InternalName): Either[ClassNotFound, ClassAndModuleNodes] = { - parsedClasses.get.getOrElseUpdate(internalName, parseClass(internalName)) + parsedClasses.getOrElseUpdate(internalName, parseClass(internalName)) } /** @@ -71,7 +71,7 @@ class BCodeRepository(frontendAccess: PostProcessorFrontendAccess, backendUtils: * the class node is not yet available, it is parsed from the classfile on the compile classpath. */ def classNodeAndSourceFilePath(internalName: InternalName): Either[ClassNotFound, (ClassAndModuleNodes, Option[String])] = { - compilingClasses.get.get(internalName) match { + compilingClasses.get(internalName) match { case Some((c, p)) => Right((c, Some(p))) case _ => parsedClassNode(internalName).map((_, None)) } @@ -82,7 +82,7 @@ class BCodeRepository(frontendAccess: PostProcessorFrontendAccess, backendUtils: * the classfile on the compile classpath. */ def classNode(internalName: InternalName): Either[ClassNotFound, ClassAndModuleNodes] = { - compilingClasses.get.get(internalName) match { + compilingClasses.get(internalName) match { case Some((c, _)) => Right(c) case None => parsedClassNode(internalName) } @@ -158,11 +158,12 @@ class BCodeRepository(frontendAccess: PostProcessorFrontendAccess, backendUtils: // https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-2.html#jvms-2.9.3 def findSignaturePolymorphic(owner: ClassNode): Option[MethodNode] = { def hasObjectArrayParam(m: MethodNode) = Type.getArgumentTypes(m.desc) match { - case Array(pt) => pt.getDimensions == 1 && pt.getElementType.getInternalName == ts.ObjectRef.internalName + case Array(pt) => pt.getDimensions == 1 && pt.getElementType.getInternalName == "java/lang/Object" case _ => false } - // Don't try to build a BType for `VarHandle`, it doesn't exist on JDK 8 - if (owner.name == ts.jliMethodHandleRef.internalName || owner.name == "java/lang/invoke/VarHandle") + // We don't need to explicitly load the BTypes of MethodHandle or VarHandle for later use here, + // because if we've reached this point, `owner` has been loaded already. + if (owner.name == "java/lang/invoke/MethodHandle" || owner.name == "java/lang/invoke/VarHandle") owner.methods.asScala.find(m => m.name == name && isNativeMethod(m) && @@ -282,44 +283,50 @@ class BCodeRepository(frontendAccess: PostProcessorFrontendAccess, backendUtils: } } - private def parseClass(internalName: InternalName): Either[ClassNotFound, ClassAndModuleNodes] = { - val fullName = internalName.replace('/', '.') - frontendAccess.findClassFileAndModuleFile(fullName).flatMap { (classFile, moduleFile) => - val classNode = new ClassNode1 - val classReader = new ClassReader(classFile.toByteArray) - - try { - // Passing the InlineInfoAttributePrototype makes the ClassReader invoke the specific `read` - // method of the InlineInfoAttribute class, instead of putting the byte array into a generic - // Attribute. - // We don't need frames when inlining, but we want to keep the local variable table, so we - // don't use SKIP_DEBUG. - classReader.accept(classNode, Array[Attribute](InlineInfoAttributePrototype), ClassReader.SKIP_FRAMES) - // SKIP_FRAMES leaves line number nodes. Remove them because they are not correct after - // inlining. - // TODO: we need to remove them also for classes that are not parsed from classfiles, why not simplify and do it once when inlining? - // OR: instead of skipping line numbers for inlined code, use write a SourceDebugExtension - // attribute that contains JSR-45 data that encodes debugging info. - // https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.11 - // https://jcp.org/aboutJava/communityprocess/final/jsr045/index.html - removeLineNumbersAndAddLMFImplMethods(classNode) - - val moduleNode = moduleFile.map(f => - val node = new ClassNode1 - val moduleReader = new ClassReader(f.toByteArray) - moduleReader.accept(node, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES) - node.module - ) - - Some(classNode, moduleNode) - } catch { - case ex: Exception => - frontendAccess.optimizerWarning(em"Error while reading InlineInfoAttribute: ${ex.getMessage}", fullName, NoSourcePosition) - None + /* Create a class path for the backend, based on the given class path. + * Used to make classes available to the inliner's bytecode repository. + * In particular, if ct.sym is used for compilation, replace it with jrt. + */ + private lazy val optimizerClassPath = classPath match { + case cp@AggregateClassPath(entries) if entries.head.isInstanceOf[CtSymClassPath] => + JrtClassPath(release = None) match { + case Some(jrt) => AggregateClassPath(entries.drop(1).prepended(jrt)) + case _ => cp } - } match { - case Some(nodes) => Right(nodes) - case None => Left(ClassNotFound(internalName)) - } + case cp => cp + } + + private def parseClass(internalName: InternalName): Either[ClassNotFound, ClassAndModuleNodes] = { + try + val fullName = internalName.replace('/', '.') + optimizerClassPath.findClassFileAndModuleFile(fullName) match + case Some(classFile, moduleFile) => + val classNode = new ClassNode1 + val classReader = new ClassReader(classFile.toByteArray) + // Passing the InlineInfoAttributePrototype makes the ClassReader invoke the specific `read` + // method of the InlineInfoAttribute class, instead of putting the byte array into a generic + // Attribute. + // We don't need frames when inlining, but we want to keep the local variable table, so we + // don't use SKIP_DEBUG. + classReader.accept(classNode, Array[Attribute](InlineInfoAttributePrototype), ClassReader.SKIP_FRAMES) + // SKIP_FRAMES leaves line number nodes. Remove them because they are not correct after + // inlining. + // TODO: we need to remove them also for classes that are not parsed from classfiles, why not simplify and do it once when inlining? + // OR: instead of skipping line numbers for inlined code, use write a SourceDebugExtension + // attribute that contains JSR-45 data that encodes debugging info. + // https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.11 + // https://jcp.org/aboutJava/communityprocess/final/jsr045/index.html + removeLineNumbersAndAddLMFImplMethods(classNode) + val moduleNode = moduleFile.map(f => + val node = new ClassNode1 + val moduleReader = new ClassReader(f.toByteArray) + moduleReader.accept(node, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES) + node.module + ) + Right(classNode, moduleNode) + case None => + Left(ClassNotFound(internalName)) + catch + case _: Exception => Left(ClassNotFound(internalName)) } } diff --git a/compiler/src/dotty/tools/backend/jvm/opt/BTypesFromClassfile.scala b/compiler/src/dotty/tools/backend/jvm/opt/BTypesFromClassfile.scala index 32c8fec8b8bf..12f2046ec9ee 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/BTypesFromClassfile.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/BTypesFromClassfile.scala @@ -13,7 +13,6 @@ package dotty.tools.backend.jvm.opt import dotty.tools.backend.jvm.BTypes.InternalName -import dotty.tools.backend.jvm.PostProcessorFrontendAccess.Lazy import dotty.tools.backend.jvm.opt.{BCodeRepository, ClassNotFound, NoClassBTypeInfo, OptimizerWarning} import dotty.tools.backend.jvm.* import dotty.tools.dotc.core.StdNames.nme @@ -24,7 +23,7 @@ import scala.jdk.CollectionConverters.* import scala.tools.asm.Opcodes import scala.tools.asm.tree.{ClassNode, InnerClassNode, ModuleNode} -class BTypesFromClassfile(val byteCodeRepository: BCodeRepository, ts: CoreBTypes) extends InlineInfoLoader { +class BTypesFromClassfile(byteCodeRepository: BCodeRepository, bTypeLoader: BTypeLoader) extends InlineInfoLoader { /** * Obtain the BType for a type descriptor or internal name. For class descriptors, the ClassBType @@ -43,18 +42,19 @@ class BTypesFromClassfile(val byteCodeRepository: BCodeRepository, ts: CoreBType } def bTypeForDescriptorFromClassfile(desc: String): Either[OptimizerWarning, BType] = (desc(0): @switch) match { - case 'V' => Right(UNIT) - case 'Z' => Right(BOOL) - case 'C' => Right(CHAR) - case 'B' => Right(BYTE) - case 'S' => Right(SHORT) - case 'I' => Right(INT) - case 'F' => Right(FLOAT) - case 'J' => Right(LONG) - case 'D' => Right(DOUBLE) - case '[' => bTypeForDescriptorFromClassfile(desc.substring(1)).map(ArrayBType.apply) - case 'L' if desc.last == ';' => classBTypeFromParsedClassfile(desc.substring(1, desc.length - 1)) - case _ => throw new IllegalArgumentException(s"Not a descriptor: $desc") + case 'V' => Right(UNIT) + case 'Z' => Right(BOOL) + case 'C' => Right(CHAR) + case 'B' => Right(BYTE) + case 'S' => Right(SHORT) + case 'I' => Right(INT) + case 'F' => Right(FLOAT) + case 'J' => Right(LONG) + case 'D' => Right(DOUBLE) + case '[' => bTypeForDescriptorFromClassfile(desc.substring(1)).map(ArrayBType.apply) + case 'L' => if desc.last == ';' then classBTypeFromParsedClassfile(desc.substring(1, desc.length - 1)) + else throw new IllegalArgumentException(s"Invalid class-like descriptor: $desc") + case _ => throw new IllegalArgumentException(s"Not a descriptor: $desc") } /** @@ -62,10 +62,7 @@ class BTypesFromClassfile(val byteCodeRepository: BCodeRepository, ts: CoreBType * be found in the `byteCodeRepository`, the `info` of the resulting ClassBType is undefined. */ def classBTypeFromParsedClassfile(internalName: InternalName): Either[OptimizerWarning, ClassBType] = { - // JLS §4.1 "There is also a special null type, the type of the expression null [...] - // In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type." - if internalName == "null" then Right(ts.ObjectRef) - else ts.classBType(internalName) { _ => + bTypeLoader.classBType(internalName) { _ => byteCodeRepository.classNode(internalName) match { case Left(msg) => Left(NoClassBTypeInfo(msg)) case Right(c, m) => computeClassInfoFromClassNode(c, m) @@ -77,7 +74,7 @@ class BTypesFromClassfile(val byteCodeRepository: BCodeRepository, ts: CoreBType * Construct the [[BTypes.ClassBType]] for a parsed classfile. */ def classBTypeFromClassNode(classNode: ClassNode, moduleNode: Option[ModuleNode]): Either[OptimizerWarning, ClassBType] = { - ts.classBType(classNode.name) { _ => + bTypeLoader.classBType(classNode.name) { _ => computeClassInfoFromClassNode(classNode, moduleNode) } } @@ -85,7 +82,7 @@ class BTypesFromClassfile(val byteCodeRepository: BCodeRepository, ts: CoreBType private def computeClassInfoFromClassNode(classNode: ClassNode, moduleNode: Option[ModuleNode]): Either[OptimizerWarning, ClassInfo] = { val superClass = classNode.superName match { case null => - assert(classNode.name == ts.ObjectRef.internalName, s"class with missing super type: ${classNode.name}") + assert(classNode.name == "java/lang/Object", s"class with missing super type: ${classNode.name}") Right(None) case superName => classBTypeFromParsedClassfile(superName).map(Some.apply) diff --git a/compiler/src/dotty/tools/backend/jvm/opt/BoxUnbox.scala b/compiler/src/dotty/tools/backend/jvm/opt/BoxUnbox.scala index 7382d047b4b2..35dd1dbb79eb 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/BoxUnbox.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/BoxUnbox.scala @@ -26,7 +26,7 @@ import dotty.tools.backend.jvm.analysis.{AsmAnalyzer, ProdConsAnalyzer} import dotty.tools.backend.jvm.BCodeUtils.* import dotty.tools.dotc.core.StdNames.nme -final class BoxUnbox(backendUtils: BackendUtils, callGraph: CallGraph, ts: CoreBTypes) { +final class BoxUnbox(backendUtils: BackendUtils, callGraph: CallGraph, ts: WellKnownBTypes) { /** * Eliminate box-unbox pairs within `method`. Such appear commonly after closure elimination: diff --git a/compiler/src/dotty/tools/backend/jvm/opt/CallGraph.scala b/compiler/src/dotty/tools/backend/jvm/opt/CallGraph.scala index ae95ee4493e9..ed04e73dc57d 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/CallGraph.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/CallGraph.scala @@ -29,8 +29,7 @@ import dotty.tools.dotc.util.{SourcePosition, NoSourcePosition} import dotty.tools.backend.jvm.PostProcessorFrontendAccess.Lazy class CallGraph(frontendAccess: PostProcessorFrontendAccess, - byteCodeRepository: BCodeRepository, bTypesFromClassfile: BTypesFromClassfile, - ts: CoreBTypes) { + byteCodeRepository: BCodeRepository, bTypesFromClassfile: BTypesFromClassfile) { /** * The call graph contains the callsites in the program being compiled. diff --git a/compiler/src/dotty/tools/backend/jvm/opt/ClosureOptimizer.scala b/compiler/src/dotty/tools/backend/jvm/opt/ClosureOptimizer.scala index e93f4915d893..5a03f42bf0cc 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/ClosureOptimizer.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/ClosureOptimizer.scala @@ -30,7 +30,8 @@ import BCodeUtils.* class ClosureOptimizer(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, byteCodeRepository: BCodeRepository, callGraph: CallGraph, - ts: CoreBTypes, bTypesFromClassfile: BTypesFromClassfile) { + ts: WellKnownBTypes, bTypesFromClassfile: BTypesFromClassfile, + settings: OptimizerSettings) { import ClosureOptimizer.* @@ -142,7 +143,7 @@ class ClosureOptimizer(ppa: PostProcessorFrontendAccess, backendUtils: BackendUt if (closureInit.ownerMethod != previousMethod) { previousMethod = closureInit.ownerMethod changedMethods += previousMethod.nn - val state = inlinerState.getOrElseUpdate(previousMethod.nn, new MethodInlinerState(ppa.compilerSettings.optLogInline)) + val state = inlinerState.getOrElseUpdate(previousMethod.nn, new MethodInlinerState(settings.optLogInline)) state.inlineLog.logClosureRewrite(closureInit, invocations, invocations.headOption.flatMap(p => state.outerCallsite(p._1))) } } @@ -409,7 +410,7 @@ class ClosureOptimizer(ppa: PostProcessorFrontendAccess, backendUtils: BackendUt // the method node is needed for building the call graph entry val bodyMethod = byteCodeRepository.methodNode(lambdaBodyHandle.getOwner, lambdaBodyHandle.getName, lambdaBodyHandle.getDesc) - val sourceFilePath = byteCodeRepository.compilingClasses.get.get(lambdaBodyHandle.getOwner).map(_._2) + val sourceFilePath = byteCodeRepository.compilingClasses.get(lambdaBodyHandle.getOwner).map(_._2) val callee = bodyMethod.flatMap({ case (bodyMethodNode, bodyMethodDeclClass) => bTypesFromClassfile.classBTypeFromParsedClassfile(bodyMethodDeclClass).flatMap(bodyDeclClassType => diff --git a/compiler/src/dotty/tools/backend/jvm/opt/CopyProp.scala b/compiler/src/dotty/tools/backend/jvm/opt/CopyProp.scala index 8993e6232024..05d43b7e1ffc 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/CopyProp.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/CopyProp.scala @@ -27,7 +27,10 @@ import dotty.tools.backend.jvm.BackendUtils.* import scala.tools.asm -class CopyProp(backendUtils: BackendUtils, callGraph: CallGraph, inliner: Inliner, ts: CoreBTypes, optAllowSkipClassLoading: Boolean) { +class CopyProp(backendUtils: BackendUtils, callGraph: CallGraph, inliner: Inliner, ts: WellKnownBTypes, settings: OptimizerSettings) { + + private val modulesAllowSkipInitialization = + if settings.optAllowSkipCoreModuleInit then backendUtils.modulesAllowSkipInitialization else Set.empty /** * For every `xLOAD n`, find all local variable slots that are aliases of `n` using an @@ -473,7 +476,7 @@ class CopyProp(backendUtils: BackendUtils, callGraph: CallGraph, inliner: Inline handleInputs(prod, 1) case GETFIELD | GETSTATIC => - if (backendUtils.isBoxedUnit(prod) || BackendUtils.isJavaLangStaticLoad(prod) || BackendUtils.isModuleLoad(prod, backendUtils.modulesAllowSkipInitialization)) toRemove += prod + if (backendUtils.isBoxedUnit(prod) || BackendUtils.isJavaLangStaticLoad(prod) || BackendUtils.isModuleLoad(prod, modulesAllowSkipInitialization)) toRemove += prod else popAfterProd() // keep potential class initialization (static field) or NPE (instance field) case INVOKEVIRTUAL | INVOKESPECIAL | INVOKESTATIC | INVOKEINTERFACE => @@ -521,7 +524,7 @@ class CopyProp(backendUtils: BackendUtils, callGraph: CallGraph, inliner: Inline toRemove += prod case _ => - if (optAllowSkipClassLoading) toRemove += prod + if (settings.optAllowSkipClassLoading) toRemove += prod else popAfterProd() } diff --git a/compiler/src/dotty/tools/backend/jvm/opt/Inliner.scala b/compiler/src/dotty/tools/backend/jvm/opt/Inliner.scala index eafc532a51be..f6f8de4c6e4d 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/Inliner.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/Inliner.scala @@ -30,8 +30,9 @@ import dotty.tools.backend.jvm.BackendUtils.LambdaMetaFactoryCall import BCodeUtils.* class Inliner(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, - callGraph: CallGraph, coreBTypes: CoreBTypes, bTypesFromClassfile: BTypesFromClassfile, byteCodeRepository: BCodeRepository, - heuristics: InlinerHeuristics, closureOptimizer: ClosureOptimizer) { + callGraph: CallGraph, bTypeLoader: BTypeLoader, bTypesFromClassfile: BTypesFromClassfile, byteCodeRepository: BCodeRepository, + heuristics: InlinerHeuristics, closureOptimizer: ClosureOptimizer, + settings: OptimizerSettings) { // True if all instructions (they would cause an IllegalAccessError otherwise) can potentially be // inlined in a later inlining round. @@ -63,7 +64,7 @@ class Inliner(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, } def runInlinerAndClosureOptimizer(): Unit = { - val runClosureOptimizer = ppa.compilerSettings.optClosureInvocations + val runClosureOptimizer = settings.optClosureInvocations var round = 0 var changedByClosureOptimizer = mutable.LinkedHashSet.empty[MethodNode] @@ -139,7 +140,7 @@ class Inliner(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, // rolled back. This avoids cloning the illegal instructions in case `m` itself gets inlined. if (requests.nonEmpty && !changedMethodHasIllegalAccess) { val (method, rs) = requests.dequeue() - val state = inlinerState.getOrElseUpdate(method, new MethodInlinerState(ppa.compilerSettings.optLogInline)) + val state = inlinerState.getOrElseUpdate(method, new MethodInlinerState(settings.optLogInline)) var changed = false def doInline(r: InlineRequest, aliasFrame: AliasingFrame[Value], w: Option[IllegalAccessInstructions]): Map[AbstractInsnNode, AbstractInsnNode] = { @@ -206,14 +207,14 @@ class Inliner(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, state.rootInlinedCallsiteWithWarning(r.callsite.callsiteInstruction, returnForwarderIfNoOther = false) match { case Some(inlinedCallsite) => val rw = inlinedCallsite.warning.get - if (rw.emitWarning(ppa.compilerSettings)) { + if (rw.emitWarning(settings)) { ppa.optimizerWarning( em"${rw.toString + inlineChainSuffix(r.callsite, state.inlineChain(inlinedCallsite.eliminatedCallsite.callsiteInstruction, skipForwarders = true))}", BackendUtils.siteString(inlinedCallsite.eliminatedCallsite.callsiteClass.internalName, inlinedCallsite.eliminatedCallsite.callsiteMethod.name), inlinedCallsite.eliminatedCallsite.callsitePosition) } case _ => - if (w.emitWarning(ppa.compilerSettings)) + if (w.emitWarning(settings)) ppa.optimizerWarning( em"${w.toString + inlineChainSuffix(r.callsite, state.inlineChain(r.callsite.callsiteInstruction, skipForwarders = true))}", BackendUtils.siteString(r.callsite.callsiteClass.internalName, r.callsite.callsiteMethod.name), @@ -236,7 +237,7 @@ class Inliner(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, // look at all callsites in a methods again, also those that were previously not selected for // inlining. after inlining, types might get more precise and make a callsite inlineable. val method = changedMethods.dequeue() - val state = inlinerState.getOrElseUpdate(method, new MethodInlinerState(ppa.compilerSettings.optLogInline)) + val state = inlinerState.getOrElseUpdate(method, new MethodInlinerState(settings.optLogInline)) def isLoop(call: MethodInsnNode, callee: Callee): Boolean = callee.callee == method || { @@ -267,7 +268,7 @@ class Inliner(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, val callsite = inlinedCallsite.eliminatedCallsite val w = inlinedCallsite.warning.get state.inlineLog.logRollback(callsite, s"Instruction ${LogUtils.textify(notInlinedIllegalInsn)} would cause an IllegalAccessError, and is not selected for (or failed) inlining", state.outerCallsite(notInlinedIllegalInsn)) - if (w.emitWarning(ppa.compilerSettings)) + if (w.emitWarning(settings)) ppa.optimizerWarning( em"${w.toString + inlineChainSuffix(callsite, state.inlineChain(callsite.callsiteInstruction, skipForwarders = true))}", BackendUtils.siteString(callsite.callsiteClass.internalName, callsite.callsiteMethod.name), @@ -422,7 +423,7 @@ class Inliner(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, // New labels for the cloned instructions val labelsMap = cloneLabels(callee) val sameSourceFile = sourceFilePath match { - case Some(calleeSource) => byteCodeRepository.compilingClasses.get.get(callsite.callsiteClass.internalName) match { + case Some(calleeSource) => byteCodeRepository.compilingClasses.get(callsite.callsiteClass.internalName) match { case Some((_, `calleeSource`)) => true case _ => false } @@ -794,7 +795,7 @@ class Inliner(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, private val isInternalCache = mutable.Map.empty[String, Either[OptimizerWarning, Boolean]] private def isInternal(name: String): Either[OptimizerWarning, Boolean] = { isInternalCache.getOrElseUpdate(name, - coreBTypes.classBTypeFromInternalName(name) match + bTypeLoader.previouslyConstructedClassBType(name) match case Some(ct) => Right(!ct.info.inlineInfo.isAccessible) case None => bTypesFromClassfile.classBTypeFromParsedClassfile(name) match case Left(l) => Left(l) diff --git a/compiler/src/dotty/tools/backend/jvm/opt/InlinerHeuristics.scala b/compiler/src/dotty/tools/backend/jvm/opt/InlinerHeuristics.scala index 3c9ebbdcf99b..fc17c8054d96 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/InlinerHeuristics.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/InlinerHeuristics.scala @@ -28,13 +28,15 @@ import PostProcessorFrontendAccess.Lazy import dotty.tools.backend.jvm.BCodeUtils.{isStrictfpMethod, isSynchronizedMethod} import dotty.tools.dotc.report -class InlinerHeuristics(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, byteCodeRepository: BCodeRepository, callGraph: CallGraph, ts: CoreBTypes) { +class InlinerHeuristics(ppa: PostProcessorFrontendAccess, backendUtils: BackendUtils, byteCodeRepository: BCodeRepository, + callGraph: CallGraph, ts: WellKnownBTypes, + settings: OptimizerSettings) { - private lazy val inlineSourceMatcher: Lazy[InlineSourceMatcher] = ppa.perRunLazy(new InlineSourceMatcher(ppa.compilerSettings.optInlineFrom)) + private lazy val inlineSourceMatcher: InlineSourceMatcher = new InlineSourceMatcher(settings.optInlineFrom) - def canInlineFromSource(sourceFilePath: Option[String], calleeDeclarationClass: InternalName): Boolean = { - inlineSourceMatcher.get.allowFromSources && sourceFilePath.isDefined || - inlineSourceMatcher.get.allow(calleeDeclarationClass) + private def canInlineFromSource(sourceFilePath: Option[String], calleeDeclarationClass: InternalName): Boolean = { + inlineSourceMatcher.allowFromSources && sourceFilePath.isDefined || + inlineSourceMatcher.allow(calleeDeclarationClass) } /** @@ -47,7 +49,7 @@ class InlinerHeuristics(ppa: PostProcessorFrontendAccess, backendUtils: BackendU // classpath. In order to get only the callsites being compiled, we start at the map of // compilingClasses in the byteCodeRepository. val compilingMethods = for { - ((classNode, _), _) <- byteCodeRepository.compilingClasses.get.valuesIterator + ((classNode, _), _) <- byteCodeRepository.compilingClasses.valuesIterator methodNode <- classNode.methods.iterator.asScala } yield methodNode @@ -59,18 +61,18 @@ class InlinerHeuristics(ppa: PostProcessorFrontendAccess, backendUtils: BackendU case Some(Right(req)) => requests += req case Some(Left(w)) => - if (w.emitWarning(ppa.compilerSettings)) { + if (w.emitWarning(settings)) { ppa.optimizerWarning(em"${w.toString}", BackendUtils.siteString(callsite.callsiteClass.internalName, callsite.callsiteMethod.name), callsite.callsitePosition) } case None => - if (callsiteWarning.exists(_.emitWarning(ppa.compilerSettings))) { + if (callsiteWarning.exists(_.emitWarning(settings))) { ppa.optimizerWarning(em"there was a problem determining if method ${callee.name} can be inlined: \n${callsiteWarning.get.toString}", BackendUtils.siteString(callsite.callsiteClass.internalName, callsite.callsiteMethod.name), pos) } } case callsite @ UnknownCallsite(ins, meth, clas, pos, _, warning) => - if (warning.emitWarning(ppa.compilerSettings)) { + if (warning.emitWarning(settings)) { ppa.optimizerWarning(em"failed to determine if ${ins.name} should be inlined:\n${warning.toString}", BackendUtils.siteString(clas.internalName, meth.name), pos) } } @@ -174,7 +176,7 @@ class InlinerHeuristics(ppa: PostProcessorFrontendAccess, backendUtils: BackendU case Some(w) => Some(Left(w)) case None => - Some(Right(InlineRequest(callsite, reason, ppa.compilerSettings.optLogInline.isEmpty, ppa.compilerSettings.optInlineHeuristics == "everything"))) + Some(Right(InlineRequest(callsite, reason, settings.optLogInline.isEmpty, settings.optInlineHeuristics == "everything"))) } } @@ -188,7 +190,7 @@ class InlinerHeuristics(ppa: PostProcessorFrontendAccess, backendUtils: BackendU if (isGeneratedForwarder) None else { val callee = callsite.callee - ppa.compilerSettings.optInlineHeuristics match { + settings.optInlineHeuristics match { case "everything" => requestIfCanInline(callsite, AnnotatedInline) diff --git a/compiler/src/dotty/tools/backend/jvm/opt/LocalOpt.scala b/compiler/src/dotty/tools/backend/jvm/opt/LocalOpt.scala index 534ddb841348..63df69271d1e 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/LocalOpt.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/LocalOpt.scala @@ -150,12 +150,14 @@ import dotty.tools.backend.jvm.BackendUtils.isArrayGetLength * Note on updating the call graph: whenever an optimization eliminates a callsite or a closure * instantiation, we eliminate the corresponding entry from the call graph. */ -class LocalOpt(backendUtils: BackendUtils, ppa: PostProcessorFrontendAccess, callGraph: CallGraph, inliner: Inliner, ts: CoreBTypes, bTypesFromClassfile: BTypesFromClassfile) { +class LocalOpt(backendUtils: BackendUtils, callGraph: CallGraph, inliner: Inliner, + ts: WellKnownBTypes, bTypesFromClassfile: BTypesFromClassfile, + settings: OptimizerSettings) { import LocalOptImpls.* private val boxUnbox = new BoxUnbox(backendUtils, callGraph, ts) - private val copyProp = new CopyProp(backendUtils, callGraph, inliner, ts, ppa.compilerSettings.optAllowSkipClassLoading) + private val copyProp = new CopyProp(backendUtils, callGraph, inliner, ts, settings) /** * Remove unreachable instructions from all (non-abstract) methods and apply various other @@ -205,7 +207,7 @@ class LocalOpt(backendUtils: BackendUtils, ppa: PostProcessorFrontendAccess, cal // for local variables in dead blocks. Maybe that's a bug in the ASM framework. var currentTrace: String | Null = null - val doTrace = ppa.compilerSettings.optTrace match { + val doTrace = settings.optTrace match { case Some(v: String) => val prefix = if (v == "_") "" else v s"$ownerClassName.${method.name}".startsWith(prefix) @@ -242,46 +244,46 @@ class LocalOpt(backendUtils: BackendUtils, ppa: PostProcessorFrontendAccess, cal traceIfChanged("beforeMethodOpt") // NULLNESS OPTIMIZATIONS - val runNullness = ppa.compilerSettings.optNullnessTracking && requestNullness + val runNullness = settings.optNullnessTracking && requestNullness val nullnessOptChanged = runNullness && nullnessOptimizations(method, ownerClassName) traceIfChanged("nullness") // UNREACHABLE CODE // Both AliasingAnalyzer (used in copyProp) and ProdConsAnalyzer (used in eliminateStaleStores, // boxUnboxElimination) require not having unreachable instructions (null frames). - val runDCE = (ppa.compilerSettings.optUnreachableCode && (requestDCE || nullnessOptChanged)) || - ppa.compilerSettings.optBoxUnbox || - ppa.compilerSettings.optCopyPropagation + val runDCE = (settings.optUnreachableCode && (requestDCE || nullnessOptChanged)) || + settings.optBoxUnbox || + settings.optCopyPropagation val codeRemoved = if (runDCE) LocalOptImpls.removeUnreachableCodeImpl(method, ownerClassName, callGraph, backendUtils) else false traceIfChanged("dce") // BOX-UNBOX - val runBoxUnbox = ppa.compilerSettings.optBoxUnbox && (requestBoxUnbox || nullnessOptChanged) + val runBoxUnbox = settings.optBoxUnbox && (requestBoxUnbox || nullnessOptChanged) val boxUnboxChanged = runBoxUnbox && boxUnbox.boxUnboxElimination(method, ownerClassName) traceIfChanged("boxUnbox") // COPY PROPAGATION - val runCopyProp = ppa.compilerSettings.optCopyPropagation && (requestCopyProp || boxUnboxChanged) + val runCopyProp = settings.optCopyPropagation && (requestCopyProp || boxUnboxChanged) val copyPropChanged = runCopyProp && copyProp.copyPropagation(method, ownerClassName) traceIfChanged("copyProp") // STALE STORES - val runStaleStores = ppa.compilerSettings.optCopyPropagation && (requestStaleStores || nullnessOptChanged || codeRemoved || boxUnboxChanged || copyPropChanged) + val runStaleStores = settings.optCopyPropagation && (requestStaleStores || nullnessOptChanged || codeRemoved || boxUnboxChanged || copyPropChanged) val (storesRemoved, intrinsicRewrittenByStaleStores, callInlinedByStaleStores) = if (!runStaleStores) (false, false, false) else copyProp.eliminateStaleStoresAndRewriteSomeIntrinsics(method, ownerClassName) traceIfChanged("staleStores") // REDUNDANT CASTS - val runRedundantCasts = ppa.compilerSettings.optRedundantCasts && (requestRedundantCasts || boxUnboxChanged || intrinsicRewrittenByStaleStores || callInlinedByStaleStores) + val runRedundantCasts = settings.optRedundantCasts && (requestRedundantCasts || boxUnboxChanged || intrinsicRewrittenByStaleStores || callInlinedByStaleStores) val (typeInsnChanged, intrinsicRewrittenByCasts) = if (!runRedundantCasts) (false, false) else eliminateRedundantCastsAndRewriteSomeIntrinsics(method, ownerClassName) traceIfChanged("redundantCasts") // PUSH-POP - val runPushPop = ppa.compilerSettings.optCopyPropagation && (requestPushPop || storesRemoved || typeInsnChanged) + val runPushPop = settings.optCopyPropagation && (requestPushPop || storesRemoved || typeInsnChanged) val (pushPopRemoved, pushPopCastAdded, pushPopNullCheckAdded) = if (!runPushPop) (false, false, false) else copyProp.eliminatePushPop(method, ownerClassName) traceIfChanged("pushPop") // STORE-LOAD PAIRS - val runStoreLoad = ppa.compilerSettings.optCopyPropagation && (requestStoreLoad || boxUnboxChanged || copyPropChanged || pushPopRemoved) + val runStoreLoad = settings.optCopyPropagation && (requestStoreLoad || boxUnboxChanged || copyPropChanged || pushPopRemoved) val storeLoadRemoved = runStoreLoad && copyProp.eliminateStoreLoad(method) traceIfChanged("storeLoadPairs") @@ -291,7 +293,7 @@ class LocalOpt(backendUtils: BackendUtils, ppa: PostProcessorFrontendAccess, cal // SIMPLIFY JUMPS // almost all of the above optimizations enable simplifying more jumps, so we just run it in every iteration - val runSimplifyJumps = ppa.compilerSettings.optSimplifyJumps + val runSimplifyJumps = settings.optSimplifyJumps val jumpsChanged = runSimplifyJumps && simplifyJumps(method) traceIfChanged("simplifyJumps") @@ -341,11 +343,11 @@ class LocalOpt(backendUtils: BackendUtils, ppa: PostProcessorFrontendAccess, cal requestPushPop = true, requestStoreLoad = true) - if (ppa.compilerSettings.optUnreachableCode) BackendUtils.setDceDone(method) + if (settings.optUnreachableCode) BackendUtils.setDceDone(method) // (*) Removing stale local variable descriptors is required for correctness, see comment in `methodOptimizations` val localsRemoved = - if (ppa.compilerSettings.optCompactLocals) compactLocalVariables(method) // also removes unused + if (settings.optCompactLocals) compactLocalVariables(method) // also removes unused else if (requireEliminateUnusedLocals) removeUnusedLocalVariableNodes(method)() // (*) else false traceIfChanged("localVariables") @@ -381,7 +383,7 @@ class LocalOpt(backendUtils: BackendUtils, ppa: PostProcessorFrontendAccess, cal */ private def nullnessOptimizations(method: MethodNode, ownerClassName: InternalName): Boolean = { Limits.sizeOKForNullness(method) && { - lazy val nullnessAnalyzer = new NullnessAnalyzer(method, ownerClassName, backendUtils.isNonNullMethodInvocation, ppa.compilerSettings.optAssumeModulesNonNull) + lazy val nullnessAnalyzer = new NullnessAnalyzer(method, ownerClassName, backendUtils.isNonNullMethodInvocation, settings.optAssumeModulesNonNull) // When running nullness optimizations the method may still have unreachable code. Analyzer // frames of unreachable instructions are `null`. @@ -538,7 +540,7 @@ class LocalOpt(backendUtils: BackendUtils, ppa: PostProcessorFrontendAccess, cal a.length - 2 == b.length && a(0) == 'L' && a.last == ';' && a.regionMatches(1, b, 0, b.length) || b.length - 2 == a.length && b(0) == 'L' && b.last == ';' && b.regionMatches(1, a, 0, a.length) } - sameClass(aDescOrIntN, bDescOrIntN) || sameClass(bDescOrIntN, ts.ObjectRef.internalName) || { + sameClass(aDescOrIntN, bDescOrIntN) || sameClass(bDescOrIntN, "java/lang/Object") || { val aType = bTypesFromClassfile.bTypeForDescriptorOrInternalNameFromClassfile(aDescOrIntN) val bType = bTypesFromClassfile.bTypeForDescriptorOrInternalNameFromClassfile(bDescOrIntN) // TODO instead of getOrElse, we should bubble the warning up... @@ -572,7 +574,7 @@ class LocalOpt(backendUtils: BackendUtils, ppa: PostProcessorFrontendAccess, cal } lazy val typeAnalyzer = new NonLubbingTypeFlowAnalyzer(method, owner) - lazy val nullnessAnalyzer = new NullnessAnalyzer(method, owner, backendUtils.isNonNullMethodInvocation, ppa.compilerSettings.optAssumeModulesNonNull) + lazy val nullnessAnalyzer = new NullnessAnalyzer(method, owner, backendUtils.isNonNullMethodInvocation, settings.optAssumeModulesNonNull) // cannot remove instructions while iterating, it gets the analysis out of synch (indexed by instructions) val toReplace = mutable.Map.empty[AbstractInsnNode, List[AbstractInsnNode]] @@ -593,16 +595,17 @@ class LocalOpt(backendUtils: BackendUtils, ppa: PostProcessorFrontendAccess, cal val frame = typeAnalyzer.frameAt(ti) frame.getValue(frame.stackTop) }) - if (isSubType(valueDesc, ti.desc)) { - if (opc == CHECKCAST) { - toReplace(ti) = Nil - } else if (valueNullness == NotNullValue) { - toReplace(ti) = List(getPop(1), new InsnNode(ICONST_1)) + if valueDesc != "Lnull;" then + if (isSubType(valueDesc, ti.desc)) { + if (opc == CHECKCAST) { + toReplace(ti) = Nil + } else if (valueNullness == NotNullValue) { + toReplace(ti) = List(getPop(1), new InsnNode(ICONST_1)) + } + } else if (opc == INSTANCEOF && isUnrelated(valueDesc, ti.desc)) { + // the two types are unrelated, so the instance check is known to fail + toReplace(ti) = List(getPop(1), new InsnNode(ICONST_0)) } - } else if (opc == INSTANCEOF && isUnrelated(valueDesc, ti.desc)) { - // the two types are unrelated, so the instance check is known to fail - toReplace(ti) = List(getPop(1), new InsnNode(ICONST_0)) - } } } @@ -1212,18 +1215,16 @@ object LocalOptImpls { case Some(prev) => val prevOp = prev.getOpcode val isIConst = prevOp >= ICONST_M1 && prevOp <= ICONST_5 - (jump.getOpcode: @switch) match { - case IFNULL if prevOp == ACONST_NULL => - replace(jump, success = true) - case IFNONNULL if prevOp == ACONST_NULL => - replace(jump, success = false) - case IFEQ if isIConst => - replace(jump, success = prevOp == ICONST_0) - case IFNE if isIConst => - replace(jump, success = prevOp != ICONST_0) - /* TODO: we also have IFLE, IF_?CMP* and friends, but how likely are they to be profitably optimizeable? */ - case _ => false - } + if jump.getOpcode == IFNULL && prevOp == ACONST_NULL then + replace(jump, success = true) + else if jump.getOpcode == IFNONNULL && prevOp == ACONST_NULL then + replace(jump, success = false) + else if jump.getOpcode == IFEQ && isIConst then + replace(jump, success = prevOp == ICONST_0) + else if jump.getOpcode == IFNE && isIConst then + replace(jump, success = prevOp != ICONST_0) + else /* TODO: we also have IFLE, IF_?CMP* and friends, but how likely are they to be profitably optimizeable? */ + false case _ => false } case _ => false diff --git a/compiler/src/dotty/tools/backend/jvm/opt/OptimizerSettings.scala b/compiler/src/dotty/tools/backend/jvm/opt/OptimizerSettings.scala new file mode 100644 index 000000000000..593fd1f014c5 --- /dev/null +++ b/compiler/src/dotty/tools/backend/jvm/opt/OptimizerSettings.scala @@ -0,0 +1,34 @@ +package dotty.tools.backend.jvm.opt + +import dotty.tools.dotc.core.Contexts.Context + +import scala.annotation.constructorOnly + +/** + * Encapsulates settings so that the optimizer can use them without directly depending on a Context, + * since the context outside of settings is single-threaded, + * and it would become tempting to use it for something else. + */ +class OptimizerSettings(using @constructorOnly ctx: Context): + val optUnreachableCode: Boolean = ctx.settings.optUnreachableCode + val optNullnessTracking: Boolean = ctx.settings.optNullnessTracking + val optBoxUnbox: Boolean = ctx.settings.optBoxUnbox + val optCopyPropagation: Boolean = ctx.settings.optCopyPropagation + val optRedundantCasts: Boolean = ctx.settings.optRedundantCasts + val optSimplifyJumps: Boolean = ctx.settings.optSimplifyJumps + val optCompactLocals: Boolean = ctx.settings.optCompactLocals + val optClosureInvocations: Boolean = ctx.settings.optClosureInvocations + val optAllowSkipCoreModuleInit: Boolean = ctx.settings.optAllowSkipCoreModuleInit + val optAssumeModulesNonNull: Boolean = ctx.settings.optAssumeModulesNonNull + val optAllowSkipClassLoading: Boolean = ctx.settings.optAllowSkipClassLoading + val optInlinerEnabled: Boolean = ctx.settings.optInline.value.nonEmpty + val optInlineFrom: List[String] = ctx.settings.optInline.value + val optInlineHeuristics: String = ctx.settings.YoptInlineHeuristics.value + val optWarningNoInlineMixed: Boolean = ctx.settings.optWarningNoInlineMixed + val optWarningNoInlineMissingBytecode: Boolean = ctx.settings.optWarningNoInlineMissingBytecode + val optWarningNoInlineMissingScalaInlineInfoAttr: Boolean = ctx.settings.optWarningNoInlineMissingScalaInlineInfoAttr + val optWarningEmitAtInlineFailed: Boolean = ctx.settings.optWarningEmitAtInlineFailed + val optWarningEmitAnyInlineFailed: Boolean = ctx.settings.optWarningEmitAnyInlineFailed + val optLogInline: Option[String] = ctx.settings.YoptLogInline.valueSetByUser + val optTrace: Option[String] = ctx.settings.YoptTrace.valueSetByUser + diff --git a/compiler/src/dotty/tools/backend/jvm/opt/OptimizerWarning.scala b/compiler/src/dotty/tools/backend/jvm/opt/OptimizerWarning.scala index a643098fed1e..259f1d874e50 100644 --- a/compiler/src/dotty/tools/backend/jvm/opt/OptimizerWarning.scala +++ b/compiler/src/dotty/tools/backend/jvm/opt/OptimizerWarning.scala @@ -2,14 +2,13 @@ package dotty.tools.backend.jvm.opt import dotty.tools.backend.jvm.BackendUtils import dotty.tools.backend.jvm.BTypes.InternalName -import dotty.tools.backend.jvm.PostProcessorFrontendAccess.CompilerSettings import dotty.tools.dotc.util.SourcePosition import scala.tools.asm.tree.AbstractInsnNode sealed trait OptimizerWarning { - def emitWarning(settings: CompilerSettings): Boolean + def emitWarning(settings: OptimizerSettings): Boolean } sealed trait MissingBytecodeWarning extends OptimizerWarning { @@ -29,7 +28,7 @@ sealed trait MissingBytecodeWarning extends OptimizerWarning { missingClass.map(c => s" Reason:\n$c").getOrElse("") } - def emitWarning(settings: CompilerSettings): Boolean = this match { + def emitWarning(settings: OptimizerSettings): Boolean = this match { case ClassNotFound(_) => settings.optWarningNoInlineMissingBytecode @@ -54,7 +53,7 @@ final case class NoClassBTypeInfo(cause: MissingBytecodeWarning) extends Optimiz override def toString: String = cause.toString - def emitWarning(settings: CompilerSettings): Boolean = + def emitWarning(settings: OptimizerSettings): Boolean = cause.emitWarning(settings) } @@ -82,7 +81,7 @@ sealed trait CalleeInfoWarning extends OptimizerWarning { s"Error while computing the inline information for method $warningMessageSignature:\n" + cause } - def emitWarning(settings: CompilerSettings): Boolean = this match { + def emitWarning(settings: OptimizerSettings): Boolean = this match { case MethodInlineInfoIncomplete(_, _, _, cause) => cause.emitWarning(settings) case MethodInlineInfoMissing(_, _, _, Some(cause)) => cause.emitWarning(settings) @@ -150,7 +149,7 @@ sealed trait CannotInlineWarning extends OptimizerWarning { warning + reason } - def emitWarning(settings: CompilerSettings): Boolean = { + def emitWarning(settings: OptimizerSettings): Boolean = { settings.optWarningEmitAnyInlineFailed || annotatedInline && settings.optWarningEmitAtInlineFailed } @@ -182,7 +181,7 @@ case class ResultingMethodTooLarge(calleeDeclarationClass: InternalName, name: S case object UnknownInvokeDynamicInstruction extends OptimizerWarning { override def toString = "The callee contains an InvokeDynamic instruction with an unknown bootstrap method (not a LambdaMetaFactory)." - def emitWarning(settings: CompilerSettings): Boolean = settings.optWarningEmitAnyInlineFailed + def emitWarning(settings: OptimizerSettings): Boolean = settings.optWarningEmitAnyInlineFailed } /** @@ -192,7 +191,7 @@ case object UnknownInvokeDynamicInstruction extends OptimizerWarning { sealed trait RewriteClosureApplyToClosureBodyFailed extends OptimizerWarning { def pos: SourcePosition - override def emitWarning(settings: CompilerSettings): Boolean = this match { + override def emitWarning(settings: OptimizerSettings): Boolean = this match { case RewriteClosureAccessCheckFailed(_, cause) => cause.emitWarning(settings) case RewriteClosureIllegalAccess(_, _) => settings.optWarningEmitAnyInlineFailed } @@ -224,7 +223,7 @@ sealed trait ClassInlineInfoWarning extends OptimizerWarning { s"Cannot read ScalaInlineInfo version $version in classfile $internalName. Use a more recent compiler." } - def emitWarning(settings: CompilerSettings): Boolean = this match { + def emitWarning(settings: OptimizerSettings): Boolean = this match { case NoInlineInfoAttribute(_) => settings.optWarningNoInlineMissingScalaInlineInfoAttr case ClassNotFoundWhenBuildingInlineInfoFromSymbol(cause) => cause.emitWarning(settings) case UnknownScalaInlineInfoVersion(_, _) => settings.optWarningNoInlineMissingScalaInlineInfoAttr diff --git a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala index 6c5f3b2d6ca9..b7b31d3e9d4c 100644 --- a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala +++ b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala @@ -1,7 +1,5 @@ package dotty.tools.backend.sjs -import scala.language.unsafeNulls - import scala.annotation.switch import scala.collection.mutable @@ -90,14 +88,14 @@ class JSCodeGen()(using genCtx: Context) { /** Resets all of the scoped state in the context of `body`. */ private def resetAllScopedVars[T](body: => T): T = { withScopedVars( - currentClassSym := null, - delambdafyTargetDefDefs := null, - methodsAllowingJSAwait := null, - currentMethodSym := null, - localNames := null, - thisLocalVarName := null, - isModuleInitialized := null, - undefinedDefaultParams := null + currentClassSym.unset, + delambdafyTargetDefDefs.unset, + methodsAllowingJSAwait.unset, + currentMethodSym.unset, + localNames.unset, + thisLocalVarName.unset, + isModuleInitialized.unset, + undefinedDefaultParams.unset ) { body } diff --git a/compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala b/compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala index 891bec5d609d..f47539d74a14 100644 --- a/compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala +++ b/compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala @@ -1,7 +1,5 @@ package dotty.tools.backend.sjs -import scala.language.unsafeNulls - import scala.annotation.threadUnsafe import dotty.tools.dotc.core.* diff --git a/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala b/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala index e17ee0abe00f..205d3df03a8c 100644 --- a/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala +++ b/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala @@ -1,7 +1,5 @@ package dotty.tools.backend.sjs -import scala.language.unsafeNulls - import scala.collection.mutable import dotty.tools.dotc.core.* diff --git a/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala b/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala index 01fbf980fe12..83c32b0b605d 100644 --- a/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala +++ b/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala @@ -1,7 +1,5 @@ package dotty.tools.backend.sjs -import scala.language.unsafeNulls - import scala.annotation.tailrec import scala.collection.mutable @@ -976,7 +974,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) { private val fixedParamNames: scala.collection.immutable.IndexedSeq[jsNames.LocalName] = (0 until minArgc).toIndexedSeq.map(_ => freshLocalIdent("arg")(using NoPosition).name) - private val restParamName: jsNames.LocalName = + private val restParamName: jsNames.LocalName | Null = if (needsRestParam) freshLocalIdent("rest")(using NoPosition).name else null @@ -986,7 +984,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) { } val restParam = { - if (needsRestParam) + if (restParamName != null) Some(js.ParamDef(js.LocalIdent(restParamName), NoOriginalName, jstpe.AnyType, mutable = false)) else None @@ -1012,7 +1010,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) { } def genRestArgRef()(implicit pos: Position): js.Tree = { - assert(needsRestParam, s"trying to generate a reference to non-existent rest param at $pos") + assert(restParamName != null, s"trying to generate a reference to non-existent rest param at $pos") js.VarRef(restParamName)(jstpe.AnyType) } @@ -1021,7 +1019,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) { js.VarRef(paramName)(jstpe.AnyType) } - if (needsRestParam) { + if (restParamName != null) { val restArgRef = js.VarRef(restParamName)(jstpe.AnyType) fixedArgRefs :+ js.JSSpread(restArgRef) } else { diff --git a/compiler/src/dotty/tools/backend/sjs/JSPositions.scala b/compiler/src/dotty/tools/backend/sjs/JSPositions.scala index a229c9ea0e58..a02d1f8bd43d 100644 --- a/compiler/src/dotty/tools/backend/sjs/JSPositions.scala +++ b/compiler/src/dotty/tools/backend/sjs/JSPositions.scala @@ -1,7 +1,5 @@ package dotty.tools.backend.sjs -import scala.language.unsafeNulls - import java.net.{URI, URISyntaxException} import dotty.tools.dotc.core.* @@ -66,25 +64,31 @@ class JSPositions()(using Context) { private object span2irPosCache { import dotty.tools.dotc.util.* - private var lastDotcSource: SourceFile = null - private var lastIRSource: ir.Position.SourceFile = null + private var lastDotcSource: SourceFile | Null = null + private var lastIRSource: ir.Position.SourceFile | Null = null def toIRSource(dotcSource: SourceFile): ir.Position.SourceFile = { if (dotcSource != lastDotcSource) { lastIRSource = convert(dotcSource) lastDotcSource = dotcSource } - lastIRSource + lastIRSource.nn } private def convert(dotcSource: SourceFile): ir.Position.SourceFile = { dotcSource.file.file match { case null => - new java.net.URI( - "virtualfile", // Pseudo-Scheme - dotcSource.file.path, // Scheme specific part - null // Fragment - ) + dotcSource.file.path match { + case "" => + // creating a virtualfile: URI with an empty scheme-specific part is not allowed + ir.Position.NoPosition.source + case path => + new java.net.URI( + "virtualfile", // Pseudo-Scheme + path, // Scheme-specific part + null // Fragment + ) + } case file => val srcURI = file.toURI sourceURIMaps.collectFirst { diff --git a/compiler/src/dotty/tools/backend/sjs/ScopedVar.scala b/compiler/src/dotty/tools/backend/sjs/ScopedVar.scala index fd271685989c..42e859f582bb 100644 --- a/compiler/src/dotty/tools/backend/sjs/ScopedVar.scala +++ b/compiler/src/dotty/tools/backend/sjs/ScopedVar.scala @@ -1,18 +1,25 @@ package dotty.tools.backend.sjs -class ScopedVar[A](init: A) { +final class ScopedVar[A <: AnyRef] private (init: A | Null, internal: Boolean) { import ScopedVar.Assignment - private[ScopedVar] var value = init + private[ScopedVar] var value: A | Null = init - def this()(implicit ev: Null <:< A) = this(ev(null)) + def this(init: A) = this(init, true) + def this() = this(null, true) + + def get: A = + val v = value + assert(v != null, "Trying to read a ScopedVar that is not set in the current scope") + v - def get: A = value def :=(newValue: A): Assignment[A] = new Assignment(this, newValue) + + def unset: Assignment[A] = new Assignment(this, null) } object ScopedVar { - class Assignment[T](scVar: ScopedVar[T], value: T) { + class Assignment[T <: AnyRef] private[ScopedVar] (scVar: ScopedVar[T], value: T | Null) { private[ScopedVar] def push(): AssignmentStackElement[T] = { val stack = new AssignmentStackElement(scVar, scVar.value) scVar.value = value @@ -20,13 +27,13 @@ object ScopedVar { } } - private class AssignmentStackElement[T](scVar: ScopedVar[T], oldValue: T) { + private class AssignmentStackElement[T <: AnyRef](scVar: ScopedVar[T], oldValue: T | Null) { private[ScopedVar] def pop(): Unit = { scVar.value = oldValue } } - implicit def toValue[T](scVar: ScopedVar[T]): T = scVar.get + implicit def toValue[T <: AnyRef](scVar: ScopedVar[T]): T = scVar.get def withScopedVars[T](ass: Assignment[?]*)(body: => T): T = { val stack = ass.map(_.push()) diff --git a/compiler/src/dotty/tools/debug/ExpressionCompilerBridge.scala b/compiler/src/dotty/tools/debug/ExpressionCompilerBridge.scala index c596c6d4a1e0..e14d218d347d 100644 --- a/compiler/src/dotty/tools/debug/ExpressionCompilerBridge.scala +++ b/compiler/src/dotty/tools/debug/ExpressionCompilerBridge.scala @@ -1,7 +1,6 @@ package dotty.tools.debug import java.nio.file.Path -import scala.util.control.NonFatal import dotty.tools.dotc.core.Contexts.Context import dotty.tools.dotc.Driver @@ -29,6 +28,6 @@ class ExpressionCompilerBridge: driver.process(args, reporter) !reporter.hasErrors catch - case NonFatal(cause) => + case cause: Exception => cause.printStackTrace() throw cause diff --git a/compiler/src/dotty/tools/debug/ExpressionCompilerConfig.scala b/compiler/src/dotty/tools/debug/ExpressionCompilerConfig.scala index 0a464299899f..a8a1e404c668 100644 --- a/compiler/src/dotty/tools/debug/ExpressionCompilerConfig.scala +++ b/compiler/src/dotty/tools/debug/ExpressionCompilerConfig.scala @@ -18,7 +18,8 @@ class ExpressionCompilerConfig private[debug] ( private[debug] val expression: String, private[debug] val localVariables: ju.Set[String], private[debug] val errorReporter: Consumer[String], - private[debug] val testMode: Boolean + private[debug] val testMode: Boolean, + private[debug] val oldSyntax: Boolean ): def this() = this( packageName = "", @@ -28,6 +29,7 @@ class ExpressionCompilerConfig private[debug] ( localVariables = ju.Collections.emptySet, errorReporter = _ => (), testMode = false, + oldSyntax = false, ) def withPackageName(packageName: String): ExpressionCompilerConfig = copy(packageName = packageName) @@ -61,5 +63,6 @@ class ExpressionCompilerConfig private[debug] ( expression, localVariables, errorReporter, - testMode + testMode, + oldSyntax ) diff --git a/compiler/src/dotty/tools/debug/InsertExpression.scala b/compiler/src/dotty/tools/debug/InsertExpression.scala index 53e29f6cf73d..230f8abaf903 100644 --- a/compiler/src/dotty/tools/debug/InsertExpression.scala +++ b/compiler/src/dotty/tools/debug/InsertExpression.scala @@ -45,6 +45,10 @@ private class InsertExpression(config: ExpressionCompilerConfig) extends Phase: override def phaseName: String = InsertExpression.name override def isCheckable: Boolean = false + private val (indexCheck, returnTypeCheck) = if config.oldSyntax + then ("if (idx == -1) throw new NoSuchElementException(name)", """if (returnTypeName == "void") { () } else { res }""") + else ("if idx == -1 then throw new NoSuchElementException(name)", """if returnTypeName == "void" then () else res""") + // TODO move reflection methods (callMethod, getField, etc) to scala3-library // under scala.runtime (or scala.debug?) to avoid recompiling them again and again private val expressionClassSource = @@ -59,13 +63,13 @@ private class InsertExpression(config: ExpressionCompilerConfig) extends Phase: | | def getLocalValue(name: String): Any = { | val idx = names.indexOf(name) - | if idx == -1 then throw new NoSuchElementException(name) + | $indexCheck | else values(idx) | } | | def setLocalValue(name: String, value: Any): Any = { | val idx = names.indexOf(name) - | if idx == -1 then throw new NoSuchElementException(name) + | $indexCheck | else values(idx) = value | } | @@ -80,7 +84,7 @@ private class InsertExpression(config: ExpressionCompilerConfig) extends Phase: | .getOrElse(throw new NoSuchMethodException(methodName)) | method.setAccessible(true) | val res = unwrapException(method.invoke(obj, args*)) - | if returnTypeName == "void" then () else res + | $returnTypeCheck | } | | def callConstructor(className: String, paramTypesNames: Array[String], args: Array[Object]): Any = { diff --git a/compiler/src/dotty/tools/dotc/CompilationUnit.scala b/compiler/src/dotty/tools/dotc/CompilationUnit.scala index dd4bcf4c8a23..b509e47a7939 100644 --- a/compiler/src/dotty/tools/dotc/CompilationUnit.scala +++ b/compiler/src/dotty/tools/dotc/CompilationUnit.scala @@ -32,7 +32,7 @@ class CompilationUnit protected (val source: SourceFile, val info: CompilationUn /** Is this the compilation unit of a Java file, or TASTy derived from a Java file */ def typedAsJava = val ext = source.file.ext - ext.isJavaOrTasty && (ext.isJava || tastyInfo.exists(_.attributes.isJava)) + ext.isJava || ext.isTasty && tastyInfo.exists(_.attributes.isJava) def tastyInfo: Option[TastyInfo] = val local = info diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala index a5b633eb9f93..aca691e6211b 100644 --- a/compiler/src/dotty/tools/dotc/Compiler.scala +++ b/compiler/src/dotty/tools/dotc/Compiler.scala @@ -43,17 +43,19 @@ class Compiler { List(new UnrollDefinitions) :: // Unroll annotated methods if detected in PostTyper List(new sjs.PrepJSInterop) :: // Additional checks and transformations for Scala.js (Scala.js only) List(new SetRootTree) :: // Set the `rootTreeOrProvider` on class symbols + List(new DesugarSpecializedTraits) :: // Process Specialized traits + List(new SpecializeInlineTraits) :: // Inline the code of inline traits into their children Nil /** Phases dealing with TASTY tree pickling and unpickling */ protected def picklerPhases: List[List[Phase]] = - List(new Pickler) :: // Generate TASTY info - List(new sbt.ExtractAPI) :: // Sends a representation of the API of classes to sbt via callbacks - List(new Inlining) :: // Inline and execute macros - List(new PostInlining) :: // Add mirror support for inlined code - List(new Staging) :: // Check staging levels and heal staged types - List(new Splicing) :: // Replace level 1 splices with holes - List(new PickleQuotes) :: // Turn quoted trees into explicit run-time data structures + List(new Pickler) :: // Generate TASTY info + List(new sbt.ExtractAPI) :: // Sends a representation of the API of classes to sbt via callbacks + List(new Inlining) :: // Inline and execute macros + List(new PostInlining) :: // Add mirror support for inlined code + List(new Staging) :: // Check staging levels and heal staged types + List(new Splicing) :: // Replace level 1 splices with holes + List(new PickleQuotes) :: // Turn quoted trees into explicit run-time data structures Nil /** Phases dealing with the transformation from pickled trees to backend trees */ @@ -69,8 +71,9 @@ class Compiler { new InlineVals, // Check right hand-sides of an `inline val`s new ExpandSAMs, // Expand single abstract method closures to anonymous classes new ElimRepeated, // Rewrite vararg parameters and arguments - new RefChecks, // Various checks mostly related to abstract members and overriding - new DropForMap) :: // Drop unused trailing map calls in for comprehensions + new DropForMap, // Drop unused trailing map calls in for comprehensions + new PruneSpecializedMethods) :: // Remove right-hand side of definitions in inline traits + List(new RefChecks) :: // Various checks mostly related to abstract members and overriding List(new init.Checker) :: // Check initialization of objects List(new ProtectedAccessors, // Add accessors for protected members new ExtensionMethods, // Expand methods of value classes with extension methods @@ -81,7 +84,8 @@ class Compiler { new ForwardDepChecks, // Check that there are no forward references to local vals new SpecializeApplyMethods, // Adds specialized methods to FunctionN new TryCatchPatterns, // Compile cases in try/catch - new PatternMatcher) :: // Compile pattern matches + new PatternMatcher, // Compile pattern matches + new PruneInlineTraits) :: // Remove right-hand side of definitions in inline traits List(new TestRecheck.Pre) :: // Test only: run rechecker, enabled under -Yrecheck-test List(new TestRecheck) :: // Test only: run rechecker, enabled under -Yrecheck-test List(new cc.Setup) :: // Preparations for check captures phase, enabled under captureChecking @@ -94,7 +98,7 @@ class Compiler { new ExplicitSelf, // Make references to non-trivial self types explicit as casts new StringInterpolatorOpt, // Optimizes raw and s and f string interpolators by rewriting them to string concatenations or formats new DropBreaks) :: // Optimize local Break throws by rewriting them - List(new PruneErasedDefs, // Make erased symbols private + List(new PruneErasedDefs, // Drop erased definitions from scopes and simplify erased expressions new UninitializedDefs, // Replaces `compiletime.uninitialized` by `_` new InlinePatterns, // Remove placeholders of inlined patterns new VCInlineMethods, // Inlines calls to value class methods @@ -143,7 +147,6 @@ class Compiler { new RestoreScopes, // Repair scopes rendered invalid by moving definitions in prior phases of the group new SelectStatic, // get rid of selects that would be compiled into GetStatic new sjs.JUnitBootstrappers, // Generate JUnit-specific bootstrapper classes for Scala.js (not enabled by default) - new CollectEntryPoints, // Collect all entry points and save them in the context new RepeatableAnnotations) :: // Aggregate repeatable annotations Nil diff --git a/compiler/src/dotty/tools/dotc/Driver.scala b/compiler/src/dotty/tools/dotc/Driver.scala index 2a4feea9ed05..a3ff038419ff 100644 --- a/compiler/src/dotty/tools/dotc/Driver.scala +++ b/compiler/src/dotty/tools/dotc/Driver.scala @@ -11,7 +11,6 @@ import reporting.* import core.Decorators.* import util.chaining.* -import scala.util.control.NonFatal import fromtasty.{TASTYCompiler, TastyFileUtil} /** Run the Dotty compiler. @@ -39,13 +38,13 @@ class Driver { catch case ex: FatalError => report.error(ex.getMessage) // signals that we should fail compilation. - case ex: Throwable if ctx.usedBestEffortTasty => + case ex: Exception if ctx.usedBestEffortTasty => report.bestEffortError(ex, "Some best-effort tasty files were not able to be read.") throw ex case ex: TypeError if !runOrNull.enrichedErrorMessage => println(runOrNull.enrichErrorMessage(s"${ex.toMessage} while compiling ${files.map(_.path).mkString(", ")}")) throw ex - case ex: Throwable if !runOrNull.enrichedErrorMessage => + case ex: Exception if !runOrNull.enrichedErrorMessage => println(runOrNull.enrichErrorMessage(s"Exception while compiling ${files.map(_.path).mkString(", ")}")) throw ex ctx.reporter @@ -80,29 +79,26 @@ class Driver { val ictx = rootCtx.fresh val summary = command.distill(args, ictx.settings)(ictx.settingsState)(using ictx) ictx.setSettings(summary.sstate) - MacroClassLoader.init(ictx) - Positioned.init(using ictx) inContext(ictx): if !ctx.settings.XdropComments.value || ctx.settings.XreadComments.value then ictx.setProperty(ContextDoc, new ContextDocstrings) val fileNamesOrNone = command.checkUsage(summary, sourcesRequired)(using ctx.settings)(using ctx.settingsState) - fileNamesOrNone.map: fileNames => - val files = fileNames.map(ctx.getFile) - (files, fromTastySetup(files)) - .tap: _ => - if !ctx.settings.Yreporter.isDefault then - ctx.settings.Yreporter.value match - case "help" => - case reporterClassName => - try - Class.forName(reporterClassName).getDeclaredConstructor().newInstance() match + fileNamesOrNone.map(fileNames => + MacroClassLoader.init(ictx) + Positioned.init + if !ctx.settings.Yreporter.isDefault && ctx.settings.Yreporter.value != "help" then + try + Class.forName(ctx.settings.Yreporter.value).getDeclaredConstructor().newInstance() match case userReporter: Reporter => ictx.setReporter(userReporter) - case badReporter => report.error: - em"Not a reporter: ${ctx.settings.Yreporter.value}" - catch case e: ReflectiveOperationException => report.error: - em"Could not create reporter ${ctx.settings.Yreporter.value}: ${e}" + case badReporter => + report.error(em"Not a reporter: ${ctx.settings.Yreporter.value}") + catch case e: ReflectiveOperationException => + report.error(em"Could not create reporter ${ctx.settings.Yreporter.value}: $e") + val files = fileNames.map(ctx.getFile) + (files, fromTastySetup(files)) + ) } /** Setup extra classpath of tasty and jar files */ @@ -215,10 +211,6 @@ class Driver { } def main(args: Array[String]): Unit = { - // Preload scala.util.control.NonFatal. Otherwise, when trying to catch a StackOverflowError, - // we may try to load it but fail with another StackOverflowError and lose the original exception, - // see . - val _ = NonFatal sys.exit(if (process(args).hasErrors) 1 else 0) } } diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala index fb7109cac343..fb77ef3a1e8b 100644 --- a/compiler/src/dotty/tools/dotc/Run.scala +++ b/compiler/src/dotty/tools/dotc/Run.scala @@ -31,13 +31,13 @@ import java.io.{BufferedWriter, OutputStreamWriter} import java.nio.charset.StandardCharsets import scala.collection.mutable, mutable.ListBuffer -import scala.util.control.NonFatal import scala.io.Codec import Run.Progress import scala.compiletime.uninitialized import dotty.tools.dotc.transform.MegaPhase import dotty.tools.dotc.transform.Pickler.AsyncTastyHolder +import dotty.tools.io.FileWriters import dotty.tools.dotc.util.chaining.* import java.util.{Timer, TimerTask} @@ -288,6 +288,26 @@ extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo { _asyncTasty = Some(async) () => async.cancel() + /** Wait for async TASTy operations (including Zinc callbacks like + * `apiPhaseCompleted`/`dependencyPhaseCompleted`) to complete and relay any + * buffered reports. This must happen before we return to Zinc, which calls + * `getCycleResultOnce` immediately after. See scala/scala3#25774. + */ + private def syncAsyncTasty()(using Context): Unit = + for + async <- _asyncTasty + bufferedReporter <- async.sync() + report <- bufferedReporter.resetReports() + do + import reporting.Diagnostic + report match + case FileWriters.Report.Error(msg, pos) => + ctx.reporter.report(Diagnostic.Error(msg(ctx), pos)) + case FileWriters.Report.Warning(msg, pos) => + ctx.reporter.report(Diagnostic.Warning(msg(ctx), pos)) + case FileWriters.Report.Log(msg) => + ctx.reporter.report(Diagnostic.Info(msg, NoSourcePosition)) + /** Will be set to true if any of the compiled compilation units contains * a pureFunctions language import. */ @@ -298,11 +318,14 @@ extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo { */ var ccEnabledSomewhere = Feature.ccEnabledBySetting(using ictx) + /** If -explain-cycles is set, a trace of cyclic reference dependencies, otherwise null */ + var cyclicReferenceTrace: CyclicReference.Trace | Null = null + private var myEnrichedErrorMessage = false def compile(files: List[AbstractFile]): Unit = try compileSources(files.map(runContext.getSource(_))) - catch case NonFatal(ex) if !this.enrichedErrorMessage => + catch case ex: Exception if !this.enrichedErrorMessage => val files1 = if units.isEmpty then files else units.map(_.source.file) report.echo(this.enrichErrorMessage(s"exception occurred while compiling ${files1.map(_.path)}")) throw ex @@ -355,7 +378,7 @@ extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo { val pluginPlan = ctx.base.addPluginPhases(ctx.base.phasePlan) val phases = ctx.base.fusePhases(pluginPlan, - ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value) + ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, ctx.settings.Ycheck.value) ctx.base.usePhases(phases, runCtx) if ctx.settings.YnoDoubleBindings.value then @@ -370,7 +393,16 @@ extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo { if (ctx.isBestEffort && phases.exists(_.phaseName == "typer")) Some("typer") else None - for phase <- allPhases do + def matchesStopAfter(p: Phase): Boolean = p match + case mp: dotty.tools.dotc.transform.MegaPhase => + mp.miniPhases.exists(sub => stopAfter.contains(sub.phaseName)) + case _ => + stopAfter.contains(p.phaseName) + + var stopped = false + var i = 0 + while i < allPhases.length && !stopped do + val phase = allPhases(i) doEnterPhase(phase) val phaseWillRun = phase.isRunnable || forceReachPhaseMaybe.nonEmpty if phaseWillRun then @@ -403,13 +435,15 @@ extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo { end if end if doAdvancePhase(phase, wasRan = phaseWillRun) - end for + if matchesStopAfter(phase) then stopped = true + i += 1 + end while profiler.finished() } val fusedPhases = runCtx.base.allPhases if ctx.settings.explainCyclic.value then - runCtx.setProperty(CyclicReference.Trace, new CyclicReference.Trace()) + cyclicReferenceTrace = new CyclicReference.Trace() runCtx.withProgressCallback: cb => _progress = Progress(cb, this, fusedPhases.map(_.traversals).sum) val cancelAsyncTasty: () => Unit = @@ -419,6 +453,7 @@ extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo { showProgress(runPhases(allPhases = fusedPhases)(using runCtx)) cancelAsyncTasty() + syncAsyncTasty() suppressions.runFinished() ctx.reporter.finalizeReporting() diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala index 6b7654ebbc7c..5ebed827b621 100644 --- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala +++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala @@ -795,17 +795,7 @@ object desugar { case PatDef(_, ids: List[Ident] @ unchecked, _, _) => ids } - val stats0 = impl.body.map(expandConstructor) - val stats = - if (ctx.owner eq defn.ScalaPackageClass) && defn.hasProblematicGetClass(className) then - stats0.filterConserve { - case ddef: DefDef => - ddef.name ne nme.getClass_ - case _ => - true - } - else - stats0 + val stats = impl.body.map(expandConstructor) if (isEnum) { val (enumCases, enumStats) = stats.partition(DesugarEnums.isEnumCase) diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala index c3ee7252cf7b..2c6fd0acd189 100644 --- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala +++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala @@ -511,6 +511,12 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped] def bodyKind(body: List[Tree])(using Context): FlagSet = body.foldLeft(NoInitsInterface)((fs, stat) => fs & defKind(stat)) + /** Is `tree` a DerivedTypeTree, possibly followed by type arguments? */ + def hasDerivedTree(tree: Tree)(using Context): Boolean = tree match + case tree: DerivedTypeTree => true + case AppliedTypeTree(tpt, _) => hasDerivedTree(tpt) + case _ => false + /** Info of a variable in a pattern: The named tree and its type */ type VarInfo = (NameTree, Tree) @@ -1110,8 +1116,12 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] => hasRefinement(tp.tp1) || hasRefinement(tp.tp2) case _ => false + def isDynamicMethod(name: Name): Boolean = + name == nme.applyDynamic || name == nme.selectDynamic || + name == nme.updateDynamic || name == nme.applyDynamicNamed !tree.symbol.exists && tree.isTerm + && !isDynamicMethod(tree.name) // Don't treat dynamic method calls as structural (prevents infinite recursion) && hasRefinement(tree.qualifier.tpe) funPart(tree) match case tree: Select => diff --git a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala index dc8d9c700700..138130887937 100644 --- a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala +++ b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala @@ -98,7 +98,7 @@ class TreeTypeMap( override def transform(tree: Tree)(using Context): Tree = treeMap(tree) match { case impl @ Template(constr, _, self, _) => - val tmap = withMappedSyms(localSyms(impl :: self :: Nil)) + val tmap = withMappedSyms(localSyms(impl :: self :: Nil)) cpy.Template(impl)( constr = tmap.transformSub(constr), parents = impl.parents.mapconserve(transform), @@ -127,14 +127,15 @@ class TreeTypeMap( cpy.Block(blk)(stats1, expr1) case lit @ Literal(Constant(tpe: Type)) => cpy.Literal(lit)(Constant(mapType(tpe))) - case ddef @ DefDef(name, paramss, tpt, _) => + case ddef @ DefDef(name, paramss, tpt, _) => // Why are we not correctly mapping foo's return type? See Reached def def ... val (tmap1, paramss1) = transformAllParamss(paramss) val res = cpy.DefDef(ddef)(name, paramss1, tmap1.transform(tpt), tmap1.transform(ddef.rhs)) res.symbol.setParamssFromDefs(paramss1) res.symbol.transformAnnotations { case ann: BodyAnnotation => ann.derivedAnnotation(transform(ann.tree)) case ann => ann - } + } + // HERE? res case tdef @ LambdaTypeTree(tparams, body) => val (tmap1, tparams1) = transformDefs(tparams) diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala index b7827724bd7e..13d70408d7db 100644 --- a/compiler/src/dotty/tools/dotc/ast/tpd.scala +++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala @@ -273,11 +273,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { val (rtp, paramss) = recur(tp.instantiate(tparams.map(_.typeRef)), remaining1) (rtp, tparams :: paramss) case tp: MethodType => - val isParamDependent = tp.isParamDependent - val previousParamRefs: mutable.ListBuffer[TermRef] = - // It is ok to assign `null` here. - // If `isParamDependent == false`, the value of `previousParamRefs` is not used. - if isParamDependent then mutable.ListBuffer[TermRef]() else (null: mutable.ListBuffer[TermRef] | Null).uncheckedNN + val previousParamRefs: mutable.ListBuffer[TermRef] | Null = + if tp.isParamDependent then mutable.ListBuffer[TermRef]() else null def valueParam(name: TermName, origInfo: Type, isErased: Boolean): TermSymbol = val maybeImplicit = @@ -288,7 +285,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { def makeSym(info: Type) = newSymbol(sym, name, TermParam | maybeImplicit | maybeErased, info, coord = sym.coord) - if isParamDependent then + if previousParamRefs ne null then val sym = makeSym(origInfo.substParams(tp, previousParamRefs.toList)) previousParamRefs += sym.termRef sym @@ -398,8 +395,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { if !overridden.is(Deferred) then fwdMeth.setFlag(Override) DefDef(fwdMeth, ref(fn).appliedToArgss(_)) } - termForwarders.map((name, sym) => forwarder(name, sym)) ++ - typeMembers.map((name, info) => TypeDef(newSymbol(cls, name, Synthetic, info).entered)) + val typeDefs = typeMembers.map((name, info) => TypeDef(newSymbol(cls, name, Synthetic, info).entered)) + termForwarders.map((name, sym) => forwarder(name, sym)) ++ typeDefs } } @@ -562,7 +559,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { def wrapArray(tree: Tree, elemtp: Type)(using Context): Tree = val wrapper = ref(defn.getWrapVarargsArrayModule) .select(wrapArrayMethodName(elemtp)) - .appliedToTypes(if (elemtp.isPrimitiveValueType) Nil else elemtp :: Nil) + .appliedToTypes(if elemtp.classSymbol.isPrimitiveValueClass then Nil else elemtp :: Nil) val actualElem = wrapper.tpe.widen.firstParamTypes.head wrapper.appliedTo(tree.ensureConforms(actualElem)) @@ -1215,7 +1212,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { def ensureHasSym(sym: Symbol)(using Context): Unit = if sym.exists && sym != tree.symbol then typr.println(i"correcting definition symbol from ${tree.symbol.showLocated} to ${sym.showLocated}") - tree.overwriteType(NamedType(sym.owner.thisType, sym.asTerm.name, sym.denot)) + tree.overwriteType(NamedType(sym.owner.thisType, sym.name, sym.denot)) def etaExpandCFT(using Context): Tree = def expand(target: Tree, tp: Type)(using Context): Tree = tp match @@ -1415,7 +1412,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { @tailrec def sameTypes(trees: List[tpd.Tree], trees1: List[tpd.Tree]): Boolean = - if (trees.isEmpty) trees.isEmpty + if (trees.isEmpty) trees1.isEmpty else if (trees1.isEmpty) trees.isEmpty else (trees.head.tpe eq trees1.head.tpe) && sameTypes(trees.tail, trees1.tail) diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala index 0466d538915e..34699c047f13 100644 --- a/compiler/src/dotty/tools/dotc/ast/untpd.scala +++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala @@ -44,6 +44,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { extends MemberDef { type ThisTree[+T <: Untyped] <: Trees.NameTree[T] & Trees.MemberDef[T] & ModuleDef def withName(name: Name)(using Context): ModuleDef = cpy.ModuleDef(this)(name.toTermName, impl) + def isBackquoted: Boolean = hasAttachment(Backquoted) } /** An untyped template with a derives clause. Derived parents are added to the end @@ -82,6 +83,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { assert(args.length == erasedParams.length) def hasErasedParams = erasedParams.contains(true) + override def toString = s"FunctionWithMods($args, $body, $mods, $erasedParams)" } /** A polymorphic function type */ diff --git a/compiler/src/dotty/tools/dotc/cc/Capability.scala b/compiler/src/dotty/tools/dotc/cc/Capability.scala index f22b55939c82..fa8833de0e50 100644 --- a/compiler/src/dotty/tools/dotc/cc/Capability.scala +++ b/compiler/src/dotty/tools/dotc/cc/Capability.scala @@ -516,6 +516,7 @@ object Capabilities: case tp1: (TermRef | TypeRef) => // can't use NamedType here since it is not a capability if tp1.symbol.maybeOwner.isClass && !tp1.symbol.is(TypeParam) then tp1.prefix match + case pre: ObjectCapability if pre.refersToPackage => tp1 case pre: Capability => pre.pathRoot case _ => tp1 else tp1 @@ -531,6 +532,7 @@ object Capabilities: */ final def pathOwner(using Context): Symbol = pathRoot match case tp1: ThisType => tp1.cls + case tp1: TermRef if tp1.symbol.is(Module) => tp1.symbol.moduleClass case tp1: NamedType => tp1.symbol.owner case _: GlobalCap => defn.CapsModule.moduleClass case tp1: LocalCap => tp1.ccOwner @@ -779,6 +781,8 @@ object Capabilities: this.subsumes(hi) case _ => y.captureSetOfInfo.elems.forall(this.subsumes) + case y: ThisType if y.cls.is(Module) => + this.subsumes(y.cls.sourceModule.termRef) case _ => false || this.match case Reach(x1) => x1.subsumes(y.stripReach) @@ -793,6 +797,8 @@ object Capabilities: lo.subsumes(y) case _ => x.captureSetOfInfo.elems.exists(_.subsumes(y)) + case x: ThisType if x.cls.is(Module) => + x.cls.sourceModule.termRef.subsumes(y) case _ => false catch case ex: AssertionError => println(i"error while subsumes $this >> $y") @@ -839,13 +845,15 @@ object Capabilities: case y: ResultCap => vs.unify(x, y) case _ => y.derivesFromCapTrait(defn.Caps_SharedCapability) case _: GlobalCap => + def globalCapSubsumes = + canAddHidden && vs != VarState.HardSeparate && CCState.globalCapIsRoot y match case _: GlobalCap => this eq y case _: ResultCap => false - case _: LocalCap if CCState.collapseLocalCaps => true - case _ => - y.derivesFromCapTrait(defn.Caps_SharedCapability) - || canAddHidden && vs != VarState.HardSeparate && CCState.globalCapIsRoot + case _: LocalCap if CCState.collapseLocalCaps || globalCapSubsumes => true + case _ => globalCapSubsumes + // also had: || y.derivesFromCapTrait(defn.Caps_SharedCapability) + // but this fails i25863a.scala, i.e compilers without errors where there should be case Restricted(x1, cls) => y.isKnownClassifiedAs(cls) && x1.maxSubsumes(y, canAddHidden) case _ => @@ -973,6 +981,20 @@ object Capabilities: else if cls2.isSubClass(cls1) then cls2 else defn.NothingClass + /** The least classifier that both `cls1` and `cls2` extend, or `AnyClass`, + * if `cls1` and `cls2` don't have a common ancestor classifier. It is + * assumed that each of `cls1` and `cls2` is either a classifier class or + * is equal to AnyClass. + */ + def greatestClassifier(cls1: ClassSymbol, cls2: ClassSymbol)(using Context): ClassSymbol = + if cls1.isSubClass(cls2) then cls1 + else if cls2.isSubClass(cls1) then cls2 + else + cls1.classDenot.baseClasses + .find: bc1 => + bc1.isClassifiedCapabilityClass && cls2.isSubClass(bc1) + .getOrElse(defn.AnyClass) + /** The smallest list D of class symbols in cs1 and cs2 such that * every class symbol in cs1 and cs2 is a subclass of a class symbol in D */ @@ -1235,7 +1257,7 @@ object Capabilities: abstract class CapMap(using Context) extends BiTypeMap: override def mapOver(t: Type): Type = t match - case t @ FunctionOrMethod(args, res) if variance > 0 && !t.isAliasFun => + case t @ FunctionOrMethod(_, _) if variance > 0 && !t.isAliasFun => t // `t` should be mapped in this case by a different call to `toResult`. See [[toResultInResults]]. case t: (LazyRef | TypeVar) => mapConserveSuper(t) diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala index 321fb1f0cf42..3818cd513538 100644 --- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala +++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala @@ -136,9 +136,7 @@ extension (tp: Type) false private def isPrefixOfTrackableRef(using Context): Boolean = - isTrackableRef || tp.match - case tp: TermRef => tp.symbol.is(Package) - case _ => false + isTrackableRef || tp.refersToPackage /** The capture set of a type. This is: * - For object capabilities: The singleton capture set consisting of @@ -504,8 +502,8 @@ extension (tp: Type) case tp: MethodType => tp.derivedLambdaType(paramInfos = argTypes, resType = resType) case tp: PolyType => - assert(argTypes.isEmpty) - tp.derivedLambdaType(resType = resType) + assert(argTypes.forall(_.isInstanceOf[TypeBounds])) + tp.derivedLambdaType(paramInfos = argTypes.asInstanceOf[List[TypeBounds]], resType = resType) case _ => tp @@ -572,26 +570,34 @@ extension (cls: ClassSymbol) { * @return the implied capture set, and the list of fields contributing to it */ def capturesImpliedByFields(core: Type)(using Context): (refs: CaptureSet, fields: List[Symbol]) = { - var infos: List[String] = Nil - def pushInfo(msg: => String) = - if ctx.settings.YccVerbose.value then infos = msg :: infos - def knownFields(cls: ClassSymbol) = ccState.fieldsWithExplicitTypes // pick fields with explicit types for classes in this compilation unit .getOrElse(cls, cls.info.decls.toList) // pick all symbols in class scope for other classes - /** The classifiers of the LocalCaps in the span capture sets of all fields - * in the given class `cls`. + def commonAncestor(clss: List[ClassSymbol]): Symbol = + if clss.isEmpty then NoSymbol + else clss.reduce(greatestClassifier) + + /** The implied classifier of the LocalCap of the class instance, derived from + * - the clasifiers of the LocalCaps in the span capture sets of all fields + * - the implied classifiers of the parent classes + * - if `cls` is a stateful class, the classifier of `cls` itself + * @return The implied classidier, or NoSymbol is there is no LocalCap + * to be generated for the instance. */ - def impliedClassifiers(cls: Symbol): List[ClassSymbol] = cls match + def impliedClassifier(cls: Symbol): Symbol = cls match case cls: ClassSymbol => - var fieldClassifiers = knownFields(cls).flatMap(classifiersOfLocalCapsInType) + val fieldClassifiers = + knownFields(cls).flatMap(classifiersOfLocalCapsInType) val parentClassifiers = - cls.parentSyms.map(impliedClassifiers).filter(_.nonEmpty) - if fieldClassifiers.isEmpty && parentClassifiers.isEmpty - then Nil - else parentClassifiers.foldLeft(fieldClassifiers.distinct)(dominators) - case _ => Nil + cls.parentSyms.map(impliedClassifier).collect: + case cl: ClassSymbol => cl + val stateClassifiers = + if cls.typeRef.isStatefulType(varsOnly = true) + then cls.classifier :: Nil + else Nil + commonAncestor(fieldClassifiers ++ parentClassifiers ++ stateClassifiers) + case _ => NoSymbol def contributingFields(cls: Symbol): List[Symbol] = cls match case cls: ClassSymbol => @@ -608,20 +614,17 @@ extension (cls: ClassSymbol) { def localCap(fields: List[Symbol]) = LocalCap(Origin.NewInstance(core, fields)) - var implied = impliedClassifiers(cls) - if cls.typeRef.isStatefulType(varsOnly = true) then - implied = dominators(cls.classifier :: Nil, implied) - val fields = contributingFields(cls) - val impliedSet = ccState.localCapClassifiersAndFieldsCache.getOrElseUpdate(cls, (implied, fields)) match - case (Nil, _) => + val impliedClr = impliedClassifier(cls) + val contributing = contributingFields(cls) + val impliedSet = impliedClr match + case impliedClr: ClassSymbol => + val result = localCap(contributing) + if impliedClr != defn.AnyClass then + result.hiddenSet.adoptClassifier(impliedClr) + maybeRO(result, contributing).singletonCaptureSet + case _ => CaptureSet.empty - case (cl :: Nil, fields) => - val result = localCap(fields) - result.hiddenSet.adoptClassifier(cl) - maybeRO(result, fields).singletonCaptureSet - case (_, fields) => - maybeRO(localCap(fields), fields).singletonCaptureSet - (impliedSet, fields) + (impliedSet, contributing) } def creationCapset(using Context)(core: Type = cls.appliedRef): CaptureSet = @@ -783,6 +786,12 @@ extension (sym: Symbol) { def isDisallowedInCapset(using Context): Boolean = sym.isOneOf(if ccConfig.strictMutability then Method else UnstableValueFlags) + def isScalaDocSnippet(using Context): Boolean = + sym.is(ModuleClass) + && (sym.sourceModule.name == nme.Snippet) + && sym.owner.is(Package) + && sym.owner.name.toString.contains("snippet") + /** Is symbol exempt from checking that its type or uses clause must * be given explicitly? This is the case for symbols that are not * visible outside the compilation unit where they are defined, @@ -790,13 +799,20 @@ extension (sym: Symbol) { */ def isExemptFromExplicitChecks(using Context): Boolean = sym.isLocalToCompilationUnit + || sym.isScalaDocSnippet + || sym.name.isReplWrapperName + || sym.isConstructor && sym.owner.name.isReplWrapperName || ctx.owner.enclosingPackageClass.isEmptyPackage - // We make an exception for symbols in the empty package. - // these could theoretically be accessed from other files in the empty package, but - // usually it would be too annoying to require explicit types. + && !sym.ownersIterator.takeWhile(!_.is(Package)) + .exists(_.hasAnnotation(defn.AssumeSafeAnnot)) + // We make an exception for symbols in the empty package unless they are + // compiled in safe mode or wrapped in @assumeSafe. These could theoretically + // be accessed from other files in the empty package, but usually it would + // be too annoying to require explicit types. @assumeSafe symbols are not exempt, + // since for them precise recording of capabilities is essential. || sym.name.is(DefaultGetterName) // Default getters are exempted since otherwise it would be - // too annoying. This is a hole since a defualt getter's result type + // too annoying. This is a hole since a default getter's result type // might leak into a type variable. /** If `sym` is a method or a non-static inner class, a capture set @@ -805,8 +821,11 @@ extension (sym: Symbol) { def useSet(using Context): CaptureSet = ccState.useSetCache.getOrElseUpdate(sym, sym.getAnnotation(defn.RetainsAnnot) match - case Some(ann: RetainingAnnotation) => - try ann.toCaptureSet + case Some(ann) => + // If we read from Tasty, the annotation is not a RetainingAnnotation but is + // instead a regular annotation of type TreeUnpickler#DeferredSymAndTree. + // Map it to a RetainingAnnotation now. + try RetainingAnnotation.fromAnnotation(ann).toCaptureSet catch case ex: IllegalCaptureRef => report.error(em"Illegal capture reference: ${ex.getMessage}", sym.srcPos) CaptureSet.empty @@ -889,12 +908,16 @@ class PathSelectionProto(val selector: Symbol, val pt: Type, val tree: Tree) ext * argument if CC is enabled (we need to do that to keep by-name status). */ class CleanupRetains(using Context) extends TypeMap: + var retainsFound: Boolean = false def apply(tp: Type): Type = tp match case tp @ AnnotatedType(parent, annot: RetainingAnnotation) => if Feature.ccEnabled then + retainsFound = true if annot.symbol == defn.RetainsCapAnnot then tp else AnnotatedType(this(parent), RetainingAnnotation(annot.symbol.asClass, defn.NothingType)) else this(parent) + case tp @ AnnotatedType(parent, annot) if annot.symbol == defn.DeclaredAnnot => + tp case _ => mapOver(tp) /** A base class for extractors that match annotated types with a specific @@ -939,14 +962,13 @@ end OnlyCapability /** An extractor for all kinds of function types as well as method and poly types. * It includes aliases of function types such as `=>`. TODO: Can we do without? - * @return 1st half: The argument types or empty if this is a type function + * @return 1st half: The argument types or type bounds if this is a type function * 2nd half: The result type */ object FunctionOrMethod: def unapply(tp: Type)(using Context): Option[(List[Type], Type)] = tp match case defn.FunctionOf(args, res, isContextual) => Some((args, res)) - case mt: MethodType => Some((mt.paramInfos, mt.resType)) - case mt: PolyType => Some((Nil, mt.resType)) + case mt: MethodOrPoly => Some((mt.paramInfos, mt.resType)) case defn.RefinedFunctionOf(rinfo) => unapply(rinfo) case _ => None diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala index 3f8ec2accec7..4557c7ae202c 100644 --- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala +++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala @@ -29,6 +29,7 @@ import NameOps.isReplWrapperName import reporting.* import reporting.Message.Note import Annotations.Annotation +import Constants.Constant import Capabilities.* import Mutability.* import util.common.alwaysTrue @@ -269,11 +270,6 @@ class CheckCaptures extends Recheck, SymTransformer: def newRechecker()(using Context) = CaptureChecker(ctx) - override def runOn(units: List[CompilationUnit])(using runCtx: Context): List[CompilationUnit] = - if Feature.ccEnabledSomewhere then - SafeRefs.init()(using ctx.withPhase(thisPhase)) - super.runOn(units) - override protected def run(using Context): Unit = if Feature.ccEnabled then super.run @@ -742,15 +738,21 @@ class CheckCaptures extends Recheck, SymTransformer: // that uses captured references. includeCallCaptures(sym, sym.info, tree) - if sym.exists && !sym.is(Method) && !sym.is(Package) then - // Mark symbol as used, either as a path if it is a field of some tracked object - // or by itself. - sym.maybeOwner.thisType match - case ref: ThisType - if ref.isTracked && sym.isTerm => - markPathFree(ref, PathSelectionProto(sym, pt, tree), tree) + if sym.exists && !sym.is(Package) + && !(sym.is(Method) && ctx.owner.isContainedIn(sym.owner.skipWeakOwner)) + // if it's a method in some enclosing scope the call captures already cover the use set + // skipWeakOwner: Also exempt symbols in package objects of the source when referenced + // from classes in the same source. + then + // Mark symbol as used + // - as a path if it is a member of some tracked object + // - by itself if it is not a method + tree.tpe.stripped match + case TermRef(prefix: (TermRef | ThisType), _) if prefix.isTracked => + markPathFree(prefix, PathSelectionProto(sym, pt, tree), tree) case _ => - markPathFree(sym.termRef, pt, tree) + if !sym.is(Method) then + markPathFree(sym.termRef, pt, tree) if sym.isMutableVar && sym.owner.isTerm && pt != LhsProto then // When we have `var x: A^{c} = ...` where `x` is a local variable then @@ -759,7 +761,6 @@ class CheckCaptures extends Recheck, SymTransformer: // charged for the prefix `p` in `p.x`. markFree(sym.info.captureSet, tree) - SafeRefs.checkSafe(tree, pt) mapResultRoots(super.recheckIdent(tree, pt), tree) } @@ -817,8 +818,6 @@ class CheckCaptures extends Recheck, SymTransformer: } case _ => denot - SafeRefs.checkSafe(tree, pt) - // Don't allow update methods to be called unless the qualifier captures // an exclusive reference. if tree.symbol.isUpdateMethod then @@ -985,14 +984,37 @@ class CheckCaptures extends Recheck, SymTransformer: /** Handle an application of method `sym` with type `mt` to arguments of types `argTypes`. * This means * - Instantiate result type with actual arguments - * - if `sym` is a constructor, refine its type with `refineInstanceType` + * - if `sym` is a constructor, refine its type with `refineConstructorInstance` */ override def instantiate(mt: MethodType, argTypes: List[Type], sym: Symbol)(using Context): Type = val ownType = if !mt.isResultDependent then mt.resType else SubstParamsMap(mt, argTypes)(mt.resType) + def instCls = ownType.finalResultType.classSymbol.asClass if sym.needsResultRefinement then - refineConstructorInstance(ownType, mt, argTypes, ownType.finalResultType.classSymbol.asClass) + refineConstructorInstance(ownType, mt, argTypes, instCls) + else if sym.isSecondaryConstructor then + // Refine primary constructor instance with a list of arguments of matching + // length that is constructed as follows: + // - If the argument is for a primary constructor parameter named `x` + // and there is a secondary constructor parameter carrying an + // annotation `@caps.internal.paramAlias("x")`, pick the actual argument + // in `argTypes` that corresponds to this secondary constructor parameter. + // We assume there can be at most one such secondary constructor parameter. + // - Otherwise the argument is NoType. + instCls.primaryConstructor.info.stripPoly match + case primaryMt: MethodType => + var aliasMap = Map.empty[Name, Type] + for (param, argType) <- sym.paramSymss.flatten.filter(_.isTerm).lazyZip(argTypes) do + for + ann <- param.annotations.filter(_.matches(defn.ParamAliasAnnot)) + name <- ann.argumentConstantString(0) + do + aliasMap = aliasMap.updated(name.toTermName, argType) + val aliasedArgs = instCls.paramGetters.map: param => + aliasMap.getOrElse(param.name, NoType) + refineConstructorInstance(ownType, primaryMt, aliasedArgs, instCls) + case _ => ownType else ownType /** Refine the type returned from a constructor as follows: @@ -1022,16 +1044,19 @@ class CheckCaptures extends Recheck, SymTransformer: for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do val getter = cls.refiningGetterNamed(getterName) if !getter.is(Private) && getter.hasTrackedParts then - if !getter.is(Tracked) then - refined = refined.refinedOverride(getterName, argType.unboxed) - // We can assume unboxed since the use set contributed by field selection is also the capture set - // So unboxing will not add anything to the use sets. - // This trick is also the principal reason why we can't make refineConstructorInstance - // an operation to work on the declared constructor types. We would miss the necessary unboxed that way. - if getter.hasAnnotation(defn.ConsumeAnnot) then - () // We make sure in checkClassDef, point (6), that consume parameters don't - // contribute to the class capture set - else allCaptures ++= argType.captureSet + if argType.exists then + if !getter.is(Tracked) then + refined = refined.refinedOverride(getterName, argType.unboxed) + // We can assume unboxed since the use set contributed by field selection is also the capture set + // So unboxing will not add anything to the use sets. + // This trick is also the principal reason why we can't make refineConstructorInstance + // an operation to work on the declared constructor types. We would miss the necessary unboxed that way. + if getter.hasAnnotation(defn.ConsumeAnnot) then + () // We make sure in checkClassDef, point (6), that consume parameters don't + // contribute to the class capture set + else allCaptures ++= argType.captureSet + else + allCaptures ++= cls.mapClassCaptures(core, getter.info.captureSet) (refined, allCaptures) /** Augment result type of constructor with refinements and captures. @@ -1066,9 +1091,6 @@ class CheckCaptures extends Recheck, SymTransformer: case fun => fun.symbol def methDescr = if meth.exists then i"$meth's type " else "" - if meth == defn.Any_asInstanceOf && Feature.safeEnabled then - report.error(em"Cannot use asInstanceOf in safe mode", tree.srcPos) - markFreeTypeArgs(tree.fun, meth, tree.args) val funType = super.recheckTypeApply(tree, pt) @@ -1170,8 +1192,8 @@ class CheckCaptures extends Recheck, SymTransformer: assert(params.hasSameLengthAs(argTypes), i"$mdef vs $pt, ${params}") inContext(ctx.withOwner(anonfun)) { // Propagate argument types to parameter types with inferred types - for (argType, param) <- argTypes.lazyZip(params) do - param.asInstanceOf[ValDef].tpt match + for case (argType, param: ValDef) <- argTypes.lazyZip(params) do + param.tpt match case paramTpt: InferredTypeTree => val localArgType = globalCapToLocal(argType, Origin.Parameter(param.symbol)) adoptCaptures(param.symbol.info, localArgType) @@ -1256,10 +1278,6 @@ class CheckCaptures extends Recheck, SymTransformer: override def seqLiteralElemProto(tree: SeqLiteral, pt: Type, declared: Type)(using Context) = super.seqLiteralElemProto(tree, pt, declared).boxed - override def recheckNew(tree: New, pt: Type)(using Context): Type = - SafeRefs.checkSafe(tree, pt) - super.recheckNew(tree, pt) - /** Recheck val and var definitions: * - disallow `any` in the type of mutable vars. * - for externally visible definitions: check that their inferred type @@ -1267,11 +1285,10 @@ class CheckCaptures extends Recheck, SymTransformer: * - Interpolate contravariant capture set variables in result type. * - for lazy vals: create a nested environment to track captures (similar to methods) */ - override def recheckValDef(tree: ValDef, sym: Symbol)(using Context): Type = + override def recheckValDef(tree: ValDef, sym: Symbol)(using Context): Type = { val savedEnv = curEnv val runInConstructor = !sym.isOneOf(Param | ParamAccessor | Lazy | NonMember) try - SafeRefs.checkSafeAnnots(sym) if sym.is(Mutable) then if !sym.hasAnnotation(defn.UncheckedCapturesAnnot) then val addendum = setup.capturedBy.get(sym) match @@ -1323,7 +1340,12 @@ class CheckCaptures extends Recheck, SymTransformer: // This is different from captureSetImpliedByFields since the latter produces // LocalCaps from inside the class. markFree(declaredCaptures, tree, addUseInfo = false) - end recheckValDef + + if sym.owner.derivesFrom(defn.Caps_Classifier) then + todoAtPostCheck += { () => + checkFieldOfClassifiedClass(sym, declaredCaptures, sym.owner.asClass, tree.namePos) + } + } /** Recheck method definitions: * - check body in a nested environment that tracks uses, in a nested level, @@ -1365,13 +1387,6 @@ class CheckCaptures extends Recheck, SymTransformer: if ac.isEmpty then ctx else ctx.withProperty(CaptureSet.AssumedContains, Some(ac)) - SafeRefs.checkSafeAnnots(sym) - for params <- tree.paramss; param <- params do - SafeRefs.checkSafeAnnots(param.symbol) - param match - case param: ValDef => SafeRefs.checkSafeAnnotsInType(param.tpt) - case param: TypeDef => SafeRefs.checkSafeAnnotsInType(param.rhs) - checkNoUnboxedReaches(tree) try checkInferredResult(super.recheckDefDef(tree, sym)(using bodyCtx), tree) @@ -1383,32 +1398,6 @@ class CheckCaptures extends Recheck, SymTransformer: curEnv = saved } - def isScalaDocSnippet(sym: Symbol)(using Context): Boolean = - sym.is(ModuleClass) - && (sym.sourceModule.name == nme.Snippet) - && sym.owner.is(Package) - && sym.owner.name.toString.contains("snippet") - - /** Is symbol exempt from checking that its type or uses clause must - * be given explicitly? This is the case for symbols that are not - * visible outside the compilation unit where they are defined, - * and also for two pragmatic exemptions, explained below. - */ - def isExemptFromExplicitChecks(sym: Symbol)(using Context): Boolean = - sym.isLocalToCompilationUnit - || isScalaDocSnippet(sym) - || sym.name.isReplWrapperName - || ctx.owner.enclosingPackageClass.isEmptyPackage - // We make an exception for symbols in the empty package. - // these could theoretically be accessed from other files in the empty package, but - // usually it would be too annoying to require explicit types. - || sym.name.is(DefaultGetterName) - // Default getters are exempted since otherwise it would be - // too annoying. This is a hole since a defualt getter's result type - // might leak into a type variable. - || sym.needsResultRefinement - // If we refine the result type anyway, the inferred type does not matter. - /** Two tests for member definitions with inferred types: * * 1. If val or def definition with inferred (result) type is visible @@ -1416,13 +1405,15 @@ class CheckCaptures extends Recheck, SymTransformer: * conforms to the expected type where all inferred capture sets are dropped. * This ensures that if files compile separately, they will also compile * in a joint compilation. - * 2. If a val has an inferred type with a terminal capability in its span capset, - * check that it this capability is subsumed by the capset that was inferred + * 2. If a val has an inferred type with a terminal capability in its capture set, + * check that this capability is subsumed by the capset that was inferred * for the class from its other fields via `captureSetImpliedByFields`. * That capset is defined to take into account all fields but is computed * only from fields with explicitly given types in order to avoid cycles. * See comment on Setup.fieldsWithExplicitTypes. So we have to make sure * that fields with inferred types would not change that capset. + * REPL wrapper objects are exempt since they are invisible to the user + * and should not impose explicit type requirements on REPL definitions. */ def checkInferredResult(tp: Type, tree: ValOrDefDef)(using Context): Type = { val sym = tree.symbol @@ -1456,7 +1447,9 @@ class CheckCaptures extends Recheck, SymTransformer: tree.tpt match case tpt: InferredTypeTree => // Test point (1) of doc comment above - if !isExemptFromExplicitChecks(sym) then // Symbols that can't be seen outside the compilation unit can have inferred types + if !sym.isExemptFromExplicitChecks // Symbols that can't be seen outside the compilation unit can have inferred types + && !sym.needsResultRefinement // If we refine the result type anyway, the inferred type does not matter + then // Symbols that can't be seen outside the compilation unit can have inferred types val expected = tpt.tpe.dropAllRetains todoAtPostCheck += { () => withGlobalCapAsRoot: @@ -1469,6 +1462,7 @@ class CheckCaptures extends Recheck, SymTransformer: cls.isPackageObject && cls.enclosingPackageClass.isEmptyPackage if sym.owner.isClass && !isToplevelDefsInEmptyPackage(sym.owner) + && !sym.owner.name.isReplWrapperName // REPL wrappers are invisible to the user && contributesLocalCapToClass(sym) && !CaptureSet.isAssumedPure(sym) then @@ -1487,28 +1481,37 @@ class CheckCaptures extends Recheck, SymTransformer: tp } - /** Check that capture sets of fields are compatible with declared extensions of - * the class. This means: - * 1. If `cls` extends a Classifier class, check that all any-classifiers in fields - * conform to the classifier of the class. - * 2. If `cls` is externally visible and has fields with `any` types, it must - * extend Capability. + /** Check that field `fld` with type `cs` only captures capabilities that conform to + * the classifier of `cls`. */ - def checkFieldCaptures(cls: ClassSymbol)(using Context): Unit = { - lazy val capFields = cls.capturesImpliedByFields(cls.appliedRef).fields - // (1) - if cls.derivesFrom(defn.Caps_Classifier) then - for fld <- capFields; cl <- fld.classifiersOfLocalCapsInType do - if !fld.name.is(WildcardParamName) && !cl.derivesFrom(cls.classifier) then - def fldClassifier = - if cl == defn.AnyClass then i"of unclassified type ${fld.info}" - else i"classified as ${cl.typeRef}" + def checkFieldOfClassifiedClass(fld: Symbol, cs: CaptureSet, cls: ClassSymbol, pos: SrcPos)(using Context): Unit = + if !fld.name.is(WildcardParamName) then + for ref <- cs.elems do + //println(i"checking $fld: $ref, ${ref.transClassifiers}, ${cs.transClassifiers} / ${cs.isConst}") + def fail(classified: String) = + val captures = + if ref.isTerminalCapability then "" + else i" captures ${ref.showAsCapability} which" report.error( - em"""$cls is classied as ${cls.classifier.typeRef} but has a field ${fld.name} $fldClassifier. + em"""$fld's type ${fld.info}$captures is $classified, + |but it is a field of $cls which is classied as ${cls.classifier.typeRef}. |Field classifiers have to conform to the classifier of the containing class.""", - cls.srcPos) - // (2) - if !isExemptFromExplicitChecks(cls) + pos) + ref.transClassifiers match + case Classifiers.Unclassified => + fail("unclassified") + case Classifiers.ClassifiedAs(cs) => + for c <- cs do + if !c.derivesFrom(cls.classifier) then + fail(i"classified as ${c.typeRef}") + case _ => + + /** Check: If `cls` is externally visible and has fields with `any` types, it must + * extend Capability. + */ + def checkFieldCaptures(cls: ClassSymbol)(using Context): Unit = + val capFields = cls.capturesImpliedByFields(cls.appliedRef).fields + if !cls.isExemptFromExplicitChecks && !cls.derivesFromCapability && capFields.nonEmpty then @@ -1520,7 +1523,6 @@ class CheckCaptures extends Recheck, SymTransformer: report.error(em"$fields need to be put in an object that extends Capability", capFields.head.srcPos) else report.error(em"$cls needs to extend Capability since it has $fields.", cls.srcPos) - } /** The normal rechecking if `sym` was already completed before */ override def skipRecheck(sym: Symbol)(using Context): Boolean = @@ -1583,7 +1585,8 @@ class CheckCaptures extends Recheck, SymTransformer: try // (2) Capture set of self type includes capture set of class val thisSet = cls.classInfo.selfType.captureSet.withDescription(i"of the self type of $cls") - checkSubset(localSet, thisSet, tree.srcPos) + withGlobalCapAsRoot: // OK? We need this here since self types use GlobalAny instead of a LocalCap + checkSubset(localSet, thisSet, tree.srcPos) // (3) Capture set of self type includes capture sets of tracked parameters for param <- cls.paramGetters do @@ -1614,7 +1617,6 @@ class CheckCaptures extends Recheck, SymTransformer: markFreeTypeArgs(tpt, fn.typeSymbol, args.map(TypeTree(_))) case _ => - SafeRefs.checkSafeAnnots(cls) checkFieldCaptures(cls) super.recheckClassDef(tree, impl, cls) @@ -1656,10 +1658,6 @@ class CheckCaptures extends Recheck, SymTransformer: tree.srcPos) tp - override def recheckTypeTree(tree: TypeTree)(using Context): Type = - SafeRefs.checkSafeAnnotsInType(tree) - super.recheckTypeTree(tree) - /* Currently not needed, since capture checking takes place after ElimByName. * Keep around in case we need to get back to it def recheckByNameArg(tree: Tree, pt: Type)(using Context): Type = @@ -1983,7 +1981,10 @@ class CheckCaptures extends Recheck, SymTransformer: val resTp = if (aargs1 eq aargs) && (ares1 eq ares) then actualShape // optimize to avoid redundant matches else actualShape.derivedFunctionOrMethod(aargs1, ares1) - (resTp, CaptureSet(curEnv.captured.elems)) + curEnv.captured match + case cs: CaptureSet.Var => cs.markSolved(provisional = true) + case _ => + (resTp, curEnv.captured) finally curEnv = saved case _ => (actualShape, CaptureSet()) diff --git a/compiler/src/dotty/tools/dotc/cc/RetainingAnnotation.scala b/compiler/src/dotty/tools/dotc/cc/RetainingAnnotation.scala index 7026313ef41c..a7bee572d900 100644 --- a/compiler/src/dotty/tools/dotc/cc/RetainingAnnotation.scala +++ b/compiler/src/dotty/tools/dotc/cc/RetainingAnnotation.scala @@ -5,13 +5,14 @@ package cc import core.* import Types.*, Symbols.*, Contexts.* import Annotations.{Annotation, CompactAnnotation, EmptyAnnotation} +import ast.tpd.TypeTree import config.Feature /** A class for annotations @retains, @retainsByName and @retainsCap * We make sure that all annotations with these classes are represented * as RetainingAnnotations. */ -class RetainingAnnotation(tpe: Type) extends CompactAnnotation(tpe): +class RetainingAnnotation(tpe: Type) extends CompactAnnotation(tpe) { def this(cls: ClassSymbol, args: Type*)(using Context) = this(cls.typeRef.appliedTo(args.toList)) @@ -48,5 +49,17 @@ class RetainingAnnotation(tpe: Type) extends CompactAnnotation(tpe): if myCaptureSet == null then myCaptureSet = CaptureSet(retainedType.retainedElements*) myCaptureSet.nn +} +object RetainingAnnotation { -end RetainingAnnotation + /** Convert annotation with retains as symbol to a RetainingAnnotation */ + def fromAnnotation(ann: Annotation)(using Context): RetainingAnnotation = ann match + case ann: RetainingAnnotation => ann + case _ => + assert(ann.symbol.isRetains) + ann.tree match + case atree: TypeTree => // this is the case if sourceVersion.enablesCompactAnnotation + CompactAnnotation(atree.tpe).asInstanceOf[RetainingAnnotation] + case atree => + CompactAnnotation(atree).asInstanceOf[RetainingAnnotation] +} diff --git a/compiler/src/dotty/tools/dotc/cc/SafeRefs.scala b/compiler/src/dotty/tools/dotc/cc/SafeRefs.scala index 70bdffb70b4b..592ef3d51134 100644 --- a/compiler/src/dotty/tools/dotc/cc/SafeRefs.scala +++ b/compiler/src/dotty/tools/dotc/cc/SafeRefs.scala @@ -6,21 +6,27 @@ import core.* import Symbols.* import Annotations.* import util.Spans.NoSpan -import util.SrcPos -import Contexts.Context +import util.{Property, SrcPos} +import Contexts.{Context, ctx} import Constants.Constant import Decorators.* import ast.tpd.* import SymDenotations.* import Flags.* import Types.* -import config.Feature +import Names.Name +import NameOps.isReplWrapperName import config.Printers.capt -import typer.ProtoTypes.SelectionProto /** Check whether references from safe mode should be allowed */ object SafeRefs { + val assumedSafePackages = List( + "scala", "scala.runtime", "scala.collection.immutable", "scala.compiletime.ops", + "scala.math", "scala.util", "scala.caps", "java.math", "java.time", + "java.util.function", "java.util.regex", "java.util.stream" + ) + private def rejectSafe(sym: Symbol)(using Context): Unit = if !sym.infoOrCompleter.isInstanceOf[StubInfo] then sym.addAnnotation(Annotation(defn.RejectSafeAnnot, List(Literal(Constant(""))), NoSpan)) @@ -50,9 +56,11 @@ object SafeRefs { * Once we have an updated ccException in the bootstrap compiler, we could add annotations * to library classes manually, as long as these library classes are capture checked. */ - def init()(using Context): Unit = + def init()(using Context): Unit = { assumeSafe("scala.Predef", except = List("print", "println", "printf")) assumeSafe("scala.runtime.coverage.Invoker") + assumeSafe("scala.reflect.ClassTag") + assumeSafe("scala.util.Properties", except = List("setProp", "clearProp", "main")) assumeSafe("java.lang.Object") assumeSafe("java.lang.Boolean") assumeSafe("java.lang.Byte") @@ -63,14 +71,45 @@ object SafeRefs { assumeSafe("java.lang.Long") assumeSafe("java.lang.Float") assumeSafe("java.lang.Double") + assumeSafe("java.lang.Void") assumeSafe("java.lang.Enum") assumeSafe("java.lang.Math") assumeSafe("java.lang.StrictMath") assumeSafe("java.lang.Number") assumeSafe("java.lang.String") assumeSafe("java.lang.Throwable") - assumeSafe("java.lang.Void") assumeSafe("java.lang.Exception") + assumeSafe("java.lang.RuntimeException") + assumeSafe("java.lang.ArithmeticException") + assumeSafe("java.lang.ArrayIndexOutOfBoundsException") + assumeSafe("java.lang.ArrayStoreException") + assumeSafe("java.lang.ClassCastException") + assumeSafe("java.lang.ClassNotFoundException") + assumeSafe("java.lang.CloneNotSupportedException") + assumeSafe("java.lang.EnumConstantNotPresentException") + assumeSafe("java.lang.IllegalAccessException") + assumeSafe("java.lang.IllegalArgumentException") + assumeSafe("java.lang.IllegalMonitorStateException") + assumeSafe("java.lang.IllegalStateException") + assumeSafe("java.lang.IllegalThreadStateException") + assumeSafe("java.lang.IndexOutOfBoundsException") + assumeSafe("java.lang.InstantiationException") + assumeSafe("java.lang.InterruptedException") + assumeSafe("java.lang.NegativeArraySizeException") + assumeSafe("java.lang.NoSuchFieldException") + assumeSafe("java.lang.NoSuchMethodException") + assumeSafe("java.lang.NullPointerException") + assumeSafe("java.lang.NumberFormatException") + assumeSafe("java.lang.ReflectiveOperationException") + assumeSafe("java.lang.SecurityException") + assumeSafe("java.lang.StringIndexOutOfBoundsException") + assumeSafe("java.lang.TypeNotPresentException") + assumeSafe("java.lang.UnsupportedOperationException") + // `java.lang.Error` and its subclasses are intentionally not marked safe: + // they indicate serious VM-level problems and should not be caught or + // thrown from safe code. + assumeSafe("java.lang.StackTraceElement") + assumeSafe("java.lang.Record") assumeSafe("java.lang.CharSequence") assumeSafe("java.lang.Comparable") assumeSafe("java.lang.Class", except = List( @@ -85,21 +124,25 @@ object SafeRefs { "getPackage", "getPackageName", "getPermittedSubclasses", "getProtectionDomain", "getRecordComponents", "getResource", "getResourceAsStream", "getSigners", "getTypeParameters", "getTypeName", "newInstance", "cast", "toGenericString")) - assumeSafe("java.util.Locale") - assumeSafe("java.util.Random") - assumeSafe("java.util.UUID") + assumeSafe("java.util.Locale", except = List("setDefault")) + assumeSafe("java.util.TimeZone", except = List("setDefault", "setID", "setRawOffset")) + assumeSafe("java.util.UUID", except = List("randomUIID")) assumeSafe("java.util.Objects") assumeSafe("java.util.Optional") assumeSafe("java.util.OptionalInt") assumeSafe("java.util.OptionalLong") assumeSafe("java.util.OptionalDouble") - assumeSafe("java.util.TimeZone") + assumeSafe("java.util.NoSuchElementException") + rejectSafe("scala.Console") rejectSafe("scala.unchecked") rejectSafe("scala.annotation.unchecked.uncheckedOverride") rejectSafe("scala.annotation.unchecked.uncheckedStable") rejectSafe("scala.annotation.unchecked.uncheckedVariance") rejectSafe("scala.annotation.unchecked.uncheckedCaptures") + rejectSafe("scala.util.DynamicVariable") + rejectSafe("scala.util.Using") // todo capture check Using + // Reject mutable classes in scala.runtime rejectSafe("scala.runtime.BooleanRef") rejectSafe("scala.runtime.ByteRef") @@ -129,21 +172,77 @@ object SafeRefs { rejectSafe("scala.runtime.LazyFloat") rejectSafe("scala.runtime.LazyDouble") rejectSafe("scala.runtime.LazyUnit") + } + + /** Allow name in safe mode even though it contains `$` characters */ + def allowDollarIn(name: Name)(using Context): Boolean = + name.isReplWrapperName && ctx.mode.is(Mode.Interactive) private def fail(sym: Symbol, reason: String, pos: SrcPos)(using Context) = report.error(em"Cannot refer to ${sym.sanitizedDescription}${sym.showExtendedLocation} from safe code since $reason", pos) false private def checkNotRejected(sym: Symbol, pos: SrcPos)(using Context): Boolean = - if !sym.exists then true - else sym.getAnnotation(defn.RejectSafeAnnot) match + !sym.exists || sym.is(Package) || sym.getAnnotation(defn.RejectSafeAnnot).match case Some(annot) => val message = annot.argumentConstantString(0).getOrElse("") - fail(sym, if message.nonEmpty then message else i"it is tagged @rejectSafe", pos) + fail(sym, if message.nonEmpty then message else i"it is tagged @rejectSafe", pos) case _ => - sym.owner.is(Package) || checkNotRejected(sym.owner, pos) + checkNotRejected(sym.owner, pos) - def checkSafe(tree: Tree, pt: Type)(using Context): Unit = { + /** Check that all nodes of given tree for the following conditions. + * - No reference to a symbol under a @rejectSafe annotation + * - All references to static symbols are assumed safe: This means + * they have been compiled in safe mode, or have an @assumeSafe + * annotation or are owned by a symbol with an @assumeSafe annotation. + * - No reference to a user-defined annotation which is marked @rejectSafe + */ + object checker extends TreeTraverser: + private var checkTypes = false + def traverse(tree: Tree)(using Context) = + val sym = tree.symbol + tree match + case tree: Ident => + checkNotRejected(sym, tree.srcPos) + val isStatic = tree.tpe match + case NamedType(prefix, _) => + prefix.dealias match + case prefix: ThisType => prefix.cls.isStatic + case prefix: TermRef => prefix.symbol.isStatic + case _ => sym.isStatic + case _ => sym.isStatic + // if sym is not static it is local, a parameter, or comes from another symbol, + // which has been checked + if isStatic && (checkTypes || sym.isTerm) then + checkSafe(sym, tree) + case tree: Select => + checkNotRejected(sym, tree.srcPos) + if sym.isStatic && (checkTypes || sym.isTerm) + then checkSafe(sym, tree) + else traverseChildren(tree) + case New(tpt) => + val saved = checkTypes + checkTypes = true + try traverse(tpt) + finally checkTypes = saved + case Inlined(call, _, _) => + traverse(call) + case tree: MemberDef if !sym.is(Synthetic) => + for ann <- sym.annotations do + checkSafeAnnot(ann, sym.srcPos) + traverseChildren(tree) + case tree: TypeApply if sym == defn.Any_asInstanceOf => + report.error(em"Cannot use asInstanceOf in safe mode", tree.srcPos) + case Annotated(arg, annot) => + checkNotRejected(annot.symbol, annot.srcPos.orElse(tree.srcPos)) + traverseChildren(arg) + case tree: Import => + // skip imports, we want to be able to wildcard import from an unsafe + // object as long as all used members are @assumeSafe + case _ => + traverseChildren(tree) + + def checkSafe(sym: Symbol, tree: Tree)(using Context): Unit = { def isSafe(sym: Symbol): Boolean = if !sym.exists then false @@ -153,46 +252,15 @@ object SafeRefs { sym.hasAnnotation(defn.AssumeSafeAnnot) || isSafe(if sym.is(ModuleVal) then sym.moduleClass else sym.owner) - val (sym, checkLater) = tree match - case tree: New => - (tree.tpt.tpe.classSymbol, false) - case tree: RefTree => - val checkLater = - !tree.symbol.is(Method) - && pt.match - case pt: PathSelectionProto => pt.selector.isStatic - case _: SelectionProto => true - case _ => false - (tree.symbol, checkLater) - - if Feature.safeEnabled - && sym.exists - && checkNotRejected(sym, tree.srcPos) - && !checkLater - && sym.isStatic // if it's not static it is local, a parameter, or comes from another symbol, - // which has been checked - && !sym.is(Package) - && !isSafe(sym) - then + if sym.exists && !sym.is(Package) && !isSafe(sym) then fail(sym, "it is neither compiled in safe mode nor tagged with @assumedSafe", tree.srcPos) else - capt.println(i"checked safe $tree, $sym, $checkLater") + capt.println(i"checked safe $tree, $sym") } private def checkSafeAnnot(ann: Annotation, pos: SrcPos)(using Context): Unit = - var errpos = ann.tree.srcPos - if !pos.sourcePos.exists then errpos = pos - checkNotRejected(ann.symbol, errpos) - - def checkSafeAnnots(sym: Symbol)(using Context): Unit = - if Feature.safeEnabled then - for ann <- sym.annotations do - checkSafeAnnot(ann, sym.srcPos) - - def checkSafeAnnotsInType(tree: Tree)(using Context): Unit = - def checkAnnotatedType(tp: Type) = tp match - case AnnotatedType(tp, ann) => checkSafeAnnot(ann, tree.srcPos) - case _ => - if Feature.safeEnabled then - tree.tpe.foreachPart(checkAnnotatedType(_)) + val span = ann.tree.span + // Skip compiler inserted annotations that have no or zero extent span. + if !span.exists || span.isZeroExtent then return + checkNotRejected(ann.symbol, ann.tree.srcPos) } diff --git a/compiler/src/dotty/tools/dotc/cc/SepCheck.scala b/compiler/src/dotty/tools/dotc/cc/SepCheck.scala index 015263cbbc73..64e327187567 100644 --- a/compiler/src/dotty/tools/dotc/cc/SepCheck.scala +++ b/compiler/src/dotty/tools/dotc/cc/SepCheck.scala @@ -10,6 +10,7 @@ import CaptureSet.{Refs, emptyRefs, HiddenSet} import NameKinds.WildcardParamName import config.Printers.capt import StdNames.nme +import transform.LiftCoverage import util.{SimpleIdentitySet, EqHashMap, SrcPos} import tpd.* import reflect.ClassTag @@ -21,12 +22,12 @@ import Capabilities.* * methods below. Rough summary: * * - Hidden sets of arguments must not be referred to in the same application - * - Hidden sets of (result-) types must not be referred to alter in the same scope. + * - Hidden sets of (result-) types must not be referred to later in the same scope. * - Returned hidden sets can only refer to consume parameters. - * - If returned hidden sets refer to an encloding this, the reference must be + * - If returned hidden sets refer to an enclosing this, the reference must be * from a consume method. * - Consumed entities cannot be used subsequently. - * - Entitites cannot be consumed in a loop. + * - Entities cannot be consumed in a loop. */ object SepCheck: @@ -34,7 +35,7 @@ object SepCheck: enum Captures derives CanEqual: case None case Explicit // one or more explicitly declared captures - case Hidden // exacttly one hidden captures + case Hidden // exactly one hidden capture case NeedsCheck // one hidden capture and one other capture (hidden or declared) def add(that: Captures): Captures = @@ -51,7 +52,7 @@ object SepCheck: case Qualifier(qual: Tree, meth: Symbol) case RHS(rhs: Tree, mvar: Symbol) - /** If this is a Result tole, the associated symbol, otherwise NoSymbol */ + /** If this is a Result role, the associated symbol, otherwise NoSymbol */ def dclSym = this match case Result(sym, _) => sym case _ => NoSymbol @@ -85,7 +86,7 @@ object SepCheck: /** The references in the set. The array should be treated as immutable in client code */ def refs: Array[Capability] - /** The associated source positoons and type roles. The array should be treated as immutable in client code */ + /** The associated source positions and type roles. The array should be treated as immutable in client code */ def locs: Array[(SrcPos, TypeRole)] /** The number of references in the set */ @@ -339,7 +340,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser: /** The set of references that were consumed so far in the current method */ private var consumed: MutConsumedSet = MutConsumedSet() - /** Infos aboput Labeled expressions enclosing the current traversal point. + /** Infos about Labeled expressions enclosing the current traversal point. * For each labeled expression, it's label name, and a list buffer containing * all consumed sets of return expressions referring to that label. */ @@ -599,13 +600,22 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser: case _ => end checkAssign + /** Is `tree` a coverage-lifted local temp or a reference to one? + * These aliases are identified through the attachment set by `LiftCoverage`, + * not by broad synthetic checks. + */ + private def isCoverageLiftedTemp(tree: Tree)(using Context): Boolean = tree match + case tree: ValDef => tree.symbol.exists && LiftCoverage.isCoverageLiftedTemp(tree.symbol) + case tree: Ident => tree.symbol.exists && LiftCoverage.isCoverageLiftedTemp(tree.symbol) + case _ => false + /** 1. Check that the capabilities used at `tree` don't overlap with * capabilities hidden by a previous definition. * 2. Also check that none of the used capabilities was consumed before. */ def checkUse(tree: Tree)(using Context): Unit = val used = tree.markedFree.elems - if !used.isEmpty then + if !used.isEmpty && !isCoverageLiftedTemp(tree) then capt.println(i"check use $tree: $used") val usedPeaks = used.allPeaks if !defsShadow.allPeaks.sharedPeaks(usedPeaks).isEmpty then @@ -682,7 +692,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser: hiddenRef.pathRoot match case ref: TermRef if ref.symbol != role.dclSym => val refSym = ref.symbol - if currentOwner.enclosingMethodOrClass.isProperlyContainedIn(refSym.maybeOwner.enclosingMethodOrClass) then + if currentOwner.enclosingMethodOrClassOrObject.isProperlyContainedIn(refSym.enclosingMethodOrClassOrObject) then report.error(em"""Separation failure: $descr non-local $refSym""", pos) else if refSym.is(TermParam) && !refSym.isConsumeParam @@ -690,7 +700,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser: then badParams += refSym case ref: ThisType => - val encl = currentOwner.enclosingMethodOrClass + val encl = currentOwner.enclosingMethodOrClassOrObject if encl.isProperlyContainedIn(ref.cls) && !encl.is(Synthetic) && !encl.hasAnnotation(defn.ConsumeAnnot) @@ -994,6 +1004,8 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser: /** Check (result-) type of `tree` for separation conditions using `checkType`. * Excluded are parameters and definitions that have an =unsafeAssumeSeparate * application as right hand sides. + * Also excluded are local temps marked by `LiftCoverage`, which are aliases + * introduced solely to preserve coverage evaluation order. * Hidden sets of checked definitions are added to `defsShadow`. */ def checkValOrDefDef(tree: ValOrDefDef)(using Context): Unit = @@ -1001,6 +1013,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser: if !sym.isOneOf(TermParamOrAccessor) && !sym.needsResultRefinement && !isUnsafeAssumeSeparate(tree.rhs) + && !isCoverageLiftedTemp(tree) then checkType(tree.tpt, sym) capt.println(i"sep check def $sym: ${tree.tpt} with ${spanCaptures(tree.tpt).transHiddenSet.directFootprint}") @@ -1008,10 +1021,10 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser: def inSection[T](op: => T)(using Context): T = val savedDefsShadow = defsShadow - val savedPrevionsDefs = previousDefs + val savedPreviousDefs = previousDefs try op finally - previousDefs = savedPrevionsDefs + previousDefs = savedPreviousDefs defsShadow = savedDefsShadow def traverseSection[T](tree: Tree)(using Context) = inSection(traverseChildren(tree)) diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala index d3cbde2a6835..052d5d73c5ad 100644 --- a/compiler/src/dotty/tools/dotc/cc/Setup.scala +++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala @@ -22,6 +22,7 @@ import CheckCaptures.CheckerAPI import NamerOps.methodType import NameOps.isSelectorName import NameKinds.{CanThrowEvidenceName, TryOwnerName, DefaultGetterName} +import Constants.Constant import Capabilities.* /** Operations accessed from CheckCaptures */ @@ -77,6 +78,38 @@ object Setup: case _ => false case _ => None + /** Add `caps.internal.paramAlias annotation("x")` to secondary constructor + * parameters that get forwarded in the constructor's super call to a primary + * constructor parameter named "x". Example: + * + * class A(x: B^, y: Int): + * def this(xx: B^) = this(xx, 0) + * + * Here we add `@caps.internal.paramAlias("x")` s annotation to parameter `xx`. + * The forward could also be indirect, that is the argument gets forwarded + * to a secondary constructor parameter that itself has a @paramAlias annotation. + * In that case the @paramAlias annotation is copied to the argument. + */ + def recordParamAliases(constr: Symbol, superCall: Apply)(using Context): Unit = { + + def addParamAlias(param: Symbol, name: String) = + val ann = Annotation(defn.ParamAliasAnnot, Literal(Constant(name)), param.span) + param.addAnnotation(ann) + capt.println(i"added $ann to $param of $constr") + + val target = superCall.fun.symbol + for case (param, arg: Ident) <- target.paramSymss.flatten.filter(_.isTerm).lazyZip(superCall.args) do + if arg.symbol.is(Param) && arg.symbol.owner == constr then + if target == constr.owner.primaryConstructor then + addParamAlias(arg.symbol, param.name.toString) + else + for + ann <- param.annotations.filter(_.matches(defn.ParamAliasAnnot)) + name <- ann.argumentConstantString(0) + do + addParamAlias(arg.symbol, name) + } + end Setup import Setup.* @@ -162,8 +195,15 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: symd.info // don't transform symbols that will anyway be updated else val symCtx = if sym.isOneOf(TermParamOrAccessor) then ctx else ctx.withOwner(sym) + val oldInfo = + if sym.is(ModuleVal) then + sym.moduleClass.getAnnotation(defn.RetainsAnnot) match + case Some(ann) => + AnnotatedType(sym.info, RetainingAnnotation.fromAnnotation(ann)) + case None => sym.info + else sym.info toResultInReturnType(sym, msg => throw TypeError(msg)): - transformExplicitType(symd.info, sym)(using symCtx) + transformExplicitType(oldInfo, sym)(using symCtx) if Synthetics.needsTransform(symd) then Synthetics.transform(symd, mappedInfo) else if sym.isClass && !sym.is(CaptureChecked) then @@ -297,11 +337,17 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: * 5. Perform normalizeCaptures * * Polytype bounds are only cleaned using step 1, but not otherwise transformed. + * @param tp the type to transform + * @param sym the definition to which this type belongs + * @param typeArgFormal if `tp` is an an inferred type argument, the formal parameter info, + * otherwise NotType */ - private def transformInferredType(tp: Type, typeArgFormal: Type = NoType)(using Context): Type = - def mapInferred(inCaptureRefinement: Boolean): TypeMap = new TypeMap with SetupTypeMap: + private def transformInferredType(tp: Type, sym: Symbol, typeArgFormal: Type = NoType, initialVariance: Int = 1)(using Context): Type = { + + def mapInferred(inCaptureRefinement: Boolean): TypeMap = new TypeMap with SetupTypeMap { override def toString = "map inferred" + variance = initialVariance var refiningNames: Set[Name] = Set() /** Refine a possibly applied class type C where the class has tracked parameters @@ -329,30 +375,33 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: case _ => tp case _ => tp - def innerApply(tp: Type) = - val tp1 = tp match + def innerApply(tp: Type) = { + + /** Normalize `tp` and add a capture set variable to it if necessary. */ + def addVar(tp1: Type) = + decorate( + addCaptureRefinements(normalizeCaptures(normalizeFunctions(tp1, tp))), + CaptureSet.VarInTypeTree(ctx.owner, _, nestedOK = !ctx.mode.is(Mode.CCPreciseOwner), isRefining = inCaptureRefinement), + transformExplicitType(_, sym, initialVariance = variance), + typeArgFormal) + + tp match case AnnotatedType(parent, annot) if annot.symbol.isRetains || annot.symbol == defn.InferredAnnot => // Drop explicit retains and @inferred annotations - apply(parent) - case tp: TypeLambda => - // Don't recurse into parameter bounds, just cleanup any stray retains annotations - tp.derivedLambdaType( - paramInfos = tp.paramInfos.mapConserve(_.dropAllRetains.bounds), - resType = this(tp.resType)) + addVar(apply(parent)) + case AnnotatedType(parent, annot) + if annot.symbol == defn.DeclaredAnnot => + transformExplicitType(parent, sym, initialVariance = variance) case tp @ RefinedType(parent, rname, rinfo) => val saved = refiningNames refiningNames += rname val parent1 = try this(parent) finally refiningNames = saved - tp.derivedRefinedType(parent1, rname, this(rinfo)) + addVar(tp.derivedRefinedType(parent1, rname, this(rinfo))) case _ => - mapFollowingAliases(tp) - addVar( - addCaptureRefinements(normalizeCaptures(normalizeFunctions(tp1, tp))), - ctx.owner, - isRefining = inCaptureRefinement, - typeArgFormal = typeArgFormal) - end mapInferred + addVar(mapFollowingAliases(tp)) + } + } try ccState.withNoVarsMapped: @@ -362,7 +411,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: catch case ex: AssertionError => println(i"error while mapping inferred $tp") throw ex - end transformInferredType + } /** Transform an explicitly given type by performing the following transformation * steps everywhere in the type: @@ -373,7 +422,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: * 5. Schedule deferred well-formed tests for types with retains annotations. * 6. Perform normalizeCaptures */ - private def transformExplicitType(tp: Type, sym: Symbol, tptToCheck: Tree = EmptyTree)(using Context): Type = + private def transformExplicitType(tp: Type, sym: Symbol, tptToCheck: Tree = EmptyTree, initialVariance: Int = 1)(using Context): Type = def fail(msg: Message) = if !tptToCheck.isEmpty then report.error(msg, tptToCheck.srcPos) @@ -394,6 +443,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: object toCapturing extends DeepTypeMap, SetupTypeMap { override def toString = "transformExplicitType" + variance = initialVariance private var enclMethodType: MethodType | Null = null @@ -474,7 +524,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: if ann.symbol == defn.UncheckedCapturesAnnot then makeUnchecked(this(parent)) else if ann.symbol == defn.InferredAnnot then - transformInferredType(parent) + transformInferredType(parent, sym, initialVariance = variance) // typeArgFormal is NoType here since we are inferring inside an argument, not at the toplevel else t.derivedAnnotatedType(this(parent), ann) @@ -491,9 +541,16 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: case t @ AppliedType(tycon, args) if defn.isNonRefinedFunction(t) && args.last.containsGlobalFreshDirectly => // Convert to dependent function so that we have a binder for `fresh` in result type. + // Copy all annotations and capturing sets of the original type to the new one. + def copyAnnots(t: Type, from: Type): Type = from match + case from @ AnnotatedType(from1, ann) => from.derivedAnnotatedType(copyAnnots(t, from1), ann) + case _ => t apply( - depFun(args.init, args.last, - isContextual = defn.isContextFunctionClass(tycon.classSymbol))) + copyAnnots( + depFun(args.init, args.last, + isContextual = defn.isContextFunctionClass(tycon.classSymbol)), + t.dealiasKeepAnnots)) + .showing(i"convert dep $t to $result", capt) case t: (LazyRef | TypeVar) => mapConserveSuper(t) case t => @@ -509,7 +566,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: else t1 } - val tp1 = toCapturing(tp) + val tp1 = ccState.withNoVarsMapped(toCapturing(tp)) if tp1 ne tp then capt.println(i"expanded explicit in ${ctx.owner}: $tp --> $tp1") val tp2 = if sym.isType then stripImpliedCaptureSet(tp1) else tp1 if tp2.containsGlobalFreshDirectly then @@ -519,7 +576,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: |The `fresh` capability may only be used in the result of a function type, |following a function arrow such as `=>` or `->`.""") - globalCapToLocal(tp2, Origin.InDecl(sym)) + if initialVariance < 0 then tp2 + else globalCapToLocal(tp2, Origin.InDecl(sym)) end transformExplicitType /** Update info of `sym` for CheckCaptures phase only */ @@ -547,7 +605,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: if !tree.hasNuType then var transformed = if tree.isInferred || sym.is(ModuleVal) - then transformInferredType(tree.tpe, typeArgFormal) + then transformInferredType(tree.tpe, sym, typeArgFormal) else transformExplicitType(tree.tpe, sym, tptToCheck = tree) if boxed then transformed = transformed.boxDeeply tree.setNuType( @@ -630,7 +688,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: case tree @ SeqLiteral(elems, tpt: TypeTree) => traverse(elems) - tpt.setNuType(transformInferredType(tpt.tpe).boxDeeply) + tpt.setNuType(transformInferredType(tpt.tpe, ctx.owner).boxDeeply) case tree @ Try(body, catches, finalizer) => val tryOwner = firstCanThrowEvidence(body) match @@ -742,7 +800,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: case tree: Bind => val sym = tree.symbol - updateInfo(sym, transformInferredType(sym.info), sym.owner) + updateInfo(sym, transformInferredType(sym.info, sym), sym.owner) case tree @ TypeDef(_, impl: Template) => val cls: ClassSymbol = tree.symbol.asClass @@ -756,9 +814,15 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: checkClassifiedInheritance(cls) val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo + // Is self info inferred, i.e. only the name is given but not the type? + def selfInfoIsInferred = + impl.body.exists: + case TypeDef(tpnme.SELF, tpt: TypeTree) => tpt.isInferred + case _ => false + // Compute new self type val selfInfo1 = - if (selfInfo ne NoType) && !cls.is(ModuleClass) then + if (selfInfo ne NoType) && !cls.is(ModuleClass) && !selfInfoIsInferred then // if selfInfo is explicitly given then use that one, except if // self info applies to a module class, these still need to be inferred selfInfo @@ -903,7 +967,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: * @param tp the type to add a capture set to * @param added A function producing the added capture set from a set of initial elements. */ - def decorate(tp: Type, added: CaptureSet.Refs => CaptureSet, typeArgFormal: Type = NoType)(using Context): Type = { + def decorate(tp: Type, added: CaptureSet.Refs => CaptureSet, handleAlias: Type => Type, typeArgFormal: Type = NoType)(using Context): Type = { if tp.typeSymbol == defn.FromJavaObjectSymbol then // For capture checking, we assume Object from Java is the same as Any tp @@ -925,15 +989,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: else fallback val dealiased = tp.dealiasKeepAnnotsAndOpaques if dealiased ne tp then - val transformed = transformInferredType(dealiased, typeArgFormal) + val transformed = handleAlias(dealiased) maybeAdd(transformed, if transformed ne dealiased then transformed else tp) else maybeAdd(tp, tp) } - /** Add a capture set variable to `tp` if necessary. */ - private def addVar(tp: Type, owner: Symbol, isRefining: Boolean, typeArgFormal: Type = NoType)(using Context): Type = - decorate(tp, CaptureSet.VarInTypeTree(owner, _, nestedOK = !ctx.mode.is(Mode.CCPreciseOwner), isRefining), typeArgFormal) - /** A map that adds capture sets at all contra- and invariant positions * in a type where a capture set would be needed. This is used to make types * that were not capture checked compatible with types that are capture checked. @@ -962,7 +1022,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI: case _ => mapOver(t) if variance > 0 then t1 - else decorate(t1, Function.const(CaptureSet.Fluid)) + else decorate(t1, Function.const(CaptureSet.Fluid), this) /** Replace all universal capture sets in this type by */ private def makeUnchecked(using Context): TypeMap = new TypeMap with FollowAliasesMap: diff --git a/compiler/src/dotty/tools/dotc/cc/ccConfig.scala b/compiler/src/dotty/tools/dotc/cc/ccConfig.scala index d98c12a06247..090fa38043da 100644 --- a/compiler/src/dotty/tools/dotc/cc/ccConfig.scala +++ b/compiler/src/dotty/tools/dotc/cc/ccConfig.scala @@ -54,7 +54,7 @@ object ccConfig: /** Not used currently. Handy for trying out new features */ def newScheme(using ctx: Context): Boolean = - Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.8`) + Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.9`) /** Allow @use annotations */ def allowUse(using Context): Boolean = diff --git a/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala index a5eedda44377..f8514a46b117 100644 --- a/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala +++ b/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala @@ -46,7 +46,7 @@ trait PackageEntry { sealed trait BinaryFileEntry extends ClassRepresentation { def file: AbstractFile final def fileName: String = file.name - final def name: String = FileUtils.stripClassExtension(file.name) // class name + final def name: String = FileUtils.stripExtension(file.name) // class name final def source: Option[AbstractFile] = None } diff --git a/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala b/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala index d8a70186d3b0..c479744022bf 100644 --- a/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala +++ b/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala @@ -7,13 +7,16 @@ import dotty.tools.io.{AbstractFile, VirtualDirectory} import FileUtils.* import dotty.tools.io.ClassPath import dotty.tools.dotc.core.Contexts.* +import dotty.tools.dotc.interactive.LogicalSourcePath +import dotty.tools.dotc.interactive.LogicalPackagesProvider +import dotty.tools.dotc.interactive.LogicalPackage import java.nio.file.Files /** * Provides factory methods for classpath. When creating classpath instances for a given path, * it uses proper type of classpath depending on a types of particular files containing sources or classes. */ -class ClassPathFactory { +class ClassPathFactory(precomputedSourcePackages: Option[LogicalPackage] = None) { /** * Create a new classpath based on the abstract file. */ @@ -23,11 +26,16 @@ class ClassPathFactory { * Creators for sub classpaths which preserve this context. */ def sourcesInPath(path: String)(using Context): List[ClassPath] = - for - file <- expandPath(path, expandStar = false) - dir <- Option(AbstractFile.getDirectory(file)) - yield createSourcePath(dir) - + precomputedSourcePackages match { + // We also accept files in case of YlogicalPackageLoading + case Some(rootPackage) if ctx.settings.YlogicalPackageLoading.value => + List(new LogicalSourcePath(path, rootPackage)) + case _ => + for + file <- expandPath(path, expandStar = false) + dir <- Option(AbstractFile.getDirectory(file)) + yield createSourcePath(dir) + } def expandPath(path: String, expandStar: Boolean = true): List[String] = dotty.tools.io.ClassPath.expandPath(path, expandStar) @@ -53,10 +61,10 @@ class ClassPathFactory { // Internal protected def classesInPathImpl(path: String, expand: Boolean)(using Context): List[ClassPath] = - val files = for { + val files: List[AbstractFile] = for { file <- expandPath(path, expand) dir <- { - def asImage = if (file.endsWith(".jimage")) Some(AbstractFile.getFile(file)) else None + def asImage = if (file.endsWith(".jimage")) Some(AbstractFile.getFile(file).nn) else None Option(AbstractFile.getDirectory(file)).orElse(asImage) } } @@ -70,7 +78,7 @@ class ClassPathFactory { path = java.nio.file.Paths.get(a.toURI()) if Files.exists(path) yield - newClassPath(AbstractFile.getFile(path)) + newClassPath(AbstractFile.getFile(path).nn) // .nn ok because of Files.exists(path) else Seq.empty diff --git a/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala index 755ab8548b21..3c0f2fb79f55 100644 --- a/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala +++ b/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala @@ -14,7 +14,6 @@ import PlainFile.toPlainFile import scala.jdk.CollectionConverters.* import scala.collection.immutable.ArraySeq -import scala.util.control.NonFatal /** * A trait allowing to look for classpath entries in directories. It provides common logic for @@ -134,7 +133,7 @@ object JrtClassPath { val ctSym = Paths.get(Properties.javaHome).resolve("lib").resolve("ct.sym") if (Files.notExists(ctSym)) None else Some(new CtSymClassPath(ctSym, v.toInt)) - catch case NonFatal(_) => None + catch case _: Exception => None case _ => try Some(new JrtClassPath(FileSystems.getFileSystem(URI.create("jrt:/")))) catch case _: ProviderNotFoundException | _: FileSystemNotFoundException => None @@ -282,7 +281,7 @@ case class DirectorySourcePath(dir: JFile) extends JFileDirectoryLookup[SourceFi def asSourcePathString: String = asClassPathString protected def createFileEntry(file: AbstractFile): SourceFileEntry = SourceFileEntry(file) - protected def isMatchingFile(f: JFile): Boolean = endsScalaOrJava(f.getName) + protected def isMatchingFile(f: JFile): Boolean = endsSourceExtension(f.getName) private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = files(inPackage) } diff --git a/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala b/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala index e51ba29483cb..d6bc4be22e2c 100644 --- a/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala +++ b/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala @@ -29,7 +29,7 @@ object FileUtils { def isScalaBinary: Boolean = file.isClass || file.isTasty - def isScalaOrJavaSource: Boolean = !file.isDirectory && file.ext.isScalaOrJava + def isSource: Boolean = !file.isDirectory && file.ext.isSourceExtension // TODO do we need to check also other files using ZipMagicNumber like in scala.tools.nsc.io.Jar.isJarOrZip? def isJarOrZip: Boolean = file.ext.isJarOrZip @@ -38,7 +38,9 @@ object FileUtils { * Safe method returning a sequence containing one URL representing this file, when underlying file exists, * and returning given default value in other case */ - def toURLs(default: => Seq[URL] = Seq.empty): Seq[URL] = if (file.file == null) default else Seq(file.toURL) + def toURLs(default: => Seq[URL] = Seq.empty): Seq[URL] = + val url = file.toURL + if (url == null) default else Seq(url) /** * Returns if there is an existing sibling `.tasty` file. @@ -76,37 +78,25 @@ object FileUtils { private val SUFFIX_TASTY = ".tasty" private val SUFFIX_BETASTY = ".betasty" private val SUFFIX_JAVA = ".java" - private val SUFFIX_SIG = ".sig" + + private val sourceSuffixes = Set(SUFFIX_SCALA, SUFFIX_JAVA) def stripSourceExtension(fileName: String): String = - if (endsScala(fileName)) stripClassExtension(fileName) - else if (endsJava(fileName)) stripJavaExtension(fileName) + if endsSourceExtension(fileName) then stripExtension(fileName) else throw new FatalError("Unexpected source file ending: " + fileName) + def endsSourceExtension(fileName: String): Boolean = + sourceSuffixes.exists(ends(fileName, _)) + def dirPath(forPackage: String): String = forPackage.replace('.', JFile.separatorChar) def dirPathInJar(forPackage: String): String = forPackage.replace('.', '/') inline private def ends (filename:String, suffix:String) = filename.endsWith(suffix) && filename.length > suffix.length - def endsClass(fileName: String): Boolean = - ends (fileName, SUFFIX_CLASS) || fileName.endsWith(SUFFIX_SIG) - - def endsScalaOrJava(fileName: String): Boolean = - endsScala(fileName) || endsJava(fileName) - - def endsJava(fileName: String): Boolean = - ends (fileName, SUFFIX_JAVA) - - def endsScala(fileName: String): Boolean = - ends (fileName, SUFFIX_SCALA) - - def stripClassExtension(fileName: String): String = + def stripExtension(fileName: String): String = fileName.substring(0, fileName.lastIndexOf('.')) - def stripJavaExtension(fileName: String): String = - fileName.substring(0, fileName.length - 5) // equivalent of fileName.length - SUFFIX_JAVA.length - // probably it should match a pattern like [a-z_]{1}[a-z0-9_]* but it cannot be changed // because then some tests in partest don't pass def mayBeValidPackage(dirName: String): Boolean = diff --git a/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala index 966252e4ab11..0ce52a94bf49 100644 --- a/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala +++ b/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala @@ -1,7 +1,5 @@ package dotty.tools.dotc.classpath -import scala.language.unsafeNulls - import dotty.tools.io.{ClassPath, ClassRepresentation} import dotty.tools.io.{AbstractFile, VirtualDirectory} import FileUtils.* @@ -12,13 +10,14 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi // From AbstractFileClassLoader private final def lookupPath(base: AbstractFile)(pathParts: Seq[String], directory: Boolean): AbstractFile | Null = { - var file: AbstractFile | Null = base + var file: AbstractFile = base val dirParts = pathParts.init.iterator while (dirParts.hasNext) { val dirPart = dirParts.next() - file = file.lookupName(dirPart, directory = true) - if (file == null) + val subFile = file.lookupName(dirPart, directory = true) + if (subFile == null) return null + file = subFile } file.lookupName(pathParts.last, directory = directory) } @@ -43,8 +42,14 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi val parentDir = lookupPath(dir)(pathSeq.init.toSeq, directory = true) if parentDir == null then None else - Option(lookupPath(parentDir)(pathSeq.last + ".class" :: Nil, directory = false), - Option.when(findModule)(lookupPath(parentDir)("module-info.class" :: Nil, directory = false))) + val classFile = lookupPath(parentDir)(pathSeq.last + ".class" :: Nil, directory = false) + if classFile == null then + None + else + val optModuleFile = + if findModule then Option(lookupPath(parentDir)("module-info.class" :: Nil, directory = false)) + else None + Some((classFile, optModuleFile)) } private[dotty] def classes(inPackage: PackageName): Seq[BinaryFileEntry] = files(inPackage) diff --git a/compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala b/compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala index 15fd034057bb..aa6e5804e76a 100644 --- a/compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala +++ b/compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala @@ -4,8 +4,6 @@ package dotty.tools.dotc package classpath -import scala.language.unsafeNulls - import java.io.File import java.net.URL import java.nio.file.Files @@ -26,13 +24,16 @@ sealed trait ZipAndJarFileLookupFactory { def create(zipFile: AbstractFile)(using Context): ClassPath = val release = Option(ctx.settings.javaOutputVersion.value).filter(_.nonEmpty) - if (ctx.settings.YdisableFlatCpCaching.value || zipFile.file == null) createForZipFile(zipFile, release) - else createUsingCache(zipFile, release) + val jFile = zipFile.file + if ctx.settings.YdisableFlatCpCaching.value || jFile == null then + createForZipFile(zipFile, jFile, release) + else + createUsingCache(zipFile, jFile, release) - protected def createForZipFile(zipFile: AbstractFile, release: Option[String]): ClassPath + protected def createForZipFile(zipFile: AbstractFile, jFile: File | Null, release: Option[String]): ClassPath - private def createUsingCache(zipFile: AbstractFile, release: Option[String]): ClassPath = - cache.getOrCreate(zipFile.file.toPath, () => createForZipFile(zipFile, release)) + private def createUsingCache(zipFile: AbstractFile, jFile: File, release: Option[String]): ClassPath = + cache.getOrCreate(jFile.toPath, () => createForZipFile(zipFile, jFile, release)) } /** @@ -140,9 +141,9 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory { case class PackageInfo(packageName: String, subpackages: List[AbstractFile]) } - override protected def createForZipFile(zipFile: AbstractFile, release: Option[String]): ClassPath = - if (zipFile.file == null) createWithoutUnderlyingFile(zipFile) - else ZipArchiveClassPath(zipFile.file, release) + override protected def createForZipFile(zipFile: AbstractFile, jFile: File | Null, release: Option[String]): ClassPath = + if (jFile == null) createWithoutUnderlyingFile(zipFile) + else ZipArchiveClassPath(jFile, release) private def createWithoutUnderlyingFile(zipFile: AbstractFile) = zipFile match { case manifestRes: ManifestResources => @@ -169,10 +170,12 @@ object ZipAndJarSourcePathFactory extends ZipAndJarFileLookupFactory { override private[dotty] def sources(inPackage: PackageName): Seq[SourceFileEntry] = files(inPackage) override protected def createFileEntry(file: FileZipArchive#Entry): SourceFileEntry = SourceFileEntry(file) - override protected def isRequiredFileType(file: AbstractFile): Boolean = file.isScalaOrJavaSource + override protected def isRequiredFileType(file: AbstractFile): Boolean = file.isSource } - override protected def createForZipFile(zipFile: AbstractFile, release: Option[String]): ClassPath = ZipArchiveSourcePath(zipFile.file) + override protected def createForZipFile(zipFile: AbstractFile, jFile: File | Null, release: Option[String]): ClassPath = + assert(jFile != null, "Zip file in ZipAndJarSourcePathFactory cannot be null") + ZipArchiveSourcePath(jFile) } final class FileBasedCache[T] { diff --git a/compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala b/compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala index e8f8168cb4cc..1f00baf7fd46 100644 --- a/compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala +++ b/compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala @@ -20,8 +20,6 @@ trait ZipArchiveFileLookup[FileEntryType <: ClassRepresentation] extends Efficie val zipFile: File def release: Option[String] - assert(zipFile ne null, "Zip file in ZipArchiveFileLookup cannot be null") - override def asURLs: Seq[URL] = Seq(zipFile.toURI.toURL) override def asClassPathStrings: Seq[String] = Seq(zipFile.getPath) diff --git a/compiler/src/dotty/tools/dotc/config/CliCommand.scala b/compiler/src/dotty/tools/dotc/config/CliCommand.scala index 4c750c613940..155af82d40c5 100644 --- a/compiler/src/dotty/tools/dotc/config/CliCommand.scala +++ b/compiler/src/dotty/tools/dotc/config/CliCommand.scala @@ -60,7 +60,7 @@ trait CliCommand: case _: Int | _: String => s.default.toString case _ => "" val deprecationMessage = s.deprecation.map(d => s"Option deprecated.\n${d.msg}").getOrElse("") - val info = List(deprecationMessage, shortHelp(s), if defaultValue.nonEmpty then s"Default $defaultValue" else "", if s.legalChoices.nonEmpty then s"Choices : ${s.legalChoices}" else "") + val info = List(deprecationMessage, shortHelp(s), if defaultValue.nonEmpty then s"Default $defaultValue" else "", if s.legalChoices.nonEmpty then s"Choices: ${s.legalChoices}" else "") (s.name, info.filter(_.nonEmpty).mkString("\n")) end help diff --git a/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala b/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala index e90bbcc36878..43f3ed63f969 100644 --- a/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala +++ b/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala @@ -9,8 +9,7 @@ abstract class CompilerCommand extends CliCommand: final def helpMsg(using settings: ConcreteSettings)(using SettingsState, Context): String = settings.allSettings.find(isHelping) match - case Some(s @ settings.language) => availableOptionsMsg(_ == s, showArgFileMsg = false) - case Some(s) => s.description + case Some(s) => availableOptionsMsg(_ == s, showArgFileMsg = false) case _ => if (settings.help.value) usageMessage else if (settings.Vhelp.value) vusageMessage diff --git a/compiler/src/dotty/tools/dotc/config/Config.scala b/compiler/src/dotty/tools/dotc/config/Config.scala index e8a234ff821f..3d603f251f50 100644 --- a/compiler/src/dotty/tools/dotc/config/Config.scala +++ b/compiler/src/dotty/tools/dotc/config/Config.scala @@ -66,13 +66,6 @@ object Config { */ inline val checkNoSkolemsInInfo = false - /** Check that Name#toString is not called directly from backend by analyzing - * the stack trace of each toString call on names. This is very expensive, - * so not suitable for continuous testing. But it can be used to find a problem - * when running a specific test. - */ - inline val checkBackendNames = false - /** Check that re-used type comparers are in their initialization state */ inline val checkTypeComparerReset = false diff --git a/compiler/src/dotty/tools/dotc/config/Feature.scala b/compiler/src/dotty/tools/dotc/config/Feature.scala index 69042935824b..b492043f520c 100644 --- a/compiler/src/dotty/tools/dotc/config/Feature.scala +++ b/compiler/src/dotty/tools/dotc/config/Feature.scala @@ -28,6 +28,7 @@ object Feature: val dependent = experimental("dependent") val erasedDefinitions = experimental("erasedDefinitions") + val specializedTraits = experimental("specializedTraits") val strictEqualityPatternMatching = experimental("strictEqualityPatternMatching") val symbolLiterals = deprecated("symbolLiterals") val saferExceptions = experimental("saferExceptions") @@ -37,7 +38,6 @@ object Feature: val into = experimental("into") val modularity = experimental("modularity") val quotedPatternsWithPolymorphicFunctions = experimental("quotedPatternsWithPolymorphicFunctions") - val packageObjectValues = experimental("packageObjectValues") val multiSpreads = experimental("multiSpreads") val subCases = experimental("subCases") val relaxedLambdaSyntax = experimental("relaxedLambdaSyntax") @@ -68,15 +68,15 @@ object Feature: (scala2macros, "Allow Scala 2 macros"), (dependent, "Allow dependent method types"), (erasedDefinitions, "Allow erased definitions"), + (specializedTraits, "Allow specialized traits"), (strictEqualityPatternMatching, "relaxed CanEqual checks for ADT pattern matching"), (symbolLiterals, "Allow symbol literals"), (saferExceptions, "Enable safer exceptions"), (pureFunctions, "Enable pure functions for capture checking"), (captureChecking, "Enable experimental capture checking"), - (separationChecking, "Enable experimental separation checking (requires captureChecking)"), + (separationChecking, "Enable experimental separation checking (implies captureChecking)"), (into, "Allow into modifier on parameter types"), (modularity, "Enable experimental modularity features"), - (packageObjectValues, "Enable experimental package objects as values"), (multiSpreads, "Enable experimental varargs with multi-spreads"), (subCases, "Enable experimental match expressions with sub-cases"), (relaxedLambdaSyntax, "Enable experimental relaxed lambda syntax"), @@ -212,7 +212,8 @@ object Feature: report.error(experimentalUseSite(which) + note, srcPos) private def ccException(sym: Symbol)(using Context): Boolean = - ccEnabled && defn.ccExperimental.contains(sym) + ccEnabledSomewhere && (defn.ccExperimental.contains(sym) + || sym.exists && defn.ccExperimental.contains(sym.owner)) def checkExperimentalDef(sym: Symbol, srcPos: SrcPos)(using Context) = val experimentalSym = diff --git a/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala b/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala index d2d0a2a71d3e..d4ad708bd8f6 100644 --- a/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala +++ b/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala @@ -7,15 +7,16 @@ import classpath.AggregateClassPath import core.* import Symbols.*, Types.*, Contexts.*, StdNames.* import Flags.* +import interactive.LogicalPackage import transform.ExplicitOuter -class JavaPlatform extends Platform { +class JavaPlatform(precomputedSourcePackages: Option[LogicalPackage] = None) extends Platform { private var currentClassPath: Option[ClassPath] = None def classPath(using Context): ClassPath = { if (currentClassPath.isEmpty) - currentClassPath = Some(new PathResolver().result) + currentClassPath = Some(new PathResolver(precomputedSourcePackages).result) val cp = currentClassPath.get cp } diff --git a/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala b/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala index 9b1b4b5f07cc..f6019a2172d6 100644 --- a/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala +++ b/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala @@ -34,6 +34,7 @@ enum MigrationVersion(val warnFrom: SourceVersion, val errorFrom: SourceVersion) case GivenSyntax extends MigrationVersion(future, future) case ImplicitParamsWithoutUsing extends MigrationVersion(`3.7`, future) case Scala2Implicits extends MigrationVersion(future, future) + case IdentifierDollars extends MigrationVersion(`3.9`, never) require(warnFrom.ordinal <= errorFrom.ordinal) diff --git a/compiler/src/dotty/tools/dotc/config/OutputDirs.scala b/compiler/src/dotty/tools/dotc/config/OutputDirs.scala index 39f25d2b0fa2..adee70faa636 100644 --- a/compiler/src/dotty/tools/dotc/config/OutputDirs.scala +++ b/compiler/src/dotty/tools/dotc/config/OutputDirs.scala @@ -28,7 +28,7 @@ class OutputDirs { checkDir(AbstractFile.getDirectory(outDir), outDir)) /** Check that dir is exists and is a directory. */ - private def checkDir(dir: AbstractFile, name: String, allowJar: Boolean = false): AbstractFile = ( + private def checkDir(dir: AbstractFile | Null, name: String, allowJar: Boolean = false): AbstractFile = ( if ((dir ne null) && dir.isDirectory) dir // was: else if (allowJar && dir == null && Path.isJarOrZip(name, false)) diff --git a/compiler/src/dotty/tools/dotc/config/PathResolver.scala b/compiler/src/dotty/tools/dotc/config/PathResolver.scala index e4f2c58b32e5..7acc950de59a 100644 --- a/compiler/src/dotty/tools/dotc/config/PathResolver.scala +++ b/compiler/src/dotty/tools/dotc/config/PathResolver.scala @@ -10,6 +10,7 @@ import PartialFunction.condOpt import core.Contexts.* import Settings.* import dotty.tools.io.File +import dotty.tools.dotc.interactive.LogicalPackage object PathResolver { @@ -169,10 +170,10 @@ object PathResolver { import PathResolver.{Defaults, ppcp} -class PathResolver(using c: Context) { +class PathResolver(precomputedSourcePackages: Option[LogicalPackage] = None)(using c: Context) { import c.base.settings - private val classPathFactory = new ClassPathFactory + private val classPathFactory = new ClassPathFactory(precomputedSourcePackages) private def cmdLineOrElse(name: String, alt: String) = commandLineFor(name) match { diff --git a/compiler/src/dotty/tools/dotc/config/Properties.scala b/compiler/src/dotty/tools/dotc/config/Properties.scala index b6da0a09af75..2fa739bfb9d3 100644 --- a/compiler/src/dotty/tools/dotc/config/Properties.scala +++ b/compiler/src/dotty/tools/dotc/config/Properties.scala @@ -49,8 +49,9 @@ trait PropertiesTrait { def propOrEmpty(name: String): String = propOrElse(name, "") def propOrNull(name: String): String|Null = propOrNone(name).orNull def propOrFalse(name: String): Boolean = propOrNone(name) exists (x => List("yes", "on", "true") contains x.toLowerCase) - def setProp(name: String, value: String): String = System.setProperty(name, value) - def clearProp(name: String): String = System.clearProperty(name) + + def setProp(name: String, value: String): String | Null = System.setProperty(name, value) + def clearProp(name: String): String | Null = System.clearProperty(name) def envOrElse(name: String, alt: => String): String = Option(System.getenv(name)).getOrElse(alt) def envOrNone(name: String): Option[String] = Option(System.getenv(name)) diff --git a/compiler/src/dotty/tools/dotc/config/SJSPlatform.scala b/compiler/src/dotty/tools/dotc/config/SJSPlatform.scala index 28a5a80e6006..18457f18760e 100644 --- a/compiler/src/dotty/tools/dotc/config/SJSPlatform.scala +++ b/compiler/src/dotty/tools/dotc/config/SJSPlatform.scala @@ -5,6 +5,7 @@ import Contexts.* import Symbols.* import dotty.tools.backend.sjs.JSDefinitions +import dotty.tools.dotc.interactive.LogicalPackage object SJSPlatform { /** The `SJSPlatform` for the current context. */ @@ -12,7 +13,7 @@ object SJSPlatform { ctx.platform.asInstanceOf[SJSPlatform] } -class SJSPlatform extends JavaPlatform { +class SJSPlatform(precomputedSourcePackages: Option[LogicalPackage] = None) extends JavaPlatform(precomputedSourcePackages) { /** Scala.js-specific definitions. */ val jsDefinitions: JSDefinitions = new JSDefinitions() diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala index 63bccaa8f50e..d155459054dc 100644 --- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala +++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala @@ -62,8 +62,6 @@ trait AllScalaSettings extends CommonScalaSettings, PluginSettings, VerboseSetti /* Decompiler settings */ val printTasty: Setting[Boolean] = BooleanSetting(RootSetting, "print-tasty", "Prints the raw tasty.", aliases = List("--print-tasty")) - @deprecated(message = "Scheduled for removal in 3.9.0, no-op since 3.8.3", since = "3.8.3") - val printLines: Setting[Boolean] = BooleanSetting(RootSetting, "print-lines", "Show source code line numbers.", aliases = List("--print-lines"), deprecation = Deprecation.removed(Some("3.9.0"))) /* Scala.js-related settings */ val scalajsGenStaticForwardersForNonTopLevelObjects: Setting[Boolean] = BooleanSetting(RootSetting, "scalajs-genStaticForwardersForNonTopLevelObjects", "Generate static forwarders even for non-top-level objects (Scala.js only).") @@ -153,10 +151,6 @@ private sealed trait VerboseSettings: val Vprofile: Setting[Boolean] = BooleanSetting(VerboseSetting, "Vprofile", "Show metrics about sources and internal representations to estimate compile-time complexity.") val VprofileSortedBy = ChoiceSetting(VerboseSetting, "Vprofile-sorted-by", "key", "Show metrics about sources and internal representations sorted by given column name", List("name", "path", "lines", "tokens", "tasty", "complexity"), "") val VprofileDetails = IntSetting(VerboseSetting, "Vprofile-details", "Show metrics about sources and internal representations of the most complex methods", 0) - @deprecated(message = "No longer supported, scheduled for removal", since = "3.9.0") - val VreplMaxPrintElements: Setting[Int] = IntSetting(VerboseSetting, "Vrepl-max-print-elements", "Number of elements to be printed before output is truncated.", 1000, deprecation = Some(Deprecation("Configuring output truncation is no longer supported"))) - @deprecated(message = "No longer supported, scheduled for removal", since = "3.9.0") - val VreplMaxPrintCharacters: Setting[Int] = IntSetting(VerboseSetting, "Vrepl-max-print-characters", "Number of characters to be printed before output is truncated.", 50000, deprecation = Some(Deprecation("Configuring output truncation is no longer supported"))) /** -W "Warnings" settings */ @@ -359,7 +353,7 @@ private sealed trait OptimizerSettings: def optAllowSkipCoreModuleInit(using Context): Boolean = optEnabled("allow-skip-core-module-init") def optAssumeModulesNonNull(using Context): Boolean = optEnabled("assume-modules-non-null") def optAllowSkipClassLoading(using Context): Boolean = optEnabled("allow-skip-class-loading") - + val inlineHelp = """Inlining requires a list of patterns defining where code can be inlined from: `-opt-inline:p1,p2`. (Use `-opt-inline:help` for more details) | @@ -383,6 +377,7 @@ private sealed trait OptimizerSettings: |such as `*`, `<`, `>`, and `$`: `'-opt-inline:p.*,!p.C$D' '-opt-inline:'`. |Quoting may not be needed in a build file.""".stripMargin val optInline: Setting[List[String]] = MultiStringSetting(RootSetting, "opt-inline", "filter", inlineHelp) + def optInlineEnabled(using Context): Boolean = optInline.value.nonEmpty val YoptInlineHeuristics = ChoiceSetting( ForkSetting, @@ -491,9 +486,6 @@ private sealed trait XSettings: val XmacroSettings: Setting[List[String]] = MultiStringSetting(AdvancedSetting, "Xmacro-settings", "setting1,setting2,..settingN", "List of settings which exposed to the macros") - @deprecated(message = "Superseded by -Wshadow, Scheduled for removal", since = "3.5.0") - val Xlint: Setting[?] = BooleanSetting(AdvancedSetting, "Xlint", "Enable or disable specific warnings", deprecation = Some(Deprecation("Use -Wshadow to enable shadowing lints. Scheduled for removal.")), ignoreInvalidArgs = true) - end XSettings /** -Y "Forking" as in forked tongue or "Private" settings */ @@ -528,9 +520,10 @@ private sealed trait YSettings: val Yskip: Setting[List[String]] = PhasesSetting(ForkSetting, "Yskip", "Skip") val YbackendParallelism: Setting[Int] = IntChoiceSetting(ForkSetting, "Ybackend-parallelism", "maximum worker threads for backend", 1 to 16, 1) val YbackendWorkerQueue: Setting[Int] = IntChoiceSetting(ForkSetting, "Ybackend-worker-queue", "backend threads worker queue size", 0 to 1000, 0) - val YstopAfter: Setting[List[String]] = PhasesSetting(ForkSetting, "Ystop-after", "Stop after", aliases = List("-stop")) // backward compat + val YstopAfter: Setting[List[String]] = PhasesSetting(ForkSetting, "Ystop-after", "Stop after the phase group containing the named phase. Mini-phases fused into a MegaPhase share a group, so the rest of that group still runs.", aliases = List("-stop")) // backward compat val YstopBefore: Setting[List[String]] = PhasesSetting(ForkSetting, "Ystop-before", "Stop before") // stop before erasure as long as we have not debugged it fully val YshowSuppressedErrors: Setting[Boolean] = BooleanSetting(ForkSetting, "Yshow-suppressed-errors", "Also show follow-on errors and warnings that are normally suppressed.") + val YlogicalPackageLoading: Setting[Boolean] = BooleanSetting(ForkSetting, "Ylogical-package-loading", "Enable logical package loading. This will load the logical package structure by preparsing the source files to discover the package structure. To be used together with -sourcepath option.") val YdetailedStats: Setting[Boolean] = BooleanSetting(ForkSetting, "Ydetailed-stats", "Show detailed internal compiler stats (needs Stats.enabled to be set to true).") val YprintPos: Setting[Boolean] = BooleanSetting(ForkSetting, "Yprint-pos", "Show tree positions.") val YprintPosSyms: Setting[Boolean] = BooleanSetting(ForkSetting, "Yprint-pos-syms", "Show symbol definitions positions.") @@ -568,8 +561,6 @@ private sealed trait YSettings: val YmagicOffsetHeader: Setting[String] = StringSetting(ForkSetting, "Ymagic-offset-header", "header", "Specify the magic header comment that marks the start of the actual code in generated wrapper scripts. Example: -Ymagic-offset-header:SOURCE_CODE_START. Then, in the source, the magic comment `///SOURCE_CODE_START:` marks the start of user code. The comment should be suffixed by `:` to indicate the original file.", "") // Experimental language features - @deprecated(message = "This flag has no effect and will be removed in a future version.", since = "3.7.0") - val YnoKindPolymorphism: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-kind-polymorphism", "Disable kind polymorphism. (This flag has no effect)", deprecation = Deprecation.removed()) val YexplicitNulls: Setting[Boolean] = BooleanSetting(ForkSetting, "Yexplicit-nulls", "Make reference types non-nullable. Nullable types can be expressed with unions: e.g. String|Null.") val YnoFlexibleTypes: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-flexible-types", "Disable turning nullable Java return types and parameter types into flexible types, which behave like abstract types with a nullable lower bound and non-nullable upper bound.") val YflexifyTasty: Setting[Boolean] = BooleanSetting(ForkSetting, "Yflexify-tasty", "Apply flexification to Scala code compiled without -Yexplicit-nulls, when reading from tasty.") @@ -591,43 +582,8 @@ private sealed trait YSettings: val YinstrumentDefs: Setting[Boolean] = BooleanSetting(ForkSetting, "Yinstrument-defs", "Add instrumentation code that counts method calls; needs -Yinstrument to be set, too.") val YimplicitToGiven: Setting[Boolean] = BooleanSetting(ForkSetting, "Yimplicit-to-given", "Allows to rewrite the implicit keywords to their scala-3 given counterparts. Does not adjust imports. Use in conjunction with --rewrite.") - // Deprecated: lifted from -Y to -X - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val YtermConflict: Setting[String] = ChoiceSetting(ForkSetting, "Yresolve-term-conflict", "strategy", "Resolve term conflicts", List("package", "object", "error"), "error", deprecation = Deprecation.renamed("-Xresolve-term-conflict")) - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val YnoGenericSig: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-generic-signatures", "Suppress generation of generic signatures for Java.", deprecation = Deprecation.renamed("-Xno-generic-signatures")) - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val Ydumpclasses: Setting[String] = StringSetting(ForkSetting, "Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", default = "", deprecation = Deprecation.renamed("-Xdump-classes")) - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val YjarCompressionLevel: Setting[Int] = IntChoiceSetting(ForkSetting, "Yjar-compression-level", "compression level to use when writing jar files", Deflater.DEFAULT_COMPRESSION to Deflater.BEST_COMPRESSION, Deflater.DEFAULT_COMPRESSION, deprecation = Deprecation.renamed("-Xjar-compression-level")) + // Should be removed but causes a lot of breakage in practice, e.g., with old versions of the sbt-typelevel plugin @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") val YkindProjector: Setting[String] = ChoiceSetting(ForkSetting, "Ykind-projector", "[underscores, enable, disable]", "Allow `*` as type lambda placeholder to be compatible with kind projector. When invoked as -Ykind-projector:underscores will repurpose `_` to be a type parameter placeholder, this will disable usage of underscore as a wildcard.", List("disable", "", "underscores"), "disable", legacyArgs = true, deprecation = Deprecation.renamed("-Xkind-projector")) - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val YdropComments: Setting[Boolean] = BooleanSetting(ForkSetting, "Ydrop-docs", "Drop documentation when scanning source files.", aliases = List("-Ydrop-comments"), deprecation = Deprecation.renamed("-Xdrop-docs")) - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val YcookComments: Setting[Boolean] = BooleanSetting(ForkSetting, "Ycook-docs", "Cook the documentation (type check `@usecase`, etc.)", aliases = List("-Ycook-comments"), deprecation = Deprecation.renamed("-Xcook-docs")) - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val YreadComments: Setting[Boolean] = BooleanSetting(ForkSetting, "Yread-docs", "Read documentation from tasty.", deprecation = Deprecation.renamed("-Xread-docs")) - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val YnoDecodeStacktraces: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.", deprecation = Deprecation.renamed("-Xno-enrich-error-messages")) - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val YnoEnrichErrorMessages: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-enrich-error-messages", "Show raw error messages, instead of enriching them with contextual information.", deprecation = Deprecation.renamed("-Xno-enrich-error-messages")) - @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0") - val YdebugMacros: Setting[Boolean] = BooleanSetting(ForkSetting, "Ydebug-macros", "Show debug info when quote pattern match fails", deprecation = Deprecation.renamed("-Xdebug-macros")) - - // @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.7.0") - // val YjavaTasty: Setting[Boolean] = BooleanSetting(ForkSetting, "Yjava-tasty", "Pickler phase should compute TASTy for .java defined symbols for use by build tools", aliases = List("-Ypickle-java"), preferPrevious = true, deprecation = Deprecation.lifted("-Xjava-tasty")) - // @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.7.0") - // val YearlyTastyOutput: Setting[AbstractFile] = OutputSetting(ForkSetting, "Yearly-tasty-output", "directory|jar", "Destination to write generated .tasty files to for use in pipelined compilation.", NoAbstractFile, aliases = List("-Ypickle-write"), preferPrevious = true, deprecation = Deprecation.lifted("-Xearly-tasty-output")) - // @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.7.0") - // val YallowOutlineFromTasty: Setting[Boolean] = BooleanSetting(ForkSetting, "Yallow-outline-from-tasty", "Allow outline TASTy to be loaded with the -from-tasty option.", deprecation = Deprecation.lifted("-Xallow-outline-from-tasty")) - - // Deprecated: lifted from -Y to -W - @deprecated(message = "Lifted to -W, Scheduled for removal.", since = "3.5.0") - val YcheckInit: Setting[Boolean] = BooleanSetting(ForkSetting, "Ysafe-init", "Ensure safe initialization of objects.", deprecation = Deprecation.renamed("-Wsafe-init")) - - // Deprecated: Scheduled for removal - @deprecated(message = "Scheduled for removal.", since = "3.5.0") - val YoutputOnlyTasty: Setting[Boolean] = BooleanSetting(ForkSetting, "Youtput-only-tasty", "Used to only generate the TASTy file without the classfiles", deprecation = Deprecation.removed()) end YSettings diff --git a/compiler/src/dotty/tools/dotc/config/Settings.scala b/compiler/src/dotty/tools/dotc/config/Settings.scala index 8965bc857c8c..737a509cff05 100644 --- a/compiler/src/dotty/tools/dotc/config/Settings.scala +++ b/compiler/src/dotty/tools/dotc/config/Settings.scala @@ -136,7 +136,7 @@ object Settings: def valueIn(state: SettingsState): T = state.value(idx).asInstanceOf[T] def updateIn(state: SettingsState, x: Any): SettingsState = x match - case _: T => state.update(idx, x) + case "help" | _: T => state.update(idx, x) // always ok to store "help" because we'll exit after printing help text case _ => throw IllegalArgumentException(s"found: $x of type ${x.getClass.getName}, required: $ct") def isDefaultIn(state: SettingsState): Boolean = valueIn(state) == default @@ -239,7 +239,7 @@ object Settings: def setOutput(arg: String, args: List[String])(using ArgsSummary) = val path = Directory(arg) val isJar = path.ext.isJar - if (!isJar && !path.isDirectory) then + if !isJar && !path.isDirectory then state.fail(s"'$arg' does not exist or is not a directory or .jar file", args) else /* Side effect, do not change this method to evaluate eagerly */ @@ -255,28 +255,29 @@ object Settings: val msg = s"missing argument for option $name" if ignoreInvalidArgs then state.warn(s"$msg, the tag was ignored", args) else state.fail(msg, args) - if ct == BooleanTag then setBoolean(argRest, args) - else if ct == OptionTag then update(Some(propertyClass.get.getConstructor().newInstance()), "", args) - else - // `-option:v` or `-option v` - val (arg1, args1) = - val argInArgRest = useArg || !argRest.isEmpty || legacyArgs + // `-option:v` or `-option v` + val (arg1, args1) = + if acceptsNoArg then (argRest, args) + else + val argInArgRest = useArg || argRest.nonEmpty || legacyArgs val useNextArg = !argInArgRest && args.nonEmpty && (ct == IntTag || !args.head.startsWith("-")) if argInArgRest then (argRest, args) else if useNextArg then (args.head, args.tail) else return missingArg - def doSet(arg: String, args: List[String]) = - ct match - case _ if preferPrevious && changed => - if ignoreInvalidArgs then state.shifted(args) - else state.warn(s"Ignoring update of option $name", args) - case ListTag => setMultivalue(arg, args) - case StringTag => setString(arg, args) - case OutputTag => setOutput(arg, args) - case IntTag => setInt(arg, args) - case VersionTag => setVersion(arg, args) - case _ => state.fail(s"unknown $ct", args) - doSet(arg1, args1) + + if arg1 == "help" then update(arg1, arg1, args1) + else if ct == BooleanTag then setBoolean(arg1, args1) + else if ct == OptionTag then update(Some(propertyClass.get.getConstructor().newInstance()), "", args1) + else if preferPrevious && changed then + if ignoreInvalidArgs then state.shifted(args1) + else state.warn(s"Ignoring update of option $name", args1) + else ct match + case ListTag => setMultivalue(arg1, args1) + case StringTag => setString(arg1, args1) + case OutputTag => setOutput(arg1, args1) + case IntTag => setInt(arg1, args1) + case VersionTag => setVersion(arg1, args1) + case _ => state.fail(s"unknown $ct", args1) end doSet def setVersion(arg: String, args: List[String])(using ArgsSummary) = @@ -319,8 +320,6 @@ object Settings: if matches then given ArgsSummary = state0 deprecation match - case Some(Deprecation(msg, _)) if ignoreInvalidArgs => // a special case for Xlint - state.warn(s"Option $name is deprecated: $msg", args) case _ => prefix match case Some(prefix) => @@ -343,6 +342,7 @@ object Settings: object Setting: extension [T](setting: Setting[T]) def value(using Context): T = setting.valueIn(ctx.settingsState) + def valueSetByUser(using Context): Option[T] = Option(setting.value).filter(_ != setting.default) def update(x: T)(using Context): SettingsState = setting.updateIn(ctx.settingsState, x) def isDefault(using Context): Boolean = setting.isDefaultIn(ctx.settingsState) diff --git a/compiler/src/dotty/tools/dotc/config/SourceVersion.scala b/compiler/src/dotty/tools/dotc/config/SourceVersion.scala index f53ab5ba9c06..799b5be9d0e5 100644 --- a/compiler/src/dotty/tools/dotc/config/SourceVersion.scala +++ b/compiler/src/dotty/tools/dotc/config/SourceVersion.scala @@ -19,8 +19,10 @@ enum SourceVersion: case `3.7-migration`, `3.7` case `3.8-migration`, `3.8` case `3.9-migration`, `3.9` + case `3.10-migration`, `3.10` + case `3.11-migration`, `3.11` // Add 3.x-migration and 3.x here - // !!! Keep in sync with scala.runtime.stdlibPatches.language !!! + // !!! Keep in sync with scala.language !!! case `2.13` case `future-migration`, `future` @@ -54,7 +56,7 @@ enum SourceVersion: object SourceVersion extends Property.Key[SourceVersion]: /* The default source version used by the built compiler */ - val defaultSourceVersion = `3.8` + val defaultSourceVersion = `3.10` /* Illegal source versions that may not appear in the settings `-source:<...>` */ val illegalInSettings = List(`2.13`, `3.1-migration`, `never`) diff --git a/compiler/src/dotty/tools/dotc/config/WrappedProperties.scala b/compiler/src/dotty/tools/dotc/config/WrappedProperties.scala index a72830331e9f..178cb603603a 100644 --- a/compiler/src/dotty/tools/dotc/config/WrappedProperties.scala +++ b/compiler/src/dotty/tools/dotc/config/WrappedProperties.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package config -import scala.language.unsafeNulls - /** For placing a wrapper function around property functions. * Motivated by places like google app engine throwing exceptions * on property lookups. @@ -14,12 +12,12 @@ trait WrappedProperties extends PropertiesTrait { protected def propCategory: String = "wrapped" protected def pickJarBasedOn: Class[?] = this.getClass - override def propIsSet(name: String): Boolean = wrap(super.propIsSet(name)) exists (x => x) - override def propOrElse(name: String, alt: => String): String = wrap(super.propOrElse(name, alt)) getOrElse alt - override def setProp(name: String, value: String): String = wrap(super.setProp(name, value)).orNull - override def clearProp(name: String): String = wrap(super.clearProp(name)).orNull - override def envOrElse(name: String, alt: => String): String = wrap(super.envOrElse(name, alt)) getOrElse alt - override def envOrNone(name: String): Option[String] = wrap(super.envOrNone(name)).flatten + override def propIsSet(name: String): Boolean = wrap(super.propIsSet(name)) exists (x => x) + override def propOrElse(name: String, alt: => String): String = wrap(super.propOrElse(name, alt)) getOrElse alt + override def setProp(name: String, value: String): String | Null = wrap(super.setProp(name, value)).orNull + override def clearProp(name: String): String | Null = wrap(super.clearProp(name)).orNull + override def envOrElse(name: String, alt: => String): String = wrap(super.envOrElse(name, alt)) getOrElse alt + override def envOrNone(name: String): Option[String] = wrap(super.envOrNone(name)).flatten def systemProperties: Iterator[(String, String)] = { import scala.jdk.CollectionConverters.* diff --git a/compiler/src/dotty/tools/dotc/core/Annotations.scala b/compiler/src/dotty/tools/dotc/core/Annotations.scala index 2cec74de4569..3ecd7e8de175 100644 --- a/compiler/src/dotty/tools/dotc/core/Annotations.scala +++ b/compiler/src/dotty/tools/dotc/core/Annotations.scala @@ -26,7 +26,11 @@ object Annotations { def hasSymbol(sym: Symbol)(using Context) = symbol == sym - def matches(cls: Symbol)(using Context): Boolean = symbol.derivesFrom(cls) + def matches(cls: Symbol)(using Context): Boolean = + // No annotation matches `AnyClass`. This is necessary since `AnyClass` + // is returned if a requiredClass call fails, and we want to be + // conservative in this case. + (cls ne defn.AnyClass) && symbol.derivesFrom(cls) def appliesToModule: Boolean = true // for now; see remark in SymDenotations diff --git a/compiler/src/dotty/tools/dotc/core/Constants.scala b/compiler/src/dotty/tools/dotc/core/Constants.scala index f404fd0fd0e0..0e3dfb2aa8e6 100644 --- a/compiler/src/dotty/tools/dotc/core/Constants.scala +++ b/compiler/src/dotty/tools/dotc/core/Constants.scala @@ -226,6 +226,49 @@ object Constants { } object Constant { + trait ValueToConstant[-T]: + def apply(value: T): Constant + + object ValueToConstant: + given ValueToConstant[Null] with + def apply(value: Null): Constant = new Constant(value, NullTag) + + given ValueToConstant[Unit] with + def apply(value: Unit): Constant = new Constant(value, UnitTag) + + given ValueToConstant[Boolean] with + def apply(value: Boolean): Constant = new Constant(value, BooleanTag) + + given ValueToConstant[Byte] with + def apply(value: Byte): Constant = new Constant(value, ByteTag) + + given ValueToConstant[Short] with + def apply(value: Short): Constant = new Constant(value, ShortTag) + + given ValueToConstant[Int] with + def apply(value: Int): Constant = new Constant(value, IntTag) + + given ValueToConstant[Long] with + def apply(value: Long): Constant = new Constant(value, LongTag) + + given ValueToConstant[Float] with + def apply(value: Float): Constant = new Constant(value, FloatTag) + + given ValueToConstant[Double] with + def apply(value: Double): Constant = new Constant(value, DoubleTag) + + given ValueToConstant[String] with + def apply(value: String): Constant = new Constant(value, StringTag) + + given ValueToConstant[Char] with + def apply(value: Char): Constant = new Constant(value, CharTag) + + given ValueToConstant[Type] with + def apply(value: Type): Constant = new Constant(value, ClazzTag) + + def fromValue[T](value: T)(using valueToConstant: ValueToConstant[T]): Constant = + valueToConstant(value) + def apply(x: Null): Constant = new Constant(x, NullTag) def apply(x: Unit): Constant = new Constant(x, UnitTag) def apply(x: Boolean): Constant = new Constant(x, BooleanTag) @@ -238,23 +281,6 @@ object Constants { def apply(x: String): Constant = new Constant(x, StringTag) def apply(x: Char): Constant = new Constant(x, CharTag) def apply(x: Type): Constant = new Constant(x, ClazzTag) - def apply(value: Any): Constant = - new Constant(value, - value match { - case null => NullTag - case x: Unit => UnitTag - case x: Boolean => BooleanTag - case x: Byte => ByteTag - case x: Short => ShortTag - case x: Int => IntTag - case x: Long => LongTag - case x: Float => FloatTag - case x: Double => DoubleTag - case x: String => StringTag - case x: Char => CharTag - case x: Type => ClazzTag - } - ) def unapply(c: Constant): Constant = c } diff --git a/compiler/src/dotty/tools/dotc/core/ContextOps.scala b/compiler/src/dotty/tools/dotc/core/ContextOps.scala index 8e1cafd56628..6123c6b1be21 100644 --- a/compiler/src/dotty/tools/dotc/core/ContextOps.scala +++ b/compiler/src/dotty/tools/dotc/core/ContextOps.scala @@ -137,6 +137,7 @@ object ContextOps: } def isRechecking: Boolean = - (ctx.base.recheckPhaseIds & (1L << ctx.phaseId)) != 0 + val phaseId = ctx.phaseId + 0 <= phaseId && phaseId < 64 && (ctx.base.recheckPhaseIds & (1L << phaseId)) != 0 end ContextOps diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala index 4d5ed74d2040..e3eb58d07bab 100644 --- a/compiler/src/dotty/tools/dotc/core/Contexts.scala +++ b/compiler/src/dotty/tools/dotc/core/Contexts.scala @@ -39,14 +39,15 @@ import dotty.tools.dotc.sbt.interfaces.{IncrementalCallback, ProgressCallback} import util.Property.Key import util.Store import plugins.* -import java.util.concurrent.atomic.AtomicInteger import java.nio.file.InvalidPathException import dotty.tools.dotc.coverage.Coverage import scala.annotation.tailrec +import dotty.tools.dotc.inlines.Inlines.InlineTraitState +import dotty.tools.dotc.transform.SpecializedTraitState object Contexts { - private val (compilerCallbackLoc, store1) = Store.empty.newLocation[CompilerCallback]() + private val (compilerCallbackLoc, store1) = Store.empty.newLocation[CompilerCallback | Null]() private val (incCallbackLoc, store2) = store1.newLocation[IncrementalCallback | Null]() private val (printerFnLoc, store3) = store2.newLocation[Context => Printer](new RefinedPrinter(_)) private val (settingsStateLoc, store4) = store3.newLocation[SettingsState]() @@ -147,6 +148,8 @@ object Contexts { def typerState: TyperState def gadt: GadtConstraint = gadtState.gadt def gadtState: GadtState + def inlineTraitState: InlineTraitState + def specializedTraitState: SpecializedTraitState def searchHistory: SearchHistory def source: SourceFile @@ -166,7 +169,7 @@ object Contexts { def store: Store /** The compiler callback implementation, or null if no callback will be called. */ - def compilerCallback: CompilerCallback = store(compilerCallbackLoc) + def compilerCallback: CompilerCallback | Null = store(compilerCallbackLoc) /** The Zinc callback implementation if we are run from Zinc, null otherwise */ def incCallback: IncrementalCallback | Null = store(incCallbackLoc) @@ -437,6 +440,8 @@ object Contexts { superOrThisCallContext(owner, constrCtx.scope) .setTyperState(typerState) .setGadtState(gadtState) + .setInlineTraitState(inlineTraitState) + .setSpecializedTraitState(specializedTraitState) .fresh .setScope(this.scope) } @@ -604,6 +609,12 @@ object Contexts { private var _gadtState: GadtState = uninitialized final def gadtState: GadtState = _gadtState + + private var _inlineTraitState: InlineTraitState = uninitialized + final def inlineTraitState: InlineTraitState = _inlineTraitState + + private var _specializedTraitState: SpecializedTraitState = uninitialized + final def specializedTraitState: SpecializedTraitState = _specializedTraitState private var _searchHistory: SearchHistory = uninitialized final def searchHistory: SearchHistory = _searchHistory @@ -629,6 +640,8 @@ object Contexts { _tree = origin.tree _scope = origin.scope _gadtState = origin.gadtState + _inlineTraitState = origin.inlineTraitState + _specializedTraitState = origin.specializedTraitState _searchHistory = origin.searchHistory _source = origin.source _moreProperties = origin.moreProperties @@ -692,6 +705,16 @@ object Contexts { def setFreshGADTBounds: this.type = setGadtState(gadtState.fresh) + def setInlineTraitState(inlineTraitState: InlineTraitState): this.type = + util.Stats.record("Context.setInlineTraitState") + this._inlineTraitState = inlineTraitState + this + + def setSpecializedTraitState(specializedTraitState: SpecializedTraitState): this.type = + util.Stats.record("Context.setSpecializedTraitState") + this._specializedTraitState = specializedTraitState + this + def setSearchHistory(searchHistory: SearchHistory): this.type = util.Stats.record("Context.setSearchHistory") this._searchHistory = searchHistory @@ -786,6 +809,8 @@ object Contexts { .updated(profilerLoc, Profiler.NoOp) c._searchHistory = new SearchRoot c._gadtState = GadtState(GadtConstraint.empty) + c._inlineTraitState = InlineTraitState() + c._specializedTraitState = SpecializedTraitState() c end FreshContext @@ -902,7 +927,7 @@ object Contexts { } /** A context base defines state and associated methods that exist once per - * compiler run. + * logical compiler instance. */ class ContextBase extends ContextState with Phases.PhasesBase diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala index b78ef947cd8b..f19d58f41666 100644 --- a/compiler/src/dotty/tools/dotc/core/Decorators.scala +++ b/compiler/src/dotty/tools/dotc/core/Decorators.scala @@ -4,9 +4,8 @@ package core import scala.annotation.tailrec import scala.collection.mutable.ListBuffer -import scala.util.control.NonFatal -import Contexts.*, Names.*, Phases.*, Symbols.* +import Contexts.*, Names.*, Phases.*, Symbols.*, Types.* import printing.{ Printer, Showable }, printing.Formatting.*, printing.Texts.* import transform.MegaPhase import reporting.{Message, NoExplanation} @@ -81,6 +80,24 @@ object Decorators { NoSymbol } + extension (tp: Type) + /** Replace synthetic parameter names (`x$0`, `x$1`, ...) of any method + * type group in `tp` (recursing through curried `MethodType`s and + * through `PolyType` result types) with dollar-free names (`x0`, + * `x1`, ...). Lets a printed signature be reused as a valid Scala + * identifier - e.g. in stub implementations or "method is not + * defined" diagnostics. + */ + def withCleanParamNames(using Context): Type = tp match + case mt: MethodType if mt.allParamNamesSynthetic => + val newNames = mt.paramNames.zipWithIndex.map((_, i) => termName("x" + i)) + mt.derivedLambdaType(newNames, mt.paramInfos, mt.resType.withCleanParamNames) + case mt: MethodType => + mt.derivedLambdaType(mt.paramNames, mt.paramInfos, mt.resType.withCleanParamNames) + case pt: PolyType => + pt.derivedLambdaType(pt.paramNames, pt.paramInfos, pt.resType.withCleanParamNames) + case _ => tp + inline val MaxFilterRecursions = 10 /** Implements filterConserve, zipWithConserve methods @@ -286,7 +303,7 @@ object Decorators { try x.show catch case ex: CyclicReference => "... (caught cyclic reference) ..." - case NonFatal(ex) + case ex: Exception if !ctx.settings.YshowPrintErrors.value => s"... (cannot display due to ${ex.className} ${ex.getMessage}) ..." case _ => String.valueOf(x) diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala index c2245f1bcdbd..5165c3922440 100644 --- a/compiler/src/dotty/tools/dotc/core/Definitions.scala +++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala @@ -15,7 +15,7 @@ import Comments.{Comment, docCtx} import util.Spans.NoSpan import config.Feature import Symbols.requiredModuleRef -import cc.{CaptureSet, RetainingAnnotation} +import cc.{CaptureSet, RetainingAnnotation, SafeRefs} import ast.tpd.ref import scala.annotation.tailrec @@ -236,6 +236,7 @@ class Definitions { @tu lazy val ScalaCollectionImmutablePackageClass: ClassSymbol = requiredPackage("scala.collection.immutable").moduleClass.asClass @tu lazy val ScalaMathPackageClass: ClassSymbol = requiredPackage("scala.math").moduleClass.asClass @tu lazy val ScalaUtilPackageClass: ClassSymbol = requiredPackage("scala.util").moduleClass.asClass + @tu lazy val ScalaSpecializePackageVal: TermSymbol = requiredPackage("scala.specialize") // fundamental modules @tu lazy val SysPackage : Symbol = requiredModule("scala.sys.package") @@ -484,6 +485,15 @@ class Definitions { } def NullType: TypeRef = NullClass.typeRef + /* + * RuntimeNothingClass and RuntimeNullClass exist at run-time only. + * They are the run-time manifestation (in method signatures only) + * of what shows up as NothingClass (scala.Nothing) resp. NullClass (scala.Null) in Scala ASTs. + * Therefore, when NothingClass or NullClass are to be emitted, a mapping is needed. + */ + @tu lazy val RuntimeNothingClass: Symbol = requiredClass("scala.runtime.Nothing$") + @tu lazy val RuntimeNullClass: Symbol = requiredClass("scala.runtime.Null$") + @tu lazy val InvokerModule = requiredModule("scala.runtime.coverage.Invoker") @tu lazy val InvokedMethodRef = InvokerModule.requiredMethodRef("invoked") @@ -680,6 +690,11 @@ class Definitions { @tu lazy val JavaCloneableClass: ClassSymbol = requiredClass("java.lang.Cloneable") @tu lazy val NullPointerExceptionClass: ClassSymbol = requiredClass("java.lang.NullPointerException") @tu lazy val IndexOutOfBoundsException: ClassSymbol = requiredClass("java.lang.IndexOutOfBoundsException") + @tu lazy val IndexOutOfBoundsExceptionType: Type = IndexOutOfBoundsException.typeRef + @tu lazy val IndexOutOfBoundsException_IntConstructor: TermSymbol = IndexOutOfBoundsException.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match { + case List(pt) => pt.isRef(IntClass) + case _ => false + }).symbol.asTerm @tu lazy val ClassClass: ClassSymbol = requiredClass("java.lang.Class") @tu lazy val BoxedNumberClass: ClassSymbol = requiredClass("java.lang.Number") @tu lazy val ClassCastExceptionClass: ClassSymbol = requiredClass("java.lang.ClassCastException") @@ -779,6 +794,10 @@ class Definitions { @tu lazy val StringAddClass : ClassSymbol = requiredClass("scala.runtime.StringAdd") @tu lazy val StringAdd_+ : Symbol = StringAddClass.requiredMethod(nme.raw.PLUS) + @tu lazy val SpecializedClass : ClassSymbol = requiredClass("scala.specialize.Specialized") + @tu lazy val SpecializedModule: Symbol = SpecializedClass.companionModule + @tu lazy val SpecializedModule_apply: Symbol = SpecializedModule.requiredMethod(nme.apply) + @tu lazy val StringContextClass: ClassSymbol = requiredClass("scala.StringContext") @tu lazy val StringContext_s : Symbol = StringContextClass.requiredMethod(nme.s) @tu lazy val StringContext_raw: Symbol = StringContextClass.requiredMethod(nme.raw_) @@ -1121,7 +1140,9 @@ class Definitions { @tu lazy val TargetNameAnnot: ClassSymbol = requiredClass("scala.annotation.targetName") @tu lazy val VarargsAnnot: ClassSymbol = requiredClass("scala.annotation.varargs") @tu lazy val ReachCapabilityAnnot = requiredClass("scala.annotation.internal.reachCapability") + @tu lazy val ParamAliasAnnot: ClassSymbol = requiredClass("scala.caps.internal.paramAlias") @tu lazy val InferredAnnot = requiredClass("scala.caps.internal.inferred") + @tu lazy val DeclaredAnnot = requiredClass("scala.caps.internal.declared") @tu lazy val ReadOnlyCapabilityAnnot = requiredClass("scala.annotation.internal.readOnlyCapability") @tu lazy val OnlyCapabilityAnnot = requiredClass("scala.annotation.internal.onlyCapability") @tu lazy val RequiresCapabilityAnnot: ClassSymbol = requiredClass("scala.annotation.internal.requiresCapability") @@ -1528,8 +1549,12 @@ class Definitions { Set(StringClass, NothingClass, NullClass) ++ ScalaValueClasses() @tu lazy val assumedSafePackages: Set[Symbol] = - Set(OpsPackageClass, ScalaPackageClass, ScalaCollectionImmutablePackageClass, ScalaRuntimePackageClass, - ScalaMathPackageClass, ScalaUtilPackageClass, JavaMathPackageClass, JavaTimePackageClass) + SafeRefs.assumedSafePackages + .map(requiredPackage) + .filter(!_.info.isInstanceOf[StubInfo]) + .map(_.moduleClass) + .toSet + + OpsPackageClass @tu lazy val capsErasedValueMethods = Set(Caps_erasedValue, Caps_unsafeErasedValue) @@ -1712,7 +1737,10 @@ class Definitions { RootRef(() => ScalaPackageVal.termRef) private val PredefImportFns: RootRef = - RootRef(() => ScalaPredefModule.termRef, isPredef=true) + RootRef(() => ScalaPredefModule.termRef) + + private val SpecializeImportFns: RootRef = // TODO: Find a solution to importing in scala package without conflict with original specialized. + RootRef(() => ScalaSpecializePackageVal.termRef) @tu private lazy val YimportsImportFns: List[RootRef] = ctx.settings.Yimports.value.map { name => val denot = @@ -1729,8 +1757,8 @@ class Definitions { @tu private lazy val ScalaRootImportFns: List[RootRef] = if !ctx.settings.Yimports.isDefault then YimportsImportFns else if ctx.settings.YnoImports.value then Nil - else if ctx.settings.YnoPredef.value then ScalaImportFns - else ScalaImportFns :+ PredefImportFns + else if ctx.settings.YnoPredef.value then ScalaImportFns :+ SpecializeImportFns + else ScalaImportFns :+ SpecializeImportFns :+ PredefImportFns @tu private lazy val JavaRootImportTypes: List[TermRef] = JavaRootImportFns.map(_.refFn()) @tu private lazy val ScalaRootImportTypes: List[TermRef] = ScalaRootImportFns.map(_.refFn()) @@ -2004,27 +2032,6 @@ class Definitions { if (isBoxedUnitClass(cls)) parents.filter(_.typeSymbol != JavaSerializableClass) else parents - private val HasProblematicGetClass: Set[Name] = Set( - tpnme.AnyVal, tpnme.Byte, tpnme.Short, tpnme.Char, tpnme.Int, tpnme.Long, tpnme.Float, tpnme.Double, - tpnme.Unit, tpnme.Boolean) - - /** When typing a primitive value class or AnyVal, we ignore the `getClass` - * member: it's supposed to be an override of the `getClass` defined on `Any`, - * but in dotty `Any#getClass` is polymorphic so it ends up being an overload. - * This is especially problematic because it means that when writing: - * - * 1.asInstanceOf[Int & AnyRef].getClass - * - * the `getClass` that returns `Class[Int]` defined in Int can be selected, - * but this call is specified to return `classOf[Integer]`, see - * tests/run/t5568.scala. - * - * FIXME: remove all the `getClass` methods defined in the standard library - * so we don't have to hot-patch it like this. - */ - def hasProblematicGetClass(className: Name): Boolean = - HasProblematicGetClass.contains(className) - @tu lazy val assumedTransparentNames: Map[Name, Set[Symbol]] = // we should do a more through sweep through it then. val strs = Map( diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala index af7455fa2994..3085db1a0043 100644 --- a/compiler/src/dotty/tools/dotc/core/Flags.scala +++ b/compiler/src/dotty/tools/dotc/core/Flags.scala @@ -453,13 +453,13 @@ object Flags { /** Flags representing source modifiers */ private val CommonSourceModifierFlags: FlagSet = - commonFlags(Private, Protected, Final, Case, Implicit, Given, Override, JavaStatic, Transparent, Erased) + commonFlags(Private, Protected, Final, Case, Implicit, Given, Override, JavaStatic, Transparent, Erased, Inline) val TypeSourceModifierFlags: FlagSet = CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque | Open | Into val TermSourceModifierFlags: FlagSet = - CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy | Tracked + CommonSourceModifierFlags.toTermFlags | AbsOverride | Lazy | Tracked /** Flags representing modifiers that can appear in trees */ val ModifierFlags: FlagSet = @@ -592,6 +592,7 @@ object Flags { val InlineOrProxy: FlagSet = Inline | InlineProxy // An inline method or inline argument proxy */ val InlineMethod: FlagSet = Inline | Method val InlineImplicitMethod: FlagSet = Implicit | InlineMethod + val InlineTrait: FlagSet = Inline | Trait val InlineParam: FlagSet = Inline | Param val InlineByNameProxy: FlagSet = InlineProxy | Method val JavaEnum: FlagSet = JavaDefined | Enum // A Java enum trait diff --git a/compiler/src/dotty/tools/dotc/core/NameKinds.scala b/compiler/src/dotty/tools/dotc/core/NameKinds.scala index b5407945929f..c19ff61d2b97 100644 --- a/compiler/src/dotty/tools/dotc/core/NameKinds.scala +++ b/compiler/src/dotty/tools/dotc/core/NameKinds.scala @@ -407,6 +407,7 @@ object NameKinds { val AdaptedClosureName: SuffixNameKind = new SuffixNameKind(ADAPTEDCLOSURE, "$adapted") { override def definesNewName = true } val SyntheticSetterName: SuffixNameKind = new SuffixNameKind(SETTER, "_$eq") val LazyVarHandleName: SuffixNameKind = new SuffixNameKind(LAZYVALVARHANDLE, "$lzyHandle") + val ReplAssignName: SuffixNameKind = new SuffixNameKind(REPL_ASSIGN, str.REPL_ASSIGN_SUFFIX) /** A name together with a signature. Used in Tasty trees. */ object SignedName extends NameKind(SIGNED) { diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala index f157da843f41..a3375c2eed8e 100644 --- a/compiler/src/dotty/tools/dotc/core/NameOps.scala +++ b/compiler/src/dotty/tools/dotc/core/NameOps.scala @@ -77,6 +77,9 @@ object NameOps { def isAnonymousFunctionName: Boolean = name.startsWith(str.ANON_FUN) def isUnapplyName: Boolean = name == nme.unapply || name == nme.unapplySeq def isRightAssocOperatorName: Boolean = name.lastPart.last == ':' + def isSpecializedTraitInterfaceName: Boolean = name.toString.contains(str.SPECIALIZED_TRAIT_SUFFIX) + def isSpecializedTraitImplementationName: Boolean = name.toString.contains(str.SPECIALIZED_TRAIT_IMPL_SUFFIX) + def isRawSpecializedTraitImplementationName: Boolean = name.toString.endsWith(str.SPECIALIZED_TRAIT_IMPL_SUFFIX) /** Does this name match `[{letter | digit} '_'] op`? * @@ -89,7 +92,7 @@ object NameOps { // Ends with operator characters while i >= 0 && isOperatorPart(name(i)) do i -= 1 if i == -1 then return true - // Optionnally prefixed with alpha-numeric characters followed by `_` + // Optionally prefixed with alpha-numeric characters followed by `_` if name(i) != '_' then return false while i >= 0 && isIdentifierPart(name(i)) do i -= 1 i == -1 diff --git a/compiler/src/dotty/tools/dotc/core/NameTags.scala b/compiler/src/dotty/tools/dotc/core/NameTags.scala index 1e45ceac30cd..2111c2bb7855 100644 --- a/compiler/src/dotty/tools/dotc/core/NameTags.scala +++ b/compiler/src/dotty/tools/dotc/core/NameTags.scala @@ -30,7 +30,7 @@ object NameTags extends TastyFormat.NameTags { inline val PARAMACC = 33 // Used for a private parameter alias - inline val SETTER = 34 // A synthesized += suffix. + inline val SETTER = 34 // A synthesized _= suffix. // Name of type variables created by `ConstraintHandling#LevelAvoidMap`. final val AVOIDUPPER = 35 @@ -42,6 +42,8 @@ object NameTags extends TastyFormat.NameTags { inline val LAZYVALVARHANDLE = 39 // A field containing a VarHandle generated for lazy vals + inline val REPL_ASSIGN = 40 // Alias of an assigned term in REPL + def nameTagToString(tag: Int): String = tag match { case UTF8 => "UTF8" case QUALIFIED => "QUALIFIED" diff --git a/compiler/src/dotty/tools/dotc/core/Names.scala b/compiler/src/dotty/tools/dotc/core/Names.scala index 1be1df47902b..5ff2ca54204b 100644 --- a/compiler/src/dotty/tools/dotc/core/Names.scala +++ b/compiler/src/dotty/tools/dotc/core/Names.scala @@ -384,39 +384,7 @@ object Names { protected def computeToString: String = if (length == 0) "" - else { - if (Config.checkBackendNames) - if (!toStringOK) { - // We print the stacktrace instead of doing an assert directly, - // because asserts are caught in exception handlers which might - // cause other failures. In that case the first, important failure - // is lost. - System.err.println("Backend should not call Name#toString, Name#mangledString should be used instead.") - Thread.dumpStack() - assert(false) - } - new String(chrs, start, length) - } - - /** It's OK to take a toString if the stacktrace does not contain a method - * from GenBCode or it also contains one of the allowed methods below. - */ - private def toStringOK = { - val trace: Array[StackTraceElement] = Thread.currentThread.getStackTrace.asInstanceOf[Array[StackTraceElement]] - !trace.exists(_.getClassName.endsWith("GenBCode")) || - trace.exists(elem => - List( - "mangledString", - "toSimpleName", - "decode", - "unmangle", - "dotty$tools$dotc$core$NameOps$NameDecorator$$functionArityFor$extension", - "dotty$tools$dotc$typer$Checking$CheckNonCyclicMap$$apply", - "$plus$plus", - "readConstant", - "extractedName") - .contains(elem.getMethodName)) - } + else new String(chrs, start, length) def debugString: String = toString } diff --git a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala index 0154c70e7949..cd7de188faa0 100644 --- a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala +++ b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala @@ -760,6 +760,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds, case tp: TypeVar if contains(tp.origin) => withHard(tp) case tp: TypeParamRef if contains(tp) => hardenTypeVars(typeVarOfParam(tp)) case tp: AndOrType => hardenTypeVars(tp.tp1).hardenTypeVars(tp.tp2) + case tp: FlexibleType => hardenTypeVars(tp.hi) case _ => this def remove(pt: TypeLambda)(using Context): This = { diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala index fef2ec843dd6..7314fd5dee79 100644 --- a/compiler/src/dotty/tools/dotc/core/Phases.scala +++ b/compiler/src/dotty/tools/dotc/core/Phases.scala @@ -4,7 +4,6 @@ package core import Periods.* import Contexts.* -import dotty.tools.backend.jvm.GenBCode import DenotTransformers.* import Denotations.* import Decorators.* @@ -19,7 +18,6 @@ import cc.CheckCaptures import typer.ImportInfo.withRootImports import ast.{tpd, untpd} import scala.annotation.internal.sharable -import scala.util.control.NonFatal import scala.compiletime.uninitialized object Phases { @@ -76,7 +74,6 @@ object Phases { final def fusePhases(phasess: List[List[Phase]], phasesToSkip: List[String], stopBeforePhases: List[String], - stopAfterPhases: List[String], YCheckAfter: List[String])(using Context): List[Phase] = { val fusedPhases = ListBuffer[Phase]() var prevPhases: Set[String] = Set.empty @@ -91,7 +88,7 @@ object Phases { val filteredPhases = phasess.map(_.filter { p => try isEnabled(p) - finally stop |= stopBeforePhases.contains(p.phaseName) | stopAfterPhases.contains(p.phaseName) + finally stop |= stopBeforePhases.contains(p.phaseName) }) var i = 0 @@ -237,6 +234,8 @@ object Phases { private var mySbtExtractAPIPhase: Phase = uninitialized private var myPicklerPhase: Phase = uninitialized private var mySetRootTreePhase: Phase = uninitialized + private var mySpecializeInlineTraitsPhase: Phase = uninitialized + private var myDesugarSpecializedTraitsPhase: Phase = uninitialized private var myInliningPhase: Phase = uninitialized private var myStagingPhase: Phase = uninitialized private var mySplicingPhase: Phase = uninitialized @@ -256,7 +255,6 @@ object Phases { private var myMixinPhase: Phase = uninitialized private var myCountOuterAccessesPhase: Phase = uninitialized private var myFlattenPhase: Phase = uninitialized - private var myGenBCodePhase: Phase = uninitialized private var myCheckCapturesPhase: Phase = uninitialized private var myCheckCapturesPhaseId: PhaseId = -2 @@ -270,6 +268,8 @@ object Phases { final def sbtExtractAPIPhase: Phase = mySbtExtractAPIPhase final def picklerPhase: Phase = myPicklerPhase final def setRootTreePhase: Phase = mySetRootTreePhase + final def specializeInlineTraitsPhase: Phase = mySpecializeInlineTraitsPhase + final def desugarSpecializedTraitsPhase: Phase = myDesugarSpecializedTraitsPhase final def inliningPhase: Phase = myInliningPhase final def stagingPhase: Phase = myStagingPhase final def splicingPhase: Phase = mySplicingPhase @@ -289,7 +289,6 @@ object Phases { final def lambdaLiftPhase: Phase = myLambdaLiftPhase final def countOuterAccessesPhase = myCountOuterAccessesPhase final def flattenPhase: Phase = myFlattenPhase - final def genBCodePhase: Phase = myGenBCodePhase final def checkCapturesPhase: Phase = myCheckCapturesPhase final def checkCapturesPhaseId: PhaseId = myCheckCapturesPhaseId @@ -303,6 +302,8 @@ object Phases { mySbtExtractAPIPhase = phaseOfClass(classOf[sbt.ExtractAPI]) mySetRootTreePhase = phaseOfClass(classOf[SetRootTree]) myPicklerPhase = phaseOfClass(classOf[Pickler]) + mySpecializeInlineTraitsPhase = phaseOfClass(classOf[SpecializeInlineTraits]) + myDesugarSpecializedTraitsPhase = phaseOfClass(classOf[DesugarSpecializedTraits]) myInliningPhase = phaseOfClass(classOf[Inlining]) myStagingPhase = phaseOfClass(classOf[Staging]) mySplicingPhase = phaseOfClass(classOf[Splicing]) @@ -322,7 +323,6 @@ object Phases { myFlattenPhase = phaseOfClass(classOf[Flatten]) myExplicitOuterPhase = phaseOfClass(classOf[ExplicitOuter]) myGettersPhase = phaseOfClass(classOf[Getters]) - myGenBCodePhase = phaseOfClass(classOf[GenBCode]) myCheckCapturesPhase = phaseOfClass(classOf[CheckCaptures]) } @@ -413,7 +413,7 @@ object Phases { catch case _: CompilationUnit.SuspendException => // this unit will be run again in `Run#compileSuspendedUnits` unitCtx.typerState.resetTo(previousTyperState) - case ex: Throwable if !ctx.run.enrichedErrorMessage => + case ex: Exception if !ctx.run.enrichedErrorMessage => println(ctx.run.enrichErrorMessage(s"unhandled exception while running $phaseName on $unit")) throw ex finally ctx.run.advanceUnit() @@ -537,7 +537,7 @@ object Phases { ctx.run.enterUnit(ctx.compilationUnit) && { try {body; true} - catch case NonFatal(ex) if !ctx.run.enrichedErrorMessage => + catch case ex: Exception if !ctx.run.enrichedErrorMessage => report.echo(ctx.run.enrichErrorMessage(s"exception occurred while $doing ${ctx.compilationUnit}")) throw ex finally ctx.run.advanceUnit() @@ -566,6 +566,8 @@ object Phases { def sbtExtractDependenciesPhase(using Context): Phase = ctx.base.sbtExtractDependenciesPhase def sbtExtractAPIPhase(using Context): Phase = ctx.base.sbtExtractAPIPhase def picklerPhase(using Context): Phase = ctx.base.picklerPhase + def specializeInlineTraitsPhase(using Context): Phase = ctx.base.specializeInlineTraitsPhase + def desugarSpecializedTraitsPhase(using Context): Phase = ctx.base.desugarSpecializedTraitsPhase def inliningPhase(using Context): Phase = ctx.base.inliningPhase def stagingPhase(using Context): Phase = ctx.base.stagingPhase def splicingPhase(using Context): Phase = ctx.base.splicingPhase @@ -582,7 +584,6 @@ object Phases { def mixinPhase(using Context): Phase = ctx.base.mixinPhase def lambdaLiftPhase(using Context): Phase = ctx.base.lambdaLiftPhase def flattenPhase(using Context): Phase = ctx.base.flattenPhase - def genBCodePhase(using Context): Phase = ctx.base.genBCodePhase def checkCapturesPhase(using Context): Phase = ctx.base.checkCapturesPhase def checkCapturesPhaseId(using Context): PhaseId = ctx.base.checkCapturesPhaseId diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala index a4c3c6c46605..0d709d008836 100644 --- a/compiler/src/dotty/tools/dotc/core/StdNames.scala +++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala @@ -26,6 +26,11 @@ object StdNames { inline val LOCALDUMMY_PREFIX = " p.classSymbol match { case pcls: ClassSymbol => builder.addAll(pcls.baseClasses) - case _ => assert(isRefinementClass || p.isError || ctx.mode.is(Mode.Interactive) || ctx.tolerateErrorsForBestEffort, s"$this has non-class parent: $p") + case _ => + // The parent type couldn't be resolved to a class, e.g. + // because a transitive dependency was removed from the + // classpath. Report a `BadSymbolicReference` (mirroring the + // pattern used by `StubInfo.complete` above) rather than + // crashing with an internal assertion. See scala/scala3#20010. + def ignoreBadParent = + isRefinementClass || p.isError + || ctx.mode.is(Mode.Interactive) || ctx.tolerateErrorsForBestEffort + p match + case p: TypeRef if p.symbol == NoSymbol && !ignoreBadParent => + val stubOwner = + p.prefix.classSymbol + .orElse(p.prefix.termSymbol.moduleClass) + .orElse(defn.RootClass) + val stub = newStubSymbol(stubOwner, p.name, CompilationUnitInfo(symbol.associatedFile)) + report.error(BadSymbolicReference(stub.denot), symbol.srcPos) + case _ => + assert(ignoreBadParent, s"$this has non-class parent: $p") } traverse(parents1) case nil => @@ -2388,7 +2433,7 @@ object SymDenotations { } } catch { - case ex: Throwable => + case ex: Exception => tp match case tp: CachedType => btrCache.remove(tp) case _ => @@ -2419,6 +2464,11 @@ object SymDenotations { case pcls: ClassSymbol => for name <- pcls.memberNames(keepOnly) do maybeAdd(name) + case _ => + // Parent failed to resolve to a class (the missing + // reference has been reported by computeBaseData). + // Skip here to avoid a secondary MatchError. + // See scala/scala3#20010. val ownSyms = if (keepOnly eq implicitFilter) if (this.is(Package)) Iterator.empty @@ -2429,8 +2479,7 @@ object SymDenotations { names } catch { - case ex: Throwable => - handleRecursive("member names", i"of $this", ex) + case ex: Throwable => handleRecursive("member names", i"of $this", ex) } } @@ -2618,7 +2667,7 @@ object SymDenotations { // since the older file might have been loaded from a jar earlier in the // classpath. def sameContainer(f: AbstractFile): Boolean = - try f.container == chosen.container catch case NonFatal(ex) => true + try f.container == chosen.container catch case ex: Exception => true if !ambiguityWarningIssued then for conflicting <- assocFiles.find(!sameContainer(_)) do report.warning(em"""${ambiguousFilesMsg(conflicting)} diff --git a/compiler/src/dotty/tools/dotc/core/SymUtils.scala b/compiler/src/dotty/tools/dotc/core/SymUtils.scala index 3dc6be427412..ff1f8708961d 100644 --- a/compiler/src/dotty/tools/dotc/core/SymUtils.scala +++ b/compiler/src/dotty/tools/dotc/core/SymUtils.scala @@ -252,6 +252,15 @@ class SymUtils: else if (self.exists) self.owner.enclosingMethodOrClass else NoSymbol + /** The closest enclosing method, class or object of this symbol. + * Module references get mapped to their moduleClasses. + */ + @tailrec final def enclosingMethodOrClassOrObject(using Context): Symbol = + if self.is(Method) || self.isClass then self + else if self.is(ModuleVal) then self.moduleClass + else if self.exists then self.owner.enclosingMethodOrClassOrObject + else NoSymbol + /** Apply symbol/symbol substitution to this symbol */ def subst(from: List[Symbol], to: List[Symbol]): Symbol = { @tailrec def loop(from: List[Symbol], to: List[Symbol]): Symbol = diff --git a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala index 0303f1626d91..c0c0f0d2b5bf 100644 --- a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala +++ b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala @@ -5,8 +5,6 @@ package core import java.io.{IOException, File} import java.nio.channels.ClosedByInterruptException -import scala.util.control.NonFatal - import dotty.tools.dotc.classpath.{ ClassPathFactory, PackageNameUtils } import dotty.tools.dotc.classpath.FileUtils.{hasTastyExtension, hasBetastyExtension} import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile, NoAbstractFile } @@ -152,7 +150,9 @@ object SymbolLoaders { def enterScanned(unit: CompilationUnit)(using Context) = { def checkPathMatches(path: List[TermName], what: String, tree: NameTree): Boolean = { - val ok = filePath == path + // Ignore empty packages if necessary so we don't warn on top-level package objects + // (such as `package object scala` in the top-level "package.scala" of the standard library) + val ok = filePath == path || filePath == path.filter(_ != nme.EMPTY_PACKAGE) if (!ok) report.warning(i"""$what ${tree.name} is in the wrong directory. |It was declared to be in package ${path.reverse.mkString(".")} @@ -435,16 +435,14 @@ abstract class SymbolLoader extends LazyType { self => report.informTime("loaded " + description, start) } catch { - case ex: InterruptedException => - throw ex case ex: ClosedByInterruptException => throw new InterruptedException case ex: IOException => signalError(ex) - case NonFatal(ex: TypeError) => + case ex: TypeError => println(s"exception caught when loading $root: ${ex.toMessage}") throw ex - case NonFatal(ex) => + case ex: Exception => println(s"exception caught when loading $root: $ex") throw ex } @@ -558,8 +556,7 @@ class TastyLoader(val tastyFile: AbstractFile) extends SymbolLoader { val tastyUUID = unpickler.unpickler.header.uuid new ClassfileTastyUUIDParser(classfile)(ctx).checkTastyUUID(tastyUUID) else - // This will be the case in any of our tests that compile with `-Youtput-only-tasty`, or when - // tasty file compiled by `-Xearly-tasty-output-write` comes from an early output jar. + // This will be the case when a tasty file compiled by `-Xearly-tasty-output-write` comes from an early output jar. report.inform(s"No classfiles found for $tastyFile when checking TASTy UUID") private def checkBeTastyUUID(tastyFile: AbstractFile, tastyBytes: Array[Byte])(using Context): Unit = diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala index c6888c045a74..36770713e57e 100644 --- a/compiler/src/dotty/tools/dotc/core/Symbols.scala +++ b/compiler/src/dotty/tools/dotc/core/Symbols.scala @@ -977,6 +977,12 @@ object Symbols extends SymUtils { copies.foreach(_.ensureCompleted()) // avoid memory leak + copies.zip(originals).foreach { (copied, original) => + if copied.retainsDefTree then + copied.defTree = original.defTree + } + + // Update Child annotations of classes encountered previously to new values // if some child is among the mapped symbols for orig <- ttmap1.substFrom do diff --git a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala index 30bd3c168269..97b0af3e3a4f 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala @@ -393,15 +393,17 @@ class TypeApplications(val self: Type) extends AnyVal { case _ => false } } - if ((dealiased eq stripped) || followAlias) - try - val instantiated = dealiased.instantiate(args) - if (followAlias) instantiated.normalized else instantiated - catch - case ex: IndexOutOfBoundsException => - AppliedType(self, args) - case ex: Throwable => - handleRecursive("try to instantiate", i"$dealiased[$args%, %]", ex) + if (dealiased eq stripped) || followAlias then + val paramsWithoutArg = dealiased.typeParams.drop(args.length).map(_.paramRef) + val hasParamsWithoutArg = paramsWithoutArg.nonEmpty && dealiased.resType.existsPart(paramsWithoutArg.contains, forceLazy = false) + if hasParamsWithoutArg then + AppliedType(self, args) + else + try + val instantiated = dealiased.instantiate(args) + if (followAlias) instantiated.normalized else instantiated + catch + case ex: Throwable => handleRecursive("try to instantiate", i"$dealiased[$args%, %]", ex) else AppliedType(self, args) } diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala index 366af03a97e2..5d06e52c8dad 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala @@ -17,7 +17,6 @@ import TypeErasure.{erasedLub, erasedGlb} import TypeApplications.* import Variances.{Variance, variancesConform} import Constants.Constant -import scala.util.control.NonFatal import typer.ProtoTypes.constrained import typer.Applications.productSelectorTypes import reporting.trace @@ -27,7 +26,10 @@ import Capabilities.Capability import NameKinds.WildcardParamName import MatchTypes.isConcrete import reporting.Message.Note +import reporting.IllegalVarianceInSpecializedTraitsNote import scala.util.boundary, boundary.break +import dotty.tools.dotc.transform.Specialization +import dotty.tools.dotc.transform.DesugarSpecializedTraits /** Provides methods to compare types. */ @@ -159,7 +161,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling def testSubType(tp1: Type, tp2: Type): CompareResult = GADTused = false opaquesUsed = false - if !topLevelSubType(tp1, tp2) then CompareResult.Fail(Nil) + errorNotes = Nil + if !topLevelSubType(tp1, tp2) then CompareResult.Fail(errorNotes.map(_._2)) else if GADTused then CompareResult.OKwithGADTUsed else if opaquesUsed then CompareResult.OKwithOpaquesUsed // we cast on GADTused, so handles if both are used else CompareResult.OK @@ -671,24 +674,28 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling // TODO: Merge with isSubInfo in hasMatchingMember. Currently, we can't since // the isSubinfo of hasMatchingMember has problems dealing with PolyTypes // (---> orphan params during pickling) - def isSubInfo(info1: Type, info2: Type): Boolean = (info1, info2) match - case (info1: PolyType, info2: PolyType) => - info1.paramNames.hasSameLengthAs(info2.paramNames) - && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1)) - case (info1: MethodType, info2: MethodType) => - matchingMethodParams(info1, info2, precise = false) - && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1)) - case (info1 @ CapturingType(parent1, refs1), info2: Type) - if info2.stripCapturing.isInstanceOf[MethodOrPoly] => - compareCaptures(info1, refs1, info2, info2.captureSet) - && isSubInfo(parent1, info2) - case (info1: Type, CapturingType(parent2, refs2)) - if info1.stripCapturing.isInstanceOf[MethodOrPoly] => - val refs1 = info1.captureSet - (refs1.isAlwaysEmpty || compareCaptures(info1, refs1, info2, refs2)) - && isSubInfo(info1, parent2) - case _ => - isSubType(info1, info2) + def isSubInfo(info1: Type, info2: Type): Boolean = + try (info1, info2) match + case (info1: PolyType, info2: PolyType) => + info1.paramNames.hasSameLengthAs(info2.paramNames) + && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1)) + case (info1: MethodType, info2: MethodType) => + matchingMethodParams(info1, info2, precise = false) + && isSubInfo(info1.resultType, info2.resultType.subst(info2, info1)) + case (info1 @ CapturingType(parent1, refs1), info2: Type) + if info2.stripCapturing.isInstanceOf[MethodOrPoly] => + compareCaptures(info1, refs1, info2, info2.captureSet) + && isSubInfo(parent1, info2) + case (info1: Type, CapturingType(parent2, refs2)) + if info1.stripCapturing.isInstanceOf[MethodOrPoly] => + val refs1 = info1.captureSet + (refs1.isAlwaysEmpty || compareCaptures(info1, refs1, info2, refs2)) + && isSubInfo(info1, parent2) + case _ => + isSubType(info1, info2) + catch case ex: AssertionError => + println(i"error while subinfo $info1 <:< $info2") + throw ex if defn.isFunctionType(tp2) then if tp2.derivesFrom(defn.PolyFunctionClass) then @@ -1637,12 +1644,18 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling needsGc = false if (Stats.monitored) recordStatistics(result, savedSuccessCount) result - catch case NonFatal(ex) => - if ex.isInstanceOf[AssertionError] then showGoal(tp1, tp2) - recCount -= 1 - restore() - successCount = savedSuccessCount - throw ex + catch + case ex: AssertionError => + showGoal(tp1, tp2) + recCount -= 1 + restore() + successCount = savedSuccessCount + throw ex + case ex: Exception => + recCount -= 1 + restore() + successCount = savedSuccessCount + throw ex } /** Undo all actions in undoLog following prevSize */ @@ -1924,8 +1937,29 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling && defn.isByNameFunction(arg2.dealias) => isSubArg(arg1res, arg2.argInfos.head) case _ => - if v < 0 then isSubType(arg2, arg1) - else if v > 0 then isSubType(arg1, arg2) + if v < 0 then + val isValidSubtype = isSubType(arg2, arg1) + if tp1.classSymbol.isSpecializedTrait + && Specialization.traitParamIsSpecialized(tp1.classSymbol, tparam.paramRef.typeSymbol) + && isValidSubtype + && !(DesugarSpecializedTraits.isSameErasureBucket(arg1, arg2)) + then // using contravariance in a way which specialized trait erasure cannot support + addErrorNote(IllegalVarianceInSpecializedTraitsNote()) + false + else + isValidSubtype + else if v > 0 then + val isValidSubtype = isSubType(arg1, arg2) + if tp1.classSymbol.isSpecializedTrait + && Specialization.traitParamIsSpecialized(tp1.classSymbol, tparam.paramRef.typeSymbol) + && isValidSubtype + && (arg1 ne arg2) + && (arg1.classSymbol == defn.NothingClass) + then + addErrorNote(IllegalVarianceInSpecializedTraitsNote()) + false + else + isValidSubtype else isSameType(arg2, arg1) val arg1 = args1.head @@ -2988,7 +3022,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling explainPoly(tp1) explainPoly(tp2) } - catch case NonFatal(ex) => + catch case ex: Exception => report.echo(s"assertion failure [[cannot display since $ex was thrown]]") /** Record statistics about the total number of subtype checks @@ -3306,8 +3340,9 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling // sjrd: I will not be surprised when this causes further issues in the future. // This is a compromise to be able to fix #21295 without breaking the world. def cannotBeNothing(tp: Type): Boolean = tp match - case tp: TypeParamRef => cannotBeNothing(tp.paramInfo) - case _ => !(tp.loBound.stripTypeVar <:< defn.NothingType) + case tp: TypeParamRef => cannotBeNothing(tp.paramInfo) + case tp: TypeRef if tp.symbol.is(TypeParam) => cannotBeNothing(tp.info.bounds) + case _ => !(tp.loBound.stripTypeVar <:< defn.NothingType) // It is possible to conclude that two types applied are disjoint by // looking at covariant type parameters if the said type parameters diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala index f9a4ecd3ab94..8f486afad741 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala @@ -7,12 +7,15 @@ import Flags.JavaDefined import Uniques.unique import backend.sjs.JSDefinitions import transform.ExplicitOuter.* +import transform.Specialization import transform.ValueClasses.* import transform.ContextFunctionResults.* import unpickleScala2.Scala2Erasure import Decorators.* import Definitions.MaxImplementedFunctionArity import scala.annotation.tailrec +import dotty.tools.dotc.transform.DesugarSpecializedTraits +import dotty.tools.dotc.util.Property /** The language in which the definition being erased was written. */ enum SourceLanguage: @@ -76,8 +79,10 @@ end SourceLanguage */ object TypeErasure: + private val DisallowSpecialized = Property.Key[Unit] + private def erasureDependsOnArgs(sym: Symbol)(using Context) = - sym == defn.ArrayClass || sym == defn.PairClass || sym.isDerivedValueClass + sym == defn.ArrayClass || sym == defn.PairClass || sym.isDerivedValueClass || sym.isSpecializedTrait /** The arity of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs. * @@ -209,6 +214,14 @@ object TypeErasure: def preErasureCtx(using Context) = if (ctx.erasedTypes) ctx.withPhase(erasurePhase) else ctx + /** The current context but with Foo[Int] erasing to Foo instead of + * Foo$sp$Int when Foo is a specialized trait. */ + def disallowSpecializedCtx(using Context) = ctx.fresh.setProperty(DisallowSpecialized, ()) + + /** The current context but with Foo[Int] erasing to Foo$sp$Int instead of + * Foo when Foo is a specialized trait. */ + def allowSpecializedCtx(using Context) = ctx.fresh.dropProperty(DisallowSpecialized) + /** The standard erasure of a Scala type. Value classes are erased as normal classes. * * @param tp The type to erase. @@ -482,7 +495,7 @@ object TypeErasure: if compareErasedGlb(tp1, tp2) <= 0 then tp1 else tp2 /** Overload of `erasedGlb` to compare more than two types at once. */ - def erasedGlb(tps: List[Type])(using Context): Type = + def erasedGlb(tps: Iterable[Type])(using Context): Type = tps.min(using (a,b) => compareErasedGlb(a, b)) /** A comparison function that induces a total order on erased types, @@ -770,6 +783,15 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst else if semiEraseVCs && sym.isDerivedValueClass then eraseDerivedValueClass(tp) else if defn.isSyntheticFunctionClass(sym) then defn.functionTypeErasure(sym) else eraseNormalClassRef(tp) + case Specialization(spec) if ((ctx.phase == erasurePhase || ctx.erasedTypes) // At the beginning the $sp$ trait symbols are not present so up until + // erasure need to consider the signature of def foo(x: Foo[Int]): Int as + // foo(Foo):Int. Only at erasure do the symbol swap. This ensures + // the signatures don't change before erasure. + && spec.isSpecialized && ctx.property(DisallowSpecialized).isEmpty) => + val specName = DesugarSpecializedTraits.newSpecializedTraitName(spec) // TODO: Maybe better as method on spec + val interfaceSymbol = spec.traitSymbol.owner.enclosingPackageClass.info.decls.lookup(specName) + assert(interfaceSymbol.exists && interfaceSymbol.isClass) + this(interfaceSymbol.typeRef.appliedTo(spec.unspecializedTypeArgs.map(_.tpe))) case tp: AppliedType => val tycon = tp.tycon if (tycon.isRef(defn.ArrayClass)) eraseArray(tp) @@ -860,19 +882,36 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst case tp @ ClassInfo(pre, cls, parents, decls, _) => if (cls.is(Package)) tp else { - def eraseParent(tp: Type) = tp.dealias match { // note: can't be opaque, since it's a class parent + def eraseParent(tp: Type)(using Context) = tp.dealias match { // note: can't be opaque, since it's a class parent case tp: AppliedType if tp.tycon.isRef(defn.PairClass) => defn.ObjectType case _ => apply(tp) } val erasedParents: List[Type] = if ((cls eq defn.ObjectClass) || cls.isPrimitiveValueClass) Nil - else parents.mapConserve(eraseParent) match { - case tr :: trs1 => - assert(!tr.classSymbol.is(Trait), i"$cls has bad parents $parents%, %") - val tr1 = if (cls.is(Trait)) defn.ObjectType else tr - tr1 :: trs1.filterNot(_.isAnyRef) - case nil => nil - } + else + // Match corresponding tree erasure in Erasure::typedClassDef + val parents1 = + if cls.isSpecializedTraitInterface then // {source: Bar, Foo both specialized traits} inline trait Bar$sp$Int extends Object, Bar, Foo$sp$Int + val (obj :: originalTrait :: inheritedParents) = parents : @unchecked + eraseParent(obj) :: apply(originalTrait)(using disallowSpecializedCtx) :: inheritedParents.mapConserve(eraseParent(_)(using allowSpecializedCtx)) + else if cls.isSpecializedTraitImplementationClass && !cls.isRawSpecializedTraitImplementationClass then // {source: Bar, Foo both specialized traits} class Bar$impl$Int extends Object, Bar$sp$Int, Bar(10) + val (objectParent :: traitSpParent :: originalTraitSpecializedParent :: Nil) = parents : @unchecked + eraseParent(objectParent) :: eraseParent(traitSpParent)(using allowSpecializedCtx) :: apply(originalTraitSpecializedParent)(using disallowSpecializedCtx) :: Nil + else + val originalSpecializedTraits = parents.filter(p => p.typeSymbol.isSpecializedTrait).map(eraseParent(_)(using allowSpecializedCtx)) + + // {source: class Bar extends Foo[Int](10) with Baz[Int](10)} + // class Bar extends Object, Foo(10), Bar(10), Foo$sp$Int, Bar$sp$Int + parents.mapConserve(p => if p.typeSymbol.isSpecializedTrait then + apply(p)(using disallowSpecializedCtx) + else eraseParent(p)) ::: originalSpecializedTraits + parents1 match { + case tr :: trs1 => + assert(!tr.classSymbol.is(Trait), i"$cls has bad parents $parents%, %") + val tr1 = if (cls.is(Trait)) defn.ObjectType else tr + tr1 :: trs1.filterNot(_.isAnyRef) + case nil => nil + } val erasedDecls = decls.filteredScope( keep = sym => !sym.isType || sym.isClass, rename = sym => @@ -933,8 +972,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst try erasureFn(sourceLanguage, semiEraseVCs = false, isConstructor, isSymbol, inSigName)(elemtp) match case _: WildcardType => WildcardType case elem => JavaArrayType(elem) - catch case ex: Throwable => - handleRecursive("erase array type", tp.show, ex) + catch case ex: Throwable => handleRecursive("erase array type", tp.show, ex) } private def erasePair(tp: Type)(using Context): Type = { @@ -946,7 +984,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst } /** The erasure of a symbol's info. This is different from `apply` in the way `ExprType`s and - * `PolyType`s are treated. `eraseInfo` maps them them to method types, whereas `apply` maps them + * `PolyType`s are treated. `eraseInfo` maps them to method types, whereas `apply` maps them * to the underlying type. */ def eraseInfo(tp: Type, sym: Symbol)(using Context): Type = @@ -992,7 +1030,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst // erased like `Array[A]` as seen from its definition site, no matter // the `X` (same if `A` is bounded). // - // The binary compatibility is checked by sbt-test/scala2-compat/i8001 + // The binary compatibility is checked by tests/run/i8001 val erasedValueClass = if erasedUnderlying.isPrimitiveValueType && !genericUnderlying.isPrimitiveValueType then defn.boxedType(erasedUnderlying) @@ -1022,7 +1060,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst else tp match case tp: TypeRef => val sym = tp.symbol - if (sym eq defn.UnitClass) sym.typeRef + if (tp.isRef(defn.UnitClass)) defn.UnitType else apply(tp) case tp: AppliedType => val sym = tp.tycon.typeSymbol diff --git a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala index 1b6156ee74e8..3a775b7d44a1 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala @@ -47,7 +47,7 @@ abstract class TypeError(using creationContext: Context) extends Exception(""): /** Uses creationContext to produce the message */ override def getMessage: String = - try toMessage.message catch case ex: Throwable => "TypeError" + try toMessage.message catch case _: Exception => "TypeError" object TypeError: def apply(msg: Message)(using Context) = new TypeError: @@ -131,7 +131,7 @@ end RecursionOverflow // Beware: Since this object is only used when handling a StackOverflow, this code // cannot consume significant amounts of stack. object handleRecursive: - inline def underlyingStackOverflowOrNull(exc: Throwable): Throwable | Null = + private inline def underlyingStackOverflowOrNull(exc: Throwable): Throwable | Null = var e: Throwable | Null = exc while e != null && !e.isInstanceOf[StackOverflowError] do e = e.getCause e @@ -155,7 +155,7 @@ end handleRecursive */ class CyclicReference( val denot: SymDenotation, - val optTrace: Option[Array[CyclicReference.TraceElement]])(using Context) + val optTrace: Array[CyclicReference.TraceElement] | Null)(using Context) extends TypeError: var inImplicitSearch: Boolean = false @@ -204,8 +204,16 @@ extends TypeError: object CyclicReference: + private def traceElements(using Context): Array[TraceElement] | Null = + val run = ctx.run + if run == null then null + else + val trace = run.cyclicReferenceTrace + if trace == null then null + else trace.toArray + def apply(denot: SymDenotation)(using Context): CyclicReference = - val ex = new CyclicReference(denot, ctx.property(Trace).map(_.toArray)) + val ex = new CyclicReference(denot, traceElements) if ex.computeStackTrace then cyclicErrors.println(s"Cyclic reference involving $denot") val sts = ex.getStackTrace.asInstanceOf[Array[StackTraceElement]] @@ -215,26 +223,15 @@ object CyclicReference: type TraceElement = Context ?=> String type Trace = mutable.ArrayBuffer[TraceElement] - val Trace = Property.Key[Trace] - - private def isTraced(using Context) = - ctx.property(CyclicReference.Trace).isDefined - - private def pushTrace(info: TraceElement)(using Context): Unit = - for buf <- ctx.property(CyclicReference.Trace) do - buf += info - - private def popTrace()(using Context): Unit = - for buf <- ctx.property(CyclicReference.Trace) do - buf.dropRightInPlace(1) inline def trace[T](info: TraceElement)(inline op: => T)(using Context): T = - val traceCycles = isTraced + val run = ctx.run + val traceCycles = run != null && run.cyclicReferenceTrace != null try - if traceCycles then pushTrace(info) + if traceCycles then run.nn.cyclicReferenceTrace.nn += info op finally - if traceCycles then popTrace() + if traceCycles then run.nn.cyclicReferenceTrace.nn.dropRightInPlace(1) inline def trace[T](prefix: String, sym: Symbol)(inline op: => T)(using Context): T = trace((ctx: Context) ?=> i"$prefix$sym")(op) diff --git a/compiler/src/dotty/tools/dotc/core/TypeEval.scala b/compiler/src/dotty/tools/dotc/core/TypeEval.scala index 5bcd45b61785..e9a23d800fee 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeEval.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeEval.scala @@ -81,12 +81,12 @@ object TypeEval: // Runs the op and returns the result as a constant type. // If the op throws an exception, then this exception is converted into a type error. - def runConstantOp(op: => Any): Type = + def runConstantOp[T](op: => T)(using Constant.ValueToConstant[T]): Type = val result = try op - catch case e: Throwable => - throw TypeError(em"${e.getMessage}") - ConstantType(Constant(result)) + catch case ex: Exception => + throw TypeError(em"${ex.getMessage}") + ConstantType(Constant.fromValue(result)) def fieldsOf: Option[Type] = expectArgsNum(1) @@ -113,25 +113,25 @@ object TypeEval: case _ => None case _ => None - def constantFold1[T](extractor: Type => Option[T], op: T => Any): Option[Type] = + def constantFold1[T, U: Constant.ValueToConstant](extractor: Type => Option[T], op: T => U): Option[Type] = expectArgsNum(1) extractor(tp.args.head).map(a => runConstantOp(op(a))) - def constantFold2[T](extractor: Type => Option[T], op: (T, T) => Any): Option[Type] = + def constantFold2[T, U: Constant.ValueToConstant](extractor: Type => Option[T], op: (T, T) => U): Option[Type] = constantFold2AB(extractor, extractor, op) - def constantFold2AB[TA, TB](extractorA: Type => Option[TA], extractorB: Type => Option[TB], op: (TA, TB) => Any): Option[Type] = + def constantFold2AB[TA, TB, U: Constant.ValueToConstant](extractorA: Type => Option[TA], extractorB: Type => Option[TB], op: (TA, TB) => U): Option[Type] = expectArgsNum(2) for a <- extractorA(tp.args(0)) b <- extractorB(tp.args(1)) yield runConstantOp(op(a, b)) - def constantFold3[TA, TB, TC]( + def constantFold3[TA, TB, TC, U: Constant.ValueToConstant]( extractorA: Type => Option[TA], extractorB: Type => Option[TB], extractorC: Type => Option[TC], - op: (TA, TB, TC) => Any + op: (TA, TB, TC) => U ): Option[Type] = expectArgsNum(3) for diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala index e59b3c794ada..069cca698d31 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala @@ -504,8 +504,7 @@ object TypeOps: mapOver(tl) case _ => super.apply(tp) - catch case ex: Throwable => - handleRecursive("traversing for avoiding local references", s"${tp.show}" , ex) + catch case ex: Throwable => handleRecursive("traversing for avoiding local references", s"${tp.show}", ex) end apply /** Three deviations from standard derivedSelect: diff --git a/compiler/src/dotty/tools/dotc/core/TypeUtils.scala b/compiler/src/dotty/tools/dotc/core/TypeUtils.scala index 594249065d98..5f2a45f7402b 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeUtils.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeUtils.scala @@ -20,8 +20,19 @@ class TypeUtils: def isErasedValueType(using Context): Boolean = self.isInstanceOf[ErasedValueType] - def isPrimitiveValueType(using Context): Boolean = - self.classSymbol.isPrimitiveValueClass + def isPrimitiveValueType(using Context): Boolean = self match + case tp: TypeRef => + val sym = tp.symbol + if sym.isClass then sym.isPrimitiveValueClass + else tp.superType.isPrimitiveValueType + case tp: TypeProxy => + tp.superType.isPrimitiveValueType + case tp: ClassInfo => + tp.cls.isPrimitiveValueClass + case _ => + // anything else definitely can't be one (e.g., AndType), + // so let's not waste time constructing a ClassSymbol + false /** Is this type a checked exception? This is the case if the type * derives from Exception but not from RuntimeException. According to @@ -222,15 +233,22 @@ class TypeUtils: tpe self match case tpe: NamedType => - if tpe.symbol.isRoot then - tpe + if tpe.prefix.refersToPackage then + tryInsert(tpe, tpe.prefix.packageClass) else - tpe.prefix match - case pre: ThisType if pre.cls.is(Package) => tryInsert(tpe, pre.cls) - case pre: TermRef if pre.symbol.is(Package) => tryInsert(tpe, pre.symbol.moduleClass) - case _ => tpe + tpe case tpe => tpe + /** If this type refers to a package, the class representing that package, + * otherwise NoSymbol. + */ + def packageClass(using Context): Symbol = self.stripped match + case self: ThisType if self.cls.is(Package) => self.cls + case self: TermRef if self.symbol.is(Package) => self.symbol.moduleClass + case _ => NoSymbol + + def refersToPackage(using Context): Boolean = packageClass.exists + /** Strip all outer refinements off this type */ def stripRefinement: Type = self match case self: RefinedOrRecType => self.parent.stripRefinement diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala index e528143d20fc..628c45eb77c7 100644 --- a/compiler/src/dotty/tools/dotc/core/Types.scala +++ b/compiler/src/dotty/tools/dotc/core/Types.scala @@ -183,8 +183,6 @@ object Types extends TypeUtils { // https://www.scala-lang.org/files/archive/spec/2.11/11-annotations.html#scala-compiler-annotations tp.annot.symbol == defn.UncheckedStableAnnot || tp.parent.isStable case tp: AndType => - // TODO: fix And type check when tp contains type parames for explicit-nulls flow-typing - // see: tests/explicit-nulls/pos/flow-stable.scala.disabled tp.tp1.isStable && (realizability(tp.tp2) eq Realizable) || tp.tp2.isStable && (realizability(tp.tp1) eq Realizable) case tp: AppliedType => tp.cachedIsStable @@ -736,8 +734,7 @@ object Types extends TypeUtils { case tp: WildcardType => tp.effectiveBounds.hi.baseClasses case _ => Nil - catch case ex: Throwable => - handleRecursive("base classes of", this.show, ex) + catch case ex: Throwable => handleRecursive("base classes of", this.show, ex) // ----- Member access ------------------------------------------------- @@ -1357,6 +1354,7 @@ object Types extends TypeUtils { case _ => this } + /** Strip PolyType prefixes */ def stripPoly(using Context): Type = this match { case tp: PolyType => tp.resType.stripPoly @@ -4967,10 +4965,7 @@ object Types extends TypeUtils { } override def toString: String = - try s"RecThis(${binder.hashCode})" - catch { - case ex: NullPointerException => s"RecThis()" - } + s"RecThis(${binder.hashCode})" } private final class RecThisImpl(binder: RecType) extends RecThis(binder) diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala index ecd258c87089..0a85b570c347 100644 --- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala +++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala @@ -3,8 +3,6 @@ package dotc package core package classfile -import scala.language.unsafeNulls - import dotty.tools.tasty.{ TastyReader, TastyHeaderUnpickler, UnpickleException } import Contexts.*, Symbols.*, Types.*, Names.*, StdNames.*, NameOps.*, Scopes.*, Decorators.* @@ -22,7 +20,6 @@ import scala.collection.mutable.{ ListBuffer, ArrayBuffer } import scala.annotation.switch import typer.Checking.checkNonCyclic import io.{AbstractFile, ZipArchive} -import scala.util.control.NonFatal import dotty.tools.dotc.classpath.FileUtils.hasSiblingTasty import scala.compiletime.uninitialized @@ -96,7 +93,7 @@ object ClassfileParser { abstract class AbstractConstantPool(using in: DataReader) { protected val len = in.nextChar protected val starts = new Array[Int](len) - protected val values = new Array[AnyRef](len) + protected val values = new Array[AnyRef | Null](len) protected val internalized = new Array[NameOrString](len) { var i = 1 @@ -129,7 +126,7 @@ object ClassfileParser { if (index <= 0 || len <= index) errorBadIndex(index) - values(index) match { + values(index).runtimeChecked match { case name: NameOrString => name case null => val start = starts(index) @@ -199,7 +196,7 @@ object ClassfileParser { } values(index) = value } - value match { + value.runtimeChecked match { case ct: Constant => ct case cls: Symbol => Constant(cls.typeRef) case arr: Type => Constant(arr) @@ -258,10 +255,10 @@ object ClassfileParser { } protected class NameOrString(val value: String) { - private var _name: SimpleName = null + private var _name: SimpleName | Null = null def name: SimpleName = { - if (_name eq null) _name = termName(value) - _name + if (_name == null) _name = termName(value) + _name.nn } } } @@ -300,7 +297,7 @@ class ClassfileParser( classfileVersion = parseHeader(classfile) this.pool = new ConstantPool val res = parseClass() - this.pool = null + this.pool = null.asInstanceOf[ConstantPool] // deinit for GC res } catch { @@ -466,9 +463,12 @@ class ClassfileParser( } class MemberCompleter(name: SimpleName, jflags: Int, sig: String) extends LazyType { - var attrCompleter: AttributeCompleter = null + var attrCompleter: AttributeCompleter | Null = null def complete(denot: SymDenotation)(using Context): Unit = { + val attrCompleter = this.attrCompleter + assert(attrCompleter != null, "complete was called but attrCompleter was not set") + val sym = denot.symbol val isEnum = (jflags & JAVA_ACC_ENUM) != 0 val isNative = (jflags & JAVA_ACC_NATIVE) != 0 @@ -562,10 +562,12 @@ class ClassfileParser( if (pt eq defn.BooleanType) && ct.tag == IntTag then Constant(ct.value != 0) else - ct.convertTo(pt) + val cst = ct.convertTo(pt) + assert(cst != null, i"Cannot convert constant $ct to type $pt") + cst } - private def sigToType(sig: String, owner: Symbol = null, isVarargs: Boolean = false)(using Context): Type = { + private def sigToType(sig: String, owner: Symbol | Null = null, isVarargs: Boolean = false)(using Context): Type = { var index = 0 val end = sig.length def accept(ch: Char): Unit = { @@ -619,7 +621,7 @@ class ClassfileParser( if (argsBuf != null) argsBuf += arg } accept('>') - if (skiptvs) tp else AppliedType(tp, argsBuf.toList) + if (argsBuf == null) tp else AppliedType(tp, argsBuf.toList) } else tp case tp => @@ -825,10 +827,10 @@ class ClassfileParser( case (name, tag: EnumTag) => untpd.NamedArg(name.name, tag.toTree).withSpan(NoSpan) } - protected var mySym: Symbol | (Context ?=> Symbol) = + protected var mySym: Symbol | (Context ?=> Symbol) | Null = (ctx: Context) ?=> annotType.classSymbol - protected var myTree: Tree | (Context ?=> Tree) = + protected var myTree: Tree | (Context ?=> Tree) | Null = (ctx: Context) ?=> untpd.resolveConstructor(annotType, args) def untpdTree(using Context): untpd.Tree = @@ -865,7 +867,7 @@ class ClassfileParser( } catch { case f: FatalError => throw f // don't eat fatal errors, they mean a class was not found - case NonFatal(ex) => + case ex: Exception => // We want to be robust when annotations are unavailable, so the very least // we can do is warn the user about the exception // There was a reference to ticket 1135, but that is outdated: a reference to a class not on @@ -887,13 +889,15 @@ class ClassfileParser( * lazily. */ class AttributeCompleter(sym: Symbol) { - var sig: String = null - var constant: Constant = null + var sig: String | Null = null + var constant: Constant | Null = null var exceptions: List[NameOrString] = Nil var annotations: List[Annotation] = Nil var namedParams: Map[Int, TermName] = Map.empty + var permittedSubclasses: List[NameOrString] = Nil def complete(tp: Type, isVarargs: Boolean = false)(using Context): Type = { val updatedType = + val sig = this.sig if sig == null then tp else { val newType = sigToType(sig, sym, isVarargs) @@ -903,8 +907,9 @@ class ClassfileParser( } val newType = - if this.constant != null then - val ct = convertTo(this.constant, updatedType) + val constant = this.constant + if constant != null then + val ct = convertTo(constant, updatedType) if ct != null then ConstantType(ct) else updatedType else updatedType @@ -915,6 +920,14 @@ class ClassfileParser( sym.addAnnotation(ThrowsAnnotation(cls.asClass)) } + permittedSubclasses.foreach { child => + val cls = getClassSymbol(child.name) + sym.addAnnotation(Annotation.deferredSymAndTree(defn.ChildAnnot)( + New(defn.ChildAnnot.typeRef.appliedTo(cls.owner.thisType.select(cls.name, cls)), Nil) + .withSpan(NoSpan) + )) + } + def fillInParamNames(t: Type): Type = t match case mt @ MethodType(oldp) if namedParams.nonEmpty => mt.derivedLambdaType(List.tabulate(oldp.size)(n => namedParams.getOrElse(n, oldp(n)))) @@ -992,6 +1005,14 @@ class ClassfileParser( report.log(s"$sym in ${sym.owner} is a java 8+ default method.") } + case tpnme.PermittedSubclassesATTR => + sym.setFlag(Flags.Sealed) + val numberOfClasses = in.nextChar + for (n <- 0 until numberOfClasses) { + val childName = pool.getClassName(in.nextChar.toInt) + res.permittedSubclasses ::= childName + } + case _ => } in.bp = end @@ -1338,26 +1359,26 @@ class ClassfileParser( def getClassOrArrayType(index: Int)(using ctx: Context, in: DataReader): Type = { if (index <= 0 || len <= index) errorBadIndex(index) val value = values(index) - var c: Type = null if (value eq null) { val start = starts(index) if (in.getByte(start).toInt != CONSTANT_CLASS) errorBadTag(start) val name = getExternalName(in.getChar(start + 1)) if (name.value.charAt(0) == ARRAY_TAG) { - c = sigToType(name.value) + val c = sigToType(name.value) values(index) = c + c } else { val sym = classNameToSymbol(name.name) values(index) = sym - c = sym.typeRef + sym.typeRef } } - else c = value match { + else + value.runtimeChecked match { case tp: Type => tp case cls: Symbol => cls.typeRef - } - c + } } def getType(index: Int, isVarargs: Boolean = false)(using Context, DataReader): Type = diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileTastyUUIDParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileTastyUUIDParser.scala index f2e34925302b..991b1c83bdb4 100644 --- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileTastyUUIDParser.scala +++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileTastyUUIDParser.scala @@ -1,7 +1,6 @@ package dotty.tools.dotc package core.classfile -import scala.language.unsafeNulls import scala.compiletime.uninitialized import dotty.tools.dotc.core.Contexts.* @@ -32,7 +31,7 @@ class ClassfileTastyUUIDParser(classfile: AbstractFile)(ictx: Context) { this.classfileVersion = ClassfileParser.parseHeader(classfile) this.pool = new ConstantPool checkTastyAttr(tastyUUID) - this.pool = null + this.pool = null.asInstanceOf[ConstantPool] // deinit for GC } catch { case e: RuntimeException => @@ -106,6 +105,6 @@ class ClassfileTastyUUIDParser(classfile: AbstractFile)(ictx: Context) { class ConstantPool(using in: DataReader) extends ClassfileParser.AbstractConstantPool { def getClassOrArrayType(index: Int)(using ctx: Context, in: DataReader): Type = throw new UnsupportedOperationException def getClassSymbol(index: Int)(using ctx: Context, in: DataReader): Symbol = throw new UnsupportedOperationException - def getType(index: Int, isVarargs: Boolean)(using x$3: Context, x$4: DataReader): Type = throw new UnsupportedOperationException + def getType(index: Int, isVarargs: Boolean)(using Context, DataReader): Type = throw new UnsupportedOperationException } } diff --git a/compiler/src/dotty/tools/dotc/core/tasty/BestEffortTastyWriter.scala b/compiler/src/dotty/tools/dotc/core/tasty/BestEffortTastyWriter.scala index a027da8a8a29..299b9fd4c800 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/BestEffortTastyWriter.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/BestEffortTastyWriter.scala @@ -21,10 +21,7 @@ object BestEffortTastyWriter: val outstream = new DataOutputStream(new PlainFile(outTastyFile).bufferedOutput) try outstream.write(binary()) catch case ex: ClosedByInterruptException => - try - outTastyFile.delete() // don't leave an empty or half-written tastyfile around after an interrupt - catch - case _: Throwable => + outTastyFile.delete() // don't leave an empty or half-written tastyfile around after an interrupt throw ex finally outstream.close() } diff --git a/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala index 12cb1b1f0473..3fd466c361f6 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala @@ -3,8 +3,6 @@ package dotc package core package tasty -import scala.language.unsafeNulls - import Contexts.*, SymDenotations.*, Decorators.* import dotty.tools.dotc.ast.tpd import TastyUnpickler.* @@ -94,7 +92,7 @@ class DottyUnpickler( protected def computeRootTrees(using Context): List[Tree] = treeUnpickler.unpickle(mode) - private var ids: Array[String] = null + private var ids: Array[String] | Null = null override def mightContain(id: String)(using Context): Boolean = { if (ids == null) @@ -102,6 +100,6 @@ class DottyUnpickler( unpickler.nameAtRef.contents.toArray.collect { case name: SimpleName => name.toString }.sorted - ids.binarySearch(id) >= 0 + ids.nn.binarySearch(id) >= 0 } } diff --git a/compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala index 3d8080e72a29..90f0483b6bdc 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala @@ -43,19 +43,19 @@ object PositionPickler: pickler.newSection(PositionsSection, buf) - /** Pickle the number of lines followed by the length of each line */ - def pickleLineOffsets(): Unit = { + /** Pickle the number of lines followed by the size of each line */ + def pickleLinesSizes(): Unit = { val content = source.content() buf.writeNat(content.count(_ == '\n') + 1) // number of lines - var lastIndex = content.indexOf('\n', 0) - buf.writeNat(lastIndex) // size of first line + var lastIndex = content.indexOf('\n') + buf.writeNat(if lastIndex != -1 then lastIndex else content.length) // size of first line while lastIndex != -1 do val nextIndex = content.indexOf('\n', lastIndex + 1) val end = if nextIndex != -1 then nextIndex else content.length buf.writeNat(end - lastIndex - 1) // size of the next line lastIndex = nextIndex } - pickleLineOffsets() + pickleLinesSizes() var lastIndex = 0 var lastSpan = Span(0, 0) diff --git a/compiler/src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala index 975264a288dd..5dda0740710e 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala @@ -27,7 +27,10 @@ class PositionUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName) { myLineSizes = new Array[Int](lines) var i = 0 while i < lines do - myLineSizes(i) += readNat() + // This should be `readNat()` per the spec, + // but previous compiler versions had a bug and could write `-1` as a Nat + val lineSize = readLongNat() + myLineSizes(i) += (if lineSize == 0xFFFFFFFFL then -1 else lineSize.toInt) i += 1 mySpans = util.HashMap[Addr, Span]() @@ -68,6 +71,7 @@ class PositionUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName) { mySourceNameRefs } + // Can include -1 entries for "unknown", as previous compiler versions had a bug private[tasty] def lineSizes: Array[Int] = { ensureDefined() myLineSizes diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala index 4f741a64718f..89f2f60f918c 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala @@ -12,8 +12,7 @@ import util.Spans.offsetToInt import dotty.tools.tasty.TastyFormat.{ASTsSection, AttributesSection, CommentsSection, PositionsSection} import java.nio.file.{Files, Paths} -import dotty.tools.io.{JarArchive, Path, PlainFile} -import dotty.tools.tasty.TastyFormat.header +import dotty.tools.io.{AbstractFile, JarArchive, Path} import scala.collection.immutable.BitSet import scala.compiletime.uninitialized @@ -60,8 +59,11 @@ object TastyPrinter: System.exit(1) else if arg.endsWith(".jar") then val jar = JarArchive.open(Path(arg), create = false) + def tastyFiles(file: AbstractFile): Iterator[AbstractFile] = + if file.isDirectory then file.iterator.flatMap(tastyFiles) + else if file.hasTastyExtension then Iterator.single(file) else Iterator.empty try - for file <- jar.allFileNames().map(f => new PlainFile(Path(f))) if file.hasTastyExtension do + for file <- tastyFiles(jar) do printTasty(s"$arg ${file.path}", file.toByteArray, isBestEffortTasty = false) finally jar.close() else @@ -214,7 +216,7 @@ class TastyPrinter(bytes: Array[Byte], isBestEffortTasty: Boolean, val testPickl sb.append(s" lines: ${lineSizes.length}\n") sb.append(s" line sizes:\n") val windowSize = 20 - for window <-posUnpickler.lineSizes.sliding(windowSize, windowSize) do + for window <- lineSizes.sliding(windowSize, windowSize) do sb.append(" ").append(window.mkString(", ")).append("\n") // sb.append(posUnpickler.lineSizes.mkString(" line sizes: ", ", ", "\n")) sb.append(" positions:\n") diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala index 63e6d28d73e9..a78d9c976000 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala @@ -3,8 +3,6 @@ package dotc package core package tasty -import scala.language.unsafeNulls - import dotty.tools.tasty.TastyFormat.* import dotty.tools.tasty.besteffort.BestEffortTastyFormat.ERRORtype import dotty.tools.tasty.TastyBuffer.* @@ -14,16 +12,12 @@ import ast.{untpd, tpd} import Contexts.*, Symbols.*, Types.*, Names.*, Constants.*, Decorators.*, Annotations.*, Flags.* import Comments.{Comment, docCtx} import NameKinds.* -import StdNames.{nme, tpnme} +import StdNames.nme import config.Config import config.Feature.sourceVersion import collection.mutable import reporting.{Profile, NoProfile} import dotty.tools.tasty.TastyFormat.ASTsSection -import quoted.QuotePatterns - -object TreePickler: - class StackSizeExceeded(val mdef: tpd.MemberDef) extends Exception class TreePickler(pickler: TastyPickler, attributes: Attributes) { val buf: TreeBuffer = new TreeBuffer @@ -31,7 +25,6 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) { import buf.* import pickler.nameBuffer.nameIndex import tpd.* - import TreePickler.* private val symRefs = Symbols.MutableSymbolMap[Addr](256) private val forwardSymRefs = Symbols.MutableSymbolMap[List[Addr]]() @@ -402,13 +395,7 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) { pickleTreeUnlessEmpty(rhs) pickleModifiers(sym, mdef) } - catch - case ex: Throwable => - if !ctx.settings.XnoEnrichErrorMessages.value - && handleRecursive.underlyingStackOverflowOrNull(ex) != null then - throw StackSizeExceeded(mdef) - else - throw ex + catch case t: Throwable => handleRecursive("tree pickling", mdef.show, t) if sym.is(Method) && sym.owner.isClass then profile.recordMethodSize(sym, (currentAddr.index - addr.index) max 1, mdef.span) for docCtx <- ctx.docCtx do @@ -471,7 +458,10 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) { writeByte(QUALTHIS) pickleTree(qual.withType(tref)) case _: ErrorType if ctx.isBestEffort => - pickleTree(qual) + if qual.hasType then + pickleTree(qual.asInstanceOf[Tree]) // it has a type, so it's a valid tpd.Tree + else + pickleErrorType() case _ => pickleCapturedThis case Select(qual, name) => name match { @@ -938,27 +928,24 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) { def pickleAnnotation(owner: Symbol, mdef: MemberDef, ann: Annotation)(using Context): Unit = if !isUnpicklable(owner, ann) then writeByte(ANNOTATION) - withLength { pickleType(ann.symbol.typeRef); pickleTree(ann.tree) } + val annotTree = ann match + case ann: CompactAnnotation => + if sourceVersion.enablesCompactAnnotation then ann.tree else ann.oldTree + case _ => + ann.tree + withLength { pickleType(ann.symbol.typeRef); pickleTree(annotTree) } var treeBuf = annotTrees.lookup(mdef) if treeBuf == null then treeBuf = new mutable.ListBuffer[Tree] annotTrees(mdef) = treeBuf - treeBuf += ann.tree + treeBuf += annotTree // ---- main entry points --------------------------------------- def pickle(trees: List[Tree])(using Context): Unit = { profile = Profile.current for tree <- trees do - try - if !tree.isEmpty then pickleTree(tree) - catch case ex: StackSizeExceeded => - report.error( - em"""Recursion limit exceeded while pickling ${ex.mdef} - |in ${ex.mdef.symbol.showLocated}. - |You could try to increase the stacksize using the -Xss JVM option. - |For the unprocessed stack trace, compile with -Xno-enrich-error-messages.""", - ex.mdef.srcPos) + if !tree.isEmpty then pickleTree(tree) def missing = forwardSymRefs.keysIterator .map(sym => i"${sym.showLocated} (line ${sym.srcPos.line}) #${sym.id}") diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala index 2b0585260a2b..232ed5c0b5b1 100644 --- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala +++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala @@ -3,8 +3,6 @@ package dotc package core package tasty -import scala.language.unsafeNulls - import Comments.docCtx import Contexts.* import Symbols.* @@ -33,6 +31,7 @@ import Trees.* import Decorators.* import config.Feature import quoted.QuotePatterns +import inlines.Inlines import dotty.tools.tasty.{TastyBuffer, TastyReader} import TastyBuffer.* @@ -96,7 +95,7 @@ class TreeUnpickler(reader: TastyReader, /** The root symbol denotation which are defined by the Tasty file associated with this * TreeUnpickler. Set by `enterTopLevel`. */ - private var roots: Set[SymDenotation] = null + private var roots: Set[SymDenotation] = uninitialized /** The root symbols that are defined in this Tasty file. This * is a subset of `roots.map(_.symbol)`. @@ -188,7 +187,7 @@ class TreeUnpickler(reader: TastyReader, if (tag >= firstLengthTreeTag) goto(readEnd()) else if (tag >= firstNatASTTreeTag) { readNat(); skipTree() } else if (tag >= firstASTTreeTag) skipTree() - else if (tag >= firstNatTreeTag) readNat() + else if (tag >= firstNatTreeTag) readLongInt() } def skipTree(): Unit = skipTree(readByte()) @@ -225,7 +224,7 @@ class TreeUnpickler(reader: TastyReader, if (mode == MemberDefsOnly) skipTree(tag) else if (tag >= firstLengthTreeTag) { val end = readEnd() - var nrefs = numRefs(tag) + val nrefs = numRefs(tag) if (nrefs < 0) { for (i <- nrefs until 0) scanTree(buf) goto(end) @@ -241,7 +240,7 @@ class TreeUnpickler(reader: TastyReader, } else if (tag >= firstNatASTTreeTag) { readNat(); scanTree(buf) } else if (tag >= firstASTTreeTag) scanTree(buf) - else if (tag >= firstNatTreeTag) readNat() + else if (tag >= firstNatTreeTag) readLongInt() } } @@ -798,7 +797,13 @@ class TreeUnpickler(reader: TastyReader, val tp = reader.readType() def readAnnotTree(rdr: TreeReader)(using Context) = if isCompactAnnotTypeTag(rdr.reader.nextByte) then TypeTree(rdr.readType()) - else rdr.readTree() + // Annotation trees may be inspected by macros via `annot.tree` and + // spliced into a macro expansion; the re-typer of that expansion + // requires every untyped tree to have a span (Typer.assertPositioned). + // For incremental compilation the enclosing unpickling does not use + // Mode.ReadPositions, so without this the deserialized annotation + // tree has no spans and the re-typer crashes (issue #21383). + else rdr.readTree()(using ctx.addMode(Mode.ReadPositions)) val lazyAnnotTree = reader.readLaterWithOwner(end, readAnnotTree(_)) owner => new DeferredSymAndTree(tp.typeSymbol, lazyAnnotTree(owner).complete): @@ -1167,10 +1172,29 @@ class TreeUnpickler(reader: TastyReader, .map(_.changeOwner(localDummy, constr.symbol))) else parents + val statsStart = currentAddr val lazyStats = readLater(end, rdr => { val stats = rdr.readIndexedStats(localDummy, end) tparams ++ vparams ++ stats }) + if cls.isInlineTrait then + cls.addAnnotation(LazyBodyAnnotation { (ctx0: Context) ?=> + val ctx1 = localContext(cls)(using ctx0).addMode(Mode.ReadPositions) + inContext(sourceChangeContext(Addr(0))(using ctx1)) { + // avoids space leaks by not capturing the current context + + // TODO: Sometimes the annotated source files are wrong when inlining macros + // into inline traits. This seems to fix it as we reload the correct source + // if not cached, but there ought to be a better way. + treeAtAddr.filterInPlace { (addr, _) => + addr.index < statsStart.index || addr.index >= end.index + } + val fork = forkAt(statsStart) + val stats = fork.readIndexedStats(localDummy, end) + val inlinedMembers = (tparams ++ vparams ++ stats).filter(member => Inlines.isInlineableFromInlineTrait(cls, member)) + Block(inlinedMembers, unitLiteral).withSpan(cls.span) + } + }) NamerOps.addConstructorProxies(cls) NamerOps.addContextBoundCompanions(cls) setSpan(start, @@ -1880,7 +1904,7 @@ class TreeUnpickler(reader: TastyReader, */ class OwnerTree(val addr: Addr, tag: Int, reader: TreeReader, val end: Addr) { - private var myChildren: List[OwnerTree] = null + private var myChildren: List[OwnerTree] | Null = null /** All definitions that have the definition at `addr` as closest enclosing definition */ def children: List[OwnerTree] = { @@ -1889,7 +1913,7 @@ class TreeUnpickler(reader: TastyReader, reader.scanTrees(buf, end, if (tag == TEMPLATE) NoMemberDefs else AllDefs) buf.toList } - myChildren + myChildren.nn } /** Find the owner of definition at `addr` */ @@ -1922,7 +1946,8 @@ class TreeUnpickler(reader: TastyReader, } override def toString: String = - s"OwnerTree(${addr.index}, ${end.index}, ${if (myChildren == null) "?" else myChildren.mkString(" ")})" + val children = myChildren + s"OwnerTree(${addr.index}, ${end.index}, ${if (children == null) "?" else children.mkString(" ")})" } } diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala index 5f5e56ce7ded..07bf41ed1f68 100644 --- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala +++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala @@ -3,8 +3,6 @@ package dotc package core package unpickleScala2 -import scala.language.unsafeNulls - import java.io.IOException import java.lang.Float.intBitsToFloat import java.lang.Double.longBitsToDouble @@ -226,7 +224,12 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas def source(using Context): AbstractFile = { val f = classRoot.symbol.associatedFile - if (f != null) f else moduleClassRoot.symbol.associatedFile + if (f != null) + f + else + val moduleF = moduleClassRoot.symbol.associatedFile + assert(moduleF != null, i"neither $classRoot nor $moduleClassRoot has an associated file") + moduleF } private def checkVersion(using Context): Unit = { @@ -444,11 +447,9 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas var flags = unpickleScalaFlags(readLongNat(), name.isTypeName) - if (name eq nme.getClass_) && defn.hasProblematicGetClass(owner.name) - // Scala 2 sometimes pickle the same type parameter symbol multiple times - // (see i11173 for an example), but we should only unpickle it once. - || tag == TYPEsym && flags.is(TypeParam) && symScope(owner).lookup(name.asTypeName).exists - then + // Scala 2 sometimes pickle the same type parameter symbol multiple times + // (see i11173 for an example), but we should only unpickle it once. + if tag == TYPEsym && flags.is(TypeParam) && symScope(owner).lookup(name.asTypeName).exists then // skip this member return NoSymbol @@ -686,7 +687,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas object localMemberUnpickler extends LocalUnpickler class ClassUnpickler(infoRef: Int) extends LocalUnpickler with TypeParamsCompleter { - private var myTypeParams: List[TypeSymbol] = null + private var myTypeParams: List[TypeSymbol] | Null = null private def readTypeParams()(using Context): Unit = { val tag = readByte() @@ -706,7 +707,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas /** Force reading type params early, we need them in setClassInfo of subclasses. */ def init()(using Context): List[TypeSymbol] = if !areParamsInitialized then loadTypeParams() - myTypeParams + myTypeParams.nn override def completerTypeParams(sym: Symbol)(using Context): List[TypeSymbol] = init() @@ -1101,27 +1102,22 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas val tag = readByte() val tpe = if (tag == EMPTYtree) NoType else readTypeRef() - // Set by the three functions to follow. If symbol is non-null - // after the new tree 't' has been created, t has its Symbol - // set to symbol; and it always has its Type set to tpe. - var symbol: Symbol = null - var mods: Modifiers = null - var name: Name = null - /** Read a Symbol, Modifiers, and a Name */ - def setSymModsName(): Unit = { - symbol = readSymbolRef() - mods = readModifiersRef(symbol.isType) - name = readNameRef() + def setSymModsName(): Symbol = { + val symbol = readSymbolRef() + readModifiersRef(symbol.isType) + readNameRef() + symbol } /** Read a Symbol and a Name */ - def setSymName(): Unit = { - symbol = readSymbolRef() - name = readNameRef() + def setSymName(): Symbol = { + val symbol = readSymbolRef() + readNameRef() + symbol } /** Read a Symbol */ - def setSym(): Unit = - symbol = readSymbolRef() + def setSym(): Symbol = + readSymbolRef() implicit val span: Span = NoSpan @@ -1136,7 +1132,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas PackageDef(pid, stats) case CLASStree => - setSymModsName() + val symbol = setSymModsName() val impl = readTemplateRef() val tparams = until(end, () => readTypeDefRef()) val cls = symbol.asClass @@ -1145,17 +1141,17 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas ClassDef(cls, constr, tparams ++ stats) case MODULEtree => - setSymModsName() + val symbol = setSymModsName() ModuleDef(symbol.asTerm, readTemplateRef().body) case VALDEFtree => - setSymModsName() + val symbol = setSymModsName() val tpt = readTreeRef() val rhs = readTreeRef() ValDef(symbol.asTerm, rhs) case DEFDEFtree => - setSymModsName() + val symbol = setSymModsName() val tparams = times(readNat(), () => readTypeDefRef()) val vparamss = times(readNat(), () => times(readNat(), () => readValDefRef())) val tpt = readTreeRef() @@ -1163,14 +1159,14 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas DefDef(symbol.asTerm, rhs) case TYPEDEFtree => - setSymModsName() + val symbol = setSymModsName() val rhs = readTreeRef() val tparams = until(end, () => readTypeDefRef()) TypeDef(symbol.asType) case LABELtree => ??? - setSymName() + val symbol = setSymName() val rhs = readTreeRef() val params = until(end, () => readIdentRef()) val ldef = DefDef(symbol.asTerm, rhs) @@ -1179,7 +1175,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas else Block(ldef :: Nil, Apply(Ident(symbol.termRef), Nil)) case IMPORTtree => - setSym() + val symbol = setSym() val expr = readTreeRef() val selectors = until(end, () => { val fromName = readNameRef() @@ -1191,7 +1187,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas Import(expr, selectors) case TEMPLATEtree => - setSym() + val symbol = setSym() val parents = times(readNat(), () => readTreeRef()) val self = readValDefRef() val body = until(end, () => readTreeRef()) @@ -1217,7 +1213,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas unimplementedTree("STAR") case BINDtree => - setSymName() + val symbol = setSymName() Bind(symbol.asTerm, readTreeRef()) case UNAPPLYtree => @@ -1232,7 +1228,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas // note can't deal with trees passed to Java methods as arrays here case FUNCTIONtree => - setSym() + val symbol = setSym() val body = readTreeRef() val vparams = until(end, () => readValDefRef()) val applyType = MethodType(vparams map (_.name), vparams map (_.tpt.tpe), body.tpe) @@ -1256,7 +1252,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas Match(selector, cases) case RETURNtree => - setSym() + val symbol = setSym() Return(readTreeRef(), Ident(symbol.termRef)) case TREtree => @@ -1305,17 +1301,17 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas Super(qual, mix) case THIStree => - setSym() + val symbol = setSym() val name = readTypeNameRef() This(symbol.asClass) case SELECTtree => - setSym() + val symbol = setSym() val qualifier = readTreeRef() val selector = readNameRef() qualifier.select(symbol.namedType) case IDENTtree => - setSymName() + val symbol = setSymName() Ident(symbol.namedType) case LITERALtree => @@ -1335,9 +1331,10 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas SingletonTypeTree(readTreeRef()) case SELECTFROMTYPEtree => + // !!! #25895 Dead code!? val qualifier = readTreeRef() val selector = readTypeNameRef() - Select(qualifier, symbol.namedType) + Select(qualifier, selector) case COMPOUNDTYPEtree => readTemplateRef() diff --git a/compiler/src/dotty/tools/dotc/fromtasty/Debug.scala b/compiler/src/dotty/tools/dotc/fromtasty/Debug.scala index 336d424e545d..a38b0fbf63ba 100644 --- a/compiler/src/dotty/tools/dotc/fromtasty/Debug.scala +++ b/compiler/src/dotty/tools/dotc/fromtasty/Debug.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package fromtasty -import scala.util.control.NonFatal - import dotty.tools.io.Directory import java.io.{File => JFile} @@ -11,11 +9,6 @@ import java.nio.file.{Files, Paths} object Debug { def main(args: Array[String]): Unit = { - // Preload scala.util.control.NonFatal. Otherwise, when trying to catch a StackOverflowError, - // we may try to load it but fail with another StackOverflowError and lose the original exception, - // see . - val _ = NonFatal - assert(!args.contains("-d")) val outPath = Paths.get("out") diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala index 4eee4884f954..14a5e01a870b 100644 --- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala +++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala @@ -119,9 +119,10 @@ object Inliner: oldOwners: List[Symbol], newOwners: List[Symbol], substFrom: List[Symbol], - substTo: List[Symbol])(using Context) + substTo: List[Symbol], + val inlineCopier: TreeCopier)(using Context) extends TreeTypeMap( - typeMap, treeMap, oldOwners, newOwners, substFrom, substTo, InlineCopier()): + typeMap, treeMap, oldOwners, newOwners, substFrom, substTo, inlineCopier): override def transform(tree: Tree)(using Context): Tree = tree match @@ -147,13 +148,15 @@ object Inliner: newOwners: List[Symbol], substFrom: List[Symbol], substTo: List[Symbol])(using Context) = - new InlinerMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo) + new InlinerMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo, inlineCopier) override def transformInlined(tree: Inlined)(using Context) = if tree.inlinedFromOuterScope then tree.expansion match case expansion: TypeTree => expansion - case _ => tree + // TODO: Check if this is a problem; previously tree. We do this because of Inlined(Inlined(EmptyTree, Select)) blocks conversion of the Select + // and this causes a problem when we have inline methods inlined into inline traits (e.g. summon in tests/run/specialized-trait-vector-dot-product.scala) + case _ => super.transformInlined(tree) else super.transformInlined(tree) end InlinerMap @@ -337,7 +340,7 @@ class Inliner(val call: tpd.Tree)(using Context): private def classNestingLevel(cls: Symbol) = cls.ownersIterator.count(_.isClass) // Compute val-definitions for all this-proxies and append them to `bindingsBuf` - private def computeThisBindings() = { + protected def computeThisBindings() = { // All needed this-proxies, paired-with and sorted-by nesting depth of // the classes they represent (innermost first) val sortedProxies = thisProxy.toList @@ -504,7 +507,7 @@ class Inliner(val call: tpd.Tree)(using Context): else arg else arg - private def canElideThis(tpe: ThisType): Boolean = + protected def canElideThis(tpe: ThisType): Boolean = inlineCallPrefix.tpe == tpe && ctx.owner.isContainedIn(tpe.cls) || tpe.cls.isContainedIn(inlinedMethod) || tpe.cls.is(Package) @@ -553,7 +556,6 @@ class Inliner(val call: tpd.Tree)(using Context): if thisTypeProxyExists then mapBackToOpaques.typeMap(thisTypeUnpacker.typeMap(inlined.expansion.tpe)) else inlined.tpe - /** Populate `thisProxy` and `paramProxy` as follows: * * 1a. If given type refers to a static this, thisProxy binds it to corresponding global reference, @@ -609,7 +611,7 @@ class Inliner(val call: tpd.Tree)(using Context): * from its `originalOwner`, and, if it comes from outside the inlined method * itself, it has to be marked as an inlined argument. */ - private def integrate(tree: Tree, originalOwner: Symbol)(using Context): Tree = + protected def integrate(tree: Tree, originalOwner: Symbol)(using Context): Tree = // assertAllPositioned(tree) // debug tree.changeOwner(originalOwner, ctx.owner) @@ -621,9 +623,73 @@ class Inliner(val call: tpd.Tree)(using Context): val reducer = new InlineReducer(this) - /** The Inlined node representing the inlined call */ - def inlined(rhsToInline: tpd.Tree): (List[MemberDef], Tree) = + protected class InlinerTypeMap extends DeepTypeMap { + override def stopAt = + if opaqueProxies.isEmpty then StopAt.Static else StopAt.Package + def apply(t: Type) = t match { + case t: ThisType => thisProxy.get(t.cls).getOrElse(t) + case t: TypeRef => paramProxy.getOrElse(t, mapOver(t)) + case t: SingletonType => + if t.termSymbol.isAllOf(InlineParam) then apply(t.widenTermRefExpr) + else paramProxy.getOrElse(t, mapOver(t)) + case t => mapOver(t) + } + } + + protected class InlinerTreeMap extends (Tree => Tree) { + def apply(tree: Tree) = tree match { + case tree: This => + tree.tpe match { + case thistpe: ThisType => + thisProxy.get(thistpe.cls) match { + case Some(t) => + val thisRef = ref(t).withSpan(call.span) + inlinedFromOutside(thisRef)(tree.span) + case None => tree + } + case _ => tree + } + case tree: Ident => + /* Span of the argument. Used when the argument is inlined directly without a binding */ + def argSpan = + if (tree.name == nme.WILDCARD) tree.span // From type match + else if (tree.symbol.isTypeParam && tree.symbol.owner.isClass) tree.span // TODO is this the correct span? + else paramSpan(tree.name) + val inlinedCtx = ctx.withSource(inlinedMethod.topLevelClass.source) + paramProxy.get(tree.tpe) match { + case Some(t) if tree.isTerm && t.isSingleton => + val inlinedSingleton = singleton(t).withSpan(argSpan) + inlinedFromOutside(inlinedSingleton)(tree.span) + case Some(t) if tree.isType => + inlinedFromOutside(new InferredTypeTree().withType(t).withSpan(argSpan))(tree.span) + case _ => tree + } + case tree @ Select(qual: This, name) if tree.symbol.is(Private) && tree.symbol.isInlineMethod => + // This inline method refers to another (private) inline method (see tests/pos/i14042.scala). + // We insert upcast to access the private inline method once inlined. This makes the selection + // keep the symbol when re-typechecking in the InlineTyper. The method is inlined and hence no + // reference to a private method is kept at runtime. + cpy.Select(tree)(qual.asInstance(qual.tpe.widen), name) + + case tree => tree + } + + private def inlinedFromOutside(tree: Tree)(span: Span): Tree = + Inlined(EmptyTree, Nil, tree)(using ctx.withSource(inlinedMethod.topLevelClass.source)).withSpan(span) + } + protected val inlinerTypeMap: InlinerTypeMap = InlinerTypeMap() + protected val inlinerTreeMap: InlinerTreeMap = InlinerTreeMap() + + protected def substFrom: List[Symbol] = Nil + protected def substTo: List[Symbol] = Nil + protected def inlineCopier: TreeCopier = InlineCopier() + + protected def inlineCtx(inlineTyper: InlineTyper)(using Context): Context = + inlineContext(Inlined(call, Nil, ref(defn.Predef_undefined))).fresh.setTyper(inlineTyper).setNewScope + + /** The Inlined node representing the inlined call */ + def inlined(rhsToInline: tpd.Tree)(using Context): (List[MemberDef], Tree) = inlining.println(i"-----------------------\nInlining $call\nWith RHS $rhsToInline") def paramTypess(call: Tree, acc: List[List[Type]]): List[List[Type]] = call match @@ -665,69 +731,26 @@ class Inliner(val call: tpd.Tree)(using Context): val inlineTyper = new InlineTyper(ctx.reporter.errorCount) - val inlineCtx = inlineContext(Inlined(call, Nil, ref(defn.Predef_undefined))).fresh.setTyper(inlineTyper).setNewScope - - def inlinedFromOutside(tree: Tree)(span: Span): Tree = - Inlined(EmptyTree, Nil, tree)(using ctx.withSource(inlinedMethod.topLevelClass.source)).withSpan(span) + val inlineCtx = this.inlineCtx(inlineTyper) // A tree type map to prepare the inlined body for typechecked. // The translation maps references to `this` and parameters to // corresponding arguments or proxies on the type and term level. It also changes // the owner from the inlined method to the current owner. - val inliner = new InlinerMap( - typeMap = - new DeepTypeMap { - override def stopAt = - if opaqueProxies.isEmpty then StopAt.Static else StopAt.Package - def apply(t: Type) = t match { - case t: ThisType => thisProxy.getOrElse(t.cls, t) - case t: TypeRef => paramProxy.getOrElse(t, mapOver(t)) - case t: SingletonType => - if t.termSymbol.isAllOf(InlineParam) then apply(t.widenTermRefExpr) - else paramProxy.getOrElse(t, mapOver(t)) - case t => mapOver(t) - } - }, - treeMap = { - case tree: This => - tree.tpe match { - case thistpe: ThisType => - thisProxy.get(thistpe.cls) match { - case Some(t) => - val thisRef = ref(t).withSpan(call.span) - inlinedFromOutside(thisRef)(tree.span) - case None => tree - } - case _ => tree - } - case tree: Ident => - /* Span of the argument. Used when the argument is inlined directly without a binding */ - def argSpan = - if (tree.name == nme.WILDCARD) tree.span // From type match - else if (tree.symbol.isTypeParam && tree.symbol.owner.isClass) tree.span // TODO is this the correct span? - else paramSpan(tree.name) - val inlinedCtx = ctx.withSource(inlinedMethod.topLevelClass.source) - paramProxy.get(tree.tpe) match { - case Some(t) if tree.isTerm && t.isSingleton => - val inlinedSingleton = singleton(t).withSpan(argSpan) - inlinedFromOutside(inlinedSingleton)(tree.span) - case Some(t) if tree.isType => - inlinedFromOutside(new InferredTypeTree().withType(t).withSpan(argSpan))(tree.span) - case _ => tree - } - case tree @ Select(qual: This, name) if tree.symbol.is(Private) && tree.symbol.isInlineMethod => - // This inline method refers to another (private) inline method (see tests/pos/i14042.scala). - // We insert upcast to access the private inline method once inlined. This makes the selection - // keep the symbol when re-typechecking in the InlineTyper. The method is inlined and hence no - // reference to a private method is kept at runtime. - cpy.Select(tree)(qual.asInstance(qual.tpe.widen), name) - case tree => tree - }, - oldOwners = inlinedMethod :: Nil, - newOwners = ctx.owner :: Nil, - substFrom = Nil, - substTo = Nil + // TODO: This gets around the fact that inline traits doesn't define inlinedMethod correctly but maybe there is a better + // way. + val oldOwners = if (inlinedMethod.exists) then inlinedMethod :: Nil else Nil + val newOwners = if (inlinedMethod.exists) then ctx.owner :: Nil else Nil + + val inliner = new InlinerMap( + typeMap = inlinerTypeMap, + treeMap = inlinerTreeMap, + oldOwners = oldOwners, + newOwners = newOwners, + substFrom = substFrom, + substTo = substTo, + inlineCopier = inlineCopier )(using inlineCtx) inlining.println( @@ -808,7 +831,6 @@ class Inliner(val call: tpd.Tree)(using Context): if (inlinedMethod == defn.Compiletime_error) issueError() addInlinedTrees(treeSize(finalExpansion)) - (finalBindings, finalExpansion) } end inlined diff --git a/compiler/src/dotty/tools/dotc/inlines/Inlines.scala b/compiler/src/dotty/tools/dotc/inlines/Inlines.scala index 31ba3733332c..1c82897d5d5b 100644 --- a/compiler/src/dotty/tools/dotc/inlines/Inlines.scala +++ b/compiler/src/dotty/tools/dotc/inlines/Inlines.scala @@ -3,8 +3,9 @@ package dotc package inlines import ast.*, core.* -import Flags.*, Symbols.*, Types.*, Decorators.*, Constants.*, Contexts.* -import StdNames.{tpnme, nme} +import Flags.*, Symbols.*, Types.*, Decorators.*, Constants.*, Contexts.*, TypeOps.* +import Names.Name +import StdNames.{str, tpnme, nme} import NameOps.* import typer.* import NameKinds.BodyRetainerName @@ -22,9 +23,18 @@ import cc.CleanupRetains import collection.mutable import reporting.{NotConstant, trace} -import util.Spans.Span +import util.Spans.{Span, spanCoord} import dotty.tools.dotc.core.Periods.PhaseId import dotty.tools.dotc.util.chaining.* +import NameOps.expandedName +import dotty.tools.dotc.core.Annotations.ConcreteBodyAnnotation +import dotty.tools.dotc.core.Annotations.LazyBodyAnnotation +import dotty.tools.dotc.core.Scopes.EmptyScope +import dotty.tools.dotc.core.Scopes.MutableScope +import dotty.tools.dotc.reporting.OverrideError +import dotty.tools.dotc.typer.RefChecks.OverridingPairsChecker +import dotty.tools.dotc.typer.ErrorReporting.err +import dotty.tools.dotc.core.NameKinds.DefaultGetterName /** Support for querying inlineable methods and for inlining calls to such methods */ object Inlines: @@ -38,7 +48,7 @@ object Inlines: /** `sym` is an inline method with a known body to inline. */ def hasBodyToInline(sym: SymDenotation)(using Context): Boolean = - sym.isInlineMethod && sym.hasAnnotation(defn.BodyAnnot) + (sym.isInlineMethod || sym.isInlineTrait) && sym.hasAnnotation(defn.BodyAnnot) /** The body to inline for method `sym`, or `EmptyTree` if none exists. * @pre hasBodyToInline(sym) @@ -54,39 +64,92 @@ object Inlines: else EmptyTree + def defsToInline(traitSym: SymDenotation)(using Context): List[Tree] = + bodyToInline(traitSym) match + case Block(defs, _) if traitSym.isInlineTrait => defs + case _ => Nil + /** Are we in an inline method body? */ def inInlineMethod(using Context): Boolean = ctx.owner.ownersIterator.exists(_.isInlineMethod) + def inInlineContext(using Context): Boolean = + ctx.owner.ownersIterator.exists(sym => sym.isInlineMethod || sym.isInlineTrait) + /** Can a call to method `meth` be inlined? */ def isInlineable(meth: Symbol)(using Context): Boolean = - meth.is(Inline) && meth.hasAnnotation(defn.BodyAnnot) && !inInlineMethod + meth.isInlineMethod && meth.hasAnnotation(defn.BodyAnnot) && !inInlineMethod + + def isInlineableFromInlineTrait(inlinedTraitSym: ClassSymbol, member: tpd.Tree)(using Context): Boolean = + !(member.isInstanceOf[tpd.TypeDef] && inlinedTraitSym.typeParams.contains(member.symbol)) + && !member.symbol.isAllOf(Inline) + // && !member.symbol.is(Deferred) // Also inline interfaces (see specialized-trait-collections-example.scala) /** Should call be inlined in this context? */ - def needsInlining(tree: Tree)(using Context): Boolean = tree match { - case Block(_, expr) => needsInlining(expr) - case _ => - def isUnapplyExpressionWithDummy: Boolean = - // The first step of typing an `unapply` consists in typing the call - // with a dummy argument (see Applications.typedUnApply). We delay the - // inlining of this call. - def rec(tree: Tree): Boolean = tree match - case Apply(_, ProtoTypes.dummyTreeOfType(_) :: Nil) => true - case Apply(fn, _) => rec(fn) - case _ => false - tree.symbol.name.isUnapplyName && rec(tree) - - isInlineable(tree.symbol) - && !tree.tpe.widenTermRefExpr.isInstanceOf[MethodOrPoly] - && StagingLevel.level == 0 + def needsInlining(tree: Tree)(using Context): Boolean = + def isInlineableInCtx = + StagingLevel.level == 0 && ( ctx.phase == Phases.inliningPhase || (ctx.phase == Phases.typerPhase && needsTransparentInlining(tree)) + || (ctx.phase == Phases.specializeInlineTraitsPhase && !tree.symbol.is(Macro) && !(tree.symbol.isSpecializedTraitImplementationClass || tree.symbol.isSpecializedTraitInterface)) + || (ctx.phase == Phases.desugarSpecializedTraitsPhase && !tree.symbol.is(Macro) && (tree.symbol.isSpecializedTraitImplementationClass || tree.symbol.isSpecializedTraitInterface) ) ) && !ctx.typer.hasInliningErrors && !ctx.base.stopInlining - && !ctx.mode.is(Mode.NoInline) - && !isUnapplyExpressionWithDummy + // && !ctx.owner.ownersIterator.exists(_.isInlineTrait) + + tree match + case Block(_, expr) => + needsInlining(expr) + case tdef @ TypeDef(_, impl: Template) => + // !tdef.symbol.isInlineTrait && + impl.parents.map(symbolFromParent).exists(sym => sym.isInlineTrait) && isInlineableInCtx + case _ => + def isUnapplyExpressionWithDummy: Boolean = + // The first step of typing an `unapply` consists in typing the call + // with a dummy argument (see Applications.typedUnApply). We delay the + // inlining of this call. + def rec(tree: Tree): Boolean = tree match + case Apply(_, ProtoTypes.dummyTreeOfType(_) :: Nil) => true + case Apply(fn, _) => rec(fn) + case _ => false + tree.symbol.name.isUnapplyName && rec(tree) + isInlineable(tree.symbol) && !tree.tpe.widenTermRefExpr.isInstanceOf[MethodOrPoly] && isInlineableInCtx && !ctx.mode.is(Mode.NoInline) && !isUnapplyExpressionWithDummy + + private[dotc] def symbolFromParent(parent: Tree)(using Context): Symbol = + if parent.symbol.isConstructor then parent.symbol.owner else parent.tpe.typeSymbol + + // Inline trait ancestors in linearization order. + private def inlineTraitAncestors(cls: TypeDef)(using Context): List[Tree] = cls match { + case tpd.TypeDef(_, tmpl: Template) => + val parentTrees: Map[Symbol, Tree] = tmpl.parents.map(par => symbolFromParent(par) -> par).toMap.filter(_._1.isInlineTrait) + val ancestors: List[ClassSymbol] = cls.tpe.baseClasses.filter(sym => sym != cls.symbol && sym.isInlineTrait // && // TODO: Do we not need to stop if there is a non-inline trait somewhere in the hierarchy? It should block the inlining right? + && !(cls.symbol.asClass.ownersIterator.toList.tail.exists(p => p.isInlineTrait)) // We can skip anything that would be inlined nested into an inline trait because it must be pruned out later + ) + ancestors.flatMap(ancestor => + def baseTree = + cls.tpe.baseType(ancestor) match + case AppliedType(tycon, targs) => + Some(AppliedTypeTree(TypeTree(tycon), targs.map(TypeTree(_)))) + case tref: TypeRef => + Some(Ident(tref)) + case baseTpe => + report.error(s"unknown base type ${baseTpe.show} for ancestor ${ancestor.show} of ${cls.symbol.show}") + None + parentTrees.get(ancestor).orElse(baseTree.map(_.withSpan(cls.span))) + ).flatMap { tree => + tree.tpe match { + case Specialization(spec) if spec.hasSpecializedParams && !spec.isFullySpecialized => None // these can only exist in cases where we don't want to inline because: + // 1) they will be pruned out later anyway and if we inline them we will create a loop (as in tests/pos/specialized-trait-inlining-causes-implementation-required-loop-bad.scala) + // 2) they are covered by another specialized type parameter in inlining and therefore we will specialize later when the inline function is called + // tests/run/specialized-trait-inline-specialized-instance-with-specialization + // 3) we already dealt with them in desugarSpecializedTraits + case other => Some(tree) + } + } + case _ => + Nil } private def needsTransparentInlining(tree: Tree)(using Context): Boolean = @@ -205,6 +268,141 @@ object Inlines: tree2 end inlineCall + private def updateFlagsFromInlinedParent(child: FlagSet, parent: FlagSet): FlagSet = + var updatedFlags = child + // Parent needs to be initialised so child must also as initialisers have been inlined + if (!parent.is(NoInits)) + updatedFlags &~= NoInits + + // Parent is impure; contaminates child as non-abstract methods have been inlined + if (!parent.is(PureInterface)) + updatedFlags &~= PureInterface + updatedFlags + + + private def checkInnerClasses(tmpl: Template)(using Context) = + tmpl.body.foreach { + case innerClass: TypeDef if innerClass.symbol.isClass => report.error("Inline traits may not define inner classes or traits.", innerClass.srcPos) + case _ => + } + + def checkAndTransformInlineTrait(inlineTrait: TypeDef)(using Context): TypeDef = + val tpd.TypeDef(_, tmpl: Template) = inlineTrait: @unchecked + checkInnerClasses(tmpl) + val body1 = tmpl.body.flatMap { + /* case innerClass: TypeDef if innerClass.symbol.isClass => + val newTrait = makeTraitFromInnerClass(innerClass) + val newType = makeTypeFromInnerClass(inlineTrait.symbol, innerClass, newTrait.symbol) + List(newTrait, newType) */ + case member: MemberDef => + List(member) + case _ => + // Remove non-memberdefs, as they are normally placed into $init() + Nil + } + val tmpl1 = cpy.Template(tmpl)(body = body1) + cpy.TypeDef(inlineTrait)(rhs = tmpl1) + end checkAndTransformInlineTrait + + + private def checkInlineTraitOverrides(clsSym: ClassSymbol)(using Context) = + /* We need to enforce `override` modifier constraints + here to ensure that the behaviour is the same as ordinary traits. The usual checks only apply + in refChecks which is too late for us. */ + + // TODO: This does cause some code duplication + def checkInlineTraitOverride(member: Symbol, other: Symbol) = + if !member.is(Override) && !other.is(Deferred) && member.owner == clsSym then + report.error( + OverrideError("needs `override` modifier", + other.info, + member, + other, + NoType, + NoType), + member.srcPos + ) + else if member.owner != clsSym && other.owner != clsSym + && !other.owner.derivesFrom(member.owner) + && !(member.isAnyOverride || member.hasAnnotation(defn.UncheckedOverrideAnnot)) + && (!other.is(Deferred) || other.isAllOf(Given | HasDefault)) + && !member.is(Deferred) + && !other.name.is(DefaultGetterName) then + + report.error( + OverrideError( + s"${clsSym} inherits conflicting members:\n " + + err.infoString(other, clsSym.asClass.thisType, showLocation = true) + " and\n " + + err.infoString(member, clsSym.thisType, showLocation = true) + + "\n(Note: this can be resolved by declaring an override in " + clsSym + ".)", + other.info, + member, + other, + NoType, + NoType) + , + clsSym.srcPos + ) + OverridingPairsChecker(clsSym, clsSym.thisType).checkAll(checkInlineTraitOverride) + + def inlineParentInlineTraits(cls: Tree)(using Context): Tree = + cls match { + case cls @ tpd.TypeDef(_, impl: Template) => + checkInlineTraitOverrides(cls.symbol.asClass) + val clsOverriddenSyms = cls.symbol.info.decls.toList.flatMap(_.allOverriddenSymbols).toSet + val ancestors = inlineTraitAncestors(cls) + if cls.symbol.isAnonymousClass && ancestors.exists(tree => Specialization.unapply(tree.tpe).exists(anc => anc.isSpecialized || anc.isFullySpecializedToTopClassesOrNothing)) then + cls // No need to inline into specialized trait anonymous class instances; these will later be replaced by $impl$ classes. + else + val cycleFound = ancestors.exists { parent => + val parentSym = symbolFromParent(parent) + val errorPos = if cls.symbol.ownersIterator.contains(parentSym) then Some(cls.srcPos) // Trying to inline into the tree which defines parentSym (need to catch this separately + // as need to catch it before we inline the second time to avoid tripping an assertion) + else if ctx.inlineTraitState.inlineOrigins(cls.symbol).contains(parentSym) then + val userPos = tpd.enclosingInlineds.last.srcPos // Select the user code that caused this error so we get two errors if there are two problematic inlines, not one + Some(userPos) // Trying to inline into the inlined body of parentSym not in the defn tree + else None // Fine + + errorPos.foreach(pos => + report.error(s"Inlining of inline traits looped. Tried to inline ${parentSym} into its own body.", pos) + ) + errorPos.nonEmpty + } + + if cycleFound then cls + else { + val newDefs = inContext(ctx.withOwner(cls.symbol)) { + ancestors.foldLeft((List.empty[Tree], impl.body)){ + case ((inlineDefs, childDefs), parent) => + val parentTraitInliner = InlineParentTrait(parent) + // Inline body + val overriddenSymbols = clsOverriddenSyms ++ inlineDefs.flatMap(_.symbol.allOverriddenSymbols) + // Need to put the new defs first because we process in linearization order to make overridees correct, + // but we want parent definitions to come first so that if child inline traits refer to values defined in a parent + // inline trait these are defined. + val inlinedDefs1 = parentTraitInliner.expandDefs(overriddenSymbols) ::: inlineDefs + cls.symbol.flags = updateFlagsFromInlinedParent(cls.symbol.flags, parent.symbol.flags) + + val childDefs1 = parentTraitInliner.adaptSuperCalls(childDefs) + (parentTraitInliner.adaptSuperCalls(inlinedDefs1), childDefs1) + } + } + + val newbody = newDefs._1 ::: newDefs._2 + val paramAccessors = newbody.filter(_.symbol.is(ParamAccessor)) + + for pacc <- paramAccessors + otherstat <- newbody if !otherstat.symbol.is(ParamAccessor) && otherstat.denot.matches(pacc.denot.asSingleDenotation) + do report.error(s"Inlining of inline trait created name conflict on ${pacc.denot.name}. Constructor parameters of inline receivers may not collide with members of inline traits.", pacc.srcPos) + + val impl1 = cpy.Template(impl)(body = newbody) + + cpy.TypeDef(cls)(rhs = impl1) + } + case _ => + cls + } + /** Try to inline a pattern with an inline unapply method. Fail with error if the maximal * inline depth is exceeded. * @@ -460,7 +658,7 @@ object Inlines: } private def packError(kind: ErrorKind, error: Error)(using Context): Tree = - def lit(x: Any) = Literal(Constant(x)) + def lit[T](x: T)(using Constant.ValueToConstant[T]) = Literal(Constant.fromValue(x)) val constructor: Tree = ref(defn.CompiletimeTesting_Error_apply) val parserErrorKind: Tree = ref(defn.CompiletimeTesting_ErrorKind_Parser) val typerErrorKind: Tree = ref(defn.CompiletimeTesting_ErrorKind_Typer) @@ -647,4 +845,329 @@ object Inlines: inlined end expand end InlineCall + + private class InlineParentTrait(parent: tpd.Tree)(using Context) extends Inliner(parent): + import tpd._ + import Inlines.* + + private val parentSym = symbolFromParent(parent) + private val paramAccessorsMapper = ParamAccessorsMapper() + + private val child = ctx.owner + private val childThisType = ctx.owner.thisType + private val childThisTree = This(ctx.owner.asClass).withSpan(parent.span) + + def inlinedSelfType = + inlinerTypeMap(parentSym.asClass.classDenot.givenSelfType) + + def expandDefs(overriddenDecls: Set[Symbol]): List[Tree] = + paramAccessorsMapper.registerParamValuesOf(parent) + val stats = Inlines.defsToInline(parentSym).filterNot(stat => overriddenDecls.contains(stat.symbol) && stat.symbol.is(Deferred)) + + val stats1 = stats.map{ // Private symbols must be entered before the RHSs are inlined + case member: MemberDef => Left((member, inlinedSym(member.symbol, overriddenDecls))) + case stat => Right(stat) + } + ctx.owner.info = ctx.owner.asClass.classInfo.integrateOpaqueMembers + stats1.map{ + case Left((tree, inlinedSym)) => expandStat(tree, inlinedSym) + case Right(tree) => inlinedRhs(tree) + } + end expandDefs + + def adaptSuperCalls(defs: List[Tree]) = + val ttmap = TreeTypeMap(treeMap = { + // We go through all ancestor inline traits so eventually we will find the one with matching parentSym + case sel@Select(Super(qual, mix), name) if sel.symbol.owner == parentSym => + // At that point either the method is overridden so needs mangling (and we just copied and mangled it in this inlining phase), + // or not, in which case call directly by original name. In both cases we are calling the method resulting from inlining, on the + // inline receiver class. + Select(This(ctx.owner.asClass), paramAccessorsMapper.getParamAccessorName(sel.symbol.owner, name).getOrElse(name)) + case tree => tree + }) + defs.map(ttmap(_)) + + protected class InlineTraitTypeMap extends InlinerTypeMap { + override def apply(t: Type) = super.apply(t) match { + case t: ThisType if t.cls == parentSym => childThisType + case t => mapOver(t) + } + } + + protected class InlineTraitTreeMap extends InlinerTreeMap { + override def apply(tree: Tree) = super.apply(tree) match { + case tree: This if tree.symbol == parentSym => + Inlined(EmptyTree, Nil, childThisTree).withSpan(parent.span) + case tree: This => + tree.tpe match { + case thisTpe: ThisType if thisTpe.cls.isInlineTrait => + integrate(This(ctx.owner.asClass).withSpan(parent.span), thisTpe.cls) + case _ => + tree + } + case sel@Select(Super(qual, mix), name) => + if sel.symbol.owner.isInlineTrait then // We need to leave this intact so that adaptSuperCalls can redirect it later + sel + else + report.error("Inline traits may not contain superclass references to classes or non-inline traits.", sel.srcPos) + sel + case sel@Select(qual, name) => + inContext(ctx.withSource(tree.source)) { // Need to ensure we preserve the fact that this Select was inlined + // potentially from a different file. Recreating it discards that info. + // See: inline-trait-multiple-stages-generic-defs. + paramAccessorsMapper.getParamAccessorName(qual.symbol, name) match { + case Some(newName) => Select(this(qual), newName).withSpan(parent.span) + case None => Select(this(qual), name) + } + } + case ident: Ident if ident.isType => + // A type parameter of the inline trait written as an identifier in source (e.g. the `S` + // in `new C[S] {}` if nested inside an inline trait) is not handled by the usual inlining machinery + // because S is not a method type parameter. We have our own way of handling this in types + // in the type map but need to also map the tree reference. + // See tests/pos/specialized-trait-inlining-causes-implementation-required-loop-bad.scala. + val mapped = inlinerTypeMap(ident.tpe) + if mapped ne ident.tpe then TypeTree(mapped).withSpan(ident.span) + else ident + case tree => + tree + } + } + + override protected val inlinerTypeMap: InlinerTypeMap = InlineTraitTypeMap() + override protected val inlinerTreeMap: InlinerTreeMap = InlineTraitTreeMap() + + override protected def inlineCopier: tpd.TreeCopier = new TypedTreeCopier() { + // FIXME it feels weird... Is this correct? + override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): Apply = + untpd.cpy.Apply(tree)(fun, args).withTypeUnchecked(tree.tpe) + } + + override protected def computeThisBindings(): Unit = () + override protected def canElideThis(tpe: ThisType): Boolean = true + + override protected def inlineCtx(inlineTyper: InlineTyper)(using Context): Context = + ctx.fresh.setTyper(inlineTyper).setNewScope + + extension (sym: Symbol) + private def isTermParamAccessor: Boolean = !sym.isType && sym.is(ParamAccessor) + + private def expandStat(stat: tpd.Tree, inlinedSym: Symbol)(using Context): tpd.Tree = stat match + case stat: ValDef => + inlinedValDef(stat, inlinedSym) + case stat: DefDef => + inlinedDefDef(stat, inlinedSym) + case stat @ TypeDef(_, _: Template) => EmptyTree + /* inlinedClassDef(stat, inlinedSym.asClass) */ // Inner classes are not allowed for now. + case stat: TypeDef => + inlinedTypeDef(stat, inlinedSym) + + private def inlinedSym(sym: Symbol, overriddenDecls: Set[Symbol], withoutFlags: FlagSet = EmptyFlags)(using Context): Symbol = + val newSym = if sym.isClass then inlinedClassSym(sym.asClass, withoutFlags) else inlinedMemberSym(sym, overriddenDecls, withoutFlags) + newSym + + private def inlinedClassSym(sym: ClassSymbol, withoutFlags: FlagSet = EmptyFlags)(using Context): ClassSymbol = + sym.info match { + case clsInfo: ClassInfo => + val typeParams: List[Type] = sym.primaryConstructor.info match { + case poly: PolyType => poly.paramRefs + case _ => Nil + } + // Extend inner class from inline trait to preserve typing + val newParent = ctx.owner.thisType.select(sym).appliedTo(typeParams) + val inlinedSym = newClassSymbol( + ctx.owner, + sym.name, + (sym.flags | Synthetic) &~ withoutFlags, + newCls => { + val ClassInfo(prefix, _, parents, _, selfInfo) = inlinerTypeMap.mapClassInfo(clsInfo) + ClassInfo(prefix, newCls, parents :+ newParent, Scopes.newScope, selfInfo) // TODO fix selfInfo (what to use?) + }, + sym.privateWithin, + spanCoord(parent.span) + ) + inlinedSym.entered + case _ => + report.error(s"Class symbol ${sym.show} does not have class info") + sym + } + + private def inlinedMemberSym(sym: Symbol, overriddenDecls: Set[Symbol], withoutFlags: FlagSet = EmptyFlags)(using Context): Symbol = + var name = sym.name + var flags = sym.flags | Synthetic + if sym.isTermParamAccessor then flags &~= ParamAccessor + if sym.is(Local) || (overriddenDecls.contains(sym)) then + name = paramAccessorsMapper.registerNewName(sym) + flags |= (Private | Local) + flags &~= Override // private override is illegal; if the inlined method was already override then we might make it private override by accident. + else + flags |= Override + sym.copy( + owner = ctx.owner, + name = name, + flags = flags &~ withoutFlags, + info = inlinerTypeMap(sym.info), + coord = spanCoord(parent.span)).entered + + private def inlinedValDef(vdef: ValDef, inlinedSym: Symbol)(using Context): ValDef = + val rhs = + paramAccessorsMapper + .getParamAccessorRhs(vdef.symbol.owner, vdef.symbol.name) + .getOrElse(inlinedRhs(vdef, inlinedSym)) + + val rhs1 = rhs.changeNonLocalOwners(inlinedSym) // if rhs.symbol.exists then rhs.changeOwner(rhs.symbol.owner, inlinedSym) else rhs + + tpd.ValDef(inlinedSym.asTerm, rhs1).withSpan(parent.span) + + private def inlinedDefDef(ddef: DefDef, inlinedSym: Symbol)(using Context): DefDef = + val rhsFun: List[List[Tree]] => Tree = + if ddef.symbol.isSetter then + _ => unitLiteral + else + paramss => + val oldParamSyms = ddef.paramss.flatten.map(_.symbol) + val newParamSyms = paramss.flatten.map(_.symbol) + val ddef1 = cpy.DefDef(ddef)(rhs = ddef.rhs.subst(oldParamSyms, newParamSyms)) + inlinedRhs(ddef1, inlinedSym) + tpd.DefDef(inlinedSym.asTerm, rhsFun).withSpan(parent.span) + + /* + private def inlinedPrimaryConstructorDefDef(ddef: DefDef)(using Context): DefDef = + // TODO check if symbol must be copied + val inlinedSym = inlinedMemberSym(ddef.symbol, withoutFlags = Override) + val constr = inlinedDefDef(ddef, inlinedSym) + cpy.DefDef(constr)(tpt = TypeTree(defn.UnitType), rhs = EmptyTree) + */ + /* + private def inlinedClassDef(clsDef: TypeDef, inlinedCls: ClassSymbol)(using Context): Tree = + val TypeDef(_, tmpl: Template) = clsDef: @unchecked + val (constr, body) = inContext(ctx.withOwner(inlinedCls)) { + val inlinedConstr = inlinedPrimaryConstructorDefDef(tmpl.constr) + val inlinedTmpl = tmpl.body.map { + case stat: TypeDef if stat.symbol.isAllOf(PrivateLocal | Param) => + expandStat(stat, inlinedSym(stat.symbol, withoutFlags = Override)) + case stat => + expandStat(stat, inlinedSym(stat.symbol)) + } + (inlinedConstr, inlinedTmpl) + } + val clsDef1 = tpd.ClassDefWithParents(inlinedCls, constr, tmpl.parents, body) // TODO add correct parent tree + inlined(clsDef1)._2.withSpan(clsDef.span) + */ + + private def inlinedTypeDef(tdef: TypeDef, inlinedSym: Symbol)(using Context): TypeDef = + if inlinedSym.isOpaqueAlias then + val inlinedRhsType = inlinerTypeMap(tdef.rhs.tpe) + inlinedSym.info = inlinedSym.opaqueToBounds(TypeAlias(inlinedRhsType), tdef.rhs, List()) + inlinedSym.typeRef.recomputeDenot() + ctx.typeAssigner.assignType(untpd.TypeDef(inlinedSym.name.asTypeName, TypeTree(inlinedRhsType)), inlinedSym).withSpan(parent.span) + else + tpd.TypeDef(inlinedSym.asType).withSpan(parent.span) + + + private def inlinedRhs(vddef: ValOrDefDef, inlinedSym: Symbol)(using Context): Tree = + val rhs = vddef.rhs.changeOwner(vddef.symbol, inlinedSym) + inlinedRhs(rhs)(using ctx.withOwner(inlinedSym)) + + private def inlinedRhs(rhs: Tree)(using Context): Tree = + if rhs.isEmpty then + rhs + else + val symbolMap = mutable.Map[Symbol, Symbol]() + // TODO make version of inlined that does not return bindings? + val rhs1 = Inlined(tpd.ref(parentSym).withSpan(parent.span), Nil, inlined(rhs)._2.withSpan(parent.span).cloneIn(parentSym.source)).withSpan(parent.span) // TODO: This inlines also calls to inline defs that were made in the inline trait body, is that desirable? + + // In case of nested inline trait inlines, because BodyAnnotation is out of date, + // body inlined misses nested expansion, but we have the symbols for the items that should be there + // Remove them so that they can be inlined prperly later. + val ttmap = TreeTypeMap(treeMap = { + case tree@TypeDef(name, tmpl: Template) if Inlines.needsInlining(tree) => + val newSym = tree.symbol.copy(coord = spanCoord(tree.span)) // Coord should correspond to original location because we will inline from there. + newSym.info = ClassInfo(tree.symbol.owner.thisType, newSym.asClass, tree.symbol.asClass.parentTypes, Scopes.newScope) + + val newConstructorSymbol = tree.symbol.primaryConstructor.copy(owner = newSym) + val rt = newSym.typeRef.appliedTo(newSym.typeParams.map(_.typeRef)) + def resultType(tpe: Type): Type = tpe match { + case mt @ MethodType(paramNames) => mt.derivedLambdaType(paramNames, mt.paramInfos, rt) + case pt : PolyType => pt.derivedLambdaType(pt.paramNames, pt.paramInfos, resultType(pt.resType)) + } + newConstructorSymbol.info = resultType(newConstructorSymbol.info) + newConstructorSymbol.info = PolyType.fromParams(newConstructorSymbol.owner.typeParams, newConstructorSymbol.info) + + symbolMap(tree.symbol.primaryConstructor) = newConstructorSymbol + + val childSyms = tree.symbol.info.decls + .filter(sym => tmpl.body.exists(vddef => vddef.symbol == sym)) + .tapEach(sym => symbolMap(sym) = sym.copy(owner = newSym, coord=sym.coord)) + .map(symbolMap) + + childSyms.foreach(p => p.entered) + newConstructorSymbol.entered + + val tmpl1 = tmpl.changeOwner(tree.symbol, newSym) + + val rhsFun: List[List[Tree]] => Tree = + paramss => + val oldParamSyms = tmpl1.constr.paramss.flatten.map(_.symbol) + val newParamSyms = paramss.flatten.map(_.symbol) + tmpl1.constr.rhs.subst(oldParamSyms, newParamSyms) + + val ctor = tpd.DefDef(newConstructorSymbol.asTerm, rhsFun) + symbolMap(tree.symbol) = newSym + + ctx.inlineTraitState.registerInlineOrigin(newSym, child, parentSym) + + tpd.ClassDefWithParents(newSym.asClass, ctor, tmpl1.parents, tmpl1.body) + case tree => tree + }) + + val rhs2 = ttmap(rhs1) + TreeTypeMap(substFrom = symbolMap.keys.toList, + substTo = symbolMap.values.toList, + oldOwners = symbolMap.keys.toList, + newOwners = symbolMap.values.toList)(rhs2) + + private class ParamAccessorsMapper: + private val paramAccessorsTrees: mutable.Map[Symbol, Map[Name, Tree]] = mutable.Map.empty + private val paramAccessorsNewNames: mutable.Map[(Symbol, Name), Name] = mutable.Map.empty + + def registerParamValuesOf(parent: Tree): Unit = + def allArgs(tree: Tree, acc: Vector[List[Tree]]): List[List[Tree]] = tree match + case Apply(fun, args) => allArgs(fun, acc :+ args) + case TypeApply(fun, _) => allArgs(fun, acc) + case _ => acc.toList + def allParams(info: Type, acc: List[List[Name]]): List[List[Name]] = info match + case mt: MethodType => allParams(mt.resultType, mt.paramNames :: acc) + case pt: PolyType => allParams(pt.resultType, acc) + case _ => acc + val info = + if parent.symbol.isClass then parent.symbol.primaryConstructor.info + else parent.symbol.info + val paramAccessors = allParams(info, Nil).flatten.zip(allArgs(parent, Vector.empty).flatten).toMap + paramAccessorsTrees.put(symbolFromParent(parent), paramAccessors) + + def registerNewName(paramAccessorSym: Symbol): paramAccessorSym.ThisName = + val oldName = paramAccessorSym.name + val newName = oldName.expandedName(parentSym) + paramAccessorsNewNames.put((paramAccessorSym.owner, oldName), newName) + newName + + def getParamAccessorRhs(parent: Symbol, paramAccessorName: Name): Option[Tree] = + paramAccessorsTrees.get(parent).flatMap(_.get(paramAccessorName)) + + def getParamAccessorName(parent: Symbol, paramAccessorName: Name): Option[Name] = + paramAccessorsNewNames.get(parent, paramAccessorName) + end ParamAccessorsMapper + end InlineParentTrait + + class InlineTraitState: + // For a class symbol created during inlining of an inline trait, + // the chain of inlined traits which produced it. We don't actually care about the order. + // Used as a "seen list" for cycle checking. Persists across invocations of InlineParentTrait + val inlineOrigins = mutable.HashMap[Symbol, Set[Symbol]]().withDefaultValue(Set.empty) + + def registerInlineOrigin(newSym: Symbol, owner: Symbol, parentSym: Symbol): Unit = + inlineOrigins(newSym) = inlineOrigins(owner) + parentSym + end InlineTraitState + end Inlines diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala index 8d7d0fe79cab..4d5f5594b500 100644 --- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala +++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala @@ -76,7 +76,7 @@ object PrepareInlineable { def referencesInlineContainedClassDef(tree: Tree): Boolean = tree match case Apply(qual, _) => referencesInlineContainedClassDef(qual) case TypeApply(qual, _) => referencesInlineContainedClassDef(qual) - case Select(qual, _) => qual.symbol.isContainedIn(inlineSym) + case Select(qual, _) => qual.tpe.isInstanceOf[ThisType] && qual.symbol.isContainedIn(inlineSym) case _ => false val sym = refTree.symbol sym.isTerm && diff --git a/compiler/src/dotty/tools/dotc/interactive/Completion.scala b/compiler/src/dotty/tools/dotc/interactive/Completion.scala index e357079554f6..ed1171c8e85c 100644 --- a/compiler/src/dotty/tools/dotc/interactive/Completion.scala +++ b/compiler/src/dotty/tools/dotc/interactive/Completion.scala @@ -26,7 +26,6 @@ import dotty.tools.dotc.util.Chars import dotty.tools.dotc.util.SourcePosition import scala.collection.mutable -import scala.util.control.NonFatal import dotty.tools.dotc.core.ContextOps.localContext import dotty.tools.dotc.core.Names import dotty.tools.dotc.core.Types @@ -52,12 +51,9 @@ object Completion: private val logger = Logger.getLogger(this.getClass.getName) - def scopeContext(pos: SourcePosition)(using Context): CompletionResult = - val tpdPath = Interactive.pathTo(ctx.compilationUnit.tpdTree, pos.span) - val completionContext = Interactive.contextOfPath(tpdPath).withPhase(Phases.typerPhase) + def scopeContext(pos: SourcePosition, tpdPath: List[tpd.Tree], completionContext: Context)(using Context): CompletionResult = inContext(completionContext): val untpdPath = Interactive.resolveTypedOrUntypedPath(tpdPath, pos) - val rawPrefix = completionPrefix(untpdPath, pos) // Lazy mode is to avoid too many checks as it's mostly for printing types val completer = new Completer(Mode.Lazy, pos, untpdPath, _ => true) completer.scopeCompletions @@ -87,10 +83,11 @@ object Completion: rawPrefix: String, tpdPath: List[tpd.Tree], untpdPath: List[untpd.Tree], - customMatcher: Option[Name => Boolean] = None + customMatcher: Option[Name => Boolean] = None, + calculatedScopeContext: Option[CompletionResult] = None )(using Context): CompletionMap = val adjustedPath = typeCheckExtensionConstructPath(untpdPath, tpdPath, pos) - computeCompletions(pos, mode, rawPrefix, adjustedPath, untpdPath, customMatcher) + computeCompletions(pos, mode, rawPrefix, adjustedPath, untpdPath, customMatcher, calculatedScopeContext) /** * Inspect `path` to determine what kinds of symbols should be considered. @@ -240,23 +237,38 @@ object Completion: rawPrefix: String, adjustedPath: List[tpd.Tree], untpdPath: List[untpd.Tree], - matches: Option[Name => Boolean] - )(using Context): CompletionMap = + matches: Option[Name => Boolean], + calculatedScopeContext: Option[CompletionResult] + )(using ctx: Context): CompletionMap = val hasBackTick = rawPrefix.headOption.contains('`') val prefix = if hasBackTick then rawPrefix.drop(1) else rawPrefix val matches0 = matches.getOrElse(_.startsWith(prefix)) - val completer = new Completer(mode, pos, untpdPath, matches0) + lazy val completer = new Completer(mode, pos, untpdPath, matches0) + lazy val scopeContextNames = calculatedScopeContext match + case Some(scopeContext) => + val isNew = isInNewContext(untpdPath) + scopeContext.names.flatMap { + case (name, CompletionDenotation(denots, site)) if matches0(name) => + def isAccessible(denot: SingleDenotation): Boolean = + site.forall(denot.symbol.isAccessibleFrom(_)) + val filtered = denots.filter(denot => + isValidCompletionSymbol(denot.symbol, mode, isNew) && isAccessible(denot) + ) + if filtered.nonEmpty then Some(name -> filtered) else None + case _ => None + } + case None => completer.scopeCompletions.names.map((name, denot) => name -> denot.denots) val result = adjustedPath match // Ignore synthetic select from `This` because in code it was `Ident` // See example in dotty.tools.languageserver.CompletionTest.syntheticThis - case tpd.Select(qual @ tpd.This(_), _) :: _ if qual.span.isSynthetic => completer.scopeCompletions.names + case tpd.Select(qual @ tpd.This(_), _) :: _ if qual.span.isSynthetic => scopeContextNames case StringContextApplication(qual) => - completer.scopeCompletions.names ++ completer.selectionCompletions(qual) + scopeContextNames ++ completer.selectionCompletions(qual) case tpd.Select(qual, _) :: _ => completer.selectionCompletions(qual) case (tree: tpd.ImportOrExport) :: _ => completer.directMemberCompletions(tree.expr) case NamedTupleSelection(qual) => completer.selectionCompletions(qual) - case _ => completer.scopeCompletions.names + case _ => scopeContextNames interactiv.println(i"""completion info with pos = $pos, | term = ${completer.mode.is(Mode.Term)}, @@ -305,7 +317,7 @@ object Completion: !valid end needsBacktick - private lazy val keywords = Tokens.keywords.map(Tokens.tokenString) + private lazy val keywords = Tokens.keywords.map(kw => Tokens.tokenString(kw).nn) /** * Return the list of code completions with descriptions based on a mapping from names to the denotations they refer to. @@ -322,7 +334,7 @@ object Completion: try if denot.isType then denot.symbol.showFullName else denot.info.widenTermRefExpr.show - catch case NonFatal(_) => denot.symbol.name.toString + catch case _: Exception => denot.symbol.name.toString def isInNewContext(untpdPath: List[untpd.Tree]): Boolean = untpdPath match @@ -350,7 +362,7 @@ object Completion: // running sourceSymbol on ExportedTerm will force a lot of computation from collectSubTrees (sym.is(ExportedTerm) || sym.sourceSymbol.exists) && (!sym.is(Package) || sym.is(ModuleClass)) && - !sym.isAllOf(Mutable | Accessor) && + !(sym.is(Mutable) && sym.is(Accessor)) && !sym.isPackageObject && !sym.is(Artifact) && !(completionMode.is(Mode.Type) && sym.isAllOf(ConstructorProxyModule)) && @@ -360,7 +372,7 @@ object Completion: || (completionMode.is(Mode.Type) && (sym.isType || sym.isStableMember))) ) catch - case NonFatal(ex) => + case ex: Exception => false end isValidCompletionSymbol @@ -401,10 +413,10 @@ object Completion: /** Temporary data structure representing denotations with the same name introduced in a given scope * as a member of a type, by a local definition or by an import clause */ - case class ScopedDenotations private (denots: Seq[SingleDenotation], ctx: Context) + case class ScopedDenotations private (denot: CompletionDenotation, ctx: Context) object ScopedDenotations: - def apply(denots: Seq[SingleDenotation], ctx: Context, includeFn: SingleDenotation => Boolean): ScopedDenotations = - ScopedDenotations(denots.filter(includeFn), ctx) + def apply(denot: CompletionDenotation, ctx: Context, includeFn: SingleDenotation => Boolean): ScopedDenotations = + ScopedDenotations(CompletionDenotation(denot.denots.filter(includeFn), denot.site), ctx) val mappings = collection.mutable.Map.empty[Name, List[ScopedDenotations]].withDefaultValue(List.empty) val renames = collection.mutable.Map.empty[Symbol, Name] @@ -414,8 +426,8 @@ object Completion: ctx.outersIterator.foreach { case ctx @ given Context => if ctx.isImportContext then val imported = importedCompletions - imported.names.foreach { (name, denots) => - addMapping(name, ScopedDenotations(denots, ctx, include(_, name))) + imported.names.foreach { (name, denot) => + addMapping(name, ScopedDenotations(denot, ctx, include(_, name))) } imported.renames.foreach { (name, newName) => renames(name) = newName @@ -423,17 +435,17 @@ object Completion: else if ctx.owner.isClass then accessibleMembers(ctx.owner.thisType) .groupByName.foreach { (name, denots) => - addMapping(name, ScopedDenotations(denots, ctx, include(_, name))) + addMapping(name, ScopedDenotations(CompletionDenotation(denots, Some(ctx.owner.thisType)), ctx, include(_, name))) } else if ctx.scope ne EmptyScope then ctx.scope.toList.filter(symbol => include(symbol, symbol.name)) .flatMap(_.alternatives) .groupByName.foreach { (name, denots) => - addMapping(name, ScopedDenotations(denots, ctx, include(_, name))) + addMapping(name, ScopedDenotations(CompletionDenotation(denots, None), ctx, include(_, name))) } } - var resultMappings = Map.empty[Name, Seq[SingleDenotation]] + var resultMappings = Map.empty[Name, CompletionDenotation] mappings.foreach { (name, denotss) => val first = denotss.head @@ -445,7 +457,7 @@ object Completion: def isImportedInDifferentScope = first.ctx.scope ne denotss(1).ctx.scope // import a.C // import a.C - def isSameSymbolImportedDouble = denotss.forall(_.denots == first.denots) + def isSameSymbolImportedDouble = denotss.forall(_.denot.denots == first.denot.denots) // https://scala-lang.org/files/archive/spec/3.4/02-identifiers-names-and-scopes.html // import java.lang.* @@ -457,16 +469,16 @@ object Completion: // } // } def notConflictingWithDefaults = // is imported symbol - denotss.filterNot(_.denots.exists(denot => Interactive.isImportedByDefault(denot.symbol))).size <= 1 + denotss.filterNot(_.denot.denots.exists(denot => Interactive.isImportedByDefault(denot.symbol))).size <= 1 denotss.find(!_.ctx.isImportContext) match { // most deeply nested member or local definition if not shadowed by an import case Some(local) if local.ctx.scope == first.ctx.scope => - resultMappings += name -> local.denots + resultMappings += name -> local.denot case None if isSingleImport || isImportedInDifferentScope || isSameSymbolImportedDouble => - resultMappings += name -> first.denots + resultMappings += name -> first.denot case None if notConflictingWithDefaults => - val ordered = denotss.map(_.denots).sorted + val ordered = denotss.map(_.denot).sortBy(_.denots) resultMappings += name -> ordered.head case _ => } @@ -493,7 +505,11 @@ object Completion: if qual.symbol.is(Package) then directMemberCompletions(adjustedQual) else if qual.typeOpt.hasSimpleKind then + def safeExtensionCompletions = + try extensionCompletions(adjustedQual) + catch case _: TypeError => Map.empty implicitConversionMemberCompletions(adjustedQual) ++ + //safeExtensionCompletions ++ extensionCompletions(adjustedQual) ++ directMemberCompletions(adjustedQual) ++ namedTupleCompletions(adjustedQual) @@ -553,7 +569,7 @@ object Completion: }.toSeq.groupByName val results = givenImports ++ wildcardMembers ++ explicitMembers - CompletionResult(results, renames.toMap) + CompletionResult(results.map((name, denots) => name -> CompletionDenotation(denots, Some(imp.site))), renames.toMap) end importedCompletions /** Completions from implicit conversions including old style extensions using implicit classes */ @@ -612,10 +628,10 @@ object Completion: try ctx.typer.tryApplyingExtensionMethod(termRef, qual) .map { tree => - val tpe = asDefLikeType(tree.typeOpt.dealias) + val tpe = asDefLikeType(tree.typeOpt.dealias) termRef.denot.asSingleDenotation.mapInfo(_ => tpe) } - catch case NonFatal(ex) => + catch case ex: Exception => logger.warning( s"Exception when trying to apply extension method:\n ${ex.getMessage()}\n${ex.getStackTrace().mkString("\n")}" ) @@ -638,8 +654,8 @@ object Completion: // 1. The extension method is visible under a simple name, by being defined or inherited or imported in a scope enclosing the reference. val extMethodsInScope = scopeCompletions.names.toList.flatMap: - case (name, denots) => - denots.collect: + case (name, denot) => + denot.denots.collect: case d if d.isTerm && d.symbol.is(Extension) => (d.symbol.termRef, name.asTermName) // 2. The extension method is a member of some given instance that is visible at the point of the reference. @@ -723,8 +739,8 @@ object Completion: interactiv.println(i"implicit conversion targets considered: ${conversions.toList}%, %") conversions - } catch case NonFatal(ex) => - logger.warning( + } catch case ex: Exception => + logger.fine( s"Exception when searching for implicit conversions:\n ${ex.getMessage()}\n${ex.getStackTrace().mkString("\n")}" ) Set.empty @@ -732,7 +748,7 @@ object Completion: /** Filter for names that should appear when looking for completions. */ private object completionsFilter extends NameFilter: def apply(pre: Type, name: Name)(using Context): Boolean = - !name.isConstructorName && name.toTermName.info.kind == SimpleNameKind + !name.isConstructorName && name.toTermName.info.kind == SimpleNameKind && matches(name) def isStable = true extension (denotations: Seq[SingleDenotation]) @@ -743,8 +759,9 @@ object Completion: def groupByName: CompletionMap = namedDenotations.groupMap((name, denot) => name)((name, denot) => denot) private type CompletionMap = Map[Name, Seq[SingleDenotation]] - - case class CompletionResult(names: Map[Name, Seq[SingleDenotation]], renames: Map[Symbol, Name]) + // A list of denotations together with site for checking accessibility + case class CompletionDenotation(denots: Seq[SingleDenotation], site: Option[Type]) + case class CompletionResult(names: Map[Name, CompletionDenotation], renames: Map[Symbol, Name]) /** * The completion mode: defines what kinds of symbols should be included in the completion * results. @@ -771,4 +788,3 @@ object Completion: val Member: Mode = new Mode(16) val Lazy: Mode = new Mode(32) - diff --git a/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala b/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala index 57c0c2fd3693..9ff0a576bdec 100644 --- a/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala +++ b/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package interactive -import scala.language.unsafeNulls - import java.net.URI import java.io.* import java.nio.file.* @@ -18,6 +16,7 @@ import dotty.tools.dotc.sbt.interfaces.ProgressCallback import dotty.tools.io.AbstractFile import ast.{Trees, tpd} +import config.* import core.*, core.Decorators.* import Contexts.*, Names.*, NameOps.*, Symbols.*, SymDenotations.*, Trees.*, Types.* import Denotations.staticRef @@ -25,10 +24,24 @@ import classpath.* import reporting.* import util.* +private class InteractiveContextBase(precomputedSourcePackages: Option[LogicalPackage]) extends ContextBase { + + override protected def newPlatform(using Context): Platform = + if (settings.scalajs.value) new SJSPlatform(precomputedSourcePackages) + else new JavaPlatform(precomputedSourcePackages) + +} + /** A Driver subclass designed to be used from IDEs */ -class InteractiveDriver(val settings: List[String]) extends Driver { +class InteractiveDriver( + val settings: List[String], + val logicalRootPackage: Option[LogicalPackage] = None +) extends Driver { import tpd.* + override protected def initCtx: Context = + new InteractiveContextBase(logicalRootPackage).initialCtx + override def sourcesRequired: Boolean = false private var myProgressCallback: ProgressCallback = new ProgressCallback: @@ -113,9 +126,9 @@ class InteractiveDriver(val settings: List[String]) extends Driver { val classNames = new mutable.ListBuffer[TypeName] val output = ctx.settings.outputDir.value if (output.isDirectory) - classesFromDir(output.jpath, classNames) + classesFromDir(output.jpath.nn, classNames) else - classesFromZip(output.file, classNames) + classesFromZip(output.file.nn, classNames) classNames.flatMap { cls => treesFromClassName(cls, id) } diff --git a/compiler/src/dotty/tools/dotc/interactive/LogicalPackage.scala b/compiler/src/dotty/tools/dotc/interactive/LogicalPackage.scala new file mode 100644 index 000000000000..7ad41d7c2ca4 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/interactive/LogicalPackage.scala @@ -0,0 +1,40 @@ +package dotty.tools.dotc.interactive + +import dotty.tools.io.AbstractFile + +/** + * A logical package representation. This is disconnected from the file system, and faithfully + * represents the nesting of packages and sources that contribute classes to those packages. + */ +trait LogicalPackage { + + def name: String + + def packages: Seq[LogicalPackage] + + /** + * Return all sources contained by this package. Only direct members are returned, and there are no duplicates. + * + */ + def sources: Seq[AbstractFile] + + def getPackage(name: String): Option[LogicalPackage] + + def prettyPrint(): String = { + prettyPrintWith().toString().stripTrailing().stripIndent() + } + + private def prettyPrintWith( + indent: Int = 0, + sb: StringBuilder = new StringBuilder + ): StringBuilder = + sb ++= " " * indent + sb ++= s"$name\n" + packages.sortBy(_.name).foreach(_.prettyPrintWith(indent + 4, sb)) + sources.foreach { s => + sb ++= (" " * (indent + 4)) + sb ++= s.name + "\n" + } + sb + +} diff --git a/compiler/src/dotty/tools/dotc/interactive/LogicalPackagesProvider.scala b/compiler/src/dotty/tools/dotc/interactive/LogicalPackagesProvider.scala new file mode 100644 index 000000000000..d1cdf6455f2a --- /dev/null +++ b/compiler/src/dotty/tools/dotc/interactive/LogicalPackagesProvider.scala @@ -0,0 +1,170 @@ +package dotty.tools.dotc.interactive + +import dotty.tools.dotc.ast.untpd +import dotty.tools.dotc.core.Contexts.* +import dotty.tools.dotc.core.StdNames.nme +import dotty.tools.dotc.parsing.JavaParsers +import dotty.tools.dotc.parsing.Parsers +import dotty.tools.dotc.util.SourceFile +import dotty.tools.io.AbstractFile +import dotty.tools.io.ClassPath +import dotty.tools.io.FileExtension +import dotty.tools.io.Path + +import java.io.File +import scala.collection.mutable +import dotty.tools.dotc.core.Contexts + +/** + * A compiler component that adds support for parsing Scala and Java source files and finding out + * the logical package structure of the whole source path. + */ +class LogicalPackagesProvider(sourcePath: String){ + + // We only use it for parser + private given Context = new ContextBase().initialCtx + + private lazy val sourceRoots: Seq[SourceFile] = + allSources(sourcePath).map(f => SourceFile(f, f.toCharArray)) + + lazy val root: LogicalPackage = parseSourcePath() + + /** + * Parse all source files in the sourcepath and build the logical package structure. + */ + def parseSourcePath(): LogicalPackage = + val pkg: ParsedLogicalPackage = newPackage() + for sourceFile <- sourceRoots do + try + parseSourceFile(sourceFile, pkg) + catch + case e: Exception => + // Silently ignore parsing errors + pkg + + private def newPackage(): ParsedLogicalPackage = + new ParsedLogicalPackage("", None) + + private def parseSourceFile( + sourceFile: SourceFile, + rootPackage: ParsedLogicalPackage + ): Unit = + val fileName = sourceFile.path + if fileName.endsWith(".scala") then + parseScalaSourceFile(sourceFile, fileName, rootPackage) + else if fileName.endsWith(".java") then + parseJavaSourceFile(sourceFile, fileName, rootPackage) + + private def parseScalaSourceFile( + sourceFile: SourceFile, + fileName: String, + rootPackage: ParsedLogicalPackage + ): Unit = + try + // Use OutlineParser for fast parsing that skips method bodies + val parser = new Parsers.OutlineParser(sourceFile) + val tree = parser.parse() + val traverser = new SourceFileTraverser(fileName, rootPackage) + traverser.traverse(tree) + catch + case e: Exception => + // Silently ignore parsing errors + + private def parseJavaSourceFile( + sourceFile: SourceFile, + fileName: String, + rootPackage: ParsedLogicalPackage + ): Unit = + try + // Use OutlineJavaParser for fast parsing + val parser = new JavaParsers.OutlineJavaParser(sourceFile) + val tree = parser.parse() + + // Traverse the tree to extract package info + val traverser = new SourceFileTraverser(fileName, rootPackage) + traverser.traverse(tree) + catch + case e: Exception => + // Silently ignore parsing errors + + /** + * Traverse an untyped AST to extract package and class definitions. + */ + private class SourceFileTraverser( + fileName: String, + rootPackage: ParsedLogicalPackage + ) { + private var currentPackage = rootPackage + + def traverse(tree: untpd.Tree): Unit = tree match + case untpd.Thicket(trees) => + trees.foreach(traverse) + case pkg: untpd.PackageDef => + traversePackageDef(pkg) + case _: untpd.MemberDef => + // Top-level class or object in default package + currentPackage.enterSource(fileName) + case _ => + + private def traversePackageDef(pkg: untpd.PackageDef): Unit = { + // Navigate to the package + val pkgName = packageNameFromTree(pkg.pid) + val newCurrentPackage = { + var current = currentPackage + for (part <- pkgName.split('.') if part.nonEmpty) { + current = current.enterPackage(part) + } + current + } + // Traverse nested definitions + val oldPackage = currentPackage + currentPackage = newCurrentPackage + pkg.stats.foreach(traverse) + currentPackage = oldPackage + } + + private def packageNameFromTree(tree: untpd.Tree): String = tree match { + case untpd.Ident(name) => + if (name == nme.ROOT || name == nme.EMPTY_PACKAGE || name == nme.EMPTY) "" + else name.toString + case untpd.Select(qual, name) => + val qualName = packageNameFromTree(qual) + if (qualName.isEmpty) name.toString + else s"$qualName.${name.toString}" + case _ => + "" + } + } + + /** + * Return all Scala and Java sources from the given sourcepath string. + */ + private def allSources(srcPath: String): Seq[AbstractFile] = { + val entries = ClassPath.split(srcPath).map(Path(_)) + def isRelevantFile(path: Path) = + path.ext == FileExtension.Scala || path.ext == FileExtension.Java + // avoid using IO operation, assume standard extensions, Metals sends files so no sense checking for directories eagerly + val rootDirs = entries.filter(f => !isRelevantFile(f)) + val rootFiles = for { + e <- entries + if isRelevantFile(e) + f <- Option(AbstractFile.getFile(e)) + } yield f + rootFiles ++ rootDirs.flatMap{ dir => + Option(AbstractFile.getDirectory(dir)).toSeq.flatMap(sourcesIn(_, "scala", "java")) + } + } + + /** + * Recursively find all source files with given extensions in a directory. + */ + private def sourcesIn( + dir: AbstractFile, + extensions: String* + ): Seq[AbstractFile] = + dir.iterator.toSeq.flatMap { file => + if (file.isDirectory) sourcesIn(file, extensions*) + else if (extensions.exists(ext => file.name.endsWith(s".$ext"))) Seq(file) + else Seq.empty[AbstractFile] + } +} diff --git a/compiler/src/dotty/tools/dotc/interactive/LogicalSourcePath.scala b/compiler/src/dotty/tools/dotc/interactive/LogicalSourcePath.scala new file mode 100644 index 000000000000..86236a962718 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/interactive/LogicalSourcePath.scala @@ -0,0 +1,79 @@ +package dotty.tools.dotc.interactive + +import dotty.tools.dotc.classpath.BinaryFileEntry +import dotty.tools.dotc.classpath.ClassPathEntries +import dotty.tools.dotc.classpath.PackageEntry +import dotty.tools.dotc.classpath.PackageEntryImpl +import dotty.tools.dotc.classpath.PackageName +import dotty.tools.dotc.classpath.SourceFileEntry +import dotty.tools.io.AbstractFile +import dotty.tools.io.ClassPath + +import java.io.File +import java.net.URL +import java.nio.file.Path + +/** + * A ClassPath implementation that can find sources regardless of the directory where they're declared. + */ +class LogicalSourcePath(val sourcepath: String, rootPackage: LogicalPackage) + extends ClassPath { + + override def findClassFileAndModuleFile(className: String, findModule: Boolean): Option[(AbstractFile, Option[AbstractFile])] = None + override def findClassFile(className: String): Option[AbstractFile] = None + override def classes(inPackage: PackageName): Seq[BinaryFileEntry] = Seq.empty + + override def hasPackage(inPackage: PackageName): Boolean = + findPackage( + inPackage.dottedString + ).isDefined + + /** Return all packages contained inside `inPackage`. Package entries contain the *full name* of the package. */ + override def packages(inPackage: PackageName): Seq[PackageEntry] = + val rawPackage = inPackage.dottedString + findPackage(rawPackage) match + case Some(pkg) => packagesIn(pkg, rawPackage) + case None => Seq.empty[PackageEntry] + + + /** Return all sources contained directly inside `inPackage` */ + override def sources(inPackage: PackageName): Seq[SourceFileEntry] = + val rawPackage = inPackage.dottedString + findPackage(rawPackage) match + case Some(pkg) => + sourcesIn(pkg) + case None => Seq.empty[SourceFileEntry] + + private def sourcesIn(pkg: LogicalPackage) = + pkg.sources.map(p => SourceFileEntry(p)) + + private def packagesIn(pkg: LogicalPackage, prefix: String) = + val pre = if (prefix.isEmpty) prefix else s"$prefix." + pkg.packages.map(p => PackageEntryImpl(pre + p.name)) + + override def list(inPackage: PackageName): ClassPathEntries = + val rawPackage = inPackage.dottedString + val res = findPackage(rawPackage) match + case Some(pkg) => + ClassPathEntries(packagesIn(pkg, rawPackage), sourcesIn(pkg)) + case None => ClassPathEntries(Seq(), Seq()) + res + + override def asURLs: Seq[URL] = sourcepath.split(File.pathSeparator).toIndexedSeq.map(new File(_)).map(_.toURI.toURL) + + override def asClassPathStrings: Seq[String] = Seq() + + override def asSourcePathString: String = sourcepath + + /** Return the package for the given fullName, if any */ + private def findPackage(fullName: String): Option[LogicalPackage] = + if fullName == "" then Option(rootPackage) + else + fullName.split('.').foldLeft(Option(rootPackage)) { (pkg, name) => + pkg.flatMap(_.getPackage(name)) + } + + override def toString: String = rootPackage.prettyPrint() + +} + diff --git a/compiler/src/dotty/tools/dotc/interactive/ParsedLogicalPackage.scala b/compiler/src/dotty/tools/dotc/interactive/ParsedLogicalPackage.scala new file mode 100644 index 000000000000..0fede66ee92e --- /dev/null +++ b/compiler/src/dotty/tools/dotc/interactive/ParsedLogicalPackage.scala @@ -0,0 +1,107 @@ +package dotty.tools.dotc.interactive + +import scala.collection.mutable +import dotty.tools.io.AbstractFile +import scala.jdk.CollectionConverters.* + +/** + * Represent a package and its contents in a way that's close to the file system. + * + * A package contains any number of nested packages and source files. It is mutable in order to allow adding + * members at any level, as they are discovered by parsing source files. + * + * @param name simple name of the package + * @note This class is not thread safe + */ +class ParsedLogicalPackage( + val name: String, + val parent: Option[ParsedLogicalPackage] +) extends LogicalPackage { + require( + (name.trim.isEmpty && parent.isEmpty) || (name.trim.nonEmpty && parent.nonEmpty), + s"Unexpected package name `$name` and parent `$parent`." + ) + + def this(name: String, parent: ParsedLogicalPackage) = + this(name, Some(parent)) + + private val subpackages = + mutable.LinkedHashMap.empty[String, ParsedLogicalPackage] + private val directSources = mutable.ListBuffer.empty[String] + + def fullName: String = + if (parent.isEmpty || parent.get.name.isEmpty) name + else s"${parent.get.fullName}.$name" + + def removeEmptyPackages(): Unit = + subpackages.values.foreach(_.removeEmptyPackages()) + if subpackages.isEmpty && directSources.isEmpty then + parent.foreach(_.subpackages.remove(name)) + + + /** + * Return the existing member package, or create a new one and add it to this package. + */ + def enterPackage(name: String): ParsedLogicalPackage = synchronized{ + subpackages.get(name) match { + case Some(p) => p + case None => + val p = new ParsedLogicalPackage(name, this) + subpackages(name) = p + p + } + } + + def getPackage(name: String): Option[ParsedLogicalPackage] = + subpackages.get(name) + + def enterSource(fileName: String): this.type = synchronized: + directSources += fileName + this + + /** Return all member packages. Only direct members are returned. */ + def packages: Seq[ParsedLogicalPackage] = subpackages.values.toList + + /** + * Return all sources contained by this package. Only direct members are returned, and there are no duplicates. + * + * The return type is a sequence and not a Set in order to have deterministic runs + */ + def sources: Seq[AbstractFile] = directSources.toSeq.distinct.flatMap(name => Option(AbstractFile.getFile(name))) + + override def toString(): String = + s"package $name(${packages.size} packages and ${sources.size} files)" +} + +object ParsedLogicalPackage{ + + def fromMbtIndex( + packages: java.util.Map[String, java.util.Set[java.nio.file.Path]] + ): ParsedLogicalPackage = + val root = new ParsedLogicalPackage("", None) + val disallowedPackages: Set[String] = Set("scala", "scala.test", "_empty_") + val validExtensions: Set[String] = Set(".scala", ".java") + + def isSupported(path: java.nio.file.Path): Boolean = + val filename = path.getFileName.toString + validExtensions.exists(filename.endsWith) + + def enterNestedPackage(pkg: String) = + val parts = pkg.split('/') + var current = root + for part <- parts if !part.isEmpty do + current = current.enterPackage(part) + current + + for ((pkg, paths) <- packages.asScala) do + val p = enterNestedPackage(pkg) + // we don't enter anything in the empty package, which is special and generally not useful (it is not) + // visible from other packages. Similarly, the scala package is special and we don't want to enter any + // symbols into it, since they might hide standard library symbols, such as scala.Option. + if p.name.nonEmpty && !disallowedPackages.contains(p.fullName) then + for path <- paths.asScala if isSupported(path) do + p.enterSource(path.toString) + + root.removeEmptyPackages() + root +} \ No newline at end of file diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala index 7f4c259224ac..67b9f25de98a 100644 --- a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala +++ b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala @@ -214,7 +214,7 @@ object JavaParsers { def identForType(): TypeName = ident().toTypeName def ident(): Name = if (in.token == IDENTIFIER) { - val name = in.name + val name = in.name.nn in.nextToken() name } @@ -317,7 +317,8 @@ object JavaParsers { def typeArgs(t: Tree): Tree = { var wildnum = 0 - def typeArg(): Tree = + def typeArg(): Tree = { + val annots = annotations() if (in.token == QMARK) { val offset = in.offset in.nextToken() @@ -335,7 +336,8 @@ object JavaParsers { } } else - typ() + annots.foldLeft(typ())((tp, ann) => Annotated(tp, ann)) + } if (in.token == LT) { in.nextToken() val t1 = convertToTypeId(t) @@ -603,7 +605,7 @@ object JavaParsers { * in particular when a `parentToken` is passed to some functions. */ def adaptRecordIdentifier(): Unit = - if in.token == IDENTIFIER && in.name == jnme.RECORDid then + if in.token == IDENTIFIER && in.name.nn == jnme.RECORDid then in.token = RECORD def termDecl(start: Offset, mods: Modifiers, parentToken: Int): List[Tree] = { @@ -1086,22 +1088,20 @@ object JavaParsers { case MINUS | BANG => in.nextToken(); true case _ => false } - val l = in.token match { - case TRUE => !negate - case FALSE => negate - case CHARLIT => in.strVal.charAt(0) - case INTLIT => in.intVal(negate).toInt - case LONGLIT => in.intVal(negate) - case FLOATLIT => in.floatVal(negate).toFloat - case DOUBLELIT => in.floatVal(negate) - case STRINGLIT => in.strVal - case _ => null + val constant = in.token match { + case TRUE => Some(Constant(!negate)) + case FALSE => Some(Constant(negate)) + case CHARLIT => Some(Constant(in.strVal.nn.charAt(0))) + case INTLIT => Some(Constant(in.intVal(negate).toInt)) + case LONGLIT => Some(Constant(in.intVal(negate))) + case FLOATLIT => Some(Constant(in.floatVal(negate).toFloat)) + case DOUBLELIT => Some(Constant(in.floatVal(negate))) + case STRINGLIT => Some(Constant(in.strVal.nn)) + case _ => None } - if (l == null) None - else { + if constant.isDefined then in.nextToken() - Some(Constant(l)) - } + constant } /** CompilationUnit ::= {Annotation} [package QualId semi] {Import} {TypeDecl} diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala b/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala index 64f586ca0410..a465c2e44ee2 100644 --- a/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala +++ b/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala @@ -632,6 +632,7 @@ object JavaScanners { /** convert name to long value */ def intVal(negated: Boolean): Long = + val strVal = this.strVal.nn if (token == CHARLIT && !negated) if (strVal.length > 0) strVal.charAt(0).toLong else 0 else { @@ -729,7 +730,7 @@ object JavaScanners { case COMMA => "," case _ => - tokenString(token) + tokenString(token).nn } /* Initialization: read first char, then first token */ diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala index d0bb32808a6b..71512c590433 100644 --- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala +++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala @@ -2,13 +2,11 @@ package dotty.tools package dotc package parsing -import scala.language.unsafeNulls - import scala.annotation.tailrec import scala.annotation.threadUnsafe as tu import scala.collection.mutable.ListBuffer import scala.collection.immutable.BitSet -import util.{ SourceFile, SourcePosition, NoSourcePosition } +import util.{SourceFile, SourcePosition, NoSourcePosition, SrcPos} import Tokens.* import Scanners.* import xml.MarkupParsers.MarkupParser @@ -51,7 +49,7 @@ object Parsers { case InGuard extends Location(false, false, false) case InPatternArgs extends Location(false, true, true) // InParens not true, since it might be an alternative case InBlock extends Location(false, false, false) - case ElseWhere extends Location(false, false, false) + case Elsewhere extends Location(false, false, false) enum ParamOwner: case Class // class or trait or enum @@ -138,6 +136,13 @@ object Parsers { def atSpan[T <: Positioned](start: Offset)(t: T): T = atSpan(start, start)(t) + inline def atNameSpan[T <: NameTree](start: Offset)(inline tree: => T): T = + val backquoted = in.token == BACKQUOTED_IDENT + atSpan(start, if backquoted then in.offset + 1 else in.offset): + tree.tap: t => + if backquoted && !t.hasAttachment(Backquoted) then + t.pushAttachment(Backquoted, ()) + def startOffset(t: Positioned): Int = if (t.span.exists) t.span.start else in.offset @@ -168,7 +173,7 @@ object Parsers { */ def syntaxError(msg: Message, offset: Int = in.offset): Unit = if offset > lastErrorOffset then - val length = if offset == in.offset && in.name != null then in.name.show.length else 0 + val length = if offset == in.offset && in.name != null then in.name.nn.show.length else 0 syntaxError(msg, Span(offset, offset + length)) lastErrorOffset = in.offset @@ -219,9 +224,8 @@ object Parsers { isIdent(nme.erased) && in.erasedEnabled && in.isSoftModifierInParamModifierPosition def isConsume = isIdent(nme.consume) && ccEnabled //\&& in.isSoftModifierInParamModifierPosition - def isSimpleLiteral = - simpleLiteralTokens.contains(in.token) - || isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token) + def isNegatedNumber = isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token) + def isSimpleLiteral = simpleLiteralTokens.contains(in.token) || isNegatedNumber def isLiteral = literalTokens contains in.token def isNumericLit = numericLitTokens contains in.token def isTemplateIntro = templateIntroTokens contains in.token @@ -255,7 +259,7 @@ object Parsers { in.token == AT || defIntroTokens.contains(in.token) || allowedMods.contains(in.token) - || in.isSoftModifierInModifierPosition && !excludedSoftModifiers.contains(in.name) + || in.isSoftModifierInModifierPosition && !excludedSoftModifiers.contains(in.name.nn) // soft modifiers have a name def isStatSep: Boolean = in.isStatSep @@ -264,8 +268,8 @@ object Parsers { * in a quoted block '{...' */ def isSplice: Boolean = - in.token == IDENTIFIER && in.name(0) == '$' && { - if in.name.length == 1 then in.lookahead.token == LBRACE + in.token == IDENTIFIER && in.name.nn(0) == '$' && { + if in.name.nn.length == 1 then in.lookahead.token == LBRACE else (staged & StageKind.Quoted) != 0 } @@ -328,6 +332,13 @@ object Parsers { if in.token == token then in.nextToken() offset + def accept(token: Int, help: String): Int = + val offset = in.offset + if in.token != token then + syntaxErrorOrIncomplete(ExpectedTokenButFound(token, in.token, suffix = help)) + if in.token == token then in.nextToken() + offset + def accept(name: Name): Int = { val offset = in.offset if !isIdent(name) then @@ -542,7 +553,13 @@ object Parsers { // into a capturing type in the typer. syntaxError(em"Implementation restriction: polymorphic function types cannot wrap function types that have capture sets", arrowOffset) errorTree - case Some(f) => + case Some(f: FunctionWithMods) if f.mods.is(Impure) && ccEnabled => + syntaxError( + em"""Implementation restriction: polymorphic function types cannot wrap impure function types if capture checking is enabled. + |Workaround: introduce an empty term-parameter list right after the type binder, e.g. `[A] => () -> B => C`.""", + arrowOffset) + errorTree + case _ => PolyFunction(tparams, body) /* --------------- PLACEHOLDERS ------------------------------------------- */ @@ -711,9 +728,7 @@ object Parsers { if in.isNewLine && !(nextIndentWidth < startIndentWidth) then warning( if startIndentWidth <= nextIndentWidth then - em"""Line is indented too far to the right, or a `{` is missing before: - | - |${t.tryToShow}""" + IndentationWarning(missing = LBRACE, before = t.tryToShow) else in.spaceTabMismatchMsg(startIndentWidth, nextIndentWidth), in.next.offset @@ -728,7 +743,7 @@ object Parsers { if in.isNewLine then val nextIndentWidth = in.indentWidth(in.next.offset) if in.currentRegion.indentWidth < nextIndentWidth && in.currentRegion.closedBy == OUTDENT then - warning(em"Line is indented too far to the right, or a `{` or `:` is missing", in.next.offset) + warning(IndentationWarning(missing = Seq(LBRACE, COLONop)*), in.next.offset) /* -------- REWRITES ----------------------------------------------------------- */ @@ -1168,11 +1183,11 @@ object Parsers { var opStack: List[OpInfo] = Nil - def checkAssoc(offset: Token, op1: Name, op2: Name, op2LeftAssoc: Boolean): Unit = + def checkAssoc(offset: Token, op1: Name, op2: Name | Null, op2LeftAssoc: Boolean): Unit = if (op1.isRightAssocOperatorName == op2LeftAssoc) syntaxError(MixedLeftAndRightAssociativeOps(op1, op2, op2LeftAssoc), offset) - def reduceStack(base: List[OpInfo], top: Tree, prec: Int, leftAssoc: Boolean, op2: Name, isType: Boolean): Tree = { + def reduceStack(base: List[OpInfo], top: Tree, prec: Int, leftAssoc: Boolean, op2: Name | Null, isType: Boolean): Tree = { if (opStack != base && precedence(opStack.head.operator.name) == prec) checkAssoc(opStack.head.offset, opStack.head.operator.name, op2, leftAssoc) def recur(top: Tree): Tree = @@ -1269,7 +1284,7 @@ object Parsers { else t def recurAtMinPrec(top: Tree): Tree = - if isIdent && isOperator && precedence(in.name) == minInfixPrec + if isIdent && isOperator && precedence(in.name.nn) == minInfixPrec || in.token == MATCH then recur(top) else top @@ -1286,11 +1301,9 @@ object Parsers { /** Accept identifier and return its name as a term name. */ def ident(): TermName = if (isIdent) { - val name = in.name + val name = in.name.nn if name == nme.CONSTRUCTOR || name == nme.STATIC_CONSTRUCTOR then - report.error( - em"""Illegal backquoted identifier: `` and `` are forbidden""", - in.sourcePos()) + report.error(IllegalIdentifier(name), in.sourcePos()) in.nextToken() name } @@ -1299,6 +1312,13 @@ object Parsers { nme.ERROR } + extension (nameTree: NameTree) + inline def checkPatternName: nameTree.type = + if !isBackquoted(nameTree) && nameTree.name.toSimpleName.contains('$') then + report.errorOrMigrationWarning( + IllegalIdentifier(nameTree.name), nameTree.srcPos, MigrationVersion.IdentifierDollars) + nameTree + /** Accept identifier and return Ident with its name as a term name. */ def termIdent(): Ident = makeIdent(in.token, in.offset, ident()) @@ -1311,7 +1331,7 @@ object Parsers { val tree = Ident(name) if (tok == BACKQUOTED_IDENT) tree.pushAttachment(Backquoted, ()) - // Make sure that even trees with parsing errors have a offset that is within the offset + // Make sure that even trees with parsing errors have an offset that is within the offset val errorOffset = offset min (in.lastOffset - 1) if (tree.name == nme.ERROR && tree.span == NoSpan) tree.withSpan(Span(errorOffset, errorOffset)) else atSpan(offset)(tree) @@ -1391,9 +1411,7 @@ object Parsers { */ def simpleLiteral(): Tree = if isIdent(nme.raw.MINUS) then - val start = in.offset - in.nextToken() - literal(negOffset = start, inTypeOrSingleton = true) + literal(start = in.skipToken(), inTypeOrSingleton = true) else literal(inTypeOrSingleton = true) @@ -1402,15 +1420,18 @@ object Parsers { * | symbolLiteral * | ‘null’ * - * @param negOffset The offset of a preceding `-' sign, if any. - * If the literal is not negated, negOffset == in.offset. + * @param start The offset of a preceding `-' sign, if any. + * If the literal is not negated, start == in.offset. */ - def literal(negOffset: Int = in.offset, inPattern: Boolean = false, inTypeOrSingleton: Boolean = false, inStringInterpolation: Boolean = false): Tree = { + def literal(start: Int = in.offset, inPattern: Boolean = false, inTypeOrSingleton: Boolean = false, inStringInterpolation: Boolean = false): Tree = { def literalOf(token: Token): Tree = { - val isNegated = negOffset < in.offset - def digits0 = in.removeNumberSeparators(in.strVal) - def digits = if (isNegated) "-" + digits0 else digits0 + val isNegated = start < in.offset + def digits0 = in.removeNumberSeparators(in.strVal.nn) + def digits = if isNegated then "-" + digits0 else digits0 if !inTypeOrSingleton then + if isNegated && start < in.offset - 1 then + warning(IllegalLiteral(), start) + patch(Span(start, in.offset + in.strVal.nn.length), "-" + in.strVal.nn.trim) token match { case INTLIT => return Number(digits, NumberKind.Whole(in.base)) case DECILIT => return Number(digits, NumberKind.Decimal) @@ -1418,48 +1439,51 @@ object Parsers { case _ => } import scala.util.FromDigits.* - val value = - try token match { - case INTLIT => intFromDigits(digits, in.base) - case LONGLIT => longFromDigits(digits, in.base) - case FLOATLIT => floatFromDigits(digits) - case DOUBLELIT | DECILIT | EXPOLIT => doubleFromDigits(digits) - case CHARLIT => in.strVal.head - case STRINGLIT | STRINGPART => in.strVal - case TRUE => true - case FALSE => false - case NULL => null - case _ => - syntaxErrorOrIncomplete(IllegalLiteral()) - null - } - catch { - case ex: FromDigitsException => syntaxErrorOrIncomplete(ex.getMessage.toMessage) - } - Literal(Constant(value)) + def lit[T](value: T)(using Constant.ValueToConstant[T]): Tree = + Literal(Constant.fromValue(value)) + try token match { + case INTLIT => lit(intFromDigits(digits, in.base)) + case LONGLIT => lit(longFromDigits(digits, in.base)) + case FLOATLIT => lit(floatFromDigits(digits)) + case DOUBLELIT | DECILIT | EXPOLIT => lit(doubleFromDigits(digits)) + case CHARLIT => lit(in.strVal.nn.head) + case STRINGLIT | STRINGPART => lit(in.strVal.nn) + case TRUE => lit(true) + case FALSE => lit(false) + case NULL => lit(null) + case _ => + syntaxErrorOrIncomplete(IllegalLiteral()) + lit(null) + } + catch { + case ex: FromDigitsException => + syntaxErrorOrIncomplete(ex.getMessage.toMessage) + lit(null) + } } if (inStringInterpolation) { val t = in.token match { case STRINGLIT | STRINGPART => - val value = in.strVal - atSpan(negOffset, negOffset, negOffset + value.length) { Literal(Constant(value)) } + val value = in.strVal.nn + atSpan(start, start, start + value.length) { Literal(Constant(value)) } case _ => syntaxErrorOrIncomplete(IllegalLiteral()) - atSpan(negOffset) { Literal(Constant(null)) } + atSpan(start) { Literal(Constant(null)) } } in.nextToken() t } - else atSpan(negOffset) { + else atSpan(start) { if (in.token == QUOTEID) - if ((staged & StageKind.Spliced) != 0 && Chars.isIdentifierStart(in.name(0))) { + val inName = in.name.nn + if ((staged & StageKind.Spliced) != 0 && Chars.isIdentifierStart(inName(0))) { val t = atSpan(in.offset + 1) { - val tok = in.toToken(in.name) + val tok = in.toToken(inName) tok match { case TRUE | FALSE | NULL => literalOf(tok) case THIS => This(EmptyTypeIdent) - case _ => Ident(in.name) + case _ => Ident(inName) } } in.nextToken() @@ -1478,7 +1502,7 @@ object Parsers { if MigrationVersion.Scala2to3.needsPatch then patch(source, Span(in.offset, in.offset + 1), "Symbol(\"") patch(source, Span(in.charOffset - 1), "\")") - atSpan(in.skipToken()) { SymbolLit(in.strVal) } + atSpan(in.skipToken()) { SymbolLit(in.strVal.nn) } else if (in.token == INTERPOLATIONID) interpolatedString(inPattern) else { val t = literalOf(in.token) @@ -1524,9 +1548,9 @@ object Parsers { nextSegment(in.offset + offsetCorrection) offsetCorrection = 0 if (in.token == STRINGLIT) - segmentBuf += literal(inPattern = inPattern, negOffset = in.offset + offsetCorrection, inStringInterpolation = true) + segmentBuf += literal(in.offset + offsetCorrection, inPattern = inPattern, inStringInterpolation = true) - InterpolatedString(interpolator, segmentBuf.toList) + InterpolatedString(interpolator.nn, segmentBuf.toList) } /* ------------- NEW LINES ------------------------------------------------- */ @@ -1545,7 +1569,7 @@ object Parsers { if in.isNewLine && in.next.token == token then in.nextToken() def newLinesOptWhenFollowedBy(name: Name): Unit = - if in.isNewLine && in.next.token == IDENTIFIER && in.next.name == name then + if in.isNewLine && in.next.token == IDENTIFIER && in.next.name.nn == name then in.nextToken() def newLineOptWhenFollowing(p: Int => Boolean): Unit = @@ -1605,11 +1629,11 @@ object Parsers { def matches(stat: T): Boolean = stat match case stat: MemberDef if !stat.name.isEmpty => if stat.name == nme.CONSTRUCTOR then in.token == THIS - else in.isIdent && in.name == stat.name.toTermName + else in.isIdent && in.name.nn == stat.name.toTermName case ExtMethods(_, _) => - in.token == IDENTIFIER && in.name == nme.extension + in.token == IDENTIFIER && in.name.nn == nme.extension case PackageDef(pid: RefTree, _) => - in.isIdent && in.name == pid.name + in.isIdent && in.name.nn == pid.name case stat: MemberDef if stat.mods.is(Given) => in.token == GIVEN case _: PatDef => in.token == VAL case _: If => in.token == IF @@ -1914,7 +1938,7 @@ object Parsers { def infixType(inContextBound: Boolean = false): Tree = infixTypeRest(inContextBound)(refinedType()) def infixTypeRest(inContextBound: Boolean = false)(t: Tree, operand: Location => Tree = refinedTypeFn): Tree = - infixOps(t, canStartInfixTypeTokens, operand, Location.ElseWhere, ParseKind.Type, + infixOps(t, canStartInfixTypeTokens, operand, Location.Elsewhere, ParseKind.Type, isOperator = !followingIsVararg() && !isPureArrow && !(isIdent(nme.as) && sourceVersion.enablesNewGivens && inContextBound) @@ -2045,13 +2069,13 @@ object Parsers { atSpan(in.offset) { val inPattern = (staged & StageKind.QuotedPattern) != 0 val expr = - if (in.name.length == 1) { + if (in.name.nn.length == 1) { in.nextToken() val inPattern = (staged & StageKind.QuotedPattern) != 0 withinStaged(StageKind.Spliced)(inBraces(if inPattern then pattern() else block(simplify = true))) } else atSpan(in.offset + 1) { - val id = Ident(in.name.drop(1)) + val id = Ident(in.name.nn.drop(1)) in.nextToken() id } @@ -2100,7 +2124,7 @@ object Parsers { // Allow symbols -_ and +_ through for compatibility with code written using kind-projector in Scala 3 underscore mode. // While these signify variant type parameters in Scala 2 + kind-projector, we ignore their variance markers since variance is inferred. else if (isIdent(nme.MINUS) || isIdent(nme.PLUS)) && in.lookahead.token == USCORE && ctx.settings.XkindProjector.value == "underscores" then - val identName = in.name.toTypeName ++ nme.USCOREkw + val identName = in.name.nn.toTypeName ++ nme.USCOREkw val start = in.skipToken() in.nextToken() Ident(identName).withSpan(Span(start, in.lastOffset, start)) @@ -2327,16 +2351,19 @@ object Parsers { /** ContextBound ::= Type [`as` id] */ def contextBound(pname: TypeName): Tree = + val start = in.offset val t = toplevelTyp(inContextBound = true) val ownName = if isIdent(nme.as) && sourceVersion.enablesNewGivens then in.nextToken() ident() else EmptyTermName - val res = ContextBoundTypeTree(t, pname, ownName) - if t.span.exists then - res.withSpan(Span(t.span.start, end = in.lastOffset, point = t.span.end)) - else res + ContextBoundTypeTree(t, pname, ownName) + .withSpan: + if t.span.exists then + Span(t.span.start, end = in.lastOffset, point = t.span.end) + else + Span(start, end = in.lastOffset, point = start) /** ContextBounds ::= ContextBound [`:` ContextBounds] * | `{` ContextBound {`,` ContextBound} `}` @@ -2402,12 +2429,12 @@ object Parsers { inSepRegion(InCond): expr1Rest( postfixExprRest( - simpleExprRest(t, Location.ElseWhere), - Location.ElseWhere), - Location.ElseWhere) + simpleExprRest(t, Location.Elsewhere), + Location.Elsewhere), + Location.Elsewhere) else if rewriteToNewSyntax(t.span) then - dropParensOrBraces(t.span.start, tokenString(altToken)) + dropParensOrBraces(t.span.start, tokenString(altToken).nn) in.observeIndented() return t else if in.isNestedStart then @@ -2454,7 +2481,7 @@ object Parsers { */ val exprInParens: () => Tree = () => expr(Location.InParens) - val expr: () => Tree = () => expr(Location.ElseWhere) + val expr: () => Tree = () => expr(Location.Elsewhere) def subExpr() = subPart(expr) @@ -2499,7 +2526,7 @@ object Parsers { wrapPlaceholders(t) } - def expr1(location: Location = Location.ElseWhere): Tree = in.token match + def expr1(location: Location = Location.Elsewhere): Tree = in.token match case IF => ifExpr(in.offset, If) case WHILE => @@ -2604,7 +2631,7 @@ object Parsers { t match case Ident(_) | Select(_, _) | Apply(_, _) | PrefixOp(_, _) | PostfixOp(_, _) => atSpan(startOffset(t), in.skipToken()) { - val loc = if location.inArgs then location else Location.ElseWhere + val loc = if location.inArgs then location else Location.Elsewhere Assign(t, subPart(() => expr(loc))) } case _ => @@ -2794,7 +2821,7 @@ object Parsers { * | InfixExpr id ColonArgument * | InfixExpr MatchClause */ - def postfixExpr(location: Location = Location.ElseWhere): Tree = + def postfixExpr(location: Location = Location.Elsewhere): Tree = val t = postfixExprRest(prefixExpr(location), location) if location.inArgs && followingIsVararg() then Typed(t, atSpan(in.skipToken()) { Ident(tpnme.WILDCARD_STAR) }) @@ -2811,14 +2838,15 @@ object Parsers { */ val prefixExpr: Location => Tree = location => if in.token == IDENTIFIER && nme.raw.isUnary(in.name) - && in.canStartExprTokens.contains(in.lookahead.token) + && { + val lookahead = in.lookahead + in.canStartExprTokens.contains(lookahead.token) && lookahead.lineOffset < 0 + } then - val start = in.offset - val op = termIdent() - if (op.name == nme.raw.MINUS && isNumericLit) - simpleExprRest(literal(start), location, canApply = true) + if isNegatedNumber then + simpleExprRest(literal(start = in.skipToken()), location, canApply = true) else - atSpan(start) { PrefixOp(op, simpleExpr(location)) } + atSpan(in.offset) { PrefixOp(termIdent(), simpleExpr(location)) } else simpleExpr(location) /** SimpleExpr ::= ‘new’ ConstrApp {`with` ConstrApp} [TemplateBody] @@ -2876,17 +2904,17 @@ object Parsers { newExpr() case MACRO => val start = in.skipToken() - MacroTree(simpleExpr(Location.ElseWhere)) + MacroTree(simpleExpr(Location.Elsewhere)) case _ => if isLiteral then literal() else if in.isColon then - syntaxError(IllegalStartSimpleExpr(tokenString(in.token))) + syntaxError(IllegalStartSimpleExpr(tokenString(in.token).nn)) in.nextToken() simpleExpr(location) else val start = in.lastOffset - syntaxErrorOrIncomplete(IllegalStartSimpleExpr(tokenString(in.token)), expectedOffset) + syntaxErrorOrIncomplete(IllegalStartSimpleExpr(tokenString(in.token).nn), expectedOffset) errorTermTree(start) } simpleExprRest(t, location, canApply) @@ -2896,6 +2924,14 @@ object Parsers { if (canApply) argumentStart() in.token match case DOT => + t match + case Number(n, _) if n(0) == '-' => + val start = t.span.start + val span = Span(start, in.lastOffset) + warning(IllegalLiteral(), start) + unpatch(ctx.compilationUnit.source, span) + patch(span, s"($n)") + case _ => in.nextToken() simpleExprRest(selectorOrMatch(t), location, canApply = true) case LBRACKET => @@ -3314,30 +3350,46 @@ object Parsers { if (isIdent(nme.raw.BAR)) { in.nextToken(); pattern1(location) :: patternAlts(location) } else Nil + // After a pattern, accept colon and type or ascription per tree. + // Warn if old style ascription after pattern that is not a simple name. + // Warn mildly for case X: String, that is, introducing a "constant" id in a typed pattern. + def checkedAscription(pat: Tree, inPattern: Boolean = true)(tree: => Tree): Tree = + val atColon = in.isColon + tree.tap: tree => + if atColon then + val isIdent = unsplice(pat) match { + case x: Ident => + if inPattern && !x.name.isVarPattern then + val tpt = tree match + case Typed(_, tpt) => i"${tpt}" + case _ => "T" + report.warning(em"Typed pattern is not a variable pattern but could be written `${x.name} @ (_: $tpt)`", + pat.sourcePos) + true + case _ => false + } + if !isIdent && !pat.isInstanceOf[Number] then + report.errorOrMigrationWarning( + em"""Type ascriptions after patterns other than: + | * variable pattern, e.g. `case x: String =>` + | * number literal pattern, e.g. `case 10.5: Double =>` + |are no longer supported. Remove the type ascription or move it to a separate variable pattern.""", + pat.sourcePos, + MigrationVersion.AscriptionAfterPattern) + /** Pattern1 ::= PatVar `:` RefinedType * | [‘-’] integerLiteral `:` RefinedType * | [‘-’] floatingPointLiteral `:` RefinedType * | Pattern2 */ def pattern1(location: Location = Location.InPattern): Tree = - val p = pattern2(location) - if in.isColon then - val isVariable = unsplice(p) match { - case x: Ident => x.name.isVarPattern - case _ => false - } - val isVariableOrNumber = isVariable || p.isInstanceOf[Number] - if !isVariableOrNumber then - report.errorOrMigrationWarning( - em"""Type ascriptions after patterns other than: - | * variable pattern, e.g. `case x: String =>` - | * number literal pattern, e.g. `case 10.5: Double =>` - |are no longer supported. Remove the type ascription or move it to a separate variable pattern.""", - p.sourcePos, - MigrationVersion.AscriptionAfterPattern) - in.nextToken() - ascription(p, location) - else p + val pat = pattern2(location) + inline def maybeAscription = + if in.isColon then + in.nextToken() + ascription(pat, location) + else pat + checkedAscription(pat, inPattern = true)(maybeAscription) /** Pattern3 ::= InfixPattern */ @@ -3378,7 +3430,7 @@ object Parsers { def infixPattern(): Tree = infixOps( simplePattern(), in.canStartExprTokens, simplePatternFn, Location.InPattern, ParseKind.Pattern, - isOperator = in.name != nme.raw.BAR && !followingIsVararg() + isOperator = (in.name: TermName | Null) != (nme.raw.BAR: TermName | Null) && !followingIsVararg() && nextCanFollowOperator(canStartPatternTokens)) /** SimplePattern ::= PatVar @@ -3395,9 +3447,8 @@ object Parsers { */ def simplePattern(): Tree = in.token match { case IDENTIFIER | BACKQUOTED_IDENT | THIS | SUPER => - simpleRef() match - case id @ Ident(nme.raw.MINUS) if isNumericLit => literal(startOffset(id)) - case t => simplePatternRest(t) + if isNegatedNumber then literal(start = in.skipToken()) + else simplePatternRest(simpleRef()) case USCORE => wildcardIdent() case LPAREN => @@ -3433,7 +3484,9 @@ object Parsers { p = atSpan(startOffset(t), in.offset) { TypeApply(p, typeArgs(namedOK = false, wildOK = false)) } if (in.token == LPAREN) p = atSpan(startOffset(t), in.offset) { Apply(p, argumentPatterns()) } - p + p match + case nt: NameTree if isVarPattern(nt) => nt.checkPatternName + case p => p /** Patterns ::= Pattern [`,' Pattern] * | NamedPattern {‘,’ NamedPattern} @@ -3474,9 +3527,7 @@ object Parsers { case nme.transparent => Mod.Transparent() case nme.infix => Mod.Infix() case nme.tracked => Mod.Tracked() - case nme.into => - Feature.checkPreviewFeature("`into`", in.sourcePos()) - Mod.Into() + case nme.into => Mod.Into() case nme.erased if in.erasedEnabled => Mod.Erased() case nme.update if Feature.ccEnabled => Mod.Update() } @@ -3501,7 +3552,7 @@ object Parsers { mods.withAddedAnnotation(consumeAnnot) else val mod = atSpan(in.skipToken()): - modOfToken(tok, name) + modOfToken(tok, name.nn) if mods.isOneOf(mod.flags) then syntaxError(RepeatedModifier(mod.flags.flagsString, source, mod.span), mod.span) addMod(mods, mod) @@ -3795,11 +3846,11 @@ object Parsers { mods = addModifier(mods) mods |= Param } - atSpan(start, nameStart) { + atNameSpan(start) { val name = ident() match case nme.using if !in.isColon => val msg = ExpectedTokenButFoundSoftKeyword(expected = COLONop, found = in.token, nme.using, paramModAdvice) - val span = Span(in.offset, in.offset + (if in.name != null then in.name.show.length else 0)) + val span = Span(in.offset, in.offset + (if in.name != null then in.name.nn.show.length else 0)) val pickOne = if in.token == IDENTIFIER then while in.isSoftModifierInParamModifierPosition do ident() // skip to intended name, discard mods @@ -3856,7 +3907,7 @@ object Parsers { syntaxError(em"`using` expected") val (firstParamMod, paramsAreNamed) = var mods = EmptyModifiers - if in.lookahead.isColon then + if in.token != INTERPOLATIONID && in.lookahead.isColon then (mods, true) else if isConsume then (mods, true) else @@ -3865,8 +3916,8 @@ object Parsers { !impliedMods.is(Given) || startParamTokens.contains(in.token) || isIdent - && (in.name == nme.inline // inline starts a name binding - || in.name == nme.tracked // tracked starts a name binding under x.modularity + && (in.name.nn == nme.inline // inline starts a name binding + || in.name.nn == nme.tracked // tracked starts a name binding under x.modularity && in.featureEnabled(Feature.modularity) || in.lookahead.isColon) // a following `:` starts a name binding (mods, paramsAreNamed) @@ -3907,6 +3958,18 @@ object Parsers { /* -------- DEFS ------------------------------------------- */ def finalizeDef(md: MemberDef, mods: Modifiers, start: Int): md.ThisTree[Untyped] = + def checkName(): Unit = + def checkName(name: Name): Unit = + if !name.isEmpty + && !Chars.isOperatorPart(name.firstCodePoint) // warn a_: not :: + && name.endsWith(":") + then + report.warning(AmbiguousTemplateName(md), md.namePos) + md match + case md @ TypeDef(name, impl: Template) if impl.body.isEmpty && !md.isBackquoted => checkName(name) + case md @ ModuleDef(name, impl) if impl.body.isEmpty && !md.isBackquoted => checkName(name) + case _ => + checkName() md.withMods(mods).setComment(in.getDocComment(start)) type ImportConstr = (Tree, List[ImportSelector]) => Tree @@ -4108,10 +4171,17 @@ object Parsers { case _ => first :: Nil } - val tpt = typedOpt() + val tpt = checkedAscription(first, inPattern = false)(typedOpt()) val rhs = if tpt.isEmpty || in.token == EQUALS then - accept(EQUALS) + if tpt.isEmpty && in.token != EQUALS then + lhs match + case Ident(name) :: Nil if name.endsWith(":") => + val help = i"; identifier ends in colon, did you mean `${name.toSimpleName.dropRight(1)}`: in backticks?" + accept(EQUALS, help) + case _ => accept(EQUALS) + else + accept(EQUALS) val rhsOffset = in.offset subExpr() match case rhs0 @ Ident(name) if placeholderParams.nonEmpty && name == placeholderParams.head.name @@ -4209,6 +4279,10 @@ object Parsers { tpt = scalaUnit if (in.token == LBRACE) expr() else EmptyTree + else if in.token == IDENTIFIER && paramss.isEmpty && name.endsWith(":") then + val help = i"; identifier ends in colon, did you mean `${name.toSimpleName.dropRight(1)}`: in backticks?" + accept(EQUALS, help) + EmptyTree else if (!isExprIntro) syntaxError(MissingReturnType(), in.lastOffset) accept(EQUALS) @@ -4303,7 +4377,7 @@ object Parsers { case SEMI | NEWLINE | NEWLINES | COMMA | RBRACE | OUTDENT | EOF => makeTypeDef(typeAndCtxBounds(tname)) case _ if (staged & StageKind.QuotedPattern) != 0 - || sourceVersion.enablesNewGivens && in.isColon => + || (sourceVersion.enablesNewGivens && in.isColon && !mods.is(Opaque)) => makeTypeDef(typeAndCtxBounds(tname)) case _ => syntaxErrorOrIncomplete(ExpectedTypeBoundOrEquals(in.token)) @@ -4349,11 +4423,12 @@ object Parsers { /** ClassDef ::= id ClassConstr TemplateOpt */ def classDef(start: Offset, mods: Modifiers): TypeDef = - atSpan(start, nameStart): + val td = atNameSpan(start): val name = ident().toTypeName val constr = classConstr(if mods.is(Case) then ParamOwner.CaseClass else ParamOwner.Class) val templ = templateOpt(constr) - finalizeDef(TypeDef(name, templ), mods, start) + TypeDef(name, templ) + finalizeDef(td, mods, start) /** ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsTermParamClauses */ @@ -4371,11 +4446,12 @@ object Parsers { /** ObjectDef ::= id TemplateOpt */ - def objectDef(start: Offset, mods: Modifiers): ModuleDef = atSpan(start, nameStart) { - val name = ident() - val templ = templateOpt(emptyConstructor) - finalizeDef(ModuleDef(name, templ), mods, start) - } + def objectDef(start: Offset, mods: Modifiers): ModuleDef = + val md = atNameSpan(start): + val nameIdent = termIdent() + val templ = templateOpt(emptyConstructor) + ModuleDef(nameIdent.name.asTermName, templ) + finalizeDef(md, mods, start) // We allow `infix` and `into` on `enum` definitions. // Syntax rules disallow these soft infix modifiers on `case`s. @@ -4392,14 +4468,13 @@ object Parsers { /** EnumDef ::= id ClassConstr InheritClauses EnumBody */ - def enumDef(start: Offset, mods: Modifiers): TypeDef = atSpan(start, nameStart) { + def enumDef(start: Offset, mods: Modifiers): TypeDef = atNameSpan(start): val mods1 = checkEnumModifiers(mods, "") val modulName = ident() val clsName = modulName.toTypeName val constr = classConstr(ParamOwner.Class) val templ = template(constr, isEnum = true) finalizeDef(TypeDef(clsName, templ), mods1, start) - } /** EnumCase = `case' (id ClassConstr [`extends' ConstrApps] | ids) */ @@ -4609,7 +4684,7 @@ object Parsers { Template(constr, parents, Nil, EmptyValDef, Nil) else if !newSyntaxAllowed || in.token == WITH && tparams.isEmpty && vparamss.isEmpty - // if new syntax is still allowed and there are parameters, they mist be new style conditions, + // if new syntax is still allowed and there are parameters, they must be new style conditions, // so old with-style syntax would not be allowed. then withTemplate(constr, parents) diff --git a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala index 1ff4e1609083..32ba1dc36765 100644 --- a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala +++ b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package parsing -import scala.language.unsafeNulls - import core.Names.*, core.Contexts.*, core.Decorators.*, util.Spans.* import core.StdNames.*, core.Comments.* import util.SourceFile @@ -20,7 +18,8 @@ import config.Feature import config.Feature.{migrateTo3, sourceVersion} import config.SourceVersion.{`3.0`, `3.0-migration`} import config.MigrationVersion -import reporting.{NoProfile, Profile, Message} +import reporting.* +import cc.SafeRefs import java.util.Objects import dotty.tools.dotc.reporting.Message.rewriteNotice @@ -55,10 +54,10 @@ object Scanners { var lineOffset: Offset = -1 /** the name of an identifier */ - var name: SimpleName = null + var name: SimpleName | Null = null /** the string value of a literal */ - var strVal: String = null + var strVal: String | Null = null /** the base of a number */ var base: Int = 0 @@ -76,7 +75,7 @@ object Scanners { def isNewLine = token == NEWLINE || token == NEWLINES def isStatSep = isNewLine || token == SEMI def isIdent = token == IDENTIFIER || token == BACKQUOTED_IDENT - def isIdent(name: Name) = token == IDENTIFIER && this.name == name + def isIdent(name: Name) = token == IDENTIFIER && (this.name: Name | Null) == (name: Name | Null) def isNestedStart = token == LBRACE || token == INDENT def isNestedEnd = token == RBRACE || token == OUTDENT @@ -89,7 +88,7 @@ object Scanners { def isOperator = token == BACKQUOTED_IDENT - || token == IDENTIFIER && isOperatorPart(name(name.length - 1)) + || token == IDENTIFIER && isOperatorPart(name.nn(name.nn.length - 1)) def isArrow = token == ARROW || token == CTXARROW @@ -148,11 +147,14 @@ object Scanners { * If `target` is different from `this`, don't treat identifiers as end tokens. */ def finishNamedToken(idtoken: Token, target: TokenData): Unit = - target.name = termName(litBuf.chars, 0, litBuf.length) + val name = termName(litBuf.chars, 0, litBuf.length) + target.name = name litBuf.clear() + if name.contains('$') && Feature.safeEnabled && !SafeRefs.allowDollarIn(name) then + report.error(em"Identifier may not contain '$$' in safe mode", sourcePos()) target.token = idtoken if idtoken == IDENTIFIER then - val converted = toToken(target.name) + val converted = toToken(target.name.nn) if converted != END || (target eq this) then target.token = converted /** The token for given `name`. Either IDENTIFIER or a keyword. */ @@ -163,9 +165,9 @@ object Scanners { strVal = litBuf.toString litBuf.clear() - @inline def isNumberSeparator(c: Char): Boolean = c == '_' + inline def isNumberSeparator(c: Char): Boolean = c == '_' - @inline def removeNumberSeparators(s: String): String = if (s.indexOf('_') == -1) s else s.replace("_", "") + def removeNumberSeparators(s: String): String = if (s.indexOf('_') == -1) s else s.replace("_", "") // disallow trailing numeric separator char, but continue lexing def checkNoTrailingSeparator(): Unit = @@ -283,7 +285,8 @@ object Scanners { private def lastKnownIndentWidth: IndentWidth = def recur(r: Region): IndentWidth = - if r.knownWidth == null then recur(r.enclosing) else r.knownWidth + val knownWidth = r.knownWidth + if knownWidth == null then recur(r.enclosing) else knownWidth recur(currentRegion) private var skipping = false @@ -604,7 +607,7 @@ object Scanners { case r => indentIsSignificant = indentSyntax r.proposeKnownWidth(nextWidth, lastToken) - lastWidth = r.knownWidth + lastWidth = r.indentWidth newlineIsSeparating = r.isInstanceOf[InBraces] // can emit OUTDENT if line is not non-empty blank line at EOF @@ -656,7 +659,7 @@ object Scanners { if r.enclosing.isClosedByUndentAt(nextWidth) then insert(OUTDENT, offset) else if r.isInstanceOf[InBraces] && !closingRegionTokens.contains(token) then - report.warning("Line is indented too far to the left, or a `}` is missing", sourcePos()) + report.warning(IndentationWarning(isLeft = true, missing = RBRACE), sourcePos()) else if lastWidth < nextWidth || lastWidth == nextWidth && (lastToken == MATCH || lastToken == CATCH) && token == CASE then if canStartIndentTokens.contains(lastToken) then @@ -724,7 +727,7 @@ object Scanners { case r: Indented if !r.isOutermost && (acceptOutdentTokens.contains(token) - || token == COMMA && r.outer.commasExpectedInEnclosing) + || token == COMMA && r.outer.nn.commasExpectedInEnclosing) // nn ok, we are not the outermost region && next.token == EMPTY => insert(OUTDENT, offset) @@ -747,7 +750,7 @@ object Scanners { * SEMI + ELSE => ELSE, COLON following id/)/] => COLONfollow * - Insert missing OUTDENTs at EOF */ - def postProcessToken(lastToken: Token, lastName: SimpleName): Unit = { + def postProcessToken(lastToken: Token, lastName: SimpleName | Null): Unit = { def fuse(tok: Int) = { token = tok offset = prev.offset @@ -918,21 +921,7 @@ object Scanners { putChar('/') getOperatorRest() } - case '0' => - def fetchLeadingZero(): Unit = { - nextChar() - ch match { - case 'x' | 'X' => base = 16 ; nextChar() - case 'b' | 'B' => base = 2 ; nextChar() - case _ => base = 10 ; putChar('0') - } - if (base != 10 && !isNumberSeparator(ch) && digit2int(ch, base) < 0) - error(em"invalid literal number") - } - fetchLeadingZero() - getNumber() - case '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' => - base = 10 + case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' => getNumber() case '`' => getBackquotedIdent() @@ -1163,9 +1152,9 @@ object Scanners { if (ch == '`') { nextChar() finishNamedToken(BACKQUOTED_IDENT, target = this) - if (name.length == 0) + if (name.nn.length == 0) error(em"empty quoted identifier") - else if (name == nme.WILDCARD) + else if (name.nn == nme.WILDCARD) error(em"wildcard invalid as backquoted identifier") } else error(em"unclosed quoted identifier") @@ -1227,11 +1216,14 @@ object Scanners { def isSoftModifier: Boolean = token == IDENTIFIER - && (softModifierNames.contains(name) - || name == nme.erased && erasedEnabled - || name == nme.tracked && trackedEnabled - || name == nme.update && Feature.ccEnabled - || name == nme.consume && Feature.ccEnabled) + && { + val name = this.name.nn + (softModifierNames.contains(name) + || name == nme.erased && erasedEnabled + || name == nme.tracked && trackedEnabled + || name == nme.update && Feature.ccEnabled + || name == nme.consume && Feature.ccEnabled) + } def isSoftModifierInModifierPosition: Boolean = isSoftModifier && inModifierPosition() @@ -1502,9 +1494,21 @@ object Scanners { if (isIdentifierPart(ch) && ch >= ' ') error(em"Invalid literal number") - /** Read a number into strVal and set base - */ - protected def getNumber(): Unit = { + /** Read a number into strVal and set base and token. + */ + def getNumber(): Unit = { + def checkNumberChar() = + if !isNumberSeparator(ch) && digit2int(ch, base) < 0 then + error(em"invalid literal number") + if ch == '0' then + nextChar() + ch match + case 'x' | 'X' => base = 16; nextChar(); checkNumberChar() + case 'b' | 'B' => base = 2; nextChar(); checkNumberChar() + case _ => base = 10; putChar('0') + else + base = 10 + while (isNumberSeparator(ch) || digit2int(ch, base) >= 0) { putChar(ch) nextChar() @@ -1527,9 +1531,7 @@ object Scanners { token = LONGLIT case _ => } - checkNoTrailingSeparator() - setStrVal() } @@ -1619,7 +1621,8 @@ object Scanners { /** The indentation width, Zero if not known */ final def indentWidth: IndentWidth = - if knownWidth == null then IndentWidth.Zero else knownWidth + val known = knownWidth + if known == null then IndentWidth.Zero else known def proposeKnownWidth(width: IndentWidth, lastToken: Token) = if knownWidth == null then @@ -1663,10 +1666,11 @@ object Scanners { def commasExpectedInEnclosing: Boolean = commasExpected || this.match - case r: Indented => r.outer.commasExpectedInEnclosing + case r: Indented => !r.isOutermost && r.outer.nn.commasExpectedInEnclosing case _ => false def toList: List[Region] = + val outer = this.outer this :: (if outer == null then Nil else outer.toList) private def delimiter = this match diff --git a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala index cb2a793b3936..a9fca198ae0c 100644 --- a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala +++ b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package parsing -import scala.language.unsafeNulls - import collection.immutable.BitSet import core.Decorators.* import core.StdNames.nme @@ -16,7 +14,7 @@ abstract class TokensCommon { def tokenRange(lo: Int, hi: Int): TokenSet = BitSet(lo to hi *) - val tokenString, debugString: Array[String] = new Array[String](maxToken + 1) + val tokenString, debugString: Array[String | Null] = new Array[String | Null](maxToken + 1) def enter(token: Int, str: String, debugStr: String = ""): Unit = { assert(tokenString(token) == null) @@ -128,7 +126,7 @@ abstract class TokensCommon { inline val lastParen = OUTDENT def buildKeywordArray(keywords: TokenSet): (Int, Array[Int]) = { - def start(tok: Token) = tokenString(tok).toTermName.asSimpleName.start + def start(tok: Token) = tokenString(tok).nn.toTermName.asSimpleName.start def sourceKeywords = keywords.toList.filter { (kw: Token) => val ts = tokenString(kw) (ts != null) && !ts.contains(' ') @@ -306,10 +304,10 @@ object Tokens extends TokensCommon { final val softModifierNames = Set(nme.inline, nme.into, nme.opaque, nme.open, nme.transparent, nme.infix) // Note: update, consume and erased are missing here since they are only modifiers under some import - def showTokenDetailed(token: Int): String = debugString(token) + def showTokenDetailed(token: Int): String = debugString(token).nn def showToken(token: Int): String = { - val str = tokenString(token) + val str = tokenString(token).nn if isKeyword(token) || token == COLONfollow || token == COLONeol then s"'$str'" else str } } diff --git a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala index 84e77547662c..9d3c74ac00d6 100644 --- a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala +++ b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala @@ -3,7 +3,6 @@ package dotc package parsing package xml -import scala.language.unsafeNulls import scala.compiletime.uninitialized import scala.collection.mutable @@ -78,8 +77,9 @@ object MarkupParsers { import parser.{ symbXMLBuilder => handle } - def curOffset : Int = input.charOffset - 1 - var tmppos : Span = NoSpan + def curOffset: Int = input.lastCharOffset + + var tmppos: Span = NoSpan def ch: Char = input.ch /** this method assign the next character to ch and advances in input */ def nextch(): Unit = { input.nextChar() } @@ -170,10 +170,8 @@ object MarkupParsers { xTakeUntil(handle.charData, () => Span(start, curOffset, mid), "]]>") } - def xUnparsed: Tree = { - val start = curOffset + def xUnparsed(start: Int): Tree = xTakeUntil(handle.unparsed, () => Span(start, curOffset, start), "") - } /** Comment ::= '' * @@ -277,7 +275,7 @@ object MarkupParsers { * | xmlTag1 '/' '>' */ def element: Tree = { - val start = curOffset // FIXME should be `curOffset - 1` (scalatest and tests/neg/i19100.scala must be updated) + val start = curOffset - 1 // include < val (qname, attrMap) = xTag(()) if (ch == '/') { // empty element xToken("/>") @@ -286,7 +284,7 @@ object MarkupParsers { else { // handle content xToken('>') if (qname == "xml:unparsed") - return xUnparsed + return xUnparsed(start) debugLastStartElement = (start, qname) :: debugLastStartElement val ts = content @@ -364,7 +362,7 @@ object MarkupParsers { handle.isPattern = false val ts = new ArrayBuffer[Tree] - val start = curOffset + val start = curOffset - 1 // include <, start == parser.in.offset tmppos = Span(curOffset) // Iuli: added this line, as it seems content_LT uses tmppos when creating trees content_LT(ts) @@ -435,7 +433,7 @@ object MarkupParsers { * | Name [S] '/' '>' */ def xPattern: Tree = { - var start = curOffset // FIXME should be `curOffset - 1` (scalatest and tests/neg/i19100.scala must be updated) + val start = curOffset - 1 // include < val qname = xName debugLastStartElement = (start, qname) :: debugLastStartElement xSpaceOpt() diff --git a/compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala b/compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala index 58701a83639c..486efdc26891 100644 --- a/compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala +++ b/compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala @@ -3,7 +3,6 @@ package dotc package parsing package xml -import scala.language.unsafeNulls import scala.compiletime.uninitialized import scala.collection.mutable @@ -55,6 +54,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) { val _Null: TermName = "Null" val __Elem: TermName = "Elem" val __Text: TermName = "Text" + val _TopScope: TermName = "TopScope" val _buf: TermName = "$buf" val _md: TermName = "$md" val _plus: TermName = "&+" @@ -66,17 +66,19 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) { import xmltypes.{_Comment, _Elem, _EntityRef, _Group, _MetaData, _NamespaceBinding, _NodeBuffer, _PrefixedAttribute, _ProcInstr, _Text, _Unparsed, _UnprefixedAttribute} - import xmlterms.{_Null, __Elem, __Text, _buf, _md, _plus, _scope, _tmpscope, _xml, _toVector} + import xmlterms.{_Null, __Elem, __Text, _TopScope, _buf, _md, _plus, _scope, _tmpscope, _xml, + _toVector} // convenience methods private def LL[A](x: A*): List[List[A]] = List(x.toList) - // Changing type to String causes a compiler crash in pickler phase, - // so we leave it as Any for now. - private def const(x: Any) = - val lit = Literal(Constant(x)) - if ctx.explicitNulls && x == null + private def const(x: String): Tree = Literal(Constant(x)) + + private def nullAsString: Tree = + val lit = Literal(Constant(null)) + if ctx.explicitNulls then TypeApply(Select(lit, nme.asInstanceOf_), TypeTree(defn.StringType) :: Nil) else lit + private def wild = Ident(nme.WILDCARD) private def wildStar = Ident(tpnme.WILDCARD_STAR) private def _scala(name: Name) = scalaDot(name) @@ -93,6 +95,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) { private def _scala_xml_PrefixedAttribute = _scala_xml(_PrefixedAttribute) private def _scala_xml_ProcInstr = _scala_xml(_ProcInstr) private def _scala_xml_Text = _scala_xml(_Text) + private def _scala_xml_TopScope = _scala_xml(_TopScope) private def _scala_xml_Unparsed = _scala_xml(_Unparsed) private def _scala_xml_UnprefixedAttribute= _scala_xml(_UnprefixedAttribute) private def _scala_xml__Elem = _scala_xml(__Elem) @@ -145,7 +148,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) { case (Some(pre), rest) => (const(pre), const(rest)) case _ => (wild, const(n)) } - mkXML(span, true, prepat, labpat, null, null, false, args) + mkXML(span, true, prepat, labpat, _scala_xml_Null, _scala_xml_TopScope, false, args) } protected def convertToTextPat(t: Tree): Tree = t match { @@ -192,15 +195,15 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) { atSpan(span)( New(_scala_xml_Unparsed, LL(const(str))) ) def element(span: Span, qname: String, attrMap: mutable.Map[String, Tree], empty: Boolean, args: collection.Seq[Tree]): Tree = { - def handleNamespaceBinding(pre: String, z: String): Tree = { + def handleNamespaceBinding(pre: Tree, z: String): Tree = { def mkAssign(t: Tree): Tree = Assign( Ident(_tmpscope), - New(_scala_xml_NamespaceBinding, LL(const(pre), t, Ident(_tmpscope))) + New(_scala_xml_NamespaceBinding, LL(pre, t, Ident(_tmpscope))) ) val uri1 = attrMap(z) match { case Apply(_, List(uri @ Literal(Constant(_)))) => mkAssign(uri) - case Select(_, nme.Nil) => mkAssign(const(null)) // allow for xmlns="" -- bug #1626 + case Select(_, nme.Nil) => mkAssign(nullAsString) // allow for xmlns="" -- bug #1626 case x => mkAssign(x) } attrMap -= z @@ -211,18 +214,18 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) { val namespaces: List[Tree] = for z <- attrMap.keys.toList if z.startsWith("xmlns") yield { val ns = splitPrefix(z) match { - case (Some(_), rest) => rest - case _ => null + case (Some(_), rest) => const(rest) + case _ => nullAsString } handleNamespaceBinding(ns, z) } val (pre, newlabel) = splitPrefix(qname) match { - case (Some(p), x) => (p, x) - case (None, x) => (null, x) + case (Some(p), x) => (const(p), x) + case (None, x) => (nullAsString, x) } - def mkAttributeTree(pre: String, key: String, value: Tree) = atSpan(span.toSynthetic) { + def mkAttributeTree(pre: String | Null, key: String, value: Tree) = atSpan(span.toSynthetic) { // XXX this is where we'd like to put Select(value, nme.toString_) for #1787 // after we resolve the Some(foo) situation. val baseArgs = List(const(key), value, Ident(_md)) @@ -258,7 +261,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(using Context) { val body = mkXML( span.toSynthetic, false, - const(pre), + pre, const(newlabel), makeSymbolicAttrs, Ident(_scope), diff --git a/compiler/src/dotty/tools/dotc/parsing/xml/Utility.scala b/compiler/src/dotty/tools/dotc/parsing/xml/Utility.scala index 6577030ec671..a9d90d6d87d4 100644 --- a/compiler/src/dotty/tools/dotc/parsing/xml/Utility.scala +++ b/compiler/src/dotty/tools/dotc/parsing/xml/Utility.scala @@ -2,8 +2,6 @@ package dotty.tools.dotc package parsing package xml -import scala.language.unsafeNulls - import scala.collection.mutable /** @@ -29,12 +27,12 @@ object Utility { * * @return `'''null'''` if `ref` was not a predefined entity. */ - private final def unescape(ref: String, s: StringBuilder): StringBuilder = + private final def unescape(ref: String, s: StringBuilder): StringBuilder | Null = ((unescMap get ref) map (s append _)).orNull def parseAttributeValue[T](value: String, text: String => T, entityRef: String => T): List[T] = { val sb = new StringBuilder - var rfb: StringBuilder = null + var rfb: StringBuilder | Null = null val nb = new mutable.ListBuffer[T]() val it = value.iterator @@ -170,4 +168,3 @@ object Utility { s.nonEmpty && isNameStart(s.head) && (s.tail forall isNameChar) } - diff --git a/compiler/src/dotty/tools/dotc/plugins/Plugin.scala b/compiler/src/dotty/tools/dotc/plugins/Plugin.scala index c0532944c9de..de70138d58cf 100644 --- a/compiler/src/dotty/tools/dotc/plugins/Plugin.scala +++ b/compiler/src/dotty/tools/dotc/plugins/Plugin.scala @@ -1,8 +1,6 @@ package dotty.tools.dotc package plugins -import scala.language.unsafeNulls - import core.* import Contexts.* import Phases.* @@ -103,15 +101,13 @@ object Plugin { /** Use a class loader to load the plugin class. */ def load(classname: String, loader: ClassLoader): Try[AnyClass] = { - import scala.util.control.NonFatal try Success[AnyClass](loader.loadClass(classname)) - catch { - case NonFatal(e) => + catch + case e: Exception => Failure(new PluginLoadException(classname, s"Error: unable to load class $classname: ${e.getMessage}")) case e: NoClassDefFoundError => Failure(new PluginLoadException(classname, s"Error: class not found: ${e.getMessage} required by $classname")) - } } /** Load all plugins specified by the arguments. @@ -144,7 +140,7 @@ object Plugin { def loadDescriptionFromJar(jarp: Path): Try[String] = { // XXX Return to this once we have more ARM support - def read(is: InputStream) = + def read(is: InputStream | Null) = if (is == null) throw new PluginLoadException(jarp.path, s"Missing $PluginFile in $jarp") else fromFile(is, jarp) @@ -210,7 +206,7 @@ object Plugin { def instantiate(clazz: AnyClass): Plugin = clazz.getConstructor().newInstance().asInstanceOf[Plugin] } -class PluginLoadException(val path: String, message: String, cause: Exception) extends Exception(message, cause) { +class PluginLoadException(val path: String, message: String, cause: Exception | Null) extends Exception(message, cause) { def this(path: String, message: String) = this(path, message, null) } diff --git a/compiler/src/dotty/tools/dotc/plugins/Plugins.scala b/compiler/src/dotty/tools/dotc/plugins/Plugins.scala index 04d12a670f2b..5f4dbfd6e7a1 100644 --- a/compiler/src/dotty/tools/dotc/plugins/Plugins.scala +++ b/compiler/src/dotty/tools/dotc/plugins/Plugins.scala @@ -35,7 +35,7 @@ trait Plugins { } val maybes = Plugin.loadAllFrom(paths, dirs, ctx.settings.disable.value) val (goods, errors) = maybes partition (_.isSuccess) - // Explicit parameterization of recover to avoid -Xlint warning about inferred Any + // Explicit parameterization of recover to avoid -Wshadow warning about inferred Any errors foreach (_.recover[Any] { // legacy behavior ignores altogether, so at least warn devs case e: MissingPluginException => report.warning(e.getMessage) diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala index c245b201d189..b47d9c2b42ee 100644 --- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala +++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala @@ -12,7 +12,6 @@ import typer.Implicits.* import typer.ImportInfo import Variances.varianceSign import util.{Chars, SourcePosition} -import scala.util.control.NonFatal import scala.annotation.switch import config.{Config, Feature} import ast.{tpd, untpd} @@ -90,7 +89,7 @@ class PlainPrinter(_ctx: Context) extends Printer { else tp private def sameBound(lo: Type, hi: Type): Boolean = - try lo frozen_=:= hi catch { case NonFatal(ex) => false } + try lo frozen_=:= hi catch { case ex: Exception => false } private def homogenizeArg(tp: Type) = tp match { case TypeBounds(lo, hi) if homogenizedView && sameBound(lo, hi) => homogenize(hi) @@ -355,7 +354,7 @@ class PlainPrinter(_ctx: Context) extends Printer { case tp: LazyRef => def refTxt = try toTextGlobal(tp.ref) - catch case _: Throwable => Str("...") // reconsider catching errors + catch case _: Exception => Str("...") // reconsider catching errors "LazyRef(" ~ refTxt ~ ")" case Range(lo, hi) => toText(lo) ~ ".." ~ toText(hi) @@ -398,8 +397,7 @@ class PlainPrinter(_ctx: Context) extends Printer { /** If -uniqid is set, the hashcode of the type, after a # */ protected def hashStr(tp: Type): String = if showUniqueIds then - try "#" + tp.hashCode - catch case ex: NullPointerException => "" + "#" + tp.hashCode else "" /** A string to append to a symbol composed of: @@ -575,10 +573,11 @@ class PlainPrinter(_ctx: Context) extends Printer { case hi => hi.derivesFromCapSet) /** Print capture variable bounds using `^` syntax. - * Plain CapSet lower bound and universal upper bound are elided. + * Plain CapSet lower bound, empty lower bound, and universal upper bound are elided. */ private def toTextCaptureVarBounds(lo: Type, hi: Type): Text = val loText = lo match + case CapturingType(_, refs: CaptureSet) if refs.elems.isEmpty && !ccVerbose => Text() // empty lower bound case CapturingType(_, refs) => " >: " ~ toTextCaptureSet(refs) case _ => Text() // plain CapSet = trivial lower bound val hiText = hi match diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala index 8937213da9fe..61d19be49f8f 100644 --- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala +++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala @@ -179,7 +179,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) { val (printPure, refsText) = if refs == null then (isPure, Str("")) else if isElidableUniversal(refs) then (false, Str("")) - else (isPure, toTextGeneralCaptureSet(refs)) + else refs match + case cs: CaptureSet if cs.isConst && cs.elems.isEmpty => (true, Str("")) + case _ => (isPure, toTextGeneralCaptureSet(refs)) arrow(isContextual, printPure) ~ refsText private def toTextFunction(args: List[Type], res: Type, fn: MethodType | AppliedType, @@ -340,7 +342,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) { toText(elemtp) ~ "[]" case tp: LazyRef if !printDebug => try toText(tp.ref) - catch case ex: Throwable => "..." + catch case _: Exception => "..." case sel: cc.PathSelectionProto => "?.{ " ~ toText(sel.selector) ~ "}" case AnySelectionProto => diff --git a/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala b/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala index fd30beb0bb5a..4ddd4cc686ba 100644 --- a/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala +++ b/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala @@ -75,10 +75,10 @@ object SyntaxHighlighting { case _ if alphaKeywords.contains(token) || isSoftModifier => highlightRange(start, end, KeywordColor) - case IDENTIFIER if name == nme.??? => + case IDENTIFIER if name.nn == nme.??? => highlightRange(start, end, Console.RED_B) - case IDENTIFIER if name.head.isUpper && name.exists(!_.isUpper) => + case IDENTIFIER if name.nn.head.isUpper && name.nn.exists(!_.isUpper) => highlightRange(start, end, KeywordColor) case _ => diff --git a/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala b/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala index 8ee81c94f735..7317e9b2e499 100644 --- a/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala +++ b/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala @@ -15,13 +15,12 @@ package dotty.tools.dotc.profile import java.io.Closeable import java.lang.management.ManagementFactory -import java.nio.file.{Files, Path} -import java.util +import java.nio.file.Path import java.util.concurrent.TimeUnit import scala.collection.mutable -object ChromeTrace { +private [profile] object ChromeTrace { private object EventType { final val Start = "B" final val Instant = "I" @@ -36,9 +35,9 @@ object ChromeTrace { } } -/** Allows writing a subset of captrue traces based on https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview# +/** Allows writing a subset of capture traces based on https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview# * Can be visualized using https://ui.perfetto.dev/, Chrome's about://tracing (outdated) or the tooling in https://www.google.com.au/search?q=catapult+tracing&oq=catapult+tracing+&aqs=chrome..69i57.3974j0j4&sourceid=chrome&ie=UTF-8 */ -final class ChromeTrace(f: Path) extends Closeable { +private [profile] final class ChromeTrace(f: Path) extends Closeable { import ChromeTrace.EventType private val traceWriter = FileUtils.newAsyncBufferedWriter(f) private val context = mutable.Stack[JsonContext](TopContext) diff --git a/compiler/src/dotty/tools/dotc/profile/FileUtils.scala b/compiler/src/dotty/tools/dotc/profile/FileUtils.scala index 28507d08bcd3..ef34d9f514ff 100644 --- a/compiler/src/dotty/tools/dotc/profile/FileUtils.scala +++ b/compiler/src/dotty/tools/dotc/profile/FileUtils.scala @@ -14,8 +14,6 @@ package dotty.tools.dotc.profile -import scala.language.unsafeNulls - import java.io.{BufferedWriter, IOException, OutputStreamWriter, Writer} import java.nio.CharBuffer import java.nio.charset.{Charset, CharsetEncoder, StandardCharsets} @@ -28,9 +26,8 @@ import scala.concurrent.duration.Duration import scala.concurrent.{Await, Promise} import scala.util.{Failure, Success} import scala.annotation.internal.sharable -import compiletime.uninitialized -object FileUtils { +private [profile] object FileUtils { def newAsyncBufferedWriter(path: Path, charset: Charset = StandardCharsets.UTF_8.nn, options: Array[OpenOption] = NO_OPTIONS, threadsafe: Boolean = false): LineWriter = { val encoder: CharsetEncoder = charset.newEncoder val writer = new OutputStreamWriter(Files.newOutputStream(path, options*), encoder) @@ -140,7 +137,7 @@ object FileUtils { override def close(): Unit = { background.ensureProcessed(current) background.ensureProcessed(AsyncBufferedWriter.Close) - current = null + current = null.asInstanceOf[CharBuffer] // deinit for GC Await.result(background.asyncStatus.future, Duration.Inf) underlying.close() } @@ -149,10 +146,10 @@ object FileUtils { import scala.concurrent.ExecutionContext.Implicits.global private val pending = new LinkedBlockingQueue[CharBuffer] - //a failure detected will case an Failure, Success indicates a close + //a failure detected will cause a Failure, Success indicates a close val asyncStatus = Promise[Unit]() private val scheduled = new AtomicBoolean - @volatile var reuseBuffer: CharBuffer = uninitialized + @volatile var reuseBuffer: CharBuffer | Null = null def ensureProcessed(buffer: CharBuffer): Unit = { if (asyncStatus.isCompleted) { @@ -187,9 +184,9 @@ object FileUtils { } } } catch { - case t: Throwable => - asyncStatus.tryFailure(t) - throw t + case ex: Exception => + asyncStatus.tryFailure(ex) + throw ex } finally scheduled.set(false) @@ -202,4 +199,4 @@ object FileUtils { } } } -} \ No newline at end of file +} diff --git a/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala b/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala index 8777a95c33cf..bba76179a65a 100644 --- a/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala +++ b/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala @@ -3,7 +3,7 @@ package dotty.tools.dotc.profile import scala.annotation.internal.sharable // Based on NameTransformer but dedicated for JSON encoding rules -object JsonNameTransformer { +private [profile] object JsonNameTransformer { private val nops = 128 @sharable private val op2code = new Array[String](nops) diff --git a/compiler/src/dotty/tools/dotc/profile/ProfiledThreadPool.scala b/compiler/src/dotty/tools/dotc/profile/ProfiledThreadPool.scala new file mode 100644 index 000000000000..7f9437ba2caa --- /dev/null +++ b/compiler/src/dotty/tools/dotc/profile/ProfiledThreadPool.scala @@ -0,0 +1,116 @@ +package dotty.tools.dotc.profile + +import java.util.concurrent.* +import java.util.concurrent.atomic.AtomicInteger +import dotty.tools.dotc.core.Phases.Phase + +import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy + +object ProfiledThreadPool { + def newExecutor(phase: Phase, profiler: Profiler, nThreads: Int, maxQueueSize: Int, shortId: String): ThreadPoolExecutor = { + val factory = profiler match { + case NoOpProfiler => new ThreadPoolFactory(phase) + case r: RealProfiler => new ProfilingThreadPoolFactory(phase, r) + } + factory.newBoundedQueueFixedThreadPool(nThreads, maxQueueSize, shortId) + } +} + +private[profile] class ThreadPoolFactory(phase: Phase) { + private val baseGroup = new ThreadGroup(s"dotc-${phase.phaseName}") + + def newBoundedQueueFixedThreadPool(nThreads: Int, maxQueueSize: Int, shortId: String): ThreadPoolExecutor = { + val threadFactory = new CommonThreadFactory(shortId) + //like Executors.newFixedThreadPool + new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue[Runnable](maxQueueSize), threadFactory, new CallerRunsPolicy()) + } + + private def childGroup(name: String) = new ThreadGroup(baseGroup, name) + + // Invoked when a new `Worker` is created, see `CommonThreadFactory.newThread` + protected def wrapWorker(worker: Runnable, shortId:String): Runnable = worker + + protected final class CommonThreadFactory(shortId: String) extends ThreadFactory { + private val group: ThreadGroup = childGroup(shortId) + private val threadNumber: AtomicInteger = new AtomicInteger(1) + private val namePrefix = s"${baseGroup.getName}-$shortId-" + + // Invoked by the `ThreadPoolExecutor` when creating a new worker thread. The argument + // runnable is the `Worker` (which extends `Runnable`). Its `run` method gets tasks from + // the thread pool and executes them (on the thread created here). + override def newThread(worker: Runnable): Thread = { + val wrapped = wrapWorker(worker, shortId) + val t: Thread = new Thread(group, wrapped, namePrefix + threadNumber.getAndIncrement, 0) + if (!t.isDaemon) t.setDaemon(true) + if (t.getPriority != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY) + t + } + } +} + +private[profile] final class ProfilingThreadPoolFactory(phase: Phase, private val profiler: RealProfiler) extends ThreadPoolFactory(phase) { + + override def newBoundedQueueFixedThreadPool(nThreads: Int, maxQueueSize: Int, shortId: String): ThreadPoolExecutor = { + val threadFactory = new CommonThreadFactory(shortId) + //like Executors.newFixedThreadPool + new SinglePhaseInstrumentedThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue[Runnable](maxQueueSize), threadFactory) + } + + override protected def wrapWorker(worker: Runnable, shortId: String): Runnable = { + () => + val data = new ThreadProfileData + localData.set(data) + + val profileStart = RealProfiler.snapThread(0) + try worker.run() finally { + val snap = RealProfiler.snapThread(data.idleNs) + val threadRange = ProfileRange(profileStart, snap, phase, shortId, data.taskCount, Thread.currentThread()) + profiler.completeBackground(threadRange) + } + } + + /** + * data for thread run. Not threadsafe, only written from a single thread + */ + private final class ThreadProfileData { + var firstStartNs = 0L + var taskCount = 0 + + var idleNs = 0L + var runningNs = 0L + + var lastStartNs = 0L + var lastEndNs = 0L + } + + private val localData = new ThreadLocal[ThreadProfileData] + + private class SinglePhaseInstrumentedThreadPoolExecutor + ( corePoolSize: Int, maximumPoolSize: Int, keepAliveTime: Long, unit: TimeUnit, + workQueue: BlockingQueue[Runnable], threadFactory: ThreadFactory + ) extends ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, new CallerRunsPolicy()) { + + override def beforeExecute(t: Thread, r: Runnable): Unit = { + val data = localData.get + data.taskCount += 1 + val now = System.nanoTime() + + if (data.firstStartNs == 0) data.firstStartNs = now + else data.idleNs += now - data.lastEndNs + + data.lastStartNs = now + + super.beforeExecute(t, r) + } + + override def afterExecute(r: Runnable, t: Throwable): Unit = { + val now = System.nanoTime() + val data = localData.get + + data.lastEndNs = now + data.runningNs += now - data.lastStartNs + + super.afterExecute(r, t) + } + } +} diff --git a/compiler/src/dotty/tools/dotc/profile/Profiler.scala b/compiler/src/dotty/tools/dotc/profile/Profiler.scala index 7573251302e8..12bbbad9e060 100644 --- a/compiler/src/dotty/tools/dotc/profile/Profiler.scala +++ b/compiler/src/dotty/tools/dotc/profile/Profiler.scala @@ -19,6 +19,7 @@ import dotty.tools.io.AbstractFile import annotation.internal.sharable import dotty.tools.dotc.core.Periods.InitialRunId import scala.collection.mutable.UnrolledBuffer +import scala.jdk.CollectionConverters.* object Profiler { def apply()(using Context): Profiler = @@ -35,18 +36,18 @@ object Profiler { private[profile] val emptySnap: ProfileSnap = ProfileSnap(0, "", 0, 0, 0, 0, 0, 0, 0, 0) } -case class GcEventData(pool:String, reportTimeNs: Long, gcStartMillis:Long, gcEndMillis:Long, durationMillis: Long, name:String, action:String, cause:String, threads:Long){ - val endNanos = System.nanoTime() +private [profile] case class GcEventData(pool:String, reportTimeNs: Long, gcStartMillis:Long, gcEndMillis:Long, durationMillis: Long, name:String, action:String, cause:String, threads:Long){ + val endNanos: Long = System.nanoTime() } -case class ProfileSnap(threadId: Long, threadName: String, snapTimeNanos : Long, +private [profile] case class ProfileSnap(threadId: Long, threadName: String, snapTimeNanos : Long, idleTimeNanos:Long, cpuTimeNanos: Long, userTimeNanos: Long, allocatedBytes:Long, heapBytes:Long, totalClassesLoaded: Long, totalJITCompilationTime: Long) { def updateHeap(heapBytes:Long): ProfileSnap = copy(heapBytes = heapBytes) } -case class ProfileRange(start: ProfileSnap, end:ProfileSnap, phase:Phase, purpose:String, taskCount:Int, thread:Thread) { +private [profile] case class ProfileRange(start: ProfileSnap, end:ProfileSnap, phase:Phase, purpose:String, taskCount:Int, thread:Thread) { def allocatedBytes: Long = end.allocatedBytes - start.allocatedBytes def userNs: Long = end.userTimeNanos - start.userTimeNanos @@ -134,19 +135,17 @@ private [profile] object NoOpProfiler extends Profiler { } private [profile] object RealProfiler { - import scala.jdk.CollectionConverters.* - val runtimeMx: RuntimeMXBean = ManagementFactory.getRuntimeMXBean - val memoryMx: MemoryMXBean = ManagementFactory.getMemoryMXBean - val gcMx: List[GarbageCollectorMXBean] = ManagementFactory.getGarbageCollectorMXBeans.asScala.toList - val classLoaderMx: ClassLoadingMXBean = ManagementFactory.getClassLoadingMXBean - val compileMx: CompilationMXBean = ManagementFactory.getCompilationMXBean - val threadMx: ExtendedThreadMxBean = ExtendedThreadMxBean.proxy + private val runtimeMx: RuntimeMXBean = ManagementFactory.getRuntimeMXBean + private val memoryMx: MemoryMXBean = ManagementFactory.getMemoryMXBean + private val gcMx: List[GarbageCollectorMXBean] = ManagementFactory.getGarbageCollectorMXBeans.asScala.toList + private val classLoaderMx: ClassLoadingMXBean = ManagementFactory.getClassLoadingMXBean + private val compileMx: CompilationMXBean = ManagementFactory.getCompilationMXBean + private val threadMx: ExtendedThreadMxBean = ExtendedThreadMxBean.proxy if (threadMx.isThreadCpuTimeSupported) threadMx.setThreadCpuTimeEnabled(true) private val idGen = new AtomicInteger() @nowarn("cat=deprecation") private[profile] def snapThread(idleTimeNanos: Long): ProfileSnap = { - import RealProfiler.* val current = Thread.currentThread() ProfileSnap( @@ -174,7 +173,7 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context) private final val GcThreadId = "GC" enum Category: - def name: String = this.toString().toLowerCase() + def name: String = this.toString.toLowerCase() case Run, Phase, File, TypeCheck, Implicit, Inline, Completion private [profile] val chromeTrace = if ctx.settings.YprofileTrace.isDefault @@ -295,7 +294,7 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context) traceThreadSnapshotCounters() } - private def traceThreadSnapshotCounters(initialSnap: => ProfileSnap = RealProfiler.snapThread(0)) = + private def traceThreadSnapshotCounters(initialSnap: => ProfileSnap = RealProfiler.snapThread(0)): Unit = if chromeTrace != null && System.nanoTime() > nextAfterUnitSnap then { val snap = initialSnap chromeTrace.traceCounterEvent("allocBytes", "allocBytes", snap.allocatedBytes, processWide = false) @@ -362,7 +361,7 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context) s"${enclosing.javaBinaryName}::${root.name}" } -enum EventType(name: String): +private [profile] enum EventType(name: String): // main thread with other tasks case MAIN extends EventType("main") // other task ( background thread) @@ -370,7 +369,7 @@ enum EventType(name: String): // total for compile case GC extends EventType("GC") -sealed trait ProfileReporter { +private [profile] sealed trait ProfileReporter { def reportBackground(profiler: RealProfiler, threadRange: ProfileRange): Unit def reportForeground(profiler: RealProfiler, threadRange: ProfileRange): Unit @@ -380,8 +379,8 @@ sealed trait ProfileReporter { def close(profiler: RealProfiler) :Unit } -object ConsoleProfileReporter extends ProfileReporter { - @sharable var totalAlloc = 0L +private [profile] object ConsoleProfileReporter extends ProfileReporter { + @sharable private var totalAlloc = 0L override def reportBackground(profiler: RealProfiler, threadRange: ProfileRange): Unit = reportCommon(EventType.BACKGROUND, profiler, threadRange) @@ -401,7 +400,7 @@ object ConsoleProfileReporter extends ProfileReporter { println(s"Profiler GC reported ${data.gcEndMillis - data.gcStartMillis}ms") } -class StreamProfileReporter(out:PrintWriter) extends ProfileReporter { +private [profile] class StreamProfileReporter(out:PrintWriter) extends ProfileReporter { override def header(profiler: RealProfiler): Unit = { out.println(s"info, ${profiler.id}, version, 2, output, ${profiler.outDir}") out.println(s"header(main/background),startNs,endNs,runId,phaseId,phaseName,purpose,task-count,threadId,threadName,runNs,idleNs,cpuTimeNs,userTimeNs,allocatedByte,heapSize") diff --git a/compiler/src/dotty/tools/dotc/profile/ThreadPoolFactory.scala b/compiler/src/dotty/tools/dotc/profile/ThreadPoolFactory.scala deleted file mode 100644 index d07a38c37485..000000000000 --- a/compiler/src/dotty/tools/dotc/profile/ThreadPoolFactory.scala +++ /dev/null @@ -1,149 +0,0 @@ -package dotty.tools.dotc.profile - -import java.util.concurrent.ThreadPoolExecutor.AbortPolicy -import java.util.concurrent.* -import java.util.concurrent.atomic.AtomicInteger - -import dotty.tools.dotc.core.Phases.Phase -import dotty.tools.dotc.core.Contexts.* - -sealed trait ThreadPoolFactory { - - def newUnboundedQueueFixedThreadPool( - nThreads: Int, - shortId: String, - priority : Int = Thread.NORM_PRIORITY) : ThreadPoolExecutor - - def newBoundedQueueFixedThreadPool( - nThreads: Int, - maxQueueSize: Int, - rejectHandler: RejectedExecutionHandler, - shortId: String, - priority : Int = Thread.NORM_PRIORITY) : ThreadPoolExecutor -} - - -object ThreadPoolFactory { - def apply(phase: Phase)(using Context): ThreadPoolFactory = ctx.profiler match { - case NoOpProfiler => new BasicThreadPoolFactory(phase) - case r: RealProfiler => new ProfilingThreadPoolFactory(phase, r) - } - - private abstract class BaseThreadPoolFactory(phase: Phase) extends ThreadPoolFactory { - val baseGroup = new ThreadGroup(s"dotc-${phase.phaseName}") - - private def childGroup(name: String) = new ThreadGroup(baseGroup, name) - - // Invoked when a new `Worker` is created, see `CommonThreadFactory.newThread` - protected def wrapWorker(worker: Runnable, shortId:String): Runnable = worker - - protected final class CommonThreadFactory( - shortId: String, - daemon: Boolean = true, - priority: Int) extends ThreadFactory { - private val group: ThreadGroup = childGroup(shortId) - private val threadNumber: AtomicInteger = new AtomicInteger(1) - private val namePrefix = s"${baseGroup.getName}-$shortId-" - - // Invoked by the `ThreadPoolExecutor` when creating a new worker thread. The argument - // runnable is the `Worker` (which extends `Runnable`). Its `run` method gets tasks from - // the thread pool and executes them (on the thread created here). - override def newThread(worker: Runnable): Thread = { - val wrapped = wrapWorker(worker, shortId) - val t: Thread = new Thread(group, wrapped, namePrefix + threadNumber.getAndIncrement, 0) - if (t.isDaemon != daemon) t.setDaemon(daemon) - if (t.getPriority != priority) t.setPriority(priority) - t - } - } - } - - private final class BasicThreadPoolFactory(phase: Phase) extends BaseThreadPoolFactory(phase) { - - override def newUnboundedQueueFixedThreadPool(nThreads: Int, shortId: String, priority: Int): ThreadPoolExecutor = { - val threadFactory = new CommonThreadFactory(shortId, priority = priority) - //like Executors.newFixedThreadPool - new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue[Runnable], threadFactory) - } - - override def newBoundedQueueFixedThreadPool(nThreads: Int, maxQueueSize: Int, rejectHandler: RejectedExecutionHandler, shortId: String, priority: Int): ThreadPoolExecutor = { - val threadFactory = new CommonThreadFactory(shortId, priority = priority) - //like Executors.newFixedThreadPool - new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue[Runnable](maxQueueSize), threadFactory, rejectHandler) - } - } - - private class ProfilingThreadPoolFactory(phase: Phase, private val profiler: RealProfiler) extends BaseThreadPoolFactory(phase) { - - override def newUnboundedQueueFixedThreadPool(nThreads: Int, shortId: String, priority: Int): ThreadPoolExecutor = { - val threadFactory = new CommonThreadFactory(shortId, priority = priority) - //like Executors.newFixedThreadPool - new SinglePhaseInstrumentedThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue[Runnable], threadFactory, new AbortPolicy) - } - - override def newBoundedQueueFixedThreadPool(nThreads: Int, maxQueueSize: Int, rejectHandler: RejectedExecutionHandler, shortId: String, priority: Int): ThreadPoolExecutor = { - val threadFactory = new CommonThreadFactory(shortId, priority = priority) - //like Executors.newFixedThreadPool - new SinglePhaseInstrumentedThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue[Runnable](maxQueueSize), threadFactory, rejectHandler) - } - - override protected def wrapWorker(worker: Runnable, shortId: String): Runnable = { - () => - val data = new ThreadProfileData - localData.set(data) - - val profileStart = RealProfiler.snapThread(0) - try worker.run finally { - val snap = RealProfiler.snapThread(data.idleNs) - val threadRange = ProfileRange(profileStart, snap, phase, shortId, data.taskCount, Thread.currentThread()) - profiler.completeBackground(threadRange) - } - } - - /** - * data for thread run. Not threadsafe, only written from a single thread - */ - final class ThreadProfileData { - var firstStartNs = 0L - var taskCount = 0 - - var idleNs = 0L - var runningNs = 0L - - var lastStartNs = 0L - var lastEndNs = 0L - } - - val localData = new ThreadLocal[ThreadProfileData] - - private class SinglePhaseInstrumentedThreadPoolExecutor - ( corePoolSize: Int, maximumPoolSize: Int, keepAliveTime: Long, unit: TimeUnit, - workQueue: BlockingQueue[Runnable], threadFactory: ThreadFactory, handler: RejectedExecutionHandler - ) extends ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler) { - - override def beforeExecute(t: Thread, r: Runnable): Unit = { - val data = localData.get - data.taskCount += 1 - val now = System.nanoTime() - - if (data.firstStartNs == 0) data.firstStartNs = now - else data.idleNs += now - data.lastEndNs - - data.lastStartNs = now - - super.beforeExecute(t, r) - } - - override def afterExecute(r: Runnable, t: Throwable): Unit = { - val now = System.nanoTime() - val data = localData.get - - data.lastEndNs = now - data.runningNs += now - data.lastStartNs - - super.afterExecute(r, t) - } - } - } -} - diff --git a/compiler/src/dotty/tools/dotc/report.scala b/compiler/src/dotty/tools/dotc/report.scala index cd7c917939cd..f68507ffb6a1 100644 --- a/compiler/src/dotty/tools/dotc/report.scala +++ b/compiler/src/dotty/tools/dotc/report.scala @@ -156,7 +156,7 @@ object report: def enrichErrorMessage(errorMessage: String)(using Context): String = if ctx.settings.XnoEnrichErrorMessages.value then errorMessage else try enrichErrorMessage1(errorMessage) - catch case _: Throwable => errorMessage // don't introduce new errors trying to report errors, so swallow exceptions + catch case _: Exception => errorMessage // don't introduce new errors trying to report errors, so swallow exceptions private def enrichErrorMessage1(errorMessage: String)(using Context): String = { import untpd.*, config.Settings.* diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala index da69926286e9..7c8f46e4dac5 100644 --- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala +++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala @@ -243,6 +243,12 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe case InferUnionWarningID // errorNumber: 225 case TypeParameterShadowsTypeID // errorNumber: 226 case PrivateShadowsTypeID // errorNumber: 227 + case AmbiguousTemplateNameID // errorNumber: 228 + case IndentationWarningID // errorNumber: 229 + case IllegalIdentifierID // errorNumber: 230 + case ConcreteClassHasUnimplementedMethodsID // errorNumer: 231 + case IllegalUseOfSpecializedID // errorNumber: 232 + case VarianceInSpecializedTraitsLimitationID // errorNumber: 233 def errorNumber = ordinal - 1 diff --git a/compiler/src/dotty/tools/dotc/reporting/ExploringReporter.scala b/compiler/src/dotty/tools/dotc/reporting/ExploringReporter.scala index 99720b8e4d29..bbc9cb55c554 100644 --- a/compiler/src/dotty/tools/dotc/reporting/ExploringReporter.scala +++ b/compiler/src/dotty/tools/dotc/reporting/ExploringReporter.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package reporting -import scala.language.unsafeNulls - import collection.mutable import core.Contexts.Context import Diagnostic.* @@ -13,14 +11,14 @@ class ExploringReporter extends StoreReporter(null, fromTyperState = false): infos = new mutable.ListBuffer[Diagnostic] override def hasUnreportedErrors: Boolean = - infos.exists(_.isInstanceOf[Error]) + infos.nn.exists(_.isInstanceOf[Error]) override def removeBufferedMessages(using Context): List[Diagnostic] = - try infos.toList finally reset() + try infos.nn.toList finally reset() override def mapBufferedMessages(f: Diagnostic => Diagnostic)(using Context): Unit = - infos.mapInPlace(f) + infos.nn.mapInPlace(f) - def reset(): Unit = infos.clear() + def reset(): Unit = infos.nn.clear() end ExploringReporter diff --git a/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala b/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala index 5fb0c1b91733..93cf428cbdf2 100644 --- a/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala +++ b/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package reporting -import scala.language.unsafeNulls - import java.lang.System.{lineSeparator => EOL} import core.Contexts.* diff --git a/compiler/src/dotty/tools/dotc/reporting/TestReporter.scala b/compiler/src/dotty/tools/dotc/reporting/TestReporter.scala index c0b5ffe8e650..6ecab1101223 100644 --- a/compiler/src/dotty/tools/dotc/reporting/TestReporter.scala +++ b/compiler/src/dotty/tools/dotc/reporting/TestReporter.scala @@ -2,13 +2,11 @@ package dotty.tools package dotc package reporting -import scala.language.unsafeNulls - import collection.mutable import Diagnostic.* /** A re-usable Reporter used in Contexts#test */ class TestingReporter extends StoreReporter(null, fromTyperState = false): infos = new mutable.ListBuffer[Diagnostic] - override def hasUnreportedErrors: Boolean = infos.exists(_.isInstanceOf[Error]) - def reset(): Unit = infos.clear() + override def hasUnreportedErrors: Boolean = infos.nn.exists(_.isInstanceOf[Error]) + def reset(): Unit = infos.nn.clear() diff --git a/compiler/src/dotty/tools/dotc/reporting/WConf.scala b/compiler/src/dotty/tools/dotc/reporting/WConf.scala index 533459bec664..80d2ac0fabe6 100644 --- a/compiler/src/dotty/tools/dotc/reporting/WConf.scala +++ b/compiler/src/dotty/tools/dotc/reporting/WConf.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package reporting -import scala.language.unsafeNulls - import dotty.tools.dotc.core.Contexts.* import dotty.tools.dotc.util.{NoSourcePosition, SourcePosition} import dotty.tools.dotc.interfaces.SourceFile @@ -85,31 +83,34 @@ object WConf: def parseFilter(s: String): Either[String, MessageFilter] = s match case "any" => Right(Any) - case Splitter(filter, conf) => filter match - case "msg" => regex(conf).map(MessagePattern.apply) - case "id" => conf match - case ErrorId(num) => - ErrorMessageID.fromErrorNumber(num.toInt) match - case Some(errId) if errId.isActive => Right(MessageID(errId)) - case Some(errId) => Left(s"E${num} is marked as inactive.") - case _ => Left(s"Unknown error message number: E${num}") - case _ => - Left(s"invalid error message id: $conf") - case "name" => - try Right(MessageID(ErrorMessageID.valueOf(conf + "ID"))) - catch case _: IllegalArgumentException => Left(s"unknown error message name: $conf") - - case "cat" => conf match - case "configuration" => Right(Configuration) - case "deprecation" => Right(Deprecated) - case "feature" => Right(Feature) - case "unchecked" => Right(Unchecked) - case _ => Left(s"unknown category: $conf") - - case "src" => regex(conf).map(SourcePattern.apply) - case "origin" => regex(conf).map(Origin.apply) - - case _ => Left(s"unknown filter: $filter") + case Splitter(filter, conf) => + assert(filter != null && conf != null, s"$Splitter should not match with missing groups") + filter match + case "msg" => regex(conf).map(MessagePattern.apply) + case "id" => conf match + case ErrorId(num) => + assert(num != null, s"$ErrorId should not match with missing groups") + ErrorMessageID.fromErrorNumber(num.toInt) match + case Some(errId) if errId.isActive => Right(MessageID(errId)) + case Some(errId) => Left(s"E${num} is marked as inactive.") + case _ => Left(s"Unknown error message number: E${num}") + case _ => + Left(s"invalid error message id: $conf") + case "name" => + try Right(MessageID(ErrorMessageID.valueOf(conf + "ID"))) + catch case _: IllegalArgumentException => Left(s"unknown error message name: $conf") + + case "cat" => conf match + case "configuration" => Right(Configuration) + case "deprecation" => Right(Deprecated) + case "feature" => Right(Feature) + case "unchecked" => Right(Unchecked) + case _ => Left(s"unknown category: $conf") + + case "src" => regex(conf).map(SourcePattern.apply) + case "origin" => regex(conf).map(Origin.apply) + + case _ => Left(s"unknown filter: $filter") case _ => Left(s"unknown filter: $s") def parsed(using Context): WConf = diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala index 84d3934d19b5..9955ce168c3a 100644 --- a/compiler/src/dotty/tools/dotc/reporting/messages.scala +++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala @@ -9,12 +9,14 @@ import Denotations.SingleDenotation import SymDenotations.SymDenotation import NameKinds.{WildcardParamName, ContextFunctionParamName} import parsing.Scanners.Token -import parsing.Tokens +import parsing.Tokens, Tokens.showToken import printing.Highlighting.* import printing.Formatting import ErrorMessageID.* -import ast.Trees +import ast.Trees.* import ast.desugar +import ast.tpd +import ast.untpd import config.{Feature, MigrationVersion, ScalaVersion} import transform.patmat.Space import transform.patmat.SpaceEngine @@ -22,12 +24,8 @@ import typer.ErrorReporting.{err, matchReductionAddendum, substitutableTypeSymbo import typer.ProtoTypes.{ViewProto, FunProto} import typer.Implicits.* import typer.Inferencing -import scala.util.control.NonFatal import StdNames.nme import Formatting.{hl, delay} -import ast.Trees.* -import ast.untpd -import ast.tpd import scala.util.matching.Regex import java.util.regex.Matcher.quoteReplacement import cc.CaptureSet @@ -39,7 +37,6 @@ import dotty.tools.dotc.util.SourceFile import dotty.tools.dotc.config.SourceVersion import DidYouMean.* import Message.{Disambiguation, Note} -import dotty.tools.dotc.util.SimpleIdentitySet /** Messages * ======== @@ -98,13 +95,14 @@ abstract class CyclicMsg(errorId: ErrorMessageID)(using Context) extends Message "\n\nStacktrace:" ++ ex.getStackTrace().mkString("\n ", "\n ", "") else "\n\n Run with both -explain-cyclic and -Ydebug-cyclic to see full stack trace." - protected def context: String = ex.optTrace match - case Some(trace) => + protected def context: String = + val trace = ex.optTrace + if trace != null then s"\n\nThe error occurred while trying to ${ trace.map(identity) // map with identity will turn Context ?=> String elements to String elements .mkString("\n which required to ") }$debugInfo" - case None => + else "\n\n Run with -explain-cyclic for more details." end CyclicMsg @@ -793,7 +791,7 @@ extends SyntaxMsg(WrongNumberOfTypeArgsID) { try fntpe.termSymbol match case NoSymbol => fntpe.show case symbol => symbol.showFullName - catch case NonFatal(ex) => fntpe.show + catch case ex: Exception => fntpe.show i"""|$msgPrefix type arguments for $prettyName$expectedArgString |expected: $expectedArgString |actual: $actualArgString""" @@ -1256,12 +1254,12 @@ extends ReferenceMsg(ForwardReferenceExtendsOverDefinitionID) { class ExpectedTokenButFound(expected: Token, found: Token, prefix: String = "", suffix: String = "")(using Context) extends SyntaxMsg(ExpectedTokenButFoundID) { - private def foundText = Tokens.showToken(found) + private def foundText = showToken(found) def msg(using Context) = val expectedText = if (Tokens.isIdentifier(expected)) "an identifier" - else Tokens.showToken(expected) + else showToken(expected) i"""$prefix$expectedText expected, but $foundText found$suffix""" def explain(using Context) = @@ -1283,7 +1281,7 @@ extends SyntaxMsg(ExpectedTokenButFoundID): def explain(using Context) = s"The soft keyword `$soft` has special meaning only in certain contexts." end ExpectedTokenButFoundSoftKeyword -class MixedLeftAndRightAssociativeOps(op1: Name, op2: Name, op2LeftAssoc: Boolean)(using Context) +class MixedLeftAndRightAssociativeOps(op1: Name, op2: Name | Null, op2LeftAssoc: Boolean)(using Context) extends SyntaxMsg(MixedLeftAndRightAssociativeOpsID) { def msg(using Context) = val op1Asso: String = if (op2LeftAssoc) "which is right-associative" else "which is left-associative" @@ -1963,7 +1961,7 @@ class ExtendFinalClass(clazz:Symbol, finalClazz: Symbol)(using Context) class ExpectedTypeBoundOrEquals(found: Token)(using Context) extends SyntaxMsg(ExpectedTypeBoundOrEqualsID) { - def msg(using Context) = i"${hl("=")}, ${hl(">:")}, or ${hl("<:")} expected, but ${Tokens.showToken(found)} found" + def msg(using Context) = i"${hl("=")}, ${hl(">:")}, or ${hl("<:")} expected, but ${showToken(found)} found" def explain(using Context) = i"""Type parameters and abstract types may be constrained by a type bound. @@ -2637,7 +2635,7 @@ class PureUnitExpression(stat: untpd.Tree, tpe: Type)(using Context) class UnqualifiedCallToAnyRefMethod(stat: untpd.Tree, method: Symbol)(using Context) extends Message(UnqualifiedCallToAnyRefMethodID) { def kind = MessageKind.PotentialIssue - def msg(using Context) = i"Suspicious top-level unqualified call to ${hl(method.name.toString)}" + def msg(using Context) = i"Universal method ${hl(method.name.toString)} does not resolve to the enclosing class" def explain(using Context) = val getClassExtraHint = if method.name == nme.getClass_ && ctx.settings.classpath.value.contains("scala3-staging") then @@ -3128,7 +3126,7 @@ class MissingImplicitArgument( def msg(using Context): String = def formatMsg(shortForm: String)(headline: String = shortForm) = arg match - case arg: Trees.SearchFailureIdent[?] => + case arg: SearchFailureIdent[?] => arg.tpe match case _: NoMatchingImplicits => headline case tpe: SearchFailureType => @@ -3868,3 +3866,138 @@ final class PrivateShadowsType(shadow: Symbol, shadowed: Symbol)(using Context) i"""A private field shadows an inherited field with the same name. |This can lead to confusion as the inherited field becomes inaccessible. |Consider renaming the private field to avoid the shadowing.""" + +class AmbiguousTemplateName(tree: NamedDefTree[?])(using Context) extends SyntaxMsg(AmbiguousTemplateNameID): + override protected def msg(using Context) = i"name `${tree.name}` should be enclosed in backticks" + override protected def explain(using Context): String = + "Names with trailing operator characters may fuse with a subsequent colon if not set off by backquotes or spaces." + +class IndentationWarning(isLeft: Boolean = false, before: String = "", missing: Token*)(using Context) +extends SyntaxMsg(IndentationWarningID): + override protected def msg(using Context) = + s"Line is indented too far to the ${if isLeft then "left" else "right"}, or a ${ + missing.map(showToken).mkString(" or ") + } is missing${ + if !before.isEmpty then i" before:\n\n$before" else "" + }" + override protected def explain(using Context): String = + "Indentation that does not reflect syntactic nesting may be due to a typo such as missing punctuation." + +final class IllegalIdentifier(name: Name)(using Context) extends SyntaxMsg(IllegalIdentifierID): + override protected def msg(using Context): String = name match + case nme.CONSTRUCTOR | nme.STATIC_CONSTRUCTOR => + "Illegal backquoted identifier: `` and `` are forbidden" + case _ => + i"The identifier `$name` should not contain `$$`, which is reserved for internal compiler use." + override protected def explain(using Context): String = name match + case nme.CONSTRUCTOR | nme.STATIC_CONSTRUCTOR => + "Names can include unusual characters when enclosed in backquotes, but `` and `` are reserved." + case _ => + i"""User identifiers may be encoded with embedded `$$`, and other compiler artifacts + |may rely on using `$$` with specific meanings. + | + |The prohibition against explicit `$$` may be ignored by enclosing the identifier in backquotes + |at the definition site.""" + +class ConcreteClassHasUnimplementedMethods( + clazz: ClassSymbol, + missingMethods: List[Symbol], + addendum: String, + methodActions: List[CodeAction])(using Context) +extends Message(ConcreteClassHasUnimplementedMethodsID), NoDisambiguation: + + def kind = MessageKind.Declaration + + private def showDecl(sym: Symbol)(using Context): String = + sym.asSeenFrom(clazz.thisType).mapInfo(_.withCleanParamNames).showDcl + + private def prelude(using Context): String = + if clazz.isAnonymousClass || clazz.is(Module) then "object creation impossible" + else if clazz.is(Synthetic) then "instance cannot be created" + else s"$clazz needs to be abstract" + + private def renderMissingMethods(using Context): List[String] = + val grouped = missingMethods.groupBy(_.owner).toList + grouped.sortBy(_._1.name).map { case (owner, members) => + val sigs = members.sortBy(_.name).map(s => s"- ${showDecl(s)}") + s"""Members declared in ${owner.fullName}: + |${sigs.mkString("\n")}""".stripMargin + } + + def msg(using Context) = missingMethods match + case single :: Nil => + val notDefined = s"${showDecl(single)} in ${single.owner.showLocated} is not defined" + s"$prelude, since $notDefined$addendum" + case _ => + s"""$prelude, since it has ${missingMethods.size} unimplemented members. + | + |${renderMissingMethods.mkString("\n\n")}""".stripMargin + + def explain(using Context) = "" + override def actions(using Context) = methodActions + +final class IllegalUseOfSpecialized(using Context) + extends SyntaxMsg(IllegalUseOfSpecializedID): + override protected def msg(using Context): String = + i"Specialized may only be used as a context bound" + override protected def explain(using Context): String = + i"""Specialized allows for a performance improvement by specializing generic type parameters + to avoid boxing/unboxing. It should only be used as a context (typeclass) bound on a + generic type in inline traits or inline methods: + + inline trait Vec[T: Specialized](val x: T) + + inline def foo[T: Specialized](v: Vec[T]) = v.x + + In this instance it was used in a way which is unsupported, such as + trying to create a type synonym or a value with explicit type Specialized[X]. + """ + +/** Shows up as a TypeError (in the notes field) if variance is attempted + * in a way which is incompatible with specialized traits. */ +final class IllegalVarianceInSpecializedTraitsNote(using Context) extends Note: + def render(using Context): String = + i""" + This use of variance is incompatible with specialized traits. + + Specialized traits achieve a performance gain through a special erasure. + - Primitives are specialized: Foo[Int] erases to Foo$$sp$$Int + - Reference types are specialized to the highest non-top class: Foo[Lion] erases to Foo$$sp$$Animal + - Top classes are erased normally: Foo[Any] / Foo[AnyVal] / Foo[Object] / Foo[AnyRef] erase to Foo. + This means that variance patterns that cross these erasure categories will fail at + runtime due to a ClassCastException, so they are not permitted. + + Please see the docs for more information on how specialized traits are erased. + Suggested fixes: + - Make the type of the target site more general e.g. Foo[Object] instead of Foo[Animal]. + - Reconsider if you really need to use Nothing / Object / Any / AnyRef / AnyVal in your code. + - Remove Specialized from the definition of the corresponding parameter. + """ + + override def covers(other: Note)(using Context): Boolean = + other.isInstanceOf[IllegalVarianceInSpecializedTraitsNote] + +final class VarianceInSpecializedTraitsLimitation(using Context) + extends Message(VarianceInSpecializedTraitsLimitationID): + override def kind = MessageKind.PotentialIssue + override protected def msg(using Context): String = + i"Type parameter is both Specialized and variant. This imposes additional typing restrictions." + override protected def explain(using Context): String = + i"""Specialized traits achieve a performance gain through a special erasure. + - Primitives are specialized: Foo[Int] erases to Foo$$sp$$Int + - Reference types are specialized to the highest non-top class: Foo[Lion] erases to Foo$$sp$$Animal + - Top classes are erased normally: Foo[Any] / Foo[AnyVal] / Foo[Object] / Foo[AnyRef] erase to Foo. + This means that certain variance patterns that cross these erasure categories will fail at + runtime due to a ClassCastException, so they are not permitted. + + For example, treating Foo[Any] as Foo[Animal] via contravariance is not allowed with Specialized. + + Please see the docs for more information on how specialized traits are erased. + + If you accept this limitation you can silence this warning with @nowarn. For example: + + @nowarn("id=E${VarianceInSpecializedTraitsLimitationID.errorNumber}") + inline trait Foo[-T: Specialized]: + + Otherwise, remove Specialized, or remove the variance. + """ diff --git a/compiler/src/dotty/tools/dotc/reporting/trace.scala b/compiler/src/dotty/tools/dotc/reporting/trace.scala index c557a6e4544c..36e698a3a364 100644 --- a/compiler/src/dotty/tools/dotc/reporting/trace.scala +++ b/compiler/src/dotty/tools/dotc/reporting/trace.scala @@ -126,7 +126,7 @@ trait TraceSyntax: case ex: runtime.NonLocalReturnControl[T @unchecked] => finalize(trailing(ex.value)) throw ex - case ex: Throwable => + case ex: Exception => val msg = s"<== $q = (with exception $ex)" finalize(msg) throw ex diff --git a/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala b/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala index 5061ae5773b8..69328acd7c5b 100644 --- a/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala +++ b/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala @@ -1,8 +1,6 @@ package dotty.tools.dotc package sbt -import scala.language.unsafeNulls - import ExtractDependencies.internalError import ast.{Positioned, Trees, tpd} import core.* @@ -137,7 +135,9 @@ class ExtractAPI extends Phase { if (ctx.settings.YdumpSbtInc.value) { // Append to existing file that should have been created by ExtractDependencies - val pw = new PrintWriter(File(sourceFile.file.jpath).changeExtension(FileExtension.Inc).toFile + val sourceFileJPath = sourceFile.file.jpath + assert(sourceFileJPath != null, s"unexpected null jpath for $sourceFile") + val pw = new PrintWriter(File(sourceFileJPath).changeExtension(FileExtension.Inc).toFile .bufferedWriter(append = true), true) try { classes.foreach(source => pw.println(DefaultShowAPI(source))) @@ -213,7 +213,7 @@ private class ExtractAPICollector(nonLocalClassSymbols: mutable.HashSet[Symbol]) * see the comment in the `RefinedType` case in `computeType` * The cache key is (api of RefinedType#parent, api of RefinedType#refinedInfo). */ - private val refinedTypeCache = new mutable.HashMap[(api.Type, api.Definition), api.Structure] + private val refinedTypeCache = new mutable.HashMap[(api.Type, api.Definition | Null), api.Structure] /** This cache is necessary to avoid infinite loops when hashing an inline "Body" annotation. * Its values are transitively seen inline references within a call chain starting from a single "origin" inline @@ -754,7 +754,10 @@ private class ExtractAPICollector(nonLocalClassSymbols: mutable.HashSet[Symbol]) // `IncOptions#useOptimizedSealed`. s.annotations.foreach { annot => val sym = annot.symbol - if sym.exists && sym != defn.BodyAnnot && sym != defn.ChildAnnot then + // Ignore annotations of type Any, this means we couldn't actually load it, + // because it's no longer on the classpath compared to when the code we're loading was compiled. + // See the i25722 special test in explicitNullsPos for an example. + if sym.exists && sym != defn.BodyAnnot && sym != defn.ChildAnnot && !sym.typeRef.isAny then annots += apiAnnotation(annot) } @@ -816,10 +819,14 @@ private class ExtractAPICollector(nonLocalClassSymbols: mutable.HashSet[Symbol]) p match case ref: RefTree @unchecked => val sym = ref.symbol - if sym.is(Inline, butNot = Param) && !seenInlineCache.contains(sym) then + if sym.is(Inline, butNot = Param | Trait) && !seenInlineCache.contains(sym) then // An inline method that calls another inline method will eventually inline the call // at a non-inline callsite, in this case if the implementation of the nested call // changes, then the callsite will have a different API, we should hash the definition + // In contrast, if an inline trait A extends an inline trait B, B's body is inlined into + // A, so a change to B will cause a change to A directly, so we can skip this, and if + // an inline method accesses a parameter of an inline trait it doesn't care about the definition + // of the trait. h = MurmurHash3.mix(h, apiDefinition(sym, inlineOrigin).hashCode) case _ => diff --git a/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala b/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala index a01baf3846a6..c86d8f93eef9 100644 --- a/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala +++ b/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala @@ -1,8 +1,6 @@ package dotty.tools.dotc package sbt -import scala.language.unsafeNulls - import java.io.File import java.nio.file.Path import java.util.EnumSet @@ -127,6 +125,9 @@ private class ExtractDependenciesCollector(rec: DependencyRecorder) extends Abst override def traverse(tree: Tree)(using Context): Unit = try recordTree(tree) + + recordInlineCallArgs(tree) + tree match case tree: Inlined if !tree.inlinedFromOuterScope => // The inlined call is normally ignored by TreeTraverser but we need to @@ -184,6 +185,26 @@ trait AbstractExtractDependenciesCollector(rec: DependencyRecorder) extends tpd. rec.addClassDependency(parent.tpe.classSymbol, depContext) } + // Only reference DependencyByMacroExpansion if it an be found on the classpath, + // as it was added later to the zinc.apiinfo DependencyContext enum + // e.g. pre 1.10.x sbt would throw java.lang.NoSuchFieldError errors here + lazy val allowsDependencyByMacroExpansion = + classOf[DependencyContext].getFields().exists(_.getName() == "DependencyByMacroExpansion") + + private def addMacroDependency(trees: List[Tree])(using Context): Unit = + if (allowsDependencyByMacroExpansion) { + val traverser = new TypeDependencyTraverser { + def addDependency(symbol: Symbol) = + if (!ignoreDependency(symbol)) { + val enclOrModuleClass = if (symbol.is(ModuleVal)) symbol.moduleClass else symbol.enclosingClass + assert(enclOrModuleClass.isClass, s"$enclOrModuleClass, $symbol") + + rec.addClassDependency(enclOrModuleClass, DependencyByMacroExpansion) + } + } + trees.foreach(tree => traverser.traverse(tree.tpe)) + } + private def depContextOf(cls: Symbol)(using Context): DependencyContext = if cls.isLocal then LocalDependencyByInheritance else DependencyByInheritance @@ -200,6 +221,12 @@ trait AbstractExtractDependenciesCollector(rec: DependencyRecorder) extends tpd. // can happen for constructor proxies. Test case is pos-macros/i13532. true + protected def recordInlineCallArgs(tree: Tree)(using Context) = + tree match + case TypeApply(fun, args) if fun.symbol.is(Inline) => + addMacroDependency(args) + case _ => + protected def recordTree(tree: Tree)(using Context): Unit = tree match case Match(selector, _) => @@ -370,8 +397,8 @@ class DependencyRecorder { * safely. */ def addUsedRawName(name: Name, includeSealedChildren: Boolean = false)(using Context): Unit = { - val fromClass = resolveDependencyFromClass - if (fromClass.exists) { + val lastFoundCache = resolveDependencyFromClass + if (lastFoundCache != null) { lastFoundCache.recordName(name, includeSealedChildren) } } @@ -437,8 +464,8 @@ class DependencyRecorder { * from the current non-local enclosing class. */ def addClassDependency(toClass: Symbol, context: DependencyContext)(using Context): Unit = - val fromClass = resolveDependencyFromClass - if (fromClass.exists) + val lastFoundCache = resolveDependencyFromClass + if (lastFoundCache != null) lastFoundCache.addDependency(toClass, context) private val _foundDeps = new util.EqHashMap[Symbol, FoundDepsInClass] @@ -531,17 +558,16 @@ class DependencyRecorder { } } - private var lastOwner: Symbol = uninitialized - private var lastDepSource: Symbol = uninitialized - private var lastFoundCache: FoundDepsInClass | Null = uninitialized + private var lastOwner: Symbol | Null = null + private var lastDepSource: Symbol | Null = null + private var lastFoundCache: FoundDepsInClass | Null = null /** The source of the dependency according to `nonLocalEnclosingClass` * if it exists, otherwise fall back to `responsibleForImports`. * * This is backed by a cache which is invalidated when `ctx.owner` changes. */ - private def resolveDependencyFromClass(using Context): Symbol = { - import dotty.tools.uncheckedNN + private def resolveDependencyFromClass(using Context): FoundDepsInClass | Null = { if (lastOwner != ctx.owner) { lastOwner = ctx.owner val source = nonLocalEnclosingClass @@ -551,7 +577,10 @@ class DependencyRecorder { lastFoundCache = _foundDeps.getOrElseUpdate(fromClass, new FoundDepsInClass) } - lastDepSource + if lastDepSource != null && lastDepSource.nn.exists then + lastFoundCache + else + null } /** The closest non-local enclosing class from `ctx.owner`. */ @@ -575,7 +604,7 @@ class DependencyRecorder { /** Top level import dependencies are registered as coming from a first top level * class/trait/object declared in the compilation unit. If none exists, issue a warning and return NoSymbol. */ - private def responsibleForImports(using Context) = { + private def responsibleForImports(using Context): Symbol = { import tpd.* def firstClassOrModule(tree: Tree) = { val acc = new TreeAccumulator[Symbol] { @@ -593,12 +622,12 @@ class DependencyRecorder { if (_responsibleForImports == null) { val tree = ctx.compilationUnit.tpdTree _responsibleForImports = firstClassOrModule(tree) - if (!_responsibleForImports.exists) + if (!_responsibleForImports.nn.exists) report.warning("""|No class, trait or object is defined in the compilation unit. |The incremental compiler cannot record the dependency information in such case. |Some errors like unused import referring to a non-existent class might not be reported. |""".stripMargin, tree.sourcePos) } - _responsibleForImports + _responsibleForImports.nn } } diff --git a/compiler/src/dotty/tools/dotc/sbt/package.scala b/compiler/src/dotty/tools/dotc/sbt/package.scala index e835a4b95fee..1b4eca3ca95a 100644 --- a/compiler/src/dotty/tools/dotc/sbt/package.scala +++ b/compiler/src/dotty/tools/dotc/sbt/package.scala @@ -10,8 +10,6 @@ import interfaces.IncrementalCallback import dotty.tools.io.FileWriters.BufferingReporter import dotty.tools.dotc.core.Decorators.em -import scala.util.control.NonFatal - inline val TermNameHash = 1987 // 300th prime inline val TypeNameHash = 1993 // 301st prime inline val InlineParamHash = 1997 // 302nd prime @@ -24,7 +22,7 @@ def asyncZincPhasesCompleted(cb: IncrementalCallback, pending: Option[BufferingR cb.apiPhaseCompleted() cb.dependencyPhaseCompleted() catch - case NonFatal(t) => + case t: Exception => zincReporter.exception(em"signaling API and Dependencies phases completion", t) zincReporter diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Descriptor.scala b/compiler/src/dotty/tools/dotc/semanticdb/Descriptor.scala index 2066322fe3d3..3dfd4da62213 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Descriptor.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Descriptor.scala @@ -1,7 +1,5 @@ package dotty.tools.dotc.semanticdb -import scala.language.unsafeNulls - import java.lang.System.{lineSeparator => EOL} import dotty.tools.dotc.semanticdb.{Descriptor => d} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 475c25208846..c8d9a9e93458 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package semanticdb -import scala.language.unsafeNulls - import core.* import Phases.* import ast.tpd.* @@ -151,7 +149,7 @@ private[semanticdb] object ExtractSemanticDB: /** Output directory for SemanticDB files */ private def semanticdbOutDir(using Context): Path = - semanticdbTarget.getOrElse(outputDirectory.jpath) + semanticdbTarget.getOrElse(outputDirectory.jpath.nn) private def absolutePath(path: Path): Path = path.toAbsolutePath.normalize diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala b/compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala index 961ee69e029d..e55e727f639c 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala @@ -13,7 +13,6 @@ import Scala3.{*, given} import scala.annotation.tailrec import scala.collection.mutable -import scala.util.control.NonFatal // The API here is a little tricky because it's used both as a stateful builder with local symbols, // and for non-local symbols that do not need any state through the companion object. @@ -116,7 +115,7 @@ private[semanticdb] object SemanticSymbolBuilder: val pkg = s.split('/').map(stripBackticks).mkString(".") requiredPackage(pkg) :: Nil catch - case NonFatal(_) => + case _: Exception => Nil else val (desc, parent) = DescriptorParser(s) @@ -198,7 +197,7 @@ private[semanticdb] object SemanticSymbolBuilder: try val res = loop(sym) res.filterNot(_ == NoSymbol) - catch case NonFatal(e) => Nil + catch case e: Exception => Nil end inverseSymbol private def addName(b: StringBuilder, name: Name): Unit = diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala index dc10df6a5bba..01bcc36467f4 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala @@ -1,7 +1,5 @@ package dotty.tools.dotc.semanticdb.internal -import scala.language.unsafeNulls - import java.nio.ByteBuffer import java.nio.charset.StandardCharsets import java.security.MessageDigest diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala index 699f85c0e303..b04f6de99ed8 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala @@ -1,7 +1,5 @@ package dotty.tools.dotc.semanticdb.internal -import scala.language.unsafeNulls - import java.io.IOException import java.io.InputStream import java.util.Arrays @@ -73,7 +71,7 @@ object SemanticdbInputStream { private val BUFFER_SIZE = 4096 } -class SemanticdbInputStream private (buffer: Array[Byte], input: InputStream) { +class SemanticdbInputStream private (buffer: Array[Byte], input: InputStream | Null) { /** * The total number of bytes read before the current buffer. The total * bytes read up to the current position can be computed as diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala index 359e861225b0..b04292de27de 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala @@ -1,7 +1,5 @@ package dotty.tools.dotc.semanticdb.internal -import scala.language.unsafeNulls - import java.io.IOException import java.io.OutputStream import java.nio.ByteBuffer @@ -221,13 +219,14 @@ object SemanticdbOutputStream { def encodeZigZag64(n: Long): Long = (n << 1) ^ (n >> 63) } -class SemanticdbOutputStream(output: OutputStream, buffer: Array[Byte]) { - private def refreshBuffer(): Unit = { +class SemanticdbOutputStream(output: OutputStream | Null, buffer: Array[Byte]) { + private def refreshBuffer(): OutputStream = { if (output == null) { throw new OutOfSpaceException() } output.write(buffer, 0, position) position = 0 + output } def flush(): Unit = { @@ -565,7 +564,7 @@ class SemanticdbOutputStream(output: OutputStream, buffer: Array[Byte]) { length -= bytesWritten position = limit totalBytesWritten += bytesWritten - refreshBuffer() + val output = refreshBuffer() while (length > limit) { value.get(buffer, 0, limit) output.write(buffer, 0, limit) @@ -592,7 +591,7 @@ class SemanticdbOutputStream(output: OutputStream, buffer: Array[Byte]) { length -= bytesWritten position = limit totalBytesWritten += bytesWritten - refreshBuffer() + val output = refreshBuffer() if (length <= limit) { System.arraycopy(value, offset, buffer, 0, length) position = length diff --git a/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala b/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala index bca75556d920..a075afa87d37 100644 --- a/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala +++ b/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala @@ -85,6 +85,7 @@ abstract class AccessProxies { val sym = newSymbol(owner, name, Synthetic | Method, info, coord = accessed.span).entered if accessed.is(Private) then sym.setFlag(Final) else if sym.allOverriddenSymbols.exists(!_.is(Deferred)) then sym.setFlag(Override) + if accessed.is(Erased) then sym.setFlag(Erased) ExperimentalAnnotation.copy(accessed).foreach(sym.addAnnotation) sym } @@ -173,8 +174,8 @@ object AccessProxies { def hostForAccessorOf(accessed: Symbol)(using Context): Symbol = { def recur(cls: Symbol): Symbol = if (!cls.exists) NoSymbol - else if cls.derivesFrom(accessed.owner) - || cls.companionModule.moduleClass == accessed.owner + else if ((cls.derivesFrom(accessed.owner) && !(accessed.is(Private) && (cls ne accessed.owner))) + || cls.companionModule.moduleClass == accessed.owner) then cls else recur(cls.owner) recur(ctx.owner) diff --git a/compiler/src/dotty/tools/dotc/transform/Bridges.scala b/compiler/src/dotty/tools/dotc/transform/Bridges.scala index 9a76a5a6be9e..e2bad9415de4 100644 --- a/compiler/src/dotty/tools/dotc/transform/Bridges.scala +++ b/compiler/src/dotty/tools/dotc/transform/Bridges.scala @@ -12,6 +12,7 @@ import ContextFunctionResults.{contextResultCount, contextFunctionResultTypeAfte import StdNames.nme import Constants.Constant import TypeErasure.transformInfo +import TypeErasure.disallowSpecializedCtx import Erasure.Boxing.adaptClosure /** A helper class for generating bridge methods in class `root`. */ @@ -19,7 +20,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) { import ast.tpd.* assert(ctx.phase == erasurePhase.next) - private val preErasureCtx = ctx.withPhase(erasurePhase) + private val preErasureCtx = disallowSpecializedCtx(using ctx.withPhase(erasurePhase.prev)) private lazy val elimErasedCtx = ctx.withPhase(elimErasedValueTypePhase.next) private class BridgesCursor(using Context) extends OverridingPairs.Cursor(root) { diff --git a/compiler/src/dotty/tools/dotc/transform/CheckLoopingImplicits.scala b/compiler/src/dotty/tools/dotc/transform/CheckLoopingImplicits.scala index 8625d2dbb289..b6058a7440d8 100644 --- a/compiler/src/dotty/tools/dotc/transform/CheckLoopingImplicits.scala +++ b/compiler/src/dotty/tools/dotc/transform/CheckLoopingImplicits.scala @@ -54,6 +54,8 @@ class CheckLoopingImplicits extends MiniPhase: ) def checkNotLooping(t: Tree): Unit = t match + case t if InstrumentCoverage.isCoverageProbe(t) => + () case t: Ident => checkNotSelfRef(t) case t @ Select(qual, _) => @@ -105,7 +107,7 @@ class CheckLoopingImplicits extends MiniPhase: if sym.isOneOf(GivenOrImplicit | Lazy | ExtensionMethod) || sym.name == nme.apply && sym.owner.is(Module) && sym.owner.sourceModule.isOneOf(GivenOrImplicit) then - checkNotLooping(mdef.rhs) + checkNotLooping(InstrumentCoverage.stripLeadingCoverage(mdef.rhs)) mdef end transform end CheckLoopingImplicits diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala index 3b1c4712b268..492af04aa929 100644 --- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala +++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala @@ -57,28 +57,25 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha tree override def transformIdent(tree: Ident)(using Context): tree.type = - refInfos.isAssignment = tree.hasAttachment(AssignmentTarget) if tree.symbol.exists then // if in an inline expansion, resolve at summonInline (synthetic pos) or in an enclosing call site - val resolving = + val resolvingImports = tree.srcPos.isUserCode(using if tree.hasAttachment(InlinedParameter) then ctx.outer else ctx) || tree.srcPos.isZeroExtentSynthetic // take as summonInline if !ignoreTree(tree) then def loopOverPrefixes(prefix: Type, depth: Int): Unit = if depth < 10 && prefix.exists && !prefix.classSymbol.isEffectiveRoot then - resolveUsage(prefix.classSymbol, nme.NO_NAME, NoPrefix, imports = resolving) + resolveUsage(prefix.classSymbol, nme.NO_NAME, NoPrefix, tree.srcPos, resolvingImports) loopOverPrefixes(prefix.normalizedPrefix, depth + 1) if tree.srcPos.isZeroExtentSynthetic then loopOverPrefixes(tree.typeOpt.normalizedPrefix, depth = 0) - resolveUsage(tree.symbol, tree.name, tree.typeOpt.importPrefix.skipPackageObject, imports = resolving) + resolveUsage(tree.symbol, tree.name, tree.typeOpt.importPrefix.skipPackageObject, tree.srcPos, resolvingImports) else if tree.hasType then - resolveUsage(tree.tpe.classSymbol, tree.name, tree.tpe.importPrefix.skipPackageObject) - refInfos.isAssignment = false + resolveUsage(tree.tpe.classSymbol, tree.name, tree.tpe.importPrefix.skipPackageObject, tree.srcPos) tree // import x.y; y may be rewritten x.y, also import x.z as y override def transformSelect(tree: Select)(using Context): tree.type = - refInfos.isAssignment = tree.hasAttachment(AssignmentTarget) val name = tree.removeAttachment(OriginalName).getOrElse(nme.NO_NAME) inline def isImportable = tree.qualifier.srcPos.isSynthetic && tree.qualifier.tpe.match @@ -95,14 +92,13 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha else if tycon.typeSymbol == defn.TypeableType then args(0) // T in Typeable[T] else return tree val target = res.dealias.typeSymbol - resolveUsage(target, target.name, res.importPrefix.skipPackageObject) // case _: T => + resolveUsage(target, target.name, res.importPrefix.skipPackageObject, tree.srcPos) // case _: T => case _ => else if isImportable || name.exists(_ != sym.name) then if !ignoreTree(tree) then - resolveUsage(sym, name, tree.qualifier.tpe) + resolveUsage(sym, name, tree.qualifier.tpe, tree.srcPos) else if !ignoreTree(tree) then - refUsage(sym) - refInfos.isAssignment = false + refUsage(sym, tree.srcPos) tree override def transformLiteral(tree: Literal)(using Context): tree.type = @@ -134,22 +130,21 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha tree match case Apply(Select(left, nme.Equals | nme.NotEquals), right :: Nil) => val caneq = defn.CanEqualClass.typeRef.appliedTo(left.tpe.widen :: right.tpe.widen :: Nil) - resolveScoped(caneq) + resolveScoped(caneq, tree.srcPos) case tree => - refUsage(tree.tpe.typeSymbol) + refUsage(tree.tpe.typeSymbol, tree.srcPos) tree override def transformTypeApply(tree: TypeApply)(using Context): tree.type = if tree.symbol.exists && tree.symbol.isConstructor then - refUsage(tree.symbol.owner) // redundant with use of resultType in transformSelect of fun + refUsage(tree.symbol.owner, tree.srcPos) // redundant with use of resultType in transformSelect of fun tree override def prepareForAssign(tree: Assign)(using Context): Context = - tree.lhs.putAttachment(AssignmentTarget, ()) // don't take LHS reference as a read - ctx - override def transformAssign(tree: Assign)(using Context): tree.type = - tree.lhs.removeAttachment(AssignmentTarget) - tree + if tree.lhs.symbol.exists then + refInfos.addAssignmentTarget(tree.lhs.symbol) + ctx.fresh.setTree(tree) + else ctx override def prepareForMatch(tree: Match)(using Context): Context = // allow case.pat against tree.selector (simple var pat only for now) @@ -160,13 +155,14 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha override def transformMatch(tree: Match)(using Context): tree.type = if tree.isInstanceOf[InlineMatch] && tree.selector.isEmpty then val sf = defn.Compiletime_summonFrom - resolveUsage(sf, sf.name, NoPrefix) + resolveUsage(sf, sf.name, NoPrefix, tree.srcPos) tree override def transformTypeTree(tree: TypeTree)(using Context): tree.type = tree.tpe match case AnnotatedType(_, annot) => transformAllDeep(annot.tree) - case tpt if !tree.isInferred && tpt.typeSymbol.exists => resolveUsage(tpt.typeSymbol, tpt.typeSymbol.name, NoPrefix) + case tpt if !tree.isInferred && tpt.typeSymbol.exists => + resolveUsage(tpt.typeSymbol, tpt.typeSymbol.name, NoPrefix, tree.srcPos) case _ => tree @@ -207,12 +203,14 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha traverseAnnotations(tree.symbol) if tree.name.startsWith("derived$") && tree.hasType then def loop(t: Tree): Unit = t match - case Ident(name) => resolveUsage(t.tpe.typeSymbol, name, t.tpe.underlyingPrefix.skipPackageObject) - case Select(t, _) => loop(t) - case _ => + case Ident(name) => + resolveUsage(t.tpe.typeSymbol, name, t.tpe.underlyingPrefix.skipPackageObject, tree.srcPos) + case Select(t, _) => + loop(t) + case _ => tree.getAttachment(OriginalTypeClass).foreach(loop) if tree.symbol.isAllOf(DeferredGivenFlags) then - resolveUsage(defn.Compiletime_deferred, nme.NO_NAME, NoPrefix) + resolveUsage(defn.Compiletime_deferred, nme.NO_NAME, NoPrefix, tree.srcPos) tree override def prepareForDefDef(tree: DefDef)(using Context): Context = @@ -232,7 +230,7 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha if tree.symbol.is(Inline) then refInfos.inliners -= 1 if tree.symbol.isAllOf(DeferredGivenFlags) then - resolveUsage(defn.Compiletime_deferred, nme.NO_NAME, NoPrefix) + resolveUsage(defn.Compiletime_deferred, nme.NO_NAME, NoPrefix, tree.srcPos) tree override def prepareForTypeDef(tree: TypeDef)(using Context): Context = @@ -300,7 +298,7 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha def resolve(tpe: Type): Unit = val sym = tpe.typeSymbol if sym.exists then - resolveUsage(sym, sym.name, NoPrefix) + resolveUsage(sym, sym.name, NoPrefix, tree.srcPos) resolve(lo) resolve(hi) case _ => @@ -325,12 +323,14 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha for annot <- sym.denot.annotations do transformAllDeep(annot.tree) - /** If sym is not an enclosing element with respect to the give context, record the reference + /** If sym is not an enclosing element with respect to the given context, record the reference * * Also check that every enclosing element is not a synthetic member * of the sym's case class companion module. + * + * The LHS of a current Assign is never recorded as a reference (that is, a usage). */ - def refUsage(sym: Symbol)(using Context): Unit = + def refUsage(sym: Symbol, pos: SrcPos)(using Context): Unit = if !refInfos.hasRef(sym) then val isCase = sym.is(Case) && sym.isClass if !ctx.outersIterator.exists: outer => @@ -340,6 +340,9 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha && owner.exists && owner.is(Synthetic) && owner.owner.eq(sym.companionModule.moduleClass) + || outer.tree.match + case Assign(lhs, _) => lhs.symbol.eq(sym) && outer.tree.srcPos.sourcePos.contains(pos.sourcePos) + case _ => false then refInfos.addRef(sym) @@ -354,7 +357,7 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha * The `imports` flag is whether an identifier can mark an import as used: the flag is false * for inlined code, except for `summonInline` (and related constructs) which are resolved at inlining. */ - def resolveUsage(sym0: Symbol, name: Name, prefix: Type, imports: Boolean = true)(using Context): Unit = + def resolveUsage(sym0: Symbol, name: Name, prefix: Type, pos: SrcPos, imports: Boolean = true)(using Context): Unit = import PrecedenceLevels.* val sym = sym0.userSymbol @@ -457,7 +460,7 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha end while // record usage and possibly an import if !enclosed then - refUsage(sym) + refUsage(sym, pos) if imports && candidate != NoContext && candidate.isImportContext && importer != null then refInfos.sels.put(importer, ()) end resolveUsage @@ -465,7 +468,7 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha /** Simulate implicit search for contextual implicits in lexical scope and mark any definitions or imports as used. * Avoid cached ctx.implicits because it needs the precise import context that introduces the given. */ - def resolveScoped(tp: Type)(using Context): Unit = + def resolveScoped(tp: Type, pos: SrcPos)(using Context): Unit = var done = false val ctxs = ctx.outersIterator while !done && ctxs.hasNext do @@ -477,7 +480,7 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha else Nil implicitRefs.find(ref => ref.underlyingRef.widen <:< tp) match case Some(found: TermRef) => - refUsage(found.denot.symbol) + refUsage(found.denot.symbol, pos) if cur.isImportContext then cur.importInfo.nn.selectors.find(sel => sel.isGiven || sel.rename == found.name) match case Some(sel) => @@ -485,7 +488,7 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha case _ => return case Some(found: RenamedImplicitRef) if cur.isImportContext => - refUsage(found.underlyingRef.denot.symbol) + refUsage(found.underlyingRef.denot.symbol, pos) cur.importInfo.nn.selectors.find(sel => sel.rename == found.implicitName) match case Some(sel) => refInfos.sels.put(sel, ()) @@ -521,9 +524,6 @@ object CheckUnused: /** Ignore reference. */ val Ignore = Property.StickyKey[Unit] - /** Tree is LHS of Assign. */ - val AssignmentTarget = Property.StickyKey[Unit] - /** Tree is an inlined parameter. */ val InlinedParameter = Property.StickyKey[Unit] @@ -578,18 +578,12 @@ object CheckUnused: var inliners = 0 // depth of inline def (not inlined yet) - // instead of refs.addOne, use refUsage -> addRef to distinguish a read from a write to var - var isAssignment = false + def addAssignmentTarget(sym: Symbol): Unit = + asss.addOne(sym) def addRef(sym: Symbol): Unit = - if isAssignment then - asss.addOne(sym) - else - refs.addOne(sym) + refs.addOne(sym) def hasRef(sym: Symbol): Boolean = - if isAssignment then - asss(sym) - else - refs(sym) + refs(sym) // currently compiletime.testing is completely erased, so ignore the unit var isNullified = false @@ -1001,7 +995,6 @@ object CheckUnused: // with aliases into requiredModule("dotty.tools.dotc.ast.tpd") val implName = s"dotty.tools.dotc.ast.Trees$$${unapplied.name}" try - import scala.language.unsafeNulls val clz = Class.forName(implName) // TODO improve to use class path or reflect val ok = clz.getConstructors.head.getParameters.map(p => termName(p.getName)).toList.init allowVariableBindings(ok, args) diff --git a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala b/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala deleted file mode 100644 index 5534947c6799..000000000000 --- a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala +++ /dev/null @@ -1,53 +0,0 @@ -package dotty.tools.dotc -package transform - -import core.* -import ast.tpd -import MegaPhase.* -import Contexts.* -import Symbols.* -import Phases.* -import dotty.tools.io.JarArchive -import dotty.tools.backend.jvm.GenBCode - -/** - * Small phase to be run to collect main classes and store them in the context. - * The general rule to run this phase is: - * - The output of compilation is JarArchive - * - There is no `-Xmain-class` defined - * - * The following flags affect this phase: - * -d path.jar - * -Xmain-class - */ -class CollectEntryPoints extends MiniPhase: - - override def phaseName: String = CollectEntryPoints.name - - override def description: String = CollectEntryPoints.description - - override def isRunnable(using Context): Boolean = - def forceRun = ctx.settings.XmainClass.isDefault && ctx.settings.outputDir.value.isInstanceOf[JarArchive] - super.isRunnable && forceRun - - override def transformTypeDef(tree: tpd.TypeDef)(using Context): tpd.Tree = - getEntryPoint(tree).map(registerEntryPoint) - tree - - private def getEntryPoint(tree: tpd.TypeDef)(using Context): Option[String] = - val sym = tree.symbol - import core.NameOps.stripModuleClassSuffix - val name = sym.fullName.stripModuleClassSuffix.toString - Option.when(sym.isStatic && !sym.is(Flags.Trait) && ctx.platform.hasMainMethod(sym))(name) - - private def registerEntryPoint(s: String)(using Context) = { - genBCodePhase match { - case genBCodePhase: GenBCode => - genBCodePhase.registerEntryPoint(s) - case _ => - } - } - -object CollectEntryPoints: - val name: String = "Collect entry points" - val description: String = "collect all entry points and save them in the context" diff --git a/compiler/src/dotty/tools/dotc/transform/Constructors.scala b/compiler/src/dotty/tools/dotc/transform/Constructors.scala index b373565489f0..61220b503ceb 100644 --- a/compiler/src/dotty/tools/dotc/transform/Constructors.scala +++ b/compiler/src/dotty/tools/dotc/transform/Constructors.scala @@ -66,19 +66,30 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase = if (sym.exists && sym.owner.isClass && mightBeDropped(sym)) { val owner = sym.owner.asClass - tree match { - case Ident(_) | Select(This(_), _) => - def inConstructor = { - val method = ctx.owner.enclosingMethod - method.isPrimaryConstructor && ctx.owner.enclosingClass == owner - } - if (inConstructor && - (sym.is(ParamAccessor) || seenPrivateVals.contains(sym))) { - // used inside constructor, accessed on this, - // could use constructor argument instead, no need to retain field + tree match { + case Ident(_) | Select(This(_), _) => + val method = ctx.owner.enclosingMethod + // template exprs are moved below to constructor; lifted anonfun takes captured env as an arg + def checkAnonFun(meth: Symbol): Boolean = + meth.isAnonymousFunction + && { + val owner = meth.owner + owner.isLocalDummy + || owner.owner == sym.owner && !owner.isOneOf(MethodOrLazy) + || checkAnonFun(owner.enclosingMethod) } - else retain() - case _ => retain() + // restriction on module because lambdalift doesn't transform correctly (to do) + val inConstructor = + (method.isPrimaryConstructor || !sym.owner.is(Module) && checkAnonFun(method)) + && ctx.owner.enclosingClass == sym.owner + val noField = + inConstructor + && (sym.is(ParamAccessor) || seenPrivateVals.contains(sym)) + // used inside constructor, accessed on this, + // could use constructor argument instead, no need to retain field + if !noField then + retain() + case _ => retain() } } } @@ -231,7 +242,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase = constrStats += intoConstr(stat, sym) } else dropped += sym - case stat @ DefDef(name, _, tpt, _) if stat.symbol.isGetter && !stat.symbol.is(Lazy) => + case stat @ DefDef(name, _, tpt, _) if stat.symbol.isGetter && !stat.symbol.is(Lazy) && !stat.symbol.owner.isInlineTrait => val sym = stat.symbol assert(isRetained(sym), sym) if sym.isConstExprFinalVal then diff --git a/compiler/src/dotty/tools/dotc/transform/Dependencies.scala b/compiler/src/dotty/tools/dotc/transform/Dependencies.scala index 730b52f9e147..041359f0f85c 100644 --- a/compiler/src/dotty/tools/dotc/transform/Dependencies.scala +++ b/compiler/src/dotty/tools/dotc/transform/Dependencies.scala @@ -243,6 +243,13 @@ abstract class Dependencies(root: ast.tpd.Tree, @constructorOnly rootContext: Co captureImplicitThis(tree.tpe) case tree: Select => if isExpr(sym) && isLocal(sym) then markCalled(sym, enclosure) + else if sym.isConstructor && tree.qualifier.isInstanceOf[Super] then + // Super-call to a parent constructor (e.g. `super(args)` in the body of a + // local class's primary constructor, after Constructors phase has moved + // parent constructor calls into the constructor body). We track this as + // a call edge so that free variables of the parent constructor are + // propagated to this constructor. See i25943. + symSet(called, enclosure) += sym case tree: New => val constr = tree.tpe.typeSymbol.primaryConstructor if constr.exists then diff --git a/compiler/src/dotty/tools/dotc/transform/DesugarSpecializedTraits.scala b/compiler/src/dotty/tools/dotc/transform/DesugarSpecializedTraits.scala new file mode 100644 index 000000000000..933a68a42637 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/transform/DesugarSpecializedTraits.scala @@ -0,0 +1,754 @@ +package dotty.tools.dotc.transform + +import dotty.tools.dotc.ast.tpd +import dotty.tools.dotc.transform.MegaPhase.MiniPhase +import dotty.tools.dotc.core.Contexts.* +import dotty.tools.dotc.core.Decorators.i +import dotty.tools.dotc.core.Decorators.className +import dotty.tools.dotc.core.Symbols.{Symbol, ClassSymbol, newNormalizedClassSymbol} +import dotty.tools.dotc.CompilationUnit +import dotty.tools.dotc.core.StdNames.* +import dotty.tools.dotc.core.Types.* +import dotty.tools.dotc.core.Flags +import dotty.tools.dotc.core.Symbols.newClassSymbol +import scala.Function.const +import dotty.tools.dotc.core.Names.TypeName +import dotty.tools.dotc.core.Symbols.TypeSymbol +import dotty.tools.dotc.core.Symbols._ +import dotty.tools.dotc.ast.untpd +import dotty.tools.dotc.core.Symbols.defn +import dotty.tools.dotc.core.Flags.EmptyFlags +import dotty.tools.dotc.ast.TreeTypeMap +import dotty.tools.dotc.core.Scopes.EmptyScope +import dotty.tools.dotc.core.StdNames.str.SPECIALIZED_TRAIT_SUFFIX +import dotty.tools.dotc.core.Names.Name +import tpd._ +import scala.collection.mutable +import scala.annotation.unspecialized +import dotty.tools.dotc.typer.Synthesizer +import dotty.tools.dotc.core.NameKinds +import dotty.tools.dotc.core.Flags.GivenOrImplicit +import dotty.tools.dotc.core.NameKinds.ContextBoundParamName +import dotty.tools.dotc.core.NameKinds.FlatName +import dotty.tools.dotc.inlines.Inlines +import dotty.tools.dotc.util.Spans.Span +import dotty.tools.dotc.report +import dotty.tools.dotc.core.Flags.InlineTrait +import dotty.tools.dotc.core.Annotations.Annotation +import dotty.tools.dotc.core.Constants.Constant +import dotty.tools.dotc.util.SrcPos +import dotty.tools.dotc.core.Decorators.nestedMap +import dotty.tools.dotc.core.NameOps.expandedName +import dotty.tools.dotc.core.DenotTransformers.DenotTransformer +import dotty.tools.dotc.core.Denotations.SingleDenotation +import dotty.tools.dotc.core.Flags.InlineMethod +import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer +import dotty.tools.dotc.core.Names.TermName +import dotty.tools.dotc.util.Spans.spanCoord +import dotty.tools.dotc.util.Spans.NoSpan +import dotty.tools.dotc.transform.DesugarSpecializedTraits.specType +import dotty.tools.dotc.transform.DesugarSpecializedTraits.isTopClass +import dotty.tools.dotc.reporting.VarianceInSpecializedTraitsLimitation +import dotty.tools.dotc.transform.DesugarSpecializedTraits.isTopClassOrNothing + +class DesugarSpecializedTraits extends MacroTransform, IdentityDenotTransformer: + + override def phaseName: String = DesugarSpecializedTraits.name + override def description: String = DesugarSpecializedTraits.description + override def changesMembers: Boolean = false + override def changesParents: Boolean = true + override def allowsImplicitSearch: Boolean = true + + private def newInterfaceTrait(specialization: Specialization, specializations: SpecializedTraitCache)(using Context): (ClassSymbol, SpecializedTraitCache) = { + val tm = new TypeMap: // TODO: Can we get this into the specialization ideally. + def apply(t: Type) = specialization.specializedTypeParamsToTypeArgumentsMap.view.mapValues(_.tpe).applyOrElse(t, mapOver) // TODO: If we can do just types we can get rid of this + + val inheritedParents = specialization.traitSymbol.denot.info.parents.filterNot(_.typeSymbol == defn.ObjectClass).map(tm(_)) + // Parents may be specializable and so we need to specialize them as well + // See ArrayIterator extends Iterator in specialized-trait-collections-example.scala + val specializations1 = inheritedParents.foldLeft(specializations)((specializations, parent) => + (parent, specialization.span) match { + case Specialization(spec) if spec.isSpecialized => specializations.addInterface(spec) + case _ => specializations + } + ) + + // Order is depended on in Erasure::typedClassDef and TypeErasure:eraseParent + val parents = defn.ObjectType + :: AppliedTypeTree(Ident(specialization.traitSymbol.typeRef), specialization.specialization).tpe // original trait, specialized to Foo[Int] + :: inheritedParents // parents of the original trait in the form Foo[Int] (later specialized to Foo$sp$Int) + + // Create new trait + val traitSymbol = newNormalizedClassSymbol( + specialization.traitSymbol.owner.enclosingPackageClass, // For specialized traits defined inside objects/classes etc, pre-Flatten the $sp$ and $impl$ def trees (i.e. + // make them live in the enclosing package with the flattened name). We do this because it's easier than + // finding the defining tree of the object, which would require scanning the whole file, and it + // might be in another compilation unit / already compiled. + DesugarSpecializedTraits.newSpecializedTraitName(specialization), + Flags.Synthetic | Flags.Trait | Flags.Inline, + parents, + tm(specialization.traitSymbol.asClass.classInfo.selfType), + specialization.traitSymbol.privateWithin, + spanCoord(specialization.span), // TODO: Show errors where they actually show up in the inline trait and not at the type of the user which is very confusing. Need to use inline stack + specialization.traitSymbol.compilationUnitInfo + ) + + buildTypeParameters(traitSymbol, specialization) + (traitSymbol.entered, specializations1) + } + + private def buildInterfaceTraitTree(specialization: Specialization, interfaceSymbol: ClassSymbol)(using Context) = { + val init = newConstructor(interfaceSymbol, EmptyFlags, Nil, Nil, coord=spanCoord(specialization.span)) + fixConstructor(init, interfaceSymbol) + ClassDef(interfaceSymbol, DefDef(init.entered), Nil).withSpan(specialization.span) + } + + /* Fix constructor so that it: + 1) Has correct generic type parameters + 2) Returns the correct type corresponding to those type parameters applied + 3) Has correct parameter names corresponding to targetParamNames */ + private def fixConstructor(init: Symbol, traitOrClassSymbol: ClassSymbol, targetParamNames: List[List[TermName]] = List())(using Context) = + val rt = traitOrClassSymbol.typeRef.appliedTo(traitOrClassSymbol.typeParams.map(_.typeRef)) + def resultType(tpe: Type, targetParamNames: List[List[TermName]]): Option[Type] = + tpe match { + case mt @ MethodType(paramNames) => targetParamNames match { + case head :: tail => Some(mt.derivedLambdaType(head, mt.paramInfos, resultType(mt.resultType, tail).getOrElse(rt))) + case Nil => Some(mt.derivedLambdaType(paramNames, mt.paramInfos, resultType(mt.resultType, targetParamNames).getOrElse(rt))) + } + case pt : PolyType => Some(pt.derivedLambdaType(pt.paramNames, pt.paramInfos, resultType(pt.resType, targetParamNames).get)) + case _ => None + } + init.info = resultType(init.info, targetParamNames).get + init.info = PolyType.fromParams(init.owner.typeParams, init.info) + + private def buildTypeParameters(traitOrClassSymbol: ClassSymbol, specialization: Specialization)(using Context) = + val tps = newTypeParams(traitOrClassSymbol, + specialization.unspecializedTypeParams.map(_.typeSymbol.name.asTypeName), + EmptyFlags, + targets => targets.map(t => specialization.traitSymbol.typeParams.find(_.name == t.name).get.info.bounds) + ) + tps.foreach(traitOrClassSymbol.enter(_, EmptyScope)) + + // Replace old type parameters that were copied from original trait with new ones + // inside the parents of the new trait + val tpMap: Map[Type, Type] = specialization.unspecializedTypeParams.zip(tps.map(_.typeRef)).toMap + val freshTypeVarMap = new TypeMap: + def apply(t: Type) = tpMap.applyOrElse(t, mapOver) + + def mapSelfType(st: Type | Symbol): Type | Symbol = + if st.isInstanceOf[Symbol] then + st.asInstanceOf[Symbol].copy(info = freshTypeVarMap(st.asInstanceOf[Symbol].info)) + else + freshTypeVarMap(st.asInstanceOf[Type]) + + traitOrClassSymbol.info = ClassInfo(traitOrClassSymbol.owner.thisType, traitOrClassSymbol, traitOrClassSymbol.info.parents.map(freshTypeVarMap(_)), traitOrClassSymbol.info.decls, mapSelfType(traitOrClassSymbol.classInfo.selfInfo)) + + // Order is depended on in Erasure::typedClassDef and TypeErasure:eraseParent + private def generateImplementationClassParents(specialization: Specialization, interfaceSymbol: Option[ClassSymbol])(using Context) = + val objectParent = defn.ObjectType + val traitSpParent = interfaceSymbol.map(_.typeRef.appliedTo(specialization.unspecializedTypeParams)) // Set using old unspecializedTypeParams and replace after. + val originalTraitSpecializedParent = AppliedTypeTree(Ident(specialization.traitSymbol.typeRef), specialization.mapSpecializedUnspecializedArgs(tr => TypeTree(specType(tr.tpe)), specialization.unspecializedTypeParams.map(TypeTree(_)))).tpe + (objectParent, traitSpParent, originalTraitSpecializedParent) + + private def newImplementationClass(specialization: Specialization, interfaceSymbol: Option[ClassSymbol])(using Context) = + val (objectParent, traitSpParent, originalTraitSpecializedParent) = generateImplementationClassParents(specialization, interfaceSymbol) + val parents = if traitSpParent.nonEmpty then List(objectParent, traitSpParent.get, originalTraitSpecializedParent) else List(objectParent, originalTraitSpecializedParent) + + val newImplementationClassSymbol = newNormalizedClassSymbol( + specialization.traitSymbol.owner.enclosingPackageClass, + DesugarSpecializedTraits.newImplementationClassName(specialization), + Flags.Synthetic, + parents, + NoType, + specialization.traitSymbol.privateWithin, + spanCoord(specialization.span), + specialization.traitSymbol.compilationUnitInfo + ) + + specialization.traitSymbol.addAnnotation(Annotation.Child(newImplementationClassSymbol, newImplementationClassSymbol.span.startPos)) + + buildTypeParameters(newImplementationClassSymbol, specialization) + + newImplementationClassSymbol.entered + + // TODO: Do we want to share some code with the newSpecializedInterfaceTrait and buildInterfaceTraitTree? + // TODO: Tidy this up a bit with functions + // intefaceSymbol: None if no interface; this only happens with the fully non-specialized $impl$ (raw) case + private def buildImplementationClassTree(specialization: Specialization, interfaceSymbol: Option[ClassSymbol], classSymbol: ClassSymbol)(using Context) = { + val (objectParent, traitSpParent_, originalTraitSpecializedParent_) = generateImplementationClassParents(specialization, interfaceSymbol) + + // Apply Type Param Fix: TODO : This really ought to be done more cleanly somewhere else. + val tpMap: Map[Type, Type] = specialization.unspecializedTypeParams.zip(classSymbol.typeParams.map(_.typeRef)).toMap + val freshTypeVarMap = new TypeMap: + def apply(t: Type) = tpMap.applyOrElse(t, mapOver) + val traitSpParent = traitSpParent_.map(tp => freshTypeVarMap(tp)) + val originalTraitSpecializedParent = freshTypeVarMap(originalTraitSpecializedParent_) + + val init = newConstructor(classSymbol, EmptyFlags, Nil, Nil, coord=spanCoord(specialization.span)) + val tm = new TypeMap: // TODO: Can we get this into the specialization ideally. + def apply(t: Type) = specialization.specializedConstructorParamToArgumentTypeMap.applyOrElse(t, mapOver) + + /* Create constructor and setup constructor type */ + val nonTypeParams = specialization.traitSymbol.primaryConstructor.rawParamss.tail + val oldTypeParams = specialization.unspecializedConstructorParams + val initTypeParams = classSymbol.typeParams.map(s => s.copy(owner = init, flags = (s.flags &~ (Flags.Private | Flags.Deferred)))) + val valueParams = nonTypeParams.map(_.map(param => param.copy(owner = init, info = tm(param.info).substSym(oldTypeParams, initTypeParams), name=param.name.expandedName(classSymbol)))) // We need to map the parameter names to avoid a name clash with val params from parents (see tests/pos/specialized-trait-val-parameter.scala) + + initTypeParams.foreach(_.entered) + init.setParamss(initTypeParams :: valueParams) + init.info = specialization.traitSymbol.primaryConstructor.info.appliedTo( // Type Arg if specialized; otherwise we want our type param. + specialization.constructorTypeParams.map(par => specialization.specializedConstructorParamToArgumentTypeMap.applyOrElse(par, _.subst(oldTypeParams, classSymbol.typeParams.map(_.typeRef)))) + ) + fixConstructor(init, classSymbol, valueParams.map(_.map(_.name.asTermName))) + + /* Build param accessors */ + val paramAccessorss = valueParams.map(params => params.map(s => s.copy(owner = classSymbol, flags=(s.flags|Flags.LocalParamAccessor) &~ Flags.Param, info = s.info.subst(initTypeParams, classSymbol.typeParams.map(_.typeRef))))) + paramAccessorss.foreach(_.foreach(classSymbol.enter(_))) + + /* Build class def tree */ + val newParamss = paramAccessorss.nestedMap(ref(_)) + val newParams1 = if (newParamss.length == 1) then newParamss ++ List(List()) else newParamss + + // Re-expand varargs parameters from Seq[T] to *T for passing into parent constructor + val newParams2 = newParams1.nestedMap( param => + if param.symbol.info.hasAnnotation(defn.RepeatedAnnot) then ctx.typer.seqToRepeated(param) else param + ) + + val opTree = New(objectParent, objectParent.classSymbol.primaryConstructor.asTerm, Nil) + val tspTree = traitSpParent.map(tsp => New(tsp, tsp.classSymbol.primaryConstructor.asTerm, Nil)) + val opSpTree = New(originalTraitSpecializedParent.typeConstructor) + .select(TermRef(originalTraitSpecializedParent.typeConstructor, specialization.traitSymbol.primaryConstructor.asTerm)) + .appliedToTypes(originalTraitSpecializedParent.argTypes) + .appliedToArgss(newParams2) + + // TODO: Clean and robust + ClassDefWithParents( + classSymbol, + DefDef(init.asTerm.entered), + if tspTree.nonEmpty then List(opTree, tspTree.get, opSpTree) + else List(opTree, opSpTree), + // Put into body of class + paramAccessorss.flatMap(syms => syms.map(sym => tpd.ValDef(sym.asTerm))) + ).withSpan(specialization.span) + } + + /* We can replace implementation class already because they implement both Foo[Int] and Foo$sp$Int so they are + a drop in replacement for the anonymous classes that implement Foo[Int], and so we can swap them in without + modifying signatures / interfaces, which we have to do later at erasure. We don't really want to wait with + this replacement because it's easier to detect the anonymous classes earlier before they undergo too many transforms, + and doing it at erasure would be strange given it's a tree transform and not a type transform. */ + private def replaceImplementationClassesMap(specializations: SpecializedTraitCache)(using Context) = + + def treeMap(tree: Tree): Tree = tree match { + /* Replace new Foo[Int] {} with new Foo$impl$Int.asInstanceOf[Foo$sp$Int] + This has already been desugared to an anonymous class instance with parents: + Objects, Parents of Foo, Foo. */ + + case AnonymousSpecializationInstance(anon) => + def deandify(tp: Type): Iterator[Type] = tp match + case AndType(l, r) => deandify(l) ++ deandify(r) + case _ => Iterator.single(tp) + anon.typeTree.tpe match { + case a: AndType => /* Multiple mixed in traits will be typed as an AndType */ + deandify(a).foreach(trt => + Specialization.unapply(trt, anon.typeTree.span).foreach {spec => + if spec.hasSpecializedParams then + report.error("Anonymous classes acting as instances of Specialized traits may not mix in other traits; you can make a named object instead if you like.", anon.srcPos) + } + ) + tree + case tpe => + Specialization.unapply(tpe, anon.typeTree.span).map(spec => + { + if spec.hasSpecializedParams then + if anon.body.filterNot(x => x.symbol.name.is(ContextBoundParamName)).nonEmpty then // Only allowed to contain evidence parameters + report.error("Anonymous classes acting as instances of Specialized traits may not have additional members; you can make a named object instead if you like.", anon.srcPos) + + anon.parentCalls match { + case (obj :: parentsOfSpecTrait) :+ (app@Apply(_, _)) if (obj.symbol.owner == ctx.definitions.ObjectClass) && (parentsOfSpecTrait.forall(x => spec.traitSymbol.asClass.baseClasses.exists(p => p == x.symbol.owner))) => + tree + case _ => + report.error("Anonymous classes acting as instances of Specialized traits may not mix in other traits; you can make a named object instead if you like.", anon.srcPos) + tree + } + else + tree + }).getOrElse(tree) + } + case tree => tree + } + new TreeTypeMap(treeMap = treeMap) + end replaceImplementationClassesMap + + /* Override flags can be generated by inline trait inlining, but after removing the Foo[Int] parent the corresponding members no longer override members in their parents. + Therefore we need to remove them. */ + def removeRedundantOverridesMap(using Context) = new TreeTypeMap(treeMap = + tree => tree match { + case dd@DefDef(name, paramss, tpt, preRhs) => + if dd.symbol.exists && dd.symbol.allOverriddenSymbols.isEmpty && (dd.symbol.owner.isSpecializedTraitInterface || dd.symbol.owner.isSpecializedTraitImplementationClass) then + dd.symbol.flags = dd.symbol.flags &~ Flags.Override + dd + + case vd@ValDef(name, tpt, preRhs) => + if vd.symbol.exists && vd.symbol.allOverriddenSymbols.isEmpty && (vd.symbol.owner.isSpecializedTraitInterface || vd.symbol.owner.isSpecializedTraitImplementationClass) then + vd.symbol.flags = vd.symbol.flags &~ Flags.Override + vd + + case tree => tree + } + ) + + // Returns (new stmts including original, new symbols including original) + private def transformStatements(stats1: List[Tree], specializations: SpecializedTraitCache)(using Context): (List[Tree], SpecializedTraitCache) = { + + val inlineSpecializedMethods = new TreeMapWithPreciseStatContexts { + override def transform(tree: Tree)(using Context): Tree = tree match { + case MethodSpecialization(methSpec) if methSpec.isSpecialized || methSpec.isFullySpecializedToTopClassesOrNothing => + // TODO: Not sure why we needed this - it doesn't seem to make any difference + def flattenTree(inlinedTree: Tree): Tree = inlinedTree match { + case it@Inlined(call, bindings, expansion) => + val callTrace = Inlines.inlineCallTrace(tree.symbol, inlinedTree.sourcePos)(using ctx.withSource(inlinedTree.source)) + cpy.Inlined(it)(callTrace, bindings, expansion)(using inlineContext(it)) + case Block(stats, expr) => Block(stats, flattenTree(expr)) + case t => t // if inlining failed due to max inlines reached + } + + val inlinedTree = Inlines.inlineCall(tree) + super.transform(flattenTree(inlinedTree)) + case tree => super.transform(tree) + } + } + + val stats = inlineSpecializedMethods.transform(stats1) + + val specializations1 = collectReferencedSpecializations(stats, specializations) + val generatedTraitStats = specializations1.getNewInterfaceSymbols.toList.map(buildInterfaceTraitTree) + val generatedClassStats = specializations1.getNewImplementationSymbols.toList.map(buildImplementationClassTree) + + val specializations2 = specializations1.installNewInterfaceSymbols.installNewImplementationSymbols + + val generatedTraitStats1 = generatedTraitStats.map { + case tree: TypeDef => + assert(tree.symbol.isInlineTrait) + val inlined = Inlines.inlineParentInlineTraits(Inlines.checkAndTransformInlineTrait(tree)).asInstanceOf[TypeDef] + cpy.TypeDef(inlined)(name = inlined.name, rhs = inlined.rhs).withSpan(inlined.span) + } + + val generatedClassStats1 = generatedClassStats.map { + case tree: TypeDef => + val inlined = Inlines.inlineParentInlineTraits(tree).asInstanceOf[TypeDef] + cpy.TypeDef(inlined)(name = inlined.name, rhs = inlined.rhs).withSpan(inlined.span) + } + + val (generatedTraitStatsFinal, generatedClassStatsFinal, specializationsFinal) = + if (generatedTraitStats1.isEmpty && generatedClassStats1.isEmpty) + (generatedTraitStats1, generatedClassStats1, specializations2) + else + val (generatedTraitStats2, specializations3) = transformStatements(generatedTraitStats1, specializations2) + val (generatedClassStats2, specializations4) = transformStatements(generatedClassStats1, specializations3) + + /* We need to do the parent removal after inlining into the $impl$ classes otherwise we break + overriding/interface implementation rules during the inlining. The $impl$ inlining + can also happen in the recursive calls, and so we need to do this right at the end (after the recursive calls): */ + (generatedTraitStats2, generatedClassStats2, specializations4) + + val statsFinal = generatedTraitStatsFinal ++ + generatedClassStatsFinal ++ + stats.map(stat => replaceImplementationClassesMap(specializationsFinal)(stat)) + + (statsFinal.map(removeRedundantOverridesMap(_)), specializationsFinal) +} + + override protected def newTransformer(using Context): Transformer = new Transformer: + override def transform(tree: Tree)(using Context): Tree = + tree match { // TODO: Is Package level processing really what we want? Given we are going to output the classes somewhere else do we not really want either to deepFold the whole tree directly or do a more direct transform? + case pkg@PackageDef(pid, stats) => // TODO: If we do everything ourselves and match only on the package then we can get rid of the MacroTransform aspect and just have a Phase with the transformPackageDef method or even transformStats ideally + + def checkType(t: Type, pos: SrcPos) = t.widen.dealias match { + case SpecializedEvidence(_) => + report.error(s"Only inline traits and inline functions may take Specialized type parameters", pos) + case _ => + } + + tree.foreachSubTree { // TODO: This is not particularly efficient + case d@DefDef(name, paramss, tpt, preRhs) if d.symbol.isConstructor && !d.symbol.owner.is(Flags.Inline) => d.paramss.flatten.foreach(p => checkType(p.tpe, d.srcPos)) + case d@DefDef(name, paramss, tpt, preRhs) if !d.symbol.isConstructor && !d.symbol.is(Flags.Inline) => d.paramss.flatten.foreach(p => checkType(p.tpe, d.srcPos)) + case _ => + } + + if ctx.specializedTraitState.specializedTraitCache.isEmpty then + ctx.specializedTraitState.specializedTraitCache = Some(SpecializedTraitCache(genInterfaceSymbol = newInterfaceTrait, genImplementationSymbol = newImplementationClass)) + + val (stats1, specializedTraitCache2) = transformStatements(stats, ctx.specializedTraitState.specializedTraitCache.get) + ctx.specializedTraitState.specializedTraitCache = Some(specializedTraitCache2) // TODO: Avoid mutation here - we will make the cache mutable instead I think. Makes more sense + + val grouped = stats1.groupBy(tree => tree.symbol.enclosingPackageClass) + + tpd.PackageDef(Ident(defn.EmptyPackageVal.namedType), + grouped.getOrElse(defn.RootClass, List()) ::: + grouped.getOrElse(defn.EmptyPackageClass, List()) ::: + grouped.toList.filter((pk, stmts) => pk != defn.RootClass && pk != defn.EmptyPackageClass).map((pkg, stmts) => tpd.PackageDef(Ident(pkg.sourceModule.namedType), stmts)) + ) + } + + private def collectReferencedSpecializations(stats: List[Tree], specializations: SpecializedTraitCache)(using Context): SpecializedTraitCache = + stats.foldLeft(specializations)((specializations, tree) => { + tree.deepFold(specializations)((specializations, tree) => tree match + case t@TypeDef(name, tmpl: Template) if t.symbol.isSpecializedTrait => + if !t.symbol.isStatic then + // The approach we use for flattening makes this quite tricky: see e.g. tests/neg/specialized-trait-scoped-inside-object-deep-nesting.scala. + // In theory can scan the tree to find where to put the generated traits instead, but this still doesn't work cross-CU, so for now we ban. + report.error("Specialized traits may not be defined inside classes or traits (this would make them path-dependent which is not currently supported); they may be defined inside objects.", t.symbol.srcPos) + t.symbol.typeParams.foreach: par => + if par.paramVariance.isOneOf(Flags.Contravariant | Flags.Covariant) && Specialization.classSpecializedTypeParams(t.symbol).exists(t => t.typeSymbol == par) then + report.warning(VarianceInSpecializedTraitsLimitation(), par.srcPos) + specializations + case Typed(Apply(Select(New(anon),ctor),List()), t: TypeTree) if anon.symbol.isAnonymousClass => + (t.tpe, t.span) match { + case Specialization(spec) if spec.isFullySpecializedToTopClassesOrNothing => specializations.addErasedImplementation(spec) // We never inline into anonymous class instances (avoids cycles in inline trait inlining), so + // all anonymous class instances must have a non-anonymous class final representation as an $impl$ class. + case Specialization(spec) if spec.isSpecialized => specializations.addInterfaceAndImplementation(spec) + case _ => specializations + } + case Specialization(spec) => + if (spec.hasSpecializedParams) { + // Block Vec[?] and similar + spec.specializedTypeArgs.filter { + case t: TypeBoundsTree => true + case _ => false + }.foreach: tr => + report.error("Wildcard types may not be substituted for Specialized type parameters.", tr.srcPos) + } + if (spec.isSpecialized) { + specializations.addInterface(spec) + } else { + // Check foo[S: Specialized] <= Vec[S: Specialized] + spec.specializedTypeArgs.flatMap(arg => { // For each type we are using in a Specialized position + arg.tpe.widen.dealias.namedPartsWith(part => // Find all type params within that type that are not marked as Specialized so we can error + part.typeSymbol.isTypeParam && + (!(if part.typeSymbol.owner.isClass then part.typeSymbol.owner.primaryConstructor else part.typeSymbol.owner).paramSymss.flatten.exists( + d => d.info match { + case SpecializedEvidence(tpeArg) => + tpeArg.typeSymbol.isTypeParam && tpeArg.typeSymbol.name == part.name + case _ => false + } + )) + ) + }).foreach: tr => + if tr.denot.symbol.srcPos.span.exists then + report.error(s"${tr.typeSymbol} used in a Specialized position, so it must be marked as Specialized at its definition.", tr.denot.symbol.srcPos) + specializations + } + + case app @ Apply(_, _) => tpd.methPart(app) match { // class / object Bar extends Foo[Int](params) + case fun @ Select(New(tpt), init) if fun.symbol.isConstructor => tpd.allArgss(tree) match { + case typeArgs :: valueArgss => + val spec = Specialization(fun.symbol.owner, typeArgs, app.span) + if spec.isSpecialized then specializations.addInterface(spec) else specializations + case _ => specializations + } + case _ => specializations + } + + case _ => specializations + ) + }) +end DesugarSpecializedTraits + +object DesugarSpecializedTraits: + val name: String = "desugarSpecializedTraits" + val description: String = "Replaces traits having type parameters that have the Specialized annotation with specialized versions" + + // TODO: Do we want to compress this more by adopting e.g. specializedTypeNames from scala 2? + // TODO: NameKind? + def canonicalName(tp: Type)(using Context): String = tp.dealias match + case AppliedType(tycon, args) => + canonicalName(tycon) + args.map(canonicalName).mkString("$_$") + case other => + other.typeSymbol.fullName.toString.replace('.', '$') + + + // TODO: What happens with this name generation if we have Vec[Vec[T]] for example? We potentially don't have an Ident + // TODO: Check what happens here when we have a case where the types being specialized into are user defined instead of primitives or type vars. + private def generateName(specialization: Specialization, suffix: String)(using Context) = + val name = (specialization.traitSymbol.name ++ suffix ++ "$").asTypeName ++ specialization.specializedTypeArgs.map(t => canonicalName(specType(t.tpe))).mkString(str.SPECIALIZED_TRAIT_TYPE_SEP) + if specialization.traitSymbol.owner.is(Flags.Package) then + name + else + FlatName(specialization.traitSymbol.owner.flatName.toTermName, name.toTermName).toSimpleName.toTypeName + + /*private[transform]*/ def newSpecializedTraitName(specialization: Specialization)(using Context): TypeName = + generateName(specialization, str.SPECIALIZED_TRAIT_SUFFIX) + + /*private[transform]*/ def newImplementationClassName(specialization: Specialization)(using Context): TypeName = + if specialization.isFullySpecializedToTopClassesOrNothing then + (specialization.traitSymbol.name ++ str.SPECIALIZED_TRAIT_IMPL_SUFFIX).asTypeName + else + generateName(specialization, str.SPECIALIZED_TRAIT_IMPL_SUFFIX) + + def isTopClass(s: Symbol)(using Context): Boolean = + (s eq defn.AnyClass) || (s eq defn.AnyValClass) || (s eq defn.ObjectClass) || (s eq defn.AnyRefAlias) + def isTopClassOrNothing(s: Symbol)(using Context): Boolean = (s eq defn.NothingClass) || isTopClass(s) + + def specType(tp: Type)(using Context): Type = + + def isSimpleClassType(s: Symbol): Boolean = + s.isClass && !s.is(Flags.Trait) && s.typeParams.isEmpty && s.isStatic + + tp.baseClasses.iterator.find(c => + isSimpleClassType(c) && (isTopClassOrNothing(c) || isTopClassOrNothing(c.asClass.superClass)) + ).map(_.typeRef).get + + def isSameErasureBucket(tp1: Type, tp2: Type)(using Context) = + val sp1 = specType(tp1) + val sp2 = specType(tp2) + (sp1 eq sp2) || isTopClassOrNothing(tp1.classSymbol) && isTopClassOrNothing(tp2.classSymbol) + +end DesugarSpecializedTraits + +/* + Stores the specializations we have found in the program and the symbols for the interface traits and implementation classes + that will replace them. We generate these symbols when we enter the specializations into the cache, via the functions + we store in genInterfaceSymbol and genImplementationSymbol. + + Model: Contains two levels: + - interface/implementation symbols we have found since the last installNewInterface/ImplementationSymbols call + (i.e. typically on this iteration) ("new") + - Those we found prior to that call, that were thus installed by it or previously + + Invariant: (newImplementationSymbols ∪ implementationSymbols) ⊆ (interfaceSymbols ∪ newInterfaceSymbols). +*/ + +object SpecializedTraitCache: + type SymbolMap = Map[Specialization, ClassSymbol] + type GenInterfaceSymbol = (Specialization, SpecializedTraitCache) => Context ?=> (ClassSymbol, SpecializedTraitCache) + type GenImplementationSymbol = (Specialization, Option[ClassSymbol]) => Context ?=> ClassSymbol + +// TODO: We don't need to share this between phases anymore and maybe we don't even need it at all. Can also rename. +class SpecializedTraitCache( + private val newInterfaceSymbols: SpecializedTraitCache.SymbolMap = Map.empty, + private val newImplementationSymbols: SpecializedTraitCache.SymbolMap = Map.empty, + private val interfaceSymbols: SpecializedTraitCache.SymbolMap = Map.empty, + private val implementationSymbols: SpecializedTraitCache.SymbolMap = Map.empty, + private val genInterfaceSymbol: SpecializedTraitCache.GenInterfaceSymbol, + private val genImplementationSymbol: SpecializedTraitCache.GenImplementationSymbol +): + + def copy( + newInterfaceSymbols: SpecializedTraitCache.SymbolMap = this.newInterfaceSymbols, + newImplementationSymbols: SpecializedTraitCache.SymbolMap = this.newImplementationSymbols, + interfaceSymbols: SpecializedTraitCache.SymbolMap = this.interfaceSymbols, + implementationSymbols: SpecializedTraitCache.SymbolMap = this.implementationSymbols, + genInterfaceSymbol: SpecializedTraitCache.GenInterfaceSymbol = this.genInterfaceSymbol, + genImplementationSymbol: SpecializedTraitCache.GenImplementationSymbol = this.genImplementationSymbol) + = SpecializedTraitCache(newInterfaceSymbols, newImplementationSymbols, interfaceSymbols, implementationSymbols, genInterfaceSymbol, genImplementationSymbol) + + def getInterfaceSymbol(spec: Specialization): Option[ClassSymbol] = newInterfaceSymbols.orElse(interfaceSymbols).lift(spec) + def getImplementationSymbol(spec: Specialization): Option[ClassSymbol] = newImplementationSymbols.orElse(implementationSymbols).lift(spec) + + def getNewInterfaceSymbols: List[(Specialization, ClassSymbol)] = newInterfaceSymbols.toList + def getNewImplementationSymbols: List[(Specialization, Option[ClassSymbol], ClassSymbol)] = newImplementationSymbols.map((k, v) => (k, getInterfaceSymbol(k), v)).toList + + def addInterface(spec: Specialization)(using Context): SpecializedTraitCache = + if (newInterfaceSymbols.contains(spec) || interfaceSymbols.contains(spec)) then + this + else + val (targetSymbol, resultingCache) = genInterfaceSymbol(spec, this) + resultingCache.copy(newInterfaceSymbols = resultingCache.newInterfaceSymbols + (spec -> targetSymbol)) + def addErasedImplementation(spec: Specialization)(using Context): SpecializedTraitCache = + val erased = Specialization(spec.traitSymbol, spec.mapSpecializedUnspecializedArgs(_ => TypeTree(defn.AnyClass.typeRef), spec.unspecializedTypeArgs), spec.span) + if (newImplementationSymbols.contains(erased) || implementationSymbols.contains(erased)) then + this + else + this.copy(newImplementationSymbols = this.newImplementationSymbols + (erased -> genImplementationSymbol(erased, this.getInterfaceSymbol(erased)))) + def addInterfaceAndImplementation(spec: Specialization)(using Context): SpecializedTraitCache = + if (newImplementationSymbols.contains(spec) || implementationSymbols.contains(spec)) then + this + else + val withInterface = addInterface(spec) + withInterface.copy(newImplementationSymbols = withInterface.newImplementationSymbols + (spec -> genImplementationSymbol(spec, withInterface.getInterfaceSymbol(spec)))) + + def installNewInterfaceSymbols = + this.copy( + newInterfaceSymbols = Map.empty, + interfaceSymbols = interfaceSymbols ++ newInterfaceSymbols) + + def installNewImplementationSymbols = + this.copy( + newImplementationSymbols = Map.empty, + implementationSymbols = implementationSymbols ++ newImplementationSymbols) + +end SpecializedTraitCache + +/* Represents an application traitSymbol[typeArguments] */ +class Specialization(val traitSymbol: Symbol, val typeArguments: List[Tree], val span: Span)(using Context): // TODO: Can we get away with List[Type] + val specializedTypeParams: List[Type] = Specialization.classSpecializedTypeParams(traitSymbol) // Type parameters marked with Specialized + + // private val specializedTypeParamsSet = specializedTypeParams.toSet // TODO: We can bring this back if we manage to get the =:= type hashing but it's really not a big deal given the expected number of type parameters. + private val paramToArgList = traitSymbol.typeParams.map(_.typeRef.asInstanceOf[Type]).zip(typeArguments) + + val unspecializedTypeParams: List[Type] = paramToArgList.filterNot((tParam, tArg) => specializedTypeParams.exists(_ =:= tParam)).map(_._1) // Type parameters not marked with Specialized + val specializedTypeArgs: List[Tree] = paramToArgList.filter((tParam, tArg) => specializedTypeParams.exists(_ =:= tParam)).map(_._2) // Type arguments provided to parameters that are marked with Specialized at their definition + val unspecializedTypeArgs: List[Tree] = paramToArgList.filterNot((tParam, tArg) => specializedTypeParams.exists(_ =:= tParam)).map(_._2) // Type arguments provided to parameters that are not marked with Specialized at their definition + + val specializedTypeParamsToTypeArgumentsMap: Map[Type, Tree] = paramToArgList.toMap.filter((k, v) => specializedTypeParams.exists(_ =:= k)).view.mapValues(tr => TypeTree(specType(tr.tpe))).toMap // TODO: Maybe not efficient + val specialization: List[Tree] = traitSymbol.typeParams.map(_.typeRef).map(specializedTypeParamsToTypeArgumentsMap.applyOrElse(_, TypeTree(_))) // TODO: Don't really like this name + + def constructorTypeParams: List[Type] = traitSymbol.primaryConstructor.rawParamss.head.map(_.typeRef) + def unspecializedConstructorParams: List[Symbol] = traitSymbol.primaryConstructor.rawParamss.head.zip(traitSymbol.typeParams).filterNot((constrParam, typeParam) => specializedTypeParams.exists(_ =:= typeParam.typeRef)).map((constrParam, typeParam) => constrParam) + def specializedConstructorParamToArgumentTypeMap: Map[Type, Type] = + traitSymbol.primaryConstructor.rawParamss.head.map(_.typeRef).zip(paramToArgList).filter((constrParam, paramArg) => specializedTypeParams.exists(_ =:= paramArg._1)).map((constrParam, paramArg) => (constrParam, specType(paramArg._2.tpe))).toMap + + val hasSpecializedParams: Boolean = specializedTypeParams.nonEmpty + + def mapSpecializedUnspecializedArgs(spec: Tree => Tree, unspec: List[Tree]): List[Tree] = paramToArgList.foldLeft((List.empty[Tree], unspec))((resUnspec, paramArg) => ((resUnspec, paramArg): @unchecked) match { + case ((result, unspec), (param, arg)) if specializedTypeParams.exists(_ =:= param) => (spec(arg) :: result, unspec) + case ((result, head :: rest), (param, arg)) => (head :: result, rest) + })._1.reverse + + /* If inline trait Foo[T: Specialized] has a method taking another Foo[T] there's no point specializing the reference + since the resulting sp$T$ would be the same as the starting trait. Also A[Object] specializes to A. */ + def isSpecialized: Boolean = + hasSpecializedParams && specializedTypeArgs.exists(tree => !isTopClassOrNothing(specType(tree.tpe).classSymbol)) + // Only works before erasure. + def isFullySpecialized: Boolean = + !specializedTypeArgs.exists(_.tpe.existsPart(part => (part.typeSymbol.isTypeParam))) + def isFullySpecializedToTopClassesOrNothing: Boolean = + hasSpecializedParams && isFullySpecialized && specializedTypeArgs.forall(tr => isTopClassOrNothing(specType(tr.tpe).classSymbol)) + + // Note: We only care about the specialized arguments for equality; a specialization of Vec[A: Specialized, B] with B = Int and one + // with B = String can be considered to be the same as they use the same specialized trait + // TODO: I don't really like this logic being in Specialization because they are really different + // We should really put that logic in the SpecializedTraitCache because it's at that point that we treat them as the same. + override def equals(obj: Any): Boolean = + obj.isInstanceOf[Specialization] && obj.asInstanceOf[Specialization].traitSymbol == traitSymbol + && specializedTypeArgs.zip(obj.asInstanceOf[Specialization].specializedTypeArgs).forall((a1, a2) => specType(a1.tpe) == specType(a2.tpe)) + + override def hashCode(): Int = + (traitSymbol, specializedTypeArgs.map(tr => specType(tr.tpe))).hashCode() + + override def toString(): String = + s"Specialization(${traitSymbol}, ${typeArguments}, ${span})" +end Specialization + +/* Represents an application methodSymbol[typeArguments](termArgs1)(termArgs2) etc */ +class MethodSpecialization(val methodSymbol: Symbol, val typeArgss: List[List[Tree]])(using Context): + val specializedTypeParams: List[Type] = methodSymbol.paramSymss.flatten.collect(_.info match { case SpecializedEvidence(typeVar) => typeVar }) // Type parameters marked with Specialized + private val paramToArgList = + methodSymbol.paramSymss.filter(l => l.nonEmpty && l.head.is(Flags.TypeParam)).zip(typeArgss).map( + (params, args) => params.map(_.typeRef.asInstanceOf[Type]).zip(args) + ).flatten + + // TODO: Can we share these? General Specialization + Method + Trait + val specializedTypeArgs: List[Tree] = paramToArgList.filter((tParam, tArg) => specializedTypeParams.exists(_ =:= tParam)).map(_._2) // Type arguments provided to parameters that are marked with Specialized at their definition + + val hasSpecializedParams: Boolean = specializedTypeParams.nonEmpty + + def isSpecialized: Boolean = + methodSymbol.isSpecializedMethod && hasSpecializedParams && specializedTypeArgs.exists(tree => !isTopClass(specType(tree.tpe).classSymbol)) + def isFullySpecialized: Boolean = + !specializedTypeArgs.exists(_.tpe.existsPart(part => (part.typeSymbol.isTypeParam))) + def isFullySpecializedToTopClassesOrNothing: Boolean = + methodSymbol.isSpecializedMethod && hasSpecializedParams && isFullySpecialized && specializedTypeArgs.forall(tr => isTopClassOrNothing(specType(tr.tpe).classSymbol)) +end MethodSpecialization + +// TODO: If we can get this in Specialization when we do inheritance that would be great. +object SpecializedEvidence { + def unapply(tpe: Type)(using Context): Option[Type] = tpe match { + case AppliedType(tycon, List(tpeArg)) if (tycon =:= ctx.definitions.SpecializedClass.typeRef && tpeArg.typeSymbol.isTypeParam) => Some(tpeArg) + case _ => None + } +} + +object Specialization: + + def unapply(tpt: Tree)(using Context): Option[Specialization] = tpt match { + case AppliedTypeTree(specializedTrait: Ident, concreteTypeTrees: List[Tree]) => Some(Specialization(specializedTrait.denot.symbol, concreteTypeTrees, tpt.span)) + case t: TypeTree => Specialization.unapply(t.tpe, t.span) + case _ => None + } + + def unapply(typeSpan: (Type, Span))(using Context): Option[Specialization] = typeSpan match { + case (AppliedType(tycon: Type, args: List[Type]), span) => Some(Specialization(tycon.typeSymbol, args.map(TypeTree(_)), span)) + case _ => None + } + + def unapply(tpe: Type)(using Context): Option[Specialization] = tpe match { + case AppliedType(tycon: Type, args: List[Type]) => Some(Specialization(tycon.typeSymbol, args.map(TypeTree(_)), NoSpan)) + case _ => None + } + + def classSpecializedTypeParams(classSym: Symbol)(using Context): List[Type] = classSym.unforcedDecls.implicitDecls.collect(_.info match { case SpecializedEvidence(typeVar) => typeVar }) + def methodSpecializedTypeParams(methodSym: Symbol)(using Context): List[Type] = methodSym.paramSymss.flatten.collect(_.info match { case SpecializedEvidence(typeVar) => typeVar }) + + // TODO: These methods are used in other phases; probably move them to the phase object? + def anonymousClassIsSpecialized(tree: Tree)(using Context) = + tree match { + case TypeDef(anon, Template(_, parentCalls: List[Tree], _, _)) => + parentCalls match { + case _ :+ Apply(Apply(t, ctorArgs), ev) => // extends Object, parents of spec trait, spec trait + val spec = Specialization.unapply(t.tpe.resultType.resultType, t.span) + spec.get.hasSpecializedParams + case _ => false + } + case _ => false + } + + def isSpecializedTrait(sym: Symbol)(using Context) = sym.isClass && sym.isAllOf(InlineTrait) && classSpecializedTypeParams(sym).nonEmpty + def isSpecializedMethod(sym: Symbol)(using Context) = sym.isAllOf(InlineMethod) && methodSpecializedTypeParams(sym).nonEmpty + def traitParamIsSpecialized(traitSym: Symbol, tParam: Symbol)(using Context) = classSpecializedTypeParams(traitSym).exists(tp => tp.typeSymbol eq tParam) +end Specialization + +object MethodSpecialization: + def unapply(tree: Tree)(using Context) = tree match { + case app: Apply => + val methSym = tpd.methPart(app).symbol + if methSym.is(Flags.Method) then + Some(MethodSpecialization(methSym, tpd.typeArgss(app))) + else + None + case _ => None + } +end MethodSpecialization + +class AnonymousSpecializationInstance( + val srcPos: SrcPos, + val symbol: Symbol, + val body: List[Tree], + val parentCalls: List[Tree], + val ctor: Name, + val typeTree: TypeTree +) + +object AnonymousSpecializationInstance: + def unapply(tree: Tree)(using Context) = tree match { + case Block(List(an@TypeDef(anon, tmpl@Template(_, parentCalls: List[Tree], _, _))), + Typed(Apply(Select(New(anon1),ctor), _), t: TypeTree)) if anon1.symbol.isAnonymousClass => + Some(AnonymousSpecializationInstance(an.srcPos, an.symbol, tmpl.body, parentCalls, ctor, t)) + case _ => None + } +end AnonymousSpecializationInstance + +class SpecializedTraitState: + var specializedTraitCache: Option[SpecializedTraitCache] = None +end SpecializedTraitState + + +// Need to somehow make my naming a lot more consistent as well. +// figure out why we generate the T version. +// Try to see if we can do with only types and not trees +// Synthesise Specialized instances so that people can't do stupid stuff like Specialized[Array[T]]. type x = Specialized[Array[Array[Int]]] +// Set the Synthetic flags somewhere +// Cache / only generate once instead of multiple times. +// Ideally standardise on either specialization or specializationMap + +// TODO: Need to try with a bigger project with multiple packages later on to see if we get the behaviour that we are expecting to get in terms of the classes that we generate. + +// TODO: need to test with explicit evidence / our own custom type classes + +// In the case of foo[S](a: Vec[S, Int, Int, Int, Int]) I think we ideally do want this because we should be able to get speed gains by accessing the specialized members + +// TODO: Only specialize if there is some material increase in specialization - I think only if at least one new parameter gets fully specialized +// Maybe it is better to not allow partial specializations -- we can think about that. + +// TODO: Don't synthesize specialized instances for random generic types probably - as Hamza said we want to be able to control the specialization diff --git a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala index 42ffa50d7129..41554b852e34 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala @@ -218,7 +218,8 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase => throw new Exception("Match error in @varargs checks. This should not happen, please open an issue " + tp) /** Add the symbol of a Java varargs forwarder to the scope. - * It retains all the flags of the original method. + * It retains the flags of the original method except `Deferred`, + * since the forwarder's body is synthesized in `transformDefDef`. * * @param original the original method symbol * @param isBridge true if we are generating a "bridge" (synthetic override forwarder) @@ -241,7 +242,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase => // For simplicity we always set the varargs flag, // although it's not strictly necessary for overrides. - val flags = original.flags | JavaVarargs + val flags = (original.flags &~ Deferred) | JavaVarargs // The java-compatible forwarder symbol val forwarder = diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala index ed2a88519ca0..3d148667d9ca 100644 --- a/compiler/src/dotty/tools/dotc/transform/Erasure.scala +++ b/compiler/src/dotty/tools/dotc/transform/Erasure.scala @@ -37,6 +37,7 @@ import core.Mode import util.Property import reporting.* import scala.annotation.tailrec +import dotty.tools.dotc.ast.tpd.* class Erasure extends Phase with DenotTransformer { @@ -702,13 +703,10 @@ object Erasure { assignType(untpd.cpy.Select(tree)(qual, tree.name.primitiveArrayOp), qual) def adaptIfSuper(qual: Tree): Tree = qual match { - case Super(thisQual, untpd.EmptyTypeIdent) => - val SuperType(thisType, supType) = qual.tpe: @unchecked - if (sym.owner.is(Flags.Trait)) - cpy.Super(qual)(thisQual, untpd.Ident(sym.owner.asClass.name)) - .withType(SuperType(thisType, sym.owner.typeRef)) - else - qual.withType(SuperType(thisType, thisType.firstParent.typeConstructor)) + case Super(thisQual, untpd.EmptyTypeIdent) if sym.owner.is(Flags.Trait) => + val SuperType(thisType, _) = qual.tpe: @unchecked + cpy.Super(qual)(thisQual, untpd.Ident(sym.owner.asClass.name)) + .withType(SuperType(thisType, sym.owner.typeRef)) case _ => qual } @@ -743,6 +741,20 @@ object Erasure { adaptIfSuper(qual) match case qual1: Super => select(qual1, sym) + case qual1 if owner.isInlineTrait && + (qual1.tpe.widenDealias.classSymbol ne sym.owner) && + qual1.tpe.widenDealias.classSymbol.derivesFrom(sym.owner) => + + // If A is an inline trait and A.foo was inlined into B, references to b.foo (val b = B()) will still + // point to A.foo until now. We want them to point to B.foo so we get the benefit of specialization. + // We fix that here rather than in a separate phase because + // it needs to happen coordinated with erasure of Specialized traits, so that: + // a) we see the erased A$sp$Int traits and can point at their members + // b) we make the replacement before boxing in case A.foo is typed with T and B.foo specializes this to e.g. Int + // Otherwise we will end up with Int.unbox(A.foo) instead of directly B.foo which won't typecheck. + val specializedInterfaceSym = qual1.tpe.widenDealias.classSymbol.asClass + val newSym = inContext(preErasureCtx) { sym.overridingSymbol(specializedInterfaceSym) } + qual1.select(newSym) case qual1 if !isJvmAccessible(qual1.tpe.typeSymbol) || !qual1.tpe.derivesFrom(sym.owner) => val castTarget = // Avoid inaccessible cast targets, see i8661 @@ -792,6 +804,35 @@ object Erasure { } } + /* Erase anonymous instances of specialized traits to $impl$ classes */ + override def typedBlock(tree: untpd.Block, pt: Type)(using Context): Tree = tree.asInstanceOf[Block] match + case AnonymousSpecializationInstance(anon) => + inContext(preErasureCtx) { + Specialization.unapply(anon.typeTree.tpe, anon.typeTree.span).flatMap(spec => { + anon.parentCalls match { + case (obj :: parentsOfSpecTrait) if (spec.isSpecialized || spec.isFullySpecializedToTopClassesOrNothing) && (obj.symbol.owner == ctx.definitions.ObjectClass) && (parentsOfSpecTrait.forall(x => spec.traitSymbol.asClass.baseClasses.exists(p => p == x.symbol.owner))) => + val app: Tree = parentsOfSpecTrait.find(p => p.symbol.owner == spec.traitSymbol).get + assert(app.isInstanceOf[Apply]) // At the very least we pass the Specialized instance. + val targetImplName = DesugarSpecializedTraits.newImplementationClassName(spec) + val implClass = spec.traitSymbol.enclosingPackageClass.info.decls.lookup(targetImplName) + assert(implClass.exists && implClass.isClass) + val erased = inContext(ctx.withSource(anon.typeTree.source)) { + Typed( + Select(New(ref(implClass)), anon.ctor) + .appliedToTypeTrees(spec.unspecializedTypeArgs) + .appliedToArgss(tpd.allArgss(app).tail.nestedMap(_.changeNonLocalOwners(anon.symbol.owner))) // Skip the type params which are not needed + , anon.typeTree) + }.withSpan(anon.typeTree.span) + Some(erased) + case _ => None + }}) + } match { + case Some(erased) => typedTyped(erased, anon.typeTree.tpe) + case None => super.typedBlock(tree, pt) + } + case _ => super.typedBlock(tree, pt) + + override def typedBind(tree: untpd.Bind, pt: Type)(using Context): Bind = atPhase(erasurePhase): checkBind(promote(tree)) @@ -804,8 +845,9 @@ object Erasure { val Apply(fun, args) = tree val origFun = fun.asInstanceOf[tpd.Tree] val origFunType = origFun.tpe.widen(using preErasureCtx) + val insideBridge = ctx.owner.ownersIterator.exists(_.is(Flags.Bridge)) val ownArgs = origFunType match - case mt: MethodType if mt.hasErasedParams => + case mt: MethodType if mt.hasErasedParams && !insideBridge => args.lazyZip(mt.paramErasureStatuses).flatMap: (arg, isErased) => if isErased then checkPureErased(arg, isArgument = true, @@ -1017,7 +1059,41 @@ object Erasure { EmptyTree override def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(using Context): Tree = - val typedTree@TypeDef(name, impl @ Template(constr, _, self, _)) = super.typedClassDef(cdef, cls): @unchecked + // drop Foo[Int] leading to duplicate Foo$sp$Int + val TypeDef(_, implInit: Template) = cdef: @unchecked + + // Match corresponding class info erasure in TypeErasure::apply ClassInfo case + val cdef1 = + val oldParents = implInit.asInstanceOf[Template].parents + val superCtxNoSpec = disallowSpecializedCtx(using ctx.superCallContext) + val newParents = + if cls.isSpecializedTraitInterface then // {source: Bar, Foo both specialized traits} inline trait Bar$sp$Int extends Object, Bar, Foo$sp$Int + val (obj :: originalTrait :: inheritedParents) = oldParents : @unchecked + obj :: typedType(originalTrait)(using superCtxNoSpec) :: inheritedParents + else if cls.isSpecializedTraitImplementationClass && !cls.isRawSpecializedTraitImplementationClass then // {source: Bar, Foo both specialized traits} class Bar$impl$Int extends Object, Bar$sp$Int, Bar(10) + val (objectParent :: traitSpParent :: originalTraitSpecializedParent :: Nil) = oldParents : @unchecked + val newParent = originalTraitSpecializedParent match { + case _: untpd.Apply => typedExpr(originalTraitSpecializedParent)(using superCtxNoSpec) + case _ => typedType(originalTraitSpecializedParent)(using superCtxNoSpec) + } + objectParent :: traitSpParent :: newParent :: Nil + else + inContext(preErasureCtx) { + val extraSpTraits = oldParents.filter(p => p.symbol.isPrimaryConstructor && p.symbol.owner.isSpecializedTrait).map(p => p.tpe.resultType) + + // {source: class Bar extends Foo[Int](10) with Baz[Int](10)} + // class Bar extends Object, Foo(10), Bar(10), Foo$sp$Int, Bar$sp$Int + oldParents.map { tp => + if tp.symbol.isPrimaryConstructor && tp.symbol.owner.isSpecializedTrait then + typedExpr(tp)(using superCtxNoSpec) + else + tp + } ::: extraSpTraits.map(sym => TypeTree(sym)) + } + + cpy.TypeDef(cdef.asInstanceOf[TypeDef])(rhs = cpy.Template(implInit.asInstanceOf[Template])(parents = newParents)) + + val typedTree@TypeDef(name, impl @ Template(constr, _, self, _)) = super.typedClassDef(cdef1, cls): @unchecked // In the case where a trait extends a class, we need to strip any non trait class from the signature // and accept the first one (see tests/run/mixins.scala) val newTraits = impl.parents.tail.filterConserve: tree => diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala index 81cc73c26ed6..0e0d211faf35 100644 --- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala +++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala @@ -22,6 +22,7 @@ import inlines.Inlines.inInlineMethod import util.Property import inlines.Inlines import reporting.InlinedAnonClassWarning +import dotty.tools.dotc.transform.Specialization.anonymousClassIsSpecialized object FirstTransform { val name: String = "firstTransform" @@ -210,7 +211,9 @@ class FirstTransform extends MiniPhase with SymTransformer { thisPhase => } override def transformTypeDef(tree: TypeDef)(using Context): Tree = - if tree.symbol.isAnonymousClass && Inlines.inInlineMethod then + if tree.symbol.isAnonymousClass && Inlines.inInlineMethod && + !anonymousClassIsSpecialized(tree) + then report.warning(InlinedAnonClassWarning(), tree.symbol.sourcePos) tree diff --git a/compiler/src/dotty/tools/dotc/transform/Getters.scala b/compiler/src/dotty/tools/dotc/transform/Getters.scala index 11adf4da83d5..c63d1384a9e7 100644 --- a/compiler/src/dotty/tools/dotc/transform/Getters.scala +++ b/compiler/src/dotty/tools/dotc/transform/Getters.scala @@ -62,6 +62,8 @@ class Getters extends MiniPhase with SymTransformer { thisPhase => override def description: String = Getters.description + override def changesMembers: Boolean = true // TODO: Is this ok? I mean it does call enteredAfter via ensureSetter and that does change members. + override def transformSym(d: SymDenotation)(using Context): SymDenotation = { def noGetterNeeded = d.isOneOf(NoGetterNeededFlags) || diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala index bb131ea0db0e..227d37e361a2 100644 --- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala +++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala @@ -81,7 +81,7 @@ class Inlining extends MacroTransform, IdentityDenotTransformer { new TreeTraverser { def traverse(tree: Tree)(using Context): Unit = tree match - case tree: RefTree if !Inlines.inInlineMethod && StagingLevel.level == 0 => + case tree: RefTree if !Inlines.inInlineContext && StagingLevel.level == 0 => assert(!tree.symbol.isInlineMethod, tree.show) case _ => traverseChildren(tree) diff --git a/compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala b/compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala index 94a7f4517ea2..fd859158b566 100644 --- a/compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala +++ b/compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala @@ -4,6 +4,7 @@ package transform import java.io.File import java.nio.file.{Files, Path} +import ast.tpd import ast.tpd.* import collection.mutable import core.Comments.Comment @@ -18,14 +19,85 @@ import core.StdNames.nme import core.Types.* import core.Decorators.* import coverage.* -import typer.LiftCoverage -import util.{SourcePosition, SourceFile} +import typer.LiftImpure +import util.{Property, SourcePosition, SourceFile} import util.Spans.Span import localopt.StringInterpolatorOpt import inlines.Inlines import scala.util.matching.Regex import java.util.regex.Pattern +/** Lift impure + lift the prefixes for coverage instrumentation. */ +object LiftCoverage extends LiftImpure: + + // Property indicating whether we're currently lifting the arguments of an application + private val LiftingArgs = new Property.Key[Boolean] + val CoverageLiftedTemp = Property.StickyKey[Unit]() + + private inline def liftingArgs(using Context): Boolean = + ctx.property(LiftingArgs).contains(true) + + private def liftingArgsContext(using Context): Context = + ctx.fresh.setProperty(LiftingArgs, true) + + /** Variant of `noLift` for the arguments of applications. + * To produce the right coverage information (especially in case of exceptions), we must lift: + * - all the applications, except the erased ones + */ + private def noLiftArg(arg: tpd.Tree)(using Context): Boolean = + arg match + case arg if isUnsafeAssumeSeparate(arg) => true + case a: tpd.Apply => a.symbol.is(Erased) // don't lift erased applications, but lift all others + case tpd.Block((meth: tpd.DefDef) :: Nil, closure: tpd.Closure) + if meth.symbol == closure.meth.symbol && closure.env.forall(noLiftArg) => true + case tpd.Block(stats, expr) => stats.forall(noLiftArg) && noLiftArg(expr) + case tpd.Inlined(_, bindings, expr) => noLiftArg(expr) + case tpd.Typed(expr, _) => noLiftArg(expr) + case _ => super.noLift(arg) + + def isUnsafeAssumeSeparate(tree: tpd.Tree)(using Context): Boolean = tree match + case tree: tpd.Apply => + tree.symbol == defn.Caps_unsafeAssumeSeparate + || isUnsafeAssumeSeparate(tree.fun) + case tpd.Select(qual, _) => isUnsafeAssumeSeparate(qual) + case tpd.Block(_, expr) => isUnsafeAssumeSeparate(expr) + case tpd.Inlined(_, _, expr) => isUnsafeAssumeSeparate(expr) + case tpd.Typed(expr, _) => isUnsafeAssumeSeparate(expr) + case _ => false + + def isCoverageLiftedTemp(sym: Symbol)(using Context): Boolean = + sym.defTree.hasAttachment(CoverageLiftedTemp) + + override protected def onLiftedDef(tree: tpd.Tree)(using Context): Unit = + tree.putAttachment(CoverageLiftedTemp, ()) + + override def noLift(expr: tpd.Tree)(using Context) = + if liftingArgs then noLiftArg(expr) + else isUnsafeAssumeSeparate(expr) || super.noLift(expr) + + /** Preserve precision for lifted coverage temps when widening would break later checks: + * compile-time constants and stable singleton types need their singleton precision, + * and capture-converted types need their local TypeBox#CAP references. + */ + override protected def liftedExprType(expr: tpd.Tree)(using Context): Type = + val dealiased = expr.tpe.dealias + val deskolemized = dealiased.deskolemized + val valueType = dealiased match + case ref: TermRef if ref.prefix.exists && ref.underlying.isInstanceOf[ExprType] => + ref.prefix.memberInfo(ref.symbol).widenExpr + case _ => + dealiased + valueType.widenTermRefExpr.normalized.simplified match + case _: ConstantType => deskolemized + case _ if dealiased.isInstanceOf[SingletonType] && dealiased.isStable => dealiased + case _ if valueType.existsPart(_.typeSymbol == defn.TypeBox_CAP) => valueType + case _ => super.liftedExprType(expr) + + def liftForCoverage(defs: mutable.ListBuffer[tpd.Tree], tree: tpd.Apply)(using Context) = + val liftedFun = liftApp(defs, tree.fun) + val liftedArgs = liftArgs(defs, tree.fun.tpe, tree.args)(using liftingArgsContext) + tpd.cpy.Apply(tree)(liftedFun, liftedArgs) + /** Implements code coverage by inserting calls to scala.runtime.coverage.Invoker * ("instruments" the source code). * The result can then be consumed by the Scoverage tool. @@ -261,7 +333,10 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer: * @return instrumentation result, with the preparation statement, coverage call and tree separated */ private def tryInstrument(tree: Apply)(using Context): InstrumentedParts = - if canInstrumentApply(tree) then + if LiftCoverage.isUnsafeAssumeSeparate(tree) then + val transformed = cpy.Apply(tree)(transformInnerApply(tree.fun), transformApplyArgs(tree.args, erasedParamStatuses(tree))) + InstrumentedParts.notCovered(transformed) + else if canInstrumentApply(tree) then // Create a call to Invoker.invoked(coverageDirectory, newStatementId) val coverageCall = createInvokeCall(tree, tree.sourcePos) @@ -301,7 +376,12 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer: private def tryInstrument(tree: Select)(using Context): InstrumentedParts = val sym = tree.symbol - val qual = transform(tree.qualifier).ensureConforms(tree.qualifier.tpe) + val transformedQual = transform(tree.qualifier) + val qual = + if tree.qualifier.symbol.exists && canInstrumentParameterless(tree.qualifier.symbol) then + transformedQual + else + transformedQual.ensureConforms(tree.qualifier.tpe) val transformed = cpy.Select(tree)(qual, tree.name) if canInstrumentParameterless(sym) then // call to a parameterless method @@ -324,6 +404,13 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer: * If the tree is empty, return itself and don't instrument. */ private def transformBranch(tree: Tree)(using Context): Tree = + transformBranchWithInherited(tree, inheritedProbes = Nil) + + /** Like [[transformBranch]], but runs `inheritedProbes` before the branch probe + * and the transformed body. Used for sub-cases: ancestor case-arm probes are + * emitted at the same successful leaves; see [[instrumentSubMatchWithProbes]]. + */ + private def transformBranchWithInherited(tree: Tree, inheritedProbes: List[Apply])(using Context): Tree = if tree.isEmpty then // - If t.isEmpty then `transform(t) == t` always hold, // so we can avoid calling transform in that case. @@ -331,7 +418,14 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer: else val transformed = transform(tree) val coverageCall = createInvokeCall(tree, tree.sourcePos, branch = true) - InstrumentedParts.singleExprTree(coverageCall, transformed) + val allProbes = inheritedProbes :+ coverageCall + allProbes match + case single :: Nil => InstrumentedParts.singleExprTree(single, transformed) + case multiple => InstrumentCoverage.blockWithExprSpan(multiple, transformed) + + private def transformCondition(tree: Tree)(using Context): Tree = tree match + case Literal(Constant(_: Boolean)) => tree + case _ => transform(tree) override def transform(tree: Tree)(using Context): Tree = inContext(transformCtx(tree)) { // necessary to position inlined code properly @@ -356,7 +450,7 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer: // branches case tree: If => cpy.If(tree)( - cond = transform(tree.cond), + cond = transformCondition(tree.cond), thenp = transformBranch(tree.thenp), elsep = transformBranch(tree.elsep) ) @@ -390,7 +484,7 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer: // This is especially important for trees like (expr[T])(args), // for which the wrong transformation crashes the compiler. // See tests/coverage/pos/PolymorphicExtensions.scala - Block( + InstrumentCoverage.blockWithExprSpan( pre :+ coverageCall, cpy.TypeApply(tree)(expr, args) ) @@ -487,7 +581,9 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer: tree.rhs else if sym.isClassConstructor then instrumentSecondaryCtor(tree) - else if !sym.isOneOf(Accessor | Artifact | Synthetic) then + else if !sym.isOneOf(Accessor | Artifact | Synthetic) + && !LiftCoverage.isUnsafeAssumeSeparate(tree.rhs) + then // If the body can be instrumented, do it (i.e. insert a "coverage call" at the beginning) // This is useful because methods can be stored and called later, or called by reflection, // and if the rhs is too simple to be instrumented (like `def f = this`), @@ -498,20 +594,54 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer: cpy.DefDef(tree)(tree.name, transformedParamss, tree.tpt, transformedRhs) + /** Span for coverage UI: end at the guard if present, else the pattern. */ + private def caseDefUserEndPos(cdef: CaseDef)(using Context): SourcePosition = + val pat = cdef.pat + val guard = cdef.guard + val friendlyEnd = if guard.span.exists then guard.span.end else pat.span.end + cdef.sourcePos(using ctx).withSpan(cdef.span.withEnd(friendlyEnd)) + + /** Re-instrument a [[SubMatch]] while keeping it a direct sub-match tree. + * Downstream, [[dotty.tools.dotc.transform.PatternMatcher]] matches on + * `CaseDef.body: SubMatch` and [[CaseDef.maybePartial]] checks `isInstanceOf[SubMatch]`; + * wrapping the body in a [[Block]] (as in [[transformBranch]]) would break that. + * + * Branch coverage for each case arm is recorded by `inheritedProbes` plus, for each + * sub-case, a probe for that arm; we attach those probes to successful sub-match leaves + * so they do not run when a partial sub-match falls through to the next outer case. + */ + private def instrumentSubMatchWithProbes(sm: SubMatch, inheritedProbes: List[Apply])(using Context): SubMatch = + val newSelector = transform(sm.selector) + val newCases = sm.cases.map(cdef => transformSubMatchCaseDef(cdef, inheritedProbes)) + cpy.Match(sm)(newSelector, newCases).asInstanceOf[SubMatch] + + private def transformSubMatchCaseDef(cdef: CaseDef, inheritedProbes: List[Apply])(using Context): CaseDef = + val pos = caseDefUserEndPos(cdef) + val transformedGuard = transform(cdef.guard) + val newBody: Tree = cdef.body match + case sm: SubMatch => + val p = createInvokeCall(sm, pos, branch = true) + instrumentSubMatchWithProbes(sm, p :: inheritedProbes) + case b => + transformBranchWithInherited(b, inheritedProbes) + cpy.CaseDef(cdef)(cdef.pat, transformedGuard, newBody) + /** Transforms a `case ...` and instruments the parts that can be. */ private def transformCaseDef(tree: CaseDef)(using Context): CaseDef = val pat = tree.pat val guard = tree.guard - - // compute a span that makes sense for the user that will read the coverage results - val friendlyEnd = if guard.span.exists then guard.span.end else pat.span.end - val pos = tree.sourcePos.withSpan(tree.span.withEnd(friendlyEnd)) // user-friendly span + val pos = caseDefUserEndPos(tree) // recursively transform the guard, but keep the pat val transformedGuard = transform(guard) - // ensure that the body is always instrumented as a branch - val instrumentedBody = transformBranch(tree.body) + // Sub-case bodies are [[SubMatch]]: keep that shape; see [[instrumentSubMatchWithProbes]]. + val instrumentedBody: Tree = tree.body match + case sm: SubMatch => + val p = createInvokeCall(sm, pos, branch = true) + instrumentSubMatchWithProbes(sm, p :: Nil) + case b => + transformBranch(b) cpy.CaseDef(tree)(pat, transformedGuard, instrumentedBody) @@ -635,14 +765,16 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer: /** Check if an Apply can be instrumented. Prevents this phase from generating incorrect code. */ private def canInstrumentApply(tree: Apply)(using Context): Boolean = - def isSecondaryCtorDelegateCall: Boolean = tree.fun match + def isSecondaryCtorDelegateCall(fun: Tree): Boolean = fun match case Select(This(_), nme.CONSTRUCTOR) => true + case Apply(fn, _) => isSecondaryCtorDelegateCall(fn) + case TypeApply(fn, _) => isSecondaryCtorDelegateCall(fn) case _ => false val sym = tree.symbol !sym.isOneOf(ExcludeMethodFlags) && !isCompilerIntrinsicMethod(sym) - && !(sym.isClassConstructor && isSecondaryCtorDelegateCall) + && !(sym.isClassConstructor && isSecondaryCtorDelegateCall(tree.fun)) && !sym.name.is(DefaultGetterName) // https://github.com/scala/scala3/issues/20255 && (tree.typeOpt match case AppliedType(tycon: NamedType, _) => @@ -706,6 +838,33 @@ object InstrumentCoverage: val scoverageLocalOn: Regex = """^\s*//\s*\$COVERAGE-ON\$""".r val scoverageLocalOff: Regex = """^\s*//\s*\$COVERAGE-OFF\$""".r + /** Coverage probes are synthetic bookkeeping calls that should be transparent to + * later warning logic and should not steal source positions from the user tree + * they wrap. + */ + def isCoverageProbe(tree: Tree)(using Context): Boolean = tree match + case Apply(fun, Literal(Constant(_: Int)) :: Literal(Constant(_: String)) :: Nil) => + fun.symbol == defn.InvokedMethodRef.symbol + case _ => + false + + /** Remove leading synthetic coverage wrappers to recover the user-written tree. */ + def stripLeadingCoverage(tree: Tree)(using Context): Tree = tree match + case Typed(expr, _) => + stripLeadingCoverage(expr) + case Inlined(_, Nil, expr) => + stripLeadingCoverage(expr) + case Block(stats, expr) if stats.forall(isCoverageProbe) => + stripLeadingCoverage(expr) + case _ => + tree + + /** Keep wrapper blocks pointed at the wrapped expression span so later warnings + * still highlight user code instead of synthetic `Invoker.invoked` scaffolding. + */ + def blockWithExprSpan(stats: List[Tree], expr: Tree)(using Context): Tree = + Block(stats, expr).withSpan(expr.span) + /** * An instrumented Tree, in 3 parts. * @param pre preparation code, e.g. lifted arguments. May be empty. @@ -718,8 +877,8 @@ object InstrumentCoverage: /** Turns this into an actual Tree. */ def toTree(using Context): Tree = if invokeCall.isEmpty then expr - else if pre.isEmpty then Block(invokeCall :: Nil, expr) - else Block(pre :+ invokeCall, expr) + else if pre.isEmpty then blockWithExprSpan(invokeCall :: Nil, expr) + else blockWithExprSpan(pre :+ invokeCall, expr) object InstrumentedParts: def notCovered(expr: Tree) = InstrumentedParts(Nil, EmptyTree, expr) @@ -727,4 +886,4 @@ object InstrumentCoverage: /** Shortcut for `singleExpr(call, expr).toTree` */ def singleExprTree(invokeCall: Apply, expr: Tree)(using Context): Tree = - Block(invokeCall :: Nil, expr) + blockWithExprSpan(invokeCall :: Nil, expr) diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala index db3157f6130d..f7302d65ec58 100644 --- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala +++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala @@ -215,6 +215,25 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer { ref(field).becomes(nullLiteral) } + /** + * Creates a ValDef used as the underlying var, + * and also returns the term name as it's later needed as a TermName (and not just any symbol name) + */ + private def mkContainerTree(x: ValOrDefDef, tpe: Type, isVolatile: Boolean)(using Context): ValDef = + val claz = x.symbol.owner.asClass + //val tpe = if isVolatile then defn.ObjectType else x.tpe.widen.resultType.widen + val containerName = LazyLocalName.fresh(x.name.asTermName) + val containerSymbol = newSymbol(claz, containerName, x.symbol.flags &~ containerFlagsMask | containerFlags | Private, tpe, coord = x.symbol.coord).enteredAfter(this) + // Keep field annotations like @transient, see scala/scala3#23487 + for a <- x.symbol.annotations do + if a.hasOneOfMetaAnnotation(Set(defn.FieldMetaAnnot)) then + containerSymbol.addAnnotation(a) + if isVolatile then + containerSymbol.addAnnotation(Annotation(defn.VolatileAnnot, containerSymbol.span)) + // for the thread-safe implementation, the generated symbol must not be static or the CAS operations won't work, see scala/scala3#16800 + containerSymbol.removeAnnotation(defn.ScalaStaticAnnot) + ValDef(containerSymbol, defaultValue(tpe)) + /** Create thread-unsafe lazy accessor equivalent to such code * ``` * def methodSymbol() = { @@ -262,24 +281,15 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer { } def transformMemberDefThreadUnsafe(x: ValOrDefDef)(using Context): Thicket = { - val claz = x.symbol.owner.asClass - val tpe = x.tpe.widen.resultType.widen - assert(!x.symbol.isMutableVarOrAccessor) - val containerName = LazyLocalName.fresh(x.name.asTermName) - val containerSymbol = newSymbol(claz, containerName, - x.symbol.flags &~ containerFlagsMask | containerFlags | Private, - tpe, coord = x.symbol.coord - ).enteredAfter(this) - - val containerTree = ValDef(containerSymbol, defaultValue(tpe)) - if (x.tpe.isNotNull && tpe <:< defn.ObjectType) + val containerTree = mkContainerTree(x, x.tpe.widen.resultType.widen, isVolatile = false) + if (x.tpe.isNotNull && containerTree.rhs.tpe <:< defn.ObjectType) // can use 'null' value instead of flag - Thicket(containerTree, mkDefThreadUnsafeNonNullable(x.symbol, containerSymbol, x.rhs)) + Thicket(containerTree, mkDefThreadUnsafeNonNullable(x.symbol, containerTree.symbol, x.rhs)) else { val flagName = LazyBitMapName.fresh(x.name.asTermName) val flagSymbol = newSymbol(x.symbol.owner, flagName, containerFlags | Private, defn.BooleanType).enteredAfter(this) val flag = ValDef(flagSymbol, Literal(Constant(false))) - Thicket(containerTree, flag, mkThreadUnsafeDef(x.symbol, flagSymbol, containerSymbol, x.rhs)) + Thicket(containerTree, flag, mkThreadUnsafeDef(x.symbol, flagSymbol, containerTree.symbol, x.rhs)) } } @@ -468,20 +478,13 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer { } def transformMemberDefThreadSafeNew(x: ValOrDefDef)(using Context): Thicket = { - import dotty.tools.dotc.core.Types.* import dotty.tools.dotc.core.Flags.* val claz = x.symbol.owner.asClass val thizClass = Literal(Constant(claz.info)) - val containerName = LazyLocalName.fresh(x.name.asTermName) - val containerSymbol = newSymbol(claz, containerName, x.symbol.flags &~ containerFlagsMask | containerFlags | Private, defn.ObjectType, coord = x.symbol.coord).enteredAfter(this) - containerSymbol.addAnnotation(Annotation(defn.VolatileAnnot, containerSymbol.span)) // private @volatile var _x: AnyRef - containerSymbol.addAnnotations(x.symbol.annotations) // pass annotations from original definition - containerSymbol.removeAnnotation(defn.ScalaStaticAnnot) - val getOffset = - Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.getOffsetStatic) - val containerTree = ValDef(containerSymbol, nullLiteral) + val containerTree = mkContainerTree(x, defn.ObjectType, isVolatile = true) + val containerName = containerTree.symbol.name.asTermName // create a VarHandle for this lazy val val varHandleSymbol: TermSymbol = newSymbol(claz, LazyVarHandleName(containerName), Private | Synthetic, defn.VarHandleClass.typeRef).enteredAfter(this) @@ -499,7 +502,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer { val swapOver = This(claz) - val (accessorDef, initMethodDef) = mkThreadSafeDef(x, claz, containerSymbol, varHandle, swapOver) + val (accessorDef, initMethodDef) = mkThreadSafeDef(x, claz, containerTree.symbol, varHandle, swapOver) Thicket(containerTree, accessorDef, initMethodDef) } diff --git a/compiler/src/dotty/tools/dotc/transform/MacroAnnotations.scala b/compiler/src/dotty/tools/dotc/transform/MacroAnnotations.scala index fd901032de4b..c12cb5e3ce8a 100644 --- a/compiler/src/dotty/tools/dotc/transform/MacroAnnotations.scala +++ b/compiler/src/dotty/tools/dotc/transform/MacroAnnotations.scala @@ -1,8 +1,6 @@ package dotty.tools.dotc package transform -import scala.language.unsafeNulls - import ast.tpd import ast.Trees.* import config.Printers.macroAnnot as debug @@ -15,9 +13,8 @@ import core.MacroClassLoader import core.Symbols.* import core.Types.* import quoted.* -import util.SrcPos -import scala.quoted.runtime.impl.{QuotesImpl, SpliceScope} +import scala.quoted.runtime.impl.{QuotesImpl, SpliceScope} import scala.quoted.Quotes import scala.util.control.NonFatal @@ -135,6 +132,8 @@ object MacroAnnotations: (List(tree), companion) case Interpreter.MissingClassValidInCurrentRun(sym, origin) => Interpreter.suspendOnMissing(sym, origin, annot.tree) + // We're dealing with user-thrown things here, so we must use NonFatal to catch anything realistic, + // including `Error`s like `NotImplementedError` case NonFatal(ex) => val stack0 = ex.getStackTrace.takeWhile(_.getClassName != this.getClass().getName()) val stack = stack0.take(1 + stack0.lastIndexWhere(_.getMethodName == "transform")) diff --git a/compiler/src/dotty/tools/dotc/transform/Mixin.scala b/compiler/src/dotty/tools/dotc/transform/Mixin.scala index 401246383864..05c9a910018b 100644 --- a/compiler/src/dotty/tools/dotc/transform/Mixin.scala +++ b/compiler/src/dotty/tools/dotc/transform/Mixin.scala @@ -6,7 +6,6 @@ import core.* import MegaPhase.* import Contexts.* import Flags.* - import Symbols.* import SymDenotations.* import Types.* @@ -18,7 +17,6 @@ import NameKinds.* import NameOps.* import Phases.erasurePhase import ast.Trees.* - import dotty.tools.dotc.transform.sjs.JSSymUtils.isJSType object Mixin { @@ -96,7 +94,7 @@ object Mixin { * def x_=(y: T) = () * * 4.5 (done in `mixinForwarders`) For every method - * ` def f[Ts](ps1)...(psN): U` in M` that needs to be disambiguated: + * ` def f[Ts](ps1)...(psN): U` in M that needs to be disambiguated: * * def f[Ts](ps1)...(psN): U = super[M].f[Ts](ps1)...(psN) * @@ -142,6 +140,24 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase => override def transformSym(sym: SymDenotation)(using Context): SymDenotation = def ownerIsTrait: Boolean = was(sym.owner, Trait, butNot = JavaDefined) + // // See: tests/run/inline-trait-param-shadows-parent.scala and tests/run/inline-trait-param-shadows-parent-indirect.scala + // // We need this even though we also have "if mixin.isInlineTrait then return Nil" because getters can come + // // from traits that inherit inline traits as well as from inline traits themselves. + // // TODO: Do we not only want to do this if we get the symbol from somewhere else in the child trait as well? + // // i.e. need to know that the trait is mixed in either directly or indirectly as another parent as well. + // // Maybe just say that ordinary traits cannot inherit from inline traits? That would probably fix it. + // def isFromInlineTraitInlining(getter: Symbol): Boolean = + // val y = mixin.parentSyms + + // val x = mixin.parentSyms.map( + // parentSym => parentSym.info.decls//.exists(d => d.name == getter.name || getter.name == d.name.expandedName(parentSym)) + // ) + // mixin.parentSyms.exists( + // parentSym => parentSym.isInlineTrait && parentSym.info.decls.exists(d => { + // d.name == getter.name) + // ) + + if (sym.is(Accessor, butNot = Deferred) && ownerIsTrait) { val sym1 = if (sym.is(Lazy) || sym.symbol.isConstExprFinalVal) sym @@ -166,6 +182,8 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase => val setter = makeTraitSetter(decl.asTerm) setter.validFor = thisPhase.validFor // validity of setter = next phase up to next transformer afterwards decls1.enter(setter) + // Re-create the setter from the unerased getter so we can have its unerased form for generic signatures + mixinGenericInfos(setter) = atPhase(erasurePhase) { makeTraitSetter(decl.asTerm).info } modified = true if modified then sym.copySymDenotation( @@ -186,6 +204,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase => sym.isGetter && !wasOneOf(sym, DeferredOrLazy | ParamAccessor) && atPhase(thisPhase) { !sym.setter.exists } && !sym.isConstExprFinalVal + && !sym.owner.isInlineTrait private def makeTraitSetter(getter: TermSymbol)(using Context): Symbol = getter.copy( @@ -271,19 +290,36 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase => cls.srcPos) EmptyTree + // See: tests/run/inline-trait-param-shadows-parent.scala and tests/run/inline-trait-param-shadows-parent-indirect.scala + // We need this even though we also have "if mixin.isInlineTrait then return Nil" because getters can come + // from traits that inherit inline traits as well as from inline traits themselves. + // TODO: Do we not only want to do this if we get the symbol from somewhere else in the child trait as well? + // i.e. need to know that the trait is mixed in either directly or indirectly as another parent as well. + // Maybe just say that ordinary traits cannot inherit from inline traits? That would probably fix it. + def isFromInlineTraitInlining(getter: Symbol): Boolean = + val y = mixin.parentSyms + + val x = mixin.parentSyms.map( + parentSym => parentSym.info.decls//.exists(d => d.name == getter.name || getter.name == d.name.expandedName(parentSym)) + ) + mixin.parentSyms.exists( + parentSym => parentSym.isInlineTrait && parentSym.info.decls.exists(d => d.name == getter.name) + ) + for getter <- mixin.info.decls.toList if getter.isGetter && !wasOneOf(getter, Deferred) && !getter.isConstExprFinalVal + && !isFromInlineTraitInlining(getter) yield if (isInImplementingClass(getter) || getter.name.is(ExpandedName)) { val rhs = if (wasOneOf(getter, ParamAccessor)) nextArgument() - else if (getter.is(Lazy, butNot = Module)) + else if (!mixin.isInlineTrait && getter.is(Lazy, butNot = Module)) transformFollowing(superRef(getter).appliedToNone) - else if (getter.is(Module)) + else if (!mixin.isInlineTrait && getter.is(Module)) if ctx.settings.scalajs.value && getter.moduleClass.isJSType then if getter.is(Scala2x) then report.error( @@ -295,24 +331,36 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase => New(getter.info.resultType, List(This(cls))) else Underscore(getter.info.resultType) - // transformFollowing call is needed to make memoize & lazy vals run - val forwarder = mkForwarderSym(getter.asTerm) - val erased = atPhase(erasurePhase) { cls.thisType.memberInfo(getter) } - mixinGenericInfos(forwarder) = erased - transformFollowing(DefDef(forwarder, rhs)) + + if (!mixin.isInlineTrait) then + // transformFollowing call is needed to make memoize & lazy vals run + val forwarder = mkForwarderSym(getter.asTerm) + // Store the unerased form for generic signature use later, + // but only if it's not private (which we must check at erasure time, as here we've removed that flag already), + // since otherwise it might refer to private classes + if atPhase(erasurePhase) { !getter.is(Private) } then + mixinGenericInfos(forwarder) = atPhase(erasurePhase) { cls.thisType.memberInfo(getter) } + transformFollowing(DefDef(forwarder, rhs)) + else + EmptyTree + } else if wasOneOf(getter, ParamAccessor) then - // mixin parameter field is defined by an override; evaluate the argument and throw it away - nextArgument() + if (mixin.isInlineTrait) then {nextArgument(); EmptyTree} else nextArgument() else EmptyTree } def setters(mixin: ClassSymbol): List[Tree] = val mixinSetters = mixin.info.decls.filter { sym => - sym.isSetter && (!wasOneOf(sym, Deferred) || sym.name.is(TraitSetterName)) + sym.isSetter && (!wasOneOf(sym, Deferred) || sym.name.is(TraitSetterName)) && !sym.owner.isInlineTrait } - for (setter <- mixinSetters) - yield transformFollowing(DefDef(mkForwarderSym(setter.asTerm), unitLiteral.withSpan(cls.span))) + mixinSetters.map(setter => { + val copied = transformFollowing(DefDef(mkForwarderSym(setter.asTerm), unitLiteral.withSpan(cls.span))) + mixinGenericInfos.get(setter) match + case Some(gi) => mixinGenericInfos(copied.symbol) = gi + case None => () + copied + }) def mixinForwarders(mixin: ClassSymbol): List[Tree] = for meth <- mixin.info.decls.filter(d => needsMixinForwarder(mixin, d)) @@ -333,7 +381,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase => // not give the same erased type. If it doesn't, we'll just give a completely // incorrect Java signature. (This could be improved by generating dedicated // bridges, but we don't go that far; scalac doesn't either.) - if TypeErasure.transformInfo(target, infoBeforeErasure) =:= sym.info then + if ElimErasedValueType.elimEVT(TypeErasure.transformInfo(target, infoBeforeErasure)) =:= sym.info then mixinGenericInfos(sym) = infoBeforeErasure sym diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala index 7f9e0cdca0bf..481b3651793c 100644 --- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala +++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala @@ -1118,7 +1118,7 @@ object PatternMatcher { def typesInCases(cdefs: List[CaseDef]): List[Type] = cdefs.flatMap(cdef => typesInPattern(cdef.pat)) def numTypes(cdefs: List[CaseDef]): Int = - typesInCases(cdefs).toSet.size: Int // without the type ascription, testPickling fails because of #2840. + typesInCases(cdefs).toSet.size val numTypesInOriginal = numTypes(original.cases) if numTypesInOriginal >= caseThreshold && numTypes(resultCases) < numTypesInOriginal then patmatch.println(i"switch warning for ${ctx.compilationUnit}") diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala index 1034dbfba940..331a4c77a96b 100644 --- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala +++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala @@ -80,9 +80,9 @@ class PickleQuotes extends MacroTransform { override def checkPostCondition(tree: Tree)(using Context): Unit = tree match case tree: Quote => - assert(Inlines.inInlineMethod) + assert(Inlines.inInlineContext) case tree: Splice => - assert(Inlines.inInlineMethod) + assert(Inlines.inInlineContext) case _ => override protected def run(using Context): Unit = diff --git a/compiler/src/dotty/tools/dotc/transform/Pickler.scala b/compiler/src/dotty/tools/dotc/transform/Pickler.scala index 3045aa2b0fe3..964d8eaeab3b 100644 --- a/compiler/src/dotty/tools/dotc/transform/Pickler.scala +++ b/compiler/src/dotty/tools/dotc/transform/Pickler.scala @@ -30,7 +30,6 @@ import dotty.tools.dotc.sbt.interfaces.IncrementalCallback import dotty.tools.dotc.sbt.asyncZincPhasesCompleted import dotty.tools.dotc.util.chaining.* import scala.concurrent.ExecutionContext -import scala.util.control.NonFatal import java.util.concurrent.atomic.AtomicBoolean import java.nio.file.Files @@ -104,8 +103,8 @@ object Pickler { case jar: JarArchive => jar.close() case _ => catch - case NonFatal(t) => - ctx.reporter.error(em"Error closing early output: ${t}") + case ex: Exception => + ctx.reporter.error(em"Error closing early output: $ex") asyncTastyWritten.trySuccess: Some( @@ -162,11 +161,11 @@ object Pickler { if !async.cancelled then val _ = writer.writeTasty(internalName, pickled) catch - case NonFatal(t) => ctx.reporter.exception(em"writing TASTy to early output", t) + case ex: Exception => ctx.reporter.exception(em"writing TASTy to early output", ex) finally writer.close() catch - case NonFatal(t) => ctx.reporter.exception(em"closing early output writer", t) + case ex: Exception => ctx.reporter.exception(em"closing early output writer", ex) finally async.signalAsyncTastyWritten() } @@ -306,7 +305,7 @@ class Pickler extends Phase { treePkl.pickle(tree :: Nil) true catch - case NonFatal(ex) if ctx.isBestEffort => + case ex: Exception if ctx.isBestEffort => report.bestEffortError(ex, "Some best-effort tasty files will not be generated.") false Profile.current.recordTasty(treePkl.buf.length) diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala index 08409b2c1122..74bccea94b03 100644 --- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala +++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala @@ -26,6 +26,8 @@ import cc.* import dotty.tools.dotc.transform.MacroAnnotations.hasMacroAnnotation import dotty.tools.dotc.core.NameKinds.DefaultGetterName import ast.TreeInfo +import dotty.tools.dotc.core.NameKinds.ContextBoundParamName +import dotty.tools.dotc.cc.derivedFunctionOrMethod object PostTyper { val name: String = "posttyper" @@ -95,6 +97,19 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => def newTransformer(using Context): Transformer = new PostTyperTransformer + override def runOn(units: List[CompilationUnit])(using runCtx: Context): List[CompilationUnit] = + if Feature.ccEnabledSomewhere then + SafeRefs.init()(using ctx.withPhase(thisPhase)) + super.runOn(units) + + override def run(using Context): Unit = + val unit = ctx.compilationUnit + if Feature.safeEnabled then + // Check safe refs before PostTyper's run since that way Inline calls have not + // yet been replaced with InlineCallTraces. + SafeRefs.checker.traverse(unit.tpdTree) + super.run + /** * Used to check that `changesParents` is called after `initContext`. * @@ -107,6 +122,13 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => initContextCalled = true compilingScala2StdLib = Feature.shouldBehaveAsScala2(using ctx) + /** The anonymous function symbols that need an explicified result type + * if their right hand side is also a closure. This is the case if + * the closure's type forms part of the type of a valdef or defdef + * that has a polymorphic closure type. + */ + private val closuresNeedingExplicify = mutable.Set[Symbol]() + val superAcc: SuperAccessors = new SuperAccessors(thisPhase) val synthMbr: SyntheticMembers = new SyntheticMembers(thisPhase) val beanProps: BeanProperties = new BeanProperties(thisPhase) @@ -243,6 +265,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => tree match case tree: ValOrDefDef if !sym.is(Synthetic) => checkInferredWellFormed(tree.tpt) + if tree.symbol.owner.isInlineTrait then checkInlTraitPrivateMemberIsLocal(tree) if sym.is(Method) then if sym.isSetter then sym.keepAnnotationsCarrying(thisPhase, Set(defn.SetterMetaAnnot)) @@ -289,6 +312,9 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => => Checking.checkAppliedTypesIn(tree) case _ => + private def checkInlTraitPrivateMemberIsLocal(tree: Tree)(using Context): Unit = + if tree.symbol.owner.isInlineTrait && tree.symbol.isAllOf(Private, butNot = Local) then + report.error(em"implementation restriction: inline traits cannot have non-local private members. This also means no retained inline methods.", tree.srcPos) private def transformSelect(tree: Select, targs: List[Tree])(using Context): Tree = { val qual = tree.qualifier @@ -397,6 +423,67 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => case _ => tpt + /** Under ccEnabled, If the (return-) type of the ValDef or DefDef is an InferredType, + * make (some parts of) it non-inferred types so that embedded retains annotations + * are kept. Specifically: + * (1) If definition overrides some other declaration, make its type non-inferred. + * For an overriding symbol the retains annotations come from the explicitly + * declared parent types, so should be kept. + * (2) If the definition is not a closure, but its right hand side is a + * closure, make all parameter types corresponding to nested closures + * non-inferred by adding `@caps.declared` annotations. + * In this case we need to keep references to bound capset variables in retains + * clauses of subsequent parameters. + * (3) If the definition is a closure that is a curried result of the + * right hand side of a defininition meeting condition (2), also make + * its parameter types non-inferred as specified by (2). + */ + private def explicifyTpt(tree: ValOrDefDef)(using Context): Tree = tree.tpt match + case tpt: InferredTypeTree if Feature.ccEnabled => + if tree.symbol.allOverriddenSymbols.hasNext then // (1) + tpd.cpy.TypeTree(tpt)(inferred = false) + else tree.rhs match + case closureDef(mdef) + if !tree.symbol.isAnonymousFunction // (2) + || closuresNeedingExplicify.remove(tree.symbol) // (3) + => + val tpe1 = makeFormalsDeclared(tpt.tpe, tree.rhs) + if tpe1 `ne` tpt.tpe + then TypeTree(tpe1, inferred = true).withSpan(tree.span).withAttachmentsFrom(tpt) + else tpt + case _ => tpt + case tpt => + tpt + + /** Insert a `@caps.declared` annotation on all parameter infos + * of a function type `tp` corresponding to a closure `rhs` that contain + * a "retains" annotation. TypeBound infos of type parameters get + * a `@caps.declared` on each bound that contains a "retains" annotation. + */ + private def makeFormalsDeclared(tp: Type, rhs: Tree)(using Context): Type = rhs match + case closureDef(mdef) => + closuresNeedingExplicify += mdef.symbol + + def makeFormalDeclared(formal: Type)(using Context): Type = formal match + case formal @ TypeBounds(lo, hi) => + formal.derivedTypeBounds(makeFormalDeclared(lo), makeFormalDeclared(hi)) + case _ => + val cleanup = CleanupRetains() + cleanup(formal) // only used for setting cleanup.retainsFound as a side effect + if cleanup.retainsFound && !formal.hasAnnotation(defn.DeclaredAnnot) + then AnnotatedType(formal, Annotation(defn.DeclaredAnnot, rhs.span)) + else formal + + tp match + case FunctionOrMethod(formals, res) => + val rhs1 = formals match + case (_: TypeBounds) :: _ => rhs + case _ => mdef.rhs + val formals1 = formals.mapConserve(makeFormalDeclared) + tp.derivedFunctionOrMethod(formals1, makeFormalsDeclared(res, rhs1)) + case _ => tp + case _ => tp + /** If one of `trees` is a spread of an expression that is not idempotent, lift out all * non-idempotent expressions (not just the spreads) and apply `within` to the resulting * pure references. Otherwise apply `within` to the original trees. @@ -491,6 +578,8 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => if tree.isType then checkNotPackage(tree) else + if tree.symbol == defn.SpecializedModule then + report.error(IllegalUseOfSpecialized(), tree.srcPos) registerNeedsInlining(tree) val tree1 = checkUsableAsValue(tree) tree1.tpe match { @@ -582,7 +671,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => annotateExperimentalCompanion(tree.symbol) registerIfHasMacroAnnotations(tree) Checking.checkPolyFunctionType(tree.tpt) - val tree1 = cpy.ValDef(tree)(tpt = makeOverrideTypeDeclared(tree.symbol, tree.tpt)) + val tree1 = cpy.ValDef(tree)(tpt = explicifyTpt(tree)) if tree1.removeAttachment(desugar.UntupledParam).isDefined then checkStableSelection(tree.rhs) processValOrDefDef(super.transform(tree1)) @@ -590,9 +679,13 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => registerIfHasMacroAnnotations(tree) Checking.checkPolyFunctionType(tree.tpt) annotateContextResults(tree) - val tree1 = cpy.DefDef(tree)(tpt = makeOverrideTypeDeclared(tree.symbol, tree.tpt)) + val tree1 = cpy.DefDef(tree)(tpt = explicifyTpt(tree)) processValOrDefDef(superAcc.wrapDefDef(tree1)(super.transform(tree1).asInstanceOf[DefDef])) case tree: TypeDef => + if tree.symbol.isInlineTrait then + ctx.compilationUnit.needsInlining = true // Transform inner classes to traits + if tree.rhs.tpe.existsPart(t => t.typeSymbol == defn.SpecializedClass.asType) then + report.error(IllegalUseOfSpecialized(), tree.srcPos) registerIfHasMacroAnnotations(tree) val sym = tree.symbol if (sym.isClass) @@ -604,6 +697,8 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => tree.rhs match case impl: Template => for parent <- impl.parents do + if Inlines.symbolFromParent(parent).isInlineTrait then + ctx.compilationUnit.needsInlining = true Checking.checkTraitInheritance(parent.tpe.classSymbol, sym.asClass, parent.srcPos) // Constructor parameters are in scope when typing a parent. // While they can safely appear in a parent tree, to preserve @@ -663,6 +758,8 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase => else if (tree.tpt.symbol == defn.orType) () // nothing to do else + if tree.tpt.symbol == defn.SpecializedClass && !ctx.owner.name.is(ContextBoundParamName) then + report.error(IllegalUseOfSpecialized(), tree.srcPos) Checking.checkAppliedType(tree) super.transform(tree) case SingletonTypeTree(ref) => diff --git a/compiler/src/dotty/tools/dotc/transform/PruneInlineTraits.scala b/compiler/src/dotty/tools/dotc/transform/PruneInlineTraits.scala new file mode 100644 index 000000000000..db191c4080ed --- /dev/null +++ b/compiler/src/dotty/tools/dotc/transform/PruneInlineTraits.scala @@ -0,0 +1,64 @@ +package dotty.tools.dotc +package transform + +import core._ +import Contexts._ +import DenotTransformers.SymTransformer +import Flags._ +import SymDenotations._ +import Symbols._ +import MegaPhase.MiniPhase +import ast.tpd +import dotty.tools.dotc.core.StdNames.str + +class PruneInlineTraits extends MiniPhase with SymTransformer { thisTransform => + import tpd._ + import PruneInlineTraits._ + + override def phaseName: String = PruneInlineTraits.name + + override def description: String = PruneInlineTraits.description + override def runsAfter: Set[String] = Set(PruneSpecializedMethods.name) + + override def transformSym(sym: SymDenotation)(using Context): SymDenotation = + if isEraseable(sym) then sym.copySymDenotation(initFlags = sym.flags | Deferred) + else if sym.isInlineTrait then + val clsInfo = sym.asClass.classInfo + val clsInfo2 = clsInfo.derivedClassInfo(decls = + clsInfo.decls.filteredScope(!isDeletable(_)) + ) + sym.copySymDenotation(initFlags = sym.flags | PureInterface | NoInits, info = clsInfo2) + else sym + + override def transformTemplate(tree: Template)(using Context): Tree = + cpy.Template(tree)(body = tree.body.flatMap({ + case stmt: ValDef if isEraseable(stmt.symbol) => Some(cpy.ValDef(stmt)(rhs = EmptyTree)) + case stmt: DefDef if isEraseable(stmt.symbol) => Some(cpy.DefDef(stmt)(rhs = EmptyTree)) + case stmt: (ValDef | DefDef) if isDeletable(stmt.symbol) => None + case stmt => Some(stmt) + })) + + private def isEraseable(sym: SymDenotation)(using Context): Boolean = + !sym.isType + && !sym.isConstructor + && !sym.is(Param) + && !sym.is(ParamAccessor) + && !sym.is(Local) + && !sym.isLocalDummy + && sym.exists + && sym.owner.isInlineTrait + + private def isDeletable(sym: SymDenotation)(using Context): Boolean = + !sym.isType + && sym.owner.isInlineTrait + && (sym.is(Local) || (sym.is(Inline) && !sym.isRetainedInline)) // isRetainedInline not an issue while we block non-local privates as retainedBody is non local private. + && !sym.is(Param) + && !sym.is(ParamAccessor) +} + +object PruneInlineTraits { + import tpd._ + + val name: String = "pruneInlineTraits" + val description: String = "drop rhs definitions in inline traits" +} diff --git a/compiler/src/dotty/tools/dotc/transform/PruneSpecializedMethods.scala b/compiler/src/dotty/tools/dotc/transform/PruneSpecializedMethods.scala new file mode 100644 index 000000000000..22d76f1dcee3 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/transform/PruneSpecializedMethods.scala @@ -0,0 +1,45 @@ +package dotty.tools.dotc +package transform + +import core._ +import Contexts._ +import DenotTransformers.SymTransformer +import Flags._ +import SymDenotations._ +import Symbols._ +import MegaPhase.MiniPhase +import ast.tpd +import dotty.tools.dotc.core.StdNames.str + +class PruneSpecializedMethods extends MiniPhase with SymTransformer { thisTransform => + import tpd._ + import PruneSpecializedMethods._ + + override def phaseName: String = PruneSpecializedMethods.name + + override def description: String = PruneSpecializedMethods.description + + override def transformSym(sym: SymDenotation)(using Context): SymDenotation = + if sym.isClass && !sym.is(Package) && sym.info.exists then + val clsInfo = sym.asClass.classInfo + val clsInfo2 = clsInfo.derivedClassInfo(decls = + clsInfo.decls.filteredScope(!isDeletable(_)) + ) + sym.copySymDenotation(info = clsInfo2) + else sym + + override def transformTemplate(tree: Template)(using Context): Tree = + cpy.Template(tree)(body = tree.body.flatMap({ + case stmt: DefDef if isDeletable(stmt.symbol) => None + case stmt => Some(stmt) + })) + + private def isDeletable(sym: SymDenotation)(using Context): Boolean = sym.isSpecializedMethod +} + +object PruneSpecializedMethods { + import tpd._ + + val name: String = "pruneSpecializedMethods" + val description: String = "drop specialized methods which have already been inlined; we can't wait until erasure because they can be broken by pruneInlineTraits removing members from the specialized traits they instantiate" +} diff --git a/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala b/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala index 1f5886b17535..3c1b469c1432 100644 --- a/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala +++ b/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala @@ -75,8 +75,6 @@ class SelectStatic extends MiniPhase with IdentityDenotTransformer { } private def normalize(t: Tree)(using Context) = t match { - case Select(Block(stats, qual), nm) => - Block(stats, cpy.Select(t)(qual, nm)) case Apply(Block(stats, qual), nm) => Block(stats, Apply(qual, nm)) case TypeApply(Block(stats, qual), nm) => diff --git a/compiler/src/dotty/tools/dotc/transform/SpecializeInlineTraits.scala b/compiler/src/dotty/tools/dotc/transform/SpecializeInlineTraits.scala new file mode 100644 index 000000000000..7e6467a8d5c4 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/transform/SpecializeInlineTraits.scala @@ -0,0 +1,124 @@ +package dotty.tools.dotc +package transform + +import core._ +import Flags._ +import Contexts._ +import Symbols._ +import dotty.tools.dotc.ast.tpd +import dotty.tools.dotc.ast.Trees._ +import dotty.tools.dotc.quoted._ +import dotty.tools.dotc.inlines.Inlines +import dotty.tools.dotc.ast.TreeMapWithImplicits +import dotty.tools.dotc.core.DenotTransformers.SymTransformer +import dotty.tools.dotc.staging.StagingLevel +import dotty.tools.dotc.core.SymDenotations.SymDenotation +import dotty.tools.dotc.core.StdNames.{str, nme} +import dotty.tools.dotc.core.Types.* +import dotty.tools.dotc.core.Names.{Name, TermName} + +import scala.collection.mutable.ListBuffer + +class SpecializeInlineTraits extends MacroTransform, SymTransformer { + + import tpd._ + + override def phaseName: String = SpecializeInlineTraits.name + + override def description: String = SpecializeInlineTraits.description + + override def changesMembers: Boolean = true + + override def changesParents: Boolean = true + + + override def run(using Context): Unit = + try super.run + catch case _: CompilationUnit.SuspendException => () + + override def newTransformer(using Context): Transformer = new Transformer { + override def transform(tree: Tree)(using Context): Tree = tree match { + case tree: TypeDef if tree.symbol.isInlineTrait => + val tree1 = Inlines.checkAndTransformInlineTrait(tree) + val tree2 = if Inlines.needsInlining(tree1) then Inlines.inlineParentInlineTraits(tree1) else tree1 + super.transform(tree2) // We may need to inline inline traits into the bodies of methods defined inside inline traits. + case tree: TypeDef if Inlines.needsInlining(tree) => + if tree.symbol.isAllOf(Trait, butNot = Inline) then + val problemParents = tree.symbol.info.parents.filter( + p => p.classSymbol.isInlineTrait + && p.classSymbol.primaryConstructor.paramSymss.exists(paramList => paramList.nonEmpty && paramList.head.isTerm) + ) + problemParents.foreach( p => + val message = if p.typeSymbol.isSpecializedTrait then "Specialized traits may not be extended by ordinary traits. They may only be extended by classes, objects or inline/specialized traits." + else s"Only parameterless inline traits may be extended by ordinary traits. Make ${tree.symbol} inline or remove inline ${p.typeSymbol}'s parameter list." + + report.error(message, tree.srcPos) + ) + val tree1 = + if tree.symbol.isInlineTrait then + Inlines.inlineParentInlineTraits(Inlines.checkAndTransformInlineTrait(tree)) + else Inlines.inlineParentInlineTraits(tree) + super.transform(tree1) + + case _ => super.transform(tree) + } + } + + override def transformSym(symd: SymDenotation)(using Context): SymDenotation = symd + /* if symd.isClass && symd.owner.isInlineTrait && !symd.is(Module) then + symd.copySymDenotation(name = SpecializeInlineTraits.newInnerClassName(symd.name), initFlags = (symd.flags &~ Final) | Trait) + else + symd +*/ + + override def checkPostCondition(tree: Tree)(using Context): Unit = + tree match { + // TODO check that things are inlined properly + case _ => + } + + /* private def makeTraitFromInnerClass(innerClass: TypeDef)(using Context): TypeDef = + val TypeDef(name, tmpl: Template) = innerClass: @unchecked + val newInnerParents = tmpl.parents.mapConserve(ConcreteParentStripper.apply) + val tmpl1 = cpy.Template(tmpl)(parents = newInnerParents) // TODO .withType(???) + val newTrait = cpy.TypeDef(innerClass)(name = SpecializeInlineTraits.newInnerClassName(name), rhs = tmpl1) + newTrait.symbol.setFlag(Synthetic) + newTrait + end makeTraitFromInnerClass + + private def makeTypeFromInnerClass(parentSym: Symbol, innerClass: TypeDef, newTraitSym: Symbol)(using Context): TypeDef = + val upperBound = innerClass.symbol.primaryConstructor.info match { + case _: MethodType => + newTraitSym.typeRef + case poly: PolyType => + HKTypeLambda(poly.paramNames)(tl => poly.paramInfos, tl => newTraitSym.typeRef.appliedTo(tl.paramRefs.head)) + } + val newTypeSym = newSymbol( + owner = parentSym, + name = newTraitSym.name.asTypeName, + flags = innerClass.symbol.flags & (Private | Protected) | Synthetic, + info = TypeBounds.upper(upperBound), + privateWithin = innerClass.symbol.privateWithin, + coord = innerClass.symbol.coord, + nestingLevel = innerClass.symbol.nestingLevel, + ).asType + TypeDef(newTypeSym) + end makeTypeFromInnerClass + */ + + private object ConcreteParentStripper extends TreeAccumulator[Tree] { + def apply(tree: Tree)(using Context): Tree = apply(tree, tree) + + override def apply(x: Tree, tree: Tree)(using Context): Tree = tree match { + case ident: Ident => ident + case tpt: TypeTree => tpt + case _ => foldOver(x, tree) + } + } +} + +object SpecializeInlineTraits: + val name: String = "specializeInlineTraits" + val description: String = "inline the code of inline traits" + + private[transform] def newInnerClassName(name: Name): name.ThisName = name ++ str.INLINE_TRAIT_INNER_CLASS_SUFFIX diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala index a40db72d0ccb..9a713f75de2d 100644 --- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala +++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala @@ -20,7 +20,6 @@ import dotty.tools.dotc.core.Constants.Constant import dotty.tools.dotc.quoted.Interpreter -import scala.util.control.NonFatal import dotty.tools.dotc.util.SrcPos import dotty.tools.io.AbstractFileClassLoader @@ -76,7 +75,7 @@ object Splicer { case ex: StopInterpretation => report.error(ex.msg, ex.pos) ref(defn.Predef_undefined).withType(ErrorType(ex.msg)) - case NonFatal(ex) => + case ex: Exception => val msg = em"""Failed to evaluate macro. | Caused by ${ex.getClass}: ${if (ex.getMessage == null) "" else ex.getMessage} diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala index 8163abbc1588..eccb256be6b8 100644 --- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala +++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala @@ -89,8 +89,8 @@ class Splicing extends MacroTransform: case tree: Quote => val body1 = QuoteTransformer().transform(tree.body)(using quoteContext) cpy.Quote(tree)(body1, tree.tags) - case tree: DefDef if tree.symbol.is(Inline) => - // Quotes in inlined methods are only pickled after they are inlined. + case _: DefDef | _: TypeDef if tree.symbol.is(Inline) => + // Quotes in inlined methods and traits are only pickled after they are inlined. tree case _ => super.transform(tree) diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala index 0077cb969e3a..545315afc8f2 100644 --- a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala +++ b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala @@ -109,7 +109,7 @@ class SuperAccessors(thisPhase: DenotTransformer) { if (sym.isTerm && !sym.is(Method, butNot = Accessor) && !ctx.owner.isAllOf(ParamForwarder)) // ParamForwaders as installed ParamForwarding.scala do use super calls to vals - report.error(em"super may be not be used on ${sym.underlyingSymbol}", sel.srcPos) + report.error(em"super may not be used on ${sym.underlyingSymbol}", sel.srcPos) else if (isDisallowed(sym)) report.error(em"super not allowed here: use this.${sel.name} instead", sel.srcPos) else if (sym.is(Deferred)) { @@ -156,6 +156,7 @@ class SuperAccessors(thisPhase: DenotTransformer) { val needAccessor = name.isTermName // Types don't need super accessors && !sym.isInlineMethod // Inline methods are not called at runtime so they don't need superaccessors. + && !clazz.isInlineTrait // Inline traits deal with super calls in their own way && (clazz != currentClass || !validCurrentClass || mix.name.isEmpty && clazz.is(Trait)) if (needAccessor) atPhase(thisPhase.next)(superAccessorCall(sel, mix.name)) diff --git a/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala b/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala index 6073447490ff..85248093fec0 100644 --- a/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala +++ b/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala @@ -189,7 +189,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) { * def productElement(index: Int): Any = index match { * case 0 => this._1 * case 1 => this._2 - * case _ => throw new IndexOutOfBoundsException(index.toString) + * case _ => throw new IndexOutOfBoundsException(index) * } * ``` */ @@ -215,7 +215,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) { * def productElement(index: Int): Any = index match { * case 0 => this.x * case 1 => this.y - * case _ => throw new IndexOutOfBoundsException(index.toString) + * case _ => throw new IndexOutOfBoundsException(index) * } * ``` */ @@ -242,7 +242,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) { * def productElementName(index: Int): String = index match { * case 0 => "x" * case 1 => "y" - * case _ => throw new IndexOutOfBoundsException(index.toString) + * case _ => throw new IndexOutOfBoundsException(index) * } * ``` */ @@ -255,20 +255,16 @@ class SyntheticMembers(thisPhase: DenotTransformer) { Match(index, (cases :+ generateIOBECase(index)).toList) } + /** Generate a tree equivalent to the following source level code: + * ```scala + * case _: Int => throw new IndexOutOfBoundsException(index) + * ``` + */ def generateIOBECase(index: Tree): CaseDef = { - val ioob = defn.IndexOutOfBoundsException.typeRef - // Second constructor of ioob that takes a String argument - def filterStringConstructor(s: Symbol): Boolean = s.info match { - case m: MethodType if s.isConstructor && m.paramInfos.size == 1 => - m.paramInfos.head.stripNull() == defn.StringType - case _ => false - } - val constructor = ioob.typeSymbol.info.decls.find(filterStringConstructor(_)).asTerm - val stringIndex = Apply(Select(index, nme.toString_), Nil) - val error = Throw(New(ioob, constructor, List(stringIndex))) - - // case _ => throw new IndexOutOfBoundsException(i.toString) - CaseDef(Underscore(defn.IntType), EmptyTree, error) + val rhs = New(defn.IndexOutOfBoundsExceptionType) + .select(defn.IndexOutOfBoundsException_IntConstructor) + .appliedTo(index) + CaseDef(Underscore(defn.IntType), EmptyTree, Throw(rhs)) } /** The class diff --git a/compiler/src/dotty/tools/dotc/transform/TailRec.scala b/compiler/src/dotty/tools/dotc/transform/TailRec.scala index 690a180e52ca..d8750dc2e21d 100644 --- a/compiler/src/dotty/tools/dotc/transform/TailRec.scala +++ b/compiler/src/dotty/tools/dotc/transform/TailRec.scala @@ -195,6 +195,7 @@ class TailRec extends MiniPhase { */ def isInfiniteRecCall(tree: Tree): Boolean = { def tailArgOrPureExpr(stat: Tree): Boolean = stat match { + case stat if InstrumentCoverage.isCoverageProbe(stat) => true case stat: ValDef if stat.name.is(TailTempName) || !stat.symbol.is(Mutable) => tailArgOrPureExpr(stat.rhs) case Assign(lhs: Ident, rhs) if lhs.symbol.name.is(TailLocalName) => tailArgOrPureExpr(rhs) || varForRewrittenThis.exists(_ == lhs.symbol && rhs.tpe.isStable) @@ -325,11 +326,31 @@ class TailRec extends MiniPhase { method.matches(calledMethod) && enclosingClass.appliedRef.widen <:< prefix.tpe.widenDealias + // Argument shape under coverage: `{ Invoker.invoked(...); f$default$n(...) }`; + // strip the probe block and recover `f$default$n`'s parameter index. + def defaultGetterIndex(arg: Tree): Option[Int] = + def fromSymbol(sym: Symbol): Option[Int] = + if sym.exists && sym.name.is(DefaultGetterName) then + val DefaultGetterName(_, index) = sym.name: @unchecked + Some(index) + else + None + + val stripped = InstrumentCoverage.stripLeadingCoverage(arg) + fromSymbol(stripped.symbol).orElse { + stripped match + case id: Ident => + id.symbol.defTree match + case vdef: ValDef => defaultGetterIndex(vdef.rhs) + case _ => None + case _ => + None + } + if isRecursiveCall then if ctx.settings.Whas.recurseWithDefault then - tree.args.find(_.symbol.name.is(DefaultGetterName)) match - case Some(arg) => - val DefaultGetterName(_, index) = arg.symbol.name: @unchecked + tree.args.iterator.flatMap(defaultGetterIndex).nextOption() match + case Some(index) => report.warning(RecurseWithDefault(calledMethod.info.firstParamNames(index)), tree.srcPos) case _ => diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala index d9c53eed8847..b4298d9a933c 100644 --- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala +++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala @@ -26,8 +26,6 @@ import staging.StagingLevel import inlines.Inlines.inInlineMethod import cc.RetainingAnnotation -import scala.util.control.NonFatal - /** Run by -Ycheck option after a given phase, this class retypes all syntax trees * and verifies that the type of each tree node so obtained conforms to the type found in the tree node. * It also performs the following checks: @@ -50,7 +48,8 @@ class TreeChecker extends Phase with SymTransformer { def testDuplicate(sym: Symbol, registry: mutable.Map[String, Symbol], typ: String)(using Context): Unit = { val name = sym.javaClassName val isDuplicate = this.flatClasses && registry.contains(name) - assert(!isDuplicate, s"$typ defined twice $sym ${sym.id} ${registry(name).id}") + // Allow users to define a class "java" even on the JVM + assert(!isDuplicate || name == "java", s"$typ defined twice $sym ${sym.id} ${registry(name).id}") registry(name) = sym } @@ -73,7 +72,11 @@ class TreeChecker extends Phase with SymTransformer { sym.isRefinementClass assert(validSuperclass, i"$sym has no superclass set") - testDuplicate(sym, seenClasses, "class") + + // Multiple references to specialized traits will specialize multiple times, but they lead to the same + // interface and implementation classes every time, so we can allow duplicates and pick one arbitrarily. + if !(sym.isSpecializedTraitInterface || sym.isSpecializedTraitImplementationClass) then + testDuplicate(sym, seenClasses, "class") } val badDeferredAndPrivate = @@ -128,7 +131,7 @@ class TreeChecker extends Phase with SymTransformer { } try checker.typedExpr(ctx.compilationUnit.tpdTree)(using checkingCtx) catch { - case NonFatal(ex) => //TODO CHECK. Check that we are bootstrapped + case ex: Exception => //TODO CHECK. Check that we are bootstrapped inContext(checkingCtx) { println(i"*** error while checking ${ctx.compilationUnit} after phase ${ctx.phase.prev.megaPhase(using ctx)} ***") } @@ -197,10 +200,10 @@ object TreeChecker { } }.apply(tp0) - def checkParents(sym: ClassSymbol, parents: List[tpd.Tree])(using Context): Unit = + def checkParents(sym: ClassSymbol, parents: List[tpd.Tree], assertionFunc: (Boolean, String) => Unit)(using Context): Unit = val symbolParents = sym.classInfo.parents.map(_.dealias.typeSymbol) val treeParents = parents.map(_.tpe.dealias.typeSymbol) - assert(symbolParents == treeParents, + assertionFunc(symbolParents == treeParents, i"""Parents of class symbol differs from the parents in the tree for $sym | |Parents in symbol: $symbolParents @@ -436,7 +439,7 @@ object TreeChecker { checkNoOrphans(res.tpe) phasesToCheck.foreach(_.checkPostCondition(res)) res - catch case NonFatal(ex) if !ctx.run.enrichedErrorMessage => + catch case ex: Exception if !ctx.run.enrichedErrorMessage => val treeStr = tree.show(using ctx.withPhase(ctx.phase.prev.megaPhase)) printer.println(ctx.run.enrichErrorMessage(s"exception while retyping $treeStr of class ${tree.className} # ${tree.uniqueId}")) throw ex @@ -578,7 +581,7 @@ object TreeChecker { assert(ctx.owner.isClass) val sym = ctx.owner.asClass if !sym.isPrimitiveValueClass then - TreeChecker.checkParents(sym, impl.parents) + TreeChecker.checkParents(sym, impl.parents, assert) } override def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree = { @@ -601,8 +604,13 @@ object TreeChecker { def isNonMagicalMember(x: Symbol) = !x.isValueClassConvertMethod && !x.name.is(DocArtifactName) && - !(ctx.phase.id >= genBCodePhase.id && x.name == str.MODULE_INSTANCE_FIELD.toTermName) + !(x.owner.isInlineTrait) + // ^TODO: Not sure if this is strictly necessary but it seems to help in some cases because + // we can generate undefined private members in inline traits - we might need to think about + // this a bit more because I think it's only fine if you assume that you can't directly instantiate + // inline traits, whereas we might want to allow that (aside from specialisation) . + val decls = cls.classInfo.decls.toList.toSet.filter(isNonMagicalMember) val defined = impl.body.map(_.symbol) @@ -821,6 +829,7 @@ object TreeChecker { assert((tp1 eq tp2) || (tp1 <:< tp2), { val mismatch = TypeMismatch(tp1, tp2, None) i"""|Type Mismatch (while checking $step): + |Position: ${tree.srcPos.sourcePos.showLineColumn} |${mismatch.message}${mismatch.explanation} |tree = $tree ${tree.className}""".stripMargin }) @@ -835,8 +844,8 @@ object TreeChecker { def checkMacroGeneratedTree(original: tpd.Tree, expansion: tpd.Tree)(using Context): Unit = if ctx.settings.XcheckMacros.value then - // We want make sure that transparent inline macros are checked in the same way that - // non transparent macros are, so we try to prepare a context which would make + // We want to make sure that transparent inline macros are checked in the same way that + // non-transparent macros are, so we try to prepare a context which would make // the checks behave the same way for both types of macros. // // E.g. Different instances of skolem types are by definition not able to be a subtype of diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala index f6e48588ffdb..dfe75c73e70c 100644 --- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala +++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package transform -import scala.language.unsafeNulls as _ - import core.* import Contexts.*, Symbols.*, Types.*, Constants.*, StdNames.*, Decorators.* import ast.untpd diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala index a8a855b6ae5b..12e93f7e1f3b 100644 --- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala +++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala @@ -635,8 +635,9 @@ object Semantic: reporter.report(error) Hot else - val error = AccessNonInit(target)(trace) - reporter.report(error) + if !receiver.classSymbol.isInlineTrait then // See tests/pos/inline-trait-y-equals-x-inlined-nowarn.scala + val error = AccessNonInit(target)(trace) + reporter.report(error) Hot else report.warning("[Internal error] Unexpected resolution failure: ref.klass = " + ref.klass.show + ", field = " + field.show + Trace.show, Trace.position) diff --git a/compiler/src/dotty/tools/dotc/transform/localopt/StringInterpolatorOpt.scala b/compiler/src/dotty/tools/dotc/transform/localopt/StringInterpolatorOpt.scala index db3a0c6c71f2..afee78503c83 100644 --- a/compiler/src/dotty/tools/dotc/transform/localopt/StringInterpolatorOpt.scala +++ b/compiler/src/dotty/tools/dotc/transform/localopt/StringInterpolatorOpt.scala @@ -1,8 +1,6 @@ package dotty.tools.dotc package transform.localopt -import scala.language.unsafeNulls - import dotty.tools.dotc.ast.tpd import dotty.tools.dotc.core.Decorators.* import dotty.tools.dotc.core.Constants.Constant @@ -49,7 +47,10 @@ class StringInterpolatorOpt extends MiniPhase: def unapply(tree: Select)(using Context): Boolean = (tree.symbol eq defn.StringContextModule_apply) && (tree.qualifier.symbol eq defn.StringContextModule) - /** Matches an s or raw string interpolator */ + /** Matches an s or raw string interpolator. + * + * The `List[Literal]` in the result is always non-empty (but not the `List[Tree]`). + */ private object SOrRawInterpolator: def unapply(tree: Tree)(using Context): Option[(List[Literal], List[Tree])] = tree match @@ -79,7 +80,7 @@ class StringInterpolatorOpt extends MiniPhase: if tree.symbol == defn.StringContext_raw then Some(strs, elems) else // tree.symbol == defn.StringContextS import dotty.tools.dotc.util.SourcePosition - var stringPosition: SourcePosition = null + var stringPosition: SourcePosition = strs.head.sourcePos // ok because strs is non-empty try val escapedStrs = strs.map { str => stringPosition = str.sourcePos diff --git a/compiler/src/dotty/tools/dotc/transform/sjs/JSExportUtils.scala b/compiler/src/dotty/tools/dotc/transform/sjs/JSExportUtils.scala index 2b0ed3c4880e..4b19e95fa159 100644 --- a/compiler/src/dotty/tools/dotc/transform/sjs/JSExportUtils.scala +++ b/compiler/src/dotty/tools/dotc/transform/sjs/JSExportUtils.scala @@ -2,8 +2,6 @@ package dotty.tools.dotc package transform package sjs -import scala.language.unsafeNulls - import core.* import NameKinds.DefaultGetterName import Names.* diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala index 6b20b98b4f17..16516a61f99b 100644 --- a/compiler/src/dotty/tools/dotc/typer/Applications.scala +++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala @@ -38,7 +38,6 @@ import Denotations.SingleDenotation import annotation.threadUnsafe import scala.annotation.tailrec -import scala.util.control.NonFatal object Applications { import tpd.* @@ -486,7 +485,7 @@ object Applications { // it's crucial that the type tree is not copied directly as argument to // `cpy$default$1`. If it was, the variable `X'` would already be interpolated // when typing the default argument, which is too early. - spliceMeth(meth, fn).appliedToTypeTrees(targs.map(targ => TypeTree(targ.tpe).withSpan(targ.span))) + spliceMeth(meth, fn).appliedToTypeTrees(targs.map(targ => TypeTree(targ.tpe, inferred = true).withSpan(targ.span))) case _ => meth } @@ -577,7 +576,8 @@ trait Applications extends Compatibility { */ protected def normalizedFun: Tree - protected def typeOfArg(arg: Arg): Type + /** The type of the given typed argument. */ + protected def typeOfArg(arg: TypedArg): Type /** If constructing trees, pull out all parts of the function * which are not idempotent into separate prefix definitions @@ -833,14 +833,15 @@ trait Applications extends Compatibility { */ def addTyped(arg: Arg): List[Type] = if !formal.isRepeatedParam then checkNoVarArg(arg) - addArg(typedArg(arg, formal), formal) + val argTyped = typedArg(arg, formal) + addArg(argTyped, formal) if methodType.looksParamDependent // need to handle also false dependencies since we generate TypeTrees from // formal parameters in makeVarArg. These are not de-aliased, so they might contain // stray parameter references. Test case is i23266.scala. - && typeOfArg(arg).exists + && typeOfArg(argTyped).exists // `typeOfArg(arg)` could be missing because the evaluation of `arg` produced type errors - then formals1.mapconserve(safeSubstParam(_, methodType.paramRefs(n), typeOfArg(arg))) + then formals1.mapconserve(safeSubstParam(_, methodType.paramRefs(n), typeOfArg(argTyped))) else formals1 def missingArg(n: Int): Unit = @@ -1111,6 +1112,8 @@ trait Applications extends Compatibility { private var myNormalizedFun: Tree = fun init() + def typeOfArg(arg: tpd.Tree): Type = arg.tpe + def addArg(arg: Tree, formal: Type): Unit = val typedArg = adapt(arg, formal.widenExpr) typedArgBuf += typedArg @@ -1264,7 +1267,6 @@ trait Applications extends Compatibility { extends TypedApply(app, fun, methRef, proto.args, resultType, proto.applyKind) { def typedArg(arg: untpd.Tree, formal: Type): TypedArg = proto.typedArg(arg, formal) def treeToArg(arg: Tree): untpd.Tree = untpd.TypedSplice(arg) - def typeOfArg(arg: untpd.Tree): Type = proto.typeOfArg(arg) } /** Subclass of Application for type checking an Apply node with typed arguments. */ @@ -1274,7 +1276,6 @@ trait Applications extends Compatibility { extends TypedApply(app, fun, methRef, args, resultType, applyKind) { def typedArg(arg: Tree, formal: Type): TypedArg = arg def treeToArg(arg: Tree): Tree = arg - def typeOfArg(arg: Tree): Type = arg.tpe } /** If `app` is a `this(...)` constructor call, the this-call argument context, diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala index 58f38d10a2b3..cc30fbca1393 100644 --- a/compiler/src/dotty/tools/dotc/typer/Checking.scala +++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala @@ -689,7 +689,7 @@ object Checking { if (sym.isConstructor && !sym.isPrimaryConstructor && sym.owner.is(Trait, butNot = JavaDefined)) val addendum = if ctx.settings.Ydebug.value then s" ${sym.owner.flagsString}" else "" fail(em"Traits cannot have secondary constructors$addendum") - checkApplicable(Inline, sym.isTerm && !sym.is(Module) && !sym.isMutableVarOrAccessor) + checkApplicable(Inline, sym.isTerm && !sym.is(Module) && !sym.isMutableVarOrAccessor || sym.is(Trait)) checkApplicable(Lazy, !sym.isOneOf(Method | Mutable)) if (sym.isType && !sym.isOneOf(Deferred | JavaDefined)) for (cls <- sym.allOverriddenSymbols.filter(_.isClass)) { diff --git a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala index afc9e2c08f46..f62bb766dd37 100644 --- a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala +++ b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala @@ -245,7 +245,7 @@ trait Dynamic { if tpe.classSymbol.isDerivedValueClass && qual.tpe <:< defn.ReflectSelectableTypeRef then val genericUnderlying = ValueClasses.valueClassUnbox(tpe.classSymbol.asClass) val underlying = tpe.select(genericUnderlying).widen.resultType - New(tpe.widen, tree.cast(underlying) :: Nil) + New(tpe.widen.dealias, tree.cast(underlying) :: Nil) else tree maybeBoxed.cast(tpe) diff --git a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala index 66639dfd668f..7a103b9dae4c 100644 --- a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala +++ b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala @@ -11,7 +11,6 @@ import Symbols.* import Names.* import NameKinds.UniqueName import util.Spans.* -import util.Property import collection.mutable import Trees.* @@ -50,7 +49,11 @@ abstract class Lifter { /** Type assigned to a lifted temporary symbol. */ protected def liftedExprType(expr: Tree)(using Context): Type = - expr.tpe.widen.deskolemized + val tp = expr.tpe.deskolemized + if tp.isStable then tp else tp.widen + + /** Hook for lifters that need to record or mark freshly created lifted defs. */ + protected def onLiftedDef(tree: Tree)(using Context): Unit = () private def lift(defs: mutable.ListBuffer[Tree], expr: Tree, prefix: TermName = EmptyTermName)(using Context): Tree = if (noLift(expr)) expr @@ -63,10 +66,12 @@ abstract class Lifter { // Lifted definitions will be added to a local block, so they need to be // at a higher nesting level to prevent leaks. See tests/pos/i15174.scala nestingLevel = ctx.nestingLevel + 1) - defs += liftedDef(lifted, expr) + val liftedTree = liftedDef(lifted, expr) .withSpan(expr.span) .changeNonLocalOwners(lifted) .setDefTree + onLiftedDef(liftedTree) + defs += liftedTree ref(lifted.termRef).withSpan(expr.span.focus) } @@ -156,7 +161,7 @@ abstract class Lifter { * val x0 = pre * x0.f(...) * - * unless `pre` is idempotent reference, a `this` reference, a literal value, or a or the prefix of an `init` (`New` tree). + * unless `pre` is idempotent reference, a `this` reference, a literal value, or the prefix of an `init` (`New` tree). * * Note that default arguments will refer to the prefix, we do not want * to re-evaluate a complex expression each time we access a getter. @@ -187,53 +192,6 @@ class LiftComplex extends Lifter { } object LiftComplex extends LiftComplex -/** Lift impure + lift the prefixes */ -object LiftCoverage extends LiftImpure { - - // Property indicating whether we're currently lifting the arguments of an application - private val LiftingArgs = new Property.Key[Boolean] - - private inline def liftingArgs(using Context): Boolean = - ctx.property(LiftingArgs).contains(true) - - private def liftingArgsContext(using Context): Context = - ctx.fresh.setProperty(LiftingArgs, true) - - /** Variant of `noLift` for the arguments of applications. - * To produce the right coverage information (especially in case of exceptions), we must lift: - * - all the applications, except the erased ones - * - all the impure arguments - * - * There's no need to lift the other arguments. - */ - private def noLiftArg(arg: tpd.Tree)(using Context): Boolean = - arg match - case a: tpd.Apply => a.symbol.is(Erased) // don't lift erased applications, but lift all others - case tpd.Block(stats, expr) => stats.forall(noLiftArg) && noLiftArg(expr) - case tpd.Inlined(_, bindings, expr) => noLiftArg(expr) - case tpd.Typed(expr, _) => noLiftArg(expr) - case _ => super.noLift(arg) - - override def noLift(expr: tpd.Tree)(using Context) = - if liftingArgs then noLiftArg(expr) else super.noLift(expr) - - /** Preserve singleton precision for lifted coverage temps when the underlying value is a - * compile-time constant (same notion ConstFold uses), so constant re-folding after lifting - * still matches the original inferred singleton type. Everything else uses the base widen. - */ - override protected def liftedExprType(expr: tpd.Tree)(using Context): Type = - val dealiased = expr.tpe.dealias.deskolemized - dealiased.widenTermRefExpr.normalized.simplified match - case _: ConstantType => dealiased - case _ => super.liftedExprType(expr) - - def liftForCoverage(defs: mutable.ListBuffer[tpd.Tree], tree: tpd.Apply)(using Context) = { - val liftedFun = liftApp(defs, tree.fun) - val liftedArgs = liftArgs(defs, tree.fun.tpe, tree.args)(using liftingArgsContext) - tpd.cpy.Apply(tree)(liftedFun, liftedArgs) - } -} - /** Lifter for eta expansion */ object EtaExpansion extends LiftImpure { import tpd.* @@ -258,7 +216,7 @@ object EtaExpansion extends LiftImpure { * * { val xs = es; (x1: T1, ..., xn: Tn) => expr(x1, ..., xn) _ } * - * where `T1, ..., Tn` are the paremeter types of the expanded method. + * where `T1, ..., Tn` are the parameter types of the expanded method. * If `expr` has implicit function type, the arguments are passed with `given`. * E.g. for (1): * diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala index d5d028530434..380fa5da0af0 100644 --- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala +++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala @@ -889,7 +889,7 @@ trait Implicits: && ctx.mode.is(Mode.ImplicitsEnabled) && from.isValueType && ( from.isValueSubType(to) - || inferView(dummyTreeOfType(from), to) + || inferView(dummyTreeOfType(from).withSpan(ctx.tree.span), to) (using ctx.fresh.addMode(Mode.ImplicitExploration).setExploreTyperState()).isSuccess // TODO: investigate why we can't TyperState#test here || from.widen.isNamedTupleType && to.derivesFrom(defn.TupleClass) @@ -1074,8 +1074,8 @@ trait Implicits: || locally: if strictEquality then strictEqualityPatternMatching && - (leftTree.symbol.isAllOf(Flags.EnumValue) || leftTree.symbol.isAllOf(Flags.Module | Flags.Case)) && - ltp <:< lift(rtp) + (leftTree.symbol.isAllOf(Flags.EnumValue) || leftTree.symbol.is(Flags.Module)) && + ltp <:< rtp else ltp <:< lift(rtp) || rtp <:< lift(ltp) } @@ -1863,15 +1863,33 @@ trait Implicits: // is larger (see `typeSize`) and is constructed using the same set of types and type // constructors (see `coveringSet`). // + // We also treat two candidates as equivalent for this check when they are sibling + // givens declared in the same owner that share a declared signature. Such siblings + // (a common pattern when modeling type class hierarchies, see i24914) demand the + // same context parameters, so exploring one and then another under the same + // prototype shape makes no progress and would otherwise lead to a factorial + // blow-up of the search before the expression-count limit eventually kicks in. + // We use `frozen_=:=` so the check does not commit constraint updates. + // // We are able to tie a recursive knot if there is compatible term already under // construction which is separated from this context by at least one by name argument // as we ascend the chain of open implicits to the outermost search context. + def equivalentCandidates(c1: Candidate, c2: Candidate): Boolean = + if c1.ref eq c2.ref then true + else + val sym1 = c1.ref.symbol + val sym2 = c2.ref.symbol + sym1.exists + && sym2.exists + && sym1.maybeOwner == sym2.maybeOwner + && c1.ref.info.frozen_=:=(c2.ref.info) + @tailrec def loop(history: SearchHistory, belowByname: Boolean): Boolean = history match case prev @ OpenSearch(cand1, tp, outer) => - if cand1.ref eq cand.ref then + if equivalentCandidates(cand1, cand) then lazy val wildTp = wildApprox(tp.widenExpr) if belowByname && (wildTp <:< wildPt) then fullyDefinedType(tp, "by-name implicit parameter", srcPos) diff --git a/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala b/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala index e8698baa46ac..0054b53e4b13 100644 --- a/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala +++ b/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala @@ -16,7 +16,7 @@ import scala.compiletime.uninitialized object ImportInfo { - case class RootRef(refFn: () => TermRef, isPredef: Boolean = false) + case class RootRef(refFn: () => TermRef) /** The import info for a root import */ def rootImport(ref: RootRef)(using Context): ImportInfo = @@ -24,9 +24,6 @@ object ImportInfo { untpd.ImportSelector(untpd.Ident(nme.WILDCARD)) // import all normal members... :: untpd.ImportSelector(untpd.Ident(nme.EMPTY)) // ... and also all given members :: Nil - if ref.isPredef then // do not import any2stringadd - selectors = untpd.ImportSelector(untpd.Ident(nme.any2stringadd), untpd.Ident(nme.WILDCARD)) - :: selectors def sym(using Context) = val expr = tpd.Ident(ref.refFn()) // refFn must be called in the context of ImportInfo.sym diff --git a/compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala b/compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala index f0d8b2e3b135..a907c045b41b 100644 --- a/compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala +++ b/compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala @@ -13,7 +13,6 @@ import ast.{untpd, tpd} import Implicits.{hasExtMethod, Candidate} import java.util.{Timer, TimerTask} import collection.mutable -import scala.util.control.NonFatal import cc.isCaptureChecking /** This trait defines the method `importSuggestionAddendum` that adds an addendum @@ -256,7 +255,7 @@ trait ImportSuggestions: match case (Nil, partials) => (extensionImports, partials) case givenImports => givenImports - catch case NonFatal(ex) => + catch case ex: Exception => if ctx.settings.Ydebug.value then println("caught exception when searching for suggestions") ex.printStackTrace() diff --git a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala index b7861c236b73..f28532d564eb 100644 --- a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala +++ b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala @@ -251,8 +251,7 @@ object Inferencing { } case tp => foldOver(x, tp) } - catch case ex: Throwable => - handleRecursive("check fully defined", tp.showSummary(20), ex) + catch case ex: Throwable => handleRecursive("check fully defined", tp.showSummary(20), ex) } def process(tp: Type): Boolean = diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala index 3ea5ef1b0bc8..10f522c7310f 100644 --- a/compiler/src/dotty/tools/dotc/typer/Namer.scala +++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala @@ -7,7 +7,7 @@ import ast.* import Trees.*, StdNames.*, Scopes.*, Denotations.*, NamerOps.*, ContextOps.* import Contexts.*, Symbols.*, Types.*, SymDenotations.*, Names.*, NameOps.*, Flags.* import Decorators.*, Comments.{_, given} -import NameKinds.DefaultGetterName +import NameKinds.{DefaultGetterName, ModuleClassName} import ast.desugar, ast.desugar.* import ProtoTypes.* import util.Spans.* @@ -15,7 +15,7 @@ import util.Property import collection.mutable, mutable.ListBuffer import tpd.tpes import Variances.alwaysInvariant -import config.{Config, Feature} +import config.{Config, Feature, MigrationVersion} import config.Printers.typr import inlines.{Inlines, PrepareInlineable} import parsing.JavaParsers.JavaParser @@ -28,6 +28,7 @@ import TypeErasure.erasure import reporting.* import config.Feature.{sourceVersion, modularity} import config.SourceVersion.* +import rewrites.Rewrites.patch import scala.compiletime.uninitialized @@ -179,6 +180,38 @@ class Namer { typer: Typer => if conflictsDetected then name.freshened else name end checkNoConflict + def checkDefName(name: Name, tree: Tree, flags: FlagSet)(using Context): Unit = + val isModule = name.is(ModuleClassName) + // nme.raw.DOLLAR or $$, avoiding toString and toSimpleName but incurring toTermName + // also matches "a" since it cannot contain "$" + inline def isDollars = + name.toTermName.match { + case simple: SimpleName => + simple.length == 1 || simple.length == 2 && simple.endsWith(str.EXPAND_SEPARATOR) + case _ => + isModule && { + val simple = name.toSimpleName + simple.length == 2 && simple.endsWith(str.EXPAND_SEPARATOR) + } + } + def exempt = + isBackquoted(tree) + || tree.span.isSynthetic + || flags.isOneOf(Synthetic | Accessor | CaseAccessor) // check the case param not the accessor + || flags.is(Param) && ctx.owner.is(Synthetic) + || isDollars + if !exempt && (isModule || !name.toTermName.isInstanceOf[DerivedName]) then + val simple = name.toSimpleName + val max = if isModule then simple.length - 1 else simple.length + val last = simple.lastIndexOf('$', start = max - 1) + if last >= 0 then + val start = tree.span.point + val errPos = tree.srcPos.sourcePos.withSpan(Span(start, start + max, start)) + if MigrationVersion.IdentifierDollars.needsPatch then + patch(errPos.sourcePos.source, errPos.span.startPos, "`") + patch(errPos.sourcePos.source, errPos.span.endPos, "`") + report.errorOrMigrationWarning(IllegalIdentifier(name), errPos, MigrationVersion.IdentifierDollars) + /** If this tree is a member def or an import, create a symbol of it * and store in symOfTree map. */ @@ -252,6 +285,8 @@ class Namer { typer: Typer => if Feature.shouldBehaveAsScala2 then flags |= Scala2x val name = checkNoConflict(tree.name, tree.span).asTypeName + if name == tree.name then + checkDefName(name, tree, flags) val cls = createOrRefine[ClassSymbol](tree, name, flags, ctx.owner, cls => adjustIfModule(new ClassCompleter(cls, tree)(ctx), tree), @@ -261,6 +296,8 @@ class Namer { typer: Typer => case tree: MemberDef => var flags = checkFlags(tree.mods.flags) val name = checkNoConflict(tree.name, tree.span) + if name == tree.name then + checkDefName(name, tree, flags) tree match case tree: ValOrDefDef => if tree.isInstanceOf[ValDef] && !flags.is(Param) && name.endsWith("_=") then @@ -343,7 +380,10 @@ class Namer { typer: Typer => report.error(PkgDuplicateSymbol(existingType), pid.srcPos) newCompletePackageSymbol(pkgOwner, (pid.name ++ "$_error_").toTermName).entered } - else newCompletePackageSymbol(pkgOwner, pid.name.asTermName).entered + else + val pname = pid.name.asTermName + checkDefName(pname, pid, EmptyFlags) + newCompletePackageSymbol(pkgOwner, pname).entered } } @@ -488,14 +528,22 @@ class Namer { typer: Typer => */ final def addChild(cls: Symbol, child: Symbol)(using Context): Unit = { val childStart = if (child.span.exists) child.span.start else -1 + // A Child annotation that is currently being forced cannot be safely + // inspected here (forcing it again would trigger an assertion in + // `LazyAnnotation.tree`). This can happen when adding a child causes + // completion of another class that itself needs to be added as a child of + // the same parent (see tests/pos-special/i24719). In that case, fall back + // to just prepending the new Child annotation. + def isReady(ann: Annotation): Boolean = + ann.symbol == defn.ChildAnnot && !ann.isEvaluating def insertInto(annots: List[Annotation]): List[Annotation] = - annots.find(_.symbol == defn.ChildAnnot) match { + annots.find(isReady) match { case Some(Annotation.Child(other)) if other.span.exists && childStart <= other.span.start => if (child == other) annots // can happen if a class has several inaccessible children else { assert(childStart != other.span.start || child.source != other.source, i"duplicate child annotation $child / $other") - val (prefix, otherAnnot :: rest) = annots.span(_.symbol != defn.ChildAnnot): @unchecked + val (prefix, otherAnnot :: rest) = annots.span(ann => !isReady(ann)): @unchecked prefix ::: otherAnnot :: insertInto(rest) } case _ => @@ -973,7 +1021,7 @@ class Namer { typer: Typer => val sym = denot.symbol def register(child: Symbol, parentCls: ClassSymbol) = { - if (parentCls.is(Sealed)) + if (parentCls.is(Sealed) && !(child.isAnonymousClass && parentCls.isSpecializedTrait)) if ((child.isInaccessibleChildOf(parentCls) || child.isAnonymousClass) && !sym.hasAnonymousChild) addChild(parentCls, parentCls) else if (!parentCls.is(ChildrenQueried)) @@ -1171,7 +1219,7 @@ class Namer { typer: Typer => val TypeDef(name, impl @ Template(constr, _, self, _)) = original: @unchecked - private val (params, rest): (List[Tree], List[Tree]) = impl.body.span { + private val (params: List[Tree], rest: List[Tree]) = impl.body.span { case td: TypeDef => td.mods.is(Param) case vd: ValDef => vd.mods.is(ParamAccessor) case _ => false diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala index 6a033282fbff..e2599d586c8c 100644 --- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala +++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala @@ -583,7 +583,7 @@ object ProtoTypes { /** The type of the argument `arg`, or `NoType` if `arg` has not been typed before * or if `arg`'s typing produced a type error. */ - def typeOfArg(arg: untpd.Tree)(using Context): Type = { + private[ProtoTypes] def typeOfArg(arg: untpd.Tree)(using Context): Type = { val t = state.typedArg(arg) if (t == null) NoType else t.tpe } diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala index 8400639706d6..cd416c460241 100644 --- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala +++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala @@ -9,7 +9,6 @@ import StdNames.* import Decorators.* import typer.ProtoTypes.* import ast.{tpd, untpd} -import scala.util.control.NonFatal import util.Spans.Span import Nullables.* import staging.StagingLevel.* diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala index 890710badf92..29ffd210d1e1 100644 --- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala +++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala @@ -24,6 +24,7 @@ import Annotations.Annotation import Constants.Constant import cc.{stripCapturing, CCState} import cc.Mutability.isUpdateMethod +import dotty.tools.dotc.util.Chars.{isLineBreakChar, isWhitespace} object RefChecks { import tpd.* @@ -338,6 +339,29 @@ object RefChecks { val clazzNameEnd = clazz.srcPos.span.start + clazz.name.stripModuleClassSuffix.lastPart.length clazz.srcPos.sourcePos.copy(span = clazz.srcPos.span.withEnd(clazzNameEnd)) + /** True when `clazz` is the synthetic anonymous class generated for an + * enum case (either a simple case via `$new` or a parameterized one + * marked with `EnumCase`). */ + def isEnumAnonCls = // courtesy of Checking.checkEnum + clazz.isAnonymousClass + && clazz.owner.isTerm + && { + clazz.owner.isAllOf(EnumCase) + || (clazz.owner.name eq nme.DOLLAR_NEW) && clazz.owner.isAllOf(Private | Synthetic) + } + + /** Positions at which to report a "needs to be abstract" / "object creation + * impossible" error for `clazz`. Normally a single position pointing at + * the class name; for enum-case anonymous classes the error is moved to + * the case definition(s) so the user sees it on `case Foo` rather than on + * the synthetic `$anon`. */ + def classErrorPositions: List[util.SrcPos] = + if !isEnumAnonCls then clazzNamePos :: Nil + else if clazz.owner.isAllOf(EnumCase) then clazz.owner.srcPos :: Nil + else + val e = clazz.parentSyms.head + e.children.filter(_.info.typeSymbol == e).map(_.srcPos) + def printMixinOverrideErrors(): Unit = mixinOverrideErrors.toList match { case Nil => @@ -393,6 +417,8 @@ object RefChecks { * of class `clazz` are met. */ def checkOverride(member: Symbol, other: Symbol): Unit = + def isInlinedFromInlineTrait = other.owner.isAllOf(InlineTrait) && member.is(Synthetic) + def memberType(self: Type) = if (member.isClass) TypeAlias(member.typeRef.etaExpand) else self.memberInfo(member) @@ -459,9 +485,9 @@ object RefChecks { def overrideDeprecation(annot: Annotation, member: Symbol, other: Symbol): Unit = if !CrossVersionChecks.skipDeprecation(member) then val message = - annot.argumentConstantString(0).filter(!_.isEmpty) + annot.argumentConstantString(0).filter(_.nonEmpty) .getOrElse(s"${infoString(member)} should be removed or renamed.") - val since = annot.argumentConstantString(1).filter(!_.isEmpty).map(" since " + _).getOrElse("") + val since = annot.argumentConstantString(1).filter(_.nonEmpty).map(" since " + _).getOrElse("") val composed = em"""overriding ${infoStringWithLocation(other)} is deprecated$since; | $message""" @@ -483,12 +509,13 @@ object RefChecks { def overrideTargetNameError() = val otherTargetName = i"@targetName(${other.targetName})" - if member.hasTargetName(member.name) then - overrideError(i"misses a target name annotation $otherTargetName") - else if other.hasTargetName(other.name) then - overrideError(i"should not have a @targetName annotation since the overridden member hasn't one either") - else - overrideError(i"has a different target name annotation; it should be $otherTargetName") + if !isInlinedFromInlineTrait then + if member.hasTargetName(member.name) then + overrideError(i"misses a target name annotation $otherTargetName") + else if other.hasTargetName(other.name) then + overrideError(i"should not have a @targetName annotation since the overridden member hasn't one either") + else + overrideError(i"has a different target name annotation; it should be $otherTargetName") //Console.println(infoString(member) + " overrides " + infoString(other) + " in " + clazz);//DEBUG @@ -524,13 +551,13 @@ object RefChecks { // direct overrides were already checked on completion (see Checking.chckWellFormed) // the test here catches indirect overriddes between two inherited base types. overrideError("cannot be used here - class definitions cannot be overridden") - else if (other.isOpaqueAlias) + else if (other.isOpaqueAlias && !isInlinedFromInlineTrait) // direct overrides were already checked on completion (see Checking.chckWellFormed) // the test here catches indirect overriddes between two inherited base types. overrideError("cannot be used here - opaque type aliases cannot be overridden") else if (!other.is(Deferred) && member.isClass) overrideError("cannot be used here - classes can only override abstract types") - else if other.isEffectivelyFinal then // (1.2) + else if (other.isEffectivelyFinal && !isInlinedFromInlineTrait) then // (1.2) overrideError(i"cannot override final member ${other.showLocated}") else if (member.is(ExtensionMethod) && !other.is(ExtensionMethod)) // (1.3) overrideError("is an extension method, cannot override a normal method") @@ -573,7 +600,7 @@ object RefChecks { overrideError("needs `override` modifier") else if (other.is(AbsOverride) && other.isIncompleteIn(clazz) && !member.is(AbsOverride)) overrideError("needs `abstract override` modifiers") - else if isMarkedOverride(member) && other.isMutableVarOrAccessor then + else if isMarkedOverride(member) && other.isMutableVarOrAccessor && !isInlinedFromInlineTrait then overrideError("cannot override a mutable variable") else if isMarkedOverride(member) && !(member.owner.thisType.baseClasses.exists(_.isSubClass(other.owner))) @@ -625,6 +652,7 @@ object RefChecks { overrideError("cannot have a @targetName annotation since external names would be different") else if other.is(ParamAccessor) && !isInheritedAccessor(member, other) && !member.is(Tracked) // see remark on tracked members above + && !other.owner.isInlineTrait // Allow inline traits to override val params because we prune the params from the parent traits later so they need to live in the children. then // (1.12) report.errorOrMigrationWarning( em"cannot override val parameter ${other.showLocated}", @@ -636,7 +664,7 @@ object RefChecks { overrideError("also needs to be declared with @publicInBinary") else if !other.isPreview && member.hasAnnotation(defn.PreviewAnnot) then // (1.15) overrideError("may not override non-preview member") - else if other.hasAnnotation(defn.DeprecatedOverridingAnnot) then + else other.getAnnotation(defn.DeprecatedOverridingAnnot).foreach(overrideDeprecation(_, member, other)) end checkOverride @@ -646,15 +674,15 @@ object RefChecks { // Verifying a concrete class has nothing unimplemented. if (!clazz.isOneOf(AbstractOrTrait)) { val abstractErrors = new mutable.ListBuffer[String] + val concreteClassUnimplementedMethodError = new mutable.ListBuffer[Message] def abstractErrorMessage = // a little formatting polish if (abstractErrors.size <= 2) abstractErrors.mkString(" ") else abstractErrors.tail.mkString(abstractErrors.head + ":\n", "\n", "") - def abstractClassError(mustBeMixin: Boolean, msg: String): Unit = { + def abstractClassError(msg: String): Unit = { def prelude = ( if (clazz.isAnonymousClass || clazz.is(Module)) "object creation impossible" - else if (mustBeMixin) s"$clazz needs to be a mixin" else if clazz.is(Synthetic) then "instance cannot be created" else s"$clazz needs to be abstract" ) + ", since" @@ -733,54 +761,28 @@ object RefChecks { .distinctBy(_.signature) // Avoid duplication for similar definitions (#19731) } - /** Replace synthetic parameter names (x$0, x$1, ...) with - * dollar-free versions (x0, x1, ...) so that stub implementations - * are directly usable as valid Scala identifiers. - */ - def replaceSyntheticParamNames(tp: Type): Type = tp match - case mt: MethodType if mt.allParamNamesSynthetic => - val newNames = mt.paramNames.zipWithIndex.map((_, i) => termName("x" + i)) - mt.derivedLambdaType(newNames, mt.paramInfos, replaceSyntheticParamNames(mt.resType)) - case mt: MethodType => - mt.derivedLambdaType(mt.paramNames, mt.paramInfos, replaceSyntheticParamNames(mt.resType)) - case pt: PolyType => - pt.derivedLambdaType(pt.paramNames, pt.paramInfos, replaceSyntheticParamNames(pt.resType)) - case _ => tp - - def stubImplementations: List[String] = { - // Grouping missing methods by the declaring class - val regrouped = missingMethods.groupBy(_.owner).toList - def membersStrings(members: List[Symbol]) = - members.sortBy(_.name.toString).map: sym => - val denot = sym.asSeenFrom(clazz.thisType) - denot.mapInfo(replaceSyntheticParamNames).showDcl + " = ???" - - if (regrouped.tail.isEmpty) - membersStrings(regrouped.head._2) - else (regrouped.sortBy(_._1.name.toString()) flatMap { - case (owner, members) => - ("// Members declared in " + owner.fullName) +: membersStrings(members) :+ "" - }).init - } + def stubImplementations: List[String] = + missingMethods.sortBy(_.name.toString).map: sym => + sym.asSeenFrom(clazz.thisType).mapInfo(_.withCleanParamNames).showDcl + " = ???" + + if missingMethods.isEmpty then return - // If there are numerous missing methods, we presume they are aware of it and - // give them a nicely formatted set of method signatures for implementing. - if (missingMethods.size > 1) { - abstractClassError(false, "it has " + missingMethods.size + " unimplemented members.") - val preface = - """|/** As seen from %s, the missing signatures are as follows. - | * For convenience, these are usable as stub implementations. - | */ - |""".stripMargin.format(clazz) - abstractErrors += stubImplementations.map(" " + _ + "\n").mkString(preface, "", "") + lazy val actions = + createAddMissingMethodsAction(clazz, stubImplementations) + ++ createMakeClassAbstractAction(clazz) + + if missingMethods.size > 1 then + concreteClassUnimplementedMethodError += ConcreteClassHasUnimplementedMethods( + clazz, missingMethods, addendum = "", actions) return - } for (member <- missingMethods) { def showDclAndLocation(sym: Symbol) = - s"${sym.mapInfo(replaceSyntheticParamNames).showDcl} in ${sym.owner.showLocated}" + s"${sym.mapInfo(_.withCleanParamNames).showDcl} in ${sym.owner.showLocated}" def undefined(msg: String) = - abstractClassError(false, s"${showDclAndLocation(member)} is not defined $msg") + val addendum = if msg.isEmpty then "" else s" $msg" + concreteClassUnimplementedMethodError += ConcreteClassHasUnimplementedMethods( + clazz, missingMethods, addendum, actions) val underlying = member.underlyingSymbol // Give a specific error message for abstract vars based on why it fails: @@ -873,7 +875,7 @@ object RefChecks { val impl1 = clazz.thisType.nonPrivateMember(decl.name) // DEBUG report.log(i"${impl1}: ${impl1.info}") // DEBUG report.log(i"${clazz.thisType.memberInfo(decl)}") // DEBUG - abstractClassError(false, "there is a deferred declaration of " + infoString(decl) + + abstractClassError("there is a deferred declaration of " + infoString(decl) + " which is not implemented in a subclass" + err.abstractVarMessage(decl)) } if (bc.asClass.superClass.is(Abstract)) @@ -943,11 +945,17 @@ object RefChecks { |This is a limitation that enables better GADT constraints in case class patterns""".stripMargin do report.errorOrMigrationWarning(withExplain, clazz.srcPos, MigrationVersion.Scala2to3) checkNoAbstractMembers() - if (abstractErrors.isEmpty) + if (abstractErrors.isEmpty && concreteClassUnimplementedMethodError.isEmpty) checkNoAbstractDecls(clazz) - if (abstractErrors.nonEmpty) - report.error(abstractErrorMessage, clazzNamePos) + if abstractErrors.nonEmpty then + val msg = abstractErrorMessage + classErrorPositions.foreach(report.error(msg, _)) + for + message <- concreteClassUnimplementedMethodError + pos <- classErrorPositions + do + report.error(message, pos) checkMemberTypesOK() checkCaseClassInheritanceInvariant() @@ -1055,14 +1063,7 @@ object RefChecks { case Nil => report.error(OverridesNothing(member), member.srcPos) case ms => - // getClass in primitive value classes is defined in the standard library as: - // override def getClass(): Class[Int] = ??? - // However, it's not actually an override in Dotty because our Any#getClass - // is polymorphic (see `Definitions#Any_getClass`), so since we can't change - // the standard library, we need to drop the override flag without reporting - // an error. - if (!(member.name == nme.getClass_ && clazz.isPrimitiveValueClass)) - report.error(OverridesNothingButNameExists(member, ms), member.srcPos) + report.error(OverridesNothingButNameExists(member, ms), member.srcPos) } member.resetFlag(Override) member.resetFlag(AbsOverride) @@ -1327,11 +1328,117 @@ object RefChecks { end checkImplicitNotFoundAnnotation def checkAnyRefMethodCall(tree: Tree)(using Context): Unit = + extension (c: Context) def enclosingClass: Symbol = + c.outersIterator.find(_.isClassDefContext).map(_.owner).getOrElse(NoSymbol) if tree.symbol.exists && defn.topClasses.contains(tree.symbol.owner) then tree.tpe match - case tp: NamedType if tp.prefix.typeSymbol != ctx.owner.enclosingClass => + case tp: NamedType if tp.prefix.typeSymbol != ctx.enclosingClass => report.warning(UnqualifiedCallToAnyRefMethod(tree, tree.symbol), tree) case _ => () + + private def createAddMissingMethodsAction(clazz: ClassSymbol, methods: List[String])(using Context): List[CodeAction] = + // Synthetic classes (e.g. anonymous classes generated by macros) may have + // no corresponding node in the untyped AST. In that case there's nothing + // to anchor a source-level patch to, so we don't offer the action. + NavigateAST.untypedPath(clazz.span) match + case (untypedTree: untpd.Tree) :: _ => + addMissingMethodsActionPatch(clazz, methods, untypedTree) + case _ => Nil + + /** Code action that prepends the `abstract` modifier to the class declaration. + * + * Only offered for regular classes that can legally become abstract. We skip: + * - modules (`object`s are implicitly final), + * - anonymous classes (no source-level keyword to modify), + * - case classes (cannot be abstract), + * - already-final classes (mutually exclusive with abstract), + * - synthetic classes (enum case singletons, given bodies, etc.). + * + * As with [[createAddMissingMethodsAction]], if the class has no node in + * the untyped AST (e.g. macro-generated) we skip silently. + */ + private def createMakeClassAbstractAction(clazz: ClassSymbol)(using Context): List[CodeAction] = + import dotty.tools.dotc.rewrites.Rewrites.ActionPatch + + val ineligible = + clazz.is(Module) || clazz.isAnonymousClass || clazz.is(Case) || + clazz.is(Final) || clazz.is(Synthetic) + if ineligible then Nil + else NavigateAST.untypedPath(clazz.span) match + case (untypedTree: untpd.Tree) :: _ => + val insertPos = untypedTree.sourcePos.withSpan(Span(untypedTree.span.start)) + val patch = ActionPatch(insertPos, "abstract ") + List(CodeAction(s"Make `${clazz.name.show}` abstract", None, List(patch))) + case _ => Nil + + private def addMissingMethodsActionPatch( + clazz: ClassSymbol, + methods: List[String], + untypedTree: untpd.Tree)(using Context): List[CodeAction] = { + import dotty.tools.dotc.rewrites.Rewrites.ActionPatch + + val classSrcPos = clazz.srcPos + val content = classSrcPos.sourcePos.source.content() + val span = classSrcPos.endPos.span + + val classText = new String(content.slice(untypedTree.span.start, untypedTree.span.end)) + val classHasBraces = classText.contains("{") && classText.contains("}") + + // Indentation for inserted methods + val lineStart = content.lastIndexWhere(isLineBreakChar, end = span.end - 1) + 1 + val baseIndent = new String(content.slice(lineStart, span.end).takeWhile(c => c == ' ' || c == '\t')) + val indent = baseIndent + " " + + val formattedMethods = methods.map(m => s"$indent$m").mkString("\n") + + val isBracelessSyntax = untypedTree match + case untpd.TypeDef(_, tmpl: untpd.Template) => + !classText.contains("{") && tmpl.body.nonEmpty + case _ => false + + if (classHasBraces) { + val insertBeforeBrace = untypedTree.sourcePos.withSpan(Span(untypedTree.span.end - 1)) + val braceStart = classText.indexOf('{') + val braceEnd = classText.lastIndexOf('}') + val bodyBetweenBraces = classText.slice(braceStart + 1, braceEnd) + val bodyIsEmpty = bodyBetweenBraces.forall(_.isWhitespace) + val bodyContainsNewLine = bodyBetweenBraces.exists(isLineBreakChar) + + val prefix = if (bodyContainsNewLine) "" else "\n" + val patchText = + prefix + + formattedMethods + + "\n" + + val patch = ActionPatch(insertBeforeBrace, patchText) + List(CodeAction("Add missing methods", None, List(patch))) + } else if (isBracelessSyntax) { + val insertAfterLastDef = untypedTree match + case untpd.TypeDef(_, tmpl: untpd.Template) if tmpl.body.nonEmpty => + val lastDef = tmpl.body.last + lastDef.sourcePos.withSpan(Span(lastDef.span.end)) + case _ => + untypedTree.sourcePos.withSpan(Span(untypedTree.span.end)) + + val patchText = "\n" + formattedMethods + + val patch = ActionPatch(insertAfterLastDef, patchText) + List(CodeAction("Add missing methods", None, List(patch))) + } else { + // Class has no body – add whole `{ ... }` after class header, same line + val insertAfterHeader = untypedTree.sourcePos.withSpan(Span(untypedTree.span.end)) + + val patchText = + " {\n" + + formattedMethods + "\n" + + "}" + + val patch = ActionPatch(insertAfterHeader, patchText) + List(CodeAction("Add missing methods", None, List(patch))) + } + } + + } import RefChecks.* diff --git a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala index 5185adfb25fd..98d0fe18fb8b 100644 --- a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala +++ b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala @@ -598,8 +598,14 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context): resType <:< target val tparams = poly.paramRefs val variances = childClass.typeParams.map(_.paramVarianceSign) - val instanceTypes = tparams.lazyZip(variances).map: (tparam, variance) => - TypeComparer.instanceType(tparam, fromBelow = variance < 0, Widen.Unions) + @tailrec def fixInstances(cur: List[Type]): List[Type] = + val next = cur.mapConserve(_.substParams(poly, cur)) + if next eq cur then next else fixInstances(next) + val instanceTypes = { + val types0 = tparams.lazyZip(variances).map: (tparam, variance) => + TypeComparer.instanceType(tparam, fromBelow = variance < 0, Widen.Unions) + fixInstances(types0) + } val instanceType = resType.substParams(poly, instanceTypes) // this is broken in tests/run/i13332intersection.scala, // because type parameters are not correctly inferred. @@ -675,6 +681,12 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context): val synthesizedMirror: SpecialHandler = (formal, span) => orElse(synthesizedProductMirror(formal, span), synthesizedSumMirror(formal, span)) + val synthesizedSpecialized: SpecialHandler = (formal, span) => formal match { + case AppliedType(tycon, arg :: Nil) if tycon =:= defn.SpecializedClass.typeRef => + withNoErrors(TypeApply(ref(defn.SpecializedModule_apply), TypeTree(arg) :: Nil)) + case _ => EmptyTreeNoError + } + private def escapeJavaArray(tp: Type)(using Context): Type = tp match case JavaArrayType(elemTp) => defn.ArrayOf(escapeJavaArray(elemTp)) case _ => tp @@ -802,6 +814,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context): defn.OptManifestClass -> synthesizedOptManifest, defn.SingletonClass -> synthesizedSingleton, defn.PreciseClass -> synthesizedPrecise, + defn.SpecializedClass -> synthesizedSpecialized ) def tryAll(formal: Type, span: Span)(using Context): TreeWithErrors = diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala index 64de9f12e44b..c84ce90e8acc 100644 --- a/compiler/src/dotty/tools/dotc/typer/Typer.scala +++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala @@ -34,21 +34,23 @@ import util.Spans.* import util.chaining.* import util.common.* import util.{Property, SimpleIdentityMap, SrcPos} -import Applications.{wrapDefs, defaultArgument} - +import Applications.{defaultArgument, wrapDefs} import collection.mutable import Implicits.* import util.Stats.record import config.Printers.{gadts, typr} -import config.Feature, Feature.{migrateTo3, modularity, sourceVersion, warnOnMigration} +import config.Feature +import Feature.{migrateTo3, modularity, sourceVersion, warnOnMigration} import config.SourceVersion.* -import rewrites.Rewrites, Rewrites.patch +import rewrites.Rewrites +import Rewrites.patch import staging.StagingLevel import reporting.* import Nullables.* import NullOpsDecorator.* -import cc.{CheckCaptures, isRetainsLike, derivesFromCapSet} +import cc.{Setup, CheckCaptures, isRetainsLike, derivesFromCapSet} import config.MigrationVersion +import dotty.tools.dotc.core.Mode.Interactive import transform.CheckUnused.OriginalName import scala.annotation.{unchecked as _, *} @@ -70,9 +72,9 @@ object Typer { this == Definition || this == NamedImport && prevPrec == WildImport } - /** Assert tree has a position, unless it is empty or a typed splice */ + /** Assert tree has a position, unless it is empty or a typed splice, or we are in interactive mode where some positions are missing */ def assertPositioned(tree: untpd.Tree)(using Context): Unit = - if (!tree.isEmpty && !tree.isInstanceOf[untpd.TypedSplice] && ctx.typerState.isGlobalCommittable) + if !tree.isEmpty && !tree.isInstanceOf[untpd.TypedSplice] && ctx.typerState.isGlobalCommittable && !ctx.mode.is(Interactive) then assert(tree.span.exists, i"position not set for $tree # ${tree.uniqueId} of ${tree.getClass} in ${tree.source}") /** An attachment for GADT constraints that were inferred for a pattern. */ @@ -585,6 +587,21 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer findRefRecur(NoType, BindingPrec.NothingBound, NoContext) } + /** If `ref` is a trackable `TermRef` of an `OrNull` type that flow typing has + * identified as non-null at this point, returns `Some(tpnn)` where `tpnn` is + * the non-null leg. Otherwise returns `None`. + */ + private def nonNullPart(ref: TermRef)(using Context): Option[Type] = + if ctx.explicitNulls + && ctx.notNullInfos.impliesNotNull(ref) + // If a reference is in the context, it is already trackable at the point we add it. + // Hence, we don't use isTracked in the next line, because checking use out of order is enough. + && !ref.usedOutOfOrder + then ref match + case OrNull(tpnn) => Some(tpnn) + case _ => None + else None + /** If `tree`'s type is a `TermRef` identified by flow typing to be non-null, then * cast away `tree`s nullability. Otherwise, `tree` remains unchanged. * @@ -594,18 +611,30 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer */ def toNotNullTermRef(tree: Tree, pt: Type)(using Context): Tree = tree.tpe match case ref: TermRef - if ctx.explicitNulls - && pt != LhsProto // Ensure it is not the lhs of Assign - && ctx.notNullInfos.impliesNotNull(ref) - // If a reference is in the context, it is already trackable at the point we add it. - // Hence, we don't use isTracked in the next line, because checking use out of order is enough. - && !ref.usedOutOfOrder => - ref match - case OrNull(tpnn) => tree.cast(AndType(ref, tpnn)) - case _ => tree + if pt != LhsProto // Ensure it is not the lhs of Assign + && pt != SingletonTypeProto => + nonNullPart(ref) match + case Some(tpnn) => tree.cast(AndType(ref, tpnn)) + case None => tree case _ => tree + /** If `tree` is a singleton type tree whose ref is identified by flow typing to be + * non-null, wrap it in an `&`-typed `AppliedTypeTree` carrying the non-null leg, + * so the resulting type is `ref.type & tpnn`. The inner singleton tree's ref is + * left unintersected, so PostTyper's realizability check on `ref.tpe` (which + * rejects AndTypes containing parameter `TermRef`s as non-concrete) still passes. + */ + def toNotNullSingletonTypeTree(tree: SingletonTypeTree)(using Context): Tree = tree.ref.tpe match + case ref: TermRef => + nonNullPart(ref) match + case Some(tpnn) => + typed( + untpd.makeAndType(untpd.TypedSplice(tree), untpd.TypedSplice(TypeTree(tpnn))) + .withSpan(tree.span)) + case None => tree + case _ => tree + /** Attribute an identifier consisting of a simple name or wildcard * * @param tree The tree representing the identifier. @@ -752,9 +781,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer val sym = tree.tpe.termSymbol if sym.isNoValue && !ctx.isJava then if sym.is(Package) - && Feature.enabled(Feature.packageObjectValues) && tree.tpe.member(nme.PACKAGE).hasAltWith(_.symbol.isPackageObject) then + // The feature is in preview for 3.10 + Feature.checkPreviewFeature("package object values", tree.srcPos) typed(untpd.Select(untpd.TypedSplice(tree), nme.PACKAGE)) else report.error(SymbolIsNotAValue(sym), tree.srcPos) @@ -1162,7 +1192,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer record("typedNumber") val digits = tree.digits val target = pt.dealias - def lit(value: Any) = Literal(Constant(value)).withSpan(tree.span).withAttachmentsFrom(tree) + def lit[T](value: T)(using Constant.ValueToConstant[T]) = + Literal(Constant.fromValue(value)).withSpan(tree.span).withAttachmentsFrom(tree) try { // Special case primitive numeric types if (target.isRef(defn.IntClass) || @@ -2692,7 +2723,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer // Fall through to normal path if widened type is not a TypeRef // (can happen with naming conflicts #25025) checkStable(ref1.tpe, tree.srcPos, "singleton type") - assignType(cpy.SingletonTypeTree(tree)(ref1), ref1) + toNotNullSingletonTypeTree(assignType(cpy.SingletonTypeTree(tree)(ref1), ref1)) def typedRefinedTypeTree(tree: untpd.RefinedTypeTree)(using Context): TypTree = { val tpt1 = if tree.tpt == EmptyTree then TypeTree(defn.ObjectType) else typedAheadType(tree.tpt) @@ -3171,7 +3202,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer val rhsToInline = PrepareInlineable.wrapRHS(ddef, tpt1, rhs1) PrepareInlineable.registerInlineInfo(sym, rhsToInline) - if sym.isConstructor then + if sym.isConstructor then { if sym.is(Inline) then report.error("constructors cannot be `inline`", ddef) @@ -3186,7 +3217,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer do if defn.isContextFunctionType(param.tpt.tpe) then report.error("case class element cannot be a context function", param.srcPos) - else + else { for params <- paramss1; param <- params do checkRefsLegal(param, sym.owner, (name, sym) => sym.is(TypeParam), "secondary constructor") @@ -3199,14 +3230,17 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer && tree.span.exists && !tree.span.isSynthetic then report.error("secondary constructor must call a preceding constructor", app.srcPos) + if Feature.ccEnabled then + Setup.recordParamAliases(sym, app) + case Block(call :: _, expr) => checkThisConstrCall(call) checkThisConstrCall(expr) case _ => checkThisConstrCall(rhs1) - end if - end if + } + } if sym.is(Method) && sym.owner.denot.isRefinementClass then for annot <- sym.paramSymss.flatten.filter(_.isTerm).flatMap(_.getAnnotation(defn.ImplicitNotFoundAnnot)) do @@ -3261,6 +3295,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer report.error(em"`$name` cannot have type parameters, because it ranges over capture sets", rhs.srcPos) case _ => val res = assignType(cpy.TypeDef(tdef)(name, rhs1), sym) + res.ensureHasSym(sym) if Feature.ccEnabled && attachCap then res.putAttachment(CaptureVar, ()) res @@ -3469,7 +3504,16 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer if defn.ScalaValueClasses()(cls) && Feature.shouldBehaveAsScala2 then constr1.symbol.resetFlag(Private) - val self1 = typed(self)(using ctx.outer).asInstanceOf[ValDef] // outer context where class members are not visible + // If original type of self ValDef was a DerivedTypeTree, its type was + // not given explicitly, and the ValDef exists only in order to introduce + // a name alias for `this`. In this case represent the `tpt` of the ValDef + // as an InferredTypeTree. + def tweakSelf(self1: ValDef, orig: untpd.ValDef): ValDef = + if untpd.hasDerivedTree(orig.tpt) + then tpd.cpy.ValDef(self1)(tpt = tpd.cpy.TypeTree(self1.tpt)(inferred = true)) + else self1 + + val self1 = tweakSelf(typed(self)(using ctx.outer).asInstanceOf[ValDef], self) // outer context where class members are not visible if (self1.tpt.tpe.isError || classExistsOnSelf(cls.unforcedDecls, self1)) // fail fast to avoid typing the body with an error type cdef.withType(UnspecifiedErrorType) @@ -3481,6 +3525,29 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer addAccessorDefs(cls, typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1))) + if !ctx.isAfterTyper && cls.isInlineTrait then + body1.map(_.symbol).filter(_.isInlineTrait).foreach(innerInlTrait => + report.error( + em"Implementation restriction: an inline trait cannot be defined inside of another inline trait", + innerInlTrait.srcPos + ) + ) + val membersToInline = body1.filter(member => Inlines.isInlineableFromInlineTrait(cls, member)) + membersToInline.foreach { + case tdef: TypeDef if tdef.symbol.isClass => + def rec(paramss: List[List[Symbol]]): Unit = paramss match { + case (param :: _) :: _ if param.isTerm => + report.error(em"Implementation restriction: inner classes inside inline traits cannot have term parameters", param.srcPos) + case _ :: paramss => + rec(paramss) + case _ => + } + rec(tdef.symbol.primaryConstructor.paramSymss) + case _ => + } + val wrappedMembersToInline = Block(membersToInline, unitLiteral).withSpan(cdef.span) + PrepareInlineable.registerInlineInfo(cls, wrappedMembersToInline) + checkNoDoubleDeclaration(cls) val impl1 = cpy.Template(impl)(constr1, parents1, Nil, self1, body1) .withType(dummy.termRef) @@ -3614,6 +3681,19 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer val packageObjectName = desugar.packageObjectName(ctx.source) val topLevelClassSymbol = pkg.moduleClass.info.decls.lookup(packageObjectName.moduleClassName) topLevelClassSymbol.ensureCompleted() + // When sibling files in this package come from the classpath (TASTy), + // force their `$package` classes now to avoid cross-unit cycles + // as in #25894: otherwise the first lookup on this package (e.g. an + // import qualifier at the top of this file) forces them during the + // import's completer, and their unpickling can chain through source + // exports back to the import itself. + if !pkg.isEffectiveRoot && pkg != defn.EmptyPackageVal then + pkg.moduleClass.denot match + case pcd: SymDenotations.PackageClassDenotation => + for pobj <- pcd.packageObjs do + if pobj.symbol.isDefinedInBinary then + pobj.symbol.ensureCompleted() + case _ => var stats1 = typedStats(tree.stats, pkg.moduleClass)._1 if (!ctx.isAfterTyper) stats1 = stats1 ++ typedBlockStats(MainProxies.proxies(stats1))._1 @@ -4503,7 +4583,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer else val union = tree.sourcePos.withSpan: tree.srcPos.span.union(pt.args.last.srcPos.span) - if union.startLine != union.endLine then union // if multiline, show more context + if union.exists && union.startLine != union.endLine then union // if multiline, show more context else tree.srcPos errorTree(tree, MethodDoesNotTakeParameters(tree), pos) } @@ -4848,13 +4928,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer tree } else TypeComparer.testSubType(tree.tpe.widenExpr, pt) match - case CompareResult.Fail(_) => + case CompareResult.Fail(notes) => wtp match case wtp: MethodType => missingArgs(wtp) case _ => typr.println(i"adapt to subtype ${tree.tpe} !<:< $pt") //typr.println(TypeComparer.explained(tree.tpe <:< pt)) - adaptToSubType(wtp) + adaptToSubType(wtp, notes) case CompareResult.OKwithGADTUsed if pt.isValueType && !inContext(ctx.fresh.setGadtState(GadtState(GadtConstraint.empty))) { @@ -4955,7 +5035,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer case tree: Closure => cpy.Closure(tree)(tpt = TypeTree(samParent)).withType(samParent) } - def adaptToSubType(wtp: Type): Tree = + def adaptToSubType(wtp: Type, cmpNotes: List[Message.Note] = Nil): Tree = // try converting a constant to the target type tree.tpe.widenTermRefExpr.normalized match case ConstantType(x) => @@ -5024,7 +5104,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer else val tree1 = healAdapt(tree, pt) if tree1 ne tree then readapt(tree1) - else err.typeMismatch(tree, pt, failure.notes) + else err.typeMismatch(tree, pt, cmpNotes ++ failure.notes) pt match case _: SelectionProto => diff --git a/compiler/src/dotty/tools/dotc/util/ClasspathFromClassloader.scala b/compiler/src/dotty/tools/dotc/util/ClasspathFromClassloader.scala index 198499f2593e..1b752d0b1b91 100644 --- a/compiler/src/dotty/tools/dotc/util/ClasspathFromClassloader.scala +++ b/compiler/src/dotty/tools/dotc/util/ClasspathFromClassloader.scala @@ -1,7 +1,5 @@ package dotty.tools.dotc.util -import scala.language.unsafeNulls - import java.net.URLClassLoader import java.nio.file.Paths diff --git a/compiler/src/dotty/tools/dotc/util/CommentParsing.scala b/compiler/src/dotty/tools/dotc/util/CommentParsing.scala index 99f8df5f349f..44afdeda7c23 100644 --- a/compiler/src/dotty/tools/dotc/util/CommentParsing.scala +++ b/compiler/src/dotty/tools/dotc/util/CommentParsing.scala @@ -5,8 +5,6 @@ */ package dotty.tools.dotc.util -import scala.language.unsafeNulls - import scala.collection.mutable /** The comment parsing in `dotc` is used by both the comment cooking and the diff --git a/compiler/src/dotty/tools/dotc/util/DiffUtil.scala b/compiler/src/dotty/tools/dotc/util/DiffUtil.scala index 126cff9b9c65..cec5978cc1f6 100644 --- a/compiler/src/dotty/tools/dotc/util/DiffUtil.scala +++ b/compiler/src/dotty/tools/dotc/util/DiffUtil.scala @@ -1,7 +1,5 @@ package dotty.tools.dotc.util -import scala.language.unsafeNulls - import scala.annotation.tailrec import scala.collection.mutable @@ -296,4 +294,3 @@ object DiffUtil { builder ++= alignment } } - diff --git a/compiler/src/dotty/tools/dotc/util/EnumFlags.scala b/compiler/src/dotty/tools/dotc/util/EnumFlags.scala index a833af7632de..9369dd853069 100644 --- a/compiler/src/dotty/tools/dotc/util/EnumFlags.scala +++ b/compiler/src/dotty/tools/dotc/util/EnumFlags.scala @@ -7,7 +7,7 @@ object EnumFlags: object FlagSet: extension [E <: reflect.Enum](set: FlagSet[E]) - def is(flag: E): Boolean = (set & (1 << flag.ordinal)) != 0 + def contains(flag: E): Boolean = (set & (1 << flag.ordinal)) != 0 def |(flag: E): FlagSet[E] = (set | (1 << flag.ordinal)) def empty[E <: reflect.Enum]: FlagSet[E] = diff --git a/compiler/src/dotty/tools/dotc/util/HashMap.scala b/compiler/src/dotty/tools/dotc/util/HashMap.scala index eec3a604b5e2..4e3c78b4b39a 100644 --- a/compiler/src/dotty/tools/dotc/util/HashMap.scala +++ b/compiler/src/dotty/tools/dotc/util/HashMap.scala @@ -1,7 +1,5 @@ package dotty.tools.dotc.util -import scala.language.unsafeNulls - /** A specialized implementation of GenericHashMap with standard hashCode and equals * as comparison */ diff --git a/compiler/src/dotty/tools/dotc/util/SourceFile.scala b/compiler/src/dotty/tools/dotc/util/SourceFile.scala index bc5b26838eae..0a0a31bb36ea 100644 --- a/compiler/src/dotty/tools/dotc/util/SourceFile.scala +++ b/compiler/src/dotty/tools/dotc/util/SourceFile.scala @@ -2,8 +2,6 @@ package dotty.tools package dotc package util -import scala.language.unsafeNulls - import dotty.tools.io.* import Spans.* import core.Contexts.* @@ -88,7 +86,7 @@ object WrappedSourceFile: regex.findFirstMatchIn(text) match case Some(m) => val sourceStartOffset = sourceFile.nextLine(m.start) - val file = ctx.getFile(m.group(1)) + val file = ctx.getFile(m.group(1).nn) if file.exists then HasHeader(sourceStartOffset, ctx.getSource(file)) else @@ -108,7 +106,7 @@ class SourceFile(val file: AbstractFile, computeContent: => Array[Char]) extends * the source is read from Tasty. */ def content(): Array[Char] = { if (myContent == null) myContent = computeContent - myContent + myContent.nn } private var _maybeInComplete: Boolean = false @@ -308,10 +306,10 @@ object SourceFile { /** Return true if file is a script: * if filename extension is not .scala and has a script header. */ - def isScript(file: AbstractFile | Null, content: Array[Char]): Boolean = + def isScript(file: AbstractFile, content: Array[Char]): Boolean = ScriptSourceFile.hasScriptHeader(content) - def apply(file: AbstractFile | Null, codec: Codec): SourceFile = + def apply(file: AbstractFile, codec: Codec): SourceFile = // Files.exists is slow on Java 8 (https://rules.sonarsource.com/java/tag/performance/RSPEC-3725), // so cope with failure. val chars = @@ -324,7 +322,7 @@ object SourceFile { else SourceFile(file, chars) - def apply(file: AbstractFile | Null, computeContent: => Array[Char]): SourceFile = new SourceFile(file, computeContent) + def apply(file: AbstractFile, computeContent: => Array[Char]): SourceFile = new SourceFile(file, computeContent) } @sharable object NoSource extends SourceFile(NoAbstractFile, Array[Char]()) { diff --git a/compiler/src/dotty/tools/dotc/util/SourcePosition.scala b/compiler/src/dotty/tools/dotc/util/SourcePosition.scala index 2c2c017966a3..825751342c4e 100644 --- a/compiler/src/dotty/tools/dotc/util/SourcePosition.scala +++ b/compiler/src/dotty/tools/dotc/util/SourcePosition.scala @@ -85,6 +85,15 @@ extends SrcPos, interfaces.SourcePosition, Showable: override def toString: String = s"${if (source.exists) source.file.toString else "(no source)"}:$span" + /** A textual representation of this position in the format `file:line:column`. + * Terminals in VS Code or IntelliJ IDEA recognize this format and turn it + * into a clickable link that jumps to the referenced location. + * Returns `""` if this position does not exist. + */ + def showLineColumn: String = + if exists then s"$source:${line + 1}:${column + 1}" + else "" + def toText(printer: Printer): Text = printer.toText(this) object SourcePosition: @@ -111,3 +120,4 @@ trait SrcPos: def endPos(using ctx: Context): SourcePosition = sourcePos.endPos def focus(using ctx: Context): SourcePosition = sourcePos.focus def line(using ctx: Context): Int = sourcePos.line + def orElse(other: SrcPos): SrcPos = if span.exists then this else other diff --git a/compiler/src/dotty/tools/dotc/util/Spans.scala b/compiler/src/dotty/tools/dotc/util/Spans.scala index 33346ad6da17..e6180e9f0f90 100644 --- a/compiler/src/dotty/tools/dotc/util/Spans.scala +++ b/compiler/src/dotty/tools/dotc/util/Spans.scala @@ -101,7 +101,7 @@ object Spans { /** Is this a zero-extent span? */ def isZeroExtent: Boolean = exists && start == end - /** A span where all components are shifted by a given `offset` + /** A span where all components are shifted by a given `offset` * relative to this span. */ def shift(offset: Int): Span = diff --git a/compiler/src/dotty/tools/io/AbstractFile.scala b/compiler/src/dotty/tools/io/AbstractFile.scala index 69c4912886d1..321efb9b34a9 100644 --- a/compiler/src/dotty/tools/io/AbstractFile.scala +++ b/compiler/src/dotty/tools/io/AbstractFile.scala @@ -5,8 +5,6 @@ package dotty.tools.io -import scala.language.unsafeNulls - import java.io.{ IOException, InputStream, OutputStream, BufferedOutputStream, ByteArrayOutputStream @@ -23,16 +21,16 @@ import java.nio.file.{FileAlreadyExistsException, Files, Paths} * @version 1.0, 23/03/2004 */ object AbstractFile { - def getFile(path: String): AbstractFile = getFile(File(path)) - def getDirectory(path: String): AbstractFile = getDirectory(Directory(path)) - def getFile(path: JPath): AbstractFile = getFile(File(path)) - def getDirectory(path: JPath): AbstractFile = getDirectory(Directory(path)) + def getFile(path: String): AbstractFile | Null = getFile(File(path)) + def getDirectory(path: String): AbstractFile | Null = getDirectory(Directory(path)) + def getFile(path: JPath): AbstractFile | Null = getFile(File(path)) + def getDirectory(path: JPath): AbstractFile | Null = getDirectory(Directory(path)) /** * If the specified File exists and is a regular file, returns an * abstract regular file backed by it. Otherwise, returns `null`. */ - def getFile(path: Path): AbstractFile = + def getFile(path: Path): AbstractFile | Null = if (path.isFile) new PlainFile(path) else null /** @@ -40,7 +38,7 @@ object AbstractFile { * readable zip or jar archive, returns an abstract directory * backed by it. Otherwise, returns `null`. */ - def getDirectory(path: Path): AbstractFile = + def getDirectory(path: Path): AbstractFile | Null = if (path.isDirectory) new PlainFile(path) else if (path.isFile && Path.isExtensionJarOrZip(path.jpath)) ZipArchive.fromFile(path.toFile) else null @@ -50,7 +48,7 @@ object AbstractFile { * abstract regular file or an abstract directory, respectively, backed by it. * Otherwise, returns `null`. */ - def getURL(url: URL): AbstractFile = + def getURL(url: URL): AbstractFile | Null = if (url.getProtocol != "file") null else new PlainFile(new Path(Paths.get(url.toURI))) @@ -83,7 +81,7 @@ object AbstractFile { * * ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' */ -abstract class AbstractFile extends Iterable[AbstractFile] { +abstract class AbstractFile extends Iterable[AbstractFile] with dotty.tools.dotc.interfaces.AbstractFile { /** Returns the name of this abstract file. */ def name: String @@ -95,7 +93,9 @@ abstract class AbstractFile extends Iterable[AbstractFile] { def absolutePath: String = path /** Returns the path of this abstract file in a canonical form. */ - def canonicalPath: String = if (jpath == null) path else jpath.normalize.toString + def canonicalPath: String = + val jpath = this.jpath + if (jpath == null) path else jpath.normalize.toString /** Checks extension case insensitively. */ @deprecated("prefer queries on ext") @@ -116,12 +116,17 @@ abstract class AbstractFile extends Iterable[AbstractFile] { /** Returns the underlying File if any and null otherwise. */ def file: JFile | Null = try { + val jpath = this.jpath if (jpath == null) null else jpath.toFile } catch { case _: UnsupportedOperationException => null } + /** Adapts `file` to the `dotty.tools.dotc.interfaces.AbstractFile` interface */ + def jfile: java.util.Optional[JFile] = + java.util.Optional.ofNullable(file) + /** Returns the underlying Path if any and null otherwise. */ def jpath: JPath | Null @@ -157,7 +162,9 @@ abstract class AbstractFile extends Iterable[AbstractFile] { /** size of this file if it is a concrete file. */ def sizeOption: Option[Int] = None - def toURL: URL = if (jpath == null) null else jpath.toUri.toURL + def toURL: URL | Null = + val jpath = this.jpath + if (jpath == null) null else jpath.toUri.toURL /** Returns contents of file (if applicable) in a Char array. * warning: use `Global.getSourceFile()` to use the proper @@ -202,7 +209,7 @@ abstract class AbstractFile extends Iterable[AbstractFile] { * Ths target name is the last of parts. */ final def lookupPath(parts: Seq[String], directory: Boolean): AbstractFile | Null = - var file: AbstractFile = this + var file: AbstractFile | Null = this var i = 0 val n = parts.length - 1 while file != null && i < n do @@ -216,7 +223,7 @@ abstract class AbstractFile extends Iterable[AbstractFile] { * `directory` tells whether to look for a directory or * a regular file. */ - def lookupName(name: String, directory: Boolean): AbstractFile + def lookupName(name: String, directory: Boolean): AbstractFile | Null /** Returns an abstract file with the given name. It does not * check that it exists. @@ -263,6 +270,7 @@ abstract class AbstractFile extends Iterable[AbstractFile] { private def fileOrSubdirectoryNamed(name: String, isDir: Boolean): AbstractFile = lookupName(name, isDir) match { case null => + val jpath = this.jpath.nn // the optional exception may be thrown for symlinks, notably /tmp on macOS. // isDirectory tests for existing directory. The default behavior is hypothetical isDirectory(jpath, FOLLOW_LINKS). try Files.createDirectories(jpath) @@ -297,7 +305,7 @@ abstract class AbstractFile extends Iterable[AbstractFile] { } protected def unsupported(): Nothing = unsupported(null) - protected def unsupported(msg: String): Nothing = throw new UnsupportedOperationException(msg) + protected def unsupported(msg: String | Null): Nothing = throw new UnsupportedOperationException(msg) /** Returns the path of this abstract file. */ override def toString(): String = path diff --git a/compiler/src/dotty/tools/io/AbstractFileClassLoader.scala b/compiler/src/dotty/tools/io/AbstractFileClassLoader.scala index 839905cf9bf6..4e09b99b3e61 100644 --- a/compiler/src/dotty/tools/io/AbstractFileClassLoader.scala +++ b/compiler/src/dotty/tools/io/AbstractFileClassLoader.scala @@ -13,8 +13,6 @@ package dotty.tools package io -import scala.language.unsafeNulls - import dotty.tools.io.AbstractFile import java.net.{URL, URLConnection, URLStreamHandler} @@ -41,19 +39,20 @@ class AbstractFileClassLoader(val root: AbstractFile, parent: ClassLoader) exten case url => Collections.enumeration(Collections.singleton(url)) override def findClass(name: String): Class[?] = { - var file: AbstractFile | Null = root + var file: AbstractFile = root val pathParts = name.split("[./]").toList for (dirPart <- pathParts.init) { - file = file.lookupName(dirPart, true) - if (file == null) { + val subFile = file.lookupName(dirPart, true) + if (subFile == null) { throw new ClassNotFoundException(name) } + file = subFile } - file = file.lookupName(pathParts.last+".class", false) - if (file == null) { + val lastFile = file.lookupName(pathParts.last+".class", false) + if (lastFile == null) { throw new ClassNotFoundException(name) } - val bytes = file.toByteArray + val bytes = lastFile.toByteArray defineClass(name, bytes, 0, bytes.length) } diff --git a/compiler/src/dotty/tools/io/ClassPath.scala b/compiler/src/dotty/tools/io/ClassPath.scala index 38390d998bc9..df18fa958b74 100644 --- a/compiler/src/dotty/tools/io/ClassPath.scala +++ b/compiler/src/dotty/tools/io/ClassPath.scala @@ -7,8 +7,6 @@ package dotty.tools package io -import scala.language.unsafeNulls - import java.net.{MalformedURLException, URI, URISyntaxException, URL} import java.util.regex.PatternSyntaxException diff --git a/compiler/src/dotty/tools/io/Directory.scala b/compiler/src/dotty/tools/io/Directory.scala index 7c2067390a09..5a4a93d1c045 100644 --- a/compiler/src/dotty/tools/io/Directory.scala +++ b/compiler/src/dotty/tools/io/Directory.scala @@ -8,8 +8,6 @@ package dotty.tools.io -import scala.language.unsafeNulls - import java.nio.file.{Files, Paths} diff --git a/compiler/src/dotty/tools/io/File.scala b/compiler/src/dotty/tools/io/File.scala index a761e0956a0a..ee12516107fc 100644 --- a/compiler/src/dotty/tools/io/File.scala +++ b/compiler/src/dotty/tools/io/File.scala @@ -35,8 +35,7 @@ object File { * * ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' */ -class File(jpath: JPath)(implicit constructorCodec: Codec) extends Path(jpath) with Streamable.Chars { - override val creationCodec: io.Codec = constructorCodec +class File(jpath: JPath)(implicit constructorCodec: Codec) extends Path(jpath) { override def toAbsolute: File = if (isAbsolute) this else super.toAbsolute.toFile override def toDirectory: Directory = new Directory(jpath) override def toFile: File = this @@ -64,7 +63,7 @@ class File(jpath: JPath)(implicit constructorCodec: Codec) extends Path(jpath) w /** Wraps a BufferedWriter around the result of writer(). */ def bufferedWriter(): BufferedWriter = bufferedWriter(append = false) - def bufferedWriter(append: Boolean): BufferedWriter = bufferedWriter(append, creationCodec) + def bufferedWriter(append: Boolean): BufferedWriter = bufferedWriter(append, constructorCodec) def bufferedWriter(append: Boolean, codec: Codec): BufferedWriter = new BufferedWriter(writer(append, codec)) @@ -90,10 +89,6 @@ class File(jpath: JPath)(implicit constructorCodec: Codec) extends Path(jpath) w finally out.close() } - def safeSlurp(): Option[String] = - try Some(slurp()) - catch { case _: IOException => None } - /** Reflection since we're into the java 6+ API. */ def setExecutable(executable: Boolean, ownerOnly: Boolean = true): Boolean = { diff --git a/compiler/src/dotty/tools/io/FileExtension.scala b/compiler/src/dotty/tools/io/FileExtension.scala index 3aeef5b902ce..24ad5d9c6b44 100644 --- a/compiler/src/dotty/tools/io/FileExtension.scala +++ b/compiler/src/dotty/tools/io/FileExtension.scala @@ -40,17 +40,14 @@ enum FileExtension(val toLowerCase: String): /** represents `".zip"` */ def isZip: Boolean = this == Zip /** represents `".jar"` or `".zip"` */ - def isJarOrZip: Boolean = FileExtension.JarOrZip.is(this) + def isJarOrZip: Boolean = FileExtension.JarOrZip.contains(this) /** represents `".scala"` or `".java"` */ - def isScalaOrJava: Boolean = FileExtension.ScalaOrJava.is(this) - /** represents `".java"` or `.tasty` */ - def isJavaOrTasty: Boolean = FileExtension.JavaOrTasty.is(this) + def isSourceExtension: Boolean = FileExtension.SourceExtension.contains(this) object FileExtension: private val JarOrZip: FlagSet[FileExtension] = FlagSet.empty | Zip | Jar - private val ScalaOrJava: FlagSet[FileExtension] = FlagSet.empty | Scala | Java - private val JavaOrTasty: FlagSet[FileExtension] = FlagSet.empty | Java | Tasty + private val SourceExtension: FlagSet[FileExtension] = FlagSet.empty | Scala | Java // this will be optimised to a single hashcode + equality check, and then fallback to slowLookup, // keep in sync with slowLookup. diff --git a/compiler/src/dotty/tools/io/FileWriters.scala b/compiler/src/dotty/tools/io/FileWriters.scala index c34ce799703a..84a86aa233d3 100644 --- a/compiler/src/dotty/tools/io/FileWriters.scala +++ b/compiler/src/dotty/tools/io/FileWriters.scala @@ -1,7 +1,5 @@ package dotty.tools.io -import scala.language.unsafeNulls - import dotty.tools.io.AbstractFile import dotty.tools.io.JarArchive import dotty.tools.io.PlainFile @@ -13,10 +11,7 @@ import java.io.IOException import java.nio.ByteBuffer import java.nio.channels.ClosedByInterruptException import java.nio.channels.FileChannel -import java.nio.file.FileAlreadyExistsException -import java.nio.file.Files -import java.nio.file.Path -import java.nio.file.StandardOpenOption +import java.nio.file.{FileAlreadyExistsException, Files, Path, Paths, StandardOpenOption} import java.nio.file.attribute.FileAttribute import java.util import java.util.concurrent.ConcurrentHashMap @@ -25,12 +20,9 @@ import java.util.zip.Deflater import java.util.zip.ZipEntry import java.util.zip.ZipOutputStream import scala.collection.mutable - -import dotty.tools.dotc.core.Contexts, Contexts.Context +import dotty.tools.dotc.core.Contexts.* import dotty.tools.dotc.core.Decorators.em - -import dotty.tools.dotc.util.{SourcePosition, NoSourcePosition} - +import dotty.tools.dotc.util.{NoSourcePosition, SourcePosition} import dotty.tools.dotc.reporting.Message import dotty.tools.dotc.report @@ -40,8 +32,8 @@ import java.util.concurrent.atomic.AtomicBoolean import java.util.ConcurrentModificationException object FileWriters { - type InternalName = String - type NullableFile = AbstractFile | Null + private def classRelativePath(className: String, suffix: String): String = + className.replace('.', '/') + suffix inline def ctx(using ReadOnlyContext): ReadOnlyContext = summon[ReadOnlyContext] @@ -143,7 +135,7 @@ object FileWriters { val debug = ctx.settings.Ydebug.value def readRun(using ctx: Context): ReadOnlyRun = new: - val suspendedAtTyperPhase = ctx.run.suspendedAtTyperPhase + val suspendedAtTyperPhase = ctx.run.nn.suspendedAtTyperPhase def buffered(using Context): BufferedReadOnlyContext = new: val settings = readSettings @@ -159,7 +151,7 @@ object FileWriters { * The interface to writing classfiles. GeneratedClassHandler calls these methods to generate the * directory and files that are created, and eventually calls `close` when the writing is complete. * - * The companion object is responsible for constructing a appropriate and optimal implementation for + * The companion object is responsible for constructing an appropriate and optimal implementation for * the supplied settings. * * Operations are threadsafe. @@ -170,43 +162,97 @@ object FileWriters { * * @param name the internal name of the class, e.g. "scala.Option" */ - def writeTasty(name: InternalName, bytes: Array[Byte])(using ReadOnlyContext): NullableFile + def writeTasty(name: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile /** * Close the writer. Behavior is undefined after a call to `close`. */ def close(): Unit - - protected def classToRelativePath(className: InternalName): String = - className.replace('.', '/') + ".tasty" } object TastyWriter { - def apply(output: AbstractFile)(using ReadOnlyContext): TastyWriter = { - - // In Scala 2 depenening on cardinality of distinct output dirs MultiClassWriter could have been used + def apply(output: AbstractFile)(using ReadOnlyContext): TastyWriter = + // In Scala 2 depending on cardinality of distinct output dirs MultiClassWriter could have been used // In Dotty we always use single output directory - val basicTastyWriter = new SingleTastyWriter( - FileWriter(output, None) - ) + new SingleTastyWriter(FileWriter(output, None)) - basicTastyWriter + private final class SingleTastyWriter(underlying: FileWriter) extends TastyWriter { + + override def writeTasty(className: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile = { + underlying.writeFile(classRelativePath(className, ".tasty"), bytes) + } + + override def close(): Unit = underlying.close() } - private final class SingleTastyWriter(underlying: FileWriter) extends TastyWriter { + } + - override def writeTasty(className: InternalName, bytes: Array[Byte])(using ReadOnlyContext): NullableFile = { - underlying.writeFile(classToRelativePath(className), bytes) + /** + * The interface to writing classfiles. GeneratedClassHandler calls these methods to generate the + * directory and files that are created, and eventually calls `close` when the writing is complete. + * + * The companion object is responsible for constructing an appropriate and optimal implementation for + * the supplied settings. + * + * Operations are threadsafe. + */ + sealed trait ClassfileWriter extends TastyWriter { + /** + * Write a classfile + */ + def writeClass(name: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile + + /** + * Close the writer. Behavior is undefined after a call to `close`. + */ + def close(): Unit + } + + object ClassfileWriter { + def apply(output: AbstractFile, jarManifestMainClass: Option[String], dumpClassesPath: Option[AbstractFile])(using ReadOnlyContext): ClassfileWriter = { + // In Scala 2 depending on cardinality of distinct output dirs MultiClassWriter could have been used + // In Dotty we always use single output directory + val basicClassWriter = new SingleClassWriter(FileWriter(output, jarManifestMainClass)) + dumpClassesPath match + case None => basicClassWriter + case Some(out) => new DebugClassWriter(basicClassWriter, FileWriter(out, None)) + } + + private final class SingleClassWriter(underlying: FileWriter) extends ClassfileWriter { + override def writeClass(className: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile = { + underlying.writeFile(classRelativePath(className, ".class"), bytes) + } + + override def writeTasty(className: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile = { + underlying.writeFile(classRelativePath(className, ".tasty"), bytes) } override def close(): Unit = underlying.close() } + private final class DebugClassWriter(basic: ClassfileWriter, dump: FileWriter) extends ClassfileWriter { + override def writeClass(className: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile = { + val outFile = basic.writeClass(className, bytes) + dump.writeFile(classRelativePath(className, ".class"), bytes) + outFile + } + + override def writeTasty(className: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile = { + basic.writeTasty(className, bytes) + } + + override def close(): Unit = { + basic.close() + dump.close() + } + } } + sealed trait FileWriter { - def writeFile(relativePath: String, bytes: Array[Byte])(using ReadOnlyContext): NullableFile + def writeFile(relativePath: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile def close(): Unit } @@ -223,7 +269,7 @@ object FileWriters { new JarEntryWriter(jarFile, jarManifestMainClass, jarCompressionLevel) } else if (file.isVirtual) new VirtualFileWriter(file) - else if (file.isDirectory) new DirEntryWriter(file.file.toPath) + else if (file.isDirectory) new DirEntryWriter(file.file.nn.toPath) else throw new IllegalStateException(s"don't know how to handle an output of $file [${file.getClass}]") } @@ -250,7 +296,7 @@ object FileWriters { lazy val crc = new CRC32 - override def writeFile(relativePath: String, bytes: Array[Byte])(using ReadOnlyContext): NullableFile = this.synchronized { + override def writeFile(relativePath: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile = this.synchronized { val entry = new ZipEntry(relativePath) if (storeOnly) { // When using compression method `STORED`, the ZIP spec requires the CRC and compressed/ @@ -267,7 +313,13 @@ object FileWriters { jarWriter.putNextEntry(entry) try jarWriter.write(bytes, 0, bytes.length) finally jarWriter.flush() - null + // important detail here, even on Windows, Zinc expects the separator within the jar + // to be the system default, (even if in the actual jar file the entry always uses '/'). + // see https://github.com/sbt/zinc/blob/dcddc1f9cfe542d738582c43f4840e17c053ce81/internal/compiler-bridge/src/main/scala/xsbt/JarUtils.scala#L47 + val pathInJar = + if java.io.File.separatorChar == '/' then relativePath + else relativePath.replace('/', java.io.File.separatorChar) + PlainFile.toPlainFile(Paths.get(s"${file.absolutePath}!$pathInJar")) } override def close(): Unit = this.synchronized(jarWriter.close()) @@ -307,15 +359,15 @@ object FileWriters { checkName(filePath.getFileName()) } - // the common case is that we are are creating a new file, and on MS Windows the create and truncate is expensive + // the common case is that we are creating a new file, and on MS Windows the create and truncate is expensive // because there is not an options in the windows API that corresponds to this so the truncate is applied as a separate call // even if the file is new. - // as this is rare, its best to always try to create a new file, and it that fails, then open with truncate if that fails + // as this is rare, it's best to always try to create a new file, and it that fails, then open with truncate if that fails private val fastOpenOptions = util.EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE) private val fallbackOpenOptions = util.EnumSet.of(StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING) - override def writeFile(relativePath: String, bytes: Array[Byte])(using ReadOnlyContext): NullableFile = { + override def writeFile(relativePath: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile = { val path = base.resolve(relativePath) try { ensureDirForPath(base, path) @@ -329,8 +381,8 @@ object FileWriters { try os.write(ByteBuffer.wrap(bytes), 0L) catch { case ex: ClosedByInterruptException => - try Files.deleteIfExists(path) // don't leave a empty of half-written classfile around after an interrupt - catch { case _: Throwable => () } + try Files.deleteIfExists(path) // don't leave an empty of half-written classfile around after an interrupt + catch { case _: java.io.IOException => () } throw ex } os.close() @@ -341,7 +393,7 @@ object FileWriters { if (ctx.settings.debug) e.printStackTrace() ctx.reporter.error(em"error writing ${path.toString}: ${e.getClass.getName} ${e.getMessage}") } - AbstractFile.getFile(path) + AbstractFile.getFile(path).nn // we just wrote to it so it better still exist } override def close(): Unit = () @@ -365,7 +417,7 @@ object FileWriters { finally out.close() } - override def writeFile(relativePath: String, bytes: Array[Byte])(using ReadOnlyContext):NullableFile = { + override def writeFile(relativePath: String, bytes: Array[Byte])(using ReadOnlyContext): AbstractFile = { val outFile = getFile(base, relativePath) writeBytes(outFile, bytes) outFile @@ -374,5 +426,5 @@ object FileWriters { } /** Can't output a file due to the state of the file system. */ - class FileConflictException(msg: String, cause: Throwable = null) extends IOException(msg, cause) + class FileConflictException(msg: String, cause: Throwable | Null = null) extends IOException(msg, cause) } diff --git a/compiler/src/dotty/tools/io/Jar.scala b/compiler/src/dotty/tools/io/Jar.scala index c324da7a2a98..2991f87f3ab1 100644 --- a/compiler/src/dotty/tools/io/Jar.scala +++ b/compiler/src/dotty/tools/io/Jar.scala @@ -7,8 +7,6 @@ package dotty.tools package io -import scala.language.unsafeNulls - import java.io.{ InputStream, OutputStream, DataOutputStream } import java.util.jar.* import scala.jdk.CollectionConverters.* @@ -47,7 +45,7 @@ class Jar(file: File) { lazy val jarFile: JarFile = new JarFile(file.jpath.toFile) lazy val manifest: Option[Manifest] = withJarInput(s => Option(s.getManifest)) - def mainClass: Option[String] = manifest.map(_(Name.MAIN_CLASS)) + def mainClass: Option[String] = manifest.flatMap(_.attrs.get(Name.MAIN_CLASS)) /** The manifest-defined classpath String if available. */ def classPathString: Option[String] = for (m <- manifest ; cp <- m.attrs.get(Name.CLASS_PATH) if !cp.trim().isEmpty()) yield cp @@ -69,7 +67,7 @@ class Jar(file: File) { Iterator.continually(in.getNextJarEntry()).takeWhile(_ != null).toList } - def getEntryStream(entry: JarEntry): java.io.InputStream = jarFile.getInputStream(entry) match + def getEntryStream(entry: JarEntry): java.io.InputStream | Null = jarFile.getInputStream(entry) match case null => errorFn("No such entry: " + entry) ; null case x => x @@ -137,7 +135,7 @@ object Jar { this(k) = v def underlying: JManifest = manifest - def attrs: mutable.Map[Name, String] = manifest.getMainAttributes().asInstanceOf[AttributeMap].asScala withDefaultValue null + def attrs: mutable.Map[Name, String] = manifest.getMainAttributes().asInstanceOf[AttributeMap].asScala def initialMainAttrs: Map[Attributes.Name, String] = { import scala.util.Properties.* Map( @@ -146,19 +144,26 @@ object Jar { ) } - def apply(name: Attributes.Name): String = attrs(name) - def apply(name: String): String = apply(new Attributes.Name(name)) + def apply(name: Attributes.Name): String | Null = attrs.getOrElse(name, null) + def apply(name: String): String | Null = apply(new Attributes.Name(name)) def update(key: Attributes.Name, value: String): Option[String] = attrs.put(key, value) def update(key: String, value: String): Option[String] = attrs.put(new Attributes.Name(key), value) - def mainClass: String = apply(Name.MAIN_CLASS) + def mainClass: String | Null = apply(Name.MAIN_CLASS) def mainClass_=(value: String): Option[String] = update(Name.MAIN_CLASS, value) } // See http://download.java.net/jdk7/docs/api/java/nio/file/Path.html // for some ideas. private val ZipMagicNumber = List[Byte](80, 75, 3, 4) - private def magicNumberIsZip(f: Path) = f.isFile && (f.toFile.bytes().take(4).toList == ZipMagicNumber) + private def magicNumberIsZip(f: Path) = f.isFile && { + val in = f.toFile.inputStream() + try + val first4 = in.readNBytes(4) + first4.toList == ZipMagicNumber + finally + in.close() + } def isJarOrZip(f: Path): Boolean = isJarOrZip(f, true) def isJarOrZip(f: Path, examineFile: Boolean): Boolean = diff --git a/compiler/src/dotty/tools/io/JarArchive.scala b/compiler/src/dotty/tools/io/JarArchive.scala index c396699f93b3..3397526098e9 100644 --- a/compiler/src/dotty/tools/io/JarArchive.scala +++ b/compiler/src/dotty/tools/io/JarArchive.scala @@ -1,7 +1,5 @@ package dotty.tools.io -import scala.language.unsafeNulls - import java.nio.file.{FileSystemAlreadyExistsException, FileSystems} import scala.jdk.CollectionConverters.* diff --git a/compiler/src/dotty/tools/io/NoAbstractFile.scala b/compiler/src/dotty/tools/io/NoAbstractFile.scala index bef045e290a5..2bf9397edefe 100644 --- a/compiler/src/dotty/tools/io/NoAbstractFile.scala +++ b/compiler/src/dotty/tools/io/NoAbstractFile.scala @@ -5,8 +5,6 @@ package dotty.tools.io -import scala.language.unsafeNulls - import java.io.InputStream /** A distinguished object so you can avoid both null @@ -17,16 +15,19 @@ import java.io.InputStream object NoAbstractFile extends AbstractFile { def absolute: AbstractFile = this def container: AbstractFile = this - def jpath: JPath = null - def input: InputStream = null + def jpath: JPath | Null = null + def input: InputStream = throw UnsupportedOperationException("NoAbstractFile.input") def isDirectory: Boolean = false override def isVirtual: Boolean = true def iterator: Iterator[AbstractFile] = Iterator.empty def lastModified: Long = 0L - def lookupName(name: String, directory: Boolean): AbstractFile = null - def lookupNameUnchecked(name: String, directory: Boolean): AbstractFile = null + def lookupName(name: String, directory: Boolean): AbstractFile | Null = null + + def lookupNameUnchecked(name: String, directory: Boolean): AbstractFile = + throw UnsupportedOperationException("NoAbstractFile.lookupNameUnchecked") + def name: String = "" - def output: java.io.OutputStream = null + def output: java.io.OutputStream = throw UnsupportedOperationException("NoAbstractFile.output") def path: String = "" override def toByteArray: Array[Byte] = Array[Byte]() override def toString: String = "" diff --git a/compiler/src/dotty/tools/io/Path.scala b/compiler/src/dotty/tools/io/Path.scala index 93e54069f421..ee5b2cd82b05 100644 --- a/compiler/src/dotty/tools/io/Path.scala +++ b/compiler/src/dotty/tools/io/Path.scala @@ -210,7 +210,7 @@ class Path private[io] (val jpath: JPath) { // deletions def delete(): Unit = - try { Files.deleteIfExists(jpath) } catch { case _: DirectoryNotEmptyException => } + try { Files.deleteIfExists(jpath) } catch { case _: java.io.IOException => } /** Deletes the path recursively. Returns false on failure. * Use with caution! diff --git a/compiler/src/dotty/tools/io/PlainFile.scala b/compiler/src/dotty/tools/io/PlainFile.scala index ff637c913cd8..9cf868cc19fd 100644 --- a/compiler/src/dotty/tools/io/PlainFile.scala +++ b/compiler/src/dotty/tools/io/PlainFile.scala @@ -6,8 +6,6 @@ package dotty.tools package io -import scala.language.unsafeNulls - import java.io.{InputStream, OutputStream} import java.nio.file.{InvalidPathException, Paths} @@ -99,7 +97,7 @@ class PlainFile(val givenPath: Path) extends AbstractFile { * argument "directory" tells whether to look for a directory or * or a regular file. */ - def lookupName(name: String, directory: Boolean): AbstractFile = { + def lookupName(name: String, directory: Boolean): AbstractFile | Null = { val child = givenPath / name if directory then if child.isDirectory /* IO! */ then diff --git a/compiler/src/dotty/tools/io/Streamable.scala b/compiler/src/dotty/tools/io/Streamable.scala deleted file mode 100644 index 2980cf2f2196..000000000000 --- a/compiler/src/dotty/tools/io/Streamable.scala +++ /dev/null @@ -1,138 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2013 LAMP/EPFL - * @author Paul Phillips - */ - -package dotty.tools.io - - -import java.net.URL -import java.io.{ BufferedInputStream, InputStream } -import java.io.{ BufferedReader, InputStreamReader, Closeable => JCloseable } -import scala.io.{ Codec, BufferedSource, Source } -import scala.collection.mutable.ArrayBuffer -import Path.fail - -/** Traits for objects which can be represented as Streams. - * - * @author Paul Phillips - * @since 2.8 - * - * ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' - */ -object Streamable { - /** Traits which can be viewed as a sequence of bytes. Source types - * which know their length should override def length: Long for more - * efficient method implementations. - * - * ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' - * - * Note that this code was not written with resource management in mind. - * Several methods (such as `chars` and `lines`) create InputStreams they - * don't close - */ - trait Bytes { - def inputStream(): InputStream - def length: Long = -1 - - def bufferedInput(): BufferedInputStream = new BufferedInputStream(inputStream()) - def bytes(): Iterator[Byte] = bytesAsInts() map (_.toByte) - def bytesAsInts(): Iterator[Int] = { - val in = bufferedInput() - Iterator continually in.read() takeWhile (_ != -1) - } - - /** This method aspires to be the fastest way to read - * a stream of known length into memory. - */ - def toByteArray(): Array[Byte] = { - // if we don't know the length, fall back on relative inefficiency - if (length == -1L) - return (new ArrayBuffer[Byte]() ++= bytes()).toArray - - val arr = new Array[Byte](length.toInt) - val len = arr.length - lazy val in = bufferedInput() - var offset = 0 - - def loop(): Unit = { - if (offset < len) { - val read = in.read(arr, offset, len - offset) - if (read >= 0) { - offset += read - loop() - } - } - } - try loop() - finally in.close() - - if (offset == arr.length) arr - else fail("Could not read entire source (%d of %d bytes)".format(offset, len)) - } - } - - /** For objects which can be viewed as Chars. - * - * ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' - */ - trait Chars extends Bytes { - /** Calls to methods requiring byte<->char transformations should be offered - * in a form which allows specifying the codec. When it is not specified, - * the one discovered at creation time will be used, which will always find the - * one in scala.io.Codec if no other is available. This can be overridden - * to use a different default. - */ - def creationCodec: Codec = implicitly[Codec] - - /** Caller is responsible for closing the returned BufferedSource. */ - def chars(codec: Codec): BufferedSource = Source.fromInputStream(inputStream())(using codec) - - /** Beware! Leaks an InputStream which will not be closed until it gets finalized. */ - def lines(): Iterator[String] = lines(creationCodec) - - /** Beware! Leaks an InputStream which will not be closed until it gets finalized. */ - def lines(codec: Codec): Iterator[String] = chars(codec).getLines() - - /** Obtains an InputStreamReader wrapped around a FileInputStream. - */ - def reader(codec: Codec): InputStreamReader = new InputStreamReader(inputStream(), codec.charSet) - - /** Wraps a BufferedReader around the result of reader(). - */ - def bufferedReader(): BufferedReader = bufferedReader(creationCodec) - def bufferedReader(codec: Codec): BufferedReader = new BufferedReader(reader(codec)) - - /** Creates a BufferedReader and applies the closure, automatically closing it on completion. - */ - def applyReader[T](f: BufferedReader => T): T = { - val in = bufferedReader() - try f(in) - finally in.close() - } - - /** Convenience function to import entire file into a String. - */ - def slurp(): String = slurp(creationCodec) - def slurp(codec: Codec): String = { - val src = chars(codec) - try src.mkString finally src.close() // Always Be Closing - } - } - - /** Call a function on something Closeable, finally closing it. */ - def closing[T <: JCloseable, U](stream: T)(f: T => U): U = - try f(stream) - finally stream.close() - - def bytes(is: => InputStream): Array[Byte] = - new Bytes { - def inputStream() = is - }.toByteArray() - - def slurp(is: => InputStream)(implicit codec: Codec): String = - new Chars { def inputStream() = is }.slurp(codec) - - def slurp(url: URL)(implicit codec: Codec): String = - slurp(url.openStream()) -} diff --git a/compiler/src/dotty/tools/io/VirtualDirectory.scala b/compiler/src/dotty/tools/io/VirtualDirectory.scala index 28c4bc308cae..d1359af9522b 100644 --- a/compiler/src/dotty/tools/io/VirtualDirectory.scala +++ b/compiler/src/dotty/tools/io/VirtualDirectory.scala @@ -4,8 +4,6 @@ package dotty.tools.io -import scala.language.unsafeNulls - import scala.collection.mutable import java.io.{InputStream, OutputStream} /** @@ -30,7 +28,7 @@ extends AbstractFile { override def isVirtual: Boolean = true val lastModified: Long = System.currentTimeMillis - override def jpath: JPath = null + override def jpath: JPath | Null = null override def input: InputStream = sys.error("directories cannot be read") override def output: OutputStream = sys.error("directories cannot be written") @@ -45,7 +43,7 @@ extends AbstractFile { // modified while its elements are iterated def iterator: Iterator[AbstractFile] = files.values.toList.iterator - override def lookupName(name: String, directory: Boolean): AbstractFile = + override def lookupName(name: String, directory: Boolean): AbstractFile | Null = (files get name filter (_.isDirectory == directory)).orNull override def fileNamed(name: String): AbstractFile = diff --git a/compiler/src/dotty/tools/io/VirtualFile.scala b/compiler/src/dotty/tools/io/VirtualFile.scala index 93788990d368..282e8819595c 100644 --- a/compiler/src/dotty/tools/io/VirtualFile.scala +++ b/compiler/src/dotty/tools/io/VirtualFile.scala @@ -5,8 +5,6 @@ package dotty.tools.io -import scala.language.unsafeNulls - import java.io.{ ByteArrayInputStream, ByteArrayOutputStream, InputStream, OutputStream } /** This class implements an in-memory file. @@ -56,12 +54,12 @@ class VirtualFile(val name: String, override val path: String) extends AbstractF private var content = Array.emptyByteArray - private var jpath_ : JPath = null + private var jpath_ : JPath | Null = null def absolute: AbstractFile = this /** Returns path, which might be a non-existing file or null. */ - def jpath: JPath = jpath_ + def jpath: JPath | Null = jpath_ override def sizeOption: Option[Int] = Some(content.length) @@ -107,7 +105,7 @@ class VirtualFile(val name: String, override val path: String) extends AbstractF * argument "directory" tells whether to look for a directory or * or a regular file. */ - def lookupName(name: String, directory: Boolean): AbstractFile = { + def lookupName(name: String, directory: Boolean): AbstractFile | Null = { assert(isDirectory, "not a directory '" + this + "'") null } diff --git a/compiler/src/dotty/tools/io/ZipArchive.scala b/compiler/src/dotty/tools/io/ZipArchive.scala index 5e6aa10f6638..106017f850bf 100644 --- a/compiler/src/dotty/tools/io/ZipArchive.scala +++ b/compiler/src/dotty/tools/io/ZipArchive.scala @@ -5,8 +5,6 @@ package dotty.tools.io -import scala.language.unsafeNulls - import java.net.URL import java.io.{ IOException, InputStream, OutputStream, FilterInputStream } import java.nio.file.Files @@ -54,7 +52,7 @@ object ZipArchive { } import ZipArchive.* /** ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' */ -abstract class ZipArchive(override val jpath: JPath, release: Option[String]) extends AbstractFile with Equals { +abstract class ZipArchive(override val jpath: JPath | Null, release: Option[String]) extends AbstractFile with Equals { self => override def underlyingSource: Option[ZipArchive] = Some(this) @@ -66,21 +64,21 @@ abstract class ZipArchive(override val jpath: JPath, release: Option[String]) ex def absolute: AbstractFile = unsupported() /** ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' */ - sealed abstract class Entry(path: String, val parent: Entry) extends VirtualFile(baseName(path), path) { + sealed abstract class Entry(path: String, val parent: Entry | Null) extends VirtualFile(baseName(path), path) { // have to keep this name for compat with sbt's compiler-interface - def getArchive: ZipFile = null + def getArchive: ZipFile | Null = null override def underlyingSource: Option[ZipArchive] = Some(self) - override def container: Entry = parent + override def container: AbstractFile = if parent == null then NoAbstractFile else parent override def toString: String = self.path + "(" + path + ")" } /** ''Note: This library is considered experimental and should not be used unless you know what you are doing.'' */ - class DirEntry(path: String, parent: Entry) extends Entry(path, parent) { + class DirEntry(path: String, parent: Entry | Null) extends Entry(path, parent) { val entries: mutable.HashMap[String, Entry] = mutable.HashMap() override def isDirectory: Boolean = true override def iterator: Iterator[Entry] = entries.valuesIterator - override def lookupName(name: String, directory: Boolean): Entry = { + override def lookupName(name: String, directory: Boolean): Entry | Null = { if (directory) entries.get(name + "/").orNull else entries.get(name).orNull } @@ -116,13 +114,13 @@ abstract class ZipArchive(override val jpath: JPath, release: Option[String]) ex final class FileZipArchive(jpath: JPath, release: Option[String]) extends ZipArchive(jpath, release) { private def openZipFile(): ZipFile = try { release match { - case Some(r) if file.getName.endsWith(".jar") => + case Some(r) if file.nn.getName.endsWith(".jar") => new JarFile(file, true, ZipFile.OPEN_READ, Runtime.Version.parse(r)) case _ => new ZipFile(file) } } catch { - case ioe: IOException => throw new IOException("Error accessing " + file.getPath, ioe) + case ioe: IOException => throw new IOException("Error accessing " + file.nn.getPath, ioe) } private class LazyEntry( @@ -157,7 +155,7 @@ final class FileZipArchive(jpath: JPath, release: Option[String]) extends ZipArc override def sizeOption: Option[Int] = Some(zipEntry.getSize.toInt) } - lazy val (root, allDirs): (DirEntry, collection.Map[String, DirEntry]) = { + lazy val (root: DirEntry, allDirs: collection.Map[String, DirEntry]) = { val root = new DirEntry("/", null) val dirs = mutable.HashMap[String, DirEntry]("/" -> root) val zipFile = openZipFile() @@ -207,8 +205,11 @@ final class FileZipArchive(jpath: JPath, release: Option[String]) extends ZipArc override def canEqual(other: Any): Boolean = other.isInstanceOf[FileZipArchive] override def hashCode(): Int = jpath.hashCode override def equals(that: Any): Boolean = that match { - case x: FileZipArchive => jpath.toAbsolutePath == x.jpath.toAbsolutePath - case _ => false + case x: FileZipArchive => + val xJPath = x.jpath + xJPath != null && jpath.toAbsolutePath == xJPath.toAbsolutePath + case _ => + false } private var closeables: List[java.io.Closeable] = Nil diff --git a/compiler/src/dotty/tools/scripting/ScriptingDriver.scala b/compiler/src/dotty/tools/scripting/ScriptingDriver.scala index 3750d0fdff9f..203326c66873 100755 --- a/compiler/src/dotty/tools/scripting/ScriptingDriver.scala +++ b/compiler/src/dotty/tools/scripting/ScriptingDriver.scala @@ -1,7 +1,5 @@ package dotty.tools.scripting -import scala.language.unsafeNulls - import java.nio.file.{ Files, Paths, Path } import java.io.File @@ -11,7 +9,7 @@ import dotty.tools.io.{ PlainDirectory, Directory, ClassPath } import Util.* class ScriptingDriver(compilerArgs: Array[String], scriptFile: File, scriptArgs: Array[String]) extends Driver: - def compileAndRun(pack:(Path, Seq[Path], String) => Boolean = null): Option[Throwable] = + def compileAndRun(pack: ((Path, Seq[Path], String) => Boolean) | Null = null): Option[Throwable] = val outDir = Files.createTempDirectory("scala3-scripting") outDir.toFile.deleteOnExit() setup(compilerArgs :+ scriptFile.getAbsolutePath, initCtx.fresh) match diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala index 908c50c45d16..0bc9f14c284d 100644 --- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala +++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala @@ -1,8 +1,6 @@ package scala.quoted package runtime.impl -import scala.language.unsafeNulls - import dotty.tools.dotc import dotty.tools.dotc.ast.tpd import dotty.tools.dotc.ast.untpd @@ -255,7 +253,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler throw new RuntimeException( "Symbols necessary for creation of the ClassDef tree could not be found." ) - val paramsAccessDefs: List[untpd.ParamClause] = + val paramsAccessDefs: List[ParamClause] = cls.primaryConstructor.paramSymss.map { paramSym => if paramSym.headOption.map(_.isType).getOrElse(false) then paramSym.map { symm => @@ -283,7 +281,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler (cdef.name.toString, cdef.constructor, cdef.parents, cdef.self, rhs.body) def module(module: Symbol, parents: List[Tree /* Term | TypeTree */], body: List[Statement]): (ValDef, ClassDef) = { - if xCheckMacro then TreeChecker.checkParents(module.moduleClass.asClass, parents) + if xCheckMacro then TreeChecker.checkParents(module.moduleClass.asClass, parents, xCheckMacroAssert) val cls = module.moduleClass val clsDef = ClassDef(cls, parents, body) val newCls = Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), Nil) @@ -907,7 +905,9 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler object Closure extends ClosureModule: def apply(meth: Term, tpe: Option[TypeRepr]): Closure = + xCheckMacroAssert(meth.symbol.isAnonymousFunction, "Closures must refer to anonymous functions") withDefaultPos(tpd.Closure(Nil, meth, tpe.map(tpd.TypeTree(_)).getOrElse(tpd.EmptyTree))) + def copy(original: Tree)(meth: Tree, tpe: Option[TypeRepr]): Closure = tpd.cpy.Closure(original)(Nil, meth, tpe.map(tpd.TypeTree(_)).getOrElse(tpd.EmptyTree)) def unapply(x: Closure): (Term, Option[TypeRepr]) = @@ -1700,7 +1700,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler def apply(params: List[ValDef]): TermParamClause = if xCheckMacro then val implicitParams = params.count(_.symbol.is(dotc.core.Flags.Implicit)) - assert(implicitParams == 0 || implicitParams == params.size, "Expected all or non of parameters to be implicit") + xCheckMacroAssert(implicitParams == 0 || implicitParams == params.size, "Expected all or none of the parameters to be implicit") params def unapply(x: TermParamClause): Some[List[ValDef]] = Some(x) end TermParamClause @@ -1906,7 +1906,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler // even if that symbol is not a direct member of that prefix, but a nested one. def isTypeRelatedToThePassedMember = import scala.util.boundary - boundary { + // the symbol for `self` will not exist for LambdaTypes, + // which don't seem to be supported by asSeenFrom anyway + // (but also don't seem to cause crashes, and return no-op member.info, + // which we might not be able to access otherwise, so we need to allow this). + val isLambdaType = self.isInstanceOf[LambdaType] + isLambdaType || boundary { var checked: Symbol = member while(checked.exists) { if self.derivesFrom(checked) @@ -1917,6 +1922,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler } boundary.break(false) } + xCheckMacroAssert(isTypeRelatedToThePassedMember, s"$member is not a member of ${self.show}") // we replace thisTypes here to avoid resolving otherwise unstable prefixes into Nothing @@ -2876,7 +2882,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler cls def newModule(owner: Symbol, name: String, modFlags: Flags, clsFlags: Flags, parents: Symbol => List[TypeRepr], decls: Symbol => List[Symbol], privateWithin: Symbol): Symbol = - assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`") + xCheckMacroAssert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`") val mod = dotc.core.Symbols.newNormalizedModuleSymbol( owner, name.toTermName, @@ -3381,7 +3387,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler given SourceFileMethods: SourceFileMethods with extension (self: SourceFile) - def jpath: java.nio.file.Path = self.file.jpath + @deprecated("Use getJPath, name, or path instead of jpath", "3.0.2") + def jpath: java.nio.file.Path = + self.file.jpath.asInstanceOf[java.nio.file.Path] // the cast is the reason this is deprecated + def getJPath: Option[java.nio.file.Path] = Option(self.file.jpath) def name: String = self.name def path: String = self.path @@ -3446,7 +3455,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler private def optional[T <: dotc.ast.Trees.Tree[?]](tree: T): Option[tree.type] = if tree.isEmpty then None else Some(tree) - private def withDefaultPos[T <: Tree](fn: Context ?=> T): T = + private def withDefaultPos[T <: untpd.Tree](fn: Context ?=> T): T = fn(using ctx.withSource(Position.ofMacroExpansion.source)).withSpan(Position.ofMacroExpansion.span) /** Checks that all definitions in this tree have the expected owner. @@ -3548,7 +3557,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler // start stack trace at the place where the user called the reflection method error.setStackTrace( error.getStackTrace - .dropWhile(_.getClassName().startsWith("scala.quoted.runtime.impl"))) + .dropWhile(l => l.getClassName().startsWith("scala.quoted.runtime.impl") || l.getClassName().startsWith("dotty.tools.dotc"))) throw error object Printer extends PrinterModule: @@ -3601,7 +3610,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler val tree = PickledQuotes.unpickleTerm(pickled, PickledQuotes.TypeHole.V1(typeHole), PickledQuotes.ExprHole.V1(termHole)) new ExprImpl(tree, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Expr[T]] - def unpickleExprV2[T](pickled: String | List[String], types: Seq[Type[?]], termHole: Null | ((Int, Seq[Type[?] | Expr[Any]], Quotes) => Expr[?])): scala.quoted.Expr[T] = + def unpickleExprV2[T](pickled: String | List[String], types: Null | Seq[Type[?]], termHole: Null | ((Int, Seq[Type[?] | Expr[Any]], Quotes) => Expr[?])): scala.quoted.Expr[T] = val tree = PickledQuotes.unpickleTerm(pickled, PickledQuotes.TypeHole.V2(types), PickledQuotes.ExprHole.V2(termHole)) new ExprImpl(tree, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Expr[T]] @@ -3609,7 +3618,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler val tree = PickledQuotes.unpickleTypeTree(pickled, PickledQuotes.TypeHole.V1(typeHole)) new TypeImpl(tree, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Type[T]] - def unpickleTypeV2[T <: AnyKind](pickled: String | List[String], types: Seq[Type[?]]): scala.quoted.Type[T] = + def unpickleTypeV2[T <: AnyKind](pickled: String | List[String], types: Null | Seq[Type[?]]): scala.quoted.Type[T] = val tree = PickledQuotes.unpickleTypeTree(pickled, PickledQuotes.TypeHole.V2(types)) new TypeImpl(tree, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Type[T]] diff --git a/compiler/test/dotc/neg-best-effort-pickling.excludelist b/compiler/test/dotc/neg-best-effort-pickling.excludelist index f3c761193a47..73cbd7841991 100644 --- a/compiler/test/dotc/neg-best-effort-pickling.excludelist +++ b/compiler/test/dotc/neg-best-effort-pickling.excludelist @@ -21,5 +21,8 @@ i974.scala # cyclic reference i13864.scala # missing symbol in pickling type-params.scala # recursion limit exceeded +unsafe-dollar-in-name.scala # missing owner in unpickler +unsafe-dollar-in-name-2.scala # missing owner in unpickler + # semantic db generation fails in the first compilation i15158.scala # cyclic reference - stack overflow diff --git a/compiler/test/dotc/neg-best-effort-unpickling.excludelist b/compiler/test/dotc/neg-best-effort-unpickling.excludelist index 9e27e6133947..6807c466e97b 100644 --- a/compiler/test/dotc/neg-best-effort-unpickling.excludelist +++ b/compiler/test/dotc/neg-best-effort-unpickling.excludelist @@ -30,3 +30,6 @@ i23504.scala # owner of anon, where package object has funky name i20511-1.scala + +# NoDenotation.owner +i18234.scala diff --git a/compiler/test/dotc/scoverage-ignore.excludelist b/compiler/test/dotc/scoverage-ignore.excludelist index 22cc1a29adb4..e7242c744efe 100644 --- a/compiler/test/dotc/scoverage-ignore.excludelist +++ b/compiler/test/dotc/scoverage-ignore.excludelist @@ -5,82 +5,21 @@ # Empty lines are ignored 16583.scala -annotation-named-pararamters -applied_constructor_types.scala -capt1.scala -capture.scala -catch-sub-cases.scala -colltest5 -gadt-cast-singleton.scala gadt-ycheck.scala -generic-java-array-src -getclass.scala help.scala i10889.scala i11247.scala -i11556.scala -i11685 -i12739.scala -i13011.scala -i13392.scala -i13542.scala -i13691.scala -i14164.scala i14947.scala i15165.scala -i15385 -i15608 -i15845 -i15864.scala -i15980 -i18263.orig.scala -i18263.scala -i18589 -i19505.scala -i19637.scala i19955a.scala i19955b.scala i20053b.scala -i2112.scala -i21313.scala i2146.scala -i2250.scala -i23179.scala -i23277.scala -i23305.scala i23489.scala -i23541.scala -i23693.scala -i2397.scala -i24039.scala -i24553.scala -i25000.scala -i25000b.scala -i3598.scala -i5039.scala -i8623.scala i8900a3.scala -i8955.scala -i8963.scala -i9228.scala -i9880.scala -infersingle.scala -interop-unsound-src -match-single-sub-case.scala -match-sub-cases.scala -match-sub-sub-cases.scala -minicheck.scala -minicheck-toplevel.scala +lazyVals_c3.0.0.scala +lazyVals_c3.1.0.scala mt-scrutinee-widen3.scala -null.scala -pf-sub-cases.scala -pos_valueclasses -precise-ctx-bound.scala -quote-function-applied-to.scala -skolems2.scala spurious-overload.scala -sub-cases-exhaustivity.scala tailrec.scala traitParams.scala -i25460.scala -matrix.scala diff --git a/compiler/test/dotty/Properties.scala b/compiler/test/dotty/Properties.scala index 42b2e6b9acc9..4123fffd3e7f 100644 --- a/compiler/test/dotty/Properties.scala +++ b/compiler/test/dotty/Properties.scala @@ -105,6 +105,9 @@ object Properties { /** fansi jar */ def sourcecode: String = sys.props("dotty.tests.classes.sourcecode") + /** scala-xml jar */ + def scalaXml: String = sys.props("dotty.tests.classes.scalaXml") + /** scalajs-javalib jar */ def scalaJSJavalib: String = sys.props("dotty.tests.classes.scalaJSJavalib") diff --git a/compiler/test/dotty/tools/backend/jvm/ArrayApplyOptTest.scala b/compiler/test/dotty/tools/backend/jvm/ArrayApplyOptTest.scala index 15732e7ba4a2..49e30b0b4593 100644 --- a/compiler/test/dotty/tools/backend/jvm/ArrayApplyOptTest.scala +++ b/compiler/test/dotty/tools/backend/jvm/ArrayApplyOptTest.scala @@ -152,7 +152,7 @@ class ArrayApplyOptTest extends DottyBytecodeTest { """.stripMargin checkBCode(source) { dir => - val clsIn = dir.lookupName("Foo.class", directory = false).input + val clsIn = dir.lookupName("Foo.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) val meth = getMethod(clsNode, "test") @@ -333,7 +333,7 @@ class ArrayApplyOptTest extends DottyBytecodeTest { def checkApplyAvoidsIntermediateArray(name: String)(source: String): Unit = { checkBCode(source) { dir => - val clsIn = dir.lookupName("Foo.class", directory = false).input + val clsIn = dir.lookupName("Foo.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) val meth1 = getMethod(clsNode, "meth1") val meth2 = getMethod(clsNode, "meth2") diff --git a/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala b/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala index 22d2515cd382..7c3b8c9eb768 100644 --- a/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala +++ b/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala @@ -1724,9 +1724,9 @@ class DottyBytecodeTests extends DottyBytecodeTest { checkBCode(source) { dir => val clsIn = dir.lookupName("Foo.class", directory = false).input val clsNode = loadClassNode(clsIn) - def testSig(methodName: String, expectedSignature: String) = { - val signature = clsNode.methods.asScala.filter(_.name == methodName).map(_.signature) - assertEquals(List(expectedSignature), signature) + def testSig(methodName: String, expectedDescriptor: String) = { + val descriptor = clsNode.methods.asScala.filter(_.name == methodName).map(_.desc) + assertEquals(List(expectedDescriptor), descriptor) } testSig("foo", "()I") testSig("bar", "()I") @@ -2059,6 +2059,35 @@ class DottyBytecodeTests extends DottyBytecodeTest { assert(clsNode.methods.asScala.exists(_.name == "test")) } } + + @Test def presenceOfGenericSignatures = { + val source = + """|object Test: + | def no0(x: Int): Unit = () + | def no1(x: Array[Int]): Array[Int] = x + | def no2(x: String): String = x + | def no3(): Array[String] = Array.empty + | + | def yes0[A](x: A): A = x + | def yes1[A, B](x: A): B = ??? + | def yes2[A](x: Int): Unit = () + | def yes3[A](x: Array[A]): A = x(0) + | + | @scala.annotation.varargs def v(x: String*): String = x(0) + |""".stripMargin + checkBCode(source) { dir => + val clsIn = dir.lookupName("Test$.class", directory = false).input + val clsNode = loadClassNode(clsIn) + for noMeth <- clsNode.methods.asScala if noMeth.name.startsWith("no") do + assert(noMeth.signature == null, s"${noMeth.name} should not have a signature but does: ${noMeth.signature}") + for yesMeth <- clsNode.methods.asScala if yesMeth.name.startsWith("yes") do + assert(yesMeth.signature != null, s"${yesMeth.name} should have a signature but does not") + // regression test for issue #10837 + val varargMeths = clsNode.methods.asScala.filter(_.name.startsWith("v")) + val bridge = varargMeths.filter(_.desc == "([Ljava/lang/String;)Ljava/lang/String;").head + assert(bridge.signature == null, "vararg bridges should not have generic signatures") + } + } } object invocationReceiversTestCode { diff --git a/compiler/test/dotty/tools/backend/jvm/IincTest.scala b/compiler/test/dotty/tools/backend/jvm/IincTest.scala index a473b845c0f2..63483ab85afb 100644 --- a/compiler/test/dotty/tools/backend/jvm/IincTest.scala +++ b/compiler/test/dotty/tools/backend/jvm/IincTest.scala @@ -59,7 +59,7 @@ class IincTest extends DottyBytecodeTest { """.stripMargin checkBCode(source) { dir => - val clsIn = dir.lookupName("Increment.class", directory = false).input + val clsIn = dir.lookupName("Increment.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) val meth = getMethod(clsNode, "test") diff --git a/compiler/test/dotty/tools/backend/jvm/MixinBytecodeTests.scala b/compiler/test/dotty/tools/backend/jvm/MixinBytecodeTests.scala index 8f0baf15fe84..ba6c4b129639 100644 --- a/compiler/test/dotty/tools/backend/jvm/MixinBytecodeTests.scala +++ b/compiler/test/dotty/tools/backend/jvm/MixinBytecodeTests.scala @@ -17,7 +17,7 @@ class MixinBytecodeTestsNoForwarders extends DottyBytecodeTest { } private def getClass(dir: AbstractFile, name: String) = - loadClassNode(dir.lookupName(name + ".class", directory = false).input) + loadClassNode(dir.lookupName(name + ".class", directory = false).nn.input) private def checkForwarder(clazz: ClassNode, target: String) = { val f = getMethod(clazz, "f") @@ -36,7 +36,7 @@ class MixinBytecodeTestsNoForwarders extends DottyBytecodeTest { """.stripMargin checkBCode(code) { dir => - val clsIn = dir.lookupName("AbstractSet2.class", directory = false).input + val clsIn = dir.lookupName("AbstractSet2.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) assertEquals(clsNode.methods.asScala.map(_.name).toList, List("")) // no bridge for apply (there's already one in AbstractSet) } @@ -95,7 +95,7 @@ class MixinBytecodeTestsNoForwarders extends DottyBytecodeTest { checkBCode(code) { dir => val noForwarder = List("C1", "C2", "C3", "C4", "C10", "C11", "C12", "C13", "C16", "C17") - val noForwarderClasses = noForwarder.map(cn => loadClassNode(dir.lookupName(cn + ".class", directory = false).input)) + val noForwarderClasses = noForwarder.map(cn => loadClassNode(dir.lookupName(cn + ".class", directory = false).nn.input)) for cn <- noForwarderClasses do val meth = cn.methods.asScala.find(_.name == "f") assert(meth.isEmpty, s"failed for ${cn.name}") @@ -304,7 +304,7 @@ class MixinBytecodeTestsNoForwarders extends DottyBytecodeTest { class MixinBytecodeTestsWithForwarders extends DottyBytecodeTest { private def getClass(dir: AbstractFile, name: String) = - loadClassNode(dir.lookupName(name + ".class", directory = false).input) + loadClassNode(dir.lookupName(name + ".class", directory = false).nn.input) @Test def sd224(): Unit = { @@ -572,4 +572,4 @@ class MixinBytecodeTestsWithForwarders extends DottyBytecodeTest { assertInvoke(getInstructions(c, "m"), "A", "m$") } } -} \ No newline at end of file +} diff --git a/compiler/test/dotty/tools/backend/jvm/OptimizationBytecodeTests.scala b/compiler/test/dotty/tools/backend/jvm/OptimizationBytecodeTests.scala index ce6972602a78..9a35f90fd0a2 100644 --- a/compiler/test/dotty/tools/backend/jvm/OptimizationBytecodeTests.scala +++ b/compiler/test/dotty/tools/backend/jvm/OptimizationBytecodeTests.scala @@ -47,7 +47,7 @@ class OptimizationBytecodeTests extends DottyBytecodeTest { """.stripMargin checkBCode(source) { dir => - val clsIn = dir.lookupName("Test.class", directory = false).input + val clsIn = dir.lookupName("Test.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) val meth1 = getMethod(clsNode, "actual") val meth2 = getMethod(clsNode, "expected") @@ -60,7 +60,7 @@ class OptimizationBytecodeTests extends DottyBytecodeTest { diffInstructions(instructions1, instructions2)) } } - + private def assertCalls(allowedCalls: (String, String) => Boolean, body: String, params: List[String] = Nil, extraMemberSources: List[String] = Nil, returnType: String = "Int"): Unit = val source = f""" @@ -72,7 +72,7 @@ class OptimizationBytecodeTests extends DottyBytecodeTest { """.stripMargin checkBCode(source) { dir => - val clsIn = dir.lookupName("Test.class", directory = false).input + val clsIn = dir.lookupName("Test.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) val meth = getMethod(clsNode, "test") val instructions = instructionsFromMethod(meth) @@ -565,7 +565,7 @@ class OptimizationBytecodeTests extends DottyBytecodeTest { |} """.stripMargin checkBCode(source) { dir => - val clsIn = dir.lookupName("C.class", directory = false).input + val clsIn = dir.lookupName("C.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) val meth1a = getMethod(clsNode, "t1a") val meth1b = getMethod(clsNode, "t1b") @@ -752,7 +752,7 @@ class OptimizationBytecodeTests extends DottyBytecodeTest { """.stripMargin checkBCode(source) { dir => - val clsIn = dir.lookupName("Foo.class", directory = false).input + val clsIn = dir.lookupName("Foo.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) val meth1 = getMethod(clsNode, "foo") @@ -774,7 +774,7 @@ class OptimizationBytecodeTests extends DottyBytecodeTest { """.stripMargin checkBCode(source) { dir => - val clsIn = dir.lookupName("Test.class", directory = false).input + val clsIn = dir.lookupName("Test.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) for m <- List(getMethod(clsNode, "bad")) do diff --git a/compiler/test/dotty/tools/backend/jvm/StringConcatTest.scala b/compiler/test/dotty/tools/backend/jvm/StringConcatTest.scala index 2610a0132bb1..3bfd02ac17f0 100644 --- a/compiler/test/dotty/tools/backend/jvm/StringConcatTest.scala +++ b/compiler/test/dotty/tools/backend/jvm/StringConcatTest.scala @@ -51,7 +51,7 @@ class StringConcatTest extends DottyBytecodeTest { checkBCode(code) { dir => def instructions(meth: String): List[Instruction] = { - val clsIn = dir.lookupName("C.class", directory = false).input + val clsIn = dir.lookupName("C.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) instructionsFromMethod(getMethod(clsNode, meth)) } diff --git a/compiler/test/dotty/tools/backend/jvm/StringInterpolatorOptTest.scala b/compiler/test/dotty/tools/backend/jvm/StringInterpolatorOptTest.scala index e92717adcb83..88a6fff02aa1 100644 --- a/compiler/test/dotty/tools/backend/jvm/StringInterpolatorOptTest.scala +++ b/compiler/test/dotty/tools/backend/jvm/StringInterpolatorOptTest.scala @@ -21,7 +21,7 @@ class StringInterpolatorOptTest extends DottyBytecodeTest { """.stripMargin checkBCode(source) { dir => - val clsIn = dir.lookupName("Foo.class", directory = false).input + val clsIn = dir.lookupName("Foo.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) val meth1 = getMethod(clsNode, "meth1") val meth2 = getMethod(clsNode, "meth2") @@ -49,7 +49,7 @@ class StringInterpolatorOptTest extends DottyBytecodeTest { """.stripMargin checkBCode(source) { dir => - val clsIn = dir.lookupName("Foo.class", directory = false).input + val clsIn = dir.lookupName("Foo.class", directory = false).nn.input val clsNode = loadClassNode(clsIn) val meth1 = getMethod(clsNode, "meth1") val meth2 = getMethod(clsNode, "meth2") diff --git a/compiler/test/dotty/tools/debug/DebugTests.scala b/compiler/test/dotty/tools/debug/DebugTests.scala index ab30afb1b542..8286c0c0b0f9 100644 --- a/compiler/test/dotty/tools/debug/DebugTests.scala +++ b/compiler/test/dotty/tools/debug/DebugTests.scala @@ -11,6 +11,7 @@ import org.junit.Test import java.util.concurrent.TimeoutException import scala.concurrent.duration.* import scala.util.control.NonFatal +import java.io.IOException class DebugTests: import DebugTests.{*, given} @@ -18,6 +19,8 @@ class DebugTests: given TestGroup = TestGroup("debug") CompilationTest.aggregateTests( compileFile("tests/debug-custom-args/eval-explicit-nulls.scala", TestConfiguration.explicitNullsOptions), + compileFile("tests/debug-custom-args/eval-syntax.scala", TestConfiguration.oldSyntax), + compileFile("tests/debug-custom-args/eval-syntax.scala", TestConfiguration.newSyntax), compileFilesInDir("tests/debug", TestConfiguration.defaultOptions), ).checkDebug() @@ -73,9 +76,13 @@ object DebugTests extends ParallelTesting: // 'Listening for transport dt_socket at address: ' message is ready to be read // by the next DebugTest debugger.dispose() - catch case DebugStepException(message, location) => - echo(s"\n[error] Debug step failed: $location\n" + message) - failTestSource(testSource) + catch + case DebugStepException(message, location) => + echo(s"\n[error] Debug step failed: $location\n" + message) + failTestSource(testSource) + case e: IOException => + // FIXME: Handle this kind of failure, do not just make the test pass. + echo(s"\n[warn] Ignoring failed debug test due to unexpected error: ${e.getMessage()}") end verifyDebug private def playDebugSteps(debugger: Debugger, steps: Seq[DebugStepAssert[?]], verbose: Boolean = false): Unit = diff --git a/compiler/test/dotty/tools/debug/ExpressionEvaluator.scala b/compiler/test/dotty/tools/debug/ExpressionEvaluator.scala index eeaf997871cf..f4dbc88814bd 100644 --- a/compiler/test/dotty/tools/debug/ExpressionEvaluator.scala +++ b/compiler/test/dotty/tools/debug/ExpressionEvaluator.scala @@ -74,7 +74,8 @@ class ExpressionEvaluator( expression = expression, localVariables = localVariables.toSet.map(_.name).asJava, errorReporter = errorMsg => errorBuilder.append(errorMsg), - testMode = true + testMode = true, + oldSyntax = options.contains("-old-syntax") ) val success = compiler.run(outputDir, classPath, options, sourceFile, config) val fullyQualifiedClassName = diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala index 335c48afed6f..d2803a4618e7 100644 --- a/compiler/test/dotty/tools/dotc/CompilationTests.scala +++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala @@ -35,6 +35,7 @@ class CompilationTests { compileFile("tests/pos-special/utf16encoded.scala", defaultOptions.and("-encoding", "UTF16")), compileDir("tests/pos-special/i18589", defaultOptions.and("-Wsafe-init").without("-Ycheck:all")), compileDir("tests/pos-special/i24547", defaultOptions.without("-Ycheck:all")), + compileDir("tests/pos-special/i24719", defaultOptions.without("-Ycheck:all")), // Run tests for legacy lazy vals compileFilesInDir("tests/pos", defaultOptions.and("-Wsafe-init", "-Ylegacy-lazy-vals", "-Ycheck-constraint-deps"), FileFilter.include(TestSources.posLazyValsAllowlist)), compileDir("tests/pos-special/java-param-names", defaultOptions.withJavacOnlyOptions("-parameters")), @@ -84,6 +85,8 @@ class CompilationTests { compileFile("tests/rewrites/i24103.scala", defaultOptions.and("-rewrite", "-source:3.4-migration")), compileFile("tests/rewrites/i24103b.scala", defaultOptions.and("-rewrite", "-source:3.4-migration")), compileFile("tests/rewrites/i24213.scala", defaultOptions.and("-rewrite", "-source:3.4-migration")), + compileFile("tests/rewrites/i18234.scala", defaultOptions.and("-rewrite", "-source:3.8-migration")), + compileFile("tests/rewrites/unary-minus.scala", defaultOptions.and("-rewrite")), )).checkRewrites() } @@ -233,6 +236,26 @@ class CompilationTests { )) runWithCoverageOrFallback[PosTestWithCoverage](compilationTest, "Pos") + // The regression test for i25722 has some atypical classpath requirements. + // The test consists of (a) one Java nullability annotation, (b) one Java user of the annotation, and (c) two Scala files, + // which must be compiled separately. In addition: + // - the output from (a) must be on the classpath while compiling (b) + // - the output from (b) must be on the classpath while compiling (c) + // - the output from (a) _must not_ be on the classpath while compiling (c) + locally { + val i25722Group = TestGroup("tests/explicit-nulls/special/i25722") + val i25722Options = explicitNullsOptions.and("-Yforce-sbt-phases") + val outDir1 = Paths.get(defaultOutputDir.getAbsolutePath, i25722Group.name, "Nullable", "annotations", "Nullable/").toString + val outDir2 = Paths.get(defaultOutputDir.getAbsolutePath, i25722Group.name, "Foo", "lib", "Foo").toString + val tests = List( + withCoverage(compileFile("tests/explicit-nulls/special/25722/jstubs/jstubs/org/jetbrains/annotations/Nullable.java", i25722Options)(using i25722Group).keepOutput), + withCoverage(compileFile("tests/explicit-nulls/special/25722/jstubs/jstubs/lib/Foo.java", i25722Options.withClasspath(outDir1))(using i25722Group).keepOutput), + withCoverage(compileDir("tests/explicit-nulls/special/25722/scala", i25722Options.withClasspath(outDir2))(using i25722Group).keepOutput) + ) + tests.foreach(t => runWithCoverageOrFallback[PosTestWithCoverage](t, "Pos")) + tests.foreach(_.delete()) + } + // locally { // val tests = List( // compileFile("tests/explicit-nulls/flexible-unpickle/pos/Unsafe_1.scala", explicitNullsOptions without "-Yexplicit-nulls"), diff --git a/compiler/test/dotty/tools/dotc/CoverageSupport.scala b/compiler/test/dotty/tools/dotc/CoverageSupport.scala index d1fb60491ed2..632603b7a489 100644 --- a/compiler/test/dotty/tools/dotc/CoverageSupport.scala +++ b/compiler/test/dotty/tools/dotc/CoverageSupport.scala @@ -6,7 +6,6 @@ import scala.language.unsafeNulls import java.nio.file.{Files, Paths} import scala.util.Try -import scala.util.control.NonFatal import dotty.tools.dotc.coverage.Serializer import vulpix.* import reporting.TestReporter @@ -97,7 +96,7 @@ trait CoverageSupport: .sorted(java.util.Comparator.reverseOrder()) .forEach(Files.delete) catch - case NonFatal(_) => // Ignore cleanup errors + case _: Exception => // Ignore cleanup errors end try end if end verifyCoverageFile @@ -116,6 +115,7 @@ trait CoverageSupport: def withCoverage(test: CompilationTest): CompilationTest = { if (Properties.testsInstrumentCoverage) { val ignoreList = scoverageIgnoreExcludelisted.toSet + val ycheckExemptList = Set("i5039.scala", "null.scala") // Filter out test sources whose filenames or directory names match the excludelist val filteredTargets = test.targets.filter { target => @@ -149,8 +149,11 @@ trait CoverageSupport: val modifiedTargets = filteredTargets.map { target => val coverageDir = Files.createTempDirectory("coverage") val sourceRoot = Paths.get(".").toAbsolutePath.toString - target.withFlags( - "-Ycheck:instrumentCoverage", + val targetWithFlags = + if target.sourceFiles.exists(file => ycheckExemptList.contains(file.getName)) then target.withoutFlags("-Ycheck:all") + else target + + targetWithFlags.withFlags( "-coverage-out", coverageDir.toString, "-sourceroot", sourceRoot ) diff --git a/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala b/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala index 6b980b695f08..be75581ebf51 100644 --- a/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala +++ b/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala @@ -97,23 +97,9 @@ class ScalaSettingsTests: s"${oldSetting.name}$value" -> newSetting val settings = ScalaSettings - List( - createTestCase(settings.YtermConflict , settings.XtermConflict, ":package"), - createTestCase(settings.YnoGenericSig , settings.XnoGenericSig), - createTestCase(settings.Ydumpclasses , settings.Xdumpclasses,":./"), - createTestCase(settings.YjarCompressionLevel , settings.XjarCompressionLevel,":0"), - createTestCase(settings.YkindProjector , settings.XkindProjector, ":underscores"), - createTestCase(settings.YdropComments , settings.XdropComments), - createTestCase(settings.YcookComments , settings.XcookComments), - createTestCase(settings.YreadComments , settings.XreadComments), - createTestCase(settings.YnoDecodeStacktraces , settings.XnoEnrichErrorMessages), - createTestCase(settings.YnoEnrichErrorMessages, settings.XnoEnrichErrorMessages), - createTestCase(settings.YdebugMacros , settings.XdebugMacros), - // createTestCase(settings.YjavaTasty , settings.XjavaTasty), - // createTestCase(settings.YearlyTastyOutput , settings.XearlyTastyOutput, ":./"), - // createTestCase(settings.YallowOutlineFromTasty, settings.XallowOutlineFromTasty), - createTestCase(settings.YcheckInit , settings.WsafeInit), - // createTestCase(settings.Xlint , settings.Wshadow, ":all"), // this setting is not going to be mapped to replacement. Read more in the commit message + List[(String, Setting[?])]( + // Fill this with newly-deprecated options, optionally with a value: + createTestCase(settings.YkindProjector , settings.XkindProjector, ":underscores"), ).map: (deprecatedArgument, newSetting) => val args = List(deprecatedArgument) val argSummary = ArgsSummary(settings.defaultState, args, errors = Nil, warnings = Nil) @@ -126,60 +112,21 @@ class ScalaSettingsTests: s"${oldSetting.name}:$value" -> newSetting val settings = ScalaSettings - List( - createTestCase(settings.YtermConflict , settings.XtermConflict), - createTestCase(settings.YnoGenericSig , settings.XnoGenericSig), - createTestCase(settings.Ydumpclasses , settings.Xdumpclasses, ""), - createTestCase(settings.YjarCompressionLevel , settings.XjarCompressionLevel), - createTestCase(settings.YkindProjector , settings.XkindProjector), - createTestCase(settings.YdropComments , settings.XdropComments), - createTestCase(settings.YcookComments , settings.XcookComments), - createTestCase(settings.YreadComments , settings.XreadComments), - createTestCase(settings.YnoDecodeStacktraces , settings.XnoEnrichErrorMessages), - createTestCase(settings.YnoEnrichErrorMessages, settings.XnoEnrichErrorMessages), - createTestCase(settings.YdebugMacros , settings.XdebugMacros), - // createTestCase(settings.YjavaTasty , settings.XjavaTasty), - // createTestCase(settings.YearlyTastyOutput , settings.XearlyTastyOutput), - // createTestCase(settings.YallowOutlineFromTasty, settings.XallowOutlineFromTasty), - createTestCase(settings.YcheckInit , settings.WsafeInit), - createTestCase(settings.Xlint , settings.Wshadow), + List[(String, Setting[?])]( + // Fill this with newly-deprecated options: + createTestCase(settings.YkindProjector , settings.XkindProjector), ).map: (deprecatedArgument, newSetting) => val args = List(deprecatedArgument) val argSummary = ArgsSummary(settings.defaultState, args, errors = Nil, warnings = Nil) val conf = settings.processArguments(argSummary, processAll = true, skipped = Nil) assert(newSetting.isDefaultIn(conf.sstate), s"Setting $deprecatedArgument was forwarded to ${newSetting.name}, when it should be ignored because first option was erroreus") - // -Xlint was handled in a special way when it was added, making in hard to deprecate it. - // For now on we will retain old behavior, in next version we will emit deprecation warning. - // It is also scheduled for removal in future versions. - @Test def `Make Xlint to ignore invalid args`: Unit = - val settings = ScalaSettings - val args = List("-Xlint:-unused,_") - val argSummary = ArgsSummary(settings.defaultState, args, errors = Nil, warnings = Nil) - val conf = settings.processArguments(argSummary, processAll = true, skipped = Nil) - assert(conf.warnings.contains("Option -Xlint is deprecated: Use -Wshadow to enable shadowing lints. Scheduled for removal.")) - assert(conf.errors.isEmpty) - @nowarn("cat=deprecation") @Test def `Aliases of deprecated options are correctly mapped to their replacements`: Unit = val settings = ScalaSettings - val tests = List( - settings.YtermConflict -> settings.XtermConflict :* "package", - settings.YnoGenericSig -> settings.XnoGenericSig, - settings.Ydumpclasses -> settings.Xdumpclasses :* "./", - settings.YjarCompressionLevel -> settings.XjarCompressionLevel :* "0", - settings.YkindProjector -> settings.XkindProjector :* "underscores", - settings.YdropComments -> settings.XdropComments, - settings.YcookComments -> settings.XcookComments, - settings.YreadComments -> settings.XreadComments, - settings.YnoDecodeStacktraces -> settings.XnoEnrichErrorMessages, - settings.YnoEnrichErrorMessages -> settings.XnoEnrichErrorMessages, - settings.YdebugMacros -> settings.XdebugMacros, - settings.YcheckInit -> settings.WsafeInit, - // createTestCase(settings.YjavaTasty , settings.XjavaTasty), - // createTestCase(settings.YearlyTastyOutput , settings.XearlyTastyOutput, ":./"), - // createTestCase(settings.YallowOutlineFromTasty, settings.XallowOutlineFromTasty), - // createTestCase(settings.Xlint , settings.Wshadow, ":all"), // this setting is not going to be mapped to replacement. Read more in the commit message + val tests = List[Setting[?] *: Setting[?] *: Tuple]( + // Fill this with newly-deprecated options, optionally with a value: + settings.YkindProjector -> settings.XkindProjector :* ":underscores", ) for test <- tests diff --git a/compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala b/compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala index 55b611310e39..1e10a4cef71c 100644 --- a/compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala +++ b/compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala @@ -117,7 +117,7 @@ class CommentPicklingTest { implicit val ctx: Context = setup(args, initCtx).map(_._2).getOrElse(initCtx) ctx.initialize() val trees = files.flatMap { f => - val unpickler = new DottyUnpickler(AbstractFile.getFile(f.jpath), f.toByteArray(), isBestEffortTasty = false) + val unpickler = new DottyUnpickler(AbstractFile.getFile(f.jpath), f.inputStream().readAllBytes(), isBestEffortTasty = false) unpickler.enter(roots = Set.empty) unpickler.rootTrees(using ctx) } diff --git a/compiler/test/dotty/tools/dotc/core/tasty/TastyUnpickerTest.scala b/compiler/test/dotty/tools/dotc/core/tasty/TastyUnpickerTest.scala new file mode 100644 index 000000000000..78ce30608282 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/core/tasty/TastyUnpickerTest.scala @@ -0,0 +1,59 @@ +package dotty.tools.dotc.core.tasty + +import dotty.tools.io.VirtualFile +import dotty.tools.dotc.core.Contexts.* +import dotty.tools.dotc.ast.* +import dotty.tools.dotc.ast.tpd.* +import dotty.tools.tasty.UnpickleException +import org.junit.Test +import org.junit.Assert.* + +class TastyUnpickerTest { + private def test(bytes: Int*): Unit = + val base = new ContextBase + given Context = base.initialCtx.fresh + val bytesArray = bytes.map(_.toByte).toArray + val dotty = new DottyUnpickler( + tastyFile = new VirtualFile("bytes.tasty", bytesArray), + bytes = bytesArray, + isBestEffortTasty = false + ) + dotty.enter(roots = Set.empty) + dotty.rootTrees.foreach(t => t.foreachSubTree(identity)) + + // this used to go into an infinite loop as we could 'goto' a negative number when looking for a section end + @Test def regressionInfiniteLoop(): Unit = + assertThrows(classOf[UnpickleException], () => test( + 0x5c, 0xa1, 0xab, 0x1f, 0x9c, 0x88, 0x80, 0xb8, 0x53, 0x63, 0x61, 0x6c, 0x61, 0x20, 0x33, 0x2e, 0x38, 0x2e, 0x32, 0x2d, + 0x52, 0x43, 0x31, 0x2d, 0x62, 0x69, 0x6e, 0x2d, 0x53, 0x4e, 0x41, 0xb0, 0xac, 0xb7, 0xa9, 0x54, 0x2d, 0x6e, 0x6f, 0x6e, + 0x62, 0x9a, 0x90, 0x8b, 0x8c, 0x74, 0x72, 0x0a, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0x6f, 0x6c, 0x77, 0x2e, + 0x64, 0x6f, 0x74, 0x3c, 0x00, 0xd5, 0x86, 0x0a, 0xd0, 0x5b, 0x65, 0xe8, 0x00, 0xd4, 0x9d, 0xda, 0xab, 0x1f, 0x3b, 0x18, + 0x02, 0xb6, 0x01, 0x84, 0x41, 0x53, 0x54, 0x73, 0x01, 0x85, 0x7a, 0x63, 0x61, 0x6c, 0x61, 0x01, 0x8a, 0x61, 0x6e, 0x6e, + 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x02, 0x82, 0x81, 0x82, 0x01, 0x8c, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x93, + 0x9a, 0x91, 0x8b, 0x61, 0x6c, 0x01, 0x88, 0x6c, 0x5d, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x01, 0x8f, 0x63, 0x61, 0x70, + 0x74, 0x75, 0x72, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x01, 0x86, 0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c, + 0x01, 0x86, 0x3c, 0x69, 0x6e, 0x69, 0x74, 0x3e, 0x01, 0x8a, 0x41, 0x6e, 0x6e, 0x6f, 0x69, 0x61, 0x74, 0x74, 0x6f, 0x6e, + 0x02, 0x82, 0x83, 0x89, 0x3f, 0x82, 0x88, 0x8a, 0x01, 0x90, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, 0x41, 0x6e, 0x6e, 0x6e, + 0x69, 0x0b, 0x00, 0x6f, 0x6f, 0x61, 0x01, 0x84, 0x55, 0x6e, 0x69, 0x74, 0x01, 0x8a, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x46, 0x69, 0x6c, 0x65, 0x01, 0x88, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x02, 0x82, 0x83, 0x8f, 0x02, 0x82, + 0x90, 0x8e, 0x01, 0x84, 0x6a, 0x61, 0x76, 0x61, 0x01, 0x84, 0x6c, 0x61, 0x6e, 0x67, 0x02, 0x82, 0x92, 0x93, 0x01, 0x86, + 0x53, 0x5d, 0x72, 0x69, 0x6c, 0x67, 0x02, 0x82, 0x94, 0x95, 0x3f, 0x83, 0x88, 0x91, 0x96, 0x01, 0xa9, 0x6c, 0x69, 0x62, + 0x72, 0x61, 0x72, 0x79, 0x2f, 0x73, 0x72, 0x63, 0x2f, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x75, 0x6e, 0x72, 0x6f, 0x6c, 0x6c, 0x2e, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x02, 0x82, + 0x83, 0x84, 0x3f, 0x83, 0x88, 0x99, 0x96, 0x01, 0x9e, 0x75, 0x6e, 0x64, 0xa3, 0x8d, 0xdf, 0x8d, 0x9a, 0x89, 0x96, 0x9a, + 0x77, 0x20, 0x61, 0x73, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x53, 0x49, 0x50, 0x2d, 0x34, 0x36, 0x01, + 0x89, 0x50, 0x6f, 0xd7, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x01, 0x88, 0x41, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x01, 0x8a, 0x41, 0x74, 0x74, 0x72, 0x69, 0x62, 0x81, 0x74, 0x6d, 0x72, 0x80, 0xd5, 0x84, 0x83, 0x72, 0xdd, 0x2e, 0x47, + 0xe1, 0x13, 0x24, 0x38, 0x40, 0x40, 0x81, 0x4b, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x86, 0x86, + 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x0f, 0x0f, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, + 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x9e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0x85, 0x02, 0x03, 0x04, 0x81, 0x98, + ) ) +} diff --git a/compiler/test/dotty/tools/dotc/parsing/ParserEdgeTest.scala b/compiler/test/dotty/tools/dotc/parsing/ParserEdgeTest.scala index 801a8f6bc23d..03e89b6d037a 100644 --- a/compiler/test/dotty/tools/dotc/parsing/ParserEdgeTest.scala +++ b/compiler/test/dotty/tools/dotc/parsing/ParserEdgeTest.scala @@ -4,10 +4,52 @@ package parsing import ast.untpd.* import core.Constants.* +import core.Decorators.* import org.junit.Test +import org.junit.Assert.assertTrue class ParserEdgeTest extends ParserTest { + def verifyXML(text: String)(p: Tree => Boolean): Unit = + val t = parseText(text) + t.checkPos(nonOverlapping = true) + assertTrue("predicate failed", p(t)) + + @Test def `i6547 xml blocks should be correctly positioned`: Unit = + val code = + i""" + |class Foo { + | + |} + """ + verifyXML(code)(_ => true) + + @Test def `i15574 span of xml literal with windows line separators`: Unit = + val code = + i""" + |object Test { + | Nil.map { _ => + | + | + | } + |} + """ + extension (text: String) def convertToLineSeparator(sep: String): String = text.linesIterator.map(_ + sep).mkString + val crlfCode = code.convertToLineSeparator("\r\n") + val lfCode = code.convertToLineSeparator("\n") + def verifyTreeHasSpans(text: String): Unit = + val x0 = text.indexOf('<') + val x1 = text.indexOf('>', x0+1) + 1 + val y0 = text.indexOf('<', x1+1) + val y1 = text.indexOf('>', y0+1) + 1 + def treeHasSpan(tree: Tree, start: Int, end: Int): Boolean = + tree.existsSubTree(t => t.span.exists && t.span.start == start && t.span.end == end) + verifyXML(text)(tree => treeHasSpan(tree, x0, x1) && treeHasSpan(tree, y0, y1)) + + assert(crlfCode != lfCode) // check construction + verifyTreeHasSpans(crlfCode) + verifyTreeHasSpans(lfCode) + // // CR after right brace of interpolated expression was stripped. // @@ -19,15 +61,15 @@ class ParserEdgeTest extends ParserTest { val text = s"""class C { def g = "X" ; def f = s${triple}123${CR}${NL}$${g}${CR}${NL}456${triple} }""" def isStripped(s: String) = s.contains(NL) && !s.contains(CR) - // sanity check + // check construction assert(text.linesIterator.size == 3, s"line count ${text.linesIterator.size}") assert(text.linesIterator.forall(!isStripped(_))) val t = parseText(text) //println(t.show) - assert(!t.existsSubTree { + assertTrue(!t.existsSubTree { case Literal(const @ Constant(_)) if const.tag == StringTag => isStripped(const.stringValue) - case st => false + case _ => false }) } /* was: diff --git a/compiler/test/dotty/tools/dotc/parsing/ScannerTest.scala b/compiler/test/dotty/tools/dotc/parsing/ScannerTest.scala index 65548ebbae95..120370631a49 100644 --- a/compiler/test/dotty/tools/dotc/parsing/ScannerTest.scala +++ b/compiler/test/dotty/tools/dotc/parsing/ScannerTest.scala @@ -48,7 +48,6 @@ class ScannerTest extends DottyTest { @Test def scanList() = { - println(System.getProperty("user.dir")) scan("compiler/src/dotty/tools/dotc/core/Symbols.scala") scan("compiler/src/dotty/tools/dotc/core/Symbols.scala") } diff --git a/compiler/test/dotty/tools/dotc/printing/PrintingTest.scala b/compiler/test/dotty/tools/dotc/printing/PrintingTest.scala index 703e21b8398c..dfdaf46c8c47 100644 --- a/compiler/test/dotty/tools/dotc/printing/PrintingTest.scala +++ b/compiler/test/dotty/tools/dotc/printing/PrintingTest.scala @@ -12,7 +12,6 @@ import reporting.TestReporter import java.io.* import java.nio.file.{Path => JPath} -import java.lang.System.{lineSeparator => EOL} import java.nio.charset.StandardCharsets import interfaces.Diagnostic.INFO @@ -46,6 +45,7 @@ class PrintingTest { case e: Throwable => println(s"Compile $path exception:") e.printStackTrace() + throw e } val actualLines = byteStream.toString(StandardCharsets.UTF_8.name).linesIterator @@ -54,7 +54,7 @@ class PrintingTest { def testIn(testsDir: String, phase: String) = val res = Directory(testsDir).list.toList - .filter(_.ext.isScalaOrJava) + .filter(_.ext.isSourceExtension) .map(f => compileFile(f.jpath, phase)) val failed = res.filter(!_) diff --git a/compiler/test/dotty/tools/dotc/reporting/CodeActionTest.scala b/compiler/test/dotty/tools/dotc/reporting/CodeActionTest.scala index e7d52da4c8f3..f58758e39bd4 100644 --- a/compiler/test/dotty/tools/dotc/reporting/CodeActionTest.scala +++ b/compiler/test/dotty/tools/dotc/reporting/CodeActionTest.scala @@ -303,6 +303,220 @@ class CodeActionTest extends DottyTest: ctxx = ctxx ) + @Test def insertMissingSingleMethodToNonEmptyClass = + checkCodeAction( + code = + """trait Animal { + | def name: String + |} + |class Dog extends Animal { + | def bbb = 2 + |} + |""".stripMargin, + title = "Add missing methods", + expected = + """trait Animal { + | def name: String + |} + |class Dog extends Animal { + | def bbb = 2 + | def name: String = ??? + |} + |""".stripMargin, + afterPhase= "erasure" + ) + + @Test def insertMissingMethodsFromMultipleSources = + checkCodeAction( + code = + """trait Animal { + | def name: String + |} + |trait Car { + | def wheels: Int + |} + |class Dog extends Animal with Car { + |} + |""".stripMargin, + title = "Add missing methods", + expected = + """trait Animal { + | def name: String + |} + |trait Car { + | def wheels: Int + |} + |class Dog extends Animal with Car { + | def name: String = ??? + | def wheels: Int = ??? + |} + |""".stripMargin, + afterPhase= "erasure" + ) + + @Test def insertMissingMethodIntoEmptyClassWithBrackets = + checkCodeAction( + code = + """trait Animal { + | def name: String + |} + |class Dog extends Animal {} + |""".stripMargin, + title = "Add missing methods", + expected = + """trait Animal { + | def name: String + |} + |class Dog extends Animal { + | def name: String = ??? + |} + |""".stripMargin, + afterPhase= "erasure" + ) + + @Test def insertMissingMethodIntoEmptyClassWithoutBrackets = + checkCodeAction( + code = + """trait Animal { + | def name: String + |} + |class Dog extends Animal + |""".stripMargin, + title = "Add missing methods", + expected = + """trait Animal { + | def name: String + |} + |class Dog extends Animal { + | def name: String = ??? + |} + |""".stripMargin, + afterPhase= "erasure" + ) + + @Test def insertMissingMethodIntoNonEmptyClassWithBraclessSyntax = + checkCodeAction( + code = + """trait Animal { + | def name: String + |} + |class Dog extends Animal: + | def bbb = 2 + |""".stripMargin, + title = "Add missing methods", + expected = + """trait Animal { + | def name: String + |} + |class Dog extends Animal: + | def bbb = 2 + | def name: String = ??? + |""".stripMargin, + afterPhase= "erasure" + ) + + @Test def insertMissingMethodsIntoMultilineClassDefinition = + checkCodeAction( + code = + """trait Animal { + | def name: String + |} + |trait Car { + | def wheels: Int + |} + |class Dog extends Animal + | with Car { + |} + |""".stripMargin, + title = "Add missing methods", + expected = + """trait Animal { + | def name: String + |} + |trait Car { + | def wheels: Int + |} + |class Dog extends Animal + | with Car { + | def name: String = ??? + | def wheels: Int = ??? + |} + |""".stripMargin, + afterPhase= "erasure" + ) + + @Test def makeClassAbstract = + checkCodeAction( + code = + """trait Animal { + | def name: String + |} + |class Dog extends Animal + |""".stripMargin, + title = "Make `Dog` abstract", + expected = + """trait Animal { + | def name: String + |} + |abstract class Dog extends Animal + |""".stripMargin, + afterPhase = "erasure" + ) + + @Test def makeClassAbstractKeepsModifiers = + checkCodeAction( + code = + """trait Animal { + | def name: String + |} + |sealed class Dog extends Animal + |""".stripMargin, + title = "Make `Dog` abstract", + expected = + """trait Animal { + | def name: String + |} + |abstract sealed class Dog extends Animal + |""".stripMargin, + afterPhase = "erasure" + ) + + @Test def noMakeAbstractForCaseClass = + assertNoActionWithTitle( + code = + """trait Animal { + | def name: String + |} + |case class Dog() extends Animal + |""".stripMargin, + title = "Make `Dog` abstract", + afterPhase = "erasure" + ) + + @Test def noMakeAbstractForFinalClass = + assertNoActionWithTitle( + code = + """trait Animal { + | def name: String + |} + |final class Dog extends Animal + |""".stripMargin, + title = "Make `Dog` abstract", + afterPhase = "erasure" + ) + + @Test def noMakeAbstractForObject = + assertNoActionWithTitle( + code = + """trait Animal { + | def name: String + |} + |object Dog extends Animal + |""".stripMargin, + title = "Make `Dog$` abstract", + afterPhase = "erasure" + ) + // Make sure we're not using the default reporter, which is the ConsoleReporter, // meaning they will get reported in the test run and that's it. private def newContext = @@ -318,11 +532,10 @@ class CodeActionTest extends DottyTest: val diagnostic = diagnostics.head val actions = diagnostic.msg.actions.toList - assertEquals("Expected exactly one action", 1, actions.size) - - // TODO account for more than 1 action - val action = actions.head - assertEquals(action.title, title) + val action = actions.find(_.title == title).getOrElse: + assertFailed( + s"Expected an action titled '$title', but found: " + + (if actions.isEmpty then "none" else actions.map(a => s"'${a.title}'").mkString(", "))) val patches = action.patches.toList if patches.nonEmpty then patches.reduceLeft: (p1, p2) => @@ -337,3 +550,14 @@ class CodeActionTest extends DottyTest: start + patch.replacement + ending assertEquals(expected, result) + + private def assertNoActionWithTitle(code: String, title: String, afterPhase: String = "typer", ctxx: Context = newContext) = + ctx = ctxx + val runCtx = checkCompile(afterPhase, code) { (_, _) => () } + val diagnostics = runCtx.reporter.removeBufferedMessages + assertEquals("Expected exactly one diagnostic", 1, diagnostics.size) + val actions = diagnostics.head.msg.actions.toList + assert( + !actions.exists(_.title == title), + s"Did not expect action '$title', but it was offered. Found: ${actions.map(_.title).mkString(", ")}" + ) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 20cac8e7b321..0820a0d13646 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -8,7 +8,6 @@ import java.nio.file.* import java.nio.charset.StandardCharsets import java.util.stream.Collectors import java.util.Comparator -import scala.util.control.NonFatal import scala.collection.mutable import scala.jdk.CollectionConverters.* import javax.tools.ToolProvider diff --git a/compiler/test/dotty/tools/dotc/transform/PatmatExhaustivityTest.scala b/compiler/test/dotty/tools/dotc/transform/PatmatExhaustivityTest.scala index 8b614865b310..a68ff2053660 100644 --- a/compiler/test/dotty/tools/dotc/transform/PatmatExhaustivityTest.scala +++ b/compiler/test/dotty/tools/dotc/transform/PatmatExhaustivityTest.scala @@ -52,7 +52,7 @@ class PatmatExhaustivityTest { /** A single test with multiple files grouped in a folder */ private def compileDir(path: JPath): Boolean = { val files = Directory(path).list.toList - .filter(_.ext.isScalaOrJava) + .filter(_.ext.isSourceExtension) .map(_.jpath) val actualLines = compile(files) diff --git a/compiler/test/dotty/tools/dotc/typer/SIP67Tests.scala b/compiler/test/dotty/tools/dotc/typer/SIP67Tests.scala index decdb4f3db80..5a4b40da394a 100644 --- a/compiler/test/dotty/tools/dotc/typer/SIP67Tests.scala +++ b/compiler/test/dotty/tools/dotc/typer/SIP67Tests.scala @@ -36,9 +36,25 @@ class SIP67Tests extends DottyTest: sealed trait Foo object Foo: - case object Bar extends Foo + object Bar extends Foo val _ = (??? : Foo) match case Foo.Bar => """ + + @Test + def sip67test3: Unit = + checkNoErrors: + """ + import scala.language.strictEquality + import scala.language.experimental.strictEqualityPatternMatching + + sealed trait Foo[A] + object Foo: + object Bar extends Foo[Int] + + def a[A](a: Foo[A]) = + a match + case Foo.Bar => + """ diff --git a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala index 5eaca78f4980..20ae41ccd3b7 100644 --- a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala +++ b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala @@ -16,7 +16,9 @@ import scala.collection.mutable, mutable.ArrayBuffer, mutable.ListBuffer import scala.io.{Codec, Source} import scala.jdk.CollectionConverters.* import scala.util.{Random, Try, Using} -import scala.collection.mutable.ListBuffer +import scala.util.control.NonFatal +import scala.util.matching.Regex +import scala.util.Properties.{isJavaAtLeast, javaSpecVersion} import dotc.{Compiler, Driver} import dotty.tools.dotc.CoverageSupport @@ -27,6 +29,7 @@ import dotc.reporting.{Reporter, TestReporter} import dotc.reporting.Diagnostic import dotc.util.{SourceFile, SourcePosition, Spans, NoSourcePosition} import io.AbstractFile +import util.chaining.* /** A parallel testing suite whose goal is to integrate nicely with JUnit * @@ -199,16 +202,15 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: flags: TestFlags, outDir: JFile )(using val group: TestGroup) extends TestSource { + import SeparateCompilationSource.* case class Group(ordinal: Int, compiler: String) - lazy val compilationGroups: List[(Group, Array[JFile])] = - val Compiler = """c([\d\.]+)""".r - val Ordinal = """(\d+)""".r + lazy val compilationGroups: List[(Group, Array[JFile])] = { def groupFor(file: JFile): Group = val groupSuffix = file.getName.dropWhile(_ != '_').stripSuffix(".scala").stripSuffix(".java") val groupSuffixParts = groupSuffix.split("_") - val ordinal = groupSuffixParts.collectFirst { case Ordinal(n) => n.toInt }.getOrElse(Int.MinValue) - val compiler = groupSuffixParts.collectFirst { case Compiler(c) => c }.getOrElse("") + val ordinal = groupSuffixParts.collectFirst { case GroupOrdinal(n) => n.toInt }.getOrElse(Int.MinValue) + val compiler = groupSuffixParts.collectFirst { case CompilerVersion(c) => c }.getOrElse("") Group(ordinal, compiler) dir.listFiles @@ -217,15 +219,32 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: .toList .sortBy { (g, _) => (g.ordinal, g.compiler) } .map { (g, f) => (g, f.sorted) } + } def sourceFiles = compilationGroups.map(_._2).flatten.toArray def checkFileBasePathCandidates: Array[String] = Array(dir.getPath) } + object SeparateCompilationSource: + val CompilerVersion = """c([\d\.]+)""".r + val HasCompilerVersion = """_c([\d\.]+)""".r.unanchored + val GroupOrdinal = """(\d+)""".r + /** Skip if there are no sources, such as in a spurious directory, + * or when compiling with a legacy compiler which may not run under this jdk. + */ protected def shouldSkipTestSource(testSource: TestSource): Boolean = - testSource.sourceFiles.length == 0 + val files = testSource.sourceFiles + files.length == 0 + || + !TestConfiguration.usingBaselineJava + && + testSource.match + case separate: SeparateCompilationSource => + separate.compilationGroups.exists((group, _) => group.compiler.nonEmpty) + case _ => + files.exists(f => SeparateCompilationSource.HasCompilerVersion.matches(f.getName)) protected def shouldReRun(testSource: TestSource): Boolean = failedTests.forall(rerun => testSource match { @@ -246,7 +265,15 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: Try(testSource match { case testSource @ JointCompilationSource(name, files, flags, outDir, fromTasty, decompilation) => val reporter = fromTasty match - case NotFromTasty => compile(testSource.sourceFiles, flags, outDir) + case NotFromTasty => + if testSource.sourceFiles.length == 1 then + testSource.sourceFiles(0).getName match + case SeparateCompilationSource.HasCompilerVersion(version) => + val compiler = version.stripSuffix(".") + compileWithOtherCompiler(compiler, testSource.sourceFiles, flags, outDir) + case _ => compile(testSource.sourceFiles, flags, outDir) + else + compile(testSource.sourceFiles, flags, outDir) case FromTasty => compileFromTasty(flags, outDir) case FromBestEffortTasty => compileFromBestEffortTasty(flags, outDir) case WithBestEffortTasty(bestEffortDir) => compileWithBestEffortTasty(testSource.sourceFiles, bestEffortDir, flags, outDir) @@ -487,7 +514,6 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: throw e protected def compile(files0: Array[JFile], flags0: TestFlags, targetDir: JFile): TestReporter = { - import scala.util.Properties.* def flattenFiles(f: JFile): Array[JFile] = if (f.isDirectory) f.listFiles.flatMap(flattenFiles) @@ -630,7 +656,7 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: case Nil => Nil flags.copy(options = loop(flags.options.toList).toArray) - protected def compileWithOtherCompiler(compiler: String, files: Array[JFile], flags: TestFlags, targetDir: JFile): TestReporter = + protected def compileWithOtherCompiler(compiler: String, files: Array[JFile], flags: TestFlags, targetDir: JFile): TestReporter = { def artifactClasspath(organizationName: String, moduleName: String) = import coursier.* val dep = Dependency( @@ -690,6 +716,8 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: } reporter + } + end compileWithOtherCompiler protected def compileFromBestEffortTasty(flags0: TestFlags, targetDir: JFile): TestReporter = { val classes = flattenFiles(targetDir).filter(isBestEffortTastyFile).map(_.toString) @@ -958,10 +986,12 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: lazy val actualErrors = reporters.foldLeft(0)(_ + _.errorCount) lazy val (expected, unexpected) = getMissingExpectedErrors(errorMap, reporters.iterator.flatMap(_.errors)) def hasMissingAnnotations = expected.nonEmpty || unexpected.nonEmpty + def showLines(title: String, lines: Seq[String]) = + if lines.isEmpty then "" else lines.mkString(s"$title\n", "\n", "") def showErrors = "-> following the errors:\n" + reporters.flatMap(_.allErrors.sortBy(_.pos.line).map(e => s"${e.pos.line + 1}: ${e.message}")).mkString(" at ", "\n at ", "") - Option { + Option: if actualErrors == 0 then s"\nNo errors found when compiling neg test $testSource" else if expectedErrors == 0 then s"""|No expected errors marked in $testSource -- use // error or // nopos-error @@ -978,13 +1008,12 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: |""".stripMargin.trim.linesIterator.mkString("\n", "\n", "") else if hasMissingAnnotations then s"""|Errors found on incorrect row numbers when compiling $testSource + |${showLines("Unfulfilled expectations:", expected)} + |${showLines("Unexpected errors:", unexpected)} |$showErrors - |${expected.mkString("Unfulfilled expectations:\n", "\n", "")} - |${unexpected.mkString("Unexpected errors:\n", "\n", "")} |""".stripMargin.trim.linesIterator.mkString("\n", "\n", "") else if !errorMap.isEmpty then s"\nExpected error(s) have {=}: $errorMap" else null - } end maybeFailureMessage override def onSuccess(testSource: TestSource, reporters: Seq[TestReporter], logger: LoggedRunnable): Unit = @@ -1532,6 +1561,8 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: * target all files are grouped according to the file suffix `_X` where `X` * is a number. These groups are then ordered in ascending order based on * the value of `X` and each group is compiled one after the other. + * A file can request compilation by a legacy compiler via a version suffix: + * `A_1_c3.2.0.scala` in group 1 is compiled by 3.2.0 when testing under the minimum supported JDK. * * For this function to work as expected, we use the same convention for * directory layout as the old partest. That is: @@ -1555,8 +1586,14 @@ trait ParallelTesting extends RunnerOrchestration with CoverageSupport: !isPicklerTest || source.compilationGroups.length == 1 } val targets = - files.map(f => JointCompilationSource(testGroup.name, Array(f), flags, createOutputDirsForFile(f, sourceDir, outDir))) ++ - dirs.map { dir => SeparateCompilationSource(testGroup.name, dir, flags, createOutputDirsForDir(dir, sourceDir, outDir)) }.filter(picklerDirFilter) + files.map: f => + val out = createOutputDirsForFile(f, sourceDir, outDir) + JointCompilationSource(testGroup.name, Array(f), flags, out) + ++ + dirs.map: dir => + val out = createOutputDirsForDir(dir, sourceDir, outDir) + SeparateCompilationSource(testGroup.name, dir, flags, out) + .filter(picklerDirFilter) // Create a CompilationTest and let the user decide whether to execute a pos or a neg test new CompilationTest(targets) diff --git a/compiler/test/dotty/tools/vulpix/RunnerOrchestration.scala b/compiler/test/dotty/tools/vulpix/RunnerOrchestration.scala index e3fc684edd47..984f7b793c3c 100644 --- a/compiler/test/dotty/tools/vulpix/RunnerOrchestration.scala +++ b/compiler/test/dotty/tools/vulpix/RunnerOrchestration.scala @@ -63,7 +63,7 @@ trait RunnerOrchestration: def cleanup() = monitor.killAll() private val monitor = new RunnerMonitor - export monitor.{debugMain/*, runMain*/} + export monitor.debugMain def runMain(classPath: String, toolArgs: ToolArgs)(using SummaryReporting): Status = monitor.runMain(classPath, toolArgs) // scala-js overrides and requires toolArgs @@ -129,10 +129,8 @@ trait RunnerOrchestration: def launch(): Unit = mainFuture = startMain(classPath) def exit(): Status = awaitStatus(mainFuture.nn) - try - f(debuggee) - debuggee.exit() - catch case e: Throwable => Failure("Bad debug") + f(debuggee) + debuggee.exit() end debugMain private def startMain(classPath: String): Future[Status] = { @@ -182,7 +180,7 @@ trait RunnerOrchestration: val url = classOf[ChildJVMMain.type].getProtectionDomain.getCodeSource.getLocation val cp = Paths.get(url.toURI).toString + JFile.pathSeparator + Properties.scalaLibrary val javaBin = Paths.get(sys.props("java.home"), "bin", "java").toString - val args = Seq("-Dfile.encoding=UTF-8", "-Duser.language=en", "-Duser.country=US", "-Xmx1g", "-cp", cp) ++ + val args = Seq("-ea", "-Dfile.encoding=UTF-8", "-Duser.language=en", "-Duser.country=US", "-Xmx1g", "-cp", cp) ++ (if debugMode then Seq("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,quiet=n") else Seq.empty) val command = (javaBin +: args) :+ "dotty.tools.vulpix.ChildJVMMain" val process = new ProcessBuilder(command*) diff --git a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala index 9049e6736c41..b21c5580632f 100644 --- a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala +++ b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala @@ -3,11 +3,16 @@ package tools package vulpix import scala.language.unsafeNulls +import scala.util.Properties.javaSpecVersion import java.io.File +import dotc.config.ScalaSettingsProperties.supportedReleaseVersions + object TestConfiguration { + val usingBaselineJava = javaSpecVersion.startsWith(supportedReleaseVersions.headOption.getOrElse("17")) + val pageWidth = 120 val noCheckOptions = Array( @@ -59,7 +64,8 @@ object TestConfiguration { Properties.jlineReader, Properties.fansi, Properties.pprint, - Properties.sourcecode + Properties.sourcecode, + Properties.scalaXml )) lazy val replWithStagingClasspath = @@ -103,6 +109,9 @@ object TestConfiguration { val explicitNullsOptions = defaultOptions `and` "-Yexplicit-nulls" + val oldSyntax = defaultOptions `and` "-old-syntax" + val newSyntax = defaultOptions `and` "-new-syntax" + /** Default target of the generated class files */ private def defaultTarget: String = "17" } diff --git a/docs/_docs/contributing/debugging/inspection.md b/docs/_docs/contributing/debugging/inspection.md index f1a60da9f905..5f5dc72cdb24 100644 --- a/docs/_docs/contributing/debugging/inspection.md +++ b/docs/_docs/contributing/debugging/inspection.md @@ -61,10 +61,10 @@ Sometimes you may want to stop the compiler after a certain phase, for example t knock-on errors from occurring from a bug in an earlier phase. Use the flag `-Ystop-after:` to prevent any phases executing afterwards. -> e.g. `-Vprint:` where `phase` is a miniphase, will print after -> the whole phase group is complete, which may be several miniphases after `phase`. -> Instead you can use `-Ystop-after: -Vprint:` to stop -> immediately after the miniphase and see the trees that you intended. +> Note: `-Ystop-after:` stops after the whole phase group containing +> `` (a MegaPhase fuses its mini-phases into one traversal). +> Combined with `-Vprint:`, the printed trees reflect the state at +> the end of the group, which may include mini-phases after ``. ## Printing TASTy of a Class diff --git a/docs/_docs/internals/inline-traits.md b/docs/_docs/internals/inline-traits.md new file mode 100644 index 000000000000..80a63ff5d162 --- /dev/null +++ b/docs/_docs/internals/inline-traits.md @@ -0,0 +1,436 @@ +# Inline Traits + +## Motivation +Inline traits is a new attempt to solve the specialization problem for the JVM in a more convenient way than the `@specialized` annotation +from Scala 2 (the main problem of this being code bloat as we generated all possible specializations at declaration time of the specialized +class). Inline traits work alongside `Specialized` traits, the latter being detailed in an accompanying document. + +The problem is as follows: due to the JVM's (lack of) support for generics, generic type parameters are erased by the compiler: +```scala +class A[T](val x: T) + +class C: + val w1 = A[Int](1) + val w2 = A[Int](2) + val w3 = A[Int](w1.x + w2.x) +``` +Is converted to: +```scala +class A: + val x: Object +class C() extends Object() { + def w1(): A = new A(Int.box(1)) + def w2(): A = new A(Int.box(2)) + def w3(): A = new A(Int.box(Int.unbox(this.w1().x()).+(Int.unbox(this.w2().x())))) +} +``` +Thus type `T` is converted to `Object`, and so every use of `A[Int]()` must first build an `Object` containing the `Int` we want to pass (*boxing*), +in order to be able to call `A(x: Object)`. There is no `A(x: int)`. When referencing `x` on an `A` we get an `Object` back, which we have to *unbox* +(extract from the wrapping `Object`). + +This object creation and deletion is very slow. We desire a way to avoid this by generating specialized instances of classes which +use primitive types instead of `Object`. These can be used in situations where the (un)boxing overhead is likely to be high. + +## Solution +An inline trait is defined just like a normal trait, but with an `inline` modifier. + +Inline traits may be freely extended by objects, classes or other inline traits. An inline trait may also be extended by an ordinary trait, but only if the inline trait does not take parameters [***]. + +The following is an example of the use of an `inline trait`. + +```scala +inline trait A[T](val x: T): + def foo: T = x + +class B extends A[Int](1) +``` +Let the term *inline trait* refer to traits such as `A` above, and let *inline receiver* refer to class-likes +we inline into, such as `B` above. + +When an inline trait is inherited by an object, class or another inline trait, all its contents are inlined, and adapted +to the context of the inline receiver. In particular this means that: +- references to type parameters of the inline trait are specialized to the type arguments provided during extension +- `this` calls are updated to refer to the inline receiver. + +Inline traits are themselves translated to pure interfaces. However their bodies are of course retained in Tasty files; this +enables us to inline them into inline receivers that exist in different compilation units (for example when an inline recevier +in user code extends an inline trait from a library). + +The example above generates: +```scala +// Inline trait converted to pure interface +inline trait A[T](x: T): + val x: T + def foo: T + +// Extending class now contains inlined body +// with references to T specialized to Int. +// this.x refers to B.x +class B extends A[Int](1): + override val x: Int = 1 + override def foo: Int = this.x +``` + +With multiple inline traits: + +```scala +inline trait A[T](val x: T): + def foo: T = x + +inline trait B extends A[Int] +class C extends B, A[Int](1) +``` + +```scala +inline trait A[T](x: T): + val x: T + def foo: T + +inline trait B extends A[Int]: + override def x: Int + override def foo: Int + +class C extends B, A[Int](1): + override def x = 1 + override def foo = x +``` +[!] This may be surprising compared to inline methods, as calls to inline methods from other inline methods are only inlined +when the outer inline method is inlined. While it is not immediately obvious why permitting inline traits to be inlined into other inline traits is useful (we could simply +inline everything into the first receiver which is not inline in the hierarchy), it becomes advantageous when we bring in the `Specialized` annotation; see the accompanying document. +Of course, patterns creating cycles of inlining are banned: + +```scala +inline trait C[S]: + def v(x: S): S = x + def w: Unit = + val x = new D[S] {} + println("w") + +inline trait D[S]: + def v(x: S): S = x + def w: Unit = + val x = new C[S] {} + println("w") + +``` + +Furthermore: +- References to members of inline traits accessed on inline receivers point to the inlined version, to ensure we avoid unnecessary boxing: [1] +```scala +inline trait A[T](val x: T): + def foo#1: T + +class B extends A[Int](1) + def foo#2: T = x + +def fun(x: B) = + x.foo // points to foo#2 +``` +- Inline traits may define private members, and these are handled specially: [2] + - Private fields in the inline trait are inlined as private fields with a mangled name in the inline receiver. This ensures they do not collide with privates inherited from other inline traits. + - The private fields are then no longer accessible in the inline trait, as it is transformed into a pure interface, so we delete them. + +```scala +inline trait A(b: Boolean): + private val x: Int = 1 + def foo(): Int = if b then x + 1 else 0 + +class B extends A(true) +``` +Is converted to: + +```scala +inline trait A(b: Boolean): + def foo(): Int + +class B extends A(true): + private val A$$b: Boolean = true + private val A$$x: Int = 1 + override def foo(): Int = if this.A$$b then this.A$$x.+(1) else 0 +``` +- An inline receiver may mix in multiple inline traits with colliding member names. This follows the same rules as normal traits. In particular, this must usually be disambiguated with an override. +```scala +inline trait A: + def foo = "Hello World" + +inline trait B: + def foo = "Bonjour" + +class C extends A, B // error: C inherits conflicting members A.foo and B.foo +``` +A typical way to disambiguate would be using `super`. For example: +```scala +class C extends A, B: + override def foo = super[A].foo +``` +This syntax is supported for inline traits. Note however that as inline traits are converted to pure interfaces it is not possible to make a direct call to the +method on A or B. Furthermore if we allowed this, specialization would be lost. Therefore, overridden methods are inlined into the inline receiver with a mangled name, +e.g. `A$$foo$`, `B$$foo` and the `override def foo` in `C` will delegate to one of these methods. Super calls to non-overridden methods are also supported. +These are transformed to point directly to the corresponding inlined methods with no need for name mangling. + +- **Interaction with other types of inline**: + + - Inline traits may define inline members (e.g. `inline def`, `inline val`). References to these are inlined as the body of the trait is inlined into the inline receiver, but the members themselves are not inlined and are deleted from the parent trait. E.g.: + + ```scala + inline trait A: + inline val x = 1 + + class B extends A: + def f = x + ``` + + becomes: + + ```scala + inline trait A + class B extends A: + def f = 1 + ``` + - As is usual, `inline val`s must have constant value types. In particular this means that they may not take the value of a parameter to the inline trait: + + ```scala + inline trait A[T](x: T): + inline val y = 1 + inline val a = y // ok + inline val z = x // Not ok + ``` + +- There is the potential for name clashes between members / parameters of inline traits and parameters / members of inline receivers. These are handled in the following way: + +| Inline Trait Member Type | Inline Receiver Member Type | Behaviour | Justification | Same as `trait` | +|---------------------------------------|----------------------------------------------|-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------| +| `val` / `var` incl. `val`/`var` param | `val` / `var` incl. `val` / `var` param | Needs `override`| Ensures behaviour matches that of normal traits. However note that normal traits will warn if we try to override a val parameter. This warning is turned off for inline traits, otherwise every inline trait with a val parameter would warn after inlining. | ✅ | +| `val` / `var` incl. `val`/`var` param | Primary constructor (local) param | Not allowed | We cannot rename the constructor param because users may specify it by name when constructing the class, and we can't have a conflict with the generated parameter accessor, yet the parameter accessor and parameter must have the same name, so we end up with a conflict between the inlined val/var param and the constructor param. Therefore we have to ban this. | ❌ | +| `val` / `var` incl. `val`/`var` param | Method | Not allowed | As normal traits, without `override` will be told "needs override"; with `override` will be told "not a stable immutable value" | ✅ | +| Primary ctor (local) param | `val` / `var` incl. `val` / `var` param | Allowed | We need to inline the generated parameter accessors into the receiver, but these are renamed (prefixed with the inline trait name) when doing so, therefore fine. This does not affect the name in the original trait. | ✅ | +| Primary ctor (local) param | Primary constructor (local) param | Allowed | We need to inline the generated parameter accessors into the receiver, but these are renamed (prefixed with the inline trait name) when doing so, therefore fine. This does not affect the name in the original trait. | ✅ | +| Primary ctor (local) param | Method | Allowed | We need to inline the generated parameter accessors into the receiver, but these are renamed (prefixed with the inline trait name) when doing so, therefore fine. This does not affect the name in the original trait. | ✅ | +| Method | `val` / `var` incl. `val` / `var` param | Requires `override` | | ✅ | +| Method | Primary constructor (local) param | Allowed unless sig match | We have the same issue as with `val`/`var` params if the signature matches, so we need to ban it. Otherwise we allow it as in `trait`. | ❌ | +| Method | Method | Requires `override` | | ✅ | +| Type | Type | Allowed | Usual rules apply | ✅ | + +- Inline receivers may not access the parameters of their parents (these are private): +```scala +inline trait A(x: Int) + +class C extends A(10): + val y = x // error: Not Found Error +``` + +- Inlined members of inline traits are typed with the type of the right hand side resulting from inlining. This is particularly important for typeclass instances: +```scala +inline trait A[T: Numeric]: + private val v: Numeric[T] = summon[Numeric[T]] + +class B extends A[Int] +``` +Is converted to: +```scala +inline trait A[T: Numeric]: + private val v: Numeric[T] = summon[Numeric[T]] + +class B extends A[Int]: + private given val A$$evidence$1: Numeric.IntIsIntegral.type = Numeric.IntIsIntegral + private val A$$v: Numeric.IntIsIntegral = this.A$$evidence$1 +``` +This means that references to `v.fromInt()`, `v.add()` etc are optimised and avoid boxing. However, this type acquisition is only applied to non-var members, as it could +lead to unsoundness if applied to `var`s: + +```scala +inline trait Counter extends Iterator: + private var current: Int = 0 + def next(): Int = current += 1 +``` +Narrowing `current` to the type of the initializer here would give it type `0`. This makes the increment operation in `next()` illegal. + +- Inline methods defined inside an inline trait are inlined directly when the body is inlined. This means that they do not exist in the inline receivers. They are then deleted from the inline trait. + +[***] Why? +Consider: +```scala +inline trait A[T](x: T): + val y = x +trait B extends A[Int] +class C extends A[Int](10), B +``` +After inlining, `B.y` is defined in terms of `B.A$$x` (the inlined copy of the parameter accessor of `x`), but this is undefined as we don't have the parameter value in `B`. +In `C` this is not a problem as we have the parameter value `10`. Even if we try to provide the value by leaving `A$$x` abstract and overriding in `C` +this will not work as `B.A$$x` will still be undefined. + +Therefore there is no case in which this could be useful, and it is likely to cause confusion, so we ban it. +However, there is a reasonable case for `trait extends inline trait` in general, to control the inlining and reduce code duplication so we allow +this pattern if the inline trait has no parameters. + +Note that this restriction does not block `inline trait extends trait` or `inline trait extends class` which are allowed with one (other) restriction: + - Inline traits may not contain `super` references to classes or non-inline traits. This is because `super` references in scala may only reference + direct parents, and, after inlining, those references that were to direct parents in the original inline traits would now have to point to ancestor // TODO: I think this ought to be fine actually because we can just call into the inline trait + classes which are further than 1 hop away. + +## Benefits of inline traits +We can now do the following with no boxing and unboxing: +```scala +inline trait A[T](val x: T) +class IntA(x: Int) extends A[Int](x) + +class C: + val w1 = IntA(1) + val w2 = IntA(2) + val w3 = IntA(w1.x + w2.x) +``` + +Inline traits avoid all of the pain points of Scala 2 specialization. They can do more than primitive specialization since they also specialize on value parameters and reference types. This helps avoid megamorphic dispatch. Inline traits also profit from all the optimizations available for inline methods, including inline matches, summonFrom, embedded splices. Indeed the analogy of inline traits and inline methods is strong: inline calls correspond to supercalls in extending classes and objects, inline parameters are inline parameters of the trait, inline traits can have nested inline matches, etc. + +Inline trait expansions are only generated on demand when a class or object extends an inline trait. This avoids the up-front cost and code explosion due to creating specialized copies which might never be needed. + +## Shortcoming of inline traits +Compared to full specialization, inline traits have one shortcoming, namely that interfaces are not specialized. For example: + +```scala +inline trait Foo[T](x: T): + def foo = x + +class Bar extends Foo[Int](42) + +def f(b: Foo[Int]) = 37 + b.foo + +@main def main = + val x = Bar() + f(x) +``` + +In this code the call to `b.foo` will refer to the version of `foo` typed `foo: T` which becomes `foo: Object` during erasure, because we accessed `foo` on +an object of declared type `Foo` (even though `b`'s actual runtime type is `Bar`). This will in turn call a bridge method which means the `foo: Int` method will be called, but unnecessary boxing and unboxing will be added: + +```scala +inline trait Foo + def foo#1(): Object + +class Bar extends Foo[Int](42): + override def foo#2(): Int = 42 + override def foo#3(): Object = Int.box(this.foo()) + +def f(b: Foo): Int = 37 + Int.unbox(b.foo#1()) // virtual call to foo#1 resolves to bridge method foo#3, which in turn calls actual method foo#2, with boxing. +``` + +This problem is addressed via `Specialized` traits; see the accompanying document on those. + +## Interaction with other language features + +| Language feature | Is currently supported inside inline traits? | +|-------------------------------------|----------------------------------------------| +| Methods | ✅ | +| `val` / `var` Properties | ✅ | +| Non-local private members [3] | ❌ | +| `type`s | ✅ | +| Inner classes/traits | ❌ [7] | +| Self types | ✅ [6] | +| Inheritance (of inline traits) | Only allowed by classes and inline traits | +| Instantiation of inline traits [4] | ✅ | +| Opaque types | ✅ [5] | + +[3] That is, members which are labelled private and accessed from within the class on other instances of the class. +Local private members (members with the same access patterns as the former `private[this]`) are allowed. + +[4] As long as this doesn't create a cycle e.g.: +```scala +inline trait C[S]: + def v(x: S): S = x + def w: Unit = + val x = new D[S] {} + println("w") + +inline trait D[S]: + def v(x: S): S = x + def w: Unit = + val x = new C[S] {} + println("w") + +class T extends D // error: Inlining of inline traits looped. Tried to inline trait D into its own body. +``` + +[5] Supported with same behaviour as in normal traits. In particular, the following is completely fine, and will be inlined into B. +```scala +inline trait A[T](val x: T): + opaque type Special = T + + def getSpecial: Special = x + def eatSpecial(y: Special) = "Mmm, that was tasty!" + +class B extends A[Int](100) +``` + +In contrast, it is not possible to use inlining to "cheat" opaque types, even though it is tempting to try to argue that +the opaque type will be inlined into B and therefore its alias should be visible. This is not allowed because type checking +is performed before inline traits, and this follows the logic that inline traits are an optimisation on top of normal traits, +rather than a semantic change to them. +```scala +inline trait A[T](val x: T): + opaque type Special = T + +class B extends A[Int](100): + def foo: Special = 10 // error: 10 does not conform to Special +``` + +[6] +Self types are supported but are not inlined. We argue this is desirable as it ensures that the behaviour of inline traits +with self types mirrors that of ordinary traits with self types. Inlining of self types would effectively remove any restictions that +these self types seek to impose because the subclass would automatically have a matching self type to that of the parent class. This +prevents an error from being thrown, irrespective of whether the subclass implements the desired traits. +Therefore, when using self types on inline traits, the behaviour observed is the following (as in ordinary traits) e.g.: +```scala +trait A[T]: + this: T1 => + +trait D extends A[Int] // error: self type of D does not conform to that of A +``` + +[7] +While inline traits may not directly define inner classes, they may contain methods which define classes within their bodies. + +## Processing of inline traits in the compiler +Inline traits in user code are inlined in the phase `specializeInlineTraits`. The phase `replaceInlinedTraitSymbols` +is responsible for updating references to members of inline receivers to point to the inlined members, instead of the +generic members in the parent inline trait (see [1] above). Finally the phase `pruneInlineTraits` is responsible for +converting inline traits into pure interfaces by removing their right hand sides. It also handles the mangling in [2]. + +Specialized traits rely on the semantics of inline traits, as they desugar to inline traits. However, the phase +`desugarSpecializedTraits` inlines these inline traits itself (sharing code with the `specializeInlineTraits` phase). +This is necessary because otherwise there would be a circular dependency between the two phases (see the Specialized traits +document for more information). This means that we need to run `specializeInlineTraits` *first* (because we don't want to inline +twice for inline traits resulting from specialization). + +## Internal Note regarding versions of inline traits +This behaviour is the same as that in Timothée's thesis except for the following points: + - We now allow inline traits to be inlined directly into other inline traits as well as objects and classes. + - We now do replacement of member accesses to point to the inlined versions throughout the whole code, not just in the bodies of inner classes + - He allows inline traits to contain inner classes in principle, however in practice they don't work which is why we ban them. + - We specialize types of member accesses on e.g. Numeric + - He in practice allows traits to extend inline traits although it doesn't work that well and there was some suggestion it should have been banned; we tighten/specify the rules on this: + - Trait extends inline trait is only allowed if the inline trait is parameterless + - Inline trait extends trait is always allowed + - We modify some of the rules around overrides and conflicting members in order to make the behaviour more consistent with ordinary traits. + In particular we require `override` in a number of locations where previously conflicts were resolved on the basis of "last extending trait wins". + - We also fix a number of bugs in the implementation, some of which have a minor effect on the processing and interaction with the rest of the compiler phases, e.g. we apply pruneInlineTraits slightly earlier than in the original implementation to avoid spurious warnings with -Wsafe-init, and we fix flags, and add support for nested inlines. + - We also implement some extra inlining such as opaque types, super references, and self types. + - We enforce a number of rules that were previously implicit, with proper errors. + - We do the RHS type narrowing for vals (not vars) described above as an optimisation + - We change the handling of private members in pruning of inline traits (we now delete them completely) + - We change the phase ordering since we conclude that inline trait inlining must happen before pickling to get the benefit of specialization + across compilation units. Otherwise with the following under separate compilation we will induce boxing: + +```scala +// File A.scala +inline trait IT[T]: + def foo(x: T): T = x + +class A extends IT[Int] + +// File B.scala +def main = + val a = new A() + val x: Int = a.foo(10) // leads to Int.unbox(a.foo(Int.box(10))) +``` + + This happens because when B.scala is compiled separately against the interface of A (derived from the pickled A.tasty) it will appear that A only supports the generic T interface (erasing to Object and so boxed), whereas it actually also has a specialized Int interface from inline trait inlining. If instead we inline before pickling we solve this problem as the generated interface is present in the pickle. There is precedent for some inlining before pickling in e.g. transparent inlines, and if one uses inline traits one expects code duplication (that's why it is opt-in) and therefore we argue this is not a problem in terms of the increased tasty file size that it leads to. diff --git a/docs/_docs/internals/specialized-traits.md b/docs/_docs/internals/specialized-traits.md new file mode 100644 index 000000000000..5dcff494dea9 --- /dev/null +++ b/docs/_docs/internals/specialized-traits.md @@ -0,0 +1,780 @@ +# Specialized Traits +Specialized traits accompany inline traits as a new attempt to solve to the specialization problem in Scala 3, replacing the `@specialized` annotation from Scala 2. + +As mentioned in the accompanying document on inline traits, inline traits have one shortcoming, namely that interfaces are not specialized. For example: + +```scala +inline trait Foo[T](x: T): + def foo = x + +class Bar extends Foo[Int](42) + +def f(b: Foo[Int]) = 37 + b.foo + +@main def main = + val x = Bar() + f(x) +``` + +In this code the call to `b.foo` will refer to the version of `foo` typed `foo: T` which becomes `foo: Object` during erasure, because we accessed `foo` on +an object of declared type `Foo` (even though `b`'s actual runtime type is `Bar`). This will in turn call a bridge method +which means the `foo: Int` method will be called, but unnecessary boxing and unboxing will be added: + +```scala +inline trait Foo + def foo#1(): Object + +class Bar extends Foo[Int](42): + override def foo#2(): Int = 42 + override def foo#3(): Object = Int.box(this.foo()) + +def f(b: Foo): Int = 37 + Int.unbox(b.foo#1()) // virtual call to foo#1 resolves to bridge method foo#3, which in turn calls actual method foo#2, adding boxing. +``` + +// TODO: I think we can rewrite this to talk about boxing maybe. Give a bit more background + + +Specialized traits seek to resolve this problem. We also want to avoid pro-actively generating all specializations (as in Scala 2 `@specialized`; code bloat), or monomorphising the whole program +(as in C++ templates; this leads to code bloat and long compile times, and is a problematic choice for binary APIs.) + +Specialized traits are an approach sitting between these two options. As in Scala 2, specialized type parameters are tagged explicitly (but with a context bound rather than an annotation). +However, as for monomorphization, specializations are only generated if a specialized type is referenced in the program. + +To make this work efficiently, we introduce a type class `Specialized` that is used as a context bound on a type parameter of some class. This allows us to transport information about +possible specialization types through generic code (full monomorphization does not need that since it eliminates all generic code). + +The `Specialized` annotation indicates that we want to create specialized versions of that class where the type parameter is instantiated to the type argument. +The specialized versions offer optimization opportunities compared to the generic class. + +## Example + +As a first example, consider a `Vec` trait for vectors over a numeric type. +```scala +import scala.math.Numeric + +inline trait Vec[T: {Specialized, Numeric}](elems: Array[T]): + private val num = summon[Numeric[T]] + + def length = elems.length + + def apply(i: Int): T = elems(i) + + def scalarProduct(other: Vec[T]): T = + require(this.length == other.length) + var result = num.fromInt(0) + for i <- 0 until length do + result = num.plus(result, num.times(this(i), other(i))) + result + +object Vec: + inline def apply[T: Specialized](elems: Array[T]) = new Vec[T](elems) {} +end Vec +``` +The idea is that we want to specialize vectors on the type parameter `T` in order to get important efficiency gains, including the following: + + - Use an array `arr` specialized to the actual element instead of a fully generic array that has to be accessed via reflection + - Avoid boxing for internal values like `result` + - Avoid boxing in the API for values like the result of `scalarProduct` + - Specialize on the concrete `Numeric` class instance for `T`, so that calls to `num`'s methods have static targets and can be inlined. + +In practice this means we create specialized instance traits of the form `inline trait Vec$sp$Int(elems: Array[Int])` and replace uses of `Vec[Int]` with `Vec$sp$Int`. This replacement happens as part of erasure. How this process works in detail is described below. + +## Expansion of Specialized Traits + +A _specialized trait_ is an inline trait that has at least one `Specialized` context bound. A specialized context bound (or its expansion to a context parameter) is only allowed for +type parameters of inline methods and inline traits. Regular methods or traits or classes +cannot take `Specialized[T]` parameters. + +**Definition**: A _simple class type_ is a reference to a static class that does not have type parameters. References to traits and references containing non-static prefixes or refinements are excluded. // TODO: This excludes List[_]. + +**Definition**: A _top class_ is one of `Any`, `AnyVal`, or `Object`. + +**Definition**: The _specializing supertype_ `SpecType(Tp)` of a type `Tp` is defined as follows: +- `SpecType(Nothing) = Nothing` + - `SpecType(Tp) =` the smallest (in the sense of smallest set of values that the type contains) simple class type `C` such that: + - `C` is a supertype of `Tp` + - The superclass of `C` is a top class, or `C` itself is a top class. + +The _erasure_ of `Vec[Tp]` where `SpecType(Tp) = C` is: + + - If `C` is one of the top classes `Any` or `AnyRef` or `AnyVal`, or if `C` is `Nothing` the usual erased trait `Vec`. + - If `C` is some other class, a new specialized instance trait with a name of the form `Vec$sp$TN`, + where `$sp$` is a fixed specialization marker and `TN` is an encoding of the fully qualified name of `C`. + +If there is more than one specialized type parameter, the specialized instance trait will reflect in its name all specializing supertypes of such type parameters in sequence. + +An anonymous class instance creation like `new Vec[T](elems) {}` expands to +an instance creation `new Vec$impl$TN(elems)` of a new _specialized instance class_ +named `Vec$impl$TN`. The class name derives from the trait name by replacing `$sp` with `$impl$`. The only exception is if the corresponding `$sp$` trait is simply the original trait +(because all Specialized arguments were specialized to top classes or `Nothing`). In this case, the specialized instance class will be named `Vec$impl`. + +The specialized instance traits are created on demand the first time they are mentioned in a type. For example, here is the definition of the specialized instance `Vec$sp$Int` for `Vec[Int]`: + +```scala +inline trait Vec$sp$Int extends Vec[Int] +``` + +In general a specialized interface trait that specializes an inline trait `A[T]` with a specialization type `S`: + + - drops all `Specialized` trait parameters of `A` + - adds `A[S]` as first parent trait + - _also_ adds all parents of `A` *in their specialized forms*, + - contains declarations from the body of `A` specialized to the type(s) in question (after inlining) + - Is an `inline trait`. This is for consistency; see [1]. + - Maintains type parameters for type params not marked with `Specialized` in the original trait, and also for specializations where the type *argument* is`T: Specialized', in the case of partial specializations. + - Does not take value parameters (including evidence parameters) + +A specialized instance class for an inline trait `A` at specialized argument `S` + + - repeats the value parameters of inline trait `A`, + - extends `A[S]` with these parameters + - extends the corresponding `$sp$` trait + +For example, here is the specialized instance class for `Vec` at `Int`: + +```scala +class Vec$impl$Int(elems: Array[T]) extends Vec[Int](elems), Vec$sp$Int +``` + +After inlining `Vec[Int]` the expanded class looks like this: +```scala +class Vec$impl$Int(elems: Array[Int])(using Numeric[Int]) extends Vec[Int](elems), Vec$sp$Int: + private val Vec$$num: Numeric.IntIsIntegral + + def length: Int = elems.length + def apply(i: Int): Int = elems(i) + + def scalarProduct(other: Vec$sp$Int): Int = + require(this.length == other.length) + var result = Vec$$num.fromInt(0) + for i <- 0 until length do + result = Vec$$num.plus(result, Vec$$num.times(this(i), other(i))) + result +``` + +After inlining and pruning of inlined definitions, the `$sp$` trait becomes the following: +```scala +inline trait Vec$sp$Int extends Vec[Int]: + def length: Int + def apply(x: Int): Int + def scalarProduct(other: Vec$sp$Int): Int +``` + + +## Creating Specialized Trait Instances +Creation of an object with specialized behaviour can occur in one of two ways: + - Instantiating a `class` or using an `object` which extends the specialized trait, specializing its type parameters. E.g.: +```scala +inline trait Foo[T: Specialized](x: T): + def foo: T = x + +class Bar extends Foo[Int](10): // Type parameter does of course not need to be specified explicitly here (it can be inferred from the value type of 10) + def myMethod = "Hello I am a method" + +// Both Baz and myBar will have specialized instances of foo. +object Baz extends Foo(12) +val myBar = Bar() +``` + - Instantiation of an anonymous class instance directly from the Specialized trait: `new A[Ts](ps1)...(psN) {}` where `A` is a specialized trait and the type parameters `Ts` and term parameters `ps1, ,,, psN` can also be absent. This has a special meaning, as it desugars to instantiating a _specialized instance class_ (see Expansion of Specialized Traits). This comes with the twin advantages that: + - there is no need for the boilerplate of manually defining an object/class to extend the specialized trait + - this specialized instance class is reused every time such an instance is created (there is no proliferation of anonymous classes). + + However, to facilitate this reuse, we must impose the following restrictions. Anonymous class instances acting as instances of Specialized traits: + - can extend only a single specialized trait [0], + - cannot mix in further classes or traits, and + - cannot contain member definitions. + + Should these restrictions be undesirable, the user can always create their own named `object` or `class` extending from a specialized trait (i.e. the first case for creation of a specialized object just above), which does not induce these restrictions. + +[0] Note that of course an anonymous class instance such as `new Foo[Int] {}` where `Foo` extends some other trait `Bar` desugars in the compiler to `new Bar[Int] with Foo[Int] {}`, which means we can't distinguish these two cases. Therefore we begrudgingly allow +`new Bar[Int] with Foo[Int] {}` although there is really no reason to use this in source code because it's exactly the same as writing `new Foo[Int] {}`. We disallow `new Foo[Int] with Bar[Int] {}` however. + +Note: This demonstrates that 'class extends specialized trait' and 'object extends specialized trait' are allowed. However, 'trait extends specialized trait' is not. This is due to the restriction on extending inline traits with parameters by ordinary traits, as discussed in `inline-traits.md`. 'inline trait extends specialized trait' is allowed as it is not subject to this restriction. + +## Variance and Specialized Traits +Specialized traits may define variance parameters e.g.: +```scala +inline trait MyFunction1[-T1: Specialized, +R: Specialized] +``` + +This would run into a problem in the contravariance case: +```scala +inline trait RecyclingBin[-T: Specialized]: + def recycle(x: T) = println(s"Recycling ${x}") + +def recycleAnInteger(bin: RecyclingBin[Int]) = + bin.recycle(100) + +recycleAnInteger(new RecyclingBin[Anyval]() {}) // RecyclingBin[AnyVal] can be interpreted as RecyclingBin[Int] due to contravariance +recycleAnInteger(new RecyclingBin[Any]() {}) // RecyclingBin[Any] can be interpreted as RecyclingBin[Int] due to contravariance + +// Yet, this erases to: + +def recycleAnInteger(bin: RecyclingBin$sp$Int) = + bin.recycle(100) +recycleAnInteger(new RecyclingBin() {}.asInstanceOf[RecyclingBin$sp$Int]) // RecyclingBin cannot be cast to RecyclingBin$sp$Int +recycleAnInteger(new RecyclingBin() {}.asInstanceOf[RecyclingBin$sp$Int]) // RecyclingBin cannot be cast to RecyclingBin$sp$Int + +// This will fail at runtime. We would rather catch it at compile time. +``` +Therefore we have the following issues: +- `RecyclingBin[Any]`, `RecyclingBin[AnyVal]` may not be passed to `RecyclingBin[Int]` whereas normally they would be able to be passed +- `RecyclingBin[Any]`, `RecyclingBin[Object / AnyRef]` may not be passed to RecyclingBin[Paper] whereas normally they would. + +So we impose an additional restriction on contravariance with specialized parameters: +- If `A[F1]` is to be interpreted as `A[F2]` under `A[-T: Specialized]`,we require that `SpecType(F1) = SpecType(F2)`. Given that we also require `F1 >:> F2`, and looking at the definition of SpecType this means: + - RecylcingBin[Any], RecylcingBin[AnyVal] may not be passed to RecylcingBin[Int] whereas normally they would + - RecylcingBin[Any], RecylcingBin[Object / AnyRef] may not be passed to RecylcingBin[Paper] whereas normally they would. + - RecylcingBin[Any] may be passed to RecylcingBin[Object], RecylcingBin[AnyRef], RecylcingBin[AnyVal] as these all erase to RecylcingBin + +Covariance has a similar problem: + - In general it works fine because it corresponds to interpreting `A[F1]` as `A[F2]` where `F1 <:< F2`. Either`A[F1]` and `A[F2]` both erase to the same type (`A$sp$SpecType(F2)` or `A` if `F1` and `F2` are both top classes), or `A[F1]` erases to `A$sp$F1` and `A[F2]` erases to `A`. But `A$sp$F1` is a subtype of `A` by definition so the upcast will succeed (and upcasts are generally cheap compared to downcasts on the JVM so this is acceptable from a performance perspective). + - The only exception is with `Nothing`, because we want to interpret `A[Nothing]` as e.g. `A[Int]`, but we erase `A[Nothing]` to `A`. `A >:> A$sp$Int` so this doesn't work and we also have to ban it. This makes the code less ergonomic in some cases. For example `case object Nil extends List[Nothing]` has to become `inline trait NilC[T: Specialized] extends List[T]` and `inline def Nil[T: Specialized] = new NilC[T] () {}`, but we don't lose too much expressivity. + + + + + + + + + +## A Larger Case Study + +As an example of a hierarchy of specialized traits, consider the following small group of specialized collection traits: + +```scala +inline trait Iterator[T: Specialized]: + def hasNext: Boolean + def next(): T + +inline trait ArrayIterator[T: Specialized](elems: Array[T]) extends Iterator[T]: + private var current = 0 + def hasNext: Boolean = current < elems.length + def next(): T = try elems(current) finally current += 1 + +inline trait Iterable[T: Specialized]: + def iterator: Iterator[T] + def forall(f: T => Unit): Unit = + val it = iterator + while it.hasNext do f(it.next()) + +inline trait Seq[T: Specialized](elems: Array[T]) extends Iterable[T]: + def length: Int = elems.length + def apply(i: Int): T = elems(i) + def iterator: Iterator[T] = new ArrayIterator[T](elems) {} +``` + +This generates the following instance traits (after inlining, conversion to pure interfaces and erasure): + +// TODO: Check that this matches what is actually generated +```scala +inline trait Iterator$sp$Int extends Iterator: + def hasNext: Boolean + def next(): Int + +inline trait ArrayIterator$sp$Int extends ArrayIterator, Iterator$sp$Int + +inline trait Iterable$sp$Int extends Iterable: + def iterator: Iterator$sp$Int + def forall(f: Int => Unit): Unit + +inline trait Seq$sp$Int extends Seq, Iterable$sp$Int: + def length: Int + def apply(i: Int): Int +``` +Note that these traits repeat the parent types of their corresponding inline traits (but with specialization added). For instance, `ArrayIterator$sp$Int` extends the specialized version of its parent `Iterator$sp$Int`, so the specialized trait may be used in contexts expecting: + +- The specialized trait `ArrayIterator$sp$Int` itself (i.e. `ArrayIterator[Int]` in source code) +- A generic `ArrayIterator` (i.e. `ArrayIterator[?]` in source code) +- Specialized traits higher in the specialized hierarchy for example `Iterator$sp$Int`. + +The specialized implementation classes for `ArrayIterator` and `Seq` are as follows (after inlining; iff `new Seq[Int] {}` and `ArrayIterator[Int] {}` are to be found in the program): + +```scala +class ArrayIterator$impl$Int(elems: Array[Int]) extends ArrayIterator$sp$Int, ArrayIterator(elems): + private var current = 0 + override def hasNext: Boolean = + current < elems.length + override def next(): Int = + try elems(current) finally current += 1 + +class Seq$impl$Int(elems: Array[Int]) extends Seq$sp$Int, Seq(elems): + override def iterator: Iterator$sp$Int = new ArrayIterator$impl$Int(elems) + + override def forall(f: Int => Unit): Unit = + val it = iterator + while it.hasNext do f(it.next()) + override def length: Int = elems.length + override def apply(i: Int): Int = elems(i) +``` + +## Summary of implementation restrictions on specialized traits +These could be lifted with additional work. + +| Behaviour | Limitation | Chance of fixing / limited by | +|--------------------------|-----------------------------------------------|---| +| Use of `?` bounds | May not be used for Specialized parameters; however may be used for non-Specialized parameters in specialized traits. | Fixable by adding bridge methods. We ban them because with if `class A extends I[Int]` implements method `def foo(x: Foo[Int])` which belongs to interface `I[T]` as `def foo(x: Foo[T])` then specializing A's `foo` means it no longer implements the interface correctly. Note that this can only occur when I is itself a specialized trait (otherwise the type signature `Foo[T]` is not valid in `I`) so in practice this reduces to `inline trait I$sp$Int extends I[Int]`. This means we can solve the problem by having `I$sp$Int` not extend `I[Int]` in the final generated code. This imposes that `I[?]` be banned as `I[Int]` in source (`I$sp$Int` after erasure) does not extend `I[?]` / `I` . Adding bridge methods seemed quite challenging because there are a large number of cases to deal with. | +| Defining specialized traits inside traits/classes/objects | May define specialized traits inside `object`s. May not define them inside `class`es or `trait`s. | Limited by the way we flatten the owners of generated `$impl$` classes and `$sp$` traits. We really need to build the `Foo$impl$` class directly next to Foo. For a single CU this would be possible if we walked the entire tree and found where these belong; for multiple CUs it is more complicated as the tree may not exist in the current CU. The case of path dependent specialized traits was deemed niche enough to not be high priority. | + + +## Transportation of Specialized through generic code + +The `Specialized` Type Class is erased at runtime. Instances of `Specialized[T]` are created automatically for types that do not contain type variables. + +It may surprise you to note that the following is valid. The `Numeric` constraint on `T` is only checked when +a concrete type is provided for `S` (and by extension `T`) when instantiating `T2`. +```scala +inline trait T1[T: Numeric] +inline trait T2[S] extends T1[S] +``` +In constrast, we do not allow this type of behaviour for `Specialized`. This is largely to avoid confusion. In particular: +```scala +inline trait T1[T: Specialized] +inline trait T2[S] extends T1[S] +val x = new T2[Int]() {} +``` +Should `x` be a Specialized `$impl$` instance or a normal anonymous class? If we naively look at just `S`'s definition we would say no, +but this is complicated by the fact that the generated anonymous class will also mixin `T1` directly as well as `T2`. Could we specialize +just for `T1`? This is hard to imagine. Furthermore if we don't specialize, this is also counter intuitive because T1 is then never specialized +to Int, because we have no specialized instance of trait `T2` to specialize into. Therefore we require users to explicitly transport `Specialized` +through their code, in the following way: + +```scala +inline trait T1[T: Specialized] + +inline trait T2 extends T1[List[Int]] // ok +inline trait T3[S] extends T1[List[S]] // error: S should be specialized +inline trait T4[S] extends T1[List[List[S]]] // error: S should be specialized +inline trait T5[S: Specialized] extends T1[List[S]] // ok; should only specialize later +inline trait T6[T[_], S] extends T1[T[S]] // error: T should be specialized // error: S should be specialized +inline trait T7[T[_]] extends T1[T[Int]] // error: T should be specialized + +inline def foo1[S](x: T1[List[S]]): Int = 10 // error: S should be specialized +inline def foo2(x: T1[List[Int]]): Int = 10 // ok +inline def foo3[S](x: T1[List[List[S]]]): Int = 10 // error: S should be specialized +inline def foo4[S: Specialized](x: T1[List[List[S]]]): Int = 10 // ok + +inline def bar1[S] = new T1[List[S]]() {} // error: S should be specialized +inline def bar2 = new T1[List[Int]]() {} // ok +inline def bar3[S] = new T1[List[List[S]]]() {} // error: S should be specialized +inline def bar4[S: Specialized] = new T1[List[List[S]]]() {} // ok +``` +Note that in the cases with `List` this restriction is not imposed because of the definition of `List`, but rather simply because we have a +type variable `S` which is not marked as Specialized which appears `somewhere inside' a type in a Specialized position. Again this is done to +avoid confusion. A user extending `T1[List[S]]` would likely expect some degree of specialization to given the definition of `T1`, but this +is not possible if `S` is not marked as `Specialized`. + +## [1] Why are the generated traits inline? +Consider the following: +```scala +inline trait A[T]: + def foo = "Hello World" +inline trait B extends A[Int] +class C extends B +// inlines to: +class C extends B: + def foo = "Hello World" + +// vs... + +inline trait A[T: Specialized]: + def foo = "Hello World" +inline trait B extends A[Int] +class C extends B +// would expand to: +trait A$sp$Int: + def foo = "Hello World" +inline trait B extends A$sp$Int +class C extends B +``` +We consider the fact that the location of the inlined `foo` method changes with only a simple +addition of `Specialized` to be inconsistent / confusing. Furthermore it would violate the rule +that ordinary traits may not extend inline traits, and causes problems with partial specialization: +```scala +// (1) +inline trait A[T: Specialized, D: Specialized]: + def foo: T + def bar: D +inline trait B[S: Specialized] extends A[S, Int] +trait C extends B[Char] + +// would expand to: +trait A$sp$S$Int[S: Specialized] extends A[S, Int]: // (Ignoring the fact that Specialized may not be used on ordinary traits). + def foo: S + def bar: Int +inline trait B[W: Specialized] extends A$sp$S$Int[W] +trait C extends B[Char] +``` +The definitions are stuck in `A$sp$S$Int$` because it is not inline. This means we can never usefully specialize on `W` even though it is declared `Specialized`. + +Side note: Because we make the generated traits inline, we modify the behaviour of inline traits relative to the original semantics from Timothée's thesis, such that inline traits extended by other inline traits are still inlined (instead of inlining only at the first ordinary class extending the family of inline traits). This is necessary so that `A$sp$S$Int` can be made inline and still contain the specialized declarations which we need when we use it as an interface. The original argument for only inlining at the bottom of the hierarchy was to reduce code generation, and that this was sufficient when we only have inline traits, however the additional code generation is only linear in the number of traits in the sequence as we do not inline multiple copies, and we consider this acceptable to implement `Specialized`. + + +## Specialized Traits in the Compiler +We introduce a new phase `desugarSpecializedTraits` responsible for detecting specializations, generating the necessary `$sp$` and `$impl$` +classes for these specializations, and inlining into them. It also replaces `new Vec[Int] {}` with `new Vec$impl$Int`. + +The replacement of references to e.g. `Vec[Int]` with `Vec$sp$Int` is done at erasure, because we cannot change signatures before then, and doing it afterwards would not prevent the boxing that we seek to avoid. + +Specialized traits rely on the semantics and implementation of inline traits, so it may seem logical that `desugarSpecializedTraits` would merely generate +the prototypes for the classes, and allow `specializeInlineTraits` to inline the bodies. We *do not* do this. Rather, the phase `desugarSpecializedTraits` directly performs inlining of the parent traits (`Vec[Int]` in the above example) into the +generated `$sp$` traits and `$impl$` classes, sharing the relevant code with the `specializeInlineTraits` phase through +the `Inlines.scala` file. + +This is done because while we want to keep the two phases separate and avoid coupling where possible (thus allowing e.g. specialized traits to be disabled +while maintaining inline traits), implementing specialized traits requires being able to alternate + between the inlining and specializing steps in some cases. Consider the following +example: + +```scala +inline trait D[R: Specialized] + +inline trait C[S: Specialized]: + def w(y: D[S]): Unit = println("w") + +inline trait A[T: Specialized]: + def x(y: C[T]): Unit = println("x") + +class B extends A[Char] +``` +If we run just the specialization part of the specialized trait processing (without the inlining yet), we get: + +```scala +inline trait A$sp$Char extends A[Char] +``` + +Inlining the body of `A` results in: +```scala +inline trait A$sp$Char extends A[Char]: + def x(y: C[Char]): Unit = println("x") +``` +Notice that this generates a reference to `C[Char]` which ought to be specialized, given that `S` is marked as `Specialized` in +the definition of `C`. Therefore we need to run the specialization process again. This time we will generate: +```scala +inline trait C$sp$Char extends C[Char] +``` +Inlining the body of `C` into this trait will create a reference to `D[Char]`, which also ought to be specialized. Thus it is clear that +it is possible to create arbitrarily long chains requiring alternating between specialized trait generation and inline trait inlining. We note that +this problem arises not only with the `$sp$` traits, but also the `$impl$` classes (see `specialized-trait-inlining-causes-implementation-required.scala`). + +To resolve this problem without alternating between and looping the `specializeInlineTraits` and `desugarSpecializedTraits` phases in an inconvenient way, we opt to make: +- `specializeInlineTraits` responsible for inlining inline traits written directly in user code. If a specialized trait creates an inline trait inlining opportunity which is not specialized, this is dealt with by specializeInlineTraits. Further if a user writes `class Bar extends Foo[Int]` where Foo is declared Specialized, `specializeInlineTraits` will do the inlining. +- `desugarSpecializedTraits` responsible for finding specializations and generating the required `$sp$` traits and `$impl$` classes, inlining the parent specialized traits into these classes, and repeating until no more inlining can be performed and no more `$sp$` traits and `$impl$` classes are needed. This phase also performs replacement of e.g. `Vec[Int]` with `Vec$sp$Int` and `new Vec[Int]` with `new Vec$impl$Int`. +- `pruneInlineTraits` responsible for converting inline traits to pure interfaces +- We also need to replace members accessed on inline receivers with the corresponding inlined symbols, and this is done in erasure. This is *whether the inline traits in question come from inline traits in source code or specialized trait expansion, in both cases.* (see the document on inline traits for a more detailed description of this operation and `pruneInlineTraits`). + +In particular this decision means that we run `specializeInlineTraits` before `desugarSpecializedTraits`, as otherwise we may duplicate the inlined bodies of the `$sp$` traits and `$impl$` classes, since we have already inlined them in `desugarSpecializedTraits`. + + +To avoid redundant repeated code generation of the same traits and classes, specialized instance traits and classes are cached. The compiler will put their tasty and classfile artifacts in a special directory +on the class path. Each artifact will contain in an annotation a hash of the contents of the trait from which the instance was derived. Before creating a new specialized instance, the compiler will consult this directory to see whether an instance with the given name exists and whether its hash matches. In that case, the artifacts can be re-used. --> + + +// NEED TO PUT THIS WITH THE CLASS BAR EXTENDS FOO PARENTS -> Explain that it's due to pattern match exhaustivity checking for sealed specialized traits +invariant is that if we extend the $sp$ trait we must also extend the original trait. + +## `sealed` Specialized traits +Like other traits, specialized traits may be sealed, but this requires some thought. In particular, the generated $sp$ traits and $impl$ classes extend the sealed specialized trait potentially from another file without the user's consent. We want to allow for example: + +```scala +// A.scala +sealed inline trait Foo[T: Specialized] + +// B.scala +def foo(x: Foo[String]) +``` +because this would be allowed with ordinary traits, but the desugaring creates `Foo$sp$String` which is arguably an illegal child of the sealed `Foo[String]` as it's produced only when compiling B.scala. + +We are also faced with the question of whether we should allow the following: +```scala +// A.scala +sealed inline trait Foo[T: Specialized] +val x = new Foo[Int]() {} // Forces creation of Foo$sp$Int and Foo$impl$Int + +// B.scala +val y = new Foo[Int]() {} +``` +In the bytecode x and y may or may not point to the same `Foo$impl$Int` depending on if we share the generated specialized classes, but in +the source code `y` extends `Foo[Int]` illegally. + +In both cases we essentially opt for the "source code" interpretation as this seems clearest for users. In particular we allow example (1) but not example (2). This happens automatically because `sealed` trait inheritance checking is done before specialized trait desugaring / erasure, so it is unaware of the `$sp$` traits and `$impl$` classes. + +It is tempting to think that since the `$impl$` classes do not exist in source we may be able to allow the second example, but this is dangerous for exhaustivity checking: + +```scala +// A.scala +sealed inline trait Foo[T: Specialized] +inline trait Bar[T: Specialized] extends Foo[T] + +def foo(x: Foo[Int]) = x match { + case y: Bar[Int] => println("All good!") +} + +// B.scala +val y = new Foo[Int]() {} // Bad; A.scala compiled with no warnings as exhaustivity checker assumed this was impossible +foo(y) +val z = new Bar[Int]() {} // Ok: We do allow this as well because Bar is not sealed so the exhaustivity checking in A.scala was correct. +foo(z) + +``` + +In terms of exhaustivity checking, we also want this to work within a single file. Consider: +```scala +sealed inline trait List[+T: Specialized] +sealed inline trait Nill[T: Specialized] extends List[T]: +sealed inline trait :+:[T: Specialized](h: T, t: List[T]) extends List[T] + +val xs: List[Double] = new Nill[Double]() {} + +def foo(x: List[Double]): Unit = x match { + case xs: :+:[_] => f(xs.head); xs.tail.foreach(f) + case _: Nill[_] => + // warning: non-exhaustive pattern match, missing case _: List[Double] +} +``` + +Without any changes, the anonymous class `Nill[Double]` also extends the `List[Double]` interface (because anonymous class instances mixin all ancestor traits), so pattern match exhaustivity checking on `List[Double]` requires `_: List[Double]` because the List trait has anonymous class children. This occurs because we don't do the `$impl$` class replacements until erasure. For that reason we exempt anonymous classes extending specialized traits from being treated as children for pattern match exhaustivity checking, but we do treat the `$impl$` classes as children (the fact that they are defined even if unused suffices for them to be taken into account). This is correct because the anonymous classes will not exist at runtime when the pattern matches run. + +Furthermore, the generated `List$sp$Double` trait also interferes. After we fix this issue: + +```scala +def foo(x: List[Double]): Unit = x match { + case xs: :+:[_] => f(xs.head); xs.tail.foreach(f) + case _: Nill[_] => + // warning: non-exhaustive pattern match, missing case _: List[Double] & List$sp$Double +} +``` +There are two potential solutions to this: +- make `$sp$` traits inherit `sealed` if the original specialized trait is, but this may make future sharing of specializations challenging if we want to extend the specialized traits from another file. +- don't register the `$sp$` traits as children of the original specialized trait for exhaustivity checking. This is safe because these traits are synthetic and we have the invariant that `T <:< Foo[Int] <=> T <:< Foo$sp$Int`, so users cannot match on `Foo$sp$Int` or `Foo[Int] minus Foo$sp$Int` (the latter being empty) + +We opt for the latter. + + + + + + + + + + + + + +Maybe try rewriting as a spec of what we actually do rather than what we wanted to do and see if we get different results! diff --git a/docs/_docs/reference/changed-features/implicit-resolution.md b/docs/_docs/reference/changed-features/implicit-resolution.md index 0df8d2d60a7a..ab02d41be5eb 100644 --- a/docs/_docs/reference/changed-features/implicit-resolution.md +++ b/docs/_docs/reference/changed-features/implicit-resolution.md @@ -118,6 +118,8 @@ the implicit search for `Q` fails. **5.** The treatment of divergence errors has also changed. A divergent implicit is treated as a normal failure, after which alternatives are still tried. This also makes sense: Encountering a divergent implicit means that we assume that no finite solution can be found on the corresponding path, but another path can still be tried. By contrast, most (but not all) divergence errors in Scala 2 would terminate the implicit search as a whole. +The divergence check that compares the in-progress search history against a new candidate also recognises sibling givens declared in the same owner that share a declared type as the same candidate. Such siblings demand identical context parameters, so exploring one and then another under the same prototype shape cannot make any new progress; without this rule, a group of look-alike givens (say several type-class instances each requiring the same enclosing type class) would force the search to enumerate every permutation before the expression-count limit kicks in. + **6.** Scala 2 gives a lower level of priority to implicit conversions with call-by-name parameters relative to implicit conversions with call-by-value parameters. Scala 3 drops this distinction. So the following code snippet would be ambiguous in Scala 3: ```scala diff --git a/docs/_docs/reference/changed-features/wildcards.md b/docs/_docs/reference/changed-features/wildcards.md index ac7235770e36..7b7a90883be4 100644 --- a/docs/_docs/reference/changed-features/wildcards.md +++ b/docs/_docs/reference/changed-features/wildcards.md @@ -35,16 +35,16 @@ A step-by-step migration is made possible with the following measures: 4. Some deprecation warnings are already available under the `-source future` setting. To smooth the transition for codebases that use kind-projector, we adopt the following measures under the command line -option `-Ykind-projector`: +option `-Xkind-projector` (`-Ykind-projector` in older versions of the Scala 3 compiler): 1. In Scala 3.0, `*` is available as a type parameter placeholder. 2. In Scala 3.2, `*` is deprecated in favor of `_`. A `-rewrite` option is available to rewrite one to the other. 3. In Scala 3.3, `*` is removed again, and all type parameter placeholders will be expressed with `_`. -These rules make it possible to cross-build between Scala 2 using the kind projector plugin and Scala 3.0 - 3.2 using the compiler option `-Ykind-projector`. +These rules make it possible to cross-build between Scala 2 using the kind projector plugin and Scala 3.0 - 3.2 using the compiler option `-Xkind-projector`. There is also a migration path for users that want a one-time transition to syntax with `_` as a type parameter placeholder. -With option `-Ykind-projector:underscores` Scala 3 will regard `_` as a type parameter placeholder, leaving `?` as the only syntax for wildcards. +With option `-Xkind-projector:underscores` Scala 3 will regard `_` as a type parameter placeholder, leaving `?` as the only syntax for wildcards. To cross-compile with old Scala 2 sources, while using `_` a placeholder, you must use options `-Xsource:3 -P:kind-projector:underscore-placeholders` together with a recent version of kind-projector (`0.13` and higher) and most recent versions of Scala 2 (`2.13.5` and higher and `2.12.14` and higher) diff --git a/docs/_docs/reference/error-codes/E006.md b/docs/_docs/reference/error-codes/E006.md index 2a90629e5f6c..1cad2ae65bcd 100644 --- a/docs/_docs/reference/error-codes/E006.md +++ b/docs/_docs/reference/error-codes/E006.md @@ -72,6 +72,8 @@ val result = knownIdentifier ``` + + diff --git a/docs/_docs/reference/error-codes/E119.md b/docs/_docs/reference/error-codes/E119.md index fee6df3b06bc..0aaa8c3283f0 100644 --- a/docs/_docs/reference/error-codes/E119.md +++ b/docs/_docs/reference/error-codes/E119.md @@ -13,16 +13,16 @@ Packages and Java classes (without companion objects) cannot be used as values i ## Example ```scala sc:fail sc-opts:-explain -val x = scala.collection +val x = java.util ``` ### Error ```scala sc:nocompile --- [E119] Type Error: example.scala:1:14 --------------------------------------- -1 |val x = scala.collection - | ^^^^^^^^^^^^^^^^ - | package scala.collection is not a value +-- [E119] Type Error: example.scala:1:13 --------------------------------------- +1 |val x = java.util + | ^^^^^^^^^ + | package java.util is not a value ``` ### Solution diff --git a/docs/_docs/reference/error-codes/E140.md b/docs/_docs/reference/error-codes/E140.md index 345a68df58ae..e2106d2b5646 100644 --- a/docs/_docs/reference/error-codes/E140.md +++ b/docs/_docs/reference/error-codes/E140.md @@ -49,6 +49,8 @@ trait A: ``` + + diff --git a/docs/_docs/reference/error-codes/E181.md b/docs/_docs/reference/error-codes/E181.md index c565dd8d935b..4dff6c390d3b 100644 --- a/docs/_docs/reference/error-codes/E181.md +++ b/docs/_docs/reference/error-codes/E181.md @@ -26,7 +26,7 @@ def example(): Unit = -- [E181] Potential Issue Warning: example.scala:2:2 --------------------------- 2 | synchronized { | ^^^^^^^^^^^^ - | Suspicious top-level unqualified call to synchronized + | Universal method synchronized does not resolve to the enclosing class |----------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -61,6 +61,8 @@ class Counter: ``` + + diff --git a/docs/_docs/reference/error-codes/E228.md b/docs/_docs/reference/error-codes/E228.md new file mode 100644 index 000000000000..f9a88a8dd47c --- /dev/null +++ b/docs/_docs/reference/error-codes/E228.md @@ -0,0 +1,40 @@ +--- +title: E228: Names With Trailing Colon +kind: Warning +since: 3.9.0 +--- +# E228: Names With Trailing Colon + +This warning occurs when a name ends with operator characters and a colon, which can confuse readers and may not reflect the writer's intent. + +For instance, `x_:` is a valid operator name, but it may have been intended as `x_` followed by a colon to mark the beginning of the body. + +--- + +## Example + +```scala sc:fail sc-opts:-Werror +object Hello_: // looks like it should have a body, but the colon is part of the name +``` + +### Error + +```scala sc:nocompile +-- [E228] Syntax Warning: example.scala:1:7 ------------------------------------ +1 |object Hello_: // looks like it should have a body, but the colon is part of the name + | ^^^^^^^ + | name `Hello_:` should be enclosed in backticks + |----------------------------------------------------------------------------- + | Explanation (enabled by `-explain`) + |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + | Names with trailing operator characters may fuse with a subsequent colon if not set off by backquotes or spaces. + ----------------------------------------------------------------------------- +``` + +### Solution + +```scala sc:compile sc-opts:-Werror +// Use backticks to make the intent explicit +object `Hello_:` +``` + diff --git a/docs/_docs/reference/error-codes/E229.md b/docs/_docs/reference/error-codes/E229.md new file mode 100644 index 000000000000..f562d5b865b9 --- /dev/null +++ b/docs/_docs/reference/error-codes/E229.md @@ -0,0 +1,43 @@ +--- +title: E229: Indentation Does Not Reflect Nesting +kind: Warning +since: 3.9.0 +--- +# E229: Indentation Does Not Reflect Nesting + +This warning occurs when indentation does not reflect syntactic nesting, which may confuse readers or reflect a misunderstanding on the code writer's part. + +This can happen when a line intended to declare a new scope does not actually do so, for instance because a colon becomes part of a name. + +--- + +## Example + + +```scala sc:nocompile +class SomeClass // no colon, so this is an empty class declaration + def y = 1 // this is a standalone, top-level definition! +``` + +### Error + +```scala sc:nocompile +-- [E229] Syntax Warning: example.scala:2:2 ------------------------------------ +2 | def y = 1 // this is a standalone, top-level definition! + | ^ + | Line is indented too far to the right, or a '{' or ':' is missing + |----------------------------------------------------------------------------- + | Explanation (enabled by `-explain`) + |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + | Indentation that does not reflect syntactic nesting may be due to a typo such as missing punctuation. + ----------------------------------------------------------------------------- +``` + +### Solution + +```scala sc:compile sc-opts:-Werror +class SomeClass +// If the declaration is intentionally at the top level, indent it as such +def y = 1 +``` + diff --git a/docs/_docs/reference/error-codes/E230.md b/docs/_docs/reference/error-codes/E230.md new file mode 100644 index 000000000000..e1ea51dffe6a --- /dev/null +++ b/docs/_docs/reference/error-codes/E230.md @@ -0,0 +1,54 @@ +--- +title: E230: Illegal Identifier +kind: Warning +since: 3.9.0 +--- +# E228: Illegal Identifier + +Besides syntactic rules for identifiers, the language specification adds: + +The ‘$’ character is reserved for compiler-synthesized identifiers. User programs should not define identifiers that contain ‘$’ characters. + +A warning is emitted for definitions with a name that contains a ‘$’ character. + +No warning is emitted for usages of such a definition. + +--- + +## Example + +```scala sc:fail sc-opts:-Werror +var next = 42 +def next$access$1 = next // attempt to explicitly define a member for binary compatibility +``` + +### Error + +```scala sc:nocompile +-- [E230] Syntax Warning: example.scala:2:4 ------------------------------------ +2 |def next$access$1 = next // attempt to explicitly define a member for binary compatibility + | ^^^^^^^^^^^^^ + |The identifier `next$access$1` should not contain `$`, which is reserved for internal compiler use. + |----------------------------------------------------------------------------- + | Explanation (enabled by `-explain`) + |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + | User identifiers may be encoded with embedded `$`, and other compiler artifacts + | may rely on using `$` with specific meanings. + | + | The prohibition against explicit `$` may be ignored by enclosing the identifier in backquotes + | at the definition site. + ----------------------------------------------------------------------------- +``` + +### Solution + +Occasionally, it is necessary to introduce an identifier that breaks this rule, +usually to preserve binary compatibility. + +That name can be wrapped in backquotes to suppress the warning: + +```scala sc:compile sc-opts:-Werror +var next = 42 +def `next$access$1` = next +``` + diff --git a/docs/_docs/reference/error-codes/E231.md b/docs/_docs/reference/error-codes/E231.md new file mode 100644 index 000000000000..2fde4b373277 --- /dev/null +++ b/docs/_docs/reference/error-codes/E231.md @@ -0,0 +1,59 @@ +--- +title: 'E231: Concrete Class Has Unimplemented Methods' +kind: Error +since: 3.9.0 +--- +# E231: Concrete Class Has Unimplemented Methods + +This error is emitted when a non-abstract class or object extends a trait or abstract class but does not provide implementations for one or more of its inherited abstract members. + +A class must either implement every inherited abstract member in itself or one of its ancestors, or be declared `abstract` so that subclasses are required to finish the job. + +--- + +## Example + +```scala sc:fail +trait Animal: + def name: String + def sound: String + +class Dog extends Animal +``` + +### Error + +```scala sc:nocompile +-- [E231] Declaration Error: example.scala:5:6 --------------------------------- +5 |class Dog extends Animal + | ^^^ + | class Dog needs to be abstract, since it has 2 unimplemented members. + | + | Members declared in Animal: + | - def name: String + | - def sound: String +``` + +### Solution + +Either implement all missing members: + +```scala sc:compile +trait Animal: + def name: String + def sound: String + +class Dog extends Animal: + def name: String = "Rex" + def sound: String = "Woof" +``` + +Or mark the class as `abstract` to defer the obligation to subclasses: + +```scala sc:compile +trait Animal: + def name: String + def sound: String + +abstract class Dog extends Animal +``` diff --git a/docs/_docs/reference/error-codes/E232.md b/docs/_docs/reference/error-codes/E232.md new file mode 100644 index 000000000000..da343c50c4a8 --- /dev/null +++ b/docs/_docs/reference/error-codes/E232.md @@ -0,0 +1,58 @@ +--- +title: E228: Illegal Use of Specialized Error +kind: Error +--- +# E232: Illegal Use of Specialized Error + +This error occurs when Specialized is used outside of a context bound. + +--- + +## Example + +```scala sc:fail +def bar(x: Specialized[Int]): Int // error: Specialized may only be used as a context bound +class Foo(x: Specialized[Int]) // error: Specialized may only be used as a context bound +class Bar(val x: Specialized[Int]) // error: Specialized may only be used as a context bound +val y: Specialized[Char] // error: Specialized may only be used as a context bound +val v = Specialized.apply[Int] // error: Specialized may only be used as a context bound +def z = println(Specialized.apply[Float]) // error: Specialized may only be used as a context bound +def a = Specialized.apply // error: Specialized may only be used as a context bound +type V = Specialized // error: Specialized may only be used as a context bound +type W = Specialized[Int] // error: Specialized may only be used as a context bound +val b = Specialized // error: Specialized may only be used as a context bound +``` + +### Error + +```scala sc:nocompile +-- [E228] Syntax Error: tests/neg/specialized-trait-specialized-incorrect-usage2.scala:24:12 +24 | val b = Specialized // error: Specialized may only be used as a context bound + | ^^^^^^^^^^^ + | Specialized may only be used as a context bound + |---------------------------------------------------------------------------- + | Explanation (enabled by `-explain`) + |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + | Specialized allows for a performance improvement by specializing generic type parameters + | to avoid boxing/unboxing. It should only be used as a context (typeclass) bound on a + | generic type in inline traits or inline methods: + | + | inline trait Vec[T: Specialized](val x: T) + | + | inline def foo[T: Specialized](v: Vec[T]) = v.x + | + | In this instance it was used in a way which is unsupported, such as + | trying to create a type synonym or a value with explicit type Specialized[X]. + | + ---------------------------------------------------------------------------- +``` + +### Solution +Use Specialized correctly, i.e. as a context bound in an inline trait or method: + + +```scala sc:compile sc-opts:-Werror +inline trait Vec[T: Specialized](val x: T) + +inline def foo[T: Specialized](v: Vec[T]) = v.x +``` diff --git a/docs/_docs/reference/error-codes/E233.md b/docs/_docs/reference/error-codes/E233.md new file mode 100644 index 000000000000..91ca274f0534 --- /dev/null +++ b/docs/_docs/reference/error-codes/E233.md @@ -0,0 +1,91 @@ +--- +title: E233: Variance in Specialized Traits Limitation +kind: Warning +--- +# E233: Variance in Specialized Traits Limitation + +Emitted when a type parameter of an inline trait is defined both Specialized and contravariant, +to remind the user that this comes with a reduction in expressivity. + +Ordinary contravariance works because of erasure, but specialized traits have a special erasure which prevents +some contravariance patterns involving Object, Any, AnyVal and AnyRef. + +The following example illustrates the problem: +```scala +inline trait RecyclingBin[-T: Specialized]: + def recycle(x: T) = println(s"Recycling ${x}") + +def recycleAnInteger(bin: RecyclingBin[Int]) = + bin.recycle(100) + +recycleAnInteger(new RecyclingBin[Anyval]() {}) // RecyclingBin[AnyVal] can be interpreted as RecyclingBin[Int] due to contravariance +recycleAnInteger(new RecyclingBin[Any]() {}) // RecyclingBin[Any] can be interpreted as RecyclingBin[Int] due to contravariance + +// Yet, this erases to: + +def recycleAnInteger(bin: RecyclingBin$sp$Int) = + bin.recycle(100) + +recycleAnInteger(new RecyclingBin() {}.asInstanceOf[RecyclingBin$sp$Int]) // RecyclingBin cannot be cast to RecyclingBin$sp$Int +recycleAnInteger(new RecyclingBin() {}.asInstanceOf[RecyclingBin$sp$Int]) // RecyclingBin cannot be cast to RecyclingBin$sp$Int + +``` +- `RecyclingBin[Any]`, `RecyclingBin[AnyVal]` may not be passed to `RecyclingBin[Int]` whereas normally they would be able to be passed +- `RecyclingBin[Any]`, `RecyclingBin[Object / AnyRef]` may not be passed to RecyclingBin[Paper] whereas normally they would. + +So we impose an additional restriction on contravariance with specialized parameters: +- If `A[F1]` is to be interpreted as `A[F2]` under `A[-T: Specialized]`,we require that `SpecType(F1) = SpecType(F2)`. Given that we also require `F1 >:> F2`, and looking at the definition of SpecType this is roughly equivalent to saying F1 may not be any of the top classes `Any`, `AnyVal`, `AnyRef` unless F2 is also. + +If this restriction is not satisfied, warning E233 is emitted, along with a type error. + +In order that the creator of the contravariant specialized trait is aware of this restriction, the warning E233 is emitted at the point of definition. + +Covariance has a similar problem: + - In general it works fine because it corresponds to interpreting `A[F1]` as `A[F2]` where `F1 <:< F2`. Either`A[F1]` and `A[F2]` both erase to the same type (`A$sp$SpecType(F2)` or `A` if `F1` and `F2` are both top classes), or `A[F1]` erases to `A$sp$F1` and `A[F2]` erases to `A`. But `A$sp$F1` is a subtype of `A` by definition so the upcast will succeed (and upcasts are generally cheap compared to downcasts on the JVM so this is acceptable from a performance perspective). + - The only exception is with `Nothing`, because we want to interpret `A[Nothing]` as e.g. `A[Int]`, but we erase `A[Nothing]` to `A`. `A >:> A$sp$Int` so this doesn't work and we also have to ban it. This makes the code less ergonomic in some cases. For example `case object Nil extends List[Nothing]` has to become `inline trait NilC[T: Specialized] extends List[T]` and `inline def Nil[T: Specialized] = new NilC[T] () {}`, but we don't lose too much expressivity. + +--- + +## Example + +```scala sc:fail +inline trait Foo[-T: Specialized] // warning: Type parameter is both Specialized and contravariant. +``` + +### Error + +```scala sc:nocompile +-- [E233] Syntax Warning: tests/run/specialized-trait-variance.scala:19:18 ----- +19 |inline trait Foo[-T: Specialized]: + | ^ + |Type parameter is both Specialized and variant. This imposes additional typing restrictions. + |---------------------------------------------------------------------------- + | Explanation (enabled by `-explain`) + |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + | Specialized traits achieve a performance gain through a special erasure. + | - Primitives are specialized: Foo[Int] erases to Foo$sp$Int + | - Reference types are specialized to the highest non-top class: Foo[Lion] erases to Foo$sp$Animal + | - Top classes are erased normally: Foo[Any / AnyVal / Object / AnyRef] erases to Foo. + | This means that certain variance patterns that cross these erasure categories will fail at + | runtime due to a ClassCastException, so they are not permitted. For example, treating Foo[Any] or + | Foo[Object] as Foo[Animal] via contravariance is not allowed with Specialized. + | + | Please see the docs for more information on how specialized traits are erased. + | + | If you accept this limitation you can silence this warning with @nowarn. For example: + | + | @nowarn("id=E233") + | inline trait Foo[-T: Specialized]: + | + | Otherwise, remove Specialized, or remove the variance. + | + ---------------------------------------------------------------------------- +``` + +### Solution +Accept downsides and ignore warning as follows, or remove one of Specialized / variant. + +```scala sc:compile sc-opts:-Werror +@nowarn("id=E233") +inline trait Foo[-T: Specialized]: +``` diff --git a/docs/_docs/reference/experimental/capture-checking/advanced.md b/docs/_docs/reference/experimental/capture-checking/advanced.md index c6fc3b2038fa..4c5e6a71d024 100644 --- a/docs/_docs/reference/experimental/capture-checking/advanced.md +++ b/docs/_docs/reference/experimental/capture-checking/advanced.md @@ -94,4 +94,4 @@ By leveraging capability polymorphism, capability members, and path-dependent ca * `Label`s store the free capabilities `C` of the `block` passed to `boundary` in their capability member `Fv`. * When suspending on a given label, the suspension handler can capture at most the capabilities that occur freely at the `boundary` that introduced the label. That prevents mentioning nested bound labels. -[Back to Capability Polymorphism](polymorphism.md) \ No newline at end of file +[Back to Capability Polymorphism](polymorphism.md) diff --git a/docs/_docs/reference/experimental/capture-checking/basics.md b/docs/_docs/reference/experimental/capture-checking/basics.md index 4e4ea0d2694f..22cb38f5fe71 100644 --- a/docs/_docs/reference/experimental/capture-checking/basics.md +++ b/docs/_docs/reference/experimental/capture-checking/basics.md @@ -85,7 +85,7 @@ trait LzyList[+A]: object LzyList: def apply[T](xs: T*): LzyList[T] = ??? //} -val xs = usingLogFile { f => +val xs = usingLogFile { f => // error // error LzyList(1, 2, 3).map { x => f.write(x); x * x } } ``` @@ -372,7 +372,7 @@ like this: ```scala sc:fail sc-compile-with:logfile-checked var loophole: () => Unit = () => () usingLogFile { f => - loophole = () => f.write(0) + loophole = () => f.write(0) // error } loophole() ``` diff --git a/docs/_docs/reference/experimental/capture-checking/cc.md b/docs/_docs/reference/experimental/capture-checking/cc.md index dd697a8a272a..a207ff0ac8ba 100644 --- a/docs/_docs/reference/experimental/capture-checking/cc.md +++ b/docs/_docs/reference/experimental/capture-checking/cc.md @@ -4,4 +4,4 @@ title: "Capture Checking" nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/capture-checking/index.html --- -Capture checking is a research project that modifies the Scala type system to track references to capabilities in values. \ No newline at end of file +Capture checking is a research project that modifies the Scala type system to track references to capabilities in values. diff --git a/docs/_docs/reference/experimental/capture-checking/checked-exceptions.md b/docs/_docs/reference/experimental/capture-checking/checked-exceptions.md index f984e94c49ff..ea1931be168b 100644 --- a/docs/_docs/reference/experimental/capture-checking/checked-exceptions.md +++ b/docs/_docs/reference/experimental/capture-checking/checked-exceptions.md @@ -73,9 +73,9 @@ As with other capability based schemes, one needs to guard against capabilities that are captured in results. For instance, here is a problematic use case: ```scala sc:fail sc-compile-with:checked-exceptions-base def escaped(xs: Double*): (() => Double) throws LimitExceeded = - try () => xs.map(f).sum // error: CanThrow escapes into returned closure + try () => xs.map(f).sum catch case ex: LimitExceeded => () => -1 -val crasher = escaped(1, 2, 10e+11) +val crasher = escaped(1, 2, 10e+11) // error: CanThrow escapes into returned closure crasher() ``` This code needs to be rejected since otherwise the call to `crasher()` would cause diff --git a/docs/_docs/reference/experimental/capture-checking/how-to-use.md b/docs/_docs/reference/experimental/capture-checking/how-to-use.md index 9430d90e9380..3f03b3734fe6 100644 --- a/docs/_docs/reference/experimental/capture-checking/how-to-use.md +++ b/docs/_docs/reference/experimental/capture-checking/how-to-use.md @@ -17,9 +17,9 @@ import language.experimental.captureChecking Requires the import above: ```scala -import language.experimental.captureChecking import language.experimental.separationChecking ``` +This will implicitly enable capture checking as well. ### SBT Project Template diff --git a/docs/_docs/reference/experimental/capture-checking/internals.md b/docs/_docs/reference/experimental/capture-checking/internals.md index 3a95ac0e25da..c639294b35d7 100644 --- a/docs/_docs/reference/experimental/capture-checking/internals.md +++ b/docs/_docs/reference/experimental/capture-checking/internals.md @@ -80,5 +80,3 @@ This section lists all variables that appeared in previous diagnostics and their - variable `31` has a constant fixed superset `{xs, f}` - variable `32` has no dependencies. - - diff --git a/docs/_docs/reference/experimental/capture-checking/scoped-capabilities.md b/docs/_docs/reference/experimental/capture-checking/scoped-capabilities.md index 3494d97e9c24..f949b65a91d9 100644 --- a/docs/_docs/reference/experimental/capture-checking/scoped-capabilities.md +++ b/docs/_docs/reference/experimental/capture-checking/scoped-capabilities.md @@ -142,7 +142,7 @@ If any scope refuses to absorb the capability, capture checking fails: ```scala sc:fail sc-compile-with:scoped-fs-context def process(fs: FileSystem^): Unit = - val f: () -> Unit = () => fs.read() // Error: fs cannot flow into {} + val f: () -> Unit = () => fs.read() // error: fs cannot flow into {} ``` The closure is declared pure (`() -> Unit`), meaning its local `any` is the empty set. The @@ -312,14 +312,14 @@ determines the binding structure automatically from where `fresh` appears in the The rules above establish a key practical distinction when writing function types. Consider: -```scala sc:fail +```scala sc:fail sc-compile-with:scoped-cc-context import caps.fresh class A class B def test(): Unit = - val f: (x: A^) -> B^{fresh} = ??? // B^{fresh}: existentially bound - val g: A^ -> B^ = ??? // B^{any}: enclosing scope's local any + val f: (x: A^) -> B^{fresh} = ??? // B^{fresh}: existentially bound + val g: A^ -> B^ = ??? // B^{any}: enclosing scope's local any val _: A^ -> B^ = f // error: fresh is not in {any} val _: A^ -> B^{fresh} = f // ok @@ -390,7 +390,7 @@ directly returning a closure that captures it: ```scala sc:fail sc-compile-with:scoped-withfile-context withFile[() => File^]("test.txt"): f => // ^^^^^^^^^^^ T = () => File^, i.e., () ->{any} File^{any} for some outer any - () => f // error: We want to return this as () => File^ + () => f // error // error // error: We want to return this as () => File^ ``` The lambda `(f: File^) => () => f` has inferred type: @@ -414,7 +414,7 @@ into this outer `any`, so the assignment fails. Otherwise, allowing widening `∃fresh. () ->{fresh} File^{fresh}` to `() => File^` would let the scoped file escape: ```scala sc:fail sc-compile-with:scoped-withfile-context -val escaped: () => File^ = withFile[() => File^]("test.txt")(f => () => f) +val escaped: () => File^ = withFile[() => File^]("test.txt")(f => () => f) // error // error // ^^^^^^^^^^^ any here is in the outer scope escaped().read() // Use-after-close! ``` diff --git a/docs/_docs/reference/experimental/capture-checking/separation-checking.md b/docs/_docs/reference/experimental/capture-checking/separation-checking.md index 6a56e09d2474..a7cacb937dd4 100644 --- a/docs/_docs/reference/experimental/capture-checking/separation-checking.md +++ b/docs/_docs/reference/experimental/capture-checking/separation-checking.md @@ -39,8 +39,8 @@ Separation checking is an extension of capture checking that enforces unique, un import language.experimental.separationChecking ``` (or the corresponding setting `-language:experimental.separationChecking`). -The import has to be given in addition to the `language.experimental.captureChecking` import that enables capture checking. -The reason for the second language import is that separation checking is less mature than capture checking proper, so we are less sure + +The reason for this separate language import is that separation checking is less mature than capture checking proper, so we are less sure we got the balance of safety and expressivity right for it at the present time. In capture checking, each occurrence of [`any`](scoped-capabilities.md), and therefore each use of `^`, has a context-dependent meaning that is tied to the lifetime of capabilities. Separation checking refines that model. It keeps track of the capabilities hidden by each `any` and enforces that these hidden sets are either separated or overlap only where the types permit it. diff --git a/docs/_docs/reference/experimental/explicit-nulls.md b/docs/_docs/reference/experimental/explicit-nulls.md index bb432ba1baea..52c807f581d0 100644 --- a/docs/_docs/reference/experimental/explicit-nulls.md +++ b/docs/_docs/reference/experimental/explicit-nulls.md @@ -457,6 +457,31 @@ See [more examples](https://github.com/scala/scala3/blob/main/tests/explicit-nul Currently, we are unable to track paths with a mutable variable prefix. For example, `x.a` if `x` is mutable. +### Tracking Mutable Fields with `@stableNull` + +By default, mutable class fields (`var`) are not tracked by flow typing, because a concurrent +assignment could set the field to `null` between the null check and its subsequent use. +To opt into flow typing for a mutable field, annotate it with +`scala.annotation.stableNull`. +The field will then be tracked whenever it is accessed through a stable prefix. + +```scala +import scala.annotation.stableNull + +class A: + @stableNull private var s: String | Null = null + def getS: String = + if s == null then s = "" + s // s: String +``` + +**Warning:** `@stableNull` can break null safety. The compiler assumes the field stays +non-nullable after a null check, but nothing prevents another thread, a reentrant call, or +unrelated code reachable from the same reference from reassigning it to `null` in between. +We recommend only using it to manage a mutable nullable state *locally* within a class. +A typical case is a field where `null` represents an uninitialized value that is assigned +once on first access. + ### Unsupported Idioms We don't support: diff --git a/docs/_docs/reference/metaprogramming/macros.md b/docs/_docs/reference/metaprogramming/macros.md index d8a1893c38bd..25e36e3024bd 100644 --- a/docs/_docs/reference/metaprogramming/macros.md +++ b/docs/_docs/reference/metaprogramming/macros.md @@ -4,7 +4,7 @@ title: "Macros" nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/macros.html --- -> **Warning:** Always enable `-Xcheck-macros` when developing macros. Without it, the compiler will not validate generated code, which may be unsound and lead to undefined behavior. +> When developing macros, enable the `-Xcheck-macros` compiler option to run extra safety checks. ## Multi-Staging diff --git a/docs/_docs/reference/preview/into.md b/docs/_docs/reference/other-new-features/into.md similarity index 95% rename from docs/_docs/reference/preview/into.md rename to docs/_docs/reference/other-new-features/into.md index 770a9adfbf99..5ca858cafbcf 100644 --- a/docs/_docs/reference/preview/into.md +++ b/docs/_docs/reference/other-new-features/into.md @@ -1,11 +1,13 @@ --- layout: doc-page title: The `into` Type and Modifier -redirectFrom: /experimental/into.html -nightlyOf: https://docs.scala-lang.org/scala3/reference/preview/into.html +redirectFrom: + - /experimental/into.html + - /preview/into.html +nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/into.html --- -This feature is available as a preview since Scala 3.8.0. +This feature is available as stable since Scala 3.9.0. ## Summary @@ -152,10 +154,10 @@ as they are seen in a method body. Here is an example: def ++ (elems: into[IterableOnce[A]]): List[A] = val buf = ListBuffer[A]() for elem <- elems.iterator do // no `.underlying` needed here - buf += elems + buf += elem buf.toList ``` -Inside the `++` method, the `elems` parameter is of type `IterableOnce[A]`, not `into[IterableOne[A]]`. Hence, we can simply write `elems.iterator` to get at the `iterator` method of the `IterableOnce` class. +Inside the `++` method, the `elems` parameter is of type `IterableOnce[A]`, not `into[IterableOnce[A]]`. Hence, we can simply write `elems.iterator` to get at the `iterator` method of the `IterableOnce` class. Specifically, we erase all `into` wrappers in the local types of parameter types that appear in covariant or invariant position. Contravariant `into` wrappers are kept since these typically are on the parameters of function arguments. @@ -216,7 +218,7 @@ Type parameters that are not fully instantiated do not count as valid conversion ```scala trait Token class Keyword(str: String) - given Conversion[String, Keyword] = KeyWord(_) + given Conversion[String, Keyword] = Keyword(_) List[into[Keyword]]("if", "then", "else") ``` @@ -241,8 +243,8 @@ def g(x: C) = () f(1) // ok g(1) // error ``` -The call `f("abc")` type-checks since `f`'s parameter type `T` is `into`. -But the call `g("abc")` does not type-check since `g`'s parameter type `C` is not `into`. It does not matter that `C` extends a trait `T` that is `into`. +The call `f(1)` type-checks since `f`'s parameter type `T` is `into`. +But the call `g(1)` does not type-check since `g`'s parameter type `C` is not `into`. It does not matter that `C` extends a trait `T` that is `into`. ## Why Two Different Schemes? @@ -277,5 +279,4 @@ of the original `Modifier` trait has changed. In summary, upgrading Laminar to u LocalModifier ::= ... | ‘into’ ``` -`into` is a soft modifier. It is only allowed classes, traits, and opaque type aliases. - +`into` is a soft modifier. It is only allowed on classes, traits, and opaque type aliases. diff --git a/docs/_docs/reference/other-new-features/kind-polymorphism.md b/docs/_docs/reference/other-new-features/kind-polymorphism.md index 4bb1e659dfe9..05fc13fd2360 100644 --- a/docs/_docs/reference/other-new-features/kind-polymorphism.md +++ b/docs/_docs/reference/other-new-features/kind-polymorphism.md @@ -43,4 +43,4 @@ It is declared `abstract` and `final`, so it can be neither instantiated nor ext `AnyKind` plays a special role in Scala's subtype system: It is a supertype of all other types no matter what their kind is. It is also assumed to be kind-compatible with all other types. Furthermore, `AnyKind` is treated as a higher-kinded type (so it cannot be used as a type of values), but at the same time it has no type parameters (so it cannot be instantiated). -**Note:** This feature is now stable. The compiler flag `-Yno-kind-polymorphism` is deprecated as of 3.7.0, has no effect (is ignored), and will be removed in a future version. +**Note:** This feature is now stable. The compiler flag `-Yno-kind-polymorphism` is deprecated and has no effect as of 3.7.0, and is removed as of 3.10.0. diff --git a/docs/_docs/reference/preview/overview.md b/docs/_docs/reference/preview/overview.md index 03787c36484f..52f8bc221fd2 100644 --- a/docs/_docs/reference/preview/overview.md +++ b/docs/_docs/reference/preview/overview.md @@ -12,7 +12,7 @@ New Scala language features or standard library APIs are initially introduced as Preview language features and APIs are guaranteed to be standardized in some next Scala minor release, but allow the compiler team to introduce small, possibly binary incompatible, changes based on the community feedback. These can be used by early adopters who can accept the possibility of binary compatibility breakage. For instance, preview features could be used in some internal tool or application. On the other hand, preview features are discouraged in publicly available libraries. -More information about preview featues can be found in [preview defintions guide](../other-new-features/preview-defs.md) +More information about preview features can be found in [preview definitions guide](../other-new-features/preview-defs.md) ### `-preview` compiler flag @@ -21,4 +21,4 @@ This flag enables the use of all preview language feature in the project. ## List of available preview features -* [The `into` Type and Modifier](into.md) +- [Automatic Parameter Unrolling with `@unroll`](unrolled-defs.md) diff --git a/docs/_docs/reference/experimental/unrolled-defs.md b/docs/_docs/reference/preview/unrolled-defs.md similarity index 97% rename from docs/_docs/reference/experimental/unrolled-defs.md rename to docs/_docs/reference/preview/unrolled-defs.md index f2e09e82bc18..9de3bfdf27f0 100644 --- a/docs/_docs/reference/experimental/unrolled-defs.md +++ b/docs/_docs/reference/preview/unrolled-defs.md @@ -1,9 +1,12 @@ --- layout: doc-page title: "Automatic Parameter Unrolling" -nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/unrolled-defs.html +redirectFrom: /experimental/unrolled-defs.html +nightlyOf: https://docs.scala-lang.org/scala3/reference/preview/unrolled-defs.html --- +This feature is available under `-preview` since Scala 3.10.0. + Parameter unrolling enables new parameters to be added to methods and classes, while still preserving backwards binary compatibility. An `@unroll` annotation, on a parameter with default value, will generate backwards compatible forwarders to a method or constructor. diff --git a/docs/_spec/APPLIEDreference/changed-features/wildcards.md b/docs/_spec/APPLIEDreference/changed-features/wildcards.md index 0d3e13c3d7e0..d44f6de237ba 100644 --- a/docs/_spec/APPLIEDreference/changed-features/wildcards.md +++ b/docs/_spec/APPLIEDreference/changed-features/wildcards.md @@ -35,16 +35,16 @@ A step-by-step migration is made possible with the following measures: 4. The Scala 3.1 behavior is already available today under the `-source future` setting. To smooth the transition for codebases that use kind-projector, we adopt the following measures under the command line -option `-Ykind-projector`: +option `-Xkind-projector` (`-Ykind-projector` in older versions of the Scala 3 compiler): 1. In Scala 3.0, `*` is available as a type parameter placeholder. 2. In Scala 3.2, `*` is deprecated in favor of `_`. A `-rewrite` option is available to rewrite one to the other. 3. In Scala 3.3, `*` is removed again, and all type parameter placeholders will be expressed with `_`. -These rules make it possible to cross build between Scala 2 using the kind projector plugin and Scala 3.0 - 3.2 using the compiler option `-Ykind-projector`. +These rules make it possible to cross build between Scala 2 using the kind projector plugin and Scala 3.0 - 3.2 using the compiler option `-Xkind-projector`. There is also a migration path for users that want a one-time transition to syntax with `_` as a type parameter placeholder. -With option `-Ykind-projector:underscores` Scala 3 will regard `_` as a type parameter placeholder, leaving `?` as the only syntax for wildcards. +With option `-Xkind-projector:underscores` Scala 3 will regard `_` as a type parameter placeholder, leaving `?` as the only syntax for wildcards. To cross-compile with old Scala 2 sources, while using `_` a placeholder, you must use options `-Xsource:3 -P:kind-projector:underscore-placeholders` together with a recent version of kind-projector (`0.13` and higher) and most recent versions of Scala 2 (`2.13.5` and higher and `2.12.14` and higher) diff --git a/docs/_spec/Gemfile b/docs/_spec/Gemfile index 6277b9514a00..36e8a3cb537d 100644 --- a/docs/_spec/Gemfile +++ b/docs/_spec/Gemfile @@ -2,8 +2,7 @@ source "https://rubygems.org" ruby "~> 2.7" -gem "jekyll", "3.6.3" +gem "jekyll" gem "webrick" gem "rouge" -# gem 's3_website' -gem "redcarpet", "3.6.1" +gem "jekyll-sass-converter", "~> 3.0" diff --git a/docs/_spec/Gemfile.lock b/docs/_spec/Gemfile.lock index 6b074b0e835e..fa0ca74a397f 100644 --- a/docs/_spec/Gemfile.lock +++ b/docs/_spec/Gemfile.lock @@ -1,46 +1,70 @@ GEM remote: https://rubygems.org/ specs: - addressable (2.8.1) - public_suffix (>= 2.0.2, < 6.0) + addressable (2.9.0) + public_suffix (>= 2.0.2, < 8.0) colorator (1.1.0) - ffi (1.15.5) + concurrent-ruby (1.3.6) + em-websocket (0.5.3) + eventmachine (>= 0.12.9) + http_parser.rb (~> 0) + eventmachine (1.2.7) + ffi (1.17.4) forwardable-extended (2.6.0) - jekyll (3.6.3) + google-protobuf (3.25.8) + google-protobuf (3.25.8-x86_64-linux) + http_parser.rb (0.8.1) + i18n (1.14.8) + concurrent-ruby (~> 1.0) + jekyll (4.3.4) addressable (~> 2.4) colorator (~> 1.0) - jekyll-sass-converter (~> 1.0) - jekyll-watch (~> 1.1) - kramdown (~> 1.14) + em-websocket (~> 0.5) + i18n (~> 1.0) + jekyll-sass-converter (>= 2.0, < 4.0) + jekyll-watch (~> 2.0) + kramdown (~> 2.3, >= 2.3.1) + kramdown-parser-gfm (~> 1.0) liquid (~> 4.0) - mercenary (~> 0.3.3) + mercenary (>= 0.3.6, < 0.5) pathutil (~> 0.9) - rouge (>= 1.7, < 3) + rouge (>= 3.0, < 5.0) safe_yaml (~> 1.0) - jekyll-sass-converter (1.5.2) - sass (~> 3.4) - jekyll-watch (1.5.1) + terminal-table (>= 1.8, < 4.0) + webrick (~> 1.7) + jekyll-sass-converter (3.0.0) + sass-embedded (~> 1.54) + jekyll-watch (2.2.1) listen (~> 3.0) - kramdown (1.17.0) - liquid (4.0.3) - listen (3.7.1) + kramdown (2.5.2) + rexml (>= 3.4.4) + kramdown-parser-gfm (1.1.0) + kramdown (~> 2.0) + liquid (4.0.4) + listen (3.10.0) + logger rb-fsevent (~> 0.10, >= 0.10.3) rb-inotify (~> 0.9, >= 0.9.10) - mercenary (0.3.6) + logger (1.7.0) + mercenary (0.4.0) pathutil (0.16.2) forwardable-extended (~> 2.6) - public_suffix (5.0.0) + public_suffix (5.1.1) + rake (13.4.2) rb-fsevent (0.11.2) - rb-inotify (0.10.1) + rb-inotify (0.11.1) ffi (~> 1.0) - redcarpet (3.6.1) - rouge (2.2.1) + rexml (3.4.4) + rouge (4.7.0) safe_yaml (1.0.5) - sass (3.7.4) - sass-listen (~> 4.0.0) - sass-listen (4.0.0) - rb-fsevent (~> 0.9, >= 0.9.4) - rb-inotify (~> 0.9, >= 0.9.7) + sass-embedded (1.63.6) + google-protobuf (~> 3.23) + rake (>= 13.0.0) + sass-embedded (1.63.6-x86_64-linux-gnu) + google-protobuf (~> 3.23) + terminal-table (3.0.2) + unicode-display_width (>= 1.1.1, < 3) + unicode-display_width (2.6.0) webrick (1.9.2) PLATFORMS @@ -48,10 +72,13 @@ PLATFORMS x86_64-linux DEPENDENCIES - jekyll (= 3.6.3) - redcarpet (= 3.6.1) + jekyll + jekyll-sass-converter (~> 3.0) rouge webrick +RUBY VERSION + ruby 2.7.8p225 + BUNDLED WITH 2.3.5 diff --git a/docs/_spec/README.md b/docs/_spec/README.md index f8a59e86896c..2dc7b417aa25 100644 --- a/docs/_spec/README.md +++ b/docs/_spec/README.md @@ -10,7 +10,7 @@ Third, we'd like to support different output formats. An html page per chapter w ## Editing -We are using Jekyll and [Redcarpet](https://github.com/vmg/redcarpet) to generate the html. +We are using Jekyll to generate the html. Check `Gemfile` for the current versions. @@ -18,19 +18,13 @@ We aim to track the configuration GitHub Pages uses but differences may arise as ## Building - To preview locally, run the following commands in the docs/_spec subfolder: ``` env UID="$(id -u)" GID="$(id -g)" docker-compose up ``` -and open http://0.0.0.0:4000/files/archive/spec/3.4/ to view the spec. Jekyll will rebuild as you edit the markdown, but make sure to restart it when you change `_config.yml`. - +and open http://localhost:4000/files/archive/spec/3.4/ to view the spec. Jekyll will rebuild as you edit the markdown, but make sure to restart it when you change `_config.yml`. ## General Advice for editors diff --git a/docs/_spec/TODOreference/experimental/explicit-nulls.md b/docs/_spec/TODOreference/experimental/explicit-nulls.md index 400659baf8ad..2dc6a8bb1b81 100644 --- a/docs/_spec/TODOreference/experimental/explicit-nulls.md +++ b/docs/_spec/TODOreference/experimental/explicit-nulls.md @@ -85,7 +85,7 @@ val c = new C() // c.f == "field is null" ``` -The unsoundness above can be caught by the compiler with the option `-Ysafe-init`. +The unsoundness above can be caught by the compiler with the option `-Wsafe-init`. More details can be found in [safe initialization](../other-new-features/safe-initialization.md). ## Equality diff --git a/docs/_spec/TODOreference/metaprogramming/macros.md b/docs/_spec/TODOreference/metaprogramming/macros.md index 244fd00eff40..1231271cd21a 100644 --- a/docs/_spec/TODOreference/metaprogramming/macros.md +++ b/docs/_spec/TODOreference/metaprogramming/macros.md @@ -4,7 +4,7 @@ title: "Macros" nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/macros.html --- -> **Warning:** Always enable `-Xcheck-macros` when developing macros. Without it, the compiler will not validate generated code, which may be unsound and lead to undefined behavior. +> When developing macros, enable the `-Xcheck-macros` compiler option to run extra safety checks. ## Multi-Staging diff --git a/docs/_spec/_config.yml b/docs/_spec/_config.yml index 3277a8bbcc77..e0f5e8867732 100644 --- a/docs/_spec/_config.yml +++ b/docs/_spec/_config.yml @@ -5,10 +5,7 @@ versionCompareMessage: "an upcoming" safe: true lsi: false highlighter: false -markdown: redcarpet encoding: utf-8 -redcarpet: - extensions: ["no_intra_emphasis", "fenced_code_blocks", "autolink", "tables", "with_toc_data", "strikethrough", "lax_spacing", "space_after_headers", "superscript", "footnotes", "disable_indented_code_blocks"] exclude: - APPLIEDreference - TODOreference diff --git a/docs/_spec/docker-compose.yml b/docs/_spec/docker-compose.yml index 3eadc939ed40..43f0542f595d 100644 --- a/docs/_spec/docker-compose.yml +++ b/docs/_spec/docker-compose.yml @@ -1,10 +1,8 @@ -version: '2' - services: jekyll: user: "${UID}:${GID}" build: . - command: sh -c "chown $UID / && bundle exec jekyll serve --incremental --host=0.0.0.0 " + command: sh -c "chown $UID / && bundle exec jekyll serve --incremental --host=0.0.0.0" ports: - '4000:4000' volumes: diff --git a/docs/sidebar.yml b/docs/sidebar.yml index 992657221079..ac52b8c4d5ab 100644 --- a/docs/sidebar.yml +++ b/docs/sidebar.yml @@ -88,6 +88,7 @@ subsection: - page: reference/other-new-features/toplevel-definitions.md - page: reference/other-new-features/better-fors.md - page: reference/other-new-features/runtimeChecked.md + - page: reference/other-new-features/into.md - title: Other Changed Features directory: changed-features index: reference/changed-features/changed-features.md @@ -144,7 +145,7 @@ subsection: directory: preview index: reference/preview/overview.md subsection: - - page: reference/preview/into.md + - page: reference/preview/unrolled-defs.md - title: Experimental Features directory: experimental index: reference/experimental/overview.md @@ -190,7 +191,6 @@ subsection: - page: reference/experimental/typeclasses.md - page: reference/experimental/runtimeChecked.md hidden: true - - page: reference/experimental/unrolled-defs.md - page: reference/experimental/package-object-values.md - page: reference/experimental/quoted-patterns-with-polymorphic-functions.md - page: reference/experimental/relaxed-lambdas.md @@ -433,3 +433,7 @@ subsection: - page: reference/error-codes/E225.md - page: reference/error-codes/E226.md - page: reference/error-codes/E227.md + - page: reference/error-codes/E228.md + - page: reference/error-codes/E229.md + - page: reference/error-codes/E230.md + - page: reference/error-codes/E231.md diff --git a/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala b/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala index 9821822f6d66..c767d77e86e2 100644 --- a/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala +++ b/language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala @@ -7,7 +7,7 @@ import java.nio.file._ import java.util.concurrent.{CompletableFuture, ConcurrentHashMap} import java.util.function.Function -import com.fasterxml.jackson.databind.ObjectMapper +import _root_.tools.jackson.databind.json.JsonMapper import org.eclipse.lsp4j @@ -32,7 +32,8 @@ import config.Printers.interactiv import languageserver.config.ProjectConfig import languageserver.worksheet.{Worksheet, WorksheetService} -import languageserver.decompiler.{TastyDecompilerService} +import languageserver.decompiler.TastyDecompilerService +import org.eclipse.lsp4j.jsonrpc.messages.Either import lsp4j.services._ @@ -68,7 +69,8 @@ class DottyLanguageServer extends LanguageServer if myDrivers == null then assert(rootUri != null, "`drivers` cannot be called before `initialize`") val configFile = new File(new URI(rootUri + '/' + IDE_CONFIG_FILE)) - val configs: List[ProjectConfig] = (new ObjectMapper).readValue(configFile, classOf[Array[ProjectConfig]]).toList + val configs: List[ProjectConfig] = + JsonMapper.builder().build().readValue(configFile, classOf[Array[ProjectConfig]]).toList val defaultFlags = List("-color:never" /*, "-Yplain-printer","-Yprint-pos"*/) @@ -250,7 +252,7 @@ class DottyLanguageServer extends LanguageServer client.publishDiagnostics(new PublishDiagnosticsParams( document.getUri, - diags.flatMap(diagnostic).asJava)) + diags.flatMap(DottyLanguageServer.diagnostic).asJava)) } override def didChange(params: DidChangeTextDocumentParams): Unit = { @@ -277,7 +279,7 @@ class DottyLanguageServer extends LanguageServer client.publishDiagnostics(new PublishDiagnosticsParams( document.getUri, - diags.flatMap(diagnostic).asJava)) + diags.flatMap(DottyLanguageServer.diagnostic).asJava)) } } @@ -320,7 +322,7 @@ class DottyLanguageServer extends LanguageServer * If cursor is on a definition, show this definition together with all overridden * and overriding definitions. */ - override def definition(params: TextDocumentPositionParams) = computeAsync { cancelToken => + override def definition(params: DefinitionParams) = computeAsync { cancelToken => val uri = new URI(params.getTextDocument.getUri) val driver = driverFor(uri) implicit def ctx: Context = driver.currentCtx @@ -329,7 +331,7 @@ class DottyLanguageServer extends LanguageServer val path = Interactive.pathTo(driver.openedTrees(uri), pos) val definitions = Interactive.findDefinitions(path, pos, driver).toList - definitions.flatMap(d => location(d.namePos)).asJava + Either.forLeft(definitions.flatMap(d => location(d.namePos)).asJava) } override def references(params: ReferenceParams) = computeAsync { cancelToken => @@ -438,7 +440,7 @@ class DottyLanguageServer extends LanguageServer new WorkspaceEdit(changes.asJava) } - override def documentHighlight(params: TextDocumentPositionParams) = computeAsync { cancelToken => + override def documentHighlight(params: DocumentHighlightParams) = computeAsync { cancelToken => val uri = new URI(params.getTextDocument.getUri) val driver = driverFor(uri) implicit def ctx: Context = driver.currentCtx @@ -458,7 +460,7 @@ class DottyLanguageServer extends LanguageServer }.distinct.asJava } - override def hover(params: TextDocumentPositionParams) = computeAsync { cancelToken => + override def hover(params: HoverParams) = computeAsync { cancelToken => val uri = new URI(params.getTextDocument.getUri) val driver = driverFor(uri) implicit def ctx: Context = driver.currentCtx @@ -509,16 +511,16 @@ class DottyLanguageServer extends LanguageServer override def symbol(params: WorkspaceSymbolParams) = computeAsync { cancelToken => val query = params.getQuery - drivers.values.toList.flatMap { driver => + Either.forLeft(drivers.values.toList.flatMap { driver => implicit def ctx: Context = driver.currentCtx val trees = driver.sourceTreesContaining(query) val defs = Interactive.namedTrees(trees, Include.empty, _.name.toString.contains(query)) defs.flatMap(d => symbolInfo(d.tree.symbol, d.namePos)) - }.asJava + }.asJava) } - override def implementation(params: TextDocumentPositionParams) = computeAsync { cancelToken => + override def implementation(params: ImplementationParams) = computeAsync { cancelToken => val uri = new URI(params.getTextDocument.getUri) val driver = driverFor(uri) @@ -544,12 +546,12 @@ class DottyLanguageServer extends LanguageServer val matches = Interactive.namedTrees(trees, Include.local, predicate)(using ctx) matches.map(tree => location(tree.namePos(using ctx))) } - }.toList + } - implementations.flatten.asJava + Either.forLeft(implementations.flatten.asJava) } - override def signatureHelp(params: TextDocumentPositionParams) = computeAsync { canceltoken => + override def signatureHelp(params: SignatureHelpParams) = computeAsync { canceltoken => val uri = new URI(params.getTextDocument.getUri) val driver = driverFor(uri) diff --git a/language-server/test/dotty/tools/languageserver/util/actions/CodeDefinition.scala b/language-server/test/dotty/tools/languageserver/util/actions/CodeDefinition.scala index b20fa633d11e..e2b327827bbd 100644 --- a/language-server/test/dotty/tools/languageserver/util/actions/CodeDefinition.scala +++ b/language-server/test/dotty/tools/languageserver/util/actions/CodeDefinition.scala @@ -17,7 +17,7 @@ import org.junit.Assert.assertEquals class CodeDefinition(override val range: CodeRange, expected: Seq[CodeRange]) extends ActionOnRange { override def onMarker(marker: CodeMarker): Exec[Unit] = { - val results = server.definition(marker.toTextDocumentPositionParams).get().asScala.toSeq.sorted + val results = server.definition(marker.toDefinitionParams).get().getLeft.asScala.toSeq.sorted val expectedLocations = expected.map(_.toLocation).sorted assertEquals(expectedLocations, results) diff --git a/language-server/test/dotty/tools/languageserver/util/actions/CodeDocumentHighlight.scala b/language-server/test/dotty/tools/languageserver/util/actions/CodeDocumentHighlight.scala index b35a246178ff..88c565f2e89a 100644 --- a/language-server/test/dotty/tools/languageserver/util/actions/CodeDocumentHighlight.scala +++ b/language-server/test/dotty/tools/languageserver/util/actions/CodeDocumentHighlight.scala @@ -21,7 +21,7 @@ class CodeDocumentHighlight(override val range: CodeRange, override def onMarker(marker: CodeMarker): Exec[Unit] = { val expectedPairs = expected.map { case (codeRange, kind) => (codeRange.toRange, kind) }.sorted - val results = server.documentHighlight(marker.toTextDocumentPositionParams).get() + val results = server.documentHighlight(marker.toDocumentHighlightParams).get() val resultPairs = results.asScala.map { result => (result.getRange, result.getKind) }.sorted assertEquals(expectedPairs, resultPairs) diff --git a/language-server/test/dotty/tools/languageserver/util/actions/CodeHover.scala b/language-server/test/dotty/tools/languageserver/util/actions/CodeHover.scala index 1bbfdd31d248..6148e15e1a93 100644 --- a/language-server/test/dotty/tools/languageserver/util/actions/CodeHover.scala +++ b/language-server/test/dotty/tools/languageserver/util/actions/CodeHover.scala @@ -17,7 +17,7 @@ import scala.jdk.CollectionConverters._ class CodeHover(override val range: CodeRange, expectedOpt: Option[String]) extends ActionOnRange { override def onMarker(marker: CodeMarker): Exec[Unit] = { - val result = server.hover(marker.toTextDocumentPositionParams).get() + val result = server.hover(marker.toHoverParams).get() expectedOpt match { case None => assertNull(result) diff --git a/language-server/test/dotty/tools/languageserver/util/actions/CodeSymbol.scala b/language-server/test/dotty/tools/languageserver/util/actions/CodeSymbol.scala index 421485ab434c..3d535990d3f7 100644 --- a/language-server/test/dotty/tools/languageserver/util/actions/CodeSymbol.scala +++ b/language-server/test/dotty/tools/languageserver/util/actions/CodeSymbol.scala @@ -16,7 +16,7 @@ import scala.jdk.CollectionConverters._ class CodeSymbol(query: String, expected: Seq[SymInfo]) extends Action { override def execute(): Exec[Unit] = { - val results = server.symbol(new WorkspaceSymbolParams(query)).get().asScala + val results = server.symbol(new WorkspaceSymbolParams(query)).get().getLeft.asScala val expectedSymInfo = expected.map(_.toSymInformation) assertEquals(expectedSymInfo, results) diff --git a/language-server/test/dotty/tools/languageserver/util/actions/Implementation.scala b/language-server/test/dotty/tools/languageserver/util/actions/Implementation.scala index 01da3ed0f41f..036b21df10e2 100644 --- a/language-server/test/dotty/tools/languageserver/util/actions/Implementation.scala +++ b/language-server/test/dotty/tools/languageserver/util/actions/Implementation.scala @@ -23,7 +23,7 @@ class Implementation(override val range: CodeRange, expected: List[CodeRange]) e override def onMarker(marker: CodeMarker): Exec[Unit] = { val expectedLocations = expected.map(_.toLocation) - val results: Seq[org.eclipse.lsp4j.Location] = server.implementation(marker.toTextDocumentPositionParams).get().asScala.toSeq + val results: Seq[org.eclipse.lsp4j.Location] = server.implementation(marker.toImplementationParams).get().getLeft.asScala.toSeq assertEquals(expectedLocations.length, results.length) expectedLocations.sorted.zip(results.sorted).foreach { diff --git a/language-server/test/dotty/tools/languageserver/util/actions/SignatureHelp.scala b/language-server/test/dotty/tools/languageserver/util/actions/SignatureHelp.scala index 4e1c0fcea77b..21a173b930e2 100644 --- a/language-server/test/dotty/tools/languageserver/util/actions/SignatureHelp.scala +++ b/language-server/test/dotty/tools/languageserver/util/actions/SignatureHelp.scala @@ -32,7 +32,7 @@ class SignatureHelp(override val marker: CodeMarker, val expectedSignatures = expected.map(DottyLanguageServer.signatureToSignatureInformation) override def execute(): Exec[Unit] = { - val results = server.signatureHelp(marker.toTextDocumentPositionParams).get() + val results = server.signatureHelp(marker.toSignatureHelpParams).get() val resultSignatures = results.getSignatures.asScala assertEquals("Number of signatures", expected.length, resultSignatures.length) diff --git a/language-server/test/dotty/tools/languageserver/util/embedded/CodeMarker.scala b/language-server/test/dotty/tools/languageserver/util/embedded/CodeMarker.scala index 33e6a875750a..c0f202ea365c 100644 --- a/language-server/test/dotty/tools/languageserver/util/embedded/CodeMarker.scala +++ b/language-server/test/dotty/tools/languageserver/util/embedded/CodeMarker.scala @@ -30,8 +30,20 @@ class CodeMarker(val name: String) extends Embedded { /** Converts this marker to a position. */ def toPosition: PosCtx[Position] = new Position(line, character) - def toTextDocumentPositionParams: PosCtx[TextDocumentPositionParams] = - new TextDocumentPositionParams(toTextDocumentIdentifier, toPosition) + def toDefinitionParams: PosCtx[DefinitionParams] = + new DefinitionParams(toTextDocumentIdentifier, toPosition) + + def toDocumentHighlightParams: PosCtx[DocumentHighlightParams] = + new DocumentHighlightParams(toTextDocumentIdentifier, toPosition) + + def toHoverParams: PosCtx[HoverParams] = + new HoverParams(toTextDocumentIdentifier, toPosition) + + def toImplementationParams: PosCtx[ImplementationParams] = + new ImplementationParams(toTextDocumentIdentifier, toPosition) + + def toSignatureHelpParams: PosCtx[SignatureHelpParams] = + new SignatureHelpParams(toTextDocumentIdentifier, toPosition) def toDocumentSymbolParams: PosCtx[DocumentSymbolParams] = new DocumentSymbolParams(toTextDocumentIdentifier) @@ -51,12 +63,8 @@ class CodeMarker(val name: String) extends Embedded { def toVersionedTextDocumentIdentifier: PosCtx[VersionedTextDocumentIdentifier] = new VersionedTextDocumentIdentifier(file.uri, 0) - def toReferenceParams(withDecl: Boolean): PosCtx[ReferenceParams] = { - val rp = new ReferenceParams(new ReferenceContext(withDecl)) - rp.setTextDocument(toTextDocumentIdentifier) - rp.setPosition(toPosition) - rp - } + def toReferenceParams(withDecl: Boolean): PosCtx[ReferenceParams] = + new ReferenceParams(toTextDocumentIdentifier, toPosition, new ReferenceContext(withDecl)) def show: PosCtx[String] = s"($name,line=$line,char=$character)" override def toString: String = s"CodePosition($name)" diff --git a/library-js/src/scala/Array.scala b/library-js/src/scala/Array.scala index 455ed0d19f43..c6bf859368af 100644 --- a/library-js/src/scala/Array.scala +++ b/library-js/src/scala/Array.scala @@ -61,7 +61,11 @@ object Array { val emptyObjectArray = new Array[Object](0) } - /** Provides an implicit conversion from the Array object to a collection Factory. */ + /** Provides an implicit conversion from the Array object to a collection Factory. + * + * @tparam A the element type of the array, must have a `ClassTag` + * @param dummy the `Array` companion object, used to trigger the implicit conversion + */ implicit def toFactory[A : ClassTag](dummy: Array.type): Factory[A, Array[A]] = new ArrayFactory(dummy) @SerialVersionUID(3L) private class ArrayFactory[A : ClassTag](dummy: Array.type) extends Factory[A, Array[A]] with Serializable { @@ -69,7 +73,11 @@ object Array { def newBuilder: mutable.Builder[A, Array[A]] = Array.newBuilder[A] } - /** Returns a new [[scala.collection.mutable.ArrayBuilder]]. */ + /** Returns a new [[scala.collection.mutable.ArrayBuilder]]. + * + * @tparam T the element type of the array to build + * @param t the `ClassTag` for the element type, used to create the correct array type at runtime + */ def newBuilder[T](implicit t: ClassTag[T]): ArrayBuilder[T] = ArrayBuilder.make[T](using t) def from[A: ClassTag](it: IterableOnce[A]^): Array[A] = { @@ -138,6 +146,11 @@ object Array { * except that this works for primitive and object arrays in a single method. * * @see `java.util.Arrays#copyOf` + * + * @tparam A the element type of the array + * @param original the array to be copied + * @param newLength the length of the copy to be returned + * @return a copy of the original array, truncated or padded with default values to obtain the specified length */ def copyOf[A](original: Array[A], newLength: Int): Array[A] = (original match { case x: Array[BoxedUnit] => newUnitArray(newLength).asInstanceOf[Array[A]] @@ -164,6 +177,12 @@ object Array { * in a single method. * * @see `java.util.Arrays#copyOf` + * + * @tparam A the element type of the destination array + * @param original the array to be copied + * @param newLength the length of the copy to be returned + * @param ct the `ClassTag` for the target element type, used to create the correct array type at runtime + * @return a copy of the original array, converted to type `Array[A]`, truncated or padded with default values to obtain the specified length */ def copyAs[A](original: Array[_], newLength: Int)(implicit ct: ClassTag[A]): Array[A] = { val runtimeClass = ct.runtimeClass @@ -190,7 +209,10 @@ object Array { result } - /** Returns an array of length 0. */ + /** Returns an array of length 0. + * + * @tparam T the element type of the empty array + */ def empty[T: ClassTag]: Array[T] = new Array[T](0) /** Creates an array with given elements. @@ -210,7 +232,11 @@ object Array { array } - /** Creates an array of `Boolean` objects. */ + /** Creates an array of `Boolean` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Boolean, xs: Boolean*): Array[Boolean] = { val array = new Array[Boolean](xs.length + 1) @@ -223,7 +249,11 @@ object Array { array } - /** Creates an array of `Byte` objects. */ + /** Creates an array of `Byte` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Byte, xs: Byte*): Array[Byte] = { val array = new Array[Byte](xs.length + 1) @@ -236,7 +266,11 @@ object Array { array } - /** Creates an array of `Short` objects. */ + /** Creates an array of `Short` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Short, xs: Short*): Array[Short] = { val array = new Array[Short](xs.length + 1) @@ -249,7 +283,11 @@ object Array { array } - /** Creates an array of `Char` objects. */ + /** Creates an array of `Char` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Char, xs: Char*): Array[Char] = { val array = new Array[Char](xs.length + 1) @@ -262,7 +300,11 @@ object Array { array } - /** Creates an array of `Int` objects. */ + /** Creates an array of `Int` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Int, xs: Int*): Array[Int] = { val array = new Array[Int](xs.length + 1) @@ -275,7 +317,11 @@ object Array { array } - /** Creates an array of `Long` objects. */ + /** Creates an array of `Long` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Long, xs: Long*): Array[Long] = { val array = new Array[Long](xs.length + 1) @@ -288,7 +334,11 @@ object Array { array } - /** Creates an array of `Float` objects. */ + /** Creates an array of `Float` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Float, xs: Float*): Array[Float] = { val array = new Array[Float](xs.length + 1) @@ -301,7 +351,11 @@ object Array { array } - /** Creates an array of `Double` objects. */ + /** Creates an array of `Double` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Double, xs: Double*): Array[Double] = { val array = new Array[Double](xs.length + 1) @@ -314,7 +368,11 @@ object Array { array } - /** Creates an array of `Unit` objects. */ + /** Creates an array of `Unit` objects. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Unit, xs: Unit*): Array[Unit] = { val array = new Array[Unit](xs.length + 1) array(0) = x @@ -326,28 +384,59 @@ object Array { array } - /** Creates array with given dimensions. */ + /** Creates array with given dimensions. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + */ def ofDim[T: ClassTag](n1: Int): Array[T] = new Array[T](n1) - /** Creates a 2-dimensional array. */ + /** Creates a 2-dimensional array. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + */ def ofDim[T: ClassTag](n1: Int, n2: Int): Array[Array[T]] = { val arr: Array[Array[T]] = (new Array[Array[T]](n1): Array[Array[T]]) for (i <- 0 until n1) arr(i) = new Array[T](n2) arr // tabulate(n1)(_ => ofDim[T](n2)) } - /** Creates a 3-dimensional array. */ + /** Creates a 3-dimensional array. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3rd dimension + */ def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] = tabulate(n1)(_ => ofDim[T](n2, n3)) - /** Creates a 4-dimensional array. */ + /** Creates a 4-dimensional array. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3rd dimension + * @param n4 the number of elements in the 4th dimension + */ def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] = tabulate(n1)(_ => ofDim[T](n2, n3, n4)) - /** Creates a 5-dimensional array. */ + /** Creates a 5-dimensional array. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3rd dimension + * @param n4 the number of elements in the 4th dimension + * @param n5 the number of elements in the 5th dimension + */ def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] = tabulate(n1)(_ => ofDim[T](n2, n3, n4, n5)) /** Concatenates all arrays into a single array. * + * @tparam T the element type of the arrays * @param xss the given arrays * @return the array created from concatenating `xss` */ @@ -367,6 +456,7 @@ object Array { * res3: Array[Double] = Array(0.365461167592537, 1.550395944913685E-4, 0.7907242137333306) * ``` * + * @tparam T the element type of the array * @param n the number of elements desired * @param elem the element computation * @return an Array of size n, where each element contains the result of computing @@ -389,6 +479,7 @@ object Array { /** Returns a two-dimensional array that contains the results of some element * computation a number of times. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param elem the element computation @@ -399,6 +490,7 @@ object Array { /** Returns a three-dimensional array that contains the results of some element * computation a number of times. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -410,6 +502,7 @@ object Array { /** Returns a four-dimensional array that contains the results of some element * computation a number of times. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -422,6 +515,7 @@ object Array { /** Returns a five-dimensional array that contains the results of some element * computation a number of times. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -435,9 +529,10 @@ object Array { /** Returns an array containing values of a given function over a range of integer * values starting from 0. * + * @tparam T the element type of the array * @param n The number of elements in the array * @param f The function computing element values - * @return A traversable consisting of elements `f(0),f(1), ..., f(n - 1)` + * @return an array consisting of elements `f(0), f(1), ..., f(n - 1)` */ def tabulate[T: ClassTag](n: Int)(f: Int => T): Array[T] = { if (n <= 0) { @@ -456,6 +551,7 @@ object Array { /** Returns a two-dimensional array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param f The function computing element values @@ -466,6 +562,7 @@ object Array { /** Returns a three-dimensional array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -477,6 +574,7 @@ object Array { /** Returns a four-dimensional array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -489,6 +587,7 @@ object Array { /** Returns a five-dimensional array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -531,6 +630,7 @@ object Array { /** Returns an array containing repeated applications of a function to a start value. * + * @tparam T the element type of the array * @param start the start value of the array * @param len the number of elements returned by the array * @param f the function that is repeatedly applied @@ -572,8 +672,9 @@ object Array { /** Called in a pattern match like `{ case Array(x,y,z) => println('3 elements')}`. * + * @tparam T the element type of the array * @param x the selector value - * @return sequence wrapped in a [[scala.Some]], if `x` is an Array, otherwise `None` + * @return a [[UnapplySeqWrapper]] wrapping the array for pattern matching extraction */ def unapplySeq[T](x: Array[T]): UnapplySeqWrapper[T] = new UnapplySeqWrapper(x) @@ -657,6 +758,8 @@ object Array { * @define willNotTerminateInf * @define collectExample * @define undefinedorder + * + * @tparam T the type of the elements in the array */ final class Array[T](_length: Int) extends java.io.Serializable with java.lang.Cloneable { self => @@ -687,7 +790,7 @@ final class Array[T](_length: Int) extends java.io.Serializable with java.lang.C /** Clones the Array. * - * @return A clone of the Array. + * @return a clone of the array */ override def clone(): Array[T] = throw new Error() } diff --git a/library-js/src/scala/collection/immutable/NumericRange.scala b/library-js/src/scala/collection/immutable/NumericRange.scala index ca91896e5da9..7db9e5e1b00d 100644 --- a/library-js/src/scala/collection/immutable/NumericRange.scala +++ b/library-js/src/scala/collection/immutable/NumericRange.scala @@ -95,11 +95,18 @@ sealed class NumericRange[T]( /** Creates a new range with the start and end values of this range and * a new `step`. + * + * @param newStep the new step value for the resulting range */ def by(newStep: T): NumericRange[T] = copy(start, end, newStep) - /** Creates a copy of this range. */ + /** Creates a copy of this range. + * + * @param start the first value of the new range + * @param end the upper bound of the new range (inclusive or exclusive, matching the original range) + * @param step the step value between successive elements of the new range + */ def copy(start: T, end: T, step: T): NumericRange[T] = new NumericRange(start, end, step, isInclusive) @@ -350,6 +357,13 @@ object NumericRange { /** Calculates the number of elements in a range given start, end, step, and * whether or not it is inclusive. Throws an exception if step == 0 or * the number of elements exceeds the maximum Int. + * + * @tparam T the numeric type of the range elements, which must have an `Integral` instance + * @param start the first value in the range + * @param end the end boundary of the range (exclusive or inclusive depending on `isInclusive`) + * @param step the increment between successive elements + * @param isInclusive whether `end` is included in the range + * @param num the `Integral` instance used for arithmetic on `T` */ def count[T](start: T, end: T, step: T, isInclusive: Boolean)(implicit num: Integral[T]): Int = { val zero = num.zero diff --git a/library-js/src/scala/collection/immutable/Range.scala b/library-js/src/scala/collection/immutable/Range.scala index d0230b72e3e5..63cd36530e6b 100644 --- a/library-js/src/scala/collection/immutable/Range.scala +++ b/library-js/src/scala/collection/immutable/Range.scala @@ -160,6 +160,7 @@ sealed abstract class Range( /** Creates a new range with the `start` and `end` values of this range and * a new `step`. * + * @param step the new step value for the range; must be non-zero * @return a new range with a different step */ final def by(step: Int): Range = copy(start, end, step) @@ -258,6 +259,9 @@ sealed abstract class Range( /** Creates a new range consisting of the last `n` elements of the range. * * $doesNotUseBuilders + * + * @param n the number of elements to take from the end of this range + * @return a new range consisting of the last `n` elements, or the entire range if `n` is greater than the range length */ final override def takeRight(n: Int): Range = { if (n <= 0) newEmptyRange(start) @@ -274,6 +278,9 @@ sealed abstract class Range( /** Creates a new range consisting of the initial `length - n` elements of the range. * * $doesNotUseBuilders + * + * @param n the number of elements to drop from the end of this range + * @return a new range consisting of all elements except the last `n`, or an empty range if `n` is greater than the range length */ final override def dropRight(n: Int): Range = { if (n <= 0) this @@ -536,6 +543,11 @@ object Range { * precondition: step != 0 * If the size of the range exceeds Int.MaxValue, the * result will be negative. + * + * @param start the first element of the range + * @param end the end boundary of the range (inclusive or exclusive depending on `isInclusive`) + * @param step the increment between successive elements; must be non-zero + * @param isInclusive whether `end` is included in the range */ def count(start: Int, end: Int, step: Int, isInclusive: Boolean): Int = { if (step == 0) @@ -565,18 +577,34 @@ object Range { /** Makes a range from `start` until `end` (exclusive) with given step value. * @note step != 0 + * + * @param start the first element of the range + * @param end the exclusive upper bound of the range + * @param step the increment between successive elements; must be non-zero */ def apply(start: Int, end: Int, step: Int): Range.Exclusive = new Range.Exclusive(start, end, step) - /** Makes a range from `start` until `end` (exclusive) with step value 1. */ + /** Makes a range from `start` until `end` (exclusive) with step value 1. + * + * @param start the first element of the range + * @param end the exclusive upper bound of the range + */ def apply(start: Int, end: Int): Range.Exclusive = new Range.Exclusive(start, end, 1) /** Makes an inclusive range from `start` to `end` with given step value. * @note step != 0 + * + * @param start the first element of the range + * @param end the inclusive upper bound of the range + * @param step the increment between successive elements; must be non-zero */ def inclusive(start: Int, end: Int, step: Int): Range.Inclusive = new Range.Inclusive(start, end, step) - /** Makes an inclusive range from `start` to `end` with step value 1. */ + /** Makes an inclusive range from `start` to `end` with step value 1. + * + * @param start the first element of the range + * @param end the inclusive upper bound of the range + */ def inclusive(start: Int, end: Int): Range.Inclusive = new Range.Inclusive(start, end, 1) @SerialVersionUID(3L) diff --git a/library-js/src/scala/collection/mutable/ArrayBuilder.scala b/library-js/src/scala/collection/mutable/ArrayBuilder.scala index 66c7a329d7d0..d9bb4308a0e1 100644 --- a/library-js/src/scala/collection/mutable/ArrayBuilder.scala +++ b/library-js/src/scala/collection/mutable/ArrayBuilder.scala @@ -54,10 +54,18 @@ sealed abstract class ArrayBuilder[T] protected[this] def resize(size: Int): Unit - /** Adds all elements of an array. */ + /** Adds all elements of an array. + * + * @param xs the array from which to add elements + */ def addAll(xs: Array[_ <: T]): this.type = addAll(xs, 0, xs.length) - /** Adds a slice of an array. */ + /** Adds a slice of an array. + * + * @param xs the array from which to add a slice of elements + * @param offset the starting index in `xs` from which to copy elements + * @param length the number of elements to copy from `xs` + */ def addAll(xs: Array[_ <: T], offset: Int, length: Int): this.type = { ensureSize(this.size + length) Array.copy(xs, offset, elems.nn, this.size, length) @@ -95,7 +103,10 @@ object ArrayBuilder { if (LinkingInfo.isWebAssembly) makeForWasm else makeForJS - /** Implementation of `make` for JS. */ + /** Implementation of `make` for JS. + * + * @tparam T the element type of the array builder, with a `ClassTag` context bound + */ @inline private def makeForJS[T: ClassTag]: ArrayBuilder[T] = new ArrayBuilder.generic[T](implicitly[ClassTag[T]].runtimeClass) @@ -103,6 +114,9 @@ object ArrayBuilder { /** Implementation of `make` for Wasm. * * This is the original upstream implementation. + * + * @tparam T the element type of the array builder, with a `ClassTag` context bound + * @return a new array builder specialized for the runtime type of `T` */ @inline private def makeForWasm[T: ClassTag]: ArrayBuilder[T] = { @@ -146,7 +160,12 @@ object ArrayBuilder { this } - /** Adds a slice of an array. */ + /** Adds a slice of an array. + * + * @param xs the array from which to add a slice of elements + * @param offset the starting index in `xs` from which to copy elements + * @param length the number of elements to copy from `xs` + */ override def addAll(xs: Array[_ <: T], offset: Int, length: Int): this.type = { val end = offset + length var i = offset diff --git a/library-js/src/scala/collection/mutable/Buffer.scala b/library-js/src/scala/collection/mutable/Buffer.scala index 9cb0aa3520c4..45791cd46214 100644 --- a/library-js/src/scala/collection/mutable/Buffer.scala +++ b/library-js/src/scala/collection/mutable/Buffer.scala @@ -17,7 +17,10 @@ import scala.language.`2.13` import scala.scalajs.js -/** A `Buffer` is a growable and shrinkable `Seq`. */ +/** A `Buffer` is a growable and shrinkable `Seq`. + * + * @tparam A the type of elements contained in this buffer + */ trait Buffer[A] extends Seq[A] with SeqOps[A, Buffer, Buffer[A]] diff --git a/library-js/src/scala/concurrent/ExecutionContext.scala b/library-js/src/scala/concurrent/ExecutionContext.scala index 581a3cfb3465..017b302a8169 100644 --- a/library-js/src/scala/concurrent/ExecutionContext.scala +++ b/library-js/src/scala/concurrent/ExecutionContext.scala @@ -169,6 +169,8 @@ object ExecutionContext { * The default `ExecutionContext` implementation is backed by a work-stealing thread pool. By default, * the thread pool uses a target number of worker threads equal to the number of * [available processors](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Runtime.html#availableProcessors()). + * + * @return the global `ExecutionContext` */ implicit final def global: ExecutionContext = ExecutionContext.global } diff --git a/library-js/src/scala/runtime/ScalaRunTime.scala b/library-js/src/scala/runtime/ScalaRunTime.scala index e7438193adbe..758d821cde73 100644 --- a/library-js/src/scala/runtime/ScalaRunTime.scala +++ b/library-js/src/scala/runtime/ScalaRunTime.scala @@ -39,7 +39,11 @@ object ScalaRunTime { def drop[Repr](coll: Repr, num: Int)(implicit iterable: IsIterable[Repr] { type C <: Repr }): Repr = iterable(coll) drop num - /** Returns the class object representing an array with element class `clazz`. */ + /** Returns the class object representing an array with element class `clazz`. + * + * @param clazz the element class for the resulting array type + * @return the `Class` object representing `Array[clazz]` + */ def arrayClass(clazz: jClass[_]): jClass[_] = { // newInstance throws an exception if the erasure is Void.TYPE. see scala/bug#5680 if (clazz == java.lang.Void.TYPE) classOf[Array[Unit]] @@ -49,11 +53,20 @@ object ScalaRunTime { /** Returns the class object representing an unboxed value type, * e.g., classOf[int], not classOf[java.lang.Integer]. The compiler * rewrites expressions like 5.getClass to come here. + * + * @tparam T the primitive value type whose runtime class is to be retrieved + * @param value the value instance (unused; the class is derived from the implicit `ClassTag`) + * @return the runtime `Class` representing the unboxed type `T` */ def anyValClass[T <: AnyVal : ClassTag](value: T): jClass[T] = classTag[T].runtimeClass.asInstanceOf[jClass[T]] - /** Retrieves generic array element. */ + /** Retrieves generic array element. + * + * @param xs the array to access, typed as `AnyRef` to support both reference and primitive arrays + * @param idx the zero-based index of the element to retrieve + * @return the element at position `idx` in the array + */ def array_apply(xs: AnyRef, idx: Int): Any = { xs match { case x: Array[AnyRef] => x(idx).asInstanceOf[Any] @@ -69,7 +82,12 @@ object ScalaRunTime { } } - /** Updates generic array element. */ + /** Updates generic array element. + * + * @param xs the array to update, typed as `AnyRef` to support both reference and primitive arrays + * @param idx the zero-based index of the element to update + * @param value the new value to store at the given index + */ def array_update(xs: AnyRef, idx: Int, value: Any): Unit = { xs match { case x: Array[AnyRef] => x(idx) = value.asInstanceOf[AnyRef] @@ -85,7 +103,11 @@ object ScalaRunTime { } } - /** Gets generic array length. */ + /** Gets generic array length. + * + * @param xs the array whose length is to be determined + * @return the number of elements in the array + */ @inline def array_length(xs: AnyRef): Int = java.lang.reflect.Array.getLength(xs) // TODO: bytecode Object.clone() will in fact work here and avoids @@ -106,6 +128,9 @@ object ScalaRunTime { /** Converts an array to an object array. * Needed to deal with vararg arguments of primitive types that are passed * to a generic Java vararg parameter T ... + * + * @param src the source array to convert, which may be a primitive array + * @return an `Array[Object]` containing the (boxed) elements of `src` */ def toObjectArray(src: AnyRef): Array[Object] = src match { case x: Array[AnyRef] => x @@ -136,7 +161,12 @@ object ScalaRunTime { def _hashCode(x: Product): Int = scala.util.hashing.MurmurHash3.productHash(x) - /** A helper for case classes. */ + /** A helper for case classes. + * + * @tparam T the target element type to which each product element is cast (unchecked) + * @param x the product instance to iterate over + * @return an iterator over the product's elements, cast to type `T` + */ def typedProductIterator[T](x: Product): Iterator[T] = { new AbstractIterator[T] { private[this] var c: Int = 0 @@ -245,7 +275,12 @@ object ScalaRunTime { } } - /** stringOf formatted for use in a repl result. */ + /** stringOf formatted for use in a repl result. + * + * @param arg the value to convert to a string representation + * @param maxElements the maximum number of collection elements to include in the output + * @return a string representation of `arg`, formatted for REPL display + */ def replStringOf(arg: Any, maxElements: Int): String = stringOf(arg, maxElements) match { case null => "null toString" diff --git a/library-js/src/scala/util/DynamicVariable.scala b/library-js/src/scala/util/DynamicVariable.scala index 1206b27d13d9..301f52a65185 100644 --- a/library-js/src/scala/util/DynamicVariable.scala +++ b/library-js/src/scala/util/DynamicVariable.scala @@ -42,6 +42,9 @@ import java.lang.InheritableThreadLocal * * @author Lex Spoon * @since 2.6 + * + * @tparam T the type of the dynamic variable's value + * @param init the initial value of the variable */ class DynamicVariable[T](init: T) { /* Scala.js: replaced InheritableThreadLocal by a simple var. @@ -56,6 +59,7 @@ class DynamicVariable[T](init: T) { /** Sets the value of the variable while executing the specified * thunk. * + * @tparam S the result type of the thunk, also the return type of this method * @param newval The value to which to set the variable * @param thunk The code to evaluate under the new setting */ diff --git a/library/src/scala/AnyVal.scala b/library/src/scala/AnyVal.scala index d9b0db327a0b..2605e1346d96 100644 --- a/library/src/scala/AnyVal.scala +++ b/library/src/scala/AnyVal.scala @@ -55,6 +55,4 @@ import scala.language.`2.13` * still must allocate a value class instance at runtime. These limitations and circumstances are * explained in greater detail in the [Value Classes and Universal Traits](https://docs.scala-lang.org/overviews/core/value-classes.html). */ -transparent abstract class AnyVal extends Any, Matchable { - def getClass(): Class[? <: AnyVal] = null.asInstanceOf[Class[? <: AnyVal]] -} +transparent abstract class AnyVal extends Any, Matchable diff --git a/library/src/scala/Array.scala b/library/src/scala/Array.scala index 4e993ae9a70d..629a9580c44f 100644 --- a/library/src/scala/Array.scala +++ b/library/src/scala/Array.scala @@ -46,7 +46,11 @@ object Array { val emptyShortArray = new Array[Short](0) val emptyObjectArray = new Array[Object](0) - /** Provides an implicit conversion from the Array object to a collection Factory. */ + /** Provides an implicit conversion from the Array object to a collection Factory. + * + * @tparam A the element type of the array to be created + * @param dummy the `Array` companion object used to trigger the implicit conversion + */ implicit def toFactory[A : ClassTag](dummy: Array.type): Factory[A, Array[A]] = new ArrayFactory(dummy) @SerialVersionUID(3L) private class ArrayFactory[A : ClassTag](dummy: Array.type) extends Factory[A, Array[A]] with Serializable { @@ -54,7 +58,11 @@ object Array { def newBuilder: mutable.Builder[A, Array[A]] = Array.newBuilder[A] } - /** Returns a new [[scala.collection.mutable.ArrayBuilder]]. */ + /** Returns a new [[scala.collection.mutable.ArrayBuilder]]. + * + * @tparam T the element type of the array to be built + * @param t the `ClassTag` providing runtime type information for `T` + */ def newBuilder[T](implicit t: ClassTag[T]): ArrayBuilder[T] = ArrayBuilder.make[T](using t) /** Builds an array from the iterable collection. @@ -67,11 +75,12 @@ object Array { * val b: Array[Int] = Array(1, 2, 3, 4) * ``` * + * @tparam A the element type of the array * @param it the iterable collection * @return an array consisting of elements of the iterable collection */ def from[A : ClassTag](it: IterableOnce[A]^): Array[A] = it match { - case it: Iterable[A] => it.toArray[A] + case it: Iterable[A @unchecked] => it.toArray[A] case _ => it.iterator.toArray[A] } @@ -123,6 +132,11 @@ object Array { * except that this works for primitive and object arrays in a single method. * * @see `java.util.Arrays#copyOf` + * + * @tparam A the element type of the array + * @param original the array to be copied + * @param newLength the length of the copy to be returned + * @return a copy of the original array, truncated or padded with default values to obtain the specified length */ def copyOf[A](original: Array[A], newLength: Int): Array[A] = ((original: @unchecked) match { case original: Array[BoxedUnit] => newUnitArray(newLength).asInstanceOf[Array[A]] @@ -149,6 +163,12 @@ object Array { * in a single method. * * @see `java.util.Arrays#copyOf` + * + * @tparam A the element type of the target array + * @param original the array to be copied + * @param newLength the length of the copy to be returned + * @param ct the `ClassTag` providing runtime type information for the target element type `A` + * @return a copy of the original array, with elements converted to type `A`, truncated or padded to the specified length */ def copyAs[A](original: Array[?], newLength: Int)(implicit ct: ClassTag[A]): Array[A] = { val runtimeClass = ct.runtimeClass @@ -175,7 +195,10 @@ object Array { result } - /** Returns an array of length 0. */ + /** Returns an array of length 0. + * + * @tparam T the element type of the array + */ def empty[T: ClassTag]: Array[T] = new Array[T](0) /** Creates an array with given elements. @@ -205,7 +228,11 @@ object Array { } } - /** Creates an array of `Boolean` objects. */ + /** Creates an array of `Boolean` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Boolean, xs: Boolean*): Array[Boolean] = { val array = new Array[Boolean](xs.length + 1) @@ -218,7 +245,11 @@ object Array { array } - /** Creates an array of `Byte` objects. */ + /** Creates an array of `Byte` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Byte, xs: Byte*): Array[Byte] = { val array = new Array[Byte](xs.length + 1) @@ -231,7 +262,11 @@ object Array { array } - /** Creates an array of `Short` objects. */ + /** Creates an array of `Short` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Short, xs: Short*): Array[Short] = { val array = new Array[Short](xs.length + 1) @@ -244,7 +279,11 @@ object Array { array } - /** Creates an array of `Char` objects. */ + /** Creates an array of `Char` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Char, xs: Char*): Array[Char] = { val array = new Array[Char](xs.length + 1) @@ -257,7 +296,11 @@ object Array { array } - /** Creates an array of `Int` objects. */ + /** Creates an array of `Int` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Int, xs: Int*): Array[Int] = { val array = new Array[Int](xs.length + 1) @@ -270,7 +313,11 @@ object Array { array } - /** Creates an array of `Long` objects. */ + /** Creates an array of `Long` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Long, xs: Long*): Array[Long] = { val array = new Array[Long](xs.length + 1) @@ -283,7 +330,11 @@ object Array { array } - /** Creates an array of `Float` objects. */ + /** Creates an array of `Float` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Float, xs: Float*): Array[Float] = { val array = new Array[Float](xs.length + 1) @@ -296,7 +347,11 @@ object Array { array } - /** Creates an array of `Double` objects. */ + /** Creates an array of `Double` objects. + * + * @param x the first element + * @param xs the remaining elements + */ // Subject to a compiler optimization in Cleanup, see above. def apply(x: Double, xs: Double*): Array[Double] = { val array = new Array[Double](xs.length + 1) @@ -309,7 +364,11 @@ object Array { array } - /** Creates an array of `Unit` objects. */ + /** Creates an array of `Unit` objects. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Unit, xs: Unit*): Array[Unit] = { val array = new Array[Unit](xs.length + 1) array(0) = x @@ -321,28 +380,59 @@ object Array { array } - /** Creates array with given dimensions. */ + /** Creates array with given dimensions. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + */ def ofDim[T: ClassTag](n1: Int): Array[T] = new Array[T](n1) - /** Creates a 2-dimensional array. */ + /** Creates a 2-dimensional array. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + */ def ofDim[T: ClassTag](n1: Int, n2: Int): Array[Array[T]] = { val arr: Array[Array[T]] = (new Array[Array[T]](n1): Array[Array[T]]) for (i <- 0 until n1) arr(i) = new Array[T](n2) arr // tabulate(n1)(_ => ofDim[T](n2)) } - /** Creates a 3-dimensional array. */ + /** Creates a 3-dimensional array. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3rd dimension + */ def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] = tabulate(n1)(_ => ofDim[T](n2, n3)) - /** Creates a 4-dimensional array. */ + /** Creates a 4-dimensional array. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3rd dimension + * @param n4 the number of elements in the 4th dimension + */ def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] = tabulate(n1)(_ => ofDim[T](n2, n3, n4)) - /** Creates a 5-dimensional array. */ + /** Creates a 5-dimensional array. + * + * @tparam T the element type of the array + * @param n1 the number of elements in the 1st dimension + * @param n2 the number of elements in the 2nd dimension + * @param n3 the number of elements in the 3rd dimension + * @param n4 the number of elements in the 4th dimension + * @param n5 the number of elements in the 5th dimension + */ def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] = tabulate(n1)(_ => ofDim[T](n2, n3, n4, n5)) /** Concatenates all arrays into a single array. * + * @tparam T the element type of the arrays * @param xss the given arrays * @return the array created from concatenating `xss` */ @@ -362,6 +452,7 @@ object Array { * res3: Array[Double] = Array(0.365461167592537, 1.550395944913685E-4, 0.7907242137333306) * ``` * + * @tparam T the element type of the array * @param n the number of elements desired * @param elem the element computation * @return an Array of size n, where each element contains the result of computing @@ -384,6 +475,7 @@ object Array { /** Returns a two-dimensional array that contains the results of some element * computation a number of times. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param elem the element computation @@ -394,6 +486,7 @@ object Array { /** Returns a three-dimensional array that contains the results of some element * computation a number of times. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -405,6 +498,7 @@ object Array { /** Returns a four-dimensional array that contains the results of some element * computation a number of times. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -417,6 +511,7 @@ object Array { /** Returns a five-dimensional array that contains the results of some element * computation a number of times. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -430,6 +525,7 @@ object Array { /** Returns an array containing values of a given function over a range of integer * values starting from 0. * + * @tparam T the element type of the array * @param n The number of elements in the array * @param f The function computing element values * @return An `Array` consisting of elements `f(0),f(1), ..., f(n - 1)` @@ -451,6 +547,7 @@ object Array { /** Returns a two-dimensional array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param f The function computing element values @@ -461,6 +558,7 @@ object Array { /** Returns a three-dimensional array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -472,6 +570,7 @@ object Array { /** Returns a four-dimensional array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -484,6 +583,7 @@ object Array { /** Returns a five-dimensional array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -525,6 +625,7 @@ object Array { /** Returns an array containing repeated applications of a function to a start value. * + * @tparam T the element type of the array * @param start the start value of the array * @param len the number of elements returned by the array * @param f the function that is repeatedly applied @@ -573,8 +674,9 @@ object Array { /** Called in a pattern match like `{ case Array(x,y,z) => println('3 elements')}`. * + * @tparam T the element type of the array * @param x the selector value - * @return sequence wrapped in a [[scala.Some]], if `x` is an Array, otherwise `None` + * @return a [[UnapplySeqWrapper]] that provides sequence-like access to the array elements */ def unapplySeq[T](x: Array[T]): UnapplySeqWrapper[T] = new UnapplySeqWrapper(x) @@ -656,6 +758,8 @@ object Array { * @define willNotTerminateInf * @define collectExample * @define undefinedorder + * + * @tparam T the element type of the array */ final class Array[T](_length: Int) extends java.io.Serializable with java.lang.Cloneable { self: Array[T] => diff --git a/library/src/scala/Boolean.scala b/library/src/scala/Boolean.scala index e624879bbf38..f07c2808bd30 100644 --- a/library/src/scala/Boolean.scala +++ b/library/src/scala/Boolean.scala @@ -57,6 +57,9 @@ final abstract class Boolean private extends AnyVal { * @note This method uses 'short-circuit' evaluation and * behaves as if it was declared as `def ||(x: => Boolean): Boolean`. * If `a` evaluates to `true`, `true` is returned without evaluating `b`. + * + * @param x the right-hand operand, only evaluated if `this` is `false` + * @return `true` if at least one operand is `true`, `false` otherwise */ def ||(x: Boolean): Boolean @@ -68,6 +71,9 @@ final abstract class Boolean private extends AnyVal { * @note This method uses 'short-circuit' evaluation and * behaves as if it was declared as `def &&(x: => Boolean): Boolean`. * If `a` evaluates to `false`, `false` is returned without evaluating `b`. + * + * @param x the right-hand operand, only evaluated if `this` is `true` + * @return `true` if both operands are `true`, `false` otherwise */ def &&(x: Boolean): Boolean @@ -83,6 +89,9 @@ final abstract class Boolean private extends AnyVal { * - `a` and `b` are `true`. * * @note This method evaluates both `a` and `b`, even if the result is already determined after evaluating `a`. + * + * @param x the right-hand operand, always evaluated + * @return `true` if at least one operand is `true`, `false` otherwise */ def |(x: Boolean): Boolean @@ -92,6 +101,9 @@ final abstract class Boolean private extends AnyVal { * - `a` and `b` are `true`. * * @note This method evaluates both `a` and `b`, even if the result is already determined after evaluating `a`. + * + * @param x the right-hand operand, always evaluated + * @return `true` if both operands are `true`, `false` otherwise */ def &(x: Boolean): Boolean @@ -100,11 +112,12 @@ final abstract class Boolean private extends AnyVal { * `a ^ b` returns `true` if and only if * - `a` is `true` and `b` is `false` or * - `a` is `false` and `b` is `true`. + * + * @param x the right-hand operand + * @return `true` if the operands evaluate to different values, `false` otherwise */ def ^(x: Boolean): Boolean - // Provide a more specific return type for Scaladoc - override def getClass(): Class[Boolean] = ??? } object Boolean extends AnyValCompanion { diff --git a/library/src/scala/Byte.scala b/library/src/scala/Byte.scala index 5d2c0f5e6021..acb933486653 100644 --- a/library/src/scala/Byte.scala +++ b/library/src/scala/Byte.scala @@ -52,6 +52,8 @@ final abstract class Byte private extends AnyVal { * ``` * 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 * ``` + * + * @param x the number of bits to shift left (only the five lowest bits are used) */ def <<(x: Int): Int /** Returns this value bit-shifted left by the specified number of bits, @@ -71,6 +73,8 @@ final abstract class Byte private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >>> 3 == * // 00011111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right (only the five lowest bits are used) */ def >>>(x: Int): Int /** Returns this value bit-shifted right by the specified number of bits, @@ -92,6 +96,8 @@ final abstract class Byte private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >> 3 == * // 11111111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right (only the five lowest bits are used) */ def >>(x: Int): Int /** Returns this value bit-shifted right by the specified number of bits, @@ -136,19 +142,40 @@ final abstract class Byte private extends AnyVal { /** Returns `true` if this value is not equal to x, `false` otherwise. */ def !=(x: Double): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Byte): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Short): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Char): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Int): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Long): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Float): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Double): Boolean /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ @@ -166,19 +193,40 @@ final abstract class Byte private extends AnyVal { /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ def <=(x: Double): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Byte): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Short): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Char): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Int): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Long): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Float): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Double): Boolean /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */ @@ -204,6 +252,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Byte): Int /** Returns the bitwise OR of this value and `x`. @@ -214,6 +264,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Short): Int /** Returns the bitwise OR of this value and `x`. @@ -224,6 +276,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Char): Int /** Returns the bitwise OR of this value and `x`. @@ -234,6 +288,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Int): Int /** Returns the bitwise OR of this value and `x`. @@ -244,6 +300,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Long): Long @@ -255,6 +313,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Byte): Int /** Returns the bitwise AND of this value and `x`. @@ -265,6 +325,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Short): Int /** Returns the bitwise AND of this value and `x`. @@ -275,6 +337,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Char): Int /** Returns the bitwise AND of this value and `x`. @@ -285,6 +349,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Int): Int /** Returns the bitwise AND of this value and `x`. @@ -295,6 +361,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Long): Long @@ -306,6 +374,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Byte): Int /** Returns the bitwise XOR of this value and `x`. @@ -316,6 +386,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Short): Int /** Returns the bitwise XOR of this value and `x`. @@ -326,6 +398,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Char): Int /** Returns the bitwise XOR of this value and `x`. @@ -336,6 +410,8 @@ final abstract class Byte private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Int): Int /** Returns the bitwise XOR of this value and `x`. @@ -346,86 +422,191 @@ final abstract class Byte private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Byte): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Short): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Char): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Int): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Float): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Double): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Byte): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Short): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Char): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Int): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Long): Long - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Float): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Double): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Byte): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Short): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Char): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Int): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Long): Long - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Float): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Double): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Byte): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Short): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Char): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Int): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Long): Long - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Float): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Double): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Byte): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Short): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Char): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Int): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Long): Long - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Float): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Double): Double - // Provide a more specific return type for Scaladoc - override def getClass(): Class[Byte] = ??? } object Byte extends AnyValCompanion { @@ -458,7 +639,10 @@ object Byte extends AnyValCompanion { /** The `String` representation of the `scala.Byte` companion object. */ override def toString() = "object scala.Byte" - /** Language mandated coercions from `Byte` to "wider" types. */ + /** Language mandated coercions from `Byte` to "wider" types. + * + * @param x the `Byte` value to convert + */ import scala.language.implicitConversions implicit def byte2short(x: Byte): Short = x.toShort implicit def byte2int(x: Byte): Int = x.toInt diff --git a/library/src/scala/Char.scala b/library/src/scala/Char.scala index f9a0ee93a7ba..a20080532ce9 100644 --- a/library/src/scala/Char.scala +++ b/library/src/scala/Char.scala @@ -52,6 +52,8 @@ final abstract class Char private extends AnyVal { * ``` * 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 * ``` + * + * @param x the number of bits to shift left */ def <<(x: Int): Int /** Returns this value bit-shifted left by the specified number of bits, @@ -71,6 +73,8 @@ final abstract class Char private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >>> 3 == * // 00011111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right */ def >>>(x: Int): Int /** Returns this value bit-shifted right by the specified number of bits, @@ -92,6 +96,8 @@ final abstract class Char private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >> 3 == * // 11111111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right */ def >>(x: Int): Int /** Returns this value bit-shifted right by the specified number of bits, @@ -136,19 +142,40 @@ final abstract class Char private extends AnyVal { /** Returns `true` if this value is not equal to x, `false` otherwise. */ def !=(x: Double): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Byte): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Short): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Char): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Int): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Long): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Float): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Double): Boolean /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ @@ -166,19 +193,40 @@ final abstract class Char private extends AnyVal { /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ def <=(x: Double): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Byte): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Short): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Char): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Int): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Long): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Float): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Double): Boolean /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */ @@ -204,6 +252,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Byte): Int /** Returns the bitwise OR of this value and `x`. @@ -214,6 +264,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Short): Int /** Returns the bitwise OR of this value and `x`. @@ -224,6 +276,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Char): Int /** Returns the bitwise OR of this value and `x`. @@ -234,6 +288,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Int): Int /** Returns the bitwise OR of this value and `x`. @@ -244,6 +300,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Long): Long @@ -255,6 +313,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Byte): Int /** Returns the bitwise AND of this value and `x`. @@ -265,6 +325,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Short): Int /** Returns the bitwise AND of this value and `x`. @@ -275,6 +337,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Char): Int /** Returns the bitwise AND of this value and `x`. @@ -285,6 +349,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Int): Int /** Returns the bitwise AND of this value and `x`. @@ -295,6 +361,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Long): Long @@ -306,6 +374,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Byte): Int /** Returns the bitwise XOR of this value and `x`. @@ -316,6 +386,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Short): Int /** Returns the bitwise XOR of this value and `x`. @@ -326,6 +398,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Char): Int /** Returns the bitwise XOR of this value and `x`. @@ -336,6 +410,8 @@ final abstract class Char private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Int): Int /** Returns the bitwise XOR of this value and `x`. @@ -346,86 +422,191 @@ final abstract class Char private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Byte): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Short): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Char): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Int): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Float): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Double): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Byte): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Short): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Char): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Int): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Long): Long - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Float): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Double): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Byte): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Short): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Char): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Int): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Long): Long - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Float): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Double): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Byte): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Short): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Char): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Int): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Long): Long - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Float): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Double): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Byte): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Short): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Char): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Int): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Long): Long - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Float): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Double): Double - // Provide a more specific return type for Scaladoc - override def getClass(): Class[Char] = ??? } object Char extends AnyValCompanion { @@ -458,7 +639,10 @@ object Char extends AnyValCompanion { /** The `String` representation of the `scala.Char` companion object. */ override def toString() = "object scala.Char" - /** Language mandated coercions from `Char` to "wider" types. */ + /** Language mandated coercions from `Char` to "wider" types. + * + * @param x the `Char` value to convert + */ import scala.language.implicitConversions implicit def char2int(x: Char): Int = x.toInt implicit def char2long(x: Char): Long = x.toLong diff --git a/library/src/scala/Conversion.scala b/library/src/scala/Conversion.scala index 753313743d88..5ca11b1c6bd6 100644 --- a/library/src/scala/Conversion.scala +++ b/library/src/scala/Conversion.scala @@ -26,7 +26,6 @@ import annotation.internal.preview */ @java.lang.FunctionalInterface abstract class Conversion[-T, +U] extends Function1[T, U]: - self => /** Converts value `x` of type `T` to type `U`. */ def apply(x: T): U @@ -42,11 +41,9 @@ object Conversion: * conversions are tried from the type of `t` to `T`. `into[T]` types are erased to `T` * in all covariant positions of the types of parameter symbols. */ - @preview opaque type into[+T] >: T = T /** Unwraps an `into`. */ extension [T](x: into[T]) - @preview def underlying: T = x end Conversion diff --git a/library/src/scala/Double.scala b/library/src/scala/Double.scala index c3a3e5294ec4..b2fce37fda10 100644 --- a/library/src/scala/Double.scala +++ b/library/src/scala/Double.scala @@ -68,19 +68,40 @@ final abstract class Double private extends AnyVal { /** Returns `true` if this value is not equal to x, `false` otherwise. */ def !=(x: Double): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def <(x: Byte): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def <(x: Short): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def <(x: Char): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def <(x: Int): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def <(x: Long): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def <(x: Float): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def <(x: Double): Boolean /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ @@ -98,19 +119,40 @@ final abstract class Double private extends AnyVal { /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ def <=(x: Double): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def >(x: Byte): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def >(x: Short): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def >(x: Char): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def >(x: Int): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def >(x: Long): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def >(x: Float): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against this one + */ def >(x: Double): Boolean /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */ @@ -128,83 +170,186 @@ final abstract class Double private extends AnyVal { /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */ def >=(x: Double): Boolean - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Byte): Double - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Short): Double - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Char): Double - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Int): Double - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Long): Double - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Float): Double - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Double): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Byte): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Short): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Char): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Int): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Long): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Float): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Double): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Byte): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Short): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Char): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Int): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Long): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Float): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Double): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Byte): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Short): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Char): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Int): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Long): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Float): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Double): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Byte): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Short): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Char): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Int): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Long): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Float): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Double): Double - // Provide a more specific return type for Scaladoc - override def getClass(): Class[Double] = ??? } object Double extends AnyValCompanion { diff --git a/library/src/scala/Float.scala b/library/src/scala/Float.scala index 72fc810a0c08..1783644721dc 100644 --- a/library/src/scala/Float.scala +++ b/library/src/scala/Float.scala @@ -68,19 +68,40 @@ final abstract class Float private extends AnyVal { /** Returns `true` if this value is not equal to x, `false` otherwise. */ def !=(x: Double): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Byte): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Short): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Char): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Int): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Long): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Float): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Double): Boolean /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ @@ -98,19 +119,40 @@ final abstract class Float private extends AnyVal { /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ def <=(x: Double): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Byte): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Short): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Char): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Int): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Long): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Float): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Double): Boolean /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */ @@ -128,83 +170,186 @@ final abstract class Float private extends AnyVal { /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */ def >=(x: Double): Boolean - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Byte): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Short): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Char): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Int): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Long): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Float): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Double): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Byte): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Short): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Char): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Int): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Long): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Float): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Double): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Byte): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Short): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Char): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Int): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Long): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Float): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Double): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Byte): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Short): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Char): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Int): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Long): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Float): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Double): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Byte): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Short): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Char): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Int): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Long): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Float): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Double): Double - // Provide a more specific return type for Scaladoc - override def getClass(): Class[Float] = ??? } object Float extends AnyValCompanion { @@ -249,7 +394,10 @@ object Float extends AnyValCompanion { /** The `String` representation of the `scala.Float` companion object. */ override def toString() = "object scala.Float" - /** Language mandated coercions from `Float` to "wider" types. */ + /** Language mandated coercions from `Float` to "wider" types. + * + * @param x the `Float` value to convert + */ import scala.language.implicitConversions implicit def float2double(x: Float): Double = x.toDouble } diff --git a/library/src/scala/Function.scala b/library/src/scala/Function.scala index bd5161c94a1b..2311f648c700 100644 --- a/library/src/scala/Function.scala +++ b/library/src/scala/Function.scala @@ -19,11 +19,18 @@ object Function { /** Given a sequence of functions `f,,1,,`, ..., `f,,n,,`, return the * function `f,,1,, andThen ... andThen f,,n,,`. * - * @param fs The given sequence of functions + * @tparam T the common input and output type of the functions in the chain + * @param fs the given sequence of functions */ def chain[T](fs: scala.collection.Seq[T => T]): T => T = { x => fs.foldLeft(x)((x, f) => f(x)) } - /** The constant function. */ + /** The constant function. + * + * @tparam T the return type + * @tparam U the type of the argument to ignore + * @param x the constant value to return + * @param y the argument that is ignored + */ def const[T, U](x: T)(y: U): T = x /** Turns a function `A => Option[B]` into a `PartialFunction[A, B]`. @@ -34,6 +41,8 @@ object Function { * function and examine the return value. * See also [[scala.PartialFunction]], method `applyOrElse`. * + * @tparam T the input type of the function + * @tparam R the result type * @param f a function `T => Option[R]` * @return a partial function defined for those inputs where * f returns `Some(_)` and undefined where `f` returns `None`. @@ -43,22 +52,51 @@ object Function { /** Uncurrying for functions of arity 2. This transforms a unary function * returning another unary function into a function of arity 2. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam R the result type + * @param f the curried function to uncurry */ def uncurried[T1, T2, R](f: T1 => T2 => R): (T1, T2) => R = { (x1, x2) => f(x1)(x2) } - /** Uncurrying for functions of arity 3. */ + /** Uncurrying for functions of arity 3. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam R the result type + * @param f the curried function to uncurry + */ def uncurried[T1, T2, T3, R](f: T1 => T2 => T3 => R): (T1, T2, T3) => R = { (x1, x2, x3) => f(x1)(x2)(x3) } - /** Uncurrying for functions of arity 4. */ + /** Uncurrying for functions of arity 4. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam R the result type + * @param f the curried function to uncurry + */ def uncurried[T1, T2, T3, T4, R](f: T1 => T2 => T3 => T4 => R): (T1, T2, T3, T4) => R = { (x1, x2, x3, x4) => f(x1)(x2)(x3)(x4) } - /** Uncurrying for functions of arity 5. */ + /** Uncurrying for functions of arity 5. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam R the result type + * @param f the curried function to uncurry + */ def uncurried[T1, T2, T3, T4, T5, R](f: T1 => T2 => T3 => T4 => T5 => R): (T1, T2, T3, T4, T5) => R = { (x1, x2, x3, x4, x5) => f(x1)(x2)(x3)(x4)(x5) } @@ -100,6 +138,11 @@ object Function { /** Un-tupling for functions of arity 2. This transforms a function taking * a pair of arguments into a binary function which takes each argument separately. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam R the result type + * @param f the tupled function to untuple */ def untupled[T1, T2, R](f: ((T1, T2)) => R): (T1, T2) => R = { (x1, x2) => f((x1, x2)) @@ -107,6 +150,12 @@ object Function { /** Un-tupling for functions of arity 3. This transforms a function taking * a triple of arguments into a ternary function which takes each argument separately. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam R the result type + * @param f the tupled function to untuple */ def untupled[T1, T2, T3, R](f: ((T1, T2, T3)) => R): (T1, T2, T3) => R = { (x1, x2, x3) => f((x1, x2, x3)) @@ -114,6 +163,13 @@ object Function { /** Un-tupling for functions of arity 4. This transforms a function taking * a 4-tuple of arguments into a function of arity 4 which takes each argument separately. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam R the result type + * @param f the tupled function to untuple */ def untupled[T1, T2, T3, T4, R](f: ((T1, T2, T3, T4)) => R): (T1, T2, T3, T4) => R = { (x1, x2, x3, x4) => f((x1, x2, x3, x4)) @@ -121,6 +177,14 @@ object Function { /** Un-tupling for functions of arity 5. This transforms a function taking * a 5-tuple of arguments into a function of arity 5 which takes each argument separately. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam R the result type + * @param f the tupled function to untuple */ def untupled[T1, T2, T3, T4, T5, R](f: ((T1, T2, T3, T4, T5)) => R): (T1, T2, T3, T4, T5) => R = { (x1, x2, x3, x4, x5) => f((x1, x2, x3, x4, x5)) diff --git a/library/src/scala/Function0.scala b/library/src/scala/Function0.scala index 6defcea5bff5..e2bab9eec04b 100644 --- a/library/src/scala/Function0.scala +++ b/library/src/scala/Function0.scala @@ -10,9 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. -// genprod generated these sources at: 2025-08-11T16:44:44.712777821Z - package scala import scala.language.`2.13` diff --git a/library/src/scala/Function1.scala b/library/src/scala/Function1.scala index d25966243849..ac7a34f2e743 100644 --- a/library/src/scala/Function1.scala +++ b/library/src/scala/Function1.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -38,6 +36,8 @@ object Function1 { * println("Not matched") * } * ``` + * + * @return a `PartialFunction` that is defined where `f` returns `Some` and undefined where `f` returns `None` */ def unlift: PartialFunction[A, B] = Function.unlift(f) } @@ -65,6 +65,8 @@ object Function1 { @annotation.implicitNotFound(msg = "No implicit view available from ${T1} => ${R}.") trait Function1[@specialized(Specializable.Arg) -T1, @specialized(Specializable.Return) +R] extends AnyRef { /** Applies the body of this function to the argument. + * + * @param v1 the function argument * @return the result of function application. */ def apply(v1: T1): R diff --git a/library/src/scala/Function10.scala b/library/src/scala/Function10.scala index 4f8b47f24bbd..d02d08144fcf 100644 --- a/library/src/scala/Function10.scala +++ b/library/src/scala/Function10.scala @@ -10,15 +10,37 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 10 parameters. */ +/** A function of 10 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam R the return type of this function + */ trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument + * @param v2 the 2nd argument + * @param v3 the 3rd argument + * @param v4 the 4th argument + * @param v5 the 5th argument + * @param v6 the 6th argument + * @param v7 the 7th argument + * @param v8 the 8th argument + * @param v9 the 9th argument + * @param v10 the 10th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10): R diff --git a/library/src/scala/Function11.scala b/library/src/scala/Function11.scala index 49128b0bd90f..e7bdc3eb2636 100644 --- a/library/src/scala/Function11.scala +++ b/library/src/scala/Function11.scala @@ -10,15 +10,39 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 11 parameters. */ +/** A function of 11 parameters. + * + * @tparam T1 the type of the 1st parameter of this function + * @tparam T2 the type of the 2nd parameter of this function + * @tparam T3 the type of the 3rd parameter of this function + * @tparam T4 the type of the 4th parameter of this function + * @tparam T5 the type of the 5th parameter of this function + * @tparam T6 the type of the 6th parameter of this function + * @tparam T7 the type of the 7th parameter of this function + * @tparam T8 the type of the 8th parameter of this function + * @tparam T9 the type of the 9th parameter of this function + * @tparam T10 the type of the 10th parameter of this function + * @tparam T11 the type of the 11th parameter of this function + * @tparam R the return type of this function + */ trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st parameter + * @param v2 the value of the 2nd parameter + * @param v3 the value of the 3rd parameter + * @param v4 the value of the 4th parameter + * @param v5 the value of the 5th parameter + * @param v6 the value of the 6th parameter + * @param v7 the value of the 7th parameter + * @param v8 the value of the 8th parameter + * @param v9 the value of the 9th parameter + * @param v10 the value of the 10th parameter + * @param v11 the value of the 11th parameter * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11): R diff --git a/library/src/scala/Function12.scala b/library/src/scala/Function12.scala index 960fac269741..130001979f6b 100644 --- a/library/src/scala/Function12.scala +++ b/library/src/scala/Function12.scala @@ -10,15 +10,41 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 12 parameters. */ +/** A function of 12 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam R the return type of this function + */ trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st argument + * @param v2 the value of the 2nd argument + * @param v3 the value of the 3rd argument + * @param v4 the value of the 4th argument + * @param v5 the value of the 5th argument + * @param v6 the value of the 6th argument + * @param v7 the value of the 7th argument + * @param v8 the value of the 8th argument + * @param v9 the value of the 9th argument + * @param v10 the value of the 10th argument + * @param v11 the value of the 11th argument + * @param v12 the value of the 12th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12): R diff --git a/library/src/scala/Function13.scala b/library/src/scala/Function13.scala index d1addc667b5f..983dc7284855 100644 --- a/library/src/scala/Function13.scala +++ b/library/src/scala/Function13.scala @@ -10,15 +10,43 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 13 parameters. */ +/** A function of 13 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam R the return type of the function + */ trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st argument + * @param v2 the value of the 2nd argument + * @param v3 the value of the 3rd argument + * @param v4 the value of the 4th argument + * @param v5 the value of the 5th argument + * @param v6 the value of the 6th argument + * @param v7 the value of the 7th argument + * @param v8 the value of the 8th argument + * @param v9 the value of the 9th argument + * @param v10 the value of the 10th argument + * @param v11 the value of the 11th argument + * @param v12 the value of the 12th argument + * @param v13 the value of the 13th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13): R diff --git a/library/src/scala/Function14.scala b/library/src/scala/Function14.scala index ba21a50fb147..b91965db10fd 100644 --- a/library/src/scala/Function14.scala +++ b/library/src/scala/Function14.scala @@ -10,15 +10,45 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 14 parameters. */ +/** A function of 14 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam T14 the type of the 14th argument + * @tparam R the type of the result + */ trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st argument + * @param v2 the value of the 2nd argument + * @param v3 the value of the 3rd argument + * @param v4 the value of the 4th argument + * @param v5 the value of the 5th argument + * @param v6 the value of the 6th argument + * @param v7 the value of the 7th argument + * @param v8 the value of the 8th argument + * @param v9 the value of the 9th argument + * @param v10 the value of the 10th argument + * @param v11 the value of the 11th argument + * @param v12 the value of the 12th argument + * @param v13 the value of the 13th argument + * @param v14 the value of the 14th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14): R diff --git a/library/src/scala/Function15.scala b/library/src/scala/Function15.scala index e734d1d15770..d6e9cb492f55 100644 --- a/library/src/scala/Function15.scala +++ b/library/src/scala/Function15.scala @@ -10,15 +10,47 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 15 parameters. */ +/** A function of 15 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam T14 the type of the 14th argument + * @tparam T15 the type of the 15th argument + * @tparam R the return type of the function + */ trait Function15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st argument + * @param v2 the value of the 2nd argument + * @param v3 the value of the 3rd argument + * @param v4 the value of the 4th argument + * @param v5 the value of the 5th argument + * @param v6 the value of the 6th argument + * @param v7 the value of the 7th argument + * @param v8 the value of the 8th argument + * @param v9 the value of the 9th argument + * @param v10 the value of the 10th argument + * @param v11 the value of the 11th argument + * @param v12 the value of the 12th argument + * @param v13 the value of the 13th argument + * @param v14 the value of the 14th argument + * @param v15 the value of the 15th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15): R diff --git a/library/src/scala/Function16.scala b/library/src/scala/Function16.scala index ebba1da5b017..4a28b1f8b7ac 100644 --- a/library/src/scala/Function16.scala +++ b/library/src/scala/Function16.scala @@ -10,15 +10,49 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 16 parameters. */ +/** A function of 16 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam T14 the type of the 14th argument + * @tparam T15 the type of the 15th argument + * @tparam T16 the type of the 16th argument + * @tparam R the result type of the function + */ trait Function16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st argument + * @param v2 the value of the 2nd argument + * @param v3 the value of the 3rd argument + * @param v4 the value of the 4th argument + * @param v5 the value of the 5th argument + * @param v6 the value of the 6th argument + * @param v7 the value of the 7th argument + * @param v8 the value of the 8th argument + * @param v9 the value of the 9th argument + * @param v10 the value of the 10th argument + * @param v11 the value of the 11th argument + * @param v12 the value of the 12th argument + * @param v13 the value of the 13th argument + * @param v14 the value of the 14th argument + * @param v15 the value of the 15th argument + * @param v16 the value of the 16th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16): R diff --git a/library/src/scala/Function17.scala b/library/src/scala/Function17.scala index b87289c92830..007f2766a1be 100644 --- a/library/src/scala/Function17.scala +++ b/library/src/scala/Function17.scala @@ -10,15 +10,51 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 17 parameters. */ +/** A function of 17 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam T14 the type of the 14th argument + * @tparam T15 the type of the 15th argument + * @tparam T16 the type of the 16th argument + * @tparam T17 the type of the 17th argument + * @tparam R the type of the result + */ trait Function17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st argument + * @param v2 the value of the 2nd argument + * @param v3 the value of the 3rd argument + * @param v4 the value of the 4th argument + * @param v5 the value of the 5th argument + * @param v6 the value of the 6th argument + * @param v7 the value of the 7th argument + * @param v8 the value of the 8th argument + * @param v9 the value of the 9th argument + * @param v10 the value of the 10th argument + * @param v11 the value of the 11th argument + * @param v12 the value of the 12th argument + * @param v13 the value of the 13th argument + * @param v14 the value of the 14th argument + * @param v15 the value of the 15th argument + * @param v16 the value of the 16th argument + * @param v17 the value of the 17th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17): R diff --git a/library/src/scala/Function18.scala b/library/src/scala/Function18.scala index 483e211dda35..46bb186ac69f 100644 --- a/library/src/scala/Function18.scala +++ b/library/src/scala/Function18.scala @@ -10,15 +10,53 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 18 parameters. */ +/** A function of 18 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam T14 the type of the 14th argument + * @tparam T15 the type of the 15th argument + * @tparam T16 the type of the 16th argument + * @tparam T17 the type of the 17th argument + * @tparam T18 the type of the 18th argument + * @tparam R the return type of the function + */ trait Function18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st argument + * @param v2 the value of the 2nd argument + * @param v3 the value of the 3rd argument + * @param v4 the value of the 4th argument + * @param v5 the value of the 5th argument + * @param v6 the value of the 6th argument + * @param v7 the value of the 7th argument + * @param v8 the value of the 8th argument + * @param v9 the value of the 9th argument + * @param v10 the value of the 10th argument + * @param v11 the value of the 11th argument + * @param v12 the value of the 12th argument + * @param v13 the value of the 13th argument + * @param v14 the value of the 14th argument + * @param v15 the value of the 15th argument + * @param v16 the value of the 16th argument + * @param v17 the value of the 17th argument + * @param v18 the value of the 18th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18): R diff --git a/library/src/scala/Function19.scala b/library/src/scala/Function19.scala index e36cdefc5dc2..aeca2a45705a 100644 --- a/library/src/scala/Function19.scala +++ b/library/src/scala/Function19.scala @@ -10,15 +10,55 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 19 parameters. */ +/** A function of 19 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam T14 the type of the 14th argument + * @tparam T15 the type of the 15th argument + * @tparam T16 the type of the 16th argument + * @tparam T17 the type of the 17th argument + * @tparam T18 the type of the 18th argument + * @tparam T19 the type of the 19th argument + * @tparam R the result type of the function + */ trait Function19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st argument + * @param v2 the value of the 2nd argument + * @param v3 the value of the 3rd argument + * @param v4 the value of the 4th argument + * @param v5 the value of the 5th argument + * @param v6 the value of the 6th argument + * @param v7 the value of the 7th argument + * @param v8 the value of the 8th argument + * @param v9 the value of the 9th argument + * @param v10 the value of the 10th argument + * @param v11 the value of the 11th argument + * @param v12 the value of the 12th argument + * @param v13 the value of the 13th argument + * @param v14 the value of the 14th argument + * @param v15 the value of the 15th argument + * @param v16 the value of the 16th argument + * @param v17 the value of the 17th argument + * @param v18 the value of the 18th argument + * @param v19 the value of the 19th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19): R diff --git a/library/src/scala/Function2.scala b/library/src/scala/Function2.scala index 1f55819ae8f6..b88a9facf85e 100644 --- a/library/src/scala/Function2.scala +++ b/library/src/scala/Function2.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -34,6 +32,9 @@ import scala.language.`2.13` */ trait Function2[@specialized(Specializable.Args) -T1, @specialized(Specializable.Args) -T2, @specialized(Specializable.Return) +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument of type `T1` + * @param v2 the 2nd argument of type `T2` * @return the result of function application. */ def apply(v1: T1, v2: T2): R diff --git a/library/src/scala/Function20.scala b/library/src/scala/Function20.scala index 3f8a125a6c89..ff086b6c5edc 100644 --- a/library/src/scala/Function20.scala +++ b/library/src/scala/Function20.scala @@ -10,15 +10,57 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 20 parameters. */ +/** A function of 20 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam T14 the type of the 14th argument + * @tparam T15 the type of the 15th argument + * @tparam T16 the type of the 16th argument + * @tparam T17 the type of the 17th argument + * @tparam T18 the type of the 18th argument + * @tparam T19 the type of the 19th argument + * @tparam T20 the type of the 20th argument + * @tparam R the result type of the function + */ trait Function20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the value of the 1st argument + * @param v2 the value of the 2nd argument + * @param v3 the value of the 3rd argument + * @param v4 the value of the 4th argument + * @param v5 the value of the 5th argument + * @param v6 the value of the 6th argument + * @param v7 the value of the 7th argument + * @param v8 the value of the 8th argument + * @param v9 the value of the 9th argument + * @param v10 the value of the 10th argument + * @param v11 the value of the 11th argument + * @param v12 the value of the 12th argument + * @param v13 the value of the 13th argument + * @param v14 the value of the 14th argument + * @param v15 the value of the 15th argument + * @param v16 the value of the 16th argument + * @param v17 the value of the 17th argument + * @param v18 the value of the 18th argument + * @param v19 the value of the 19th argument + * @param v20 the value of the 20th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20): R diff --git a/library/src/scala/Function21.scala b/library/src/scala/Function21.scala index 716b6cab58f0..3591f30c9c47 100644 --- a/library/src/scala/Function21.scala +++ b/library/src/scala/Function21.scala @@ -10,15 +10,59 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 21 parameters. */ +/** A function of 21 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam T14 the type of the 14th argument + * @tparam T15 the type of the 15th argument + * @tparam T16 the type of the 16th argument + * @tparam T17 the type of the 17th argument + * @tparam T18 the type of the 18th argument + * @tparam T19 the type of the 19th argument + * @tparam T20 the type of the 20th argument + * @tparam T21 the type of the 21st argument + * @tparam R the result type of the function + */ trait Function21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument of type `T1` + * @param v2 the 2nd argument of type `T2` + * @param v3 the 3rd argument of type `T3` + * @param v4 the 4th argument of type `T4` + * @param v5 the 5th argument of type `T5` + * @param v6 the 6th argument of type `T6` + * @param v7 the 7th argument of type `T7` + * @param v8 the 8th argument of type `T8` + * @param v9 the 9th argument of type `T9` + * @param v10 the 10th argument of type `T10` + * @param v11 the 11th argument of type `T11` + * @param v12 the 12th argument of type `T12` + * @param v13 the 13th argument of type `T13` + * @param v14 the 14th argument of type `T14` + * @param v15 the 15th argument of type `T15` + * @param v16 the 16th argument of type `T16` + * @param v17 the 17th argument of type `T17` + * @param v18 the 18th argument of type `T18` + * @param v19 the 19th argument of type `T19` + * @param v20 the 20th argument of type `T20` + * @param v21 the 21st argument of type `T21` * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21): R diff --git a/library/src/scala/Function22.scala b/library/src/scala/Function22.scala index bcd897715d20..169e54fa8200 100644 --- a/library/src/scala/Function22.scala +++ b/library/src/scala/Function22.scala @@ -10,15 +10,61 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 22 parameters. */ +/** A function of 22 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam T10 the type of the 10th argument + * @tparam T11 the type of the 11th argument + * @tparam T12 the type of the 12th argument + * @tparam T13 the type of the 13th argument + * @tparam T14 the type of the 14th argument + * @tparam T15 the type of the 15th argument + * @tparam T16 the type of the 16th argument + * @tparam T17 the type of the 17th argument + * @tparam T18 the type of the 18th argument + * @tparam T19 the type of the 19th argument + * @tparam T20 the type of the 20th argument + * @tparam T21 the type of the 21st argument + * @tparam T22 the type of the 22nd argument + * @tparam R the result type of the function + */ trait Function22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument of type `T1` + * @param v2 the 2nd argument of type `T2` + * @param v3 the 3rd argument of type `T3` + * @param v4 the 4th argument of type `T4` + * @param v5 the 5th argument of type `T5` + * @param v6 the 6th argument of type `T6` + * @param v7 the 7th argument of type `T7` + * @param v8 the 8th argument of type `T8` + * @param v9 the 9th argument of type `T9` + * @param v10 the 10th argument of type `T10` + * @param v11 the 11th argument of type `T11` + * @param v12 the 12th argument of type `T12` + * @param v13 the 13th argument of type `T13` + * @param v14 the 14th argument of type `T14` + * @param v15 the 15th argument of type `T15` + * @param v16 the 16th argument of type `T16` + * @param v17 the 17th argument of type `T17` + * @param v18 the 18th argument of type `T18` + * @param v19 the 19th argument of type `T19` + * @param v20 the 20th argument of type `T20` + * @param v21 the 21st argument of type `T21` + * @param v22 the 22nd argument of type `T22` * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22): R diff --git a/library/src/scala/Function3.scala b/library/src/scala/Function3.scala index 919b15ca157d..ec1328a0cead 100644 --- a/library/src/scala/Function3.scala +++ b/library/src/scala/Function3.scala @@ -10,15 +10,23 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 3 parameters. */ +/** A function of 3 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam R the return type of the function + */ trait Function3[-T1, -T2, -T3, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument + * @param v2 the 2nd argument + * @param v3 the 3rd argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3): R diff --git a/library/src/scala/Function4.scala b/library/src/scala/Function4.scala index 0484b43044c8..397062b06970 100644 --- a/library/src/scala/Function4.scala +++ b/library/src/scala/Function4.scala @@ -10,15 +10,25 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 4 parameters. */ +/** A function of 4 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam R the return type of the function + */ trait Function4[-T1, -T2, -T3, -T4, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument + * @param v2 the 2nd argument + * @param v3 the 3rd argument + * @param v4 the 4th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4): R diff --git a/library/src/scala/Function5.scala b/library/src/scala/Function5.scala index 42df8eb58f39..9ce9e9a8a413 100644 --- a/library/src/scala/Function5.scala +++ b/library/src/scala/Function5.scala @@ -10,15 +10,27 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 5 parameters. */ +/** A function of 5 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam R the return type of this function + */ trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument + * @param v2 the 2nd argument + * @param v3 the 3rd argument + * @param v4 the 4th argument + * @param v5 the 5th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5): R diff --git a/library/src/scala/Function6.scala b/library/src/scala/Function6.scala index b56720859aeb..d3449403587f 100644 --- a/library/src/scala/Function6.scala +++ b/library/src/scala/Function6.scala @@ -10,15 +10,29 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 6 parameters. */ +/** A function of 6 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam R the return type of the function + */ trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument + * @param v2 the 2nd argument + * @param v3 the 3rd argument + * @param v4 the 4th argument + * @param v5 the 5th argument + * @param v6 the 6th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6): R diff --git a/library/src/scala/Function7.scala b/library/src/scala/Function7.scala index 703549ee3609..256a4f98614e 100644 --- a/library/src/scala/Function7.scala +++ b/library/src/scala/Function7.scala @@ -10,15 +10,31 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 7 parameters. */ +/** A function of 7 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam R the return type of the function + */ trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument + * @param v2 the 2nd argument + * @param v3 the 3rd argument + * @param v4 the 4th argument + * @param v5 the 5th argument + * @param v6 the 6th argument + * @param v7 the 7th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7): R diff --git a/library/src/scala/Function8.scala b/library/src/scala/Function8.scala index b2ac2bd4c9d2..e9d4c4d3ef63 100644 --- a/library/src/scala/Function8.scala +++ b/library/src/scala/Function8.scala @@ -10,15 +10,33 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 8 parameters. */ +/** A function of 8 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam R the return type of the function + */ trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument + * @param v2 the 2nd argument + * @param v3 the 3rd argument + * @param v4 the 4th argument + * @param v5 the 5th argument + * @param v6 the 6th argument + * @param v7 the 7th argument + * @param v8 the 8th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8): R diff --git a/library/src/scala/Function9.scala b/library/src/scala/Function9.scala index 848a7b35be63..47954cb29851 100644 --- a/library/src/scala/Function9.scala +++ b/library/src/scala/Function9.scala @@ -10,15 +10,35 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` -/** A function of 9 parameters. */ +/** A function of 9 parameters. + * + * @tparam T1 the type of the 1st argument + * @tparam T2 the type of the 2nd argument + * @tparam T3 the type of the 3rd argument + * @tparam T4 the type of the 4th argument + * @tparam T5 the type of the 5th argument + * @tparam T6 the type of the 6th argument + * @tparam T7 the type of the 7th argument + * @tparam T8 the type of the 8th argument + * @tparam T9 the type of the 9th argument + * @tparam R the return type of this function + */ trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends AnyRef { /** Applies the body of this function to the arguments. + * + * @param v1 the 1st argument + * @param v2 the 2nd argument + * @param v3 the 3rd argument + * @param v4 the 4th argument + * @param v5 the 5th argument + * @param v6 the 6th argument + * @param v7 the 7th argument + * @param v8 the 8th argument + * @param v9 the 9th argument * @return the result of function application. */ def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9): R diff --git a/library/src/scala/IArray.scala b/library/src/scala/IArray.scala index 752f39c50693..46a0aa149c18 100644 --- a/library/src/scala/IArray.scala +++ b/library/src/scala/IArray.scala @@ -44,87 +44,155 @@ object IArray: extension [T](arr: IArray[T]) def length: Int = arr.asInstanceOf[Array[T]].length - /** Tests whether this array contains a given value as an element. */ + /** Tests whether this array contains a given value as an element. + * + * @param elem the value to test for membership + */ extension [T](arr: IArray[T]) def contains(elem: T): Boolean = genericArrayOps(arr).contains(elem.asInstanceOf) - /** Copies elements of this array to another array. */ + /** Copies elements of this array to another array. + * + * @tparam U the element type of the destination array, a supertype of `T` + * @param xs the destination array to copy to + */ extension [T](arr: IArray[T]) def copyToArray[U >: T](xs: Array[U]): Int = genericArrayOps(arr).copyToArray(xs) - /** Copies elements of this array to another array. */ + /** Copies elements of this array to another array. + * + * @tparam U the element type of the destination array, a supertype of `T` + * @param xs the destination array to copy to + * @param start the index in `xs` at which to start copying + */ extension [T](arr: IArray[T]) def copyToArray[U >: T](xs: Array[U], start: Int): Int = genericArrayOps(arr).copyToArray(xs, start) - /** Copies elements of this array to another array. */ + /** Copies elements of this array to another array. + * + * @tparam U the element type of the destination array, a supertype of `T` + * @param xs the destination array to copy to + * @param start the index in `xs` at which to start copying + * @param len the maximum number of elements to copy + */ extension [T](arr: IArray[T]) def copyToArray[U >: T](xs: Array[U], start: Int, len: Int): Int = genericArrayOps(arr).copyToArray(xs, start, len) - /** Counts the number of elements in this array which satisfy a predicate. */ + /** Counts the number of elements in this array which satisfy a predicate. + * + * @param p the predicate used to test elements + */ extension [T](arr: IArray[T]) def count(p: T => Boolean): Int = genericArrayOps(arr).count(p) - /** The rest of the array without its `n` first elements. */ + /** The rest of the array without its `n` first elements. + * + * @param n the number of elements to drop from the front + */ extension [T](arr: IArray[T]) def drop(n: Int): IArray[T] = genericArrayOps(arr).drop(n) - /** The rest of the array without its `n` last elements. */ + /** The rest of the array without its `n` last elements. + * + * @param n the number of elements to drop from the end + */ extension [T](arr: IArray[T]) def dropRight(n: Int): IArray[T] = genericArrayOps(arr).dropRight(n) - /** Drops longest prefix of elements that satisfy a predicate. */ + /** Drops longest prefix of elements that satisfy a predicate. + * + * @param p the predicate used to test elements + */ extension [T](arr: IArray[T]) def dropWhile(p: T => Boolean): IArray[T] = genericArrayOps(arr).dropWhile(p) - /** Tests whether a predicate holds for at least one element of this array. */ + /** Tests whether a predicate holds for at least one element of this array. + * + * @param p the predicate used to test elements + */ extension [T](arr: IArray[T]) def exists(p: T => Boolean): Boolean = genericArrayOps(arr).exists(p) - /** Selects all elements of this array which satisfy a predicate. */ + /** Selects all elements of this array which satisfy a predicate. + * + * @param p the predicate used to test elements + */ extension [T](arr: IArray[T]) def filter(p: T => Boolean): IArray[T] = genericArrayOps(arr).filter(p) - /** Selects all elements of this array which do not satisfy a predicate. */ + /** Selects all elements of this array which do not satisfy a predicate. + * + * @param p the predicate used to test elements + */ extension [T](arr: IArray[T]) def filterNot(p: T => Boolean): IArray[T] = genericArrayOps(arr).filterNot(p) - /** Finds the first element of the array satisfying a predicate, if any. */ + /** Finds the first element of the array satisfying a predicate, if any. + * + * @param p the predicate used to test elements + */ extension [T](arr: IArray[T]) def find(p: T => Boolean): Option[T] = genericArrayOps(arr).find(p) /** Builds a new array by applying a function to all elements of this array * and using the elements of the resulting collections. + * + * @tparam U the element type of the returned array + * @param f the function to apply to each element, returning a collection of results */ extension [T](arr: IArray[T]) def flatMap[U: ClassTag](f: T => IterableOnce[U]^): IArray[U] = genericArrayOps(arr).flatMap(f) /** Flattens a two-dimensional array by concatenating all its rows * into a single array. + * + * @tparam U the element type of the resulting array after flattening + * @param asIterable the implicit evidence that `T` can be viewed as `Iterable[U]` */ extension [T](arr: IArray[T]) def flatten[U](using asIterable: T => Iterable[U]^, ct: ClassTag[U]): IArray[U] = genericArrayOps(arr).flatten - /** Folds the elements of this array using the specified associative binary operator. */ + /** Folds the elements of this array using the specified associative binary operator. + * + * @tparam U the result type of the binary operator, a supertype of `T` + * @param z the start value + * @param op the associative binary operator + */ extension [T](arr: IArray[T]) def fold[U >: T](z: U)(op: (U, U) => U): U = genericArrayOps(arr).fold(z)(op) /** Applies a binary operator to a start value and all elements of this array, * going left to right. + * + * @tparam U the result type of the binary operator + * @param z the start value + * @param op the binary operator applied from left to right */ extension [T](arr: IArray[T]) def foldLeft[U](z: U)(op: (U, T) => U): U = genericArrayOps(arr).foldLeft(z)(op) /** Applies a binary operator to all elements of this array and a start value, * going right to left. + * + * @tparam U the result type of the binary operator + * @param z the start value + * @param op the binary operator applied from right to left */ extension [T](arr: IArray[T]) def foldRight[U](z: U)(op: (T, U) => U): U = genericArrayOps(arr).foldRight(z)(op) - /** Tests whether a predicate holds for all elements of this array. */ + /** Tests whether a predicate holds for all elements of this array. + * + * @param p the predicate used to test elements + */ extension [T](arr: IArray[T]) def forall(p: T => Boolean): Boolean = genericArrayOps(arr).forall(p) - /** Applies `f` to each element for its side effects. */ + /** Applies `f` to each element for its side effects. + * + * @tparam U the return type of `f`, discarded + * @param f the function to apply to each element + */ extension [T](arr: IArray[T]) def foreach[U](f: T => U): Unit = genericArrayOps(arr).foreach(f) @@ -136,14 +204,22 @@ object IArray: extension [T](arr: IArray[T]) def headOption: Option[T] = genericArrayOps(arr).headOption - /** Finds index of first occurrence of some value in this array after or at some start index. */ + /** Finds index of first occurrence of some value in this array after or at some start index. + * + * @param elem the value to search for + * @param from the start index where the search begins + */ extension [T](arr: IArray[T]) def indexOf(elem: T, from: Int = 0): Int = // `asInstanceOf` needed because `elem` does not have type `arr.T` // We could use `arr.iterator.indexOf(elem, from)` or `arr.indexWhere(_ == elem, from)` // but these would incur some overhead. genericArrayOps(arr).indexOf(elem.asInstanceOf, from) - /** Finds index of the first element satisfying some predicate after or at some start index. */ + /** Finds index of the first element satisfying some predicate after or at some start index. + * + * @param p the predicate used to test elements + * @param from the start index where the search begins + */ extension [T](arr: IArray[T]) def indexWhere(p: T => Boolean, from: Int = 0): Int = genericArrayOps(arr).indexWhere(p, from) @@ -171,16 +247,28 @@ object IArray: extension [T](arr: IArray[T]) def lastOption: Option[T] = genericArrayOps(arr).lastOption - /** Finds index of last occurrence of some value in this array before or at a given end index. */ + /** Finds index of last occurrence of some value in this array before or at a given end index. + * + * @param elem the value to search for + * @param end the end index (inclusive) where the search ends + */ extension [T](arr: IArray[T]) def lastIndexOf(elem: T, end: Int = arr.length - 1): Int = // see: same issue in `indexOf` genericArrayOps(arr).lastIndexOf(elem.asInstanceOf, end) - /** Finds index of last element satisfying some predicate before or at given end index. */ + /** Finds index of last element satisfying some predicate before or at given end index. + * + * @param p the predicate used to test elements + * @param end the end index (inclusive) where the search ends + */ extension [T](arr: IArray[T]) def lastIndexWhere(p: T => Boolean, end: Int = arr.length - 1): Int = genericArrayOps(arr).lastIndexWhere(p, end) - /** Builds a new array by applying a function to all elements of this array. */ + /** Builds a new array by applying a function to all elements of this array. + * + * @tparam U the element type of the returned array + * @param f the function to apply to each element + */ extension [T](arr: IArray[T]) def map[U: ClassTag](f: T => U): IArray[U] = genericArrayOps(arr).map(f) @@ -188,7 +276,10 @@ object IArray: extension [T](arr: IArray[T]) def nonEmpty: Boolean = genericArrayOps(arr).nonEmpty - /** A pair of, first, all elements that satisfy predicate `p` and, second, all elements that do not. */ + /** A pair of, first, all elements that satisfy predicate `p` and, second, all elements that do not. + * + * @param p the predicate used to partition elements + */ extension [T](arr: IArray[T]) def partition(p: T => Boolean): (IArray[T], IArray[T]) = genericArrayOps(arr).partition(p) @@ -196,18 +287,31 @@ object IArray: extension [T](arr: IArray[T]) def reverse: IArray[T] = genericArrayOps(arr).reverse - /** Computes a prefix scan of the elements of the array. */ + /** Computes a prefix scan of the elements of the array. + * + * @tparam U the element type of the returned array, a supertype of `T` + * @param z the initial value for the scan + * @param op the associative binary operator + */ extension [T](arr: IArray[T]) def scan[U >: T: ClassTag](z: U)(op: (U, U) => U): IArray[U] = genericArrayOps(arr).scan(z)(op) /** Produces an array containing cumulative results of applying the binary * operator going left to right. + * + * @tparam U the element type of the returned array + * @param z the initial value for the scan + * @param op the binary operator applied from left to right */ extension [T](arr: IArray[T]) def scanLeft[U: ClassTag](z: U)(op: (U, T) => U): IArray[U] = genericArrayOps(arr).scanLeft(z)(op) /** Produces an array containing cumulative results of applying the binary * operator going right to left. + * + * @tparam U the element type of the returned array + * @param z the initial value for the scan + * @param op the binary operator applied from right to left */ extension [T](arr: IArray[T]) def scanRight[U: ClassTag](z: U)(op: (T, U) => U): IArray[U] = genericArrayOps(arr).scanRight(z)(op) @@ -216,29 +320,47 @@ object IArray: extension [T](arr: IArray[T]) def size: Int = arr.length - /** Selects the interval of elements between the given indices. */ + /** Selects the interval of elements between the given indices. + * + * @param from the index of the first included element + * @param until the index of the first excluded element + */ extension [T](arr: IArray[T]) def slice(from: Int, until: Int): IArray[T] = genericArrayOps(arr).slice(from, until) /** Sorts this array according to the Ordering which results from transforming * an implicitly given Ordering with a transformation function. - */ + * + * @tparam U the target type of the transformation function, which has an `Ordering` + * @param f the transformation function mapping elements to their sort keys + */ extension [T](arr: IArray[T]) def sortBy[U](f: T => U)(using math.Ordering[U]): IArray[T] = genericArrayOps(arr).sortBy(f) - /** Sorts this array according to a comparison function. */ + /** Sorts this array according to a comparison function. + * + * @param f the comparison function returning true if its first argument should come first + */ extension [T](arr: IArray[T]) def sortWith(f: (T, T) => Boolean): IArray[T] = genericArrayOps(arr).sortWith(f) - /** Sorts this array according to an Ordering. */ + /** Sorts this array according to an Ordering. + * + */ extension [T](arr: IArray[T]) def sorted(using math.Ordering[T]^): IArray[T] = genericArrayOps(arr).sorted - /** Splits this array into a prefix/suffix pair according to a predicate. */ + /** Splits this array into a prefix/suffix pair according to a predicate. + * + * @param p the predicate used to test elements + */ extension [T](arr: IArray[T]) def span(p: T => Boolean): (IArray[T], IArray[T]) = genericArrayOps(arr).span(p) - /** Splits this array into two at a given position. */ + /** Splits this array into two at a given position. + * + * @param n the position at which to split + */ extension [T](arr: IArray[T]) def splitAt(n: Int): (IArray[T], IArray[T]) = genericArrayOps(arr).splitAt(n) @@ -246,15 +368,24 @@ object IArray: extension [T](arr: IArray[T]) def tail: IArray[T] = genericArrayOps(arr).tail - /** An array containing the first `n` elements of this array. */ + /** An array containing the first `n` elements of this array. + * + * @param n the number of elements to take from the front + */ extension [T](arr: IArray[T]) def take(n: Int): IArray[T] = genericArrayOps(arr).take(n) - /** An array containing the last `n` elements of this array. */ + /** An array containing the last `n` elements of this array. + * + * @param n the number of elements to take from the end + */ extension [T](arr: IArray[T]) def takeRight(n: Int): IArray[T] = genericArrayOps(arr).takeRight(n) - /** Takes longest prefix of elements that satisfy a predicate. */ + /** Takes longest prefix of elements that satisfy a predicate. + * + * @param p the predicate used to test elements + */ extension [T](arr: IArray[T]) def takeWhile(p: T => Boolean): IArray[T] = genericArrayOps(arr).takeWhile(p) @@ -348,11 +479,19 @@ object IArray: // We intentionally keep this signature to discourage passing nulls implicitly while // preserving the previous behavior for backward compatibility. - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @tparam T the element type of the array + * @param arr the immutable array to wrap + */ implicit def genericWrapArray[T](arr: IArray[T]): ArraySeq[T] = mapNull(arr, ArraySeq.unsafeWrapArray(arr)) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @tparam T the element type of the array, a reference type + * @param arr the immutable array to wrap + */ implicit def wrapRefArray[T <: AnyRef | Null](arr: IArray[T]): ArraySeq.ofRef[T] = // Since the JVM thinks arrays are covariant, one 0-length Array[AnyRef | Null] // is as good as another for all T <: AnyRef | Null. Instead of creating 100,000,000 @@ -362,49 +501,82 @@ object IArray: else ArraySeq.ofRef(arr.asInstanceOf[Array[T]]) ) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @param arr the immutable `Int` array to wrap + */ implicit def wrapIntArray(arr: IArray[Int]): ArraySeq.ofInt = mapNull(arr, new ArraySeq.ofInt(arr.asInstanceOf[Array[Int]])) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @param arr the immutable `Double` array to wrap + */ implicit def wrapDoubleIArray(arr: IArray[Double]): ArraySeq.ofDouble = mapNull(arr, new ArraySeq.ofDouble(arr.asInstanceOf[Array[Double]])) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @param arr the immutable `Long` array to wrap + */ implicit def wrapLongIArray(arr: IArray[Long]): ArraySeq.ofLong = mapNull(arr, new ArraySeq.ofLong(arr.asInstanceOf[Array[Long]])) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @param arr the immutable `Float` array to wrap + */ implicit def wrapFloatIArray(arr: IArray[Float]): ArraySeq.ofFloat = mapNull(arr, new ArraySeq.ofFloat(arr.asInstanceOf[Array[Float]])) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @param arr the immutable `Char` array to wrap + */ implicit def wrapCharIArray(arr: IArray[Char]): ArraySeq.ofChar = mapNull(arr, new ArraySeq.ofChar(arr.asInstanceOf[Array[Char]])) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @param arr the immutable `Byte` array to wrap + */ implicit def wrapByteIArray(arr: IArray[Byte]): ArraySeq.ofByte = mapNull(arr, new ArraySeq.ofByte(arr.asInstanceOf[Array[Byte]])) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @param arr the immutable `Short` array to wrap + */ implicit def wrapShortIArray(arr: IArray[Short]): ArraySeq.ofShort = mapNull(arr, new ArraySeq.ofShort(arr.asInstanceOf[Array[Short]])) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @param arr the immutable `Boolean` array to wrap + */ implicit def wrapBooleanIArray(arr: IArray[Boolean]): ArraySeq.ofBoolean = mapNull(arr, new ArraySeq.ofBoolean(arr.asInstanceOf[Array[Boolean]])) - /** Conversion from IArray to immutable.ArraySeq. */ + /** Conversion from IArray to immutable.ArraySeq. + * + * @param arr the immutable `Unit` array to wrap + */ implicit def wrapUnitIArray(arr: IArray[Unit]): ArraySeq.ofUnit = mapNull(arr, new ArraySeq.ofUnit(arr.asInstanceOf[Array[Unit]])) /** Converts an array into an immutable array without copying, the original array * must _not_ be mutated after this or the guaranteed immutablity of IArray will * be violated. + * + * @tparam T the element type of the array + * @param s the mutable array to treat as immutable (must not be mutated afterward) */ def unsafeFromArray[T](s: Array[T]): IArray[T] = s - /** An immutable array of length 0. */ + /** An immutable array of length 0. + * + * @tparam T the element type of the empty array + */ def empty[T: ClassTag]: IArray[T] = new Array[T](0) /** An immutable boolean array of length 0. */ @@ -426,25 +598,65 @@ object IArray: /** An immutable object array of length 0. */ def emptyObjectIArray: IArray[Object] = Array.emptyObjectArray - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @tparam T the element type of the array + * @param xs the elements to include in the array + */ def apply[T](xs: T*)(using ct: ClassTag[T]): IArray[T] = Array(xs*) - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Boolean, xs: Boolean*): IArray[Boolean] = Array(x, xs*) - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Byte, xs: Byte*): IArray[Byte] = Array(x, xs*) - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Short, xs: Short*): IArray[Short] = Array(x, xs*) - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Char, xs: Char*): IArray[Char] = Array(x, xs*) - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Int, xs: Int*): IArray[Int] = Array(x, xs*) - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Long, xs: Long*): IArray[Long] = Array(x, xs*) - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Float, xs: Float*): IArray[Float] = Array(x, xs*) - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Double, xs: Double*): IArray[Double] = Array(x, xs*) - /** An immutable array with given elements. */ + /** An immutable array with given elements. + * + * @param x the first element + * @param xs the remaining elements + */ def apply(x: Unit, xs: Unit*): IArray[Unit] = Array(x, xs*) /** Builds an array from the iterable collection. @@ -457,6 +669,7 @@ object IArray: * val b: IArray[Int] = IArray(1, 2, 3, 4) * ``` * + * @tparam A the element type of the array * @param it the iterable collection * @return an array consisting of elements of the iterable collection */ @@ -468,6 +681,7 @@ object IArray: /** Concatenates all arrays into a single immutable array. * + * @tparam T the element type of the arrays * @param xss the given immutable arrays * @return the array created from concatenating `xss` */ @@ -480,6 +694,7 @@ object IArray: /** Returns an immutable array that contains the results of some element computation a number * of times. Each element is determined by a separate computation. * + * @tparam T the element type of the array * @param n the number of elements in the array * @param elem the element computation */ @@ -489,6 +704,7 @@ object IArray: /** Returns a two-dimensional immutable array that contains the results of some element computation a number * of times. Each element is determined by a separate computation. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param elem the element computation @@ -499,9 +715,10 @@ object IArray: /** Returns a three-dimensional immutable array that contains the results of some element computation a number * of times. Each element is determined by a separate computation. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension - * @param n3 the number of elements in the 3nd dimension + * @param n3 the number of elements in the 3rd dimension * @param elem the element computation */ def fill[T: ClassTag](n1: Int, n2: Int, n3: Int)(elem: => T): IArray[IArray[IArray[T]]] = @@ -510,9 +727,10 @@ object IArray: /** Returns a four-dimensional immutable array that contains the results of some element computation a number * of times. Each element is determined by a separate computation. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension - * @param n3 the number of elements in the 3nd dimension + * @param n3 the number of elements in the 3rd dimension * @param n4 the number of elements in the 4th dimension * @param elem the element computation */ @@ -522,9 +740,10 @@ object IArray: /** Returns a five-dimensional immutable array that contains the results of some element computation a number * of times. Each element is determined by a separate computation. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension - * @param n3 the number of elements in the 3nd dimension + * @param n3 the number of elements in the 3rd dimension * @param n4 the number of elements in the 4th dimension * @param n5 the number of elements in the 5th dimension * @param elem the element computation @@ -535,6 +754,7 @@ object IArray: /** Returns an immutable array containing values of a given function over a range of integer * values starting from 0. * + * @tparam T the element type of the array * @param n The number of elements in the array * @param f The function computing element values */ @@ -544,6 +764,7 @@ object IArray: /** Returns a two-dimensional immutable array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param f The function computing element values @@ -554,6 +775,7 @@ object IArray: /** Returns a three-dimensional immutable array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -565,6 +787,7 @@ object IArray: /** Returns a four-dimensional immutable array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -577,6 +800,7 @@ object IArray: /** Returns a five-dimensional immutable array containing values of a given function * over ranges of integer values starting from `0`. * + * @tparam T the element type of the array * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -607,6 +831,7 @@ object IArray: /** Returns an immutable array containing repeated applications of a function to a start value. * + * @tparam T the element type of the array * @param start the start value of the array * @param len the number of elements returned by the array * @param f the function that is repeatedly applied @@ -628,17 +853,26 @@ object IArray: /** Returns a decomposition of the array into a sequence. This supports * a pattern match like `{ case IArray(x,y,z) => println('3 elements')}`. * + * @tparam T the element type of the array * @param x the selector value * @return sequence wrapped in a [[scala.Some]], if `x` is a Seq, otherwise `None` */ def unapplySeq[T](x: IArray[T]): Array.UnapplySeqWrapper[? <: T] = Array.unapplySeq(x) - /** A lazy filtered array. No filtering is applied until one of `foreach`, `map` or `flatMap` is called. */ + /** A lazy filtered array. No filtering is applied until one of `foreach`, `map` or `flatMap` is called. + * + * @tparam T the element type of the array + * @param p the filter predicate + * @param xs the underlying immutable array + */ class WithFilter[T](p: T => Boolean, xs: IArray[T]): /** Applies `f` to each element for its side effects. * Note: [U] parameter needed to help scalac's type inference. + * + * @tparam U the return type of `f`, discarded + * @param f the function to apply to each element */ def foreach[U](f: T => U): Unit = { val len = xs.length @@ -690,7 +924,10 @@ object IArray: def flatMap[BS, U](f: T => BS)(using asIterable: BS => Iterable[U]^, m: ClassTag[U]): IArray[U] = flatMap[U](x => asIterable(f(x))) - /** Creates a new non-strict filter which combines this filter with the given predicate. */ + /** Creates a new non-strict filter which combines this filter with the given predicate. + * + * @param q the additional predicate to apply + */ def withFilter(q: T => Boolean): WithFilter[T]^{p, q} = new WithFilter[T](a => p(a) && q(a), xs) end WithFilter diff --git a/library/src/scala/Int.scala b/library/src/scala/Int.scala index 8993a894376a..74067567da02 100644 --- a/library/src/scala/Int.scala +++ b/library/src/scala/Int.scala @@ -52,6 +52,8 @@ final abstract class Int private extends AnyVal { * ``` * 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 * ``` + * + * @param x the number of bits to shift left (only the 5 lowest-order bits are used) */ def <<(x: Int): Int /** Returns this value bit-shifted left by the specified number of bits, @@ -71,6 +73,8 @@ final abstract class Int private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >>> 3 == * // 00011111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right (only the 5 lowest-order bits are used) */ def >>>(x: Int): Int /** Returns this value bit-shifted right by the specified number of bits, @@ -92,6 +96,8 @@ final abstract class Int private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >> 3 == * // 11111111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right (only the 5 lowest-order bits are used) */ def >>(x: Int): Int /** Returns this value bit-shifted right by the specified number of bits, @@ -136,19 +142,40 @@ final abstract class Int private extends AnyVal { /** Returns `true` if this value is not equal to x, `false` otherwise. */ def !=(x: Double): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Byte): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Short): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Char): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Int): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Long): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Float): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Double): Boolean /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ @@ -166,19 +193,40 @@ final abstract class Int private extends AnyVal { /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ def <=(x: Double): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Byte): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Short): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Char): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Int): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Long): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Float): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Double): Boolean /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */ @@ -204,6 +252,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Byte): Int /** Returns the bitwise OR of this value and `x`. @@ -214,6 +264,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Short): Int /** Returns the bitwise OR of this value and `x`. @@ -224,6 +276,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Char): Int /** Returns the bitwise OR of this value and `x`. @@ -234,6 +288,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Int): Int /** Returns the bitwise OR of this value and `x`. @@ -244,6 +300,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Long): Long @@ -255,6 +313,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Byte): Int /** Returns the bitwise AND of this value and `x`. @@ -265,6 +325,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Short): Int /** Returns the bitwise AND of this value and `x`. @@ -275,6 +337,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Char): Int /** Returns the bitwise AND of this value and `x`. @@ -285,6 +349,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Int): Int /** Returns the bitwise AND of this value and `x`. @@ -295,6 +361,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Long): Long @@ -306,6 +374,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Byte): Int /** Returns the bitwise XOR of this value and `x`. @@ -316,6 +386,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Short): Int /** Returns the bitwise XOR of this value and `x`. @@ -326,6 +398,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Char): Int /** Returns the bitwise XOR of this value and `x`. @@ -336,6 +410,8 @@ final abstract class Int private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Int): Int /** Returns the bitwise XOR of this value and `x`. @@ -346,86 +422,191 @@ final abstract class Int private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Byte): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Short): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Char): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Int): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Float): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Double): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Byte): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Short): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Char): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Int): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Long): Long - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Float): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Double): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Byte): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Short): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Char): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Int): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Long): Long - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Float): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Double): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Byte): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Short): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Char): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Int): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Long): Long - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Float): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Double): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Byte): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Short): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Char): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Int): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Long): Long - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Float): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Double): Double - // Provide a more specific return type for Scaladoc - override def getClass(): Class[Int] = ??? } object Int extends AnyValCompanion { diff --git a/library/src/scala/Long.scala b/library/src/scala/Long.scala index b28141b46b68..192f96ae47a2 100644 --- a/library/src/scala/Long.scala +++ b/library/src/scala/Long.scala @@ -52,6 +52,8 @@ final abstract class Long private extends AnyVal { * ``` * 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 * ``` + * + * @param x the number of bits to shift left */ def <<(x: Int): Long /** Returns this value bit-shifted left by the specified number of bits, @@ -60,6 +62,8 @@ final abstract class Long private extends AnyVal { * ``` * 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 * ``` + * + * @param x the number of bits to shift left */ def <<(x: Long): Long /** Returns this value bit-shifted right by the specified number of bits, @@ -70,6 +74,8 @@ final abstract class Long private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >>> 3 == * // 00011111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right */ def >>>(x: Int): Long /** Returns this value bit-shifted right by the specified number of bits, @@ -80,6 +86,8 @@ final abstract class Long private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >>> 3 == * // 00011111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right */ def >>>(x: Long): Long /** Returns this value bit-shifted right by the specified number of bits, @@ -90,6 +98,8 @@ final abstract class Long private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >> 3 == * // 11111111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right */ def >>(x: Int): Long /** Returns this value bit-shifted right by the specified number of bits, @@ -100,6 +110,8 @@ final abstract class Long private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >> 3 == * // 11111111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right */ def >>(x: Long): Long @@ -133,19 +145,40 @@ final abstract class Long private extends AnyVal { /** Returns `true` if this value is not equal to x, `false` otherwise. */ def !=(x: Double): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Byte): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Short): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Char): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Int): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Long): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Float): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Double): Boolean /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ @@ -163,19 +196,40 @@ final abstract class Long private extends AnyVal { /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ def <=(x: Double): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Byte): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Short): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Char): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Int): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Long): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Float): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Double): Boolean /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */ @@ -201,6 +255,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Byte): Long /** Returns the bitwise OR of this value and `x`. @@ -211,6 +267,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Short): Long /** Returns the bitwise OR of this value and `x`. @@ -221,6 +279,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Char): Long /** Returns the bitwise OR of this value and `x`. @@ -231,6 +291,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Int): Long /** Returns the bitwise OR of this value and `x`. @@ -241,6 +303,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Long): Long @@ -252,6 +316,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Byte): Long /** Returns the bitwise AND of this value and `x`. @@ -262,6 +328,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Short): Long /** Returns the bitwise AND of this value and `x`. @@ -272,6 +340,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Char): Long /** Returns the bitwise AND of this value and `x`. @@ -282,6 +352,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Int): Long /** Returns the bitwise AND of this value and `x`. @@ -292,6 +364,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Long): Long @@ -303,6 +377,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Byte): Long /** Returns the bitwise XOR of this value and `x`. @@ -313,6 +389,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Short): Long /** Returns the bitwise XOR of this value and `x`. @@ -323,6 +401,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Char): Long /** Returns the bitwise XOR of this value and `x`. @@ -333,6 +413,8 @@ final abstract class Long private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Int): Long /** Returns the bitwise XOR of this value and `x`. @@ -343,86 +425,191 @@ final abstract class Long private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Byte): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Short): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Char): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Int): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Float): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Double): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Byte): Long - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Short): Long - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Char): Long - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Int): Long - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Long): Long - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Float): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Double): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Byte): Long - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Short): Long - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Char): Long - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Int): Long - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Long): Long - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Float): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Double): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Byte): Long - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Short): Long - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Char): Long - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Int): Long - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Long): Long - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Float): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Double): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Byte): Long - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Short): Long - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Char): Long - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Int): Long - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Long): Long - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Float): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Double): Double - // Provide a more specific return type for Scaladoc - override def getClass(): Class[Long] = ??? } object Long extends AnyValCompanion { diff --git a/library/src/scala/NamedTuple.scala b/library/src/scala/NamedTuple.scala index 48c3124475bd..c5d5b034387b 100644 --- a/library/src/scala/NamedTuple.scala +++ b/library/src/scala/NamedTuple.scala @@ -185,7 +185,7 @@ object NamedTupleDecomposition: * the polymorphic mapping function `f`. The names of elements are preserved. * If `x = (n1 = v1, ..., ni = vi)` then `x.map(f) = `(n1 = f(v1), ..., ni = f(vi))`. */ - inline def map[F[_]](f: [t] => t => F[t]): Map[NamedTuple[N, V], F] = + inline def map[F[_]](f: [t] -> t -> F[t]): Map[NamedTuple[N, V], F] = x.toTuple.map[F](f) /** The named tuple consisting of all elements of this tuple in reverse. */ diff --git a/library/src/scala/Option.scala b/library/src/scala/Option.scala index 68f2ee039e7e..a4c9dbd27129 100644 --- a/library/src/scala/Option.scala +++ b/library/src/scala/Option.scala @@ -18,13 +18,18 @@ object Option { import scala.language.implicitConversions - /** An implicit conversion that converts an option to an iterable value. */ + /** An implicit conversion that converts an option to an iterable value. + * + * @tparam A the element type of the option + * @param xo the option to convert to an iterable + */ implicit def option2Iterable[A](xo: Option[A]): Iterable[A] = if (xo.isEmpty) Iterable.empty else Iterable.single(xo.get) /** An Option factory which creates Some(x) if the argument is not null, * and None if it is null. * + * @tparam A the type of the value * @param x the value * @return Some(value) if value != null, None if value == null */ @@ -32,18 +37,28 @@ object Option { /** An Option factory which returns `None` in a manner consistent with * the collections hierarchy. + * + * @tparam A the type of the option's value */ def empty[A] : Option[A] = None /** When a given condition is true, evaluates the `a` argument and returns * `Some(a)`. When the condition is false, `a` is not evaluated and `None` is * returned. + * + * @tparam A the type of the value + * @param cond the condition to evaluate + * @param a the value to wrap in `Some` when `cond` is true (evaluated lazily) */ def when[A](cond: Boolean)(a: => A): Option[A] = if (cond) Some(a) else None /** Unless a given condition is true, this will evaluate the `a` argument and * return `Some(a)`. Otherwise, `a` is not evaluated and `None` is returned. + * + * @tparam A the type of the value + * @param cond the condition to evaluate + * @param a the value to wrap in `Some` when `cond` is false (evaluated lazily) */ @inline def unless[A](cond: Boolean)(a: => A): Option[A] = when(!cond)(a) @@ -141,6 +156,8 @@ object Option { * @define willNotTerminateInf * @define collectExample * @define undefinedorder + * + * @tparam A the type of the value contained in the option */ @SerialVersionUID(-114498752079829388L) // value computed by serialver for 2.11.2, annotation added in 2.11.4 sealed abstract class Option[+A] extends IterableOnce[A] with Product with Serializable { @@ -155,6 +172,8 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * case None => true * } * ``` + * + * @return `true` if the option is `None`, `false` otherwise */ final def isEmpty: Boolean = this eq None @@ -167,6 +186,8 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * case None => false * } * ``` + * + * @return `true` if the option is a `Some`, `false` otherwise */ final def isDefined: Boolean = !isEmpty @@ -182,6 +203,7 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * } * ``` * @note The option must be nonempty. + * @return the contained value * @throws NoSuchElementException if the option is empty. */ def get: A @@ -197,7 +219,9 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * } * ``` * + * @tparam B the result type, a supertype of `A` * @param default the default expression. + * @return the option's value if nonempty, otherwise the result of evaluating `default` */ @inline final def getOrElse[B >: A](default: => B): B = if (isEmpty) default else this.get @@ -219,8 +243,15 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * val initialText: Option[String] = getInitialText * val textField = new JComponent(initialText.orNull,20) * ``` + * + * @tparam A1 a supertype of `A` for which `Null` is a valid value + * @param ev evidence that `Null` is a subtype of `A1` + * @return the option's value if nonempty, or `null` if empty */ - @inline final def orNull[A1 >: A](implicit ev: Null <:< A1): A1 = this getOrElse ev(null) + @inline final def orNull[A1 >: A | Null]: A1 = this.getOrElse(null) + + // for binary and TASTy backwards compatibility + @deprecated @inline protected final def orNull[A1 >: A](implicit ev: Null <:< A1): A1 = this getOrElse ev(null) /** Returns a $some containing the result of applying $f to this $option's * value if this $option is nonempty. @@ -236,7 +267,9 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * @note This is similar to `flatMap` except here, * $f does not need to wrap its result in an $option. * + * @tparam B the result type of the function `f` * @param f the function to apply + * @return a `Some` containing the result of applying `f` to this option's value if nonempty, otherwise `None` * @see flatMap * @see foreach */ @@ -258,8 +291,10 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * ``` * option.map(f).getOrElse(ifEmpty) * ``` + * @tparam B the result type of the fold * @param ifEmpty the expression to evaluate if empty. * @param f the function to apply if nonempty. + * @return the result of applying `f` to this option's value if nonempty, otherwise the result of evaluating `ifEmpty` */ @inline final def fold[B](ifEmpty: => B)(f: A => B): B = if (isEmpty) ifEmpty else f(this.get) @@ -277,7 +312,9 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * case None => None * } * ``` + * @tparam B the element type of the returned option * @param f the function to apply + * @return the result of applying `f` to this option's value if nonempty, otherwise `None` * @see map * @see foreach */ @@ -301,6 +338,9 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * @param ev an implicit conversion that asserts that the value is * also an $option. * @see flatMap + * + * @tparam B the element type of the nested option + * @return the contained option if nonempty, otherwise `None` */ def flatten[B](implicit ev: A <:< Option[B]): Option[B] = if (isEmpty) None else ev(this.get) @@ -316,6 +356,7 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * } * ``` * @param p the predicate used for testing. + * @return this option if nonempty and the predicate returns true, otherwise `None` */ @inline final def filter(p: A => Boolean): Option[A] = if (isEmpty || p(this.get)) this else None @@ -331,6 +372,7 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * } * ``` * @param p the predicate used for testing. + * @return this option if nonempty and the predicate returns false, otherwise `None` */ @inline final def filterNot(p: A => Boolean): Option[A] = if (isEmpty || !p(this.get)) this else None @@ -345,17 +387,23 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * } * ``` * @note Implemented here to avoid the implicit conversion to Iterable. + * + * @return `true` if the option is a `Some`, `false` otherwise */ final def nonEmpty: Boolean = isDefined /** Necessary to keep $option from being implicitly converted to * [[scala.collection.Iterable]] in `for` comprehensions. + * + * @param p the predicate used to test elements */ @inline final def withFilter(p: A => Boolean): WithFilter = new WithFilter(p) /** We need a whole WithFilter class to honor the "doesn't create a new * collection" contract even though it seems unlikely to matter much in a * collection with max size 1. + * + * @param p the predicate used to filter the option value */ class WithFilter(p: A => Boolean) { def map[B](f: A => B): Option[B] = self filter p map f @@ -387,6 +435,8 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * @param elem the element to test. * @return `true` if the option has an element that is equal (as * determined by `==`) to `elem`, `false` otherwise. + * + * @tparam A1 a supertype of `A` used for the equality comparison */ final def contains[A1 >: A](elem: A1): Boolean = !isEmpty && this.get == elem @@ -403,6 +453,7 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * } * ``` * @param p the predicate to test + * @return `true` if this option is nonempty and `p` returns true when applied to the value, `false` otherwise */ @inline final def exists(p: A => Boolean): Boolean = !isEmpty && p(this.get) @@ -418,6 +469,7 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * } * ``` * @param p the predicate to test + * @return `true` if this option is empty or the predicate returns true when applied to the value */ @inline final def forall(p: A => Boolean): Boolean = isEmpty || p(this.get) @@ -431,6 +483,7 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * case None => () * } * ``` + * @tparam U the result type of the procedure `f` (result is discarded) * @param f the procedure to apply. * @see map * @see flatMap @@ -459,6 +512,8 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * @param pf the partial function. * @return the result of applying `pf` to this $option's * value (if possible), or $none. + * + * @tparam B the result type of the partial function */ @inline final def collect[B](pf: PartialFunction[A, B]): Option[B] = if (!isEmpty) pf.lift(this.get) else None @@ -473,7 +528,9 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * case None => alternative * } * ``` + * @tparam B the element type of the alternative option, a supertype of `A` * @param alternative the alternative expression. + * @return this option if nonempty, otherwise the result of evaluating `alternative` */ @inline final def orElse[B >: A](alternative: => Option[B]): Option[B] = if (isEmpty) alternative else this @@ -501,6 +558,10 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * ``` * * @param that the options which is going to be zipped + * + * @tparam A1 a supertype of `A`, the type of the first element of the resulting pair + * @tparam B the type of the second element of the resulting pair + * @return a `Some` containing a pair of both values if both options are nonempty, otherwise `None` */ final def zip[A1 >: A, B](that: Option[B]): Option[(A1, B)] = if (isEmpty || that.isEmpty) None else Some((this.get, that.get)) @@ -572,6 +633,8 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * case None => Nil * } * ``` + * + * @return a singleton list containing the option's value if nonempty, or the empty list if empty */ def toList: List[A] = if (isEmpty) List() else new ::(this.get, Nil) @@ -588,7 +651,9 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * case None => Left(left) * } * ``` + * @tparam X the type of the `Left` value * @param left the expression to evaluate and return if this is empty + * @return a `Right` containing this option's value if nonempty, or a `Left` containing the result of evaluating `left` * @see toLeft */ @inline final def toRight[X](left: => X): Either[X, A] = @@ -606,7 +671,9 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria * case None => Right(right) * } * ``` + * @tparam X the type of the `Right` value * @param right the expression to evaluate and return if this is empty + * @return a `Left` containing this option's value if nonempty, or a `Right` containing the result of evaluating `right` * @see toRight */ @inline final def toLeft[X](right: => X): Either[A, X] = @@ -615,6 +682,9 @@ sealed abstract class Option[+A] extends IterableOnce[A] with Product with Seria /** Class `Some[A]` represents existing values of type * `A`. + * + * @tparam A the type of the contained value + * @param value the contained value */ @SerialVersionUID(1234815782226070388L) // value computed by serialver for 2.11.2, annotation added in 2.11.4 final case class Some[+A](value: A) extends Option[A] { diff --git a/library/src/scala/PartialFunction.scala b/library/src/scala/PartialFunction.scala index a13d033530c4..969e44b284d3 100644 --- a/library/src/scala/PartialFunction.scala +++ b/library/src/scala/PartialFunction.scala @@ -162,7 +162,7 @@ trait PartialFunction[-A, +B] extends Function1[A, B] { self: PartialFunction[A, * arguments `x` to `k(this(x))`. */ override def andThen[C](k: B => C): PartialFunction[A, C]^{this, k} = k match { - case pf: (PartialFunction[B, C]^{k}) => andThen(pf) + case pf: (PartialFunction[B @unchecked, C @unchecked]^{k}) => andThen(pf) case _ => new AndThen[A, B, C](this, k) } diff --git a/library/src/scala/Predef.scala b/library/src/scala/Predef.scala index a43bd3ed8d0e..85f4908faa04 100644 --- a/library/src/scala/Predef.scala +++ b/library/src/scala/Predef.scala @@ -119,6 +119,8 @@ object Predef extends LowPriorityImplicits { * * @return The runtime [[Class]] representation of type `T`. * @group utilities + * + * @tparam T the type whose runtime class representation is returned */ def classOf[T]: Class[T] = null.asInstanceOf[Class[T]] // This is a stub method. The actual implementation is filled in by the compiler. @@ -133,6 +135,10 @@ object Predef extends LowPriorityImplicits { * // bar is 23.type = 23 * ``` * @group utilities + * + * @tparam T the singleton type whose unique value is retrieved + * @param vt the implicit `ValueOf` instance that provides the value + * @return the unique inhabitant of type `T` */ @inline def valueOf[T](implicit vt: ValueOf[T]): T = vt.value @@ -147,6 +153,9 @@ object Predef extends LowPriorityImplicits { * // bar is 23.type = 23 * ``` * @group utilities + * + * @tparam T the singleton type whose unique value is retrieved + * @return the unique inhabitant of type `T` */ inline def valueOf[T]: T = summonFrom { case ev: ValueOf[T] => ev.value @@ -217,9 +226,9 @@ object Predef extends LowPriorityImplicits { // Minor variations on identity functions /** A method that returns its input value. - * @tparam A type of the input value x. - * @param x the value of type `A` to be returned. - * @return the value `x`. + * @tparam A the type of the input value `x` + * @param x the value of type `A` to be returned + * @return the value `x` * @group utilities */ @inline def identity[A](x: A): A = x // see `$conforms` for the implicit version @@ -227,6 +236,7 @@ object Predef extends LowPriorityImplicits { /** Summon an implicit value of type `T`. Usually, the argument is not passed explicitly. * * @tparam T the type of the value to be summoned + * @param e the implicit value of type `T` * @return the implicit value of type `T` * @group utilities */ @@ -235,7 +245,8 @@ object Predef extends LowPriorityImplicits { /** Summon a given value of type `T`. Usually, the argument is not passed explicitly. * * @tparam T the type of the value to be summoned - * @return the given value typed: the provided type parameter + * @param x the given value of type `T` + * @return the given value with its singleton type preserved */ transparent inline def summon[T](using x: T): x.type = x @@ -267,6 +278,8 @@ object Predef extends LowPriorityImplicits { * // locally guards the block and helps communicate intent * ``` * @group utilities + * + * @tparam T the type of the expression being guarded */ @inline def locally[T](@deprecatedName("x") x: T): T = x @@ -384,14 +397,24 @@ object Predef extends LowPriorityImplicits { // implicit classes ----------------------------------------------------- - /** @group implicit-classes-any */ + /** + * @group implicit-classes-any + * + * @tparam A the type of the left-hand side of the arrow association + * @param self the value to use as the first element of the resulting tuple + */ implicit final class ArrowAssoc[A](private val self: A) extends AnyVal { @inline def -> [B](y: B): (A, B) = (self, y) @deprecated("Use `->` instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.", "2.13.0") def →[B](y: B): (A, B) = ->(y) } - /** @group implicit-classes-any */ + /** + * @group implicit-classes-any + * + * @tparam A the type of the value being checked with `ensuring` + * @param self the value to check postconditions against + */ implicit final class Ensuring[A](private val self: A) extends AnyVal { def ensuring(cond: Boolean): A = { assert(cond); self } def ensuring(cond: Boolean, msg: => Any): A = { assert(cond, msg); self } @@ -399,7 +422,12 @@ object Predef extends LowPriorityImplicits { def ensuring(cond: A => Boolean, msg: => Any): A = { assert(cond(self), msg); self } } - /** @group implicit-classes-any */ + /** + * @group implicit-classes-any + * + * @tparam A the type of the value to be formatted as a string + * @param self the value to format + */ implicit final class StringFormat[A](private val self: A) extends AnyVal { /** Returns string formatted according to given `format` string. * Format strings are as for `String.format` @@ -415,11 +443,17 @@ object Predef extends LowPriorityImplicits { @(deprecated @companionMethod)("Implicit injection of + is deprecated. Convert to String to call +", "2.13.0") @(deprecated @companionClass)("Implicit injection of + is deprecated. Convert to String to call +", "2.13.0") // for Scaladoc // scala/bug#8229 retaining the pre 2.11 name for source compatibility in shadowing this implicit - implicit final class any2stringadd[A](private val self: A) extends AnyVal { + private[scala] final class any2stringadd[A](private val self: A) extends AnyVal { def +(other: String): String = String.valueOf(self) + other } + @deprecated + private[scala] def any2stringadd[A](self: A): any2stringadd[A] = new any2stringadd[A](self) - /** @group char-sequence-wrappers */ + /** + * @group char-sequence-wrappers + * + * @param sequenceOfChars the indexed sequence of characters to wrap as a `CharSequence` + */ final class SeqCharSequence(sequenceOfChars: scala.collection.IndexedSeq[Char]) extends CharSequence { def length: Int = sequenceOfChars.length def charAt(index: Int): Char = sequenceOfChars(index) @@ -427,10 +461,18 @@ object Predef extends LowPriorityImplicits { override def toString() = sequenceOfChars.mkString } - /** @group char-sequence-wrappers */ + /** + * @group char-sequence-wrappers + * + * @param sequenceOfChars the indexed sequence of characters to wrap as a `CharSequence` + */ def SeqCharSequence(sequenceOfChars: scala.collection.IndexedSeq[Char]): SeqCharSequence = new SeqCharSequence(sequenceOfChars) - /** @group char-sequence-wrappers */ + /** + * @group char-sequence-wrappers + * + * @param arrayOfChars the array of characters to wrap as a `CharSequence` + */ final class ArrayCharSequence(arrayOfChars: Array[Char]) extends CharSequence { def length: Int = arrayOfChars.length def charAt(index: Int): Char = arrayOfChars(index) @@ -438,10 +480,18 @@ object Predef extends LowPriorityImplicits { override def toString() = arrayOfChars.mkString } - /** @group char-sequence-wrappers */ + /** + * @group char-sequence-wrappers + * + * @param arrayOfChars the array of characters to wrap as a `CharSequence` + */ def ArrayCharSequence(arrayOfChars: Array[Char]): ArrayCharSequence = new ArrayCharSequence(arrayOfChars) - /** @group conversions-string */ + /** + * @group conversions-string + * + * @param x the string to enrich with `StringOps` methods + */ @inline implicit def augmentString(x: String): StringOps = new StringOps(x) // printing ----------------------------------------------------------- @@ -508,38 +558,102 @@ object Predef extends LowPriorityImplicits { // "Autoboxing" and "Autounboxing" --------------------------------------------------- - /** @group conversions-anyval-to-java */ + /** + * @group conversions-anyval-to-java + * + * @param x the Scala `Byte` value to convert + */ implicit def byte2Byte(x: Byte): java.lang.Byte = x.asInstanceOf[java.lang.Byte] - /** @group conversions-anyval-to-java */ + /** + * @group conversions-anyval-to-java + * + * @param x the Scala `Short` value to convert + */ implicit def short2Short(x: Short): java.lang.Short = x.asInstanceOf[java.lang.Short] - /** @group conversions-anyval-to-java */ + /** + * @group conversions-anyval-to-java + * + * @param x the Scala `Char` value to convert + */ implicit def char2Character(x: Char): java.lang.Character = x.asInstanceOf[java.lang.Character] - /** @group conversions-anyval-to-java */ + /** + * @group conversions-anyval-to-java + * + * @param x the Scala `Int` value to convert + */ implicit def int2Integer(x: Int): java.lang.Integer = x.asInstanceOf[java.lang.Integer] - /** @group conversions-anyval-to-java */ + /** + * @group conversions-anyval-to-java + * + * @param x the Scala `Long` value to convert + */ implicit def long2Long(x: Long): java.lang.Long = x.asInstanceOf[java.lang.Long] - /** @group conversions-anyval-to-java */ + /** + * @group conversions-anyval-to-java + * + * @param x the Scala `Float` value to convert + */ implicit def float2Float(x: Float): java.lang.Float = x.asInstanceOf[java.lang.Float] - /** @group conversions-anyval-to-java */ + /** + * @group conversions-anyval-to-java + * + * @param x the Scala `Double` value to convert + */ implicit def double2Double(x: Double): java.lang.Double = x.asInstanceOf[java.lang.Double] - /** @group conversions-anyval-to-java */ + /** + * @group conversions-anyval-to-java + * + * @param x the Scala `Boolean` value to convert + */ implicit def boolean2Boolean(x: Boolean): java.lang.Boolean = x.asInstanceOf[java.lang.Boolean] - /** @group conversions-java-to-anyval */ + /** + * @group conversions-java-to-anyval + * + * @param x the `java.lang.Byte` value to convert + */ implicit def Byte2byte(x: java.lang.Byte): Byte = x.asInstanceOf[Byte] - /** @group conversions-java-to-anyval */ + /** + * @group conversions-java-to-anyval + * + * @param x the `java.lang.Short` value to convert + */ implicit def Short2short(x: java.lang.Short): Short = x.asInstanceOf[Short] - /** @group conversions-java-to-anyval */ + /** + * @group conversions-java-to-anyval + * + * @param x the `java.lang.Character` value to convert + */ implicit def Character2char(x: java.lang.Character): Char = x.asInstanceOf[Char] - /** @group conversions-java-to-anyval */ + /** + * @group conversions-java-to-anyval + * + * @param x the `java.lang.Integer` value to convert + */ implicit def Integer2int(x: java.lang.Integer): Int = x.asInstanceOf[Int] - /** @group conversions-java-to-anyval */ + /** + * @group conversions-java-to-anyval + * + * @param x the `java.lang.Long` value to convert + */ implicit def Long2long(x: java.lang.Long): Long = x.asInstanceOf[Long] - /** @group conversions-java-to-anyval */ + /** + * @group conversions-java-to-anyval + * + * @param x the `java.lang.Float` value to convert + */ implicit def Float2float(x: java.lang.Float): Float = x.asInstanceOf[Float] - /** @group conversions-java-to-anyval */ + /** + * @group conversions-java-to-anyval + * + * @param x the `java.lang.Double` value to convert + */ implicit def Double2double(x: java.lang.Double): Double = x.asInstanceOf[Double] - /** @group conversions-java-to-anyval */ + /** + * @group conversions-java-to-anyval + * + * @param x the `java.lang.Boolean` value to convert + */ implicit def Boolean2boolean(x: java.lang.Boolean): Boolean = x.asInstanceOf[Boolean] /** An implicit of type `A => A` is available for all `A` because it can always @@ -561,6 +675,8 @@ object Predef extends LowPriorityImplicits { * val s3: String | Null = null * val s4: String = s3.nn // throw NullPointerException * ``` + * + * @return the value cast to its non-nullable type `x.type & T` */ extension [T](x: T | Null) inline def nn: x.type & T = if x.asInstanceOf[Any] == null then scala.runtime.Scala3RunTime.nnFail() @@ -570,12 +686,16 @@ object Predef extends LowPriorityImplicits { /** Enables an expression of type `T|Null`, where `T` is a subtype of `AnyRef`, to be checked for `null` * using `eq` rather than only `==`. This is needed because `Null` no longer has * `eq` or `ne` methods, only `==` and `!=` inherited from `Any`. + * + * @param y the reference to compare against for reference equality */ inline infix def eq(inline y: AnyRef | Null): Boolean = x.asInstanceOf[AnyRef] eq y.asInstanceOf[AnyRef] /** Enables an expression of type `T|Null`, where `T` is a subtype of `AnyRef`, to be checked for `null` * using `ne` rather than only `!=`. This is needed because `Null` no longer has * `eq` or `ne` methods, only `==` and `!=` inherited from `Any`. + * + * @param y the reference to compare against for reference non-equality */ inline infix def ne(inline y: AnyRef | Null): Boolean = !(x eq y) @@ -629,6 +749,9 @@ private[scala] abstract class LowPriorityImplicits extends LowPriorityImplicits2 * the call to xxxWrapper is not eliminated even though it does nothing. * Even inlined, every call site does a no-op retrieval of Predef's MODULE$ * because maybe loading Predef has side effects! + * + * @param x the primitive value to wrap + * @return a rich wrapper providing additional methods on the primitive value */ @inline implicit def byteWrapper(x: Byte): runtime.RichByte = new runtime.RichByte(x) @inline implicit def shortWrapper(x: Short): runtime.RichShort = new runtime.RichShort(x) @@ -639,39 +762,89 @@ private[scala] abstract class LowPriorityImplicits extends LowPriorityImplicits2 @inline implicit def doubleWrapper(x: Double): runtime.RichDouble = new runtime.RichDouble(x) @inline implicit def booleanWrapper(x: Boolean): runtime.RichBoolean = new runtime.RichBoolean(x) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @tparam T the element type of the array + * @param xs the array to wrap as an `ArraySeq` + */ implicit def genericWrapArray[T](xs: Array[T]): ArraySeq[T] = mapNull(xs, ArraySeq.make(xs)) // Since the JVM thinks arrays are covariant, one 0-length Array[AnyRef] // is as good as another for all T <: AnyRef. Instead of creating 100,000,000 // unique ones by way of this implicit, let's share one. - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @tparam T the element type of the array, must be a reference type + * @param xs the array of reference-typed elements to wrap as an `ArraySeq` + */ implicit def wrapRefArray[T <: AnyRef | Null](xs: Array[T]): ArraySeq.ofRef[T] = mapNull(xs, if (xs.length == 0) ArraySeq.empty[AnyRef].asInstanceOf[ArraySeq.ofRef[T]] else new ArraySeq.ofRef[T](xs)) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @param xs the array to wrap as an `ArraySeq` + */ implicit def wrapIntArray(xs: Array[Int]): ArraySeq.ofInt = mapNull(xs, new ArraySeq.ofInt(xs)) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @param xs the array to wrap as an `ArraySeq` + */ implicit def wrapDoubleArray(xs: Array[Double]): ArraySeq.ofDouble = mapNull(xs, new ArraySeq.ofDouble(xs)) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @param xs the array to wrap as an `ArraySeq` + */ implicit def wrapLongArray(xs: Array[Long]): ArraySeq.ofLong = mapNull(xs, new ArraySeq.ofLong(xs)) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @param xs the array to wrap as an `ArraySeq` + */ implicit def wrapFloatArray(xs: Array[Float]): ArraySeq.ofFloat = mapNull(xs, new ArraySeq.ofFloat(xs)) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @param xs the array to wrap as an `ArraySeq` + */ implicit def wrapCharArray(xs: Array[Char]): ArraySeq.ofChar = mapNull(xs, new ArraySeq.ofChar(xs)) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @param xs the array to wrap as an `ArraySeq` + */ implicit def wrapByteArray(xs: Array[Byte]): ArraySeq.ofByte = mapNull(xs, new ArraySeq.ofByte(xs)) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @param xs the array to wrap as an `ArraySeq` + */ implicit def wrapShortArray(xs: Array[Short]): ArraySeq.ofShort = mapNull(xs, new ArraySeq.ofShort(xs)) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @param xs the array to wrap as an `ArraySeq` + */ implicit def wrapBooleanArray(xs: Array[Boolean]): ArraySeq.ofBoolean = mapNull(xs, new ArraySeq.ofBoolean(xs)) - /** @group conversions-array-to-wrapped-array */ + /** + * @group conversions-array-to-wrapped-array + * + * @param xs the array to wrap as an `ArraySeq` + */ implicit def wrapUnitArray(xs: Array[Unit]): ArraySeq.ofUnit = mapNull(xs, new ArraySeq.ofUnit(xs)) - /** @group conversions-string */ + /** + * @group conversions-string + * + * @param s the string to wrap as a `WrappedString` + */ implicit def wrapString(s: String): WrappedString = mapNull(s, new WrappedString(s)) } diff --git a/library/src/scala/Product1.scala b/library/src/scala/Product1.scala index d0e6066babfa..20e2b83a2294 100644 --- a/library/src/scala/Product1.scala +++ b/library/src/scala/Product1.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` diff --git a/library/src/scala/Product10.scala b/library/src/scala/Product10.scala index 1d2a4b53a8ff..d7d1774a2d8e 100644 --- a/library/src/scala/Product10.scala +++ b/library/src/scala/Product10.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,19 @@ object Product10 { Some(x) } -/** Product10 is a Cartesian product of 10 components. */ +/** Product10 is a Cartesian product of 10 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + */ trait Product10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10] extends Any with Product { /** The arity of this product. * @return 10 diff --git a/library/src/scala/Product11.scala b/library/src/scala/Product11.scala index 05f2455dc57e..e1338b7c7b35 100644 --- a/library/src/scala/Product11.scala +++ b/library/src/scala/Product11.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,20 @@ object Product11 { Some(x) } -/** Product11 is a Cartesian product of 11 components. */ +/** Product11 is a Cartesian product of 11 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + */ trait Product11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11] extends Any with Product { /** The arity of this product. * @return 11 diff --git a/library/src/scala/Product12.scala b/library/src/scala/Product12.scala index 6100bd2c387a..4c1ca393f677 100644 --- a/library/src/scala/Product12.scala +++ b/library/src/scala/Product12.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,21 @@ object Product12 { Some(x) } -/** Product12 is a Cartesian product of 12 components. */ +/** Product12 is a Cartesian product of 12 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + */ trait Product12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12] extends Any with Product { /** The arity of this product. * @return 12 @@ -32,8 +44,8 @@ trait Product12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12] e /** Returns the n-th projection of this product if 0 <= n < productArity, * otherwise throws an `IndexOutOfBoundsException`. * - * @param n number of the projection to be returned - * @return same as `._(n+1)`, for example `productElement(0)` is the same as `._1`. + * @param n the zero-based index of the projection to be returned + * @return the element at the given zero-based index, equivalent to `._(n+1)` (e.g., `productElement(0)` returns `._1`) * @throws IndexOutOfBoundsException if the `n` is out of range(n < 0 || n >= 12). */ diff --git a/library/src/scala/Product13.scala b/library/src/scala/Product13.scala index 42bbedc089ec..1978cbec24fa 100644 --- a/library/src/scala/Product13.scala +++ b/library/src/scala/Product13.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,22 @@ object Product13 { Some(x) } -/** Product13 is a Cartesian product of 13 components. */ +/** Product13 is a Cartesian product of 13 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + */ trait Product13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13] extends Any with Product { /** The arity of this product. * @return 13 diff --git a/library/src/scala/Product14.scala b/library/src/scala/Product14.scala index 3c33be6bda23..b0966f12b3e0 100644 --- a/library/src/scala/Product14.scala +++ b/library/src/scala/Product14.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,23 @@ object Product14 { Some(x) } -/** Product14 is a Cartesian product of 14 components. */ +/** Product14 is a Cartesian product of 14 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + */ trait Product14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14] extends Any with Product { /** The arity of this product. * @return 14 diff --git a/library/src/scala/Product15.scala b/library/src/scala/Product15.scala index 4cd5f68c5bf5..fd5aa882a9cc 100644 --- a/library/src/scala/Product15.scala +++ b/library/src/scala/Product15.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,24 @@ object Product15 { Some(x) } -/** Product15 is a Cartesian product of 15 components. */ +/** Product15 is a Cartesian product of 15 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + */ trait Product15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15] extends Any with Product { /** The arity of this product. * @return 15 diff --git a/library/src/scala/Product16.scala b/library/src/scala/Product16.scala index b1bc30b1eb9b..dc07b93a9d88 100644 --- a/library/src/scala/Product16.scala +++ b/library/src/scala/Product16.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,25 @@ object Product16 { Some(x) } -/** Product16 is a Cartesian product of 16 components. */ +/** Product16 is a Cartesian product of 16 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + */ trait Product16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16] extends Any with Product { /** The arity of this product. * @return 16 diff --git a/library/src/scala/Product17.scala b/library/src/scala/Product17.scala index 5975d167fd98..2111cca6d6c0 100644 --- a/library/src/scala/Product17.scala +++ b/library/src/scala/Product17.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,26 @@ object Product17 { Some(x) } -/** Product17 is a Cartesian product of 17 components. */ +/** Product17 is a Cartesian product of 17 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + */ trait Product17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17] extends Any with Product { /** The arity of this product. * @return 17 diff --git a/library/src/scala/Product18.scala b/library/src/scala/Product18.scala index 5a37bffe0e8e..87a05b9de5c6 100644 --- a/library/src/scala/Product18.scala +++ b/library/src/scala/Product18.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,27 @@ object Product18 { Some(x) } -/** Product18 is a Cartesian product of 18 components. */ +/** Product18 is a Cartesian product of 18 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + */ trait Product18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18] extends Any with Product { /** The arity of this product. * @return 18 diff --git a/library/src/scala/Product19.scala b/library/src/scala/Product19.scala index ae98c8094224..ff246f57b886 100644 --- a/library/src/scala/Product19.scala +++ b/library/src/scala/Product19.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,28 @@ object Product19 { Some(x) } -/** Product19 is a Cartesian product of 19 components. */ +/** Product19 is a Cartesian product of 19 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + * @tparam T19 the type of the 19th element + */ trait Product19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19] extends Any with Product { /** The arity of this product. * @return 19 diff --git a/library/src/scala/Product2.scala b/library/src/scala/Product2.scala index e7ab6be6e677..05f076172377 100644 --- a/library/src/scala/Product2.scala +++ b/library/src/scala/Product2.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` diff --git a/library/src/scala/Product20.scala b/library/src/scala/Product20.scala index d9659b33f493..82fe54d2d100 100644 --- a/library/src/scala/Product20.scala +++ b/library/src/scala/Product20.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,29 @@ object Product20 { Some(x) } -/** Product20 is a Cartesian product of 20 components. */ +/** Product20 is a Cartesian product of 20 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + * @tparam T19 the type of the 19th element + * @tparam T20 the type of the 20th element + */ trait Product20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20] extends Any with Product { /** The arity of this product. * @return 20 diff --git a/library/src/scala/Product21.scala b/library/src/scala/Product21.scala index eb3b8220d44c..47d09b4395a4 100644 --- a/library/src/scala/Product21.scala +++ b/library/src/scala/Product21.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,30 @@ object Product21 { Some(x) } -/** Product21 is a Cartesian product of 21 components. */ +/** Product21 is a Cartesian product of 21 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + * @tparam T19 the type of the 19th element + * @tparam T20 the type of the 20th element + * @tparam T21 the type of the 21st element + */ trait Product21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21] extends Any with Product { /** The arity of this product. * @return 21 diff --git a/library/src/scala/Product22.scala b/library/src/scala/Product22.scala index ec21e7dedfde..b52b1f011a22 100644 --- a/library/src/scala/Product22.scala +++ b/library/src/scala/Product22.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,31 @@ object Product22 { Some(x) } -/** Product22 is a Cartesian product of 22 components. */ +/** Product22 is a Cartesian product of 22 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + * @tparam T19 the type of the 19th element + * @tparam T20 the type of the 20th element + * @tparam T21 the type of the 21st element + * @tparam T22 the type of the 22nd element + */ trait Product22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22] extends Any with Product { /** The arity of this product. * @return 22 diff --git a/library/src/scala/Product3.scala b/library/src/scala/Product3.scala index 222e70430d2c..1c7b2a2b33ee 100644 --- a/library/src/scala/Product3.scala +++ b/library/src/scala/Product3.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,12 @@ object Product3 { Some(x) } -/** Product3 is a Cartesian product of 3 components. */ +/** Product3 is a Cartesian product of 3 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + */ trait Product3[+T1, +T2, +T3] extends Any with Product { /** The arity of this product. * @return 3 diff --git a/library/src/scala/Product4.scala b/library/src/scala/Product4.scala index b27cc65bfbdc..a09f62f60581 100644 --- a/library/src/scala/Product4.scala +++ b/library/src/scala/Product4.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,13 @@ object Product4 { Some(x) } -/** Product4 is a Cartesian product of 4 components. */ +/** Product4 is a Cartesian product of 4 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + */ trait Product4[+T1, +T2, +T3, +T4] extends Any with Product { /** The arity of this product. * @return 4 diff --git a/library/src/scala/Product5.scala b/library/src/scala/Product5.scala index 80bf7b38413c..bbfa0c449ccf 100644 --- a/library/src/scala/Product5.scala +++ b/library/src/scala/Product5.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,14 @@ object Product5 { Some(x) } -/** Product5 is a Cartesian product of 5 components. */ +/** Product5 is a Cartesian product of 5 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + */ trait Product5[+T1, +T2, +T3, +T4, +T5] extends Any with Product { /** The arity of this product. * @return 5 diff --git a/library/src/scala/Product6.scala b/library/src/scala/Product6.scala index 73a36c352546..125fbc40ce7c 100644 --- a/library/src/scala/Product6.scala +++ b/library/src/scala/Product6.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,15 @@ object Product6 { Some(x) } -/** Product6 is a Cartesian product of 6 components. */ +/** Product6 is a Cartesian product of 6 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + */ trait Product6[+T1, +T2, +T3, +T4, +T5, +T6] extends Any with Product { /** The arity of this product. * @return 6 diff --git a/library/src/scala/Product7.scala b/library/src/scala/Product7.scala index b7add358f835..c50eb9e07c2c 100644 --- a/library/src/scala/Product7.scala +++ b/library/src/scala/Product7.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,16 @@ object Product7 { Some(x) } -/** Product7 is a Cartesian product of 7 components. */ +/** Product7 is a Cartesian product of 7 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + */ trait Product7[+T1, +T2, +T3, +T4, +T5, +T6, +T7] extends Any with Product { /** The arity of this product. * @return 7 diff --git a/library/src/scala/Product8.scala b/library/src/scala/Product8.scala index 3a2732f07ed4..afaaba9a6f7c 100644 --- a/library/src/scala/Product8.scala +++ b/library/src/scala/Product8.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,17 @@ object Product8 { Some(x) } -/** Product8 is a Cartesian product of 8 components. */ +/** Product8 is a Cartesian product of 8 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + */ trait Product8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8] extends Any with Product { /** The arity of this product. * @return 8 diff --git a/library/src/scala/Product9.scala b/library/src/scala/Product9.scala index 4d35d7d86864..2ed71b52165e 100644 --- a/library/src/scala/Product9.scala +++ b/library/src/scala/Product9.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -21,7 +19,18 @@ object Product9 { Some(x) } -/** Product9 is a Cartesian product of 9 components. */ +/** Product9 is a Cartesian product of 9 components. + * + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + */ trait Product9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9] extends Any with Product { /** The arity of this product. * @return 9 diff --git a/library/src/scala/Short.scala b/library/src/scala/Short.scala index b1d2057fc6c8..9fc9f1edd43a 100644 --- a/library/src/scala/Short.scala +++ b/library/src/scala/Short.scala @@ -52,6 +52,8 @@ final abstract class Short private extends AnyVal { * ``` * 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 * ``` + * + * @param x the number of bits to shift left */ def <<(x: Int): Int /** Returns this value bit-shifted left by the specified number of bits, @@ -71,6 +73,8 @@ final abstract class Short private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >>> 3 == * // 00011111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right */ def >>>(x: Int): Int /** Returns this value bit-shifted right by the specified number of bits, @@ -92,6 +96,8 @@ final abstract class Short private extends AnyVal { * // in binary: 11111111 11111111 11111111 11101011 >> 3 == * // 11111111 11111111 11111111 11111101 * ``` + * + * @param x the number of bits to shift right */ def >>(x: Int): Int /** Returns this value bit-shifted right by the specified number of bits, @@ -136,19 +142,40 @@ final abstract class Short private extends AnyVal { /** Returns `true` if this value is not equal to x, `false` otherwise. */ def !=(x: Double): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Byte): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Short): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Char): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Int): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Long): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Float): Boolean - /** Returns `true` if this value is less than x, `false` otherwise. */ + /** Returns `true` if this value is less than x, `false` otherwise. + * + * @param x the value to compare against + */ def <(x: Double): Boolean /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ @@ -166,19 +193,40 @@ final abstract class Short private extends AnyVal { /** Returns `true` if this value is less than or equal to x, `false` otherwise. */ def <=(x: Double): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Byte): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Short): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Char): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Int): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Long): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Float): Boolean - /** Returns `true` if this value is greater than x, `false` otherwise. */ + /** Returns `true` if this value is greater than x, `false` otherwise. + * + * @param x the value to compare against + */ def >(x: Double): Boolean /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */ @@ -204,6 +252,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Byte): Int /** Returns the bitwise OR of this value and `x`. @@ -214,6 +264,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Short): Int /** Returns the bitwise OR of this value and `x`. @@ -224,6 +276,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Char): Int /** Returns the bitwise OR of this value and `x`. @@ -234,6 +288,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Int): Int /** Returns the bitwise OR of this value and `x`. @@ -244,6 +300,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 11111010 * ``` + * + * @param x the value to OR with this value */ def |(x: Long): Long @@ -255,6 +313,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Byte): Int /** Returns the bitwise AND of this value and `x`. @@ -265,6 +325,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Short): Int /** Returns the bitwise AND of this value and `x`. @@ -275,6 +337,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Char): Int /** Returns the bitwise AND of this value and `x`. @@ -285,6 +349,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Int): Int /** Returns the bitwise AND of this value and `x`. @@ -295,6 +361,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 10100000 * ``` + * + * @param x the value to AND with this value */ def &(x: Long): Long @@ -306,6 +374,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Byte): Int /** Returns the bitwise XOR of this value and `x`. @@ -316,6 +386,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Short): Int /** Returns the bitwise XOR of this value and `x`. @@ -326,6 +398,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Char): Int /** Returns the bitwise XOR of this value and `x`. @@ -336,6 +410,8 @@ final abstract class Short private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Int): Int /** Returns the bitwise XOR of this value and `x`. @@ -346,86 +422,191 @@ final abstract class Short private extends AnyVal { * // -------- * // 01011010 * ``` + * + * @param x the value to XOR with this value */ def ^(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Byte): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Short): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Char): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Int): Int - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Long): Long - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Float): Float - /** Returns the sum of this value and `x`. */ + /** Returns the sum of this value and `x`. + * + * @param x the value to add to this value + */ def +(x: Double): Double - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Byte): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Short): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Char): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Int): Int - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Long): Long - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Float): Float - /** Returns the difference of this value and `x`. */ + /** Returns the difference of this value and `x`. + * + * @param x the value to subtract from this value + */ def -(x: Double): Double - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Byte): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Short): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Char): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Int): Int - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Long): Long - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Float): Float - /** Returns the product of this value and `x`. */ + /** Returns the product of this value and `x`. + * + * @param x the value to multiply this value by + */ def *(x: Double): Double - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Byte): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Short): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Char): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Int): Int - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Long): Long - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Float): Float - /** Returns the quotient of this value and `x`. */ + /** Returns the quotient of this value and `x`. + * + * @param x the value to divide this value by + */ def /(x: Double): Double - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Byte): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Short): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Char): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Int): Int - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Long): Long - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Float): Float - /** Returns the remainder of the division of this value by `x`. */ + /** Returns the remainder of the division of this value by `x`. + * + * @param x the divisor + */ def %(x: Double): Double - // Provide a more specific return type for Scaladoc - override def getClass(): Class[Short] = ??? } object Short extends AnyValCompanion { @@ -458,7 +639,10 @@ object Short extends AnyValCompanion { /** The `String` representation of the `scala.Short` companion object. */ override def toString() = "object scala.Short" - /** Language mandated coercions from `Short` to "wider" types. */ + /** Language mandated coercions from `Short` to "wider" types. + * + * @param x the `Short` value to be implicitly converted + */ import scala.language.implicitConversions implicit def short2int(x: Short): Int = x.toInt implicit def short2long(x: Short): Long = x.toLong diff --git a/library/src/scala/Tuple.scala b/library/src/scala/Tuple.scala index 75b72db946f4..02c21c013b63 100644 --- a/library/src/scala/Tuple.scala +++ b/library/src/scala/Tuple.scala @@ -34,35 +34,55 @@ sealed trait Tuple extends Product { /** Gets the i-th element of this tuple. * Equivalent to productElement but with a precise return type. + * + * @tparam This the exact type of this tuple + * @param n the zero-based index of the element to retrieve */ inline def apply[This >: this.type <: Tuple](n: Int): Elem[This, n.type] = runtime.Tuples.apply(this, n).asInstanceOf[Elem[This, n.type]] - /** Gets the head of this tuple. */ + /** Gets the head of this tuple. + * + * @tparam This the exact type of this tuple + */ inline def head[This >: this.type <: Tuple]: Head[This] = runtime.Tuples.apply(this, 0).asInstanceOf[Head[This]] - /** Gets the initial part of the tuple without its last element. */ + /** Gets the initial part of the tuple without its last element. + * + * @tparam This the exact type of this tuple + */ inline def init[This >: this.type <: Tuple]: Init[This] = runtime.Tuples.init(this).asInstanceOf[Init[This]] - /** Gets the last of this tuple. */ + /** Gets the last of this tuple. + * + * @tparam This the exact type of this tuple + */ inline def last[This >: this.type <: Tuple]: Last[This] = runtime.Tuples.last(this).asInstanceOf[Last[This]] /** Gets the tail of this tuple. * This operation is O(this.size) + * + * @tparam This the exact type of this tuple */ inline def tail[This >: this.type <: Tuple]: Tail[This] = runtime.Tuples.tail(this).asInstanceOf[Tail[This]] /** Returns a new tuple by concatenating `this` tuple with `that` tuple. * This operation is O(this.size + that.size) + * + * @tparam This the exact type of this tuple + * @param that the tuple to append to this tuple */ inline def ++ [This >: this.type <: Tuple](that: Tuple): This ++ that.type = runtime.Tuples.concat(this, that).asInstanceOf[This ++ that.type] - /** Returns the size (or arity) of the tuple. */ + /** Returns the size (or arity) of the tuple. + * + * @tparam This the exact type of this tuple + */ inline def size[This >: this.type <: Tuple]: Size[This] = runtime.Tuples.size(this).asInstanceOf[Size[This]] @@ -72,27 +92,37 @@ sealed trait Tuple extends Product { * The result is typed as `((A1, B1), ..., (An, Bn))` if at least one of the * tuple types has a `EmptyTuple` tail. Otherwise the result type is * `(A1, B1) *: ... *: (Ai, Bi) *: Tuple` + * + * @tparam This the exact type of this tuple + * @tparam T2 the type of the other tuple to zip with + * @param t2 the tuple to zip with this tuple */ inline def zip[This >: this.type <: Tuple, T2 <: Tuple](t2: T2): Zip[This, T2] = runtime.Tuples.zip(this, t2).asInstanceOf[Zip[This, T2]] /** Called on a tuple `(a1, ..., an)`, returns a new tuple `(f(a1), ..., f(an))`. * The result is typed as `(F[A1], ..., F[An])` if the tuple type is fully known. - * If the tuple is of the form `a1 *: ... *: Tuple` (that is, the tail is not known - * to be the cons type. + * Otherwise the result type is `F[A1] *: Tuple`. + * + * @tparam F the type constructor applied to each element type */ - inline def map[F[_]](f: [t] => t => F[t]): Map[this.type, F] = + inline def map[F[_]](f: [t] -> t -> F[t]): Map[this.type, F] = runtime.Tuples.map(this, f).asInstanceOf[Map[this.type, F]] /** Given a tuple `(a1, ..., am)`, returns the tuple `(a1, ..., an)` consisting * of its first n elements. + * + * @tparam This the exact type of this tuple + * @param n the number of elements to take from the beginning */ inline def take[This >: this.type <: Tuple](n: Int): Take[This, n.type] = runtime.Tuples.take(this, n).asInstanceOf[Take[This, n.type]] - /** Given a tuple `(a1, ..., am)`, returns the tuple `(an+1, ..., am)` consisting * all its elements except the first n ones. + * + * @tparam This the exact type of this tuple + * @param n the number of elements to drop from the beginning */ inline def drop[This >: this.type <: Tuple](n: Int): Drop[This, n.type] = runtime.Tuples.drop(this, n).asInstanceOf[Drop[This, n.type]] @@ -100,12 +130,17 @@ sealed trait Tuple extends Product { /** Given a tuple `(a1, ..., am)`, returns a pair of the tuple `(a1, ..., an)` * consisting of the first n elements, and the tuple `(an+1, ..., am)` consisting * of the remaining elements. + * + * @tparam This the exact type of this tuple + * @param n the number of elements in the first part of the split */ inline def splitAt[This >: this.type <: Tuple](n: Int): Split[This, n.type] = runtime.Tuples.splitAt(this, n).asInstanceOf[Split[This, n.type]] /** Given a tuple `(a1, ..., am)`, returns the reversed tuple `(am, ..., a1)` * consisting all its elements. + * + * @tparam This the exact type of this tuple */ inline def reverse[This >: this.type <: Tuple]: Reverse[This] = runtime.Tuples.reverse(this).asInstanceOf[Reverse[This]] @@ -285,13 +320,24 @@ object Tuple { /** Empty tuple. */ def apply(): EmptyTuple = EmptyTuple - /** Tuple with one element. */ + /** Tuple with one element. + * + * @tparam T the type of the element + * @param x the single element of the tuple + */ def apply[T](x: T): T *: EmptyTuple = Tuple1(x) - /** Matches an empty tuple. */ + /** Matches an empty tuple. + * + * @param x the empty tuple to match + */ def unapply(x: EmptyTuple): true = true - /** Converts an array into a tuple of unknown arity and types. */ + /** Converts an array into a tuple of unknown arity and types. + * + * @tparam T the element type of the array + * @param xs the array to convert into a tuple + */ def fromArray[T](xs: Array[T]): Tuple = { val xs2 = xs match { case xs: Array[Object] => xs @@ -300,7 +346,11 @@ object Tuple { runtime.Tuples.fromArray(xs2) } - /** Converts an immutable array into a tuple of unknown arity and types. */ + /** Converts an immutable array into a tuple of unknown arity and types. + * + * @tparam T the element type of the immutable array + * @param xs the immutable array to convert into a tuple + */ def fromIArray[T](xs: IArray[T]): Tuple = { val xs2: IArray[Object] = xs match { case xs: IArray[Object] @unchecked => xs @@ -310,7 +360,10 @@ object Tuple { runtime.Tuples.fromIArray(xs2) } - /** Converts a Product into a tuple of unknown arity and types. */ + /** Converts a Product into a tuple of unknown arity and types. + * + * @param product the product to convert into a tuple + */ def fromProduct(product: Product): Tuple = runtime.Tuples.fromProduct(product) diff --git a/library/src/scala/Tuple1.scala b/library/src/scala/Tuple1.scala index b172fc372d62..1cc62247c9a2 100644 --- a/library/src/scala/Tuple1.scala +++ b/library/src/scala/Tuple1.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` diff --git a/library/src/scala/Tuple10.scala b/library/src/scala/Tuple10.scala index 38a8aed871c5..cd5d37f89b7e 100644 --- a/library/src/scala/Tuple10.scala +++ b/library/src/scala/Tuple10.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,16 +17,26 @@ import scala.language.`2.13` /** A tuple of 10 elements; the canonical representation of a [[scala.Product10]]. * * @constructor Create a new tuple with 10 elements. Note that it is more idiomatic to create a Tuple10 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)` - * @param _1 Element 1 of this Tuple10 - * @param _2 Element 2 of this Tuple10 - * @param _3 Element 3 of this Tuple10 - * @param _4 Element 4 of this Tuple10 - * @param _5 Element 5 of this Tuple10 - * @param _6 Element 6 of this Tuple10 - * @param _7 Element 7 of this Tuple10 - * @param _8 Element 8 of this Tuple10 - * @param _9 Element 9 of this Tuple10 - * @param _10 Element 10 of this Tuple10 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @param _1 element 1 of this Tuple10 + * @param _2 element 2 of this Tuple10 + * @param _3 element 3 of this Tuple10 + * @param _4 element 4 of this Tuple10 + * @param _5 element 5 of this Tuple10 + * @param _6 element 6 of this Tuple10 + * @param _7 element 7 of this Tuple10 + * @param _8 element 8 of this Tuple10 + * @param _9 element 9 of this Tuple10 + * @param _10 element 10 of this Tuple10 */ final case class Tuple10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10) extends Product10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] diff --git a/library/src/scala/Tuple11.scala b/library/src/scala/Tuple11.scala index 516dc8a0d8b4..00c8c641f817 100644 --- a/library/src/scala/Tuple11.scala +++ b/library/src/scala/Tuple11.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,17 @@ import scala.language.`2.13` /** A tuple of 11 elements; the canonical representation of a [[scala.Product11]]. * * @constructor Create a new tuple with 11 elements. Note that it is more idiomatic to create a Tuple11 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element * @param _1 Element 1 of this Tuple11 * @param _2 Element 2 of this Tuple11 * @param _3 Element 3 of this Tuple11 diff --git a/library/src/scala/Tuple12.scala b/library/src/scala/Tuple12.scala index f3a0d3ff1192..de737b43e60a 100644 --- a/library/src/scala/Tuple12.scala +++ b/library/src/scala/Tuple12.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,18 @@ import scala.language.`2.13` /** A tuple of 12 elements; the canonical representation of a [[scala.Product12]]. * * @constructor Create a new tuple with 12 elements. Note that it is more idiomatic to create a Tuple12 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element * @param _1 Element 1 of this Tuple12 * @param _2 Element 2 of this Tuple12 * @param _3 Element 3 of this Tuple12 diff --git a/library/src/scala/Tuple13.scala b/library/src/scala/Tuple13.scala index 29b016d8fe0f..1997c9dd56f3 100644 --- a/library/src/scala/Tuple13.scala +++ b/library/src/scala/Tuple13.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,19 @@ import scala.language.`2.13` /** A tuple of 13 elements; the canonical representation of a [[scala.Product13]]. * * @constructor Create a new tuple with 13 elements. Note that it is more idiomatic to create a Tuple13 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element * @param _1 Element 1 of this Tuple13 * @param _2 Element 2 of this Tuple13 * @param _3 Element 3 of this Tuple13 diff --git a/library/src/scala/Tuple14.scala b/library/src/scala/Tuple14.scala index 1cc257ba384d..45c1f7a3f385 100644 --- a/library/src/scala/Tuple14.scala +++ b/library/src/scala/Tuple14.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,20 +17,34 @@ import scala.language.`2.13` /** A tuple of 14 elements; the canonical representation of a [[scala.Product14]]. * * @constructor Create a new tuple with 14 elements. Note that it is more idiomatic to create a Tuple14 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14)` - * @param _1 Element 1 of this Tuple14 - * @param _2 Element 2 of this Tuple14 - * @param _3 Element 3 of this Tuple14 - * @param _4 Element 4 of this Tuple14 - * @param _5 Element 5 of this Tuple14 - * @param _6 Element 6 of this Tuple14 - * @param _7 Element 7 of this Tuple14 - * @param _8 Element 8 of this Tuple14 - * @param _9 Element 9 of this Tuple14 - * @param _10 Element 10 of this Tuple14 - * @param _11 Element 11 of this Tuple14 - * @param _12 Element 12 of this Tuple14 - * @param _13 Element 13 of this Tuple14 - * @param _14 Element 14 of this Tuple14 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @param _1 element 1 of this Tuple14 + * @param _2 element 2 of this Tuple14 + * @param _3 element 3 of this Tuple14 + * @param _4 element 4 of this Tuple14 + * @param _5 element 5 of this Tuple14 + * @param _6 element 6 of this Tuple14 + * @param _7 element 7 of this Tuple14 + * @param _8 element 8 of this Tuple14 + * @param _9 element 9 of this Tuple14 + * @param _10 element 10 of this Tuple14 + * @param _11 element 11 of this Tuple14 + * @param _12 element 12 of this Tuple14 + * @param _13 element 13 of this Tuple14 + * @param _14 element 14 of this Tuple14 */ final case class Tuple14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14) extends Product14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] diff --git a/library/src/scala/Tuple15.scala b/library/src/scala/Tuple15.scala index e7dcd5cedb81..10af44b0c7f8 100644 --- a/library/src/scala/Tuple15.scala +++ b/library/src/scala/Tuple15.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,21 @@ import scala.language.`2.13` /** A tuple of 15 elements; the canonical representation of a [[scala.Product15]]. * * @constructor Create a new tuple with 15 elements. Note that it is more idiomatic to create a Tuple15 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element * @param _1 Element 1 of this Tuple15 * @param _2 Element 2 of this Tuple15 * @param _3 Element 3 of this Tuple15 diff --git a/library/src/scala/Tuple16.scala b/library/src/scala/Tuple16.scala index f585f8e8a54c..5000ddb54956 100644 --- a/library/src/scala/Tuple16.scala +++ b/library/src/scala/Tuple16.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,22 @@ import scala.language.`2.13` /** A tuple of 16 elements; the canonical representation of a [[scala.Product16]]. * * @constructor Create a new tuple with 16 elements. Note that it is more idiomatic to create a Tuple16 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element * @param _1 Element 1 of this Tuple16 * @param _2 Element 2 of this Tuple16 * @param _3 Element 3 of this Tuple16 diff --git a/library/src/scala/Tuple17.scala b/library/src/scala/Tuple17.scala index d2fbbc2bc961..d5b911cd05e8 100644 --- a/library/src/scala/Tuple17.scala +++ b/library/src/scala/Tuple17.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,23 +17,40 @@ import scala.language.`2.13` /** A tuple of 17 elements; the canonical representation of a [[scala.Product17]]. * * @constructor Create a new tuple with 17 elements. Note that it is more idiomatic to create a Tuple17 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17)` - * @param _1 Element 1 of this Tuple17 - * @param _2 Element 2 of this Tuple17 - * @param _3 Element 3 of this Tuple17 - * @param _4 Element 4 of this Tuple17 - * @param _5 Element 5 of this Tuple17 - * @param _6 Element 6 of this Tuple17 - * @param _7 Element 7 of this Tuple17 - * @param _8 Element 8 of this Tuple17 - * @param _9 Element 9 of this Tuple17 - * @param _10 Element 10 of this Tuple17 - * @param _11 Element 11 of this Tuple17 - * @param _12 Element 12 of this Tuple17 - * @param _13 Element 13 of this Tuple17 - * @param _14 Element 14 of this Tuple17 - * @param _15 Element 15 of this Tuple17 - * @param _16 Element 16 of this Tuple17 - * @param _17 Element 17 of this Tuple17 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @param _1 element 1 of this Tuple17 + * @param _2 element 2 of this Tuple17 + * @param _3 element 3 of this Tuple17 + * @param _4 element 4 of this Tuple17 + * @param _5 element 5 of this Tuple17 + * @param _6 element 6 of this Tuple17 + * @param _7 element 7 of this Tuple17 + * @param _8 element 8 of this Tuple17 + * @param _9 element 9 of this Tuple17 + * @param _10 element 10 of this Tuple17 + * @param _11 element 11 of this Tuple17 + * @param _12 element 12 of this Tuple17 + * @param _13 element 13 of this Tuple17 + * @param _14 element 14 of this Tuple17 + * @param _15 element 15 of this Tuple17 + * @param _16 element 16 of this Tuple17 + * @param _17 element 17 of this Tuple17 */ final case class Tuple17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17) extends Product17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] diff --git a/library/src/scala/Tuple18.scala b/library/src/scala/Tuple18.scala index 8928c483d09e..f831101dbd0f 100644 --- a/library/src/scala/Tuple18.scala +++ b/library/src/scala/Tuple18.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,24 +17,42 @@ import scala.language.`2.13` /** A tuple of 18 elements; the canonical representation of a [[scala.Product18]]. * * @constructor Create a new tuple with 18 elements. Note that it is more idiomatic to create a Tuple18 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18)` - * @param _1 Element 1 of this Tuple18 - * @param _2 Element 2 of this Tuple18 - * @param _3 Element 3 of this Tuple18 - * @param _4 Element 4 of this Tuple18 - * @param _5 Element 5 of this Tuple18 - * @param _6 Element 6 of this Tuple18 - * @param _7 Element 7 of this Tuple18 - * @param _8 Element 8 of this Tuple18 - * @param _9 Element 9 of this Tuple18 - * @param _10 Element 10 of this Tuple18 - * @param _11 Element 11 of this Tuple18 - * @param _12 Element 12 of this Tuple18 - * @param _13 Element 13 of this Tuple18 - * @param _14 Element 14 of this Tuple18 - * @param _15 Element 15 of this Tuple18 - * @param _16 Element 16 of this Tuple18 - * @param _17 Element 17 of this Tuple18 - * @param _18 Element 18 of this Tuple18 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + * @param _1 element 1 of this Tuple18 + * @param _2 element 2 of this Tuple18 + * @param _3 element 3 of this Tuple18 + * @param _4 element 4 of this Tuple18 + * @param _5 element 5 of this Tuple18 + * @param _6 element 6 of this Tuple18 + * @param _7 element 7 of this Tuple18 + * @param _8 element 8 of this Tuple18 + * @param _9 element 9 of this Tuple18 + * @param _10 element 10 of this Tuple18 + * @param _11 element 11 of this Tuple18 + * @param _12 element 12 of this Tuple18 + * @param _13 element 13 of this Tuple18 + * @param _14 element 14 of this Tuple18 + * @param _15 element 15 of this Tuple18 + * @param _16 element 16 of this Tuple18 + * @param _17 element 17 of this Tuple18 + * @param _18 element 18 of this Tuple18 */ final case class Tuple18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18) extends Product18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] diff --git a/library/src/scala/Tuple19.scala b/library/src/scala/Tuple19.scala index a95ab333d64c..141faaca0a5b 100644 --- a/library/src/scala/Tuple19.scala +++ b/library/src/scala/Tuple19.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,25 @@ import scala.language.`2.13` /** A tuple of 19 elements; the canonical representation of a [[scala.Product19]]. * * @constructor Create a new tuple with 19 elements. Note that it is more idiomatic to create a Tuple19 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + * @tparam T19 the type of the 19th element * @param _1 Element 1 of this Tuple19 * @param _2 Element 2 of this Tuple19 * @param _3 Element 3 of this Tuple19 diff --git a/library/src/scala/Tuple2.scala b/library/src/scala/Tuple2.scala index 5e2a53d5072a..3e4141f40076 100644 --- a/library/src/scala/Tuple2.scala +++ b/library/src/scala/Tuple2.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` diff --git a/library/src/scala/Tuple20.scala b/library/src/scala/Tuple20.scala index 79217269fae7..193afb3fd51e 100644 --- a/library/src/scala/Tuple20.scala +++ b/library/src/scala/Tuple20.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,26 +17,46 @@ import scala.language.`2.13` /** A tuple of 20 elements; the canonical representation of a [[scala.Product20]]. * * @constructor Create a new tuple with 20 elements. Note that it is more idiomatic to create a Tuple20 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20)` - * @param _1 Element 1 of this Tuple20 - * @param _2 Element 2 of this Tuple20 - * @param _3 Element 3 of this Tuple20 - * @param _4 Element 4 of this Tuple20 - * @param _5 Element 5 of this Tuple20 - * @param _6 Element 6 of this Tuple20 - * @param _7 Element 7 of this Tuple20 - * @param _8 Element 8 of this Tuple20 - * @param _9 Element 9 of this Tuple20 - * @param _10 Element 10 of this Tuple20 - * @param _11 Element 11 of this Tuple20 - * @param _12 Element 12 of this Tuple20 - * @param _13 Element 13 of this Tuple20 - * @param _14 Element 14 of this Tuple20 - * @param _15 Element 15 of this Tuple20 - * @param _16 Element 16 of this Tuple20 - * @param _17 Element 17 of this Tuple20 - * @param _18 Element 18 of this Tuple20 - * @param _19 Element 19 of this Tuple20 - * @param _20 Element 20 of this Tuple20 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + * @tparam T19 the type of the 19th element + * @tparam T20 the type of the 20th element + * @param _1 the 1st element of this Tuple20 + * @param _2 the 2nd element of this Tuple20 + * @param _3 the 3rd element of this Tuple20 + * @param _4 the 4th element of this Tuple20 + * @param _5 the 5th element of this Tuple20 + * @param _6 the 6th element of this Tuple20 + * @param _7 the 7th element of this Tuple20 + * @param _8 the 8th element of this Tuple20 + * @param _9 the 9th element of this Tuple20 + * @param _10 the 10th element of this Tuple20 + * @param _11 the 11th element of this Tuple20 + * @param _12 the 12th element of this Tuple20 + * @param _13 the 13th element of this Tuple20 + * @param _14 the 14th element of this Tuple20 + * @param _15 the 15th element of this Tuple20 + * @param _16 the 16th element of this Tuple20 + * @param _17 the 17th element of this Tuple20 + * @param _18 the 18th element of this Tuple20 + * @param _19 the 19th element of this Tuple20 + * @param _20 the 20th element of this Tuple20 */ final case class Tuple20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20) extends Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] diff --git a/library/src/scala/Tuple21.scala b/library/src/scala/Tuple21.scala index 951bccf2bc97..c524e4beed6e 100644 --- a/library/src/scala/Tuple21.scala +++ b/library/src/scala/Tuple21.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,27 @@ import scala.language.`2.13` /** A tuple of 21 elements; the canonical representation of a [[scala.Product21]]. * * @constructor Create a new tuple with 21 elements. Note that it is more idiomatic to create a Tuple21 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + * @tparam T19 the type of the 19th element + * @tparam T20 the type of the 20th element + * @tparam T21 the type of the 21st element * @param _1 Element 1 of this Tuple21 * @param _2 Element 2 of this Tuple21 * @param _3 Element 3 of this Tuple21 diff --git a/library/src/scala/Tuple22.scala b/library/src/scala/Tuple22.scala index f0f3533cd4bd..e10a9bfb38b8 100644 --- a/library/src/scala/Tuple22.scala +++ b/library/src/scala/Tuple22.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,28 +17,50 @@ import scala.language.`2.13` /** A tuple of 22 elements; the canonical representation of a [[scala.Product22]]. * * @constructor Create a new tuple with 22 elements. Note that it is more idiomatic to create a Tuple22 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22)` - * @param _1 Element 1 of this Tuple22 - * @param _2 Element 2 of this Tuple22 - * @param _3 Element 3 of this Tuple22 - * @param _4 Element 4 of this Tuple22 - * @param _5 Element 5 of this Tuple22 - * @param _6 Element 6 of this Tuple22 - * @param _7 Element 7 of this Tuple22 - * @param _8 Element 8 of this Tuple22 - * @param _9 Element 9 of this Tuple22 - * @param _10 Element 10 of this Tuple22 - * @param _11 Element 11 of this Tuple22 - * @param _12 Element 12 of this Tuple22 - * @param _13 Element 13 of this Tuple22 - * @param _14 Element 14 of this Tuple22 - * @param _15 Element 15 of this Tuple22 - * @param _16 Element 16 of this Tuple22 - * @param _17 Element 17 of this Tuple22 - * @param _18 Element 18 of this Tuple22 - * @param _19 Element 19 of this Tuple22 - * @param _20 Element 20 of this Tuple22 - * @param _21 Element 21 of this Tuple22 - * @param _22 Element 22 of this Tuple22 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element + * @tparam T10 the type of the 10th element + * @tparam T11 the type of the 11th element + * @tparam T12 the type of the 12th element + * @tparam T13 the type of the 13th element + * @tparam T14 the type of the 14th element + * @tparam T15 the type of the 15th element + * @tparam T16 the type of the 16th element + * @tparam T17 the type of the 17th element + * @tparam T18 the type of the 18th element + * @tparam T19 the type of the 19th element + * @tparam T20 the type of the 20th element + * @tparam T21 the type of the 21st element + * @tparam T22 the type of the 22nd element + * @param _1 the 1st element of this Tuple22 + * @param _2 the 2nd element of this Tuple22 + * @param _3 the 3rd element of this Tuple22 + * @param _4 the 4th element of this Tuple22 + * @param _5 the 5th element of this Tuple22 + * @param _6 the 6th element of this Tuple22 + * @param _7 the 7th element of this Tuple22 + * @param _8 the 8th element of this Tuple22 + * @param _9 the 9th element of this Tuple22 + * @param _10 the 10th element of this Tuple22 + * @param _11 the 11th element of this Tuple22 + * @param _12 the 12th element of this Tuple22 + * @param _13 the 13th element of this Tuple22 + * @param _14 the 14th element of this Tuple22 + * @param _15 the 15th element of this Tuple22 + * @param _16 the 16th element of this Tuple22 + * @param _17 the 17th element of this Tuple22 + * @param _18 the 18th element of this Tuple22 + * @param _19 the 19th element of this Tuple22 + * @param _20 the 20th element of this Tuple22 + * @param _21 the 21st element of this Tuple22 + * @param _22 the 22nd element of this Tuple22 */ final case class Tuple22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20, _21: T21, _22: T22) extends Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] diff --git a/library/src/scala/Tuple3.scala b/library/src/scala/Tuple3.scala index c63abe5786a0..07536ba36471 100644 --- a/library/src/scala/Tuple3.scala +++ b/library/src/scala/Tuple3.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,9 @@ import scala.language.`2.13` /** A tuple of 3 elements; the canonical representation of a [[scala.Product3]]. * * @constructor Create a new tuple with 3 elements. Note that it is more idiomatic to create a Tuple3 via `(t1, t2, t3)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element * @param _1 Element 1 of this Tuple3 * @param _2 Element 2 of this Tuple3 * @param _3 Element 3 of this Tuple3 diff --git a/library/src/scala/Tuple4.scala b/library/src/scala/Tuple4.scala index e48cb2043d4c..31d3d6dc37e5 100644 --- a/library/src/scala/Tuple4.scala +++ b/library/src/scala/Tuple4.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,10 +17,14 @@ import scala.language.`2.13` /** A tuple of 4 elements; the canonical representation of a [[scala.Product4]]. * * @constructor Create a new tuple with 4 elements. Note that it is more idiomatic to create a Tuple4 via `(t1, t2, t3, t4)` - * @param _1 Element 1 of this Tuple4 - * @param _2 Element 2 of this Tuple4 - * @param _3 Element 3 of this Tuple4 - * @param _4 Element 4 of this Tuple4 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @param _1 element 1 of this Tuple4 + * @param _2 element 2 of this Tuple4 + * @param _3 element 3 of this Tuple4 + * @param _4 element 4 of this Tuple4 */ final case class Tuple4[+T1, +T2, +T3, +T4](_1: T1, _2: T2, _3: T3, _4: T4) extends Product4[T1, T2, T3, T4] diff --git a/library/src/scala/Tuple5.scala b/library/src/scala/Tuple5.scala index c4a4fc6cf415..76aa8836afe3 100644 --- a/library/src/scala/Tuple5.scala +++ b/library/src/scala/Tuple5.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,11 +17,16 @@ import scala.language.`2.13` /** A tuple of 5 elements; the canonical representation of a [[scala.Product5]]. * * @constructor Create a new tuple with 5 elements. Note that it is more idiomatic to create a Tuple5 via `(t1, t2, t3, t4, t5)` - * @param _1 Element 1 of this Tuple5 - * @param _2 Element 2 of this Tuple5 - * @param _3 Element 3 of this Tuple5 - * @param _4 Element 4 of this Tuple5 - * @param _5 Element 5 of this Tuple5 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @param _1 the 1st element of this Tuple5 + * @param _2 the 2nd element of this Tuple5 + * @param _3 the 3rd element of this Tuple5 + * @param _4 the 4th element of this Tuple5 + * @param _5 the 5th element of this Tuple5 */ final case class Tuple5[+T1, +T2, +T3, +T4, +T5](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5) extends Product5[T1, T2, T3, T4, T5] diff --git a/library/src/scala/Tuple6.scala b/library/src/scala/Tuple6.scala index 1e28feb1661b..c2a885689e61 100644 --- a/library/src/scala/Tuple6.scala +++ b/library/src/scala/Tuple6.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,12 +17,18 @@ import scala.language.`2.13` /** A tuple of 6 elements; the canonical representation of a [[scala.Product6]]. * * @constructor Create a new tuple with 6 elements. Note that it is more idiomatic to create a Tuple6 via `(t1, t2, t3, t4, t5, t6)` - * @param _1 Element 1 of this Tuple6 - * @param _2 Element 2 of this Tuple6 - * @param _3 Element 3 of this Tuple6 - * @param _4 Element 4 of this Tuple6 - * @param _5 Element 5 of this Tuple6 - * @param _6 Element 6 of this Tuple6 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @param _1 the 1st element of this Tuple6 + * @param _2 the 2nd element of this Tuple6 + * @param _3 the 3rd element of this Tuple6 + * @param _4 the 4th element of this Tuple6 + * @param _5 the 5th element of this Tuple6 + * @param _6 the 6th element of this Tuple6 */ final case class Tuple6[+T1, +T2, +T3, +T4, +T5, +T6](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6) extends Product6[T1, T2, T3, T4, T5, T6] diff --git a/library/src/scala/Tuple7.scala b/library/src/scala/Tuple7.scala index 64e261eb7f32..da370fd3cc6d 100644 --- a/library/src/scala/Tuple7.scala +++ b/library/src/scala/Tuple7.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,13 +17,20 @@ import scala.language.`2.13` /** A tuple of 7 elements; the canonical representation of a [[scala.Product7]]. * * @constructor Create a new tuple with 7 elements. Note that it is more idiomatic to create a Tuple7 via `(t1, t2, t3, t4, t5, t6, t7)` - * @param _1 Element 1 of this Tuple7 - * @param _2 Element 2 of this Tuple7 - * @param _3 Element 3 of this Tuple7 - * @param _4 Element 4 of this Tuple7 - * @param _5 Element 5 of this Tuple7 - * @param _6 Element 6 of this Tuple7 - * @param _7 Element 7 of this Tuple7 + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @param _1 the 1st element of this Tuple7 + * @param _2 the 2nd element of this Tuple7 + * @param _3 the 3rd element of this Tuple7 + * @param _4 the 4th element of this Tuple7 + * @param _5 the 5th element of this Tuple7 + * @param _6 the 6th element of this Tuple7 + * @param _7 the 7th element of this Tuple7 */ final case class Tuple7[+T1, +T2, +T3, +T4, +T5, +T6, +T7](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7) extends Product7[T1, T2, T3, T4, T5, T6, T7] diff --git a/library/src/scala/Tuple8.scala b/library/src/scala/Tuple8.scala index 5c5adfd5a5b4..c5b6ba3eaa05 100644 --- a/library/src/scala/Tuple8.scala +++ b/library/src/scala/Tuple8.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,14 @@ import scala.language.`2.13` /** A tuple of 8 elements; the canonical representation of a [[scala.Product8]]. * * @constructor Create a new tuple with 8 elements. Note that it is more idiomatic to create a Tuple8 via `(t1, t2, t3, t4, t5, t6, t7, t8)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element * @param _1 Element 1 of this Tuple8 * @param _2 Element 2 of this Tuple8 * @param _3 Element 3 of this Tuple8 diff --git a/library/src/scala/Tuple9.scala b/library/src/scala/Tuple9.scala index 3a69c9ae8b25..5bc76f302274 100644 --- a/library/src/scala/Tuple9.scala +++ b/library/src/scala/Tuple9.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala import scala.language.`2.13` @@ -19,6 +17,15 @@ import scala.language.`2.13` /** A tuple of 9 elements; the canonical representation of a [[scala.Product9]]. * * @constructor Create a new tuple with 9 elements. Note that it is more idiomatic to create a Tuple9 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9)` + * @tparam T1 the type of the 1st element + * @tparam T2 the type of the 2nd element + * @tparam T3 the type of the 3rd element + * @tparam T4 the type of the 4th element + * @tparam T5 the type of the 5th element + * @tparam T6 the type of the 6th element + * @tparam T7 the type of the 7th element + * @tparam T8 the type of the 8th element + * @tparam T9 the type of the 9th element * @param _1 Element 1 of this Tuple9 * @param _2 Element 2 of this Tuple9 * @param _3 Element 3 of this Tuple9 diff --git a/library/src/scala/Unit.scala b/library/src/scala/Unit.scala index bd69c022da46..3faf3dc25935 100644 --- a/library/src/scala/Unit.scala +++ b/library/src/scala/Unit.scala @@ -19,10 +19,7 @@ import scala.language.`2.13` * runtime system. A method with return type `Unit` is analogous to a Java * method which is declared `void`. */ -final abstract class Unit private extends AnyVal { - // Provide a more specific return type for Scaladoc - override def getClass(): Class[Unit] = ??? -} +final abstract class Unit private extends AnyVal @scala.annotation.compileTimeOnly("`Unit` companion object is not allowed in source; instead, use `()` for the unit value") object Unit extends AnyValCompanion { diff --git a/library/src/scala/annotation/MacroAnnotation.scala b/library/src/scala/annotation/MacroAnnotation.scala index 077acc1817cf..10fff4862964 100644 --- a/library/src/scala/annotation/MacroAnnotation.scala +++ b/library/src/scala/annotation/MacroAnnotation.scala @@ -42,10 +42,9 @@ trait MacroAnnotation extends StaticAnnotation: * * #### Example 1 * This example shows how to modify a `def` and add a `val` next to it using a macro annotation. - * ```scala + * ```scala sc-hidden sc-name:memoize-context * import scala.quoted.* * import scala.collection.concurrent - * * class memoize extends MacroAnnotation: * def transform(using Quotes)( * definition: quotes.reflect.Definition, @@ -76,7 +75,7 @@ trait MacroAnnotation extends StaticAnnotation: * end transform * ``` * with this macro annotation a user can write - * ```scala + * ```scala sc:compile * //{ * class memoize extends scala.annotation.StaticAnnotation * //} @@ -86,7 +85,7 @@ trait MacroAnnotation extends StaticAnnotation: * if n <= 1 then n else fib(n - 1) + fib(n - 2) * ``` * and the macro will modify the definition to create - * ```scala + * ```scala sc-compile-with:memoize-context * val fibCache$macro$1 = * scala.collection.concurrent.TrieMap.empty[Int, Int] * def fib(n: Int): Int = @@ -102,7 +101,7 @@ trait MacroAnnotation extends StaticAnnotation: * #### Example 2 * This example shows how to modify a `class` using a macro annotation. * It shows how to override inherited members and add new ones. - * ```scala + * ```scala sc:compile * import scala.annotation.{experimental, MacroAnnotation} * import scala.quoted.* * @@ -193,14 +192,14 @@ trait MacroAnnotation extends StaticAnnotation: * } * ``` * with this macro annotation a user can write - * ```scala + * ```scala sc:compile * //{ * class equals extends scala.annotation.StaticAnnotation * //} * @equals class User(val name: String, val id: Int) * ``` * and the macro will modify the class definition to generate the following code - * ```scala + * ```scala sc:compile * class User(val name: String, val id: Int): * override def equals(that: Any): Boolean = * that match diff --git a/library/src/scala/annotation/internal/$into.scala b/library/src/scala/annotation/internal/$into.scala index 3ca9d193bd0f..db6b996dae2a 100644 --- a/library/src/scala/annotation/internal/$into.scala +++ b/library/src/scala/annotation/internal/$into.scala @@ -7,5 +7,4 @@ package scala.annotation.internal * `T`. Hence, we don't need to use `.underlying` to go from an into type to its * underlying type in the types of local parameters. */ -@preview -class $into extends annotation.StaticAnnotation \ No newline at end of file +class `$into` extends annotation.StaticAnnotation diff --git a/library/src/scala/annotation/meta/package.scala b/library/src/scala/annotation/meta/package.scala index 8c2d6d6defc1..4a8016f41570 100644 --- a/library/src/scala/annotation/meta/package.scala +++ b/library/src/scala/annotation/meta/package.scala @@ -21,8 +21,14 @@ import scala.language.`2.13` * * For instance in the following class definition * + * ```scala sc-hidden sc-name:bean-imports + * import scala.beans.BeanProperty + * import scala.annotation.Annotation + * import scala.annotation.meta.beanGetter * ``` - * class C(@myAnnot @BeanProperty var c: Int) + * ```scala sc-compile-with:bean-imports + * class myAnnotation extends Annotation + * class C(@myAnnotation @BeanProperty var c: Int) * ``` * * there are six entities which can carry the annotation `@myAnnot`: the @@ -41,12 +47,12 @@ import scala.language.`2.13` * * The target meta-annotations can be put on the annotation type when * instantiating the annotation. In the following example, the annotation - * `@Id` will be added only to the bean getter `getX`. + * `@MyId` will be added only to the bean getter `getX`. * - * ``` - * import javax.persistence.Id + * ```scala sc-compile-with:bean-imports + * class MyId extends Annotation * class A { - * @(Id @beanGetter) @BeanProperty val x = 0 + * @(MyId @beanGetter) @BeanProperty val x = 0 * } * ``` * @@ -55,11 +61,12 @@ import scala.language.`2.13` * * The syntax can be improved using a type alias: * - * ``` - * object ScalaJPA { - * type Id = javax.persistence.Id @beanGetter + * ```scala sc-compile-with:bean-imports + * class MyId extends Annotation + * object ScalaAnnotation { + * type Id = MyId @beanGetter * } - * import ScalaJPA.Id + * import ScalaAnnotation.Id * class A { * @Id @BeanProperty val x = 0 * } @@ -70,7 +77,11 @@ import scala.language.`2.13` * For annotations defined in Scala, a default target can be specified * in the annotation class itself, for example * + * ```scala sc-hidden sc-name:getter-imports + * import scala.annotation.Annotation + * import scala.annotation.meta.getter * ``` + * ```scala sc-compile-with:getter-imports * @getter * class myAnnotation extends Annotation * ``` diff --git a/library/src/scala/annotation/meta/superArg.scala b/library/src/scala/annotation/meta/superArg.scala index cfde5967ff52..a64d2b9d911b 100644 --- a/library/src/scala/annotation/meta/superArg.scala +++ b/library/src/scala/annotation/meta/superArg.scala @@ -17,18 +17,24 @@ import scala.language.`2.13` /** This internal annotation encodes arguments passed to annotation superclasses. Example: * - * ``` - * class a(x: Int) extends Annotation - * class b extends a(42) // the compiler adds `@superArg("x", 42)` to class b - * ``` + * ```scala sc-hidden sc-name:superarg-imports + * import scala.annotation.Annotation + * ``` + * ```scala sc-compile-with:superarg-imports + * class a(x: Int) extends Annotation + * class b extends a(42) // the compiler adds `@superArg("x", 42)` to class b + * ``` */ class superArg(p: String, v: Any) extends StaticAnnotation /** This internal annotation encodes arguments passed to annotation superclasses. Example: * - * ``` - * class a(x: Int) extends Annotation - * class b(y: Int) extends a(y) // the compiler adds `@superFwdArg("x", "y")` to class b - * ``` + * ```scala sc-hidden sc-name:superarg-imports + * import scala.annotation.Annotation + * ``` + * ```scala sc-compile-with:superarg-imports + * class a(x: Int) extends Annotation + * class b(y: Int) extends a(y) // the compiler adds `@superFwdArg("x", "y")` to class b + * ``` */ class superFwdArg(p: String, n: String) extends StaticAnnotation diff --git a/library/src/scala/annotation/nowarn.scala b/library/src/scala/annotation/nowarn.scala index 5145379b0157..0c7aa51b36b7 100644 --- a/library/src/scala/annotation/nowarn.scala +++ b/library/src/scala/annotation/nowarn.scala @@ -37,7 +37,7 @@ import scala.language.`2.13` * def f = { 1; deprecated() } // show deprecation warning * ``` * - * To ensure that a `@nowarn` annotation actually suppresses a warning, enable `-Xlint:unused` or `-Wunused:nowarn`. + * To ensure that a `@nowarn` annotation actually suppresses a warning, enable `-Wunused:nowarn`. * The unused annotation warning is emitted in category `unused-nowarn` and can be selectively managed * using `-Wconf:cat=unused-nowarn:s`. */ diff --git a/library/src/scala/annotation/stableNull.scala b/library/src/scala/annotation/stableNull.scala index e2ebac72fce5..045c8b29d123 100644 --- a/library/src/scala/annotation/stableNull.scala +++ b/library/src/scala/annotation/stableNull.scala @@ -7,4 +7,4 @@ package scala.annotation * prefix is a stable path. * See `tests/explicit-nulls/pos/force-track-var-fields.scala` for an example. */ -private[scala] final class stableNull extends StaticAnnotation +final class stableNull extends StaticAnnotation diff --git a/library/src/scala/annotation/strictfp.scala b/library/src/scala/annotation/strictfp.scala index fd558390abfb..0b9bc894fc5c 100644 --- a/library/src/scala/annotation/strictfp.scala +++ b/library/src/scala/annotation/strictfp.scala @@ -18,4 +18,5 @@ import scala.language.`2.13` * the strictfp flag will be emitted. */ @deprecatedInheritance("Scheduled for being final in the future", "2.13.0") +@deprecated("As of JDK 17, all floating-point expressions are evaluated strictly and 'strictfp' is not required", "3.8.0") class strictfp extends scala.annotation.StaticAnnotation diff --git a/library/src/scala/annotation/unroll.scala b/library/src/scala/annotation/unroll.scala index d046810bd171..5766eb2491a7 100644 --- a/library/src/scala/annotation/unroll.scala +++ b/library/src/scala/annotation/unroll.scala @@ -1,8 +1,9 @@ package scala.annotation import language.experimental.captureChecking +import scala.annotation.internal.preview -@experimental("under review as part of SIP-61") +@preview /**The `@unroll` annotation is reserved for parameters of classes and methods. * * It enables to add new parameters while preserving backwards binary compatibility, diff --git a/library/src/scala/beans/BeanProperty.scala b/library/src/scala/beans/BeanProperty.scala index e66a0e5fb350..fe54e97933ba 100644 --- a/library/src/scala/beans/BeanProperty.scala +++ b/library/src/scala/beans/BeanProperty.scala @@ -18,14 +18,19 @@ import scala.annotation.meta.{beanGetter, beanSetter, field} /** When attached to a field, this annotation adds a setter and a getter * method following the Java Bean convention. For example: - * ``` - * @BeanProperty - * var status = "" + * ```scala sc:compile + * class Person: + * @BeanProperty + * var status = "" * ``` * adds the following methods to the class: - * ``` - * def setStatus(s: String): Unit = { this.status = s } - * def getStatus(): String = this.status + * ```scala sc:compile + * class Person: + * @BeanProperty + * var status = "" + * // The annotation generates: + * // def setStatus(s: String): Unit = { this.status = s } + * // def getStatus(): String = this.status * ``` * For fields of type `Boolean`, if you need a getter named `isStatus`, * use the `scala.beans.BooleanBeanProperty` annotation instead. diff --git a/library/src/scala/caps/package.scala b/library/src/scala/caps/package.scala index b16c2dcf6723..3374924a5142 100644 --- a/library/src/scala/caps/package.scala +++ b/library/src/scala/caps/package.scala @@ -182,11 +182,17 @@ object internal: final class consume extends annotation.StaticAnnotation /** An annotation on a type indicating that the type was inferred. Added - * during inlining when we want to mark portions of aotherwise explicit type + * during inlining when we want to mark portions of an otherwise explicit type * as inferred. */ final class inferred extends annotation.StaticAnnotation + /** An annotation on a type indicating that the type was declared. Added + * during PostTyper when we want to mark types of closure parameters as + * explicit, even if the closure type as a whole is inferred. + */ + final class declared extends annotation.StaticAnnotation + /** An internal annotation placed on a refinement created by capture checking. * Refinements with this annotation unconditionally override any * info from the parent type, so no intersection needs to be formed. @@ -195,6 +201,13 @@ object internal: @deprecated final class refineOverride extends annotation.StaticAnnotation + /** An internal annotation placed on a parameter of a secondary constructor + * that gets forwarded indirectly or directly to a parameter of the + * corresponding primary constructor. + * @param parmName the name of the primary constructor parameter + */ + final class paramAlias(paramName: String) extends annotation.StaticAnnotation + /** An erasedValue issued internally by the compiler. Unlike the * user-accessible compiletime.erasedValue, this version is assumed * to be a pure expression, hence capability safe. The compiler generates this diff --git a/library/src/scala/collection/ArrayOps.scala b/library/src/scala/collection/ArrayOps.scala index 32108fcb5250..5706d49bebd5 100644 --- a/library/src/scala/collection/ArrayOps.scala +++ b/library/src/scala/collection/ArrayOps.scala @@ -63,11 +63,19 @@ object ArrayOps { override def toString(): String = immutable.ArraySeq.unsafeWrapArray(xs).mkString("ArrayView(", ", ", ")") } - /** A lazy filtered array. No filtering is applied until one of `foreach`, `map` or `flatMap` is called. */ + /** A lazy filtered array. No filtering is applied until one of `foreach`, `map` or `flatMap` is called. + * + * @tparam A the element type of the array + * @param p the filter predicate applied to each element + * @param xs the underlying array being filtered + */ class WithFilter[A](p: A => Boolean, xs: Array[A]) { /** Applies `f` to each element for its side effects. * Note: [U] parameter needed to help scalac's type inference. + * + * @tparam U the return type of the function `f`, used only for side effects + * @param f the function to apply to each element */ def foreach[U](f: A => U): Unit = { val len = xs.length @@ -119,7 +127,10 @@ object ArrayOps { def flatMap[BS, B](f: A => BS)(implicit asIterable: BS => Iterable[B], m: ClassTag[B]): Array[B] = flatMap[B](x => asIterable(f(x))) - /** Creates a new non-strict filter which combines this filter with the given predicate. */ + /** Creates a new non-strict filter which combines this filter with the given predicate. + * + * @param q the additional predicate to apply in conjunction with `p` + */ def withFilter(q: A => Boolean): WithFilter[A]^{this, q} = new WithFilter[A](a => p(a) && q(a), xs) } @@ -199,6 +210,7 @@ object ArrayOps { * `filter` and `map` will yield an array, whereas an `ArraySeq` will remain an `ArraySeq`. * * @tparam A type of the elements contained in this array. + * @param xs the underlying array being wrapped */ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { @@ -294,6 +306,8 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * this.sizeIs >= size // this.sizeCompare(size) >= 0 * this.sizeIs > size // this.sizeCompare(size) > 0 * ``` + * + * @return the number of elements in this array */ def sizeIs: Int = xs.length @@ -311,6 +325,8 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * this.lengthIs >= len // this.lengthCompare(len) >= 0 * this.lengthIs > len // this.lengthCompare(len) > 0 * ``` + * + * @return the number of elements in this array */ def lengthIs: Int = xs.length @@ -373,16 +389,28 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { private def iterateUntilEmpty(f: Array[A] => Array[A]): Iterator[Array[A]]^{f} = Iterator.iterate(xs)(f).takeWhile(x => x.length != 0) ++ Iterator.single(Array.empty[A]) - /** An array containing the first `n` elements of this array. */ + /** An array containing the first `n` elements of this array. + * + * @param n the number of elements to take from this array + */ def take(n: Int): Array[A] = slice(0, n) - /** The rest of the array without its `n` first elements. */ + /** The rest of the array without its `n` first elements. + * + * @param n the number of elements to drop from the front of this array + */ def drop(n: Int): Array[A] = slice(n, xs.length) - /** An array containing the last `n` elements of this array. */ + /** An array containing the last `n` elements of this array. + * + * @param n the number of elements to take from the end of this array + */ def takeRight(n: Int): Array[A] = drop(xs.length - max(n, 0)) - /** The rest of the array without its `n` last elements. */ + /** The rest of the array without its `n` last elements. + * + * @param n the number of elements to drop from the end of this array + */ def dropRight(n: Int): Array[A] = take(xs.length - max(n, 0)) /** Takes longest prefix of elements that satisfy a predicate. @@ -476,7 +504,10 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { */ def splitAt(n: Int): (Array[A], Array[A]) = (take(n), drop(n)) - /** A pair of, first, all elements that satisfy predicate `p` and, second, all elements that do not. */ + /** A pair of, first, all elements that satisfy predicate `p` and, second, all elements that do not. + * + * @param p the predicate used to partition the elements + */ def partition(p: A => Boolean): (Array[A], Array[A]) = { val res1, res2 = ArrayBuilder.make[A] var i = 0 @@ -507,7 +538,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * @param f the 'split function' mapping the elements of this array to an [[scala.util.Either]] * * @return a pair of arrays: the first one made of those values returned by `f` that were wrapped in [[scala.util.Left]], - * and the second one made of those wrapped in [[scala.util.Right]]. + * and the second one made of those wrapped in [[scala.util.Right]]. */ def partitionMap[A1: ClassTag, A2: ClassTag](f: A => Either[A1, A2]): (Array[A1], Array[A2]) = { val res1 = ArrayBuilder.make[A1] @@ -586,6 +617,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * * @see [[scala.math.Ordering]] * + * @tparam B the element type for the ordering, a supertype of `A` * @param ord the ordering to be used to compare elements. * @return an array consisting of the elements of this array * sorted according to the ordering `ord`. @@ -721,6 +753,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { /** Finds index of last element satisfying some predicate before or at given end index. * * @param p the predicate used to test elements. + * @param end the maximum index to search up to (inclusive), defaults to the last index * @return the index `<= end` of the last element of this array that satisfies the predicate `p`, * or `-1`, if none exists. */ @@ -926,6 +959,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * * @tparam B the element type of the returned array. * @param f the function to apply to each element. + * @param ct the class tag for the element type `B`, required to create the result array * @return a new array resulting from applying the given function * `f` to each element of this array and collecting the results. */ @@ -984,6 +1018,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * * @tparam B Type of row elements. * @param asIterable A function that converts elements of this array to rows - Iterables of type `B`. + * @param m the class tag for the element type `B`, required to create the result array * @return An array obtained by concatenating rows of this array. */ def flatten[B](implicit asIterable: A => IterableOnce[B]^, m: ClassTag[B]): Array[B] = { @@ -1032,7 +1067,9 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { } /** Finds the first element of the array for which the given partial function is defined, and applies the - * partial function to it. + * partial function to it. + * + * @tparam B the result type of the partial function */ def collectFirst[B](@deprecatedName("f","2.13.9") pf: PartialFunction[A, B]^): Option[B] = { val fallback: Any => Any = ArrayOps.fallback @@ -1091,6 +1128,8 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * If one of the two collections is shorter than the other, * placeholder elements are used to extend the shorter collection to the length of the longer. * + * @tparam A1 the type of the first element of each pair in the result, a supertype of `A` + * @tparam B the type of elements in `that` iterable * @param that the iterable providing the second half of each result pair * @param thisElem the element to be used to fill up the result if this array is shorter than `that`. * @param thatElem the element to be used to fill up the result if `that` is shorter than this array. @@ -1135,7 +1174,11 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { b } - /** A copy of this array with an element appended. */ + /** A copy of this array with an element appended. + * + * @tparam B the element type of the returned array, a supertype of `A` + * @param x the element to append + */ def appended[B >: A : ClassTag](x: B): Array[B] = { val dest = Array.copyAs[B](xs, xs.length+1) dest(xs.length) = x @@ -1144,7 +1187,11 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { @`inline` final def :+ [B >: A : ClassTag](x: B): Array[B] = appended(x) - /** A copy of this array with an element prepended. */ + /** A copy of this array with an element prepended. + * + * @tparam B the element type of the returned array, a supertype of `A` + * @param x the element to prepend + */ def prepended[B >: A : ClassTag](x: B): Array[B] = { val dest = new Array[B](xs.length + 1) dest(0) = x @@ -1154,7 +1201,11 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { @`inline` final def +: [B >: A : ClassTag](x: B): Array[B] = prepended(x) - /** A copy of this array with all elements of a collection prepended. */ + /** A copy of this array with all elements of a collection prepended. + * + * @tparam B the element type of the returned array, a supertype of `A` + * @param prefix the collection to prepend + */ def prependedAll[B >: A : ClassTag](prefix: IterableOnce[B]^): Array[B] = { val b = ArrayBuilder.make[B] val k = prefix.knownSize @@ -1165,7 +1216,11 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { b.result() } - /** A copy of this array with all elements of an array prepended. */ + /** A copy of this array with all elements of an array prepended. + * + * @tparam B the element type of the returned array, a supertype of `A` + * @param prefix the array to prepend + */ def prependedAll[B >: A : ClassTag](prefix: Array[? <: B]): Array[B] = { val dest = Array.copyAs[B](prefix, prefix.length+xs.length) Array.copy(xs, 0, dest, prefix.length, xs.length) @@ -1176,7 +1231,11 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { @`inline` final def ++: [B >: A : ClassTag](prefix: Array[? <: B]): Array[B] = prependedAll(prefix) - /** A copy of this array with all elements of a collection appended. */ + /** A copy of this array with all elements of a collection appended. + * + * @tparam B the element type of the returned array, a supertype of `A` + * @param suffix the collection to append + */ def appendedAll[B >: A : ClassTag](suffix: IterableOnce[B]^): Array[B] = { val b = ArrayBuilder.make[B] b.sizeHint(suffix, delta = xs.length) @@ -1185,7 +1244,11 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { b.result() } - /** A copy of this array with all elements of an array appended. */ + /** A copy of this array with all elements of an array appended. + * + * @tparam B the element type of the returned array, a supertype of `A` + * @param suffix the array to append + */ def appendedAll[B >: A : ClassTag](suffix: Array[? <: B]): Array[B] = { val dest = Array.copyAs[B](xs, xs.length+suffix.length) Array.copy(suffix, 0, dest, xs.length, suffix.length) @@ -1217,6 +1280,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * Patching at indices at or larger than the length of the original array appends the patch to the end. * If more values are replaced than actually exist, the excess is ignored. * + * @tparam B the element type of the returned array, a supertype of `A` * @param from The start index from which to patch * @param other The patch values * @param replaced The number of values in the original array that are replaced by the patch. @@ -1319,6 +1383,9 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { /** Applies `f` to each element for its side effects. * Note: [U] parameter needed to help scalac's type inference. + * + * @tparam U the return type of the function `f`, used only for side effects + * @param f the function to apply to each element */ def foreach[U](f: A => U): Unit = { val len = xs.length @@ -1419,6 +1486,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * @tparam B the type of values returned by the transformation function * @param key the discriminator function * @param f the element transformation function + * @return a map associating each key `k` with an array of transformed elements for which `key` returns `k` */ def groupMap[K, B : ClassTag](key: A => K)(f: A => B): immutable.Map[K, Array[B]] = { val m = mutable.Map.empty[K, ArrayBuilder[B]] @@ -1478,7 +1546,10 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { copied } - /** Creates a copy of this array with the specified element type. */ + /** Creates a copy of this array with the specified element type. + * + * @tparam B the element type of the copy, a supertype of `A` + */ def toArray[B >: A: ClassTag]: Array[B] = { val destination = new Array[B](xs.length) @annotation.unused val copied = copyToArray(destination, 0) @@ -1486,7 +1557,10 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { destination } - /** Counts the number of elements in this array which satisfy a predicate. */ + /** Counts the number of elements in this array which satisfy a predicate. + * + * @param p the predicate used to test elements + */ def count(p: A => Boolean): Int = { var i, res = 0 val len = xs.length @@ -1498,11 +1572,16 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { } // can't use a default arg because we already have another overload with a default arg - /** Tests whether this array starts with the given array. */ + /** Tests whether this array starts with the given array. + * + * @tparam B the element type of the prefix array, a supertype of `A` + * @param that the array to test as a prefix + */ @`inline` def startsWith[B >: A](that: Array[B]): Boolean = startsWith(that, 0) /** Tests whether this array contains the given array at a given index. * + * @tparam B the element type of the prefix array, a supertype of `A` * @param that the array to test * @param offset the index where the array is searched. * @return `true` if the array `that` is contained in this array at @@ -1524,6 +1603,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { /** Tests whether this array ends with the given array. * + * @tparam B the element type of the suffix array, a supertype of `A` * @param that the array to test * @return `true` if this array has `that` as a suffix, `false` otherwise. */ @@ -1542,6 +1622,8 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { } /** A copy of this array with one single replaced element. + * + * @tparam B the element type of the returned array, a supertype of `A` * @param index the position of the replacement * @param elem the replacing element * @return a new array which is a copy of this array with the element at position `index` replaced by `elem`. @@ -1567,6 +1649,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { /** Computes the multiset difference between this array and another sequence. * + * @tparam B the element type of the other sequence, a supertype of `A` * @param that the sequence of elements to remove * @return a new array which contains all elements of this array * except some of occurrences of elements that also appear in `that`. @@ -1578,6 +1661,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { /** Computes the multiset intersection between this array and another sequence. * + * @tparam B the element type of the other sequence, a supertype of `A` * @param that the sequence of elements to intersect with. * @return a new array which contains all elements of this array * which also appear in `that`. @@ -1622,8 +1706,9 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { * of the original sequence, but the order in which elements were selected, by "first index"; * the order of each `x` element is also arbitrary. * + * @param n the number of elements in each combination * @return An Iterator which traverses the n-element combinations of this array - * @example ``` + * @example ```scala sc:compile * Array('a', 'b', 'b', 'b', 'c').combinations(2).map(runtime.ScalaRunTime.stringOf).foreach(println) * // Array(a, b) * // Array(a, c) @@ -1651,6 +1736,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { // we have another overload here, so we need to duplicate this method /** Tests whether this array contains the given sequence at a given index. * + * @tparam B the element type of the prefix sequence, a supertype of `A` * @param that the sequence to test * @param offset the index where the sequence is searched. * @return `true` if the sequence `that` is contained in this array at @@ -1661,6 +1747,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal { // we have another overload here, so we need to duplicate this method /** Tests whether this array ends with the given sequence. * + * @tparam B the element type of the suffix sequence, a supertype of `A` * @param that the sequence to test * @return `true` if this array has `that` as a suffix, `false` otherwise. */ diff --git a/library/src/scala/collection/BitSet.scala b/library/src/scala/collection/BitSet.scala index 17df9360f834..9d0e8b77027b 100644 --- a/library/src/scala/collection/BitSet.scala +++ b/library/src/scala/collection/BitSet.scala @@ -84,7 +84,10 @@ object BitSet extends SpecificIterableFactory[Int, BitSet] { } } -/** Base implementation type of bitsets. */ +/** Base implementation type of bitsets. + * + * @tparam C the type of the bitset itself, used for return types of operations + */ transparent trait BitSetOps[+C <: BitSet & BitSetOps[C]] extends SortedSetOps[Int, SortedSet, C] { self => import BitSetOps._ @@ -100,10 +103,15 @@ transparent trait BitSetOps[+C <: BitSet & BitSetOps[C]] /** The words at index `idx`, or 0L if outside the range of the set * **Note:** requires `idx >= 0` + * + * @param idx the index of the word to retrieve, must be non-negative */ protected[collection] def word(idx: Int): Long - /** Creates a new set of this kind from an array of longs */ + /** Creates a new set of this kind from an array of longs + * + * @param elems the array of 64-bit words representing the bit mask for the new set + */ protected[collection] def fromBitMaskNoCopy(elems: Array[Long]): C def contains(elem: Int): Boolean = diff --git a/library/src/scala/collection/BufferedIterator.scala b/library/src/scala/collection/BufferedIterator.scala index 96f588a06e16..0ac6f3cc03ce 100644 --- a/library/src/scala/collection/BufferedIterator.scala +++ b/library/src/scala/collection/BufferedIterator.scala @@ -17,6 +17,8 @@ import language.experimental.captureChecking /** Buffered iterators are iterators which provide a method `head` * that inspects the next element without discarding it. + * + * @tparam A the type of elements returned by this iterator */ trait BufferedIterator[+A] extends Iterator[A] { diff --git a/library/src/scala/collection/BuildFrom.scala b/library/src/scala/collection/BuildFrom.scala index bcc175fe589d..1ca9c4659f99 100644 --- a/library/src/scala/collection/BuildFrom.scala +++ b/library/src/scala/collection/BuildFrom.scala @@ -19,6 +19,7 @@ import scala.annotation.implicitNotFound import scala.collection.mutable.Builder import scala.collection.immutable.WrappedString import scala.reflect.ClassTag +import caps.unsafe.unsafeAssumePure /** Builds a collection of type `C` from elements of type `A` when a source collection of type `From` is available. * Implicit instances of `BuildFrom` are available for all collection types. @@ -28,18 +29,23 @@ import scala.reflect.ClassTag * @tparam C Type of collection (e.g. `List[Int]`, `TreeMap[Int, String]`, etc.) */ @implicitNotFound(msg = "Cannot construct a collection of type ${C} with elements of type ${A} based on a collection of type ${From}.") -trait BuildFrom[-From, -A, +C] extends Any { self => +trait BuildFrom[-From, -A, +C] extends Any { self: BuildFrom[From, A, C] => def fromSpecific(from: From)(it: IterableOnce[A]^): C^{it} /** Gets a Builder for the collection. For non-strict collection types this will use an intermediate buffer. - * Building collections with `fromSpecific` is preferred because it can be lazy for lazy collections. + * Building collections with `fromSpecific` is preferred because it can be lazy for lazy collections. + * + * @param from the source collection providing the factory for creating the builder */ def newBuilder(from: From): Builder[A, C] @deprecated("Use newBuilder() instead of apply()", "2.13.0") @`inline` def apply(from: From): Builder[A, C] = newBuilder(from) - /** Partially apply a BuildFrom to a Factory. */ + /** Partially apply a BuildFrom to a Factory. + * + * @param from the source collection to partially apply, producing a `Factory` bound to it + */ def toFactory(from: From): Factory[A, C] = new Factory[A, C] { def fromSpecific(it: IterableOnce[A]^): C^{it} = self.fromSpecific(from)(it) def newBuilder: Builder[A, C] = self.newBuilder(from) @@ -48,14 +54,20 @@ trait BuildFrom[-From, -A, +C] extends Any { self => object BuildFrom extends BuildFromLowPriority1 { - /** Builds the source collection type from a MapOps. */ + /** Builds the source collection type from a MapOps. + * + * @tparam CC the higher-kinded type constructor of the map collection (e.g. `HashMap`) + */ implicit def buildFromMapOps[CC[X, Y] <: Map[X, Y] & MapOps[X, Y, CC, ?], K0, V0, K, V]: BuildFrom[CC[K0, V0] & Map[K0, V0], (K, V), CC[K, V] & Map[K, V]] = new BuildFrom[CC[K0, V0], (K, V), CC[K, V]] { //TODO: Reuse a prototype instance def newBuilder(from: CC[K0, V0]): Builder[(K, V), CC[K, V]] = (from: MapOps[K0, V0, CC, ?]).mapFactory.newBuilder[K, V] def fromSpecific(from: CC[K0, V0])(it: IterableOnce[(K, V)]^): CC[K, V] = (from: MapOps[K0, V0, CC, ?]).mapFactory.from(it) } - /** Builds the source collection type from a SortedMapOps. */ + /** Builds the source collection type from a SortedMapOps. + * + * @tparam CC the higher-kinded type constructor of the sorted map collection (e.g. `TreeMap`) + */ implicit def buildFromSortedMapOps[CC[X, Y] <: SortedMap[X, Y] & SortedMapOps[X, Y, CC, ?], K0, V0, K : Ordering, V]: BuildFrom[CC[K0, V0] & SortedMap[K0, V0], (K, V), CC[K, V] & SortedMap[K, V]] = new BuildFrom[CC[K0, V0], (K, V), CC[K, V]] { def newBuilder(from: CC[K0, V0]): Builder[(K, V), CC[K, V]] = (from: SortedMapOps[K0, V0, CC, ?]).sortedMapFactory.newBuilder[K, V] def fromSpecific(from: CC[K0, V0])(it: IterableOnce[(K, V)]^): CC[K, V] = (from: SortedMapOps[K0, V0, CC, ?]).sortedMapFactory.from(it) @@ -81,7 +93,9 @@ object BuildFrom extends BuildFromLowPriority1 { implicit def buildFromArray[A : ClassTag]: BuildFrom[Array[?], A, Array[A]] = new BuildFrom[Array[?], A, Array[A]] { - def fromSpecific(from: Array[?])(it: IterableOnce[A]^): Array[A] = Factory.arrayFactory[A].fromSpecific(it) + def fromSpecific(from: Array[?])(it: IterableOnce[A]^): Array[A] = + Factory.arrayFactory[A].fromSpecific(it).unsafeAssumePure + // .unsafeAssumePure needed since Array is technically pure, but foes not extend from Pure. def newBuilder(from: Array[?]): Builder[A, Array[A]] = Factory.arrayFactory[A].newBuilder } @@ -95,7 +109,10 @@ object BuildFrom extends BuildFromLowPriority1 { trait BuildFromLowPriority1 extends BuildFromLowPriority2 { - /** Builds the source collection type from an Iterable with SortedOps. */ + /** Builds the source collection type from an Iterable with SortedOps. + * + * @tparam CC the higher-kinded type constructor of the sorted set collection (e.g. `TreeSet`) + */ // Restating the upper bound of CC in the result type seems redundant, but it serves to prune the // implicit search space for faster compilation and reduced change of divergence. See the compilation // test in test/junit/scala/collection/BuildFromTest.scala and discussion in https://github.com/scala/scala/pull/10209 @@ -112,7 +129,10 @@ trait BuildFromLowPriority1 extends BuildFromLowPriority2 { } trait BuildFromLowPriority2 { - /** Builds the source collection type from an IterableOps. */ + /** Builds the source collection type from an IterableOps. + * + * @tparam CC the higher-kinded type constructor of the iterable collection (e.g. `List`, `Vector`) + */ implicit def buildFromIterableOps[CC[X] <: Iterable[X] & IterableOps[X, CC, ?], A0, A]: BuildFrom[CC[A0], A, CC[A]] = new BuildFrom[CC[A0], A, CC[A]] { //TODO: Reuse a prototype instance def newBuilder(from: CC[A0]): Builder[A, CC[A]] = (from: IterableOps[A0, CC, ?]).iterableFactory.newBuilder[A] diff --git a/library/src/scala/collection/Factory.scala b/library/src/scala/collection/Factory.scala index 8efeb65a7fd9..382a5025f3e0 100644 --- a/library/src/scala/collection/Factory.scala +++ b/library/src/scala/collection/Factory.scala @@ -31,17 +31,16 @@ import scala.reflect.ClassTag * @tparam A Type of elements (e.g. `Int`, `Boolean`, etc.) * @tparam C Type of collection (e.g. `List[Int]`, `TreeMap[Int, String]`, etc.) */ -trait Factory[-A, +C] extends Any { self => +trait Factory[-A, +C] extends Any { self: Factory[A, C] => /** - * @param it Source collection - * @return A collection of type `C` containing the same elements - * as the source collection `it`. + * @param it the source of elements to include in the collection + * @return a collection of type `C` containing the elements from `it` */ def fromSpecific(it: IterableOnce[A]^): C^{it} /** Gets a Builder for the collection. For non-strict collection types this will use an intermediate buffer. - * Building collections with `fromSpecific` is preferred because it can be lazy for lazy collections. + * Building collections with `fromSpecific` is preferred because it can be lazy for lazy collections. */ def newBuilder: Builder[A, C] } @@ -107,6 +106,7 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { /** Produces a $coll containing repeated applications of a function to a start value. * + * @tparam A the element type of the $coll * @param start the start value of the $coll * @param len the number of elements contained in the $coll * @param f the function that's repeatedly applied @@ -128,6 +128,7 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { /** Produces a $coll containing a sequence of increasing of integers. * + * @tparam A the element type of the $coll, which must have an `Integral` instance * @param start the first element of the $coll * @param end the end value of the $coll (the first value NOT contained) * @return a $coll with values `start, start + 1, ..., end - 1` @@ -135,6 +136,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { def range[A : Integral](start: A, end: A): CC[A] = from(NumericRange(start, end, implicitly[Integral[A]].one)) /** Produces a $coll containing equally spaced values in some integer interval. + * + * @tparam A the element type of the $coll, which must have an `Integral` instance * @param start the start value of the $coll * @param end the end value of the $coll (the first value NOT contained) * @param step the difference between successive elements of the $coll (must be positive or negative) @@ -144,11 +147,13 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { /** * @tparam A the type of the ${coll}’s elements - * @return A builder for $Coll objects. + * @return a builder for $Coll objects. */ def newBuilder[A]: Builder[A, CC[A]] /** Produces a $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll * @param n the number of elements contained in the $coll. * @param elem the element computation * @return A $coll that contains the results of `n` evaluations of `elem`. @@ -156,6 +161,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { def fill[A](n: Int)(elem: => A): CC[A]^{elem} = from(new View.Fill(n)(elem)) /** Produces a two-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param elem the element computation @@ -164,6 +171,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { def fill[A](n1: Int, n2: Int)(elem: => A): CC[(CC[A]^{elem}) @uncheckedVariance]^{elem} = fill(n1)(fill(n2)(elem)) /** Produces a three-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -173,6 +182,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { def fill[A](n1: Int, n2: Int, n3: Int)(elem: => A): CC[(CC[CC[A]^{elem}]^{elem}) @uncheckedVariance]^{elem} = fill(n1)(fill(n2, n3)(elem)) /** Produces a four-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -184,6 +195,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { fill(n1)(fill(n2, n3, n4)(elem)) /** Produces a five-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -196,6 +209,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { fill(n1)(fill(n2, n3, n4, n5)(elem)) /** Produces a $coll containing values of a given function over a range of integer values starting from 0. + * + * @tparam A the element type of the $coll * @param n The number of elements in the $coll * @param f The function computing element values * @return A $coll consisting of elements `f(0), ..., f(n -1)` @@ -203,6 +218,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { def tabulate[A](n: Int)(f: Int => A): CC[A]^{f} = from(new View.Tabulate(n)(f)) /** Produces a two-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param f The function computing element values @@ -213,6 +230,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { tabulate(n1)(i1 => tabulate(n2)(f(i1, _))) /** Produces a three-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -224,6 +243,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { tabulate(n1)(i1 => tabulate(n2, n3)(f(i1, _, _))) /** Produces a four-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -236,6 +257,8 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { tabulate(n1)(i1 => tabulate(n2, n3, n4)(f(i1, _, _, _))) /** Produces a five-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -250,6 +273,7 @@ trait IterableFactory[+CC[_]] extends Serializable, caps.Pure { /** Concatenates all argument collections into a single $coll. * + * @tparam A the element type of the $coll * @param xss the collections that are to be concatenated. * @return the concatenation of all the collections. */ @@ -315,7 +339,7 @@ object SeqFactory { def lengthCompare(len: Int): Int = c.lengthCompare(len) def apply(i: Int): A = c(i) def drop(n: Int): scala.Seq[A] = c match { - case seq: scala.Seq[A] => seq.drop(n) + case seq: scala.Seq[A @unchecked] => seq.drop(n) case _ => c.view.drop(n).toSeq } def toSeq: scala.Seq[A] = c.toSeq @@ -382,22 +406,46 @@ trait SpecificIterableFactory[-A, +C] extends Factory[A, C] { * * @define coll collection * @define Coll `Iterable` + * + * @tparam CC Collection type constructor for the map (e.g. `Map`, `HashMap`) */ -trait MapFactory[+CC[_, _]] extends Serializable { self => +trait MapFactory[+CC[_, _]] extends Serializable { self: MapFactory[CC] => - /** An empty Map. */ + /** An empty Map. + * + * @tparam K the type of the keys + * @tparam V the type of the values + */ def empty[K, V]: CC[K, V] - /** A collection of type Map generated from given iterable object. */ + /** A collection of type Map generated from given iterable object. + * + * @tparam K the type of the keys + * @tparam V the type of the values + * @param it the source collection of key-value pairs + */ def from[K, V](it: IterableOnce[(K, V)]^): CC[K, V]^{it} - /** A collection of type Map that contains given key/value bindings. */ + /** A collection of type Map that contains given key/value bindings. + * + * @tparam K the type of the keys + * @tparam V the type of the values + * @param elems the key-value pairs to include in the map + */ def apply[K, V](elems: (K, V)*): CC[K, V] = from(elems) - /** The default builder for Map objects. */ + /** The default builder for Map objects. + * + * @tparam K the type of the keys + * @tparam V the type of the values + */ def newBuilder[K, V]: Builder[(K, V), CC[K, V]] - /** The default Factory instance for maps. */ + /** The default Factory instance for maps. + * + * @tparam K the type of the keys + * @tparam V the type of the values + */ implicit def mapFactory[K, V]: Factory[(K, V), CC[K, V]] = MapFactory.toFactory(this) } @@ -454,6 +502,8 @@ trait EvidenceIterableFactory[+CC[_], Ev[_]] extends Serializable, caps.Pure { def apply[A : Ev](xs: A*): CC[A] = from(xs) /** Produces a $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll, for which an implicit `Ev` instance must exist * @param n the number of elements contained in the $coll. * @param elem the element computation * @return A $coll that contains the results of `n` evaluations of `elem`. @@ -461,6 +511,8 @@ trait EvidenceIterableFactory[+CC[_], Ev[_]] extends Serializable, caps.Pure { def fill[A : Ev](n: Int)(elem: => A): CC[A] = from(new View.Fill(n)(elem)) /** Produces a $coll containing values of a given function over a range of integer values starting from 0. + * + * @tparam A the element type of the $coll, for which an implicit `Ev` instance must exist * @param n The number of elements in the $coll * @param f The function computing element values * @return A $coll consisting of elements `f(0), ..., f(n -1)` @@ -469,6 +521,7 @@ trait EvidenceIterableFactory[+CC[_], Ev[_]] extends Serializable, caps.Pure { /** Produces a $coll containing repeated applications of a function to a start value. * + * @tparam A the element type of the $coll, for which an implicit `Ev` instance must exist * @param start the start value of the $coll * @param len the number of elements contained in the $coll * @param f the function that's repeatedly applied @@ -547,6 +600,7 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT /** Produces a $coll containing a sequence of increasing of integers. * + * @tparam A the element type of the $coll, which must have `Integral` and `ClassTag` instances * @param start the first element of the $coll * @param end the end value of the $coll (the first value NOT contained) * @return a $coll with values `start, start + 1, ..., end - 1` @@ -554,6 +608,8 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT def range[A : Integral : ClassTag](start: A, end: A): CC[A] = from(NumericRange(start, end, implicitly[Integral[A]].one)) /** Produces a $coll containing equally spaced values in some integer interval. + * + * @tparam A the element type of the $coll, which must have `Integral` and `ClassTag` instances * @param start the start value of the $coll * @param end the end value of the $coll (the first value NOT contained) * @param step the difference between successive elements of the $coll (must be positive or negative) @@ -562,6 +618,8 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT def range[A : Integral : ClassTag](start: A, end: A, step: A): CC[A] = from(NumericRange(start, end, step)) /** Produces a two-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll, which must have a `ClassTag` * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param elem the element computation @@ -570,6 +628,8 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT def fill[A : ClassTag](n1: Int, n2: Int)(elem: => A): CC[CC[A] @uncheckedVariance] = fill(n1)(fill(n2)(elem)) /** Produces a three-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll, which must have a `ClassTag` * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -579,6 +639,8 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT def fill[A : ClassTag](n1: Int, n2: Int, n3: Int)(elem: => A): CC[CC[CC[A]] @uncheckedVariance] = fill(n1)(fill(n2, n3)(elem)) /** Produces a four-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll, which must have a `ClassTag` * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -590,6 +652,8 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT fill(n1)(fill(n2, n3, n4)(elem)) /** Produces a five-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll, which must have a `ClassTag` * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -602,6 +666,8 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT fill(n1)(fill(n2, n3, n4, n5)(elem)) /** Produces a two-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the $coll, which must have a `ClassTag` * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param f The function computing element values @@ -612,6 +678,8 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT tabulate(n1)(i1 => tabulate(n2)(f(i1, _))) /** Produces a three-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the $coll, which must have a `ClassTag` * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -623,6 +691,8 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT tabulate(n1)(i1 => tabulate(n2, n3)(f(i1, _, _))) /** Produces a four-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the $coll, which must have a `ClassTag` * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -635,6 +705,8 @@ trait ClassTagIterableFactory[+CC[_]] extends EvidenceIterableFactory[CC, ClassT tabulate(n1)(i1 => tabulate(n2, n3, n4)(f(i1, _, _, _))) /** Produces a five-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the $coll, which must have a `ClassTag` * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -654,7 +726,7 @@ object ClassTagIterableFactory { extends EvidenceIterableFactory.Delegate[CC, ClassTag](delegate) with ClassTagIterableFactory[CC] /** An IterableFactory that uses ClassTag.Any as the evidence for every element type. This may or may not be - * sound depending on the use of the `ClassTag` by the collection implementation. + * sound depending on the use of the `ClassTag` by the collection implementation. */ @SerialVersionUID(3L) class AnyIterableDelegate[CC[_]](delegate: ClassTagIterableFactory[CC]) extends IterableFactory[CC] { @@ -685,7 +757,7 @@ object ClassTagSeqFactory { extends ClassTagIterableFactory.Delegate[CC](delegate) with ClassTagSeqFactory[CC] /** A SeqFactory that uses ClassTag.Any as the evidence for every element type. This may or may not be - * sound depending on the use of the `ClassTag` by the collection implementation. + * sound depending on the use of the `ClassTag` by the collection implementation. */ @SerialVersionUID(3L) class AnySeqDelegate[CC[A] <: SeqOps[A, Seq, Seq[A]] & caps.Pure](delegate: ClassTagSeqFactory[CC]) @@ -724,6 +796,8 @@ trait StrictOptimizedClassTagSeqFactory[+CC[A] <: SeqOps[A, Seq, Seq[A]]] extend * * @define coll collection * @define Coll `Iterable` + * + * @tparam CC Collection type constructor for the sorted map (e.g. `TreeMap`) */ trait SortedMapFactory[+CC[_, _]] extends Serializable { this: SortedMapFactory[CC] => diff --git a/library/src/scala/collection/IndexedSeq.scala b/library/src/scala/collection/IndexedSeq.scala index fcf7053e1050..ff31b03267cb 100644 --- a/library/src/scala/collection/IndexedSeq.scala +++ b/library/src/scala/collection/IndexedSeq.scala @@ -21,7 +21,10 @@ import scala.collection.Searching.{Found, InsertionPoint, SearchResult} import scala.collection.Stepper.EfficientSplit import scala.math.Ordering -/** Base trait for indexed sequences that have efficient `apply` and `length`. */ +/** Base trait for indexed sequences that have efficient `apply` and `length`. + * + * @tparam A the element type of the indexed sequence + */ trait IndexedSeq[+A] extends Seq[A] with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]] with IterableFactoryDefaults[A, IndexedSeq] { @@ -34,7 +37,12 @@ trait IndexedSeq[+A] extends Seq[A] @SerialVersionUID(3L) object IndexedSeq extends SeqFactory.Delegate[IndexedSeq](immutable.IndexedSeq) -/** Base trait for indexed Seq operations. */ +/** Base trait for indexed Seq operations. + * + * @tparam A the element type of the sequence + * @tparam CC the type constructor for the resulting collection (e.g., `IndexedSeq`) + * @tparam C the type of the concrete collection + */ transparent trait IndexedSeqOps[+A, +CC[_], +C] extends Any with SeqOps[A, CC, C] { self: IndexedSeqOps[A, CC, C]^ => def iterator: Iterator[A]^{this} = view.iterator @@ -155,7 +163,11 @@ transparent trait IndexedSeqOps[+A, +CC[_], +C] extends Any with SeqOps[A, CC, C } } -/** A fast sliding iterator for IndexedSeqs which uses the underlying `slice` operation. */ +/** A fast sliding iterator for IndexedSeqs which uses the underlying `slice` operation. + * + * @tparam A the element type of the sequence + * @tparam CC the type constructor for the resulting collection (e.g., `IndexedSeq`) + */ private final class IndexedSeqSlidingIterator[A, CC[_], C](s: IndexedSeqOps[A, CC, C]^, size: Int, step: Int) extends AbstractIterator[C^{s}] { // CC note: seems like the compiler cannot figure out that this class <: Iterator[C^{s}], diff --git a/library/src/scala/collection/IndexedSeqView.scala b/library/src/scala/collection/IndexedSeqView.scala index db922425024c..879b8a5fff87 100644 --- a/library/src/scala/collection/IndexedSeqView.scala +++ b/library/src/scala/collection/IndexedSeqView.scala @@ -19,7 +19,10 @@ import language.experimental.captureChecking import scala.annotation.nowarn -/** View defined in terms of indexing a range. */ +/** View defined in terms of indexing a range. + * + * @tparam A the element type of the view + */ trait IndexedSeqView[+A] extends IndexedSeqOps[A, View, View[A]] with SeqView[A] { override def view: IndexedSeqView[A]^{this} = this @@ -162,7 +165,7 @@ object IndexedSeqView { @SerialVersionUID(3L) class Reverse[A](underlying: SomeIndexedSeqOps[A]^) extends SeqView.Reverse[A](underlying) with IndexedSeqView[A] { override def reverse: IndexedSeqView[A]^{this} = underlying match { - case x: IndexedSeqView[A] => x + case x: IndexedSeqView[A @unchecked] => x case _ => super.reverse } } diff --git a/library/src/scala/collection/Iterable.scala b/library/src/scala/collection/Iterable.scala index 61395463e7fa..bc30faee5bdc 100644 --- a/library/src/scala/collection/Iterable.scala +++ b/library/src/scala/collection/Iterable.scala @@ -66,6 +66,8 @@ trait Iterable[+A] extends IterableOnce[A] * published, but provides the exclusive access needed by * `scala.runtime.ScalaRunTime.stringOf` (and a few tests in * the test suite). + * + * @return the class name of this collection, as returned by `className` */ private[scala] final def collectionClassName: String = className @@ -113,6 +115,7 @@ trait Iterable[+A] extends IterableOnce[A] * with a different type of element `B` (e.g. `map`) return a `CC[B]`. * @tparam C type of the collection (e.g. `List[Int]`, `String`, `BitSet`). Operations returning a collection * with the same type of element (e.g. `drop`, `filter`) return a `C`. + * @tparam A the element type of the collection * * @define Coll Iterable * @define coll iterable collection @@ -175,6 +178,9 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w * might be unsound. However, as long as it is called with an * `Iterable[A]` obtained from `this` collection (as it is the case in the * implementations of operations where we use a `View[A]`), it is safe. + * + * @param coll the source collection to convert + * @return a new collection of type `C` containing the elements of `coll` */ protected def fromSpecific(coll: IterableOnce[A @uncheckedVariance]^): C^{coll} @@ -183,6 +189,8 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w * @note When implementing a custom collection type and refining `CC` to the new type, this * method needs to be overridden to return a factory for the new type (the compiler will * issue an error otherwise). + * + * @return the companion factory object for this collection type */ def iterableFactory: IterableFactory[CC] @@ -303,6 +311,8 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w * this.sizeIs >= size // this.sizeCompare(size) >= 0 * this.sizeIs > size // this.sizeCompare(size) > 0 * ``` + * + * @return a wrapper that allows size comparisons using operators such as `<`, `<=`, `==`, `!=`, `>=`, and `>` */ @inline final def sizeIs: IterableOps.SizeCompareOps^{this} = new IterableOps.SizeCompareOps(caps.unsafe.unsafeAssumePure(this) /* see comment in SizeCompareOps*/) @@ -430,6 +440,9 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w * The default implementation provided here needs to traverse the collection twice. * Strict collections have an overridden version of `partition` in `StrictOptimizedIterableOps`, * which requires only a single traversal. + * + * @param p the predicate used to test elements + * @return a pair of ${coll}s: the first containing all elements that satisfy `p`, the second containing those that do not */ def partition(p: A => Boolean): (C^{this, p}, C^{this, p}) = { val first = new View.Filter(this, p, isFlipped = false) @@ -592,6 +605,7 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w * @tparam B the type of values returned by the transformation function * @param key the discriminator function * @param f the element transformation function + * @return a map associating each key `k` produced by `key` with a $coll of values produced by applying `f` to elements that map to `k` */ def groupMap[K, B](key: A => K)(f: A => B): immutable.Map[K, CC[B]] = { val m = mutable.Map.empty[K, Builder[B, CC[B]]] @@ -622,6 +636,12 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w * ``` * * $willForceEvaluation + * + * @tparam K the type of keys returned by the discriminator function + * @tparam B the type of values returned by the transformation function + * @param key the discriminator function + * @param f the element transformation function + * @param reduce the reduction function used to combine values mapped to the same key */ def groupMapReduce[K, B](key: A => K)(f: A => B)(reduce: (B, B) => B): immutable.Map[K, B] = { val m = mutable.Map.empty[K, B] @@ -728,12 +748,16 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w */ def concat[B >: A](suffix: IterableOnce[B]^): CC[B]^{this, suffix} = iterableFactory.from { suffix match { - case suffix: Iterable[B] => new View.Concat(this, suffix) + case suffix: Iterable[B @unchecked] => new View.Concat(this, suffix) case suffix => iterator ++ suffix.iterator } } - /** Alias for `concat`. */ + /** Alias for `concat`. + * + * @tparam B the element type of the returned collection + * @param suffix the iterable to append to this $coll + */ @inline final def ++ [B >: A](suffix: IterableOnce[B]^): CC[B]^{this, suffix} = concat(suffix) /** Returns a $ccoll formed from this $coll and another iterable collection @@ -746,7 +770,7 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w * The length of the returned collection is the minimum of the lengths of this $coll and `that`. */ def zip[B](that: IterableOnce[B]^): CC[(A @uncheckedVariance, B)]^{this, that} = iterableFactory.from(that match { // sound bcs of VarianceNote - case that: Iterable[B] => new View.Zip(this, that) + case that: Iterable[B @unchecked] => new View.Zip(this, that) case _ => iterator.zip(that) }) @@ -757,6 +781,8 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w * If one of the two collections is shorter than the other, * placeholder elements are used to extend the shorter collection to the length of the longer. * + * @tparam A1 the type of the first element in each result pair (supertype of `A`) + * @tparam B the type of the second element in each result pair * @param that the iterable providing the second half of each result pair * @param thisElem the element to be used to fill up the result if this $coll is shorter than `that`. * @param thatElem the element to be used to fill up the result if `that` is shorter than this $coll. @@ -849,12 +875,12 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w // `this.tail.tail` doesn't compile as `C` is unbounded // `Iterable.from(this)` would eagerly copy non-immutable collections val it = Iterator.iterate(toIterable: @nowarn("cat=deprecation"))(f).takeWhile(_.nonEmpty) - (it ++ Iterator.single(Iterable.empty)).map(fromSpecific) + (it ++ Iterator.single(Iterable.empty: Iterable[A]^{this})).map(fromSpecific) } @deprecated("Use ++ instead of ++: for collections of type Iterable", "2.13.0") def ++:[B >: A](that: IterableOnce[B]^): CC[B]^{this, that} = iterableFactory.from(that match { - case xs: Iterable[B] => new View.Concat(xs, this) + case xs: Iterable[B @unchecked] => new View.Concat(xs, this) case _ => that.iterator ++ iterator }) } @@ -874,7 +900,10 @@ object IterableOps { // is pending/pos-custom-args/captures/SizeCompareOps-redux.scala. // Without the `^`s, the `sizeIs` method needs an unsafeAssumePure. - /** Tests if the size of the collection is less than some value. */ + /** Tests if the size of the collection is less than some value. + * + * @param size the value to compare the collection size against + */ @inline def <(size: Int): Boolean = it.sizeCompare(size) < 0 /** Tests if the size of the collection is less than or equal to some value. */ @inline def <=(size: Int): Boolean = it.sizeCompare(size) <= 0 @@ -884,7 +913,10 @@ object IterableOps { @inline def !=(size: Int): Boolean = it.sizeCompare(size) != 0 /** Tests if the size of the collection is greater than or equal to some value. */ @inline def >=(size: Int): Boolean = it.sizeCompare(size) >= 0 - /** Tests if the size of the collection is greater than some value. */ + /** Tests if the size of the collection is greater than some value. + * + * @param size the value to compare the collection size against + */ @inline def >(size: Int): Boolean = it.sizeCompare(size) > 0 } @@ -940,7 +972,10 @@ object Iterable extends IterableFactory.Delegate[Iterable](immutable.Iterable) { } } -/** Explicit instantiation of the `Iterable` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Iterable` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the collection + */ abstract class AbstractIterable[+A] extends Iterable[A] /** This trait provides default implementations for the factory methods `fromSpecific` and @@ -949,6 +984,9 @@ abstract class AbstractIterable[+A] extends Iterable[A] * * The default implementations in this trait can be used in the common case when `CC[A]` is the * same as `C`. + * + * @tparam A the element type of the collection + * @tparam CC the type constructor of the collection */ trait IterableFactoryDefaults[+A, +CC[x] <: IterableOps[x, CC, CC[x]]] extends IterableOps[A, CC, CC[A @uncheckedVariance]] { protected def fromSpecific(coll: IterableOnce[A @uncheckedVariance]^): CC[A @uncheckedVariance]^{coll} = iterableFactory.from(coll) @@ -965,6 +1003,9 @@ trait IterableFactoryDefaults[+A, +CC[x] <: IterableOps[x, CC, CC[x]]] extends I * * The default implementations in this trait can be used in the common case when `CC[A]` is the * same as `C`. + * + * @tparam A the element type of the collection + * @tparam CC the type constructor of the collection */ trait EvidenceIterableFactoryDefaults[+A, +CC[x] <: IterableOps[x, CC, CC[x]], Ev[_]] extends IterableOps[A, CC, CC[A @uncheckedVariance]] { protected def evidenceIterableFactory: EvidenceIterableFactory[CC, Ev] @@ -985,6 +1026,9 @@ trait EvidenceIterableFactoryDefaults[+A, +CC[x] <: IterableOps[x, CC, CC[x]], E * * The default implementations in this trait can be used in the common case when `CC[A]` is the * same as `C`. + * + * @tparam A the element type of the sorted set + * @tparam CC the type constructor of the sorted set */ trait SortedSetFactoryDefaults[+A, +CC[X] <: SortedSet[X] & SortedSetOps[X, CC, CC[X]], @@ -1011,6 +1055,10 @@ trait SortedSetFactoryDefaults[+A, * * The default implementations in this trait can be used in the common case when `CC[A]` is the * same as `C`. + * + * @tparam K the type of keys in the map + * @tparam V the type of values in the map + * @tparam CC the type constructor of the map */ trait MapFactoryDefaults[K, +V, +CC[x, y] <: IterableOps[(x, y), Iterable, Iterable[(x, y)]], @@ -1039,6 +1087,10 @@ trait MapFactoryDefaults[K, +V, * * The default implementations in this trait can be used in the common case when `CC[A]` is the * same as `C`. + * + * @tparam K the type of keys in the sorted map + * @tparam V the type of values in the sorted map + * @tparam CC the type constructor of the sorted map */ trait SortedMapFactoryDefaults[K, +V, +CC[x, y] <: Map[x, y] & SortedMapOps[x, y, CC, CC[x, y]] & UnsortedCC[x, y], diff --git a/library/src/scala/collection/IterableOnce.scala b/library/src/scala/collection/IterableOnce.scala index 4f6b988ff53a..d23631ba62f3 100644 --- a/library/src/scala/collection/IterableOnce.scala +++ b/library/src/scala/collection/IterableOnce.scala @@ -31,12 +31,12 @@ import IterableOnce.elemsToCopyToArray * * Note: `IterableOnce` does not extend [[IterableOnceOps]]. This is different than the general * design of the collections library, which uses the following pattern: - * ``` - * trait Seq extends Iterable with SeqOps - * trait SeqOps extends IterableOps + * ```scala sc:compile + * transparent trait SeqOps[+A, +CC[_], +C] extends Any + * trait Seq[+A] extends Iterable[A] with SeqOps[A, Seq, Seq[A]] * - * trait IndexedSeq extends Seq with IndexedSeqOps - * trait IndexedSeqOps extends SeqOps + * transparent trait IndexedSeqOps[+A, +CC[_], +C] extends Any with SeqOps[A, CC, C] + * trait IndexedSeq[+A] extends Seq[A] with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]] * ``` * * The goal is to provide a minimal interface without any sequential operations. This allows @@ -45,6 +45,8 @@ import IterableOnce.elemsToCopyToArray * * @define coll collection * @define ccoll $coll + * + * @tparam A the element type of the collection */ trait IterableOnce[+A] extends Any { this: IterableOnce[A]^ => @@ -53,6 +55,8 @@ trait IterableOnce[+A] extends Any { this: IterableOnce[A]^ => * If an `IterableOnce` object is in fact an [[scala.collection.Iterator]], this method always returns itself, * in its current state, but if it is an [[scala.collection.Iterable]], this method always returns a new * [[scala.collection.Iterator]]. + * + * @return an iterator over all elements of this $coll */ def iterator: Iterator[A]^{this} @@ -75,6 +79,8 @@ trait IterableOnce[+A] extends Any { this: IterableOnce[A]^ => * [[scala.collection.Stepper.EfficientSplit]], the converters in [[scala.jdk.StreamConverters]] * allow creating parallel streams, whereas bare `Stepper`s can be converted only to sequential * streams. + * + * @tparam S the type of the returned `Stepper`, determined by the implicit `StepperShape` */ def stepper[S <: Stepper[?]](implicit shape: StepperShape[A, S]): S^{this} = { import convert.impl._ @@ -162,7 +168,7 @@ final class IterableOnceExtensionMethods[A](private val it: IterableOnce[A]) ext @deprecated("Use .iterator.foreach(...) instead", "2.13.0") @`inline` def foreach[U](f: A => U): Unit = it match { - case it: Iterable[A] => it.foreach(f) + case it: Iterable[A @unchecked] => it.foreach(f) case _ => it.iterator.foreach(f) } @@ -174,7 +180,7 @@ final class IterableOnceExtensionMethods[A](private val it: IterableOnce[A]) ext @deprecated("Use .iterator.toArray", "2.13.0") def toArray[B >: A: ClassTag]: Array[B] = it match { - case it: Iterable[B] => it.toArray[B] + case it: Iterable[B @unchecked] => it.toArray[B] case _ => it.iterator.toArray[B] } @@ -208,25 +214,25 @@ final class IterableOnceExtensionMethods[A](private val it: IterableOnce[A]) ext @deprecated("Use .iterator.isEmpty instead", "2.13.0") def isEmpty: Boolean = it match { - case it: Iterable[A] => it.isEmpty + case it: Iterable[A @unchecked] => it.isEmpty case _ => it.iterator.isEmpty } @deprecated("Use .iterator.mkString instead", "2.13.0") def mkString(start: String, sep: String, end: String): String = it match { - case it: Iterable[A] => it.mkString(start, sep, end) + case it: Iterable[A @unchecked] => it.mkString(start, sep, end) case _ => it.iterator.mkString(start, sep, end) } @deprecated("Use .iterator.mkString instead", "2.13.0") def mkString(sep: String): String = it match { - case it: Iterable[A] => it.mkString(sep) + case it: Iterable[A @unchecked] => it.mkString(sep) case _ => it.iterator.mkString(sep) } @deprecated("Use .iterator.mkString instead", "2.13.0") def mkString: String = it match { - case it: Iterable[A] => it.mkString + case it: Iterable[A @unchecked] => it.mkString case _ => it.iterator.mkString } @@ -250,13 +256,13 @@ final class IterableOnceExtensionMethods[A](private val it: IterableOnce[A]) ext @deprecated("Use .iterator.map instead or consider requiring an Iterable", "2.13.0") def map[B](f: A => B): IterableOnce[B]^{f} = it match { - case it: Iterable[A]^{f} => it.map(f) + case it: Iterable[A @unchecked]^{f} => it.map(f) case _ => it.iterator.map(f) } @deprecated("Use .iterator.flatMap instead or consider requiring an Iterable", "2.13.0") def flatMap[B](f: A => IterableOnce[B]^): IterableOnce[B]^{f} = it match { - case it: Iterable[A] => it.flatMap(f) + case it: Iterable[A @unchecked] => it.flatMap(f) case _ => it.iterator.flatMap(f) } @@ -288,13 +294,17 @@ object IterableOnce { math.max(0, total) } - /** Calls `copyToArray` on the given collection, regardless of whether or not it is an `Iterable`. */ + /** Calls `copyToArray` on the given collection, regardless of whether or not it is an `Iterable`. + * + * @tparam A the element type of the source collection + * @tparam B the element type of the destination array, a supertype of `A` + */ @inline private[collection] def copyElemsToArray[A, B >: A](elems: IterableOnce[A]^, xs: Array[B], start: Int = 0, len: Int = Int.MaxValue): Int = elems match { - case src: Iterable[A] => src.copyToArray[B](xs, start, len) + case src: Iterable[A @unchecked] => src.copyToArray[B](xs, start, len) case src => src.iterator.copyToArray[B](xs, start, len) } } @@ -332,6 +342,9 @@ object IterableOnce { * The order of applications of the operator is unspecified and may be nondeterministic. * @define exactlyOnce * Each element appears exactly once in the computation. + * + * @tparam A the element type of the collection + * @tparam CC the type constructor for the collection's "same element type" results (e.g., `List` for `List[Int]`) */ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A]^ => /////////////////////////////////////////////////////////////// Abstract methods that must be implemented @@ -383,12 +396,9 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn * * Example: * - * ``` - * scala> List(1, 2, 3, 100, 4).takeWhile(n => n < 10) - * val res0: List[Int] = List(1, 2, 3) - * - * scala> List(1, 2, 3, 100, 4).takeWhile(n => n == 0) - * val res1: List[Int] = List() + * ```scala sc:compile + * List(1, 2, 3, 100, 4).takeWhile(n => n < 10) // List(1, 2, 3) + * List(1, 2, 3, 100, 4).takeWhile(n => n == 0) // List() * ``` * * Use [[span]] to obtain both the prefix and suffix. @@ -418,12 +428,9 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn * * Example: * - * ``` - * scala> List(1, 2, 3, 100, 4).dropWhile(n => n < 10) - * val res0: List[Int] = List(100, 4) - * - * scala> List(1, 2, 3, 100, 4).dropWhile(n => n == 0) - * val res1: List[Int] = List(1, 2, 3, 100, 4) + * ```scala sc:compile + * List(1, 2, 3, 100, 4).dropWhile(n => n < 10) // List(100, 4) + * List(1, 2, 3, 100, 4).dropWhile(n => n == 0) // List(1, 2, 3, 100, 4) * ``` * * Use [[span]] to obtain both the prefix and suffix. @@ -467,19 +474,19 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn * * For example: * - * ``` + * ```scala sc:compile * def getWords(lines: Seq[String]): Seq[String] = lines.flatMap(line => line.split("\\W+")) * ``` * * The type of the resulting collection is guided by the static type of this $coll. This might * cause unexpected results sometimes. For example: * - * ``` + * ```scala sc:compile * // lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set * def lettersOf(words: Seq[String]) = words.flatMap(word => word.toSet) * - * // lettersOf will return a Set[Char], not a Seq - * def lettersOf(words: Seq[String]) = words.toSet.flatMap(word => word.toSeq) + * // lettersOf2 will return a Set[Char], not a Seq + * def lettersOf2(words: Seq[String]) = words.toSet.flatMap(word => word.toSeq) * * // xs will be an Iterable[Int] * val xs = Map("a" -> List(11, 111), "b" -> List(22, 222)).flatMap(_._2) @@ -501,7 +508,7 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn * The resulting collection's type will be guided by the * type of $coll. For example: * - * ``` + * ```scala sc:compile * val xs = List( * Set(1, 2, 3), * Set(1, 2, 3) @@ -626,6 +633,9 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn /** Applies `f` to each element for its side effects. * Note: `U` parameter needed to help scalac's type inference. + * + * @tparam U the return type of `f`; the value is discarded, but the type parameter aids type inference + * @param f the function to apply to each element for its side effects */ def foreach[U](f: A => U): Unit = { val it = iterator @@ -1264,6 +1274,7 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn * $mayNotTerminateInf * $orderDependent * + * @tparam B the result type of the partial function * @param pf the partial function * @return an option value containing pf applied to the first * value for which it is defined, or `None` if none exists. @@ -1372,15 +1383,10 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn * * Example: * - * ``` - * scala> val a = List(1,2,3,4) - * a: List[Int] = List(1, 2, 3, 4) - * - * scala> val b = new StringBuilder() - * b: StringBuilder = - * - * scala> a.addString(b , "List(" , ", " , ")") - * res5: StringBuilder = List(1, 2, 3, 4) + * ```scala sc:compile + * val a = List(1,2,3,4) // List(1, 2, 3, 4) + * val b = new StringBuilder() + * a.addString(b , "List(" , ", " , ")") // List(1, 2, 3, 4) * ``` * * @param b the string builder to which elements are appended. @@ -1410,15 +1416,10 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn * * Example: * - * ``` - * scala> val a = List(1,2,3,4) - * a: List[Int] = List(1, 2, 3, 4) - * - * scala> val b = new StringBuilder() - * b: StringBuilder = - * - * scala> a.addString(b, ", ") - * res0: StringBuilder = 1, 2, 3, 4 + * ```scala sc:compile + * val a = List(1,2,3,4) // List(1, 2, 3, 4) + * val b = new StringBuilder() + * a.addString(b, ", ") // 1, 2, 3, 4 * ``` * * @param b the string builder to which elements are appended. @@ -1433,15 +1434,10 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn * * Example: * - * ``` - * scala> val a = List(1,2,3,4) - * a: List[Int] = List(1, 2, 3, 4) - * - * scala> val b = new StringBuilder() - * b: StringBuilder = - * - * scala> val h = a.addString(b) - * h: StringBuilder = 1234 + * ```scala sc:compile + * val a = List(1,2,3,4) // List(1, 2, 3, 4) + * val b = new StringBuilder() + * val h = a.addString(b) // 1234 * ``` * * @param b the string builder to which elements are appended. @@ -1452,11 +1448,21 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn /** Given a collection factory `factory`, converts this $coll to the appropriate * representation for the current element type `A`. Example uses: * + * ```scala sc-name:import-and-xs sc-hidden + * import scala.collection.mutable.ArrayBuffer + * import scala.collection.immutable.BitSet + * val xs: Iterable[Int] = Seq(1, 2, 3, 4, 5) * ``` + * + * ```scala sc-compile-with:import-and-xs * xs.to(List) * xs.to(ArrayBuffer) * xs.to(BitSet) // for xs: Iterable[Int] * ``` + * + * @tparam C1 the target collection type + * @param factory the factory for the target collection type + * @return a new collection of type `C1` containing all elements of this $coll */ def to[C1](factory: Factory[A, C1]): C1^{this} = factory.fromSpecific(this) @@ -1479,7 +1485,7 @@ transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOn * * @tparam K The key type for the resulting map. * @tparam V The value type for the resulting map. - * @param ev An implicit coercion from `A` to `[K, V]`. + * @param ev an implicit evidence that `A` is a subtype of `(K, V)` * @return This $coll as a `Map[K, V]`. */ def toMap[K, V](implicit ev: A <:< (K, V)): immutable.Map[K, V] = diff --git a/library/src/scala/collection/Iterator.scala b/library/src/scala/collection/Iterator.scala index a0af8cd7da9d..a5cbe06e850d 100644 --- a/library/src/scala/collection/Iterator.scala +++ b/library/src/scala/collection/Iterator.scala @@ -41,7 +41,7 @@ import caps.unsafe.untrackedCaptures * * Consider this example for safe and unsafe use: * - * ``` + * ```scala sc:compile * def f[A](it: Iterator[A]) = { * if (it.hasNext) { // Safe to reuse "it" after "hasNext" * it.next() // Safe to reuse "it" after "next" @@ -74,6 +74,8 @@ import caps.unsafe.untrackedCaptures * is undefined, subject to change, and may result in changes to the new * iterators as well. * @define coll iterator + * + * @tparam A the element type of the iterator */ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Iterator[A]] { self: Iterator[A]^ => @@ -157,6 +159,11 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite * * A `GroupedIterator` is yielded by `grouped` and by `sliding`, * where the `step` may differ from the group `size`. + * + * @tparam B the element type of the sequences produced by the grouped iterator, a supertype of `A` + * @param self the underlying iterator to group + * @param size the number of elements per group + * @param step the distance between the first elements of successive groups */ class GroupedIterator[B >: A](self: Iterator[B]^, size: Int, step: Int) extends AbstractIterator[immutable.Seq[B]] { @@ -226,6 +233,8 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite * If unable to deliver size, then pad if padding enabled, otherwise drop segment. * Returns true if successful in delivering `count` elements, * or padded segment, or partial segment. + * + * @return `true` if a segment was successfully buffered, `false` otherwise */ private def fulfill(): Boolean = { val builder = newBuilder @@ -346,6 +355,9 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite * ``` * * @note Reuse: $consumesAndProducesIterator + * + * @tparam B the element type of the sequences produced by the grouped iterator, a supertype of `A` + * @param size the number of elements per group */ def grouped[B >: A](size: Int): GroupedIterator[B]^{this} = new GroupedIterator[B](self, size, size) @@ -373,6 +385,7 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite * (1 to 5).iterator.sliding(4, 3).withPadding(it2.next).toList * ``` * + * @tparam B the element type of the sequences produced by the grouped iterator, a supertype of `A` * @param size the number of elements per group * @param step the distance between the first elements of successive * groups @@ -444,6 +457,7 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite * object in this iterable object. * $mayNotTerminateInf * + * @tparam B the type of the element to search for, a supertype of `A` * @param elem element to search for. * @return the index of the first occurrence of `elem` in the values produced by this iterator, * or -1 if such an element does not exist until the end of the iterator is reached. @@ -455,6 +469,7 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite * after or at some start index. * $mayNotTerminateInf * + * @tparam B the type of the element to search for, a supertype of `A` * @param elem element to search for. * @param from the start index * @return the index `>= from` of the first occurrence of `elem` in the values produced by this @@ -692,6 +707,8 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite /** @inheritdoc * * @note Reuse: $consumesOneAndProducesTwoIterators + * + * @param p the predicate used to partition elements into the leading and trailing iterators */ def span(p: A => Boolean): (Iterator[A]^{this, p}, Iterator[A]^{this, p}) = { /* @@ -794,7 +811,11 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite def slice(from: Int, until: Int): Iterator[A]^{this} = sliceIterator(from, until max 0) - /** Creates an optionally bounded slice, unbounded if `until` is negative. */ + /** Creates an optionally bounded slice, unbounded if `until` is negative. + * + * @param from the index of the first element in the slice + * @param until the index of the first element following the slice, or negative for unbounded + */ protected def sliceIterator(from: Int, until: Int): Iterator[A]^{this} = { val lo = from max 0 val rest = @@ -910,6 +931,7 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite * Patching at indices at or larger than the length of the original iterator appends the patch to the end. * If more values are replaced than actually exist, the excess is ignored. * + * @tparam B the element type of the returned iterator, a supertype of `A` * @param from The start index from which to patch * @param patchElems The iterator of patch values * @param replaced The number of values in the original iterator that are replaced by the patch. @@ -999,7 +1021,10 @@ object Iterator extends IterableFactory[Iterator] { */ override def from[A](source: IterableOnce[A]^): Iterator[A]^{source} = source.iterator - /** The iterator which produces no values. */ + /** The iterator which produces no values. + * + * @tparam T the element type of the empty iterator + */ @`inline` final def empty[T]: Iterator[T] = _empty def single[A](a: A): Iterator[A] = new AbstractIterator[A] { @@ -1024,6 +1049,7 @@ object Iterator extends IterableFactory[Iterator] { /** Creates iterator that produces the results of some element computation a number of times. * + * @tparam A the element type of the iterator * @param len the number of elements returned by the iterator. * @param elem the element computation * @return An iterator that produces the results of `n` evaluations of `elem`. @@ -1039,6 +1065,7 @@ object Iterator extends IterableFactory[Iterator] { /** Creates an iterator producing the values of a given function over a range of integer values starting from 0. * + * @tparam A the element type of the iterator * @param end The number of elements returned by the iterator * @param f The function computing element values * @return An iterator that produces the values `f(0), ..., f(n -1)`. @@ -1111,6 +1138,7 @@ object Iterator extends IterableFactory[Iterator] { /** Creates an infinite iterator that repeatedly applies a given function to the previous result. * + * @tparam T the element type of the iterator * @param start the start value of the iterator * @param f the function that's repeatedly applied * @return the iterator producing the infinite sequence of values `start, f(start), f(f(start)), ...` @@ -1142,6 +1170,7 @@ object Iterator extends IterableFactory[Iterator] { /** Creates an infinite-length iterator returning the results of evaluating an expression. * The expression is recomputed for every element. * + * @tparam A the element type of the iterator * @param elem the element computation. * @return the iterator containing an infinite number of results of evaluating `elem`. */ @@ -1152,6 +1181,9 @@ object Iterator extends IterableFactory[Iterator] { /** Creates an iterator to which other iterators can be appended efficiently. * Nested ConcatIterators are merged to avoid blowing the stack. + * + * @tparam A the element type of the iterator + * @param from the initial iterator to concatenate, or `null` if starting empty */ private final class ConcatIterator[+A](val from: (Iterator[A @uncheckedVariance]^) | Null) extends AbstractIterator[A] { @annotation.stableNull @@ -1234,6 +1266,11 @@ object Iterator extends IterableFactory[Iterator] { /** Creates a delegating iterator capped by a limit count. Negative limit means unbounded. * Lazily skip to start on first evaluation. Avoids daisy-chained iterators due to slicing. + * + * @tparam A the element type of the iterator + * @param underlying the source iterator to slice + * @param start the number of leading elements to drop + * @param limit the maximum number of elements to return, or negative for unbounded */ private[scala] final class SliceIterator[A](val underlying: Iterator[A]^, start: Int, limit: Int) extends AbstractIterator[A] { private var remaining = limit @@ -1293,6 +1330,10 @@ object Iterator extends IterableFactory[Iterator] { /** Creates an iterator that uses a function `f` to produce elements of * type `A` and update an internal state of type `S`. + * + * @tparam A the element type produced by the iterator + * @tparam S the type of the internal state + * @param init the initial state value */ private final class UnfoldIterator[A, S](init: S)(f: S => Option[(A, S)]) extends AbstractIterator[A] { private var state: S = init @@ -1321,5 +1362,8 @@ object Iterator extends IterableFactory[Iterator] { } } -/** Explicit instantiation of the `Iterator` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Iterator` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the iterator + */ abstract class AbstractIterator[+A] extends Iterator[A] diff --git a/library/src/scala/collection/JavaConverters.scala b/library/src/scala/collection/JavaConverters.scala index 90de8dc9a159..baa5173c3ef7 100644 --- a/library/src/scala/collection/JavaConverters.scala +++ b/library/src/scala/collection/JavaConverters.scala @@ -55,8 +55,10 @@ import scala.language.implicitConversions * ``` * In all cases, converting from a source type to a target type and back * again will return the original source object. For example: - * ``` + ```scala sc-hidden sc-name:import-java-converters * import scala.collection.JavaConverters._ + * ``` + * ```scala sc-compile-with:import-java-converters * * val source = new scala.collection.mutable.ListBuffer[Int] * val target: java.util.List[Int] = source.asJava @@ -64,18 +66,15 @@ import scala.language.implicitConversions * assert(source eq other) * ``` * Alternatively, the conversion methods have descriptive names and can be invoked explicitly. - * ``` - * scala> val vs = java.util.Arrays.asList("hi", "bye") - * vs: java.util.List[String] = [hi, bye] - * - * scala> val ss = asScalaIterator(vs.iterator) - * ss: Iterator[String] = - * - * scala> .toList - * res0: List[String] = List(hi, bye) - * - * scala> val ss = asScalaBuffer(vs) - * ss: scala.collection.mutable.Buffer[String] = Buffer(hi, bye) + * ```scala sc-compile-with:import-java-converters + * val vs = java.util.Arrays.asList("hi", "bye") + * // vs: java.util.List[String] = [hi, bye] + * val ss = asScalaIterator(vs.iterator) + * // ss: Iterator[String] = + * ss.toList + * // res0: List[String] = List(hi, bye) + * val ss2 = asScalaBuffer(vs) + * // ss2: scala.collection.mutable.Buffer[String] = Buffer(hi, bye) * ``` */ @deprecated("Use `scala.jdk.CollectionConverters` instead", "2.13.0") @@ -145,78 +144,121 @@ object JavaConverters extends AsJavaConverters with AsScalaConverters { /** Adds an `asJava` method that implicitly converts a Scala `Iterator` to a Java `Iterator`. * @see [[asJavaIterator]] + * + * @tparam A the element type of the iterator + * @param i the Scala `Iterator` to be converted */ implicit def asJavaIteratorConverter[A](i : Iterator[A]): AsJava[ju.Iterator[A]] = new AsJava(asJavaIterator(i)) /** Adds an `asJavaEnumeration` method that implicitly converts a Scala `Iterator` to a Java `Enumeration`. * @see [[asJavaEnumeration]] + * + * @tparam A the element type of the iterator + * @param i the Scala `Iterator` to be converted */ implicit def asJavaEnumerationConverter[A](i : Iterator[A]): AsJavaEnumeration[A] = new AsJavaEnumeration(i) /** Adds an `asJava` method that implicitly converts a Scala `Iterable` to a Java `Iterable`. * @see [[asJavaIterable]] + * + * @tparam A the element type of the iterable + * @param i the Scala `Iterable` to be converted */ implicit def asJavaIterableConverter[A](i : Iterable[A]): AsJava[jl.Iterable[A]] = new AsJava(asJavaIterable(i)) /** Adds an `asJavaCollection` method that implicitly converts a Scala `Iterable` to an immutable Java `Collection`. * @see [[asJavaCollection]] + * + * @tparam A the element type of the iterable + * @param i the Scala `Iterable` to be converted */ implicit def asJavaCollectionConverter[A](i : Iterable[A]): AsJavaCollection[A] = new AsJavaCollection(i) /** Adds an `asJava` method that implicitly converts a Scala mutable `Buffer` to a Java `List`. * @see [[bufferAsJavaList]] + * + * @tparam A the element type of the buffer + * @param b the Scala mutable `Buffer` to be converted */ implicit def bufferAsJavaListConverter[A](b : mutable.Buffer[A]): AsJava[ju.List[A]] = new AsJava(bufferAsJavaList(b)) /** Adds an `asJava` method that implicitly converts a Scala mutable `Seq` to a Java `List`. * @see [[mutableSeqAsJavaList]] + * + * @tparam A the element type of the sequence + * @param b the Scala mutable `Seq` to be converted */ implicit def mutableSeqAsJavaListConverter[A](b : mutable.Seq[A]): AsJava[ju.List[A]] = new AsJava(mutableSeqAsJavaList(b)) /** Adds an `asJava` method that implicitly converts a Scala `Seq` to a Java `List`. * @see [[seqAsJavaList]] + * + * @tparam A the element type of the sequence + * @param b the Scala `Seq` to be converted */ implicit def seqAsJavaListConverter[A](b : Seq[A]): AsJava[ju.List[A]] = new AsJava(seqAsJavaList(b)) /** Adds an `asJava` method that implicitly converts a Scala mutable `Set` to a Java `Set`. * @see [[mutableSetAsJavaSet]] + * + * @tparam A the element type of the set + * @param s the Scala mutable `Set` to be converted */ implicit def mutableSetAsJavaSetConverter[A](s : mutable.Set[A]): AsJava[ju.Set[A]] = new AsJava(mutableSetAsJavaSet(s)) /** Adds an `asJava` method that implicitly converts a Scala `Set` to a Java `Set`. * @see [[setAsJavaSet]] + * + * @tparam A the element type of the set + * @param s the Scala `Set` to be converted */ implicit def setAsJavaSetConverter[A](s : Set[A]): AsJava[ju.Set[A]] = new AsJava(setAsJavaSet(s)) /** Adds an `asJava` method that implicitly converts a Scala mutable `Map` to a Java `Map`. * @see [[mutableMapAsJavaMap]] + * + * @tparam K the type of the map keys + * @tparam V the type of the map values + * @param m the Scala mutable `Map` to be converted */ implicit def mutableMapAsJavaMapConverter[K, V](m : mutable.Map[K, V]): AsJava[ju.Map[K, V]] = new AsJava(mutableMapAsJavaMap(m)) /** Adds an `asJavaDictionary` method that implicitly converts a Scala mutable `Map` to a Java `Dictionary`. * @see [[asJavaDictionary]] + * + * @tparam K the type of the map keys + * @tparam V the type of the map values + * @param m the Scala mutable `Map` to be converted */ implicit def asJavaDictionaryConverter[K, V](m : mutable.Map[K, V]): AsJavaDictionary[K, V] = new AsJavaDictionary(m) /** Adds an `asJava` method that implicitly converts a Scala `Map` to a Java `Map`. * @see [[mapAsJavaMap]] + * + * @tparam K the type of the map keys + * @tparam V the type of the map values + * @param m the Scala `Map` to be converted */ implicit def mapAsJavaMapConverter[K, V](m : Map[K, V]): AsJava[ju.Map[K, V]] = new AsJava(mapAsJavaMap(m)) /** Adds an `asJava` method that implicitly converts a Scala mutable `concurrent.Map` to a Java `ConcurrentMap`. * @see [[mapAsJavaConcurrentMap]]. + * + * @tparam K the type of the map keys + * @tparam V the type of the map values + * @param m the Scala `concurrent.Map` to be converted */ implicit def mapAsJavaConcurrentMapConverter[K, V](m: concurrent.Map[K, V]): AsJava[juc.ConcurrentMap[K, V]] = new AsJava(mapAsJavaConcurrentMap(m)) @@ -224,90 +266,143 @@ object JavaConverters extends AsJavaConverters with AsScalaConverters { /** Adds an `asScala` method that implicitly converts a Java `Iterator` to a Scala `Iterator`. * @see [[asScalaIterator]] + * + * @tparam A the element type of the iterator + * @param i the Java `Iterator` to be converted */ implicit def asScalaIteratorConverter[A](i : ju.Iterator[A]): AsScala[Iterator[A]] = new AsScala(asScalaIterator(i)) /** Adds an `asScala` method that implicitly converts a Java `Enumeration` to a Scala `Iterator`. * @see [[enumerationAsScalaIterator]] + * + * @tparam A the element type of the enumeration + * @param i the Java `Enumeration` to be converted */ implicit def enumerationAsScalaIteratorConverter[A](i : ju.Enumeration[A]): AsScala[Iterator[A]] = new AsScala(enumerationAsScalaIterator(i)) /** Adds an `asScala` method that implicitly converts a Java `Iterable` to a Scala `Iterable`. * @see [[iterableAsScalaIterable]] + * + * @tparam A the element type of the iterable + * @param i the Java `Iterable` to be converted */ implicit def iterableAsScalaIterableConverter[A](i : jl.Iterable[A]): AsScala[Iterable[A]] = new AsScala(iterableAsScalaIterable(i)) /** Adds an `asScala` method that implicitly converts a Java `Collection` to an Scala `Iterable`. * @see [[collectionAsScalaIterable]] + * + * @tparam A the element type of the collection + * @param i the Java `Collection` to be converted */ implicit def collectionAsScalaIterableConverter[A](i : ju.Collection[A]): AsScala[Iterable[A]] = new AsScala(collectionAsScalaIterable(i)) /** Adds an `asScala` method that implicitly converts a Java `List` to a Scala mutable `Buffer`. * @see [[asScalaBuffer]] + * + * @tparam A the element type of the list + * @param l the Java `List` to be converted */ implicit def asScalaBufferConverter[A](l : ju.List[A]): AsScala[mutable.Buffer[A]] = new AsScala(asScalaBuffer(l)) /** Adds an `asScala` method that implicitly converts a Java `Set` to a Scala mutable `Set`. * @see [[asScalaSet]] + * + * @tparam A the element type of the set + * @param s the Java `Set` to be converted */ implicit def asScalaSetConverter[A](s : ju.Set[A]): AsScala[mutable.Set[A]] = new AsScala(asScalaSet(s)) /** Adds an `asScala` method that implicitly converts a Java `Map` to a Scala mutable `Map`. * @see [[mapAsScalaMap]] + * + * @tparam K the type of the map keys + * @tparam V the type of the map values + * @param m the Java `Map` to be converted */ implicit def mapAsScalaMapConverter[K, V](m : ju.Map[K, V]): AsScala[mutable.Map[K, V]] = new AsScala(mapAsScalaMap(m)) /** Adds an `asScala` method that implicitly converts a Java `ConcurrentMap` to a Scala mutable `concurrent.Map`. * @see [[mapAsScalaConcurrentMap]] + * + * @tparam K the type of the map keys + * @tparam V the type of the map values + * @param m the Java `ConcurrentMap` to be converted */ implicit def mapAsScalaConcurrentMapConverter[K, V](m: juc.ConcurrentMap[K, V]): AsScala[concurrent.Map[K, V]] = new AsScala(mapAsScalaConcurrentMap(m)) /** Adds an `asScala` method that implicitly converts a Java `Dictionary` to a Scala mutable `Map`. * @see [[dictionaryAsScalaMap]] + * + * @tparam K the type of the dictionary keys + * @tparam V the type of the dictionary values + * @param p the Java `Dictionary` to be converted */ implicit def dictionaryAsScalaMapConverter[K, V](p: ju.Dictionary[K, V]): AsScala[mutable.Map[K, V]] = new AsScala(dictionaryAsScalaMap(p)) /** Adds an `asScala` method that implicitly converts a Java `Properties` to a Scala mutable `Map[String, String]`. * @see [[propertiesAsScalaMap]] + * + * @param p the Java `Properties` to be converted */ implicit def propertiesAsScalaMapConverter(p: ju.Properties): AsScala[mutable.Map[String, String]] = new AsScala(propertiesAsScalaMap(p)) - /** Generic class containing the `asJava` converter method. */ + /** Generic class containing the `asJava` converter method. + * + * @tparam A the target type of the conversion result + * @param op the conversion operation, evaluated lazily + */ class AsJava[A](op: => A) { /** Converts a Scala collection to the corresponding Java collection. */ def asJava: A = op } - /** Generic class containing the `asScala` converter method. */ + /** Generic class containing the `asScala` converter method. + * + * @tparam A the target type of the conversion result + * @param op the conversion operation, evaluated lazily + */ class AsScala[A](op: => A) { /** Converts a Java collection to the corresponding Scala collection. */ def asScala: A = op } - /** Generic class containing the `asJavaCollection` converter method. */ + /** Generic class containing the `asJavaCollection` converter method. + * + * @tparam A the element type of the collection + * @param i the Scala `Iterable` to be converted + */ class AsJavaCollection[A](i: Iterable[A]) { /** Converts a Scala `Iterable` to a Java `Collection`. */ def asJavaCollection: ju.Collection[A] = JavaConverters.asJavaCollection(i) } - /** Generic class containing the `asJavaEnumeration` converter method. */ + /** Generic class containing the `asJavaEnumeration` converter method. + * + * @tparam A the element type of the enumeration + * @param i the Scala `Iterator` to be converted + */ class AsJavaEnumeration[A](i: Iterator[A]) { /** Converts a Scala `Iterator` to a Java `Enumeration`. */ def asJavaEnumeration: ju.Enumeration[A] = JavaConverters.asJavaEnumeration(i) } - /** Generic class containing the `asJavaDictionary` converter method. */ + /** Generic class containing the `asJavaDictionary` converter method. + * + * @tparam K the type of the map keys + * @tparam V the type of the map values + * @param m the Scala mutable `Map` to be converted + */ class AsJavaDictionary[K, V](m : mutable.Map[K, V]) { /** Converts a Scala `Map` to a Java `Dictionary`. */ def asJavaDictionary: ju.Dictionary[K, V] = JavaConverters.asJavaDictionary(m) diff --git a/library/src/scala/collection/LazyZipOps.scala b/library/src/scala/collection/LazyZipOps.scala index 008dbfa0839d..2f3a54f67e11 100644 --- a/library/src/scala/collection/LazyZipOps.scala +++ b/library/src/scala/collection/LazyZipOps.scala @@ -22,6 +22,10 @@ import language.experimental.captureChecking * @define willNotTerminateInf * * Note: will not terminate for infinite-sized collections. + * + * @tparam El1 the element type of the first collection + * @tparam El2 the element type of the second collection + * @tparam C1 the type of the source collection, used to determine the result type of strict operations */ final class LazyZip2[+El1, +El2, C1] private[collection](src: C1, coll1: Iterable[El1]^, coll2: Iterable[El2]^) { @@ -147,6 +151,11 @@ object LazyZip2 { * @define willNotTerminateInf * * Note: will not terminate for infinite-sized collections. + * + * @tparam El1 the element type of the first collection + * @tparam El2 the element type of the second collection + * @tparam El3 the element type of the third collection + * @tparam C1 the type of the source collection, used to determine the result type of strict operations */ final class LazyZip3[+El1, +El2, +El3, C1] private[collection](src: C1, coll1: Iterable[El1]^, @@ -288,6 +297,12 @@ object LazyZip3 { * @define willNotTerminateInf * * Note: will not terminate for infinite-sized collections. + * + * @tparam El1 the element type of the first collection + * @tparam El2 the element type of the second collection + * @tparam El3 the element type of the third collection + * @tparam El4 the element type of the fourth collection + * @tparam C1 the type of the source collection, used to determine the result type of strict operations */ final class LazyZip4[+El1, +El2, +El3, +El4, C1] private[collection](src: C1, coll1: Iterable[El1]^, diff --git a/library/src/scala/collection/LinearSeq.scala b/library/src/scala/collection/LinearSeq.scala index d91893bf1d3a..a9283164d483 100644 --- a/library/src/scala/collection/LinearSeq.scala +++ b/library/src/scala/collection/LinearSeq.scala @@ -21,6 +21,8 @@ import scala.annotation.{nowarn, tailrec} /** Base trait for linearly accessed sequences that have efficient `head` and * `tail` operations. * Known subclasses: List, LazyList + * + * @tparam A the element type of the sequence */ trait LinearSeq[+A] extends Seq[A] with LinearSeqOps[A, LinearSeq, LinearSeq[A]] @@ -34,7 +36,12 @@ trait LinearSeq[+A] extends Seq[A] @SerialVersionUID(3L) object LinearSeq extends SeqFactory.Delegate[LinearSeq](immutable.LinearSeq) -/** Base trait for linear Seq operations. */ +/** Base trait for linear Seq operations. + * + * @tparam A the element type of the sequence + * @tparam CC the type constructor for the collection (e.g., `List`, `LazyList`) + * @tparam C the concrete collection type + */ transparent trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] & LinearSeqOps[A, CC, C]] extends Any with SeqOps[A, CC, C] with caps.Pure { self => /** @inheritdoc @@ -201,7 +208,7 @@ transparent trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] & } that match { - case that: LinearSeq[B] => linearSeqEq(coll, that) + case that: LinearSeq[B @unchecked] => linearSeqEq(coll, that) case _ => super.sameElements(that) } } @@ -288,6 +295,9 @@ transparent trait StrictOptimizedLinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: /** A specialized Iterator for LinearSeqs that is lazy enough for Stream and LazyList. This is accomplished by not * evaluating the tail after returning the current head. + * + * @tparam A the element type of the linear sequence being iterated + * @param coll the linear sequence to iterate over */ private[collection] final class LinearSeqIterator[A](coll: LinearSeqOps[A, LinearSeq, LinearSeq[A]]) extends AbstractIterator[A] { // A call-by-need cell diff --git a/library/src/scala/collection/Map.scala b/library/src/scala/collection/Map.scala index 77b2b5e45411..e79f994c5ed0 100644 --- a/library/src/scala/collection/Map.scala +++ b/library/src/scala/collection/Map.scala @@ -21,7 +21,11 @@ import scala.collection.generic.DefaultSerializable import scala.collection.mutable.StringBuilder import scala.util.hashing.MurmurHash3 -/** Base Map type. */ +/** Base Map type. + * + * @tparam K the type of keys in this map + * @tparam V the type of values associated with keys in this map + */ trait Map[K, +V] extends Iterable[(K, V)] with MapOps[K, V, Map, Map[K, V]] @@ -48,20 +52,15 @@ trait Map[K, +V] * to unexpected results if `ordering.equiv(k1, k2)` (used for lookup in `TreeMap`) is different from `k1 == k2` * (used for lookup in `HashMap`). * + * ```scala sc:compile + * import scala.collection.immutable._ + * val ord: Ordering[String] = _ compareToIgnoreCase _ + * val result1 = TreeMap("A" -> 1)(using ord) == HashMap("a" -> 1) // false + * val result2 = HashMap("a" -> 1) == TreeMap("A" -> 1)(using ord) // true * ``` - * scala> import scala.collection.immutable._ - * scala> val ord: Ordering[String] = _ compareToIgnoreCase _ - * - * scala> TreeMap("A" -> 1)(ord) == HashMap("a" -> 1) - * val res0: Boolean = false - * - * scala> HashMap("a" -> 1) == TreeMap("A" -> 1)(ord) - * val res1: Boolean = true - * ``` - * * - * @param o The map to which this map is compared - * @return `true` if the two maps are equal according to the description + * @param o the object to compare this map with for equality + * @return `true` if `o` is a `Map` with the same size and identical key-value mappings */ override def equals(o: Any): Boolean = (this eq o.asInstanceOf[AnyRef]) || (o match { @@ -107,7 +106,10 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] override def view: MapView[K, V]^{this} = new MapView.Id(this) - /** Returns a [[Stepper]] for the keys of this map. See method [[stepper]]. */ + /** Returns a [[Stepper]] for the keys of this map. See method [[stepper]]. + * + * @tparam S the type of `Stepper` to use, determined by the implicit `StepperShape` + */ def keyStepper[S <: Stepper[?]](implicit shape: StepperShape[K, S]): S = { import convert.impl._ val s = shape.shape match { @@ -119,7 +121,10 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] s.asInstanceOf[S] } - /** Returns a [[Stepper]] for the values of this map. See method [[stepper]]. */ + /** Returns a [[Stepper]] for the values of this map. See method [[stepper]]. + * + * @tparam S the type of `Stepper` to use, determined by the implicit `StepperShape` + */ def valueStepper[S <: Stepper[?]](implicit shape: StepperShape[V, S]): S = { import convert.impl._ val s = shape.shape match { @@ -133,6 +138,10 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] /** Similar to `fromIterable`, but returns a Map collection type. * Note that the return type is now `CC[K2, V2]`. + * + * @tparam K2 the key type of the returned map + * @tparam V2 the value type of the returned map + * @param it the iterable of key-value pairs to convert into a map */ @`inline` protected final def mapFromIterable[K2, V2](it: Iterable[(K2, V2)]^): CC[K2, V2]^{it} = mapFactory.from(it) @@ -141,6 +150,8 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] * @note When implementing a custom collection type and refining `CC` to the new type, this * method needs to be overridden to return a factory for the new type (the compiler will * issue an error otherwise). + * + * @return the `MapFactory` companion object for this map type */ def mapFactory: MapFactory[CC] @@ -271,6 +282,9 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] /** Applies `f` to each key/value pair for its side effects * Note: [U] parameter needed to help scalac's type inference. + * + * @tparam U the result type of the function `f`; not used in the method result but aids type inference + * @param f the function to apply to each key-value pair */ def foreachEntry[U](f: (K, V) => U): Unit = { val it = iterator @@ -303,6 +317,7 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] * but it may be overridden by subclasses. * * @param key the given key value for which a binding is missing. + * @return the value associated with the given key when it is not found in the map * @throws NoSuchElementException if no default value is defined */ @throws[NoSuchElementException] @@ -331,6 +346,8 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] /** Builds a new map by applying a function to all elements of this $coll. * + * @tparam K2 the key type of the returned map + * @tparam V2 the value type of the returned map * @param f the function to apply to each element. * @return a new $coll resulting from applying the given function * `f` to each element of this $coll and collecting the results. @@ -353,6 +370,8 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] /** Builds a new map by applying a function to all elements of this $coll * and using the elements of the resulting collections. * + * @tparam K2 the key type of the returned map + * @tparam V2 the value type of the returned map * @param f the function to apply to each element. * @return a new $coll resulting from applying the given collection-valued function * `f` to each element of this $coll and concatenating the results. @@ -363,18 +382,23 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] * right hand operand. The element type of the $coll is the most specific superclass encompassing * the element types of the two operands. * + * @tparam V2 the value type of the returned map, a supertype of `V` * @param suffix the iterable to append. * @return a new $coll which contains all elements * of this $coll followed by all elements of `suffix`. */ def concat[V2 >: V](suffix: collection.IterableOnce[(K, V2)]^): CC[K, V2]^{this, suffix} = mapFactory.from(suffix match { - case it: Iterable[(K, V2)] => new View.Concat(this, it) + case it: Iterable[(K, V2) @unchecked] => new View.Concat(this, it) case _ => iterator.concat(suffix.iterator) }) // Not final because subclasses refine the result type, e.g. in SortedMap, the result type is // SortedMap's CC, while Map's CC is fixed to Map - /** Alias for `concat`. */ + /** Alias for `concat`. + * + * @tparam V2 the value type of the returned map, a supertype of `V` + * @param xs the key-value pairs to append + */ /*@`inline` final*/ def ++ [V2 >: V](xs: collection.IterableOnce[(K, V2)]^): CC[K, V2]^{this, xs} = concat(xs) override def addString(sb: StringBuilder, start: String, sep: String, end: String): sb.type = @@ -397,7 +421,7 @@ transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C] @deprecated("Use ++ instead of ++: for collections of type Iterable", "2.13.0") def ++: [V1 >: V](that: IterableOnce[(K,V1)]^): CC[K,V1]^{this, that} = { val thatIterable: Iterable[(K, V1)]^{that} = that match { - case that: Iterable[(K, V1)] => that + case that: Iterable[(K, V1) @unchecked] => that case that => View.from(that) } mapFactory.from(new View.Concat(thatIterable, this)) @@ -428,7 +452,12 @@ object MapOps { } - /** The implementation class of the set returned by `keySet`, for pure maps. */ + /** The implementation class of the set returned by `keySet`, for pure maps. + * + * @tparam K the key type of the underlying map + * @tparam V the value type of the underlying map + * @tparam CC the type constructor of the underlying map + */ private[collection] class LazyKeySet[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C](mp: MapOps[K, V, CC, C]) extends AbstractSet[K] with DefaultSerializable { def iterator: Iterator[K] = mp.keysIterator def diff(that: Set[K]): Set[K] = LazyKeySet.this.fromSpecific(this.view.filterNot(that)) @@ -438,7 +467,12 @@ object MapOps { override def isEmpty: Boolean = mp.isEmpty } - /** The implementation class of the set returned by `keySet`, for impure maps (i.e. views). */ + /** The implementation class of the set returned by `keySet`, for impure maps (i.e. views). + * + * @tparam K the key type of the underlying map + * @tparam V the value type of the underlying map + * @tparam CC the type constructor of the underlying map + */ private[collection] class StrictKeySet[K, +V, +CC[_, _] <: IterableOps[?, AnyConstr, ?], +C](@annotation.constructorOnly mp: MapOps[K, V, CC, C]^) extends AbstractSet[K] with DefaultSerializable { val allKeys = mp.keysIterator.to(mutable.LinkedHashSet) def iterator: Iterator[K] = allKeys.iterator @@ -460,5 +494,9 @@ object Map extends MapFactory.Delegate[Map](immutable.Map) { private val DefaultSentinelFn: () -> AnyRef = () => DefaultSentinel } -/** Explicit instantiation of the `Map` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Map` trait to reduce class file size in subclasses. + * + * @tparam K the type of keys in this map + * @tparam V the type of values associated with keys in this map + */ abstract class AbstractMap[K, +V] extends AbstractIterable[(K, V)] with Map[K, V] diff --git a/library/src/scala/collection/MapView.scala b/library/src/scala/collection/MapView.scala index bfd4694e5c3e..19970a473011 100644 --- a/library/src/scala/collection/MapView.scala +++ b/library/src/scala/collection/MapView.scala @@ -48,6 +48,8 @@ trait MapView[K, +V] override def filterKeys(p: K => Boolean): MapView[K, V]^{this, p} = new MapView.FilterKeys(this, p) /** Transforms this map by applying a function to every retrieved value. + * + * @tparam W the type of the transformed values * @param f the function used to transform values of this map. * @return a map view which maps every key of this map * to `f(this(key))`. The resulting map wraps the original map without copying any elements. @@ -167,7 +169,7 @@ object MapView extends MapViewFactory { override def from[K, V](it: IterableOnce[(K, V)]^): View[(K, V)]^{it} = View.from(it) override def from[K, V](it: SomeMapOps[K, V]): MapView[K, V] = it match { - case mv: MapView[K, V] => mv + case mv: MapView[K @unchecked, V @unchecked] => mv case other => new MapView.Id(other) } diff --git a/library/src/scala/collection/Searching.scala b/library/src/scala/collection/Searching.scala index c8eaf779de4b..3af26bd260ca 100644 --- a/library/src/scala/collection/Searching.scala +++ b/library/src/scala/collection/Searching.scala @@ -24,13 +24,11 @@ object Searching { * * Example usage: * - * ``` + * ```scala sc:compile * val list = List(1, 3, 4, 5) // list must be sorted before searching * list.search(4) // Found(2) * list.search(2) // InsertionPoint(1) * ``` - * - * */ sealed abstract class SearchResult { /** The index corresponding to the element searched for in the sequence, if it was found, diff --git a/library/src/scala/collection/Seq.scala b/library/src/scala/collection/Seq.scala index 0b98561f0def..3d8faac0fe27 100644 --- a/library/src/scala/collection/Seq.scala +++ b/library/src/scala/collection/Seq.scala @@ -83,7 +83,9 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any override def view: SeqView[A]^{this} = new SeqView.Id[A](this) /** Gets the element at the specified index. This operation is provided for convenience in `Seq`. It should - * not be assumed to be efficient unless you have an `IndexedSeq`. + * not be assumed to be efficient unless you have an `IndexedSeq`. + * + * @param i the index of the element to retrieve, zero-based */ @throws[IndexOutOfBoundsException] def apply(i: Int): A @@ -96,21 +98,16 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * Also, the original $coll is not modified, so you will want to capture the result. * * Example: - * ``` - * scala> val x = List(1) - * x: List[Int] = List(1) - * - * scala> val y = 2 +: x - * y: List[Int] = List(2, 1) - * - * scala> println(x) - * List(1) + * ```scala sc:compile + * val x = List(1) + * val y = 2 +: x + * // x is still List(1), y is List(2, 1) * ``` * * @tparam B the element type of the returned $coll. * @param elem the prepended element * - * @return a new $coll consisting of `value` followed + * @return a new $coll consisting of `elem` followed * by all elements of this $coll. */ def prepended[B >: A](elem: B): CC[B]^{this} = iterableFactory.from(new View.Prepended(elem, this)) @@ -119,6 +116,8 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * * Note that :-ending operators are right associative (see example). * A mnemonic for `+:` vs. `:+` is: the COLon goes on the COLlection side. + * + * @return a new $coll consisting of `elem` followed by all elements of this $coll */ @`inline` final def +: [B >: A](elem: B): CC[B]^{this} = prepended(elem) @@ -127,21 +126,15 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * $willNotTerminateInf * * Example: - * ``` - * scala> val a = List(1) - * a: List[Int] = List(1) - * - * scala> val b = a :+ 2 - * b: List[Int] = List(1, 2) - * - * scala> println(a) - * List(1) - * ``` - * + * ```scala sc:compile + * val a = List(1) + * val b = a :+ 2 + * // a is still List(1), b is List(1, 2) + * ``` * * @tparam B the element type of the returned $coll. * @param elem the appended element * @return a new $coll consisting of - * all elements of this $coll followed by `value`. + * all elements of this $coll followed by `elem`. */ def appended[B >: A](elem: B): CC[B]^{this} = iterableFactory.from(new View.Appended(this, elem)) @@ -165,7 +158,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * by all the elements of this $coll. */ def prependedAll[B >: A](prefix: IterableOnce[B]^): CC[B]^{this, prefix} = iterableFactory.from(prefix match { - case prefix: Iterable[B] => new View.Concat(prefix, this) + case prefix: Iterable[B @unchecked] => new View.Concat(prefix, this) case _ => prefix.iterator ++ iterator }) @@ -242,6 +235,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * **Note**: If the both the receiver object `this` and the argument * `that` are infinite sequences this method may not terminate. * + * @tparam B the element type used for comparison (a supertype of `A`) * @param that the sequence to test * @param offset the index where the sequence is searched. * @return `true` if the sequence `that` is contained in this $coll at @@ -259,6 +253,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any /** Tests whether this $coll ends with the given sequence. * $willNotTerminateInf + * @tparam B the element type used for comparison (a supertype of `A`) * @param that the sequence to test * @return `true` if this $coll has `that` as a suffix, `false` otherwise. */ @@ -395,6 +390,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * $willNotTerminateInf * * @param p the predicate used to test elements. + * @param end the maximum index to consider (inclusive) * @return the index `<= end` of the last element of this $coll that satisfies the predicate `p`, * or `-1`, if none exists. */ @@ -423,6 +419,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any /** Finds first index after or at a start index where this $coll contains a given sequence as a slice. * $mayNotTerminateInf + * @tparam B the element type used for comparison (a supertype of `A`) * @param that the sequence to test * @param from the start index * @return the first index `>= from` such that the elements of this $coll starting at this index @@ -468,6 +465,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * * $willNotTerminateInf * + * @tparam B the element type used for comparison (a supertype of `A`) * @param that the sequence to test * @param end the end index * @return the last index `<= end` such that the elements of this $coll starting at this index @@ -514,6 +512,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any /** Tests whether this $coll contains a given sequence as a slice. * $mayNotTerminateInf + * @tparam B the element type used for comparison (a supertype of `A`) * @param that the sequence to test * @return `true` if this $coll contains a slice with the same elements * as `that`, otherwise `false`. @@ -523,6 +522,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any /** Tests whether this $coll contains a given value as an element. * $mayNotTerminateInf * + * @tparam A1 the type of the element to test (a supertype of `A`) * @param elem the element to test. * @return `true` if this $coll has an element that is equal (as * determined by `==`) to `elem`, `false` otherwise. @@ -537,7 +537,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * $willForceEvaluation * * @return An Iterator which traverses the distinct permutations of this $coll. - * @example ``` + * @example ```scala sc:compile * Seq('a', 'b', 'b').permutations.foreach(println) * // List(a, b, b) * // List(b, a, b) @@ -573,8 +573,9 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * * $willForceEvaluation * + * @param n the number of elements in each combination * @return An Iterator which traverses the n-element combinations of this $coll. - * @example ``` + * @example ```scala sc:compile * Seq('a', 'b', 'b', 'b', 'c').combinations(2).foreach(println) * // List(a, b) * // List(a, c) @@ -716,6 +717,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * * $willForceEvaluation * + * @tparam B the element type used for ordering (a supertype of `A`) * @param ord the ordering to be used to compare elements. * @return a $coll consisting of the elements of this $coll * sorted according to the ordering `ord`. @@ -752,9 +754,9 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * the desired ordering. * @return a $coll consisting of the elements of this $coll * sorted according to the comparison function `lt`. - * @example ``` - * List("Steve", "Bobby", "Tom", "John", "Bob").sortWith((x, y) => x.take(3).compareTo(y.take(3)) < 0) = - * List("Bobby", "Bob", "John", "Steve", "Tom") + * @example ```scala sc:compile + * List("Steve", "Bobby", "Tom", "John", "Bob").sortWith((x, y) => x.take(3).compareTo(y.take(3)) < 0) + * // List("Bobby", "Bob", "John", "Steve", "Tom") * ``` */ def sortWith(lt: (A, A) => Boolean): C^{this} = sorted(using Ordering.fromLessThan(lt)) @@ -777,11 +779,11 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * sorted according to the ordering where `x < y` if * `ord.lt(f(x), f(y))`. * - * @example ``` + * @example ```scala sc:compile * val words = "The quick brown fox jumped over the lazy dog".split(' ') * // this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]] - * words.sortBy(x => (x.length, x.head)) - * res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped) + * val sorted = words.sortBy(x => (x.length, x.head)) + * // sorted: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped) * ``` */ def sortBy[B](f: A => B)(implicit ord: Ordering[B]): C^{this} = sorted(using ord.on(f)) @@ -842,6 +844,8 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * this.lengthIs >= len // this.lengthCompare(len) >= 0 * this.lengthIs > len // this.lengthCompare(len) > 0 * ``` + * + * @return an object providing `<`, `<=`, `==`, `!=`, `>=`, and `>` operations for comparing the length */ @inline final def lengthIs: IterableOps.SizeCompareOps^{this} = new IterableOps.SizeCompareOps(caps.unsafe.unsafeAssumePure(this) /* see comment in SizeCompareOps*/) @@ -887,6 +891,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any /** Computes the multiset difference between this $coll and another sequence. * + * @tparam B the element type used for comparison (a supertype of `A`) * @param that the sequence of elements to remove * @return a new $coll which contains all elements of this $coll * except some of the occurrences of elements that also appear in `that`. @@ -912,6 +917,7 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any /** Computes the multiset intersection between this $coll and another sequence. * + * @tparam B the element type used for comparison (a supertype of `A`) * @param that the sequence of elements to intersect with. * @return a new $coll which contains all elements of this $coll * which also appear in `that`. @@ -987,9 +993,10 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * @see [[scala.math.Ordering]] * @see [[scala.collection.SeqOps]], method `sorted` * + * @tparam B the element type used for searching and ordering (a supertype of `A`) * @param elem the element to find. - * @param ord the ordering to be used to compare elements. * + * @param ord the ordering to be used to compare elements. * @return a `Found` value containing the index corresponding to the element in the * sequence, or the `InsertionPoint` where the element would be inserted if * the element is not in the sequence. @@ -1008,11 +1015,12 @@ transparent trait SeqOps[+A, +CC[_], +C] extends Any * @see [[scala.math.Ordering]] * @see [[scala.collection.SeqOps]], method `sorted` * + * @tparam B the element type used for searching and ordering (a supertype of `A`) * @param elem the element to find. * @param from the index where the search starts. * @param to the index following where the search ends. - * @param ord the ordering to be used to compare elements. * + * @param ord the ordering to be used to compare elements. * @return a `Found` value containing the index corresponding to the element in the * sequence, or the `InsertionPoint` where the element would be inserted if * the element is not in the sequence. @@ -1044,6 +1052,7 @@ object SeqOps { /** A KMP implementation, based on the undoubtedly reliable wikipedia entry. * Note: I made this private to keep it from entering the API. That can be reviewed. * + * @tparam B the element type of the sequences being searched * @param S Sequence that may contain target * @param m0 First index of S to consider * @param m1 Last index of S to consider (exclusive) @@ -1131,13 +1140,15 @@ object SeqOps { /** Makes sure a target sequence has fast, correctly-ordered indexing for KMP. * + * @tparam B the element type of the target sequence * @param W The target sequence * @param n0 The first element in the target sequence that we should use * @param n1 The far end of the target sequence that we should use (exclusive) + * @param forward `true` to index in forward order, `false` to index in reverse order * @return Target packed in an IndexedSeq (taken from iterator unless W already is an IndexedSeq) */ private def kmpOptimizeWord[B](W: scala.collection.Seq[B], n0: Int, n1: Int, forward: Boolean): IndexedSeqView[B] = W match { - case iso: IndexedSeq[B] => + case iso: IndexedSeq[B @unchecked] => // Already optimized for indexing--use original (or custom view of original) if (forward && n0==0 && n1==W.length) iso.view else if (forward) new AbstractIndexedSeqView[B] { @@ -1169,6 +1180,7 @@ object SeqOps { /** Makes a jump table for KMP search. * + * @tparam B the element type of the target sequence * @param Wopt The target sequence * @param wlen Just in case we're only IndexedSeq and not IndexedSeqOptimized * @return KMP jump table for target sequence @@ -1197,5 +1209,8 @@ object SeqOps { } } -/** Explicit instantiation of the `Seq` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Seq` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the collection + */ abstract class AbstractSeq[+A] extends AbstractIterable[A] with Seq[A] diff --git a/library/src/scala/collection/Set.scala b/library/src/scala/collection/Set.scala index b878eaa49715..e7b497db01fa 100644 --- a/library/src/scala/collection/Set.scala +++ b/library/src/scala/collection/Set.scala @@ -21,7 +21,10 @@ import java.lang.String import scala.annotation.nowarn -/** Base trait for set collections. */ +/** Base trait for set collections. + * + * @tparam A the element type of the set + */ trait Set[A] extends Iterable[A] with SetOps[A, Set, Set[A]] @@ -46,18 +49,13 @@ trait Set[A] * to unexpected results if `ordering.equiv(e1, e2)` (used for lookup in `TreeSet`) is different from `e1 == e2` * (used for lookup in `HashSet`). * - * ``` - * scala> import scala.collection.immutable._ - * scala> val ord: Ordering[String] = _ compareToIgnoreCase _ - * - * scala> TreeSet("A")(ord) == HashSet("a") - * val res0: Boolean = false - * - * scala> HashSet("a") == TreeSet("A")(ord) - * val res1: Boolean = true + * ```scala sc:compile + * import scala.collection.immutable._ + * val ord: Ordering[String] = _ compareToIgnoreCase _ + * val result1 = TreeSet("A")(using ord) == HashSet("a") // false + * val result2 = HashSet("a") == TreeSet("A")(using ord) // true * ``` * - * * @param that The set to which this set is compared * @return `true` if the two sets are equal according to the description */ @@ -86,6 +84,9 @@ trait Set[A] * * @define coll set * @define Coll `Set` + * + * @tparam A the element type of the set + * @tparam CC the type constructor for the set's collection type */ transparent trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] extends IterableOps[A, CC, C] @@ -149,6 +150,9 @@ transparent trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] * ListSet(1,2,3).subsets => {{1},{2},{3},{1,2},{1,3},{2,3},{1,2,3}} * * $willForceEvaluation + * + * @param elms the elements of the set as an indexed sequence + * @param len the size of each subset to generate */ private class SubsetsItr(elms: IndexedSeq[A], len: Int) extends AbstractIterator[C] { private val idxs = Array.range(0, len+1) @@ -186,7 +190,10 @@ transparent trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] */ def intersect(that: Set[A]): C = this.filter(that) - /** Alias for `intersect`. */ + /** Alias for `intersect`. + * + * @param that the set to intersect with + */ @`inline` final def & (that: Set[A]): C = intersect(that) /** Computes the difference of this set and another set. @@ -197,7 +204,10 @@ transparent trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] */ def diff(that: Set[A]): C - /** Alias for `diff`. */ + /** Alias for `diff`. + * + * @param that the set of elements to exclude + */ @`inline` final def &~ (that: Set[A]): C = this diff that @deprecated("Consider requiring an immutable Set", "2.13.0") @@ -231,10 +241,10 @@ transparent trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] while (it.hasNext) result = result + it.next() result.asInstanceOf[C] case _ => fromSpecific(that match { - case that: collection.Iterable[A] => new View.Concat(this, that) + case that: collection.Iterable[A @unchecked] => new View.Concat(this, that) case _ => iterator.concat(that.iterator) }) - } + } @deprecated("Consider requiring an immutable Set or fall back to Set.union", "2.13.0") def + (elem: A): C = fromSpecific(new View.Appended(this, elem)) @@ -242,7 +252,10 @@ transparent trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] @deprecated("Use ++ with an explicit collection argument instead of + with varargs", "2.13.0") def + (elem1: A, elem2: A, elems: A*): C = fromSpecific(new View.Concat(new View.Appended(new View.Appended(this, elem1), elem2), elems)) - /** Alias for `concat`. */ + /** Alias for `concat`. + * + * @param that the collection containing the elements to add + */ @`inline` final def ++ (that: collection.IterableOnce[A]^): C = concat(that) /** Computes the union between of set and another set. @@ -253,7 +266,10 @@ transparent trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] */ @`inline` final def union(that: Set[A]): C = concat(that) - /** Alias for `union`. */ + /** Alias for `union`. + * + * @param that the set to form the union with + */ @`inline` final def | (that: Set[A]): C = concat(that) } @@ -264,5 +280,8 @@ transparent trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]] @SerialVersionUID(3L) object Set extends IterableFactory.Delegate[Set](immutable.Set) -/** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the set + */ abstract class AbstractSet[A] extends AbstractIterable[A] with Set[A] diff --git a/library/src/scala/collection/SortedMap.scala b/library/src/scala/collection/SortedMap.scala index 6c76e6697df2..50c8ba613c86 100644 --- a/library/src/scala/collection/SortedMap.scala +++ b/library/src/scala/collection/SortedMap.scala @@ -18,7 +18,11 @@ import language.experimental.captureChecking import scala.annotation.{implicitNotFound, nowarn} -/** A Map whose keys are sorted according to a [[scala.math.Ordering]]. */ +/** A Map whose keys are sorted according to a [[scala.math.Ordering]]. + * + * @tparam K the type of the keys contained in this sorted map + * @tparam V the type of the values associated with the keys + */ trait SortedMap[K, +V] extends Map[K, V] with SortedMapOps[K, V, SortedMap, SortedMap[K, V]] @@ -60,11 +64,17 @@ transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] & SortedMapOps[X, Y * @note When implementing a custom collection type and refining `CC` to the new type, this * method needs to be overridden to return a factory for the new type (the compiler will * issue an error otherwise). + * + * @return the factory for this sorted map type */ def sortedMapFactory: SortedMapFactory[CC] /** Similar to `mapFromIterable`, but returns a SortedMap collection type. * Note that the return type is now `CC[K2, V2]`. + * + * @tparam K2 the type of the keys in the resulting sorted map + * @tparam V2 the type of the values in the resulting sorted map + * @param it the iterable of key-value pairs to convert into a sorted map */ @`inline` protected final def sortedMapFromIterable[K2, V2](it: Iterable[(K2, V2)]^)(implicit ordering: Ordering[K2]): CC[K2, V2] = sortedMapFactory.from(it) @@ -76,8 +86,9 @@ transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] & SortedMapOps[X, Y * this map. x.iteratorFrom(y) is equivalent * to but often more efficient than x.from(y).iterator. * - * @param start The lower bound (inclusive) + * @param start the lower bound (inclusive) * on the keys to be returned + * @return an iterator over all key-value pairs with keys greater than or equal to `start` */ def iteratorFrom(start: K): Iterator[(K, V)] @@ -87,8 +98,9 @@ transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] & SortedMapOps[X, Y * is equivalent to but often more efficient than * x.from(y).keysIterator. * - * @param start The lower bound (inclusive) + * @param start the lower bound (inclusive) * on the keys to be returned + * @return an iterator over all keys greater than or equal to `start` */ def keysIteratorFrom(start: K): Iterator[K] @@ -98,8 +110,9 @@ transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] & SortedMapOps[X, Y * equivalent to but often more efficient than * x.from(y).valuesIterator. * - * @param start The lower bound (inclusive) + * @param start the lower bound (inclusive) * on the keys to be returned + * @return an iterator over all values associated with keys greater than or equal to `start` */ def valuesIteratorFrom(start: K): Iterator[V] = iteratorFrom(start).map(_._2) @@ -163,7 +176,10 @@ transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] & SortedMapOps[X, Y // And finally, we add new overloads taking an ordering /** Builds a new sorted map by applying a function to all elements of this $coll. * + * @tparam K2 the type of the keys in the returned sorted map + * @tparam V2 the type of the values in the returned sorted map * @param f the function to apply to each element. + * @param ordering the ordering to use for the keys of the returned sorted map * @return a new $coll resulting from applying the given function * `f` to each element of this $coll and collecting the results. */ @@ -173,7 +189,10 @@ transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] & SortedMapOps[X, Y /** Builds a new sorted map by applying a function to all elements of this $coll * and using the elements of the resulting collections. * + * @tparam K2 the type of the keys in the returned sorted map + * @tparam V2 the type of the values in the returned sorted map * @param f the function to apply to each element. + * @param ordering the ordering to use for the keys of the returned sorted map * @return a new $coll resulting from applying the given collection-valued function * `f` to each element of this $coll and concatenating the results. */ @@ -183,6 +202,8 @@ transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] & SortedMapOps[X, Y /** Builds a new sorted map by applying a partial function to all elements of this $coll * on which the function is defined. * + * @tparam K2 the type of the keys in the returned sorted map + * @tparam V2 the type of the values in the returned sorted map * @param pf the partial function which filters and maps the $coll. * @return a new $coll resulting from applying the given partial function * `pf` to each element on which it is defined and collecting the results. @@ -192,11 +213,15 @@ transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] & SortedMapOps[X, Y sortedMapFactory.from(new View.Collect(this, pf)) override def concat[V2 >: V](suffix: IterableOnce[(K, V2)]^): CC[K, V2] = sortedMapFactory.from(suffix match { - case it: Iterable[(K, V2)] => new View.Concat(this, it) + case it: Iterable[(K, V2) @unchecked] => new View.Concat(this, it) case _ => iterator.concat(suffix.iterator) })(using ordering) - /** Alias for `concat`. */ + /** Alias for `concat`. + * + * @tparam V2 the value type of the returned sorted map, a supertype of `V` + * @param xs the collection of key-value pairs to append + */ @`inline` override final def ++ [V2 >: V](xs: IterableOnce[(K, V2)]^): CC[K, V2] = concat(xs) @deprecated("Consider requiring an immutable Map or fall back to Map.concat", "2.13.0") @@ -212,6 +237,12 @@ object SortedMapOps { /** Specializes `MapWithFilter` for sorted Map collections * * @define coll sorted map collection + * + * @tparam K the type of the keys + * @tparam V the type of the values + * @tparam IterableCC the type constructor of the underlying iterable collection + * @tparam MapCC the type constructor of the underlying map collection + * @tparam CC the type constructor of the sorted map collection */ class WithFilter[K, +V, +IterableCC[_], +MapCC[X, Y] <: Map[X, Y], +CC[X, Y] <: Map[X, Y] & SortedMapOps[X, Y, CC, ?]]( self: SortedMapOps[K, V, CC, ?] & MapOps[K, V, MapCC, ?] & IterableOps[(K, V), IterableCC, ?], diff --git a/library/src/scala/collection/SortedOps.scala b/library/src/scala/collection/SortedOps.scala index bc99532bdf11..7a39b0c2c28d 100644 --- a/library/src/scala/collection/SortedOps.scala +++ b/library/src/scala/collection/SortedOps.scala @@ -15,7 +15,11 @@ package scala.collection import scala.language.`2.13` import language.experimental.captureChecking -/** Base trait for sorted collections. */ +/** Base trait for sorted collections. + * + * @tparam A the element type of this sorted collection + * @tparam C the type of the sorted collection itself + */ transparent trait SortedOps[A, +C] { def ordering: Ordering[A] @@ -42,6 +46,7 @@ transparent trait SortedOps[A, +C] { * `None` if there is no lower bound. * @param until The upper-bound (exclusive) of the ranged projection. * `None` if there is no upper bound. + * @return a ranged projection of this collection containing only elements within the specified range */ def rangeImpl(from: Option[A], until: Option[A]): C diff --git a/library/src/scala/collection/SortedSet.scala b/library/src/scala/collection/SortedSet.scala index 05cb6fdb168c..17a43942bb45 100644 --- a/library/src/scala/collection/SortedSet.scala +++ b/library/src/scala/collection/SortedSet.scala @@ -18,7 +18,10 @@ import language.experimental.captureChecking import scala.annotation.{implicitNotFound, nowarn} import scala.annotation.unchecked.uncheckedVariance -/** Base type of sorted sets. */ +/** Base type of sorted sets. + * + * @tparam A the element type of the set + */ trait SortedSet[A] extends Set[A] with SortedSetOps[A, SortedSet, SortedSet[A]] with SortedSetFactoryDefaults[A, SortedSet, Set] { @@ -57,6 +60,8 @@ transparent trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, * @note When implementing a custom collection type and refining `CC` to the new type, this * method needs to be overridden to return a factory for the new type (the compiler will * issue an error otherwise). + * + * @return a factory for creating new sorted collections of the same type */ def sortedIterableFactory: SortedIterableFactory[CC] @@ -71,7 +76,7 @@ transparent trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, * @param start The lower-bound (inclusive) of the iterator */ def iteratorFrom(start: A): Iterator[A] - + @deprecated("Use `iteratorFrom` instead.", "2.13.0") @`inline` def keysIteratorFrom(start: A): Iterator[A] = iteratorFrom(start) @@ -145,7 +150,7 @@ transparent trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, */ def zip[B](that: IterableOnce[B]^)(implicit @implicitNotFound(SortedSetOps.zipOrdMsg) ev: Ordering[(A @uncheckedVariance, B)]): CC[(A @uncheckedVariance, B)] = // sound bcs of VarianceNote sortedIterableFactory.from(that match { - case that: Iterable[B] => new View.Zip(this, that) + case that: Iterable[B @unchecked] => new View.Zip(this, that) case _ => iterator.zip(that) }) @@ -169,6 +174,9 @@ object SortedSetOps { /** Specialize `WithFilter` for sorted collections * * @define coll sorted collection + * + * @tparam A the element type of the sorted collection + * @tparam IterableCC the type constructor for the unsorted collection type */ class WithFilter[+A, +IterableCC[_], +CC[X] <: SortedSet[X]]( self: SortedSetOps[A, CC, ?] & IterableOps[A, IterableCC, ?], diff --git a/library/src/scala/collection/Stepper.scala b/library/src/scala/collection/Stepper.scala index 2e8312e4dd74..e03c9c81a226 100644 --- a/library/src/scala/collection/Stepper.scala +++ b/library/src/scala/collection/Stepper.scala @@ -53,6 +53,8 @@ trait Stepper[@specialized(Double, Int, Long) +A] { * May return `null`, in which case the current Stepper yields the same elements as before. * * See method `trySplit` in [[java.util.Spliterator]]. + * + * @return a new `Stepper` containing a portion of the elements, or `null` if this stepper cannot be split */ def trySplit(): Stepper[A]^{this} | Null @@ -71,6 +73,9 @@ trait Stepper[@specialized(Double, Int, Long) +A] { * Note that the return type is `Spliterator[_]` instead of `Spliterator[A]` to allow returning * a [[java.util.Spliterator.OfInt]] (which is a `Spliterator[Integer]`) in the subclass [[IntStepper]] * (which is a `Stepper[Int]`). + * + * @tparam B a supertype of the element type `A` + * @return a `Spliterator` over the remaining elements of this stepper */ def spliterator[B >: A]: Spliterator[?]^{this} @@ -79,6 +84,9 @@ trait Stepper[@specialized(Double, Int, Long) +A] { * Note that the return type is `Iterator[_]` instead of `Iterator[A]` to allow returning * a [[java.util.PrimitiveIterator.OfInt]] (which is a `Iterator[Integer]`) in the subclass * [[IntStepper]] (which is a `Stepper[Int]`). + * + * @tparam B a supertype of the element type `A` + * @return a Java `Iterator` over the remaining elements of this stepper */ def javaIterator[B >: A]: JIterator[?]^{this} @@ -184,7 +192,10 @@ object Stepper { } } -/** A `Stepper` for arbitrary element types. See [[Stepper]]. */ +/** A `Stepper` for arbitrary element types. See [[Stepper]]. + * + * @tparam A the element type of the stepper + */ trait AnyStepper[+A] extends Stepper[A] { def trySplit(): AnyStepper[A]^{this} | Null diff --git a/library/src/scala/collection/StepperShape.scala b/library/src/scala/collection/StepperShape.scala index 05bb41a73f27..51d6a1b6b56a 100644 --- a/library/src/scala/collection/StepperShape.scala +++ b/library/src/scala/collection/StepperShape.scala @@ -21,6 +21,9 @@ import scala.collection.Stepper.EfficientSplit /** An implicit StepperShape instance is used in the [[IterableOnce.stepper]] to return a possibly * specialized Stepper `S` according to the element type `T`. + * + * @tparam T the element type of the collection (may be a primitive or reference type) + * @tparam S the type of `Stepper` to use, possibly specialized for primitive types */ sealed trait StepperShape[-T, S <: Stepper[?]] { self => /** Returns the Int constant (as defined in the `StepperShape` companion object) for this `StepperShape`. */ @@ -28,11 +31,15 @@ sealed trait StepperShape[-T, S <: Stepper[?]] { self => /** Creates an unboxing primitive sequential Stepper from a boxed `AnyStepper`. * This is an identity operation for reference shapes. + * + * @param st the boxed `AnyStepper` to convert into a possibly specialized stepper */ def seqUnbox(st: AnyStepper[T]^): S^{st} /** Creates an unboxing primitive parallel (i.e. `with EfficientSplit`) Stepper from a boxed `AnyStepper`. * This is an identity operation for reference shapes. + * + * @param st the boxed `AnyStepper` with `EfficientSplit` capability to convert into a possibly specialized stepper */ def parUnbox(st: (AnyStepper[T] & EfficientSplit)^): (S & EfficientSplit)^{st} } diff --git a/library/src/scala/collection/StrictOptimizedIterableOps.scala b/library/src/scala/collection/StrictOptimizedIterableOps.scala index 4680d14e8270..a0d03d6d38de 100644 --- a/library/src/scala/collection/StrictOptimizedIterableOps.scala +++ b/library/src/scala/collection/StrictOptimizedIterableOps.scala @@ -254,6 +254,8 @@ transparent trait StrictOptimizedIterableOps[+A, +CC[_], +C] /** A collection containing the last `n` elements of this collection. * $willForceEvaluation + * + * @param n the number of elements to take from the end of this collection */ override def takeRight(n: Int): C = { val b = newSpecificBuilder @@ -271,6 +273,8 @@ transparent trait StrictOptimizedIterableOps[+A, +CC[_], +C] /** The rest of the collection without its `n` last elements. For * linear, immutable collections this should avoid making a copy. * $willForceEvaluation + * + * @param n the number of elements to drop from the end of this collection */ override def dropRight(n: Int): C = { val b = newSpecificBuilder diff --git a/library/src/scala/collection/StrictOptimizedSeqOps.scala b/library/src/scala/collection/StrictOptimizedSeqOps.scala index d4644fb23ba9..d649e394efbf 100644 --- a/library/src/scala/collection/StrictOptimizedSeqOps.scala +++ b/library/src/scala/collection/StrictOptimizedSeqOps.scala @@ -17,6 +17,9 @@ import language.experimental.captureChecking /** Trait that overrides operations on sequences in order * to take advantage of strict builders. + * + * @tparam A the element type of the sequence + * @tparam CC the type constructor of the collection */ transparent trait StrictOptimizedSeqOps [+A, +CC[_] <: caps.Pure, +C] extends Any with SeqOps[A, CC, C] with StrictOptimizedIterableOps[A, CC, C] with caps.Pure { diff --git a/library/src/scala/collection/StringOps.scala b/library/src/scala/collection/StringOps.scala index 33c18a002e01..3dc5dca1dbb1 100644 --- a/library/src/scala/collection/StringOps.scala +++ b/library/src/scala/collection/StringOps.scala @@ -64,11 +64,18 @@ object StringOps { } } - /** A lazy filtered string. No filtering is applied until one of `foreach`, `map` or `flatMap` is called. */ + /** A lazy filtered string. No filtering is applied until one of `foreach`, `map` or `flatMap` is called. + * + * @param p the predicate used to filter characters + * @param s the underlying string to filter + */ class WithFilter(p: Char => Boolean, s: String) { /** Applies `f` to each element for its side effects. * Note: [U] parameter needed to help scalac's type inference. + * + * @tparam U the return type of the function `f`, used only for side effects + * @param f the function to apply to each char */ def foreach[U](f: Char => U): Unit = { val len = s.length @@ -82,6 +89,7 @@ object StringOps { /** Builds a new collection by applying a function to all chars of this filtered string. * + * @tparam B the element type of the returned collection * @param f the function to apply to each char. * @return a new collection resulting from applying the given function * `f` to each char of this string and collecting the results. @@ -120,6 +128,7 @@ object StringOps { /** Builds a new collection by applying a function to all chars of this filtered string * and using the elements of the resulting collections. * + * @tparam B the element type of the returned collection * @param f the function to apply to each char. * @return a new collection resulting from applying the given collection-valued function * `f` to each char of this string and concatenating the results. @@ -155,7 +164,10 @@ object StringOps { sb.toString } - /** Creates a new non-strict filter which combines this filter with the given predicate. */ + /** Creates a new non-strict filter which combines this filter with the given predicate. + * + * @param q the additional predicate to apply to each char + */ def withFilter(q: Char => Boolean): WithFilter^{this, q} = new WithFilter(a => p(a) && q(a), s) } @@ -177,6 +189,8 @@ object StringOps { * The user is responsible for making sure such cases * are handled correctly. Failing to do so may result in * an invalid Unicode string. + * + * @param s the underlying string being wrapped */ final class StringOps(private val s: String) extends AnyVal { self => import StringOps._ @@ -187,7 +201,10 @@ final class StringOps(private val s: String) extends AnyVal { self => @inline def knownSize: Int = s.length - /** Gets the char at the specified index. */ + /** Gets the char at the specified index. + * + * @param i the zero-based index of the char to retrieve + */ @inline def apply(i: Int): Char = s.charAt(i) def sizeCompare(otherSize: Int): Int = Integer.compare(s.length, otherSize) @@ -200,6 +217,7 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Builds a new collection by applying a function to all chars of this string. * + * @tparam B the element type of the returned collection * @param f the function to apply to each char. * @return a new collection resulting from applying the given function * `f` to each char of this string and collecting the results. @@ -235,6 +253,7 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Builds a new collection by applying a function to all chars of this string * and using the elements of the resulting collections. * + * @tparam B the element type of the returned collection * @param f the function to apply to each char. * @return a new collection resulting from applying the given collection-valued function * `f` to each char of this string and concatenating the results. @@ -310,6 +329,7 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Returns a new collection containing the chars from this string followed by the elements from the * right hand operand. * + * @tparam B the element type of the returned collection, a supertype of `Char` * @param suffix the collection to append. * @return a new collection which contains all chars * of this string followed by all elements of `suffix`. @@ -347,17 +367,28 @@ final class StringOps(private val s: String) extends AnyVal { self => */ @inline def concat(suffix: String): String = s + suffix - /** Alias for `concat`. */ + /** Alias for `concat`. + * + * @tparam B the element type of the returned collection, a supertype of `Char` + * @param suffix the collection to append + */ @inline def ++[B >: Char](suffix: Iterable[B]^): immutable.IndexedSeq[B] = concat(suffix) - /** Alias for `concat`. */ + /** Alias for `concat`. + * + * @param suffix the collection of chars to append + */ @inline def ++(suffix: IterableOnce[Char]^): String = concat(suffix) - /** Alias for `concat`. */ + /** Alias for `concat`. + * + * @param xs the string to append + */ def ++(xs: String): String = concat(xs) /** Returns a collection with an element appended until a given target length is reached. * + * @tparam B the element type of the returned collection, a supertype of `Char` * @param len the target length * @param elem the padding value * @return a collection consisting of @@ -397,7 +428,11 @@ final class StringOps(private val s: String) extends AnyVal { self => } } - /** A copy of the string with an element prepended. */ + /** A copy of the string with an element prepended. + * + * @tparam B the element type of the returned collection, a supertype of `Char` + * @param elem the element to prepend + */ def prepended[B >: Char](elem: B): immutable.IndexedSeq[B] = { val b = immutable.IndexedSeq.newBuilder[B] b.sizeHint(s.length + 1) @@ -409,14 +444,21 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Alias for `prepended`. */ @inline def +: [B >: Char] (elem: B): immutable.IndexedSeq[B] = prepended(elem) - /** A copy of the string with an char prepended. */ + /** A copy of the string with an char prepended. + * + * @param c the char to prepend + */ def prepended(c: Char): String = new JStringBuilder(s.length + 1).append(c).append(s).toString /** Alias for `prepended`. */ @inline def +: (c: Char): String = prepended(c) - /** A copy of the string with all elements from a collection prepended. */ + /** A copy of the string with all elements from a collection prepended. + * + * @tparam B the element type of the returned collection, a supertype of `Char` + * @param prefix the collection to prepend + */ def prependedAll[B >: Char](prefix: IterableOnce[B]^): immutable.IndexedSeq[B] = { val b = immutable.IndexedSeq.newBuilder[B] val k = prefix.knownSize @@ -429,13 +471,20 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Alias for `prependedAll`. */ @inline def ++: [B >: Char] (prefix: IterableOnce[B]^): immutable.IndexedSeq[B] = prependedAll(prefix) - /** A copy of the string with another string prepended. */ + /** A copy of the string with another string prepended. + * + * @param prefix the string to prepend + */ def prependedAll(prefix: String): String = prefix + s /** Alias for `prependedAll`. */ @inline def ++: (prefix: String): String = prependedAll(prefix) - /** A copy of the string with an element appended. */ + /** A copy of the string with an element appended. + * + * @tparam B the element type of the returned collection, a supertype of `Char` + * @param elem the element to append + */ def appended[B >: Char](elem: B): immutable.IndexedSeq[B] = { val b = immutable.IndexedSeq.newBuilder[B] b.sizeHint(s.length + 1) @@ -447,14 +496,21 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Alias for `appended`. */ @inline def :+ [B >: Char](elem: B): immutable.IndexedSeq[B] = appended(elem) - /** A copy of the string with an element appended. */ + /** A copy of the string with an element appended. + * + * @param c the char to append + */ def appended(c: Char): String = new JStringBuilder(s.length + 1).append(s).append(c).toString /** Alias for `appended`. */ @inline def :+ (c: Char): String = appended(c) - /** A copy of the string with all elements from a collection appended. */ + /** A copy of the string with all elements from a collection appended. + * + * @tparam B the element type of the returned collection, a supertype of `Char` + * @param suffix the collection to append + */ @inline def appendedAll[B >: Char](suffix: IterableOnce[B]^): immutable.IndexedSeq[B] = concat(suffix) @@ -462,7 +518,10 @@ final class StringOps(private val s: String) extends AnyVal { self => @inline def :++ [B >: Char](suffix: IterableOnce[B]^): immutable.IndexedSeq[B] = concat(suffix) - /** A copy of the string with another string appended. */ + /** A copy of the string with another string appended. + * + * @param suffix the string to append + */ @inline def appendedAll(suffix: String): String = s + suffix /** Alias for `appendedAll`. */ @@ -474,6 +533,7 @@ final class StringOps(private val s: String) extends AnyVal { self => * Patching at indices at or larger than the length of the original string appends the patch to the end. * If more values are replaced than actually exist, the excess is ignored. * + * @tparam B the element type of the returned collection, a supertype of `Char` * @param from the index of the first replaced char * @param other the replacement collection * @param replaced the number of chars to drop in the original string @@ -588,14 +648,27 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Returns this string. */ @inline final def mkString: String = s - /** Appends this string to a string builder. */ + /** Appends this string to a string builder. + * + * @param b the string builder to append to + */ @inline final def addString(b: StringBuilder): b.type = b.append(s) - /** Appends this string to a string builder using a separator string. */ + /** Appends this string to a string builder using a separator string. + * + * @param b the string builder to append to + * @param sep the separator string inserted between chars + */ @inline final def addString(b: StringBuilder, sep: String): b.type = addString(b, "", sep, "") - /** Appends this string to a string builder using start, end and separator strings. */ + /** Appends this string to a string builder using start, end and separator strings. + * + * @param b the string builder to append to + * @param start the string to prepend before all chars + * @param sep the separator string inserted between chars + * @param end the string to append after all chars + */ final def addString(b: StringBuilder, start: String, sep: String, end: String): b.type = { val jsb = b.underlying if (start.length != 0) jsb.append(start) @@ -638,7 +711,10 @@ final class StringOps(private val s: String) extends AnyVal { self => else s.substring(start, end) } - /** Returns the current string concatenated `n` times. */ + /** Returns the current string concatenated `n` times. + * + * @param n the number of times to repeat this string + */ def *(n: Int): String = if (n <= 0) { "" @@ -668,6 +744,8 @@ final class StringOps(private val s: String) extends AnyVal { self => * including trailing line separator characters. * * The empty string yields an empty iterator. + * + * @return an iterator over the lines in this string, including line separator characters */ def linesWithSeparators: Iterator[String] = linesSeparated(stripped = false) @@ -716,6 +794,8 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Returns this string with the given `prefix` stripped. If this string does not * start with `prefix`, it is returned unchanged. + * + * @param prefix the prefix to strip from this string */ def stripPrefix(prefix: String): String = if (s.startsWith(prefix)) s.substring(prefix.length) @@ -723,6 +803,8 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Returns this string with the given `suffix` stripped. If this string does not * end with `suffix`, it is returned unchanged. + * + * @param suffix the suffix to strip from this string */ def stripSuffix(suffix: String): String = if (s.endsWith(suffix)) s.substring(0, s.length - suffix.length) @@ -742,6 +824,9 @@ final class StringOps(private val s: String) extends AnyVal { self => * * Strip a leading prefix consisting of blanks or control characters * followed by `marginChar` from the line. + * + * @param marginChar the character used as a margin delimiter + * @return the string with leading margin characters and preceding whitespace removed from each line */ def stripMargin(marginChar: Char): String = { val sb = new JStringBuilder(s.length) @@ -761,6 +846,8 @@ final class StringOps(private val s: String) extends AnyVal { self => * * Strip a leading prefix consisting of blanks or control characters * followed by `|` from the line. + * + * @return the string with leading `|` margin characters and preceding whitespace removed from each line */ def stripMargin: String = stripMargin('|') @@ -785,39 +872,31 @@ final class StringOps(private val s: String) extends AnyVal { self => * The behaviour follows, and is implemented in terms of String.split(re: String) * * - * @example ``` - * "a.b".split('.') //returns Array("a", "b") - * - * //splitting the empty string always returns the array with a single - * //empty string - * "".split('.') //returns Array("") - * - * //only trailing empty substrings are removed - * "a.".split('.') //returns Array("a") - * ".a.".split('.') //returns Array("", "a") - * "..a..".split('.') //returns Array("", "", "a") - * - * //all parts are empty and trailing - * ".".split('.') //returns Array() - * "..".split('.') //returns Array() - * - * //surrogate pairs + * @example ```scala sc:compile + * "a.b".split('.') // Array("a", "b") + * // splitting the empty string always returns the array with a single empty string + * "".split('.') // Array("") + * "a.".split('.') // Array("a") + * ".a.".split('.') // Array("", "a") + * "..a..".split('.') // Array("", "", "a") + * // all parts are empty and trailing + * ".".split('.') // Array() + * "..".split('.') // Array() + * // surrogate pairs * val high = 0xD852.toChar * val low = 0xDF62.toChar * val highstring = high.toString * val lowstring = low.toString - * - * //well-formed surrogate pairs are not split + * // well-formed surrogate pairs are not split * val highlow = highstring + lowstring - * highlow.split(high) //returns Array(highlow) - * - * //bare surrogate characters are split + * highlow.split(high) // Array(highlow) + * // bare surrogate characters are split * val bare = "_" + highstring + "_" - * bare.split(high) //returns Array("_", "_") - * + * bare.split(high) // Array("_", "_") * ``` - * * @param separator the character used as a delimiter + * + * @return an array of strings computed by splitting this string around occurrences of the separator character */ def split(separator: Char): Array[String] = s.split(escape(separator)) @@ -834,6 +913,8 @@ final class StringOps(private val s: String) extends AnyVal { self => * `"""(?\d\d)-(?\d\d)-(?\d\d\d\d)""".r` matches dates * and provides its subcomponents through groups named "month", "day" and * "year". + * + * @return a `Regex` with this string as the pattern */ def r: Regex = new Regex(s) @@ -958,6 +1039,7 @@ final class StringOps(private val s: String) extends AnyVal { self => * checks the format string at compilation. * * @param args the arguments used to instantiating the pattern. + * @return the string with format placeholders replaced by the formatted arguments * @throws java.util.IllegalFormatException if the format contains syntax or conversion errors */ def format(args: Any*): String = @@ -974,6 +1056,7 @@ final class StringOps(private val s: String) extends AnyVal { self => * * @param l an instance of `java.util.Locale` * @param args the arguments used to instantiating the pattern. + * @return the string with format placeholders replaced by the formatted arguments using the given locale * @throws java.util.IllegalFormatException if the format contains syntax or conversion errors */ def formatLocal(l: java.util.Locale, args: Any*): String = @@ -981,10 +1064,16 @@ final class StringOps(private val s: String) extends AnyVal { self => def compare(that: String): Int = s.compareTo(that) - /** Returns true if `this` is less than `that`. */ + /** Returns true if `this` is less than `that`. + * + * @param that the string to compare against + */ def < (that: String): Boolean = compare(that) < 0 - /** Returns true if `this` is greater than `that`. */ + /** Returns true if `this` is greater than `that`. + * + * @param that the string to compare against + */ def > (that: String): Boolean = compare(that) > 0 /** Returns true if `this` is less than or equal to `that`. */ @@ -993,7 +1082,10 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Returns true if `this` is greater than or equal to `that`. */ def >= (that: String): Boolean = compare(that) >= 0 - /** Counts the number of chars in this string which satisfy a predicate. */ + /** Counts the number of chars in this string which satisfy a predicate. + * + * @param p the predicate used to test chars + */ def count(p: (Char) => Boolean): Int = { var i, res = 0 val len = s.length @@ -1006,6 +1098,9 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Applies `f` to each element for its side effects. * Note: [U] parameter needed to help scalac's type inference. + * + * @tparam U the return type of the function `f`, used only for side effects + * @param f the function to apply to each char */ def foreach[U](f: Char => U): Unit = { val len = s.length @@ -1186,21 +1281,29 @@ final class StringOps(private val s: String) extends AnyVal { self => /** A string containing the first `n` chars of this string. * @note $unicodeunaware + * + * @param n the number of chars to take from the beginning of this string */ def take(n: Int): String = slice(0, min(n, s.length)) /** The rest of the string without its `n` first chars. * @note $unicodeunaware + * + * @param n the number of chars to drop from the beginning of this string */ def drop(n: Int): String = slice(min(n, s.length), s.length) /** A string containing the last `n` chars of this string. * @note $unicodeunaware + * + * @param n the number of chars to take from the end of this string */ def takeRight(n: Int): String = drop(s.length - max(n, 0)) /** The rest of the string without its `n` last chars. * @note $unicodeunaware + * + * @param n the number of chars to drop from the end of this string */ def dropRight(n: Int): String = take(s.length - max(n, 0)) @@ -1226,7 +1329,10 @@ final class StringOps(private val s: String) extends AnyVal { self => private def iterateUntilEmpty(f: String => String): Iterator[String]^{f} = Iterator.iterate(s)(f).takeWhile(x => !x.isEmpty) ++ Iterator.single("") - /** Selects all chars of this string which satisfy a predicate. */ + /** Selects all chars of this string which satisfy a predicate. + * + * @param pred the predicate used to test chars + */ def filter(pred: Char => Boolean): String = { val len = s.length val sb = new JStringBuilder(len) @@ -1239,7 +1345,10 @@ final class StringOps(private val s: String) extends AnyVal { self => if(len == sb.length()) s else sb.toString } - /** Selects all chars of this string which do not satisfy a predicate. */ + /** Selects all chars of this string which do not satisfy a predicate. + * + * @param pred the predicate used to test chars + */ @inline def filterNot(pred: Char => Boolean): String = filter(c => !pred(c)) /** Copies chars of this string to an array. @@ -1314,7 +1423,10 @@ final class StringOps(private val s: String) extends AnyVal { self => -1 } - /** Tests whether a predicate holds for at least one char of this string. */ + /** Tests whether a predicate holds for at least one char of this string. + * + * @param p the predicate used to test chars + */ def exists(p: Char => Boolean): Boolean = indexWhere(p) != -1 /** Finds the first char of the string satisfying a predicate, if any. @@ -1339,7 +1451,10 @@ final class StringOps(private val s: String) extends AnyVal { self => case i => s.substring(i) } - /** Takes longest prefix of chars that satisfy a predicate. */ + /** Takes longest prefix of chars that satisfy a predicate. + * + * @param p the predicate used to test chars + */ def takeWhile(p: Char => Boolean): String = indexWhere(c => !p(c)) match { case -1 => s case i => s.substring(0, i) @@ -1380,7 +1495,10 @@ final class StringOps(private val s: String) extends AnyVal { self => */ def grouped(size: Int): Iterator[String] = new StringOps.GroupedIterator(s, size) - /** A pair of, first, all chars that satisfy predicate `p` and, second, all chars that do not. */ + /** A pair of, first, all chars that satisfy predicate `p` and, second, all chars that do not. + * + * @param p the predicate used to partition chars + */ def partition(p: Char => Boolean): (String, String) = { val res1, res2 = new JStringBuilder var i = 0 @@ -1453,6 +1571,7 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Computes the multiset difference between this string and another sequence. * + * @tparam B the element type of the other sequence, a supertype of `Char` * @param that the sequence of chars to remove * @return a new string which contains all chars of this string * except some of occurrences of elements that also appear in `that`. @@ -1465,6 +1584,7 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Computes the multiset intersection between this string and another sequence. * + * @tparam B the element type of the other sequence, a supertype of `Char` * @param that the sequence of chars to intersect with. * @return a new string which contains all chars of this string * which also appear in `that`. @@ -1498,6 +1618,7 @@ final class StringOps(private val s: String) extends AnyVal { self => * * @see [[scala.math.Ordering]] * + * @tparam B the type over which the ordering is defined, a supertype of `Char` * @param ord the ordering to be used to compare elements. * @return a string consisting of the chars of this string * sorted according to the ordering `ord`. @@ -1588,6 +1709,7 @@ final class StringOps(private val s: String) extends AnyVal { self => * of the original sequence, but the order in which elements were selected, by "first index"; * the order of each `x` element is also arbitrary. * + * @param n the number of elements per combination * @return An Iterator which traverses the n-element combinations of this string. * @example ``` * "abbbc".combinations(2).foreach(println) @@ -1606,7 +1728,7 @@ final class StringOps(private val s: String) extends AnyVal { self => /** Iterates over distinct permutations of elements. * * @return An Iterator which traverses the distinct permutations of this string. - * @example ``` + * @example ```scala sc:compile * "abb".permutations.foreach(println) * // abb * // bab diff --git a/library/src/scala/collection/View.scala b/library/src/scala/collection/View.scala index 8f2342522e8d..bb03b016db06 100644 --- a/library/src/scala/collection/View.scala +++ b/library/src/scala/collection/View.scala @@ -26,6 +26,8 @@ import caps.unsafe.unsafeAssumePure * or when the view is converted to a strict collection type (using the `to` operation). * @define coll view * @define Coll `View` + * + * @tparam A the element type of the view */ trait View[+A] extends Iterable[A] with IterableOps[A, View, View[A]] with IterableFactoryDefaults[A, View] with Serializable { @@ -73,8 +75,8 @@ object View extends IterableFactory[View] { * @return A view iterating over the given `Iterable` */ def from[E](it: IterableOnce[E]^): View[E]^{it} = it match { - case it: (View[E]^{it}) => it - case it: (Iterable[E]^{it}) => View.fromIteratorProvider(() => it.iterator) + case it: (View[E @unchecked]^{it}) => it + case it: (Iterable[E @unchecked]^{it}) => View.fromIteratorProvider(() => it.iterator) case _ => LazyList.from(it).view } @@ -415,7 +417,7 @@ object View extends IterableFactory[View] { private[collection] class Patched[A](underlying: SomeIterableOps[A]^, from: Int, other: IterableOnce[A]^, replaced: Int) extends AbstractView[A] { // we may be unable to traverse `other` more than once, so we need to cache it if that's the case private val _other: Iterable[A]^{other} = other match { - case other: Iterable[A] => other + case other: Iterable[A @unchecked] => other case other => LazyList.from(other) } diff --git a/library/src/scala/collection/concurrent/TrieMap.scala b/library/src/scala/collection/concurrent/TrieMap.scala index c6ee982443c0..d138358fad40 100644 --- a/library/src/scala/collection/concurrent/TrieMap.scala +++ b/library/src/scala/collection/concurrent/TrieMap.scala @@ -105,7 +105,14 @@ private[collection] final class INode[K, V](bn: MainNode[K, V] | Null, g: Gen, e /** Inserts a key value pair, overwriting the old pair if the keys match. * - * @return true if successful, false otherwise + * @param k the key to insert + * @param v the value to associate with `k` + * @param hc the hashcode of `k` + * @param lev the current level in the trie (in bits, increments of 5) + * @param parent the parent i-node, or null if this is the root + * @param startgen the generation of the root when the operation started + * @param ct the TrieMap instance + * @return true if the insertion was committed, false if a retry is needed */ @tailrec def rec_insert(k: K, v: V, hc: Int, lev: Int, parent: INode[K, V] | Null, startgen: Gen, ct: TrieMap[K, V]): Boolean = { val m = GCAS_READ(ct) // use -Yinline! @@ -161,7 +168,13 @@ private[collection] final class INode[K, V](bn: MainNode[K, V] | Null, g: Gen, e * @param fullEquals whether to use reference or full equals when comparing `v` to the current value * @param hc the hashcode of `k` * - * @return null if unsuccessful, Option[V] otherwise (indicating previous value bound to the key) + * @param k the key to insert + * @param v the value to associate with `k` + * @param lev the current level in the trie (in bits, increments of 5) + * @param parent the parent i-node, or null if this is the root + * @param startgen the generation of the root when the operation started + * @param ct the TrieMap instance + * @return null if unsuccessful, `Option[V]` otherwise (indicating the previous value bound to the key) */ @tailrec def rec_insertif(k: K, v: V, hc: Int, cond: AnyRef, fullEquals: Boolean, lev: Int, parent: INode[K, V] | Null, startgen: Gen, ct: TrieMap[K, V]): Option[V] | Null = { val m = GCAS_READ(ct) // use -Yinline! @@ -256,6 +269,11 @@ private[collection] final class INode[K, V](bn: MainNode[K, V] | Null, g: Gen, e * * @param hc the hashcode of `k` * + * @param k the key to look up + * @param lev the current level in the trie (in bits, increments of 5) + * @param parent the parent i-node, or null if this is the root + * @param startgen the generation of the root when the operation started + * @param ct the TrieMap instance * @return NO_SUCH_ELEMENT_SENTINEL if no value has been found, RESTART if the operation wasn't successful, * or any other value otherwise */ @@ -306,6 +324,12 @@ private[collection] final class INode[K, V](bn: MainNode[K, V] | Null, g: Gen, e * @param removalPolicy policy deciding whether to remove `k` based on `v` and the * current value associated with `k` (Always, FullEquals, or ReferenceEq) * + * @param k the key to remove + * @param v the value to compare against when `removalPolicy` requires it + * @param lev the current level in the trie (in bits, increments of 5) + * @param parent the parent i-node, or null if this is the root + * @param startgen the generation of the root when the operation started + * @param ct the TrieMap instance * @return null if not successful, an Option[V] indicating the previous value otherwise */ def rec_remove( @@ -587,6 +611,9 @@ private[collection] final class CNode[K, V](val bitmap: Int, val array: Array[Ba /** Returns a copy of this cnode such that all the i-nodes below it are copied * to the specified generation `ngen`. + * + * @param ngen the new generation to copy i-nodes into + * @param ct the TrieMap instance */ def renewed(ngen: Gen, ct: TrieMap[K, V]) = { var i = 0 @@ -814,7 +841,7 @@ final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater * @param k the key to look up * @param hc the hashcode of `k` * - * @return the value: V associated with `k`, if it exists. Otherwise, INodeBase.NO_SUCH_ELEMENT_SENTINEL + * @return the value associated with `k` if it exists, or `INodeBase.NO_SUCH_ELEMENT_SENTINEL` if not found */ @tailrec private def lookuphc(k: K, hc: Int): AnyRef = { val r = RDCSS_READ_ROOT() @@ -826,9 +853,10 @@ final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater /** Removes a key-value pair from the map * * @param k the key to remove - * @param v the value compare with the value found associated with the key + * @param v the value to compare against the current value associated with the key * @param removalPolicy policy deciding whether to remove `k` based on `v` and the * current value associated with `k` (Always, FullEquals, or ReferenceEq) + * @param hc the hashcode of `k` * @return an `Option[V]` indicating the previous value */ @tailrec private def removehc(k: K, v: V, removalPolicy: Int, hc: Int): Option[V] = { @@ -855,6 +883,8 @@ final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater * This means that the work of rebuilding both the snapshot and this * TrieMap is distributed across all the threads doing updates or accesses * subsequent to the snapshot creation. + * + * @return a new mutable `TrieMap` snapshot that shares structure with this map */ @tailrec def snapshot(): TrieMap[K, V] = { val r = RDCSS_READ_ROOT() @@ -874,6 +904,8 @@ final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater * the `snapshot` method, but the obtained snapshot cannot be modified. * * This method is used by other methods such as `size` and `iterator`. + * + * @return an immutable read-only snapshot of this map */ @tailrec def readOnlySnapshot(): scala.collection.Map[K, V] = { val r = RDCSS_READ_ROOT() @@ -1071,7 +1103,8 @@ object TrieMap extends MapFactory[TrieMap] { } // non-final as an extension point for parallel collections -private[collection] class TrieMapIterator[K, V](var level: Int, private var ct: TrieMap[K, V], mustInit: Boolean = true) extends AbstractIterator[(K, V)] { self => +private[collection] class TrieMapIterator[K, V](var level: Int, private var ct: TrieMap[K, V], mustInit: Boolean = true) extends AbstractIterator[(K, V)] { + self: TrieMapIterator[K, V] => private val stack = new Array[Array[BasicNode]](7) private val stackpos = new Array[Int](7) private var depth = -1 diff --git a/library/src/scala/collection/convert/AsJavaConverters.scala b/library/src/scala/collection/convert/AsJavaConverters.scala index 3f38a7728c33..ba6d068bd4cf 100644 --- a/library/src/scala/collection/convert/AsJavaConverters.scala +++ b/library/src/scala/collection/convert/AsJavaConverters.scala @@ -41,6 +41,7 @@ trait AsJavaConverters { * If the Scala `Iterator` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `Iterator` will be returned. * + * @tparam A the element type of the iterator * @param i The Scala `Iterator` to be converted. * @return A Java `Iterator` view of the argument. */ @@ -58,6 +59,7 @@ trait AsJavaConverters { * If the Scala `Iterator` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `Enumeration` will be returned. * + * @tparam A the element type of the iterator * @param i The Scala `Iterator` to be converted. * @return A Java `Enumeration` view of the argument. */ @@ -75,6 +77,7 @@ trait AsJavaConverters { * If the Scala `Iterable` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `Iterable` will be returned. * + * @tparam A the element type of the iterable * @param i The Scala `Iterable` to be converted. * @return A Java `Iterable` view of the argument. */ @@ -89,6 +92,7 @@ trait AsJavaConverters { * If the Scala `Iterable` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `Collection` will be returned. * + * @tparam A the element type of the iterable * @param i The Scala `Iterable` to be converted. * @return A Java `Collection` view of the argument. */ @@ -106,6 +110,7 @@ trait AsJavaConverters { * If the Scala `Buffer` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `List` will be returned. * + * @tparam A the element type of the buffer * @param b The Scala `Buffer` to be converted. * @return A Java `List` view of the argument. */ @@ -123,6 +128,7 @@ trait AsJavaConverters { * If the Scala `Seq` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `List` will be returned. * + * @tparam A the element type of the sequence * @param s The Scala `Seq` to be converted. * @return A Java `List` view of the argument. */ @@ -140,6 +146,7 @@ trait AsJavaConverters { * If the Scala `Seq` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `List` will be returned. * + * @tparam A the element type of the sequence * @param s The Scala `Seq` to be converted. * @return A Java `List` view of the argument. */ @@ -157,6 +164,7 @@ trait AsJavaConverters { * If the Scala `Set` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `Set` will be returned. * + * @tparam A the element type of the set * @param s The Scala mutable `Set` to be converted. * @return A Java `Set` view of the argument. */ @@ -174,6 +182,7 @@ trait AsJavaConverters { * If the Scala `Set` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `Set` will be returned. * + * @tparam A the element type of the set * @param s The Scala `Set` to be converted. * @return A Java `Set` view of the argument. */ @@ -191,6 +200,8 @@ trait AsJavaConverters { * If the Scala `Map` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `Map` will be returned. * + * @tparam K the key type of the map + * @tparam V the value type of the map * @param m The Scala mutable `Map` to be converted. * @return A Java `Map` view of the argument. */ @@ -209,7 +220,9 @@ trait AsJavaConverters { * If the Scala `Map` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `Dictionary` will be returned. * - * @param m The Scala `Map` to be converted. + * @tparam K the key type of the map + * @tparam V the value type of the map + * @param m The Scala mutable `Map` to be converted. * @return A Java `Dictionary` view of the argument. */ def asJavaDictionary[K, V](m: mutable.Map[K, V]): ju.Dictionary[K, V] = (m: mutable.Map[K, V] | Null) match { @@ -226,6 +239,8 @@ trait AsJavaConverters { * If the Scala `Map` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `Map` will be returned. * + * @tparam K the key type of the map + * @tparam V the value type of the map * @param m The Scala `Map` to be converted. * @return A Java `Map` view of the argument. */ @@ -244,6 +259,8 @@ trait AsJavaConverters { * If the Scala `concurrent.Map` was previously obtained from an implicit or explicit call of * `asScala` then the original Java `ConcurrentMap` will be returned. * + * @tparam K the key type of the map + * @tparam V the value type of the map * @param m The Scala `concurrent.Map` to be converted. * @return A Java `ConcurrentMap` view of the argument. */ diff --git a/library/src/scala/collection/convert/AsScalaConverters.scala b/library/src/scala/collection/convert/AsScalaConverters.scala index 2ed9a460e3f6..8266528ff563 100644 --- a/library/src/scala/collection/convert/AsScalaConverters.scala +++ b/library/src/scala/collection/convert/AsScalaConverters.scala @@ -42,6 +42,7 @@ trait AsScalaConverters { * If the Java `Iterator` was previously obtained from an implicit or explicit call of * `asJava` then the original Scala `Iterator` will be returned. * + * @tparam A the element type of the iterator * @param i The Java `Iterator` to be converted. * @return A Scala `Iterator` view of the argument. */ @@ -59,6 +60,7 @@ trait AsScalaConverters { * If the Java `Enumeration` was previously obtained from an implicit or explicit call of * `asJavaEnumeration` then the original Scala `Iterator` will be returned. * + * @tparam A the element type of the enumeration * @param e The Java `Enumeration` to be converted. * @return A Scala `Iterator` view of the argument. */ @@ -76,6 +78,7 @@ trait AsScalaConverters { * If the Java `Iterable` was previously obtained from an implicit or explicit call of * `asJava` then the original Scala `Iterable` will be returned. * + * @tparam A the element type of the iterable * @param i The Java `Iterable` to be converted. * @return A Scala `Iterable` view of the argument. */ @@ -90,6 +93,7 @@ trait AsScalaConverters { * If the Java `Collection` was previously obtained from an implicit or explicit call of * `asJavaCollection` then the original Scala `Iterable` will be returned. * + * @tparam A the element type of the collection * @param c The Java `Collection` to be converted. * @return A Scala `Iterable` view of the argument. */ @@ -107,6 +111,7 @@ trait AsScalaConverters { * If the Java `List` was previously obtained from an implicit or explicit call of * `asJava` then the original Scala `Buffer` will be returned. * + * @tparam A the element type of the list * @param l The Java `List` to be converted. * @return A Scala mutable `Buffer` view of the argument. */ @@ -124,6 +129,7 @@ trait AsScalaConverters { * If the Java `Set` was previously obtained from an implicit or explicit call of * `asJava` then the original Scala `Set` will be returned. * + * @tparam A the element type of the set * @param s The Java `Set` to be converted. * @return A Scala mutable `Set` view of the argument. */ @@ -146,6 +152,8 @@ trait AsScalaConverters { * This includes `get`, as `java.util.Map`'s API does not allow for an atomic `get` when `null` * values may be present. * + * @tparam K the type of keys in the map + * @tparam V the type of values in the map * @param m The Java `Map` to be converted. * @return A Scala mutable `Map` view of the argument. */ @@ -164,6 +172,8 @@ trait AsScalaConverters { * If the Java `ConcurrentMap` was previously obtained from an implicit or explicit call of * `asJava` then the original Scala `ConcurrentMap` will be returned. * + * @tparam K the type of keys in the map + * @tparam V the type of values in the map * @param m The Java `ConcurrentMap` to be converted. * @return A Scala mutable `ConcurrentMap` view of the argument. */ @@ -181,6 +191,8 @@ trait AsScalaConverters { * If the Java `Dictionary` was previously obtained from an implicit or explicit call of * `asJavaDictionary` then the original Scala `Map` will be returned. * + * @tparam K the type of keys in the dictionary + * @tparam V the type of values in the dictionary * @param d The Java `Dictionary` to be converted. * @return A Scala mutable `Map` view of the argument. */ diff --git a/library/src/scala/collection/convert/ImplicitConversions.scala b/library/src/scala/collection/convert/ImplicitConversions.scala index 11e402848a13..ba426b126972 100644 --- a/library/src/scala/collection/convert/ImplicitConversions.scala +++ b/library/src/scala/collection/convert/ImplicitConversions.scala @@ -162,6 +162,20 @@ object ImplicitConversionsToJava extends ToJavaImplicits * * It is recommended to use explicit conversions provided by [[collection.JavaConverters]] instead. * Implicit conversions may cause unexpected issues, see [[ImplicitConversions]]. + * Example: + * + * ```scala sc-hidden sc-name:import-implicit-conversions + * import collection.convert.ImplicitConversions._ + * ``` + * ```scala sc-compile-with:import-implicit-conversions + * case class StringBox(s: String) + * val m = Map(StringBox("one") -> "uno") + * m.get("one") + * ``` + * + * The above example returns `null` instead of producing a type error at compile-time. The map is + * implicitly converted to a `java.util.Map` which provides a method `get(x: AnyRef)`. + * */ @deprecated("Use `scala.jdk.CollectionConverters` instead", "2.13.0") object ImplicitConversionsToScala extends ToScalaImplicits @@ -172,8 +186,10 @@ object ImplicitConversionsToScala extends ToScalaImplicits * It is recommended to use explicit conversions provided by [[collection.JavaConverters]] instead. * Implicit conversions may cause unexpected issues. Example: * - * ``` + * ```scala sc-hidden sc-name:import-implicit-conversions * import collection.convert.ImplicitConversions._ + * ``` + * ```scala sc-compile-with:import-implicit-conversions * case class StringBox(s: String) * val m = Map(StringBox("one") -> "uno") * m.get("one") @@ -181,7 +197,7 @@ object ImplicitConversionsToScala extends ToScalaImplicits * * The above example returns `null` instead of producing a type error at compile-time. The map is * implicitly converted to a `java.util.Map` which provides a method `get(x: AnyRef)`. - + * */ @deprecated("Use `scala.jdk.CollectionConverters` instead", "2.13.0") object ImplicitConversions extends ToScalaImplicits with ToJavaImplicits diff --git a/library/src/scala/collection/convert/JavaCollectionWrappers.scala b/library/src/scala/collection/convert/JavaCollectionWrappers.scala index 6dc918ac330b..9bab9276c112 100644 --- a/library/src/scala/collection/convert/JavaCollectionWrappers.scala +++ b/library/src/scala/collection/convert/JavaCollectionWrappers.scala @@ -252,7 +252,8 @@ private[collection] object JavaCollectionWrappers extends Serializable { } @SerialVersionUID(3L) - class MapWrapper[K, V](underlying: Map[K, V]) extends ju.AbstractMap[K, V] with Serializable { self => + class MapWrapper[K, V](underlying: Map[K, V]) extends ju.AbstractMap[K, V] with Serializable { + self: MapWrapper[K, V] => override def size = underlying.size override def get(key: AnyRef): V = try { diff --git a/library/src/scala/collection/convert/StreamExtensions.scala b/library/src/scala/collection/convert/StreamExtensions.scala index 308ce286b185..cd8ee14e1600 100644 --- a/library/src/scala/collection/convert/StreamExtensions.scala +++ b/library/src/scala/collection/convert/StreamExtensions.scala @@ -37,6 +37,8 @@ trait StreamExtensions { /** Creates a sequential [[java.util.stream.Stream Java Stream]] for this collection. If the * collection contains primitive values, a corresponding specialized Stream is returned (e.g., * [[java.util.stream.IntStream `IntStream`]]). + * + * @tparam S the type of Java Stream to create, determined by the element type `A` */ def asJavaSeqStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[A, S, St], st: StepperShape[A, St]): S = s.fromStepper(cc.stepper, par = false) @@ -51,6 +53,8 @@ trait StreamExtensions { /** Creates a parallel [[java.util.stream.Stream Java Stream]] for this collection. If the * collection contains primitive values, a corresponding specialized Stream is returned (e.g., * [[java.util.stream.IntStream `IntStream`]]). + * + * @tparam S the type of Java Stream to create, determined by the element type `A` */ def asJavaParStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[A, S, St], @@ -66,6 +70,8 @@ trait StreamExtensions { /** Creates a sequential [[java.util.stream.Stream Java Stream]] for the keys of this map. If * the keys are primitive values, a corresponding specialized Stream is returned (e.g., * [[java.util.stream.IntStream `IntStream`]]). + * + * @tparam S the type of Java Stream to create, determined by the key type `K` */ def asJavaSeqKeyStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[K, S, St], st: StepperShape[K, St]): S = s.fromStepper(cc.keyStepper, par = false) @@ -73,6 +79,8 @@ trait StreamExtensions { /** Creates a sequential [[java.util.stream.Stream Java Stream]] for the values of this map. If * the values are primitives, a corresponding specialized Stream is returned (e.g., * [[java.util.stream.IntStream `IntStream`]]). + * + * @tparam S the type of Java Stream to create, determined by the value type `V` */ def asJavaSeqValueStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[V, S, St], st: StepperShape[V, St]): S = s.fromStepper(cc.valueStepper, par = false) @@ -80,6 +88,8 @@ trait StreamExtensions { // The asJavaSeqStream extension method for IterableOnce doesn't apply because its `CC` takes a single type parameter, whereas the one here takes two /** Creates a sequential [[java.util.stream.Stream Java Stream]] for the `(key, value)` pairs of * this map. + * + * @tparam S the type of Java Stream to create, determined by the pair type `(K, V)` */ def asJavaSeqStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[(K, V), S, St], st: StepperShape[(K, V), St]): S = s.fromStepper(cc.stepper, par = false) @@ -94,6 +104,8 @@ trait StreamExtensions { /** Creates a parallel [[java.util.stream.Stream Java Stream]] for the keys of this map. If * the keys are primitive values, a corresponding specialized Stream is returned (e.g., * [[java.util.stream.IntStream `IntStream`]]). + * + * @tparam S the type of Java Stream to create, determined by the key type `K` */ def asJavaParKeyStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[K, S, St], @@ -105,6 +117,8 @@ trait StreamExtensions { /** Creates a parallel [[java.util.stream.Stream Java Stream]] for the values of this map. If * the values are primitives, a corresponding specialized Stream is returned (e.g., * [[java.util.stream.IntStream `IntStream`]]). + * + * @tparam S the type of Java Stream to create, determined by the value type `V` */ def asJavaParValueStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[V, S, St], @@ -116,6 +130,8 @@ trait StreamExtensions { // The asJavaParStream extension method for IterableOnce doesn't apply because its `CC` takes a single type parameter, whereas the one here takes two /** Creates a parallel [[java.util.stream.Stream Java Stream]] for the `(key, value)` pairs of * this map. + * + * @tparam S the type of Java Stream to create, determined by the pair type `(K, V)` */ def asJavaParStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[(K, V), S, St], @@ -131,10 +147,12 @@ trait StreamExtensions { /** Creates a sequential [[java.util.stream.Stream Java Stream]] for this stepper. If the * stepper yields primitive values, a corresponding specialized Stream is returned (e.g., * [[java.util.stream.IntStream `IntStream`]]). + * + * @tparam S the type of Java Stream to create, determined by the element type `A` */ def asJavaSeqStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[A, S, St], st: StepperShape[A, St]): S = { val sStepper = stepper match { - case as: AnyStepper[A] => st.seqUnbox(as) + case as: AnyStepper[A @unchecked] => st.seqUnbox(as) case _ => stepper.asInstanceOf[St] } s.fromStepper(sStepper, par = false) @@ -145,6 +163,8 @@ trait StreamExtensions { /** Creates a parallel [[java.util.stream.Stream Java Stream]] for this stepper. If the * stepper yields primitive values, a corresponding specialized Stream is returned (e.g., * [[java.util.stream.IntStream `IntStream`]]). + * + * @tparam S the type of Java Stream to create, determined by the element type `A` */ def asJavaParStream[S <: BaseStream[?, ?], St <: Stepper[?]](implicit s: StreamShape[A, S, St], st: StepperShape[A, St]): S = { val sStepper = (stepper: @unchecked) match { @@ -260,6 +280,11 @@ trait StreamExtensions { * * Sequential streams are directly converted to the target collection. If the target collection * is lazy, the conversion is lazy as well. + * + * @tparam C1 the type of the target Scala collection + * @param factory the factory used to build the target collection + * @param info implicit evidence connecting the element type to a specialized `Accumulator`, or a generic fallback (resolved automatically) + * @return the elements of this stream collected into a Scala collection of type `C1` */ def toScala[C1](factory: collection.Factory[A, C1])(implicit info: AccumulatorFactoryInfo[A, C1]): C1 = { @@ -274,6 +299,9 @@ trait StreamExtensions { /** Converts a generic Java Stream wrapping a primitive type to a corresponding primitive * Stream. + * + * @tparam S the resulting primitive stream type (e.g., `IntStream`, `LongStream`, `DoubleStream`) + * @param unboxer implicit conversion from boxed `Stream[A]` to primitive stream `S` */ def asJavaPrimitiveStream[S](implicit unboxer: StreamUnboxer[A, S]): S = unboxer(stream) } @@ -294,6 +322,11 @@ trait StreamExtensions { * * Sequential streams are directly converted to the target collection. If the target collection * is lazy, the conversion is lazy as well. + * + * @tparam C1 the type of the target Scala collection + * @param factory the factory used to build the target collection + * @param info implicit evidence connecting `Int` to a specialized `IntAccumulator`, or a generic fallback + * @return the elements of this stream collected into a Scala collection of type `C1` */ def toScala[C1](factory: collection.Factory[Int, C1])(implicit info: AccumulatorFactoryInfo[Int, C1]): C1 = { def intAcc = stream.collect(IntAccumulator.supplier, IntAccumulator.adder, IntAccumulator.merger) @@ -320,6 +353,11 @@ trait StreamExtensions { * * Sequential streams are directly converted to the target collection. If the target collection * is lazy, the conversion is lazy as well. + * + * @tparam C1 the type of the target Scala collection + * @param factory the factory used to build the target collection + * @param info implicit evidence connecting `Long` to a specialized `LongAccumulator`, or a generic fallback + * @return the elements of this stream collected into a Scala collection of type `C1` */ def toScala[C1](factory: collection.Factory[Long, C1])(implicit info: AccumulatorFactoryInfo[Long, C1]): C1 = { def longAcc = stream.collect(LongAccumulator.supplier, LongAccumulator.adder, LongAccumulator.merger) @@ -346,6 +384,11 @@ trait StreamExtensions { * * Sequential streams are directly converted to the target collection. If the target collection * is lazy, the conversion is lazy as well. + * + * @tparam C1 the type of the target Scala collection + * @param factory the factory used to build the target collection + * @param info implicit evidence connecting `Double` to a specialized `DoubleAccumulator`, or a generic fallback + * @return the elements of this stream collected into a Scala collection of type `C1` */ def toScala[C1](factory: collection.Factory[Double, C1])(implicit info: AccumulatorFactoryInfo[Double, C1]): C1 = { def doubleAcc = stream.collect(DoubleAccumulator.supplier, DoubleAccumulator.adder, DoubleAccumulator.merger) @@ -361,6 +404,10 @@ object StreamExtensions { /** An implicit StreamShape instance connects element types with the corresponding specialized * Stream and Stepper types. This is used in `asJavaStream` extension methods to create * generic or primitive streams according to the element type. + * + * @tparam T the element type of the collection + * @tparam S the type of Java Stream (e.g., `Stream[T]`, `IntStream`, `LongStream`, `DoubleStream`) + * @tparam St the type of `Stepper` used to traverse elements */ sealed trait StreamShape[T, S <: BaseStream[?, ?], St <: Stepper[?]] { final def fromStepper(st: St, par: Boolean): S = mkStream(st, par) @@ -413,6 +460,9 @@ object StreamExtensions { /** Connects a stream element type `A` to the corresponding, potentially specialized, Stream type. * Used in the `stream.asJavaPrimitiveStream` extension method. + * + * @tparam A the boxed element type of the stream + * @tparam S the target primitive stream type (e.g., `IntStream`, `LongStream`, `DoubleStream`) */ sealed trait StreamUnboxer[A, S] { def apply(s: Stream[A]): S @@ -442,6 +492,9 @@ object StreamExtensions { * * When converting to a collection other than `Accumulator`, the generic * `noAccumulatorFactoryInfo` is passed. + * + * @tparam A the element type of the stream + * @tparam C the target collection type, potentially a specialized `Accumulator` */ trait AccumulatorFactoryInfo[A, C] { val companion: AnyRef | Null diff --git a/library/src/scala/collection/convert/impl/BinaryTreeStepper.scala b/library/src/scala/collection/convert/impl/BinaryTreeStepper.scala index 0c57f7346f08..5f9bfdff2935 100644 --- a/library/src/scala/collection/convert/impl/BinaryTreeStepper.scala +++ b/library/src/scala/collection/convert/impl/BinaryTreeStepper.scala @@ -45,6 +45,11 @@ private[collection] object BinaryTreeStepper { * * Subclasses should allow this class to do all the work of maintaining state; `next` should simply * reduce `maxLength` by one, and consume `myCurrent` and set it to `null` if `hasNext` is true. + * + * @tparam A the element type produced by this stepper + * @tparam T the type of tree nodes being traversed, must be a reference type + * @tparam Sub the public stepper type returned by `trySplit` + * @tparam Semi the self type of the concrete stepper subclass, which must extend both `Sub` and `BinaryTreeStepperBase` */ private[collection] abstract class BinaryTreeStepperBase[A, T <: AnyRef, Sub, Semi <: Sub & BinaryTreeStepperBase[A, T, ?, ?]]( protected var maxLength: Int, protected var myCurrent: T | Null, protected var stack: Array[AnyRef | Null], protected var index: Int, @@ -54,6 +59,8 @@ extends EfficientSplit { /** Unrolls a subtree onto the stack starting from a particular node, returning * the last node found. This final node is _not_ placed on the stack, and * may have things to its right. + * + * @param from the tree node from which to begin unrolling leftward */ @tailrec protected final def unroll(from: T): T = { val l = left(from) @@ -71,6 +78,8 @@ extends EfficientSplit { * the subtree from the stack entirely (so it is ready to use). It returns * the node that is being detached. Note that the node must _not_ already be * on the stack. + * + * @param node the tree node to detach, whose left subtree has already been visited */ protected final def detach(node: T): node.type = { val r = right(node) @@ -88,6 +97,9 @@ extends EfficientSplit { * tree is not already empty. * * Right now overwrites everything so could allow reuse, but isn't used for it. + * + * @param root the root node of the tree to traverse, or `null` for an empty tree + * @param size the total number of elements in the tree */ private[impl] final def initialize(root: T | Null, size: Int): Unit = if (root eq null) { @@ -122,6 +134,8 @@ extends EfficientSplit { * detaching the root, and leaving the right-hand side of the root unrolled. * * If the tree is empty or only has one element left, it returns `null` instead of splitting. + * + * @return a new stepper covering the left portion of the remaining elements, or `null` if the stepper cannot be split */ def trySplit(): Sub | Null = if (!hasStep || index < 0) null diff --git a/library/src/scala/collection/convert/impl/ChampStepper.scala b/library/src/scala/collection/convert/impl/ChampStepper.scala index 692d9eb8a4e2..ec7a6c7dd306 100644 --- a/library/src/scala/collection/convert/impl/ChampStepper.scala +++ b/library/src/scala/collection/convert/impl/ChampStepper.scala @@ -21,6 +21,9 @@ import scala.collection.immutable.Node /** A stepper that is a slightly elaborated version of the ChampBaseIterator; * the main difference is that it knows when it should stop instead of running * to the end of all trees. + * + * @tparam A the element type produced by this stepper + * @tparam T the CHAMP trie node type, with recursive bound `T <: Node[T]` */ private[collection] abstract class ChampStepperBase[ A, T <: Node[T], Sub, Semi <: Sub & ChampStepperBase[A, T, ?, ?] diff --git a/library/src/scala/collection/convert/impl/InOrderStepperBase.scala b/library/src/scala/collection/convert/impl/InOrderStepperBase.scala index 45b365be8ea1..ddda92eef30f 100644 --- a/library/src/scala/collection/convert/impl/InOrderStepperBase.scala +++ b/library/src/scala/collection/convert/impl/InOrderStepperBase.scala @@ -22,6 +22,11 @@ import scala.collection.Stepper.EfficientSplit * that has an indexable ordering but may have gaps. * * For collections that are guaranteed to not have gaps, use `IndexedStepperBase` instead. + * + * @tparam Sub the concrete stepper subtype, used as the self-type and return type of `trySplit` + * @tparam Semi the concrete type of the split-off stepper half, constrained to be a subtype of `Sub` + * @param i0 the starting index (inclusive) of the range to step over + * @param iN the ending index (exclusive) of the range to step over */ private[convert] abstract class InOrderStepperBase[Sub, Semi <: Sub](protected var i0: Int, protected var iN: Int) extends EfficientSplit { diff --git a/library/src/scala/collection/convert/impl/IndexedStepperBase.scala b/library/src/scala/collection/convert/impl/IndexedStepperBase.scala index 9d8420bf1652..ccc9f54971ca 100644 --- a/library/src/scala/collection/convert/impl/IndexedStepperBase.scala +++ b/library/src/scala/collection/convert/impl/IndexedStepperBase.scala @@ -18,7 +18,13 @@ import java.util.Spliterator import scala.collection.Stepper.EfficientSplit -/** Abstracts all the generic operations of stepping over an indexable collection. */ +/** Abstracts all the generic operations of stepping over an indexable collection. + * + * @tparam Sub the concrete stepper subtype + * @tparam Semi the type returned by splitting, a subtype of `Sub` + * @param i0 the starting index (inclusive) into the underlying collection + * @param iN the ending index (exclusive) into the underlying collection + */ private[convert] abstract class IndexedStepperBase[Sub, Semi <: Sub](protected var i0: Int, protected var iN: Int) extends EfficientSplit { protected def semiclone(half: Int): Semi diff --git a/library/src/scala/collection/convert/impl/IteratorStepper.scala b/library/src/scala/collection/convert/impl/IteratorStepper.scala index 2e8e35e29205..39211d25fab9 100644 --- a/library/src/scala/collection/convert/impl/IteratorStepper.scala +++ b/library/src/scala/collection/convert/impl/IteratorStepper.scala @@ -119,7 +119,12 @@ private[collection] class LongIteratorStepper(_underlying: Iterator[Long] | Null } } -/** Common functionality for Steppers that step through an Iterator, caching the results as needed when a split is requested. */ +/** Common functionality for Steppers that step through an Iterator, caching the results as needed when a split is requested. + * + * @tparam A the element type of the iterator being stepped through + * @tparam SP the specific `Stepper` subtype, bounded by `Stepper[A]`, used for proxied delegation and split results + * @tparam Semi the concrete stepper subtype returned by `semiclone()`, must extend `SP` + */ private[convert] abstract class IteratorStepperBase[A, SP <: Stepper[A], Semi <: SP](final protected val underlying: Iterator[A] | Null) { final protected var nextChunkSize = 16 @annotation.stableNull diff --git a/library/src/scala/collection/convert/impl/RangeStepper.scala b/library/src/scala/collection/convert/impl/RangeStepper.scala index 9f784c3cf063..41f29ab380f9 100644 --- a/library/src/scala/collection/convert/impl/RangeStepper.scala +++ b/library/src/scala/collection/convert/impl/RangeStepper.scala @@ -19,6 +19,11 @@ import scala.collection.{IntStepper, Stepper} /** Implements Stepper on an integer Range. You don't actually need the Range to do this, * so only the relevant parts are included. Because the arguments are protected, they are * not error-checked; `Range` is required to provide valid arguments. + * + * @param myNext the next integer value to be produced by this stepper + * @param myStep the increment between consecutive elements of the range + * @param _i0 the starting index (inclusive) into the logical element sequence + * @param _iN the ending index (exclusive) into the logical element sequence */ private[collection] final class RangeStepper(protected var myNext: Int, myStep: Int, _i0: Int, _iN: Int) extends IndexedStepperBase[IntStepper, RangeStepper](_i0, _iN) diff --git a/library/src/scala/collection/convert/impl/StringStepper.scala b/library/src/scala/collection/convert/impl/StringStepper.scala index 0dd3f3d186e8..32406c704e6e 100644 --- a/library/src/scala/collection/convert/impl/StringStepper.scala +++ b/library/src/scala/collection/convert/impl/StringStepper.scala @@ -20,7 +20,10 @@ import java.util.Spliterator import scala.collection.Stepper.EfficientSplit import scala.collection.{IntStepper, Stepper} -/** Implements `Stepper` on a `String` where you step through chars packed into `Int`. */ +/** Implements `Stepper` on a `String` where you step through chars packed into `Int`. + * + * @param underlying the `String` to step through + */ private[collection] final class CharStringStepper(underlying: String, _i0: Int, _iN: Int) extends IndexedStepperBase[IntStepper, CharStringStepper](_i0, _iN) with IntStepper { @@ -31,7 +34,12 @@ with IntStepper { def semiclone(half: Int): CharStringStepper = new CharStringStepper(underlying, i0, half) } -/** Implements `Stepper` on a `String` where you step through code points. */ +/** Implements `Stepper` on a `String` where you step through code points. + * + * @param underlying the `String` to step through by code point + * @param i0 the starting char index (inclusive) into the string + * @param iN the ending char index (exclusive) into the string + */ private[collection] final class CodePointStringStepper(underlying: String, private var i0: Int, private var iN: Int) extends IntStepper with EfficientSplit { def characteristics: Int = Spliterator.IMMUTABLE | Spliterator.NONNULL | Spliterator.ORDERED diff --git a/library/src/scala/collection/generic/CommonErrors.scala b/library/src/scala/collection/generic/CommonErrors.scala index f2500b7db116..83a347963135 100644 --- a/library/src/scala/collection/generic/CommonErrors.scala +++ b/library/src/scala/collection/generic/CommonErrors.scala @@ -18,12 +18,19 @@ import language.experimental.captureChecking /** Some precomputed common errors to reduce the generated code size. */ private[collection] object CommonErrors { - /** IndexOutOfBounds exception with a known max index. */ + /** IndexOutOfBounds exception with a known max index. + * + * @param index the index that was out of bounds + * @param max the upper bound of the valid index range + */ @noinline def indexOutOfBounds(index: Int, max: Int): IndexOutOfBoundsException = new IndexOutOfBoundsException(s"$index is out of bounds (min 0, max ${max})") - /** IndexOutOfBounds exception with an unknown max index. */ + /** IndexOutOfBounds exception with an unknown max index. + * + * @param index the index that was out of bounds + */ @noinline def indexOutOfBounds(index: Int): IndexOutOfBoundsException = new IndexOutOfBoundsException(s"$index is out of bounds (min 0, max unknown)") diff --git a/library/src/scala/collection/generic/IsIterable.scala b/library/src/scala/collection/generic/IsIterable.scala index 63f2d0267866..95ed542cb447 100644 --- a/library/src/scala/collection/generic/IsIterable.scala +++ b/library/src/scala/collection/generic/IsIterable.scala @@ -39,7 +39,7 @@ import caps.unsafe.untrackedCaptures * is to provide a generic extension method `mapReduce` for any type that extends * or can be converted to `Iterable`, such as `String`. * - * ``` + * ```scala sc:compile * import scala.collection.generic.IsIterable * * extension [Repr, I <: IsIterable[Repr]](coll: Repr)(using it: I) @@ -51,9 +51,9 @@ import caps.unsafe.untrackedCaptures * res * } * - * // See it in action! - * List(1, 2, 3).mapReduce(_ * 2)(_ + _) // res0: Int = 12 - * "Yeah, well, you know, that's just, like, your opinion, man.".mapReduce(x => 1)(_ + _) // res1: Int = 59 + * // See it in action! + * val res0 = List(1, 2, 3).mapReduce(_ * 2)(_ + _) // res0: Int = 12 + * val res1 = "Yeah, well, you know, that's just, like, your opinion, man.".mapReduce(x => 1)(_ + _) // res1: Int = 59 * ``` * * The extension method takes a receiver `coll` of type `Repr`, where @@ -79,7 +79,10 @@ import caps.unsafe.untrackedCaptures * the implicit value for any `IterableOps`, as for `List` in the previous example. * Similarly, the instance for `String` was available because the library provides an `IsSeq[String]`. * + * ```scala sc-name:iterableops-import sc-hidden + * import scala.collection.IterableOps * ``` + * ```scala sc-compile-with:iterableops-import * implicit val rangeRepr: IsIterable[Range] { type A = Int; type C = IndexedSeq[Int] } = * new IsIterable[Range] { * type A = Int @@ -87,6 +90,11 @@ import caps.unsafe.untrackedCaptures * def apply(coll: Range): IterableOps[Int, IndexedSeq, IndexedSeq[Int]] = coll * } * ``` + * + * @note In practice the `IsIterable[Range]` instance is already provided by + * the standard library, and it is defined as an `IsSeq[Range]` instance. + * + * @tparam Repr the representation type (e.g. `String`, `Array[Int]`) that can be converted to an `Iterable` */ transparent trait IsIterable[Repr] extends IsIterableOnce[Repr] { @@ -102,7 +110,10 @@ transparent trait IsIterable[Repr] extends IsIterableOnce[Repr] { @untrackedCaptures override val conversion: Repr => IterableOps[A, Iterable, C] = apply(_) - /** A conversion from the type `Repr` to `IterableOps[A, Iterable, C]`. */ + /** A conversion from the type `Repr` to `IterableOps[A, Iterable, C]`. + * + * @param coll the collection or value to convert to `IterableOps[A, Iterable, C]` + */ def apply(coll: Repr): IterableOps[A, Iterable, C] } diff --git a/library/src/scala/collection/generic/IsIterableOnce.scala b/library/src/scala/collection/generic/IsIterableOnce.scala index c77d9e23bc8a..695bdfbd7e3f 100644 --- a/library/src/scala/collection/generic/IsIterableOnce.scala +++ b/library/src/scala/collection/generic/IsIterableOnce.scala @@ -26,7 +26,10 @@ import caps.unsafe.untrackedCaptures * framework in their implementation. * * Example usage, + * ```scala sc-name:import-buildfrom sc-hidden + * import scala.collection.BuildFrom * ``` + * ```scala sc-compile-with:import-buildfrom * extension [Repr, I <: IsIterableOnce[Repr]](coll: Repr)(using it: I) { * final def filterMap[B, That](f: it.A => Option[B])(using bf: BuildFrom[Repr, B, That]): That = { * val b = bf.newBuilder(coll) @@ -38,6 +41,8 @@ import caps.unsafe.untrackedCaptures * List(1, 2, 3, 4, 5).filterMap(i => if(i % 2 == 0) Some(i) else None) * // == List(2, 4) * ``` + * + * @tparam Repr the collection representation type that can be converted to `IterableOnce` */ transparent trait IsIterableOnce[Repr] { @@ -48,7 +53,10 @@ transparent trait IsIterableOnce[Repr] { @untrackedCaptures val conversion: Repr => IterableOnce[A] = apply(_) - /** A conversion from the representation type `Repr` to a `IterableOnce[A]`. */ + /** A conversion from the representation type `Repr` to an `IterableOnce[A]`. + * + * @param coll the representation type instance to view as an `IterableOnce[A]` + */ def apply(coll: Repr): IterableOnce[A] } diff --git a/library/src/scala/collection/generic/IsMap.scala b/library/src/scala/collection/generic/IsMap.scala index d562de71200d..2e9ae8c28c74 100644 --- a/library/src/scala/collection/generic/IsMap.scala +++ b/library/src/scala/collection/generic/IsMap.scala @@ -43,6 +43,9 @@ transparent trait IsMap[Repr] extends IsIterable[Repr] { * @note The third type parameter of the returned `MapOps` value is * still `Iterable` (and not `Map`) because `MapView[K, V]` only * extends `MapOps[K, V, View, View[A]]`. + * + * @param c the collection to convert to `MapOps` + * @return a `MapOps[K, V, Iterable, C]` view of the collection */ override def apply(c: Repr): MapOps[K, V, Tupled[Iterable]#Ap, C] diff --git a/library/src/scala/collection/generic/IsSeq.scala b/library/src/scala/collection/generic/IsSeq.scala index 76b001cb064e..3c422af4bf0c 100644 --- a/library/src/scala/collection/generic/IsSeq.scala +++ b/library/src/scala/collection/generic/IsSeq.scala @@ -28,6 +28,8 @@ import scala.reflect.ClassTag * their implementation. * * @see [[scala.collection.generic.IsIterable]] + * + * @tparam Repr the collection representation type that is witnessed to have sequence-like operations */ transparent trait IsSeq[Repr] extends IsIterable[Repr] { @@ -40,6 +42,9 @@ transparent trait IsSeq[Repr] extends IsIterable[Repr] { * @note The second type parameter of the returned `SeqOps` value is * still `Iterable` (and not `Seq`) because `SeqView[A]` only * extends `SeqOps[A, View, View[A]]`. + * + * @param coll the collection to convert + * @return a `SeqOps` instance that provides sequence operations on `coll` */ def apply(coll: Repr): SeqOps[A, Iterable, C] } diff --git a/library/src/scala/collection/immutable/ArraySeq.scala b/library/src/scala/collection/immutable/ArraySeq.scala index 711062b56273..56f325f8d391 100644 --- a/library/src/scala/collection/immutable/ArraySeq.scala +++ b/library/src/scala/collection/immutable/ArraySeq.scala @@ -33,6 +33,8 @@ import scala.util.hashing.MurmurHash3 * * @define coll immutable array * @define Coll `ArraySeq` + * + * @tparam A the element type of the immutable array */ sealed abstract class ArraySeq[+A] extends AbstractSeq[A] @@ -90,7 +92,9 @@ sealed abstract class ArraySeq[+A] /** Fast concatenation of two [[ArraySeq]]s. * - * @return null if optimisation not possible. + * @tparam B the element type of the resulting sequence, a supertype of `A` + * @param that the `ArraySeq` to append to this sequence + * @return the concatenated `ArraySeq`, or `null` if optimization is not possible */ private def appendedAllArraySeq[B >: A](that: ArraySeq[B]): ArraySeq[B] | Null = { // Optimise concatenation of two ArraySeqs @@ -310,6 +314,10 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self => * boxed, the resulting instance is an [[ArraySeq.ofRef]]. Writing * `ArraySeq.unsafeWrapArray(a.asInstanceOf[Array[Int]])` does not work, it throws a * `ClassCastException` at runtime. + * + * @tparam T the element type of the array to wrap + * @param x the array to wrap, which must not be modified after wrapping + * @return an `ArraySeq` backed by the given array, using the appropriate primitive specialization */ def unsafeWrapArray[T](x: Array[T]): ArraySeq[T] = ((x: @unchecked) match { case null => null diff --git a/library/src/scala/collection/immutable/BitSet.scala b/library/src/scala/collection/immutable/BitSet.scala index 677169f244cc..725a51fdd86a 100644 --- a/library/src/scala/collection/immutable/BitSet.scala +++ b/library/src/scala/collection/immutable/BitSet.scala @@ -65,7 +65,11 @@ sealed abstract class BitSet } else this } - /** Updates word at index `idx`; enlarges set if `idx` outside range of set. */ + /** Updates word at index `idx`; enlarges set if `idx` outside range of set. + * + * @param idx the index of the word to update + * @param w the new value for the word at index `idx` + */ protected def updateWord(idx: Int, w: Long): BitSet override def map(f: Int => Int): BitSet = strictOptimizedMap(newSpecificBuilder, f) @@ -108,7 +112,10 @@ object BitSet extends SpecificIterableFactory[Int, BitSet] { private def createSmall(a: Long, b: Long): BitSet = if (b == 0L) new BitSet1(a) else new BitSet2(a, b) - /** A bitset containing all the bits in an array. */ + /** A bitset containing all the bits in an array. + * + * @param elems the array of `Long` words representing the bits; the array is defensively copied + */ def fromBitMask(elems: Array[Long]): BitSet = { val len = elems.length if (len == 0) empty @@ -122,6 +129,8 @@ object BitSet extends SpecificIterableFactory[Int, BitSet] { /** A bitset containing all the bits in an array, wrapping the existing * array without copying. + * + * @param elems the array of `Long` words representing the bits; the caller must not modify the array after this call */ def fromBitMaskNoCopy(elems: Array[Long]): BitSet = { val len = elems.length diff --git a/library/src/scala/collection/immutable/ChampCommon.scala b/library/src/scala/collection/immutable/ChampCommon.scala index 7cc92e04f564..cb9d01b71ed3 100644 --- a/library/src/scala/collection/immutable/ChampCommon.scala +++ b/library/src/scala/collection/immutable/ChampCommon.scala @@ -105,6 +105,7 @@ private[collection] abstract class Node[T <: Node[T]] { * node before traversing sub-nodes (left to right). * * @tparam T the trie node type we are iterating over + * @tparam A the element type produced by the iterator */ private[immutable] abstract class ChampBaseIterator[A, T <: Node[T]] extends AbstractIterator[A] { @@ -191,6 +192,7 @@ private[immutable] abstract class ChampBaseIterator[A, T <: Node[T]] extends Abs * iterator performs a depth-first post-order traversal, traversing sub-nodes (right to left). * * @tparam T the trie node type we are iterating over + * @tparam A the element type produced by the iterator */ private[immutable] abstract class ChampBaseReverseIterator[A, T <: Node[T]] extends AbstractIterator[A] { diff --git a/library/src/scala/collection/immutable/HashMap.scala b/library/src/scala/collection/immutable/HashMap.scala index 6e07d53b253f..7a625e7a68bf 100644 --- a/library/src/scala/collection/immutable/HashMap.scala +++ b/library/src/scala/collection/immutable/HashMap.scala @@ -274,7 +274,10 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode: override def foreachEntry[U](f: (K, V) => U): Unit = rootNode.foreachEntry(f) - /** Applies a function to each key, value, and **original** hash value in this Map. */ + /** Applies a function to each key, value, and **original** hash value in this Map. + * + * @param f the function to apply to each key, value, and original hash triple + */ @inline private[collection] def foreachWithHash(f: (K, V, Int) => Unit): Unit = rootNode.foreachWithHash(f) override def equals(that: Any): Boolean = @@ -300,7 +303,7 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode: /** Merges this HashMap with an other HashMap by combining all key-value pairs of both maps, and delegating to a merge * function to resolve any key collisions between the two HashMaps. * - * @example ``` + * @example ```scala sc:compile * val left = HashMap(1 -> 1, 2 -> 1) * val right = HashMap(2 -> 2, 3 -> 2) * @@ -318,7 +321,7 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode: * found in `this` or `that`, it is not defined which value will be chosen. For example: * * Colliding multiple results of merging: - * ``` + * ```scala sc:compile * // key `3` collides between a result of merging keys `1` and `2` * val left = HashMap(1 -> 1, 2 -> 2) * val right = HashMap(1 -> 1, 2 -> 2) @@ -327,7 +330,7 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode: * // HashMap(3 -> 2) is returned, but it could also have returned HashMap(3 -> 1) * ``` * Colliding results of merging with other keys: - * ``` + * ```scala sc:compile * // key `2` collides between a result of merging `1`, and existing key `2` * val left = HashMap(1 -> 1, 2 -> 1) * val right = HashMap(1 -> 2) @@ -336,6 +339,8 @@ final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode: * // HashMap(2 -> 1) is returned, but it could also have returned HashMap(2 -> 3) * ``` * + * + * @tparam V1 the value type of the resulting HashMap, a supertype of `V` */ def merged[V1 >: V](that: HashMap[K, V1])(mergef: ((K, V), (K, V1)) => (K, V1)): HashMap[K, V1] = if (mergef == null) { @@ -555,9 +560,10 @@ private[immutable] sealed abstract class MapNode[K, +V] extends Node[MapNode[K, /** Returns a MapNode with the passed key-value assignment added * + * @tparam V1 the value type of the returned node, a supertype of `V` * @param key the key to add to the MapNode * @param value the value to associate with `key` - * @param originalHash the original hash of `key` + * @param originalHash the original hash code of `key` (via `key.##`) * @param hash the improved hash of `key` * @param shift the shift of the node (distanceFromRoot * BitPartitionSize) * @param replaceValue if true, then the value currently associated to `key` will be replaced with the passed value @@ -565,6 +571,7 @@ private[immutable] sealed abstract class MapNode[K, +V] extends Node[MapNode[K, * if false, then the key will be inserted if not already present, however if the key is present * then the passed value will not replace the current value. That is, if `false`, then this * method has `update if not exists` semantics. + * @return a new `MapNode` containing the updated key-value mapping */ def updated[V1 >: V](key: K, value: V1, originalHash: Int, hash: Int, shift: Int, replaceValue: Boolean): MapNode[K, V1] @@ -606,17 +613,30 @@ private[immutable] sealed abstract class MapNode[K, +V] extends Node[MapNode[K, * * `this` should be a node from `left` hashmap in `left.merged(right)(mergef)` * + * @tparam V1 the value type of the merged result, a supertype of `V` * @param that node from the "right" HashMap. Must also be at the same "path" or "position" within the right tree, * as `this` is, within the left tree + * @param builder the builder used to accumulate the merged key-value pairs + * @param shift the bit-level offset into the hash code, equal to `depth * BitPartitionSize` + * @param mergef the function used to resolve collisions between keys present in both nodes */ def mergeInto[V1 >: V](that: MapNode[K, V1], builder: HashMapBuilder[K, V1], shift: Int)(mergef: ((K, V), (K, V1)) => (K, V1)): Unit /** Returns the exact (equal by reference) key, and value, associated to a given key. * If the key is not bound to a value, then an exception is thrown + * + * @param key the key to look up + * @param originalHash the original hash code of `key` (via `key.##`) + * @param hash the improved hash of `key` + * @param shift the bit-level offset into the hash code, equal to `depth * BitPartitionSize` */ def getTuple(key: K, originalHash: Int, hash: Int, shift: Int): (K, V) - /** Adds all key-value pairs to a builder. */ + /** Adds all key-value pairs to a builder. + * + * @tparam V1 the value type of the target builder, a supertype of `V` + * @param builder the builder to add the key-value pairs to + */ def buildTo[V1 >: V](builder: HashMapBuilder[K, V1]): Unit } @@ -784,13 +804,15 @@ private final class BitmapIndexedMapNode[K, +V]( * If instead this method may not mutate the child node in which the to-be-updated key-value pair belongs, then * that child will be updated immutably, but the result will be mutably re-inserted as a child of this node. * + * @tparam V1 the value type of the updated node, a supertype of `V` * @param key the key to update * @param value the value to set `key` to * @param originalHash key.## * @param keyHash the improved hash + * * @param shallowlyMutableNodeMap bitmap of child nodes of this node, which can be shallowly mutated * during the call to this method - * + * @param shift the bit-level offset into the hash code, equal to `depth * BitPartitionSize` * @return Int which is the bitwise OR of shallowlyMutableNodeMap and any freshly created nodes, which will be * available for mutations in subsequent calls. */ @@ -1023,6 +1045,7 @@ private final class BitmapIndexedMapNode[K, +V]( /** Variant of `copyAndMigrateFromInlineToNode` which mutates `this` rather than returning a new node. * + * @tparam V1 the value type of the child node, a supertype of `V` * @param bitpos the bit position of the data to migrate to node * @param keyHash the improved hash of the key currently at `bitpos` * @param node the node to place at `bitpos` beneath `this` @@ -2171,9 +2194,17 @@ private final class MapKeyValueTupleHashIterator[K, V](rootNode: MapNode[K, V]) } } -/** Used in HashMap[K, V]#removeAll(HashSet[K]). */ +/** Used in HashMap[K, V]#removeAll(HashSet[K]). + * + * @tparam K the key type + * @param rootSetNode the root node of the `HashSet` whose keys are to be removed + */ private final class MapNodeRemoveAllSetNodeIterator[K](rootSetNode: SetNode[K]) extends ChampBaseIterator[K, SetNode[K]](rootSetNode) { - /** Returns the result of immutably removing all keys in `rootSetNode` from `rootMapNode`. */ + /** Returns the result of immutably removing all keys in `rootSetNode` from `rootMapNode`. + * + * @tparam V the value type of the map node + * @param rootMapNode the root node of the map from which keys will be removed + */ def removeAll[V](rootMapNode: BitmapIndexedMapNode[K, V]): BitmapIndexedMapNode[K, V] = { var curr = rootMapNode while (curr.size > 0 && hasNext) { @@ -2214,6 +2245,9 @@ object HashMap extends MapFactory[HashMap] { /** Creates a new Builder which can be reused after calling `result()` without an * intermediate call to `clear()` in order to build multiple related results. + * + * @tparam K the key type of the HashMap + * @tparam V the value type of the HashMap */ def newBuilder[K, V]: ReusableBuilder[(K, V), HashMap[K, V]] = new HashMapBuilder[K, V] } @@ -2221,6 +2255,9 @@ object HashMap extends MapFactory[HashMap] { /** A `Builder` for a `HashMap`. * $multipleResults + * + * @tparam K the key type of the HashMap being built + * @tparam V the value type of the HashMap being built */ private[immutable] final class HashMapBuilder[K, V] extends ReusableBuilder[(K, V), HashMap[K, V]] { import MapNode._ @@ -2230,7 +2267,7 @@ private[immutable] final class HashMapBuilder[K, V] extends ReusableBuilder[(K, /** The last given out HashMap as a return value of `result()`, if any, otherwise null. * Indicates that on next add, the elements should be copied to an identical structure, before continuing - * mutations. + * mutations. */ @annotation.stableNull private var aliased: HashMap[K, V] | Null = compiletime.uninitialized @@ -2247,7 +2284,12 @@ private[immutable] final class HashMapBuilder[K, V] extends ReusableBuilder[(K, rootNode.getOrElse(key, originalHash, improve(originalHash), 0, value) } - /** Inserts element `elem` into array `as` at index `ix`, shifting right the trailing elems. */ + /** Inserts element `elem` into array `as` at index `ix`, shifting right the trailing elems. + * + * @param as the source array to insert into + * @param ix the zero-based index at which to insert `elem` + * @param elem the element to insert + */ private def insertElement(as: Array[Int], ix: Int, elem: Int): Array[Int] = { if (ix < 0) throw new ArrayIndexOutOfBoundsException if (ix > as.length) throw new ArrayIndexOutOfBoundsException @@ -2258,7 +2300,16 @@ private[immutable] final class HashMapBuilder[K, V] extends ReusableBuilder[(K, result } - /** Inserts key-value into the bitmapIndexMapNode. Requires that this is a new key-value pair. */ + /** Inserts key-value into the bitmapIndexMapNode. Requires that this is a new key-value pair. + * + * @tparam V1 the value type being inserted, a supertype of `V` + * @param bm the bitmap-indexed map node to mutate + * @param bitpos the bit position in the bitmap where the key-value pair should be inserted + * @param key the key to insert + * @param originalHash the original hash code of `key` (via `key.##`) + * @param keyHash the improved hash of `key` + * @param value the value to associate with `key` + */ private def insertValue[V1 >: V](bm: BitmapIndexedMapNode[K, V],bitpos: Int, key: K, originalHash: Int, keyHash: Int, value: V1): Unit = { val dataIx = bm.dataIndex(bitpos) val idx = TupleLength * dataIx @@ -2281,7 +2332,15 @@ private[immutable] final class HashMapBuilder[K, V] extends ReusableBuilder[(K, bm.cachedJavaKeySetHashCode += keyHash } - /** Upserts a key/value pair into mapNode, mutably. */ + /** Upserts a key/value pair into mapNode, mutably. + * + * @param mapNode the map node to update in place + * @param key the key to insert or update + * @param value the value to associate with `key` + * @param originalHash the original hash code of `key` (via `key.##`) + * @param keyHash the improved hash of `key` + * @param shift the bit-level offset into the hash code, equal to `depth * BitPartitionSize` + */ private[immutable] def update(mapNode: MapNode[K, V], key: K, value: V, originalHash: Int, keyHash: Int, shift: Int): Unit = { mapNode match { case bm: BitmapIndexedMapNode[K, V] => diff --git a/library/src/scala/collection/immutable/HashSet.scala b/library/src/scala/collection/immutable/HashSet.scala index abe439cc8442..1ef6257bc855 100644 --- a/library/src/scala/collection/immutable/HashSet.scala +++ b/library/src/scala/collection/immutable/HashSet.scala @@ -186,11 +186,16 @@ final class HashSet[A] private[immutable](private[immutable] val rootNode: Bitma override def foreach[U](f: A => U): Unit = rootNode.foreach(f) - /** Applies a function f to each element, and its corresponding **original** hash, in this Set. */ + /** Applies a function f to each element, and its corresponding **original** hash, in this Set. + * + * @param f the function to apply to each element and its original hash + */ @`inline` private[collection] def foreachWithHash(f: (A, Int) => Unit): Unit = rootNode.foreachWithHash(f) /** Applies a function f to each element, and its corresponding **original** hash, in this Set * Stops iterating the first time that f returns `false`. + * + * @param f the function to apply to each element and its original hash, returning `true` to continue iteration or `false` to stop */ @`inline` private[collection] def foreachWithHashWhile(f: (A, Int) => Boolean): Unit = rootNode.foreachWithHashWhile(f) @@ -279,6 +284,9 @@ final class HashSet[A] private[immutable](private[immutable] val rootNode: Bitma * Mutation is used internally, but only on root SetNodes which this method itself creates. * * That is, this method is safe to call on published sets because it does not mutate `this` + * + * @param that the collection of elements to remove + * @return a new `HashSet` with all elements of `that` removed */ private def removedAllWithShallowMutations(that: IterableOnce[A]^): HashSet[A] = { val iter = that.iterator @@ -531,12 +539,12 @@ private final class BitmapIndexedSetNode[A]( * If instead this method may not mutate the child node in which the to-be-updated value is located, then * that child will be updated immutably, but the result will be mutably re-inserted as a child of this node. * - * @param key the key to update - * @param originalHash key.## - * @param keyHash the improved hash + * @param element the element to insert or update + * @param originalHash the original hash of `element` (i.e. `element.##`) + * @param elementHash the improved hash of `element` + * @param shift the bit shift for the current trie level (0 at root, incremented by `BitPartitionSize` per level) * @param shallowlyMutableNodeMap bitmap of child nodes of this node, which can be shallowly mutated * during the call to this method - * * @return Int which is the bitwise OR of shallowlyMutableNodeMap and any freshly created nodes, which will be * available for mutations in subsequent calls. */ @@ -654,6 +662,7 @@ private final class BitmapIndexedSetNode[A]( * @param element the element to remove * @param originalHash the original hash of `element` * @param elementHash the improved hash of `element` + * @return `this` node, mutated in-place to remove the element */ def removeWithShallowMutations(element: A, originalHash: Int, elementHash: Int): this.type = { val mask = maskFrom(elementHash, 0) @@ -876,6 +885,7 @@ private final class BitmapIndexedSetNode[A]( * @param bitpos the bit position of the data to migrate to node * @param keyHash the improved hash of the element currently at `bitpos` * @param node the node to place at `bitpos` + * @return `this` node, mutated in-place with the data at `bitpos` replaced by `node` */ def migrateFromInlineToNodeInPlace(bitpos: Int, keyHash: Int, node: SetNode[A]): this.type = { val dataIx = dataIndex(bitpos) @@ -929,6 +939,8 @@ private final class BitmapIndexedSetNode[A]( * we reuse this.content by shifting data/nodes around, rather than allocating a new array. * * @param bitpos the bit position of the node to migrate inline + * @param originalHash the original hash (`element.##`) of the single element in `node` + * @param elementHash the improved hash of the single element in `node` * @param oldNode the node currently stored at position `bitpos` * @param node the node containing the single element to migrate inline */ @@ -1319,6 +1331,7 @@ private final class BitmapIndexedSetNode[A]( * @param mapOfNewNodes bitmap of positions of new nodes to include in the new SetNode * @param newNodes queue in order of child position, of all new nodes to include in the new SetNode * @param newCachedHashCode the cached java keyset hashcode of the new SetNode + * @return a new `BitmapIndexedSetNode` from the specified parameters, the empty node if `newSize` is 0, or `this` if `newSize` equals `size` */ private def newNodeFrom( newSize: Int, @@ -1760,6 +1773,12 @@ private final class HashCollisionSetNode[A](val originalHash: Int, val hash: Int * When after deletion only one element remains, we return a bit-mapped indexed node with a * singleton element and a hash-prefix for trie level 0. This node will be then a) either become * the new root, or b) unwrapped and inlined deeper in the trie. + * + * @param element the element to remove from this collision node + * @param originalHash the original hash (`element.##`) of the element + * @param hash the improved hash of the element + * @param shift the bit shift for the current trie level + * @return a new `SetNode` without the element, which may be a `BitmapIndexedSetNode` if only one element remains */ def removed(element: A, originalHash: Int, hash: Int, shift: Int): SetNode[A] = if (!this.contains(element, originalHash, hash, shift)) { @@ -1947,12 +1966,16 @@ object HashSet extends IterableFactory[HashSet] { /** Creates a new Builder which can be reused after calling `result()` without an * intermediate call to `clear()` in order to build multiple related results. + * + * @tparam A the element type of the set to build */ def newBuilder[A]: ReusableBuilder[A, HashSet[A]] = new HashSetBuilder } /** Builder for HashSet. * $multipleResults + * + * @tparam A the element type of the set being built */ private[collection] final class HashSetBuilder[A] extends ReusableBuilder[A, HashSet[A]] { import Node._ @@ -1972,7 +1995,12 @@ private[collection] final class HashSetBuilder[A] extends ReusableBuilder[A, Has /** The root node of the partially built hashmap. */ private var rootNode: BitmapIndexedSetNode[A] = newEmptyRootNode - /** Inserts element `elem` into array `as` at index `ix`, shifting right the trailing elems. */ + /** Inserts element `elem` into array `as` at index `ix`, shifting right the trailing elems. + * + * @param as the source array to insert into + * @param ix the index at which to insert the element + * @param elem the element to insert + */ private def insertElement(as: Array[Int], ix: Int, elem: Int): Array[Int] = { if (ix < 0) throw new ArrayIndexOutOfBoundsException if (ix > as.length) throw new ArrayIndexOutOfBoundsException @@ -1983,7 +2011,15 @@ private[collection] final class HashSetBuilder[A] extends ReusableBuilder[A, Has result } - /** Inserts key-value into the bitmapIndexMapNode. Requires that this is a new key-value pair. */ + /** Inserts key-value into the bitmapIndexMapNode. Requires that this is a new key-value pair. + * + * @tparam A1 the upper-bound element type, a supertype of `A` + * @param bm the bitmap-indexed set node to mutate + * @param bitpos the bit position at which to insert + * @param key the element to insert + * @param originalHash the original hash (`key.##`) of the element + * @param keyHash the improved hash of the element + */ private def insertValue[A1 >: A](bm: BitmapIndexedSetNode[A], bitpos: Int, key: A, originalHash: Int, keyHash: Int): Unit = { val dataIx = bm.dataIndex(bitpos) val idx = TupleLength * dataIx @@ -2005,7 +2041,13 @@ private[collection] final class HashSetBuilder[A] extends ReusableBuilder[A, Has bm.cachedJavaKeySetHashCode += keyHash } - /** Mutates `bm` to replace inline data at bit position `bitpos` with updated key/value. */ + /** Mutates `bm` to replace inline data at bit position `bitpos` with updated key/value. + * + * @tparam A1 the upper-bound element type, a supertype of `A` + * @param bm the bitmap-indexed set node to mutate + * @param bitpos the bit position of the data to replace + * @param elem the new element value to store + */ private def setValue[A1 >: A](bm: BitmapIndexedSetNode[A], bitpos: Int, elem: A): Unit = { val dataIx = bm.dataIndex(bitpos) val idx = TupleLength * dataIx diff --git a/library/src/scala/collection/immutable/IntMap.scala b/library/src/scala/collection/immutable/IntMap.scala index 3486f610488a..986ba8fb49fd 100644 --- a/library/src/scala/collection/immutable/IntMap.scala +++ b/library/src/scala/collection/immutable/IntMap.scala @@ -126,7 +126,10 @@ private[immutable] abstract class IntMapIterator[V, T](it: IntMap[V]) extends Ab } push(it) - /** What value do we assign to a tip? */ + /** What value do we assign to a tip? + * + * @param tip the leaf node to extract a value from + */ def valueOf(tip: IntMap.Tip[V]): T def hasNext = index != 0 @@ -210,7 +213,11 @@ sealed abstract class IntMap[+T] extends AbstractMap[Int, T] case _ => new IntMapEntryIterator(this) } - /** Loops over the key, value pairs of the map in unsigned order of the keys. */ + /** Loops over the key, value pairs of the map in unsigned order of the keys. + * + * @tparam U the return type of the function `f`, used only for side effects + * @param f the function applied to each key-value pair in the map + */ override final def foreach[U](f: ((Int, T)) => U): Unit = this match { case IntMap.Bin(_, _, left, right) => { left.foreach(f); right.foreach(f) } case IntMap.Tip(key, value) => f((key, value)) @@ -231,6 +238,7 @@ sealed abstract class IntMap[+T] extends AbstractMap[Int, T] /** Loop over the keys of the map. The same as `keys.foreach(f)`, but may * be more efficient. * + * @tparam U the return type of the function `f`, used only for side effects * @param f The loop body */ final def foreachKey[U](f: Int => U): Unit = this match { @@ -247,6 +255,7 @@ sealed abstract class IntMap[+T] extends AbstractMap[Int, T] /** Loop over the values of the map. The same as `values.foreach(f)`, but may * be more efficient. * + * @tparam U the return type of the function `f`, used only for side effects * @param f The loop body */ final def foreachValue[U](f: T => U): Unit = this match { @@ -333,14 +342,20 @@ sealed abstract class IntMap[+T] extends AbstractMap[Int, T] /** Updates the map, using the provided function to resolve conflicts if the key is already present. * * Equivalent to: + * ```scala sc-name:updateWithExampleContext sc-hidden + * val map = IntMap(1 -> "one", 2 -> "two") + * val key = 2 + * val value = "deux" + * val f = (oldValue: String, newValue: String) => oldValue + "-" + newValue * ``` - * this.get(key) match { - * case None => this.update(key, value) - * case Some(oldvalue) => this.update(key, f(oldvalue, value) + * ```scala sc-compile-with:updateWithExampleContext + * map.get(key) match { + * case None => map.updated(key, value) + * case Some(oldvalue) => map.updated(key, f(oldvalue, value)) * } * ``` * - * @tparam S The supertype of values in this `LongMap`. + * @tparam S the supertype of values in this `IntMap`. * @param key The key to update * @param value The value to use if there is no conflict * @param f The function used to resolve conflicts. @@ -372,7 +387,7 @@ sealed abstract class IntMap[+T] extends AbstractMap[Int, T] * for each `(key, value)` mapping in this map, if `f(key, value) == None` * the map contains no mapping for key, and if `f(key, value)`. * - * @tparam S The type of the values in the resulting `LongMap`. + * @tparam S the type of the values in the resulting `IntMap`. * @param f The transforming function. * @return The modified map. */ @@ -427,7 +442,7 @@ sealed abstract class IntMap[+T] extends AbstractMap[Int, T] * values produced from the original mappings by combining them with `f`. * * @tparam S The type of values in `that`. - * @tparam R The type of values in the resulting `LongMap`. + * @tparam R the type of values in the resulting `IntMap`. * @param that The map to intersect with. * @param f The combining function. * @return Intersection of `this` and `that`, with values for identical keys produced by function `f`. diff --git a/library/src/scala/collection/immutable/Iterable.scala b/library/src/scala/collection/immutable/Iterable.scala index 65f95ad87a27..705ad21be063 100644 --- a/library/src/scala/collection/immutable/Iterable.scala +++ b/library/src/scala/collection/immutable/Iterable.scala @@ -34,7 +34,7 @@ trait Iterable[+A] extends collection.Iterable[A] @SerialVersionUID(3L) object Iterable extends IterableFactory.Delegate[Iterable](List) { override def from[E](it: IterableOnce[E]^): Iterable[E]^{it} = it match { - case iterable: Iterable[E] => iterable + case iterable: Iterable[E @unchecked] => iterable case _ => super.from(it) } } diff --git a/library/src/scala/collection/immutable/LazyList.scala b/library/src/scala/collection/immutable/LazyList.scala index 84fd7ecc05d8..bed2de8b756f 100644 --- a/library/src/scala/collection/immutable/LazyList.scala +++ b/library/src/scala/collection/immutable/LazyList.scala @@ -62,7 +62,7 @@ import scala.runtime.Statics * Here is an example showing the Fibonacci sequence, * which may be evaluated to an arbitrary number of elements: * - * ``` + * ```scala sc:compile * import scala.math.BigInt * val fibs: LazyList[BigInt] = * BigInt(0) #:: BigInt(1) #:: fibs.zip(fibs.tail).map(n => n._1 + n._2) @@ -75,7 +75,7 @@ import scala.runtime.Statics * To illustrate, let's add some output to the definition `fibs`, so we * see what's going on. * - * ``` + * ```scala sc:compile * import scala.math.BigInt * import scala.util.chaining._ * val fibs: LazyList[BigInt] = @@ -126,7 +126,7 @@ import scala.runtime.Statics * Here's an example that illustrates these behaviors. * Let's begin with an iteration of the natural numbers. * - * ``` + * ```scala sc:compile * // We'll start with a silly iteration * def loop(s: String, i: Int, iter: Iterator[Int]): Unit = { * // Stop after 200,000 @@ -174,7 +174,7 @@ import scala.runtime.Statics * If we defined `fibs` such that only `0` were concretely known, then the act * of determining `tail` would require the evaluation of `tail`, so the * computation would be unable to progress, as in this code: - * ``` + * ```scala sc:compile * // The first time we try to access the tail we're going to need more * // information which will require us to recurse, which will require us to * // recurse, which... @@ -186,7 +186,7 @@ import scala.runtime.Statics * implementation provides a more "cost effective" implementation due to the * fact that it has a more direct route to the numbers themselves: * - * ``` + * ```scala sc:compile * lazy val fib: LazyList[Int] = { * def loop(h: Int, n: Int): LazyList[Int] = h #:: loop(n, h + n) * loop(1, 1) @@ -206,7 +206,7 @@ import scala.runtime.Statics * * For example: * - * ``` + * ```scala sc:compile * def tailWithSideEffect: LazyList[Nothing] = { * println("getting empty LazyList") * LazyList.empty @@ -232,7 +232,7 @@ import scala.runtime.Statics * from itself, and is attempting to read the element currently being evaluated. * As a trivial example: * - * ``` + * ```scala sc:compile * lazy val a: LazyList[Int] = 1 #:: 2 #:: a.filter(_ > 2) * ``` * @@ -362,7 +362,7 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * This method detects cycles in lazy lists, and terminates after all * elements of the cycle are evaluated. For example: * - * ``` + * ```scala sc:compile * val ring: LazyList[Int] = 1 #:: 2 #:: 3 #:: ring * ring.force * ring.toString @@ -405,7 +405,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** Applies the given function `f` to each element of this linear sequence * (while respecting the order of the elements). * - * @param f The treatment to apply to each element. + * @tparam U the return type of the function `f`, used only for side effects + * @param f the function to apply to each element * @note Overridden here as final to trigger tail-call optimization, which * replaces 'this' with 'tail' at each iteration. This is absolutely * necessary for allowing the GC to collect the underlying LazyList as elements @@ -446,8 +447,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * $appendStackSafety * - * @param suffix The collection that gets appended to this lazy list - * @return The lazy list containing elements of this lazy list and the iterable object. + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param suffix the collection that gets appended to this lazy list + * @return the lazy list containing elements of this lazy list and the iterable object */ def lazyAppendedAll[B >: A](suffix: => collection.IterableOnce[B]): LazyList[B] = newLL { @@ -464,6 +466,10 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * $preservesLaziness * * $appendStackSafety + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param suffix the collection to append + * @return a new lazy list containing elements from this lazy list followed by elements from `suffix` */ override def appendedAll[B >: A](suffix: IterableOnce[B]): LazyList[B] = if (knownIsEmpty) LazyList.from(suffix) @@ -474,6 +480,10 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * $preservesLaziness * * $appendStackSafety + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param elem the element to append + * @return a new lazy list containing all elements of this lazy list followed by `elem` */ override def appended[B >: A](elem: B): LazyList[B] = if (knownIsEmpty) eagerCons(elem, Empty) @@ -482,6 +492,10 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list + * @param z the initial value for the scan + * @param op the binary operator applied to the intermediate result and each element */ override def scanLeft[B](z: B)(op: (B, A) => B): LazyList[B] = if (knownIsEmpty) eagerCons(z, Empty) @@ -519,12 +533,18 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @param p the predicate used to test elements */ override def partition(p: A => Boolean): (LazyList[A], LazyList[A]) = (filter(p), filterNot(p)) /** @inheritdoc * * $preservesLaziness + * + * @tparam A1 the element type of the first returned lazy list + * @tparam A2 the element type of the second returned lazy list + * @param f the function mapping elements to `Left` or `Right` */ override def partitionMap[A1, A2](f: A => Either[A1, A2]): (LazyList[A1], LazyList[A2]) = { val (left, right) = map(f).partition(_.isLeft) @@ -534,6 +554,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @param pred the predicate used to test elements */ override def filter(pred: A => Boolean): LazyList[A] = if (knownIsEmpty) Empty @@ -542,6 +564,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @param pred the predicate used to test elements */ override def filterNot(pred: A => Boolean): LazyList[A] = if (knownIsEmpty) Empty @@ -554,6 +578,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * The `collection.WithFilter` returned by this method preserves laziness; elements are * only evaluated individually as needed. + * + * @param p the predicate used to test elements + * @return a `WithFilter` that supports `map`, `flatMap`, `foreach`, and `withFilter` operations */ override def withFilter(p: A => Boolean): collection.WithFilter[A, LazyList] = new LazyList.WithFilter(coll, p) @@ -561,12 +588,18 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param elem the element to prepend */ override def prepended[B >: A](elem: B): LazyList[B] = eagerCons(elem, this) /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param prefix the collection to prepend */ override def prependedAll[B >: A](prefix: collection.IterableOnce[B]): LazyList[B] = if (knownIsEmpty) LazyList.from(prefix) @@ -576,6 +609,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list + * @param f the function to apply to each element */ override def map[B](f: A => B): LazyList[B] = if (knownIsEmpty) Empty @@ -584,6 +620,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam U the return type of the function `f`, used only for side effects + * @param f the function to apply to each element for its side effect */ override def tapEach[U](f: A => U): LazyList[A] = map { a => f(a); a } @@ -596,6 +635,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list + * @param pf the partial function which filters and maps elements */ override def collect[B](pf: PartialFunction[A, B]): LazyList[B] = if (knownIsEmpty) Empty @@ -605,6 +647,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * This method does not evaluate any elements further than * the first element for which the partial function is defined. + * + * @tparam B the result type of the partial function + * @param pf the partial function to apply to elements */ @tailrec override def collectFirst[B](pf: PartialFunction[A, B]): Option[B] = @@ -619,6 +664,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * This method does not evaluate any elements further than * the first element matching the predicate. + * + * @param p the predicate used to test elements */ @tailrec override def find(p: A => Boolean): Option[A] = @@ -642,12 +689,18 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the nested collections + * @param asIterable an implicit conversion from elements of type `A` to `IterableOnce[B]` */ override def flatten[B](implicit asIterable: A => IterableOnce[B]): LazyList[B] = flatMap(asIterable) /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the second collection + * @param that the collection to zip with this lazy list */ override def zip[B](that: collection.IterableOnce[B]): LazyList[(A, B)] = if (knownIsEmpty || that.knownSize == 0) Empty @@ -666,6 +719,12 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam A1 the element type of the first half of the returned pairs, a supertype of `A` + * @tparam B the element type of the second half of the returned pairs + * @param that the collection to zip with this lazy list + * @param thisElem the element to use when this lazy list is shorter than `that` + * @param thatElem the element to use when `that` is shorter than this lazy list */ override def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): LazyList[(A1, B)] = { if (knownIsEmpty) { @@ -694,6 +753,10 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * The `collection.LazyZip2` returned by this method preserves laziness; elements are * only evaluated individually as needed. + * + * @tparam B the element type of the other collection + * @param that the collection providing the second half of each pair + * @return a `LazyZip2` decorator that supports multi-collection operations such as `map` and `filter` */ // just in case it can be meaningfully overridden at some point override def lazyZip[B](that: collection.Iterable[B]): LazyZip2[A, B, this.type] = @@ -702,6 +765,10 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam A1 the type of the first element in each pair + * @tparam A2 the type of the second element in each pair + * @param asPair an implicit conversion from elements of type `A` to pairs of `(A1, A2)` */ override def unzip[A1, A2](implicit asPair: A => (A1, A2)): (LazyList[A1], LazyList[A2]) = (map(asPair(_)._1), map(asPair(_)._2)) @@ -709,6 +776,11 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam A1 the type of the first element in each triple + * @tparam A2 the type of the second element in each triple + * @tparam A3 the type of the third element in each triple + * @param asTriple an implicit conversion from elements of type `A` to triples of `(A1, A2, A3)` */ override def unzip3[A1, A2, A3](implicit asTriple: A => (A1, A2, A3)): (LazyList[A1], LazyList[A2], LazyList[A3]) = (map(asTriple(_)._1), map(asTriple(_)._2), map(asTriple(_)._3)) @@ -717,6 +789,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * $initiallyLazy * Additionally, it preserves laziness for all except the first `n` elements. + * + * @param n the number of elements to drop from this lazy list */ override def drop(n: Int): LazyList[A] = if (n <= 0) this @@ -727,6 +801,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * $initiallyLazy * Additionally, it preserves laziness for all elements after the predicate returns `false`. + * + * @param p the predicate used to test elements; elements are dropped while this returns `true` */ override def dropWhile(p: A => Boolean): LazyList[A] = if (knownIsEmpty) Empty @@ -735,6 +811,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $initiallyLazy + * + * @param n the number of elements to drop from the right end */ override def dropRight(n: Int): LazyList[A] = { if (n <= 0) this @@ -758,6 +836,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @param n the number of elements to take from this lazy list */ override def take(n: Int): LazyList[A] = if (knownIsEmpty) Empty @@ -774,6 +854,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @param p the predicate used to test elements; elements are taken while this returns `true` */ override def takeWhile(p: A => Boolean): LazyList[A] = if (knownIsEmpty) Empty @@ -788,6 +870,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $initiallyLazy + * + * @param n the number of elements to take from the right end */ override def takeRight(n: Int): LazyList[A] = if (n <= 0 || knownIsEmpty) Empty @@ -797,6 +881,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * $initiallyLazy * Additionally, it preserves laziness for all but the first `from` elements. + * + * @param from the index of the first element in the slice + * @param until the index of the element following the slice */ override def slice(from: Int, until: Int): LazyList[A] = take(until).drop(from) @@ -815,6 +902,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the other sequence, a supertype of `A` + * @param that the sequence of elements to remove from this lazy list */ override def diff[B >: A](that: collection.Seq[B]): LazyList[A] = if (knownIsEmpty) Empty @@ -823,6 +913,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the other sequence, a supertype of `A` + * @param that the sequence to intersect with */ override def intersect[B >: A](that: collection.Seq[B]): LazyList[A] = if (knownIsEmpty) Empty @@ -838,6 +931,8 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * The iterator returned by this method mostly preserves laziness; * a single element ahead of the iterator is evaluated. + * + * @param size the number of elements per group, must be positive */ override def grouped(size: Int): Iterator[LazyList[A]] = { require(size > 0, "size must be positive, but was " + size) @@ -848,6 +943,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => * * The iterator returned by this method mostly preserves laziness; * `size - step max 1` elements ahead of the iterator are evaluated. + * + * @param size the number of elements per window, must be positive + * @param step the number of elements to advance per window, must be positive */ override def sliding(size: Int, step: Int): Iterator[LazyList[A]] = { require(size > 0 && step > 0, s"size=$size and step=$step, but both must be positive") @@ -861,6 +959,10 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param len the minimum length of the result; no padding if this lazy list is already at least `len` long + * @param elem the element to use for padding */ override def padTo[B >: A](len: Int, elem: B): LazyList[B] = if (len <= 0) this @@ -872,6 +974,11 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param from the index at which to begin patching + * @param other the elements to insert at the patch position + * @param replaced the number of elements in this lazy list to replace */ override def patch[B >: A](from: Int, other: IterableOnce[B], replaced: Int): LazyList[B] = if (knownIsEmpty) LazyList from other @@ -887,6 +994,9 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $evaluatesAllElements + * + * @tparam B the element type of the inner collections + * @param asIterable an implicit conversion from elements of type `A` to `Iterable[B]` */ // overridden just in case a lazy implementation is developed at some point override def transpose[B](implicit asIterable: A => collection.Iterable[B]): LazyList[LazyList[B]] = super.transpose @@ -894,6 +1004,10 @@ final class LazyList[+A] private (lazyState: AnyRef /* EmptyMarker.type | () => /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param index the zero-based position of the element to replace + * @param elem the new element to place at position `index` */ override def updated[B >: A](index: Int, elem: B): LazyList[B] = if (index < 0) throw new IndexOutOfBoundsException(s"$index") @@ -1051,10 +1165,19 @@ object LazyList extends SeqFactory[LazyList] { private val Empty: LazyList[Nothing] = new LazyList(EmptyMarker) - /** Creates a new LazyList. */ + /** Creates a new LazyList. + * + * @tparam A the element type of the lazy list + * @param state the by-name expression computing the initial state of the lazy list + */ @inline private def newLL[A](state: => LazyList[A]): LazyList[A] = new LazyList[A](() => state) - /** Creates a new LazyList with evaluated `head` and `tail`. */ + /** Creates a new LazyList with evaluated `head` and `tail`. + * + * @tparam A the element type of the lazy list + * @param hd the head element of the lazy list + * @param tl the already-evaluated tail of the lazy list + */ @inline private def eagerCons[A](hd: A, tl: LazyList[A]): LazyList[A] = new LazyList[A](hd, tl) private val anyToMarker: Any => Any = _ => Statics.pfMarker @@ -1188,12 +1311,18 @@ object LazyList extends SeqFactory[LazyList] { /** An alternative way of building and matching lazy lists using LazyList.cons(hd, tl). */ object cons { /** A lazy list consisting of a given first element and remaining elements. + * + * @tparam A the element type of the lazy list * @param hd The first element of the result lazy list * @param tl The remaining elements of the result lazy list */ def apply[A](hd: => A, tl: => LazyList[A]): LazyList[A] = newLL(eagerCons(hd, newLL(tl))) - /** Maps a lazy list to its head and tail. */ + /** Maps a lazy list to its head and tail. + * + * @tparam A the element type of the lazy list + * @param xs the lazy list to decompose + */ def unapply[A](xs: LazyList[A]): Option[(A, LazyList[A])] = #::.unapply(xs) } @@ -1225,12 +1354,20 @@ object LazyList extends SeqFactory[LazyList] { /** Creates a LazyList with the elements of an iterator followed by a LazyList suffix. * Eagerly evaluates the first element. + * + * @tparam A the element type of the lazy list + * @param it the iterator whose elements are prepended + * @param suffix the lazy list to append after the iterator's elements are exhausted */ private def eagerHeadPrependIterator[A](it: Iterator[A])(suffix: => LazyList[A]): LazyList[A] = if (it.hasNext) eagerCons(it.next(), newLL(eagerHeadPrependIterator(it)(suffix))) else suffix - /** Creates a LazyList from an Iterator. Eagerly evaluates the first element. */ + /** Creates a LazyList from an Iterator. Eagerly evaluates the first element. + * + * @tparam A the element type of the lazy list + * @param it the iterator to convert into a lazy list + */ private def eagerHeadFromIterator[A](it: Iterator[A]): LazyList[A] = if (it.hasNext) eagerCons(it.next(), newLL(eagerHeadFromIterator(it))) else Empty @@ -1245,6 +1382,7 @@ object LazyList extends SeqFactory[LazyList] { /** An infinite LazyList that repeatedly applies a given function to a start value. * + * @tparam A the element type of the lazy list * @param start the start value of the LazyList * @param f the function that's repeatedly applied * @return the LazyList returning the infinite sequence of values `start, f(start), f(f(start)), ...` @@ -1275,6 +1413,7 @@ object LazyList extends SeqFactory[LazyList] { /** Creates an infinite LazyList containing the given element expression (which * is computed for each occurrence). * + * @tparam A the element type of the lazy list * @param elem the element composing the resulting LazyList * @return the LazyList containing an infinite number of elem */ diff --git a/library/src/scala/collection/immutable/LazyListIterable.scala b/library/src/scala/collection/immutable/LazyListIterable.scala index bbedebf3c5d5..0d9e0380f41a 100644 --- a/library/src/scala/collection/immutable/LazyListIterable.scala +++ b/library/src/scala/collection/immutable/LazyListIterable.scala @@ -65,7 +65,7 @@ import caps.unsafe.untrackedCaptures * Here is an example showing the Fibonacci sequence, * which may be evaluated to an arbitrary number of elements: * - * ``` + * ```scala sc:compile * import scala.math.BigInt * val fibs: LazyListIterable[BigInt] = * BigInt(0) #:: BigInt(1) #:: fibs.zip(fibs.tail).map(n => n._1 + n._2) @@ -78,7 +78,7 @@ import caps.unsafe.untrackedCaptures * To illustrate, let's add some output to the definition `fibs`, so we * see what's going on. * - * ``` + * ```scala sc:compile * import scala.math.BigInt * import scala.util.chaining._ * val fibs: LazyListIterable[BigInt] = @@ -129,7 +129,7 @@ import caps.unsafe.untrackedCaptures * Here's an example that illustrates these behaviors. * Let's begin with an iteration of the natural numbers. * - * ``` + * ```scala sc:compile * // We'll start with a silly iteration * def loop(s: String, i: Int, iter: Iterator[Int]): Unit = { * // Stop after 200,000 @@ -177,7 +177,7 @@ import caps.unsafe.untrackedCaptures * If we defined `fibs` such that only `0` were concretely known, then the act * of determining `tail` would require the evaluation of `tail`, so the * computation would be unable to progress, as in this code: - * ``` + * ```scala sc:compile * // The first time we try to access the tail we're going to need more * // information which will require us to recurse, which will require us to * // recurse, which... @@ -189,7 +189,7 @@ import caps.unsafe.untrackedCaptures * implementation provides a more "cost effective" implementation due to the * fact that it has a more direct route to the numbers themselves: * - * ``` + * ```scala sc:compile * lazy val fib: LazyListIterable[Int] = { * def loop(h: Int, n: Int): LazyListIterable[Int] = h #:: loop(n, h + n) * loop(1, 1) @@ -209,7 +209,7 @@ import caps.unsafe.untrackedCaptures * * For example: * - * ``` + * ```scala sc:compile * def tailWithSideEffect: LazyListIterable[Nothing] = { * println("getting empty LazyListIterable") * LazyListIterable.empty @@ -235,7 +235,7 @@ import caps.unsafe.untrackedCaptures * from itself, and is attempting to read the element currently being evaluated. * As a trivial example: * - * ``` + * ```scala sc:compile * lazy val a: LazyListIterable[Int] = 1 #:: 2 #:: a.filter(_ > 2) * ``` * @@ -383,7 +383,7 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * This method detects cycles in lazy lists, and terminates after all * elements of the cycle are evaluated. For example: * - * ``` + * ```scala sc:compile * val ring: LazyListIterable[Int] = 1 #:: 2 #:: 3 #:: ring * ring.force * ring.toString @@ -426,6 +426,7 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** Applies the given function `f` to each element of this linear sequence * (while respecting the order of the elements). * + * @tparam U the return type of the function `f` * @param f The treatment to apply to each element. * @note Overridden here as final to trigger tail-call optimization, which * replaces 'this' with 'tail' at each iteration. This is absolutely @@ -467,6 +468,7 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * $appendStackSafety * + * @tparam B the element type of the returned lazy list, a supertype of `A` * @param suffix The collection that gets appended to this lazy list * @return The lazy list containing elements of this lazy list and the iterable object. */ @@ -485,6 +487,10 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * $preservesLaziness * * $appendStackSafety + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param suffix the collection to append + * @return a new lazy list containing elements of this lazy list followed by elements of `suffix` */ override def appendedAll[B >: A](suffix: IterableOnce[B]^): LazyListIterable[B]^{this, suffix} = if (knownIsEmpty) LazyListIterable.from(suffix) @@ -495,6 +501,10 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * $preservesLaziness * * $appendStackSafety + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param elem the element to append + * @return a new lazy list containing all elements of this lazy list followed by `elem` */ override def appended[B >: A](elem: B): LazyListIterable[B]^{this} = if (knownIsEmpty) eagerCons(elem, Empty) @@ -503,6 +513,10 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the result type of the binary operator and the type of the initial value + * @param z the initial value + * @param op the binary operator applied to the intermediate result and the element */ override def scanLeft[B](z: B)(op: (B, A) => B): LazyListIterable[B]^{this, op} = if (knownIsEmpty) eagerCons(z, Empty) @@ -540,12 +554,18 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @param p the predicate used to test elements */ override def partition(p: A => Boolean): (LazyListIterable[A]^{this, p}, LazyListIterable[A]^{this, p}) = (filter(p), filterNot(p)) /** @inheritdoc * * $preservesLaziness + * + * @tparam A1 the element type of the first resulting collection + * @tparam A2 the element type of the second resulting collection + * @param f the function applied to each element that returns `Left` or `Right` */ override def partitionMap[A1, A2](f: A => Either[A1, A2]): (LazyListIterable[A1]^{this, f}, LazyListIterable[A2]^{this, f}) = { val p: (LazyListIterable[Either[A1, A2]]^{this, f}, LazyListIterable[Either[A1, A2]]^{this, f}) = map(f).partition(_.isLeft) @@ -555,6 +575,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @param pred the predicate used to test elements */ override def filter(pred: A => Boolean): LazyListIterable[A]^{this, pred} = if (knownIsEmpty) Empty @@ -563,6 +585,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @param pred the predicate used to test elements */ override def filterNot(pred: A => Boolean): LazyListIterable[A]^{this, pred} = if (knownIsEmpty) Empty @@ -575,6 +599,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * The `collection.WithFilter` returned by this method preserves laziness; elements are * only evaluated individually as needed. + * + * @param p the predicate used to test elements + * @return an object of class `WithFilter`, which supports `map`, `flatMap`, `foreach`, and `withFilter` operations */ override def withFilter(p: A => Boolean): collection.WithFilter[A, LazyListIterable]^{this, p} = new LazyListIterable.WithFilter(coll, p) @@ -582,12 +609,18 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param elem the element to prepend */ override def prepended[B >: A](elem: B): LazyListIterable[B]^{this} = eagerCons(elem, this) /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param prefix the collection to prepend */ override def prependedAll[B >: A](prefix: collection.IterableOnce[B]^): LazyListIterable[B]^{this, prefix} = if (knownIsEmpty) LazyListIterable.from(prefix) @@ -597,6 +630,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list + * @param f the function to apply to each element */ override def map[B](f: A => B): LazyListIterable[B]^{this, f} = if (knownIsEmpty) Empty @@ -605,6 +641,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam U the return type of the function `f` + * @param f the function to apply to each element for its side effect */ override def tapEach[U](f: A => U): LazyListIterable[A]^{this, f} = map { a => f(a); a } @@ -617,6 +656,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list + * @param pf the partial function which filters and maps elements */ override def collect[B](pf: PartialFunction[A, B]^): LazyListIterable[B]^{this, pf} = if (knownIsEmpty) Empty @@ -626,6 +668,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * This method does not evaluate any elements further than * the first element for which the partial function is defined. + * + * @tparam B the element type of the returned option + * @param pf the partial function which filters and maps elements */ @tailrec override def collectFirst[B](pf: PartialFunction[A, B]^): Option[B] = @@ -640,6 +685,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * This method does not evaluate any elements further than * the first element matching the predicate. + * + * @param p the predicate used to test elements */ @tailrec override def find(p: A => Boolean): Option[A] = @@ -663,12 +710,18 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list + * @param asIterable an implicit conversion which asserts that the element type of this lazy list is an `IterableOnce` */ override def flatten[B](implicit asIterable: A -> IterableOnce[B]): LazyListIterable[B]^{this} = flatMap(asIterable) /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the second half of the returned pairs + * @param that the iterable providing the second half of each result pair */ override def zip[B](that: collection.IterableOnce[B]^): LazyListIterable[(A, B)]^{this, that} = if (knownIsEmpty || that.knownSize == 0) Empty @@ -687,6 +740,12 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam A1 the type of the first half of the returned pairs, a supertype of `A` + * @tparam B the type of the second half of the returned pairs + * @param that the iterable providing the second half of each result pair + * @param thisElem the element to use if this lazy list is shorter than `that` + * @param thatElem the element to use if `that` is shorter than this lazy list */ override def zipAll[A1 >: A, B](that: collection.Iterable[B]^, thisElem: A1, thatElem: B): LazyListIterable[(A1, B)]^{this, that} = { if (knownIsEmpty) { @@ -715,6 +774,10 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * The `collection.LazyZip2` returned by this method preserves laziness; elements are * only evaluated individually as needed. + * + * @tparam B the element type of the second collection + * @param that the collection providing the second element of each pair + * @return a `LazyZip2` decorator for lazy pairing with `that` */ // just in case it can be meaningfully overridden at some point override def lazyZip[B](that: collection.Iterable[B]^): LazyZip2[A, B, this.type]^{this, that} = @@ -723,6 +786,10 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam A1 the type of the first element in each pair + * @tparam A2 the type of the second element in each pair + * @param asPair an implicit conversion which asserts that the element type of this lazy list is a pair */ override def unzip[A1, A2](implicit asPair: A -> (A1, A2)): (LazyListIterable[A1]^{this}, LazyListIterable[A2]^{this}) = (map(asPair(_)._1), map(asPair(_)._2)) @@ -730,6 +797,11 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam A1 the type of the first element in each triple + * @tparam A2 the type of the second element in each triple + * @tparam A3 the type of the third element in each triple + * @param asTriple an implicit conversion which asserts that the element type of this lazy list is a triple */ override def unzip3[A1, A2, A3](implicit asTriple: A -> (A1, A2, A3)): (LazyListIterable[A1]^{this}, LazyListIterable[A2]^{this}, LazyListIterable[A3]^{this}) = (map(asTriple(_)._1), map(asTriple(_)._2), map(asTriple(_)._3)) @@ -738,6 +810,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * $initiallyLazy * Additionally, it preserves laziness for all except the first `n` elements. + * + * @param n the number of elements to drop from this lazy list */ override def drop(n: Int): LazyListIterable[A]^{this} = if (n <= 0) this @@ -748,6 +822,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * $initiallyLazy * Additionally, it preserves laziness for all elements after the predicate returns `false`. + * + * @param p the predicate used to test elements */ override def dropWhile(p: A => Boolean): LazyListIterable[A]^{this, p} = if (knownIsEmpty) Empty @@ -756,6 +832,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $initiallyLazy + * + * @param n the number of elements to drop from the right end */ override def dropRight(n: Int): LazyListIterable[A]^{this} = { if (n <= 0) this @@ -779,6 +857,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @param n the number of elements to take from this lazy list */ override def take(n: Int): LazyListIterable[A]^{this} = if (knownIsEmpty) Empty @@ -795,6 +875,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @param p the predicate used to test elements */ override def takeWhile(p: A => Boolean): LazyListIterable[A]^{this, p} = if (knownIsEmpty) Empty @@ -809,6 +891,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $initiallyLazy + * + * @param n the number of elements to take from the right end */ override def takeRight(n: Int): LazyListIterable[A]^{this} = if (n <= 0 || knownIsEmpty) Empty @@ -818,6 +902,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * $initiallyLazy * Additionally, it preserves laziness for all but the first `from` elements. + * + * @param from the index of the first element in the slice + * @param until the index of the element following the slice */ override def slice(from: Int, until: Int): LazyListIterable[A]^{this} = take(until).drop(from) @@ -836,6 +923,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param that the sequence of elements to subtract (by multiplicity) */ override def diff[B >: A](that: collection.Seq[B]): LazyListIterable[A]^{this} = if (knownIsEmpty) Empty @@ -844,6 +934,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param that the sequence of elements to intersect with */ override def intersect[B >: A](that: collection.Seq[B]): LazyListIterable[A]^{this} = if (knownIsEmpty) Empty @@ -859,6 +952,8 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * The iterator returned by this method mostly preserves laziness; * a single element ahead of the iterator is evaluated. + * + * @param size the number of elements per group, must be positive */ override def grouped(size: Int): Iterator[LazyListIterable[A]^{this}]^{this} = { require(size > 0, "size must be positive, but was " + size) @@ -869,6 +964,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke * * The iterator returned by this method mostly preserves laziness; * `size - step max 1` elements ahead of the iterator are evaluated. + * + * @param size the number of elements per window, must be positive + * @param step the number of elements to advance per window, must be positive */ override def sliding(size: Int, step: Int): Iterator[LazyListIterable[A]^{this}]^{this} = { require(size > 0 && step > 0, s"size=$size and step=$step, but both must be positive") @@ -884,6 +982,10 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param len the length to which this lazy list should be padded + * @param elem the padding element */ override def padTo[B >: A](len: Int, elem: B): LazyListIterable[B]^{this} = if (len <= 0) this @@ -895,6 +997,11 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param from the index of the first replaced element + * @param other the collection of replacement elements + * @param replaced the number of elements to replace starting from index `from` */ override def patch[B >: A](from: Int, other: IterableOnce[B]^, replaced: Int): LazyListIterable[B]^{this, other} = if (knownIsEmpty) LazyListIterable from other @@ -910,6 +1017,9 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $evaluatesAllElements + * + * @tparam B the element type of each nested iterable + * @param asIterable an implicit conversion which asserts that the element type of this lazy list is an `Iterable` */ // overridden just in case a lazy implementation is developed at some point override def transpose[B](implicit asIterable: A -> collection.Iterable[B]): LazyListIterable[LazyListIterable[B]^{this}]^{this} = super.transpose @@ -917,6 +1027,10 @@ final class LazyListIterable[+A] private (lazyState: LazyListIterable.EmptyMarke /** @inheritdoc * * $preservesLaziness + * + * @tparam B the element type of the returned lazy list, a supertype of `A` + * @param index the zero-based index of the element to replace + * @param elem the replacing element */ override def updated[B >: A](index: Int, elem: B): LazyListIterable[B]^{this} = if (index < 0) throw new IndexOutOfBoundsException(s"$index") @@ -1074,11 +1188,22 @@ object LazyListIterable extends IterableFactory[LazyListIterable] { private val Empty: LazyListIterable[Nothing] = new LazyListIterable(EmptyMarker) - /** Creates a new LazyListIterable. */ + /** Creates a new LazyListIterable. + * + * @tparam A the element type of the lazy list + * @param state the by-name expression that computes the lazy list state when forced + */ @inline private def newLL[A](state: => LazyListIterable[A]^): LazyListIterable[A]^{state} = new LazyListIterable[A](() => state) - /** Creates a new LazyListIterable with evaluated `head` and `tail`. */ - @inline private def eagerCons[A](hd: A, tl: LazyListIterable[A]^): LazyListIterable[A]^{tl} = new LazyListIterable[A](hd, tl) + /** Creates a new LazyListIterable with evaluated `head` and `tail`. + * + * @tparam A the element type of the lazy list + * @param hd the head element of the cons cell + * @param tl the tail lazy list of the cons cell + */ + @inline private def eagerCons[A](hd: A, tl: LazyListIterable[A]^): LazyListIterable[A]^{tl} = + new LazyListIterable[A](hd, tl).asInstanceOf[LazyListIterable[A]^{tl}] + // SAFETY: cc gets confused by private secondary constructor here private val anyToMarker: Any -> Any = _ => Statics.pfMarker @@ -1211,12 +1336,18 @@ object LazyListIterable extends IterableFactory[LazyListIterable] { /** An alternative way of building and matching lazy lists using LazyListIterable.cons(hd, tl). */ object cons { /** A lazy list consisting of a given first element and remaining elements. + * + * @tparam A the element type of the lazy list * @param hd The first element of the result lazy list * @param tl The remaining elements of the result lazy list */ def apply[A](hd: => A, tl: => LazyListIterable[A]): LazyListIterable[A]^{hd, tl} = newLL(eagerCons(hd, newLL(tl))) - /** Maps a lazy list to its head and tail. */ + /** Maps a lazy list to its head and tail. + * + * @tparam A the element type of the lazy list + * @param xs the lazy list to decompose + */ def unapply[A](xs: LazyListIterable[A]^): Option[(A, LazyListIterable[A]^{xs})] = #::.unapply(xs) } @@ -1248,12 +1379,20 @@ object LazyListIterable extends IterableFactory[LazyListIterable] { /** Creates a LazyListIterable with the elements of an iterator followed by a LazyListIterable suffix. * Eagerly evaluates the first element. + * + * @tparam A the element type of the lazy list + * @param it the iterator whose elements are prepended + * @param suffix the lazy list to append after the iterator elements are exhausted */ private def eagerHeadPrependIterator[A](it: Iterator[A]^)(suffix: => LazyListIterable[A]^): LazyListIterable[A]^{it, suffix} = if (it.hasNext) eagerCons(it.next(), newLL(eagerHeadPrependIterator(it)(suffix))) else suffix - /** Creates a LazyListIterable from an Iterator. Eagerly evaluates the first element. */ + /** Creates a LazyListIterable from an Iterator. Eagerly evaluates the first element. + * + * @tparam A the element type of the lazy list + * @param it the iterator to convert into a lazy list + */ private def eagerHeadFromIterator[A](it: Iterator[A]^): LazyListIterable[A]^{it} = if (it.hasNext) eagerCons(it.next(), newLL(eagerHeadFromIterator(it))) else Empty @@ -1281,6 +1420,7 @@ object LazyListIterable extends IterableFactory[LazyListIterable] { /** An infinite LazyListIterable that repeatedly applies a given function to a start value. * + * @tparam A the element type of the lazy list * @param start the start value of the LazyListIterable * @param f the function that's repeatedly applied * @return the LazyListIterable returning the infinite sequence of values `start, f(start), f(f(start)), ...` @@ -1311,6 +1451,7 @@ object LazyListIterable extends IterableFactory[LazyListIterable] { /** Creates an infinite LazyListIterable containing the given element expression (which * is computed for each occurrence). * + * @tparam A the element type of the lazy list * @param elem the element composing the resulting LazyListIterable * @return the LazyListIterable containing an infinite number of elem */ diff --git a/library/src/scala/collection/immutable/List.scala b/library/src/scala/collection/immutable/List.scala index 810f590dce9e..90fb13dd0906 100644 --- a/library/src/scala/collection/immutable/List.scala +++ b/library/src/scala/collection/immutable/List.scala @@ -40,14 +40,14 @@ import scala.runtime.Statics.releaseFence * * **Space:** `List` implements **structural sharing** of the tail list. This means that many operations are either * zero- or constant-memory cost. - * ``` + * ```scala sc:compile * val mainList = List(3, 2, 1) * val with4 = 4 :: mainList // re-uses mainList, costs one :: instance * val with42 = 42 :: mainList // also re-uses mainList, cost one :: instance * val shorter = mainList.tail // costs nothing as it uses the same 2::1::Nil instances as mainList * ``` * - * @example ``` + * @example ```scala sc:compile * // Make a list via the companion object factory * val days = List("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday") * @@ -96,14 +96,18 @@ sealed abstract class List[+A] * @return a list which contains `x` as first element and * which continues with this list. * Example: - * ```1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3) ``` + * ```scala sc:compile + * 1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3) + * ``` */ def :: [B >: A](elem: B): List[B] = new ::(elem, this) /** Adds the elements of a given list in front of this list. * * Example: - * ```List(1, 2) ::: List(3, 4) = List(3, 4).:::(List(1, 2)) = List(1, 2, 3, 4) ``` + * ```scala sc:compile + * List(1, 2) ::: List(3, 4) == List(3, 4).:::(List(1, 2)) // List(1, 2, 3, 4) + * ``` * * @param prefix The list elements to prepend. * @return a list resulting from the concatenation of the given @@ -424,7 +428,7 @@ sealed abstract class List[+A] } override def corresponds[B](that: collection.Seq[B])(p: (A, B) => Boolean): Boolean = that match { - case that: LinearSeq[B] => + case that: LinearSeq[B @unchecked] => var i = this var j = that while (!(i.isEmpty || j.isEmpty)) { @@ -652,7 +656,7 @@ final case class :: [+A](override val head: A, private[scala] var next: List[A @ override def tail: List[A] = next @publicInBinary - private[::] def next$access$1 = next + private[::] def `next$access$1` = next } diff --git a/library/src/scala/collection/immutable/ListMap.scala b/library/src/scala/collection/immutable/ListMap.scala index c9aa3029a9c1..f397465f5c8c 100644 --- a/library/src/scala/collection/immutable/ListMap.scala +++ b/library/src/scala/collection/immutable/ListMap.scala @@ -128,7 +128,14 @@ sealed class ListMap[K, +V] */ @SerialVersionUID(3L) object ListMap extends MapFactory[ListMap] { - /** Represents an entry in the `ListMap`. */ + /** Represents an entry in the `ListMap`. + * + * @tparam K the type of the keys in this map entry + * @tparam V the type of the values in this map entry + * @param private[immutable] val key the key for this map entry + * @param private[immutable] var _value the value associated with the key + * @param private[immutable] var _init the rest of the list map (tail), or `null` during construction + */ private[immutable] final class Node[K, V]( override private[immutable] val key: K, private[immutable] var _value: V, @@ -271,6 +278,7 @@ object ListMap extends MapFactory[ListMap] { * * @tparam K the map key type * @tparam V the map value type + * @return a new `ReusableBuilder` for creating `ListMap` instances */ def newBuilder[K, V]: ReusableBuilder[(K, V), ListMap[K, V]] = new ListMapBuilder[K, V] @@ -282,6 +290,9 @@ object ListMap extends MapFactory[ListMap] { /** Builder for ListMap. * $multipleResults + * + * @tparam K the type of the keys in the list map being built + * @tparam V the type of the values in the list map being built */ private[immutable] final class ListMapBuilder[K, V] extends mutable.ReusableBuilder[(K, V), ListMap[K, V]] { private var isAliased: Boolean = false diff --git a/library/src/scala/collection/immutable/ListSet.scala b/library/src/scala/collection/immutable/ListSet.scala index cdca40518658..c02d527af484 100644 --- a/library/src/scala/collection/immutable/ListSet.scala +++ b/library/src/scala/collection/immutable/ListSet.scala @@ -71,7 +71,10 @@ sealed class ListSet[A] override def iterableFactory: IterableFactory[ListSet] = ListSet - /** Represents an entry in the `ListSet`. */ + /** Represents an entry in the `ListSet`. + * + * @param elem the element contained in this node of the list set + */ protected class Node(override protected val elem: A) extends ListSet[A] { override def size = sizeInternal(this, 0) diff --git a/library/src/scala/collection/immutable/LongMap.scala b/library/src/scala/collection/immutable/LongMap.scala index 292a24a9d8cc..1da57dc569bf 100644 --- a/library/src/scala/collection/immutable/LongMap.scala +++ b/library/src/scala/collection/immutable/LongMap.scala @@ -123,7 +123,10 @@ private[immutable] abstract class LongMapIterator[V, T](it: LongMap[V]) extends } push(it) - /** What value do we assign to a tip? */ + /** What value do we assign to a tip? + * + * @param tip the leaf node to extract a value from + */ def valueOf(tip: LongMap.Tip[V]): T def hasNext = index != 0 @@ -204,7 +207,11 @@ sealed abstract class LongMap[+T] extends AbstractMap[Long, T] case _ => new LongMapEntryIterator(this) } - /** Loops over the key, value pairs of the map in unsigned order of the keys. */ + /** Loops over the key, value pairs of the map in unsigned order of the keys. + * + * @tparam U the return type of the function `f`, used only for side effects + * @param f the function applied to each key-value pair in the map + */ override final def foreach[U](f: ((Long, T)) => U): Unit = this match { case LongMap.Bin(_, _, left, right) => { left.foreach(f); right.foreach(f) } case LongMap.Tip(key, value) => f((key, value)) @@ -225,6 +232,7 @@ sealed abstract class LongMap[+T] extends AbstractMap[Long, T] /** Loop over the keys of the map. The same as keys.foreach(f), but may * be more efficient. * + * @tparam U the return type of the function `f`, used only for side effects * @param f The loop body */ final def foreachKey[U](f: Long => U): Unit = this match { @@ -241,6 +249,7 @@ sealed abstract class LongMap[+T] extends AbstractMap[Long, T] /** Loop over the values of the map. The same as values.foreach(f), but may * be more efficient. * + * @tparam U the return type of the function `f`, used only for side effects * @param f The loop body */ final def foreachValue[U](f: T => U): Unit = this match { @@ -315,10 +324,16 @@ sealed abstract class LongMap[+T] extends AbstractMap[Long, T] /** Updates the map, using the provided function to resolve conflicts if the key is already present. * * Equivalent to + * ```scala sc-name:updateWithExampleContext sc-hidden + * val map = LongMap(1L -> "one", 2L -> "two") + * val key = 2L + * val value = "deux" + * val f = (oldValue: String, newValue: String) => oldValue + "-" + newValue * ``` - * this.get(key) match { - * case None => this.update(key, value) - * case Some(oldvalue) => this.update(key, f(oldvalue, value) + * ```scala sc-compile-with:updateWithExampleContext + * map.get(key) match { + * case None => map.updated(key, value) + * case Some(oldvalue) => map.updated(key, f(oldvalue, value)) * } * ``` * diff --git a/library/src/scala/collection/immutable/Map.scala b/library/src/scala/collection/immutable/Map.scala index f4f4ddaeec6f..54c45d37af72 100644 --- a/library/src/scala/collection/immutable/Map.scala +++ b/library/src/scala/collection/immutable/Map.scala @@ -23,7 +23,11 @@ import scala.collection.immutable.Map.Map4 import scala.collection.mutable.{Builder, ReusableBuilder} import SeqMap.{SeqMap1, SeqMap2, SeqMap3, SeqMap4} -/** Base type of immutable Maps. */ +/** Base type of immutable Maps. + * + * @tparam K the type of the keys in this map + * @tparam V the type of the values associated with the keys + */ trait Map[K, +V] extends Iterable[(K, V)] with collection.Map[K, V] @@ -40,6 +44,7 @@ trait Map[K, +V] * * Invoking transformer methods (e.g. `map`) will not preserve the default value. * + * @tparam V1 the type of the values returned by the default function, which must be a supertype of `V` * @param d the function mapping keys to values, used for non-present keys * @return a wrapper of the map with a default value */ @@ -51,6 +56,7 @@ trait Map[K, +V] * * Invoking transformer methods (e.g. `map`) will not preserve the default value. * + * @tparam V1 the type of the default value, which must be a supertype of `V` * @param d default value used for non-present keys * @return a wrapper of the map with a default value */ @@ -61,6 +67,10 @@ trait Map[K, +V] * * @define coll immutable map * @define Coll `immutable.Map` + * + * @tparam K the type of the keys in this map + * @tparam V the type of the values associated with the keys + * @tparam CC the type constructor of the resulting map (e.g., `Map`, `HashMap`) */ transparent trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, ?], +C <: MapOps[K, V, CC, C]] extends IterableOps[(K, V), Iterable, C] @@ -76,7 +86,10 @@ transparent trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, ?], +C <: MapOps[ */ def removed(key: K): C - /** Alias for `removed`. */ + /** Alias for `removed`. + * + * @param key the key to remove from this map + */ @`inline` final def - (key: K): C = removed(key) @deprecated("Use -- with an explicit collection", "2.13.0") @@ -93,7 +106,10 @@ transparent trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, ?], +C <: MapOps[ */ def removedAll(keys: IterableOnce[K]^): C = keys.iterator.foldLeft[C](coll)(_ - _) - /** Alias for `removedAll`. */ + /** Alias for `removedAll`. + * + * @param keys the collection of keys to remove from this map + */ @`inline` final override def -- (keys: IterableOnce[K]^): C = removedAll(keys) /** Creates a new map obtained by updating this map with a given key/value pair. @@ -111,6 +127,7 @@ transparent trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, ?], +C <: MapOps[ * If the remapping function returns `None`, the mapping is removed (or remains absent if initially absent). * If the function itself throws an exception, the exception is rethrown, and the current mapping is left unchanged. * + * @tparam V1 the type of the values in the returned map, which must be a supertype of `V` * @param key the key value * @param remappingFunction a function that receives current optionally mapped value and returns a new mapping * @return A new map with the updated mapping with the key @@ -136,6 +153,7 @@ transparent trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, ?], +C <: MapOps[ /** This function transforms all the values of mappings contained * in this map with function `f`. * + * @tparam W the type of the transformed values * @param f A function over keys and values * @return the updated map */ @@ -664,7 +682,11 @@ object Map extends MapFactory[Map] { } } -/** Explicit instantiation of the `Map` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Map` trait to reduce class file size in subclasses. + * + * @tparam K the type of the keys in this map + * @tparam V the type of the values associated with the keys + */ abstract class AbstractMap[K, +V] extends scala.collection.AbstractMap[K, V] with Map[K, V] private[immutable] final class MapBuilderImpl[K, V] extends ReusableBuilder[(K, V), Map[K, V]] { diff --git a/library/src/scala/collection/immutable/NumericRange.scala b/library/src/scala/collection/immutable/NumericRange.scala index 48e1c2adb3d1..09b49ef08c97 100644 --- a/library/src/scala/collection/immutable/NumericRange.scala +++ b/library/src/scala/collection/immutable/NumericRange.scala @@ -29,7 +29,7 @@ import scala.annotation.compileTimeOnly * and `Range.BigDecimal`. `Range.Int` exists for completeness, but * the `Int`-based `scala.Range` should be more performant. * - * ``` + * ```scala sc:compile * val r1 = Range(0, 100, 1) * val veryBig = Int.MaxValue.toLong + 1 * val r2 = Range.Long(veryBig, veryBig + 100, 1) @@ -98,11 +98,18 @@ sealed class NumericRange[T]( /** Creates a new range with the start and end values of this range and * a new `step`. + * + * @param newStep the new step value for the range */ def by(newStep: T): NumericRange[T] = copy(start, end, newStep) - /** Creates a copy of this range. */ + /** Creates a copy of this range. + * + * @param start the start value of the new range + * @param end the end value of the new range + * @param step the step value of the new range + */ def copy(start: T, end: T, step: T): NumericRange[T] = new NumericRange(start, end, step, isInclusive) @@ -407,6 +414,13 @@ object NumericRange { /** Calculates the number of elements in a range given start, end, step, and * whether or not it is inclusive. Throws an exception if step == 0 or * the number of elements exceeds the maximum Int. + * + * @tparam T the numeric type of the range elements, which must have an `Integral` instance + * @param start the first element of the range + * @param end the exclusive or inclusive upper bound, depending on `isInclusive` + * @param step the increment between successive elements, must not be zero + * @param isInclusive whether `end` is included in the range + * @param num the `Integral` instance used for arithmetic on `T` */ def count[T](start: T, end: T, step: T, isInclusive: Boolean)(implicit num: Integral[T]): Int = { val zero = num.zero diff --git a/library/src/scala/collection/immutable/Queue.scala b/library/src/scala/collection/immutable/Queue.scala index 14cdba946af6..037015c0332a 100644 --- a/library/src/scala/collection/immutable/Queue.scala +++ b/library/src/scala/collection/immutable/Queue.scala @@ -37,6 +37,8 @@ import scala.collection.mutable.{Builder, ListBuffer} * @define coll immutable queue * @define mayNotTerminateInf * @define willNotTerminateInf + * + * @tparam A the type of elements contained in this queue */ sealed class Queue[+A] protected(protected val in: List[A], protected val out: List[A]) @@ -139,6 +141,7 @@ sealed class Queue[+A] protected(protected val in: List[A], protected val out: L /** Creates a new queue with element added at the end * of the old queue. * + * @tparam B the element type of the returned queue, a supertype of `A` * @param elem the element to insert */ def enqueue[B >: A](elem: B): Queue[B] = new Queue(elem :: in, out) @@ -160,7 +163,9 @@ sealed class Queue[+A] protected(protected val in: List[A], protected val out: L * The elements are appended in the order they are given out by the * iterator. * + * @tparam B the element type of the returned queue, a supertype of `A` * @param iter an iterable object + * @return a new queue with all elements of `iter` appended at the end */ def enqueueAll[B >: A](iter: scala.collection.Iterable[B]^): Queue[B] = appendedAll(iter) diff --git a/library/src/scala/collection/immutable/Range.scala b/library/src/scala/collection/immutable/Range.scala index 36413f2cf554..11ed87488675 100644 --- a/library/src/scala/collection/immutable/Range.scala +++ b/library/src/scala/collection/immutable/Range.scala @@ -27,7 +27,7 @@ import scala.util.hashing.MurmurHash3 * It's a special case of an indexed sequence. * For example: * - * ``` + * ```scala sc:compile * val r1 = 0 until 10 * val r2 = r1.start until r1.end by r1.step + 1 * println(r2.length) // = 5 @@ -138,6 +138,9 @@ sealed abstract class Range( * * If the mathematical result is not within this Range, the result won't * make sense, but won't error out. + * + * @param n the number of steps from `start`, interpreted as an unsigned integer + * @return the element at position `n` in this range, i.e., `start + step * n` */ @inline private def locationAfterN(n: Int): Int = { @@ -222,6 +225,7 @@ sealed abstract class Range( /** Creates a new range with the `start` and `end` values of this range and * a new `step`. * + * @param step the new step value for the range; must be non-zero * @return a new range with a different step */ final def by(step: Int): Range = copy(start, end, step) @@ -299,6 +303,9 @@ sealed abstract class Range( * in this non-empty range? * * This method returns nonsensical results if `n < 0` or if `this.isEmpty`. + * + * @param n the non-negative value to compare against the number of elements + * @return `true` if `n` is greater than or equal to the number of elements in this range */ @inline private def greaterEqualNumRangeElements(n: Int): Boolean = (n ^ Int.MinValue) > ((numRangeElements - 1) ^ Int.MinValue) // unsigned comparison @@ -326,6 +333,9 @@ sealed abstract class Range( /** Creates a new range consisting of the last `n` elements of the range. * * $doesNotUseBuilders + * + * @param n the number of elements to take from the right + * @return a new range consisting of the last `n` elements, or an empty range if `n <= 0`, or the entire range if `n` is greater than its length */ final override def takeRight(n: Int): Range = { if (n <= 0 || isEmpty) newEmptyRange(start) @@ -336,6 +346,9 @@ sealed abstract class Range( /** Creates a new range consisting of the initial `length - n` elements of the range. * * $doesNotUseBuilders + * + * @param n the number of elements to drop from the right + * @return a new range consisting of all elements except the last `n`, or this range unchanged if `n <= 0`, or an empty range if `n` is greater than its length */ final override def dropRight(n: Int): Range = { if (n <= 0 || isEmpty) this @@ -585,6 +598,11 @@ object Range { * precondition: step != 0 * If the size of the range exceeds Int.MaxValue, the * result will be negative. + * + * @param start the start value of the range + * @param end the end value of the range (exclusive or inclusive depending on `isInclusive`) + * @param step the step value between consecutive elements, must be non-zero + * @param isInclusive whether `end` is included in the range */ def count(start: Int, end: Int, step: Int, isInclusive: Boolean): Int = { if (step == 0) @@ -617,18 +635,34 @@ object Range { /** Makes a range from `start` until `end` (exclusive) with given step value. * @note step != 0 + * + * @param start the start value of the range + * @param end the exclusive end value of the range + * @param step the step value between consecutive elements, must be non-zero */ def apply(start: Int, end: Int, step: Int): Range.Exclusive = new Range.Exclusive(start, end, step) - /** Makes a range from `start` until `end` (exclusive) with step value 1. */ + /** Makes a range from `start` until `end` (exclusive) with step value 1. + * + * @param start the start value of the range + * @param end the exclusive end value of the range + */ def apply(start: Int, end: Int): Range.Exclusive = new Range.Exclusive(start, end, 1) /** Makes an inclusive range from `start` to `end` with given step value. * @note step != 0 + * + * @param start the start value of the range + * @param end the inclusive end value of the range + * @param step the step value between consecutive elements, must be non-zero */ def inclusive(start: Int, end: Int, step: Int): Range.Inclusive = new Range.Inclusive(start, end, step) - /** Makes an inclusive range from `start` to `end` with step value 1. */ + /** Makes an inclusive range from `start` to `end` with step value 1. + * + * @param start the start value of the range + * @param end the inclusive end value of the range + */ def inclusive(start: Int, end: Int): Range.Inclusive = new Range.Inclusive(start, end, 1) @SerialVersionUID(4L) @@ -696,7 +730,7 @@ private class RangeIterator( step: Int, lastElement: Int, initiallyEmpty: Boolean -) extends AbstractIterator[Int] with Serializable { self => +) extends AbstractIterator[Int] with Serializable { self: RangeIterator => private var _hasNext: Boolean = !initiallyEmpty private var _next: Int = start override def knownSize: Int = if (_hasNext) (lastElement - _next) / step + 1 else 0 diff --git a/library/src/scala/collection/immutable/RedBlackTree.scala b/library/src/scala/collection/immutable/RedBlackTree.scala index 4eb3770f18a5..383fea4d9820 100644 --- a/library/src/scala/collection/immutable/RedBlackTree.scala +++ b/library/src/scala/collection/immutable/RedBlackTree.scala @@ -71,6 +71,12 @@ private[collection] object RedBlackTree { } /** Creates a new balanced tree where `newLeft` replaces `tree.left`. * tree and newLeft are never null + * + * @tparam A1 the key type of the tree + * @tparam B the original value type of the tree + * @tparam B1 the value type of the result, a supertype of `B` + * @param tree the original tree whose left child is being replaced + * @param newLeft the new left subtree to substitute in */ protected final def mutableBalanceLeft[A1, B, B1 >: B](tree: Tree[A1, B], newLeft: Tree[A1, B1]): Tree[A1, B1] = { // Parameter trees @@ -115,6 +121,12 @@ private[collection] object RedBlackTree { } /** Creates a new balanced tree where `newRight` replaces `tree.right`. * tree and newRight are never null + * + * @tparam A1 the key type of the tree + * @tparam B the original value type of the tree + * @tparam B1 the value type of the result, a supertype of `B` + * @param tree the original tree whose right child is being replaced + * @param newRight the new right subtree to substitute in */ protected final def mutableBalanceRight[A1, B, B1 >: B](tree: Tree[A1, B], newRight: Tree[A1, B1]): Tree[A1, B1] = { // Parameter trees @@ -246,7 +258,14 @@ private[collection] object RedBlackTree { blacken(_init(tree)) } - /** Returns the smallest node with a key larger than or equal to `x`. Returns `null` if there is no such node. */ + /** Returns the smallest node with a key larger than or equal to `x`. Returns `null` if there is no such node. + * + * @tparam A the key type + * @tparam B the value type + * @param tree the red-black tree to search + * @param x the inclusive lower bound key to search for + * @param ordering the ordering used to compare keys + */ def minAfter[A, B](tree: Tree[A, B] | Null, x: A)(implicit ordering: Ordering[A]): Tree[A, B] | Null = if (tree eq null) null else { val cmp = ordering.compare(x, tree.key) if (cmp == 0) tree @@ -256,7 +275,14 @@ private[collection] object RedBlackTree { } else minAfter(tree.right, x) } - /** Returns the largest node with a key smaller than `x`. Returns `null` if there is no such node. */ + /** Returns the largest node with a key smaller than `x`. Returns `null` if there is no such node. + * + * @tparam A the key type + * @tparam B the value type + * @param tree the red-black tree to search + * @param x the exclusive upper bound key + * @param ordering the ordering used to compare keys + */ def maxBefore[A, B](tree: Tree[A, B] | Null, x: A)(implicit ordering: Ordering[A]): Tree[A, B] | Null = if (tree eq null) null else { val cmp = ordering.compare(x, tree.key) if (cmp <= 0) maxBefore(tree.left, x) @@ -338,7 +364,13 @@ private[collection] object RedBlackTree { new Tree(key, value.asInstanceOf[AnyRef], left, right, sizeAndColour) } - /** Creates a new balanced tree where `newLeft` replaces `tree.left`. */ + /** Creates a new balanced tree where `newLeft` replaces `tree.left`. + * + * @tparam A the key type + * @tparam B1 the value type + * @param tree the original tree whose left child is being replaced + * @param newLeft the new left subtree to substitute in + */ private def balanceLeft[A, B1](tree: Tree[A, B1], newLeft: Tree[A, B1]): Tree[A, B1] = { // Parameter trees // tree | newLeft @@ -379,7 +411,13 @@ private[collection] object RedBlackTree { } } } - /** Creates a new balanced tree where `newRight` replaces `tree.right`. */ + /** Creates a new balanced tree where `newRight` replaces `tree.right`. + * + * @tparam A the key type + * @tparam B1 the value type + * @param tree the original tree whose right child is being replaced + * @param newRight the new right subtree to substitute in + */ private def balanceRight[A, B1](tree: Tree[A, B1], newRight: Tree[A, B1]): Tree[A, B1] = { // Parameter trees // tree | newRight @@ -785,6 +823,13 @@ private[collection] object RedBlackTree { /** Creates a new immutable red tree. * left and right may be null. + * + * @tparam A the key type + * @tparam B the value type + * @param key the key stored in this node + * @param value the value associated with the key + * @param left the left subtree, or `null` if absent + * @param right the right subtree, or `null` if absent */ private[immutable] def RedTree[A, B](key: A, value: B, left: Tree[A, B] | Null, right: Tree[A, B] | Null): Tree[A, B] = { //assertNotMutable(left) @@ -857,6 +902,8 @@ private[collection] object RedBlackTree { * the leftmost subtree with the key that would be "next" after it according * to the ordering. Along the way build up the iterator's path stack so that "next" * functionality works. + * + * @param key the key from which to start iteration */ private def startFrom(key: A) : Tree[A,B] | Null = if (root eq null) null else { @tailrec def find(tree: Tree[A, B] | Null): Tree[A, B] | Null = @@ -936,7 +983,12 @@ private[collection] object RedBlackTree { override def nextResult(tree: Tree[A, B]) = tree.value } - /** Builds a Tree suitable for a TreeSet from an ordered sequence of keys. */ + /** Builds a Tree suitable for a TreeSet from an ordered sequence of keys. + * + * @tparam A the key type + * @param xs an iterator yielding keys in ascending order + * @param size the number of keys to consume from the iterator + */ def fromOrderedKeys[A](xs: Iterator[A]^, size: Int): Tree[A, Null] | Null = { val maxUsedDepth = 32 - Integer.numberOfLeadingZeros(size) // maximum depth of non-leaf nodes def f(level: Int, size: Int): Tree[A, Null] | Null = size match { @@ -952,7 +1004,13 @@ private[collection] object RedBlackTree { f(1, size) } - /** Builds a Tree suitable for a TreeMap from an ordered sequence of key/value pairs. */ + /** Builds a Tree suitable for a TreeMap from an ordered sequence of key/value pairs. + * + * @tparam A the key type + * @tparam B the value type + * @param xs an iterator yielding key-value pairs in ascending key order + * @param size the number of entries to consume from the iterator + */ def fromOrderedEntries[A, B](xs: Iterator[(A, B)]^, size: Int): Tree[A, B] | Null = { val maxUsedDepth = 32 - Integer.numberOfLeadingZeros(size) // maximum depth of non-leaf nodes def f(level: Int, size: Int): Tree[A, B] | Null = size match { @@ -1089,7 +1147,13 @@ private[collection] object RedBlackTree { tl.nn.right.nn.redWithLeftRight(balance(tl.nn, tl.nn.left.nn.red, tl.nn.right.nn.left), tree.blackWithLeftRight(tl.nn.right.nn.right, tr)) else sys.error("Defect: invariance violation") - /** `append` is similar to `join2` but requires that both subtrees have the same black height. */ + /** `append` is similar to `join2` but requires that both subtrees have the same black height. + * + * @tparam A the key type + * @tparam B the value type + * @param tl the left subtree to append, or `null` if empty + * @param tr the right subtree to append, or `null` if empty + */ private def append[A, B](tl: Tree[A, B] | Null, tr: Tree[A, B] | Null): Tree[A, B] | Null = { if (tl eq null) tr else if (tr eq null) tl @@ -1129,7 +1193,11 @@ private[collection] object RedBlackTree { def difference[A, B](t1: Tree[A, B] | Null, t2: Tree[A, ?] | Null)(implicit ordering: Ordering[A]): Tree[A, B] | Null = blacken(_difference(t1, t2.asInstanceOf[Tree[A, B]])) - /** Computes the rank from a tree and its black height. */ + /** Computes the rank from a tree and its black height. + * + * @param t the tree node, or `null` for an empty subtree + * @param bh the black height of `t` + */ @`inline` private def rank(t: Tree[?, ?] | Null, bh: Int): Int = { if(t eq null) 0 else if(t.isBlack) 2*(bh-1) diff --git a/library/src/scala/collection/immutable/Seq.scala b/library/src/scala/collection/immutable/Seq.scala index 618f6127ce5b..805868af18ee 100644 --- a/library/src/scala/collection/immutable/Seq.scala +++ b/library/src/scala/collection/immutable/Seq.scala @@ -30,6 +30,9 @@ trait Seq[+A] extends Iterable[A] /** * @define coll immutable sequence * @define Coll `immutable.Seq` + * + * @tparam A the element type of the sequence + * @tparam CC the type constructor for the collection type, constrained to be pure */ transparent trait SeqOps[+A, +CC[B] <: caps.Pure, +C] extends Any with collection.SeqOps[A, CC, C] with caps.Pure @@ -40,12 +43,15 @@ transparent trait SeqOps[+A, +CC[B] <: caps.Pure, +C] extends Any with collectio @SerialVersionUID(3L) object Seq extends SeqFactory.Delegate[Seq](List) { override def from[E](it: IterableOnce[E]^): Seq[E] = it match { - case s: Seq[E] => s + case s: Seq[E @unchecked] => s case _ => super.from(it) } } -/** Base trait for immutable indexed sequences that have efficient `apply` and `length`. */ +/** Base trait for immutable indexed sequences that have efficient `apply` and `length`. + * + * @tparam A the element type of the indexed sequence + */ trait IndexedSeq[+A] extends Seq[A] with collection.IndexedSeq[A] with IndexedSeqOps[A, IndexedSeq, IndexedSeq[A]] @@ -94,7 +100,7 @@ trait IndexedSeq[+A] extends Seq[A] /** a hint to the runtime when scanning values * [[apply]] is preferred for scan with a max index less than this value * [[iterator]] is preferred for scans above this range - * @return a hint about when to use [[apply]] or [[iterator]] + * @return the maximum length below which [[apply]] is preferred over [[iterator]] for element access */ protected def applyPreferredMaxLength: Int = IndexedSeqDefaults.defaultApplyPreferredMaxLength @@ -113,12 +119,16 @@ object IndexedSeqDefaults { @SerialVersionUID(3L) object IndexedSeq extends SeqFactory.Delegate[IndexedSeq](Vector) { override def from[E](it: IterableOnce[E]^): IndexedSeq[E] = it match { - case is: IndexedSeq[E] => is + case is: IndexedSeq[E @unchecked] => is case _ => super.from(it) } } -/** Base trait for immutable indexed `Seq` operations. */ +/** Base trait for immutable indexed `Seq` operations. + * + * @tparam A the element type of the indexed sequence + * @tparam CC the type constructor for the collection type, constrained to be pure + */ transparent trait IndexedSeqOps[+A, +CC[B] <: caps.Pure, +C] extends SeqOps[A, CC, C] with collection.IndexedSeqOps[A, CC, C] { @@ -131,7 +141,10 @@ transparent trait IndexedSeqOps[+A, +CC[B] <: caps.Pure, +C] } -/** Base trait for immutable linear sequences that have efficient `head` and `tail`. */ +/** Base trait for immutable linear sequences that have efficient `head` and `tail`. + * + * @tparam A the element type of the linear sequence + */ trait LinearSeq[+A] extends Seq[A] with collection.LinearSeq[A] @@ -144,7 +157,7 @@ trait LinearSeq[+A] @SerialVersionUID(3L) object LinearSeq extends SeqFactory.Delegate[LinearSeq](List) { override def from[E](it: IterableOnce[E]^): LinearSeq[E] = it match { - case ls: LinearSeq[E] => ls + case ls: LinearSeq[E @unchecked] => ls case _ => super.from(it) } } @@ -153,5 +166,8 @@ transparent trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] & extends Any with SeqOps[A, CC, C] with collection.LinearSeqOps[A, CC, C] -/** Explicit instantiation of the `Seq` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Seq` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the sequence + */ abstract class AbstractSeq[+A] extends scala.collection.AbstractSeq[A] with Seq[A] diff --git a/library/src/scala/collection/immutable/Set.scala b/library/src/scala/collection/immutable/Set.scala index 96de17239bbb..9cbb872daed6 100644 --- a/library/src/scala/collection/immutable/Set.scala +++ b/library/src/scala/collection/immutable/Set.scala @@ -20,7 +20,10 @@ import language.experimental.captureChecking import scala.collection.immutable.Set.Set4 import scala.collection.mutable.{Builder, ReusableBuilder} -/** Base trait for immutable set collections. */ +/** Base trait for immutable set collections. + * + * @tparam A the element type of the set + */ trait Set[A] extends Iterable[A] with collection.Set[A] with SetOps[A, Set, Set[A]] @@ -32,6 +35,9 @@ trait Set[A] extends Iterable[A] * * @define coll immutable set * @define Coll `immutable.Set` + * + * @tparam A the element type of the set + * @tparam CC the type constructor for the resulting set (e.g., `Set`) */ transparent trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] extends collection.SetOps[A, CC, C] { @@ -45,7 +51,10 @@ transparent trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] */ def incl(elem: A): C - /** Alias for `incl`. */ + /** Alias for `incl`. + * + * @param elem the element to add + */ override final def + (elem: A): C = incl(elem) // like in collection.Set but not deprecated /** Creates a new set with a given element removed from this set. @@ -56,7 +65,10 @@ transparent trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] */ def excl(elem: A): C - /** Alias for `excl`. */ + /** Alias for `excl`. + * + * @param elem the element to remove + */ @`inline` final override def - (elem: A): C = excl(elem) def diff(that: collection.Set[A]): C = @@ -70,7 +82,10 @@ transparent trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] */ def removedAll(that: IterableOnce[A]^): C = that.iterator.foldLeft[C](coll)(_ - _) - /** Alias for removedAll. */ + /** Alias for removedAll. + * + * @param that the collection of elements to remove + */ override final def -- (that: IterableOnce[A]^): C = removedAll(that) } @@ -355,11 +370,16 @@ object Set extends IterableFactory[Set] { } } -/** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the set + */ abstract class AbstractSet[A] extends scala.collection.AbstractSet[A] with Set[A] /** Builder for Set. * $multipleResults + * + * @tparam A the element type of the set being built */ private final class SetBuilderImpl[A] extends ReusableBuilder[A, Set[A]] { private var elems: Set[A] = Set.empty diff --git a/library/src/scala/collection/immutable/SortedMap.scala b/library/src/scala/collection/immutable/SortedMap.scala index 55ae6cbbd692..3efe6424ebcb 100644 --- a/library/src/scala/collection/immutable/SortedMap.scala +++ b/library/src/scala/collection/immutable/SortedMap.scala @@ -25,7 +25,7 @@ import scala.collection.mutable.Builder * Allows for range queries to be performed on its keys, and implementations must guarantee that traversal happens in * sorted order, according to the map's [[scala.math.Ordering]]. * - * @example ``` + * @example ```scala sc:compile * import scala.collection.immutable.SortedMap * * // Make a SortedMap via the companion object factory @@ -69,6 +69,7 @@ trait SortedMap[K, +V] * * Invoking transformer methods (e.g. `map`) will not preserve the default value. * + * @tparam V1 the type of the values in the resulting map, a supertype of `V` * @param d the function mapping keys to values, used for non-present keys * @return a wrapper of the map with a default value */ @@ -80,6 +81,7 @@ trait SortedMap[K, +V] * * Invoking transformer methods (e.g. `map`) will not preserve the default value. * + * @tparam V1 the type of the values in the resulting map, a supertype of `V` * @param d default value used for non-present keys * @return a wrapper of the map with a default value */ diff --git a/library/src/scala/collection/immutable/SortedSet.scala b/library/src/scala/collection/immutable/SortedSet.scala index 39a31ceecfa1..d2a08ee13696 100644 --- a/library/src/scala/collection/immutable/SortedSet.scala +++ b/library/src/scala/collection/immutable/SortedSet.scala @@ -17,7 +17,10 @@ package immutable import scala.language.`2.13` import language.experimental.captureChecking -/** Base trait for sorted sets. */ +/** Base trait for sorted sets. + * + * @tparam A the element type of the sorted set, which must have an implicit `Ordering` + */ trait SortedSet[A] extends Set[A] with collection.SortedSet[A] @@ -32,6 +35,10 @@ trait SortedSet[A] /** * @define coll immutable sorted set * @define Coll `immutable.SortedSet` + * + * @tparam A the element type of the sorted set + * @tparam CC the type constructor for the resulting sorted set (e.g., `SortedSet`) + * @tparam C the type of the concrete sorted set */ transparent trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C] diff --git a/library/src/scala/collection/immutable/Stream.scala b/library/src/scala/collection/immutable/Stream.scala index e8d3fa4f9570..d601a080ae89 100644 --- a/library/src/scala/collection/immutable/Stream.scala +++ b/library/src/scala/collection/immutable/Stream.scala @@ -52,6 +52,7 @@ sealed abstract class Stream[+A] extends AbstractSeq[A] /** Applies the given function `f` to each element of this linear sequence * (while respecting the order of the elements). * + * @tparam U the result type of `f`, discarded by `foreach` * @param f The treatment to apply to each element. * @note Overridden here as final to trigger tail-call optimization, which * replaces 'this' with 'tail' at each iteration. This is absolutely @@ -117,6 +118,7 @@ sealed abstract class Stream[+A] extends AbstractSeq[A] /** The stream resulting from the concatenation of this stream with the argument stream. * + * @tparam B the element type of the returned stream, which must be a supertype of `A` * @param suffix The collection that gets appended to this stream * @return The stream containing elements of this stream and the iterable object. */ @@ -163,7 +165,10 @@ sealed abstract class Stream[+A] extends AbstractSeq[A] else iterableFactory.empty } - /** A `collection.WithFilter` which allows GC of the head of stream during processing. */ + /** A `collection.WithFilter` which allows GC of the head of stream during processing. + * + * @param p the predicate used to test elements + */ override final def withFilter(p: A => Boolean): collection.WithFilter[A, Stream] = Stream.withFilter(coll, p) @@ -213,7 +218,7 @@ sealed abstract class Stream[+A] extends AbstractSeq[A] if (this.isEmpty || that.isEmpty) iterableFactory.empty else { val thatIterable = that match { - case that: collection.Iterable[B] => that + case that: collection.Iterable[B @unchecked] => that case _ => LazyList.from(that) } Stream.cons[(A, B)]((this.head, thatIterable.head), this.tail.zip(thatIterable.tail)) @@ -362,12 +367,18 @@ object Stream extends SeqFactory[Stream] { /** An alternative way of building and matching Streams using Stream.cons(hd, tl). */ object cons { /** A stream consisting of a given first element and remaining elements. + * + * @tparam A the element type of the stream * @param hd The first element of the result stream * @param tl The remaining elements of the result stream */ def apply[A](hd: A, tl: => Stream[A]): Stream[A] = new Cons(hd, tl) - /** Maps a stream to its head and tail. */ + /** Maps a stream to its head and tail. + * + * @tparam A the element type of the stream + * @param xs the stream to decompose + */ def unapply[A](xs: Stream[A]): Option[(A, Stream[A])] = #::.unapply(xs) } @@ -487,6 +498,7 @@ object Stream extends SeqFactory[Stream] { /** An infinite Stream that repeatedly applies a given function to a start value. * + * @tparam A the element type of the stream * @param start the start value of the Stream * @param f the function that's repeatedly applied * @return the Stream returning the infinite sequence of values `start, f(start), f(f(start)), ...` @@ -515,6 +527,7 @@ object Stream extends SeqFactory[Stream] { /** Creates an infinite Stream containing the given element expression (which * is computed for each occurrence). * + * @tparam A the element type of the stream * @param elem the element composing the resulting Stream * @return the Stream containing an infinite number of elem */ diff --git a/library/src/scala/collection/immutable/StrictOptimizedSeqOps.scala b/library/src/scala/collection/immutable/StrictOptimizedSeqOps.scala index 9dd2c040c0cc..4dbfce8a4a70 100644 --- a/library/src/scala/collection/immutable/StrictOptimizedSeqOps.scala +++ b/library/src/scala/collection/immutable/StrictOptimizedSeqOps.scala @@ -19,7 +19,12 @@ import language.experimental.captureChecking import scala.collection.generic.CommonErrors -/** Trait that overrides operations to take advantage of strict builders. */ +/** Trait that overrides operations to take advantage of strict builders. + * + * @tparam A the element type of the collection + * @tparam CC the type constructor of the collection (higher-kinded) + * @tparam C the type of the collection itself + */ transparent trait StrictOptimizedSeqOps[+A, +CC[B] <: caps.Pure, +C] extends Any with SeqOps[A, CC, C] diff --git a/library/src/scala/collection/immutable/TreeMap.scala b/library/src/scala/collection/immutable/TreeMap.scala index 75221b8e612a..28c1835c0848 100644 --- a/library/src/scala/collection/immutable/TreeMap.scala +++ b/library/src/scala/collection/immutable/TreeMap.scala @@ -34,7 +34,7 @@ import scala.runtime.AbstractFunction2 * consider a * [[scala.collection.immutable.SeqMap]], which does not need to * have an ordering supplied. * - * @example ``` + * @example ```scala sc:compile * import scala.collection.immutable.TreeMap * * // Make a TreeMap via the companion object factory @@ -155,7 +155,7 @@ final class TreeMap[K, +V] private (private val tree: RB.Tree[K, V] | Null)(impl newMapOrSelf(that match { case tm: TreeMap[K, V] @unchecked if ordering == tm.ordering => RB.union(tree, tm.tree) - case ls: LinearSeq[(K,V1)] => + case ls: LinearSeq[(K,V1) @unchecked] => if (ls.isEmpty) tree //to avoid the creation of the adder else { val adder = new Adder[V1] diff --git a/library/src/scala/collection/immutable/Vector.scala b/library/src/scala/collection/immutable/Vector.scala index 725a4aee03ea..b75905ace24b 100644 --- a/library/src/scala/collection/immutable/Vector.scala +++ b/library/src/scala/collection/immutable/Vector.scala @@ -48,7 +48,7 @@ object Vector extends StrictOptimizedSeqFactory[Vector] { val a1: Arr1 = it match { case as: ArraySeq.ofRef[?] if as.elemTag.runtimeClass == classOf[AnyRef] => as.unsafeArray.asInstanceOf[Arr1] - case it: Iterable[E] => + case it: Iterable[E @unchecked] => val a1 = new Arr1(knownSize) @annotation.unused val copied = it.copyToArray(a1.asInstanceOf[Array[Any]]) //assert(copied == knownSize) @@ -72,6 +72,11 @@ object Vector extends StrictOptimizedSeqFactory[Vector] { * Unlike `fill`, which takes a by-name argument for the value and can thereby * compute different values for each index, this method guarantees that all * elements are identical. This allows sparse allocation in O(log n) time and space. + * + * @tparam A the element type of the vector + * @param n the number of elements in the vector + * @param elem the element to fill every position with + * @return a new vector of size `n` with each element set to `elem` */ private[collection] def fillSparse[A](n: Int)(elem: A): Vector[A] = { //TODO Make public; this method is private for now because it is not forward binary compatible @@ -115,6 +120,8 @@ object Vector extends StrictOptimizedSeqFactory[Vector] { * * In addition to the data slices (`prefix1`, `prefix2`, ..., `dataN`, ..., `suffix2`, `suffix1`) we store a running * count of elements after each prefix for more efficient indexing without having to dereference all prefix arrays. + * + * @tparam A the element type of the vector */ sealed abstract class Vector[+A] private[immutable] (private[immutable] final val prefix1: Arr1) extends AbstractSeq[A] @@ -259,14 +266,24 @@ sealed abstract class Vector[+A] private[immutable] (private[immutable] final va override def tail: Vector[A] = slice(1, length) override def init: Vector[A] = slice(0, length-1) - /** Like slice but parameters must be 0 <= lo < hi < length. */ + /** Like slice but parameters must be `0 <= lo < hi <= length`. + * + * @param lo the lowest index to include (inclusive), must satisfy `0 <= lo < hi` + * @param hi the exclusive upper bound index, must satisfy `lo < hi <= length` + */ protected def slice0(lo: Int, hi: Int): Vector[A] /** Number of slices. */ protected[immutable] def vectorSliceCount: Int - /** Slices at index. */ + /** Slices at index. + * + * @param idx the zero-based slice index + */ protected[immutable] def vectorSlice(idx: Int): Array[? <: AnyRef | Null] - /** Length of all slices up to and including index. */ + /** Length of all slices up to and including index. + * + * @param idx the zero-based slice index + */ protected[immutable] def vectorSlicePrefixLength(idx: Int): Int override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int = iterator.copyToArray(xs, start, len) @@ -317,7 +334,10 @@ sealed abstract class Vector[+A] private[immutable] (private[immutable] final va } -/** This class only exists because we cannot override `slice` in `Vector` in a binary-compatible way. */ +/** This class only exists because we cannot override `slice` in `Vector` in a binary-compatible way. + * + * @tparam A the element type of the vector + */ private sealed abstract class VectorImpl[+A](_prefix1: Arr1) extends Vector[A](_prefix1) { override final def slice(from: Int, until: Int): Vector[A] = { @@ -330,7 +350,12 @@ private sealed abstract class VectorImpl[+A](_prefix1: Arr1) extends Vector[A](_ } -/** Vector with suffix and length fields; all Vector subclasses except Vector1 extend this. */ +/** Vector with suffix and length fields; all Vector subclasses except Vector1 extend this. + * + * @tparam A the element type of the vector + * @param suffix1 the last data array containing the rightmost elements + * @param length0 the total number of elements in this vector + */ private sealed abstract class BigVector[+A](_prefix1: Arr1, private[immutable] val suffix1: Arr1, private[immutable] val length0: Int) extends VectorImpl[A](_prefix1) { protected[immutable] final def foreachRest[U](f: A => U): Unit = { @@ -385,7 +410,10 @@ private object Vector0 extends BigVector[Nothing](empty1, empty1, 0) { new IndexOutOfBoundsException(s"$index is out of bounds (empty vector)") } -/** Flat ArraySeq-like structure. */ +/** Flat ArraySeq-like structure. + * + * @tparam A the element type of the vector + */ private final class Vector1[+A](_data1: Arr1) extends VectorImpl[A](_data1) { @inline def apply(index: Int): A = { @@ -443,7 +471,12 @@ private final class Vector1[+A](_data1: Arr1) extends VectorImpl[A](_data1) { } -/** 2-dimensional radix-balanced finger tree. */ +/** 2-dimensional radix-balanced finger tree. + * + * @tparam A the element type of the vector + * @param len1 the number of elements in `prefix1` + * @param data2 the central 2-dimensional data array + */ private final class Vector2[+A](_prefix1: Arr1, private[immutable] val len1: Int, private[immutable] val data2: Arr2, _suffix1: Arr1, @@ -543,7 +576,15 @@ private final class Vector2[+A](_prefix1: Arr1, private[immutable] val len1: Int } -/** 3-dimensional radix-balanced finger tree. */ +/** 3-dimensional radix-balanced finger tree. + * + * @tparam A the element type of the vector + * @param len1 the number of elements in `prefix1` + * @param prefix2 the 2nd-level prefix data arrays + * @param len12 the combined number of elements in `prefix1` and `prefix2` + * @param data3 the central 3-dimensional data array + * @param suffix2 the 2nd-level suffix data arrays + */ private final class Vector3[+A](_prefix1: Arr1, private[immutable] val len1: Int, private[immutable] val prefix2: Arr2, private[immutable] val len12: Int, private[immutable] val data3: Arr3, @@ -666,7 +707,18 @@ private final class Vector3[+A](_prefix1: Arr1, private[immutable] val len1: Int } -/** 4-dimensional radix-balanced finger tree. */ +/** 4-dimensional radix-balanced finger tree. + * + * @tparam A the element type of the vector + * @param len1 the number of elements in `prefix1` + * @param prefix2 the 2nd-level prefix data arrays + * @param len12 the combined number of elements in `prefix1` and `prefix2` + * @param prefix3 the 3rd-level prefix data arrays + * @param len123 the combined number of elements in `prefix1` through `prefix3` + * @param data4 the central 4-dimensional data array + * @param suffix3 the 3rd-level suffix data arrays + * @param suffix2 the 2nd-level suffix data arrays + */ private final class Vector4[+A](_prefix1: Arr1, private[immutable] val len1: Int, private[immutable] val prefix2: Arr2, private[immutable] val len12: Int, private[immutable] val prefix3: Arr3, private[immutable] val len123: Int, @@ -810,7 +862,21 @@ private final class Vector4[+A](_prefix1: Arr1, private[immutable] val len1: Int } -/** 5-dimensional radix-balanced finger tree. */ +/** 5-dimensional radix-balanced finger tree. + * + * @tparam A the element type of the vector + * @param len1 the number of elements in `prefix1` + * @param prefix2 the 2nd-level prefix data arrays + * @param len12 the combined number of elements in `prefix1` and `prefix2` + * @param prefix3 the 3rd-level prefix data arrays + * @param len123 the combined number of elements in `prefix1` through `prefix3` + * @param prefix4 the 4th-level prefix data arrays + * @param len1234 the combined number of elements in `prefix1` through `prefix4` + * @param data5 the central 5-dimensional data array + * @param suffix4 the 4th-level suffix data arrays + * @param suffix3 the 3rd-level suffix data arrays + * @param suffix2 the 2nd-level suffix data arrays + */ private final class Vector5[+A](_prefix1: Arr1, private[immutable] val len1: Int, private[immutable] val prefix2: Arr2, private[immutable] val len12: Int, private[immutable] val prefix3: Arr3, private[immutable] val len123: Int, @@ -975,7 +1041,24 @@ private final class Vector5[+A](_prefix1: Arr1, private[immutable] val len1: Int } -/** 6-dimensional radix-balanced finger tree. */ +/** 6-dimensional radix-balanced finger tree. + * + * @tparam A the element type of the vector + * @param len1 the number of elements in `prefix1` + * @param prefix2 the 2nd-level prefix data arrays + * @param len12 the combined number of elements in `prefix1` and `prefix2` + * @param prefix3 the 3rd-level prefix data arrays + * @param len123 the combined number of elements in `prefix1` through `prefix3` + * @param prefix4 the 4th-level prefix data arrays + * @param len1234 the combined number of elements in `prefix1` through `prefix4` + * @param prefix5 the 5th-level prefix data arrays + * @param len12345 the combined number of elements in `prefix1` through `prefix5` + * @param data6 the central 6-dimensional data array + * @param suffix5 the 5th-level suffix data arrays + * @param suffix4 the 4th-level suffix data arrays + * @param suffix3 the 3rd-level suffix data arrays + * @param suffix2 the 2nd-level suffix data arrays + */ private final class Vector6[+A](_prefix1: Arr1, private[immutable] val len1: Int, private[immutable] val prefix2: Arr2, private[immutable] val len12: Int, private[immutable] val prefix3: Arr3, private[immutable] val len123: Int, @@ -1166,6 +1249,9 @@ private final class Vector6[+A](_prefix1: Arr1, private[immutable] val len1: Int * of the originating vector is or where the cut is performed, this always results in a * structure with the highest-dimensional data in the middle and fingers of decreasing dimension * at both ends, which can be turned into a new vector with very little rebalancing. + * + * @param lo the start index (inclusive) of the slice + * @param hi the end index (exclusive) of the slice */ private final class VectorSliceBuilder(lo: Int, hi: Int) { //println(s"***** VectorSliceBuilder($lo, $hi)") @@ -1348,7 +1434,10 @@ private final class VectorSliceBuilder(lo: Int, hi: Int) { } } - /** Ensures prefix is not empty. */ + /** Ensures prefix is not empty. + * + * @param n the dimension level (1 through `maxDim`) at which to ensure the prefix is non-empty + */ private def balancePrefix(n: Int): Unit = { if(slices(prefixIdx(n)) eq null) { if(n == maxDim) { @@ -1369,7 +1458,10 @@ private final class VectorSliceBuilder(lo: Int, hi: Int) { } } - /** Ensures suffix is not empty. */ + /** Ensures suffix is not empty. + * + * @param n the dimension level (1 through `maxDim`) at which to ensure the suffix is non-empty + */ private def balanceSuffix(n: Int): Unit = { if(slices(suffixIdx(n)) eq null) { if(n == maxDim) { @@ -2015,7 +2107,11 @@ private[immutable] object VectorInline { type Arr5 = Array[Array[Array[Array[Array[AnyRef]]]]] type Arr6 = Array[Array[Array[Array[Array[Array[AnyRef]]]]]] - /** Dimension of the slice at index. */ + /** Dimension of the slice at index. + * + * @param count the total number of slices + * @param idx the zero-based slice index + */ @inline def vectorSliceDim(count: Int, idx: Int): Int = { val c = count/2 c+1-abs(idx-c) diff --git a/library/src/scala/collection/mutable/AnyRefMap.scala b/library/src/scala/collection/mutable/AnyRefMap.scala index 90489b740c96..d6138485a4ef 100644 --- a/library/src/scala/collection/mutable/AnyRefMap.scala +++ b/library/src/scala/collection/mutable/AnyRefMap.scala @@ -53,17 +53,26 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi import AnyRefMap._ def this() = this(AnyRefMap.exceptionDefault, 16, initBlank = true) - /** Creates a new `AnyRefMap` that returns default values according to a supplied key-value mapping. */ + /** Creates a new `AnyRefMap` that returns default values according to a supplied key-value mapping. + * + * @param defaultEntry the function mapping keys to default values + */ def this(defaultEntry: K -> V) = this(defaultEntry, 16, initBlank = true) /** Creates a new `AnyRefMap` with an initial buffer of specified size. * * An `AnyRefMap` can typically contain half as many elements as its buffer size * before it requires resizing. + * + * @param initialBufferSize the initial size of the internal buffer; the map can hold about half this many elements before resizing */ def this(initialBufferSize: Int) = this(AnyRefMap.exceptionDefault, initialBufferSize, initBlank = true) - /** Creates a new `AnyRefMap` with specified default values and initial buffer size. */ + /** Creates a new `AnyRefMap` with specified default values and initial buffer size. + * + * @param defaultEntry the function mapping keys to default values + * @param initialBufferSize the initial size of the internal buffer; the map can hold about half this many elements before resizing + */ def this(defaultEntry: K -> V, initialBufferSize: Int) = this(defaultEntry, initialBufferSize, initBlank = true) private var mask = 0 @@ -198,6 +207,9 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi * Note: this is the fastest way to retrieve a value that may or * may not exist, if the default null/zero is acceptable. For key/value * pairs that do exist, `apply` (i.e. `map(key)`) is equally fast. + * + * @param key the key to look up + * @return the value associated with `key`, or `null` if the key is not present */ def getOrNull(key: K): V | Null = { val i = seekEntry(hashOf(key), key) @@ -208,6 +220,8 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi * If the key does not exist in the map, the `defaultEntry` for that key * will be returned instead; an exception will be thrown if no * `defaultEntry` was supplied. + * + * @param key the key to look up */ override def apply(key: K): V = { val i = seekEntry(hashOf(key), key) @@ -216,6 +230,8 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi /** Defers to defaultEntry to find a default value for the key. Throws an * exception if no other default behavior was specified. + * + * @param key the key to look up a default value for */ override def default(key: K): V = defaultEntry(key) @@ -282,6 +298,9 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi /** Updates the map to include a new key-value pair. * * This is the fastest way to add an entry to an `AnyRefMap`. + * + * @param key the key to update + * @param value the new value to associate with `key` */ override def update(key: K, value: V): Unit = { val h = hashOf(key) @@ -305,7 +324,11 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi @deprecated("Use `addOne` or `update` instead; infix operations with an operand of multiple args will be deprecated", "2.13.3") def +=(key: K, value: V): this.type = { update(key, value); this } - /** Adds a new key/value pair to this map and returns the map. */ + /** Adds a new key/value pair to this map and returns the map. + * + * @param key the key to add + * @param value the value to associate with `key` + */ @inline final def addOne(key: K, value: V): this.type = { update(key, value); this } @inline override final def addOne(kv: (K, V)): this.type = { update(kv._1, kv._2); this } @@ -433,15 +456,26 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi } } - /** Applies a function to all keys of this map. */ + /** Applies a function to all keys of this map. + * + * @tparam A the result type of the function + * @param f the function to apply to each key + */ def foreachKey[A](f: K => A): Unit = foreachElement[K,A](_keys, f) - /** Applies a function to all values of this map. */ + /** Applies a function to all values of this map. + * + * @tparam A the result type of the function + * @param f the function to apply to each value + */ def foreachValue[A](f: V => A): Unit = foreachElement[V,A](_values, f) /** Creates a new `AnyRefMap` with different values. * Unlike `mapValues`, this method generates a new * collection immediately. + * + * @tparam V1 the new value type + * @param f the transformation function to apply to each value */ def mapValuesNow[V1](f: V => V1): AnyRefMap[K, V1] = { val arm = new AnyRefMap[K,V1](AnyRefMap.exceptionDefault, 1, initBlank = false) @@ -469,6 +503,8 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi /** Applies a transformation function to all values stored in this map. * Note: the default, if any, is not transformed. + * + * @param f the transformation function to apply to each value */ def transformValuesInPlace(f: V => V): this.type = { var i,j = 0 @@ -487,22 +523,28 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi // Previously, in Scala 2, f took `K with AnyRef` scala/bug#11035 /** An overload of `map` which produces an `AnyRefMap`. * - * @param f the mapping function must produce a key-value pair where the key is an `AnyRef` - * @param dummy an implicit placeholder for purposes of distinguishing the (erased) signature of this method + * @tparam K2 the key type of the resulting map, must be a subtype of `AnyRef` + * @tparam V2 the value type of the resulting map + * @param f the function mapping each key-value pair to a new key-value pair; the resulting key must be an `AnyRef` + * @param dummy implicit parameter used to distinguish this overload from the inherited version after erasure */ def map[K2 <: AnyRef, V2](f: ((K, V)) => (K2, V2))(implicit dummy: DummyImplicit): AnyRefMap[K2, V2] = AnyRefMap.from(new View.Map(this, f)) /** An overload of `flatMap` which produces an `AnyRefMap`. * - * @param f the mapping function must produce key-value pairs where the key is an `AnyRef` - * @param dummy an implicit placeholder for purposes of distinguishing the (erased) signature of this method + * @tparam K2 the key type of the resulting map, must be a subtype of `AnyRef` + * @tparam V2 the value type of the resulting map + * @param f the function mapping each key-value pair to a collection of new key-value pairs; the resulting keys must be `AnyRef`s + * @param dummy implicit parameter used to distinguish this overload from the inherited version after erasure */ def flatMap[K2 <: AnyRef, V2](f: ((K, V)) => IterableOnce[(K2, V2)]^)(implicit dummy: DummyImplicit): AnyRefMap[K2, V2] = AnyRefMap.from(new View.FlatMap(this, f)) /** An overload of `collect` which produces an `AnyRefMap`. * - * @param pf the mapping function must produce a key-value pair where the key is an `AnyRef` - * @param dummy an implicit placeholder for purposes of distinguishing the (erased) signature of this method + * @tparam K2 the key type of the resulting map, must be a subtype of `AnyRef` + * @tparam V2 the value type of the resulting map + * @param pf the partial function mapping key-value pairs to new key-value pairs; the resulting key must be an `AnyRef` + * @param dummy implicit parameter used to distinguish this overload from the inherited version after erasure */ def collect[K2 <: AnyRef, V2](pf: PartialFunction[(K, V), (K2, V2)])(implicit dummy: DummyImplicit): AnyRefMap[K2, V2] = strictOptimizedCollect(AnyRefMap.newBuilder[K2, V2], pf) @@ -537,6 +579,9 @@ object AnyRefMap { /** A builder for instances of `AnyRefMap`. * * This builder can be reused to create multiple instances. + * + * @tparam K the type of keys, must be a subtype of `AnyRef` + * @tparam V the type of values */ final class AnyRefMapBuilder[K <: AnyRef, V] extends ReusableBuilder[(K, V), AnyRefMap[K, V]] { private[collection] var elems: AnyRefMap[K, V] = new AnyRefMap[K, V] @@ -549,7 +594,12 @@ object AnyRefMap { override def knownSize: Int = elems.knownSize } - /** Creates a new `AnyRefMap` with zero or more key/value pairs. */ + /** Creates a new `AnyRefMap` with zero or more key/value pairs. + * + * @tparam K the type of keys, must be a subtype of `AnyRef` + * @tparam V the type of values + * @param elems the key-value pairs to initialize the map with + */ def apply[K <: AnyRef, V](elems: (K, V)*): AnyRefMap[K, V] = buildFromIterableOnce(elems) def newBuilder[K <: AnyRef, V]: ReusableBuilder[(K, V), AnyRefMap[K, V]] = new AnyRefMapBuilder[K, V] @@ -563,17 +613,26 @@ object AnyRefMap { arm } - /** Creates a new empty `AnyRefMap`. */ + /** Creates a new empty `AnyRefMap`. + * + * @tparam K the type of keys, must be a subtype of `AnyRef` + * @tparam V the type of values + */ def empty[K <: AnyRef, V]: AnyRefMap[K, V] = new AnyRefMap[K, V] - /** Creates a new empty `AnyRefMap` with the supplied default. */ + /** Creates a new empty `AnyRefMap` with the supplied default. + * + * @tparam K the type of keys, must be a subtype of `AnyRef` + * @tparam V the type of values + * @param default the function mapping keys to default values + */ def withDefault[K <: AnyRef, V](default: K -> V): AnyRefMap[K, V] = new AnyRefMap[K, V](default) /** Creates a new `AnyRefMap` from an existing source collection. A source collection * which is already an `AnyRefMap` gets cloned. * - * @tparam K the type of the keys - * @tparam V the type of the values + * @tparam K the type of keys, must be a subtype of `AnyRef` + * @tparam V the type of values * @param source Source collection * @return a new `AnyRefMap` with the elements of `source` */ @@ -584,6 +643,11 @@ object AnyRefMap { /** Creates a new `AnyRefMap` from arrays of keys and values. * Equivalent to but more efficient than `AnyRefMap((keys zip values): _*)`. + * + * @tparam K the type of keys, must be a subtype of `AnyRef` + * @tparam V the type of values + * @param keys the array of keys + * @param values the array of values, paired positionally with `keys` */ def fromZip[K <: AnyRef, V](keys: Array[K], values: Array[V]): AnyRefMap[K, V] = { val sz = math.min(keys.length, values.length) @@ -596,6 +660,11 @@ object AnyRefMap { /** Creates a new `AnyRefMap` from keys and values. * Equivalent to but more efficient than `AnyRefMap((keys zip values): _*)`. + * + * @tparam K the type of keys, must be a subtype of `AnyRef` + * @tparam V the type of values + * @param keys the collection of keys + * @param values the collection of values, paired positionally with `keys` */ def fromZip[K <: AnyRef, V](keys: Iterable[K], values: Iterable[V]): AnyRefMap[K, V] = { val sz = math.min(keys.size, values.size) diff --git a/library/src/scala/collection/mutable/ArrayBuffer.scala b/library/src/scala/collection/mutable/ArrayBuffer.scala index 7b276495cd28..15ae5c0fbe53 100644 --- a/library/src/scala/collection/mutable/ArrayBuffer.scala +++ b/library/src/scala/collection/mutable/ArrayBuffer.scala @@ -65,7 +65,10 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int) override def knownSize: Int = super[IndexedSeqOps].knownSize - /** Ensures that the internal array has at least `n` cells. */ + /** Ensures that the internal array has at least `n` cells. + * + * @param n the minimum number of cells required in the internal array + */ protected def ensureSize(n: Int): Unit = { array = ArrayBuffer.ensureSize(array, size0, n) } @@ -77,7 +80,10 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int) def sizeHint(size: Int): Unit = if(size > length && size >= 1) ensureSize(size) - /** Reduces length to `n`, nulling out all dropped elements. */ + /** Reduces length to `n`, nulling out all dropped elements. + * + * @param n the new size of the buffer, must be less than or equal to the current size + */ private def reduceToSize(n: Int): Unit = { mutationCount += 1 Arrays.fill(array, n, size0, null) @@ -95,6 +101,8 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int) /** Trims the `array` buffer size down to either a power of 2 * or Int.MaxValue while keeping first `requiredLength` elements. + * + * @param requiredLength the number of elements to retain in the resized array */ private def resize(requiredLength: Int): Unit = array = ArrayBuffer.downsize(array, requiredLength) @@ -179,7 +187,7 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int) def insertAll(@deprecatedName("n", "2.13.0") index: Int, elems: IterableOnce[A]^): Unit = { checkWithinBounds(index, index) elems match { - case elems: collection.Iterable[A] => + case elems: collection.Iterable[A @unchecked] => val elemsLength = elems.size if (elemsLength > 0) { mutationCount += 1 @@ -246,6 +254,7 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int) /** Sorts this $coll in place according to an Ordering. * * @see [[scala.collection.mutable.IndexedSeqOps.sortInPlace]] + * @tparam B a supertype of the element type `A` for which an `Ordering` is available * @param ord the ordering to be used to compare elements. * @return modified input $coll sorted according to the ordering `ord`. */ diff --git a/library/src/scala/collection/mutable/ArrayBuilder.scala b/library/src/scala/collection/mutable/ArrayBuilder.scala index 20fdb60a75e6..8102aae99736 100644 --- a/library/src/scala/collection/mutable/ArrayBuilder.scala +++ b/library/src/scala/collection/mutable/ArrayBuilder.scala @@ -47,10 +47,18 @@ sealed abstract class ArrayBuilder[T] protected def resize(size: Int): Unit - /** Adds all elements of an array. */ + /** Adds all elements of an array. + * + * @param xs the array of elements to add + */ def addAll(xs: Array[? <: T]): this.type = addAll(xs, 0, xs.length) - /** Adds a slice of an array. */ + /** Adds a slice of an array. + * + * @param xs the array from which a slice of elements is added + * @param offset the start index within `xs` from which to copy elements (clamped to 0 if negative) + * @param length the maximum number of elements to copy from `xs` (clamped to 0 if negative, and to the number of available elements) + */ def addAll(xs: Array[? <: T], offset: Int, length: Int): this.type = { val offset1 = offset.max(0) val length1 = length.max(0) diff --git a/library/src/scala/collection/mutable/ArraySeq.scala b/library/src/scala/collection/mutable/ArraySeq.scala index c0dc31098729..d9d6e613fc23 100644 --- a/library/src/scala/collection/mutable/ArraySeq.scala +++ b/library/src/scala/collection/mutable/ArraySeq.scala @@ -121,6 +121,10 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self => * boxed, the resulting instance is an [[ArraySeq.ofRef]]. Writing * `ArraySeq.make(a.asInstanceOf[Array[Int]])` does not work, it throws a `ClassCastException` * at runtime. + * + * @tparam T the element type of the array + * @param x the array to wrap + * @return an `ArraySeq` wrapping the given array using the appropriate primitive specialization, or `null` if `x` is `null` */ def make[T](x: Array[T]): ArraySeq[T] = ((x: @unchecked) match { case null => null diff --git a/library/src/scala/collection/mutable/BitSet.scala b/library/src/scala/collection/mutable/BitSet.scala index bbf84d8424f4..e216736d910d 100644 --- a/library/src/scala/collection/mutable/BitSet.scala +++ b/library/src/scala/collection/mutable/BitSet.scala @@ -34,6 +34,8 @@ import scala.annotation.implicitNotFound * @define orderDependentFold * @define mayNotTerminateInf * @define willNotTerminateInf + * + * @param protected[collection] final var elems the underlying array of `Long` words storing the bits; used directly without copying, so external mutations will affect this bitset */ class BitSet(protected[collection] final var elems: Array[Long]) extends AbstractSet[Int] @@ -215,7 +217,7 @@ class BitSet(protected[collection] final var elems: Array[Long]) } this - case sorted: collection.SortedSet[Int] => + case sorted: collection.SortedSet[Int @unchecked] => // if `sorted` is using the regular Int ordering, ensure capacity for the largest // element up front to avoid multiple resizing allocations if (sorted.nonEmpty) { @@ -368,7 +370,10 @@ object BitSet extends SpecificIterableFactory[Int, BitSet] { def newBuilder: Builder[Int, BitSet] = new GrowableBuilder(empty) - /** A bitset containing all the bits in an array. */ + /** A bitset containing all the bits in an array. + * + * @param elems the array of `Long` words representing the bits; a defensive copy is made + */ def fromBitMask(elems: Array[Long]): BitSet = { val len = elems.length if (len == 0) empty @@ -380,6 +385,8 @@ object BitSet extends SpecificIterableFactory[Int, BitSet] { /** A bitset containing all the bits in an array, wrapping the existing * array without copying. + * + * @param elems the array of `Long` words representing the bits, used directly without copying; the caller must not mutate the array afterward */ def fromBitMaskNoCopy(elems: Array[Long]): BitSet = { val len = elems.length diff --git a/library/src/scala/collection/mutable/Buffer.scala b/library/src/scala/collection/mutable/Buffer.scala index c6c46847afea..637acefcd91a 100644 --- a/library/src/scala/collection/mutable/Buffer.scala +++ b/library/src/scala/collection/mutable/Buffer.scala @@ -22,6 +22,8 @@ import scala.annotation.nowarn * * @define coll buffer * @define Coll `Buffer` + * + * @tparam A the element type of the buffer */ trait Buffer[A] extends Seq[A] @@ -311,5 +313,8 @@ object Buffer extends SeqFactory.Delegate[Buffer](ArrayBuffer) @SerialVersionUID(3L) object IndexedBuffer extends SeqFactory.Delegate[IndexedBuffer](ArrayBuffer) -/** Explicit instantiation of the `Buffer` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Buffer` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the buffer + */ abstract class AbstractBuffer[A] extends AbstractSeq[A] with Buffer[A] diff --git a/library/src/scala/collection/mutable/Builder.scala b/library/src/scala/collection/mutable/Builder.scala index 0060c05b8538..7e19327bcea4 100644 --- a/library/src/scala/collection/mutable/Builder.scala +++ b/library/src/scala/collection/mutable/Builder.scala @@ -22,6 +22,9 @@ import language.experimental.captureChecking * Builder, in which case `result()` simply returns `this`. * * @see [[scala.collection.mutable.ReusableBuilder]] for Builders which can be reused after calling `result()` + * + * @tparam A the type of elements that can be added to this builder + * @tparam To the type of collection produced by this builder */ trait Builder[-A, +To] extends Growable[A] { self: Builder[A, To]^ => @@ -50,9 +53,14 @@ trait Builder[-A, +To] extends Growable[A] { self: Builder[A, To]^ => * to have the same size as the given collection, plus some delta. * * This method provides a hint only if the collection has a known size, - * as specified by the following pseudocode: + * as specified by the following code: * + * ```scala sc-name:builder-sizehint-context sc-hidden + * val coll: scala.collection.IterableOnce[?] = ??? + * val delta: Int = 0 + * def sizeHint(size: Int): Unit = () * ``` + * ```scala sc-compile-with:builder-sizehint-context * if (coll.knownSize != -1) * if (coll.knownSize + delta <= 0) sizeHint(0) * else sizeHint(coll.knownSize + delta) @@ -94,7 +102,11 @@ trait Builder[-A, +To] extends Growable[A] { self: Builder[A, To]^ => } } - /** A builder resulting from this builder by mapping the result using `f`. */ + /** A builder resulting from this builder by mapping the result using `f`. + * + * @tparam NewTo the type of collection produced by the returned builder + * @param f the function to apply to this builder's result + */ def mapResult[NewTo](f: To => NewTo): Builder[A, NewTo]^{this, f} = new Builder[A, NewTo] { def addOne(x: A): this.type = { self += x; this } def clear(): Unit = self.clear() diff --git a/library/src/scala/collection/mutable/CheckedIndexedSeqView.scala b/library/src/scala/collection/mutable/CheckedIndexedSeqView.scala index ba9af308e8c7..928a35f87699 100644 --- a/library/src/scala/collection/mutable/CheckedIndexedSeqView.scala +++ b/library/src/scala/collection/mutable/CheckedIndexedSeqView.scala @@ -102,7 +102,7 @@ private[mutable] object CheckedIndexedSeqView { class Reverse[A](underlying: SomeIndexedSeqOps[A]^)(protected val mutationCount: () => Int) extends IndexedSeqView.Reverse[A](underlying) with CheckedIndexedSeqView[A] { override def reverse: IndexedSeqView[A]^{this} = underlying match { - case x: IndexedSeqView[A] => x + case x: IndexedSeqView[A @unchecked] => x case _ => super.reverse } } diff --git a/library/src/scala/collection/mutable/CollisionProofHashMap.scala b/library/src/scala/collection/mutable/CollisionProofHashMap.scala index 12dffebdc4a5..533fa511fb3e 100644 --- a/library/src/scala/collection/mutable/CollisionProofHashMap.scala +++ b/library/src/scala/collection/mutable/CollisionProofHashMap.scala @@ -34,6 +34,11 @@ import scala.runtime.Statics * @define coll mutable collision-proof hash map * @define mayNotTerminateInf * @define willNotTerminateInf + * + * @tparam K the type of the keys contained in this hash map + * @tparam V the type of the values associated with the keys + * @param initialCapacity the initial capacity of the internal hash table + * @param loadFactor the load factor for the hash table, used to determine when to resize */ final class CollisionProofHashMap[K, V](initialCapacity: Int, loadFactor: Double)(implicit ordering: Ordering[K]) extends AbstractMap[K, V] @@ -414,6 +419,8 @@ final class CollisionProofHashMap[K, V](initialCapacity: Int, loadFactor: Double /** Builds a new `CollisionProofHashMap` by applying a function to all elements of this $coll. * + * @tparam K2 the key type of the returned collection + * @tparam V2 the value type of the returned collection * @param f the function to apply to each element. * @return a new $coll resulting from applying the given function * `f` to each element of this $coll and collecting the results. @@ -425,6 +432,8 @@ final class CollisionProofHashMap[K, V](initialCapacity: Int, loadFactor: Double /** Builds a new `CollisionProofHashMap` by applying a function to all elements of this $coll * and using the elements of the resulting collections. * + * @tparam K2 the key type of the returned collection + * @tparam V2 the value type of the returned collection * @param f the function to apply to each element. * @return a new $coll resulting from applying the given collection-valued function * `f` to each element of this $coll and concatenating the results. @@ -436,6 +445,8 @@ final class CollisionProofHashMap[K, V](initialCapacity: Int, loadFactor: Double /** Builds a new sorted map by applying a partial function to all elements of this $coll * on which the function is defined. * + * @tparam K2 the key type of the returned collection + * @tparam V2 the value type of the returned collection * @param pf the partial function which filters and maps the $coll. * @return a new $coll resulting from applying the given partial function * `pf` to each element on which it is defined and collecting the results. @@ -446,11 +457,15 @@ final class CollisionProofHashMap[K, V](initialCapacity: Int, loadFactor: Double sortedMapFactory.from(new View.Collect(this, pf)) override def concat[V2 >: V](suffix: IterableOnce[(K, V2)]^): CollisionProofHashMap[K, V2] = sortedMapFactory.from(suffix match { - case it: Iterable[(K, V2)] => new View.Concat(this, it) + case it: Iterable[(K, V2) @unchecked] => new View.Concat(this, it) case _ => iterator.concat(suffix.iterator) }) - /** Alias for `concat`. */ + /** Alias for `concat`. + * + * @tparam V2 the value type of the returned collection + * @param xs the key-value pairs to append to this collection + */ @`inline` override final def ++ [V2 >: V](xs: IterableOnce[(K, V2)]^): CollisionProofHashMap[K, V2] = concat(xs) @deprecated("Consider requiring an immutable Map or fall back to Map.concat", "2.13.0") @@ -695,6 +710,10 @@ final class CollisionProofHashMap[K, V](initialCapacity: Int, loadFactor: Double /** Transplant the node `from` to the place of node `to`. This is done by setting `from` as a child of `to`'s previous * parent and setting `from`'s parent to the `to`'s previous parent. The children of `from` are left unchanged. + * + * @param _root the root of the red-black tree + * @param to the node to be replaced in the tree + * @param from the node that replaces `to` */ private def transplant(_root: RBNode, to: RBNode, from: RBNode): RBNode = { var root = _root @@ -836,6 +855,10 @@ object CollisionProofHashMap extends SortedMapFactory[CollisionProofHashMap] { /** Returns the node that follows `node` in an in-order tree traversal. If `node` has the maximum key (and is, * therefore, the last node), this method returns `null`. + * + * @tparam A the key type of the tree nodes + * @tparam B the value type of the tree nodes + * @param node the node whose successor is to be found */ private def successor[A, B](node: RBNode[A, B]): RBNode[A, B] | Null = { if (node.right ne null) minNodeNonNull(node.right) @@ -894,4 +917,3 @@ object CollisionProofHashMap extends SortedMapFactory[CollisionProofHashMap] { } } } - diff --git a/library/src/scala/collection/mutable/Growable.scala b/library/src/scala/collection/mutable/Growable.scala index 7b1231b5eee5..45b0e3e14ef4 100644 --- a/library/src/scala/collection/mutable/Growable.scala +++ b/library/src/scala/collection/mutable/Growable.scala @@ -25,6 +25,8 @@ import language.experimental.captureChecking * @define Coll `Growable` * @define add add * @define Add Add + * + * @tparam A the type of elements that can be added to this collection */ trait Growable[-A] extends Clearable { diff --git a/library/src/scala/collection/mutable/GrowableBuilder.scala b/library/src/scala/collection/mutable/GrowableBuilder.scala index ba9308279916..f53b4fc81fdd 100644 --- a/library/src/scala/collection/mutable/GrowableBuilder.scala +++ b/library/src/scala/collection/mutable/GrowableBuilder.scala @@ -23,6 +23,9 @@ import language.experimental.captureChecking * * @define Coll `GrowingBuilder` * @define coll growing builder + * + * @tparam Elem the type of elements that can be added to the builder + * @tparam To the type of the resulting growable collection, which must be a subtype of `Growable[Elem]` */ class GrowableBuilder[Elem, To <: Growable[Elem]](protected val elems: To) extends Builder[Elem, To] { diff --git a/library/src/scala/collection/mutable/HashMap.scala b/library/src/scala/collection/mutable/HashMap.scala index c15225b85805..930a4138c456 100644 --- a/library/src/scala/collection/mutable/HashMap.scala +++ b/library/src/scala/collection/mutable/HashMap.scala @@ -62,10 +62,16 @@ class HashMap[K, V](initialCapacity: Int, loadFactor: Double) override def size: Int = contentSize - /** Performs the inverse operation of improveHash. In this case, it happens to be identical to improveHash. */ + /** Performs the inverse operation of improveHash. In this case, it happens to be identical to improveHash. + * + * @param improvedHash the improved hash value to convert back to the original `any.##` hash + */ @`inline` private[collection] def unimproveHash(improvedHash: Int): Int = improveHash(improvedHash) - /** Computes the improved hash of an original (`any.##`) hash. */ + /** Computes the improved hash of an original (`any.##`) hash. + * + * @param originalHash the original hash code from `any.##` + */ @`inline` private def improveHash(originalHash: Int): Int = { // Improve the hash by xoring the high 16 bits into the low 16 bits just in case entropy is skewed towards the // high-value bits. We only use the lowest bits to determine the hash bucket. This is the same improvement @@ -77,7 +83,10 @@ class HashMap[K, V](initialCapacity: Int, loadFactor: Double) originalHash ^ (originalHash >>> 16) } - /** Computes the improved hash of this key. */ + /** Computes the improved hash of this key. + * + * @param o the key for which to compute the improved hash + */ @`inline` private def computeHash(o: K): Int = improveHash(o.##) @`inline` private def index(hash: Int) = hash & (table.length - 1) diff --git a/library/src/scala/collection/mutable/HashSet.scala b/library/src/scala/collection/mutable/HashSet.scala index 27f635488c10..9267aaad0333 100644 --- a/library/src/scala/collection/mutable/HashSet.scala +++ b/library/src/scala/collection/mutable/HashSet.scala @@ -30,6 +30,10 @@ import scala.util.hashing.MurmurHash3 * @define coll mutable hash set * @define mayNotTerminateInf * @define willNotTerminateInf + * + * @tparam A the element type of the set + * @param initialCapacity the initial capacity of the internal hash table + * @param loadFactor the load factor for the hash table (ratio of size to capacity that triggers resizing) */ final class HashSet[A](initialCapacity: Int, loadFactor: Double) extends AbstractSet[A] @@ -57,10 +61,16 @@ final class HashSet[A](initialCapacity: Int, loadFactor: Double) override def size: Int = contentSize - /** Performs the inverse operation of improveHash. In this case, it happens to be identical to improveHash. */ + /** Performs the inverse operation of improveHash. In this case, it happens to be identical to improveHash. + * + * @param improvedHash the improved hash value to convert back to a standard hash index + */ @`inline` private[collection] def unimproveHash(improvedHash: Int): Int = improveHash(improvedHash) - /** Computes the improved hash of an original (`any.##`) hash. */ + /** Computes the improved hash of an original (`any.##`) hash. + * + * @param originalHash the original hash code obtained from `##` + */ private def improveHash(originalHash: Int): Int = { // Improve the hash by xoring the high 16 bits into the low 16 bits just in case entropy is skewed towards the // high-value bits. We only use the lowest bits to determine the hash bucket. This is the same improvement @@ -68,7 +78,10 @@ final class HashSet[A](initialCapacity: Int, loadFactor: Double) originalHash ^ (originalHash >>> 16) } - /** Computes the improved hash of this element. */ + /** Computes the improved hash of this element. + * + * @param o the element whose hash to compute + */ @`inline` private def computeHash(o: A): Int = improveHash(o.##) @`inline` private def index(hash: Int) = hash & (table.length - 1) diff --git a/library/src/scala/collection/mutable/HashTable.scala b/library/src/scala/collection/mutable/HashTable.scala index e28793ac6fad..32085041b0d4 100644 --- a/library/src/scala/collection/mutable/HashTable.scala +++ b/library/src/scala/collection/mutable/HashTable.scala @@ -36,6 +36,8 @@ import java.lang.Integer * overriding the corresponding values in class `HashTable`. * * @tparam A type of the elements contained in this hash table. + * @tparam B type of the values associated with keys in this hash table. + * @tparam Entry the type of hash table entries, must extend `HashEntry[A, Entry]` */ // Not used in the standard library, but used in scala-parallel-collections private[collection] trait HashTable[A, B, Entry <: HashEntry[A, Entry]] extends HashTable.HashUtils[A] { @@ -83,6 +85,9 @@ private[collection] trait HashTable[A, B, Entry <: HashEntry[A, Entry]] extends /** Initializes the collection from the input stream. `readEntry` will be called for each * entry to be read from the input stream. + * + * @param in the input stream to read the collection data from + * @param readEntry a by-name expression that reads and returns a single entry from the stream */ private[collection] def init(in: java.io.ObjectInputStream, readEntry: => Entry): Unit = { _loadFactor = in.readInt() @@ -113,6 +118,9 @@ private[collection] trait HashTable[A, B, Entry <: HashEntry[A, Entry]] extends * * `foreachEntry` determines the order in which the key/value pairs are saved to the stream. To * deserialize, `init` should be used. + * + * @param out the output stream to write the collection data to + * @param writeEntry a function that writes a single entry to the output stream */ private[collection] def serializeTo(out: java.io.ObjectOutputStream, writeEntry: Entry => Unit): Unit = { out.writeInt(_loadFactor) @@ -123,7 +131,10 @@ private[collection] trait HashTable[A, B, Entry <: HashEntry[A, Entry]] extends foreachEntry(writeEntry) } - /** Finds entry with given key in table, null if not found. */ + /** Finds entry with given key in table, null if not found. + * + * @param key the key to look up in the hash table + */ final def findEntry(key: A): Entry | Null = findEntry0(key, index(elemHashCode(key))) @@ -135,6 +146,8 @@ private[collection] trait HashTable[A, B, Entry <: HashEntry[A, Entry]] extends /** Adds entry to table * pre: no entry with same key exists + * + * @param e the entry to add to the hash table */ protected[collection] final def addEntry(e: Entry): Unit = { addEntry0(e, index(elemHashCode(e.key))) @@ -154,6 +167,9 @@ private[collection] trait HashTable[A, B, Entry <: HashEntry[A, Entry]] extends * computes entry's hash index only once. * Returns entry found in table or null. * New entries are created by calling `createNewEntry` method. + * + * @param key the key to find or insert + * @param value the value to associate with the key if a new entry is created */ def findOrAddEntry(key: A, value: B): Entry | Null = { val h = index(elemHashCode(key)) @@ -164,14 +180,24 @@ private[collection] trait HashTable[A, B, Entry <: HashEntry[A, Entry]] extends /** Creates new entry to be immediately inserted into the hashtable. * This method is guaranteed to be called only once and in case that the entry * will be added. In other words, an implementation may be side-effecting. + * + * @param key the key for the new entry + * @param value the value to associate with the key */ def createNewEntry(key: A, value: B): Entry - /** Removes entry from table if present. */ + /** Removes entry from table if present. + * + * @param key the key of the entry to remove + */ final def removeEntry(key: A) : Entry | Null = { removeEntry0(key, index(elemHashCode(key))) } - /** Removes entry from table if present. */ + /** Removes entry from table if present. + * + * @param key the key of the entry to remove + * @param h the hash index into the table + */ private[collection] final def removeEntry0(key: A, h: Int) : Entry | Null = { var e = table(h).asInstanceOf[Entry | Null] if (e != null) { @@ -217,7 +243,11 @@ private[collection] trait HashTable[A, B, Entry <: HashEntry[A, Entry]] extends } } - /** Avoid iterator for a 2x faster traversal. */ + /** Avoid iterator for a 2x faster traversal. + * + * @tparam U the return type of the function `f` + * @param f the function to apply to each entry in the hash table + */ def foreachEntry[U](f: Entry => U): Unit = { val iterTable = table var idx = lastPopulatedIndex @@ -349,6 +379,8 @@ private[collection] trait HashTable[A, B, Entry <: HashEntry[A, Entry]] extends /** Note: we take the most significant bits of the hashcode, not the lower ones * this is of crucial importance when populating the table in parallel + * + * @param hcode the hash code of the element to index */ protected[collection] final def index(hcode: Int): Int = { val ones = table.length - 1 @@ -375,26 +407,29 @@ private[collection] object HashTable { protected[collection] def elemHashCode(key: KeyType) = key.## - /** Defer to a high-quality hash in [[scala.util.hashing]]. - * The goal is to distribute across bins as well as possible even if a hash code has low entropy at some bits. - *

- * OLD VERSION - quick, but bad for sequence 0-10000 - little entropy in higher bits - since 2003 - * ``` - * var h: Int = hcode + ~(hcode << 9) - * h = h ^ (h >>> 14) - * h = h + (h << 4) - * h ^ (h >>> 10) - * ``` - * the rest of the computation is due to SI-5293 + /** Defer to high-quality bit mixing in [[scala.util.hashing]]. + * The current implementation byte-swaps the original hash code and rotates it by a + * seed derived from the table size, to help spread entries across bins even when the + * original hash code has low entropy in some bits. + * + * @param hcode the original hash code to improve + * @param seed the seed value derived from the table size, used to rotate the hash */ protected final def improve(hcode: Int, seed: Int): Int = rotateRight(byteswap32(hcode), seed) } - /** Returns a power of two >= `target`. */ + /** Returns a power of two >= `target`. + * + * @param target the minimum value for the returned power of two + */ private[collection] def nextPositivePowerOfTwo(target: Int): Int = 1 << -numberOfLeadingZeros(target - 1) } -/** Class used internally. */ +/** Class used internally. + * + * @tparam A the type of the keys stored in this hash entry + * @tparam E the concrete entry type, forming a linked list via `next` + */ private[collection] trait HashEntry[A, E <: HashEntry[A, E]] { val key: A var next: E | Null = compiletime.uninitialized diff --git a/library/src/scala/collection/mutable/ImmutableBuilder.scala b/library/src/scala/collection/mutable/ImmutableBuilder.scala index a1a4d8870a9d..aaff9f7aa1bf 100644 --- a/library/src/scala/collection/mutable/ImmutableBuilder.scala +++ b/library/src/scala/collection/mutable/ImmutableBuilder.scala @@ -17,7 +17,11 @@ package mutable import scala.language.`2.13` import language.experimental.captureChecking -/** Reusable builder for immutable collections */ +/** Reusable builder for immutable collections + * + * @tparam A the element type of the collection being built + * @tparam C the type of the immutable collection to build (must be a subtype of `IterableOnce[?]`) + */ abstract class ImmutableBuilder[-A, C <: IterableOnce[?]](empty: C) extends ReusableBuilder[A, C] { diff --git a/library/src/scala/collection/mutable/IndexedSeq.scala b/library/src/scala/collection/mutable/IndexedSeq.scala index a0a97121a7d8..548679af447e 100644 --- a/library/src/scala/collection/mutable/IndexedSeq.scala +++ b/library/src/scala/collection/mutable/IndexedSeq.scala @@ -48,6 +48,7 @@ transparent trait IndexedSeqOps[A, +CC[_] <: caps.Pure, +C <: AnyRef] /** Sorts this $coll in place according to an Ordering. * * @see [[scala.collection.SeqOps.sorted]] + * @tparam B a supertype of the element type `A` for which an `Ordering` is available * @param ord the ordering to be used to compare elements. * @return modified input $coll sorted according to the ordering `ord`. */ @@ -73,6 +74,8 @@ transparent trait IndexedSeqOps[A, +CC[_] <: caps.Pure, +C <: AnyRef] /** Sorts this $coll in place according to a comparison function. * * @see [[scala.collection.SeqOps.sortWith]] + * + * @param lt the less-than comparison function; should return `true` if the first argument strictly precedes the second in the desired ordering */ def sortInPlaceWith(lt: (A, A) => Boolean): this.type = sortInPlace()(using Ordering.fromLessThan(lt)) @@ -80,6 +83,10 @@ transparent trait IndexedSeqOps[A, +CC[_] <: caps.Pure, +C <: AnyRef] * an implicitly given Ordering with a transformation function. * * @see [[scala.collection.SeqOps.sortBy]] + * + * @tparam B the target type of the transformation function `f`, for which an `Ordering` must exist + * @param f the transformation function that extracts a sort key of type `B` from each element + * @param ord the implicit ordering on type `B` used to compare transformed elements */ def sortInPlaceBy[B](f: A => B)(implicit ord: Ordering[B]): this.type = sortInPlace()(using ord.on(f)) diff --git a/library/src/scala/collection/mutable/Iterable.scala b/library/src/scala/collection/mutable/Iterable.scala index 87705ed7a1b7..87e7ec512b63 100644 --- a/library/src/scala/collection/mutable/Iterable.scala +++ b/library/src/scala/collection/mutable/Iterable.scala @@ -31,5 +31,8 @@ trait Iterable[A] @SerialVersionUID(3L) object Iterable extends IterableFactory.Delegate[Iterable](ArrayBuffer) -/** Explicit instantiation of the `Iterable` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Iterable` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the `Iterable` + */ abstract class AbstractIterable[A] extends scala.collection.AbstractIterable[A] with Iterable[A] diff --git a/library/src/scala/collection/mutable/LinkedHashMap.scala b/library/src/scala/collection/mutable/LinkedHashMap.scala index 8be32a31475c..f255a6eccb72 100644 --- a/library/src/scala/collection/mutable/LinkedHashMap.scala +++ b/library/src/scala/collection/mutable/LinkedHashMap.scala @@ -159,8 +159,8 @@ class LinkedHashMap[K, V] /** Removes a key from this map if it exists * * @param elem the element to remove - * @param hash the **improved** hashcode of `element` (see computeHash) - * @return the node that contained element if it was present, otherwise null + * @param hash the **improved** hash code of `elem` (see `computeHash`) + * @return the entry that contained `elem` if it was present, otherwise `null` */ private def removeEntry0(elem: K, hash: Int): Entry | Null = { val idx = index(hash) @@ -190,13 +190,19 @@ class LinkedHashMap[K, V] } } - /** Computes the improved hash of an original (`any.##`) hash. */ + /** Computes the improved hash of an original (`any.##`) hash. + * + * @param originalHash the original hash code obtained from `any.##` + */ @`inline` private def improveHash(originalHash: Int): Int = { originalHash ^ (originalHash >>> 16) } @`inline` private[collection] def unimproveHash(improvedHash: Int): Int = improveHash(improvedHash) - /** Computes the improved hash of this key. */ + /** Computes the improved hash of this key. + * + * @param o the key whose improved hash to compute + */ @`inline` private def computeHash(o: K): Int = improveHash(o.##) @`inline` private def index(hash: Int) = hash & (table.length - 1) @@ -365,7 +371,10 @@ class LinkedHashMap[K, V] e } - /** Deletes the entry from the LinkedHashMap, set the `earlier` and `later` pointers correctly. */ + /** Deletes the entry from the `LinkedHashMap`, set the `earlier` and `later` pointers correctly. + * + * @param e the entry to remove from the `LinkedHashMap` + */ private def deleteEntry(e: Entry): Unit = { if (e.earlier eq null) firstEntry = e.later else e.earlier.nn.later = e.later @@ -495,7 +504,14 @@ object LinkedHashMap extends MapFactory[LinkedHashMap] { def newBuilder[K, V]: GrowableBuilder[(K, V), LinkedHashMap[K, V]] = new GrowableBuilder(empty[K, V]) - /** Class for the linked hash map entry, used internally. */ + /** Class for the linked hash map entry, used internally. + * + * @tparam K the type of key stored in this entry + * @tparam V the type of value stored in this entry + * @param key the key for this map entry + * @param hash the improved hash code of `key` (see `improveHash`) + * @param value the value associated with `key` + */ private[mutable] final class LinkedEntry[K, V](val key: K, val hash: Int, var value: V) { var earlier: LinkedEntry[K, V] | Null = null var later: LinkedEntry[K, V] | Null = null diff --git a/library/src/scala/collection/mutable/LinkedHashSet.scala b/library/src/scala/collection/mutable/LinkedHashSet.scala index 20cc93188cd7..4dac570f2dbd 100644 --- a/library/src/scala/collection/mutable/LinkedHashSet.scala +++ b/library/src/scala/collection/mutable/LinkedHashSet.scala @@ -152,7 +152,10 @@ class LinkedHashSet[A] @`inline` private[collection] def unimproveHash(improvedHash: Int): Int = improveHash(improvedHash) - /** Computes the improved hash of this key. */ + /** Computes the improved hash of this key. + * + * @param o the key whose hash to compute + */ @`inline` private def computeHash(o: A): Int = improveHash(o.##) @`inline` private def index(hash: Int) = hash & (table.length - 1) @@ -180,7 +183,10 @@ class LinkedHashSet[A] e } - /** Deletes the entry from the LinkedHashSet, set the `earlier` and `later` pointers correctly. */ + /** Deletes the entry from the `LinkedHashSet`, set the `earlier` and `later` pointers correctly. + * + * @param e the entry to remove from the `LinkedHashSet` + */ private def deleteEntry(e: Entry): Unit = { if (e.earlier eq null) firstEntry = e.later else e.earlier.later = e.later @@ -329,7 +335,12 @@ object LinkedHashSet extends IterableFactory[LinkedHashSet] { def newBuilder[A]: GrowableBuilder[A, LinkedHashSet[A]] = new GrowableBuilder(empty[A]) - /** Class for the linked hash set entry, used internally. */ + /** Class for the linked hash set entry, used internally. + * + * @tparam A the type of the elements contained in the linked hash set + * @param key the element stored in this entry + * @param hash the hash value of `key` + */ private[mutable] final class Entry[A](val key: A, val hash: Int) { @annotation.stableNull var earlier: Entry[A] | Null = null @annotation.stableNull var later: Entry[A] | Null = null diff --git a/library/src/scala/collection/mutable/ListBuffer.scala b/library/src/scala/collection/mutable/ListBuffer.scala index c7b1740957d6..6260feb1db18 100644 --- a/library/src/scala/collection/mutable/ListBuffer.scala +++ b/library/src/scala/collection/mutable/ListBuffer.scala @@ -182,6 +182,8 @@ class ListBuffer[A] /** Reduces the length of the buffer, and nulls out last0 * if this reduces the length to 0. + * + * @param num the number of elements by which to reduce the length */ private def reduceLengthBy(num: Int): Unit = { len -= num @@ -393,7 +395,7 @@ class ListBuffer[A] * * Runs in constant time. * - * @return The last element of this $coll. + * @return the last element of this $coll. * @throws NoSuchElementException If the $coll is empty. */ override def last: A = if (last0 eq null) throw new NoSuchElementException("last of empty ListBuffer") else last0.head @@ -402,7 +404,7 @@ class ListBuffer[A] * * Runs in constant time. * - * @return the last element of this $coll$ if it is nonempty, `None` if it is empty. + * @return the last element of this $coll if it is nonempty, `None` if it is empty. */ override def lastOption: Option[A] = if (last0 eq null) None else Some(last0.head) diff --git a/library/src/scala/collection/mutable/LongMap.scala b/library/src/scala/collection/mutable/LongMap.scala index 2a9018495999..a41b69316b2b 100644 --- a/library/src/scala/collection/mutable/LongMap.scala +++ b/library/src/scala/collection/mutable/LongMap.scala @@ -36,6 +36,8 @@ import scala.language.implicitConversions * This map is not intended to contain more than 229 entries (approximately * 500 million). The maximum capacity is 230, but performance will degrade * rapidly as 230 is approached. + * + * @tparam V the type of the values stored in this map */ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBufferSize: Int, initBlank: Boolean) extends AbstractMap[Long, V] @@ -56,17 +58,26 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff } override protected def newSpecificBuilder: Builder[(Long, V),LongMap[V]] = new GrowableBuilder(LongMap.empty[V]) - /** Creates a new `LongMap` that returns default values according to a supplied key-value mapping. */ + /** Creates a new `LongMap` that returns default values according to a supplied key-value mapping. + * + * @param defaultEntry the function mapping keys to default values + */ def this(defaultEntry: Long -> V) = this(defaultEntry, 16, initBlank = true) /** Creates a new `LongMap` with an initial buffer of specified size. * * A LongMap can typically contain half as many elements as its buffer size * before it requires resizing. + * + * @param initialBufferSize the initial size of the internal buffer; the map can hold about half this many elements before resizing */ def this(initialBufferSize: Int) = this(LongMap.exceptionDefault, initialBufferSize, initBlank = true) - /** Creates a new `LongMap` with specified default values and initial buffer size. */ + /** Creates a new `LongMap` with specified default values and initial buffer size. + * + * @param defaultEntry the function mapping keys to default values + * @param initialBufferSize the initial size of the internal buffer; the map can hold about half this many elements before resizing + */ def this(defaultEntry: Long -> V, initialBufferSize: Int) = this(defaultEntry, initialBufferSize, initBlank = true) private var mask = 0 @@ -220,6 +231,9 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff * Note: this is the fastest way to retrieve a value that may or * may not exist, if the default null/zero is acceptable. For key/value * pairs that do exist, `apply` (i.e. `map(key)`) is equally fast. + * + * @param key the key to look up + * @return the value associated with `key`, or `null` if not present */ def getOrNull(key: Long): V | Null = { if (key == -key) { @@ -236,6 +250,8 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff /** Retrieves the value associated with a key. * If the key does not exist in the map, the `defaultEntry` for that key * will be returned instead. + * + * @param key the key to look up */ override def apply(key: Long): V = { if (key == -key) { @@ -251,6 +267,8 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff /** The user-supplied default value for the key. Throws an exception * if no other default behavior was specified. + * + * @param key the key whose default value is requested */ override def default(key: Long) = defaultEntry(key) @@ -321,6 +339,9 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff /** Updates the map to include a new key-value pair. * * This is the fastest way to add an entry to a `LongMap`. + * + * @param key the key of the entry to update + * @param value the new value to associate with `key` */ override def update(key: Long, value: V): Unit = { if (key == -key) { @@ -354,7 +375,11 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff @deprecated("Use `addOne` or `update` instead; infix operations with an operand of multiple args will be deprecated", "2.13.3") def +=(key: Long, value: V): this.type = { update(key, value); this } - /** Adds a new key/value pair to this map and returns the map. */ + /** Adds a new key/value pair to this map and returns the map. + * + * @param key the key to add + * @param value the value to associate with `key` + */ @inline final def addOne(key: Long, value: V): this.type = { update(key, value); this } @inline override final def addOne(kv: (Long, V)): this.type = { update(kv._1, kv._2); this } @@ -486,7 +511,11 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff override def updated[V1 >: V](key: Long, value: V1): LongMap[V1] = clone().asInstanceOf[LongMap[V1]].addOne(key, value) - /** Applies a function to all keys of this map. */ + /** Applies a function to all keys of this map. + * + * @tparam A the result type of the function + * @param f the function to apply to each key + */ def foreachKey[A](f: Long => A): Unit = { if ((extraKeys & 1) == 1) f(0L) if ((extraKeys & 2) == 2) f(Long.MinValue) @@ -501,7 +530,11 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff } } - /** Applies a function to all values of this map. */ + /** Applies a function to all values of this map. + * + * @tparam A the result type of the function + * @param f the function to apply to each value + */ def foreachValue[A](f: V => A): Unit = { if ((extraKeys & 1) == 1) f(zeroValue.asInstanceOf[V]) if ((extraKeys & 2) == 2) f(minValue.asInstanceOf[V]) @@ -519,6 +552,9 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff /** Creates a new `LongMap` with different values. * Unlike `mapValues`, this method generates a new * collection immediately. + * + * @tparam V1 the type of the values in the resulting map + * @param f the transformation function applied to each value */ def mapValuesNow[V1](f: V => V1): LongMap[V1] = { val zv = if ((extraKeys & 1) == 1) f(zeroValue.asInstanceOf[V]).asInstanceOf[AnyRef | Null] else null @@ -547,6 +583,8 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff /** Applies a transformation function to all values stored in this map. * Note: the default, if any, is not transformed. + * + * @param f the transformation function applied to each value */ def transformValuesInPlace(f: V => V): this.type = { if ((extraKeys & 1) == 1) zeroValue = f(zeroValue.asInstanceOf[V]).asInstanceOf[AnyRef | Null] @@ -565,19 +603,22 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff /** An overload of `map` which produces a `LongMap`. * + * @tparam V2 the value type of the resulting map * @param f the mapping function */ def map[V2](f: ((Long, V)) => (Long, V2)): LongMap[V2] = LongMap.from(new View.Map(coll, f)) /** An overload of `flatMap` which produces a `LongMap`. * + * @tparam V2 the value type of the resulting map * @param f the mapping function */ def flatMap[V2](f: ((Long, V)) => IterableOnce[(Long, V2)]^): LongMap[V2] = LongMap.from(new View.FlatMap(coll, f)) /** An overload of `collect` which produces a `LongMap`. * - * @param pf the mapping function + * @tparam V2 the value type of the resulting map + * @param pf the partial function to apply to matching elements */ def collect[V2](pf: PartialFunction[(Long, V), (Long, V2)]): LongMap[V2] = strictOptimizedCollect(LongMap.newBuilder[V2], pf) @@ -598,6 +639,8 @@ object LongMap { /** A builder for instances of `LongMap`. * * This builder can be reused to create multiple instances. + * + * @tparam V the type of the values in the map being built */ final class LongMapBuilder[V] extends ReusableBuilder[(Long, V), LongMap[V]] { private[collection] var elems: LongMap[V] = new LongMap[V] @@ -610,7 +653,11 @@ object LongMap { override def knownSize: Int = elems.knownSize } - /** Creates a new `LongMap` with zero or more key/value pairs. */ + /** Creates a new `LongMap` with zero or more key/value pairs. + * + * @tparam V the type of the values + * @param elems the key/value pairs to initialize the map with + */ def apply[V](elems: (Long, V)*): LongMap[V] = buildFromIterableOnce(elems) private def buildFromIterableOnce[V](elems: IterableOnce[(Long, V)]^): LongMap[V] = { @@ -622,18 +669,25 @@ object LongMap { lm } - /** Creates a new empty `LongMap`. */ + /** Creates a new empty `LongMap`. + * + * @tparam V the type of the values + */ def empty[V]: LongMap[V] = new LongMap[V] - /** Creates a new empty `LongMap` with the supplied default. */ + /** Creates a new empty `LongMap` with the supplied default. + * + * @tparam V the type of the values + * @param default the function mapping keys to default values + */ def withDefault[V](default: Long -> V): LongMap[V] = new LongMap[V](default) /** Creates a new `LongMap` from an existing source collection. A source collection * which is already a `LongMap` gets cloned. * - * @tparam V the type of the collection’s elements - * @param source Source collection - * @return a new `LongMap` with the elements of `source` + * @tparam V the type of the values + * @param source the source collection to create the map from + * @return a new `LongMap` with the elements of `source`; if `source` is already a `LongMap`, it is cloned */ def from[V](source: IterableOnce[(Long, V)]^): LongMap[V] = source match { case source: LongMap[?] => source.clone().asInstanceOf[LongMap[V]] @@ -644,6 +698,10 @@ object LongMap { /** Creates a new `LongMap` from arrays of keys and values. * Equivalent to but more efficient than `LongMap((keys zip values): _*)`. + * + * @tparam V the type of the values + * @param keys the array of `Long` keys + * @param values the array of values corresponding to each key */ def fromZip[V](keys: Array[Long], values: Array[V]): LongMap[V] = { val sz = math.min(keys.length, values.length) @@ -656,6 +714,10 @@ object LongMap { /** Creates a new `LongMap` from keys and values. * Equivalent to but more efficient than `LongMap((keys zip values): _*)`. + * + * @tparam V the type of the values + * @param keys the iterable of `Long` keys + * @param values the iterable of values corresponding to each key */ def fromZip[V](keys: scala.collection.Iterable[Long], values: scala.collection.Iterable[V]): LongMap[V] = { val sz = math.min(keys.size, values.size) diff --git a/library/src/scala/collection/mutable/Map.scala b/library/src/scala/collection/mutable/Map.scala index 9078cdca9d23..aeace6994a0b 100644 --- a/library/src/scala/collection/mutable/Map.scala +++ b/library/src/scala/collection/mutable/Map.scala @@ -18,7 +18,11 @@ import language.experimental.captureChecking import scala.language.`2.13` -/** Base type of mutable Maps. */ +/** Base type of mutable Maps. + * + * @tparam K the type of keys in the map + * @tparam V the type of values associated with keys + */ trait Map[K, V] extends Iterable[(K, V)] with collection.Map[K, V] @@ -65,6 +69,11 @@ trait Map[K, V] /** * @define coll mutable map * @define Coll `mutable.Map` + * + * @tparam K the type of keys in the map + * @tparam V the type of values associated with keys + * @tparam CC the higher-kinded type constructor for map operations returning the same collection type + * @tparam C the concrete type of the map collection */ transparent trait MapOps[K, V, +CC[X, Y] <: MapOps[X, Y, CC, ?], +C <: MapOps[K, V, CC, C]] extends IterableOps[(K, V), Iterable, C] @@ -267,5 +276,9 @@ object Map extends MapFactory.Delegate[Map](HashMap) { } -/** Explicit instantiation of the `Map` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Map` trait to reduce class file size in subclasses. + * + * @tparam K the type of keys in the map + * @tparam V the type of values associated with keys + */ abstract class AbstractMap[K, V] extends scala.collection.AbstractMap[K, V] with Map[K, V] diff --git a/library/src/scala/collection/mutable/MultiMap.scala b/library/src/scala/collection/mutable/MultiMap.scala index ed92d3689d63..c2cbbbbb60b5 100644 --- a/library/src/scala/collection/mutable/MultiMap.scala +++ b/library/src/scala/collection/mutable/MultiMap.scala @@ -20,7 +20,7 @@ import language.experimental.captureChecking * This class is typically used as a mixin. It turns maps which map `K` * to `Set[V]` objects into multimaps that map `K` to `V` objects. * - * @example ``` + * @example ```scala sc:compile * // first import all necessary types from package `collection.mutable` * import collection.mutable.{ HashMap, MultiMap, Set } * diff --git a/library/src/scala/collection/mutable/OpenHashMap.scala b/library/src/scala/collection/mutable/OpenHashMap.scala index 6003ea6d543f..8b4077816d98 100644 --- a/library/src/scala/collection/mutable/OpenHashMap.scala +++ b/library/src/scala/collection/mutable/OpenHashMap.scala @@ -41,6 +41,12 @@ object OpenHashMap extends MapFactory[OpenHashMap] { * deleted if and only if its `value` is `None`. * If its `key` is not the default value of type `Key`, the entry is occupied. * If the entry is occupied, `hash` contains the hash value of `key`. + * + * @tparam Key the type of keys stored in this entry + * @tparam Value the type of values stored in this entry + * @param key the key associated with this entry + * @param hash the cached hash code of `key` + * @param value `Some(v)` if the entry is occupied, `None` if deleted */ final private class OpenEntry[Key, Value](var key: Key, var hash: Int, @@ -101,7 +107,10 @@ class OpenHashMap[Key, Value](initialSize : Int) override def knownSize: Int = size private def size_=(s : Int): Unit = _size = s override def isEmpty: Boolean = _size == 0 - /** Returns a mangled hash code of the provided key. */ + /** Returns a mangled hash code of the provided key. + * + * @param key the key to compute the hash for + */ protected def hashOf(key: Key) = { var h = key.## h ^= ((h >>> 20) ^ (h >>> 12)) @@ -126,7 +135,8 @@ class OpenHashMap[Key, Value](initialSize : Int) /** Returns the index of the first slot in the hash table (in probe order) * that is, in order of preference, either occupied by the given key, deleted, or empty. * - * @param hash hash value for `key` + * @param hash the hash code of `key` + * @param key the key to search for in the hash table */ private def findIndex(key: Key, hash: Int): Int = { var index = hash & mask @@ -186,7 +196,10 @@ class OpenHashMap[Key, Value](initialSize : Int) } } - /** Deletes the hash table slot contained in the given entry. */ + /** Deletes the hash table slot contained in the given entry. + * + * @param entry the hash table entry to mark as deleted + */ @`inline` private def deleteSlot(entry: Entry) = { entry.key = null.asInstanceOf[Key] diff --git a/library/src/scala/collection/mutable/PriorityQueue.scala b/library/src/scala/collection/mutable/PriorityQueue.scala index aaa40215be9d..ea59c9df1aa9 100644 --- a/library/src/scala/collection/mutable/PriorityQueue.scala +++ b/library/src/scala/collection/mutable/PriorityQueue.scala @@ -47,17 +47,16 @@ import scala.math.Ordering * the invariant of the underlying heap-ordered tree. Note that [[clone]] * does not rebuild the underlying tree. * - * ``` - * scala> val pq = collection.mutable.PriorityQueue(1, 2, 5, 3, 7) - * val pq: scala.collection.mutable.PriorityQueue[Int] = PriorityQueue(7, 3, 5, 1, 2) + * ```scala sc:compile + * val pq = collection.mutable.PriorityQueue(1, 2, 5, 3, 7) + * // pq: scala.collection.mutable.PriorityQueue[Int] = PriorityQueue(7, 3, 5, 1, 2) * - * scala> pq.toList // also not in order - * val res0: List[Int] = List(7, 3, 5, 1, 2) - * - * scala> pq.clone.dequeueAll - * val res1: Seq[Int] = ArraySeq(7, 5, 3, 2, 1) - * ``` + * pq.toList // also not in order + * // res0: List[Int] = List(7, 3, 5, 1, 2) * + * pq.clone.dequeueAll + * // res1: Seq[Int] = ArraySeq(7, 5, 3, 2, 1) + * ``` * * @tparam A type of the elements in this priority queue. * @param ord implicit ordering used to compare the elements of type `A`. * @@ -264,7 +263,10 @@ sealed class PriorityQueue[A](implicit val ord: Ordering[A]) } else throw new NoSuchElementException("no element to remove from heap") - /** Dequeues all elements and returns them in a sequence, in priority order. */ + /** Dequeues all elements and returns them in a sequence, in priority order. + * + * @tparam A1 a supertype of the element type `A`, allowing the result to be typed more broadly + */ def dequeueAll[A1 >: A]: immutable.Seq[A1] = { val b = ArrayBuilder.make[Any] b.sizeHint(size) @@ -347,6 +349,8 @@ sealed class PriorityQueue[A](implicit val ord: Ordering[A]) /** Returns a regular queue containing the same elements. * * Note: the order of elements is undefined. + * + * @return a mutable `Queue` containing all elements of this priority queue */ def toQueue: Queue[A] = new Queue[A] ++= this.iterator diff --git a/library/src/scala/collection/mutable/Queue.scala b/library/src/scala/collection/mutable/Queue.scala index 6f6f85ebead6..d1b88350721c 100644 --- a/library/src/scala/collection/mutable/Queue.scala +++ b/library/src/scala/collection/mutable/Queue.scala @@ -28,6 +28,8 @@ import scala.collection.generic.DefaultSerializable * @define orderDependentFold * @define mayNotTerminateInf * @define willNotTerminateInf + * + * @tparam A the element type stored in this queue */ class Queue[A] protected (array: Array[AnyRef | Null], start: Int, end: Int) extends ArrayDeque[A](array, start, end) @@ -48,30 +50,32 @@ class Queue[A] protected (array: Array[AnyRef | Null], start: Int, end: Int) /** Adds elements to the end of this queue * - * @param elem - * @return this + * @param elem the element to enqueue + * @return the queue with the element enqueued */ def enqueue(elem: A): this.type = this += elem /** Enqueue two or more elements at the end of the queue. The last element * of the sequence will be on end of the queue. * - * @param elems the element sequence. - * @return this + * @param elem1 the first element to enqueue + * @param elem2 the second element to enqueue + * @param elems the remaining elements to enqueue + * @return the queue with the elements enqueued */ def enqueue(elem1: A, elem2: A, elems: A*): this.type = enqueue(elem1).enqueue(elem2).enqueueAll(elems) /** Enqueues all elements in the given iterable object into the queue. The - * last element in the iterable object will be on front of the new queue. + * last element in the iterable object will be at the end of the queue. * * @param elems the iterable object. - * @return this + * @return the queue with the elements enqueued */ def enqueueAll(elems: scala.collection.IterableOnce[A]^): this.type = this ++= elems /** Removes the first element from this queue and returns it. * - * @return + * @return the first element of the queue * @throws NoSuchElementException when queue is empty */ def dequeue(): A = removeHead() @@ -97,8 +101,8 @@ class Queue[A] protected (array: Array[AnyRef | Null], start: Int, end: Int) /** Returns and dequeues all elements from the queue which satisfy the given predicate. * - * @param f the predicate used for choosing elements - * @return The removed elements + * @param f the predicate that must hold true for elements to be dequeued from the front + * @return the removed elements, in order from front of the queue */ def dequeueWhile(f: A => Boolean): scala.collection.Seq[A] = removeHeadWhile(f) diff --git a/library/src/scala/collection/mutable/RedBlackTree.scala b/library/src/scala/collection/mutable/RedBlackTree.scala index 697edb0ed25d..f6d106b08c0a 100644 --- a/library/src/scala/collection/mutable/RedBlackTree.scala +++ b/library/src/scala/collection/mutable/RedBlackTree.scala @@ -128,6 +128,12 @@ private[collection] object RedBlackTree { /** Returns the first (lowest) map entry with a key equal or greater than `key`. Returns `None` if there is no such * node. + * + * @tparam A the key type of the tree entries + * @tparam B the value type of the tree entries + * @param tree the red-black tree to search + * @param key the lower bound (inclusive) for the key lookup + * @param ord the ordering used to compare keys */ def minAfter[A, B](tree: Tree[A, B], key: A)(implicit ord: Ordering[A]): Option[(A, B)] = minNodeAfter(tree.root, key) match { @@ -157,7 +163,14 @@ private[collection] object RedBlackTree { } } - /** Returns the last (highest) map entry with a key smaller than `key`. Returns `None` if there is no such node. */ + /** Returns the last (highest) map entry with a key smaller than `key`. Returns `None` if there is no such entry. + * + * @tparam A the key type of the tree entries + * @tparam B the value type of the tree entries + * @param tree the red-black tree to search + * @param key the upper bound (exclusive) for the key lookup + * @param ord the ordering used to compare keys + */ def maxBefore[A, B](tree: Tree[A, B], key: A)(implicit ord: Ordering[A]): Option[(A, B)] = maxNodeBefore(tree.root, key) match { case null => None @@ -360,6 +373,10 @@ private[collection] object RedBlackTree { /** Returns the node that follows `node` in an in-order tree traversal. If `node` has the maximum key (and is, * therefore, the last node), this method returns `null`. + * + * @tparam A the key type of the tree entries + * @tparam B the value type of the tree entries + * @param node the node whose in-order successor is to be found */ private def successor[A, B](node: Node[A, B]): Node[A, B] | Null = { if (node.right ne null) minNodeNonNull(node.right) @@ -376,6 +393,10 @@ private[collection] object RedBlackTree { /** Returns the node that precedes `node` in an in-order tree traversal. If `node` has the minimum key (and is, * therefore, the first node), this method returns `null`. + * + * @tparam A the key type of the tree entries + * @tparam B the value type of the tree entries + * @param node the node whose in-order predecessor is to be found */ private def predecessor[A, B](node: Node[A, B]): Node[A, B] | Null = { if (node.left ne null) maxNodeNonNull(node.left) @@ -424,6 +445,12 @@ private[collection] object RedBlackTree { /** Transplant the node `from` to the place of node `to`. This is done by setting `from` as a child of `to`'s previous * parent and setting `from`'s parent to the `to`'s previous parent. The children of `from` are left unchanged. + * + * @tparam A the key type of the tree entries + * @tparam B the value type of the tree entries + * @param tree the red-black tree being modified + * @param to the node to be replaced + * @param from the node to put in `to`'s position, or `null` to leave the position empty */ private def transplant[A, B](tree: Tree[A, B], to: Node[A, B], from: Node[A, B] | Null): Unit = { if (to.parent eq null) tree.root = from @@ -542,11 +569,20 @@ private[collection] object RedBlackTree { * - All red-black properties are satisfied; * - All non-null nodes have their `parent` reference correct; * - The size variable in `tree` corresponds to the actual size of the tree. + * + * @tparam A the key type of the tree entries + * @tparam B the value type of the tree entries + * @param tree the red-black tree to validate */ def isValid[A: Ordering, B](tree: Tree[A, B]): Boolean = isValidBST(tree.root) && hasProperParentRefs(tree) && isValidRedBlackTree(tree) && size(tree.root) == tree.size - /** Returns true if all non-null nodes have their `parent` reference correct. */ + /** Returns true if all non-null nodes have their `parent` reference correct. + * + * @tparam A the key type of the tree entries + * @tparam B the value type of the tree entries + * @param tree the red-black tree to check + */ private def hasProperParentRefs[A, B](tree: Tree[A, B]): Boolean = { def hasProperParentRefs(node: Node[A, B] | Null): Boolean = { @@ -562,7 +598,13 @@ private[collection] object RedBlackTree { else (tree.root.nn.parent eq null) && hasProperParentRefs(tree.root) } - /** Returns true if this node follows the properties of a binary search tree. */ + /** Returns true if this node follows the properties of a binary search tree. + * + * @tparam A the key type of the tree entries + * @tparam B the value type of the tree entries + * @param node the root node of the subtree to validate + * @param ord the ordering used to compare keys + */ private def isValidBST[A, B](node: Node[A, B] | Null)(implicit ord: Ordering[A]): Boolean = { if (node eq null) true else { @@ -574,6 +616,10 @@ private[collection] object RedBlackTree { /** Returns true if the tree has all the red-black tree properties: if the root node is black, if all children of red * nodes are black and if the path from any node to any of its null children has the same number of black nodes. + * + * @tparam A the key type of the tree entries + * @tparam B the value type of the tree entries + * @param tree the red-black tree to validate */ private def isValidRedBlackTree[A, B](tree: Tree[A, B]): Boolean = { @@ -600,7 +646,12 @@ private[collection] object RedBlackTree { // building - /** Builds a Tree suitable for a TreeSet from an ordered sequence of keys. */ + /** Builds a Tree suitable for a TreeSet from an ordered sequence of keys. + * + * @tparam A the key type of the set entries + * @param xs an iterator over keys in ascending order + * @param size the number of keys in the iterator + */ def fromOrderedKeys[A](xs: Iterator[A]^, size: Int): Tree[A, Null] = { val maxUsedDepth = 32 - Integer.numberOfLeadingZeros(size) // maximum depth of non-leaf nodes def f(level: Int, size: Int): Node[A, Null] | Null = size match { @@ -619,7 +670,13 @@ private[collection] object RedBlackTree { new Tree(f(1, size), size) } - /** Builds a Tree suitable for a TreeMap from an ordered sequence of key/value pairs. */ + /** Builds a Tree suitable for a TreeMap from an ordered sequence of key/value pairs. + * + * @tparam A the key type of the map entries + * @tparam B the value type of the map entries + * @param xs an iterator over key-value pairs in ascending key order + * @param size the number of key-value pairs in the iterator + */ def fromOrderedEntries[A, B](xs: Iterator[(A, B)]^, size: Int): Tree[A, B] = { val maxUsedDepth = 32 - Integer.numberOfLeadingZeros(size) // maximum depth of non-leaf nodes def f(level: Int, size: Int): Node[A, B] | Null = size match { diff --git a/library/src/scala/collection/mutable/Seq.scala b/library/src/scala/collection/mutable/Seq.scala index 72cbf8b67aba..615ead149898 100644 --- a/library/src/scala/collection/mutable/Seq.scala +++ b/library/src/scala/collection/mutable/Seq.scala @@ -35,6 +35,10 @@ object Seq extends SeqFactory.Delegate[Seq](ArrayBuffer) /** * @define coll mutable sequence * @define Coll `mutable.Seq` + * + * @tparam A the element type of the sequence + * @tparam CC the type constructor for the resulting collection + * @tparam C the full sequence type */ transparent trait SeqOps[A, +CC[_] <: caps.Pure, +C <: AnyRef] extends collection.SeqOps[A, CC, C] @@ -65,5 +69,8 @@ transparent trait SeqOps[A, +CC[_] <: caps.Pure, +C <: AnyRef] } } -/** Explicit instantiation of the `Seq` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Seq` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the sequence + */ abstract class AbstractSeq[A] extends scala.collection.AbstractSeq[A] with Seq[A] diff --git a/library/src/scala/collection/mutable/Set.scala b/library/src/scala/collection/mutable/Set.scala index 1145f5c75584..e464b627eedc 100644 --- a/library/src/scala/collection/mutable/Set.scala +++ b/library/src/scala/collection/mutable/Set.scala @@ -16,7 +16,10 @@ import scala.language.`2.13` import language.experimental.captureChecking import scala.collection.{IterableFactory, IterableFactoryDefaults, IterableOps} -/** Base trait for mutable sets. */ +/** Base trait for mutable sets. + * + * @tparam A the element type of the set + */ trait Set[A] extends Iterable[A] with collection.Set[A] @@ -29,6 +32,10 @@ trait Set[A] /** * @define coll mutable set * @define Coll `mutable.Set` + * + * @tparam A the element type of the set + * @tparam CC the type constructor for the collection (e.g., `Set`) + * @tparam C the concrete collection type */ transparent trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] extends collection.SetOps[A, CC, C] @@ -55,7 +62,11 @@ transparent trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] * This method allows one to add or remove an element `elem` * from this set depending on the value of parameter `included`. * Typically, one would use the following syntax: + * ```scala sc-name:set-update-context sc-hidden + * val set = scala.collection.mutable.Set(1) + * val elem = 1 * ``` + * ```scala sc-compile-with:set-update-context * set(elem) = true // adds element * set(elem) = false // removes element * ``` @@ -119,5 +130,8 @@ transparent trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]] object Set extends IterableFactory.Delegate[Set](HashSet) -/** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. */ +/** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. + * + * @tparam A the element type of the set + */ abstract class AbstractSet[A] extends scala.collection.AbstractSet[A] with Set[A] diff --git a/library/src/scala/collection/mutable/Shrinkable.scala b/library/src/scala/collection/mutable/Shrinkable.scala index 5b71b4bad057..2bb1fb0d0c2d 100644 --- a/library/src/scala/collection/mutable/Shrinkable.scala +++ b/library/src/scala/collection/mutable/Shrinkable.scala @@ -22,6 +22,8 @@ import scala.annotation.tailrec * * @define coll shrinkable collection * @define Coll `Shrinkable` + * + * @tparam A the type of elements that can be removed from this collection */ trait Shrinkable[-A] { @@ -68,7 +70,7 @@ trait Shrinkable[-A] { } } else { xs match { - case xs: collection.LinearSeq[A] => loop(xs) + case xs: collection.LinearSeq[A @unchecked] => loop(xs) case xs => xs.iterator.foreach(subtractOne) } } diff --git a/library/src/scala/collection/mutable/SortedMap.scala b/library/src/scala/collection/mutable/SortedMap.scala index 5fe3c3c6b3ca..7d05e2f4c1d8 100644 --- a/library/src/scala/collection/mutable/SortedMap.scala +++ b/library/src/scala/collection/mutable/SortedMap.scala @@ -17,7 +17,11 @@ import scala.language.`2.13` import language.experimental.captureChecking import scala.collection.{SortedMapFactory, SortedMapFactoryDefaults} -/** Base type for mutable sorted map collections */ +/** Base type for mutable sorted map collections + * + * @tparam K the type of the keys in this sorted map; an implicit `Ordering[K]` is required for most operations + * @tparam V the type of the values associated with the keys + */ trait SortedMap[K, V] extends collection.SortedMap[K, V] with Map[K, V] diff --git a/library/src/scala/collection/mutable/SortedSet.scala b/library/src/scala/collection/mutable/SortedSet.scala index 671a88b18630..fa799a36169a 100644 --- a/library/src/scala/collection/mutable/SortedSet.scala +++ b/library/src/scala/collection/mutable/SortedSet.scala @@ -17,7 +17,10 @@ package mutable import scala.language.`2.13` import language.experimental.captureChecking -/** Base type for mutable sorted set collections */ +/** Base type for mutable sorted set collections + * + * @tparam A the element type of the set, which must have an implicit `Ordering` + */ trait SortedSet[A] extends Set[A] with collection.SortedSet[A] @@ -32,6 +35,9 @@ trait SortedSet[A] /** * @define coll mutable sorted set * @define Coll `mutable.SortedSet` + * + * @tparam A the element type of the set + * @tparam CC the type constructor for the sorted set collection */ transparent trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]] extends SetOps[A, Set, C] diff --git a/library/src/scala/collection/mutable/Stack.scala b/library/src/scala/collection/mutable/Stack.scala index ab6c93357279..5d5aff7385cf 100644 --- a/library/src/scala/collection/mutable/Stack.scala +++ b/library/src/scala/collection/mutable/Stack.scala @@ -54,15 +54,17 @@ class Stack[A] protected (array: Array[AnyRef | Null], start: Int, end: Int) /** Adds elements to the top of this stack * - * @param elem - * @return + * @param elem the element to push onto the stack + * @return the stack with the new element on top */ def push(elem: A): this.type = prepend(elem) /** Pushes two or more elements onto the stack. The last element * of the sequence will be on top of the new stack. * - * @param elems the element sequence. + * @param elem1 the first element to push + * @param elem2 the second element to push + * @param elems the remaining elements to push * @return the stack with the new elements on top. */ def push(elem1: A, elem2: A, elems: A*): this.type = { @@ -79,13 +81,13 @@ class Stack[A] protected (array: Array[AnyRef | Null], start: Int, end: Int) */ def pushAll(elems: scala.collection.IterableOnce[A]^): this.type = prependAll(elems match { - case it: scala.collection.Seq[A] => it.view.reverse + case it: scala.collection.Seq[A @unchecked] => it.view.reverse case it => IndexedSeq.from(it).view.reverse }) /** Removes the top element from this stack and returns it * - * @return + * @return the element removed from the top of the stack * @throws NoSuchElementException when stack is empty */ def pop(): A = removeHead() diff --git a/library/src/scala/collection/mutable/StringBuilder.scala b/library/src/scala/collection/mutable/StringBuilder.scala index 6064524793b8..0d2570afd03a 100644 --- a/library/src/scala/collection/mutable/StringBuilder.scala +++ b/library/src/scala/collection/mutable/StringBuilder.scala @@ -71,11 +71,16 @@ final class StringBuilder(val underlying: java.lang.StringBuilder) extends Abstr /** Constructs a string builder with initial characters * equal to characters of `str`. + * + * @param str the initial string content of this builder */ def this(str: String) = this(new java.lang.StringBuilder(str)) /** Constructs a string builder initialized with string value `initValue` * and with additional character capacity `initCapacity`. + * + * @param initCapacity additional character capacity beyond the length of `initValue` + * @param initValue the initial string content of this builder */ def this(initCapacity: Int, initValue: String) = this(new java.lang.StringBuilder(initValue.length + initCapacity).append(initValue)) @@ -101,7 +106,10 @@ final class StringBuilder(val underlying: java.lang.StringBuilder) extends Abstr def clear(): Unit = underlying.setLength(0) - /** Overloaded version of `addAll` that takes a string. */ + /** Overloaded version of `addAll` that takes a string. + * + * @param s the string to append to this builder + */ def addAll(s: String): this.type = { underlying.append(s); this } /** Alias for `addAll`. */ @@ -447,7 +455,11 @@ final class StringBuilder(val underlying: java.lang.StringBuilder) extends Abstr */ def substring(start: Int, end: Int): String = underlying.substring(start, end) - /** For implementing CharSequence. */ + /** For implementing CharSequence. + * + * @param start the beginning index, inclusive + * @param end the ending index, exclusive + */ def subSequence(start: Int, end: Int): java.lang.CharSequence = underlying.substring(start, end) diff --git a/library/src/scala/collection/mutable/TreeMap.scala b/library/src/scala/collection/mutable/TreeMap.scala index b444edbdd5ab..183d5a2a003e 100644 --- a/library/src/scala/collection/mutable/TreeMap.scala +++ b/library/src/scala/collection/mutable/TreeMap.scala @@ -128,6 +128,7 @@ sealed class TreeMap[K, V] private (tree: RB.Tree[K, V])(implicit val ordering: * bound. * @param until the upper bound (exclusive) of this projection wrapped in a `Some`, or `None` if there is no upper * bound. + * @return a new `TreeMap` that is a ranged projection of this map, sharing the same underlying data */ def rangeImpl(from: Option[K], until: Option[K]): TreeMap[K, V] = new TreeMapProjection(from, until) @@ -165,21 +166,30 @@ sealed class TreeMap[K, V] private (tree: RB.Tree[K, V])(implicit val ordering: */ private final class TreeMapProjection(from: Option[K], until: Option[K]) extends TreeMap[K, V](tree) { - /** Given a possible new lower bound, chooses and returns the most constraining one (the maximum). */ + /** Given a possible new lower bound, chooses and returns the most constraining one (the maximum). + * + * @param newFrom a possible new lower bound wrapped in a `Some`, or `None` if unconstrained + */ private def pickLowerBound(newFrom: Option[K]): Option[K] = (from, newFrom) match { case (Some(fr), Some(newFr)) => Some(ordering.max(fr, newFr)) case (None, _) => newFrom case _ => from } - /** Given a possible new upper bound, chooses and returns the most constraining one (the minimum). */ + /** Given a possible new upper bound, chooses and returns the most constraining one (the minimum). + * + * @param newUntil a possible new upper bound wrapped in a `Some`, or `None` if unconstrained + */ private def pickUpperBound(newUntil: Option[K]): Option[K] = (until, newUntil) match { case (Some(unt), Some(newUnt)) => Some(ordering.min(unt, newUnt)) case (None, _) => newUntil case _ => until } - /** Returns true if the argument is inside the view bounds (between `from` and `until`). */ + /** Returns true if the argument is inside the view bounds (between `from` and `until`). + * + * @param key the key to check against the view bounds + */ private def isInsideViewBounds(key: K): Boolean = { val afterFrom = from.isEmpty || ordering.compare(from.get, key) <= 0 val beforeUntil = until.isEmpty || ordering.compare(key, until.get) < 0 diff --git a/library/src/scala/collection/mutable/TreeSet.scala b/library/src/scala/collection/mutable/TreeSet.scala index 91660a5f38f7..eda514ee5618 100644 --- a/library/src/scala/collection/mutable/TreeSet.scala +++ b/library/src/scala/collection/mutable/TreeSet.scala @@ -115,21 +115,30 @@ sealed class TreeSet[A] private (private val tree: RB.Tree[A, Null])(implicit va private final class TreeSetProjection(from: Option[A], until: Option[A]) extends TreeSet[A](tree) { self: TreeSetProjection^{} => - /** Given a possible new lower bound, chooses and returns the most constraining one (the maximum). */ + /** Given a possible new lower bound, chooses and returns the most constraining one (the maximum). + * + * @param newFrom a possible new lower bound wrapped in a `Some`, or `None` if unbounded + */ private def pickLowerBound(newFrom: Option[A]): Option[A] = (from, newFrom) match { case (Some(fr), Some(newFr)) => Some(ordering.max(fr, newFr)) case (None, _) => newFrom case _ => from } - /** Given a possible new upper bound, chooses and returns the most constraining one (the minimum). */ + /** Given a possible new upper bound, chooses and returns the most constraining one (the minimum). + * + * @param newUntil a possible new upper bound wrapped in a `Some`, or `None` if unbounded + */ private def pickUpperBound(newUntil: Option[A]): Option[A] = (until, newUntil) match { case (Some(unt), Some(newUnt)) => Some(ordering.min(unt, newUnt)) case (None, _) => newUntil case _ => until } - /** Returns true if the argument is inside the view bounds (between `from` and `until`). */ + /** Returns true if the argument is inside the view bounds (between `from` and `until`). + * + * @param key the element to check against the view bounds + */ private def isInsideViewBounds(key: A): Boolean = { val afterFrom = from.isEmpty || ordering.compare(from.get, key) <= 0 val beforeUntil = until.isEmpty || ordering.compare(key, until.get) < 0 diff --git a/library/src/scala/collection/mutable/UnrolledBuffer.scala b/library/src/scala/collection/mutable/UnrolledBuffer.scala index 618d331d24f2..1fdc4623616c 100644 --- a/library/src/scala/collection/mutable/UnrolledBuffer.scala +++ b/library/src/scala/collection/mutable/UnrolledBuffer.scala @@ -261,7 +261,10 @@ object UnrolledBuffer extends StrictOptimizedClassTagSeqFactory[UnrolledBuffer] private[collection] val unrolledlength = 32 - /** Unrolled buffer node. */ + /** Unrolled buffer node. + * + * @tparam T the element type stored in the node's array; requires an implicit `ClassTag` for array creation + */ class Unrolled[T: ClassTag] private[collection] (var size: Int, var array: Array[T], var next: Unrolled[T] | Null, val buff: UnrolledBuffer[T] | Null = null) { this: Unrolled[T]^{} => private[collection] def this() = this(0, new Array[T](unrolledlength), null, null) diff --git a/library/src/scala/collection/package.scala b/library/src/scala/collection/package.scala index d251eaea40c9..1095b0a6ae28 100644 --- a/library/src/scala/collection/package.scala +++ b/library/src/scala/collection/package.scala @@ -64,7 +64,10 @@ package object collection { /** An extractor used to head/tail deconstruct sequences. */ object +: { /** Splits a sequence into head +: tail. - * @return Some((head, tail)) if sequence is non-empty. None otherwise. + * + * @tparam A the element type of the sequence + * @tparam CC the type constructor of the sequence (e.g., `List`, `Vector`) + * @return `Some((head, tail))` if the sequence is non-empty, `None` otherwise */ def unapply[A, CC[_] <: Seq[?], C <: SeqOps[A, CC, C]](t: (C & SeqOps[A, CC, C])^): Option[(A, C^{t})] = if(t.isEmpty) None @@ -74,7 +77,10 @@ package object collection { /** An extractor used to init/last deconstruct sequences. */ object :+ { /** Splits a sequence into init :+ last. - * @return Some((init, last)) if sequence is non-empty. None otherwise. + * + * @tparam A the element type of the sequence + * @tparam CC the type constructor of the sequence (e.g., `List`, `Vector`) + * @return `Some((init, last))` if the sequence is non-empty, `None` otherwise */ def unapply[A, CC[_] <: Seq[?], C <: SeqOps[A, CC, C]](t: (C & SeqOps[A, CC, C])^): Option[(C^{t}, A)] = if(t.isEmpty) None diff --git a/library/src/scala/compat/Platform.scala b/library/src/scala/compat/Platform.scala index 20f40aa09fbc..edcf4f8346d1 100644 --- a/library/src/scala/compat/Platform.scala +++ b/library/src/scala/compat/Platform.scala @@ -71,7 +71,7 @@ object Platform { * * The caller must cast the returned value to the correct type. * - * @example ``` + * @example ```scala sc:compile * val a = scala.compat.Platform.createArray(classOf[Int], 4).asInstanceOf[Array[Int]] // returns Array[Int](0, 0, 0, 0) * ``` * @@ -105,7 +105,7 @@ object Platform { * @throws java.lang.LinkageError if the linkage fails * @throws java.lang.ExceptionInInitializerError if the initialization provoked by this method fails * @throws java.lang.ClassNotFoundException if the class cannot be located - * @example ``` + * @example ```scala sc:compile * val a = scala.compat.Platform.getClassForName("java.lang.Integer") // returns the Class[_] for java.lang.Integer * ``` */ diff --git a/library/src/scala/compiletime/ops/any.scala b/library/src/scala/compiletime/ops/any.scala index 26e38d234b78..0ea252a0abbf 100644 --- a/library/src/scala/compiletime/ops/any.scala +++ b/library/src/scala/compiletime/ops/any.scala @@ -5,10 +5,10 @@ import language.experimental.captureChecking object any: /** Equality comparison of two singleton types. - * ```scala - * //{ - * import compiletime.ops.any.* - * //} + * ```scala sc-hidden sc-name:ops-any-eq-imports + * import compiletime.ops.any.* + * ``` + * ```scala sc:compile sc-compile-with:ops-any-eq-imports * val eq1: 1 == 1 = true * val eq2: 1 == "1" = false * val eq3: "1" == "1" = true @@ -18,10 +18,10 @@ object any: infix type ==[X, Y] <: Boolean /** Inequality comparison of two singleton types. - * ```scala - * //{ - * import compiletime.ops.any.* - * //} + * ```scala sc-hidden sc-name:ops-any-neq-imports + * import compiletime.ops.any.* + * ``` + * ```scala sc:compile sc-compile-with:ops-any-neq-imports * val eq1: 1 != 1 = false * val eq2: 1 != "1" = true * val eq3: "1" != "1" = false @@ -31,10 +31,10 @@ object any: infix type !=[X, Y] <: Boolean /** Tests if a type is a constant. - * ```scala - * //{ - * import compiletime.ops.any.* - * //} + * ```scala sc-hidden sc-name:ops-any-isconst-imports + * import compiletime.ops.any.* + * ``` + * ```scala sc:compile sc-compile-with:ops-any-isconst-imports * val c1: IsConst[1] = true * val c2: IsConst["hi"] = true * val c3: IsConst[false] = true @@ -42,10 +42,7 @@ object any: * ``` * If the type is not yet known, then `IsConst` remains unevaluated, and * will be evaluated only at its concrete type application. E.g.: - * ```scala - * //{ - * import compiletime.ops.any.* - * //} + * ```scala sc:compile sc-compile-with:ops-any-isconst-imports * //def `isConst`` returns the type `IsConst[X]`, since `X` is not yet known. * def isConst[X] : IsConst[X] = ??? * val c5 : true = isConst[1] //now the type is known to be a constant @@ -56,10 +53,10 @@ object any: type IsConst[X] <: Boolean /** String conversion of a constant singleton type. - * ```scala - * //{ - * import compiletime.ops.any.* - * //} + * ```scala sc-hidden sc-name:ops-any-tostring-imports + * import compiletime.ops.any.* + * ``` + * ```scala sc:compile sc-compile-with:ops-any-tostring-imports * val s1: ToString[1] = "1" * val sTrue: ToString[true] = "true" * ``` diff --git a/library/src/scala/compiletime/ops/boolean.scala b/library/src/scala/compiletime/ops/boolean.scala index 0ef6785e2fcd..4c885ece17d3 100644 --- a/library/src/scala/compiletime/ops/boolean.scala +++ b/library/src/scala/compiletime/ops/boolean.scala @@ -6,10 +6,10 @@ import language.experimental.captureChecking object boolean: /** Negation of a `Boolean` singleton type. - * ```scala - * //{ - * import compiletime.ops.boolean.* - * //} + * ```scala sc-hidden sc-name:ops-boolean-not-imports + * import compiletime.ops.boolean.* + * ``` + * ```scala sc:compile sc-compile-with:ops-boolean-not-imports * val notFalse: ![false] = true * val notTrue: ![true] = false * ``` @@ -18,10 +18,10 @@ object boolean: type ![X <: Boolean] <: Boolean /** Exclusive disjunction of two `Boolean` singleton types. - * ```scala - * //{ - * import compiletime.ops.boolean.* - * //} + * ```scala sc-hidden sc-name:ops-boolean-xor-imports + * import compiletime.ops.boolean.* + * ``` + * ```scala sc:compile sc-compile-with:ops-boolean-xor-imports * val a: true ^ true = false * val b: false ^ true = true * ``` @@ -30,10 +30,10 @@ object boolean: infix type ^[X <: Boolean, Y <: Boolean] <: Boolean /** Conjunction of two `Boolean` singleton types. - * ```scala - * //{ - * import compiletime.ops.boolean.* - * //} + * ```scala sc-hidden sc-name:ops-boolean-and-imports + * import compiletime.ops.boolean.* + * ``` + * ```scala sc:compile sc-compile-with:ops-boolean-and-imports * val a: true && true = true * val b: false && true = false * ``` @@ -42,10 +42,10 @@ object boolean: infix type &&[X <: Boolean, Y <: Boolean] <: Boolean /** Disjunction of two `Boolean` singleton types. - * ```scala - * //{ - * import compiletime.ops.boolean.* - * //} + * ```scala sc-hidden sc-name:ops-boolean-or-imports + * import compiletime.ops.boolean.* + * ``` + * ```scala sc:compile sc-compile-with:ops-boolean-or-imports * val a: true || false = true * val b: false || false = false * ``` diff --git a/library/src/scala/compiletime/ops/double.scala b/library/src/scala/compiletime/ops/double.scala index 789df9c6462c..c039d3c23231 100644 --- a/library/src/scala/compiletime/ops/double.scala +++ b/library/src/scala/compiletime/ops/double.scala @@ -5,10 +5,10 @@ import language.experimental.captureChecking object double: /** Addition of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-plus-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-plus-imports * val sum: 2.0 + 2.0 = 4.0 * ``` * @syntax markdown @@ -16,10 +16,10 @@ object double: infix type +[X <: Double, Y <: Double] <: Double /** Subtraction of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-minus-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-minus-imports * val sub: 4.0 - 2.0 = 2.0 * ``` * @syntax markdown @@ -27,10 +27,10 @@ object double: infix type -[X <: Double, Y <: Double] <: Double /** Multiplication of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-times-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-times-imports * val mul: 4.0 * 2.0 = 8.0 * ``` * @syntax markdown @@ -38,10 +38,10 @@ object double: infix type *[X <: Double, Y <: Double] <: Double /** Integer division of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-div-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-div-imports * val div: 5.0 / 2.0 = 2.5 * ``` * @syntax markdown @@ -49,10 +49,10 @@ object double: infix type /[X <: Double, Y <: Double] <: Double /** Remainder of the division of `X` by `Y`. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-mod-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-mod-imports * val mod: 5.0 % 2.0 = 1.0 * ``` * @syntax markdown @@ -60,10 +60,10 @@ object double: infix type %[X <: Double, Y <: Double] <: Double /** Less-than comparison of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-lt-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-lt-imports * val lt1: 4.0 < 2.0 = false * val lt2: 2.0 < 4.0 = true * ``` @@ -72,10 +72,10 @@ object double: infix type <[X <: Double, Y <: Double] <: Boolean /** Greater-than comparison of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-gt-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-gt-imports * val gt1: 4.0 > 2.0 = true * val gt2: 2.0 > 2.0 = false * ``` @@ -84,10 +84,10 @@ object double: infix type >[X <: Double, Y <: Double] <: Boolean /** Greater-or-equal comparison of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-ge-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-ge-imports * val ge1: 4.0 >= 2.0 = true * val ge2: 2.0 >= 3.0 = false * ``` @@ -96,10 +96,10 @@ object double: infix type >=[X <: Double, Y <: Double] <: Boolean /** Less-or-equal comparison of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-le-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-le-imports * val lt1: 4.0 <= 2.0 = false * val lt2: 2.0 <= 2.0 = true * ``` @@ -108,10 +108,10 @@ object double: infix type <=[X <: Double, Y <: Double] <: Boolean /** Absolute value of an `Double` singleton type. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-abs-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-abs-imports * val abs: Abs[-1.0] = 1.0 * ``` * @syntax markdown @@ -119,10 +119,10 @@ object double: infix type Abs[X <: Double] <: Double /** Negation of an `Double` singleton type. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-negate-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-negate-imports * val neg1: Negate[-1.0] = 1.0 * val neg2: Negate[1.0] = -1.0 * ``` @@ -131,10 +131,10 @@ object double: type Negate[X <: Double] <: Double /** Minimum of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-min-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-min-imports * val min: Min[-1.0, 1.0] = -1.0 * ``` * @syntax markdown @@ -142,10 +142,10 @@ object double: type Min[X <: Double, Y <: Double] <: Double /** Maximum of two `Double` singleton types. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-max-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-max-imports * val max: Max[-1.0, 1.0] = 1.0 * ``` * @syntax markdown @@ -153,10 +153,10 @@ object double: type Max[X <: Double, Y <: Double] <: Double /** Int conversion of a `Double` singleton type. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-toint-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-toint-imports * val x: ToInt[1.0] = 1 * ``` * @syntax markdown @@ -164,10 +164,10 @@ object double: type ToInt[X <: Double] <: Int /** Long conversion of a `Double` singleton type. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-tolong-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-tolong-imports * val x: ToLong[1.0] = 1L * ``` * @syntax markdown @@ -175,10 +175,10 @@ object double: type ToLong[X <: Double] <: Long /** Float conversion of a `Double` singleton type. - * ```scala - * //{ - * import compiletime.ops.double.* - * //} + * ```scala sc-hidden sc-name:ops-double-tofloat-imports + * import compiletime.ops.double.* + * ``` + * ```scala sc:compile sc-compile-with:ops-double-tofloat-imports * val x: ToFloat[1.0] = 1.0f * ``` * @syntax markdown diff --git a/library/src/scala/compiletime/ops/float.scala b/library/src/scala/compiletime/ops/float.scala index 70a06522f526..b05bd0cbc006 100644 --- a/library/src/scala/compiletime/ops/float.scala +++ b/library/src/scala/compiletime/ops/float.scala @@ -5,10 +5,10 @@ import language.experimental.captureChecking object float: /** Addition of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-plus-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-plus-imports * val sum: 2.0f + 2.0f = 4.0f * ``` * @syntax markdown @@ -16,10 +16,10 @@ object float: infix type +[X <: Float, Y <: Float] <: Float /** Subtraction of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-minus-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-minus-imports * val sub: 4.0f - 2.0f = 2.0f * ``` * @syntax markdown @@ -27,10 +27,10 @@ object float: infix type -[X <: Float, Y <: Float] <: Float /** Multiplication of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-times-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-times-imports * val mul: 4.0f * 2.0f = 8.0f * ``` * @syntax markdown @@ -38,10 +38,10 @@ object float: infix type *[X <: Float, Y <: Float] <: Float /** Integer division of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-div-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-div-imports * val div: 5.0f / 2.0f = 2.5f * ``` * @syntax markdown @@ -49,10 +49,10 @@ object float: infix type /[X <: Float, Y <: Float] <: Float /** Remainder of the division of `X` by `Y`. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-mod-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-mod-imports * val mod: 5.0f % 2.0f = 1.0f * ``` * @syntax markdown @@ -60,10 +60,10 @@ object float: infix type %[X <: Float, Y <: Float] <: Float /** Less-than comparison of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-lt-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-lt-imports * val lt1: 4.0f < 2.0f = false * val lt2: 2.0f < 4.0f = true * ``` @@ -72,10 +72,10 @@ object float: infix type <[X <: Float, Y <: Float] <: Boolean /** Greater-than comparison of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-gt-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-gt-imports * val gt1: 4.0f > 2.0f = true * val gt2: 2.0f > 2.0f = false * ``` @@ -84,10 +84,10 @@ object float: infix type >[X <: Float, Y <: Float] <: Boolean /** Greater-or-equal comparison of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-ge-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-ge-imports * val ge1: 4.0f >= 2.0f = true * val ge2: 2.0f >= 3.0f = false * ``` @@ -96,10 +96,10 @@ object float: infix type >=[X <: Float, Y <: Float] <: Boolean /** Less-or-equal comparison of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-le-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-le-imports * val lt1: 4.0f <= 2.0f = false * val lt2: 2.0f <= 2.0f = true * ``` @@ -108,10 +108,10 @@ object float: infix type <=[X <: Float, Y <: Float] <: Boolean /** Absolute value of an `Float` singleton type. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-abs-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-abs-imports * val abs: Abs[-1.0f] = 1.0f * ``` * @syntax markdown @@ -119,10 +119,10 @@ object float: type Abs[X <: Float] <: Float /** Negation of an `Float` singleton type. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-negate-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-negate-imports * val neg1: Negate[-1.0f] = 1.0f * val neg2: Negate[1.0f] = -1.0f * ``` @@ -131,10 +131,10 @@ object float: type Negate[X <: Float] <: Float /** Minimum of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-min-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-min-imports * val min: Min[-1.0f, 1.0f] = -1.0f * ``` * @syntax markdown @@ -142,10 +142,10 @@ object float: type Min[X <: Float, Y <: Float] <: Float /** Maximum of two `Float` singleton types. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-max-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-max-imports * val max: Max[-1.0f, 1.0f] = 1.0f * ``` * @syntax markdown @@ -153,10 +153,10 @@ object float: type Max[X <: Float, Y <: Float] <: Float /** Int conversion of a `Float` singleton type. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-toint-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-toint-imports * val x: ToInt[1.0f] = 1 * ``` * @syntax markdown @@ -164,10 +164,10 @@ object float: type ToInt[X <: Float] <: Int /** Long conversion of a `Float` singleton type. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-tolong-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-tolong-imports * val x: ToLong[1.0f] = 1L * ``` * @syntax markdown @@ -175,10 +175,10 @@ object float: type ToLong[X <: Float] <: Long /** Double conversion of a `Float` singleton type. - * ```scala - * //{ - * import compiletime.ops.float.* - * //} + * ```scala sc-hidden sc-name:ops-float-todouble-imports + * import compiletime.ops.float.* + * ``` + * ```scala sc:compile sc-compile-with:ops-float-todouble-imports * val x: ToDouble[1.0f] = 1.0 * ``` * @syntax markdown diff --git a/library/src/scala/compiletime/ops/int.scala b/library/src/scala/compiletime/ops/int.scala index b74ee054da6d..8eaf56a8dd3b 100644 --- a/library/src/scala/compiletime/ops/int.scala +++ b/library/src/scala/compiletime/ops/int.scala @@ -6,10 +6,10 @@ import language.experimental.captureChecking object int: /** Successor of a natural number where zero is the type 0 and successors are reduced as if the definition was: * - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-s-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-s-imports * type S[N <: Int] <: Int = N match { * case 0 => 1 * case 1 => 2 @@ -23,10 +23,10 @@ object int: type S[N <: Int] <: Int /** Addition of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-plus-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-plus-imports * val sum: 2 + 2 = 4 * ``` * @syntax markdown @@ -34,10 +34,10 @@ object int: infix type +[X <: Int, Y <: Int] <: Int /** Subtraction of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-minus-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-minus-imports * val sub: 4 - 2 = 2 * ``` * @syntax markdown @@ -45,10 +45,10 @@ object int: infix type -[X <: Int, Y <: Int] <: Int /** Multiplication of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-times-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-times-imports * val mul: 4 * 2 = 8 * ``` * @syntax markdown @@ -56,10 +56,10 @@ object int: infix type *[X <: Int, Y <: Int] <: Int /** Integer division of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-div-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-div-imports * val div: 5 / 2 = 2 * ``` * @syntax markdown @@ -67,10 +67,10 @@ object int: infix type /[X <: Int, Y <: Int] <: Int /** Remainder of the division of `X` by `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-mod-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-mod-imports * val mod: 5 % 2 = 1 * ``` * @syntax markdown @@ -78,10 +78,10 @@ object int: infix type %[X <: Int, Y <: Int] <: Int /** Binary left shift of `X` by `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-lshift-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-lshift-imports * val lshift: 1 << 2 = 4 * ``` * @syntax markdown @@ -89,10 +89,10 @@ object int: infix type <<[X <: Int, Y <: Int] <: Int /** Binary right shift of `X` by `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-rshift-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-rshift-imports * val rshift: 10 >> 1 = 5 * ``` * @syntax markdown @@ -100,10 +100,10 @@ object int: infix type >>[X <: Int, Y <: Int] <: Int /** Binary right shift of `X` by `Y`, filling the left with zeros. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-urshift-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-urshift-imports * val rshiftzero: 10 >>> 1 = 5 * ``` * @syntax markdown @@ -111,10 +111,10 @@ object int: infix type >>>[X <: Int, Y <: Int] <: Int /** Bitwise xor of `X` and `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-xor-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-xor-imports * val xor: 10 ^ 30 = 20 * ``` * @syntax markdown @@ -122,10 +122,10 @@ object int: infix type ^[X <: Int, Y <: Int] <: Int /** Less-than comparison of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-lt-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-lt-imports * val lt1: 4 < 2 = false * val lt2: 2 < 4 = true * ``` @@ -134,10 +134,10 @@ object int: infix type <[X <: Int, Y <: Int] <: Boolean /** Greater-than comparison of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-gt-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-gt-imports * val gt1: 4 > 2 = true * val gt2: 2 > 2 = false * ``` @@ -146,10 +146,10 @@ object int: infix type >[X <: Int, Y <: Int] <: Boolean /** Greater-or-equal comparison of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-ge-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-ge-imports * val ge1: 4 >= 2 = true * val ge2: 2 >= 3 = false * ``` @@ -158,10 +158,10 @@ object int: infix type >=[X <: Int, Y <: Int] <: Boolean /** Less-or-equal comparison of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-le-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-le-imports * val lt1: 4 <= 2 = false * val lt2: 2 <= 2 = true * ``` @@ -170,10 +170,10 @@ object int: infix type <=[X <: Int, Y <: Int] <: Boolean /** Bitwise and of `X` and `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-bitwiseand-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-bitwiseand-imports * val and1: BitwiseAnd[4, 4] = 4 * val and2: BitwiseAnd[10, 5] = 0 * ``` @@ -182,10 +182,10 @@ object int: type BitwiseAnd[X <: Int, Y <: Int] <: Int /** Bitwise or of `X` and `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-bitwiseor-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-bitwiseor-imports * val or: BitwiseOr[10, 11] = 11 * ``` * @syntax markdown @@ -193,10 +193,10 @@ object int: type BitwiseOr[X <: Int, Y <: Int] <: Int /** Absolute value of an `Int` singleton type. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-abs-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-abs-imports * val abs: Abs[-1] = 1 * ``` * @syntax markdown @@ -204,10 +204,10 @@ object int: type Abs[X <: Int] <: Int /** Negation of an `Int` singleton type. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-negate-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-negate-imports * val neg1: Negate[-1] = 1 * val neg2: Negate[1] = -1 * ``` @@ -216,10 +216,10 @@ object int: type Negate[X <: Int] <: Int /** Minimum of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-min-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-min-imports * val min: Min[-1, 1] = -1 * ``` * @syntax markdown @@ -227,10 +227,10 @@ object int: type Min[X <: Int, Y <: Int] <: Int /** Maximum of two `Int` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-max-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-max-imports * val max: Max[-1, 1] = 1 * ``` * @syntax markdown @@ -238,10 +238,10 @@ object int: type Max[X <: Int, Y <: Int] <: Int /** String conversion of an `Int` singleton type. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-tostring-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-tostring-imports * val abs: ToString[1] = "1" * ``` * @syntax markdown @@ -250,10 +250,10 @@ object int: type ToString[X <: Int] <: String /** Long conversion of an `Int` singleton type. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-int-tolong-imports * import compiletime.ops.int.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-int-tolong-imports * val x: ToLong[1] = 1L * ``` * @syntax markdown @@ -261,10 +261,10 @@ object int: type ToLong[X <: Int] <: Long /** Float conversion of an `Int` singleton type. - * ```scala - * //{ - * import compiletime.ops.int.* - * //} + * ```scala sc-hidden sc-name:ops-int-tofloat-imports + * import compiletime.ops.int.* + * ``` + * ```scala sc:compile sc-compile-with:ops-int-tofloat-imports * val x: ToFloat[1] = 1.0f * ``` * @syntax markdown @@ -272,10 +272,10 @@ object int: type ToFloat[X <: Int] <: Float /** Double conversion of an `Int` singleton type. - * ```scala - * //{ - * import compiletime.ops.int.* - * //} + * ```scala sc-hidden sc-name:ops-int-todouble-imports + * import compiletime.ops.int.* + * ``` + * ```scala sc:compile sc-compile-with:ops-int-todouble-imports * val x: ToDouble[1] = 1.0 * ``` * @syntax markdown @@ -286,10 +286,10 @@ object int: * one-bit in the two's complement binary representation of the specified `Int` singleton type. * Returns 32 if the specified singleton type has no one-bits in its two's complement representation, * in other words if it is equal to zero. - * ```scala - * //{ - * import compiletime.ops.int.* - * //} + * ```scala sc-hidden sc-name:ops-int-leadingzeros-imports + * import compiletime.ops.int.* + * ``` + * ```scala sc:compile sc-compile-with:ops-int-leadingzeros-imports * val zero_lzc: NumberOfLeadingZeros[0] = 32 * val eight_lzc: NumberOfLeadingZeros[8] = 28 * type Log2[N <: Int] = 31 - NumberOfLeadingZeros[N] diff --git a/library/src/scala/compiletime/ops/long.scala b/library/src/scala/compiletime/ops/long.scala index 7188dffb5af8..351f84d0c318 100644 --- a/library/src/scala/compiletime/ops/long.scala +++ b/library/src/scala/compiletime/ops/long.scala @@ -6,7 +6,7 @@ import language.experimental.captureChecking object long: /** Successor of a natural number where zero is the type 0 and successors are reduced as if the definition was: * - * ```scala + * ```scala sc:compile * type S[N <: Long] <: Long = N match { * case 0L => 1L * case 1L => 2L @@ -21,10 +21,10 @@ object long: type S[N <: Long] <: Long /** Addition of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-plus-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-plus-imports * val sum: 2L + 2L = 4L * ``` * @syntax markdown @@ -32,10 +32,10 @@ object long: infix type +[X <: Long, Y <: Long] <: Long /** Subtraction of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-minus-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-minus-imports * val sub: 4L - 2L = 2L * ``` * @syntax markdown @@ -43,10 +43,10 @@ object long: infix type -[X <: Long, Y <: Long] <: Long /** Multiplication of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-times-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-times-imports * val mul: 4L * 2L = 8L * ``` * @syntax markdown @@ -54,10 +54,10 @@ object long: infix type *[X <: Long, Y <: Long] <: Long /** Integer division of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-div-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-div-imports * val div: 5L / 2L = 2L * ``` * @syntax markdown @@ -65,10 +65,10 @@ object long: infix type /[X <: Long, Y <: Long] <: Long /** Remainder of the division of `X` by `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-mod-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-mod-imports * val mod: 5L % 2L = 1L * ``` * @syntax markdown @@ -76,10 +76,10 @@ object long: infix type %[X <: Long, Y <: Long] <: Long /** Binary left shift of `X` by `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-lshift-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-lshift-imports * val lshift: 1L << 2L = 4L * ``` * @syntax markdown @@ -87,10 +87,10 @@ object long: infix type <<[X <: Long, Y <: Long] <: Long /** Binary right shift of `X` by `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-rshift-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-rshift-imports * val rshift: 10L >> 1L = 5L * ``` * @syntax markdown @@ -98,10 +98,10 @@ object long: infix type >>[X <: Long, Y <: Long] <: Long /** Binary right shift of `X` by `Y`, filling the left with zeros. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-urshift-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-urshift-imports * val rshiftzero: 10L >>> 1L = 5L * ``` * @syntax markdown @@ -109,10 +109,10 @@ object long: infix type >>>[X <: Long, Y <: Long] <: Long /** Bitwise xor of `X` and `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-xor-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-xor-imports * val xor: 10L ^ 30L = 20L * ``` * @syntax markdown @@ -120,10 +120,10 @@ object long: infix type ^[X <: Long, Y <: Long] <: Long /** Less-than comparison of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-lt-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-lt-imports * val lt1: 4L < 2L = false * val lt2: 2L < 4L = true * ``` @@ -132,10 +132,10 @@ object long: infix type <[X <: Long, Y <: Long] <: Boolean /** Greater-than comparison of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-gt-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-gt-imports * val gt1: 4L > 2L = true * val gt2: 2L > 2L = false * ``` @@ -144,10 +144,10 @@ object long: infix type >[X <: Long, Y <: Long] <: Boolean /** Greater-or-equal comparison of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-ge-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-ge-imports * val ge1: 4L >= 2L = true * val ge2: 2L >= 3L = false * ``` @@ -156,10 +156,10 @@ object long: infix type >=[X <: Long, Y <: Long] <: Boolean /** Less-or-equal comparison of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-le-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-le-imports * val lt1: 4L <= 2L = false * val lt2: 2L <= 2L = true * ``` @@ -168,10 +168,10 @@ object long: infix type <=[X <: Long, Y <: Long] <: Boolean /** Bitwise and of `X` and `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-bitwiseand-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-bitwiseand-imports * val and1: BitwiseAnd[4L, 4L] = 4L * val and2: BitwiseAnd[10L, 5L] = 0L * ``` @@ -180,10 +180,10 @@ object long: type BitwiseAnd[X <: Long, Y <: Long] <: Long /** Bitwise or of `X` and `Y`. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-bitwiseor-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-bitwiseor-imports * val or: BitwiseOr[10L, 11L] = 11L * ``` * @syntax markdown @@ -191,10 +191,10 @@ object long: type BitwiseOr[X <: Long, Y <: Long] <: Long /** Absolute value of an `Long` singleton type. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-abs-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-abs-imports * val abs: Abs[-1L] = 1L * ``` * @syntax markdown @@ -202,10 +202,10 @@ object long: type Abs[X <: Long] <: Long /** Negation of an `Long` singleton type. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-negate-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-negate-imports * val neg1: Negate[-1L] = 1L * val neg2: Negate[1L] = -1L * ``` @@ -214,10 +214,10 @@ object long: type Negate[X <: Long] <: Long /** Minimum of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-min-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-min-imports * val min: Min[-1L, 1L] = -1L * ``` * @syntax markdown @@ -225,10 +225,10 @@ object long: type Min[X <: Long, Y <: Long] <: Long /** Maximum of two `Long` singleton types. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-max-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-max-imports * val max: Max[-1L, 1L] = 1L * ``` * @syntax markdown @@ -239,10 +239,10 @@ object long: * one-bit in the two's complement binary representation of the specified `Long` singleton type. * Returns 64 if the specified singleton type has no one-bits in its two's complement representation, * in other words if it is equal to zero. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-long-leadingzeros-imports * import compiletime.ops.long.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-long-leadingzeros-imports * val zero_lzc: NumberOfLeadingZeros[0L] = 64 * val eight_lzc: NumberOfLeadingZeros[8L] = 60 * type Log2[N <: Long] = int.-[63, NumberOfLeadingZeros[N]] @@ -253,10 +253,10 @@ object long: type NumberOfLeadingZeros[X <: Long] <: Int /** Int conversion of a `Long` singleton type. - * ```scala - * //{ - * import compiletime.ops.long.* - * //} + * ```scala sc-hidden sc-name:ops-long-toint-imports + * import compiletime.ops.long.* + * ``` + * ```scala sc:compile sc-compile-with:ops-long-toint-imports * val x: ToInt[1L] = 1 * ``` * @syntax markdown @@ -264,10 +264,10 @@ object long: type ToInt[X <: Long] <: Int /** Float conversion of a `Long` singleton type. - * ```scala - * //{ - * import compiletime.ops.long.* - * //} + * ```scala sc-hidden sc-name:ops-long-tofloat-imports + * import compiletime.ops.long.* + * ``` + * ```scala sc:compile sc-compile-with:ops-long-tofloat-imports * val x: ToFloat[1L] = 1.0f * ``` * @syntax markdown @@ -275,10 +275,10 @@ object long: type ToFloat[X <: Long] <: Float /** Double conversion of a `Long` singleton type. - * ```scala - * //{ - * import compiletime.ops.long.* - * //} + * ```scala sc-hidden sc-name:ops-long-todouble-imports + * import compiletime.ops.long.* + * ``` + * ```scala sc:compile sc-compile-with:ops-long-todouble-imports * val x: ToDouble[1L] = 1.0 * ``` * @syntax markdown diff --git a/library/src/scala/compiletime/ops/string.scala b/library/src/scala/compiletime/ops/string.scala index 9ef5a3fb7b79..84cd9a2f53d9 100644 --- a/library/src/scala/compiletime/ops/string.scala +++ b/library/src/scala/compiletime/ops/string.scala @@ -5,10 +5,10 @@ import language.experimental.captureChecking object string: /** Concatenation of two `String` singleton types. - * ```scala - * //{ - * import compiletime.ops.string.* - * //} + * ```scala sc-hidden sc-name:ops-string-plus-imports + * import compiletime.ops.string.* + * ``` + * ```scala sc:compile sc-compile-with:ops-string-plus-imports * val hello: "hello " + "world" = "hello world" * ``` * @syntax markdown @@ -16,10 +16,10 @@ object string: infix type +[X <: String, Y <: String] <: String /** Length of a `String` singleton type. - * ```scala - * //{ - * import compiletime.ops.string.* - * //} + * ```scala sc-hidden sc-name:ops-string-length-imports + * import compiletime.ops.string.* + * ``` + * ```scala sc:compile sc-compile-with:ops-string-length-imports * val helloSize: Length["hello"] = 5 * ``` * @syntax markdown @@ -30,10 +30,10 @@ object string: * begin inclusive index `IBeg`, and a singleton type exclusive end index `IEnd`. * The substring begins at the specified IBeg and extends to the character at index IEnd - 1. * Thus the length of the substring is IEnd-IBeg. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-string-substring-imports * import compiletime.ops.string.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-string-substring-imports * val x: Substring["hamburger", 4, 8] = "urge" * val y: Substring["smiles", 1, 5] = "mile" * ``` @@ -43,10 +43,10 @@ object string: /** Tests if this `String` singleton type matches the given * regular expression `String` singleton type. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-string-matches-imports * import compiletime.ops.string.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-string-matches-imports * val x: Matches["unhappy", "un.*"] = true * ``` * @syntax markdown @@ -56,10 +56,10 @@ object string: /** Returns the Char type at the specified index. * An index ranges from 0 to Length[S] - 1. The first Char of * the sequence is at index 0, the next at index 1, and so on. - * ```scala - * //{ + * ```scala sc-hidden sc-name:ops-string-charat-imports * import string.* - * //} + * ``` + * ```scala sc:compile sc-compile-with:ops-string-charat-imports * val c: CharAt["hello", 0] = 'h' * ``` * @syntax markdown diff --git a/library/src/scala/compiletime/package.scala b/library/src/scala/compiletime/package.scala index 16eb005a4791..9141b27ff874 100644 --- a/library/src/scala/compiletime/package.scala +++ b/library/src/scala/compiletime/package.scala @@ -8,8 +8,9 @@ import annotation.{compileTimeOnly, experimental} /** Use this method when you have a type, do not have a value for it but want to * pattern match on it. For example, given a type `Tup <: Tuple`, one can * pattern-match on it as follows: - * ```scala + * ```scala sc:compile * //{ + * import scala.compiletime.* * type Tup * inline def f = { * //} @@ -24,15 +25,18 @@ import annotation.{compileTimeOnly, experimental} * This value can only be used in an inline match and the value cannot be used in * the branches. * @syntax markdown + * + * @tparam T the type to match against in an inline match expression */ def erasedValue[T]: T = erasedValue[T] /** Used as the initializer of a mutable class or object field, like this: * - * ```scala - * //{ + * ```scala sc-hidden sc-name:compiletime-uninitialized-preamble + * import scala.compiletime.* * type T - * //} + * ``` + * ```scala sc:compile sc-compile-with:compiletime-uninitialized-preamble * var x: T = uninitialized * ``` * @@ -45,8 +49,13 @@ def uninitialized: Nothing = ??? /** Used as the right hand side of a given in a trait, like this * + * ```scala sc-hidden sc-name:compiletime-deferred-preamble + * import scala.compiletime.* + * trait DeferredHolder: + * type T * ``` - * given T = deferred + * ```scala sc:compile sc-compile-with:compiletime-deferred-preamble + * given T = deferred * ``` * * This signifies that the given will get a synthesized definition in all classes @@ -59,21 +68,28 @@ def deferred: Nothing = ??? /** The error method is used to produce user-defined compile errors during inline expansion. * If an inline expansion results in a call error(msgStr) the compiler produces an error message containing the given msgStr. * - * ```scala sc:fail + * ```scala sc-hidden sc-name:compiletime-error-imports + * import scala.compiletime.* + * ``` + * ```scala sc:fail sc-compile-with:compiletime-error-imports * error("My error message") * ``` * or - * ```scala + * ```scala sc:compile sc-compile-with:compiletime-error-imports * inline def errorOnThisCode(inline x: Any) = * error("My error of this code: " + codeOf(x)) * ``` * @syntax markdown + * + * @param msg the error message to display at compile time + * @return this method never returns; it always produces a compile-time error */ inline def error(inline msg: String): Nothing = ??? /** Returns the string representation of argument code: * - * ```scala + * ```scala sc:compile + * import scala.compiletime.* * inline def logged(inline p1: Any) = * ("code: " + codeOf(p1), p1) * @@ -88,6 +104,9 @@ inline def error(inline msg: String): Nothing = ??? * Other values may display unintutively. * * @syntax markdown + * + * @param arg the expression whose source code representation is returned + * @return the string representation of the argument's source code */ transparent inline def codeOf(arg: Any): String = // implemented in dotty.tools.dotc.typer.Inliner.Intrinsics @@ -98,6 +117,7 @@ transparent inline def codeOf(arg: Any): String = * * Usage: * ```scala sc:fail + * import scala.compiletime.* * inline def twice(inline n: Int): Int = * requireConst(n) // compile-time assertion that the parameter `n` is a constant * n + n @@ -107,6 +127,8 @@ transparent inline def codeOf(arg: Any): String = * twice(m) // error: expected a constant value but found: m * ``` * @syntax markdown + * + * @param x the value that must be a compile-time constant after inlining */ inline def requireConst(inline x: Boolean | Byte | Short | Int | Long | Float | Double | Char | String): Unit = // implemented in dotty.tools.dotc.typer.Inliner @@ -115,6 +137,8 @@ inline def requireConst(inline x: Boolean | Byte | Short | Int | Long | Float | /** Same as `constValue` but returns a `None` if a constant value * cannot be constructed from the provided type. Otherwise returns * that value wrapped in `Some`. + * + * @tparam T the constant singleton type to attempt to convert to a value */ transparent inline def constValueOpt[T]: Option[T] = // implemented in dotty.tools.dotc.typer.Inliner @@ -122,6 +146,8 @@ transparent inline def constValueOpt[T]: Option[T] = /** Given a constant, singleton type `T`, convert it to a value * of the same singleton type. For example: `assert(constValue[1] == 1)`. + * + * @tparam T the constant singleton type to convert to a value */ transparent inline def constValue[T]: T = // implemented in dotty.tools.dotc.typer.Inliner @@ -129,6 +155,8 @@ transparent inline def constValue[T]: T = /** Given a tuple type `(X1, ..., Xn)`, returns a tuple value * `(constValue[X1], ..., constValue[Xn])`. + * + * @tparam T the tuple type whose element types are constant singleton types */ inline def constValueTuple[T <: Tuple]: T = // implemented in dotty.tools.dotc.typer.Inliner @@ -137,8 +165,9 @@ inline def constValueTuple[T <: Tuple]: T = /** Summons first given matching one of the listed cases. E.g. in * - * ```scala + * ```scala sc:compile * //{ + * import scala.compiletime.* * type A * trait B * type C @@ -158,6 +187,10 @@ inline def constValueTuple[T <: Tuple]: T = * ``` * the returned value would be `2`. * @syntax markdown + * + * @tparam T the result type of the match expression + * @param f a match block with cases that summon givens of specified types + * @return the result of the first matching case */ transparent inline def summonFrom[T](f: Nothing => T): T = error("Compiler bug: `summonFrom` was not evaluated by the compiler") @@ -175,13 +208,17 @@ transparent inline def summonInline[T]: T = * a Tuple. * * @tparam T the tuple containing the types of the values to be summoned - * @return the given values typed as elements of the tuple + * @return a tuple of the summoned given instances corresponding to the element types of `T` */ inline def summonAll[T <: Tuple]: T = // implemented in dotty.tools.dotc.typer.Inliner error("Compiler bug: `summonAll` was not evaluated by the compiler") -/** Assertion that an argument is by-name. Used for nullability checking. */ +/** Assertion that an argument is by-name. Used for nullability checking. + * + * @tparam T the result type of the by-name argument + * @param x the by-name argument to evaluate + */ def byName[T](x: => T): T = x /** Casts a value to be `Matchable`. This is needed if the value's type is an unconstrained diff --git a/library/src/scala/compiletime/testing/Error.scala b/library/src/scala/compiletime/testing/Error.scala index 65ad302771db..0f0e7c682035 100644 --- a/library/src/scala/compiletime/testing/Error.scala +++ b/library/src/scala/compiletime/testing/Error.scala @@ -10,5 +10,10 @@ import language.experimental.captureChecking * errors. This means the format and the API may change from * version to version. This API is to be used for testing purposes * only. + * + * @param message the error message produced by the compiler + * @param lineContent the source line containing the error + * @param column the zero-based column position within `lineContent` where the error occurred + * @param kind the phase in which the error occurred, either `ErrorKind.Parser` or `ErrorKind.Typer` */ final case class Error(message: String, lineContent: String, column: Int, kind: ErrorKind) diff --git a/library/src/scala/compiletime/testing/package.scala b/library/src/scala/compiletime/testing/package.scala index fadf6b07f92e..386ac355dee6 100644 --- a/library/src/scala/compiletime/testing/package.scala +++ b/library/src/scala/compiletime/testing/package.scala @@ -7,9 +7,8 @@ import language.experimental.captureChecking * * An inline definition with a call to `typeChecks` should be transparent. * - * @param code The code to be type checked - * - * @return `false` if the code has syntax error or type error in the current context, `true` otherwise. + * @param code a string literal containing the Scala code to type-check at compile time + * @return `true` if the code type-checks successfully, `false` if the code has a syntax or type error in the current context. * * The code should be a sequence of expressions or statements that may appear in a block. */ @@ -26,9 +25,8 @@ transparent inline def typeChecks(inline code: String): Boolean = * * An inline definition with a call to `typeCheckErrors` should be transparent. * - * @param code The code to be type checked - * - * @return a list of errors encountered during parsing and typechecking. + * @param code a string literal containing the Scala code to type-check at compile time + * @return an empty list if the code type-checks successfully, or a list of `Error` values describing the errors encountered during parsing and type-checking. * * The code should be a sequence of expressions or statements that may appear in a block. */ diff --git a/library/src/scala/concurrent/Awaitable.scala b/library/src/scala/concurrent/Awaitable.scala index b200fa727ac2..2443d4c58d69 100644 --- a/library/src/scala/concurrent/Awaitable.scala +++ b/library/src/scala/concurrent/Awaitable.scala @@ -24,6 +24,8 @@ import scala.concurrent.duration.Duration * The [[Await]] object provides methods that allow accessing the result of an `Awaitable` * by blocking the current thread until the `Awaitable` has been completed or a timeout has * occurred. + * + * @tparam T the type of the result value */ trait Awaitable[+T] { diff --git a/library/src/scala/concurrent/BatchingExecutor.scala b/library/src/scala/concurrent/BatchingExecutor.scala index 4fdbf0be7e6f..1f86859a5658 100644 --- a/library/src/scala/concurrent/BatchingExecutor.scala +++ b/library/src/scala/concurrent/BatchingExecutor.scala @@ -60,30 +60,38 @@ private[concurrent] object BatchingExecutorStatics { * When you implement this trait for async executors like thread pools, * you're going to need to implement it something like the following: * - * ``` - * final override def submitAsync(runnable: Runnable): Unit = - * super[SuperClass].execute(runnable) // To prevent reentrancy into `execute` + * ```scala sc:compile + * import java.util.concurrent.Executor + * + * final class AsyncBatchingExecutor(delegate: Executor) + * extends ExecutionContextExecutor + * with BatchingExecutor { + * final override def submitForExecution(runnable: Runnable): Unit = + * delegate.execute(runnable) * - * final override def execute(runnable: Runnable): Unit = - * if (runnable.isInstanceOf[Batchable]) // Or other logic - * submitAsyncBatched(runnable) - * else - * submitAsync(runnable) + * final override def execute(runnable: Runnable): Unit = + * if (runnable.isInstanceOf[Batchable]) + * submitAsyncBatched(runnable) + * else + * submitForExecution(runnable) * - * final override def reportFailure(cause: Throwable): Unit = … + * final override def reportFailure(cause: Throwable): Unit = () + * } * ``` * * And if you want to implement if for a sync, trampolining, executor you're * going to implement it something like this: * - * ``` - * final override def submitAsync(runnable: Runnable): Unit = () + * ```scala sc:compile + * final class TrampoliningExecutor extends ExecutionContextExecutor with BatchingExecutor { + * final override def submitForExecution(runnable: Runnable): Unit = () * - * final override def execute(runnable: Runnable): Unit = - * submitSyncBatched(runnable) // You typically will want to batch everything + * final override def execute(runnable: Runnable): Unit = + * submitSyncBatched(runnable) * - * final override def reportFailure(cause: Throwable): Unit = - * ExecutionContext.defaultReporter(cause) // Or choose something more fitting + * final override def reportFailure(cause: Throwable): Unit = + * ExecutionContext.defaultReporter(cause) + * } * ``` */ private[concurrent] trait BatchingExecutor extends Executor { @@ -221,16 +229,22 @@ private[concurrent] trait BatchingExecutor extends Executor { /** MUST throw a NullPointerException when `runnable` is null * When implementing a sync BatchingExecutor, it is RECOMMENDED * to implement this method as `runnable.run()` + * + * @param runnable the `Runnable` to submit for execution; must not be null */ protected def submitForExecution(runnable: Runnable): Unit /** Reports that an asynchronous computation failed. * See `ExecutionContext.reportFailure(throwable: Throwable)` + * + * @param throwable the `Throwable` that caused the computation to fail */ protected def reportFailure(throwable: Throwable): Unit /** WARNING: Never use both `submitAsyncBatched` and `submitSyncBatched` in the same * implementation of `BatchingExecutor` + * + * @param runnable the `Runnable` to add to the current async batch, or to submit as a new batch if no batch is active */ protected final def submitAsyncBatched(runnable: Runnable): Unit = { val b = _tasksLocal.get @@ -240,6 +254,8 @@ private[concurrent] trait BatchingExecutor extends Executor { /** WARNING: Never use both `submitAsyncBatched` and `submitSyncBatched` in the same * implementation of `BatchingExecutor` + * + * @param runnable the `Runnable` to submit for synchronous execution, either directly or via a sync batch; must not be null */ protected final def submitSyncBatched(runnable: Runnable): Unit = { Objects.requireNonNull(runnable, "runnable is null") diff --git a/library/src/scala/concurrent/BlockContext.scala b/library/src/scala/concurrent/BlockContext.scala index 330bf8a6ce28..4bd97a58f466 100644 --- a/library/src/scala/concurrent/BlockContext.scala +++ b/library/src/scala/concurrent/BlockContext.scala @@ -27,7 +27,7 @@ import scala.language.`2.13` * * Typically, you'll want to chain to the previous `BlockContext`, * like this: - * ``` + * ```scala sc:compile * val oldContext = BlockContext.current * val myContext = new BlockContext { * override def blockOn[T](thunk: => T)(implicit permission: CanAwait): T = { @@ -53,6 +53,10 @@ trait BlockContext { * In implementations of this method it is RECOMMENDED to first check if `permission` is `null` and * if it is, throw an `IllegalArgumentException`. * + * @tparam T the result type of the blocking thunk + * @param thunk the code to execute that may block the current thread + * @param permission the implicit `CanAwait` permit granting permission to block + * @return the result of executing `thunk` * @throws IllegalArgumentException if the `permission` is `null` */ def blockOn[T](thunk: => T)(implicit permission: CanAwait): T @@ -83,7 +87,12 @@ object BlockContext { */ final def current: BlockContext = prefer(contextLocal.get) - /** Installs a current `BlockContext` around executing `body`. */ + /** Installs a current `BlockContext` around executing `body`. + * + * @tparam T the result type of `body` + * @param blockContext the `BlockContext` to install for the duration of `body` + * @param body the code to execute with the given `blockContext` installed + */ final def withBlockContext[T](blockContext: BlockContext)(body: => T): T = { val old = contextLocal.get // can be null if (old eq blockContext) body @@ -94,6 +103,11 @@ object BlockContext { } /** Installs the BlockContext `blockContext` around the invocation to `f` and passes in the previously installed BlockContext to `f`. + * + * @tparam I unused type parameter (kept for binary compatibility) + * @tparam T the result type of `f` + * @param blockContext the `BlockContext` to install for the duration of `f` + * @param f the function to execute, receiving the previously installed `BlockContext` as its argument * @return the value produced by applying `f` */ final def usingBlockContext[I, T](blockContext: BlockContext)(f: BlockContext => T): T = { diff --git a/library/src/scala/concurrent/ExecutionContext.scala b/library/src/scala/concurrent/ExecutionContext.scala index bfa6d598f61e..5ad8ef448a90 100644 --- a/library/src/scala/concurrent/ExecutionContext.scala +++ b/library/src/scala/concurrent/ExecutionContext.scala @@ -155,7 +155,7 @@ object ExecutionContext { * in case the `opportunistic` field is missing (example below). The resulting `ExecutionContext` has batching * behavior in all Scala 2.13 versions (`global` is batching in 2.13.0-3). * - * ``` + * ```scala sc:compile * implicit val ec: scala.concurrent.ExecutionContext = try { * scala.concurrent.ExecutionContext.getClass * .getDeclaredMethod("opportunistic") @@ -174,19 +174,23 @@ object ExecutionContext { * 1. Writing a Scala `object` in the `scala` package (example below). * 1. Writing a Java source file. This works because `private[scala]` is emitted as `public` in Java bytecode. * - * ``` - * // Option 1 + * ```scala sc:compile + * import scala.language.reflectiveCalls + * + * type ExecutionContextCompanionApi = AnyRef { + * def opportunistic: scala.concurrent.ExecutionContextExecutor + * } + * * implicit val ec: scala.concurrent.ExecutionContext = - * (scala.concurrent.ExecutionContext: - * {def opportunistic: scala.concurrent.ExecutionContextExecutor} - * ).opportunistic - * - * // Option 2 - * package scala { - * object OpportunisticEC { - * implicit val ec: scala.concurrent.ExecutionContext = - * scala.concurrent.ExecutionContext.opportunistic - * } + * scala.concurrent.ExecutionContext + * .asInstanceOf[ExecutionContextCompanionApi] + * .opportunistic + * ``` + * + * ```scala sc:compile + * object OpportunisticEC { + * implicit val ec: scala.concurrent.ExecutionContext = + * scala.concurrent.ExecutionContext.opportunistic * } * ``` * @@ -252,7 +256,7 @@ object ExecutionContext { * If it is guaranteed that none of the executed tasks are blocking, a single-threaded `ExecutorService` * can be used to create an `ExecutionContext` as follows: * - * ``` + * ```scala sc:compile * import java.util.concurrent.Executors * val ec = ExecutionContext.fromExecutorService(Executors.newSingleThreadExecutor()) * ``` diff --git a/library/src/scala/concurrent/Future.scala b/library/src/scala/concurrent/Future.scala index f268bdbefea8..b80f3e492649 100644 --- a/library/src/scala/concurrent/Future.scala +++ b/library/src/scala/concurrent/Future.scala @@ -31,7 +31,7 @@ import scala.concurrent.impl.Promise.DefaultPromise * Computations are executed using an `ExecutionContext`, which is usually supplied implicitly, * and which is commonly backed by a thread pool. * - * ``` + * ```scala sc:compile * import ExecutionContext.Implicits.global * val s = "Hello" * val f: Future[String] = Future { @@ -79,7 +79,8 @@ import scala.concurrent.impl.Promise.DefaultPromise * @define forComprehensionExamples * Example: * - * ``` + * ```scala sc:compile + * import ExecutionContext.Implicits.global * val f = Future { 5 } * val g = Future { 3 } * val h = for { @@ -90,7 +91,10 @@ import scala.concurrent.impl.Promise.DefaultPromise * * is translated to: * - * ``` + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * val f = Future { 5 } + * val g = Future { 3 } * f flatMap { (x: Int) => g map { (y: Int) => x + y } } * ``` * @@ -103,6 +107,8 @@ import scala.concurrent.impl.Promise.DefaultPromise * in a batch within a single `execute()` and it may run * `execute()` either immediately or asynchronously. * Completion of the `Future` must *happen-before* the invocation of the callback. + * + * @tparam T the type of the value contained in this `Future` */ trait Future[+T] extends Awaitable[T] { @@ -122,6 +128,7 @@ trait Future[+T] extends Awaitable[T] { * * @tparam U only used to accept any return type of the given callback function * @param f the function to be executed when this `Future` completes + * @param executor the `ExecutionContext` on which the callback will be executed * @group Callbacks */ def onComplete[U](f: Try[T] => U)(implicit executor: ExecutionContext): Unit @@ -179,6 +186,7 @@ trait Future[+T] extends Awaitable[T] { * @tparam U only used to accept any return type of the given callback function * @param f the function which will be executed if this `Future` completes with a result, * the return value of `f` will be discarded. + * @param executor the `ExecutionContext` on which the callback will be executed * @group Callbacks */ def foreach[U](f: T => U)(implicit executor: ExecutionContext): Unit = onComplete { _ foreach f } @@ -191,6 +199,7 @@ trait Future[+T] extends Awaitable[T] { * @tparam S the type of the returned `Future` * @param s function that transforms a successful result of the receiver into a successful result of the returned future * @param f function that transforms a failure of the receiver into a failure of the returned future + * @param executor the `ExecutionContext` on which the transformation will be executed * @return a `Future` that will be completed with the transformed value * @group Transformations */ @@ -207,6 +216,7 @@ trait Future[+T] extends Awaitable[T] { * * @tparam S the type of the returned `Future` * @param f function that transforms the result of this future + * @param executor the `ExecutionContext` on which the transformation will be executed * @return a `Future` that will be completed with the transformed value * @group Transformations */ @@ -218,6 +228,7 @@ trait Future[+T] extends Awaitable[T] { * * @tparam S the type of the returned `Future` * @param f function that transforms the result of this future + * @param executor the `ExecutionContext` on which the transformation will be executed * @return a `Future` that will be completed with the transformed value * @group Transformations */ @@ -230,9 +241,10 @@ trait Future[+T] extends Awaitable[T] { * * Example: * - * ``` + * ```scala sc:compile + * import ExecutionContext.Implicits.global * val f = Future { "The future" } - * val g = f map { x: String => x + " is now!" } + * val g = f.map { (x: String) => x + " is now!" } * ``` * * Note that a for comprehension involving a `Future` @@ -242,6 +254,7 @@ trait Future[+T] extends Awaitable[T] { * * @tparam S the type of the returned `Future` * @param f the function which will be applied to the successful result of this `Future` + * @param executor the `ExecutionContext` on which the function will be executed * @return a `Future` which will be completed with the result of the application of the function * @group Transformations */ @@ -256,6 +269,7 @@ trait Future[+T] extends Awaitable[T] { * * @tparam S the type of the returned `Future` * @param f the function which will be applied to the successful result of this `Future` + * @param executor the `ExecutionContext` on which the function will be executed * @return a `Future` which will be completed with the result of the application of the function * @group Transformations */ @@ -269,6 +283,7 @@ trait Future[+T] extends Awaitable[T] { * to `flatMap(identity)`. * * @tparam S the type of the returned `Future` + * @param ev evidence that `T` is itself a `Future[S]` * @group Transformations */ def flatten[S](implicit ev: T <:< Future[S]): Future[S] = flatMap(ev)(using parasitic) @@ -281,7 +296,9 @@ trait Future[+T] extends Awaitable[T] { * If the current future fails, then the resulting future also fails. * * Example: - * ``` + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * import scala.concurrent.duration.Duration * val f = Future { 5 } * val g = f filter { _ % 2 == 1 } * val h = f filter { _ % 2 == 0 } @@ -290,6 +307,7 @@ trait Future[+T] extends Awaitable[T] { * ``` * * @param p the predicate to apply to the successful result of this `Future` + * @param executor the `ExecutionContext` on which the callback will be executed * @return a `Future` which will hold the successful result of this `Future` if it matches the predicate or a `NoSuchElementException` * @group Transformations */ @@ -304,6 +322,9 @@ trait Future[+T] extends Awaitable[T] { /** Used by for-comprehensions. * @group Transformations + * + * @param p the predicate to apply to the successful result of this `Future` + * @param executor the `ExecutionContext` on which the predicate will be executed */ final def withFilter(p: T => Boolean)(implicit executor: ExecutionContext): Future[T] = filter(p)(using executor) @@ -315,7 +336,9 @@ trait Future[+T] extends Awaitable[T] { * If the current future fails, then the resulting future also fails. * * Example: - * ``` + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * import scala.concurrent.duration.Duration * val f = Future { -5 } * val g = f collect { * case x if x < 0 => -x @@ -329,6 +352,7 @@ trait Future[+T] extends Awaitable[T] { * * @tparam S the type of the returned `Future` * @param pf the `PartialFunction` to apply to the successful result of this `Future` + * @param executor the `ExecutionContext` on which the `PartialFunction` will be executed * @return a `Future` holding the result of application of the `PartialFunction` or a `NoSuchElementException` * @group Transformations */ @@ -346,14 +370,16 @@ trait Future[+T] extends Awaitable[T] { * * Example: * - * ``` - * Future (6 / 0) recover { case e: ArithmeticException => 0 } // result: 0 - * Future (6 / 0) recover { case e: NotFoundException => 0 } // result: exception - * Future (6 / 2) recover { case e: ArithmeticException => 0 } // result: 3 + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * Future(6 / 0).recover { case _: ArithmeticException => 0 } // result: 0 + * Future(6 / 0).recover { case _: NoSuchElementException => 0 } // result: exception + * Future(6 / 2).recover { case _: ArithmeticException => 0 } // result: 3 * ``` * * @tparam U the type of the returned `Future` * @param pf the `PartialFunction` to apply if this `Future` fails + * @param executor the `ExecutionContext` on which the callback will be executed * @return a `Future` with the successful value of this `Future` or the result of the `PartialFunction` * @group Transformations */ @@ -368,13 +394,15 @@ trait Future[+T] extends Awaitable[T] { * * Example: * - * ``` + * ```scala sc:compile + * import ExecutionContext.Implicits.global * val f = Future { Int.MaxValue } - * Future (6 / 0) recoverWith { case e: ArithmeticException => f } // result: Int.MaxValue + * Future(6 / 0).recoverWith { case _: ArithmeticException => f } // result: Int.MaxValue * ``` * * @tparam U the type of the returned `Future` * @param pf the `PartialFunction` to apply if this `Future` fails + * @param executor the `ExecutionContext` on which the `PartialFunction` will be executed * @return a `Future` with the successful value of this `Future` or the outcome of the `Future` returned by the `PartialFunction` * @group Transformations */ @@ -437,7 +465,8 @@ trait Future[+T] extends Awaitable[T] { * Using this method will not cause concurrent programs to become nondeterministic. * * Example: - * ``` + * ```scala sc:compile + * import ExecutionContext.Implicits.global * val f = Future { throw new RuntimeException("failed") } * val g = Future { 5 } * val h = f fallbackTo g @@ -491,7 +520,9 @@ trait Future[+T] extends Awaitable[T] { * * The following example prints out `5`: * - * ``` + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * import scala.util.{Failure, Success} * val f = Future { 5 } * f andThen { * case r => throw new RuntimeException("runtime exception") @@ -505,6 +536,7 @@ trait Future[+T] extends Awaitable[T] { * * @tparam U only used to accept any return type of the given `PartialFunction` * @param pf a `PartialFunction` which will be conditionally applied to the outcome of this `Future` + * @param executor the `ExecutionContext` on which the callback will be executed * @return a `Future` which will be completed with the exact same outcome as this `Future` but after the `PartialFunction` has been executed. * @group Callbacks */ @@ -671,10 +703,12 @@ object Future { * * The following expressions are equivalent: * - * ``` - * val f1 = Future(expr) - * val f2 = Future.unit.map(_ => expr) - * val f3 = Future.unit.transform(_ => Success(expr)) + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * import scala.util.Success + * val f1 = Future(1 + 1) + * val f2 = Future.unit.map(_ => 1 + 1) + * val f3 = Future.unit.transform(_ => Success(1 + 1)) * ``` * * The result becomes available once the asynchronous computation is completed. @@ -691,10 +725,11 @@ object Future { * * The following expressions are semantically equivalent: * - * ``` - * val f1 = Future(expr).flatten - * val f2 = Future.delegate(expr) - * val f3 = Future.unit.flatMap(_ => expr) + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * val f1 = Future(Future.successful(1 + 1)).flatten + * val f2 = Future.delegate(Future.successful(1 + 1)) + * val f3 = Future.unit.flatMap(_ => Future.successful(1 + 1)) * ``` * * The result becomes available once the resulting Future of the asynchronous computation is completed. @@ -726,6 +761,7 @@ object Future { * * @tparam T the type of the value in the future * @param futures the `IterableOnce` of Futures in which to find the first completed + * @param executor the `ExecutionContext` on which the futures' completion handlers will be executed * @return the `Future` holding the result of the future that is first to be completed */ final def firstCompletedOf[T](futures: IterableOnce[Future[T]])(implicit executor: ExecutionContext): Future[T] = { @@ -765,6 +801,7 @@ object Future { * @tparam T the type of the value in the future * @param futures the `scala.collection.immutable.Iterable` of Futures to search * @param p the predicate which indicates if it's a match + * @param executor the `ExecutionContext` on which the futures' completion handlers will be executed * @return the `Future` holding the optional result of the search */ final def find[T](futures: scala.collection.immutable.Iterable[Future[T]])(p: T => Boolean)(implicit executor: ExecutionContext): Future[Option[T]] = { @@ -785,8 +822,10 @@ object Future { * or the result of the fold. * * Example: - * ``` - * val futureSum = Future.foldLeft(futures)(0)(_ + _) + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * val futures = List(Future.successful(1), Future.successful(2), Future.successful(3)) + * val futureSum = Future.foldLeft(futures)(0)(_ + _) * ``` * * @tparam T the type of the value of the input Futures @@ -809,8 +848,10 @@ object Future { * or the result of the fold. * * Example: - * ``` - * val futureSum = Future.fold(futures)(0)(_ + _) + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * val futures = List(Future.successful(1), Future.successful(2), Future.successful(3)) + * val futureSum = Future.fold(futures)(0)(_ + _) * ``` * * @tparam T the type of the value of the input Futures @@ -830,8 +871,10 @@ object Future { * where the fold-zero is the result value of the first `Future` in the collection. * * Example: - * ``` - * val futureSum = Future.reduce(futures)(_ + _) + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * val futures = List(Future.successful(1), Future.successful(2), Future.successful(3)) + * val futureSum = Future.reduce(futures)(_ + _) * ``` * @tparam T the type of the value of the input Futures * @tparam R the type of the value of the returned `Future` @@ -849,8 +892,10 @@ object Future { * where the zero is the result value of the first `Future`. * * Example: - * ``` - * val futureSum = Future.reduceLeft(futures)(_ + _) + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * val futures = List(Future.successful(1), Future.successful(2), Future.successful(3)) + * val futureSum = Future.reduceLeft(futures)(_ + _) * ``` * @tparam T the type of the value of the input Futures * @tparam R the type of the value of the returned `Future` @@ -869,8 +914,11 @@ object Future { * This is useful for performing a parallel map. For example, to apply a function to all items of a list * in parallel: * - * ``` - * val myFutureList = Future.traverse(myList)(x => Future(myFunc(x))) + * ```scala sc:compile + * import ExecutionContext.Implicits.global + * val myList = List(1, 2, 3) + * def myFunc(x: Int): Int = x + 1 + * val myFutureList = Future.traverse(myList)(x => Future(myFunc(x))) * ``` * @tparam A the type of the value inside the Futures in the collection * @tparam B the type of the value of the returned `Future` diff --git a/library/src/scala/concurrent/Promise.scala b/library/src/scala/concurrent/Promise.scala index 6354586b00db..f50f3fa2936f 100644 --- a/library/src/scala/concurrent/Promise.scala +++ b/library/src/scala/concurrent/Promise.scala @@ -33,6 +33,8 @@ import scala.util.{ Try, Success, Failure } * * @define nonDeterministic * Note: Using this method may result in non-deterministic concurrent programs. + * + * @tparam T the type of the value held by this promise and its associated future */ trait Promise[T] { /** Future containing the value of this promise. */ @@ -49,7 +51,8 @@ trait Promise[T] { /** Completes the promise with either an exception or a value. * - * @param result Either the value or the exception to complete the promise with. + * @param result either the value or the exception to complete the promise with + * @return this promise * * $promiseCompletion */ @@ -60,12 +63,14 @@ trait Promise[T] { * * $nonDeterministic * + * @param result either the value or the exception to complete the promise with * @return If the promise has already been completed returns `false`, or `true` otherwise. */ def tryComplete(result: Try[T]): Boolean /** Completes this promise with the specified future, once that future is completed. * + * @param other the future whose result will be used to complete this promise * @return This promise */ def completeWith(other: Future[T]): this.type = { @@ -84,7 +89,8 @@ trait Promise[T] { /** Completes the promise with a value. * - * @param value The value to complete the promise with. + * @param value the value to complete the promise with + * @return this promise * * $promiseCompletion */ @@ -94,13 +100,15 @@ trait Promise[T] { * * $nonDeterministic * + * @param value the value to complete the promise with * @return If the promise has already been completed returns `false`, or `true` otherwise. */ def trySuccess(value: T): Boolean = tryComplete(Success(value)) /** Completes the promise with an exception. * - * @param cause The throwable to complete the promise with. + * @param cause the throwable to complete the promise with + * @return this promise * * $allowedThrowables * @@ -112,6 +120,7 @@ trait Promise[T] { * * $nonDeterministic * + * @param cause the throwable to complete the promise with * @return If the promise has already been completed returns `false`, or `true` otherwise. */ def tryFailure(cause: Throwable): Boolean = tryComplete(Failure(cause)) @@ -128,6 +137,7 @@ object Promise { /** Creates an already completed Promise with the specified exception. * * @tparam T the type of the value in the promise + * @param exception the throwable to fail the promise with * @return the newly created `Promise` instance */ final def failed[T](exception: Throwable): Promise[T] = fromTry(Failure(exception)) @@ -135,6 +145,7 @@ object Promise { /** Creates an already completed Promise with the specified result. * * @tparam T the type of the value in the promise + * @param result the successful value to complete the promise with * @return the newly created `Promise` instance */ final def successful[T](result: T): Promise[T] = fromTry(Success(result)) @@ -142,6 +153,7 @@ object Promise { /** Creates an already completed Promise with the specified result or exception. * * @tparam T the type of the value in the promise + * @param result the `Try` value (success or failure) to complete the promise with * @return the newly created `Promise` instance */ final def fromTry[T](result: Try[T]): Promise[T] = new impl.Promise.DefaultPromise[T](result) diff --git a/library/src/scala/concurrent/SyncVar.scala b/library/src/scala/concurrent/SyncVar.scala index f6422548cfec..33caf16b475d 100644 --- a/library/src/scala/concurrent/SyncVar.scala +++ b/library/src/scala/concurrent/SyncVar.scala @@ -37,6 +37,8 @@ class SyncVar[A] { /** Waits `timeout` millis. If `timeout <= 0` just returns 0. * It never returns negative results. + * + * @param timeout the maximum time to wait, in milliseconds */ private def waitMeasuringElapsed(timeout: Long): Long = if (timeout <= 0) 0 else { val start = System.nanoTime() @@ -80,8 +82,8 @@ class SyncVar[A] { * to become defined and then gets the stored value, unsetting it * as a side effect. * - * @param timeout the amount of milliseconds to wait - * @return the value or a throws an exception if the timeout occurs + * @param timeout the maximum time to wait, in milliseconds + * @return the value held in this `SyncVar` * @throws NoSuchElementException on timeout */ def take(timeout: Long): A = synchronized { @@ -91,6 +93,8 @@ class SyncVar[A] { /** Place a value in the SyncVar. If the SyncVar already has a stored value, * wait until another thread takes it. + * + * @param x the value to store in this `SyncVar` */ def put(x: A): Unit = synchronized { while (isDefined) wait() diff --git a/library/src/scala/concurrent/duration/Deadline.scala b/library/src/scala/concurrent/duration/Deadline.scala index e12eb5d2da4d..a079cf156c32 100644 --- a/library/src/scala/concurrent/duration/Deadline.scala +++ b/library/src/scala/concurrent/duration/Deadline.scala @@ -17,8 +17,8 @@ import scala.language.`2.13` /** This class stores a deadline, as obtained via `Deadline.now` or the * duration DSL: * - * ``` - * import scala.concurrent.duration._ + * ```scala sc:compile + * import scala.concurrent.duration.* * 3.seconds.fromNow * ``` * @@ -29,31 +29,49 @@ import scala.language.`2.13` * seconds). */ case class Deadline private (time: FiniteDuration) extends Ordered[Deadline] { - /** Returns a deadline advanced (i.e., moved into the future) by the given duration. */ + /** Returns a deadline advanced (i.e., moved into the future) by the given duration. + * + * @param other the duration by which to advance this deadline + */ def +(other: FiniteDuration): Deadline = copy(time = time + other) - /** Returns a deadline moved backwards (i.e., towards the past) by the given duration. */ + /** Returns a deadline moved backwards (i.e., towards the past) by the given duration. + * + * @param other the duration by which to move this deadline backwards + */ def -(other: FiniteDuration): Deadline = copy(time = time - other) - /** Calculates time difference between this and the other deadline, where the result is directed (i.e., may be negative). */ + /** Calculates time difference between this and the other deadline, where the result is directed (i.e., may be negative). + * + * @param other the deadline to subtract from this deadline, yielding a directed duration + */ def -(other: Deadline): FiniteDuration = time - other.time /** Calculates time difference between this duration and now; the result is negative if the deadline has passed. * * ***Note that on some systems this operation is costly because it entails a system call.*** * Checks `System.nanoTime` for your platform. + * + * @return the duration remaining until this deadline, negative if the deadline has passed */ def timeLeft: FiniteDuration = this - Deadline.now /** Determine whether the deadline still lies in the future at the point where this method is called. * * ***Note that on some systems this operation is costly because it entails a system call.*** * Checks `System.nanoTime` for your platform. + * + * @return `true` if the deadline has not yet passed, `false` otherwise */ def hasTimeLeft(): Boolean = !isOverdue() /** Determine whether the deadline lies in the past at the point where this method is called. * * ***Note that on some systems this operation is costly because it entails a system call.*** * Checks `System.nanoTime` for your platform. + * + * @return `true` if the deadline has passed, `false` otherwise */ def isOverdue(): Boolean = (time.toNanos - System.nanoTime()) < 0 - /** The natural ordering for deadline is determined by the natural order of the underlying (finite) duration. */ + /** The natural ordering for deadline is determined by the natural order of the underlying (finite) duration. + * + * @param other the deadline to compare against + */ def compare(other: Deadline): Int = time compare other.time } diff --git a/library/src/scala/concurrent/duration/Duration.scala b/library/src/scala/concurrent/duration/Duration.scala index aefb54c94b88..815266d20bc3 100644 --- a/library/src/scala/concurrent/duration/Duration.scala +++ b/library/src/scala/concurrent/duration/Duration.scala @@ -25,12 +25,18 @@ object Duration { * * Infinite inputs (and NaN) are converted into [[Duration.Inf]], [[Duration.MinusInf]] and [[Duration.Undefined]], respectively. * + * @param length the duration length as a floating-point number + * @param unit the time unit in which `length` is measured + * @return a duration representing the given length in the given unit, possibly infinite or undefined * @throws IllegalArgumentException if the length was finite but the resulting duration cannot be expressed as a [[FiniteDuration]] */ def apply(length: Double, unit: TimeUnit): Duration = fromNanos(unit.toNanos(1) * length) /** Constructs a finite duration from the given length and time unit. The unit given is retained * throughout calculations as long as possible, so that it can be retrieved later. + * + * @param length the duration length as a whole number + * @param unit the time unit in which `length` is measured */ def apply(length: Long, unit: TimeUnit): FiniteDuration = new FiniteDuration(length, unit) @@ -39,6 +45,10 @@ object Duration { * * `d, day, h, hr, hour, m, min, minute, s, sec, second, ms, milli, millisecond, µs, micro, microsecond, ns, nano, nanosecond` * and their pluralized forms (for every but the first mentioned form of each unit, i.e. no "ds", but "days"). + * + * @param length the duration length as a whole number + * @param unit the string representation of the time unit (e.g. `"ms"`, `"second"`, `"days"`) + * @return a finite duration of the given length with the resolved time unit */ def apply(length: Long, unit: String): FiniteDuration = new FiniteDuration(length, Duration.timeUnit(unit)) @@ -50,6 +60,7 @@ object Duration { * designated by `"Inf"`, `"PlusInf"`, `"+Inf"`, `"Duration.Inf"` and `"-Inf"`, `"MinusInf"` or `"Duration.MinusInf"`. * Undefined is designated by `"Duration.Undefined"`. * + * @param s the string to parse into a duration * @throws NumberFormatException if format is not parsable */ def apply(s: String): Duration = { @@ -96,11 +107,16 @@ object Duration { /** Extracts length and time unit out of a string, where the format must match the description for [[Duration$.apply(s:String)* apply(String)]]. * The extractor will not match for malformed strings or non-finite durations. + * + * @param s the string to parse and extract a length and time unit from */ def unapply(s: String): Option[(Long, TimeUnit)] = ( try Some(apply(s)) catch { case _: RuntimeException => None } ) flatMap unapply - /** Extracts length and time unit out of a duration, if it is finite. */ + /** Extracts length and time unit out of a duration, if it is finite. + * + * @param d the duration to decompose into length and time unit + */ def unapply(d: Duration): Option[(Long, TimeUnit)] = if (d.isFinite) Some((d.length, d.unit)) else None @@ -114,6 +130,8 @@ object Duration { * The semantics of the resulting Duration objects matches the semantics of their Double * counterparts with respect to arithmetic operations. * + * @param nanos the number of nanoseconds as a floating-point value, may be infinite or NaN + * @return a duration corresponding to the given number of nanoseconds, possibly infinite or undefined * @throws IllegalArgumentException if the length was finite but the resulting duration cannot be expressed as a [[FiniteDuration]] */ def fromNanos(nanos: Double): Duration = { @@ -138,6 +156,7 @@ object Duration { * result will have the coarsest possible time unit which can exactly express * this duration. * + * @param nanos the number of nanoseconds * @throws IllegalArgumentException for `Long.MinValue` since that would lead to inconsistent behavior afterwards (cannot be negated) */ def fromNanos(nanos: Long): FiniteDuration = { @@ -251,6 +270,9 @@ object Duration { /** Constructs a finite duration from the given length and time unit. The unit given is retained * throughout calculations as long as possible, so that it can be retrieved later. + * + * @param length the duration length as a whole number + * @param unit the time unit in which `length` is measured */ def create(length: Long, unit: TimeUnit): FiniteDuration = apply(length, unit) /** Constructs a Duration from the given length and unit. Observe that nanosecond precision may be lost if @@ -260,6 +282,9 @@ object Duration { * * Infinite inputs (and NaN) are converted into [[Duration.Inf]], [[Duration.MinusInf]] and [[Duration.Undefined]], respectively. * + * @param length the duration length as a floating-point number + * @param unit the time unit in which `length` is measured + * @return a duration representing the given length in the given unit, possibly infinite or undefined * @throws IllegalArgumentException if the length was finite but the resulting duration cannot be expressed as a [[FiniteDuration]] */ def create(length: Double, unit: TimeUnit): Duration = apply(length, unit) @@ -268,12 +293,17 @@ object Duration { * * `d, day, h, hour, min, minute, s, sec, second, ms, milli, millisecond, µs, micro, microsecond, ns, nano, nanosecond` * and their pluralized forms (for every but the first mentioned form of each unit, i.e. no "ds", but "days"). + * + * @param length the duration length as a whole number + * @param unit the string representation of the time unit (e.g. `"ms"`, `"second"`, `"days"`) + * @return a finite duration of the given length with the resolved time unit */ def create(length: Long, unit: String): FiniteDuration = apply(length, unit) /** Parses String into Duration. Format is `""`, where * whitespace is allowed before, between and after the parts. Infinities are * designated by `"Inf"`, `"PlusInf"`, `"+Inf"` and `"-Inf"` or `"MinusInf"`. * + * @param s the string to parse into a duration * @throws NumberFormatException if format is not parsable */ def create(s: String): Duration = apply(s) @@ -293,11 +323,11 @@ object Duration { * *

* Examples: - * ``` - * import scala.concurrent.duration._ + * ```scala sc:compile + * import scala.concurrent.duration.* * * val duration = Duration(100, MILLISECONDS) - * val duration = Duration(100, "millis") + * val sameDuration = Duration(100, "millis") * * duration.toNanos * duration < 1.second @@ -308,8 +338,8 @@ object Duration { * *

* Implicits are also provided for Int, Long and Double. Example usage: - * ``` - * import scala.concurrent.duration._ + * ```scala sc:compile + * import scala.concurrent.duration.* * * val duration = 100.millis * ``` @@ -317,7 +347,9 @@ object Duration { * ***The DSL provided by the implicit conversions always allows construction of finite durations, even for infinite Double inputs; use Duration.Inf instead.*** * * Extractors, parsing and arithmetic are also included: - * ``` + * ```scala sc:compile + * import scala.concurrent.duration.* + * import scala.language.postfixOps * val d = Duration("1.2 µs") * val Duration(length, unit) = 5 millis * val d2 = d * 2.5 @@ -354,46 +386,64 @@ sealed abstract class Duration extends Serializable with Ordered[Duration] { /** Obtains the length of this Duration measured in the unit obtained by the `unit` method. * * $exc + * + * @return the numeric length of this duration, measured in its associated `unit` */ def length: Long /** Obtains the time unit in which the length of this duration is measured. * * $exc + * + * @return the time unit used to measure this duration */ def unit: TimeUnit /** Returns the length of this duration measured in whole nanoseconds, rounding towards zero. * * $exc + * + * @return the length of this duration in nanoseconds */ def toNanos: Long /** Returns the length of this duration measured in whole microseconds, rounding towards zero. * * $exc + * + * @return the length of this duration in microseconds */ def toMicros: Long /** Returns the length of this duration measured in whole milliseconds, rounding towards zero. * * $exc + * + * @return the length of this duration in milliseconds */ def toMillis: Long /** Returns the length of this duration measured in whole seconds, rounding towards zero. * * $exc + * + * @return the length of this duration in seconds */ def toSeconds: Long /** Returns the length of this duration measured in whole minutes, rounding towards zero. * * $exc + * + * @return the length of this duration in minutes */ def toMinutes: Long /** Returns the length of this duration measured in whole hours, rounding towards zero. * * $exc + * + * @return the length of this duration in hours */ def toHours: Long /** Returns the length of this duration measured in whole days, rounding towards zero. * * $exc + * + * @return the length of this duration in days */ def toDays: Long /** Returns the number of nanoseconds as floating point number, scaled down to the given unit. @@ -402,6 +452,8 @@ sealed abstract class Duration extends Serializable with Ordered[Duration] { * - [[Duration.Undefined]] is mapped to Double.NaN * - [[Duration.Inf]] is mapped to Double.PositiveInfinity * - [[Duration.MinusInf]] is mapped to Double.NegativeInfinity + * + * @param unit the time unit to convert to */ def toUnit(unit: TimeUnit): Double @@ -409,28 +461,42 @@ sealed abstract class Duration extends Serializable with Ordered[Duration] { * of Double. * * $ovf + * + * @param other the duration to add to this one + * @return the sum of the two durations */ def +(other: Duration): Duration /** Returns the difference of that duration and this. When involving non-finite summands the semantics match those * of Double. * * $ovf + * + * @param other the duration to subtract from this one + * @return the difference of the two durations */ def -(other: Duration): Duration /** Returns this duration multiplied by the scalar factor. When involving non-finite factors the semantics match those * of Double. * * $ovf + * + * @param factor the scalar to multiply by + * @return this duration scaled by the given factor */ def *(factor: Double): Duration /** Returns this duration divided by the scalar factor. When involving non-finite factors the semantics match those * of Double. * * $ovf + * + * @param divisor the scalar to divide by + * @return this duration divided by the given divisor */ def /(divisor: Double): Duration /** Returns the quotient of this and that duration as floating-point number. The semantics are * determined by Double as if calculating the quotient of the nanosecond lengths of both factors. + * + * @param divisor the duration to divide by */ def /(divisor: Duration): Double /** Negate this duration. The only two values which are mapped to themselves are [[Duration.Zero]] and [[Duration.Undefined]]. */ @@ -439,9 +505,15 @@ sealed abstract class Duration extends Serializable with Ordered[Duration] { * `!isInfinite` for Double because this method also returns `false` for [[Duration.Undefined]]. */ def isFinite: Boolean - /** Returns the smaller of this and that duration as determined by the natural ordering. */ + /** Returns the smaller of this and that duration as determined by the natural ordering. + * + * @param other the duration to compare with + */ def min(other: Duration): Duration = if (this < other) this else other - /** Returns the larger of this and that duration as determined by the natural ordering. */ + /** Returns the larger of this and that duration as determined by the natural ordering. + * + * @param other the duration to compare with + */ def max(other: Duration): Duration = if (this > other) this else other // Java API @@ -450,10 +522,15 @@ sealed abstract class Duration extends Serializable with Ordered[Duration] { * of Double. * * $ovf + * + * @param divisor the scalar to divide by + * @return this duration divided by the given divisor */ def div(divisor: Double): Duration = this / divisor /** Returns the quotient of this and that duration as floating-point number. The semantics are * determined by Double as if calculating the quotient of the nanosecond lengths of both factors. + * + * @param other the duration to divide by */ def div(other: Duration): Double = this / other def gt(other: Duration): Boolean = this > other @@ -464,12 +541,18 @@ sealed abstract class Duration extends Serializable with Ordered[Duration] { * of Double. * * $ovf + * + * @param other the duration to subtract from this one + * @return the difference of the two durations */ def minus(other: Duration): Duration = this - other /** Returns this duration multiplied by the scalar factor. When involving non-finite factors the semantics match those * of Double. * * $ovf + * + * @param factor the scalar to multiply by + * @return this duration scaled by the given factor */ def mul(factor: Double): Duration = this * factor /** Negate this duration. The only two values which are mapped to themselves are [[Duration.Zero]] and [[Duration.Undefined]]. */ @@ -478,12 +561,16 @@ sealed abstract class Duration extends Serializable with Ordered[Duration] { * of Double. * * $ovf + * + * @param other the duration to add to this one + * @return the sum of the two durations */ def plus(other: Duration): Duration = this + other /** Returns duration which is equal to this duration but with a coarsest Unit, or self in case it is already the coarsest Unit *

* Examples: - * ``` + * ```scala sc:compile + * import scala.concurrent.duration.* * Duration(60, MINUTES).toCoarsest // Duration(1, HOURS) * Duration(1000, MILLISECONDS).toCoarsest // Duration(1, SECONDS) * Duration(48, HOURS).toCoarsest // Duration(2, DAYS) @@ -514,6 +601,9 @@ object FiniteDuration { /** This class represents a finite duration. Its addition and subtraction operators are overloaded to retain * this guarantee statically. The range of this class is limited to `+-(2^63-1)`ns, which is roughly 292 years. + * + * @param length the number of time units in this duration + * @param unit the time unit in which `length` is measured */ final class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration { import FiniteDuration._ @@ -532,9 +622,6 @@ final class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duratio case MINUTES => bounded(max_min) case HOURS => bounded(max_h) case DAYS => bounded(max_d) - case _ => - val v = DAYS.convert(length, unit) - -max_d <= v && v <= max_d }, "Duration is limited to +-(2^63-1)ns (ca. 292 years)") def toNanos: Long = unit.toNanos(length) @@ -609,12 +696,14 @@ final class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duratio /** Returns the quotient of this duration and the given integer factor. * + * @param divisor the integer value to divide by * @throws java.lang.ArithmeticException if the factor is 0 */ def /(divisor: Long): FiniteDuration = fromNanos(toNanos / divisor) /** Returns the product of this duration and the given integer factor. * + * @param factor the integer value to multiply by * @throws IllegalArgumentException if the result would overflow the range of FiniteDuration */ def *(factor: Long): FiniteDuration = new FiniteDuration(safeMul(length, factor), unit) @@ -641,12 +730,14 @@ final class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duratio /** Returns the quotient of this duration and the given integer factor. * + * @param divisor the integer value to divide by * @throws java.lang.ArithmeticException if the factor is 0 */ def div(divisor: Long): FiniteDuration = this / divisor /** Returns the product of this duration and the given integer factor. * + * @param factor the integer value to multiply by * @throws IllegalArgumentException if the result would overflow the range of FiniteDuration */ def mul(factor: Long): FiniteDuration = this * factor diff --git a/library/src/scala/concurrent/duration/package.scala b/library/src/scala/concurrent/duration/package.scala index 8eafd0f7f8bc..4111462c77f0 100644 --- a/library/src/scala/concurrent/duration/package.scala +++ b/library/src/scala/concurrent/duration/package.scala @@ -20,12 +20,12 @@ package object duration { * This object can be used as closing token if you prefer dot-less style but do not want * to enable language.postfixOps: * - * ``` - * import scala.concurrent.duration._ + * ```scala sc:compile + * import scala.concurrent.duration.* * * val duration = 2 seconds span * ``` - + */ object span @@ -33,12 +33,12 @@ package object duration { * This object can be used as closing token for declaring a deadline at some future point * in time: * - * ``` - * import scala.concurrent.duration._ + * ```scala sc:compile + * import scala.concurrent.duration.* * * val deadline = 3 seconds fromNow * ``` - + */ object fromNow diff --git a/library/src/scala/concurrent/impl/Promise.scala b/library/src/scala/concurrent/impl/Promise.scala index 6a763dcc39ee..e9c1eba11c0c 100644 --- a/library/src/scala/concurrent/impl/Promise.scala +++ b/library/src/scala/concurrent/impl/Promise.scala @@ -31,6 +31,8 @@ import java.io.{IOException, NotSerializableException, ObjectInputStream, Object * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * https://creativecommons.org/publicdomain/zero/1.0/ + * + * @tparam T the type of the result value held by this latch */ private[impl] final class CompletionLatch[T] extends AbstractQueuedSynchronizer with (Try[T] => Unit) { //@volatie not needed since we use acquire/release @@ -58,15 +60,26 @@ private[concurrent] object Promise { * * If when compressing a chain of Links it is discovered that the root has been completed, * the `owner`'s value is completed with that value, and the Link chain is discarded. + * + * @tparam T the type of the promised value + * @param to the target `DefaultPromise` that this link initially points to */ private[concurrent] final class Link[T](to: DefaultPromise[T]) extends AtomicReference[DefaultPromise[T]](to) { - /** Compresses this chain and returns the currently known root of this chain of Links. */ + /** Compresses this chain and returns the currently known root of this chain of Links. + * + * @param owner the `DefaultPromise` that owns this link, used to complete it if the root is already resolved + */ final def promise(owner: DefaultPromise[T]): DefaultPromise[T] = { val c = get() compressed(current = c, target = c, owner = owner) } - /** The combination of traversing and possibly unlinking of a given `target` DefaultPromise. */ + /** The combination of traversing and possibly unlinking of a given `target` DefaultPromise. + * + * @param current the `DefaultPromise` most recently read from this link's atomic reference + * @param target the `DefaultPromise` currently being inspected while traversing the chain + * @param owner the `DefaultPromise` that owns this link, used to complete it if the root is already resolved + */ @inline @tailrec private final def compressed(current: DefaultPromise[T], target: DefaultPromise[T], owner: DefaultPromise[T]): DefaultPromise[T] = { val value = target.get() if (value.isInstanceOf[Callbacks[?]]) { @@ -82,6 +95,9 @@ private[concurrent] object Promise { /** The process of "resolving" a Try is to validate that it only contains * those values which makes sense in the context of Futures. + * + * @tparam T the type of the value contained in the `Try` + * @param value the `Try` to resolve, must not be null */ // requireNonNull is paramount to guard against null completions private final def resolve[T](value: Try[T]): Try[T] = @@ -98,7 +114,10 @@ private[concurrent] object Promise { // Left non-final to enable addition of extra fields by Java/Scala converters in scala-java8-compat. class DefaultPromise[T] private (initial: AnyRef) extends AtomicReference[AnyRef](initial) with scala.concurrent.Promise[T] with scala.concurrent.Future[T] with (Try[T] => Unit) { - /** Constructs a new, completed, Promise. */ + /** Constructs a new, completed, Promise. + * + * @param result the completed result value to initialize this promise with + */ final def this(result: Try[T]) = this(resolve(result): AnyRef) /** Constructs a new, un-completed, Promise. */ @@ -106,6 +125,8 @@ private[concurrent] object Promise { /** WARNING: the `resolved` value needs to have been pre-resolved using `resolve()` * INTERNAL API + * + * @param resolved the pre-resolved `Try` value to complete this promise with */ override final def apply(resolved: Try[T]): Unit = tryComplete0(get(), resolved) @@ -207,6 +228,10 @@ private[concurrent] object Promise { /** The same as [[onComplete]], but additionally returns a function which can be * invoked to unregister the callback function. Removing a callback from a long-lived * future can enable garbage collection of objects referenced by the closure. + * + * @tparam U the result type of the callback function + * @param func the callback function to invoke when the future completes + * @param executor the `ExecutionContext` used to run the callback */ private[concurrent] final def onCompleteWithUnregister[U](func: Try[T] => U)(implicit executor: ExecutionContext): () => Unit = { val t = new Transformation[T, Unit](Xform_onComplete, func, executor) @@ -305,6 +330,8 @@ private[concurrent] object Promise { /** Tries to add the callback, if already completed, it dispatches the callback to be executed. * Used by `onComplete()` to add callbacks to a promise and by `link()` to transfer callbacks * to the root promise when linking two promises together. + * + * @tparam C the specific subtype of `Callbacks[T]` being dispatched or added */ @tailrec private final def dispatchOrAddCallbacks[C <: Callbacks[T]](state: AnyRef, callbacks: C): C = if (state.isInstanceOf[Try[?]]) { @@ -360,7 +387,11 @@ private[concurrent] object Promise { callbacks.asInstanceOf[Transformation[T, ?]].submitWithValue(resolved) } - /** Link this promise to the root of another promise. */ + /** Link this promise to the root of another promise. + * + * @param target the `DefaultPromise` to link this promise's root to + * @param link a reusable `Link` instance for the connection, or null to create a new one + */ @tailrec private[concurrent] final def linkRootOf(target: DefaultPromise[T], link: Link[T] | Null): Unit = if (this ne target) { val state = get() @@ -379,6 +410,8 @@ private[concurrent] object Promise { /** Unlinks (removes) the link chain if the root is discovered to be already completed, * and completes the `owner` with that result. + * + * @param resolved the already-resolved result to complete all promises in the link chain with */ @tailrec private[concurrent] final def unlink(resolved: Try[T]): Unit = { val state = get() @@ -426,6 +459,9 @@ private[concurrent] object Promise { * Producing a value of type T (it is a Promise[T]). * In order to conserve allocations, indirections, and avoid introducing bi/mega-morphicity the transformation * function's type parameters are erased, and the _xform tag will be used to reify them. + * + * @tparam F the input type (the value type of the future being transformed) + * @tparam T the output type (the value type produced by the transformation) */ final class Transformation[-F, T] private ( @annotation.stableNull private final var _fun: (Any => Any) | Null, diff --git a/library/src/scala/concurrent/package.scala b/library/src/scala/concurrent/package.scala index 36ee2fdc33c3..fe0f47ac0a80 100644 --- a/library/src/scala/concurrent/package.scala +++ b/library/src/scala/concurrent/package.scala @@ -30,7 +30,7 @@ import scala.util.Try * When working with Futures, you will often find that importing the whole concurrent * package is convenient: * - * ``` + * ```scala sc:compile * import scala.concurrent._ * ``` * @@ -40,10 +40,12 @@ import scala.util.Try * If the code in question is a class or method definition, and no `ExecutionContext` is available, * request one from the caller by adding an implicit parameter list: * - * ``` - * def myMethod(myParam: MyType)(implicit ec: ExecutionContext) = … - * //Or - * class MyClass(myParam: MyType)(implicit ec: ExecutionContext) { … } + * ```scala sc:compile + * def myMethod(myParam: Int)(implicit ec: ExecutionContext): Int = myParam + 1 + * // Or + * class MyClass(myParam: Int)(implicit ec: ExecutionContext) { + * def doubled: Int = myParam * 2 + * } * ``` * * This allows the caller of the method, or creator of the instance of the class, to decide which @@ -51,7 +53,7 @@ import scala.util.Try * * For typical REPL usage and experimentation, importing the global `ExecutionContext` is often desired. * - * ``` + * ```scala sc:compile * import scala.concurrent.ExecutionContext.Implicits.global * ``` * @@ -60,8 +62,8 @@ import scala.util.Try * Operations often require a duration to be specified. A duration DSL is available * to make defining these easier: * - * ``` - * import scala.concurrent.duration._ + * ```scala sc:compile + * import scala.concurrent.duration.* * val d: Duration = 10.seconds * ``` * @@ -72,13 +74,12 @@ import scala.util.Try * without blocking the current thread. In order to create the Future you will need * either an implicit or explicit ExecutionContext to be provided: * - * ``` - * import scala.concurrent._ + * ```scala sc:compile + * import scala.concurrent.* * import ExecutionContext.Implicits.global // implicit execution context * * val firstZebra: Future[Int] = Future { - * val words = Files.readAllLines("/etc/dictionaries-common/words").asScala - * words.indexOfSlice("zebra") + * "aardvark zebra".indexOf("zebra") * } * ``` * @@ -86,8 +87,10 @@ import scala.util.Try * * Although blocking is possible in order to await results (with a mandatory timeout duration): * - * ``` - * import scala.concurrent.duration._ + * ```scala sc:compile + * import scala.concurrent.* + * import scala.concurrent.duration.* + * val firstZebra = Future.successful(9) * Await.result(firstZebra, 10.seconds) * ``` * @@ -96,14 +99,18 @@ import scala.util.Try * potential deadlocks and improve performance. Instead, use callbacks or combinators to * remain in the future domain: * - * ``` + * ```scala sc:compile + * import scala.concurrent.* + * import scala.concurrent.ExecutionContext.Implicits.global + * val firstAardvark = Future.successful(0) + * val firstZebra = Future.successful(600001) * val animalRange: Future[Int] = for { * aardvark <- firstAardvark * zebra <- firstZebra * } yield zebra - aardvark * - * animalRange.onSuccess { - * case x if x > 500000 => println("It's a long way from Aardvark to Zebra") + * animalRange.foreach { x => + * if (x > 500000) println("It's a long way from Aardvark to Zebra") * } * ``` */ @@ -172,7 +179,7 @@ package concurrent { @throws(classOf[TimeoutException]) @throws(classOf[InterruptedException]) final def ready[T](awaitable: Awaitable[T], atMost: Duration): awaitable.type = awaitable match { - case f: Future[T] if f.isCompleted => + case f: Future[T @unchecked] if f.isCompleted => if (atMost eq Duration.Undefined) Future.waitUndefinedError() // preserve semantics, see scala/scala#10972 else awaitable case _ => @@ -211,7 +218,7 @@ package concurrent { private object FutureValue { def unapply[T](a: Awaitable[T]): Option[Try[T]] = a match { - case f: Future[T] => f.value + case f: Future[T @unchecked] => f.value case _ => None } } diff --git a/library/src/scala/deprecatedName.scala b/library/src/scala/deprecatedName.scala index 03f325539a14..b0caca66f5c1 100644 --- a/library/src/scala/deprecatedName.scala +++ b/library/src/scala/deprecatedName.scala @@ -20,8 +20,6 @@ import scala.annotation.meta._ * Using this name in a named argument generates a deprecation warning. * * If the `name` is omitted, then using the canonical name is deprecated. - * In that case, lints such as `-Xlint:named-booleans` which encourage - * the use of a name will not warn. * * Library authors should state the library's deprecation policy in their documentation to give * developers guidance on how long a deprecated name will be preserved. diff --git a/library/src/scala/io/AnsiColor.scala b/library/src/scala/io/AnsiColor.scala index c22ba3cc5dff..5625784067ac 100644 --- a/library/src/scala/io/AnsiColor.scala +++ b/library/src/scala/io/AnsiColor.scala @@ -22,8 +22,8 @@ import scala.language.`2.13` * This group of escape codes provides control over text styling. For example, to turn on reverse video with bold and * then turn off all styling embed these codes, * - * ``` - * import io.AnsiColor._ + * ```scala sc:compile + * import scala.io.AnsiColor._ * * println(s"\${REVERSED}\${BOLD}Hello 1979!\${RESET}") * ``` diff --git a/library/src/scala/io/BufferedSource.scala b/library/src/scala/io/BufferedSource.scala index cc11013d6869..83026fdfdf5f 100644 --- a/library/src/scala/io/BufferedSource.scala +++ b/library/src/scala/io/BufferedSource.scala @@ -20,6 +20,9 @@ import scala.collection.mutable.StringBuilder /** This object provides convenience methods to create an iterable * representation of a source file. + * + * @param inputStream the underlying input stream to read characters from + * @param bufferSize the size of the internal buffer used for reading */ class BufferedSource(inputStream: InputStream, bufferSize: Int)(implicit val codec: Codec) extends Source { def this(inputStream: InputStream)(implicit codec: Codec) = this(inputStream, DefaultBufSize)(using codec) @@ -91,6 +94,12 @@ class BufferedSource(inputStream: InputStream, bufferSize: Int)(implicit val cod * * Note: This function may temporarily load the entire buffer into * memory. + * + * @param sb the string builder to append to + * @param start the string to prepend before the first character + * @param sep the separator string inserted between elements + * @param end the string to append after the last element + * @return the string builder `sb` with all elements appended */ override def addString(sb: StringBuilder, start: String, sep: String, end: String): sb.type = if (sep.isEmpty) { diff --git a/library/src/scala/io/Codec.scala b/library/src/scala/io/Codec.scala index 1a5bd9b19cf0..f02647aaa644 100644 --- a/library/src/scala/io/Codec.scala +++ b/library/src/scala/io/Codec.scala @@ -30,7 +30,10 @@ import scala.language.implicitConversions // MacRoman vs. UTF-8: see https://groups.google.com/d/msg/jruby-developers/-qtwRhoE1WM/whSPVpTNV28J // -Dfile.encoding: see https://bugs.java.com/view_bug.do?bug_id=4375816 -/** A class for character encoding/decoding preferences. */ +/** A class for character encoding/decoding preferences. + * + * @param charSet the character set used for encoding and decoding operations + */ class Codec(val charSet: Charset) { type Configure[T] = (T => T, Boolean) type Handler = CharacterCodingException => Int diff --git a/library/src/scala/io/Position.scala b/library/src/scala/io/Position.scala index 1aff54021b89..70dd3ab4367e 100644 --- a/library/src/scala/io/Position.scala +++ b/library/src/scala/io/Position.scala @@ -31,17 +31,28 @@ import annotation.nowarn * the undefined position is 0: `encode(0,0) == 0` * encodings are non-negative : `encode(line,column) >= 0` * position order is preserved: + * ```scala sc:compile sc-name:lines-and-columns + * val line1 = 1 + * val column1 = 2 + * val line2 = 1 + * val column2 = 3 * ``` + * ```scala sc-compile-with:lines-and-columns * (line1 <= line2) || (line1 == line2 && column1 <= column2) * ``` * implies - * ``` - * encode(line1,column1) <= encode(line2,column2) + * ```scala sc-compile-with:lines-and-columns + * import scala.io.Position.encode + * encode(line1, column1) <= encode(line2, column2) * ``` */ @deprecated("this class will be removed", "2.10.0") private[scala] abstract class Position { - /** Definable behavior for overflow conditions. */ + /** Definable behavior for overflow conditions. + * + * @param line the 1-based line number to validate (0 for undefined, negative values throw) + * @param column the 1-based column number to validate (must be 0 when `line` is 0, negative values throw) + */ def checkInput(line: Int, column: Int): Unit /** Number of bits used to encode the line number. */ @@ -53,7 +64,11 @@ private[scala] abstract class Position { /** Mask to decode the column number. */ final val COLUMN_MASK = (1 << COLUMN_BITS) - 1 - /** Encodes a position into a single integer. */ + /** Encodes a position into a single integer. + * + * @param line the 1-based line number, or 0 for undefined; values at or above `LINE_MASK` are clamped and the column is set to 0 + * @param column the 1-based column number, or 0 for undefined; clamped to `COLUMN_MASK`, ignored when `line` >= `LINE_MASK` + */ final def encode(line: Int, column: Int): Int = { checkInput(line, column) @@ -63,13 +78,22 @@ private[scala] abstract class Position { (line << COLUMN_BITS) | scala.math.min(COLUMN_MASK, column) } - /** Returns the line number of the encoded position. */ + /** Returns the line number of the encoded position. + * + * @param pos the encoded position as returned by `encode` + */ final def line(pos: Int): Int = (pos >> COLUMN_BITS) & LINE_MASK - /** Returns the column number of the encoded position. */ + /** Returns the column number of the encoded position. + * + * @param pos the encoded position as returned by `encode` + */ final def column(pos: Int): Int = pos & COLUMN_MASK - /** Returns a string representation of the encoded position. */ + /** Returns a string representation of the encoded position. + * + * @param pos the encoded position as returned by `encode` + */ def toString(pos: Int): String = line(pos) + ":" + column(pos) } diff --git a/library/src/scala/io/Source.scala b/library/src/scala/io/Source.scala index aaae4803f0d6..ad6f69170595 100644 --- a/library/src/scala/io/Source.scala +++ b/library/src/scala/io/Source.scala @@ -38,42 +38,72 @@ object Source { val iter = iterable.iterator } withReset(() => fromIterable(iterable)) - /** Creates a Source instance from a single character. */ + /** Creates a Source instance from a single character. + * + * @param c the character to use as the source content + */ def fromChar(c: Char): Source = fromIterable(Array(c)) - /** creates Source from array of characters, with empty description. */ + /** Creates Source from array of characters, with empty description. + * + * @param chars the array of characters to use as the source content + */ def fromChars(chars: Array[Char]): Source = fromIterable(chars) - /** creates Source from a String, with no description. */ + /** Creates Source from a String, with no description. + * + * @param s the string to use as the source content + */ def fromString(s: String): Source = fromIterable(s) - /** creates Source from file with given name, setting its description to + /** Creates Source from file with given name, setting its description to * filename. + * + * @param name the name of the file to read + * @param codec the implicit codec used for character encoding */ def fromFile(name: String)(implicit codec: Codec): BufferedSource = fromFile(new JFile(name))(using codec) - /** creates Source from file with given name, using given encoding, setting + /** Creates Source from file with given name, using given encoding, setting * its description to filename. + * + * @param name the name of the file to read + * @param enc the name of the character encoding to use */ def fromFile(name: String, enc: String): BufferedSource = fromFile(name)(using Codec(enc)) - /** creates `source` from file with given file `URI`. */ + /** Creates `source` from file with given file `URI`. + * + * @param uri the file URI to read from + * @param codec the implicit codec used for character encoding + */ def fromFile(uri: URI)(implicit codec: Codec): BufferedSource = fromFile(new JFile(uri))(using codec) - /** creates Source from file with given file: URI */ + /** Creates Source from file with given file: URI + * + * @param uri the file URI to read from + * @param enc the name of the character encoding to use + */ def fromFile(uri: URI, enc: String): BufferedSource = fromFile(uri)(using Codec(enc)) - /** creates Source from file, using default character encoding, setting its + /** Creates Source from file, using default character encoding, setting its * description to filename. + * + * @param file the file to read from + * @param codec the implicit codec used for character encoding */ def fromFile(file: JFile)(implicit codec: Codec): BufferedSource = fromFile(file, Source.DefaultBufSize)(using codec) - /** same as fromFile(file, enc, Source.DefaultBufSize) */ + /** same as fromFile(file, enc, Source.DefaultBufSize) + * + * @param file the file to read from + * @param enc the name of the character encoding to use + */ def fromFile(file: JFile, enc: String): BufferedSource = fromFile(file)(using Codec(enc)) @@ -83,6 +113,10 @@ object Source { /** Creates Source from `file`, using given character encoding, setting * its description to filename. Input is buffered in a buffer of size * `bufferSize`. + * + * @param file the file to read from + * @param bufferSize the size of the input buffer, in characters + * @param codec the implicit codec used for character encoding */ def fromFile(file: JFile, bufferSize: Int)(implicit codec: Codec): BufferedSource = { val inputStream = new FileInputStream(file) @@ -98,6 +132,8 @@ object Source { /** Creates a `Source` from array of bytes, decoding * the bytes according to codec. * + * @param bytes the array of bytes to decode into characters + * @param codec the implicit codec used for character encoding * @return the created `Source` instance. */ def fromBytes(bytes: Array[Byte])(implicit codec: Codec): Source = @@ -113,23 +149,43 @@ object Source { def fromRawBytes(bytes: Array[Byte]): Source = fromString(new String(bytes, Codec.ISO8859.charSet)) - /** creates `Source` from file with given file: URI */ + /** creates `Source` from file with given file: URI + * + * @param uri the file URI to read from + * @param codec the implicit codec used for character encoding + */ def fromURI(uri: URI)(implicit codec: Codec): BufferedSource = fromFile(new JFile(uri))(using codec) - /** same as fromURL(new URL(s))(Codec(enc)) */ + /** Same as fromURL(new URL(s))(Codec(enc)) + * + * @param s the URL string to read from + * @param enc the name of the character encoding to use + */ def fromURL(s: String, enc: String): BufferedSource = fromURL(s)(using Codec(enc)) - /** same as fromURL(new URL(s)) */ + /** Same as fromURL(new URL(s)) + * + * @param s the URL string to read from + * @param codec the implicit codec used for character encoding + */ def fromURL(s: String)(implicit codec: Codec): BufferedSource = fromURL(new URI(s).toURL)(using codec) - /** same as fromInputStream(url.openStream())(Codec(enc)) */ + /** Same as fromInputStream(url.openStream())(Codec(enc)) + * + * @param url the URL to read from + * @param enc the name of the character encoding to use + */ def fromURL(url: URL, enc: String): BufferedSource = fromURL(url)(using Codec(enc)) - /** same as fromInputStream(url.openStream())(codec) */ + /** Same as fromInputStream(url.openStream())(codec) + * + * @param url the URL to read from + * @param codec the implicit codec used for character encoding + */ def fromURL(url: URL)(implicit codec: Codec): BufferedSource = fromInputStream(url.openStream())(using codec) @@ -347,7 +403,10 @@ abstract class Source extends Iterator[Char] with Closeable { descr = text this } - /** Change or disable the positioner. */ + /** Change or disable the positioner. + * + * @param on whether to enable (`true`) or disable (`false`) position tracking + */ def withPositioning(on: Boolean): this.type = { positioner = if (on) RelaxedPositioner else NoPositioner this diff --git a/library/src/scala/jdk/Accumulator.scala b/library/src/scala/jdk/Accumulator.scala index 4d45f9e10e91..3d2875b9e93a 100644 --- a/library/src/scala/jdk/Accumulator.scala +++ b/library/src/scala/jdk/Accumulator.scala @@ -38,18 +38,15 @@ import scala.language.implicitConversions * Note: to run the example, start the Scala REPL with `scala -Yrepl-class-based` to avoid * deadlocks, see [[https://github.com/scala/bug/issues/9076]]. * - * ``` - * scala> import scala.jdk.StreamConverters._ - * import scala.jdk.StreamConverters._ - * - * scala> def isPrime(n: Int): Boolean = !(2 +: (3 to Math.sqrt(n).toInt by 2) exists (n % _ == 0)) - * isPrime: (n: Int)Boolean + * ```scala sc:compile + * import scala.jdk.StreamConverters.* * - * scala> val intAcc = (1 to 10000).asJavaParStream.filter(isPrime).toScala(scala.jdk.Accumulator) - * intAcc: scala.jdk.IntAccumulator = IntAccumulator(1, 3, 5, 7, 11, 13, 17, 19, ... + * def isPrime(n: Int): Boolean = n > 1 && !(2 +: (3 to Math.sqrt(n).toInt by 2)).exists(n % _ == 0) * - * scala> val stringAcc = (1 to 100).asJavaParStream.mapToObj("<>" * _).toScala(Accumulator) - * stringAcc: scala.jdk.AnyAccumulator[String] = AnyAccumulator(<>, <><>, <><><>, ... + * val intAcc = (1 to 10000).asJavaParStream.filter(isPrime).toScala(scala.jdk.Accumulator) + * // intAcc: scala.jdk.IntAccumulator = IntAccumulator(1, 3, 5, 7, 11, 13, 17, 19, ... + * val stringAcc = (1 to 100).asJavaParStream.mapToObj("<>" * _).toScala(Accumulator) + * // stringAcc: scala.jdk.AnyAccumulator[String] = AnyAccumulator(<>, <><>, <><><>, ... * ``` * * There are two possibilities to process elements of a primitive Accumulator without boxing: @@ -70,6 +67,8 @@ import scala.language.implicitConversions * The [[Accumulator]] class is a base class to share code between [[AnyAccumulator]] (for * reference types) and the manual specializations [[IntAccumulator]], [[LongAccumulator]] and * [[DoubleAccumulator]]. + * + * @tparam CC the covariant higher-kinded type constructor for the specific accumulator collection, constrained to `mutable.Seq` */ abstract class Accumulator[@specialized(Double, Int, Long) A, +CC[X] <: mutable.Seq[X], +C <: mutable.Seq[A]] extends mutable.Seq[A] @@ -97,6 +96,8 @@ abstract class Accumulator[@specialized(Double, Int, Long) A, +CC[X] <: mutable. * double's 52 fraction bits (so any collection that fits in memory). * - [[IntAccumulator]] uses the last two slots in every array to store the cumulative length, every array is * allocated with 1 extra slot. So `history(0)` has 17 slots of which the first 15 store elements. + * + * @param i the index into the `history` array, where `0 <= i < `hIndex`` */ private[jdk] def cumulative(i: Int): Long @@ -151,18 +152,15 @@ abstract class Accumulator[@specialized(Double, Int, Long) A, +CC[X] <: mutable. * the implicit [[Accumulator.AccumulatorFactoryShape]] instance is used to build a specialized * Accumulator according to the element type: * - * ``` - * scala> val intAcc = Accumulator(1,2,3) - * intAcc: scala.collection.convert.IntAccumulator = IntAccumulator(1, 2, 3) - * - * scala> val anyAccc = Accumulator("K") - * anyAccc: scala.collection.convert.AnyAccumulator[String] = AnyAccumulator(K) - * - * scala> val intAcc2 = List(1,2,3).to(Accumulator) - * intAcc2: scala.jdk.IntAccumulator = IntAccumulator(1, 2, 3) - * - * scala> val anyAcc2 = List("K").to(Accumulator) - * anyAcc2: scala.jdk.AnyAccumulator[String] = AnyAccumulator(K) + * ```scala sc:compile + * val intAcc = Accumulator(1, 2, 3) + * // intAcc: scala.collection.convert.IntAccumulator = IntAccumulator(1, 2, 3) + * val anyAcc = Accumulator("K") + * // anyAccc: scala.collection.convert.AnyAccumulator[String] = AnyAccumulator(K) + * val intAcc2 = List(1, 2, 3).to(Accumulator) + * // intAcc2: scala.jdk.IntAccumulator = IntAccumulator(1, 2, 3) + * val anyAcc2 = List("K").to(Accumulator) + * // anyAcc2: scala.jdk.AnyAccumulator[String] = AnyAccumulator(K) * ``` * * @define coll Accumulator @@ -176,21 +174,27 @@ object Accumulator { * @tparam A the type of the ${coll}’s elements * @tparam C the (inferred) specific type of the $coll * @param source Source collection + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return a new $coll with the elements of `source` */ def from[A, C](source: IterableOnce[A])(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = source.iterator.to(canAccumulate.factory) /** An empty collection. + * * @tparam A the type of the ${coll}'s elements + * @tparam C the (inferred) specific type of the $coll + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build */ def empty[A, C](implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = canAccumulate.empty /** Creates an $coll with the specified elements. + * * @tparam A the type of the ${coll}'s elements * @tparam C the (inferred) specific type of the $coll * @param elems the elements of the created $coll + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return a new $coll with elements `elems` */ def apply[A, C](elems: A*)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = @@ -198,9 +202,12 @@ object Accumulator { /** Produces an $coll containing repeated applications of a function to a start value. * + * @tparam A the element type of the $coll + * @tparam C the (inferred) specific type of the $coll * @param start the start value of the $coll * @param len the number of elements contained in the $coll * @param f the function that's repeatedly applied + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return an $coll with `len` values in the sequence `start, f(start), f(f(start)), ...` */ def iterate[A, C](start: A, len: Int)(f: A => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = @@ -222,17 +229,24 @@ object Accumulator { /** Produces an $coll containing a sequence of increasing of integers. * + * @tparam A the element type of the $coll, which must have an implicit `Integral` instance + * @tparam C the (inferred) specific type of the $coll * @param start the first element of the $coll * @param end the end value of the $coll (the first value NOT contained) + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return an $coll with values `start, start + 1, ..., end - 1` */ def range[A: Integral, C](start: A, end: A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = from(collection.immutable.NumericRange(start, end, implicitly[Integral[A]].one)) /** Produces an $coll containing equally spaced values in some integer interval. + * + * @tparam A the element type of the $coll, which must have an implicit `Integral` instance + * @tparam C the (inferred) specific type of the $coll * @param start the start value of the $coll * @param end the end value of the $coll (the first value NOT contained) * @param step the difference between successive elements of the $coll (must be positive or negative) + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return an $coll with values `start, start + step, ...` up to, but excluding `end` */ def range[A: Integral, C](start: A, end: A, step: A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = @@ -241,70 +255,98 @@ object Accumulator { /** * @tparam A the type of the ${coll}’s elements * @tparam C the specific type of the $coll + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return A builder for $Coll objects. */ def newBuilder[A, C](implicit canAccumulate: AccumulatorFactoryShape[A, C]): collection.mutable.Builder[A, C] = canAccumulate.factory.newBuilder /** Produces an $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the $coll + * @tparam C the (inferred) specific type of the $coll * @param n the number of elements contained in the $coll. * @param elem the element computation + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return An $coll that contains the results of `n` evaluations of `elem`. */ def fill[A, C](n: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = from(new collection.View.Fill(n)(elem)) /** Produces a two-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the innermost $coll + * @tparam C the (inferred) specific type of the innermost $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param elem the element computation + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return An $coll that contains the results of `n1 x n2` evaluations of `elem`. */ - def fill[A, C](n1: Int, n2: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[C] = + def fill[A, C](n1: Int, n2: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[C] = fill(n1)(fill(n2)(elem)(using canAccumulate))(using AccumulatorFactoryShape.anyAccumulatorFactoryShape[C]) /** Produces a three-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the innermost $coll + * @tparam C the (inferred) specific type of the innermost $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension * @param elem the element computation + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return An $coll that contains the results of `n1 x n2 x n3` evaluations of `elem`. */ def fill[A, C](n1: Int, n2: Int, n3: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[AnyAccumulator[C]] = fill(n1)(fill(n2, n3)(elem)(using canAccumulate))(using AccumulatorFactoryShape.anyAccumulatorFactoryShape[AnyAccumulator[C]]) /** Produces a four-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the innermost $coll + * @tparam C the (inferred) specific type of the innermost $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension * @param n4 the number of elements in the 4th dimension * @param elem the element computation + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return An $coll that contains the results of `n1 x n2 x n3 x n4` evaluations of `elem`. */ def fill[A, C](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[AnyAccumulator[AnyAccumulator[C]]] = fill(n1)(fill(n2, n3, n4)(elem)(using canAccumulate))(using AccumulatorFactoryShape.anyAccumulatorFactoryShape[AnyAccumulator[AnyAccumulator[C]]]) /** Produces a five-dimensional $coll containing the results of some element computation a number of times. + * + * @tparam A the element type of the innermost $coll + * @tparam C the (inferred) specific type of the innermost $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension * @param n4 the number of elements in the 4th dimension * @param n5 the number of elements in the 5th dimension * @param elem the element computation + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return An $coll that contains the results of `n1 x n2 x n3 x n4 x n5` evaluations of `elem`. */ def fill[A, C](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): AnyAccumulator[AnyAccumulator[AnyAccumulator[AnyAccumulator[C]]]] = fill(n1)(fill(n2, n3, n4, n5)(elem)(using canAccumulate))(using AccumulatorFactoryShape.anyAccumulatorFactoryShape[AnyAccumulator[AnyAccumulator[AnyAccumulator[C]]]]) /** Produces an $coll containing values of a given function over a range of integer values starting from 0. + * + * @tparam A the element type of the $coll + * @tparam C the (inferred) specific type of the $coll * @param n The number of elements in the $coll * @param f The function computing element values + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return An $coll consisting of elements `f(0), ..., f(n -1)` */ def tabulate[A, C](n: Int)(f: Int => A)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = from(new collection.View.Tabulate(n)(f)) /** Produces a two-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the innermost $coll + * @tparam C the (inferred) specific type of the innermost $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param f The function computing element values @@ -315,6 +357,9 @@ object Accumulator { tabulate(n1)(i1 => tabulate(n2)(f(i1, _))(using canAccumulate))(using AccumulatorFactoryShape.anyAccumulatorFactoryShape[C]) /** Produces a three-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the innermost $coll + * @tparam C the (inferred) specific type of the innermost $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -326,6 +371,9 @@ object Accumulator { tabulate(n1)(i1 => tabulate(n2, n3)(f(i1, _, _))(using canAccumulate))(using AccumulatorFactoryShape.anyAccumulatorFactoryShape[AnyAccumulator[C]]) /** Produces a four-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the innermost $coll + * @tparam C the (inferred) specific type of the innermost $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -338,6 +386,9 @@ object Accumulator { tabulate(n1)(i1 => tabulate(n2, n3, n4)(f(i1, _, _, _))(using canAccumulate))(using AccumulatorFactoryShape.anyAccumulatorFactoryShape[AnyAccumulator[AnyAccumulator[C]]]) /** Produces a five-dimensional $coll containing values of a given function over ranges of integer values starting from 0. + * + * @tparam A the element type of the innermost $coll + * @tparam C the (inferred) specific type of the innermost $coll * @param n1 the number of elements in the 1st dimension * @param n2 the number of elements in the 2nd dimension * @param n3 the number of elements in the 3rd dimension @@ -352,10 +403,13 @@ object Accumulator { /** Concatenates all argument collections into a single $coll. * + * @tparam A the element type of the $coll + * @tparam C the (inferred) specific type of the $coll * @param xss the collections that are to be concatenated. + * @param canAccumulate the implicit factory shape that determines the specific accumulator type to build * @return the concatenation of all the collections. */ - def concat[A, C](xss: Iterable[A]*)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = + def concat[A, C](xss: Iterable[A]*)(implicit canAccumulate: AccumulatorFactoryShape[A, C]): C = if (xss.isEmpty) canAccumulate.empty else { val b = canAccumulate.factory.newBuilder @@ -365,6 +419,9 @@ object Accumulator { /** An implicit `AccumulatorFactoryShape` is used in Accumulator factory method to return * specialized variants according to the element type. + * + * @tparam A the element type to be accumulated + * @tparam C the specific accumulator type produced (e.g., `IntAccumulator`, `DoubleAccumulator`, or `AnyAccumulator[A]`) */ sealed trait AccumulatorFactoryShape[A, C] { def factory: collection.Factory[A, C] diff --git a/library/src/scala/jdk/AnyAccumulator.scala b/library/src/scala/jdk/AnyAccumulator.scala index e587e26fe19d..7999065a35f3 100644 --- a/library/src/scala/jdk/AnyAccumulator.scala +++ b/library/src/scala/jdk/AnyAccumulator.scala @@ -21,7 +21,10 @@ import scala.collection.Stepper.EfficientSplit import scala.collection.{AnyStepper, Factory, IterableFactoryDefaults, SeqFactory, Stepper, StepperShape, mutable} import scala.reflect.ClassTag -/** An `Accumulator` for arbitrary element types, see [[Accumulator]]. */ +/** An `Accumulator` for arbitrary element types, see [[Accumulator]]. + * + * @tparam A the element type stored in this accumulator + */ final class AnyAccumulator[A] extends Accumulator[A, AnyAccumulator, AnyAccumulator[A]] with mutable.SeqOps[A, AnyAccumulator, AnyAccumulator[A]] @@ -60,7 +63,10 @@ final class AnyAccumulator[A] } } - /** Appends an element to this `AnyAccumulator`. */ + /** Appends an element to this `AnyAccumulator`. + * + * @param a the element to append + */ def addOne(a: A): this.type = { totalSize += 1 if (index >= current.length) expand() @@ -72,7 +78,11 @@ final class AnyAccumulator[A] /** Result collection consisting of all elements appended so far. */ override def result(): AnyAccumulator[A] = this - /** Removes all elements from `that` and appends them to this `AnyAccumulator`. */ + /** Removes all elements from `that` and appends them to this `AnyAccumulator`. + * + * @tparam A1 the element type of the source accumulator, must be a subtype of `A` + * @param that the accumulator to drain; it will be empty after this operation + */ def drain[A1 <: A](that: AnyAccumulator[A1]): Unit = { var h = 0 var prev = 0L @@ -127,7 +137,10 @@ final class AnyAccumulator[A] cumul = AnyAccumulator.emptyLongArray } - /** Retrieves the `ix`th element. */ + /** Retrieves the `ix`th element. + * + * @param ix the zero-based index of the element to retrieve, as a `Long` + */ def apply(ix: Long): A = { if (totalSize - ix <= index || hIndex == 0) current((ix - (totalSize - index)).toInt).asInstanceOf[A] else { @@ -136,7 +149,10 @@ final class AnyAccumulator[A] } } - /** Retrieves the `ix`th element, using an `Int` index. */ + /** Retrieves the `ix`th element, using an `Int` index. + * + * @param i the zero-based index of the element to retrieve + */ def apply(i: Int): A = apply(i.toLong) def update(idx: Long, elem: A): Unit = { @@ -160,7 +176,10 @@ final class AnyAccumulator[A] r } - /** Copies the elements in this `AnyAccumulator` into an `Array`. */ + /** Copies the elements in this `AnyAccumulator` into an `Array`. + * + * @tparam B the element type of the resulting array, must be a supertype of `A` + */ override def toArray[B >: A : ClassTag]: Array[B] = { if (totalSize > Int.MaxValue) throw new IllegalArgumentException("Too many elements accumulated for an array: "+totalSize.toString) val a = new Array[B](totalSize.toInt) @@ -211,6 +230,9 @@ final class AnyAccumulator[A] /** Copies the elements in this `AnyAccumulator` to a specified collection. Example use: * `acc.to(Vector)`. + * + * @tparam C1 the type of the resulting collection + * @param factory the factory used to build the target collection */ override def to[C1](factory: Factory[A, C1]): C1 = { if (totalSize > Int.MaxValue) throw new IllegalArgumentException("Too many elements accumulated for a Scala collection: "+totalSize.toString) @@ -229,10 +251,16 @@ object AnyAccumulator extends collection.SeqFactory[AnyAccumulator] { import java.util.{function => jf} - /** A `Supplier` of `AnyAccumulator`s, suitable for use with `java.util.stream.Stream`'s `collect` method. */ + /** A `Supplier` of `AnyAccumulator`s, suitable for use with `java.util.stream.Stream`'s `collect` method. + * + * @tparam A the element type of the accumulator to supply + */ def supplier[A]: jf.Supplier[AnyAccumulator[A]] = () => new AnyAccumulator[A] - /** A `BiConsumer` that adds an element to an `AnyAccumulator`, suitable for use with `java.util.stream.Stream`'s `collect` method. */ + /** A `BiConsumer` that adds an element to an `AnyAccumulator`, suitable for use with `java.util.stream.Stream`'s `collect` method. + * + * @tparam A the element type to add to the accumulator + */ def adder[A]: jf.BiConsumer[AnyAccumulator[A], A] = (ac: AnyAccumulator[A], a: A) => ac addOne a /** A `BiConsumer` that adds an `Int` to an `AnyAccumulator`, suitable for use with `java.util.stream.Stream`'s `collect` method. */ @@ -244,7 +272,10 @@ object AnyAccumulator extends collection.SeqFactory[AnyAccumulator] { /** A `BiConsumer` that adds a `Double` to an `AnyAccumulator`, suitable for use with `java.util.stream.Stream`'s `collect` method. */ def unboxedDoubleAdder: jf.ObjDoubleConsumer[AnyAccumulator[Double]] = (ac: AnyAccumulator[Double], a: Double) => ac addOne a - /** A `BiConsumer` that merges `AnyAccumulator`s, suitable for use with `java.util.stream.Stream`'s `collect` method. */ + /** A `BiConsumer` that merges `AnyAccumulator`s, suitable for use with `java.util.stream.Stream`'s `collect` method. + * + * @tparam A the element type of the accumulators to merge + */ def merger[A]: jf.BiConsumer[AnyAccumulator[A], AnyAccumulator[A]] = (a1: AnyAccumulator[A], a2: AnyAccumulator[A]) => a1 drain a2 def from[A](source: IterableOnce[A]): AnyAccumulator[A] = (source: @unchecked) match { diff --git a/library/src/scala/jdk/CollectionConverters.scala b/library/src/scala/jdk/CollectionConverters.scala index 2e0df23e9cc2..cade2f154b99 100644 --- a/library/src/scala/jdk/CollectionConverters.scala +++ b/library/src/scala/jdk/CollectionConverters.scala @@ -23,27 +23,20 @@ import scala.collection.convert.{AsJavaExtensions, AsScalaExtensions} * Note: to create [[java.util.stream.Stream Java Streams]] that operate on Scala collections * (sequentially or in parallel), use [[StreamConverters]]. * - * ``` - * import scala.jdk.CollectionConverters._ - * val s: java.util.Set[String] = Set("one", "two").asJava + * ```scala sc:compile + * import scala.jdk.CollectionConverters.* + * val s: java.util.Set[String] = Set("one", "two").asJava * ``` * * The conversions return adapters for the corresponding API, i.e., the collections are wrapped, * not copied. Changes to the original collection are reflected in the view, and vice versa: * - * ``` - * scala> import scala.jdk.CollectionConverters._ - * - * scala> val s = collection.mutable.Set("one") - * s: scala.collection.mutable.Set[String] = HashSet(one) - * - * scala> val js = s.asJava - * js: java.util.Set[String] = [one] - * - * scala> js.add("two") - * - * scala> s - * res2: scala.collection.mutable.Set[String] = HashSet(two, one) + * ```scala sc:compile + * import scala.jdk.CollectionConverters.* + * val s = collection.mutable.Set("one") + * val js = s.asJava + * js.add("two") + * assert(s == collection.mutable.Set("one", "two")) * ``` * * The following conversions are supported via `asScala` and `asJava`: @@ -84,13 +77,13 @@ import scala.collection.convert.{AsJavaExtensions, AsScalaExtensions} * In all cases, converting from a source type to a target type and back * again will return the original source object. For example: * - * ``` - * import scala.jdk.CollectionConverters._ + * ```scala sc:compile + * import scala.jdk.CollectionConverters.* * - * val source = new scala.collection.mutable.ListBuffer[Int] - * val target: java.util.List[Int] = source.asJava - * val other: scala.collection.mutable.Buffer[Int] = target.asScala - * assert(source eq other) + * val source = new scala.collection.mutable.ListBuffer[Int] + * val target: java.util.List[Int] = source.asJava + * val other: scala.collection.mutable.Buffer[Int] = target.asScala + * assert(source eq other) * ``` */ object CollectionConverters extends AsJavaExtensions with AsScalaExtensions diff --git a/library/src/scala/jdk/DoubleAccumulator.scala b/library/src/scala/jdk/DoubleAccumulator.scala index 7b374fffbf6e..27d10d8edb99 100644 --- a/library/src/scala/jdk/DoubleAccumulator.scala +++ b/library/src/scala/jdk/DoubleAccumulator.scala @@ -62,7 +62,10 @@ final class DoubleAccumulator else history = java.util.Arrays.copyOf(history, history.length << 1) } - /** Appends an element to this `DoubleAccumulator`. */ + /** Appends an element to this `DoubleAccumulator`. + * + * @param a the `Double` value to append + */ def addOne(a: Double): this.type = { totalSize += 1 if (index+1 >= current.length) expand() @@ -74,7 +77,10 @@ final class DoubleAccumulator /** Result collection consisting of all elements appended so far. */ override def result(): DoubleAccumulator = this - /** Removes all elements from `that` and appends them to this `DoubleAccumulator`. */ + /** Removes all elements from `that` and appends them to this `DoubleAccumulator`. + * + * @param that the `DoubleAccumulator` to drain elements from; it will be empty after this operation + */ def drain(that: DoubleAccumulator): Unit = { var h = 0 var prev = 0L @@ -137,7 +143,10 @@ final class DoubleAccumulator history = DoubleAccumulator.emptyDoubleArrayArray } - /** Retrieves the `ix`th element. */ + /** Retrieves the `ix`th element. + * + * @param ix the zero-based index of the element to retrieve + */ def apply(ix: Long): Double = { if (totalSize - ix <= index || hIndex == 0) current((ix - (totalSize - index)).toInt) else { @@ -146,7 +155,10 @@ final class DoubleAccumulator } } - /** Retrieves the `ix`th element, using an `Int` index. */ + /** Retrieves the `ix`th element, using an `Int` index. + * + * @param i the zero-based index of the element to retrieve (converted to `Long` internally) + */ def apply(i: Int): Double = apply(i.toLong) def update(idx: Long, elem: Double): Unit = { @@ -283,6 +295,9 @@ final class DoubleAccumulator /** Copies the elements in this `DoubleAccumulator` to a specified collection. * Note that the target collection is not specialized. * Usage example: `acc.to(Vector)` + * + * @tparam C1 the result type of the target collection (e.g., `Vector[Double]`) + * @param factory the factory for creating the target collection from elements */ override def to[C1](factory: Factory[Double, C1]): C1 = { if (totalSize > Int.MaxValue) throw new IllegalArgumentException("Too many elements accumulated for a Scala collection: "+totalSize.toString) diff --git a/library/src/scala/jdk/FunctionConverters.scala b/library/src/scala/jdk/FunctionConverters.scala index f4f238234809..fc4389c2000f 100644 --- a/library/src/scala/jdk/FunctionConverters.scala +++ b/library/src/scala/jdk/FunctionConverters.scala @@ -25,30 +25,30 @@ import scala.language.`2.13` * Using the `.asJava` extension method on a Scala function produces the most specific possible * Java function type: * - * ``` - * scala> import scala.jdk.FunctionConverters._ - * scala> val f = (x: Int) => x + 1 - * - * scala> val jf1 = f.asJava - * jf1: java.util.function.IntUnaryOperator = ... + * ```scala sc:compile + * import scala.jdk.FunctionConverters.* + * val f = (x: Int) => x + 1 + * val jf1 = f.asJava * ``` * * More generic Java function types can be created using the corresponding `asJavaXYZ` extension * method: * - * ``` - * scala> val jf2 = f.asJavaFunction - * jf2: java.util.function.Function[Int,Int] = ... - * - * scala> val jf3 = f.asJavaUnaryOperator - * jf3: java.util.function.UnaryOperator[Int] = ... + * ```scala sc:compile + * import scala.jdk.FunctionConverters.* + * val f = (x: Int) => x + 1 + * val jf2 = f.asJavaFunction + * val jf3 = f.asJavaUnaryOperator * ``` * * Converting a Java function to Scala is done using the `asScala` extension method: * - * ``` - * scala> List(1,2,3).map(jf2.asScala) - * res1: List[Int] = List(2, 3, 4) + * ```scala sc:compile + * import scala.jdk.FunctionConverters.* + * val f = (x: Int) => x + 1 + * val jf2 = f.asJavaFunction + * val mapped = List(1, 2, 3).map(jf2.asScala) + * assert(mapped == List(2, 3, 4)) * ``` */ object FunctionConverters extends Priority0FunctionExtensions diff --git a/library/src/scala/jdk/IntAccumulator.scala b/library/src/scala/jdk/IntAccumulator.scala index 0697fb4081e0..8f47abbe0577 100644 --- a/library/src/scala/jdk/IntAccumulator.scala +++ b/library/src/scala/jdk/IntAccumulator.scala @@ -65,7 +65,10 @@ final class IntAccumulator else history = java.util.Arrays.copyOf(history, history.length << 1) } - /** Appends an element to this `IntAccumulator`. */ + /** Appends an element to this `IntAccumulator`. + * + * @param a the `Int` value to append + */ def addOne(a: Int): this.type = { totalSize += 1 if (index+2 >= current.length) expand() @@ -77,7 +80,10 @@ final class IntAccumulator /** Result collection consisting of all elements appended so far. */ override def result(): IntAccumulator = this - /** Removes all elements from `that` and appends them to this `IntAccumulator`. */ + /** Removes all elements from `that` and appends them to this `IntAccumulator`. + * + * @param that the `IntAccumulator` to drain elements from; it will be empty after this operation + */ def drain(that: IntAccumulator): Unit = { var h = 0 var prev = 0L @@ -143,7 +149,10 @@ final class IntAccumulator history = IntAccumulator.emptyIntArrayArray } - /** Retrieves the `ix`th element. */ + /** Retrieves the `ix`th element. + * + * @param ix the zero-based index of the element to retrieve, as a `Long` + */ def apply(ix: Long): Int = { if (totalSize - ix <= index || hIndex == 0) current((ix - (totalSize - index)).toInt) else { @@ -152,7 +161,10 @@ final class IntAccumulator } } - /** Retrieves the `ix`th element, using an `Int` index. */ + /** Retrieves the `ix`th element, using an `Int` index. + * + * @param i the zero-based index of the element to retrieve + */ def apply(i: Int): Int = apply(i.toLong) def update(idx: Long, elem: Int): Unit = { @@ -289,6 +301,9 @@ final class IntAccumulator /** Copies the elements in this `IntAccumulator` to a specified collection. * Note that the target collection is not specialized. * Usage example: `acc.to(Vector)` + * + * @tparam C1 the type of the target collection + * @param factory the factory for building the target collection from `Int` elements */ override def to[C1](factory: Factory[Int, C1]): C1 = { if (totalSize > Int.MaxValue) throw new IllegalArgumentException("Too many elements accumulated for a Scala collection: "+totalSize.toString) diff --git a/library/src/scala/jdk/LongAccumulator.scala b/library/src/scala/jdk/LongAccumulator.scala index 1369ace75bc3..d73196138a59 100644 --- a/library/src/scala/jdk/LongAccumulator.scala +++ b/library/src/scala/jdk/LongAccumulator.scala @@ -63,7 +63,10 @@ final class LongAccumulator else history = java.util.Arrays.copyOf(history, history.length << 1) } - /** Appends an element to this `LongAccumulator`. */ + /** Appends an element to this `LongAccumulator`. + * + * @param a the `Long` value to append + */ def addOne(a: Long): this.type = { totalSize += 1 if (index+1 >= current.length) expand() @@ -75,7 +78,10 @@ final class LongAccumulator /** Result collection consisting of all elements appended so far. */ override def result(): LongAccumulator = this - /** Removes all elements from `that` and appends them to this `LongAccumulator`. */ + /** Removes all elements from `that` and appends them to this `LongAccumulator`. + * + * @param that the `LongAccumulator` to drain elements from; it will be empty after this operation + */ def drain(that: LongAccumulator): Unit = { var h = 0 var prev = 0L @@ -138,7 +144,10 @@ final class LongAccumulator history = LongAccumulator.emptyLongArrayArray } - /** Retrieves the `ix`th element. */ + /** Retrieves the `ix`th element. + * + * @param ix the zero-based index of the element to retrieve + */ def apply(ix: Long): Long = { if (totalSize - ix <= index || hIndex == 0) current((ix - (totalSize - index)).toInt) else { @@ -147,7 +156,10 @@ final class LongAccumulator } } - /** Retrieves the `ix`th element, using an `Int` index. */ + /** Retrieves the `ix`th element, using an `Int` index. + * + * @param i the zero-based index of the element to retrieve + */ def apply(i: Int): Long = apply(i.toLong) def update(idx: Long, elem: Long): Unit = { @@ -284,6 +296,9 @@ final class LongAccumulator /** Copies the elements in this `LongAccumulator` to a specified collection. * Note that the target collection is not specialized. * Usage example: `acc.to(Vector)` + * + * @tparam C1 the result type of the target collection + * @param factory the factory for the target collection type */ override def to[C1](factory: Factory[Long, C1]): C1 = { if (totalSize > Int.MaxValue) throw new IllegalArgumentException("Too many elements accumulated for a Scala collection: "+totalSize.toString) diff --git a/library/src/scala/jdk/OptionConverters.scala b/library/src/scala/jdk/OptionConverters.scala index 46827f368093..30b03c700444 100644 --- a/library/src/scala/jdk/OptionConverters.scala +++ b/library/src/scala/jdk/OptionConverters.scala @@ -31,21 +31,25 @@ import java.util.{Optional, OptionalDouble, OptionalInt, OptionalLong} * * Example usage: * - * ``` - * import scala.jdk.OptionConverters._ - * val a = Option("example").toJava // Creates java.util.Optional[String] containing "example" - * val b = (None: Option[String]).toJava // Creates an empty java.util.Optional[String] - * val c = a.toScala // Back to Option("example") - * val d = b.toScala // Back to None typed as Option[String] - * val e = Option(2.7).toJava // java.util.Optional[Double] containing boxed 2.7 - * val f = Option(2.7).toJavaPrimitive // java.util.OptionalDouble containing 2.7 (not boxed) - * val g = f.toScala // Back to Option(2.7) - * val h = f.toJavaGeneric // Same as e - * val i = e.toJavaPrimitive // Same as f + * ```scala sc:compile + * import scala.jdk.OptionConverters.* + * val a = Option("example").toJava // Creates java.util.Optional[String] containing "example" + * val b = (None: Option[String]).toJava // Creates an empty java.util.Optional[String] + * val c = a.toScala // Back to Option("example") + * val d = b.toScala // Back to None typed as Option[String] + * val e = Option(2.7).toJava // java.util.Optional[Double] containing boxed 2.7 + * val f = Option(2.7).toJavaPrimitive // java.util.OptionalDouble containing 2.7 (not boxed) + * val g = f.toScala // Back to Option(2.7) + * val h = f.toJavaGeneric // Same as e + * val i = e.toJavaPrimitive // Same as f * ``` */ object OptionConverters { - /** Provides conversions from Java `Optional` to Scala `Option` and specialized `Optional` types. */ + /** Provides conversions from Java `Optional` to Scala `Option` and specialized `Optional` types. + * + * @tparam A the type of the value contained in the `Optional` + * @param o the Java `Optional` to convert + */ implicit class RichOptional[A](private val o: java.util.Optional[A]) extends AnyVal { /** Converts a Java `Optional` to a Scala `Option`. */ def toScala: Option[A] = if (o.isPresent) Some(o.get) else None @@ -54,11 +58,19 @@ object OptionConverters { @deprecated("Use `toScala` instead", "2.13.0") def asScala: Option[A] = if (o.isPresent) Some(o.get) else None - /** Converts a generic Java `Optional` to a specialized variant. */ + /** Converts a generic Java `Optional` to a specialized variant. + * + * @tparam O the target specialized Java `Optional` type, inferred from the available `OptionShape` instance (e.g., `OptionalInt`, `OptionalDouble`, `OptionalLong`) + * @param shape implicit evidence that defines how to convert between `Optional[A]` and the specialized type `O` + */ def toJavaPrimitive[O](implicit shape: OptionShape[A, O]): O = shape.fromJava(o) } - /** Provides conversions from Scala `Option` to Java `Optional` types. */ + /** Provides conversions from Scala `Option` to Java `Optional` types. + * + * @tparam A the type of the value contained in the `Option` + * @param o the Scala `Option` to convert + */ implicit class RichOption[A](private val o: Option[A]) extends AnyVal { /** Converts a Scala `Option` to a generic Java `Optional`. */ def toJava: Optional[A] = o match { case Some(a) => Optional.ofNullable(a); case _ => Optional.empty[A] } @@ -67,11 +79,18 @@ object OptionConverters { @deprecated("Use `toJava` instead", "2.13.0") def asJava: Optional[A] = o match { case Some(a) => Optional.ofNullable(a); case _ => Optional.empty[A] } - /** Converts a Scala `Option` to a specialized Java `Optional`. */ + /** Converts a Scala `Option` to a specialized Java `Optional`. + * + * @tparam O the specialized Java `Optional` type (e.g., `OptionalInt`, `OptionalDouble`, `OptionalLong`) + * @param shape implicit evidence that defines how to convert between `Option[A]` and the specialized type `O` + */ def toJavaPrimitive[O](implicit shape: OptionShape[A, O]): O = shape.fromScala(o) } - /** Provides conversions from `OptionalDouble` to Scala `Option` and the generic `Optional`. */ + /** Provides conversions from `OptionalDouble` to Scala `Option` and the generic `Optional`. + * + * @param o the Java `OptionalDouble` to convert + */ implicit class RichOptionalDouble(private val o: OptionalDouble) extends AnyVal { /** Converts a Java `OptionalDouble` to a Scala `Option`. */ def toScala: Option[Double] = if (o.isPresent) Some(o.getAsDouble) else None @@ -84,7 +103,10 @@ object OptionConverters { def toJavaGeneric: Optional[Double] = if (o.isPresent) Optional.of(o.getAsDouble) else Optional.empty[Double] } - /** Provides conversions from `OptionalInt` to Scala `Option` and the generic `Optional`. */ + /** Provides conversions from `OptionalInt` to Scala `Option` and the generic `Optional`. + * + * @param o the Java `OptionalInt` to convert + */ implicit class RichOptionalInt(private val o: OptionalInt) extends AnyVal { /** Converts a Java `OptionalInt` to a Scala `Option`. */ def toScala: Option[Int] = if (o.isPresent) Some(o.getAsInt) else None @@ -97,7 +119,10 @@ object OptionConverters { def toJavaGeneric: Optional[Int] = if (o.isPresent) Optional.of(o.getAsInt) else Optional.empty[Int] } - /** Provides conversions from `OptionalLong` to Scala `Option` and the generic `Optional`. */ + /** Provides conversions from `OptionalLong` to Scala `Option` and the generic `Optional`. + * + * @param o the Java `OptionalLong` to convert + */ implicit class RichOptionalLong(private val o: OptionalLong) extends AnyVal { /** Converts a Java `OptionalLong` to a Scala `Option`. */ def toScala: Option[Long] = if (o.isPresent) Some(o.getAsLong) else None diff --git a/library/src/scala/jdk/OptionShape.scala b/library/src/scala/jdk/OptionShape.scala index 840ff6ecba37..d859b9065838 100644 --- a/library/src/scala/jdk/OptionShape.scala +++ b/library/src/scala/jdk/OptionShape.scala @@ -26,9 +26,15 @@ import scala.annotation.implicitNotFound */ @implicitNotFound("No specialized Optional type exists for elements of type ${A}") sealed abstract class OptionShape[A, O] { - /** Converts from `Optional` to the specialized variant `O`. */ + /** Converts from `Optional` to the specialized variant `O`. + * + * @param o the generic `Optional` to convert to the specialized variant + */ def fromJava(o: Optional[A]): O - /** Converts from `Option` to the specialized variant `O`. */ + /** Converts from `Option` to the specialized variant `O`. + * + * @param o the Scala `Option` to convert to the specialized Java variant + */ def fromScala(o: Option[A]): O } diff --git a/library/src/scala/jdk/StreamConverters.scala b/library/src/scala/jdk/StreamConverters.scala index 634d0d8bb7cb..7e816716d8b6 100644 --- a/library/src/scala/jdk/StreamConverters.scala +++ b/library/src/scala/jdk/StreamConverters.scala @@ -25,25 +25,23 @@ import scala.collection.convert.StreamExtensions * * The methods `asJavaSeqStream` and `asJavaParStream` convert a collection to a Java Stream: * - * ``` - * scala> import scala.jdk.StreamConverters._ - * - * scala> val s = (1 to 10).toList.asJavaSeqStream - * s: java.util.stream.IntStream = java.util.stream.IntPipeline\$Head@7b1e5e55 + * ```scala sc:compile + * import scala.jdk.StreamConverters.* * - * scala> s.map(_ * 2).filter(_ > 5).toScala(List) - * res1: List[Int] = List(6, 8, 10, 12, 14, 16, 18, 20) + * val s = (1 to 10).toList.asJavaSeqStream + * // s: java.util.stream.IntStream = java.util.stream.IntPipeline\$Head@7b1e5e55 + * val doubled = s.map(_ * 2).filter(_ > 5).toScala(List) + * assert(doubled == List(6, 8, 10, 12, 14, 16, 18, 20)) * ``` * * Note: using parallel streams in the Scala REPL causes deadlocks, see * [[https://github.com/scala/bug/issues/9076]]. As a workaround, use `scala -Yrepl-class-based`. * - * ``` - * scala> def isPrime(n: Int): Boolean = !(2 +: (3 to Math.sqrt(n).toInt by 2) exists (n % _ == 0)) - * isPrime: (n: Int)Boolean - * - * scala> (10000 to 1000000).asJavaParStream.filter(isPrime).toScala(Vector) - * res6: scala.collection.immutable.Vector[Int] = Vector(10007, 10009, 10037, 10039, ... + * ```scala sc:compile + * import scala.jdk.StreamConverters.* + * def isPrime(n: Int): Boolean = n > 1 && !(2 +: (3 to Math.sqrt(n).toInt by 2)).exists(n % _ == 0) + * val primes = (10000 to 10100).asJavaParStream.filter(isPrime).toScala(Vector) + * // primes: scala.collection.immutable.Vector[Int] = Vector(10007, 10009, 10037, 10039, ... * ``` * * A Java [[Stream]] provides operations on a sequence of elements. Streams are created from diff --git a/library/src/scala/jdk/javaapi/DurationConverters.scala b/library/src/scala/jdk/javaapi/DurationConverters.scala index 853f23c83e3c..a01cbae34c7a 100644 --- a/library/src/scala/jdk/javaapi/DurationConverters.scala +++ b/library/src/scala/jdk/javaapi/DurationConverters.scala @@ -29,6 +29,8 @@ object DurationConverters { * zero, the returned duration will have a time unit of seconds. If there is a nanoseconds part, * the Scala duration will have a time unit of nanoseconds. * + * @param duration the Java `java.time.Duration` to convert + * @return a Scala `FiniteDuration` with the same length, using seconds or nanoseconds as the time unit * @throws IllegalArgumentException If the given Java Duration is out of bounds of what can be * expressed by [[scala.concurrent.duration.FiniteDuration]]. */ @@ -58,6 +60,9 @@ object DurationConverters { /** Converts a Scala `FiniteDuration` to a Java duration. Note that the Scala duration keeps the * time unit it was created with, while a Java duration always is a pair of seconds and nanos, * so the unit it lost. + * + * @param duration the Scala `FiniteDuration` to convert + * @return a Java `java.time.Duration` representing the same length of time */ def toJava(duration: FiniteDuration): JDuration = { if (duration.length == 0) JDuration.ZERO diff --git a/library/src/scala/jdk/javaapi/FunctionConverters.scala b/library/src/scala/jdk/javaapi/FunctionConverters.scala index b1bfdb84d2dd..9892861ed0bc 100644 --- a/library/src/scala/jdk/javaapi/FunctionConverters.scala +++ b/library/src/scala/jdk/javaapi/FunctionConverters.scala @@ -32,6 +32,10 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the bi-consumer + * @tparam U the second input type of the bi-consumer + * @param jf the Java `BiConsumer` to convert */ @inline def asScalaFromBiConsumer[T, U](jf: java.util.function.BiConsumer[T, U]): scala.Function2[T, U, scala.runtime.BoxedUnit] = jf match { case AsJavaBiConsumer((f @ _)) => f.asInstanceOf[scala.Function2[T, U, scala.runtime.BoxedUnit]] @@ -43,18 +47,32 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the bi-consumer + * @tparam U the second input type of the bi-consumer + * @param sf the Scala `Function2` to convert to a Java `BiConsumer` */ @inline def asJavaBiConsumer[T, U](sf: scala.Function2[T, U, scala.runtime.BoxedUnit]): java.util.function.BiConsumer[T, U] = ((sf): AnyRef) match { case FromJavaBiConsumer((f @ _)) => f.asInstanceOf[java.util.function.BiConsumer[T, U]] case _ => new AsJavaBiConsumer[T, U](sf.asInstanceOf[scala.Function2[T, U, Unit]]) } - + + /** @tparam T the first input type of the bi-function + * @tparam U the second input type of the bi-function + * @tparam R the return type of the bi-function + * @param jf the Java `BiFunction` to convert + */ @inline def asScalaFromBiFunction[T, U, R](jf: java.util.function.BiFunction[T, U, R]): scala.Function2[T, U, R] = jf match { case AsJavaBiFunction((f @ _)) => f.asInstanceOf[scala.Function2[T, U, R]] case _ => new FromJavaBiFunction[T, U, R](jf).asInstanceOf[scala.Function2[T, U, R]] } + /** @tparam T the first input type of the bi-function + * @tparam U the second input type of the bi-function + * @tparam R the return type of the bi-function + * @param sf the Scala `Function2` to convert to a Java `BiFunction` + */ @inline def asJavaBiFunction[T, U, R](sf: scala.Function2[T, U, R]): java.util.function.BiFunction[T, U, R] = ((sf): AnyRef) match { case FromJavaBiFunction((f @ _)) => f.asInstanceOf[java.util.function.BiFunction[T, U, R]] case _ => new AsJavaBiFunction[T, U, R](sf.asInstanceOf[scala.Function2[T, U, R]]) @@ -66,6 +84,10 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the bi-predicate + * @tparam U the second input type of the bi-predicate + * @param jf the Java `BiPredicate` to convert */ @inline def asScalaFromBiPredicate[T, U](jf: java.util.function.BiPredicate[T, U]): scala.Function2[T, U, java.lang.Boolean] = jf match { case AsJavaBiPredicate((f @ _)) => f.asInstanceOf[scala.Function2[T, U, java.lang.Boolean]] @@ -77,6 +99,10 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the bi-predicate + * @tparam U the second input type of the bi-predicate + * @param sf the Scala `Function2` to convert to a Java `BiPredicate` */ @inline def asJavaBiPredicate[T, U](sf: scala.Function2[T, U, java.lang.Boolean]): java.util.function.BiPredicate[T, U] = ((sf): AnyRef) match { case FromJavaBiPredicate((f @ _)) => f.asInstanceOf[java.util.function.BiPredicate[T, U]] @@ -84,11 +110,17 @@ object FunctionConverters { } + /** @tparam T the input and output type of the binary operator + * @param jf the Java `BinaryOperator` to convert + */ @inline def asScalaFromBinaryOperator[T](jf: java.util.function.BinaryOperator[T]): scala.Function2[T, T, T] = jf match { case AsJavaBinaryOperator((f @ _)) => f.asInstanceOf[scala.Function2[T, T, T]] case _ => new FromJavaBinaryOperator[T](jf).asInstanceOf[scala.Function2[T, T, T]] } + /** @tparam T the input and output type of the binary operator + * @param sf the Scala `Function2` to convert to a Java `BinaryOperator` + */ @inline def asJavaBinaryOperator[T](sf: scala.Function2[T, T, T]): java.util.function.BinaryOperator[T] = ((sf): AnyRef) match { case FromJavaBinaryOperator((f @ _)) => f.asInstanceOf[java.util.function.BinaryOperator[T]] case _ => new AsJavaBinaryOperator[T](sf.asInstanceOf[scala.Function2[T, T, T]]) @@ -100,6 +132,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `BooleanSupplier` to convert */ @inline def asScalaFromBooleanSupplier(jf: java.util.function.BooleanSupplier): scala.Function0[java.lang.Boolean] = jf match { case AsJavaBooleanSupplier((f @ _)) => f.asInstanceOf[scala.Function0[java.lang.Boolean]] @@ -111,6 +145,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function0` to convert to a Java `BooleanSupplier` */ @inline def asJavaBooleanSupplier(sf: scala.Function0[java.lang.Boolean]): java.util.function.BooleanSupplier = ((sf): AnyRef) match { case FromJavaBooleanSupplier((f @ _)) => f.asInstanceOf[java.util.function.BooleanSupplier] @@ -123,6 +159,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the consumer + * @param jf the Java `Consumer` to convert */ @inline def asScalaFromConsumer[T](jf: java.util.function.Consumer[T]): scala.Function1[T, scala.runtime.BoxedUnit] = jf match { case AsJavaConsumer((f @ _)) => f.asInstanceOf[scala.Function1[T, scala.runtime.BoxedUnit]] @@ -134,6 +173,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the consumer + * @param sf the Scala `Function1` to convert to a Java `Consumer` */ @inline def asJavaConsumer[T](sf: scala.Function1[T, scala.runtime.BoxedUnit]): java.util.function.Consumer[T] = ((sf): AnyRef) match { case FromJavaConsumer((f @ _)) => f.asInstanceOf[java.util.function.Consumer[T]] @@ -146,6 +188,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `DoubleBinaryOperator` to convert */ @inline def asScalaFromDoubleBinaryOperator(jf: java.util.function.DoubleBinaryOperator): scala.Function2[java.lang.Double, java.lang.Double, java.lang.Double] = jf match { case AsJavaDoubleBinaryOperator((f @ _)) => f.asInstanceOf[scala.Function2[java.lang.Double, java.lang.Double, java.lang.Double]] @@ -157,6 +201,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function2` to convert to a Java `DoubleBinaryOperator` */ @inline def asJavaDoubleBinaryOperator(sf: scala.Function2[java.lang.Double, java.lang.Double, java.lang.Double]): java.util.function.DoubleBinaryOperator = ((sf): AnyRef) match { case FromJavaDoubleBinaryOperator((f @ _)) => f.asInstanceOf[java.util.function.DoubleBinaryOperator] @@ -169,6 +215,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `DoubleConsumer` to convert */ @inline def asScalaFromDoubleConsumer(jf: java.util.function.DoubleConsumer): scala.Function1[java.lang.Double, scala.runtime.BoxedUnit] = jf match { case AsJavaDoubleConsumer((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Double, scala.runtime.BoxedUnit]] @@ -180,6 +228,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `DoubleConsumer` */ @inline def asJavaDoubleConsumer(sf: scala.Function1[java.lang.Double, scala.runtime.BoxedUnit]): java.util.function.DoubleConsumer = ((sf): AnyRef) match { case FromJavaDoubleConsumer((f @ _)) => f.asInstanceOf[java.util.function.DoubleConsumer] @@ -192,6 +242,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam R the return type of the function + * @param jf the Java `DoubleFunction` to convert */ @inline def asScalaFromDoubleFunction[R](jf: java.util.function.DoubleFunction[R]): scala.Function1[java.lang.Double, R] = jf match { case AsJavaDoubleFunction((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Double, R]] @@ -203,6 +256,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam R the return type of the function + * @param sf the Scala `Function1` to convert to a Java `DoubleFunction` */ @inline def asJavaDoubleFunction[R](sf: scala.Function1[java.lang.Double, R]): java.util.function.DoubleFunction[R] = ((sf): AnyRef) match { case FromJavaDoubleFunction((f @ _)) => f.asInstanceOf[java.util.function.DoubleFunction[R]] @@ -215,6 +271,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `DoublePredicate` to convert */ @inline def asScalaFromDoublePredicate(jf: java.util.function.DoublePredicate): scala.Function1[java.lang.Double, java.lang.Boolean] = jf match { case AsJavaDoublePredicate((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Double, java.lang.Boolean]] @@ -226,6 +284,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `DoublePredicate` */ @inline def asJavaDoublePredicate(sf: scala.Function1[java.lang.Double, java.lang.Boolean]): java.util.function.DoublePredicate = ((sf): AnyRef) match { case FromJavaDoublePredicate((f @ _)) => f.asInstanceOf[java.util.function.DoublePredicate] @@ -238,6 +298,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `DoubleSupplier` to convert */ @inline def asScalaFromDoubleSupplier(jf: java.util.function.DoubleSupplier): scala.Function0[java.lang.Double] = jf match { case AsJavaDoubleSupplier((f @ _)) => f.asInstanceOf[scala.Function0[java.lang.Double]] @@ -249,6 +311,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function0` to convert to a Java `DoubleSupplier` */ @inline def asJavaDoubleSupplier(sf: scala.Function0[java.lang.Double]): java.util.function.DoubleSupplier = ((sf): AnyRef) match { case FromJavaDoubleSupplier((f @ _)) => f.asInstanceOf[java.util.function.DoubleSupplier] @@ -261,6 +325,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `DoubleToIntFunction` to convert */ @inline def asScalaFromDoubleToIntFunction(jf: java.util.function.DoubleToIntFunction): scala.Function1[java.lang.Double, java.lang.Integer] = jf match { case AsJavaDoubleToIntFunction((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Double, java.lang.Integer]] @@ -272,6 +338,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `DoubleToIntFunction` */ @inline def asJavaDoubleToIntFunction(sf: scala.Function1[java.lang.Double, java.lang.Integer]): java.util.function.DoubleToIntFunction = ((sf): AnyRef) match { case FromJavaDoubleToIntFunction((f @ _)) => f.asInstanceOf[java.util.function.DoubleToIntFunction] @@ -284,6 +352,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `DoubleToLongFunction` to convert */ @inline def asScalaFromDoubleToLongFunction(jf: java.util.function.DoubleToLongFunction): scala.Function1[java.lang.Double, java.lang.Long] = jf match { case AsJavaDoubleToLongFunction((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Double, java.lang.Long]] @@ -295,6 +365,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `DoubleToLongFunction` */ @inline def asJavaDoubleToLongFunction(sf: scala.Function1[java.lang.Double, java.lang.Long]): java.util.function.DoubleToLongFunction = ((sf): AnyRef) match { case FromJavaDoubleToLongFunction((f @ _)) => f.asInstanceOf[java.util.function.DoubleToLongFunction] @@ -307,6 +379,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `DoubleUnaryOperator` to convert */ @inline def asScalaFromDoubleUnaryOperator(jf: java.util.function.DoubleUnaryOperator): scala.Function1[java.lang.Double, java.lang.Double] = jf match { case AsJavaDoubleUnaryOperator((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Double, java.lang.Double]] @@ -318,6 +392,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `DoubleUnaryOperator` */ @inline def asJavaDoubleUnaryOperator(sf: scala.Function1[java.lang.Double, java.lang.Double]): java.util.function.DoubleUnaryOperator = ((sf): AnyRef) match { case FromJavaDoubleUnaryOperator((f @ _)) => f.asInstanceOf[java.util.function.DoubleUnaryOperator] @@ -325,11 +401,19 @@ object FunctionConverters { } + /** @tparam T the input type of the function + * @tparam R the return type of the function + * @param jf the Java `Function` to convert + */ @inline def asScalaFromFunction[T, R](jf: java.util.function.Function[T, R]): scala.Function1[T, R] = jf match { case AsJavaFunction((f @ _)) => f.asInstanceOf[scala.Function1[T, R]] case _ => new FromJavaFunction[T, R](jf).asInstanceOf[scala.Function1[T, R]] } + /** @tparam T the input type of the function + * @tparam R the return type of the function + * @param sf the Scala `Function1` to convert to a Java `Function` + */ @inline def asJavaFunction[T, R](sf: scala.Function1[T, R]): java.util.function.Function[T, R] = ((sf): AnyRef) match { case FromJavaFunction((f @ _)) => f.asInstanceOf[java.util.function.Function[T, R]] case _ => new AsJavaFunction[T, R](sf.asInstanceOf[scala.Function1[T, R]]) @@ -341,6 +425,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `IntBinaryOperator` to convert */ @inline def asScalaFromIntBinaryOperator(jf: java.util.function.IntBinaryOperator): scala.Function2[java.lang.Integer, java.lang.Integer, java.lang.Integer] = jf match { case AsJavaIntBinaryOperator((f @ _)) => f.asInstanceOf[scala.Function2[java.lang.Integer, java.lang.Integer, java.lang.Integer]] @@ -352,6 +438,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function2` to convert to a Java `IntBinaryOperator` */ @inline def asJavaIntBinaryOperator(sf: scala.Function2[java.lang.Integer, java.lang.Integer, java.lang.Integer]): java.util.function.IntBinaryOperator = ((sf): AnyRef) match { case FromJavaIntBinaryOperator((f @ _)) => f.asInstanceOf[java.util.function.IntBinaryOperator] @@ -364,6 +452,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `IntConsumer` to convert */ @inline def asScalaFromIntConsumer(jf: java.util.function.IntConsumer): scala.Function1[java.lang.Integer, scala.runtime.BoxedUnit] = jf match { case AsJavaIntConsumer((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Integer, scala.runtime.BoxedUnit]] @@ -375,6 +465,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `IntConsumer` */ @inline def asJavaIntConsumer(sf: scala.Function1[java.lang.Integer, scala.runtime.BoxedUnit]): java.util.function.IntConsumer = ((sf): AnyRef) match { case FromJavaIntConsumer((f @ _)) => f.asInstanceOf[java.util.function.IntConsumer] @@ -387,6 +479,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam R the return type of the function + * @param jf the Java `IntFunction` to convert */ @inline def asScalaFromIntFunction[R](jf: java.util.function.IntFunction[R]): scala.Function1[java.lang.Integer, R] = jf match { case AsJavaIntFunction((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Integer, R]] @@ -398,6 +493,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam R the return type of the function + * @param sf the Scala `Function1` to convert to a Java `IntFunction` */ @inline def asJavaIntFunction[R](sf: scala.Function1[java.lang.Integer, R]): java.util.function.IntFunction[R] = ((sf): AnyRef) match { case FromJavaIntFunction((f @ _)) => f.asInstanceOf[java.util.function.IntFunction[R]] @@ -410,6 +508,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `IntPredicate` to convert */ @inline def asScalaFromIntPredicate(jf: java.util.function.IntPredicate): scala.Function1[java.lang.Integer, java.lang.Boolean] = jf match { case AsJavaIntPredicate((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Integer, java.lang.Boolean]] @@ -421,6 +521,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `IntPredicate` */ @inline def asJavaIntPredicate(sf: scala.Function1[java.lang.Integer, java.lang.Boolean]): java.util.function.IntPredicate = ((sf): AnyRef) match { case FromJavaIntPredicate((f @ _)) => f.asInstanceOf[java.util.function.IntPredicate] @@ -433,6 +535,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `IntSupplier` to convert */ @inline def asScalaFromIntSupplier(jf: java.util.function.IntSupplier): scala.Function0[java.lang.Integer] = jf match { case AsJavaIntSupplier((f @ _)) => f.asInstanceOf[scala.Function0[java.lang.Integer]] @@ -444,6 +548,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function0` to convert to a Java `IntSupplier` */ @inline def asJavaIntSupplier(sf: scala.Function0[java.lang.Integer]): java.util.function.IntSupplier = ((sf): AnyRef) match { case FromJavaIntSupplier((f @ _)) => f.asInstanceOf[java.util.function.IntSupplier] @@ -456,6 +562,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `IntToDoubleFunction` to convert */ @inline def asScalaFromIntToDoubleFunction(jf: java.util.function.IntToDoubleFunction): scala.Function1[java.lang.Integer, java.lang.Double] = jf match { case AsJavaIntToDoubleFunction((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Integer, java.lang.Double]] @@ -467,6 +575,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `IntToDoubleFunction` */ @inline def asJavaIntToDoubleFunction(sf: scala.Function1[java.lang.Integer, java.lang.Double]): java.util.function.IntToDoubleFunction = ((sf): AnyRef) match { case FromJavaIntToDoubleFunction((f @ _)) => f.asInstanceOf[java.util.function.IntToDoubleFunction] @@ -479,6 +589,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `IntToLongFunction` to convert */ @inline def asScalaFromIntToLongFunction(jf: java.util.function.IntToLongFunction): scala.Function1[java.lang.Integer, java.lang.Long] = jf match { case AsJavaIntToLongFunction((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Integer, java.lang.Long]] @@ -490,6 +602,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `IntToLongFunction` */ @inline def asJavaIntToLongFunction(sf: scala.Function1[java.lang.Integer, java.lang.Long]): java.util.function.IntToLongFunction = ((sf): AnyRef) match { case FromJavaIntToLongFunction((f @ _)) => f.asInstanceOf[java.util.function.IntToLongFunction] @@ -502,6 +616,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `IntUnaryOperator` to convert */ @inline def asScalaFromIntUnaryOperator(jf: java.util.function.IntUnaryOperator): scala.Function1[java.lang.Integer, java.lang.Integer] = jf match { case AsJavaIntUnaryOperator((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Integer, java.lang.Integer]] @@ -513,6 +629,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `IntUnaryOperator` */ @inline def asJavaIntUnaryOperator(sf: scala.Function1[java.lang.Integer, java.lang.Integer]): java.util.function.IntUnaryOperator = ((sf): AnyRef) match { case FromJavaIntUnaryOperator((f @ _)) => f.asInstanceOf[java.util.function.IntUnaryOperator] @@ -525,6 +643,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `LongBinaryOperator` to convert */ @inline def asScalaFromLongBinaryOperator(jf: java.util.function.LongBinaryOperator): scala.Function2[java.lang.Long, java.lang.Long, java.lang.Long] = jf match { case AsJavaLongBinaryOperator((f @ _)) => f.asInstanceOf[scala.Function2[java.lang.Long, java.lang.Long, java.lang.Long]] @@ -536,6 +656,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function2` to convert to a Java `LongBinaryOperator` */ @inline def asJavaLongBinaryOperator(sf: scala.Function2[java.lang.Long, java.lang.Long, java.lang.Long]): java.util.function.LongBinaryOperator = ((sf): AnyRef) match { case FromJavaLongBinaryOperator((f @ _)) => f.asInstanceOf[java.util.function.LongBinaryOperator] @@ -548,6 +670,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `LongConsumer` to convert */ @inline def asScalaFromLongConsumer(jf: java.util.function.LongConsumer): scala.Function1[java.lang.Long, scala.runtime.BoxedUnit] = jf match { case AsJavaLongConsumer((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Long, scala.runtime.BoxedUnit]] @@ -559,6 +683,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `LongConsumer` */ @inline def asJavaLongConsumer(sf: scala.Function1[java.lang.Long, scala.runtime.BoxedUnit]): java.util.function.LongConsumer = ((sf): AnyRef) match { case FromJavaLongConsumer((f @ _)) => f.asInstanceOf[java.util.function.LongConsumer] @@ -571,6 +697,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam R the return type of the function + * @param jf the Java `LongFunction` to convert */ @inline def asScalaFromLongFunction[R](jf: java.util.function.LongFunction[R]): scala.Function1[java.lang.Long, R] = jf match { case AsJavaLongFunction((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Long, R]] @@ -582,6 +711,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam R the return type of the function + * @param sf the Scala `Function1` to convert to a Java `LongFunction` */ @inline def asJavaLongFunction[R](sf: scala.Function1[java.lang.Long, R]): java.util.function.LongFunction[R] = ((sf): AnyRef) match { case FromJavaLongFunction((f @ _)) => f.asInstanceOf[java.util.function.LongFunction[R]] @@ -594,6 +726,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `LongPredicate` to convert */ @inline def asScalaFromLongPredicate(jf: java.util.function.LongPredicate): scala.Function1[java.lang.Long, java.lang.Boolean] = jf match { case AsJavaLongPredicate((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Long, java.lang.Boolean]] @@ -605,6 +739,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `LongPredicate` */ @inline def asJavaLongPredicate(sf: scala.Function1[java.lang.Long, java.lang.Boolean]): java.util.function.LongPredicate = ((sf): AnyRef) match { case FromJavaLongPredicate((f @ _)) => f.asInstanceOf[java.util.function.LongPredicate] @@ -617,6 +753,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `LongSupplier` to convert */ @inline def asScalaFromLongSupplier(jf: java.util.function.LongSupplier): scala.Function0[java.lang.Long] = jf match { case AsJavaLongSupplier((f @ _)) => f.asInstanceOf[scala.Function0[java.lang.Long]] @@ -628,6 +766,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function0` to convert to a Java `LongSupplier` */ @inline def asJavaLongSupplier(sf: scala.Function0[java.lang.Long]): java.util.function.LongSupplier = ((sf): AnyRef) match { case FromJavaLongSupplier((f @ _)) => f.asInstanceOf[java.util.function.LongSupplier] @@ -640,6 +780,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `LongToDoubleFunction` to convert */ @inline def asScalaFromLongToDoubleFunction(jf: java.util.function.LongToDoubleFunction): scala.Function1[java.lang.Long, java.lang.Double] = jf match { case AsJavaLongToDoubleFunction((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Long, java.lang.Double]] @@ -651,6 +793,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `LongToDoubleFunction` */ @inline def asJavaLongToDoubleFunction(sf: scala.Function1[java.lang.Long, java.lang.Double]): java.util.function.LongToDoubleFunction = ((sf): AnyRef) match { case FromJavaLongToDoubleFunction((f @ _)) => f.asInstanceOf[java.util.function.LongToDoubleFunction] @@ -663,6 +807,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `LongToIntFunction` to convert */ @inline def asScalaFromLongToIntFunction(jf: java.util.function.LongToIntFunction): scala.Function1[java.lang.Long, java.lang.Integer] = jf match { case AsJavaLongToIntFunction((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Long, java.lang.Integer]] @@ -674,6 +820,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `LongToIntFunction` */ @inline def asJavaLongToIntFunction(sf: scala.Function1[java.lang.Long, java.lang.Integer]): java.util.function.LongToIntFunction = ((sf): AnyRef) match { case FromJavaLongToIntFunction((f @ _)) => f.asInstanceOf[java.util.function.LongToIntFunction] @@ -686,6 +834,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param jf the Java `LongUnaryOperator` to convert */ @inline def asScalaFromLongUnaryOperator(jf: java.util.function.LongUnaryOperator): scala.Function1[java.lang.Long, java.lang.Long] = jf match { case AsJavaLongUnaryOperator((f @ _)) => f.asInstanceOf[scala.Function1[java.lang.Long, java.lang.Long]] @@ -697,6 +847,8 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @param sf the Scala `Function1` to convert to a Java `LongUnaryOperator` */ @inline def asJavaLongUnaryOperator(sf: scala.Function1[java.lang.Long, java.lang.Long]): java.util.function.LongUnaryOperator = ((sf): AnyRef) match { case FromJavaLongUnaryOperator((f @ _)) => f.asInstanceOf[java.util.function.LongUnaryOperator] @@ -709,6 +861,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the type of the first (object) argument to the consumer + * @param jf the Java `ObjDoubleConsumer` to convert */ @inline def asScalaFromObjDoubleConsumer[T](jf: java.util.function.ObjDoubleConsumer[T]): scala.Function2[T, java.lang.Double, scala.runtime.BoxedUnit] = jf match { case AsJavaObjDoubleConsumer((f @ _)) => f.asInstanceOf[scala.Function2[T, java.lang.Double, scala.runtime.BoxedUnit]] @@ -720,6 +875,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the type of the first (object) argument to the consumer + * @param sf the Scala `Function2` to convert to a Java `ObjDoubleConsumer` */ @inline def asJavaObjDoubleConsumer[T](sf: scala.Function2[T, java.lang.Double, scala.runtime.BoxedUnit]): java.util.function.ObjDoubleConsumer[T] = ((sf): AnyRef) match { case FromJavaObjDoubleConsumer((f @ _)) => f.asInstanceOf[java.util.function.ObjDoubleConsumer[T]] @@ -732,6 +890,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the type of the first (object) argument to the consumer + * @param jf the Java `ObjIntConsumer` to convert */ @inline def asScalaFromObjIntConsumer[T](jf: java.util.function.ObjIntConsumer[T]): scala.Function2[T, java.lang.Integer, scala.runtime.BoxedUnit] = jf match { case AsJavaObjIntConsumer((f @ _)) => f.asInstanceOf[scala.Function2[T, java.lang.Integer, scala.runtime.BoxedUnit]] @@ -743,6 +904,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the type of the first (object) argument to the consumer + * @param sf the Scala `Function2` to convert to a Java `ObjIntConsumer` */ @inline def asJavaObjIntConsumer[T](sf: scala.Function2[T, java.lang.Integer, scala.runtime.BoxedUnit]): java.util.function.ObjIntConsumer[T] = ((sf): AnyRef) match { case FromJavaObjIntConsumer((f @ _)) => f.asInstanceOf[java.util.function.ObjIntConsumer[T]] @@ -755,6 +919,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the type of the first (object) argument to the consumer + * @param jf the Java `ObjLongConsumer` to convert */ @inline def asScalaFromObjLongConsumer[T](jf: java.util.function.ObjLongConsumer[T]): scala.Function2[T, java.lang.Long, scala.runtime.BoxedUnit] = jf match { case AsJavaObjLongConsumer((f @ _)) => f.asInstanceOf[scala.Function2[T, java.lang.Long, scala.runtime.BoxedUnit]] @@ -766,6 +933,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the type of the first (object) argument to the consumer + * @param sf the Scala `Function2` to convert to a Java `ObjLongConsumer` */ @inline def asJavaObjLongConsumer[T](sf: scala.Function2[T, java.lang.Long, scala.runtime.BoxedUnit]): java.util.function.ObjLongConsumer[T] = ((sf): AnyRef) match { case FromJavaObjLongConsumer((f @ _)) => f.asInstanceOf[java.util.function.ObjLongConsumer[T]] @@ -778,6 +948,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the predicate + * @param jf the Java `Predicate` to convert */ @inline def asScalaFromPredicate[T](jf: java.util.function.Predicate[T]): scala.Function1[T, java.lang.Boolean] = jf match { case AsJavaPredicate((f @ _)) => f.asInstanceOf[scala.Function1[T, java.lang.Boolean]] @@ -789,6 +962,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the predicate + * @param sf the Scala `Function1` to convert to a Java `Predicate` */ @inline def asJavaPredicate[T](sf: scala.Function1[T, java.lang.Boolean]): java.util.function.Predicate[T] = ((sf): AnyRef) match { case FromJavaPredicate((f @ _)) => f.asInstanceOf[java.util.function.Predicate[T]] @@ -796,11 +972,17 @@ object FunctionConverters { } + /** @tparam T the return type of the supplier + * @param jf the Java `Supplier` to convert + */ @inline def asScalaFromSupplier[T](jf: java.util.function.Supplier[T]): scala.Function0[T] = jf match { case AsJavaSupplier((f @ _)) => f.asInstanceOf[scala.Function0[T]] case _ => new FromJavaSupplier[T](jf).asInstanceOf[scala.Function0[T]] } + /** @tparam T the return type of the supplier + * @param sf the Scala `Function0` to convert to a Java `Supplier` + */ @inline def asJavaSupplier[T](sf: scala.Function0[T]): java.util.function.Supplier[T] = ((sf): AnyRef) match { case FromJavaSupplier((f @ _)) => f.asInstanceOf[java.util.function.Supplier[T]] case _ => new AsJavaSupplier[T](sf.asInstanceOf[scala.Function0[T]]) @@ -812,6 +994,10 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the function + * @tparam U the second input type of the function + * @param jf the Java `ToDoubleBiFunction` to convert */ @inline def asScalaFromToDoubleBiFunction[T, U](jf: java.util.function.ToDoubleBiFunction[T, U]): scala.Function2[T, U, java.lang.Double] = jf match { case AsJavaToDoubleBiFunction((f @ _)) => f.asInstanceOf[scala.Function2[T, U, java.lang.Double]] @@ -823,6 +1009,10 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the function + * @tparam U the second input type of the function + * @param sf the Scala `Function2` to convert to a Java `ToDoubleBiFunction` */ @inline def asJavaToDoubleBiFunction[T, U](sf: scala.Function2[T, U, java.lang.Double]): java.util.function.ToDoubleBiFunction[T, U] = ((sf): AnyRef) match { case FromJavaToDoubleBiFunction((f @ _)) => f.asInstanceOf[java.util.function.ToDoubleBiFunction[T, U]] @@ -835,6 +1025,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the function + * @param jf the Java `ToDoubleFunction` to convert */ @inline def asScalaFromToDoubleFunction[T](jf: java.util.function.ToDoubleFunction[T]): scala.Function1[T, java.lang.Double] = jf match { case AsJavaToDoubleFunction((f @ _)) => f.asInstanceOf[scala.Function1[T, java.lang.Double]] @@ -846,6 +1039,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the function + * @param sf the Scala `Function1` to convert to a Java `ToDoubleFunction` */ @inline def asJavaToDoubleFunction[T](sf: scala.Function1[T, java.lang.Double]): java.util.function.ToDoubleFunction[T] = ((sf): AnyRef) match { case FromJavaToDoubleFunction((f @ _)) => f.asInstanceOf[java.util.function.ToDoubleFunction[T]] @@ -858,6 +1054,10 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the function + * @tparam U the second input type of the function + * @param jf the Java `ToIntBiFunction` to convert */ @inline def asScalaFromToIntBiFunction[T, U](jf: java.util.function.ToIntBiFunction[T, U]): scala.Function2[T, U, java.lang.Integer] = jf match { case AsJavaToIntBiFunction((f @ _)) => f.asInstanceOf[scala.Function2[T, U, java.lang.Integer]] @@ -869,6 +1069,10 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the function + * @tparam U the second input type of the function + * @param sf the Scala `Function2` to convert to a Java `ToIntBiFunction` */ @inline def asJavaToIntBiFunction[T, U](sf: scala.Function2[T, U, java.lang.Integer]): java.util.function.ToIntBiFunction[T, U] = ((sf): AnyRef) match { case FromJavaToIntBiFunction((f @ _)) => f.asInstanceOf[java.util.function.ToIntBiFunction[T, U]] @@ -881,6 +1085,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the function + * @param jf the Java `ToIntFunction` to convert */ @inline def asScalaFromToIntFunction[T](jf: java.util.function.ToIntFunction[T]): scala.Function1[T, java.lang.Integer] = jf match { case AsJavaToIntFunction((f @ _)) => f.asInstanceOf[scala.Function1[T, java.lang.Integer]] @@ -892,6 +1099,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the function + * @param sf the Scala `Function1` to convert to a Java `ToIntFunction` */ @inline def asJavaToIntFunction[T](sf: scala.Function1[T, java.lang.Integer]): java.util.function.ToIntFunction[T] = ((sf): AnyRef) match { case FromJavaToIntFunction((f @ _)) => f.asInstanceOf[java.util.function.ToIntFunction[T]] @@ -904,6 +1114,10 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the function + * @tparam U the second input type of the function + * @param jf the Java `ToLongBiFunction` to convert */ @inline def asScalaFromToLongBiFunction[T, U](jf: java.util.function.ToLongBiFunction[T, U]): scala.Function2[T, U, java.lang.Long] = jf match { case AsJavaToLongBiFunction((f @ _)) => f.asInstanceOf[scala.Function2[T, U, java.lang.Long]] @@ -915,6 +1129,10 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the first input type of the function + * @tparam U the second input type of the function + * @param sf the Scala `Function2` to convert to a Java `ToLongBiFunction` */ @inline def asJavaToLongBiFunction[T, U](sf: scala.Function2[T, U, java.lang.Long]): java.util.function.ToLongBiFunction[T, U] = ((sf): AnyRef) match { case FromJavaToLongBiFunction((f @ _)) => f.asInstanceOf[java.util.function.ToLongBiFunction[T, U]] @@ -927,6 +1145,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the function + * @param jf the Java `ToLongFunction` to convert */ @inline def asScalaFromToLongFunction[T](jf: java.util.function.ToLongFunction[T]): scala.Function1[T, java.lang.Long] = jf match { case AsJavaToLongFunction((f @ _)) => f.asInstanceOf[scala.Function1[T, java.lang.Long]] @@ -938,6 +1159,9 @@ object FunctionConverters { * Scala compiler emits `C[Int]` as `C[Object]` in bytecode due to * [scala/bug#4214](https://github.com/scala/bug/issues/4214)). In Scala code, add * `import scala.jdk.FunctionConverters._` and use the extension methods instead. + * + * @tparam T the input type of the function + * @param sf the Scala `Function1` to convert to a Java `ToLongFunction` */ @inline def asJavaToLongFunction[T](sf: scala.Function1[T, java.lang.Long]): java.util.function.ToLongFunction[T] = ((sf): AnyRef) match { case FromJavaToLongFunction((f @ _)) => f.asInstanceOf[java.util.function.ToLongFunction[T]] @@ -945,11 +1169,17 @@ object FunctionConverters { } + /** @tparam T the input and output type of the unary operator + * @param jf the Java `UnaryOperator` to convert + */ @inline def asScalaFromUnaryOperator[T](jf: java.util.function.UnaryOperator[T]): scala.Function1[T, T] = jf match { case AsJavaUnaryOperator((f @ _)) => f.asInstanceOf[scala.Function1[T, T]] case _ => new FromJavaUnaryOperator[T](jf).asInstanceOf[scala.Function1[T, T]] } + /** @tparam T the input and output type of the unary operator + * @param sf the Scala `Function1` to convert to a Java `UnaryOperator` + */ @inline def asJavaUnaryOperator[T](sf: scala.Function1[T, T]): java.util.function.UnaryOperator[T] = ((sf): AnyRef) match { case FromJavaUnaryOperator((f @ _)) => f.asInstanceOf[java.util.function.UnaryOperator[T]] case _ => new AsJavaUnaryOperator[T](sf.asInstanceOf[scala.Function1[T, T]]) diff --git a/library/src/scala/jdk/javaapi/FutureConverters.scala b/library/src/scala/jdk/javaapi/FutureConverters.scala index cf1e31fdadcd..005d7194ec31 100644 --- a/library/src/scala/jdk/javaapi/FutureConverters.scala +++ b/library/src/scala/jdk/javaapi/FutureConverters.scala @@ -40,6 +40,7 @@ object FutureConverters { * therefore the returned CompletionStage routes all calls to synchronous transformations to * their asynchronous counterparts, i.e., `thenRun` will internally call `thenRunAsync`. * + * @tparam T the result type of the Future and CompletionStage * @param f The Scala Future which may eventually supply the completion for the returned * CompletionStage * @return a CompletionStage that runs all callbacks asynchronously and does not support the @@ -62,6 +63,7 @@ object FutureConverters { * executed asynchronously as specified by the ExecutionContext that is given to the combinator * methods. * + * @tparam T the result type of the CompletionStage and Future * @param cs The CompletionStage which may eventually supply the completion for the returned * Scala Future * @return a Scala Future that represents the CompletionStage's completion diff --git a/library/src/scala/jdk/javaapi/OptionConverters.scala b/library/src/scala/jdk/javaapi/OptionConverters.scala index 8385da1f42cb..7473f57a0232 100644 --- a/library/src/scala/jdk/javaapi/OptionConverters.scala +++ b/library/src/scala/jdk/javaapi/OptionConverters.scala @@ -29,7 +29,12 @@ import java.{lang => jl} * extension methods instead. */ object OptionConverters { - /** Converts a Scala `Option` to a Java `Optional`. */ + /** Converts a Scala `Option` to a Java `Optional`. + * + * @tparam A the element type of the `Option` and the resulting `Optional` + * @param o the Scala `Option` to convert + * @return a Java `Optional` containing the value, or empty if `o` is `None` + */ def toJava[A](o: Option[A]): Optional[A] = o match { case Some(a) => Optional.ofNullable(a) case _ => Optional.empty[A] @@ -38,6 +43,9 @@ object OptionConverters { /** Converts a Scala `Option[java.lang.Double]` to a Java `OptionalDouble`. * * $primitiveNote + * + * @param o the Scala `Option` to convert + * @return a Java `OptionalDouble` containing the value, or empty if `o` is `None` */ def toJavaOptionalDouble(o: Option[jl.Double]): OptionalDouble = o match { case Some(a) => OptionalDouble.of(a) @@ -47,6 +55,9 @@ object OptionConverters { /** Converts a Scala `Option[java.lang.Integer]` to a Java `OptionalInt`. * * $primitiveNote + * + * @param o the Scala `Option` to convert + * @return a Java `OptionalInt` containing the value, or empty if `o` is `None` */ def toJavaOptionalInt(o: Option[jl.Integer]): OptionalInt = o match { case Some(a) => OptionalInt.of(a) @@ -56,30 +67,47 @@ object OptionConverters { /** Converts a Scala `Option[java.lang.Long]` to a Java `OptionalLong`. * * $primitiveNote + * + * @param o the Scala `Option` to convert + * @return a Java `OptionalLong` containing the value, or empty if `o` is `None` */ def toJavaOptionalLong(o: Option[jl.Long]): OptionalLong = o match { case Some(a) => OptionalLong.of(a) case _ => OptionalLong.empty } - /** Converts a Java `Optional` to a Scala `Option`. */ + /** Converts a Java `Optional` to a Scala `Option`. + * + * @tparam A the element type of the `Optional` + * @param o the Java `Optional` to convert + * @return a Scala `Option` containing the value, or `None` if the `Optional` is empty + */ def toScala[A](o: Optional[A]): Option[A] = if (o.isPresent) Some(o.get) else None /** Converts a Java `OptionalDouble` to a Scala `Option[java.lang.Double]`. * * $primitiveNote + * + * @param o the Java `OptionalDouble` to convert + * @return a Scala `Option` containing the value as a boxed `java.lang.Double`, or `None` if empty */ def toScala(o: OptionalDouble): Option[jl.Double] = if (o.isPresent) Some(o.getAsDouble) else None /** Converts a Java `OptionalInt` to a Scala `Option[java.lang.Integer]`. * * $primitiveNote + * + * @param o the Java `OptionalInt` to convert + * @return a Scala `Option` containing the value as a boxed `java.lang.Integer`, or `None` if empty */ def toScala(o: OptionalInt): Option[jl.Integer] = if (o.isPresent) Some(o.getAsInt) else None /** Converts a Java `OptionalLong` to a Scala `Option[java.lang.Long]`. * * $primitiveNote + * + * @param o the Java `OptionalLong` to convert + * @return a Scala `Option` containing the value as a boxed `java.lang.Long`, or `None` if empty */ def toScala(o: OptionalLong): Option[jl.Long] = if (o.isPresent) Some(o.getAsLong) else None } diff --git a/library/src/scala/jdk/javaapi/StreamConverters.scala b/library/src/scala/jdk/javaapi/StreamConverters.scala index c08830bd96a1..ff7cae4056af 100644 --- a/library/src/scala/jdk/javaapi/StreamConverters.scala +++ b/library/src/scala/jdk/javaapi/StreamConverters.scala @@ -45,130 +45,224 @@ object StreamConverters { // sequential streams for collections ///////////////////////////////////// - /** Creates a sequential [[java.util.stream.Stream Java Stream]] for a Scala collection. */ + /** Creates a sequential [[java.util.stream.Stream Java Stream]] for a Scala collection. + * + * @tparam A the element type of the collection + * @param cc the Scala collection to convert to a Java Stream + * @return a sequential `Stream` for the collection + */ def asJavaSeqStream[A](cc: IterableOnce[A]): Stream[A] = StreamSupport.stream(cc.stepper.spliterator, false) /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for a Scala collection. * * $primitiveNote + * + * @param cc the Scala collection of integers to convert + * @return a sequential `IntStream` for the collection */ def asJavaSeqIntStream (cc: IterableOnce[jl.Integer]): IntStream = StreamSupport.intStream(cc.stepper.spliterator, false) /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for a Scala collection. * * $primitiveNote + * + * @param cc the Scala collection of bytes to convert + * @return a sequential `IntStream` for the collection */ def asJavaSeqIntStreamFromByte (cc: IterableOnce[jl.Byte]): IntStream = StreamSupport.intStream(cc.stepper.spliterator, false) /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for a Scala collection. * * $primitiveNote + * + * @param cc the Scala collection of shorts to convert + * @return a sequential `IntStream` for the collection */ def asJavaSeqIntStreamFromShort(cc: IterableOnce[jl.Short]): IntStream = StreamSupport.intStream(cc.stepper.spliterator, false) /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for a Scala collection. * * $primitiveNote + * + * @param cc the Scala collection of characters to convert + * @return a sequential `IntStream` for the collection */ def asJavaSeqIntStreamFromChar (cc: IterableOnce[jl.Character]): IntStream = StreamSupport.intStream(cc.stepper.spliterator, false) /** Creates a sequential [[java.util.stream.DoubleStream Java DoubleStream]] for a Scala collection. * * $primitiveNote + * + * @param cc the Scala collection of doubles to convert + * @return a sequential `DoubleStream` for the collection */ def asJavaSeqDoubleStream (cc: IterableOnce[jl.Double]): DoubleStream = StreamSupport.doubleStream(cc.stepper.spliterator, false) /** Creates a sequential [[java.util.stream.DoubleStream Java DoubleStream]] for a Scala collection. * * $primitiveNote + * + * @param cc the Scala collection of floats to convert + * @return a sequential `DoubleStream` for the collection */ def asJavaSeqDoubleStreamFromFloat(cc: IterableOnce[jl.Float]): DoubleStream = StreamSupport.doubleStream(cc.stepper.spliterator, false) /** Creates a sequential [[java.util.stream.LongStream Java LongStream]] for a Scala collection. * * $primitiveNote + * + * @param cc the Scala collection of longs to convert + * @return a sequential `LongStream` for the collection */ def asJavaSeqLongStream(cc: IterableOnce[jl.Long]): LongStream = StreamSupport.longStream(cc.stepper.spliterator, false) // Map Key Streams - /** Creates a sequential [[java.util.stream.Stream Java Stream]] for the keys of a Scala Map. */ + /** Creates a sequential [[java.util.stream.Stream Java Stream]] for the keys of a Scala Map. + * + * @tparam K the key type of the map + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a sequential `Stream` for the map's keys + */ def asJavaSeqKeyStream[K, V](m: collection.Map[K, V]): Stream[K] = StreamSupport.stream(m.keyStepper.spliterator, false) /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the keys of a Scala Map. * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a sequential `IntStream` for the map's keys */ def asJavaSeqKeyIntStream [V](m: collection.Map[jl.Integer, V]): IntStream = StreamSupport.intStream(m.keyStepper.spliterator, false) /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the keys of a Scala Map. * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a sequential `IntStream` for the map's keys */ def asJavaSeqKeyIntStreamFromByte [V](m: collection.Map[jl.Byte, V]): IntStream = StreamSupport.intStream(m.keyStepper.spliterator, false) /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the keys of a Scala Map. * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a sequential `IntStream` for the map's keys */ def asJavaSeqKeyIntStreamFromShort[V](m: collection.Map[jl.Short, V]): IntStream = StreamSupport.intStream(m.keyStepper.spliterator, false) /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the keys of a Scala Map. * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a sequential `IntStream` for the map's keys */ def asJavaSeqKeyIntStreamFromChar [V](m: collection.Map[jl.Character, V]): IntStream = StreamSupport.intStream(m.keyStepper.spliterator, false) /** Creates a sequential [[java.util.stream.DoubleStream Java DoubleStream]] for the keys of a Scala Map. * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a sequential `DoubleStream` for the map's keys */ def asJavaSeqKeyDoubleStream [V](m: collection.Map[jl.Double, V]): DoubleStream = StreamSupport.doubleStream(m.keyStepper.spliterator, false) /** Creates a sequential [[java.util.stream.DoubleStream Java DoubleStream]] for the keys of a Scala Map. * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a sequential `DoubleStream` for the map's keys */ def asJavaSeqKeyDoubleStreamFromFloat[V](m: collection.Map[jl.Float, V]): DoubleStream = StreamSupport.doubleStream(m.keyStepper.spliterator, false) /** Creates a sequential [[java.util.stream.LongStream Java LongStream]] for the keys of a Scala Map. * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a sequential `LongStream` for the map's keys */ def asJavaSeqKeyLongStream[V](m: collection.Map[jl.Long, V]): LongStream = StreamSupport.longStream(m.keyStepper.spliterator, false) // Map Value Streams - /** Creates a sequential [[java.util.stream.Stream Java Stream]] for the values of a Scala Map. */ + /** Creates a sequential [[java.util.stream.Stream Java Stream]] for the values of a Scala Map. + * + * @tparam K the key type of the map + * @tparam V the value type of the map + * @param m the Scala Map whose values to stream over + * @return a sequential `Stream` for the map's values + */ def asJavaSeqValueStream[K, V](m: collection.Map[K, V]): Stream[V] = StreamSupport.stream(m.valueStepper.spliterator, false) - /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the values of a + /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the values of a Scala Map. * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a sequential `IntStream` for the map's values */ def asJavaSeqValueIntStream [K](m: collection.Map[K, jl.Integer]): IntStream = StreamSupport.intStream(m.valueStepper.spliterator, false) - /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the values of a + /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the values of a Scala Map. * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a sequential `IntStream` for the map's values */ def asJavaSeqValueIntStreamFromByte [K](m: collection.Map[K, jl.Byte]): IntStream = StreamSupport.intStream(m.valueStepper.spliterator, false) - /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the values of a + /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the values of a Scala Map. * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a sequential `IntStream` for the map's values */ def asJavaSeqValueIntStreamFromShort[K](m: collection.Map[K, jl.Short]): IntStream = StreamSupport.intStream(m.valueStepper.spliterator, false) - /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the values of a + /** Creates a sequential [[java.util.stream.IntStream Java IntStream]] for the values of a Scala Map. * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a sequential `IntStream` for the map's values */ def asJavaSeqValueIntStreamFromChar [K](m: collection.Map[K, jl.Character]): IntStream = StreamSupport.intStream(m.valueStepper.spliterator, false) - /** Creates a sequential [[java.util.stream.DoubleStream Java DoubleStream]] for the values of a + /** Creates a sequential [[java.util.stream.DoubleStream Java DoubleStream]] for the values of a Scala Map. * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a sequential `DoubleStream` for the map's values */ def asJavaSeqValueDoubleStream [K](m: collection.Map[K, jl.Double]): DoubleStream = StreamSupport.doubleStream(m.valueStepper.spliterator, false) - /** Creates a sequential [[java.util.stream.DoubleStream Java DoubleStream]] for the values of a + /** Creates a sequential [[java.util.stream.DoubleStream Java DoubleStream]] for the values of a Scala Map. * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a sequential `DoubleStream` for the map's values */ def asJavaSeqValueDoubleStreamFromFloat[K](m: collection.Map[K, jl.Float]): DoubleStream = StreamSupport.doubleStream(m.valueStepper.spliterator, false) - /** Creates a sequential [[java.util.stream.LongStream Java LongStream]] for the values of a + /** Creates a sequential [[java.util.stream.LongStream Java LongStream]] for the values of a Scala Map. * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a sequential `LongStream` for the map's values */ def asJavaSeqValueLongStream[K](m: collection.Map[K, jl.Long]): LongStream = StreamSupport.longStream(m.valueStepper.spliterator, false) @@ -179,6 +273,10 @@ object StreamConverters { /** Creates a parallel [[java.util.stream.Stream Java Stream]] for a Scala collection. * * $parNote + * + * @tparam A the element type of the collection + * @param cc the Scala collection to convert to a parallel Java Stream + * @return a parallel `Stream` for the collection */ def asJavaParStream[A](cc: IterableOnce[A]): Stream[A] = StreamSupport.stream(cc.stepper.spliterator, true) @@ -187,6 +285,9 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @param cc the Scala collection of integers to convert + * @return a parallel `IntStream` for the collection */ def asJavaParIntStream (cc: IterableOnce[jl.Integer]): IntStream = StreamSupport.intStream(cc.stepper.spliterator, true) /** Creates a parallel [[java.util.stream.IntStream Java IntStream]] for a Scala collection. @@ -194,6 +295,9 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @param cc the Scala collection of bytes to convert + * @return a parallel `IntStream` for the collection */ def asJavaParIntStreamFromByte (cc: IterableOnce[jl.Byte]): IntStream = StreamSupport.intStream(cc.stepper.spliterator, true) /** Creates a parallel [[java.util.stream.IntStream Java IntStream]] for a Scala collection. @@ -201,6 +305,9 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @param cc the Scala collection of shorts to convert + * @return a parallel `IntStream` for the collection */ def asJavaParIntStreamFromShort(cc: IterableOnce[jl.Short]): IntStream = StreamSupport.intStream(cc.stepper.spliterator, true) /** Creates a parallel [[java.util.stream.IntStream Java IntStream]] for a Scala collection. @@ -208,6 +315,9 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @param cc the Scala collection of characters to convert + * @return a parallel `IntStream` for the collection */ def asJavaParIntStreamFromChar (cc: IterableOnce[jl.Character]): IntStream = StreamSupport.intStream(cc.stepper.spliterator, true) @@ -216,6 +326,9 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @param cc the Scala collection of doubles to convert + * @return a parallel `DoubleStream` for the collection */ def asJavaParDoubleStream (cc: IterableOnce[jl.Double]): DoubleStream = StreamSupport.doubleStream(cc.stepper.spliterator, true) /** Creates a parallel [[java.util.stream.DoubleStream Java DoubleStream]] for a Scala collection. @@ -223,6 +336,9 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @param cc the Scala collection of floats to convert + * @return a parallel `DoubleStream` for the collection */ def asJavaParDoubleStreamFromFloat(cc: IterableOnce[jl.Float]): DoubleStream = StreamSupport.doubleStream(cc.stepper.spliterator, true) @@ -231,6 +347,9 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @param cc the Scala collection of longs to convert + * @return a parallel `LongStream` for the collection */ def asJavaParLongStream(cc: IterableOnce[jl.Long]): LongStream = StreamSupport.longStream(cc.stepper.spliterator, true) @@ -240,6 +359,11 @@ object StreamConverters { /** Creates a parallel [[java.util.stream.Stream Java Stream]] for the keys of a Scala Map. * * $parNote + * + * @tparam K the key type of the map + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a parallel `Stream` for the map's keys */ def asJavaParKeyStream[K, V](m: collection.Map[K, V]): Stream[K] = StreamSupport.stream(m.keyStepper.spliterator, true) @@ -248,6 +372,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a parallel `IntStream` for the map's keys */ def asJavaParKeyIntStream [V](m: collection.Map[jl.Integer, V]): IntStream = StreamSupport.intStream(m.keyStepper.spliterator, true) /** Creates a parallel [[java.util.stream.IntStream Java IntStream]] for the keys of a Scala Map. @@ -255,6 +383,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a parallel `IntStream` for the map's keys */ def asJavaParKeyIntStreamFromByte [V](m: collection.Map[jl.Byte, V]): IntStream = StreamSupport.intStream(m.keyStepper.spliterator, true) /** Creates a parallel [[java.util.stream.IntStream Java IntStream]] for the keys of a Scala Map. @@ -262,6 +394,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a parallel `IntStream` for the map's keys */ def asJavaParKeyIntStreamFromShort[V](m: collection.Map[jl.Short, V]): IntStream = StreamSupport.intStream(m.keyStepper.spliterator, true) /** Creates a parallel [[java.util.stream.IntStream Java IntStream]] for the keys of a Scala Map. @@ -269,6 +405,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a parallel `IntStream` for the map's keys */ def asJavaParKeyIntStreamFromChar [V](m: collection.Map[jl.Character, V]): IntStream = StreamSupport.intStream(m.keyStepper.spliterator, true) @@ -277,6 +417,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a parallel `DoubleStream` for the map's keys */ def asJavaParKeyDoubleStream [V](m: collection.Map[jl.Double, V]): DoubleStream = StreamSupport.doubleStream(m.keyStepper.spliterator, true) /** Creates a parallel [[java.util.stream.DoubleStream Java DoubleStream]] for the keys of a Scala Map. @@ -284,6 +428,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a parallel `DoubleStream` for the map's keys */ def asJavaParKeyDoubleStreamFromFloat[V](m: collection.Map[jl.Float, V]): DoubleStream = StreamSupport.doubleStream(m.keyStepper.spliterator, true) @@ -292,6 +440,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam V the value type of the map + * @param m the Scala Map whose keys to stream over + * @return a parallel `LongStream` for the map's keys */ def asJavaParKeyLongStream[V](m: collection.Map[jl.Long, V]): LongStream = StreamSupport.longStream(m.keyStepper.spliterator, true) @@ -300,6 +452,11 @@ object StreamConverters { /** Creates a parallel [[java.util.stream.Stream Java Stream]] for the values of a Scala Map. * * $parNote + * + * @tparam K the key type of the map + * @tparam V the value type of the map + * @param m the Scala Map whose values to stream over + * @return a parallel `Stream` for the map's values */ def asJavaParValueStream[K, V](m: collection.Map[K, V]): Stream[V] = StreamSupport.stream(m.valueStepper.spliterator, true) @@ -308,6 +465,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a parallel `IntStream` for the map's values */ def asJavaParValueIntStream [K](m: collection.Map[K, jl.Integer]): IntStream = StreamSupport.intStream(m.valueStepper.spliterator, true) /** Creates a parallel [[java.util.stream.IntStream Java IntStream]] for the values of a Scala Map. @@ -315,6 +476,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a parallel `IntStream` for the map's values */ def asJavaParValueIntStreamFromByte [K](m: collection.Map[K, jl.Byte]): IntStream = StreamSupport.intStream(m.valueStepper.spliterator, true) /** Creates a parallel [[java.util.stream.IntStream Java IntStream]] for the values of a Scala Map. @@ -322,6 +487,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a parallel `IntStream` for the map's values */ def asJavaParValueIntStreamFromShort[K](m: collection.Map[K, jl.Short]): IntStream = StreamSupport.intStream(m.valueStepper.spliterator, true) /** Creates a parallel [[java.util.stream.IntStream Java IntStream]] for the values of a Scala Map. @@ -329,6 +498,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a parallel `IntStream` for the map's values */ def asJavaParValueIntStreamFromChar [K](m: collection.Map[K, jl.Character]): IntStream = StreamSupport.intStream(m.valueStepper.spliterator, true) @@ -337,6 +510,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a parallel `DoubleStream` for the map's values */ def asJavaParValueDoubleStream [K](m: collection.Map[K, jl.Double]): DoubleStream = StreamSupport.doubleStream(m.valueStepper.spliterator, true) /** Creates a parallel [[java.util.stream.DoubleStream Java DoubleStream]] for the values of a Scala Map. @@ -344,6 +521,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a parallel `DoubleStream` for the map's values */ def asJavaParValueDoubleStreamFromFloat[K](m: collection.Map[K, jl.Float]): DoubleStream = StreamSupport.doubleStream(m.valueStepper.spliterator, true) @@ -352,6 +533,10 @@ object StreamConverters { * $parNote * * $primitiveNote + * + * @tparam K the key type of the map + * @param m the Scala Map whose values to stream over + * @return a parallel `LongStream` for the map's values */ def asJavaParValueLongStream[K](m: collection.Map[K, jl.Long]): LongStream = StreamSupport.longStream(m.valueStepper.spliterator, true) } diff --git a/library/src/scala/language.scala b/library/src/scala/language.scala index 04ec3d603d14..f6fe9b4e78fe 100644 --- a/library/src/scala/language.scala +++ b/library/src/scala/language.scala @@ -195,7 +195,7 @@ object language { * * @group experimental */ - object experimental { + object experimental: import languageFeature.experimental._ @@ -243,6 +243,13 @@ object language { @compileTimeOnly("`erasedDefinitions` can only be used at compile time in import statements") object erasedDefinitions + /** Experimental support for specialized traits + * + * @see [[docs/_docs/internals/specialized-traits.md]] + */ + @compileTimeOnly("`specializedTraits` can only be used at compile time in import statements") + object specializedTraits + /** Experimental support for relaxed CanEqual checks for ADT pattern matching * * @see [[https://github.com/scala/improvement-proposals/pull/97]] @@ -266,7 +273,7 @@ object language { /** Adds support for clause interleaving: * Methods can now have as many type clauses as they like, this allows to have type bounds depend on terms: `def f(x: Int)[A <: x.type]: A` * - * @see [[https://github.com/scala/improvement-proposals/blob/main/content/clause-interleaving.md]] + * @see [[https://docs.scala-lang.org/sips/clause-interleaving.html]] */ @compileTimeOnly("`clauseInterleaving` can only be used at compile time in import statements") @deprecated("`clauseInterleaving` is now standard, no language import is needed", since = "3.6") @@ -299,7 +306,7 @@ object language { * @see [[https://nightly.scala-lang.org/docs/reference/preview/into]] */ @compileTimeOnly("`into` can only be used at compile time in import statements") - @deprecated("The into language import is no longer needed since the feature is now in preview", since = "3.8") + @deprecated("The `into` language import is no longer needed since the feature is now in preview", since = "3.8") object into /** Experimental support for named tuples. @@ -307,7 +314,7 @@ object language { * @see [[https://nightly.scala-lang.org/docs/reference/experimental/named-tuples]] */ @compileTimeOnly("`namedTuples` can only be used at compile time in import statements") - @deprecated("The experimental.namedTuples language import is no longer needed since the feature is now standard", since = "3.7") + @deprecated("`experimental.namedTuples` is now standard, no language import is needed", since = "3.7") object namedTuples /** Experimental support for new features for better modularity, including @@ -327,7 +334,7 @@ object language { * @see [[https://nightly.scala-lang.org/docs/reference/contextual/extension-methods]] */ @compileTimeOnly("`relaxedExtensionImports` can only be used at compile time in import statements") - @deprecated("The experimental.relaxedExtensionImports language import is no longer needed since the feature is now standard", since = "3.4") + @deprecated("`experimental.relaxedExtensionImports` is now standard, no language import is needed", since = "3.4") object relaxedExtensionImports /** Enhance match type extractors to follow aliases and singletons. @@ -335,7 +342,7 @@ object language { * @see [[https://github.com/scala/improvement-proposals/pull/84]] */ @compileTimeOnly("`betterMatchTypeExtractors` can only be used at compile time in import statements") - @deprecated("The experimental.betterMatchTypeExtractors language import is no longer needed since the feature is now standard. It now has no effect, including when setting an older source version.", since = "3.6") + @deprecated("`experimental.betterMatchTypeExtractors` is now standard, no language import is needed", since = "3.6") object betterMatchTypeExtractors /** Experimental support for quote pattern matching with polymorphic functions @@ -350,12 +357,13 @@ object language { * @see [[https://github.com/scala/improvement-proposals/pull/79]] */ @compileTimeOnly("`betterFors` can only be used at compile time in import statements") - @deprecated("The `experimental.betterFors` language import no longer has any effect, the feature is being stabilised and can be enabled using `-preview` flag", since = "3.7") + @deprecated("`experimental.betterFors` is now standard, no language import is needed", since = "3.7") object betterFors /** Experimental support for package object values */ @compileTimeOnly("`packageObjectValues` can only be used at compile time in import statements") + @deprecated("The `experimental.packageObjectValues` language import is no longer needed since the feature is now in preview", since = "3.10") object packageObjectValues /** Experimental support for multiple spread arguments. @@ -368,7 +376,7 @@ object language { @compileTimeOnly("`subCases` can only be used at compile time in import statements") object subCases - /** Experimental support for single-line lambdas and case clause expressions after `:` + /** Experimental support for single-line lambdas and case clause expressions after `:` */ @compileTimeOnly("`relaxedLambdaSyntax` can only be used at compile time in import statements") object relaxedLambdaSyntax @@ -377,9 +385,9 @@ object language { */ @compileTimeOnly("`safe` can only be used at compile time in import statements") object safe - } + end experimental - /** The deprecated object contains features that are no longer officially suypported in Scala. + /** The deprecated object contains features that are no longer officially suypported in Scala. * Features in this object are slated for removal. New code should not use them and * old code should migrate away from them. */ @@ -600,4 +608,37 @@ object language { */ @compileTimeOnly("`3.9` can only be used at compile time in import statements") object `3.9` + + /** Sets source version to 3.10-migration. + * + * @see [[https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html]] + */ + @compileTimeOnly("`3.10-migration` can only be used at compile time in import statements") + object `3.10-migration` + + /** Sets source version to 3.10 + * + * @see [[https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html]] + */ + @compileTimeOnly("`3.10` can only be used at compile time in import statements") + object `3.10` + + + /** Sets source version to 3.10-migration. + * + * @see [[https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html]] + */ + @compileTimeOnly("`3.11-migration` can only be used at compile time in import statements") + object `3.11-migration` + + /** Sets source version to 3.10 + * + * @see [[https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html]] + */ + @compileTimeOnly("`3.11` can only be used at compile time in import statements") + object `3.11` + + // !!! Keep in sync with dotty.tools.dotc.config.SourceVersion !!! + // When adding a new `3.x` / `3.x-migration` here, add matching tests: + // `tests/pos/source-import-3-x.scala` and `tests/pos/source-import-3-x-migration.scala`. } diff --git a/library/src/scala/math/BigDecimal.scala b/library/src/scala/math/BigDecimal.scala index 1914f3ee28db..60623fb1f246 100644 --- a/library/src/scala/math/BigDecimal.scala +++ b/library/src/scala/math/BigDecimal.scala @@ -48,16 +48,26 @@ object BigDecimal { val UNNECESSARY = Value(JRM.UNNECESSARY.ordinal) } - /** Constructs a `BigDecimal` using the decimal text representation of `Double` value `d`, rounding if necessary. */ + /** Constructs a `BigDecimal` using the decimal text representation of `Double` value `d`, rounding if necessary. + * + * @param d the `Double` value to convert to a `BigDecimal` + * @param mc the precision and rounding mode for the conversion + */ def decimal(d: Double, mc: MathContext): BigDecimal = new BigDecimal(new BigDec(java.lang.Double.toString(d), mc), mc) - /** Constructs a `BigDecimal` using the decimal text representation of `Double` value `d`. */ + /** Constructs a `BigDecimal` using the decimal text representation of `Double` value `d`. + * + * @param d the `Double` value to convert to a `BigDecimal` + */ def decimal(d: Double): BigDecimal = decimal(d, defaultMathContext) /** Constructs a `BigDecimal` using the decimal text representation of `Float` value `f`, rounding if necessary. * Note that `BigDecimal.decimal(0.1f) != 0.1f` since equality agrees with the `Double` representation, and * `0.1 != 0.1f`. + * + * @param f the `Float` value to convert to a `BigDecimal` + * @param mc the precision and rounding mode for the conversion */ def decimal(f: Float, mc: MathContext): BigDecimal = new BigDecimal(new BigDec(java.lang.Float.toString(f), mc), mc) @@ -65,18 +75,31 @@ object BigDecimal { /** Constructs a `BigDecimal` using the decimal text representation of `Float` value `f`. * Note that `BigDecimal.decimal(0.1f) != 0.1f` since equality agrees with the `Double` representation, and * `0.1 != 0.1f`. + * + * @param f the `Float` value to convert to a `BigDecimal` */ def decimal(f: Float): BigDecimal = decimal(f, defaultMathContext) // This exists solely to avoid conversion from Int/Long to Float, screwing everything up. - /** Constructs a `BigDecimal` from a `Long`, rounding if necessary. This is identical to `BigDecimal(l, mc)`. */ + /** Constructs a `BigDecimal` from a `Long`, rounding if necessary. This is identical to `BigDecimal(l, mc)`. + * + * @param l the `Long` value to convert to a `BigDecimal` + * @param mc the precision and rounding mode for the conversion + */ def decimal(l: Long, mc: MathContext): BigDecimal = apply(l, mc) // This exists solely to avoid conversion from Int/Long to Float, screwing everything up. - /** Constructs a `BigDecimal` from a `Long`. This is identical to `BigDecimal(l)`. */ + /** Constructs a `BigDecimal` from a `Long`. This is identical to `BigDecimal(l)`. + * + * @param l the `Long` value to convert to a `BigDecimal` + */ def decimal(l: Long): BigDecimal = apply(l) - /** Constructs a `BigDecimal` using a `java.math.BigDecimal`, rounding if necessary. */ + /** Constructs a `BigDecimal` using a `java.math.BigDecimal`, rounding if necessary. + * + * @param bd the `java.math.BigDecimal` to convert + * @param mc the precision and rounding mode for the conversion + */ def decimal(bd: BigDec, mc: MathContext): BigDecimal = new BigDecimal(bd.round(mc), mc) /** Constructs a `BigDecimal` by expanding the binary fraction @@ -84,18 +107,25 @@ object BigDecimal { * rounding if necessary. When a `Float` is converted to a * `Double`, the binary fraction is preserved, so this method * also works for converted `Float`s. + * + * @param d the `Double` value whose binary fraction is expanded + * @param mc the precision and rounding mode for the conversion */ def binary(d: Double, mc: MathContext): BigDecimal = new BigDecimal(new BigDec(d, mc), mc) /** Constructs a `BigDecimal` by expanding the binary fraction * contained by `Double` value `d` into a decimal representation. * Note: this also works correctly on converted `Float`s. + * + * @param d the `Double` value whose binary fraction is expanded */ def binary(d: Double): BigDecimal = binary(d, defaultMathContext) /** Constructs a `BigDecimal` from a `java.math.BigDecimal`. The * precision is the default for `BigDecimal` or enough to represent * the `java.math.BigDecimal` exactly, whichever is greater. + * + * @param repr the `java.math.BigDecimal` to represent exactly */ def exact(repr: BigDec): BigDecimal = { val mc = @@ -107,25 +137,36 @@ object BigDecimal { /** Constructs a `BigDecimal` by fully expanding the binary fraction * contained by `Double` value `d`, adjusting the precision as * necessary. Note: this works correctly on converted `Float`s also. + * + * @param d the `Double` value whose binary fraction is fully expanded */ def exact(d: Double): BigDecimal = exact(new BigDec(d)) - /** Constructs a `BigDecimal` that exactly represents a `BigInt`. */ + /** Constructs a `BigDecimal` that exactly represents a `BigInt`. + * + * @param bi the `BigInt` value to represent exactly + */ def exact(bi: BigInt): BigDecimal = exact(new BigDec(bi.bigInteger)) /** Constructs a `BigDecimal` that exactly represents a `Long`. Note that * all creation methods for `BigDecimal` that do not take a `MathContext` * represent a `Long`; this is equivalent to `apply`, `valueOf`, etc.. + * + * @param l the `Long` value to represent exactly */ def exact(l: Long): BigDecimal = apply(l) /** Constructs a `BigDecimal` that exactly represents the number * specified in a `String`. + * + * @param s the string representation of the number */ def exact(s: String): BigDecimal = exact(new BigDec(s)) /** Constructs a `BigDecimal` that exactly represents the number * specified in base 10 in a character array. + * + * @param cs the character array containing the decimal representation */ def exact(cs: Array[Char]): BigDecimal = exact(new BigDec(cs)) @@ -233,22 +274,32 @@ object BigDecimal { /** Translates a character array representation of a `BigDecimal` * into a `BigDecimal`. + * + * @param x the character array containing the decimal representation */ def apply(x: Array[Char]): BigDecimal = exact(x) /** Translates a character array representation of a `BigDecimal` * into a `BigDecimal`, rounding if necessary. + * + * @param x the character array containing the decimal representation + * @param mc the precision and rounding mode for creation of this value and future operations on it */ def apply(x: Array[Char], mc: MathContext): BigDecimal = new BigDecimal(new BigDec(x, mc), mc) /** Translates the decimal String representation of a `BigDecimal` * into a `BigDecimal`. + * + * @param x the string representation of the decimal value */ def apply(x: String): BigDecimal = exact(x) /** Translates the decimal String representation of a `BigDecimal` * into a `BigDecimal`, rounding if necessary. + * + * @param x the string representation of the decimal value + * @param mc the precision and rounding mode for creation of this value and future operations on it */ def apply(x: String, mc: MathContext): BigDecimal = new BigDecimal(new BigDec(x, mc), mc) @@ -292,16 +343,28 @@ object BigDecimal { def apply(unscaledVal: BigInt, scale: Int, mc: MathContext): BigDecimal = new BigDecimal(new BigDec(unscaledVal.bigInteger, scale, mc), mc) - /** Constructs a `BigDecimal` from a `java.math.BigDecimal`. */ + /** Constructs a `BigDecimal` from a `java.math.BigDecimal`. + * + * @param bd the `java.math.BigDecimal` to convert + */ def apply(bd: BigDec): BigDecimal = new BigDecimal(bd, defaultMathContext) - /** Implicit conversion from `Int` to `BigDecimal`. */ + /** Implicit conversion from `Int` to `BigDecimal`. + * + * @param i the `Int` value to convert + */ implicit def int2bigDecimal(i: Int): BigDecimal = apply(i) - /** Implicit conversion from `Long` to `BigDecimal`. */ + /** Implicit conversion from `Long` to `BigDecimal`. + * + * @param l the `Long` value to convert + */ implicit def long2bigDecimal(l: Long): BigDecimal = apply(l) - /** Implicit conversion from `Double` to `BigDecimal`. */ + /** Implicit conversion from `Double` to `BigDecimal`. + * + * @param d the `Double` value to convert + */ implicit def double2bigDecimal(d: Double): BigDecimal = decimal(d) // For the following function, both the parameter and the return type are non-nullable. @@ -309,7 +372,10 @@ object BigDecimal { // We intentionally keep this signature to discourage passing nulls implicitly while // preserving the previous behavior for backward compatibility. - /** Implicit conversion from `java.math.BigDecimal` to `scala.BigDecimal`. */ + /** Implicit conversion from `java.math.BigDecimal` to `scala.BigDecimal`. + * + * @param x the `java.math.BigDecimal` to convert + */ implicit def javaBigDecimal2bigDecimal(x: BigDec): BigDecimal = mapNull(x, apply(x)) } @@ -358,6 +424,9 @@ object BigDecimal { * and powers. The left-hand argument's `MathContext` always determines the * degree of rounding, if any, and is the one propagated through arithmetic * operations that do not apply rounding themselves. + * + * @param bigDecimal the underlying `java.math.BigDecimal` + * @param mc the `MathContext` specifying the precision and rounding mode for operations */ final class BigDecimal(val bigDecimal: BigDec, val mc: MathContext) extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[BigDecimal] { @@ -403,6 +472,8 @@ extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[ /** Compares this BigDecimal with the specified value for equality. Where `Float` and `Double` * disagree, `BigDecimal` will agree with the `Double` value + * + * @param that the value to compare with this `BigDecimal` */ override def equals (that: Any): Boolean = that match { case that: BigDecimal => this equals that @@ -474,55 +545,93 @@ extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[ def underlying: java.math.BigDecimal = bigDecimal - /** Compares this BigDecimal with the specified BigDecimal for equality. */ + /** Compares this BigDecimal with the specified BigDecimal for equality. + * + * @param that the `BigDecimal` to compare with + */ def equals (that: BigDecimal): Boolean = compare(that) == 0 - /** Compares this BigDecimal with the specified BigDecimal */ + /** Compares this BigDecimal with the specified BigDecimal + * + * @param that the `BigDecimal` to compare with + */ def compare (that: BigDecimal): Int = this.bigDecimal.compareTo(that.bigDecimal) - /** Addition of BigDecimals */ + /** Addition of BigDecimals + * + * @param that the `BigDecimal` to add to this value + */ def + (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal.add(that.bigDecimal, mc), mc) - /** Subtraction of BigDecimals */ + /** Subtraction of BigDecimals + * + * @param that the `BigDecimal` to subtract from this value + */ def - (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal.subtract(that.bigDecimal, mc), mc) - /** Multiplication of BigDecimals */ + /** Multiplication of BigDecimals + * + * @param that the `BigDecimal` to multiply with this value + */ def * (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal.multiply(that.bigDecimal, mc), mc) - /** Division of BigDecimals */ + /** Division of BigDecimals + * + * @param that the `BigDecimal` to divide this value by + */ def / (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal.divide(that.bigDecimal, mc), mc) /** Division and Remainder - returns tuple containing the result of * divideToIntegralValue and the remainder. The computation is exact: no rounding is applied. + * + * @param that the `BigDecimal` divisor */ def /% (that: BigDecimal): (BigDecimal, BigDecimal) = { val qr = this.bigDecimal.divideAndRemainder(that.bigDecimal, mc) (new BigDecimal(qr(0), mc), new BigDecimal(qr(1), mc)) } - /** Divide to Integral value. */ + /** Divide to Integral value. + * + * @param that the `BigDecimal` divisor + */ def quot (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal.divideToIntegralValue(that.bigDecimal, mc), mc) - /** Returns the minimum of this and that, or this if the two are equal */ + /** Returns the minimum of this and that, or this if the two are equal + * + * @param that the `BigDecimal` to compare with + */ def min (that: BigDecimal): BigDecimal = (this compare that) match { case x if x <= 0 => this case _ => that } - /** Returns the maximum of this and that, or this if the two are equal */ + /** Returns the maximum of this and that, or this if the two are equal + * + * @param that the `BigDecimal` to compare with + */ def max (that: BigDecimal): BigDecimal = (this compare that) match { case x if x >= 0 => this case _ => that } - /** Remainder after dividing this by that. */ + /** Remainder after dividing this by that. + * + * @param that the `BigDecimal` divisor + */ def remainder (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal.remainder(that.bigDecimal, mc), mc) - /** Remainder after dividing this by that. */ + /** Remainder after dividing this by that. + * + * @param that the `BigDecimal` divisor + */ def % (that: BigDecimal): BigDecimal = this.remainder(that) - /** Returns a BigDecimal whose value is this ** n. */ + /** Returns a BigDecimal whose value is this ** n. + * + * @param n the exponent to raise this `BigDecimal` to + */ def pow (n: Int): BigDecimal = new BigDecimal(this.bigDecimal.pow(n, mc), mc) /** Returns a BigDecimal whose value is the negation of this BigDecimal */ @@ -550,6 +659,8 @@ extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[ /** Returns a BigDecimal rounded according to the supplied MathContext settings, but * preserving its own MathContext for future operations. + * + * @param mc the `MathContext` specifying the precision and rounding mode */ def round(mc: MathContext): BigDecimal = { val r = this.bigDecimal.round(mc) @@ -568,11 +679,16 @@ extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[ /** Returns the size of an ulp, a unit in the last place, of this BigDecimal. */ def ulp: BigDecimal = new BigDecimal(this.bigDecimal.ulp, mc) - /** Returns a new BigDecimal based on the supplied MathContext, rounded as needed. */ + /** Returns a new BigDecimal based on the supplied MathContext, rounded as needed. + * + * @param mc the new `MathContext` for precision and rounding + */ def apply(mc: MathContext): BigDecimal = new BigDecimal(this.bigDecimal.round(mc), mc) /** Returns a `BigDecimal` whose scale is the specified value, and whose value is * numerically equal to this BigDecimal's. + * + * @param scale the scale to set for this `BigDecimal` */ def setScale(scale: Int): BigDecimal = if (this.scale == scale) this @@ -665,7 +781,7 @@ extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[ * `[start;end)`, where start is the target BigDecimal. The step * must be supplied via the "by" method of the returned object in order * to receive the fully constructed range. For example: - * ``` + * ```scala sc:compile * val partial = BigDecimal(1.0) to 2.0 // not usable yet * val range = partial by 0.01 // now a NumericRange * val range2 = BigDecimal(0) to 1.0 by 0.01 // all at once of course is fine too @@ -677,14 +793,25 @@ extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[ def until(end: BigDecimal): Range.Partial[BigDecimal, NumericRange.Exclusive[BigDecimal]] = new Range.Partial(until(end, _)) - /** Same as the one-argument `until`, but creates the range immediately. */ + /** Same as the one-argument `until`, but creates the range immediately. + * + * @param end the end value of the range (exclusive) + * @param step the increment between successive values in the range + */ def until(end: BigDecimal, step: BigDecimal): NumericRange.Exclusive[BigDecimal] = Range.BigDecimal(this, end, step) - /** Like `until`, but inclusive of the end value. */ + /** Like `until`, but inclusive of the end value. + * + * @param end the end value of the range (inclusive) + */ def to(end: BigDecimal): Range.Partial[BigDecimal, NumericRange.Inclusive[BigDecimal]] = new Range.Partial(to(end, _)) - /** Like `until`, but inclusive of the end value. */ + /** Like `until`, but inclusive of the end value. + * + * @param end the end value of the range (inclusive) + * @param step the increment between successive values in the range + */ def to(end: BigDecimal, step: BigDecimal) = Range.BigDecimal.inclusive(this, end, step) /** Converts this `BigDecimal` to a scala.BigInt. */ diff --git a/library/src/scala/math/BigInt.scala b/library/src/scala/math/BigInt.scala index 78e7d7cb6164..09db16d6d8a8 100644 --- a/library/src/scala/math/BigInt.scala +++ b/library/src/scala/math/BigInt.scala @@ -64,6 +64,8 @@ object BigInt { /** Translates a byte array containing the two's-complement binary * representation of a BigInt into a BigInt. + * + * @param x the two's-complement big-endian binary representation of a `BigInt` */ def apply(x: Array[Byte]): BigInt = apply(new BigInteger(x)) @@ -74,33 +76,50 @@ object BigInt { * for positive). * @param magnitude big-endian binary representation of the magnitude of * the number. + * @return the `BigInt` with the specified sign and magnitude */ def apply(signum: Int, magnitude: Array[Byte]): BigInt = apply(new BigInteger(signum, magnitude)) /** Constructs a randomly generated positive BigInt that is probably prime, * with the specified bitLength. + * + * @param bitlength the bit length of the generated probable prime `BigInt` + * @param certainty a measure of the uncertainty that the caller is willing to tolerate: the probability of primality exceeds `(1 - 1/2 ^ certainty)` + * @param rnd the source of randomness used to generate the candidate */ def apply(bitlength: Int, certainty: Int, rnd: scala.util.Random): BigInt = apply(new BigInteger(bitlength, certainty, rnd.self)) /** Constructs a randomly generated BigInt, uniformly distributed over the * range `0` to `(2 ^ numBits - 1)`, inclusive. + * + * @param numbits the number of random bits used to generate the `BigInt` + * @param rnd the source of randomness used for the generation */ def apply(numbits: Int, rnd: scala.util.Random): BigInt = apply(new BigInteger(numbits, rnd.self)) - /** Translates the decimal String representation of a BigInt into a BigInt. */ + /** Translates the decimal String representation of a BigInt into a BigInt. + * + * @param x the decimal string representation of the `BigInt` + */ def apply(x: String): BigInt = apply(new BigInteger(x)) /** Translates the string representation of a `BigInt` in the * specified `radix` into a BigInt. + * + * @param x the string representation of the `BigInt` in the specified radix + * @param radix the radix to use when parsing `x` */ def apply(x: String, radix: Int): BigInt = apply(new BigInteger(x, radix)) - /** Translates a `java.math.BigInteger` into a BigInt. */ + /** Translates a `java.math.BigInteger` into a BigInt. + * + * @param x the `java.math.BigInteger` value to convert + */ def apply(x: BigInteger): BigInt = { if (x.bitLength <= 63) { val l = x.longValue @@ -108,14 +127,24 @@ object BigInt { } else new BigInt(x, Long.MinValue) } - /** Returns a positive BigInt that is probably prime, with the specified bitLength. */ + /** Returns a positive BigInt that is probably prime, with the specified bitLength. + * + * @param bitLength the bit length of the returned probable prime `BigInt` + * @param rnd the source of randomness used to generate the candidate + */ def probablePrime(bitLength: Int, rnd: scala.util.Random): BigInt = apply(BigInteger.probablePrime(bitLength, rnd.self)) - /** Implicit conversion from `Int` to `BigInt`. */ + /** Implicit conversion from `Int` to `BigInt`. + * + * @param i the `Int` value to convert + */ implicit def int2bigInt(i: Int): BigInt = apply(i) - /** Implicit conversion from `Long` to `BigInt`. */ + /** Implicit conversion from `Long` to `BigInt`. + * + * @param l the `Long` value to convert + */ implicit def long2bigInt(l: Long): BigInt = apply(l) // For the following function, both the parameter and the return type are non-nullable. @@ -123,7 +152,10 @@ object BigInt { // We intentionally keep this signature to discourage passing nulls implicitly while // preserving the previous behavior for backward compatibility. - /** Implicit conversion from `java.math.BigInteger` to `scala.BigInt`. */ + /** Implicit conversion from `java.math.BigInteger` to `scala.BigInt`. + * + * @param x the `java.math.BigInteger` value to convert + */ implicit def javaBigInteger2bigInt(x: BigInteger): BigInt = mapNull(x, apply(x)) // this method is adapted from Google Guava's version at @@ -132,7 +164,11 @@ object BigInt { // * Copyright (C) 2011 The Guava Authors // * // * Licensed under the Apache License, Version 2.0 (the "License") - /** Returns the greatest common divisor of a and b. Returns 0 if a == 0 && b == 0. */ + /** Returns the greatest common divisor of a and b. Returns 0 if a == 0 && b == 0. + * + * @param a the first non-negative operand + * @param b the second non-negative operand + */ private def longGcd(a: Long, b: Long): Long = { // both a and b must be >= 0 if (a == 0) { // 0 % b == 0, so b divides a, but the converse doesn't hold. @@ -201,7 +237,10 @@ final class BigInt private ( // // Additionally, we know that if this.isValidLong is true, then _long is the encoded value. - /** Public constructor present for compatibility. Use the BigInt.apply companion object method instead. */ + /** Public constructor present for compatibility. Use the BigInt.apply companion object method instead. + * + * @param bigInteger the `java.math.BigInteger` value to wrap + */ def this(bigInteger: BigInteger) = this( bigInteger, // even if it is a short BigInteger, we cache the instance if (bigInteger.bitLength <= 63) @@ -282,14 +321,20 @@ final class BigInt private ( def isWhole: Boolean = true def underlying: BigInteger = bigInteger - /** Compares this BigInt with the specified BigInt for equality. */ + /** Compares this BigInt with the specified BigInt for equality. + * + * @param that the `BigInt` to compare against + */ def equals(that: BigInt): Boolean = if (this.longEncoding) that.longEncoding && (this._long == that._long) else !that.longEncoding && (this._bigInteger == that._bigInteger) - /** Compares this BigInt with the specified BigInt */ + /** Compares this BigInt with the specified BigInt + * + * @param that the `BigInt` to compare against + */ def compare(that: BigInt): Int = if (this.longEncoding) { if (that.longEncoding) java.lang.Long.compare(this._long, that._long) else -that._bigInteger.nn.signum() @@ -297,7 +342,10 @@ final class BigInt private ( if (that.longEncoding) _bigInteger.nn.signum() else this._bigInteger.nn.compareTo(that._bigInteger) } - /** Addition of BigInts */ + /** Addition of BigInts + * + * @param that the value to add to this `BigInt` + */ def +(that: BigInt): BigInt = { if (this.longEncoding && that.longEncoding) { // fast path val x = this._long @@ -308,7 +356,10 @@ final class BigInt private ( BigInt(this.bigInteger.add(that.bigInteger)) } - /** Subtraction of BigInts */ + /** Subtraction of BigInts + * + * @param that the value to subtract from this `BigInt` + */ def -(that: BigInt): BigInt = { if (this.longEncoding && that.longEncoding) { // fast path val x = this._long @@ -319,7 +370,10 @@ final class BigInt private ( BigInt(this.bigInteger.subtract(that.bigInteger)) } - /** Multiplication of BigInts */ + /** Multiplication of BigInts + * + * @param that the value to multiply with this `BigInt` + */ def *(that: BigInt): BigInt = { if (this.longEncoding && that.longEncoding) { // fast path val x = this._long @@ -332,7 +386,10 @@ final class BigInt private ( BigInt(this.bigInteger.multiply(that.bigInteger)) } - /** Division of BigInts */ + /** Division of BigInts + * + * @param that the divisor + */ def /(that: BigInt): BigInt = // in the fast path, note that the original code avoided storing -Long.MinValue in a long: // if (this._long != Long.MinValue || that._long != -1) return BigInt(this._long / that._long) @@ -340,13 +397,19 @@ final class BigInt private ( if (this.longEncoding && that.longEncoding) BigInt(this._long / that._long) else BigInt(this.bigInteger.divide(that.bigInteger)) - /** Remainder of BigInts */ + /** Remainder of BigInts + * + * @param that the divisor + */ def %(that: BigInt): BigInt = // see / for the original logic regarding Long.MinValue if (this.longEncoding && that.longEncoding) BigInt(this._long % that._long) else BigInt(this.bigInteger.remainder(that.bigInteger)) - /** Returns a pair of two BigInts containing (this / that) and (this % that). */ + /** Returns a pair of two BigInts containing (this / that) and (this % that). + * + * @param that the divisor + */ def /%(that: BigInt): (BigInt, BigInt) = if (this.longEncoding && that.longEncoding) { val x = this._long @@ -358,11 +421,17 @@ final class BigInt private ( (BigInt(dr(0)), BigInt(dr(1))) } - /** Leftshift of BigInt */ + /** Leftshift of BigInt + * + * @param n the number of bits to shift left + */ def <<(n: Int): BigInt = if (longEncoding && n <= 0) (this >> (-n)) else BigInt(this.bigInteger.shiftLeft(n)) - /** (Signed) rightshift of BigInt */ + /** (Signed) rightshift of BigInt + * + * @param n the number of bits to shift right + */ def >>(n: Int): BigInt = if (longEncoding && n >= 0) { if (n < 64) BigInt(_long >> n) @@ -370,31 +439,46 @@ final class BigInt private ( else BigInt(0) // for _long >= 0 } else BigInt(this.bigInteger.shiftRight(n)) - /** Bitwise and of BigInts */ + /** Bitwise and of BigInts + * + * @param that the value to AND with this `BigInt` + */ def &(that: BigInt): BigInt = if (this.longEncoding && that.longEncoding) BigInt(this._long & that._long) else BigInt(this.bigInteger.and(that.bigInteger)) - /** Bitwise or of BigInts */ + /** Bitwise or of BigInts + * + * @param that the value to OR with this `BigInt` + */ def |(that: BigInt): BigInt = if (this.longEncoding && that.longEncoding) BigInt(this._long | that._long) else BigInt(this.bigInteger.or(that.bigInteger)) - /** Bitwise exclusive-or of BigInts */ + /** Bitwise exclusive-or of BigInts + * + * @param that the value to XOR with this `BigInt` + */ def ^(that: BigInt): BigInt = if (this.longEncoding && that.longEncoding) BigInt(this._long ^ that._long) else BigInt(this.bigInteger.xor(that.bigInteger)) - /** Bitwise and-not of BigInts. Returns a BigInt whose value is (this & ~that). */ + /** Bitwise and-not of BigInts. Returns a BigInt whose value is (this & ~that). + * + * @param that the value whose complement is ANDed with this `BigInt` + */ def &~(that: BigInt): BigInt = if (this.longEncoding && that.longEncoding) BigInt(this._long & ~that._long) else BigInt(this.bigInteger.andNot(that.bigInteger)) - /** Returns the greatest common divisor of abs(this) and abs(that) */ + /** Returns the greatest common divisor of abs(this) and abs(that) + * + * @param that the other value for computing the greatest common divisor + */ def gcd(that: BigInt): BigInt = if (this.longEncoding) { if (this._long == 0) return that.abs @@ -427,23 +511,38 @@ final class BigInt private ( if (res >= 0) BigInt(res) else BigInt(res + that._long) } else BigInt(this.bigInteger.mod(that.bigInteger)) - /** Returns the minimum of this and that */ + /** Returns the minimum of this and that + * + * @param that the value to compare with this `BigInt` + */ def min(that: BigInt): BigInt = if (this <= that) this else that - /** Returns the maximum of this and that */ + /** Returns the maximum of this and that + * + * @param that the value to compare with this `BigInt` + */ def max(that: BigInt): BigInt = if (this >= that) this else that - /** Returns a BigInt whose value is (this raised to the power of exp). */ + /** Returns a BigInt whose value is (this raised to the power of exp). + * + * @param exp the exponent, must be non-negative + */ def pow(exp: Int): BigInt = BigInt(this.bigInteger.pow(exp)) /** Returns a BigInt whose value is * (this raised to the power of exp modulo m). + * + * @param exp the exponent + * @param m the modulus, must be positive */ def modPow(exp: BigInt, m: BigInt): BigInt = BigInt(this.bigInteger.modPow(exp.bigInteger, m.bigInteger)) - /** Returns a BigInt whose value is (the inverse of this modulo m). */ + /** Returns a BigInt whose value is (the inverse of this modulo m). + * + * @param m the modulus, must be positive + */ def modInverse(m: BigInt): BigInt = BigInt(this.bigInteger.modInverse(m.bigInteger)) /** Returns a BigInt whose value is the negation of this BigInt */ @@ -471,7 +570,10 @@ final class BigInt private ( // it is equal to -(this + 1) if (longEncoding && _long != Long.MaxValue) BigInt(-(_long + 1)) else BigInt(this.bigInteger.not()) - /** Returns true if and only if the designated bit is set. */ + /** Returns true if and only if the designated bit is set. + * + * @param n the zero-based index of the bit to test + */ def testBit(n: Int): Boolean = if (longEncoding && n >= 0) { if (n <= 63) @@ -480,15 +582,24 @@ final class BigInt private ( _long < 0 // give the sign bit } else this.bigInteger.testBit(n) - /** Returns a BigInt whose value is equivalent to this BigInt with the designated bit set. */ + /** Returns a BigInt whose value is equivalent to this BigInt with the designated bit set. + * + * @param n the zero-based index of the bit to set + */ def setBit(n: Int): BigInt = // note that we do not operate on the Long sign bit #63 if (longEncoding && n <= 62 && n >= 0) BigInt(_long | (1L << n)) else BigInt(this.bigInteger.setBit(n)) - /** Returns a BigInt whose value is equivalent to this BigInt with the designated bit cleared. */ + /** Returns a BigInt whose value is equivalent to this BigInt with the designated bit cleared. + * + * @param n the zero-based index of the bit to clear + */ def clearBit(n: Int): BigInt = // note that we do not operate on the Long sign bit #63 if (longEncoding && n <= 62 && n >= 0) BigInt(_long & ~(1L << n)) else BigInt(this.bigInteger.clearBit(n)) - /** Returns a BigInt whose value is equivalent to this BigInt with the designated bit flipped. */ + /** Returns a BigInt whose value is equivalent to this BigInt with the designated bit flipped. + * + * @param n the zero-based index of the bit to flip + */ def flipBit(n: Int): BigInt = // note that we do not operate on the Long sign bit #63 if (longEncoding && n <= 62 && n >= 0) BigInt(_long ^ (1L << n)) else BigInt(this.bigInteger.flipBit(n)) @@ -586,17 +697,24 @@ final class BigInt private ( * * @param end the end value of the range (exclusive) * @param step the distance between elements (defaults to 1) - * @return the range + * @return the exclusive `NumericRange` from this to `end` */ def until(end: BigInt, step: BigInt = BigInt(1)): NumericRange.Exclusive[BigInt] = Range.BigInt(this, end, step) - /** Like until, but inclusive of the end value. */ + /** Like until, but inclusive of the end value. + * + * @param end the end value of the range (inclusive) + * @param step the distance between elements (defaults to 1) + */ def to(end: BigInt, step: BigInt = BigInt(1)): NumericRange.Inclusive[BigInt] = Range.BigInt.inclusive(this, end, step) /** Returns the decimal String representation of this BigInt. */ override def toString(): String = if (longEncoding) _long.toString() else _bigInteger.toString() - /** Returns the String representation in the specified radix of this BigInt. */ + /** Returns the String representation in the specified radix of this BigInt. + * + * @param radix the radix to use in the string representation + */ def toString(radix: Int): String = this.bigInteger.toString(radix) /** Returns a byte array containing the two's-complement representation of diff --git a/library/src/scala/math/Equiv.scala b/library/src/scala/math/Equiv.scala index 120967714c0d..2c7b8d0123eb 100644 --- a/library/src/scala/math/Equiv.scala +++ b/library/src/scala/math/Equiv.scala @@ -30,10 +30,16 @@ import scala.annotation.migration * 1. symmetric: `equiv(x, y) == equiv(y, x)` for any `x` and `y` of type `T`. * 1. transitive: if `equiv(x, y) == true` and `equiv(y, z) == true`, then * `equiv(x, z) == true` for any `x`, `y`, and `z` of type `T`. + * + * @tparam T the type of values being compared for equivalence */ trait Equiv[T] extends Any with Serializable { - /** Returns `true` iff `x` is equivalent to `y`. */ + /** Returns `true` iff `x` is equivalent to `y`. + * + * @param x the first value to compare + * @param y the second value to compare + */ def equiv(x: T, y: T): Boolean } @@ -95,10 +101,16 @@ object Equiv extends LowPriorityEquiv { trait ExtraImplicits { /** Not in the standard scope due to the potential for divergence: * For instance `implicitly[Equiv[Any]]` diverges in its presence. + * + * @tparam CC the collection type constructor, a subtype of `Seq` (e.g., `List`, `Vector`) + * @tparam T the element type of the collection */ implicit def seqEquiv[CC[X] <: scala.collection.Seq[X], T](implicit eqv: Equiv[T]): Equiv[CC[T]] = new IterableEquiv[CC, T](eqv) + /** @tparam CC the collection type constructor, a subtype of `SortedSet` + * @tparam T the element type of the collection + */ implicit def sortedSetEquiv[CC[X] <: scala.collection.SortedSet[X], T](implicit eqv: Equiv[T]): Equiv[CC[T]] = new IterableEquiv[CC, T](eqv) } diff --git a/library/src/scala/math/Integral.scala b/library/src/scala/math/Integral.scala index 89465fb81023..1c41fcdf8980 100644 --- a/library/src/scala/math/Integral.scala +++ b/library/src/scala/math/Integral.scala @@ -35,6 +35,10 @@ object Integral { /** The regrettable design of Numeric/Integral/Fractional has them all * bumping into one another when searching for this implicit, so they * are exiled into their own companions. + * + * @tparam T the numeric type for which an `Integral` instance exists + * @param x the value to wrap with integral operator syntax (`/`, `%`, `/%`) + * @param num the implicit `Integral` instance for type `T` */ implicit def infixIntegralOps[T](x: T)(implicit num: Integral[T]): Integral[T]#IntegralOps = new num.IntegralOps(x) } diff --git a/library/src/scala/math/Numeric.scala b/library/src/scala/math/Numeric.scala index b12c05451295..622c552a6657 100644 --- a/library/src/scala/math/Numeric.scala +++ b/library/src/scala/math/Numeric.scala @@ -25,9 +25,14 @@ object Numeric { /** These implicits create conversions from a value for which an implicit Numeric * exists to the inner class which creates infix operations. Once imported, you * can write methods as follows: - * ``` + * ```scala sc:compile + * import scala.math.Numeric.Implicits.* * def plus[T: Numeric](x: T, y: T) = x + y * ``` + * + * @tparam T the numeric type for which a `Numeric` instance exists + * @param x the value to wrap with numeric infix operations + * @param num the implicit `Numeric` instance that provides the arithmetic operations */ implicit def infixNumericOps[T](x: T)(implicit num: Numeric[T]): Numeric[T]#NumericOps = new num.NumericOps(x) } diff --git a/library/src/scala/math/Ordered.scala b/library/src/scala/math/Ordered.scala index ad7c63ddcbe1..f7c42a0a4b43 100644 --- a/library/src/scala/math/Ordered.scala +++ b/library/src/scala/math/Ordered.scala @@ -34,7 +34,7 @@ import scala.language.implicitConversions * [[scala.math.PartiallyOrdered]] is an alternative to this trait for partially ordered data. * * For example, create a simple class that implements `Ordered` and then sort it with [[scala.util.Sorting]]: - * ``` + * ```scala sc:compile * case class OrderedClass(n:Int) extends Ordered[OrderedClass] { * def compare(that: OrderedClass) = this.n - that.n * } @@ -56,6 +56,8 @@ import scala.language.implicitConversions * provide it yourself either when inheriting or instantiating. * * @see [[scala.math.Ordering]], [[scala.math.PartiallyOrdered]] + * + * @tparam A the type of the objects that this object can be compared to */ trait Ordered[A] extends Any with java.lang.Comparable[A] { @@ -70,13 +72,22 @@ trait Ordered[A] extends Any with java.lang.Comparable[A] { * - `x == 0` when `this == that` * * - `x > 0` when `this > that` + * + * @param that the instance to compare against + * @return an integer whose sign indicates the ordering relation between `this` and `that` */ def compare(that: A): Int - /** Returns true if `this` is less than `that` */ + /** Returns true if `this` is less than `that` + * + * @param that the instance to compare against + */ def < (that: A): Boolean = (this compare that) < 0 - /** Returns true if `this` is greater than `that`. */ + /** Returns true if `this` is greater than `that`. + * + * @param that the instance to compare against + */ def > (that: A): Boolean = (this compare that) > 0 /** Returns true if `this` is less than or equal to `that`. */ @@ -85,12 +96,20 @@ trait Ordered[A] extends Any with java.lang.Comparable[A] { /** Returns true if `this` is greater than or equal to `that`. */ def >= (that: A): Boolean = (this compare that) >= 0 - /** Result of comparing `this` with operand `that`. */ + /** Result of comparing `this` with operand `that`. + * + * @param that the instance to compare against + */ def compareTo(that: A): Int = compare(that) } object Ordered { - /** Lens from `Ordering[T]` to `Ordered[T]`. */ + /** Lens from `Ordering[T]` to `Ordered[T]`. + * + * @tparam T the type of the value to be wrapped as `Ordered` + * @param x the value to be converted to an `Ordered` instance + * @param ord the implicit `Ordering` instance used to perform comparisons + */ implicit def orderingToOrdered[T](x: T)(implicit ord: Ordering[T]): Ordered[T] = new Ordered[T] { def compare(that: T): Int = ord.compare(x, that) } } diff --git a/library/src/scala/math/Ordering.scala b/library/src/scala/math/Ordering.scala index 3275362f018b..88ba27084cac 100644 --- a/library/src/scala/math/Ordering.scala +++ b/library/src/scala/math/Ordering.scala @@ -29,15 +29,21 @@ import scala.annotation.unchecked.uncheckedOverride * To sort instances by one or more member variables, you can take advantage * of these built-in orderings using [[Ordering.by]] and [[Ordering.on]]: * - * ``` + * ```scala sc:compile * import scala.util.Sorting * val pairs = Array(("a", 5, 2), ("c", 3, 1), ("b", 1, 3)) * * // sort by 2nd element - * Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2)) + * { + * given Ordering[(String, Int, Int)] = Ordering.by[(String, Int, Int), Int](_._2) + * Sorting.quickSort(pairs) + * } * * // sort by the 3rd element, then 1st - * Sorting.quickSort(pairs)(Ordering[(Int, String)].on(x => (x._3, x._1))) + * { + * given Ordering[(String, Int, Int)] = Ordering.by[(String, Int, Int), (Int, String)](x => (x._3, x._1)) + * Sorting.quickSort(pairs) + * } * ``` * * An `Ordering[T]` is implemented by specifying the [[compare]] method, @@ -47,7 +53,7 @@ import scala.annotation.unchecked.uncheckedOverride * * For example: * - * ``` + * ```scala sc:compile * import scala.util.Sorting * * case class Person(name:String, age:Int) @@ -57,7 +63,8 @@ import scala.annotation.unchecked.uncheckedOverride * object AgeOrdering extends Ordering[Person] { * def compare(a:Person, b:Person) = a.age.compare(b.age) * } - * Sorting.quickSort(people)(AgeOrdering) + * given Ordering[Person] = AgeOrdering + * Sorting.quickSort(people) * ``` * * This trait and [[scala.math.Ordered]] both provide this same functionality, but @@ -70,12 +77,17 @@ import scala.annotation.unchecked.uncheckedOverride * implicit orderings. * * @see [[scala.math.Ordered]], [[scala.util.Sorting]], [[scala.math.Ordering.Implicits]] + * + * @tparam T the type of objects that this ordering can compare */ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable { outer => /** Returns whether a comparison between `x` and `y` is defined, and if so * the result of `compare(x, y)`. + * + * @param x the first value to compare + * @param y the second value to compare */ def tryCompare(x: T, y: T): Some[Int] = Some(compare(x, y)) @@ -86,28 +98,62 @@ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializabl * - negative if x < y * - positive if x > y * - zero otherwise (if x == y) + * + * @param x the first value to compare + * @param y the second value to compare + * @return a negative integer, zero, or a positive integer as `x` is less than, equal to, or greater than `y` */ def compare(x: T, y: T): Int - /** Returns true if `x` <= `y` in the ordering. */ + /** Returns true if `x` <= `y` in the ordering. + * + * @param x the first value to compare + * @param y the second value to compare + */ override def lteq(x: T, y: T): Boolean = compare(x, y) <= 0 - /** Returns true if `x` >= `y` in the ordering. */ + /** Returns true if `x` >= `y` in the ordering. + * + * @param x the first value to compare + * @param y the second value to compare + */ override def gteq(x: T, y: T): Boolean = compare(x, y) >= 0 - /** Returns true if `x` < `y` in the ordering. */ + /** Returns true if `x` < `y` in the ordering. + * + * @param x the first value to compare + * @param y the second value to compare + */ override def lt(x: T, y: T): Boolean = compare(x, y) < 0 - /** Returns true if `x` > `y` in the ordering. */ + /** Returns true if `x` > `y` in the ordering. + * + * @param x the first value to compare + * @param y the second value to compare + */ override def gt(x: T, y: T): Boolean = compare(x, y) > 0 - /** Returns true if `x` == `y` in the ordering. */ + /** Returns true if `x` == `y` in the ordering. + * + * @param x the first value to compare + * @param y the second value to compare + */ override def equiv(x: T, y: T): Boolean = compare(x, y) == 0 - /** Returns `x` if `x` >= `y`, otherwise `y`. */ + /** Returns `x` if `x` >= `y`, otherwise `y`. + * + * @tparam U a subtype of `T`, used to preserve the specific type in the return value + * @param x the first candidate value + * @param y the second candidate value + */ @uncheckedOverride def max[U <: T](x: U, y: U): U = if (gteq(x, y)) x else y - /** Returns `x` if `x` <= `y`, otherwise `y`. */ + /** Returns `x` if `x` <= `y`, otherwise `y`. + * + * @tparam U a subtype of `T`, used to preserve the specific type in the return value + * @param x the first candidate value + * @param y the second candidate value + */ @uncheckedOverride def min[U <: T](x: U, y: U): U = if (lteq(x, y)) x else y /** Returns the opposite ordering of this one. @@ -115,6 +161,8 @@ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializabl * Implementations overriding this method MUST override [[isReverseOf]] * as well if they change the behavior at all (for example, caching does * not require overriding it). + * + * @return an `Ordering[T]` that compares elements in the reverse order of this ordering */ override def reverse: Ordering[T] = new Ordering.Reverse[T](this) @@ -125,6 +173,9 @@ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializabl * * Implementations should only override this method if they are overriding * [[reverse]] as well. + * + * @param other the ordering to check + * @return `true` if `other` is the reverse of this ordering, `false` otherwise */ def isReverseOf(other: Ordering[?]): Boolean = other match { case that: Ordering.Reverse[?] => that.outer == this @@ -134,9 +185,13 @@ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializabl /** Given f, a function from U into T, creates an Ordering[U] whose compare * function is equivalent to: * + * ```scala sc:compile + * def compare[U, T: Ordering](x: U, y: U, f: U => T) = Ordering[T].compare(f(x), f(y)) * ``` - * def compare(x:U, y:U) = Ordering[T].compare(f(x), f(y)) - * ``` + * + * @tparam U the type of the values to be ordered + * @param f the function to extract a `T` value from a `U` value + * @return an `Ordering[U]` that orders values by applying `f` and comparing the results using this ordering */ def on[U](f: U => T): Ordering[U] = new Ordering[U] { def compare(x: U, y: U) = outer.compare(f(x), f(y)) @@ -147,7 +202,7 @@ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializabl * or else the result of `other`s compare function. * * @example - * ``` + * ```scala sc:compile * case class Pair(a: Int, b: Int) * * val pairOrdering = Ordering.by[Pair, Int](_.a) @@ -155,6 +210,7 @@ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializabl * ``` * * @param other an Ordering to use if this Ordering returns zero + * @return an `Ordering[T]` that uses this ordering first, falling back to `other` when values are equal */ def orElse(other: Ordering[T]): Ordering[T] = (x, y) => { val res1 = outer.compare(x, y) @@ -165,20 +221,25 @@ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializabl * function returns the result of this Ordering's compare function, * if it is non-zero, or else a result equivalent to: * - * ``` - * Ordering[S].compare(f(x), f(y)) + * ```scala sc:compile + * def compare[T, S: Ordering](x: T, y: T, f: T => S) = Ordering[S].compare(f(x), f(y)) * ``` * * This function is equivalent to passing the result of `Ordering.by(f)` * to `orElse`. * * @example - * ``` + * ```scala sc:compile * case class Pair(a: Int, b: Int) * * val pairOrdering = Ordering.by[Pair, Int](_.a) * .orElseBy[Int](_.b) * ``` + * + * @tparam S the type returned by the extraction function `f` + * @param f the function to extract a comparison key from a `T` value + * @param ord the implicit ordering for the extracted key type `S` + * @return an `Ordering[T]` that uses this ordering first, falling back to comparing by `f` when values are equal */ def orElseBy[S](f: T => S)(implicit ord: Ordering[S]): Ordering[T] = (x, y) => { val res1 = outer.compare(x, y) @@ -189,6 +250,8 @@ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializabl * * It can't extend `AnyVal` because it is not a top-level class * or a member of a statically accessible object. + * + * @param lhs the left-hand side value for infix comparison operations */ class OrderingOps(lhs: T) { def <(rhs: T): Boolean = lt(lhs, rhs) @@ -202,6 +265,8 @@ trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializabl /** This implicit method augments `T` with the comparison operators defined * in `scala.math.Ordering.Ops`. + * + * @param lhs the value to enrich with ordering operators */ implicit def mkOrderingOps(lhs: T): OrderingOps = new OrderingOps(lhs) } @@ -215,6 +280,9 @@ trait LowPriorityOrderingImplicits { * via subclassing we can make `Ordered[A] => Ordering[A]` only * turn up if nothing else works. Since `Ordered[A]` extends * `Comparable[A]` anyway, we can throw in some Java interop too. + * + * @tparam A the type to be ordered, which must be convertible to `Comparable` + * @param asComparable the implicit conversion from `A` to `Comparable[? >: A]` */ implicit def ordered[A](implicit asComparable: AsComparable[A]): Ordering[A] = new Ordering[A] { def compare(x: A, y: A): Int = asComparable(x).compareTo(y) @@ -237,14 +305,21 @@ object Ordering extends LowPriorityOrderingImplicits { @inline def apply[T](implicit ord: Ordering[T]) = ord - /** An ordering which caches the value of its reverse. */ + /** An ordering which caches the value of its reverse. + * + * @tparam T the type of objects that this ordering can compare + */ sealed trait CachedReverse[T] extends Ordering[T] { private val _reverse = super.reverse override final def reverse: Ordering[T] = _reverse override final def isReverseOf(other: Ordering[?]): Boolean = other eq _reverse } - /** A reverse ordering. */ + /** A reverse ordering. + * + * @tparam T the type of objects that this ordering can compare + * @param outer the original ordering to be reversed + */ private final class Reverse[T](private[Ordering] val outer: Ordering[T]) extends Ordering[T] { override def reverse: Ordering[T] = outer override def isReverseOf(other: Ordering[?]): Boolean = other == outer @@ -291,6 +366,8 @@ object Ordering extends LowPriorityOrderingImplicits { trait ExtraImplicits { /** Not in the standard scope due to the potential for divergence: * For instance `implicitly[Ordering[Any]]` diverges in its presence. + * + * @tparam CC the higher-kinded type constructor for the sequence type, bounded by `scala.collection.Seq` */ implicit def seqOrdering[CC[X] <: scala.collection.Seq[X], T](implicit ord: Ordering[T]): Ordering[CC[T]] = new IterableOrdering[CC, T](ord) @@ -302,9 +379,15 @@ object Ordering extends LowPriorityOrderingImplicits { * implicit `Ordering` exists to the class which creates infix operations. * With it imported, you can write methods as follows: * + * ```scala sc:compile + * import scala.math.Ordering.Implicits.* + * def lessThan[T: Ordering](x: T, y: T) = x < y * ``` - * def lessThan[T: Ordering](x: T, y: T) = x < y - * ``` + * + * @tparam T the type of the value being compared + * @param x the value to enrich with infix ordering operators + * @param ord the implicit `Ordering` instance for type `T` + * @return an `OrderingOps` instance providing infix comparison operators */ implicit def infixOrderingOps[T](x: T)(implicit ord: Ordering[T]): Ordering[T]#OrderingOps = new ord.OrderingOps(x) } @@ -312,7 +395,11 @@ object Ordering extends LowPriorityOrderingImplicits { /** An object containing implicits which are not in the default scope. */ object Implicits extends ExtraImplicits { } - /** Constructs an Ordering[T] given a function `lt`. */ + /** Constructs an Ordering[T] given a function `lt`. + * + * @tparam T the type of objects to be ordered + * @param cmp a function that returns `true` if the first argument is less than the second + */ def fromLessThan[T](cmp: (T, T) => Boolean): Ordering[T] = new Ordering[T] { def compare(x: T, y: T) = if (cmp(x, y)) -1 else if (cmp(y, x)) 1 else 0 // overrides to avoid multiple comparisons @@ -325,12 +412,18 @@ object Ordering extends LowPriorityOrderingImplicits { /** Given f, a function from T into S, creates an Ordering[T] whose compare * function is equivalent to: * - * ``` - * def compare(x:T, y:T) = Ordering[S].compare(f(x), f(y)) + * ```scala sc:compile + * def compare[T, S: Ordering](x: T, y: T, f: T => S) = Ordering[S].compare(f(x), f(y)) * ``` * * This function is an analogue to Ordering.on where the Ordering[S] * parameter is passed implicitly. + * + * @tparam T the type of objects to be ordered + * @tparam S the type of the sort key extracted by `f` + * @param f the function to extract a comparison key of type `S` from a value of type `T` + * @param ord the implicit ordering for the extracted key type `S` + * @return an `Ordering[T]` that orders values by applying `f` and comparing the results */ def by[T, S](f: T => S)(implicit ord: Ordering[S]): Ordering[T] = new Ordering[T] { def compare(x: T, y: T) = ord.compare(f(x), f(y)) @@ -404,7 +497,7 @@ object Ordering extends LowPriorityOrderingImplicits { * `Float.NaN == Float.NaN` all yield `false`, analogous `None` in `flatMap`. * * - * ``` + * ```scala sc:compile * List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).sorted // List(-Infinity, 0.0, 1.0, NaN) * List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).min // -Infinity * implicitly[Ordering[Float]].lt(0.0F, 0.0F / 0.0F) // true @@ -501,7 +594,7 @@ object Ordering extends LowPriorityOrderingImplicits { * which brings back the `java.lang.Double.compare` semantics for all operations. * The default extends `TotalOrdering`. * - * ``` + * ```scala sc:compile * List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).sorted // List(-Infinity, 0.0, 1.0, NaN) * List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).min // -Infinity * implicitly[Ordering[Double]].lt(0.0, 0.0 / 0.0) // true diff --git a/library/src/scala/math/PartialOrdering.scala b/library/src/scala/math/PartialOrdering.scala index 519e9a909595..b0155b41343a 100644 --- a/library/src/scala/math/PartialOrdering.scala +++ b/library/src/scala/math/PartialOrdering.scala @@ -38,6 +38,8 @@ import scala.language.`2.13` * `lteq(x, y) && lteq(y, x) == **true**`. This equivalence relation is * exposed as the `equiv` method, inherited from the * [[scala.math.Equiv Equiv]] trait. + * + * @tparam T the type of elements being ordered */ trait PartialOrdering[T] extends Equiv[T] { @@ -49,26 +51,47 @@ trait PartialOrdering[T] extends Equiv[T] { * - `r < 0` iff `x < y` * - `r == 0` iff `x == y` * - `r > 0` iff `x > y` + * + * @param x the first element to compare + * @param y the second element to compare */ def tryCompare(x: T, y: T): Option[Int] - /** Returns `**true**` iff `x` comes before `y` in the ordering. */ + /** Returns `**true**` iff `x` comes before `y` in the ordering. + * + * @param x the first element to compare + * @param y the second element to compare + */ def lteq(x: T, y: T): Boolean - /** Returns `**true**` iff `y` comes before `x` in the ordering. */ + /** Returns `**true**` iff `y` comes before `x` in the ordering. + * + * @param x the first element to compare + * @param y the second element to compare + */ def gteq(x: T, y: T): Boolean = lteq(y, x) /** Returns `**true**` iff `x` comes before `y` in the ordering * and is not the same as `y`. + * + * @param x the first element to compare + * @param y the second element to compare */ def lt(x: T, y: T): Boolean = lteq(x, y) && !equiv(x, y) /** Returns `**true**` iff `y` comes before `x` in the ordering * and is not the same as `x`. + * + * @param x the first element to compare + * @param y the second element to compare */ def gt(x: T, y: T): Boolean = gteq(x, y) && !equiv(x, y) - /** Returns `**true**` iff `x` is equivalent to `y` in the ordering. */ + /** Returns `**true**` iff `x` is equivalent to `y` in the ordering. + * + * @param x the first element to compare + * @param y the second element to compare + */ def equiv(x: T, y: T): Boolean = lteq(x,y) && lteq(y,x) def reverse : PartialOrdering[T] = new PartialOrdering[T] { diff --git a/library/src/scala/math/PartiallyOrdered.scala b/library/src/scala/math/PartiallyOrdered.scala index a8a83fd33177..096f1ea1d703 100644 --- a/library/src/scala/math/PartiallyOrdered.scala +++ b/library/src/scala/math/PartiallyOrdered.scala @@ -15,7 +15,10 @@ package math import scala.language.`2.13` -/** A class for partially ordered data. */ +/** A class for partially ordered data. + * + * @tparam A the type of the elements being ordered + */ trait PartiallyOrdered[+A] extends Any { type AsPartiallyOrdered[B] = B => PartiallyOrdered[B] @@ -26,6 +29,9 @@ trait PartiallyOrdered[+A] extends Any { * - `x < 0` iff `**this** < that` * - `x == 0` iff `**this** == that` * - `x > 0` iff `**this** > that` + * + * @tparam B a supertype of `A` for which an implicit conversion to `PartiallyOrdered[B]` exists + * @param that the value to compare against */ def tryCompareTo [B >: A: AsPartiallyOrdered](that: B): Option[Int] diff --git a/library/src/scala/math/ScalaNumericConversions.scala b/library/src/scala/math/ScalaNumericConversions.scala index 5db00f22454e..44c6a2cf2a0b 100644 --- a/library/src/scala/math/ScalaNumericConversions.scala +++ b/library/src/scala/math/ScalaNumericConversions.scala @@ -27,7 +27,7 @@ trait ScalaNumericConversions extends ScalaNumber with ScalaNumericAnyConversion */ trait ScalaNumericAnyConversions extends Any { /** - * @return `**true**` if this number has no decimal component, `**false**` otherwise. + * @return `true` if this number has no decimal component, `false` otherwise. */ def isWhole: Boolean @@ -112,6 +112,8 @@ trait ScalaNumericAnyConversions extends Any { * in its lower 64 bits. Or a BigDecimal with more precision * than Double can hold: same thing. There's no way given the * interface available here to prevent this error. + * + * @param x the value to compare against this numeric value for primitive equality */ protected def unifiedPrimitiveEquals(x: Any) = x match { case x: Char => isValidChar && (toInt == x.toInt) diff --git a/library/src/scala/math/package.scala b/library/src/scala/math/package.scala index e8a3a7a6fba5..c57b58361d1c 100644 --- a/library/src/scala/math/package.scala +++ b/library/src/scala/math/package.scala @@ -105,17 +105,41 @@ package object math { */ def random(): Double = java.lang.Math.random() - /** @group trig */ + /** + * @group trig + * + * @param x the angle, in radians + */ def sin(x: Double): Double = java.lang.Math.sin(x) - /** @group trig */ + /** + * @group trig + * + * @param x the angle, in radians + */ def cos(x: Double): Double = java.lang.Math.cos(x) - /** @group trig */ + /** + * @group trig + * + * @param x the angle, in radians + */ def tan(x: Double): Double = java.lang.Math.tan(x) - /** @group trig */ + /** + * @group trig + * + * @param x the value whose arc sine is to be returned + */ def asin(x: Double): Double = java.lang.Math.asin(x) - /** @group trig */ + /** + * @group trig + * + * @param x the value whose arc cosine is to be returned + */ def acos(x: Double): Double = java.lang.Math.acos(x) - /** @group trig */ + /** + * @group trig + * + * @param x the value whose arc tangent is to be returned + */ def atan(x: Double): Double = java.lang.Math.atan(x) /** Converts an angle measured in degrees to an approximately equivalent @@ -138,8 +162,8 @@ package object math { /** Converts rectangular coordinates `(x, y)` to polar `(r, theta)`. * - * @param x the ordinate coordinate - * @param y the abscissa coordinate + * @param y the ordinate coordinate + * @param x the abscissa coordinate * @return the *theta* component of the point `(r, theta)` in polar * coordinates that corresponds to the point `(x, y)` in * Cartesian coordinates. @@ -154,6 +178,10 @@ package object math { * coordinates that corresponds to the point `(x, y)` in * Cartesian coordinates. * @group polar-coords + * + * @param x the x coordinate value + * @param y the y coordinate value + * @return sqrt(`x`² + `y`²) without intermediate overflow or underflow */ def hypot(x: Double, y: Double): Double = java.lang.Math.hypot(x, y) @@ -161,9 +189,17 @@ package object math { // rounding functions // ----------------------------------------------------------------------- - /** @group rounding */ + /** + * @group rounding + * + * @param x the value to be rounded up + */ def ceil(x: Double): Double = java.lang.Math.ceil(x) - /** @group rounding */ + /** + * @group rounding + * + * @param x the value to be rounded down + */ def floor(x: Double): Double = java.lang.Math.floor(x) /** Returns the `Double` value that is closest in value to the @@ -195,93 +231,227 @@ package object math { /** Returns the closest `Long` to the argument. * * @param x a floating-point value to be rounded to a `Long`. - * @return the value of the argument rounded to the nearest`long` value. + * @return the value of the argument rounded to the nearest `Long` value. * @group rounding */ def round(x: Double): Long = java.lang.Math.round(x) - /** @group abs */ + /** + * @group abs + * + * @param x the value whose absolute value is to be determined + */ def abs(x: Int): Int = java.lang.Math.abs(x) - /** @group abs */ + /** + * @group abs + * + * @param x the value whose absolute value is to be determined + */ def abs(x: Long): Long = java.lang.Math.abs(x) - /** @group abs */ + /** + * @group abs + * + * @param x the value whose absolute value is to be determined + */ def abs(x: Float): Float = java.lang.Math.abs(x) - /** @group abs */ + /** + * @group abs + * + * @param x the value whose absolute value is to be determined + */ def abs(x: Double): Double = java.lang.Math.abs(x) - /** @group minmax */ + /** + * @group minmax + * + * @param x the first value to compare + * @param y the second value to compare + */ def max(x: Int, y: Int): Int = java.lang.Math.max(x, y) - /** @group minmax */ + /** + * @group minmax + * + * @param x the first value to compare + * @param y the second value to compare + */ def max(x: Long, y: Long): Long = java.lang.Math.max(x, y) - /** @group minmax */ + /** + * @group minmax + * + * @param x the first value to compare + * @param y the second value to compare + */ def max(x: Float, y: Float): Float = java.lang.Math.max(x, y) - /** @group minmax */ + /** + * @group minmax + * + * @param x the first value to compare + * @param y the second value to compare + */ def max(x: Double, y: Double): Double = java.lang.Math.max(x, y) - /** @group minmax */ + /** + * @group minmax + * + * @param x the first value to compare + * @param y the second value to compare + */ def min(x: Int, y: Int): Int = java.lang.Math.min(x, y) - /** @group minmax */ + /** + * @group minmax + * + * @param x the first value to compare + * @param y the second value to compare + */ def min(x: Long, y: Long): Long = java.lang.Math.min(x, y) - /** @group minmax */ + /** + * @group minmax + * + * @param x the first value to compare + * @param y the second value to compare + */ def min(x: Float, y: Float): Float = java.lang.Math.min(x, y) - /** @group minmax */ + /** + * @group minmax + * + * @param x the first value to compare + * @param y the second value to compare + */ def min(x: Double, y: Double): Double = java.lang.Math.min(x, y) /** * @group signs * @note Forwards to [[java.lang.Integer]] + * + * @param x the value whose signum is to be computed */ def signum(x: Int): Int = java.lang.Integer.signum(x) /** * @group signs * @note Forwards to [[java.lang.Long]] + * + * @param x the value whose signum is to be computed */ def signum(x: Long): Long = java.lang.Long.signum(x) - /** @group signs */ + /** + * @group signs + * + * @param x the value whose signum is to be computed + */ def signum(x: Float): Float = java.lang.Math.signum(x) - /** @group signs */ + /** + * @group signs + * + * @param x the value whose signum is to be computed + */ def signum(x: Double): Double = java.lang.Math.signum(x) - /** @group modquo */ + /** + * @group modquo + * + * @param x the dividend + * @param y the divisor + */ def floorDiv(x: Int, y: Int): Int = java.lang.Math.floorDiv(x, y) - /** @group modquo */ + /** + * @group modquo + * + * @param x the dividend + * @param y the divisor + */ def floorDiv(x: Long, y: Long): Long = java.lang.Math.floorDiv(x, y) - /** @group modquo */ + /** + * @group modquo + * + * @param x the dividend + * @param y the divisor + */ def floorMod(x: Int, y: Int): Int = java.lang.Math.floorMod(x, y) - /** @group modquo */ + /** + * @group modquo + * + * @param x the dividend + * @param y the divisor + */ def floorMod(x: Long, y: Long): Long = java.lang.Math.floorMod(x, y) - /** @group signs */ + /** + * @group signs + * + * @param magnitude the value providing the magnitude of the result + * @param sign the value providing the sign of the result + */ def copySign(magnitude: Double, sign: Double): Double = java.lang.Math.copySign(magnitude, sign) - /** @group signs */ + /** + * @group signs + * + * @param magnitude the value providing the magnitude of the result + * @param sign the value providing the sign of the result + */ def copySign(magnitude: Float, sign: Float): Float = java.lang.Math.copySign(magnitude, sign) - /** @group adjacent-float */ + /** + * @group adjacent-float + * + * @param start the starting floating-point value + * @param direction the value indicating which of `start`'s neighbors should be returned + */ def nextAfter(start: Double, direction: Double): Double = java.lang.Math.nextAfter(start, direction) - /** @group adjacent-float */ + /** + * @group adjacent-float + * + * @param start the starting floating-point value + * @param direction the value indicating which of `start`'s neighbors should be returned + */ def nextAfter(start: Float, direction: Double): Float = java.lang.Math.nextAfter(start, direction) - /** @group adjacent-float */ + /** + * @group adjacent-float + * + * @param d the starting floating-point value + */ def nextUp(d: Double): Double = java.lang.Math.nextUp(d) - /** @group adjacent-float */ + /** + * @group adjacent-float + * + * @param f the starting floating-point value + */ def nextUp(f: Float): Float = java.lang.Math.nextUp(f) - /** @group adjacent-float */ + /** + * @group adjacent-float + * + * @param d the starting floating-point value + */ def nextDown(d: Double): Double = java.lang.Math.nextDown(d) - /** @group adjacent-float */ + /** + * @group adjacent-float + * + * @param f the starting floating-point value + */ def nextDown(f: Float): Float = java.lang.Math.nextDown(f) - /** @group scaling */ + /** + * @group scaling + * + * @param d the value to be scaled by a power of two + * @param scaleFactor the power of 2 used to scale `d` + */ def scalb(d: Double, scaleFactor: Int): Double = java.lang.Math.scalb(d, scaleFactor) - /** @group scaling */ + /** + * @group scaling + * + * @param f the value to be scaled by a power of two + * @param scaleFactor the power of 2 used to scale `f` + */ def scalb(f: Float, scaleFactor: Int): Float = java.lang.Math.scalb(f, scaleFactor) // ----------------------------------------------------------------------- @@ -321,7 +491,7 @@ package object math { /** Returns Euler's number `e` raised to the power of a `Double` value. * * @param x the exponent to raise `e` to. - * @return the value `e^a^`, where `e` is the base of the natural + * @return the value `e^x^`, where `e` is the base of the natural * logarithms. * @group explog */ @@ -329,13 +499,23 @@ package object math { /** Returns `exp(x) - 1`. * @group explog + * + * @param x the exponent to raise `e` to in the computation of `e`^`x`^ - 1 */ def expm1(x: Double): Double = java.lang.Math.expm1(x) - /** @group explog */ + /** + * @group explog + * + * @param f the `Float` value whose unbiased exponent is to be extracted + */ def getExponent(f: Float): Int = java.lang.Math.getExponent(f) - /** @group explog */ + /** + * @group explog + * + * @param d the `Double` value whose unbiased exponent is to be extracted + */ def getExponent(d: Double): Int = java.lang.Math.getExponent(d) // ----------------------------------------------------------------------- @@ -345,18 +525,22 @@ package object math { /** Returns the natural logarithm of a `Double` value. * * @param x the number to take the natural logarithm of - * @return the value `logₑ(x)` where `e` is Eulers number + * @return the value `logₑ(x)` where `e` is Euler's number * @group explog */ def log(x: Double): Double = java.lang.Math.log(x) /** Returns the natural logarithm of the sum of the given `Double` value and 1. * @group explog + * + * @param x the value for which to compute `ln(1 + x)` */ def log1p(x: Double): Double = java.lang.Math.log1p(x) /** Returns the base 10 logarithm of the given `Double` value. * @group explog + * + * @param x the value whose base 10 logarithm is to be computed */ def log10(x: Double): Double = java.lang.Math.log10(x) @@ -366,16 +550,22 @@ package object math { /** Returns the hyperbolic sine of the given `Double` value. * @group hyperbolic + * + * @param x the value whose hyperbolic sine is to be returned */ def sinh(x: Double): Double = java.lang.Math.sinh(x) /** Returns the hyperbolic cosine of the given `Double` value. * @group hyperbolic + * + * @param x the value whose hyperbolic cosine is to be returned */ def cosh(x: Double): Double = java.lang.Math.cosh(x) /** Returns the hyperbolic tangent of the given `Double` value. * @group hyperbolic + * + * @param x the value whose hyperbolic tangent is to be returned */ def tanh(x: Double):Double = java.lang.Math.tanh(x) @@ -385,58 +575,125 @@ package object math { /** Returns the size of an ulp of the given `Double` value. * @group ulp + * + * @param x the `Double` value whose ulp is to be returned */ def ulp(x: Double): Double = java.lang.Math.ulp(x) /** Returns the size of an ulp of the given `Float` value. * @group ulp + * + * @param x the `Float` value whose ulp is to be returned */ def ulp(x: Float): Float = java.lang.Math.ulp(x) - /** @group exact */ + /** + * @group exact + * + * @param x the dividend value + * @param y the divisor value + */ def IEEEremainder(x: Double, y: Double): Double = java.lang.Math.IEEEremainder(x, y) // ----------------------------------------------------------------------- // exact functions // ----------------------------------------------------------------------- - /** @group exact */ + /** + * @group exact + * + * @param x the first addend + * @param y the second addend + */ def addExact(x: Int, y: Int): Int = java.lang.Math.addExact(x, y) - /** @group exact */ + /** + * @group exact + * + * @param x the first addend + * @param y the second addend + */ def addExact(x: Long, y: Long): Long = java.lang.Math.addExact(x, y) - /** @group exact */ + /** + * @group exact + * + * @param x the minuend + * @param y the subtrahend + */ def subtractExact(x: Int, y: Int): Int = java.lang.Math.subtractExact(x, y) - /** @group exact */ + /** + * @group exact + * + * @param x the minuend + * @param y the subtrahend + */ def subtractExact(x: Long, y: Long): Long = java.lang.Math.subtractExact(x, y) - /** @group exact */ + /** + * @group exact + * + * @param x the first factor + * @param y the second factor + */ def multiplyExact(x: Int, y: Int): Int = java.lang.Math.multiplyExact(x, y) - /** @group exact */ + /** + * @group exact + * + * @param x the first factor + * @param y the second factor + */ def multiplyExact(x: Long, y: Long): Long = java.lang.Math.multiplyExact(x, y) - /** @group exact */ + /** + * @group exact + * + * @param x the value to be incremented + */ def incrementExact(x: Int): Int = java.lang.Math.incrementExact(x) - /** @group exact */ + /** + * @group exact + * + * @param x the value to be incremented + */ def incrementExact(x: Long) = java.lang.Math.incrementExact(x) - /** @group exact */ + /** + * @group exact + * + * @param x the value to be decremented + */ def decrementExact(x: Int) = java.lang.Math.decrementExact(x) - /** @group exact */ + /** + * @group exact + * + * @param x the value to be decremented + */ def decrementExact(x: Long) = java.lang.Math.decrementExact(x) - /** @group exact */ + /** + * @group exact + * + * @param x the value to be negated + */ def negateExact(x: Int) = java.lang.Math.negateExact(x) - /** @group exact */ + /** + * @group exact + * + * @param x the value to be negated + */ def negateExact(x: Long) = java.lang.Math.negateExact(x) - /** @group exact */ + /** + * @group exact + * + * @param x the `Long` value to convert to an `Int` + */ def toIntExact(x: Long): Int = java.lang.Math.toIntExact(x) } diff --git a/library/src/scala/quoted/Expr.scala b/library/src/scala/quoted/Expr.scala index a14cd1e15fbc..df02e42bf57b 100644 --- a/library/src/scala/quoted/Expr.scala +++ b/library/src/scala/quoted/Expr.scala @@ -5,6 +5,8 @@ import language.experimental.captureChecking /** Quoted expression of type `T`. * * `Expr` has extension methods that are defined in `scala.quoted.Quotes`. + * + * @tparam T the type of the quoted expression */ abstract class Expr[+T] private[scala] () @@ -51,6 +53,10 @@ object Expr { * ... * f[X1, Y1, ..., Xn, Yn, ...](x1, y1, ..., xn, yn, ...) * ``` + * + * @tparam T the type of the expression to beta-reduce + * @param expr the expression to beta-reduce + * @return the beta-reduced expression, or `expr` unchanged if no reduction is possible */ def betaReduce[T](expr: Expr[T])(using Quotes): Expr[T] = import quotes.reflect.* @@ -61,13 +67,21 @@ object Expr { /** Returns an expression containing a block with the given statements and ending with the expression * Given list of statements `s1 :: s2 :: ... :: Nil` and an expression `e` the resulting expression * will be equivalent to `'{ $s1; $s2; ...; $e }`. + * + * @tparam T the type of the final expression, which determines the block's result type + * @param statements the statements to execute before the final expression in the block + * @param expr the final expression whose value becomes the result of the block */ def block[T](statements: List[Expr[Any]], expr: Expr[T])(using Quotes): Expr[T] = { import quotes.reflect.* Block(statements.map(asTerm), expr.asTerm).asExpr.asInstanceOf[Expr[T]] } - /** Creates an expression that will construct the value `x`. */ + /** Creates an expression that will construct the value `x`. + * + * @tparam T the type of the value to be lifted into an expression + * @param x the value to lift into a quoted expression + */ def apply[T](x: T)(using ToExpr[T])(using Quotes): Expr[T] = scala.Predef.summon[ToExpr[T]].apply(x) @@ -82,6 +96,10 @@ object Expr { * ``` * * To directly get the value of an expression `expr: Expr[T]` consider using `expr.value`/`expr.valueOrError` instead. + * + * @tparam T the type of the value to extract from the expression + * @param x the expression to extract a value from + * @return `Some` containing the extracted value if `x` is a literal constant or known constructor, `None` otherwise */ def unapply[T](x: Expr[T])(using FromExpr[T])(using Quotes): Option[T] = scala.Predef.summon[FromExpr[T]].unapply(x) @@ -92,6 +110,10 @@ object Expr { * `Seq(e1, e2, ...)` where `ei: Expr[T]` * to an expression equivalent to * `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]` + * + * @tparam T the element type of the sequence + * @param xs the sequence of expressions to combine + * @return an expression representing a `Seq[T]` constructed from the given element expressions */ def ofSeq[T](xs: Seq[Expr[T]])(using Type[T])(using Quotes): Expr[Seq[T]] = Varargs(xs) @@ -102,6 +124,10 @@ object Expr { * `List(e1, e2, ...)` where `ei: Expr[T]` * to an expression equivalent to * `'{ List($e1, $e2, ...) }` typed as an `Expr[List[T]]` + * + * @tparam T the element type of the list + * @param xs the sequence of expressions to combine into a list expression + * @return an expression representing a `List[T]` constructed from the given element expressions */ def ofList[T](xs: Seq[Expr[T]])(using Type[T])(using Quotes): Expr[List[T]] = if xs.isEmpty then Expr(Nil) else '{ List(${Varargs(xs)}*) } @@ -112,6 +138,9 @@ object Expr { * `Seq(e1, e2, ...)` where `ei: Expr[Any]` * to an expression equivalent to * `'{ ($e1, $e2, ...) }` typed as an `Expr[Tuple]` + * + * @param seq the sequence of element expressions to combine into a tuple expression + * @return an expression representing a tuple constructed from the given element expressions */ def ofTupleFromSeq(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] = { seq.size match { @@ -262,7 +291,10 @@ object Expr { AppliedType(consRef, expr.asTerm.tpe :: ts :: Nil) } - /** Given a tuple of the form `(Expr[A1], ..., Expr[An])`, outputs a tuple `Expr[(A1, ..., An)]`. */ + /** Given a tuple of the form `(Expr[A1], ..., Expr[An])`, outputs a tuple `Expr[(A1, ..., An)]`. + * + * @tparam T the tuple type where each element is wrapped in `Expr`, e.g., `(Expr[A1], ..., Expr[An])` + */ def ofTuple[T <: Tuple: Tuple.IsMappedBy[Expr]: Type](tup: T)(using Quotes): Expr[Tuple.InverseMap[T, Expr]] = { val elems: Seq[Expr[Any]] = tup.asInstanceOf[Product].productIterator.toSeq.asInstanceOf[Seq[Expr[Any]]] ofTupleFromSeq(elems).asExprOf[Tuple.InverseMap[T, Expr]] @@ -289,6 +321,7 @@ object Expr { * * @tparam T type of the implicit parameter * @param ignored Symbols ignored during the initial implicit search + * @return `Some` containing the found implicit expression, or `None` if implicit resolution failed * * @note if the found given requires additional search for other given instances, * this additional search will NOT exclude the symbols from the `ignored` list. diff --git a/library/src/scala/quoted/ExprMap.scala b/library/src/scala/quoted/ExprMap.scala index b420403c3c40..1c5de2ed718b 100644 --- a/library/src/scala/quoted/ExprMap.scala +++ b/library/src/scala/quoted/ExprMap.scala @@ -4,10 +4,22 @@ import language.experimental.captureChecking trait ExprMap: - /** Maps an expression `e` with a type `T`. */ + /** Maps an expression `e` with a type `T`. + * Requires a given `Type[T]` instance for staging and a `Quotes` instance + * for access to the reflection API. + * + * @tparam T the type of the expression being transformed + * @param e the expression to transform + */ def transform[T](e: Expr[T])(using Type[T])(using Quotes): Expr[T] - /** Maps sub-expressions an expression `e` with a type `T`. */ + /** Maps the sub-expressions of an expression `e` with type `T`. + * Requires a given `Type[T]` instance for staging and a `Quotes` instance + * for access to the reflection API. + * + * @tparam T the type of the expression whose children are transformed + * @param e the expression whose direct sub-expressions will be transformed via `transform` + */ def transformChildren[T](e: Expr[T])(using Type[T])(using Quotes): Expr[T] = { import quotes.reflect.* final class MapChildren() { diff --git a/library/src/scala/quoted/Exprs.scala b/library/src/scala/quoted/Exprs.scala index 5744e79b7139..69e80d1ba8da 100644 --- a/library/src/scala/quoted/Exprs.scala +++ b/library/src/scala/quoted/Exprs.scala @@ -7,13 +7,17 @@ object Exprs: /** Matches literal sequence of literal constant value expressions and returns a sequence of values. * * Usage: - * ```scala + * ```scala sc:compile * inline def sum(args: Int*): Int = ${ sumExpr('args) } * def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] = argsExpr match - * case Varargs(Exprs(args)) => ??? + * case Varargs(Exprs(args)) => Expr(args.sum) * // args: Seq[Int] * ``` * To directly get the value of all expressions in a sequence `exprs: Seq[Expr[T]]` consider using `exprs.map(_.value)`/`exprs.map(_.valueOrError)` instead. + * + * @tparam T the type of values being extracted from the expressions + * @param exprs the sequence of expressions to extract values from + * @return `Some` containing the sequence of extracted values if all expressions yield a value, or `None` if any expression cannot be converted */ def unapply[T](exprs: Seq[Expr[T]])(using FromExpr[T])(using Quotes): Option[Seq[T]] = val builder = Seq.newBuilder[T] diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index cae056079adf..40fea5b42258 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -11,6 +11,8 @@ import language.experimental.captureChecking * - This expression must be some kind of data structure (`Some`, `List`, `Either`, ...) * - Calls to `new X` or `X.apply` can be lifted into its value * - Arguments of constructors can be recursively unlifted + * + * @tparam T the type of the value that can be extracted from the quoted expression */ trait FromExpr[T] { @@ -18,6 +20,9 @@ trait FromExpr[T] { * * Returns `None` if the expression does not represent a value or possibly contains side effects. * Otherwise returns the `Some` of the value. + * + * @param x the quoted expression to extract a value from + * @return `Some(value)` if the expression contains an extractable value, `None` otherwise */ def unapply(x: Expr[T])(using Quotes): Option[T] @@ -81,7 +86,10 @@ object FromExpr { */ given StringFromExpr[T <: String]: FromExpr[T] = new PrimitiveFromExpr - /** Lift a quoted primitive value `'{ x }` into `x`. */ + /** Lift a quoted primitive value `'{ x }` into `x`. + * + * @tparam T the primitive or `String` type to extract from the quoted literal + */ private class PrimitiveFromExpr[T <: Boolean | Byte | Short | Int | Long | Float | Double | Char | String] extends FromExpr[T] { def unapply(expr: Expr[T])(using Quotes) = import quotes.reflect.* diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala index 88bf265d9cd1..49197e8ae3e0 100644 --- a/library/src/scala/quoted/Quotes.scala +++ b/library/src/scala/quoted/Quotes.scala @@ -8,13 +8,16 @@ import scala.reflect.TypeTest /** Current Quotes in scope * * Usage: - * ```scala + * ```scala sc:compile * import scala.quoted.* * def myExpr[T](using Quotes): Expr[T] = { * import quotes.reflect.* * ??? * } * ``` + * + * @param q the implicit `Quotes` instance in scope + * @return the provided `Quotes` instance with its singleton type preserved */ transparent inline def quotes(using q: Quotes): q.type = q @@ -24,14 +27,15 @@ transparent inline def quotes(using q: Quotes): q.type = q * It contains the low-level Typed AST API metaprogramming API. * This API does not have the static type guarantees that `Expr` and `Type` provide. * `Quotes` are generated from an enclosing `${ ... }` or `scala.staging.run`. For example: - * ```scala sc:nocompile + * ```scala sc:compile * import scala.quoted.* - * inline def myMacro: Expr[T] = - * ${ /* (quotes: Quotes) ?=> */ myExpr } - * def myExpr(using Quotes): Expr[T] = - * '{ f(${ /* (quotes: Quotes) ?=> */ myOtherExpr }) } - * } - * def myOtherExpr(using Quotes): Expr[U] = '{ ... } + * inline def myMacro[T]: T = + * ${ myMacroExpr[T] } + * def myMacroExpr[T: Type](using Quotes): Expr[T] = + * '{ f[T](${ myOtherExpr[Int] }) } + * def myOtherExpr[U: Type](using Quotes): Expr[U] = + * '{ ??? : U } + * def f[T](x: Int): T = ??? * ``` */ @@ -56,6 +60,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * case '{...} => true // where the contents of the pattern are the contents of `that` * case _ => false * ``` + * + * @param that the expression to pattern match against */ def matches(that: Expr[Any]): Boolean @@ -63,6 +69,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * Returns `None` if the expression does not represent a value or possibly contains side effects. * Otherwise returns the `Some` of the value. + * + * @return `Some` with the extracted value, or `None` if the expression cannot be evaluated to a constant */ def value(using FromExpr[T]): Option[T] = given Quotes = Quotes.this @@ -86,6 +94,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * Emits an error and aborts if the expression does not represent a value or possibly contains side effects. * Otherwise returns the value. + * + * @return the extracted value, or aborts compilation with an error if extraction fails */ def valueOrAbort(using FromExpr[T]): T @@ -93,10 +103,16 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => // Extension methods for `Expr[Any]` that take another explicit type parameter extension (self: Expr[Any]) - /** Checks is the `quoted.Expr[?]` is valid expression of type `X`. */ + /** Checks is the `quoted.Expr[?]` is valid expression of type `X`. + * + * @tparam X the target type to check against + */ def isExprOf[X](using Type[X]): Boolean - /** Converts this to an `quoted.Expr[X]` if this expression is a valid expression of type `X` or throws. */ + /** Converts this to an `quoted.Expr[X]` if this expression is a valid expression of type `X` or throws. + * + * @tparam X the target type to cast this expression to + */ def asExprOf[X](using Type[X]): Expr[X] end extension @@ -105,7 +121,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Provides all functionality related to AST-based metaprogramming. * * Usage: - * ```scala + * ```scala sc:compile * import scala.quoted.* * def f(expr: Expr[Int])(using Quotes) = * import quotes.reflect.* @@ -256,6 +272,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Are we expanding a `inline` macro while typing the program? * * This will be true when the macro is used in a transparent inline. + * + * @return `true` if the macro is being expanded during typing (transparent inline), `false` otherwise */ def isWhileTyping: Boolean @@ -264,6 +282,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * These will be used to expand any transparent macros or any non-transparent macro that is forced to expand while expanding the transparent macro. * Non-transparent macros are not guaranteed to be expanded with the same set of settings. + * + * @return the list of macro settings strings passed via `-Xmacro-settings` */ @experimental def XmacroSettings: List[String] @@ -315,7 +335,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => def asExprOf[T](using Type[T]): Expr[T] extension [ThisTree <: Tree](self: ThisTree) - /** Changes the owner of the symbols in the tree. */ + /** Changes the owner of the symbols in the tree. + * + * @param newOwner the new owner symbol for the definitions in this tree + */ def changeOwner(newOwner: Symbol): ThisTree end extension @@ -346,11 +369,23 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val PackageClause`. */ trait PackageClauseModule { this: PackageClause.type => - /** Creates a package clause `package pid { stats }`. */ + /** Creates a package clause `package pid { stats }`. + * + * @param pid the package name reference + * @param stats the definitions, imports, or exports within the package + */ def apply(pid: Ref, stats: List[Tree]): PackageClause - /** Copies a package clause `package pid { stats }`. */ + /** Copies a package clause `package pid { stats }`. + * + * @param original the original tree being copied + * @param pid the package name reference + * @param stats the definitions, imports, or exports within the package + */ def copy(original: Tree)(pid: Ref, stats: List[Tree]): PackageClause - /** Matches a package clause `package pid { stats }` and extracts the `pid` and `stats`. */ + /** Matches a package clause `package pid { stats }` and extracts the `pid` and `stats`. + * + * @param tree the package clause tree to match against + */ def unapply(tree: PackageClause): (Ref, List[Tree]) } @@ -381,11 +416,23 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Import`. */ trait ImportModule { this: Import.type => - /** Creates an `Import` with the given qualifier and selectors. */ + /** Creates an `Import` with the given qualifier and selectors. + * + * @param expr the qualifier term being imported from + * @param selectors the list of import selectors + */ def apply(expr: Term, selectors: List[Selector]): Import - /** Copies an `Import` with the given qualifier and selectors. */ + /** Copies an `Import` with the given qualifier and selectors. + * + * @param original the original tree being copied + * @param expr the qualifier term being imported from + * @param selectors the list of import selectors + */ def copy(original: Tree)(expr: Term, selectors: List[Selector]): Import - /** Matches an `Import` and extracts the qualifier and selectors. */ + /** Matches an `Import` and extracts the qualifier and selectors. + * + * @param tree the import tree to match against + */ def unapply(tree: Import): (Term, List[Selector]) } @@ -400,6 +447,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** List selectors of the import * * See documentation on `Selector` + * + * @return the list of import selectors specifying what is imported */ def selectors: List[Selector] end extension @@ -418,7 +467,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Export`. */ trait ExportModule { this: Export.type => - /** Matches an `Export` and extracts the qualifier and selectors. */ + /** Matches an `Export` and extracts the qualifier and selectors. + * + * @param tree the export tree to match against + */ def unapply(tree: Export): (Term, List[Selector]) } @@ -433,6 +485,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** List selectors of the export * * See documentation on `Selector` + * + * @return the list of export selectors specifying what is exported */ def selectors: List[Selector] end extension @@ -489,6 +543,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Parents can be `TypeTree`s if they don't have term parameter, * otherwise the can be `Term` containing the `New` applied to the parameters of the extended class. * @param body List of members of the class. The members must align with the members of `cls`. + * @return a new `ClassDef` tree for the given class symbol */ // TODO add selfOpt: Option[ValDef]? // ^ if a use-case shows up, we add this via an overloaded method @@ -535,7 +590,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => def parents: List[Tree /* Term | TypeTree */] /** Self-type of the class * - * ```scala + * ```scala sc:compile * //{ * type T * //} @@ -543,15 +598,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * ??? * } * ``` + * + * @return the self-type `ValDef` if one is declared, or `None` */ def self: Option[ValDef] /** Statements within the class * - * ```scala + * ```scala sc:compile * class C { * ??? // statements * } * ``` + * + * @return the list of statements within the class body */ def body: List[Statement] end extension @@ -602,6 +661,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Use `Symbol.asQuotes` to create the rhs using quoted code. * * See also: `Tree.changeOwner` + * + * @param symbol the method symbol (created using `Symbol.newMethod`) + * @param rhsFn a function that takes references to the method parameters and returns the method body, or `None` for abstract methods + * @return a new `DefDef` tree for the given method symbol */ def apply(symbol: Symbol, rhsFn: List[List[Tree]] => Option[Term]): DefDef def copy(original: Tree)(name: String, paramss: List[ParamClause], tpt: TypeTree, rhs: Option[Term]): DefDef @@ -620,13 +683,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** List of leading type parameters or Nil if the method does not have leading type parameters. * * Note: Non leading type parameters can be found in extension methods such as - * ```scala + * ```scala sc:compile * //{ * type A * type T * //} * extension (a: A) def f[T]() = ??? * ``` + * + * @return the leading type parameter definitions, or `Nil` if there are none */ def leadingTypeParams: List[TypeDef] @@ -634,13 +699,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Returns all parameter clauses if there are no leading type parameters. * * Non leading type parameters can be found in extension methods such as - * ```scala + * ```scala sc:compile * //{ * type T * type A * //} * extension (a: A) def f[T]() = ??? * ``` + * + * @return the parameter clauses following the leading type parameters, or all clauses if there are no leading type parameters */ def trailingParamss: List[ParamClause] @@ -679,6 +746,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Use `Symbol.asQuotes` to create the rhs using quoted code. * * See also: `Tree.changeOwner` + * + * @param symbol the val/var/lazy val symbol (created using `Symbol.newVal`) + * @param rhs `Some` containing the right-hand side term, or `None` for abstract values + * @return a new `ValDef` tree for the given symbol */ def apply(symbol: Symbol, rhs: Option[Term]): ValDef def copy(original: Tree)(name: String, tpt: TypeTree, rhs: Option[Term]): ValDef @@ -696,6 +767,11 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * ``` * * @param flags extra flags to with which the symbol should be constructed. Can be `Final | Implicit | Lazy | Mutable | Given | Synthetic` + * @param owner the owner symbol for the generated `val` definition + * @param name the name of the `val` binding + * @param rhs the right-hand side term to bind + * @param body a function that takes a reference to the bound value and returns the body term + * @return a block containing the `val` definition and the body */ // Keep: `flags` doc aligned with QuotesImpl's `validValInLetFlags` def let(owner: Symbol, name: String, rhs: Term, flags: Flags)(body: Ref => Term): Term @@ -710,6 +786,12 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * } * } * ``` + * + * @param owner the owner symbol for the generated `val` definition + * @param name the name of the `val` binding + * @param rhs the right-hand side term to bind + * @param body a function that takes a reference to the bound value and returns the body term + * @return a block containing the `val` definition and the body */ def let(owner: Symbol, name: String, rhs: Term)(body: Ref => Term): Term @@ -723,6 +805,11 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * } * } * ``` + * + * @param owner the owner symbol for the generated `val` definition + * @param rhs the right-hand side term to bind + * @param body a function that takes a reference to the bound value and returns the body term + * @return a block containing the `val` definition and the body */ def let(owner: Symbol, rhs: Term)(body: Ref => Term): Term = let(owner, "x", rhs)(body) @@ -735,6 +822,11 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * ... * } * ``` + * + * @param owner the owner symbol for the generated `val` definitions + * @param terms the list of right-hand side terms to bind + * @param body a function that takes references to all bound values and returns the body term + * @return a block containing all `val` definitions and the body */ def let(owner: Symbol, terms: List[Term])(body: List[Ref] => Term): Term } @@ -837,6 +929,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * ... * f[X1, Y1, ..., Xn, Yn, ...](x1, y1, ..., xn, yn, ...) * ``` + * + * @param term the term to attempt to beta-reduce + * @return `Some` with the beta-reduced term if reduction was possible, or `None` otherwise */ def betaReduce(term: Term): Option[Term] @@ -857,6 +952,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * Warning: This tree may contain references that are out of scope and should not be used in the generated code. * This method should only used to port Scala 2 that used to access their outer scope unsoundly. + * + * @return the underlying term with `Inlined` nodes and `InlineProxy` references removed */ def underlyingArgument: Term @@ -865,23 +962,40 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * Warning: This tree may contain references that are out of scope and should not be used in the generated code. * This method should only used to port Scala 2 that used to access their outer scope unsoundly. + * + * @return the underlying term with inline proxy and val references resolved */ def underlying: Term - /** Converts a partially applied term into a lambda expression. */ + /** Converts a partially applied term into a lambda expression. + * + * @param owner the owner symbol of the generated lambda + */ def etaExpand(owner: Symbol): Term - /** A unary apply node with given argument: `tree(arg)`. */ + /** A unary apply node with given argument: `tree(arg)`. + * + * @param arg the argument to apply + */ def appliedTo(arg: Term): Term - /** An apply node with given arguments: `tree(arg, args0, ..., argsN)`. */ + /** An apply node with given arguments: `tree(arg, args0, ..., argsN)`. + * + * @param arg the first argument to apply + * @param args the remaining arguments to apply + */ def appliedTo(arg: Term, args: Term*): Term - /** An apply node with given argument list `tree(args(0), ..., args(args.length - 1))`. */ + /** An apply node with given argument list `tree(args(0), ..., args(args.length - 1))`. + * + * @param args the list of arguments to apply + */ def appliedToArgs(args: List[Term]): Apply /** The current tree applied to given argument lists: * `tree (argss(0)) ... (argss(argss.length -1))` + * + * @param argss the list of argument lists to apply sequentially */ def appliedToArgss(argss: List[List[Term]]): Term @@ -891,16 +1005,28 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** The current tree applied to `()` unless the tree's widened type is parameterless or expects type parameters. */ def ensureApplied: Term - /** The current tree applied to given type argument: `tree[targ]`. */ + /** The current tree applied to given type argument: `tree[targ]`. + * + * @param targ the type argument to apply + */ def appliedToType(targ: TypeRepr): Term - /** The current tree applied to given type arguments: `tree[targ0, ..., targN]`. */ + /** The current tree applied to given type arguments: `tree[targ0, ..., targN]`. + * + * @param targs the type arguments to apply + */ def appliedToTypes(targs: List[TypeRepr]): Term - /** The current tree applied to given type argument list: `tree[targs(0), ..., targs(targs.length - 1)]`. */ + /** The current tree applied to given type argument list: `tree[targs(0), ..., targs(targs.length - 1)]`. + * + * @param targs the type argument trees to apply + */ def appliedToTypeTrees(targs: List[TypeTree]): Term - /** A select node that selects the given symbol. */ + /** A select node that selects the given symbol. + * + * @param sym the symbol of the member to select + */ def select(sym: Symbol): Select end extension @@ -919,7 +1045,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Ref`. */ trait RefModule { this: Ref.type => - /** A tree representing the same reference as the given type. */ + /** A tree representing the same reference as the given type. + * + * @param tp the term reference type to create a reference tree for + */ def term(tp: TermRef): Ref /** Creates a reference tree from a symbol @@ -939,6 +1068,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * For example, it is incorrect to have `C.this.foo` outside * the class body of `C`, or have `foo` outside the lexical * scope for the definition of `foo`. + * + * @param sym the symbol to create a reference to + * @return a reference tree for the given symbol */ def apply(sym: Symbol): Ref } @@ -958,7 +1090,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => def copy(original: Tree)(name: String): Ident - /** Matches a term identifier and returns its name. */ + /** Matches a term identifier and returns its name. + * + * @param tree the identifier tree to match against + */ def unapply(tree: Ident): Some[String] } @@ -986,7 +1121,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => trait WildcardModule { this: Wildcard.type => /** Creates a tree representing a `_` wildcard. */ def apply(): Wildcard - /** Matches a tree representing a `_` wildcard. */ + /** Matches a tree representing a `_` wildcard. + * + * @param wildcard the wildcard tree to match against + */ def unapply(wildcard: Wildcard): true } @@ -1001,7 +1139,11 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Select`. */ trait SelectModule { this: Select.type => - /** Selects a term member by symbol. */ + /** Selects a term member by symbol. + * + * @param qualifier the term on which the member is selected + * @param symbol the symbol of the member to select + */ def apply(qualifier: Term, symbol: Symbol): Select /** Selects a field or a non-overloaded method by name @@ -1009,18 +1151,38 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @note The method will produce an assertion error if the selected * method is overloaded. The method `overloaded` should be used * in that case. + * + * @param qualifier the term on which the member is selected + * @param name the name of the field or non-overloaded method + * @return a `Select` tree for the named member */ def unique(qualifier: Term, name: String): Select - /** Calls an overloaded method with the given type and term parameters. */ + /** Calls an overloaded method with the given type and term parameters. + * + * @param qualifier the term on which the method is called + * @param name the name of the overloaded method + * @param targs the type arguments for overload resolution + * @param args the term arguments for overload resolution + */ def overloaded(qualifier: Term, name: String, targs: List[TypeRepr], args: List[Term]): Term - /** Calls an overloaded method with the given type and term parameters. */ + /** Calls an overloaded method with the given type and term parameters. + * + * @param qualifier the term on which the method is called + * @param name the name of the overloaded method + * @param targs the type arguments for overload resolution + * @param args the term arguments for overload resolution + * @param returnType the expected return type for overload resolution + */ def overloaded(qualifier: Term, name: String, targs: List[TypeRepr], args: List[Term], returnType: TypeRepr): Term def copy(original: Tree)(qualifier: Term, name: String): Select - /** Matches `.`. */ + /** Matches `.`. + * + * @param x the select tree to match against + */ def unapply(x: Select): (Term, String) } @@ -1051,12 +1213,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Literal`. */ trait LiteralModule { this: Literal.type => - /** Creates a literal constant. */ + /** Creates a literal constant. + * + * @param constant the constant value for the literal + */ def apply(constant: Constant): Literal def copy(original: Tree)(constant: Constant): Literal - /** Matches a literal constant. */ + /** Matches a literal constant. + * + * @param x the `Literal` to match against + */ def unapply(x: Literal): Some[Constant] } @@ -1083,12 +1251,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val This`. */ trait ThisModule { this: This.type => - /** Creates a `C.this` for `C` pointing to `cls`. */ + /** Creates a `C.this` for `C` pointing to `cls`. + * + * @param cls the symbol of the enclosing class + */ def apply(cls: Symbol): This def copy(original: Tree)(qual: Option[String]): This - /** Matches `this` or `qual.this` and returns the name of `qual`. */ + /** Matches `this` or `qual.this` and returns the name of `qual`. + * + * @param x the `This` to match against + */ def unapply(x: This): Some[Option[String]] } @@ -1101,6 +1275,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Returns `C` if the underlying tree is of the form `C.this` * * Otherwise, return `None`. + * + * @return the optional qualifying class name */ def id: Option[String] end extension @@ -1118,12 +1294,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val New`. */ trait NewModule { this: New.type => - /** Creates a `new `. */ + /** Creates a `new `. + * + * @param tpt the type tree of the class to instantiate + */ def apply(tpt: TypeTree): New def copy(original: Tree)(tpt: TypeTree): New - /** Matches `new `. */ + /** Matches `new `. + * + * @param x the `New` to match against + */ def unapply(x: New): Some[TypeTree] } @@ -1150,12 +1332,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val NamedArg`. */ trait NamedArgModule { this: NamedArg.type => - /** Creates a named argument ` = `. */ + /** Creates a named argument ` = `. + * + * @param name the argument name + * @param arg the argument value + */ def apply(name: String, arg: Term): NamedArg def copy(original: Tree)(name: String, arg: Term): NamedArg - /** Matches a named argument ` = `. */ + /** Matches a named argument ` = `. + * + * @param x the `NamedArg` to match against + */ def unapply(x: NamedArg): (String, Term) } @@ -1186,12 +1375,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Apply`. */ trait ApplyModule { this: Apply.type => - /** Creates a function application `()`. */ + /** Creates a function application `()`. + * + * @param fun the function being applied + * @param args the term arguments + */ def apply(fun: Term, args: List[Term]): Apply def copy(original: Tree)(fun: Term, args: List[Term]): Apply - /** Matches a function application `()`. */ + /** Matches a function application `()`. + * + * @param x the `Apply` to match against + */ def unapply(x: Apply): (Term, List[Term]) } @@ -1204,23 +1400,27 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** The `fun` part of an (implicit) application like `fun(args)` * * It may be a partially applied method: - * ```scala + * ```scala sc:compile * def f(x1: Int)(x2: Int) = ??? * f(1)(2) * ``` * - `fun` is `f(1)` in the `Apply` of `f(1)(2)` * - `fun` is `f` in the `Apply` of `f(1)` + * + * @return the function part of the application */ def fun: Term /** The arguments (implicitly) passed to the method * * The `Apply` may be a partially applied method: - * ```scala + * ```scala sc:compile * def f(x1: Int)(x2: Int) = ??? * f(1)(2) * ``` * - `args` is `(2)` in the `Apply` of `f(1)(2)` * - `args` is `(1)` in the `Apply` of `f(1)` + * + * @return the list of arguments passed to the method */ def args: List[Term] end extension @@ -1238,12 +1438,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val TypeApply`. */ trait TypeApplyModule { this: TypeApply.type => - /** Creates a function type application `[]`. */ + /** Creates a function type application `[]`. + * + * @param fun the function being applied + * @param args the type argument trees + */ def apply(fun: Term, args: List[TypeTree]): TypeApply def copy(original: Tree)(fun: Term, args: List[TypeTree]): TypeApply - /** Matches a function type application `[]`. */ + /** Matches a function type application `[]`. + * + * @param x the `TypeApply` to match against + */ def unapply(x: TypeApply): (Term, List[TypeTree]) } @@ -1256,7 +1463,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** The `fun` part of an (inferred) type application like `fun[Args]` * * It may be a partially applied method: - * ```scala + * ```scala sc:compile * //{ * type T * //} @@ -1269,12 +1476,14 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * // f(1)[Int](2) * ``` * - `fun` is `f(1)` in the `TypeApply` of `f(1)[Int]` + * + * @return the function part of the type application */ def fun: Term /** The (inferred) type arguments passed to the method * * The `TypeApply` may be a partially applied method: - * ```scala + * ```scala sc:compile * //{ * type T * //} @@ -1287,6 +1496,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * // f(1)[Int](2) * ``` * - `fun` is `[Int]` in the `TypeApply` of `f(1)[Int]` + * + * @return the list of type arguments passed to the method */ def args: List[TypeTree] end extension @@ -1304,12 +1515,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Super`. */ trait SuperModule { this: Super.type => - /** Creates a `.super[`. */ + /** Creates a `.super[`. + * + * @param qual the qualifier term + * @param mix the optional mixin class name for `super[mix]` + */ def apply(qual: Term, mix: Option[String]): Super def copy(original: Tree)(qual: Term, mix: Option[String]): Super - /** Matches a `.super[`. */ + /** Matches a `.super[`. + * + * @param x the `Super` to match against + */ def unapply(x: Super): (Term, Option[String]) } @@ -1341,12 +1559,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Typed`. */ trait TypedModule { this: Typed.type => - /** Creates a type ascription `: `. */ + /** Creates a type ascription `: `. + * + * @param expr the expression being ascribed + * @param tpt the type tree for the ascription + */ def apply(expr: Term, tpt: TypeTree): Typed def copy(original: Tree)(expr: Term, tpt: TypeTree): Typed - /** Matches `: `. */ + /** Matches `: `. + * + * @param x the `Typed` to match against + */ def unapply(x: Typed): (Term, TypeTree) } @@ -1373,12 +1598,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Assign`. */ trait AssignModule { this: Assign.type => - /** Creates an assignment ` = `. */ + /** Creates an assignment ` = `. + * + * @param lhs the left-hand side of the assignment + * @param rhs the right-hand side of the assignment + */ def apply(lhs: Term, rhs: Term): Assign def copy(original: Tree)(lhs: Term, rhs: Term): Assign - /** Matches an assignment ` = `. */ + /** Matches an assignment ` = `. + * + * @param x the `Assign` to match against + */ def unapply(x: Assign): (Term, Term) } @@ -1405,12 +1637,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Block`. */ trait BlockModule { this: Block.type => - /** Creates a block `{ ; }`. */ + /** Creates a block `{ ; }`. + * + * @param stats the list of statements + * @param expr the result expression of the block + */ def apply(stats: List[Statement], expr: Term): Block def copy(original: Tree)(stats: List[Statement], expr: Term): Block - /** Matches a block `{ ; }`. */ + /** Matches a block `{ ; }`. + * + * @param x the `Block` to match against + */ def unapply(x: Block): (List[Statement], Term) } @@ -1484,6 +1723,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Block((DefDef(_, _, params :: Nil, _, Some(body))) :: Nil, Closure(meth, _)) * ``` * Extracts the parameter definitions and body. + * + * @param tree the tree to match against */ def unapply(tree: Block): Option[(List[ValDef], Term)] @@ -1532,12 +1773,20 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val If`. */ trait IfModule { this: If.type => - /** Creates an if/then/else `if () else `. */ + /** Creates an if/then/else `if () else `. + * + * @param cond the condition expression + * @param thenp the then branch expression + * @param elsep the else branch expression + */ def apply(cond: Term, thenp: Term, elsep: Term): If def copy(original: Tree)(cond: Term, thenp: Term, elsep: Term): If - /** Matches an if/then/else `if () else `. */ + /** Matches an if/then/else `if () else `. + * + * @param tree the tree to match against + */ def unapply(tree: If): (Term, Term, Term) } @@ -1566,12 +1815,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Match`. */ trait MatchModule { this: Match.type => - /** Creates a pattern match ` match { }`. */ + /** Creates a pattern match ` match { }`. + * + * @param selector the scrutinee expression being matched + * @param cases the list of case definitions + */ def apply(selector: Term, cases: List[CaseDef]): Match def copy(original: Tree)(selector: Term, cases: List[CaseDef]): Match - /** Matches a pattern match ` match { }`. */ + /** Matches a pattern match ` match { }`. + * + * @param x the `Match` to match against + */ def unapply(x: Match): (Term, List[CaseDef]) } @@ -1599,12 +1855,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val SummonFrom`. */ trait SummonFromModule { this: SummonFrom.type => - /** Creates a pattern match `given match { }`. */ + /** Creates a pattern match `given match { }`. + * + * @param cases the list of match cases for the given match + */ def apply(cases: List[CaseDef]): SummonFrom def copy(original: Tree)(cases: List[CaseDef]): SummonFrom - /** Matches a pattern match `given match { }`. */ + /** Matches a pattern match `given match { }`. + * + * @param x the `SummonFrom` to match against + */ def unapply(x: SummonFrom): Some[List[CaseDef]] } @@ -1630,12 +1892,20 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Try`. */ trait TryModule { this: Try.type => - /** Creates a try/catch `try catch { } finally `. */ + /** Creates a try/catch `try catch { } finally `. + * + * @param expr the body expression of the try block + * @param cases the list of catch case definitions + * @param finalizer the optional finally block expression + */ def apply(expr: Term, cases: List[CaseDef], finalizer: Option[Term]): Try def copy(original: Tree)(expr: Term, cases: List[CaseDef], finalizer: Option[Term]): Try - /** Matches a try/catch `try catch { } finally `. */ + /** Matches a try/catch `try catch { } finally `. + * + * @param x the `Try` to match against + */ def unapply(x: Try): (Term, List[CaseDef], Option[Term]) } @@ -1663,12 +1933,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Return`. */ trait ReturnModule { this: Return.type => - /** Creates `return `. */ + /** Creates `return `. + * + * @param expr the expression being returned + * @param from the symbol of the enclosing method + */ def apply(expr: Term, from: Symbol): Return def copy(original: Tree)(expr: Term, from: Symbol): Return - /** Matches `return ` and extracts the expression and symbol of the method. */ + /** Matches `return ` and extracts the expression and symbol of the method. + * + * @param x the `Return` to match against + */ def unapply(x: Return): (Term, Symbol) } @@ -1691,7 +1968,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * arguments `1, 2` of `List.apply(1, 2)` can be represented as follows: * * - * ```scala + * ```scala sc:compile * //{ * import scala.quoted._ * def inQuotes(using Quotes) = { @@ -1718,11 +1995,23 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Repeated`. */ trait RepeatedModule { this: Repeated.type => - /** Creates a literal sequence of elements. */ + /** Creates a literal sequence of elements. + * + * @param elems the list of element terms in the sequence + * @param tpt the element type tree + */ def apply(elems: List[Term], tpt: TypeTree): Repeated - /** Copies a literal sequence of elements. */ + /** Copies a literal sequence of elements. + * + * @param original the original tree being copied + * @param elems the list of element terms in the sequence + * @param tpt the element type tree + */ def copy(original: Tree)(elems: List[Term], tpt: TypeTree): Repeated - /** Matches a literal sequence of elements. */ + /** Matches a literal sequence of elements. + * + * @param x the `Repeated` to match against + */ def unapply(x: Repeated): (List[Term], TypeTree) } @@ -1805,12 +2094,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val While`. */ trait WhileModule { this: While.type => - /** Creates a while loop `while () ` and returns (, ). */ + /** Creates a while loop `while () ` and returns (, ). + * + * @param cond the condition expression + * @param body the loop body expression + */ def apply(cond: Term, body: Term): While def copy(original: Tree)(cond: Term, body: Term): While - /** Extractor for while loops. Matches `while () ` and returns (, ). */ + /** Extractor for while loops. Matches `while () ` and returns (, ). + * + * @param x the `While` to match against + */ def unapply(x: While): (Term, Term) } @@ -1837,12 +2133,19 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val TypedOrTest`. */ trait TypedOrTestModule { this: TypedOrTest.type => - /** Creates a type ascription `: `. */ + /** Creates a type ascription `: `. + * + * @param expr the expression being ascribed + * @param tpt the type tree for the ascription + */ def apply(expr: Tree, tpt: TypeTree): TypedOrTest def copy(original: Tree)(expr: Tree, tpt: TypeTree): TypedOrTest - /** Matches `: `. */ + /** Matches `: `. + * + * @param x the `TypedOrTest` to match against + */ def unapply(x: TypedOrTest): (Tree, TypeTree) } @@ -1870,7 +2173,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val TypeTree`. */ trait TypeTreeModule { this: TypeTree.type => - /** Returns the tree of type or kind (TypeTree) of T. */ + /** Returns the tree of type or kind (TypeTree) of T. + * + * @tparam T the type or kind to create a `TypeTree` for + */ def of[T <: AnyKind](using Type[T]): TypeTree /** Returns a type tree reference to the symbol @@ -1903,7 +2209,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Inferred`. */ trait InferredModule { this: Inferred.type => def apply(tpe: TypeRepr): Inferred - /** Matches a TypeTree containing an inferred type. */ + /** Matches a TypeTree containing an inferred type. + * + * @param x the `Inferred` to match against + */ def unapply(x: Inferred): true } @@ -2279,7 +2588,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val WildcardTypeTree`. */ trait WildcardTypeTreeModule { this: WildcardTypeTree.type => def apply(tpe: TypeRepr): WildcardTypeTree - /** Matches a TypeBoundsTree containing wildcard type bounds. */ + /** Matches a TypeBoundsTree containing wildcard type bounds. + * + * @param x the `WildcardTypeTree` to match against + */ def unapply(x: WildcardTypeTree): true } @@ -2390,11 +2702,25 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Unapply`. */ trait UnapplyModule { this: Unapply.type => - /** Creates an `Unapply` tree representing a pattern `()(using )`. */ + /** Creates an `Unapply` tree representing a pattern `()(using )`. + * + * @param fun the extractor function + * @param implicits the implicit arguments passed to the extractor + * @param patterns the list of nested patterns + */ def apply(fun: Term, implicits: List[Term], patterns: List[Tree]): Unapply - /** Copies an `Unapply` tree representing a pattern `()(using )`. */ + /** Copies an `Unapply` tree representing a pattern `()(using )`. + * + * @param original the original tree being copied + * @param fun the extractor function + * @param implicits the implicit arguments passed to the extractor + * @param patterns the list of nested patterns + */ def copy(original: Tree)(fun: Term, implicits: List[Term], patterns: List[Tree]): Unapply - /** Matches an `Unapply(fun, implicits, patterns)` tree representing a pattern `()(using )`. */ + /** Matches an `Unapply(fun, implicits, patterns)` tree representing a pattern `()(using )`. + * + * @param x the `Unapply` to match against + */ def unapply(x: Unapply): (Term, List[Term], List[Tree]) } @@ -2408,6 +2734,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * It may be a reference to the `unapply` method of the pattern or may be a * partially applied tree containing type parameters and leading given parameters. + * + * @return the function part of the application */ def fun: Term /** Training implicit parameters of the `unapply` method. */ @@ -2448,7 +2776,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * `[X1, ..., Xn]` are represented with `TypeParamClause` and `(x1: X1, ..., xn: Xx)` are represented with `TermParamClause` * * `ParamClause` encodes the following enumeration - * ```scala + * ```scala sc:compile * //{ * import scala.quoted.* * def inQuotes(using Quotes) = { @@ -2682,10 +3010,16 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val TypeRepr`. */ trait TypeReprModule { this: TypeRepr.type => - /** Returns the type or kind (TypeRepr) of T. */ + /** Returns the type or kind (TypeRepr) of T. + * + * @tparam T the type or kind to get the `TypeRepr` for + */ def of[T <: AnyKind](using Type[T]): TypeRepr - /** Returns the type constructor of the runtime (erased) class. */ + /** Returns the type constructor of the runtime (erased) class. + * + * @param clazz the runtime class + */ def typeConstructorOf(clazz: Class[?]): TypeRepr } @@ -2702,7 +3036,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Converts this `TypeRepr` to an `Type[?]` * * Usage: - * ```scala + * ```scala sc:compile * //{ * import scala.quoted.* * def f(using Quotes) = { @@ -2717,6 +3051,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * } * //} * ``` + * + * @return a `Type[?]` representation of this type */ def asType: Type[?] @@ -2736,6 +3072,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * class Outer { class C ; val x: C } * def o: Outer * .widen = o.C + * + * @return the widened type */ def widen: TypeRepr @@ -2766,6 +3104,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** The type of `member` as seen from prefix `self`. * * Also see `typeRef` and `termRef` + * + * @param member the member symbol whose type is to be computed + * @return the type of the member as seen from this prefix type */ def memberType(member: Symbol): TypeRepr @@ -2779,10 +3120,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * class C extends p.D[Int] * ThisType(C).baseType(D) = p.D[Int] * ``` + * + * @param cls the class symbol to compute the base type for */ def baseType(cls: Symbol): TypeRepr - /** Is this type an instance of a non-bottom subclass of the given class `cls`? */ + /** Is this type an instance of a non-bottom subclass of the given class `cls`? + * + * @param cls the class symbol to check against + */ def derivesFrom(cls: Symbol): Boolean /** Is this type a function type? @@ -2820,17 +3166,29 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => */ def isTupleN: Boolean - /** The type , reduced if possible. */ + /** The type , reduced if possible. + * + * @param sym the member symbol to select + */ def select(sym: Symbol): TypeRepr - /** The current type applied to given type arguments: `this[targ]`. */ + /** The current type applied to given type arguments: `this[targ]`. + * + * @param targ the type argument to apply + */ def appliedTo(targ: TypeRepr): TypeRepr - /** The current type applied to given type arguments: `this[targ0, ..., targN]`. */ + /** The current type applied to given type arguments: `this[targ0, ..., targN]`. + * + * @param targs the type arguments + */ def appliedTo(targs: List[TypeRepr]): TypeRepr /** Substitutes all types that refer in their symbol attribute to * one of the symbols in `from` by the corresponding types in `to`. + * + * @param from the list of symbols to substitute + * @param to the list of replacement types corresponding to `from` */ def substituteTypes(from: List[Symbol], to: List[TypeRepr]): TypeRepr @@ -2985,7 +3343,11 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val AppliedType`. */ trait AppliedTypeModule { this: AppliedType.type => - /** Applied the type constructor `T` to a list of type arguments `T_1,..,T_n` to create `T[T_1,..,T_n]`. */ + /** Applied the type constructor `T` to a list of type arguments `T_1,..,T_n` to create `T[T_1,..,T_n]`. + * + * @param tycon the type constructor + * @param args the type arguments + */ def apply(tycon: TypeRepr, args: List[TypeRepr]): AppliedType def unapply(x: AppliedType): (TypeRepr, List[TypeRepr]) } @@ -3105,7 +3467,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Type of a by-name definition of type `=>T`. * * May represent by-name parameter such as `thunk` in - * ```scala + * ```scala sc:compile * //{ * type T * //} @@ -3113,7 +3475,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * ``` * * May also represent a the return type of a parameterless method definition such as - * ```scala + * ```scala sc:compile * def foo: Int = ??? * ``` */ @@ -3233,6 +3595,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * where `z` refers to the created rec-type is replaced by * `type T`. This avoids infinite recursions later when we * try to follow these references. + * + * @param parentExp a function that takes the recursive type itself and returns its underlying type + * @return a new `RecursiveType` */ def apply(parentExp: RecursiveType => TypeRepr): RecursiveType @@ -3371,13 +3736,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Extension methods of `TypeLambda`. */ trait TypeLambdaMethods: extension (self: TypeLambda) - /** Reference to the i-th parameter. */ + /** Reference to the i-th parameter. + * + * @param idx the zero-based index of the parameter + */ def param(idx: Int) : TypeRepr /** Type bounds of the i-th parameter. */ def paramBounds: List[TypeBounds] /** Variance flags for the i-th parameter * * Variance flags can be one of `Flags.{Covariant, Contravariant, EmptyFlags}`. + * + * @return the list of variance flags, one per type parameter */ def paramVariances: List[Flags] end extension @@ -3532,9 +3902,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val BooleanConstant`. */ trait BooleanConstantModule { this: BooleanConstant.type => - /** Creates a constant Boolean value. */ + /** Creates a constant Boolean value. + * + * @param x the `Boolean` value + */ def apply(x: Boolean): BooleanConstant - /** Match Boolean value constant and extract its value. */ + /** Match Boolean value constant and extract its value. + * + * @param constant the `BooleanConstant` to match against + */ def unapply(constant: BooleanConstant): Some[Boolean] } @@ -3549,9 +3925,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val ByteConstant`. */ trait ByteConstantModule { this: ByteConstant.type => - /** Creates a constant Byte value. */ + /** Creates a constant Byte value. + * + * @param x the `Byte` value + */ def apply(x: Byte): ByteConstant - /** Match Byte value constant and extract its value. */ + /** Match Byte value constant and extract its value. + * + * @param constant the `ByteConstant` to match against + */ def unapply(constant: ByteConstant): Some[Byte] } @@ -3566,9 +3948,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Short`. */ trait ShortConstantModule { this: ShortConstant.type => - /** Creates a constant Short value. */ + /** Creates a constant Short value. + * + * @param x the `Short` value + */ def apply(x: Short): ShortConstant - /** Match Short value constant and extract its value. */ + /** Match Short value constant and extract its value. + * + * @param constant the `ShortConstant` to match against + */ def unapply(constant: ShortConstant): Some[Short] } @@ -3583,9 +3971,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val IntConstant`. */ trait IntConstantModule { this: IntConstant.type => - /** Creates a constant Int value. */ + /** Creates a constant Int value. + * + * @param x the `Int` value + */ def apply(x: Int): IntConstant - /** Match Int value constant and extract its value. */ + /** Match Int value constant and extract its value. + * + * @param constant the `IntConstant` to match against + */ def unapply(constant: IntConstant): Some[Int] } @@ -3600,9 +3994,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val LongConstant`. */ trait LongConstantModule { this: LongConstant.type => - /** Creates a constant Long value. */ + /** Creates a constant Long value. + * + * @param x the `Long` value + */ def apply(x: Long): LongConstant - /** Match Long value constant and extract its value. */ + /** Match Long value constant and extract its value. + * + * @param constant the `LongConstant` to match against + */ def unapply(constant: LongConstant): Some[Long] } @@ -3617,9 +4017,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val FloatConstant`. */ trait FloatConstantModule { this: FloatConstant.type => - /** Creates a constant Float value. */ + /** Creates a constant Float value. + * + * @param x the `Float` value + */ def apply(x: Float): FloatConstant - /** Match Float value constant and extract its value. */ + /** Match Float value constant and extract its value. + * + * @param constant the `FloatConstant` to match against + */ def unapply(constant: FloatConstant): Some[Float] } @@ -3634,9 +4040,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val DoubleConstant`. */ trait DoubleConstantModule { this: DoubleConstant.type => - /** Creates a constant Double value. */ + /** Creates a constant Double value. + * + * @param x the `Double` value + */ def apply(x: Double): DoubleConstant - /** Match Double value constant and extract its value. */ + /** Match Double value constant and extract its value. + * + * @param constant the `DoubleConstant` to match against + */ def unapply(constant: DoubleConstant): Some[Double] } @@ -3651,9 +4063,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val CharConstant`. */ trait CharConstantModule { this: CharConstant.type => - /** Creates a constant Char value. */ + /** Creates a constant Char value. + * + * @param x the `Char` value + */ def apply(x: Char): CharConstant - /** Match Char value constant and extract its value. */ + /** Match Char value constant and extract its value. + * + * @param constant the `CharConstant` to match against + */ def unapply(constant: CharConstant): Some[Char] } @@ -3671,9 +4089,14 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Creates a constant String value * * @throw `IllegalArgumentException` if the argument is `null` + * + * @param x the `String` value */ def apply(x: String): StringConstant - /** Match String value constant and extract its value. */ + /** Match String value constant and extract its value. + * + * @param constant the `StringConstant` to match against + */ def unapply(constant: StringConstant): Some[String] } @@ -3690,7 +4113,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => trait UnitConstantModule { this: UnitConstant.type => /** Creates a constant Unit value. */ def apply(): UnitConstant - /** Match Unit value constant. */ + /** Match Unit value constant. + * + * @param constant the `UnitConstant` to match against + */ def unapply(constant: UnitConstant): true } @@ -3707,7 +4133,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => trait NullConstantModule { this: NullConstant.type => /** Creates a constant null value. */ def apply(): NullConstant - /** Matches null value constant. */ + /** Matches null value constant. + * + * @param constant the `NullConstant` to match against + */ def unapply(constant: NullConstant): Boolean } @@ -3722,9 +4151,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val ClassOf`. */ trait ClassOfConstantModule { this: ClassOfConstant.type => - /** Creates a constant class value representing `classOf[]`. */ + /** Creates a constant class value representing `classOf[]`. + * + * @param tpe the type represented by the `classOf` constant + */ def apply(tpe: TypeRepr): ClassOfConstant - /** Matches a class value constant representing `classOf[]` and extracts its type. */ + /** Matches a class value constant representing `classOf[]` and extracts its type. + * + * @param constant the `ClassOfConstant` to match against + */ def unapply(constant: ClassOfConstant): Option[TypeRepr] } @@ -3750,6 +4185,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * @param tpe type of the implicit parameter * @param ignored Symbols ignored during the initial implicit search + * @return the result of the implicit search * * @note if an found given requires additional search for other given instances, * this additional search will NOT exclude the symbols from the `ignored` list. @@ -3828,22 +4264,39 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * ``` * * For a macro splice, it is the symbol of the definition where the macro expansion happens. + * + * @return the symbol of the definition enclosing the current macro expansion splice */ def spliceOwner: Symbol - /** Gets package symbol if package is either defined in current compilation run or present on classpath. */ + /** Gets package symbol if package is either defined in current compilation run or present on classpath. + * + * @param path the fully qualified package name (e.g., `scala.collection.immutable`) + */ def requiredPackage(path: String): Symbol - /** Gets class symbol if class is either defined in current compilation run or present on classpath. */ + /** Gets class symbol if class is either defined in current compilation run or present on classpath. + * + * @param path the fully qualified name (e.g., `scala.collection.immutable.List`) + */ def requiredClass(path: String): Symbol - /** Gets module symbol if module is either defined in current compilation run or present on classpath. */ + /** Gets module symbol if module is either defined in current compilation run or present on classpath. + * + * @param path the fully qualified module name (e.g., `scala.Predef`) + */ def requiredModule(path: String): Symbol - /** Gets method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload. */ + /** Gets method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload. + * + * @param path the fully qualified method name (e.g., `scala.Predef.println`) + */ def requiredMethod(path: String): Symbol - /** The class Symbol of a global class definition. */ + /** The class Symbol of a global class definition. + * + * @param fullName the fully qualified name of the class + */ def classSymbol(fullName: String): Symbol /** Generates a new class symbol for a class with a public parameterless constructor. @@ -3880,6 +4333,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @param parents The parent classes of the class. The first parent must not be a trait. * @param decls The member declarations of the class provided the symbol of this class * @param selfType The self type of the class if it has one + * @return the newly created class symbol * * This symbol starts without an accompanying definition. * It is the meta-programmer's responsibility to provide exactly one corresponding definition by passing @@ -4069,7 +4523,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * This method returns the module symbol. The module class can be accessed calling `moduleClass` on this symbol. * * Example usage: - * ```scala + * ```scala sc:compile * //{ * given Quotes = ??? * import quotes.reflect.* @@ -4091,7 +4545,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Block(modDef.toList, callRun) * ``` * constructs the equivalent to - * ```scala + * ```scala sc:compile * //{ * given Quotes = ??? * import quotes.reflect.* @@ -4103,13 +4557,14 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * } * ``` * - * @param parent The owner of the class * @param name The name of the class * @param modFlags extra flags with which the module symbol should be constructed * @param clsFlags extra flags with which the module class symbol should be constructed * @param parents A function that takes the symbol of the module class as input and returns the parent classes of the class. The first parent must not be a trait. * @param decls A function that takes the symbol of the module class as input and returns the symbols of its declared members * @param privateWithin the symbol within which this new method symbol should be private. May be noSymbol. + * @param owner the owner of the module + * @return the newly created module symbol * * This symbol starts without an accompanying definition. * It is the meta-programmer's responsibility to provide exactly one corresponding definition by passing @@ -4129,6 +4584,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @param parent The owner of the method * @param name The name of the method * @param tpe The type of the method (MethodType, PolyType, ByNameType) + * @return the newly created method symbol * * This symbol starts without an accompanying definition. * It is the meta-programmer's responsibility to provide exactly one corresponding definition by passing @@ -4148,6 +4604,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @param tpe The type of the method (MethodType, PolyType, ByNameType) * @param flags extra flags to with which the symbol should be constructed. `Method` flag will be added. Can be `Private | Protected | Override | Deferred | Final | Method | Implicit | Given | Local | JavaStatic | Synthetic | Artifact` * @param privateWithin the symbol within which this new method symbol should be private. May be noSymbol. + * @return the newly created method symbol */ // Keep: `flags` doc aligned with QuotesImpl's `validMethodFlags` def newMethod(parent: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol @@ -4165,6 +4622,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @param tpe The type of the val/var/lazy val * @param flags extra flags to with which the symbol should be constructed. Can be `Private | Protected | Override | Deferred | Final | Param | Implicit | Lazy | Mutable | Local | ParamAccessor | Module | Package | Case | CaseAccessor | Given | Enum | JavaStatic | Synthetic | Artifact` * @param privateWithin the symbol within which this new method symbol should be private. May be noSymbol. + * @return the newly created val symbol * @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be * direct or indirect children of the reflection context's owner. */ @@ -4181,6 +4639,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @param name The name of the binding * @param flags extra flags to with which the symbol should be constructed. `Case` flag will be added. Can be `Case` * @param tpe The type of the binding + * @return the newly created bind symbol * @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be * direct or indirect children of the reflection context's owner. */ @@ -4198,6 +4657,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @param flags extra flags to with which symbol can be constructed. Can be `Private` | `Protected` | `Override` | `Final` | `Infix` | `Local` * @param tpe The rhs the type alias * @param privateWithin the symbol within which this new type symbol should be private. May be noSymbol. + * @return the newly created type alias symbol * @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be * direct or indirect children of the reflection context's owner. */ @@ -4216,6 +4676,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @param flags extra flags to with which symbol can be constructed. `Deferred` flag will be added. Can be `Private` | `Protected` | `Override` | `Deferred` | `Final` | `Infix` | `Local` * @param tpe The bounds of the type * @param privateWithin the symbol within which this new type symbol should be private. May be noSymbol. + * @return the newly created bounded type symbol * @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be * direct or indirect children of the reflection context's owner. */ @@ -4234,6 +4695,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Examples: See `scala.annotation.MacroAnnotation` * * @param prefix Prefix of the fresh name + * @return a fresh name with the given prefix */ def freshName(prefix: String): String } @@ -4300,13 +4762,21 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * tp.memberType(symbol) * symbol.typeRef * symbol.termRef + * + * @return the definition tree of this symbol */ def tree: Tree - /** Is the annotation defined with `annotSym` attached to this symbol? */ + /** Is the annotation defined with `annotSym` attached to this symbol? + * + * @param annotSym the symbol of the annotation to check for + */ def hasAnnotation(annotSym: Symbol): Boolean - /** Gets the annotation defined with `annotSym` attached to this symbol. */ + /** Gets the annotation defined with `annotSym` attached to this symbol. + * + * @param annotSym the symbol of the annotation to retrieve + */ def getAnnotation(annotSym: Symbol): Option[Term] /** Annotations attached to this symbol. */ @@ -4371,7 +4841,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Does this symbol represent a definition? */ def exists: Boolean - /** Field with the given name directly declared in the class. */ + /** Field with the given name directly declared in the class. + * + * @param name the name of the field + */ def declaredField(name: String): Symbol /** Fields directly declared in the class. */ @@ -4381,7 +4854,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => @deprecated("Use fieldMember", "3.1.0") def memberField(name: String): Symbol - /** Gets named non-private fields declared or inherited. */ + /** Gets named non-private fields declared or inherited. + * + * @param name the name of the field + */ def fieldMember(name: String): Symbol /** Gets all non-private fields declared or inherited. */ @@ -4391,7 +4867,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Gets all non-private fields declared or inherited. */ def fieldMembers: List[Symbol] - /** Gets non-private named methods defined directly inside the class. */ + /** Gets non-private named methods defined directly inside the class. + * + * @param name the name of the method + */ def declaredMethod(name: String): List[Symbol] /** Gets all non-private methods defined directly inside the class, excluding constructors. */ @@ -4401,7 +4880,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => @deprecated("Use methodMember", "3.1.0") def memberMethod(name: String): List[Symbol] - /** Gets named non-private methods declared or inherited. */ + /** Gets named non-private methods declared or inherited. + * + * @param name the name of the method + */ def methodMember(name: String): List[Symbol] /** Gets all non-private methods declared or inherited. */ @@ -4411,7 +4893,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Gets all non-private methods declared or inherited. */ def methodMembers: List[Symbol] - /** Gets non-private named type defined directly inside the class. */ + /** Gets non-private named type defined directly inside the class. + * + * @param name the name of the type + */ def declaredType(name: String): List[Symbol] /** Gets all non-private types defined directly inside the class. */ @@ -4421,7 +4906,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => @deprecated("Use declaredType or typeMember", "3.1.0") def memberType(name: String): Symbol - /** Type member with the given name declared or inherited in the class. */ + /** Type member with the given name declared or inherited in the class. + * + * @param name the name of the type member + */ def typeMember(name: String): Symbol /** Type member directly declared in the class. */ @@ -4461,6 +4949,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * Variance flags can be one of `Flags.{Covariant, Contravariant, EmptyFlags}`. * If this is not the symbol of a type parameter the result is `Flags.EmptyFlags`. + * + * @return the variance flags for this type parameter */ def paramVariance: Flags @@ -4484,7 +4974,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Changes the owner under which the definition in a quote are created. * * Usages: - * ```scala + * ```scala sc:compile * def rhsExpr(using q: Quotes): Expr[Unit] = * import q.reflect.* * '{ val y = ???; (y, y) } @@ -4495,7 +4985,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * ValDef(sym, Some(rhs)) * ``` * - * ```scala + * ```scala sc:compile * //{ * def inQuotes(using q: Quotes) = { * import q.reflect.* @@ -4512,6 +5002,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * } * //} * ``` + * + * @return a nested `Quotes` instance with this symbol as the splice owner */ def asQuotes: Nested @@ -4521,6 +5013,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @see TypeReprMethods.select * * @pre symbol.isType returns true + * + * @return a `TypeRef` to this type symbol */ def typeRef: TypeRef @@ -4544,7 +5038,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val Signature`. */ trait SignatureModule { this: Signature.type => - /** Matches the method signature and returns its parameters and result type. */ + /** Matches the method signature and returns its parameters and result type. + * + * @param sig the signature to match against + */ def unapply(sig: Signature): (List[String | Int], String) } @@ -4561,6 +5058,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * to the number of type parameters in the section. * Each *term parameter* is represented by a String corresponding to the fully qualified * name of the parameter type. + * + * @return the list of parameter signatures */ def paramSigs: List[String | Int] @@ -4733,10 +5232,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * - 22nd element is `Tuple22` * - 23nd element is `NoSymbol` // TODO update when we will have more tuples * - ... + * + * @param arity the arity of the tuple */ def TupleClass(arity: Int): Symbol - /** Returns `true` if `sym` is a `Tuple1`, `Tuple2`, ... `Tuple22`. */ + /** Returns `true` if `sym` is a `Tuple1`, `Tuple2`, ... `Tuple22`. + * + * @param sym the symbol to check + */ def isTupleClass(sym: Symbol): Boolean /** Contains Scala primitive value classes: @@ -4785,6 +5289,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * This corresponds to a definition declared as "abstract override def" in the source. * See https://stackoverflow.com/questions/23645172/why-is-abstract-override-required-not-override-alone-in-subtrait for examples. + * + * @return the flag indicating an abstract override definition */ def AbsOverride: Flags @@ -4933,13 +5439,22 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Extension methods of `Flags`. */ trait FlagsMethods { extension (self: Flags) - /** Is the given flag set a subset of this flag sets. */ + /** Is the given flag set a subset of this flag sets. + * + * @param that the flag set to check for + */ def is(that: Flags): Boolean - /** Union of the two flag sets. */ + /** Union of the two flag sets. + * + * @param that the flag set to combine with + */ def |(that: Flags): Flags - /** Intersection of the two flag sets. */ + /** Intersection of the two flag sets. + * + * @param that the flag set to combine with + */ def &(that: Flags): Flags /** Shows the flags as a String. */ @@ -4965,7 +5480,12 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Position of the expansion site of the macro. */ def ofMacroExpansion: Position - /** Creates a new position in the source with the given range. The range must be contained in the file. */ + /** Creates a new position in the source with the given range. The range must be contained in the file. + * + * @param sourceFile the source file for the position + * @param start the start offset in the source file + * @param end the end offset in the source file + */ def apply(sourceFile: SourceFile, start: Int, end: Int): Position } @@ -5035,6 +5555,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * It does not necessarily point to a path in the filesystem, it could be the path of a virtual file. * Use `getJPath` to get paths to the filesystem. + * + * @return the path string of this source file */ def path: String @@ -5053,22 +5575,44 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val report`. */ trait reportModule { self: report.type => - /** Report an error at the position of the macro expansion. */ + /** Report an error at the position of the macro expansion. + * + * @param msg the message text to report + */ def error(msg: String): Unit - /** Report an error at the position of `expr`. */ + /** Report an error at the position of `expr`. + * + * @param msg the message text to report + * @param expr the expression whose position is used for reporting + */ def error(msg: String, expr: Expr[Any]): Unit - /** Report an error message at the given position. */ + /** Report an error message at the given position. + * + * @param msg the message text to report + * @param pos the position at which to report the message + */ def error(msg: String, pos: Position): Unit - /** Report an error at the position of the macro expansion and throw a StopMacroExpansion. */ + /** Report an error at the position of the macro expansion and throw a StopMacroExpansion. + * + * @param msg the message text to report + */ def errorAndAbort(msg: String): Nothing - /** Report an error at the position of `expr` and throw a StopMacroExpansion. */ + /** Report an error at the position of `expr` and throw a StopMacroExpansion. + * + * @param msg the message text to report + * @param expr the expression whose position is used for reporting + */ def errorAndAbort(msg: String, expr: Expr[Any]): Nothing - /** Report an error message at the given position and throw a StopMacroExpansion. */ + /** Report an error message at the given position and throw a StopMacroExpansion. + * + * @param msg the message text to report + * @param pos the position at which to report the message + */ def errorAndAbort(msg: String, pos: Position): Nothing /** Report an error at the position of the macro expansion and throw a StopMacroExpansion. */ @@ -5083,22 +5627,44 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => @deprecated("Use errorAndAbort", "3.1.0") def throwError(msg: String, pos: Position): Nothing - /** Report a warning at the position of the macro expansion. */ + /** Report a warning at the position of the macro expansion. + * + * @param msg the message text to report + */ def warning(msg: String): Unit - /** Report a warning at the position of `expr`. */ + /** Report a warning at the position of `expr`. + * + * @param msg the message text to report + * @param expr the expression whose position is used for reporting + */ def warning(msg: String, expr: Expr[Any]): Unit - /** Report a warning message at the given position. */ + /** Report a warning message at the given position. + * + * @param msg the message text to report + * @param pos the position at which to report the message + */ def warning(msg: String, pos: Position): Unit - /** Report an info at the position of the macro expansion. */ + /** Report an info at the position of the macro expansion. + * + * @param msg the message text to report + */ def info(msg: String): Unit - /** Report an info message at the position of `expr`. */ + /** Report an info message at the position of `expr`. + * + * @param msg the message text to report + * @param expr the expression whose position is used for reporting + */ def info(msg: String, expr: Expr[Any]): Unit - /** Report an info message at the given position. */ + /** Report an info message at the given position. + * + * @param msg the message text to report + * @param pos the position at which to report the message + */ def info(msg: String, pos: Position): Unit } @@ -5112,7 +5678,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Customizable Tree accumulator. * * Usage: - * ```scala + * ```scala sc:compile * //{ * def inQuotes(using q: Quotes) = { * import q.reflect.* @@ -5124,6 +5690,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * } * //} * ``` + * + * @tparam X the type of the accumulated value */ trait TreeAccumulator[X]: @@ -5225,7 +5793,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Customizable tree traverser. * * Usage: - * ```scala + * ```scala sc:compile * //{ * def inQuotes(using q: Quotes) = { * import q.reflect.* @@ -5251,7 +5819,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Customizable tree mapper. * * Usage: - * ```scala + * ```scala sc:compile * //{ * def inQuotes(using q: Quotes) = { * import q.reflect.* @@ -5445,9 +6013,15 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => end TreeMap - /** Type class used in `show` methods to provide customizable `String` representations. */ + /** Type class used in `show` methods to provide customizable `String` representations. + * + * @tparam T the type of value that this printer can render + */ trait Printer[T]: - /** Shows the arguments as a `String`. */ + /** Shows the arguments as a `String`. + * + * @param x the value to render as a `String` + */ def show(x: T): String end Printer diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index 58368692d2bb..963b498f415c 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -6,10 +6,15 @@ import scala.reflect.ClassTag /** A type class for types that can convert a value of `T` into `quoted.Expr[T]` * an expression that will create a copy of the value. + * + * @tparam T the type of the value to be lifted into an `Expr[T]` */ trait ToExpr[T] { - /** Lift a value into an expression containing the construction of that value. */ + /** Lift a value into an expression containing the construction of that value. + * + * @param x the value to lift into a quoted expression + */ def apply(x: T)(using Quotes): Expr[T] } diff --git a/library/src/scala/quoted/Type.scala b/library/src/scala/quoted/Type.scala index b18a873201aa..c9fa1bfc151f 100644 --- a/library/src/scala/quoted/Type.scala +++ b/library/src/scala/quoted/Type.scala @@ -4,7 +4,10 @@ import language.experimental.captureChecking import scala.annotation.{compileTimeOnly, experimental} -/** Type (or type constructor) `T` needed contextually when using `T` in a quoted expression `'{... T ...}`. */ +/** Type (or type constructor) `T` needed contextually when using `T` in a quoted expression `'{... T ...}`. + * + * @tparam T the type or type constructor being represented + */ abstract class Type[T <: AnyKind] private[scala]: /** The type represented by `Type`. */ type Underlying = T @@ -13,7 +16,10 @@ end Type /** Methods to interact with the current `Type[T]` in scope. */ object Type: - /** Shows a source code like representation of this type without syntax highlight. */ + /** Shows a source code like representation of this type without syntax highlight. + * + * @tparam T the type or type constructor to show + */ def show[T <: AnyKind](using Type[T])(using Quotes): String = import quotes.reflect.* TypeTree.of[T].show @@ -28,7 +34,7 @@ object Type: * Returns `None` if the type is not a singleton constant type. * * Example usage: - * ```scala + * ```scala sc:compile * //{ * import scala.deriving.* * def f(using Quotes) = { @@ -43,6 +49,9 @@ object Type: * } * //} * ``` + * + * @tparam T the singleton constant type to extract the value from + * @return `Some` with the constant value if `T` is a singleton constant type, `None` otherwise */ def valueOfConstant[T](using Type[T])(using Quotes): Option[T] = ValueOf.unapply(quotes.reflect.TypeRepr.of[T]).asInstanceOf[Option[T]] @@ -52,7 +61,7 @@ object Type: * Returns `None` if the type is not a tuple singleton constant types. * * Example usage: - * ```scala + * ```scala sc:compile * //{ * import scala.deriving.* * def f(using Quotes) = { @@ -67,6 +76,9 @@ object Type: * } * //} * ``` + * + * @tparam T the tuple type of singleton constant types to extract values from + * @return `Some` with the tuple of constant values if all elements are singleton constant types, `None` otherwise */ def valueOfTuple[T <: Tuple](using Type[T])(using Quotes): Option[T] = valueOfTuple(quotes.reflect.TypeRepr.of[T]).asInstanceOf[Option[T]] diff --git a/library/src/scala/quoted/Varargs.scala b/library/src/scala/quoted/Varargs.scala index f5096d8c4e35..db34df55ab40 100644 --- a/library/src/scala/quoted/Varargs.scala +++ b/library/src/scala/quoted/Varargs.scala @@ -17,7 +17,7 @@ object Varargs { * `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]` * * Usage: - * ```scala + * ```scala sc:compile * //{ * def f(using Quotes) = { * import quotes.reflect.* @@ -27,6 +27,10 @@ object Varargs { * } * //} * ``` + * + * @tparam T the element type of the expressions in the sequence + * @param xs the sequence of individual expressions to lift into a single expression + * @return an expression representing the sequence `Seq(xs(0), xs(1), ...)` as an `Expr[Seq[T]]` */ def apply[T](xs: Seq[Expr[T]])(using Type[T])(using Quotes): Expr[Seq[T]] = { import quotes.reflect.* @@ -36,12 +40,16 @@ object Varargs { /** Matches a literal sequence of expressions and returns a sequence of expressions. * * Usage: - * ```scala + * ```scala sc:compile * inline def sum(args: Int*): Int = ${ sumExpr('args) } * def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] = argsExpr match - * case Varargs(argVarargs) => ??? + * case Varargs(argVarargs) => Expr(argVarargs.size) * // argVarargs: Seq[Expr[Int]] + * ``` * + * @tparam T the element type of the varargs sequence + * @param expr the expression of a sequence to destructure into individual expressions + * @return `Some` containing the individual element expressions, or `None` if the expression is not a literal sequence */ def unapply[T](expr: Expr[Seq[T]])(using Quotes): Option[Seq[Expr[T]]] = { import quotes.reflect.* diff --git a/library/src/scala/quoted/runtime/QuoteMatching.scala b/library/src/scala/quoted/runtime/QuoteMatching.scala index e19ea211e3dc..3512bfb3e2d9 100644 --- a/library/src/scala/quoted/runtime/QuoteMatching.scala +++ b/library/src/scala/quoted/runtime/QuoteMatching.scala @@ -25,6 +25,8 @@ trait QuoteMatching: * - scala.quoted.runtime.Patterns.patternHole[T]: hole that matches an expression `x` of type `Expr[U]` * if `U <:< T` and returns `x` as part of the match. * + * @tparam TypeBindings a kind-level list (`KList`) encoding the type variables bound in the pattern during matching + * @tparam Tup the tuple type containing the types of the matched expression holes, where each element is an `Expr[Ti]` * @param scrutinee `Expr[Any]` on which we are pattern matching * @param pattern `Expr[Any]` containing the pattern tree * @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Expr[Ti]`` @@ -38,6 +40,8 @@ trait QuoteMatching: /** Pattern matches an the scrutineeType against the patternType and returns a tuple * with the matched holes if successful. * + * @tparam TypeBindings a kind-level list (`KList`) encoding the type variables bound in the pattern during matching + * @tparam Tup the tuple type containing the types of the matched type holes, where each element is a `Type[Ti]` * @param scrutinee `Type[?]` on which we are pattern matching * @param pattern `Type[?]` containing the pattern tree * @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Type[Ti]`` diff --git a/library/src/scala/quoted/runtime/QuoteUnpickler.scala b/library/src/scala/quoted/runtime/QuoteUnpickler.scala index 5a36f5fab51a..198fbfe1aaea 100644 --- a/library/src/scala/quoted/runtime/QuoteUnpickler.scala +++ b/library/src/scala/quoted/runtime/QuoteUnpickler.scala @@ -11,6 +11,11 @@ trait QuoteUnpickler: * replacing splice nodes with `holes` * * Generated for code compiled with Scala 3.0.x and 3.1.x + * + * @tparam T the type of the expression being unpickled + * @param pickled the pickled representation of the expression tree, as a single string or a list of strings + * @param typeHole a function that resolves type splice nodes by index and captured arguments + * @param termHole a function that resolves term splice nodes by index, with captured arguments and a `Quotes` context */ def unpickleExpr[T](pickled: String | List[String], typeHole: (Int, Seq[Any]) => Type[?], termHole: (Int, Seq[Any], Quotes) => Expr[?]): scala.quoted.Expr[T] @@ -18,6 +23,11 @@ trait QuoteUnpickler: * replacing splice nodes with `holes`. * * Generated for code compiled with Scala 3.2.0+ + * + * @tparam T the type of the expression being unpickled + * @param pickled the pickled representation of the expression tree, as a single string or a list of strings + * @param types the types used in splice nodes, or `null` if there are none + * @param termHole a function that resolves term splice nodes by index, with spliced types/expressions and a `Quotes` context, or `null` if there are none */ def unpickleExprV2[T](pickled: String | List[String], types: Null | Seq[Type[?]], termHole: Null | ((Int, Seq[Type[?] | Expr[Any]], Quotes) => Expr[?])): scala.quoted.Expr[T] @@ -25,6 +35,11 @@ trait QuoteUnpickler: * replacing splice nodes with `holes` * * Generated for code compiled with Scala 3.0.x and 3.1.x + * + * @tparam T the type being unpickled, which may be of any kind (e.g., `*`, `* => *`) + * @param pickled the pickled representation of the type tree, as a single string or a list of strings + * @param typeHole a function that resolves type splice nodes by index and captured arguments + * @param termHole a function that resolves term splice nodes by index, with captured arguments and a `Quotes` context */ def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: (Int, Seq[Any]) => Type[?], termHole: (Int, Seq[Any], Quotes) => Expr[?]): scala.quoted.Type[T] @@ -32,5 +47,9 @@ trait QuoteUnpickler: * replacing splice nodes with `holes` * * Generated for code compiled with Scala 3.2.0+ + * + * @tparam T the type being unpickled, which may be of any kind (e.g., `*`, `* => *`) + * @param pickled the pickled representation of the type tree, as a single string or a list of strings + * @param types the types used in splice nodes, or `null` if there are none */ def unpickleTypeV2[T <: AnyKind](pickled: String | List[String], types: Null | Seq[Type[?]]): scala.quoted.Type[T] diff --git a/library/src/scala/ref/Reference.scala b/library/src/scala/ref/Reference.scala index 6d5e15f8f0b8..5c227370230b 100644 --- a/library/src/scala/ref/Reference.scala +++ b/library/src/scala/ref/Reference.scala @@ -16,6 +16,8 @@ import scala.language.`2.13` /** * @see `java.lang.ref.Reference` + * + * @tparam T the type of the referenced object, constrained to `AnyRef` (i.e., non-primitive types) */ trait Reference[+T <: AnyRef] extends Function0[T] { /** Returns the underlying value. */ diff --git a/library/src/scala/ref/SoftReference.scala b/library/src/scala/ref/SoftReference.scala index 6a9e25dbbc1a..d136708b68de 100644 --- a/library/src/scala/ref/SoftReference.scala +++ b/library/src/scala/ref/SoftReference.scala @@ -24,10 +24,18 @@ class SoftReference[+T <: AnyRef](value : T, queue : ReferenceQueue[T] | Null) e /** A companion object that implements an extractor for `SoftReference` values */ object SoftReference { - /** Creates a `SoftReference` pointing to `value`. */ + /** Creates a `SoftReference` pointing to `value`. + * + * @tparam T the type of the referenced object, must be a reference type + * @param value the object to be softly referenced; may be reclaimed by the garbage collector when memory is low + */ def apply[T <: AnyRef](value: T): SoftReference[T] = new SoftReference(value) - /** Optionally returns the referenced value, or `None` if that value no longer exists. */ + /** Optionally returns the referenced value, or `None` if that value no longer exists. + * + * @tparam T the type of the referenced object, must be a reference type + * @param sr the `SoftReference` to extract the value from + */ def unapply[T <: AnyRef](sr: SoftReference[T]): Option[T] = Option(sr.underlying.get) } diff --git a/library/src/scala/ref/WeakReference.scala b/library/src/scala/ref/WeakReference.scala index c76593184e58..bf1f7e2d6119 100644 --- a/library/src/scala/ref/WeakReference.scala +++ b/library/src/scala/ref/WeakReference.scala @@ -17,6 +17,10 @@ import scala.language.`2.13` /** A wrapper class for java.lang.ref.WeakReference * The new functionality is (1) results are Option values, instead of using null. * (2) There is an extractor that maps the weak reference itself into an option. + * + * @tparam T the covariant type of the weakly referenced object, must be a subtype of `AnyRef` + * @param value the object to be weakly referenced + * @param queue an optional reference queue to which the reference will be enqueued when the referent becomes weakly reachable, or `null` for no queue */ class WeakReference[+T <: AnyRef](value: T, queue: ReferenceQueue[T] | Null) extends ReferenceWrapper[T] { def this(value: T) = this(value, null) @@ -27,10 +31,18 @@ class WeakReference[+T <: AnyRef](value: T, queue: ReferenceQueue[T] | Null) ext /** An extractor for weak reference values. */ object WeakReference { - /** Creates a weak reference pointing to `value`. */ + /** Creates a weak reference pointing to `value`. + * + * @tparam T the type of the value to wrap in a weak reference + * @param value the object to be weakly referenced + */ def apply[T <: AnyRef](value: T): WeakReference[T] = new WeakReference(value) - /** Optionally returns the referenced value, or `None` if that value no longer exists. */ + /** Optionally returns the referenced value, or `None` if that value no longer exists. + * + * @tparam T the type of the value to extract from the weak reference + * @param wr the weak reference to extract a value from + */ def unapply[T <: AnyRef](wr: WeakReference[T]): Option[T] = Option(wr.underlying.get) } diff --git a/library/src/scala/reflect/ClassTag.scala b/library/src/scala/reflect/ClassTag.scala index 6b469c6f0759..a85681592f81 100644 --- a/library/src/scala/reflect/ClassTag.scala +++ b/library/src/scala/reflect/ClassTag.scala @@ -27,15 +27,13 @@ import scala.runtime.ClassValueCompat * its argument types. This runtime information is enough for runtime `Array` creation. * * For example: - * ``` - * scala> def mkArray[T : ClassTag](elems: T*) = Array[T](elems*) - * def mkArray[T](elems: T*)(using ClassTag[T]): Array[T] + * ```scala sc:compile + * import scala.reflect.ClassTag * - * scala> mkArray(42, 13) - * val res0: Array[Int] = Array(42, 13) + * def mkArray[T: ClassTag](elems: T*): Array[T] = Array[T](elems*) * - * scala> mkArray("Japan","Brazil","Germany") - * val res1: Array[String] = Array(Japan, Brazil, Germany) + * val ints = mkArray(42, 13) + * val strings = mkArray("Japan", "Brazil", "Germany") * ``` * * For compile-time type information in macros, see the facilities in the diff --git a/library/src/scala/reflect/Manifest.scala b/library/src/scala/reflect/Manifest.scala index cdcbd83b9acb..57bf81120b0d 100644 --- a/library/src/scala/reflect/Manifest.scala +++ b/library/src/scala/reflect/Manifest.scala @@ -27,21 +27,21 @@ import scala.collection.mutable.{ArrayBuilder, ArraySeq} * which are not yet adequately represented in manifests. * * Example usages: - * ``` - * def arr[T] = new Array[T](0) // does not compile - * def arr[T](implicit m: Manifest[T]) = new Array[T](0) // compiles - * def arr[T: Manifest] = new Array[T](0) // shorthand for the preceding + * ```scala sc:compile + * import scala.reflect.Manifest + * + * def arr[T: Manifest]: Array[T] = new Array[T](0) * * // Methods manifest and optManifest are in [[scala.Predef]]. - * def isApproxSubType[T: Manifest, U: Manifest] = manifest[T] <:< manifest[U] - * isApproxSubType[List[String], List[AnyRef]] // true - * isApproxSubType[List[String], List[Int]] // false + * def isApproxSubType[T: Manifest, U: Manifest]: Boolean = manifest[T] <:< manifest[U] + * val stringsAreAnyRefs = isApproxSubType[List[String], List[AnyRef]] + * val stringsAreInts = isApproxSubType[List[String], List[Int]] * * def methods[T: Manifest] = manifest[T].runtimeClass.getMethods * def retType[T: Manifest](name: String) = - * methods[T] find (_.getName == name) map (_.getGenericReturnType) + * methods[T].find(_.getName == name).map(_.getGenericReturnType) * - * retType[Map[_, _]]("values") // Some(scala.collection.Iterable) + * val mapValuesReturnType = retType[Map[_, _]]("values") * ``` */ @nowarn("""cat=deprecation&origin=scala\.reflect\.ClassManifest(DeprecatedApis.*)?""") @@ -115,7 +115,7 @@ object Manifest { ManifestFactory.classType[T](clazz) /** Manifest for the class type `clazz`, where `clazz` is - * a top-level or static class and args are its type arguments. + * a top-level or static class and args are its type arguments. */ def classType[T](clazz: Predef.Class[T], arg1: Manifest[?], args: Manifest[?]*): Manifest[T] = ManifestFactory.classType[T](clazz, arg1, args*) @@ -131,7 +131,7 @@ object Manifest { /** Manifest for the abstract type `prefix # name`. `upperBound` is not * strictly necessary as it could be obtained by reflection. It was - * added so that erasure can be calculated without reflection. + * added so that erasure can be calculated without reflection. */ def abstractType[T](prefix: Manifest[?], name: String, upperBound: Predef.Class[?], args: Manifest[?]*): Manifest[T] = ManifestFactory.abstractType[T](prefix, name, upperBound, args*) @@ -158,8 +158,7 @@ abstract class AnyValManifest[T <: AnyVal](override val toString: String) extend case _ => false } override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef] - @transient - override val hashCode = System.identityHashCode(this) + override def hashCode = System.identityHashCode(this) } /** `ManifestFactory` defines factory methods for manifests. @@ -390,7 +389,7 @@ object ManifestFactory { new ClassTypeManifest[T](None, clazz, Nil) /** Manifest for the class type `clazz`, where `clazz` is - * a top-level or static class and args are its type arguments. + * a top-level or static class and args are its type arguments. */ def classType[T](clazz: Predef.Class[T], arg1: Manifest[?], args: Manifest[?]*): Manifest[T] = new ClassTypeManifest[T](None, clazz, arg1 :: args.toList) @@ -405,12 +404,11 @@ object ManifestFactory { private abstract class PhantomManifest[T](_runtimeClass: Predef.Class[?], override val toString: String) extends ClassTypeManifest[T](None, _runtimeClass, Nil) { override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef] - @transient - override val hashCode = System.identityHashCode(this) + override def hashCode = System.identityHashCode(this) } /** Manifest for the class type `clazz[args]`, where `clazz` is - * a top-level or static class. + * a top-level or static class. */ @SerialVersionUID(1L) private class ClassTypeManifest[T](prefix: Option[Manifest[?]], @@ -434,7 +432,7 @@ object ManifestFactory { /** Manifest for the abstract type `prefix # name`. `upperBound` is not * strictly necessary as it could be obtained by reflection. It was - * added so that erasure can be calculated without reflection. + * added so that erasure can be calculated without reflection. */ def abstractType[T](prefix: Manifest[?], name: String, upperBound: Predef.Class[?], args: Manifest[?]*): Manifest[T] = new AbstractTypeManifest[T](prefix, name, upperBound, args) diff --git a/library/src/scala/runtime/$throws.scala b/library/src/scala/runtime/$throws.scala index f02b5b205f47..d9925d7e95a1 100644 --- a/library/src/scala/runtime/$throws.scala +++ b/library/src/scala/runtime/$throws.scala @@ -11,4 +11,4 @@ import annotation.experimental * Used in desugar.throws. */ @experimental -infix type $throws[R, +E <: Exception] = CanThrow[E] ?=> R +infix type `$throws`[R, +E <: Exception] = CanThrow[E] ?=> R diff --git a/library/src/scala/runtime/AbstractFunction0.scala b/library/src/scala/runtime/AbstractFunction0.scala index 1b2253a01ca2..474492c904ed 100644 --- a/library/src/scala/runtime/AbstractFunction0.scala +++ b/library/src/scala/runtime/AbstractFunction0.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction1.scala b/library/src/scala/runtime/AbstractFunction1.scala index c490b36e2acc..cc3b422e3ab9 100644 --- a/library/src/scala/runtime/AbstractFunction1.scala +++ b/library/src/scala/runtime/AbstractFunction1.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction10.scala b/library/src/scala/runtime/AbstractFunction10.scala index 02d0db52ef19..e55fa73f8781 100644 --- a/library/src/scala/runtime/AbstractFunction10.scala +++ b/library/src/scala/runtime/AbstractFunction10.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction11.scala b/library/src/scala/runtime/AbstractFunction11.scala index 403c0407e8dc..df0cfbe6427b 100644 --- a/library/src/scala/runtime/AbstractFunction11.scala +++ b/library/src/scala/runtime/AbstractFunction11.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction12.scala b/library/src/scala/runtime/AbstractFunction12.scala index d704ba37d683..9ff62db2d141 100644 --- a/library/src/scala/runtime/AbstractFunction12.scala +++ b/library/src/scala/runtime/AbstractFunction12.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction13.scala b/library/src/scala/runtime/AbstractFunction13.scala index 907507a64762..3598d549c857 100644 --- a/library/src/scala/runtime/AbstractFunction13.scala +++ b/library/src/scala/runtime/AbstractFunction13.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction14.scala b/library/src/scala/runtime/AbstractFunction14.scala index 7ea6ed451bfb..ec668f06c994 100644 --- a/library/src/scala/runtime/AbstractFunction14.scala +++ b/library/src/scala/runtime/AbstractFunction14.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction15.scala b/library/src/scala/runtime/AbstractFunction15.scala index c1dd9a63e4f1..8bb01b0cb79b 100644 --- a/library/src/scala/runtime/AbstractFunction15.scala +++ b/library/src/scala/runtime/AbstractFunction15.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction16.scala b/library/src/scala/runtime/AbstractFunction16.scala index 6830b3048d60..0ea5487ea39f 100644 --- a/library/src/scala/runtime/AbstractFunction16.scala +++ b/library/src/scala/runtime/AbstractFunction16.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction17.scala b/library/src/scala/runtime/AbstractFunction17.scala index ab5b6304e546..3f0149d1ad76 100644 --- a/library/src/scala/runtime/AbstractFunction17.scala +++ b/library/src/scala/runtime/AbstractFunction17.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction18.scala b/library/src/scala/runtime/AbstractFunction18.scala index a5dea969565c..90741e19468b 100644 --- a/library/src/scala/runtime/AbstractFunction18.scala +++ b/library/src/scala/runtime/AbstractFunction18.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction19.scala b/library/src/scala/runtime/AbstractFunction19.scala index b2723deb1e77..348f53d9f58c 100644 --- a/library/src/scala/runtime/AbstractFunction19.scala +++ b/library/src/scala/runtime/AbstractFunction19.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction2.scala b/library/src/scala/runtime/AbstractFunction2.scala index 58d84f76481b..653caadb390e 100644 --- a/library/src/scala/runtime/AbstractFunction2.scala +++ b/library/src/scala/runtime/AbstractFunction2.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction20.scala b/library/src/scala/runtime/AbstractFunction20.scala index 01b65bc527b3..8559e50375df 100644 --- a/library/src/scala/runtime/AbstractFunction20.scala +++ b/library/src/scala/runtime/AbstractFunction20.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction21.scala b/library/src/scala/runtime/AbstractFunction21.scala index e40ca7daeccc..55170eabdc2d 100644 --- a/library/src/scala/runtime/AbstractFunction21.scala +++ b/library/src/scala/runtime/AbstractFunction21.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction22.scala b/library/src/scala/runtime/AbstractFunction22.scala index a97373349452..d06afc3d80d5 100644 --- a/library/src/scala/runtime/AbstractFunction22.scala +++ b/library/src/scala/runtime/AbstractFunction22.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction3.scala b/library/src/scala/runtime/AbstractFunction3.scala index c1a88307bbae..cb14d76cac23 100644 --- a/library/src/scala/runtime/AbstractFunction3.scala +++ b/library/src/scala/runtime/AbstractFunction3.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction4.scala b/library/src/scala/runtime/AbstractFunction4.scala index 49837a0880d4..a280f757b071 100644 --- a/library/src/scala/runtime/AbstractFunction4.scala +++ b/library/src/scala/runtime/AbstractFunction4.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction5.scala b/library/src/scala/runtime/AbstractFunction5.scala index a5e5f307f9a6..e51923764eff 100644 --- a/library/src/scala/runtime/AbstractFunction5.scala +++ b/library/src/scala/runtime/AbstractFunction5.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction6.scala b/library/src/scala/runtime/AbstractFunction6.scala index e6be191fced3..22a5fbe5d188 100644 --- a/library/src/scala/runtime/AbstractFunction6.scala +++ b/library/src/scala/runtime/AbstractFunction6.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction7.scala b/library/src/scala/runtime/AbstractFunction7.scala index 51c7fa6d1cfa..70c0effc89d0 100644 --- a/library/src/scala/runtime/AbstractFunction7.scala +++ b/library/src/scala/runtime/AbstractFunction7.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction8.scala b/library/src/scala/runtime/AbstractFunction8.scala index 07fd8838e9f0..0c73d8f15f1c 100644 --- a/library/src/scala/runtime/AbstractFunction8.scala +++ b/library/src/scala/runtime/AbstractFunction8.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/AbstractFunction9.scala b/library/src/scala/runtime/AbstractFunction9.scala index 915eddf41932..a6a322ddd469 100644 --- a/library/src/scala/runtime/AbstractFunction9.scala +++ b/library/src/scala/runtime/AbstractFunction9.scala @@ -10,8 +10,6 @@ * additional information regarding copyright ownership. */ -// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. - package scala.runtime import scala.language.`2.13` diff --git a/library/src/scala/runtime/Arrays.scala b/library/src/scala/runtime/Arrays.scala index 3635250d9ca1..e5497d069a8a 100644 --- a/library/src/scala/runtime/Arrays.scala +++ b/library/src/scala/runtime/Arrays.scala @@ -16,18 +16,36 @@ object Arrays { /** Creates an array of some element type determined by the given `ClassTag` * argument. The erased type of applications of this method is `Object`. + * + * @tparam T the element type of the array to create + * @param length the number of elements in the new array + * @param tag the `ClassTag` providing the runtime class information for `T` + * @return the newly created array of type `T` */ def newGenericArray[T](length: Int)(implicit tag: ClassTag[T]): Array[T] = tag.newArray(length) - /** Converts a sequence to a Java array with element type given by `clazz`. */ + /** Converts a sequence to a Java array with element type given by `clazz`. + * + * @tparam T the element type of the sequence and resulting array + * @param xs the sequence to convert to an array + * @param clazz the runtime `Class` of the element type `T` + * @return a new array containing the elements of `xs` + */ def seqToArray[T](xs: Seq[T], clazz: Class[?]): Array[T] = { val arr = java.lang.reflect.Array.newInstance(clazz, xs.length).asInstanceOf[Array[T]] xs.copyToArray(arr) arr } - /** Creates an array of a reference type T. */ + /** Creates an array of a reference type T. + * + * @tparam Arr the type of the resulting array, which may be multi-dimensional (e.g., `Array[Array[Int]]`) + * @param componentType the runtime `Class` of the array's component type + * @param returnType the `Class` representing the return type `Arr` (unused at runtime, provides type information for the compiler) + * @param dimensions the sizes for each dimension of the new array + * @return the newly created (possibly multi-dimensional) array + */ def newArray[Arr](componentType: Class[?], @unused returnType: Class[Arr], dimensions: Array[Int]): Arr = jlr.Array.newInstance(componentType, dimensions*).asInstanceOf[Arr] } diff --git a/library/src/scala/runtime/BoxesRunTime.java b/library/src/scala/runtime/BoxesRunTime.java index 3ddc2516fbb9..6b8fac3ef8c1 100644 --- a/library/src/scala/runtime/BoxesRunTime.java +++ b/library/src/scala/runtime/BoxesRunTime.java @@ -12,6 +12,7 @@ package scala.runtime; +import java.util.Objects; import scala.math.ScalaNumber; /** An object (static class) that defines methods used for creating, @@ -108,7 +109,6 @@ public static float unboxToFloat(Object f) { } public static double unboxToDouble(Object d) { - // System.out.println("unbox " + d); return d == null ? 0.0d : ((java.lang.Double)d).doubleValue(); } @@ -167,12 +167,12 @@ public static boolean equalsNumNum(java.lang.Number xn, java.lang.Number yn) { } public static boolean equalsCharObject(java.lang.Character xc, Object y) { + if (xc == null) + return y == null; if (y instanceof java.lang.Character) return xc.charValue() == ((java.lang.Character)y).charValue(); if (y instanceof java.lang.Number) return equalsNumChar((java.lang.Number)y, xc); - if (xc == null) - return y == null; return xc.equals(y); } @@ -192,7 +192,7 @@ public static boolean equalsNumChar(java.lang.Number xn, java.lang.Character yc) case DOUBLE: return xn.doubleValue() == ch; default: - return xn.equals(yc); + return Objects.equals(xn, yc); } } diff --git a/library/src/scala/runtime/FunctionXXL.scala b/library/src/scala/runtime/FunctionXXL.scala index 66fd0cdc938d..0117db7b873d 100644 --- a/library/src/scala/runtime/FunctionXXL.scala +++ b/library/src/scala/runtime/FunctionXXL.scala @@ -5,7 +5,10 @@ import language.experimental.captureChecking /** A function with all parameters grouped in an array. */ trait FunctionXXL { - /** Applies all parameters grouped in xs to this function. */ + /** Applies all parameters grouped in xs to this function. + * + * @param xs the function arguments, packed into an immutable array of `Object` + */ def apply(xs: IArray[Object]): Object override def toString() = "" diff --git a/library/src/scala/runtime/LambdaDeserializer.scala b/library/src/scala/runtime/LambdaDeserializer.scala index 5c16097a9898..c76bdfbcb366 100644 --- a/library/src/scala/runtime/LambdaDeserializer.scala +++ b/library/src/scala/runtime/LambdaDeserializer.scala @@ -39,7 +39,10 @@ object LambdaDeserializer { * @param cache A cache used to avoid spinning up a class for each deserialization of a given lambda. May be `null` * @param serialized The lambda to deserialize. Note that this is typically created by the `readResolve` * member of the anonymous class created by `LambdaMetaFactory`. - * @return An instance of the functional interface + * @param targetMethodMap a mapping from lambda implementation method name and signature keys (as produced by + * `LambdaDeserialize.nameAndDescriptorKey`) to their `MethodHandle`s, used to look up the + * implementation method during deserialization. Must not be `null` + * @return an instance of the functional interface */ def deserializeLambda(lookup: MethodHandles.Lookup, cache: java.util.Map[String, MethodHandle], targetMethodMap: java.util.Map[String, MethodHandle], serialized: SerializedLambda): AnyRef = { diff --git a/library/src/scala/runtime/MatchCase.scala b/library/src/scala/runtime/MatchCase.scala index 35876d6b6919..8acf081a855d 100644 --- a/library/src/scala/runtime/MatchCase.scala +++ b/library/src/scala/runtime/MatchCase.scala @@ -2,5 +2,9 @@ package scala.runtime import language.experimental.captureChecking -/** A type constructor for a case in a match type. */ +/** A type constructor for a case in a match type. + * + * @tparam Pat the pattern type to match against the scrutinee of the match type + * @tparam Body the result type produced when the scrutinee matches `Pat` + */ final abstract class MatchCase[Pat, +Body] diff --git a/library/src/scala/runtime/MethodCache.scala b/library/src/scala/runtime/MethodCache.scala index e65ddc4d31e3..e0b81bf98572 100644 --- a/library/src/scala/runtime/MethodCache.scala +++ b/library/src/scala/runtime/MethodCache.scala @@ -33,6 +33,8 @@ private[scala] sealed abstract class MethodCache { * `null` is returned. If `null` is returned, find's caller should look- * up the right method using whichever means it prefers, and add it to * the cache for later use. + * + * @param forReceiver the runtime `Class` of the receiver object to look up in the cache */ def find(forReceiver: JClass[?]): JMethod | Null def add(forReceiver: JClass[?], forMethod: JMethod): MethodCache @@ -68,6 +70,8 @@ private[scala] final class PolyMethodCache( /** To achieve tail recursion this must be a separate method * from `find`, because the type of next is not `PolyMethodCache`. + * + * @param forReceiver the runtime `Class` of the receiver object to look up in the cache chain via tail recursion */ @tailrec private def findInternal(forReceiver: JClass[?]): JMethod | Null = if (forReceiver eq receiver) method diff --git a/library/src/scala/runtime/RichInt.scala b/library/src/scala/runtime/RichInt.scala index a154d857cc6e..38f9c766d84f 100644 --- a/library/src/scala/runtime/RichInt.scala +++ b/library/src/scala/runtime/RichInt.scala @@ -56,33 +56,33 @@ final class RichInt(val self: Int) extends AnyVal with ScalaNumberProxy[Int] wit type ResultWithoutStep = Range /** - * @param end The final bound of the range to make. - * @return A [[scala.collection.immutable.Range]] from `this` up to but - * not including `end`. + * @param end the final bound of the range to make (exclusive) + * @return a [[scala.collection.immutable.Range]] from `this` up to but + * not including `end` */ def until(end: Int): Range = Range(self, end) /** - * @param end The final bound of the range to make. - * @param step The number to increase by for each step of the range. - * @return A [[scala.collection.immutable.Range]] from `this` up to but - * not including `end`. + * @param end the final bound of the range to make (exclusive) + * @param step the increment value of the range + * @return a [[scala.collection.immutable.Range]] from `this` up to but + * not including `end` */ def until(end: Int, step: Int): Range = Range(self, end, step) - /** Like `until`, but includes the last index. */ - /** - * @param end The final bound of the range to make. - * @return A [[scala.collection.immutable.Range]] from `**this**` up to - * and including `end`. + /** Like `until`, but includes the last index. + * + * @param end the final bound of the range to make (inclusive) + * @return a [[scala.collection.immutable.Range.Inclusive]] from `this` up to + * and including `end` */ def to(end: Int): Range.Inclusive = Range.inclusive(self, end) /** - * @param end The final bound of the range to make. - * @param step The number to increase by for each step of the range. - * @return A [[scala.collection.immutable.Range]] from `**this**` up to - * and including `end`. + * @param end the final bound of the range to make (inclusive) + * @param step the increment value of the range + * @return a [[scala.collection.immutable.Range.Inclusive]] from `this` up to + * and including `end` */ def to(end: Int, step: Int): Range.Inclusive = Range.inclusive(self, end, step) } diff --git a/library/src/scala/runtime/Scala3RunTime.scala b/library/src/scala/runtime/Scala3RunTime.scala index 685947f293e0..df2c88fbe91a 100644 --- a/library/src/scala/runtime/Scala3RunTime.scala +++ b/library/src/scala/runtime/Scala3RunTime.scala @@ -25,6 +25,8 @@ object Scala3RunTime: /** Called by the inline extension def `nn`. * * Extracted to minimize the bytecode size at call site. + * + * @throws NullPointerException always, indicating that a null value was encountered where non-null was expected */ def nnFail(): Nothing = throw new NullPointerException("tried to cast away nullability, but value is null") diff --git a/library/src/scala/runtime/ScalaNumberProxy.scala b/library/src/scala/runtime/ScalaNumberProxy.scala index c3f6b27ec6bd..a528a147731a 100644 --- a/library/src/scala/runtime/ScalaNumberProxy.scala +++ b/library/src/scala/runtime/ScalaNumberProxy.scala @@ -33,9 +33,17 @@ trait ScalaNumberProxy[T] extends Any with ScalaNumericAnyConversions with Proxy def byteValue = intValue.toByte def shortValue = intValue.toShort - /** Returns `**this**` if `**this** < that` or `that` otherwise. */ + /** Returns `**this**` if `**this** < that` or `that` otherwise. + * + * @param that the value to compare against for finding the minimum + * @return the smaller of `this` and `that` + */ def min(that: T): T = num.min(self, that) - /** Returns `**this**` if `**this** > that` or `that` otherwise. */ + /** Returns `**this**` if `**this** > that` or `that` otherwise. + * + * @param that the value to compare against for finding the maximum + * @return the larger of `this` and `that` + */ def max(that: T): T = num.max(self, that) /** Returns the absolute value of `**this**`. */ def abs = num.abs(self) diff --git a/library/src/scala/runtime/ScalaRunTime.scala b/library/src/scala/runtime/ScalaRunTime.scala index e88ad5a3f4eb..cda9eb7ea922 100644 --- a/library/src/scala/runtime/ScalaRunTime.scala +++ b/library/src/scala/runtime/ScalaRunTime.scala @@ -38,7 +38,11 @@ object ScalaRunTime { def drop[Repr](coll: Repr, num: Int)(implicit iterable: IsIterable[Repr] { type C <: Repr }): Repr = iterable(coll) drop num - /** Returns the class object representing an array with element class `clazz`. */ + /** Returns the class object representing an array with element class `clazz`. + * + * @param clazz the element class of the desired array type + * @return the `Class` object representing `Array[clazz]` + */ def arrayClass(clazz: jClass[?]): jClass[?] = { // newInstance throws an exception if the erasure is Void.TYPE. see scala/bug#5680 if (clazz == java.lang.Void.TYPE) classOf[Array[Unit]] @@ -48,11 +52,20 @@ object ScalaRunTime { /** Returns the class object representing an unboxed value type, * e.g., classOf[int], not classOf[java.lang.Integer]. The compiler * rewrites expressions like 5.getClass to come here. + * + * @tparam T the value type whose runtime class is retrieved + * @param value the boxed value whose unboxed class is returned + * @return the runtime `Class` representing the unboxed type `T` */ def anyValClass[T <: AnyVal : ClassTag](value: T): jClass[T] = classTag[T].runtimeClass.asInstanceOf[jClass[T]] - /** Retrieves generic array element. */ + /** Retrieves generic array element. + * + * @param xs the array to read from (typed as `AnyRef` to support both reference and primitive arrays) + * @param idx the index of the element to retrieve + * @return the element at position `idx` in the array + */ def array_apply(xs: AnyRef, idx: Int): Any = { (xs: @unchecked) match { case x: Array[AnyRef] => x(idx).asInstanceOf[Any] @@ -68,7 +81,12 @@ object ScalaRunTime { } } - /** Updates generic array element. */ + /** Updates generic array element. + * + * @param xs the array to update (typed as `AnyRef` to support both reference and primitive arrays) + * @param idx the index of the element to set + * @param value the value to store at the given index + */ def array_update(xs: AnyRef, idx: Int, value: Any): Unit = { (xs: @unchecked) match { case x: Array[AnyRef] => x(idx) = value.asInstanceOf[AnyRef] @@ -84,7 +102,11 @@ object ScalaRunTime { } } - /** Gets generic array length. */ + /** Gets generic array length. + * + * @param xs the array to measure, as an `AnyRef` + * @return the number of elements in the array + */ @inline def array_length(xs: AnyRef): Int = java.lang.reflect.Array.getLength(xs) // TODO: bytecode Object.clone() will in fact work here and avoids @@ -105,6 +127,9 @@ object ScalaRunTime { /** Converts an array to an object array. * Needed to deal with vararg arguments of primitive types that are passed * to a generic Java vararg parameter T ... + * + * @param src the source array to convert, which may be a primitive array + * @return an `Array[Object]` containing the (boxed) elements of `src` */ def toObjectArray(src: AnyRef): Array[Object] = { def copy[@specialized T <: AnyVal](src: Array[T]): Array[Object] = { @@ -163,7 +188,12 @@ object ScalaRunTime { // There used to be an `_equals` method as well which was removed in 5e7e81ab2a. def _hashCode(x: Product): Int = scala.util.hashing.MurmurHash3.caseClassHash(x) - /** A helper for case classes. */ + /** A helper for case classes. + * + * @tparam T the expected element type; elements are cast to this type without checking + * @param x the product whose elements are iterated over + * @return an iterator over the product's elements, cast to type `T` + */ def typedProductIterator[T](x: Product): Iterator[T] = { new AbstractIterator[T] { private var c: Int = 0 @@ -272,9 +302,14 @@ object ScalaRunTime { } } - /** stringOf formatted for use in a repl result. */ + /** stringOf formatted for use in a repl result. + * + * @param arg the value to convert to its string representation + * @param maxElements the maximum number of collection elements to include + * @return a string representation of `arg`, formatted for REPL display + */ def replStringOf(arg: Any, maxElements: Int): String = - stringOf(arg, maxElements) match { + (stringOf(arg, maxElements): String | Null) match { case null => "null toString" case s if s.indexOf('\n') >= 0 => "\n" + s + "\n" case s => s + "\n" diff --git a/library/src/scala/runtime/Statics.java b/library/src/scala/runtime/Statics.java index ff6f09d03ae9..9f4ce4f37718 100644 --- a/library/src/scala/runtime/Statics.java +++ b/library/src/scala/runtime/Statics.java @@ -125,10 +125,10 @@ public static int anyHash(Object x) { private static int anyHashNumber(Number x) { if (x instanceof java.lang.Long) return longHash(((java.lang.Long)x).longValue()); - + if (x instanceof java.lang.Double) return doubleHash(((java.lang.Double)x).doubleValue()); - + if (x instanceof java.lang.Float) return floatHash(((java.lang.Float)x).floatValue()); @@ -148,6 +148,7 @@ public static void releaseFence() throws Throwable { * Used by the synthetic `productElement` and `productElementName` methods in case classes. * Delegating the exception-throwing to this function reduces the bytecode size of the case class. */ + @Deprecated public static final T ioobe(int n) throws IndexOutOfBoundsException { throw new IndexOutOfBoundsException(String.valueOf(n)); } diff --git a/library/src/scala/runtime/TupleMirror.scala b/library/src/scala/runtime/TupleMirror.scala index 2abe4a5004d5..15eda7e3af2a 100644 --- a/library/src/scala/runtime/TupleMirror.scala +++ b/library/src/scala/runtime/TupleMirror.scala @@ -4,6 +4,8 @@ import language.experimental.captureChecking /** A concrete subclass of `scala.deriving.Mirror.Product`, enabling reduction of bytecode size. * as we do not need to synthesize an anonymous Mirror class at every callsite. + * + * @param arity the number of elements in the mirrored tuple type, must be non-negative */ final class TupleMirror(arity: Int) extends scala.deriving.Mirror.Product with Serializable: assert(arity >= 0) // technically could be used for EmptyTuple also, but it has its own singleton mirror. diff --git a/library/src/scala/runtime/Tuples.scala b/library/src/scala/runtime/Tuples.scala index d9a078a5456a..73db6b1b0604 100644 --- a/library/src/scala/runtime/Tuples.scala +++ b/library/src/scala/runtime/Tuples.scala @@ -597,7 +597,7 @@ object Tuples { ) } - def map[F[_]](self: Tuple, f: [t] => t => F[t]): Tuple = self match { + def map[F[_]](self: Tuple, f: [t] -> t -> F[t]): Tuple = self match { case EmptyTuple => self case _ => fromIArray(self.productIterator.map(f(_).asInstanceOf[Object]).toArray.asInstanceOf[IArray[Object]]) // TODO use toIArray } diff --git a/library/src/scala/runtime/TypeBox.scala b/library/src/scala/runtime/TypeBox.scala index 629242460564..8f1331eb4202 100644 --- a/library/src/scala/runtime/TypeBox.scala +++ b/library/src/scala/runtime/TypeBox.scala @@ -7,6 +7,9 @@ import language.experimental.captureChecking * is a tree `t` of type `C[_ >: L <: U]` and an expected type `C[X]` where `X` is an * instantiatable type variable. To be able to instantiate `X`, we cast the tree to type * `X[$n.CAP]` where `$n` is a fresh skolem type with underlying type `TypeBox[L, U]`. + * + * @tparam L the lower bound of the wildcard type being captured + * @tparam U the upper bound of the wildcard type being captured */ final abstract class TypeBox[-L <: U, +U] { type CAP >: L <: U diff --git a/library/src/scala/runtime/stdLibPatches/Predef.scala b/library/src/scala/runtime/stdLibPatches/Predef.scala index a781a0f241f2..3284bdd3a00a 100644 --- a/library/src/scala/runtime/stdLibPatches/Predef.scala +++ b/library/src/scala/runtime/stdLibPatches/Predef.scala @@ -28,6 +28,9 @@ private[scala] object Predef: * // bar is 23.type = 23 * ``` * @group utilities + * + * @tparam T the singleton type whose unique value is to be retrieved + * @return the unique inhabitant of type `T` */ inline def valueOf[T]: T = summonFrom { case ev: ValueOf[T] => ev.value @@ -36,7 +39,8 @@ private[scala] object Predef: /** Summon a given value of type `T`. Usually, the argument is not passed explicitly. * * @tparam T the type of the value to be summoned - * @return the given value typed: the provided type parameter + * @param x the given instance of `T` to return + * @return the summoned given instance of type `T` */ transparent inline def summon[T](using x: T): x.type = x @@ -51,6 +55,8 @@ private[scala] object Predef: * val s3: String | Null = null * val s4: String = s3.nn // throw NullPointerException * ``` + * + * @return the value cast to its non-nullable type */ extension [T](x: T | Null) inline def nn: x.type & T = if x.asInstanceOf[Any] == null then scala.runtime.Scala3RunTime.nnFail() @@ -60,12 +66,16 @@ private[scala] object Predef: /** Enables an expression of type `T|Null`, where `T` is a subtype of `AnyRef`, to be checked for `null` * using `eq` rather than only `==`. This is needed because `Null` no longer has * `eq` or `ne` methods, only `==` and `!=` inherited from `Any`. + * + * @param y the reference to compare against for referential equality */ inline infix def eq(inline y: AnyRef | Null): Boolean = x.asInstanceOf[AnyRef] eq y.asInstanceOf[AnyRef] /** Enables an expression of type `T|Null`, where `T` is a subtype of `AnyRef`, to be checked for `null` * using `ne` rather than only `!=`. This is needed because `Null` no longer has * `eq` or `ne` methods, only `==` and `!=` inherited from `Any`. + * + * @param y the reference to compare against for referential inequality */ inline infix def ne(inline y: AnyRef | Null): Boolean = !(x eq y) diff --git a/library/src/scala/runtime/stdLibPatches/language.scala b/library/src/scala/runtime/stdLibPatches/language.scala index a1ecb3d86a5c..d001ba729f8d 100644 --- a/library/src/scala/runtime/stdLibPatches/language.scala +++ b/library/src/scala/runtime/stdLibPatches/language.scala @@ -33,7 +33,7 @@ private[scala] object language: /** Experimental support for named type arguments. * - * @see [[https://nightly.scala-lang.org/docs/reference/other-new-features/named-typeargs]] + * @see [[https://docs.scala-lang.org/scala3/reference/experimental/named-typeargs.html]] */ @compileTimeOnly("`namedTypeArguments` can only be used at compile time in import statements") object namedTypeArguments @@ -52,6 +52,9 @@ private[scala] object language: @compileTimeOnly("`erasedDefinitions` can only be used at compile time in import statements") object erasedDefinitions + @compileTimeOnly("`specializedTraits` can only be used at compile time in import statements") + object specializedTraits + /** Experimental support for relaxed CanEqual checks for ADT pattern matching * * @see [[https://github.com/scala/improvement-proposals/pull/97]] diff --git a/library/src/scala/specialize/Specialized.scala b/library/src/scala/specialize/Specialized.scala new file mode 100644 index 000000000000..a2f70cc43a1d --- /dev/null +++ b/library/src/scala/specialize/Specialized.scala @@ -0,0 +1,10 @@ +package scala.specialize +import language.experimental.erasedDefinitions +import scala.annotation.nowarn + +sealed trait Specialized[T] extends compiletime.Erased + +object Specialized: + /* @nowarn: New anonymous class definition will be duplicated at each inline site, + however it's erased at runtime so we don't care. */ + @nowarn inline def apply[T] = new Specialized[T] {} diff --git a/library/src/scala/sys/BooleanProp.scala b/library/src/scala/sys/BooleanProp.scala index 3160ce47dd43..0eb055940fac 100644 --- a/library/src/scala/sys/BooleanProp.scala +++ b/library/src/scala/sys/BooleanProp.scala @@ -67,6 +67,8 @@ object BooleanProp { * the value be equal to the String "true", case insensitively. This method * creates a BooleanProp instance which adheres to that definition. * + * @tparam T unused type parameter, retained for API compatibility + * @param key the name of the system property to look up * @return A BooleanProp which acts like java's Boolean.getBoolean */ def valueIsTrue[T](key: String): BooleanProp = new BooleanPropImpl(key, _.toLowerCase == "true") @@ -76,11 +78,17 @@ object BooleanProp { * compared case-insensitively, or the empty string. This way -Dmy.property * results in a true-valued property, but -Dmy.property=false does not. * + * @tparam T unused type parameter, retained for API compatibility + * @param key the name of the system property to look up * @return A BooleanProp with a liberal truth policy */ def keyExists[T](key: String): BooleanProp = new BooleanPropImpl(key, s => s == "" || s.equalsIgnoreCase("true")) - /** A constant true or false property which ignores all method calls. */ + /** A constant true or false property which ignores all method calls. + * + * @param key the name of the system property + * @param isOn whether the constant property is true or false + */ def constant(key: String, isOn: Boolean): BooleanProp = new ConstantImpl(key, isOn) implicit def booleanPropAsBoolean(b: BooleanProp): Boolean = b.value diff --git a/library/src/scala/sys/Prop.scala b/library/src/scala/sys/Prop.scala index 1d6b061c6b85..3cb3e658afb7 100644 --- a/library/src/scala/sys/Prop.scala +++ b/library/src/scala/sys/Prop.scala @@ -20,6 +20,8 @@ import scala.language.`2.13` * is not a requirement. * * See `scala.sys.SystemProperties` for an example usage. + * + * @tparam T the type of the property value after conversion from string */ trait Prop[+T] { /** The full name of the property, e.g., "java.awt.headless". */ @@ -45,7 +47,12 @@ trait Prop[+T] { */ def set(newValue: String): String | Null - /** Sets the property with a value of the represented type. */ + /** Sets the property with a value of the represented type. + * + * @tparam T1 a supertype of `T`, used as the input type since `Prop` is covariant in `T` + * @param value the value to set for this property + * @return the previous value of this property + */ def setValue[T1 >: T](value: T1): T /** Gets the current string value if any. Will not return null: use @@ -58,7 +65,11 @@ trait Prop[+T] { def option: Option[T] // Do not open until 2.12. - //** This value if the property is set, an alternative value otherwise. */ + /** This value if the property is set, an alternative value otherwise. + * + * @tparam T1 a supertype of `T`, the result type + * @param alt the alternative value to use if the property is not set + */ //def or[T1 >: T](alt: => T1): T1 /** Removes the property from the underlying map. */ @@ -78,7 +89,10 @@ object Prop { */ @annotation.implicitNotFound("No implicit property creator available for type ${T}.") trait Creator[+T] { - /** Creates a Prop[T] of this type based on the given key. */ + /** Creates a Prop[T] of this type based on the given key. + * + * @param key the property name used for lookup + */ def apply(key: String): Prop[T] } diff --git a/library/src/scala/sys/PropImpl.scala b/library/src/scala/sys/PropImpl.scala index b7a21b208a8d..34fbbc0945ee 100644 --- a/library/src/scala/sys/PropImpl.scala +++ b/library/src/scala/sys/PropImpl.scala @@ -16,7 +16,12 @@ package sys import scala.language.`2.13` import scala.collection.mutable -/** The internal implementation of scala.sys.Prop. */ +/** The internal implementation of scala.sys.Prop. + * + * @tparam T the type of the property value after conversion from `String` + * @param key the system property key used to look up the value + * @param valueFn the function that converts the raw `String` property value to type `T` + */ private[sys] class PropImpl[+T](val key: String, valueFn: String => T) extends Prop[T] { def value: T = if (isSet) valueFn(get) else zero def isSet = underlying contains key diff --git a/library/src/scala/sys/ShutdownHookThread.scala b/library/src/scala/sys/ShutdownHookThread.scala index ea213079820d..d894e119fd66 100644 --- a/library/src/scala/sys/ShutdownHookThread.scala +++ b/library/src/scala/sys/ShutdownHookThread.scala @@ -30,6 +30,8 @@ object ShutdownHookThread { } /** Creates, names, and registers a shutdown hook to run the * given code. + * + * @param body the code to execute when the JVM shuts down */ def apply(body: => Unit): ShutdownHookThread = { val t = new ShutdownHookThread(() => body, hookName()) diff --git a/library/src/scala/sys/SystemProperties.scala b/library/src/scala/sys/SystemProperties.scala index 9ad6d1e0bf81..d2378a0f2f94 100644 --- a/library/src/scala/sys/SystemProperties.scala +++ b/library/src/scala/sys/SystemProperties.scala @@ -67,6 +67,9 @@ extends mutable.AbstractMap[String, String | Null] { object SystemProperties { /** An unenforceable, advisory only place to do some synchronization when * mutating system properties. + * + * @tparam T the return type of the body expression + * @param body the code to execute while holding the lock */ def exclusively[T](body: => T): T = this.synchronized: body diff --git a/library/src/scala/sys/package.scala b/library/src/scala/sys/package.scala index 5d5b707259e5..694e4849e520 100644 --- a/library/src/scala/sys/package.scala +++ b/library/src/scala/sys/package.scala @@ -23,19 +23,21 @@ import scala.jdk.CollectionConverters._ package object sys { /** Throws a new RuntimeException with the supplied message. * - * @return Nothing. + * @param message the detail message for the `RuntimeException` + * @return this method never returns normally (return type is `Nothing`) */ def error(message: String): Nothing = throw new RuntimeException(message) /** Exits the JVM with the default status code. * - * @return Nothing. + * @return this method never returns normally (return type is `Nothing`) */ def exit(): Nothing = exit(0) /** Exits the JVM with the given status code. * - * @return Nothing. + * @param status the exit status code passed to `System.exit` (0 for success, non-zero for failure) + * @return this method never returns normally (return type is `Nothing`) */ def exit(status: Int): Nothing = { java.lang.System.exit(status) @@ -50,7 +52,7 @@ package object sys { /** A bidirectional, mutable Map representing the current system Properties. * - * @return a SystemProperties. + * @return a `SystemProperties` instance wrapping the current system properties * @see [[scala.sys.SystemProperties]] */ def props: SystemProperties = new SystemProperties @@ -79,7 +81,7 @@ package object sys { * Note that shutdown hooks are NOT guaranteed to be run. * * @param body the body of code to run at shutdown - * @return the Thread which will run the shutdown hook. + * @return the `ShutdownHookThread` which will run the shutdown hook * @see [[scala.sys.ShutdownHookThread]] */ def addShutdownHook(body: => Unit): ShutdownHookThread = ShutdownHookThread(body) diff --git a/library/src/scala/sys/process/BasicIO.scala b/library/src/scala/sys/process/BasicIO.scala index b4ec6ef1efb0..260ef6e1e149 100644 --- a/library/src/scala/sys/process/BasicIO.scala +++ b/library/src/scala/sys/process/BasicIO.scala @@ -160,7 +160,10 @@ object BasicIO { private def processErrFully(log: ProcessLogger) = processFully(log err _) private def processOutFully(log: ProcessLogger) = processFully(log out _) - /** Closes a `Closeable` without throwing an exception. */ + /** Closes a `Closeable` without throwing an exception. + * + * @param c the `Closeable` resource to close; any `IOException` thrown during closing is silently ignored + */ def close(c: Closeable) = try c.close() catch { case _: IOException => () } /** Returns a function `InputStream => Unit` that appends all data read to the @@ -193,6 +196,9 @@ object BasicIO { /** Calls `processLine` with the result of `readLine` until the latter returns * `null` or the current thread is interrupted. + * + * @param processLine a function called with each line read from the input + * @param readLine a function that returns the next line, or `null` when finished */ def processLinesFully(processLine: String => Unit)(readLine: () => String): Unit = { def working = !Thread.currentThread.isInterrupted @@ -214,12 +220,17 @@ object BasicIO { readFully() } - /** Copies contents of stdin to the `OutputStream`. */ + /** Copies contents of stdin to the `OutputStream`. + * + * @param o the `OutputStream` (typically a process's input stream) to which stdin contents are copied + */ def connectToIn(o: OutputStream): Unit = transferFully(Uncloseable protect stdin, o) /** Returns a function `OutputStream => Unit` that either reads the content * from stdin or does nothing but close the stream. This function can be used by * [[scala.sys.process.ProcessIO]]. + * + * @param connect if true, stdin is connected to the process input; if false, the process input stream is not connected */ def input(connect: Boolean): OutputStream => Unit = if (connect) connectToStdIn else connectNoOp @@ -229,10 +240,16 @@ object BasicIO { /** A sentinel value telling ProcessBuilderImpl not to process. */ private[process] val connectNoOp: OutputStream => Unit = _ => () - /** Returns a `ProcessIO` connected to stdout and stderr, and, optionally, stdin. */ + /** Returns a `ProcessIO` connected to stdout and stderr, and, optionally, stdin. + * + * @param connectInput if true, stdin is connected to the process input + */ def standard(connectInput: Boolean): ProcessIO = standard(input(connectInput)) - /** Returns a `ProcessIO` connected to stdout, stderr and the provided `in`. */ + /** Returns a `ProcessIO` connected to stdout, stderr and the provided `in`. + * + * @param in a function to handle the process input stream + */ def standard(in: OutputStream => Unit): ProcessIO = new ProcessIO(in, toStdOut, toStdErr) /** Sends all the input from the stream to stderr, and closes the input stream @@ -247,6 +264,9 @@ object BasicIO { /** Copies all input from the input stream to the output stream. Closes the * input stream once it's all read. + * + * @param in the input stream to read from + * @param out the output stream to write to */ def transferFully(in: InputStream, out: OutputStream): Unit = try transferFullyImpl(in, out) diff --git a/library/src/scala/sys/process/Parser.scala b/library/src/scala/sys/process/Parser.scala index 32fc88e23fc7..8b6d7a58403a 100644 --- a/library/src/scala/sys/process/Parser.scala +++ b/library/src/scala/sys/process/Parser.scala @@ -23,7 +23,9 @@ private[scala] object Parser { /** Splits the line into tokens separated by whitespace or quotes. * - * @return either an error message or reverse list of tokens + * @param line the command line string to parse + * @param errorFn the error handler invoked with a message when parsing fails (e.g., unmatched quote) + * @return a list of parsed tokens in order of appearance, or `Nil` after invoking `errorFn` on failure */ def tokenize(line: String, errorFn: String => Unit): List[String] = { import Character.isWhitespace diff --git a/library/src/scala/sys/process/Process.scala b/library/src/scala/sys/process/Process.scala index 8e0f6d119d59..83b166066a7c 100644 --- a/library/src/scala/sys/process/Process.scala +++ b/library/src/scala/sys/process/Process.scala @@ -57,6 +57,9 @@ trait ProcessCreation { * ``` * apply("cat file.txt") * ``` + * + * @param command the command string, including parameters separated by spaces + * @return a new `ProcessBuilder` for the given command */ def apply(command: String): ProcessBuilder = apply(command, None) @@ -67,6 +70,9 @@ trait ProcessCreation { * ``` * apply("cat" :: files) * ``` + * + * @param command a sequence where the first element is the executable and the rest are arguments + * @return a new `ProcessBuilder` for the given command */ def apply(command: scala.collection.Seq[String]): ProcessBuilder = apply(command, None) @@ -77,6 +83,10 @@ trait ProcessCreation { * ``` * apply("cat", files) * ``` + * + * @param command the executable to run + * @param arguments the arguments to pass to the command + * @return a new `ProcessBuilder` for the given command and arguments */ def apply(command: String, arguments: scala.collection.Seq[String]): ProcessBuilder = apply(command +: arguments, None) @@ -87,6 +97,11 @@ trait ProcessCreation { * ``` * apply("java", new java.io.File("/opt/app"), "CLASSPATH" -> "library.jar") * ``` + * + * @param command the command string, including parameters separated by spaces + * @param cwd the working directory for the process + * @param extraEnv environment variable name-value pairs to add to the process environment + * @return a new `ProcessBuilder` for the given command with the specified working directory */ def apply(command: String, cwd: File, extraEnv: (String, String)*): ProcessBuilder = apply(command, Some(cwd), extraEnv*) @@ -98,6 +113,11 @@ trait ProcessCreation { * ``` * apply("java" :: javaArgs, new java.io.File("/opt/app"), "CLASSPATH" -> "library.jar") * ``` + * + * @param command a sequence where the first element is the executable and the rest are arguments + * @param cwd the working directory for the process + * @param extraEnv environment variable name-value pairs to add to the process environment + * @return a new `ProcessBuilder` for the given command with the specified working directory */ def apply(command: scala.collection.Seq[String], cwd: File, extraEnv: (String, String)*): ProcessBuilder = apply(command, Some(cwd), extraEnv*) @@ -109,6 +129,11 @@ trait ProcessCreation { * ``` * apply("java", params.get("cwd"), "CLASSPATH" -> "library.jar") * ``` + * + * @param command the command string, including parameters separated by spaces + * @param cwd an optional working directory for the process + * @param extraEnv environment variable name-value pairs to add to the process environment + * @return a new `ProcessBuilder` for the given command */ def apply(command: String, cwd: Option[File], extraEnv: (String, String)*): ProcessBuilder = apply(Parser.tokenize(command), cwd, extraEnv*) @@ -120,6 +145,11 @@ trait ProcessCreation { * ``` * apply("java" :: javaArgs, params.get("cwd"), "CLASSPATH" -> "library.jar") * ``` + * + * @param command a sequence where the first element is the executable and the rest are arguments + * @param cwd an optional working directory for the process + * @param extraEnv environment variable name-value pairs to add to the process environment + * @return a new `ProcessBuilder` for the given command */ def apply(command: scala.collection.Seq[String], cwd: Option[File], extraEnv: (String, String)*): ProcessBuilder = { val jpb = new JProcessBuilder(command.toArray*) @@ -133,34 +163,55 @@ trait ProcessCreation { * @example ``` * apply((new java.lang.ProcessBuilder("ls", "-l")) directory new java.io.File(System.getProperty("user.home"))) * ``` + * + * @param builder the `java.lang.ProcessBuilder` to wrap + * @return a new `ProcessBuilder` wrapping the given Java process builder */ def apply(builder: JProcessBuilder): ProcessBuilder = new Simple(builder) /** Creates a [[scala.sys.process.ProcessBuilder]] from a `java.io.File`. This * `ProcessBuilder` can then be used as a `Source` or a `Sink`, so one can * pipe things from and to it. + * + * @param file the file to use as a source or sink for the process + * @return a `FileBuilder` wrapping the given file */ def apply(file: File): FileBuilder = new FileImpl(file) /** Creates a [[scala.sys.process.ProcessBuilder]] from a `java.net.URL`. This * `ProcessBuilder` can then be used as a `Source`, so that one can pipe things * from it. + * + * @param url the URL to use as a source for the process + * @return a `URLBuilder` wrapping the given URL */ def apply(url: URL): URLBuilder = new URLImpl(url) /** Creates a [[scala.sys.process.ProcessBuilder]] from a `Boolean`. This can be * to force an exit value. + * + * @param value if `true`, the process exits with code 0; if `false`, with code 1 + * @return a `ProcessBuilder` that immediately exits with the corresponding exit code */ def apply(value: Boolean): ProcessBuilder = apply(value.toString, if (value) 0 else 1) /** Creates a [[scala.sys.process.ProcessBuilder]] from a `String` name and a * `Boolean`. This can be used to force an exit value, with the name being * used for `toString`. + * + * @param name the name used for the `toString` representation of this process + * @param exitValue the exit code that this process will return (by-name, evaluated on each access) + * @return a `ProcessBuilder` that immediately exits with the given exit code */ def apply(name: String, exitValue: => Int): ProcessBuilder = new Dummy(name, exitValue) /** Creates a sequence of [[scala.sys.process.ProcessBuilder.Source]] from a sequence of * something else for which there's an implicit conversion to `Source`. + * + * @tparam T the type of the elements to be converted to `Source` + * @param builders the sequence of elements to convert + * @param convert the implicit conversion from `T` to `Source` + * @return a sequence of `Source` instances converted from the input elements */ def applySeq[T](builders: scala.collection.Seq[T])(implicit convert: T => Source): scala.collection.Seq[Source] = builders.map(convert) @@ -181,6 +232,10 @@ trait ProcessCreation { * val build = new File("project/build.properties") * cat(spde, dispatch, build) #| "grep -i scala" ! * ``` + * + * @param file the first `Source` to concatenate + * @param files additional `Source` values to concatenate after the first + * @return a `ProcessBuilder` whose output is the concatenation of all sources */ def cat(file: Source, files: Source*): ProcessBuilder = cat(file +: files) @@ -189,6 +244,9 @@ trait ProcessCreation { * piped to something else. * * This will concatenate the output of all sources. + * + * @param files the non-empty sequence of sources to concatenate; throws `IllegalArgumentException` if empty + * @return a `ProcessBuilder` whose output is the concatenation of all sources */ def cat(files: scala.collection.Seq[Source]): ProcessBuilder = { require(files.nonEmpty) @@ -206,10 +264,19 @@ trait ProcessImplicits { /** Returns a sequence of [[scala.sys.process.ProcessBuilder.Source]] from a sequence * of values for which an implicit conversion to `Source` is available. + * + * @tparam T the type of the elements to be converted to `Source` + * @param builders the sequence of elements to convert + * @param convert the implicit conversion from `T` to `Source` + * @return a sequence of `Source` instances converted from the input elements */ implicit def buildersToProcess[T](builders: scala.collection.Seq[T])(implicit convert: T => Source): scala.collection.Seq[Source] = applySeq(builders) - /** Implicitly convert a `java.lang.ProcessBuilder` into a Scala one. */ + /** Implicitly convert a `java.lang.ProcessBuilder` into a Scala one. + * + * @param builder the `java.lang.ProcessBuilder` to convert + * @return a Scala `ProcessBuilder` wrapping the given Java process builder + */ implicit def builderToProcess(builder: JProcessBuilder): ProcessBuilder = apply(builder) /** Implicitly convert a `java.io.File` into a @@ -219,6 +286,9 @@ trait ProcessImplicits { * import scala.sys.process._ * "ls" #> new java.io.File("dirContents.txt") ! * ``` + * + * @param file the file to convert into a `FileBuilder` + * @return a `FileBuilder` wrapping the given file */ implicit def fileToProcess(file: File): FileBuilder = apply(file) @@ -229,16 +299,26 @@ trait ProcessImplicits { * import scala.sys.process._ * Seq("xmllint", "--html", "-") #< new java.net.URL("https://www.scala-lang.org") #> new java.io.File("fixed.html") ! * ``` + * + * @param url the URL to convert into a `URLBuilder` + * @return a `URLBuilder` wrapping the given URL */ implicit def urlToProcess(url: URL): URLBuilder = apply(url) - /** Implicitly convert a `String` into a [[scala.sys.process.ProcessBuilder]]. */ + /** Implicitly convert a `String` into a [[scala.sys.process.ProcessBuilder]]. + * + * @param command the command string to convert into a `ProcessBuilder` + * @return a `ProcessBuilder` for the given command string + */ implicit def stringToProcess(command: String): ProcessBuilder = apply(command) /** Implicitly convert a sequence of `String` into a * [[scala.sys.process.ProcessBuilder]]. The first argument will be taken to * be the command to be executed, and the remaining will be its arguments. * When using this, arguments may contain spaces. + * + * @param command a sequence where the first element is the executable and the rest are arguments + * @return a `ProcessBuilder` for the given command sequence */ implicit def stringSeqToProcess(command: scala.collection.Seq[String]): ProcessBuilder = apply(command) } diff --git a/library/src/scala/sys/process/ProcessBuilder.scala b/library/src/scala/sys/process/ProcessBuilder.scala index 7869c5a52aef..79331158c975 100644 --- a/library/src/scala/sys/process/ProcessBuilder.scala +++ b/library/src/scala/sys/process/ProcessBuilder.scala @@ -145,6 +145,8 @@ trait ProcessBuilder extends Source with Sink { /** Starts the process represented by this builder, blocks until it exits, and * returns the output as a String. Standard error is sent to the provided * ProcessLogger. If the exit code is non-zero, an exception is thrown. + * + * @param log the `ProcessLogger` to receive standard error output */ def !!(log: ProcessLogger): String @@ -159,6 +161,8 @@ trait ProcessBuilder extends Source with Sink { * returns the output as a String. Standard error is sent to the provided * ProcessLogger. If the exit code is non-zero, an exception is thrown. The * newly started process reads from standard input of the current process. + * + * @param log the `ProcessLogger` to receive standard error output */ def !!<(log: ProcessLogger): String @@ -178,6 +182,8 @@ trait ProcessBuilder extends Source with Sink { * Standard error is sent to the console. If the process exits * with a non-zero value, the `LazyList` will provide all lines up to termination * and then throw an exception. + * + * @param capacity the maximum number of lines to buffer before blocking the producer */ def lazyLines(capacity: Integer): LazyList[String] @@ -186,6 +192,8 @@ trait ProcessBuilder extends Source with Sink { * completed. Standard error is sent to the provided `ProcessLogger`. If the * process exits with a non-zero value, the `LazyList` will provide all lines up * to termination and then throw an exception. + * + * @param log the `ProcessLogger` to receive standard error output */ def lazyLines(log: ProcessLogger): LazyList[String] @@ -197,6 +205,9 @@ trait ProcessBuilder extends Source with Sink { * Standard error is sent to the provided `ProcessLogger`. If the * process exits with a non-zero value, the `LazyList` will provide all lines up * to termination and then throw an exception. + * + * @param log the `ProcessLogger` to receive standard error output + * @param capacity the maximum number of lines to buffer before blocking the producer */ def lazyLines(log: ProcessLogger, capacity: Integer): LazyList[String] @@ -216,6 +227,8 @@ trait ProcessBuilder extends Source with Sink { * Standard error is sent to the console. If the process exits * with a non-zero value, the `LazyList` will provide all lines up to termination * but will not throw an exception. + * + * @param capacity the maximum number of lines to buffer before blocking the producer */ def lazyLines_!(capacity: Integer): LazyList[String] @@ -224,6 +237,8 @@ trait ProcessBuilder extends Source with Sink { * completed. Standard error is sent to the provided `ProcessLogger`. If the * process exits with a non-zero value, the `LazyList` will provide all lines up * to termination but will not throw an exception. + * + * @param log the `ProcessLogger` to receive standard error output */ def lazyLines_!(log: ProcessLogger): LazyList[String] @@ -235,6 +250,9 @@ trait ProcessBuilder extends Source with Sink { * Standard error is sent to the provided `ProcessLogger`. If the * process exits with a non-zero value, the `LazyList` will provide all lines up * to termination but will not throw an exception. + * + * @param log the `ProcessLogger` to receive standard error output + * @param capacity the maximum number of lines to buffer before blocking the producer */ def lazyLines_!(log: ProcessLogger, capacity: Integer): LazyList[String] @@ -330,6 +348,8 @@ trait ProcessBuilder extends Source with Sink { /** Starts the process represented by this builder, blocks until it exits, and * returns the exit code. Standard output and error are sent to the given * ProcessLogger. + * + * @param log the `ProcessLogger` to receive standard output and error */ def !(log: ProcessLogger): Int @@ -343,53 +363,82 @@ trait ProcessBuilder extends Source with Sink { * returns the exit code. Standard output and error are sent to the given * ProcessLogger. The newly started process reads from standard input of the * current process. + * + * @param log the `ProcessLogger` to receive standard output and error */ def !<(log: ProcessLogger): Int /** Starts the process represented by this builder. Standard output and error * are sent to the console. + * + * @return the started `Process` */ def run(): Process /** Starts the process represented by this builder. Standard output and error * are sent to the given ProcessLogger. + * + * @param log the `ProcessLogger` to receive standard output and error + * @return the started `Process` */ def run(log: ProcessLogger): Process /** Starts the process represented by this builder. I/O is handled by the * given ProcessIO instance. + * + * @param io the `ProcessIO` that handles the process's standard input, output, and error streams + * @return the started `Process` */ def run(io: ProcessIO): Process /** Starts the process represented by this builder. Standard output and error * are sent to the console. The newly started process reads from standard * input of the current process if `connectInput` is true. + * + * @param connectInput whether to connect the process's standard input to the current process's stdin + * @return the started `Process` */ def run(connectInput: Boolean): Process /** Starts the process represented by this builder. Standard output and error * are sent to the given ProcessLogger. The newly started process reads from * standard input of the current process if `connectInput` is true. + * + * @param log the `ProcessLogger` to receive standard output and error + * @param connectInput whether to connect the process's standard input to the current process's stdin + * @return the started `Process` */ def run(log: ProcessLogger, connectInput: Boolean): Process /** Constructs a command that runs this command first and then `other` if this * command succeeds. + * + * @param other the command to run if this one returns an exit code of zero + * @return a new `ProcessBuilder` that sequences this and `other` conditionally */ def #&& (other: ProcessBuilder): ProcessBuilder /** Constructs a command that runs this command first and then `other` if this * command does not succeed. + * + * @param other the command to run if this one returns a non-zero exit code + * @return a new `ProcessBuilder` that sequences this and `other` conditionally */ def #|| (other: ProcessBuilder): ProcessBuilder /** Constructs a command that will run this command and pipes the output to * `other`. `other` must be a simple command. + * + * @param other the command to receive the output of this process as its input + * @return a new `ProcessBuilder` that pipes output from this to `other` */ def #| (other: ProcessBuilder): ProcessBuilder /** Constructs a command that will run this command and then `other`. The * exit code will be the exit code of `other`. + * + * @param other the command to run after this one, regardless of exit code + * @return a new `ProcessBuilder` that sequences this and `other` unconditionally */ def ### (other: ProcessBuilder): ProcessBuilder @@ -417,16 +466,32 @@ object ProcessBuilder extends ProcessBuilderImpl { * [[scala.sys.process.ProcessBuilder.Sink]] from a file. */ trait FileBuilder extends Sink with Source { - /** Appends the contents of a `java.io.File` to this file. */ + /** Appends the contents of a `java.io.File` to this file. + * + * @param f the file whose contents will be appended + * @return a `ProcessBuilder` that appends `f` to this file when run + */ def #<<(f: File): ProcessBuilder - /** Appends the contents from a `java.net.URL` to this file. */ + /** Appends the contents from a `java.net.URL` to this file. + * + * @param u the URL whose contents will be appended + * @return a `ProcessBuilder` that appends `u` to this file when run + */ def #<<(u: URL): ProcessBuilder - /** Appends the contents of a `java.io.InputStream` to this file. */ + /** Appends the contents of a `java.io.InputStream` to this file. + * + * @param i the input stream whose contents will be appended + * @return a `ProcessBuilder` that appends `i` to this file when run + */ def #<<(i: => InputStream): ProcessBuilder - /** Appends the contents of a [[scala.sys.process.ProcessBuilder]] to this file. */ + /** Appends the contents of a [[scala.sys.process.ProcessBuilder]] to this file. + * + * @param p the process builder whose output will be appended + * @return a `ProcessBuilder` that appends `p`'s output to this file when run + */ def #<<(p: ProcessBuilder): ProcessBuilder } @@ -436,19 +501,34 @@ object ProcessBuilder extends ProcessBuilderImpl { trait Source { protected def toSource: ProcessBuilder - /** Writes the output stream of this process to the given file. */ + /** Writes the output stream of this process to the given file. + * + * @param f the file to write the output to + * @return a `ProcessBuilder` that redirects output to `f` + */ def #> (f: File): ProcessBuilder = toFile(f, append = false) - /** Appends the output stream of this process to the given file. */ + /** Appends the output stream of this process to the given file. + * + * @param f the file to append the output to + * @return a `ProcessBuilder` that appends output to `f` + */ def #>> (f: File): ProcessBuilder = toFile(f, append = true) /** Writes the output stream of this process to the given OutputStream. The * argument is call-by-name, so the stream is recreated, written, and closed each * time this process is executed. + * + * @param out the output stream to write to, created anew for each execution + * @return a `ProcessBuilder` that redirects output to `out` */ def #>(out: => OutputStream): ProcessBuilder = #> (new OStreamBuilder(out, "")) - /** Writes the output stream of this process to a [[scala.sys.process.ProcessBuilder]]. */ + /** Writes the output stream of this process to a [[scala.sys.process.ProcessBuilder]]. + * + * @param b the process builder to receive this process's output as input + * @return a `ProcessBuilder` that pipes output to `b` + */ def #>(b: ProcessBuilder): ProcessBuilder = new PipedBuilder(toSource, b, toError = false) /** Returns a [[scala.sys.process.ProcessBuilder]] representing this `Source`. */ @@ -462,19 +542,34 @@ object ProcessBuilder extends ProcessBuilderImpl { trait Sink { protected def toSink: ProcessBuilder - /** Reads the given file into the input stream of this process. */ + /** Reads the given file into the input stream of this process. + * + * @param f the file to read from as input + * @return a `ProcessBuilder` that reads input from `f` + */ def #< (f: File): ProcessBuilder = #< (new FileInput(f)) - /** Reads the given URL into the input stream of this process. */ + /** Reads the given URL into the input stream of this process. + * + * @param f the `URL` to read from as input + * @return a `ProcessBuilder` that reads input from `f` + */ def #< (f: URL): ProcessBuilder = #< (new URLInput(f)) /** Reads the given InputStream into the input stream of this process. The * argument is call-by-name, so the stream is recreated, read, and closed each * time this process is executed. + * + * @param in the input stream to read from, created anew for each execution + * @return a `ProcessBuilder` that reads input from `in` */ def #<(in: => InputStream): ProcessBuilder = #< (new IStreamBuilder(in, "")) - /** Reads the output of a [[scala.sys.process.ProcessBuilder]] into the input stream of this process. */ + /** Reads the output of a [[scala.sys.process.ProcessBuilder]] into the input stream of this process. + * + * @param b the process builder whose output will be used as input to this process + * @return a `ProcessBuilder` that pipes `b`'s output to this process + */ def #<(b: ProcessBuilder): ProcessBuilder = new PipedBuilder(b, toSink, toError = false) } } diff --git a/library/src/scala/sys/process/ProcessBuilderImpl.scala b/library/src/scala/sys/process/ProcessBuilderImpl.scala index 9e5eda4f68dd..9fa255370110 100644 --- a/library/src/scala/sys/process/ProcessBuilderImpl.scala +++ b/library/src/scala/sys/process/ProcessBuilderImpl.scala @@ -86,7 +86,10 @@ private[process] trait ProcessBuilderImpl { } } - /** Represents a simple command without any redirection or combination. */ + /** Represents a simple command without any redirection or combination. + * + * @param p the underlying `java.lang.ProcessBuilder` used to start the external process + */ private[process] class Simple(p: JProcessBuilder) extends AbstractBuilder { override def run(io: ProcessIO): Process = { import java.lang.ProcessBuilder.Redirect.{INHERIT => Inherit} @@ -166,6 +169,8 @@ private[process] trait ProcessBuilderImpl { * * Note: not in the public API because it's not fully baked, but I need the capability * for fsc. + * + * @return a new `ProcessBuilder` that runs this command with all I/O threads daemonized */ def daemonized(): ProcessBuilder = new DaemonBuilder(this) diff --git a/library/src/scala/sys/process/ProcessIO.scala b/library/src/scala/sys/process/ProcessIO.scala index 724ff2875bf3..ee8cc37f32de 100644 --- a/library/src/scala/sys/process/ProcessIO.scala +++ b/library/src/scala/sys/process/ProcessIO.scala @@ -59,15 +59,30 @@ final class ProcessIO( ) { def this(in: OutputStream => Unit, out: InputStream => Unit, err: InputStream => Unit) = this(in, out, err, daemonizeThreads = false) - /** Creates a new `ProcessIO` with a different handler for the process input. */ + /** Creates a new `ProcessIO` with a different handler for the process input. + * + * @param write the new function to handle the process input `OutputStream` + * @return a new `ProcessIO` with the specified input handler + */ def withInput(write: OutputStream => Unit): ProcessIO = new ProcessIO(write, processOutput, processError, daemonizeThreads) - /** Creates a new `ProcessIO` with a different handler for the normal output. */ + /** Creates a new `ProcessIO` with a different handler for the normal output. + * + * @param process the new function to handle the process standard output `InputStream` + * @return a new `ProcessIO` with the specified output handler + */ def withOutput(process: InputStream => Unit): ProcessIO = new ProcessIO(writeInput, process, processError, daemonizeThreads) - /** Creates a new `ProcessIO` with a different handler for the error output. */ + /** Creates a new `ProcessIO` with a different handler for the error output. + * + * @param process the new function to handle the process error output `InputStream` + * @return a new `ProcessIO` with the specified error handler + */ def withError(process: InputStream => Unit): ProcessIO = new ProcessIO(writeInput, processOutput, process, daemonizeThreads) - /** Creates a new `ProcessIO`, with `daemonizeThreads` true. */ + /** Creates a new `ProcessIO`, with `daemonizeThreads` true. + * + * @return a new `ProcessIO` that runs all I/O threads as daemon threads + */ def daemonized(): ProcessIO = new ProcessIO(writeInput, processOutput, processError, daemonizeThreads = true) } diff --git a/library/src/scala/sys/process/ProcessImpl.scala b/library/src/scala/sys/process/ProcessImpl.scala index fa183c58c442..039983aa889d 100644 --- a/library/src/scala/sys/process/ProcessImpl.scala +++ b/library/src/scala/sys/process/ProcessImpl.scala @@ -13,12 +13,10 @@ package scala.sys.process import scala.language.`2.13` -import processInternal._ - +import processInternal.* import java.util.concurrent.LinkedBlockingQueue import java.io.{PipedInputStream, PipedOutputStream} - -import scala.annotation.tailrec +import scala.annotation.{nowarn, tailrec} private[process] trait ProcessImpl { self: Process.type => @@ -193,6 +191,7 @@ private[process] trait ProcessImpl { private def ioHandler(e: IOException): Unit = e.printStackTrace() } + @nowarn("msg=Calling the external method .*Name") // setName+getName are safe to call in a constructor private[process] class PipeSource(label: => String) extends PipeThread(isSink = false, () => label) { setName(s"PipeSource($label)-$getName") protected val pipe = new PipedOutputStream @@ -216,6 +215,7 @@ private[process] trait ProcessImpl { } def done() = source.put(None) } + @nowarn("msg=Calling the external method .*Name") // setName+getName are safe to call in a constructor private[process] class PipeSink(label: => String) extends PipeThread(isSink = true, () => label) { setName(s"PipeSink($label)-$getName") protected val pipe = new PipedInputStream @@ -242,6 +242,8 @@ private[process] trait ProcessImpl { /** A thin wrapper around a java.lang.Process. `ioThreads` are the Threads created to do I/O. * The implementation of `exitValue` waits until these threads die before returning. + * + * @param action the by-name computation whose result will be used as the exit value */ private[process] class DummyProcess(action: => Int) extends Process { private val (thread, value) = Future(action) @@ -260,6 +262,10 @@ private[process] trait ProcessImpl { * * The implementation of `exitValue` interrupts `inputThread` * and then waits until all I/O threads die before returning. + * + * @param p the underlying `java.lang.Process` being wrapped + * @param inputThread the thread writing to the process's stdin, or null if stdin was inherited + * @param outputThreads the threads reading from the process's stdout and stderr streams */ private[process] class SimpleProcess(p: JProcess, inputThread: Thread | Null, outputThreads: List[Thread]) extends Process { override def isAlive() = p.isAlive() diff --git a/library/src/scala/sys/process/ProcessLogger.scala b/library/src/scala/sys/process/ProcessLogger.scala index e56224ae218a..d7f1fb26fb24 100644 --- a/library/src/scala/sys/process/ProcessLogger.scala +++ b/library/src/scala/sys/process/ProcessLogger.scala @@ -38,10 +38,16 @@ import java.io._ * @see [[scala.sys.process.ProcessBuilder]] */ trait ProcessLogger { - /** Will be called with each line read from the process output stream. */ + /** Will be called with each line read from the process output stream. + * + * @param s a lazily-evaluated line from the process standard output + */ def out(s: => String): Unit - /** Will be called with each line read from the process error stream. */ + /** Will be called with each line read from the process error stream. + * + * @param s a lazily-evaluated line from the process standard error + */ def err(s: => String): Unit /** If a process is begun with one of these `ProcessBuilder` methods: @@ -53,11 +59,17 @@ trait ProcessLogger { * an opportunity to set up and tear down buffering. At present the * library implementations of `ProcessLogger` simply execute the body * unbuffered. + * + * @tparam T the return type of the buffered operation + * @param f the code to execute with buffering, evaluated by name */ def buffer[T](f: => T): T } -/** A [[scala.sys.process.ProcessLogger]] that writes output to a file. */ +/** A [[scala.sys.process.ProcessLogger]] that writes output to a file. + * + * @param file the file to which both standard and error output will be appended + */ class FileProcessLogger(file: File) extends ProcessLogger with Closeable with Flushable { private val writer = ( new PrintWriter( @@ -80,20 +92,27 @@ class FileProcessLogger(file: File) extends ProcessLogger with Closeable with Fl * when run. */ object ProcessLogger { - /** Creates a [[scala.sys.process.ProcessLogger]] that redirects output to a `java.io.File`. */ + /** Creates a [[scala.sys.process.ProcessLogger]] that redirects output to a `java.io.File`. + * + * @param file the `java.io.File` to which output will be appended + * @return a `FileProcessLogger` that writes to the given file + */ def apply(file: File): FileProcessLogger = new FileProcessLogger(file) /** Creates a [[scala.sys.process.ProcessLogger]] that sends all output, standard and error, * to the passed function. + * + * @param fn the function to apply to each line of standard and error output + * @return a `ProcessLogger` that passes all output to `fn` */ def apply(fn: String => Unit): ProcessLogger = apply(fn, fn) /** Creates a [[scala.sys.process.ProcessLogger]] that sends all output to the corresponding * function. * - * @param fout This function will receive standard output. - * - * @param ferr This function will receive standard error. + * @param fout the function that will receive each line of standard output + * @param ferr the function that will receive each line of standard error + * @return a `ProcessLogger` that passes output to `fout` and errors to `ferr` */ def apply(fout: String => Unit, ferr: String => Unit): ProcessLogger = new ProcessLogger { diff --git a/library/src/scala/util/ChainingOps.scala b/library/src/scala/util/ChainingOps.scala index fc3351b91f87..8c978f88d29f 100644 --- a/library/src/scala/util/ChainingOps.scala +++ b/library/src/scala/util/ChainingOps.scala @@ -15,12 +15,17 @@ package util import scala.language.`2.13` import scala.language.implicitConversions +import language.experimental.captureChecking trait ChainingSyntax { @inline implicit final def scalaUtilChainingOps[A](a: A): ChainingOps[A] = new ChainingOps(a) } -/** Adds chaining methods `tap` and `pipe` to every type. */ +/** Adds chaining methods `tap` and `pipe` to every type. + * + * @tparam A the type of the wrapped value + * @param self the value to enrich with chaining operations + */ final class ChainingOps[A](private val self: A) extends AnyVal { /** Applies `f` to the value for its side effects, and returns the original value. * diff --git a/library/src/scala/util/CommandLineParser.scala b/library/src/scala/util/CommandLineParser.scala index 9b3a8f332612..a86e05bc4a2d 100644 --- a/library/src/scala/util/CommandLineParser.scala +++ b/library/src/scala/util/CommandLineParser.scala @@ -12,6 +12,11 @@ object CommandLineParser { class ParseError(val idx: Int, val msg: String) extends Exception /** Parses command line argument `s`, which has index `n`, as a value of type `T`. + * + * @tparam T the target type to parse the string into + * @param str the command line argument string to parse + * @param n the zero-based index of the argument, used for error reporting + * @param fs the type class instance (usually provided implicitly) that converts a string to type `T` * @throws ParseError if argument cannot be converted to type `T`. */ def parseString[T](str: String, n: Int)(using fs: FromString[T]^): T = { @@ -22,6 +27,11 @@ object CommandLineParser { } /** Parses `n`'th argument in `args` (counting from 0) as a value of type `T`. + * + * @tparam T the target type to parse the argument into + * @param args the command line arguments array + * @param n the zero-based index of the argument to parse + * @param fs the type class instance that converts a string to type `T` * @throws ParseError if argument does not exist or cannot be converted to type `T`. */ def parseArgument[T](args: Array[String], n: Int)(using fs: FromString[T]^): T = @@ -29,13 +39,21 @@ object CommandLineParser { else throw ParseError(n, "more arguments expected") /** Parses all arguments from `n`'th one (counting from 0) as a list of values of type `T`. + * + * @tparam T the target type to parse each argument into + * @param args the command line arguments array + * @param n the zero-based index of the first remaining argument to parse + * @param fs the type class instance that converts a string to type `T` * @throws ParseError if some of the arguments cannot be converted to type `T`. */ def parseRemainingArguments[T](args: Array[String], n: Int)(using fs: FromString[T]^): List[T] = if n < args.length then parseString(args(n), n) :: parseRemainingArguments(args, n + 1) else Nil - /** Prints error message explaining given ParserError. */ + /** Prints error message explaining given ParserError. + * + * @param err the parse error to display + */ def showError(err: ParseError): Unit = { val where = if err.idx == 0 then "" @@ -45,7 +63,10 @@ object CommandLineParser { } trait FromString[T] { - /** Can throw java.lang.IllegalArgumentException. */ + /** Can throw java.lang.IllegalArgumentException. + * + * @param s the string to convert to type `T` + */ def fromString(s: String): T def fromStringOption(s: String): Option[T] = diff --git a/library/src/scala/util/DynamicVariable.scala b/library/src/scala/util/DynamicVariable.scala index eccbdaadd01a..7a97e6735257 100644 --- a/library/src/scala/util/DynamicVariable.scala +++ b/library/src/scala/util/DynamicVariable.scala @@ -26,18 +26,22 @@ import java.lang.InheritableThreadLocal * parameterless closure, executes. When the second argument finishes, * the variable reverts to the previous value. * - * ``` + * ```scala sc:compile + * val someDynamicVariable = new DynamicVariable[Int](0) + * val newValue = 42 * someDynamicVariable.withValue(newValue) { * // ... code called in here that calls value ... * // ... will be given back the newValue ... * } * ``` - * * Each thread gets its own stack of bindings. When a * new thread is created, the `DynamicVariable` gets a copy * of the stack of bindings from the parent thread, and * from then on the bindings for the new thread * are independent of those for the original thread. + * + * @tparam T the type of the dynamic variable's value + * @param init the initial value of the variable, inherited by new threads */ class DynamicVariable[T](init: T) { private val tl = new InheritableThreadLocal[T] { @@ -50,8 +54,9 @@ class DynamicVariable[T](init: T) { /** Sets the value of the variable while executing the specified * thunk. * - * @param newval The value to which to set the variable - * @param thunk The code to evaluate under the new setting + * @tparam S the result type of the thunk + * @param newval the value to which to set the variable + * @param thunk the code to evaluate under the new setting */ def withValue[S](newval: T)(thunk: => S): S = { val oldval = value diff --git a/library/src/scala/util/Either.scala b/library/src/scala/util/Either.scala index 70745eaf7e04..7f7f12e61b19 100644 --- a/library/src/scala/util/Either.scala +++ b/library/src/scala/util/Either.scala @@ -14,6 +14,7 @@ package scala package util import scala.language.`2.13` +import language.experimental.captureChecking /** Represents a value of one of two possible types (a disjoint union). * An instance of `Either` is an instance of either [[scala.util.Left]] or [[scala.util.Right]]. @@ -27,7 +28,7 @@ import scala.language.`2.13` * For example, you could use `Either[String, Int]` to indicate whether a * received input is a `String` or an `Int`. * - * ``` + * ```scala sc:compile * import scala.io.StdIn._ * val in = readLine("Type Either a string or an Int: ") * val result: Either[String,Int] = @@ -45,14 +46,14 @@ import scala.language.`2.13` * `Either` is right-biased, which means that `Right` is assumed to be the default case to * operate on. If it is `Left`, operations like `map` and `flatMap` return the `Left` value unchanged: * - * ``` + * ```scala sc:compile * def doubled(i: Int) = i * 2 * Right(42).map(doubled) // Right(84) * Left(42).map(doubled) // Left(42) * ``` * * Since `Either` defines the methods `map` and `flatMap`, it can also be used in for comprehensions: - * ``` + * ```scala sc:compile * val right1 = Right(1) : Right[Double, Int] * val right2 = Right(2) * val right3 = Right(3) @@ -76,25 +77,32 @@ import scala.language.`2.13` * y <- left23 * z <- right2 * } yield x + y + z // Left(23.0) + * ``` * - * // Guard expressions are not supported: + * Guard expressions are not supported: + * ```scala sc:nocompile + * val right1 = Right(1) : Right[Double, Int] * for { * i <- right1 * if i > 0 * } yield i * // error: value withFilter is not a member of Right[Double,Int] + * ``` * - * // Similarly, refutable patterns are not supported: + * Similarly, refutable patterns are not supported: + * ```scala sc:nocompile + * val right1 = Right(1) : Right[Double, Int] * for (x: Int <- right1) yield x * // error: value withFilter is not a member of Right[Double,Int] + * ``` * - * // To use a filtered value, convert to an Option first, - * // which drops the Left case, as None contains no value: + * To use a filtered value, convert to an Option first: + * ```scala sc:compile + * val right1 = Right(1) : Right[Double, Int] * for { * i <- right1.toOption * if i > 0 * } yield i - * * ``` * * Since `for` comprehensions use `map` and `flatMap`, the types @@ -104,12 +112,18 @@ import scala.language.`2.13` * type argument for type parameter `B`, the right value. Otherwise, * it might be inferred as `Nothing`. * - * ``` - * for { - * x <- left23 - * y <- right1 - * z <- left42 // type at this position: Either[Double, Nothing] - * } yield x + y + z + * ```scala sc:compile + * val right1 = Right(1) : Right[Double, Int] + * val right2 = Right(2) + * val left23 = Left(23.0) : Left[Double, Int] + * val left42 = Left(42.0) + * + * // The following shows type inference issues: + * // for { + * // x <- left23 + * // y <- right1 + * // z <- left42 // type at this position: Either[Double, Nothing] + * // } yield x + y + z * // ^ * // error: ambiguous reference to overloaded definition, * // both method + in class Int of type (x: Char)Int @@ -117,15 +131,18 @@ import scala.language.`2.13` * // match argument types (Nothing) * * for (x <- right2 ; y <- left23) yield x + y // Left(23.0) - * for (x <- right2 ; y <- left42) yield x + y // error + * // for (x <- right2 ; y <- left42) yield x + y // error * - * for { - * x <- right1 - * y <- left42 // type at this position: Either[Double, Nothing] - * z <- left23 - * } yield x + y + z + * // for { + * // x <- right1 + * // y <- left42 // type at this position: Either[Double, Nothing] + * // z <- left23 + * // } yield x + y + z * // Left(42.0), but unexpectedly a `Either[Double,String]` * ``` + * + * @tparam A the type of the `Left` value + * @tparam B the type of the `Right` value */ sealed abstract class Either[+A, +B] extends Product with Serializable { /** Projects this `Either` as a `Left`. @@ -133,14 +150,27 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * This allows for-comprehensions over the left side of `Either` instances, * reversing `Either`'s usual right-bias. * - * For example ``` + * For example ```scala sc:compile * for (s <- Left("flower").left) yield s.length // Left(6) * ``` * * Continuing the analogy with [[scala.Option]], a `LeftProjection` declares * that `Left` should be analogous to `Some` in some code. * - * ``` + * ```scala sc:compile + * import java.sql.SQLException + * + * // Placeholder types for illustration + * case class Query(query: String) + * case class Result(data: String) + * + * // Placeholder functions for illustration + * def getResultFromDatabase(x: Query): Result = Result("data") + * def generateReport(result: Result): String = s"Report: ${result.data}" + * def send(report: String): Unit = () + * def log(msg: String): Unit = () + * val someQuery = Query("SELECT * FROM table") + * * // using Option * def interactWithDB(x: Query): Option[Result] = * try Some(getResultFromDatabase(x)) @@ -156,20 +186,20 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * } * * // using Either - * def interactWithDB(x: Query): Either[Exception, Result] = + * def interactWithDB2(x: Query): Either[SQLException, Result] = * try Right(getResultFromDatabase(x)) * catch { * case e: SQLException => Left(e) * } * * // run a report only if interactWithDB returns a Right - * val report = for (result <- interactWithDB(someQuery)) yield generateReport(result) - * report match { + * val report2 = for (result <- interactWithDB2(someQuery)) yield generateReport(result) + * report2 match { * case Right(r) => send(r) * case Left(e) => log(s"report not generated, reason was \$e") * } * // only report errors - * for (e <- interactWithDB(someQuery).left) log(s"query failed, reason was \$e") + * for (e <- interactWithDB2(someQuery).left) log(s"query failed, reason was \$e") * ``` */ def left = Either.LeftProjection(this) @@ -183,7 +213,7 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { /** Applies `fa` if this is a `Left` or `fb` if this is a `Right`. * - * @example ``` + * @example ```scala sc:compile * val result = util.Try("42".toInt).toEither * result.fold( * e => s"Operation failed with \$e", @@ -191,9 +221,11 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * ) * ``` * - * @param fa the function to apply if this is a `Left` - * @param fb the function to apply if this is a `Right` - * @return the results of applying the function + * @param fa the function to apply to the `Left` value + * @param fb the function to apply to the `Right` value + * @return the result of applying `fa` or `fb` to the contained value + * + * @tparam C the result type of the fold */ def fold[C](fa: A => C, fb: B => C): C = this match { case Right(b) => fb(b) @@ -202,11 +234,11 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { /** If this is a `Left`, then return the left value in `Right` or vice versa. * - * @example ``` + * @example ```scala sc:compile * val left: Either[String, Int] = Left("left") * val right: Either[Int, String] = left.swap // Result: Right("left") * ``` - * @example ``` + * @example ```scala sc:compile * val right = Right(2) * val left = Left(3) * for { @@ -214,6 +246,8 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * r2 <- left.swap * } yield r1 * r2 // Right(6) * ``` + * + * @return an `Either` with the left and right values swapped */ def swap: Either[B, A] = this match { case Left(a) => Right(a) @@ -237,6 +271,12 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * ``` * * This method, and `joinLeft`, are analogous to `Option#flatten` + * + * @tparam A1 the supertype of `A` used to widen the left type + * @tparam B1 the supertype of `B`, evidenced to be an `Either[A1, C]` + * @tparam C the right type of the inner `Either` + * @param ev evidence that `B1` is a subtype of `Either[A1, C]` + * @return the inner `Either` if this is a `Right`, otherwise this `Left` value */ def joinRight[A1 >: A, B1 >: B, C](implicit ev: B1 <:< Either[A1, C]): Either[A1, C] = this match { case Right(b) => b @@ -260,6 +300,12 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * ``` * * This method, and `joinRight`, are analogous to `Option#flatten`. + * + * @tparam A1 the supertype of `A` constrained to be an `Either[C, B1]` + * @tparam B1 the supertype of `B` used to widen the right type + * @tparam C the left type of the inner `Either` + * @param ev evidence that `A1` is a subtype of `Either[C, B1]` + * @return the inner `Either` if this is a `Left`, otherwise this `Right` value */ def joinLeft[A1 >: A, B1 >: B, C](implicit ev: A1 <:< Either[C, B1]): Either[C, B1] = this match { case Left(a) => a @@ -272,7 +318,8 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Right(12).foreach(println) // prints "12" * Left(12).foreach(println) // doesn't print * ``` - * @param f The side-effecting function to execute. + * @tparam U the return type of the side-effecting function (discarded) + * @param f the side-effecting function to execute */ def foreach[U](f: B => U): Unit = this match { case Right(b) => f(b) @@ -285,6 +332,10 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Right(12).getOrElse(17) // 12 * Left(12).getOrElse(17) // 17 * ``` + * + * @tparam B1 the supertype of `B` used to widen the return type + * @param or the default value to return if this is a `Left`, evaluated lazily + * @return the `Right` value if present, otherwise `or` */ def getOrElse[B1 >: B](or: => B1): B1 = this match { case Right(b) => b @@ -298,6 +349,11 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Left(1) orElse Left(2) // Left(2) * Left(1) orElse Left(2) orElse Right(3) // Right(3) * ``` + * + * @tparam A1 the supertype of `A` used to widen the left type + * @tparam B1 the supertype of `B` used to widen the right type + * @param or the alternative `Either` to return if this is a `Left`, evaluated lazily + * @return this `Either` if it is a `Right`, otherwise `or` */ def orElse[A1 >: A, B1 >: B](or: => Either[A1, B1]): Either[A1, B1] = this match { case Right(_) => this @@ -318,6 +374,7 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Left("something") contains "something" * ``` * + * @tparam B1 the supertype of `B` used to widen the comparison type * @param elem the element to test. * @return `true` if this is a `Right` value equal to `elem`. */ @@ -334,6 +391,9 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Right(7).forall(_ > 10) // false * Left(12).forall(_ => false) // true * ``` + * + * @param f the predicate to apply to the `Right` value + * @return `true` if this is a `Left` or the predicate holds for the `Right` value */ def forall(f: B => Boolean): Boolean = this match { case Right(b) => f(b) @@ -348,6 +408,9 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Right(7).exists(_ > 10) // false * Left(12).exists(_ => true) // false * ``` + * + * @param p the predicate to apply to the `Right` value + * @return `true` if this is a `Right` and the predicate holds for its value */ def exists(p: B => Boolean): Boolean = this match { case Right(b) => p(b) @@ -356,7 +419,9 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { /** Binds the given function across `Right`. * - * @param f The function to bind across `Right`. + * @tparam A1 the supertype of `A` used to widen the left type + * @tparam B1 the right type of the resulting `Either` + * @param f the function to bind across `Right` */ def flatMap[A1 >: A, B1](f: B => Either[A1, B1]): Either[A1, B1] = this match { case Right(b) => f(b) @@ -378,6 +443,11 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * ``` * * Equivalent to `flatMap(id => id)` + * + * @tparam A1 the supertype of `A` used to widen the left type + * @tparam B1 the right type of the inner `Either` + * @param ev evidence that `B` is a subtype of `Either[A1, B1]` + * @return the inner `Either` if this is a `Right`, otherwise the outer `Left` */ def flatten[A1 >: A, B1](implicit ev: B <:< Either[A1, B1]): Either[A1, B1] = flatMap(ev) @@ -387,6 +457,10 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Right(12).map(x => "flower") // Result: Right("flower") * Left(12).map(x => "flower") // Result: Left(12) * ``` + * + * @tparam B1 the result type of the mapping function + * @param f the function to apply to the `Right` value + * @return a new `Either` with the function applied if this is a `Right`, otherwise the unchanged `Left` */ def map[B1](f: B => B1): Either[A, B1] = this match { case Right(b) => Right(f(b)) @@ -403,6 +477,11 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Right(7).filterOrElse(_ > 10, -1) // Left(-1) * Left(7).filterOrElse(_ => false, -1) // Left(7) * ``` + * + * @tparam A1 the supertype of `A` used to widen the left type + * @param p the predicate to test the `Right` value against + * @param zero the value to use as `Left` if the predicate does not hold, evaluated lazily + * @return this `Either` if it is a `Left` or the predicate holds, otherwise `Left(zero)` */ def filterOrElse[A1 >: A](p: B => Boolean, zero: => A1): Either[A1, B] = this match { case Right(b) if !p(b) => Left(zero) @@ -416,6 +495,8 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Right(12).toSeq // Seq(12) * Left(12).toSeq // Seq() * ``` + * + * @return a `Seq` containing the `Right` value, or an empty `Seq` if this is a `Left` */ def toSeq: collection.immutable.Seq[B] = this match { case Right(b) => collection.immutable.Seq(b) @@ -429,6 +510,8 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Right(12).toOption // Some(12) * Left(12).toOption // None * ``` + * + * @return a `Some` containing the `Right` value, or `None` if this is a `Left` */ def toOption: Option[B] = this match { case Right(b) => Some(b) @@ -446,6 +529,8 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Left("tulip").isLeft // true * Right("venus fly-trap").isLeft // false * ``` + * + * @return `true` if this is a `Left`, `false` otherwise */ def isLeft: Boolean @@ -455,11 +540,18 @@ sealed abstract class Either[+A, +B] extends Product with Serializable { * Left("tulip").isRight // false * Right("venus fly-trap").isRight // true * ``` + * + * @return `true` if this is a `Right`, `false` otherwise */ def isRight: Boolean } -/** The left side of the disjoint union, as opposed to the [[scala.util.Right]] side. */ +/** The left side of the disjoint union, as opposed to the [[scala.util.Right]] side. + * + * @tparam A the type of the value contained in this `Left` + * @tparam B the type of the `Right` alternative + * @param value the value wrapped in this `Left` + */ final case class Left[+A, +B](value: A) extends Either[A, B] { def isLeft = true def isRight = false @@ -469,12 +561,19 @@ final case class Left[+A, +B](value: A) extends Either[A, B] { * Left(1) // Either[Int, Nothing] * Left(1).withRight[String] // Either[Int, String] * ``` + * + * @tparam B1 the target right type to widen to */ def withRight[B1 >: B]: Either[A, B1] = this } -/** The right side of the disjoint union, as opposed to the [[scala.util.Left]] side. */ +/** The right side of the disjoint union, as opposed to the [[scala.util.Left]] side. + * + * @tparam A the type of the `Left` alternative + * @tparam B the type of the value contained in this `Right` + * @param value the value wrapped in this `Right` + */ final case class Right[+A, +B](value: B) extends Either[A, B] { def isLeft = false def isRight = true @@ -484,6 +583,8 @@ final case class Right[+A, +B](value: B) extends Either[A, B] { * Right("x") // Either[Nothing, String] * Right("x").withLeft[Int] // Either[Int, String] * ``` + * + * @tparam A1 the target left type to widen to */ def withLeft[A1 >: A]: Either[A1, B] = this @@ -494,13 +595,23 @@ object Either { /** If the condition is satisfied, return the given `B` in `Right`, * otherwise, return the given `A` in `Left`. * - * ``` - * val userInput: String = readLine() + * ```scala sc:compile + * import scala.io.StdIn + * case class PhoneNumber(number: String) + * val userInput: String = StdIn.readLine() * Either.cond( * userInput.forall(_.isDigit) && userInput.size == 10, * PhoneNumber(userInput), * s"The input (\$userInput) does not look like a phone number" + * ) * ``` + * + * @tparam A the `Left` type + * @tparam B the `Right` type + * @param test the condition to evaluate + * @param right the `Right` value to use if `test` is `true`, evaluated lazily + * @param left the `Left` value to use if `test` is `false`, evaluated lazily + * @return `Right(right)` if `test` is `true`, `Left(left)` otherwise */ def cond[A, B](test: Boolean, right: => B, left: => A): Either[A, B] = if (test) Right(right) else Left(left) @@ -514,6 +625,9 @@ object Either { * l.merge: Seq[Int] // List(1) * r.merge: Seq[Int] // Vector(1) * ``` + * + * @tparam A the common type of both sides of the `Either` + * @param x the `Either` instance whose left and right types are the same */ implicit class MergeableEither[A](private val x: Either[A, A]) extends AnyVal { def merge: A = x match { @@ -525,6 +639,10 @@ object Either { /** Projects an `Either` into a `Left`. * * @see [[scala.util.Either#left]] + * + * @tparam A the type of the `Left` value + * @tparam B the type of the `Right` value + * @param e the `Either` value to project */ final case class LeftProjection[+A, +B](e: Either[A, B]) { /** Returns the value from this `Left` or throws `NoSuchElementException` @@ -549,7 +667,8 @@ object Either { * Left(12).left.foreach(x => println(x)) // prints "12" * Right(12).left.foreach(x => println(x)) // doesn't print * ``` - * @param f The side-effecting function to execute. + * @tparam U the return type of the side-effecting function (discarded) + * @param f the side-effecting function to execute */ def foreach[U](f: A => U): Unit = e match { case Left(a) => f(a) @@ -562,6 +681,10 @@ object Either { * Left(12).left.getOrElse(17) // 12 * Right(12).left.getOrElse(17) // 17 * ``` + * + * @tparam A1 the supertype of `A` used to widen the return type + * @param or the default value to return if this is a `Right`, evaluated lazily + * @return the `Left` value if present, otherwise `or` */ def getOrElse[A1 >: A](or: => A1): A1 = e match { case Left(a) => a @@ -576,6 +699,9 @@ object Either { * Left(7).left.forall(_ > 10) // false * Right(12).left.forall(_ > 10) // true * ``` + * + * @param p the predicate to apply to the `Left` value + * @return `true` if this is a `Right` or the predicate holds for the `Left` value */ def forall(p: A => Boolean): Boolean = e match { case Left(a) => p(a) @@ -590,6 +716,9 @@ object Either { * Left(7).left.exists(_ > 10) // false * Right(12).left.exists(_ > 10) // false * ``` + * + * @param p the predicate to apply to the `Left` value + * @return `true` if this is a `Left` and the predicate holds for its value */ def exists(p: A => Boolean): Boolean = e match { case Left(a) => p(a) @@ -602,7 +731,10 @@ object Either { * Left(12).left.flatMap(x => Left("scala")) // Left("scala") * Right(12).left.flatMap(x => Left("scala")) // Right(12) * ``` - * @param f The function to bind across `Left`. + * @tparam A1 the left type of the resulting `Either` + * @tparam B1 the supertype of `B` used to widen the right type + * @param f the function to bind across `Left` + * @return the result of applying `f` if this is a `Left`, otherwise the unchanged `Right` */ def flatMap[A1, B1 >: B](f: A => Either[A1, B1]): Either[A1, B1] = e match { case Left(a) => f(a) @@ -615,6 +747,10 @@ object Either { * Left(12).left.map(_ + 2) // Left(14) * Right[Int, Int](12).left.map(_ + 2) // Right(12) * ``` + * + * @tparam A1 the result type of the mapping function + * @param f the function to apply to the `Left` value + * @return a new `Either` with the function applied if this is a `Left`, otherwise the unchanged `Right` */ def map[A1](f: A => A1): Either[A1, B] = e match { case Left(a) => Left(f(a)) @@ -644,6 +780,10 @@ object Either { * Left(7).left.filterToOption(_ > 10) // None * Right(12).left.filterToOption(_ > 10) // None * ``` + * + * @tparam B1 the right type of the resulting `Either` + * @param p the predicate to apply to the `Left` value + * @return `Some(Left(value))` if this is a `Left` and the predicate holds, `None` otherwise */ def filterToOption[B1](p: A => Boolean): Option[Either[A, B1]] = e match { case x @ Left(a) if p(a) => Some(x.asInstanceOf[Either[A, B1]]) @@ -657,6 +797,8 @@ object Either { * Left(12).left.toSeq // Seq(12) * Right(12).left.toSeq // Seq() * ``` + * + * @return a `Seq` containing the `Left` value, or an empty `Seq` if this is a `Right` */ def toSeq: Seq[A] = e match { case Left(a) => Seq(a) @@ -670,6 +812,8 @@ object Either { * Left(12).left.toOption // Some(12) * Right(12).left.toOption // None * ``` + * + * @return a `Some` containing the `Left` value, or `None` if this is a `Right` */ def toOption: Option[A] = e match { case Left(a) => Some(a) @@ -708,7 +852,8 @@ object Either { * Right(12).right.foreach(x => println(x)) // prints "12" * Left(12).right.foreach(x => println(x)) // doesn't print * ``` - * @param f The side-effecting function to execute. + * @tparam U the return type of the side-effecting function (discarded) + * @param f the side-effecting function to execute */ def foreach[U](f: B => U): Unit = e match { case Right(b) => f(b) @@ -721,6 +866,10 @@ object Either { * Right(12).right.getOrElse(17) // 12 * Left(12).right.getOrElse(17) // 17 * ``` + * + * @tparam B1 the supertype of `B` used to widen the return type + * @param or the default value to return if this is a `Left`, evaluated lazily + * @return the `Right` value if present, otherwise `or` */ def getOrElse[B1 >: B](or: => B1): B1 = e match { case Right(b) => b @@ -735,6 +884,9 @@ object Either { * Right(7).right.forall(_ > 10) // false * Left(12).right.forall(_ > 10) // true * ``` + * + * @param f the predicate to apply to the `Right` value + * @return `true` if this is a `Left` or the predicate holds for the `Right` value */ def forall(f: B => Boolean): Boolean = e match { case Right(b) => f(b) @@ -749,6 +901,9 @@ object Either { * Right(7).right.exists(_ > 10) // false * Left(12).right.exists(_ > 10) // false * ``` + * + * @param p the predicate to apply to the `Right` value + * @return `true` if this is a `Right` and the predicate holds for its value */ def exists(p: B => Boolean): Boolean = e match { case Right(b) => p(b) @@ -757,7 +912,9 @@ object Either { /** Binds the given function across `Right`. * - * @param f The function to bind across `Right`. + * @tparam A1 the supertype of `A` used to widen the left type + * @tparam B1 the right type of the resulting `Either` + * @param f the function to bind across `Right` */ def flatMap[A1 >: A, B1](f: B => Either[A1, B1]): Either[A1, B1] = e match { case Right(b) => f(b) @@ -770,6 +927,10 @@ object Either { * Right(12).right.map(x => "flower") // Result: Right("flower") * Left(12).right.map(x => "flower") // Result: Left(12) * ``` + * + * @tparam B1 the result type of the mapping function + * @param f the function to apply to the `Right` value + * @return a new `Either` with the function applied if this is a `Right`, otherwise the unchanged `Left` */ def map[B1](f: B => B1): Either[A, B1] = e match { case Right(b) => Right(f(b)) @@ -801,6 +962,10 @@ object Either { * Right(7).right.filterToOption(_ > 10) // None * Left(12).right.filterToOption(_ > 10) // None * ``` + * + * @tparam A1 the left type of the resulting `Either` + * @param p the predicate to apply to the `Right` value + * @return `Some(Right(value))` if this is a `Right` and the predicate holds, `None` otherwise */ def filterToOption[A1](p: B => Boolean): Option[Either[A1, B]] = e match { case r @ Right(b) if p(b) => Some(r.asInstanceOf[Either[A1, B]]) @@ -814,6 +979,8 @@ object Either { * Right(12).right.toSeq // Seq(12) * Left(12).right.toSeq // Seq() * ``` + * + * @return a `Seq` containing the `Right` value, or an empty `Seq` if this is a `Left` */ def toSeq: Seq[B] = e match { case Right(b) => Seq(b) @@ -827,6 +994,8 @@ object Either { * Right(12).right.toOption // Some(12) * Left(12).right.toOption // None * ``` + * + * @return a `Some` containing the `Right` value, or `None` if this is a `Left` */ def toOption: Option[B] = e match { case Right(b) => Some(b) diff --git a/library/src/scala/util/FromDigits.scala b/library/src/scala/util/FromDigits.scala index d3bade2893a6..880ff73bd0b6 100644 --- a/library/src/scala/util/FromDigits.scala +++ b/library/src/scala/util/FromDigits.scala @@ -5,7 +5,10 @@ import annotation.internal.sharable import language.experimental.captureChecking -/** A type class for types that admit numeric literals. */ +/** A type class for types that admit numeric literals. + * + * @tparam T the numeric type that digit strings can be converted to + */ trait FromDigits[T] { /** Converts `digits` string to value of type `T` @@ -13,6 +16,8 @@ trait FromDigits[T] { * - sign `+` or `-` * - sequence of digits between 0 and 9 * + * @param digits the string representation of the numeric literal to convert + * @return the value of type `T` represented by the digit string * @throws FromDigits.MalformedNumber if digit string is not legal for the given type * @throws FromDigits.NumberTooLarge if value of result does not fit into `T`'s range * @throws FromDigits.NumberTooSmall in case of numeric underflow (e.g. a non-zero @@ -25,41 +30,60 @@ object FromDigits { /** A subclass of `FromDigits` that also allows to convert whole number literals * with a radix other than 10 + * + * @tparam T the numeric type that digit strings with arbitrary radix can be converted to */ trait WithRadix[T] extends FromDigits[T] { def fromDigits(digits: String): T = fromDigits(digits, 10) /** Converts digits string with given radix to number of type `T`. * E.g. if radix is 16, digits `a..f` and `A..F` are also allowed. + * + * @param digits the string representation of the numeric literal to convert + * @param radix the base for the number system (e.g. 10 for decimal, 16 for hexadecimal) */ def fromDigits(digits: String, radix: Int): T } /** A subclass of `FromDigits` that also allows to convert number * literals containing a decimal point ".". + * + * @tparam T the numeric type that digit strings with decimal points can be converted to */ trait Decimal[T] extends FromDigits[T] /** A subclass of `FromDigits`that allows also to convert number * literals containing a decimal point "." or an * exponent `('e' | 'E')['+' | '-']digit digit*`. + * + * @tparam T the numeric type that floating-point digit strings can be converted to */ trait Floating[T] extends Decimal[T] /** The base type for exceptions that can be thrown from * `fromDigits` conversions + * + * @param msg the detail message describing the conversion error */ abstract class FromDigitsException(msg: String) extends NumberFormatException(msg) - /** Thrown if value of result does not fit into result type's range. */ + /** Thrown if value of result does not fit into result type's range. + * + * @param msg the detail message describing the overflow error + */ class NumberTooLarge(msg: String = "number too large") extends FromDigitsException(msg) /** Thrown in case of numeric underflow (e.g. a non-zero * floating point literal that produces a zero value) + * + * @param msg the detail message describing the underflow error */ class NumberTooSmall(msg: String = "number too small") extends FromDigitsException(msg) - /** Thrown if digit string is not legal for the given type. */ + /** Thrown if digit string is not legal for the given type. + * + * @param msg the detail message describing the format error + */ class MalformedNumber(msg: String = "malformed number literal") extends FromDigitsException(msg) /** Converts digits and radix to integer value (either int or Long) @@ -67,6 +91,10 @@ object FromDigits { * Note: We cannot use java.lang.Integer.valueOf or java.lang.Long.valueOf * since these do not handle unsigned hex numbers greater than the maximal value * correctly. + * + * @param digits the string representation of the numeric literal to convert + * @param radix the base for the number system (e.g. 10 for decimal, 16 for hexadecimal) + * @param limit the upper bound for positive values of the result type (e.g. `Int.MaxValue` or `Long.MaxValue`) */ private def integerFromDigits(digits: String, radix: Int, limit: Long): Long = { var value: Long = 0 diff --git a/library/src/scala/util/NotGiven.scala b/library/src/scala/util/NotGiven.scala index 3a6279fccda8..9ebc4398f6a0 100644 --- a/library/src/scala/util/NotGiven.scala +++ b/library/src/scala/util/NotGiven.scala @@ -23,6 +23,8 @@ import language.experimental.captureChecking * * In Dotty, ambiguity is a global error, and therefore cannot be used to implement negation. * Instead, `NotGiven` is treated natively in implicit search. + * + * @tparam T the type for which no implicit instance should be available */ final class NotGiven[+T] private () diff --git a/library/src/scala/util/Properties.scala b/library/src/scala/util/Properties.scala index ceeadd9009d9..3d8fac036cfc 100644 --- a/library/src/scala/util/Properties.scala +++ b/library/src/scala/util/Properties.scala @@ -17,6 +17,7 @@ import scala.language.`2.13` import java.io.{IOException, PrintWriter} import java.util.jar.Attributes.{Name => AttributeName} import scala.annotation.tailrec +import language.experimental.captureChecking /** Loads `library.properties` from the jar. */ object Properties extends PropertiesTrait { diff --git a/library/src/scala/util/Random.scala b/library/src/scala/util/Random.scala index f7c04c6646f1..7410eec271c9 100644 --- a/library/src/scala/util/Random.scala +++ b/library/src/scala/util/Random.scala @@ -19,12 +19,19 @@ import scala.collection.mutable.ArrayBuffer import scala.collection.BuildFrom import scala.collection.immutable.LazyList import scala.language.implicitConversions +import language.experimental.captureChecking -class Random(val self: java.util.Random) extends AnyRef with Serializable { - /** Creates a new random number generator using a single long seed. */ +class Random(val self: java.util.Random^) extends AnyRef with Serializable { + /** Creates a new random number generator using a single long seed. + * + * @param seed the initial seed for the random number generator + */ def this(seed: Long) = this(new java.util.Random(seed)) - /** Creates a new random number generator using a single integer seed. */ + /** Creates a new random number generator using a single integer seed. + * + * @param seed the initial seed for the random number generator + */ def this(seed: Int) = this(seed.toLong) /** Creates a new random number generator. */ @@ -37,16 +44,21 @@ class Random(val self: java.util.Random) extends AnyRef with Serializable { /** Generates random bytes and places them into a user-supplied byte * array. + * + * @param bytes the byte array to fill with random bytes */ def nextBytes(bytes: Array[Byte]): Unit = { self.nextBytes(bytes) } - - /** Generates `n` random bytes and returns them in a new array. */ + + /** Generates `n` random bytes and returns them in a new array. + * + * @param n the number of random bytes to generate + */ def nextBytes(n: Int): Array[Byte] = { val bytes = new Array[Byte](0 max n) self.nextBytes(bytes) bytes } - + /** Returns the next pseudorandom, uniformly distributed double value * between 0.0 and 1.0 from this random number generator's sequence. */ @@ -54,6 +66,9 @@ class Random(val self: java.util.Random) extends AnyRef with Serializable { /** Returns the next pseudorandom, uniformly distributed double value * between min (inclusive) and max (exclusive) from this random number generator's sequence. + * + * @param minInclusive the lower bound (inclusive) of the range + * @param maxExclusive the upper bound (exclusive) of the range, must be greater than `minInclusive` */ def between(minInclusive: Double, maxExclusive: Double): Double = { require(minInclusive < maxExclusive, "Invalid bounds") @@ -70,6 +85,9 @@ class Random(val self: java.util.Random) extends AnyRef with Serializable { /** Returns the next pseudorandom, uniformly distributed float value * between min (inclusive) and max (exclusive) from this random number generator's sequence. + * + * @param minInclusive the lower bound (inclusive) of the range + * @param maxExclusive the upper bound (exclusive) of the range, must be greater than `minInclusive` */ def between(minInclusive: Float, maxExclusive: Float): Float = { require(minInclusive < maxExclusive, "Invalid bounds") @@ -93,12 +111,17 @@ class Random(val self: java.util.Random) extends AnyRef with Serializable { /** Returns a pseudorandom, uniformly distributed int value between 0 * (inclusive) and the specified value (exclusive), drawn from this * random number generator's sequence. + * + * @param n the exclusive upper bound for the returned value (0 is the inclusive lower bound), must be positive */ def nextInt(n: Int): Int = self.nextInt(n) /** Returns a pseudorandom, uniformly distributed int value between min * (inclusive) and the specified value max (exclusive), drawn from this * random number generator's sequence. + * + * @param minInclusive the lower bound (inclusive) of the range + * @param maxExclusive the upper bound (exclusive) of the range, must be greater than `minInclusive` */ def between(minInclusive: Int, maxExclusive: Int): Int = { require(minInclusive < maxExclusive, "Invalid bounds") @@ -128,6 +151,8 @@ class Random(val self: java.util.Random) extends AnyRef with Serializable { /** Returns a pseudorandom, uniformly distributed long value between 0 * (inclusive) and the specified value (exclusive), drawn from this * random number generator's sequence. + * + * @param n the exclusive upper bound for the returned value (0 is the inclusive lower bound), must be positive */ def nextLong(n: Long): Long = { require(n > 0, "n must be positive") @@ -159,6 +184,9 @@ class Random(val self: java.util.Random) extends AnyRef with Serializable { /** Returns a pseudorandom, uniformly distributed long value between min * (inclusive) and the specified value max (exclusive), drawn from this * random number generator's sequence. + * + * @param minInclusive the lower bound (inclusive) of the range + * @param maxExclusive the upper bound (exclusive) of the range, must be greater than `minInclusive` */ def between(minInclusive: Long, maxExclusive: Long): Long = { require(minInclusive < maxExclusive, "Invalid bounds") @@ -186,8 +214,8 @@ class Random(val self: java.util.Random) extends AnyRef with Serializable { * so please don't use this for anything important. It's primarily * intended for generating test data. * - * @param length the desired length of the String - * @return the String + * @param length the desired length of the `String` + * @return a randomly generated `String` of the specified length */ def nextString(length: Int): String = { def safeChar(): Char = { @@ -221,6 +249,10 @@ class Random(val self: java.util.Random) extends AnyRef with Serializable { /** Returns a new collection of the same type in a randomly chosen order. * + * @tparam T the element type of the collection + * @tparam C the type of the collection returned, determined by the implicit `BuildFrom` + * @param xs the collection to shuffle + * @param bf the implicit `BuildFrom` instance used to build the result collection * @return the shuffled collection */ def shuffle[T, C](xs: IterableOnce[T])(implicit bf: BuildFrom[xs.type, T, C]): C = { diff --git a/library/src/scala/util/Sorting.scala b/library/src/scala/util/Sorting.scala index 987a145216ae..10da3fd5294b 100644 --- a/library/src/scala/util/Sorting.scala +++ b/library/src/scala/util/Sorting.scala @@ -16,6 +16,7 @@ package util import scala.language.`2.13` import scala.reflect.ClassTag import scala.math.Ordering +import language.experimental.captureChecking /** The `Sorting` object provides convenience wrappers for `java.util.Arrays.sort`. * Methods that defer to `java.util.Arrays.sort` say that they do or under what @@ -37,20 +38,32 @@ import scala.math.Ordering * other libraries that cover this use case. */ object Sorting { - /** Sorts an array of Doubles using `java.util.Arrays.sort`. */ - def quickSort(a: Array[Double]): Unit = java.util.Arrays.sort(a) + /** Sorts an array of Doubles using `java.util.Arrays.sort`. + * + * @param a the array of `Double`s to sort in place + */ + def quickSort(a: Array[Double]^): Unit = java.util.Arrays.sort(a) - /** Sorts an array of Ints using `java.util.Arrays.sort`. */ - def quickSort(a: Array[Int]): Unit = java.util.Arrays.sort(a) + /** Sorts an array of Ints using `java.util.Arrays.sort`. + * + * @param a the array of `Int`s to sort in place + */ + def quickSort(a: Array[Int]^): Unit = java.util.Arrays.sort(a) - /** Sorts an array of Floats using `java.util.Arrays.sort`. */ - def quickSort(a: Array[Float]): Unit = java.util.Arrays.sort(a) + /** Sorts an array of Floats using `java.util.Arrays.sort`. + * + * @param a the array of `Float`s to sort in place + */ + def quickSort(a: Array[Float]^): Unit = java.util.Arrays.sort(a) private final val qsortThreshold = 16 /** Sorts array `a` with quicksort, using the Ordering on its elements. * This algorithm sorts in place, so no additional memory is used aside from * what might be required to box individual elements during comparison. + * + * @tparam K the element type of the array, which must have an `Ordering` + * @param a the array to sort in place */ def quickSort[K: Ordering](a: Array[K]): Unit = { // Must have iN >= i0 or math will fail. Also, i0 >= 0. @@ -214,7 +227,7 @@ object Sorting { } // Why would you even do this? - private def booleanSort(a: Array[Boolean], from: Int, until: Int): Unit = { + private def booleanSort(a: Array[Boolean]^, from: Int, until: Int): Unit = { var i = from var n = 0 while (i < until) { @@ -252,21 +265,29 @@ object Sorting { } /** Sorts array `a` using the Ordering on its elements, preserving the original ordering where possible. - * Uses `java.util.Arrays.sort` unless `K` is a primitive type. This is the same as `stableSort(a, 0, a.length)`. + * Uses `java.util.Arrays.sort` unless `K` is a primitive type. This is the same as `stableSort(a, 0, a.length)`. + * + * @tparam K the element type of the array, which must have an `Ordering` + * @param a the array to sort in place */ @`inline` def stableSort[K: Ordering](a: Array[K]): Unit = stableSort(a, 0, a.length) /** Sorts array `a` or a part of it using the Ordering on its elements, preserving the original ordering where possible. * Uses `java.util.Arrays.sort` unless `K` is a primitive type. * - * @param a The array to sort - * @param from The first index in the array to sort - * @param until The last index (exclusive) in the array to sort + * @tparam K the element type of the array, which must have an `Ordering` + * @param a the array to sort in place + * @param from the first index in the array to sort + * @param until the last index (exclusive) in the array to sort */ def stableSort[K: Ordering](a: Array[K], from: Int, until: Int): Unit = sort(a, from, until, Ordering[K]) /** Sorts array `a` using function `f` that computes the less-than relation for each element. - * Uses `java.util.Arrays.sort` unless `K` is a primitive type. This is the same as `stableSort(a, f, 0, a.length)`. + * Uses `java.util.Arrays.sort` unless `K` is a primitive type. This is the same as `stableSort(a, f, 0, a.length)`. + * + * @tparam K the element type of the array + * @param a the array to sort in place + * @param f a function that returns `true` if its first argument is less than its second */ @`inline` def stableSort[K](a: Array[K], f: (K, K) => Boolean): Unit = stableSort(a, f, 0, a.length) @@ -274,14 +295,19 @@ object Sorting { /** Sorts array `a` or a part of it using function `f` that computes the less-than relation for each element. * Uses `java.util.Arrays.sort` unless `K` is a primitive type. * - * @param a The array to sort - * @param f A function that computes the less-than relation for each element - * @param from The first index in the array to sort - * @param until The last index (exclusive) in the array to sort + * @tparam K the element type of the array + * @param a the array to sort in place + * @param f a function that returns `true` if its first argument is less than its second + * @param from the first index in the array to sort + * @param until the last index (exclusive) in the array to sort */ def stableSort[K](a: Array[K], f: (K, K) => Boolean, from: Int, until: Int): Unit = sort(a, from, until, Ordering fromLessThan f) - /** A sorted Array, using the Ordering for the elements in the sequence `a`. Uses `java.util.Arrays.sort` unless `K` is a primitive type. */ + /** A sorted Array, using the Ordering for the elements in the sequence `a`. Uses `java.util.Arrays.sort` unless `K` is a primitive type. + * + * @tparam K the element type, which must have a `ClassTag` and an `Ordering` + * @param a the sequence of elements to sort + */ def stableSort[K: ClassTag: Ordering](a: scala.collection.Seq[K]): Array[K] = { val ret = a.toArray sort(ret, 0, ret.length, Ordering[K]) @@ -289,14 +315,25 @@ object Sorting { } // TODO: make this fast for primitive K (could be specialized if it didn't go through Ordering) - /** A sorted Array, given a function `f` that computes the less-than relation for each item in the sequence `a`. Uses `java.util.Arrays.sort` unless `K` is a primitive type. */ + /** A sorted Array, given a function `f` that computes the less-than relation for each item in the sequence `a`. Uses `java.util.Arrays.sort` unless `K` is a primitive type. + * + * @tparam K the element type, which must have a `ClassTag` + * @param a the sequence of elements to sort + * @param f a function that returns `true` if its first argument is less than its second + */ def stableSort[K: ClassTag](a: scala.collection.Seq[K], f: (K, K) => Boolean): Array[K] = { val ret = a.toArray sort(ret, 0, ret.length, Ordering fromLessThan f) ret } - /** A sorted Array, given an extraction function `f` that returns an ordered key for each item in the sequence `a`. Uses `java.util.Arrays.sort` unless `K` is a primitive type. */ + /** A sorted Array, given an extraction function `f` that returns an ordered key for each item in the sequence `a`. Uses `java.util.Arrays.sort` unless `K` is a primitive type. + * + * @tparam K the element type, which must have a `ClassTag` + * @tparam M the key type returned by the extraction function, which must have an `Ordering` + * @param a the sequence of elements to sort + * @param f a function that extracts a comparable key from each element + */ def stableSort[K: ClassTag, M: Ordering](a: scala.collection.Seq[K], f: K => M): Array[K] = { val ret = a.toArray sort(ret, 0, ret.length, Ordering[M] on f) diff --git a/library/src/scala/util/Try.scala b/library/src/scala/util/Try.scala index c98c8499b630..37fb81cbe515 100644 --- a/library/src/scala/util/Try.scala +++ b/library/src/scala/util/Try.scala @@ -30,11 +30,13 @@ import caps.Control * `Try` can reduce or eliminate the need for explicit exception handling in all of the places * where an exception might be thrown. * - * Example: + * ```scala sc-hidden sc-name:try-imports + * import scala.io.StdIn + * import scala.util.{Try, Success, Failure} * ``` - * import scala.io.StdIn - * import scala.util.{Try, Success, Failure} * + * Example: + * ```scala sc:compile sc-compile-with:try-imports * def divide: Try[Int] = { * val dividend = Try(StdIn.readLine("Enter an Int that you'd like to divide:\n").toInt) * val divisor = Try(StdIn.readLine("Enter an Int that you'd like to divide by:\n").toInt) @@ -63,6 +65,8 @@ import caps.Control * Serious system errors, on the other hand, will be thrown. * * *Note:*: all Try combinators will catch exceptions and return failure unless otherwise specified in the documentation. + * + * @tparam T the type of the value computed by the `Try` */ sealed abstract class Try[+T] extends Product with Serializable { self: Try[T]^ => @@ -75,10 +79,18 @@ sealed abstract class Try[+T] extends Product with Serializable { self: Try[T]^ /** Returns the value from this `Success` or the given `default` argument if this is a `Failure`. * * *Note:*: This will throw an exception if it is not a success and default throws an exception. + * + * @tparam U the type of the returned value, a supertype of `T` + * @param default the default value to return if this is a `Failure` + * @return the value if this is a `Success`, otherwise `default` */ def getOrElse[U >: T](default: => U): U - /** Returns this `Try` if it's a `Success` or the given `default` argument if this is a `Failure`. */ + /** Returns this `Try` if it's a `Success` or the given `default` argument if this is a `Failure`. + * + * @tparam U the type of the value in the returned `Try`, a supertype of `T` + * @param default the fallback `Try` to return if this is a `Failure` (evaluated lazily) + */ def orElse[U >: T](default: => Try[U]^): Try[U]^{default} /** Returns the value from this `Success` or throws the exception if this is a `Failure`. */ @@ -87,19 +99,37 @@ sealed abstract class Try[+T] extends Product with Serializable { self: Try[T]^ /** Applies the given function `f` if this is a `Success`, otherwise returns `Unit` if this is a `Failure`. * * *Note:* If `f` throws, then this method may throw an exception. + * + * @tparam U the (discarded) result type of the function `f` + * @param f the function to apply to the value if this is a `Success` */ def foreach[U](f: T => U): Unit - /** Returns the given function applied to the value from this `Success` or returns this if this is a `Failure`. */ + /** Returns the given function applied to the value from this `Success` or returns this if this is a `Failure`. + * + * @tparam U the type of the value in the resulting `Try` + * @param f the function to apply to the value if this is a `Success` + */ def flatMap[U](f: T => Try[U]^): Try[U]^{this, f} - /** Maps the given function to the value from this `Success` or returns this if this is a `Failure`. */ + /** Maps the given function to the value from this `Success` or returns this if this is a `Failure`. + * + * @tparam U the type of the mapped value + * @param f the function to apply to the value if this is a `Success` + */ def map[U](f: T => U): Try[U]^{this, f.only[Control]} - /** Applies the given partial function to the value from this `Success` or returns this if this is a `Failure`. */ + /** Applies the given partial function to the value from this `Success` or returns this if this is a `Failure`. + * + * @tparam U the type of the value returned by the partial function + * @param pf the partial function to apply to the value if this is a `Success` + */ def collect[U](pf: PartialFunction[T, U]^): Try[U]^{this, pf.only[Control]} - /** Converts this to a `Failure` if the predicate is not satisfied. */ + /** Converts this to a `Failure` if the predicate is not satisfied. + * + * @param p the predicate to test the value against + */ def filter(p: T => Boolean): Try[T]^{this, p.only[Control]} /** Creates a non-strict filter, which eventually converts this to a `Failure` @@ -123,6 +153,8 @@ sealed abstract class Try[+T] extends Product with Serializable { self: Try[T]^ /** We need a whole WithFilter class to honor the "doesn't create a new * collection" contract even though it seems unlikely to matter much in a * collection with max size 1. + * + * @param p the predicate used to test elements */ final class WithFilter(p: T => Boolean) uses Try.this { def map[U](f: T => U): Try[U]^{Try.this, p.only[Control], f.only[Control]} = Try.this.filter(p).map(f) @@ -134,11 +166,17 @@ sealed abstract class Try[+T] extends Product with Serializable { self: Try[T]^ /** Applies the given function `f` if this is a `Failure`, otherwise returns this if this is a `Success`. * This is like `flatMap` for the exception. + * + * @tparam U the type of the value in the resulting `Try`, a supertype of `T` + * @param pf the partial function to apply if this is a `Failure` */ def recoverWith[U >: T](pf: PartialFunction[Throwable, Try[U]^]^): Try[U]^{this, pf} /** Applies the given function `f` if this is a `Failure`, otherwise returns this if this is a `Success`. * This is like map for the exception. + * + * @tparam U the type of the value in the resulting `Try`, a supertype of `T` + * @param pf the partial function to apply if this is a `Failure` */ def recover[U >: T](pf: PartialFunction[Throwable, U]^): Try[U]^{this, pf.only[Control]} @@ -147,6 +185,9 @@ sealed abstract class Try[+T] extends Product with Serializable { self: Try[T]^ /** Transforms a nested `Try`, ie, a `Try` of type `Try[Try[T]]`, * into an un-nested `Try`, ie, a `Try` of type `Try[T]`. + * + * @tparam U the type of the value in the inner `Try` + * @param ev evidence that `T` is itself a `Try[U]` */ def flatten[U](implicit ev: T <:< Try[U]): Try[U]^{this} @@ -157,6 +198,10 @@ sealed abstract class Try[+T] extends Product with Serializable { self: Try[T]^ /** Completes this `Try` by applying the function `f` to this if this is of type `Failure`, or conversely, by applying * `s` if this is a `Success`. + * + * @tparam U the type of the value in the resulting `Try` + * @param s the function to apply if this is a `Success` + * @param f the function to apply if this is a `Failure` */ def transform[U](s: T => Try[U]^, f: Throwable => Try[U]^): Try[U]^{s, f} @@ -178,6 +223,8 @@ sealed abstract class Try[+T] extends Product with Serializable { self: Try[T]^ * @param fa the function to apply if this is a `Failure` * @param fb the function to apply if this is a `Success` * @return the results of applying the function + * + * @tparam U the type of the result */ def fold[U](fa: Throwable => U, fb: T => U): U @@ -191,6 +238,7 @@ object Try { * Any non-fatal exception is caught and results in a `Failure` * that holds the exception. * + * @tparam T the type of the value to be computed * @param r the result value to compute * @return the result of evaluating the value, as a `Success` or `Failure` */ diff --git a/library/src/scala/util/Using.scala b/library/src/scala/util/Using.scala index d3aca82fbeb6..7bce4fcd10f9 100644 --- a/library/src/scala/util/Using.scala +++ b/library/src/scala/util/Using.scala @@ -27,7 +27,7 @@ import scala.runtime.ScalaRunTime.nullForGC * resource opening, operation, and resource releasing in a `Try`. * * Example: - * ``` + * ```scala sc:compile * import java.io.{BufferedReader, FileReader} * import scala.util.{Try, Using} * @@ -42,7 +42,7 @@ import scala.runtime.ScalaRunTime.nullForGC * release are all wrapped in a `Try`. * * Example: - * ``` + * ```scala sc:compile * import java.io.{BufferedReader, FileReader} * import scala.util.{Try, Using} * @@ -62,13 +62,19 @@ import scala.runtime.ScalaRunTime.nullForGC * Composed or "wrapped" resources may be acquired in order of construction, * if "underlying" resources are not closed. Although redundant in this case, * here is the previous example with a wrapped call to `use`: - * ``` + * ```scala sc:compile + * import java.io.{BufferedReader, FileReader} + * import scala.util.Using + * + * Using.Manager { use => * def mkreader(filename: String) = use(new BufferedReader(use(new FileReader(filename)))) + * mkreader("file.txt") + * } * ``` * * Custom resources can be registered on construction by requiring an implicit `Manager`. * This ensures they will be released even if composition fails: - * ``` + * ```scala sc:compile * import scala.util.Using * * case class X(x: String)(implicit mgr: Using.Manager) extends AutoCloseable { @@ -98,7 +104,7 @@ import scala.runtime.ScalaRunTime.nullForGC * [[Using.resource `Using.resource`]], which throws any exceptions that occur. * * Example: - * ``` + * ```scala sc:compile * import java.io.{BufferedReader, FileReader} * import scala.util.Using * @@ -143,6 +149,10 @@ object Using { * * $suppressionBehavior * + * @tparam R the type of the resource + * @tparam A the return type of the operation + * @param resource the resource to be used and then released + * @param f the operation to perform using the resource * @return a [[Try]] containing an exception if one or more were thrown, * or the result of the operation if no exceptions were thrown */ @@ -183,6 +193,9 @@ object Using { /** Registers the specified resource with this manager, so that * the resource is released when the manager is closed, and then * returns the (unmodified) resource. + * + * @tparam R the type of the resource, which must have a `Releasable` instance + * @param resource the resource to register with this manager */ def apply[R: Releasable](resource: R): resource.type = { acquire(resource) @@ -191,6 +204,9 @@ object Using { /** Registers the specified resource with this manager, so that * the resource is released when the manager is closed. + * + * @tparam R the type of the resource, which must have a `Releasable` instance + * @param resource the resource to register, must be non-null */ def acquire[R: Releasable](resource: R): Unit = { if (resource == null) throw new NullPointerException("null resource") @@ -285,8 +301,9 @@ object Using { * * @tparam R the type of the resource * @tparam A the return type of the operation - * @param resource the resource + * @param resource the resource to be used and then released * @param body the operation to perform with the resource + * @param releasable the implicit `Releasable` instance used to release the resource * @return the result of the operation, if neither the operation nor * releasing the resource throws */ @@ -319,8 +336,8 @@ object Using { * @tparam R1 the type of the first resource * @tparam R2 the type of the second resource * @tparam A the return type of the operation - * @param resource1 the first resource - * @param resource2 the second resource + * @param resource1 the first resource (eagerly evaluated) + * @param resource2 the second resource (by-name, evaluated after the first is acquired) * @param body the operation to perform using the resources * @return the result of the operation, if neither the operation nor * releasing the resources throws @@ -418,7 +435,10 @@ object Using { * @tparam R the type of the resource */ trait Releasable[-R] { - /** Releases the specified resource. */ + /** Releases the specified resource. + * + * @param resource the resource to release + */ def release(resource: R): Unit } diff --git a/library/src/scala/util/boundary.scala b/library/src/scala/util/boundary.scala index d457c0c088c6..ad49c05169da 100644 --- a/library/src/scala/util/boundary.scala +++ b/library/src/scala/util/boundary.scala @@ -18,7 +18,7 @@ import scala.annotation.implicitNotFound * * Example usage: * - * ```scala + * ```scala sc:compile * import scala.util.boundary, boundary.break * * def firstIndex[T](xs: List[T], elem: T): Int = @@ -35,11 +35,16 @@ object boundary: * * Note that it is **capability unsafe** to access `label` from a `Break`. * This field will be marked private in a future release. + * + * @tparam T the type of the value carried by this `Break` exception */ final class Break[T] private[boundary](val label: Label[T]^{}, val value: T) extends RuntimeException( /*message*/ null, /*cause*/ null, /*enableSuppression=*/ false, /*writableStackTrace*/ false): - /** Compares the given [[Label]] to the one this [[Break]] was constructed with. */ + /** Compares the given [[Label]] to the one this [[Break]] was constructed with. + * + * @param other the `Label` to compare against this `Break`'s label + */ def isSameLabelAs(other: Label[T]) = label eq other object Break: @@ -54,12 +59,18 @@ object boundary: /** Abort current computation and instead return `value` as the value of * the enclosing `boundary` call that created `label`. + * + * @tparam T the type of the value to return from the enclosing `boundary` + * @param value the value to return from the enclosing `boundary` call + * @param label the label identifying the target `boundary` to exit */ def break[T](value: T)(using label: Label[T]): Nothing = throw Break(label, value) /** Abort current computation and instead continue after the `boundary` call that * created `label`. + * + * @param label the label identifying the target `boundary` to exit */ def break()(using label: Label[Unit]): Nothing = throw Break(label, ()) @@ -67,6 +78,9 @@ object boundary: /** Run `body` with freshly generated label as implicit argument. Catch any * breaks associated with that label and return their results instead of * `body`'s result. + * + * @tparam T the result type of the boundary block + * @param body the computation to execute, which receives a fresh `Label[T]` as a context parameter */ inline def apply[T](inline body: Label[T] ?=> T): T = val local = Label[T]() diff --git a/library/src/scala/util/control/Breaks.scala b/library/src/scala/util/control/Breaks.scala index 96ad77213834..3d810f844870 100644 --- a/library/src/scala/util/control/Breaks.scala +++ b/library/src/scala/util/control/Breaks.scala @@ -42,10 +42,14 @@ import scala.language.`2.13` * convenience value `Breaks`. * * Example usage: - * ``` + * ```scala sc:compile * val mybreaks = new Breaks * import mybreaks.{break, breakable} * + * var done = false + * def f(x: Int): Int = x + * val xs = (1 to 10).toList + * * breakable { * for (x <- xs) { * if (done) break() @@ -58,10 +62,16 @@ import scala.language.`2.13` * * Any intervening exception handlers should use `NonFatal`, * or use `Try` for evaluation: - * ``` + * ```scala sc:compile + * import scala.util.Try + * * val mybreaks = new Breaks * import mybreaks.{break, breakable} * + * var quit = false + * def f(x: Int): Int = x + * val xs = (1 to 10).toList + * * breakable { * for (x <- xs) Try { if (quit) break else f(x) }.foreach(println) * } @@ -74,6 +84,8 @@ class Breaks { /** A block from which one can exit with a `break`. The `break` may be * executed further down in the call stack provided that it is called on the * exact same instance of `Breaks`. + * + * @param op the computation to execute, which may call `break` to exit early */ def breakable(op: => Unit): Unit = try op catch { case ex: BreakControl if ex eq breakException => } @@ -85,13 +97,20 @@ class Breaks { /** Try a computation that produces a value, supplying a default * to be used if the computation terminates with a `break`. * - * ``` + * ```scala sc:compile + * val mybreaks = new Breaks + * import mybreaks.{break, breakable, tryBreakable} + * * tryBreakable { - * (1 to 3).map(i => if (math.random < .5) break else i * 2) + * (1 to 3).map(i => if math.random() < .5 then break() else i * 2) * } catchBreak { * Vector.empty * } * ``` + * + * @tparam T the result type of the computation + * @param op the computation to evaluate, which may call `break` to abort + * @return a `TryBlock` whose `catchBreak` method provides the fallback value if `break` is invoked */ def tryBreakable[T](op: => T): TryBlock[T] = new TryBlock[T] { @@ -111,13 +130,12 @@ class Breaks { /** An object that can be used for the break control abstraction. * * Example usage: - * ``` + * ```scala sc:compile * import Breaks.{break, breakable} * * breakable { - * for (...) { - * if (...) break - * } + * for i <- 1 to 10 do + * if i == 5 then break * } * ``` */ diff --git a/library/src/scala/util/control/ControlThrowable.scala b/library/src/scala/util/control/ControlThrowable.scala index 571d80d3c88a..f6942c3bbebe 100644 --- a/library/src/scala/util/control/ControlThrowable.scala +++ b/library/src/scala/util/control/ControlThrowable.scala @@ -20,9 +20,13 @@ import scala.language.`2.13` * * As a convenience, `NonFatal` does not match `ControlThrowable`. * - * ``` + * ```scala sc:compile * import scala.util.control.{Breaks, NonFatal}, Breaks.{break, breakable} * + * def log(t: Throwable): Unit = () + * def p(v: Int): Boolean = v == 3 + * val values = (1 to 10).toList + * * breakable { * for (v <- values) { * try { @@ -41,6 +45,8 @@ import scala.language.`2.13` * * Instances of `ControlThrowable` should not normally have a cause. * Legacy subclasses may set a cause using `initCause`. + * + * @param message the detail message for this control throwable, or `null` if none */ abstract class ControlThrowable(message: String | Null) extends Throwable( message, /*cause*/ null, /*enableSuppression=*/ false, /*writableStackTrace*/ false) { diff --git a/library/src/scala/util/control/Exception.scala b/library/src/scala/util/control/Exception.scala index 557ac21c7779..8efde1932b04 100644 --- a/library/src/scala/util/control/Exception.scala +++ b/library/src/scala/util/control/Exception.scala @@ -30,11 +30,14 @@ import scala.language.implicitConversions * * ### Examples * - * Creates a `Catch` which handles specified exceptions. - * ``` + * ```scala sc-hidden sc-name:exception-imports-1 * import scala.util.control.Exception._ + * import scala.util.Try * import java.net._ + * ``` * + * Creates a `Catch` which handles specified exceptions. + * ```scala sc:compile sc-compile-with:exception-imports-1 * val s = "https://www.scala-lang.org/" * * // Some(https://www.scala-lang.org/) @@ -52,14 +55,19 @@ import scala.language.implicitConversions * val x4: URL = failAsValue(classOf[MalformedURLException])(defaultUrl)(new URL("htt/xx")) * ``` * - * Creates a `Catch` which logs exceptions using `handling` and `by`. + * ```scala sc-hidden sc-name:exception-imports-2 + * import scala.util.control.Exception._ + * import java.net._ * ``` + * + * Creates a `Catch` which logs exceptions using `handling` and `by`. + * ```scala sc:compile sc-compile-with:exception-imports-2 * def log(t: Throwable): Unit = t.printStackTrace * * val withThrowableLogging: Catch[Unit] = handling(classOf[MalformedURLException]) by (log) * * def printUrl(url: String) : Unit = { - * val con = new URL(url) openConnection() + * val con = new URL(url).openConnection() * val source = scala.io.Source.fromInputStream(con.getInputStream()) * source.getLines().foreach(println) * } @@ -77,8 +85,12 @@ import scala.language.implicitConversions * withThrowableLogging { printUrl(goodUrl) } * ``` * - * Use `unwrapping` to create a `Catch` that unwraps exceptions before rethrowing. + * ```scala sc-hidden sc-name:exception-imports-3 + * import scala.util.control.Exception._ * ``` + * + * Use `unwrapping` to create a `Catch` that unwraps exceptions before rethrowing. + * ```scala sc:compile sc-compile-with:exception-imports-3 * class AppException(cause: Throwable) extends RuntimeException(cause) * * val unwrappingCatch: Catch[Nothing] = unwrapping(classOf[AppException]) @@ -91,9 +103,13 @@ import scala.language.implicitConversions * val result = unwrappingCatch(calcResult) * ``` * + * ```scala sc-hidden sc-name:exception-imports-4 + * import scala.util.control.Exception._ + * ``` + * * Use `failAsValue` to provide a default when a specified exception is caught. * - * ``` + * ```scala sc:compile sc-compile-with:exception-imports-4 * val inputDefaulting: Catch[Int] = failAsValue(classOf[NumberFormatException])(0) * val candidatePick = "seven" // scala.io.StdIn.readLine() * @@ -101,8 +117,12 @@ import scala.language.implicitConversions * val pick = inputDefaulting(candidatePick.toInt) * ``` * - * Compose multiple `Catch`s with `or` to build a `Catch` that provides default values varied by exception. + * ```scala sc-hidden sc-name:exception-imports-5 + * import scala.util.control.Exception._ * ``` + * + * Compose multiple `Catch`s with `or` to build a `Catch` that provides default values varied by exception. + * ```scala sc:compile sc-compile-with:exception-imports-5 * val formatDefaulting: Catch[Int] = failAsValue(classOf[NumberFormatException])(0) * val nullDefaulting: Catch[Int] = failAsValue(classOf[NullPointerException])(-1) * val otherDefaulting: Catch[Int] = nonFatalCatch withApply(_ => -100) @@ -170,7 +190,8 @@ object Exception { /** !!! Not at all sure of every factor which goes into this, * and/or whether we need multiple standard variations. - * @return true if `x` is $protectedExceptions otherwise false. + * @param x the throwable to check + * @return true if `x` is a $protectedExceptions, otherwise `false`. */ def shouldRethrow(x: Throwable): Boolean = x match { case _: ControlThrowable => true @@ -205,10 +226,10 @@ object Exception { * Pass a different value for rethrow if you want to probably * unwisely allow catching control exceptions and other throwables * which the rest of the world may expect to get through. - * @tparam T result type of bodies used in try and catch blocks - * @param pf Partial function used when applying catch logic to determine result value - * @param fin Finally logic which if defined will be invoked after catch logic - * @param rethrow Predicate on throwables determining when to rethrow a caught [[Throwable]] + * @tparam T result type produced by the catch logic + * @param pf partial function used when applying catch logic to determine result value + * @param fin finally logic which, if defined, will be invoked after catch logic + * @param rethrow predicate on throwables determining when to rethrow a caught [[Throwable]] * @group logic-container */ class Catch[+T]( @@ -219,11 +240,19 @@ object Exception { protected val name = "Catch" - /** Creates a new Catch with additional exception handling logic. */ + /** Creates a new Catch with additional exception handling logic. + * + * @tparam U the result type of the combined catch logic, a supertype of `T` + * @param pf2 the additional exception handler to combine with the existing one + */ def or[U >: T](pf2: Catcher[U]): Catch[U] = new Catch(pf orElse pf2, fin, rethrow) def or[U >: T](other: Catch[U]): Catch[U] = or(other.pf) - /** Applies this catch logic to the supplied body. */ + /** Applies this catch logic to the supplied body. + * + * @tparam U the result type of the body, a supertype of `T` + * @param body the code block to execute with exception handling + */ def apply[U >: T](body: => U): U = try body catch { @@ -233,7 +262,7 @@ object Exception { finally fin foreach (_.invoke()) /** Creates a new Catch container from this object and the supplied finally body. - * @param body The additional logic to apply after all existing finally bodies + * @param body the additional logic to apply after all existing finally bodies */ def andFinally(body: => Unit): Catch[T] = { val appendedFin = fin map(_ and body) getOrElse new Finally(body) @@ -242,22 +271,34 @@ object Exception { /** Applies this catch logic to the supplied body, mapping the result * into `Option[T]` - `None` if any exception was caught, `Some(T)` otherwise. + * + * @tparam U the result type of the body, a supertype of `T` + * @param body the code block to execute, whose result is wrapped in `Some` on success */ def opt[U >: T](body: => U): Option[U] = toOption(Some(body)) /** Applies this catch logic to the supplied body, mapping the result * into `Either[Throwable, T]` - `Left(exception)` if an exception was caught, * `Right(T)` otherwise. + * + * @tparam U the result type of the body, a supertype of `T` + * @param body the code block to execute, whose result is wrapped in `Right` on success */ def either[U >: T](body: => U): Either[Throwable, U] = toEither(Right(body)) /** Applies this catch logic to the supplied body, mapping the result * into `Try[T]` - `Failure` if an exception was caught, `Success(T)` otherwise. + * + * @tparam U the result type of the body, a supertype of `T` + * @param body the code block to execute, whose result is wrapped in `Success` on success */ def withTry[U >: T](body: => U): scala.util.Try[U] = toTry(Success(body)) /** Creates a `Catch` object with the same `isDefinedAt` logic as this one, - * but with the supplied `apply` method replacing the current one. + * but with the supplied `apply` method replacing the current one. + * + * @tparam U the result type of the new exception handler + * @param f the function to apply to caught exceptions instead of the current handler */ def withApply[U](f: Throwable => U): Catch[U] = { val pf2 = new Catcher[U] { @@ -284,11 +325,15 @@ object Exception { /** A `Catch` object which catches everything. * @group canned-behavior + * + * @tparam T the result type of the `Catch` body */ final def allCatch[T]: Catch[T] = new Catch(allCatcher[T]) withDesc "" /** A `Catch` object which catches non-fatal exceptions. * @group canned-behavior + * + * @tparam T the result type of the `Catch` body */ final def nonFatalCatch[T]: Catch[T] = new Catch(nonFatalCatcher[T]) withDesc "" @@ -301,6 +346,10 @@ object Exception { * which should only be caught in exceptional circumstances. If you really want * to catch exactly what you specify, use `catchingPromiscuously` instead. * @group composition-catch + * + * @tparam T the result type of the `Catch` body + * @param exceptions the exception classes to catch + * @return a `Catch` object that will catch the specified exceptions */ def catching[T](exceptions: Class[?]*): Catch[T] = new Catch(pfFromExceptions(exceptions*)) withDesc (exceptions map (_.getName) mkString ", ") @@ -311,24 +360,36 @@ object Exception { * Unlike "catching" which filters out those in shouldRethrow, this one will * catch whatever you ask of it including $protectedExceptions. * @group composition-catch-promiscuously + * + * @tparam T the result type of the `Catch` body + * @param exceptions the exception classes to catch, including $protectedExceptions */ def catchingPromiscuously[T](exceptions: Class[?]*): Catch[T] = catchingPromiscuously(pfFromExceptions(exceptions*)) def catchingPromiscuously[T](c: Catcher[T]): Catch[T] = new Catch(c, None, _ => false) /** Creates a `Catch` object which catches and ignores any of the supplied exceptions. * @group composition-catch + * + * @param exceptions the exception classes to catch and ignore */ def ignoring(exceptions: Class[?]*): Catch[Unit] = catching(exceptions*) withApply (_ => ()) /** Creates a `Catch` object which maps all the supplied exceptions to `None`. * @group composition-catch + * + * @tparam T the value type of the resulting `Option` + * @param exceptions the exception classes to catch, mapping them to `None` */ def failing[T](exceptions: Class[?]*): Catch[Option[T]] = catching(exceptions*) withApply (_ => None) /** Creates a `Catch` object which maps all the supplied exceptions to the given value. * @group composition-catch + * + * @tparam T the result type of the `Catch` body and the default value + * @param exceptions the exception classes to catch + * @param value the default value to return when one of the specified exceptions is caught */ def failAsValue[T](exceptions: Class[?]*)(value: => T): Catch[T] = catching(exceptions*) withApply (_ => value) @@ -340,10 +401,16 @@ object Exception { /** Returns a partially constructed `Catch` object, which you must give * an exception handler function as an argument to `by`. * @example - * ``` - * handling(classOf[MalformedURLException], classOf[NullPointerException]) by (_.printStackTrace) + * ```scala sc:compile + * import scala.util.control.Exception._ + * import java.net.MalformedURLException + * + * handling(classOf[MalformedURLException], classOf[NullPointerException]) by (_.printStackTrace) * ``` * @group dsl + * + * @tparam T the result type of the handler function passed to `by` + * @param exceptions the exception classes to catch */ def handling[T](exceptions: Class[?]*): By[Throwable => T, Catch[T]] = { def fun(f: Throwable => T): Catch[T] = catching(exceptions*) withApply f @@ -352,11 +419,17 @@ object Exception { /** Returns a `Catch` object with no catch logic and the argument as the finally logic. * @group composition-finally + * + * @tparam T the result type of the `Catch` body + * @param body the finally logic to execute after the `Catch` body completes */ def ultimately[T](body: => Unit): Catch[T] = noCatch andFinally body /** Creates a `Catch` object which unwraps any of the supplied exceptions. * @group composition-catch + * + * @tparam T the result type of the `Catch` body + * @param exceptions the wrapper exception classes to unwrap before rethrowing */ def unwrapping[T](exceptions: Class[?]*): Catch[T] = { @tailrec @@ -367,7 +440,11 @@ object Exception { catching(exceptions*) withApply (x => throw unwrap(x)) } - /** Private. */ + /** Private. + * + * @param x the throwable to test against `classes` + * @param classes the exception classes to match against + */ private def wouldMatch(x: Throwable, classes: scala.collection.Seq[Class[?]]): Boolean = classes exists (_.isAssignableFrom(x.getClass)) diff --git a/library/src/scala/util/control/NonFatal.scala b/library/src/scala/util/control/NonFatal.scala index 8ec66eaabc59..6c8e0c186ee5 100644 --- a/library/src/scala/util/control/NonFatal.scala +++ b/library/src/scala/util/control/NonFatal.scala @@ -22,10 +22,17 @@ import scala.language.`2.13` * Note that [[scala.util.control.ControlThrowable]], an internal Throwable, is not matched by * `NonFatal` (and would therefore be thrown). * - * For example, all harmless Throwables can be caught by: + * ```scala sc-hidden sc-name:nonfatal-log + * object log { + * def error(e: Throwable, msg: String): Unit = println(s"$msg: $e") + * } * ``` + * + * For example, all harmless Throwables can be caught by: + * ```scala sc:compile sc-compile-with:nonfatal-log * try { - * // dangerous stuff + * // dangerous stuff goes here, we throw an exception for demonstration purposes + * throw new RuntimeException("test") * } catch { * case NonFatal(e) => log.error(e, "Something not that bad.") * // or @@ -41,6 +48,9 @@ object NonFatal { case _: VirtualMachineError | _: ThreadDeath | _: InterruptedException | _: LinkageError | _: ControlThrowable => false case _ => true } - /** Returns `Some`(t) if `NonFatal`(t) == true, otherwise `None` */ + /** Returns `Some`(t) if `NonFatal`(t) == true, otherwise `None` + * + * @param t the `Throwable` to test for being non-fatal + */ def unapply(t: Throwable): Option[Throwable] = if (apply(t)) Some(t) else None } diff --git a/library/src/scala/util/control/TailCalls.scala b/library/src/scala/util/control/TailCalls.scala index 2bd4dd3715ac..f41280619b7e 100644 --- a/library/src/scala/util/control/TailCalls.scala +++ b/library/src/scala/util/control/TailCalls.scala @@ -25,10 +25,12 @@ import annotation.tailrec * Implemented as described in "Stackless Scala with Free Monads" * [[https://blog.higher-order.com/assets/trampolines.pdf]] * - * Here's a usage example: - * ``` + * ```scala sc-hidden sc-name:tailcalls-import * import scala.util.control.TailCalls._ + * ``` * + * Here's a usage example: + * ```scala sc:compile sc-compile-with:tailcalls-import * def isEven(xs: List[Int]): TailRec[Boolean] = * if (xs.isEmpty) done(true) else tailcall(isOdd(xs.tail)) * @@ -48,14 +50,24 @@ import annotation.tailrec */ object TailCalls { - /** This class represents a tailcalling computation. */ + /** This class represents a tailcalling computation. + * + * @tparam A the result type of the computation + */ sealed abstract class TailRec[+A] { - /** Continue the computation with `f`. */ + /** Continue the computation with `f`. + * + * @tparam B the result type of the mapped computation + * @param f the function to apply to the result, transforming `A` to `B` + */ final def map[B](f: A => B): TailRec[B] = flatMap(a => Call(() => Done(f(a)))) /** Continue the computation with `f` and merge the trampolining * of this computation with that of `f`. + * + * @tparam B the result type of the continuation + * @param f the function to apply to the result, returning a new tailcalling computation */ final def flatMap[B](f: A => TailRec[B]): TailRec[B] = this match { case Done(a) => Call(() => f(a)) @@ -89,27 +101,43 @@ object TailCalls { } } - /** Internal class representing a tailcall. */ + /** Internal class representing a tailcall. + * + * @tparam A the result type of the computation + * @param rest a thunk that computes the next step of the tailcalling computation + */ protected case class Call[A](rest: () => TailRec[A]) extends TailRec[A] /** Internal class representing the final result returned from a tailcalling * computation. + * + * @tparam A the result type of the computation + * @param value the final result of the tailcalling computation */ protected case class Done[A](value: A) extends TailRec[A] /** Internal class representing a continuation with function A => TailRec[B]. * It is needed for the flatMap to be implemented. + * + * @tparam A the intermediate result type + * @tparam B the final result type of the continuation + * @param a the first computation to evaluate + * @param f the continuation function to apply to the result of `a` */ protected case class Cont[A, B](a: TailRec[A], f: A => TailRec[B]) extends TailRec[B] /** Perform a tailcall. + * + * @tparam A the result type of the tailcalling computation * @param rest the expression to be evaluated in the tailcall * @return a `TailRec` object representing the expression `rest` */ def tailcall[A](rest: => TailRec[A]): TailRec[A] = Call(() => rest) /** Returns the final result from a tailcalling computation. - * @param `result` the result value + * + * @tparam A the result type of the computation + * @param result the value to wrap as a completed computation * @return a `TailRec` object representing a computation which immediately * returns `result` */ diff --git a/library/src/scala/util/hashing/ByteswapHashing.scala b/library/src/scala/util/hashing/ByteswapHashing.scala index 48131fd73d25..9c36d9b8af6b 100644 --- a/library/src/scala/util/hashing/ByteswapHashing.scala +++ b/library/src/scala/util/hashing/ByteswapHashing.scala @@ -15,7 +15,10 @@ package util.hashing import scala.language.`2.13` -/** A fast multiplicative hash by Phil Bagwell. */ +/** A fast multiplicative hash by Phil Bagwell. + * + * @tparam T the type of values to be hashed + */ final class ByteswapHashing[T] extends Hashing[T] { def hash(v: T) = byteswap32(v.##) @@ -29,7 +32,11 @@ object ByteswapHashing { def hash(v: T) = byteswap32(h.hash(v)) } - /** Composes another `Hashing` with the Byteswap hash. */ + /** Composes another `Hashing` with the Byteswap hash. + * + * @tparam T the type of values to be hashed + * @param h the hashing instance whose result is passed through byteswap hashing + */ def chain[T](h: Hashing[T]): Hashing[T] = new Chained(h) } diff --git a/library/src/scala/util/hashing/MurmurHash3.scala b/library/src/scala/util/hashing/MurmurHash3.scala index 73347719ac3d..dfbc1e20e6d3 100644 --- a/library/src/scala/util/hashing/MurmurHash3.scala +++ b/library/src/scala/util/hashing/MurmurHash3.scala @@ -17,7 +17,11 @@ import scala.language.`2.13` import java.lang.Integer.{ rotateLeft => rotl } private[hashing] class MurmurHash3 { - /** Mix in a block of data into an intermediate hash value. */ + /** Mix in a block of data into an intermediate hash value. + * + * @param hash the intermediate hash value + * @param data the new block of data to mix in + */ final def mix(hash: Int, data: Int): Int = { var h = mixLast(hash, data) h = rotl(h, 13) @@ -27,6 +31,9 @@ private[hashing] class MurmurHash3 { /** May optionally be used as the last mixing step. Is a little bit faster than mix, * as it does no further mixing of the resulting hash. For the last element this is not * necessary as the hash is thoroughly mixed during finalization anyway. + * + * @param hash the intermediate hash value + * @param data the last block of data to mix in */ final def mixLast(hash: Int, data: Int): Int = { var k = data @@ -38,10 +45,17 @@ private[hashing] class MurmurHash3 { hash ^ k } - /** Finalize a hash to incorporate the length and make sure all bits avalanche. */ + /** Finalize a hash to incorporate the length and make sure all bits avalanche. + * + * @param hash the intermediate hash value after all mix steps + * @param length the number of elements hashed + */ final def finalizeHash(hash: Int, length: Int): Int = avalanche(hash ^ length) - /** Force all bits of the hash to avalanche. Used for finalizing the hash. */ + /** Force all bits of the hash to avalanche. Used for finalizing the hash. + * + * @param hash the intermediate hash value whose bits should be thoroughly mixed + */ private final def avalanche(hash: Int): Int = { var h = hash @@ -83,7 +97,12 @@ private[hashing] class MurmurHash3 { } } - /** See the [[MurmurHash3.caseClassHash(x:Product,caseClassName:String)]] overload. */ + /** See the [[MurmurHash3.caseClassHash(x:Product,caseClassName:String)]] overload. + * + * @param x the case class instance to hash + * @param seed the initial seed for the hash computation + * @param caseClassName the case class name used for hashing, or `null` to fall back to `x.productPrefix` + */ final def caseClassHash(x: Product, seed: Int, caseClassName: String | Null): Int = { val arr = x.productArity val aye = (if (caseClassName != null) caseClassName else x.productPrefix).hashCode @@ -101,7 +120,11 @@ private[hashing] class MurmurHash3 { } - /** Computes the hash of a string. */ + /** Computes the hash of a string. + * + * @param str the string to hash + * @param seed the initial seed for the hash computation + */ final def stringHash(str: String, seed: Int): Int = { var h = seed var i = 0 @@ -117,6 +140,9 @@ private[hashing] class MurmurHash3 { /** Computes a hash that is symmetric in its arguments - that is a hash * where the order of appearance of elements does not matter. * This is useful for hashing sets, for example. + * + * @param xs the elements to hash (order-independent) + * @param seed the initial seed for the hash computation */ final def unorderedHash(xs: IterableOnce[Any], seed: Int): Int = { var a, b, n = 0 @@ -139,6 +165,9 @@ private[hashing] class MurmurHash3 { /** Computes a hash that depends on the order of its arguments. Potential range * hashes are recognized to produce a hash that is compatible with rangeHash. + * + * @param xs the elements to hash in traversal order + * @param seed the initial seed for the hash computation */ final def orderedHash(xs: IterableOnce[Any], seed: Int): Int = { val it = xs.iterator @@ -175,6 +204,9 @@ private[hashing] class MurmurHash3 { /** Computes the hash of an array. Potential range hashes are recognized to produce a * hash that is compatible with rangeHash. + * + * @param a the array to hash + * @param seed the initial seed for the hash computation */ final def arrayHash[@specialized T](a: Array[T], seed: Int): Int = { var h = seed @@ -213,6 +245,11 @@ private[hashing] class MurmurHash3 { /** Computes the hash of a Range with at least 2 elements. Ranges with fewer * elements need to use seqHash instead. The `last` parameter must be the * actual last element produced by a Range, not the nominal `end`. + * + * @param start the first element of the range + * @param step the increment between successive elements + * @param last the actual last element produced by the range + * @param seed the initial seed for the hash computation */ final def rangeHash(start: Int, step: Int, last: Int, seed: Int): Int = avalanche(mix(mix(mix(seed, start), step), last)) @@ -220,6 +257,9 @@ private[hashing] class MurmurHash3 { /** Computes the hash of a byte array. Faster than arrayHash, because * it hashes 4 bytes at once. Note that the result is not compatible with * arrayHash! + * + * @param data the byte array to hash + * @param seed the initial seed for the hash computation */ final def bytesHash(data: Array[Byte], seed: Int): Int = { var len = data.length @@ -254,6 +294,9 @@ private[hashing] class MurmurHash3 { /** Computes the hash of an IndexedSeq. Potential range hashes are recognized to produce a * hash that is compatible with rangeHash. + * + * @param a the indexed sequence to hash + * @param seed the initial seed for the hash computation */ final def indexedSeqHash(a: scala.collection.IndexedSeq[Any], seed: Int): Int = { var h = seed @@ -291,6 +334,9 @@ private[hashing] class MurmurHash3 { /** Computes the hash of a List. Potential range hashes are recognized to produce a * hash that is compatible with rangeHash. + * + * @param xs the list to hash + * @param seed the initial seed for the hash computation */ final def listHash(xs: scala.collection.immutable.List[?], seed: Int): Int = { var n = 0 @@ -393,13 +439,20 @@ object MurmurHash3 extends MurmurHash3 { * scala> MurmurHash3.caseClassHash(C(1), "C") * val res2: Int = -668012062 * ``` + * + * @param x the case class instance to hash + * @param caseClassName the case class name to use for hashing, or `null` to use `x.productPrefix` + * @return the hash code, equivalent to the synthetic `hashCode` when `caseClassName` matches the declared class name */ def caseClassHash(x: Product, caseClassName: String | Null = null): Int = caseClassHash(x, productSeed, caseClassName) private[scala] def arraySeqHash[@specialized T](a: Array[T]): Int = arrayHash(a, seqSeed) private[scala] def tuple2Hash(x: Any, y: Any): Int = tuple2Hash(x.##, y.##, productSeed) - /** To offer some potential for optimization. */ + /** To offer some potential for optimization. + * + * @param xs the sequence to hash (dispatches to specialized implementations for `IndexedSeq` and `List`) + */ def seqHash(xs: scala.collection.Seq[?]): Int = xs match { case xs: scala.collection.IndexedSeq[?] => indexedSeqHash(xs, seqSeed) case xs: List[?] => listHash(xs, seqSeed) diff --git a/library/src/scala/util/hashing/package.scala b/library/src/scala/util/hashing/package.scala index 7898ac713caa..825c0acb3337 100644 --- a/library/src/scala/util/hashing/package.scala +++ b/library/src/scala/util/hashing/package.scala @@ -17,7 +17,10 @@ import scala.language.`2.13` package object hashing { - /** Fast multiplicative hash with a nice distribution. */ + /** Fast multiplicative hash with a nice distribution. + * + * @param v the 32-bit `Int` value to hash + */ def byteswap32(v: Int): Int = { var hc = v * 0x9e3775cd hc = java.lang.Integer.reverseBytes(hc) @@ -26,6 +29,8 @@ package object hashing { /** Fast multiplicative hash with a nice distribution * for 64-bit values. + * + * @param v the 64-bit `Long` value to hash */ def byteswap64(v: Long): Long = { var hc = v * 0x9e3775cd9e3775cdL diff --git a/library/src/scala/util/matching/Regex.scala b/library/src/scala/util/matching/Regex.scala index 39089f7cf2db..65268eab4c72 100644 --- a/library/src/scala/util/matching/Regex.scala +++ b/library/src/scala/util/matching/Regex.scala @@ -44,7 +44,7 @@ import java.util.regex.{ Pattern, Matcher } * The canonical way to create a `Regex` is by using the method `r`, provided * implicitly for strings: * - * ``` + * ```scala sc:compile sc-name:date-pattern * val date = raw"(\d{4})-(\d{2})-(\d{2})".r * ``` * @@ -57,7 +57,7 @@ import java.util.regex.{ Pattern, Matcher } * To extract the capturing groups when a `Regex` is matched, use it as * an extractor in a pattern match: * - * ``` + * ```scala sc:compile sc-compile-with:date-pattern * "2004-01-20" match { * case date(year, month, day) => s"\$year was a good year for PLs." * } @@ -66,7 +66,7 @@ import java.util.regex.{ Pattern, Matcher } * To check only whether the `Regex` matches, ignoring any groups, * use a sequence wildcard: * - * ``` + * ```scala sc:compile sc-compile-with:date-pattern * "2004-01-20" match { * case date(_*) => "It's a date!" * } @@ -76,7 +76,7 @@ import java.util.regex.{ Pattern, Matcher } * Extracting only the year from a date could also be expressed with * a sequence wildcard: * - * ``` + * ```scala sc:compile sc-compile-with:date-pattern * "2004-01-20" match { * case date(year, _*) => s"\$year was a good year for PLs." * } @@ -86,7 +86,7 @@ import java.util.regex.{ Pattern, Matcher } * However, an unanchored `Regex` finds the pattern anywhere * in the input. * - * ``` + * ```scala sc:compile sc-compile-with:date-pattern * val embeddedDate = date.unanchored * "Date: 2004-01-20 17:25:18 GMT (10 years, 28 weeks, 5 days, 17 hours and 51 minutes ago)" match { * case embeddedDate("2004", "01", "20") => "A Scala is born." @@ -102,7 +102,7 @@ import java.util.regex.{ Pattern, Matcher } * can also be accomplished using `findFirstMatchIn`. The `findFirst` methods return an `Option` * which is non-empty if a match is found, or `None` for no match: * - * ``` + * ```scala sc:compile sc-compile-with:date-pattern * val dates = "Important dates in history: 2004-01-20, 1958-09-05, 2010-10-06, 2011-07-15" * val firstDate = date.findFirstIn(dates).getOrElse("No date found.") * val firstYear = for (m <- date.findFirstMatchIn(dates)) yield m.group(1) @@ -110,13 +110,14 @@ import java.util.regex.{ Pattern, Matcher } * * To find all matches: * - * ``` + * ```scala sc:compile sc-compile-with:date-pattern + * val dates = "Important dates in history: 2004-01-20, 1958-09-05, 2010-10-06, 2011-07-15" * val allYears = for (m <- date.findAllMatchIn(dates)) yield m.group(1) * ``` * * To check whether input is matched by the regex: * - * ``` + * ```scala sc:compile sc-compile-with:date-pattern * date.matches("2018-03-01") // true * date.matches("Today is 2018-03-01") // false * date.unanchored.matches("Today is 2018-03-01") // true @@ -125,7 +126,8 @@ import java.util.regex.{ Pattern, Matcher } * To iterate over the matched strings, use `findAllIn`, which returns a special iterator * that can be queried for the `MatchData` of the last match: * - * ``` + * ```scala sc:compile sc-compile-with:date-pattern + * val dates = "Important dates in history: 2004-01-20, 1958-09-05, 2010-10-06, 2011-07-15" * val mi = date.findAllIn(dates) * while (mi.hasNext) { * val d = mi.next @@ -138,7 +140,7 @@ import java.util.regex.{ Pattern, Matcher } * side effect of advancing the underlying matcher to the next unconsumed match. * This effect is visible in the `MatchData` representing the "current match". * - * ``` + * ```scala sc:compile * val r = "(ab+c)".r * val s = "xxxabcyyyabbczzz" * r.findAllIn(s).start // 3 @@ -162,7 +164,7 @@ import java.util.regex.{ Pattern, Matcher } * * Note that `findAllIn` finds matches that don't overlap. (See [[findAllIn]] for more examples.) * - * ``` + * ```scala sc:compile * val num = raw"(\d+)".r * val all = num.findAllIn("123").toList // List("123"), not List("123", "23", "3") * ``` @@ -170,7 +172,10 @@ import java.util.regex.{ Pattern, Matcher } * ### Replace Text * Text replacement can be performed unconditionally or as a function of the current match: * - * ``` + * ```scala sc:compile + * import java.util.Calendar + * val date = raw"(\d{4})-(\d{2})-(\d{2})".r + * val dates = "Important dates in history: 2004-01-20, 1958-09-05, 2010-10-06, 2011-07-15" * val redacted = date.replaceAllIn(dates, "XXXX-XX-XX") * val yearsOnly = date.replaceAllIn(dates, m => m.group(1)) * val months = (0 to 11).map { i => val c = Calendar.getInstance; c.set(2014, i, 1); f"\$c%tb" } @@ -181,7 +186,9 @@ import java.util.regex.{ Pattern, Matcher } * In the expression for `reformatted`, each `date` match is computed once. But it is possible to apply a * `Regex` to a `Match` resulting from a different pattern: * - * ``` + * ```scala sc:compile + * val date = raw"(\d{4})-(\d{2})-(\d{2})".r + * val dates = "Important dates in history: 2004-01-20, 1958-09-05, 2010-10-06, 2011-07-15" * val docSpree = """2011(?:-\d{2}){2}""".r * val docView = date.replaceAllIn(dates, _ match { * case docSpree() => "Historic doc spree!" @@ -213,11 +220,11 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * * If group names are supplied, they can be used this way: * - * ``` + * ```scala sc:compile * val namedDate = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") + * val dates = "Important dates in history: 2004-01-20, 1958-09-05, 2010-10-06, 2011-07-15" * val namedYears = for (m <- namedDate findAllMatchIn dates) yield m group "year" - * ``` - * + * ``` * * Inline group names are preferred over group names supplied to the constructor * when retrieving matched groups by name. Group names supplied to the constructor * should be considered deprecated. @@ -244,7 +251,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * * For example: * - * ``` + * ```scala sc:compile * val p1 = "ab*c".r * val p1Matches = "abbbc" match { * case p1() => true // no groups @@ -295,7 +302,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * * For example: * - * ``` + * ```scala sc:compile * val cat = "cat" * // the case must consume the group to match * val r = """(\p{Lower})""".r @@ -305,18 +312,17 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * cat(0) match { case r() => true } // no match * * // there is no group to extract - * val r = """\p{Lower}""".r - * cat(0) match { case r(x) => true } // no match - * cat(0) match { case r(_) => true } // no match - * cat(0) match { case r(_*) => true } // matches - * cat(0) match { case r() => true } // matches + * val r2 = """\p{Lower}""".r + * cat(0) match { case r2(x) => true } // no match + * cat(0) match { case r2(_) => true } // no match + * cat(0) match { case r2(_*) => true } // matches + * cat(0) match { case r2() => true } // matches * * // even if there are multiple groups, only one is returned - * val r = """((.))""".r - * cat(0) match { case r(_) => true } // matches - * cat(0) match { case r(_,_) => true } // no match + * val r3 = """((.))""".r + * cat(0) match { case r3(_) => true } // matches + * cat(0) match { case r3(_,_) => true } // no match * ``` - * * @param c The Char to match * @return The match */ @@ -335,6 +341,9 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * * Otherwise, this Regex is applied to the previously matched input, * and the result of that match is used. + * + * @param m the `Match` to extract groups from + * @return the matched groups, or `None` if the match was unsuccessful */ def unapplySeq(m: Match): Option[List[String | Null]] = if (m.matched == null) None @@ -358,7 +367,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * followed by the next match that follows the input consumed by the * first match: * - * ``` + * ```scala sc:compile * val hat = "hat[^a]+".r * val hathaway = "hathatthattthatttt" * val hats = hat.findAllIn(hathaway).toList // List(hath, hattth) @@ -368,8 +377,9 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * To return overlapping matches, it is possible to formulate a regular expression * with lookahead (`?=`) that does not consume the overlapping region. * - * ``` + * ```scala sc:compile * val madhatter = "(h)(?=(at[^a]+))".r + * val hathaway = "hathatthattthatttt" * val madhats = madhatter.findAllMatchIn(hathaway).map { * case madhatter(x,y) => s"\$x\$y" * }.toList // List(hath, hatth, hattth, hatttt) @@ -391,7 +401,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * @param source The text to match against. * @return A [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]] for all matches. * @example - * ``` + * ```scala sc:compile * for (words <- """\w+""".r findAllMatchIn "A simple example.") yield words.start * ``` */ @@ -412,7 +422,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * @param source The text to match against. * @return An [[scala.Option]] of the first matching string in the text. * @example - * ``` + * ```scala sc:compile * """\w+""".r findFirstIn "A simple example." foreach println // prints "A" * ``` */ @@ -430,7 +440,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * @param source The text to match against. * @return A [[scala.Option]] of [[scala.util.matching.Regex.Match]] of the first matching string in the text. * @example - * ``` + * ```scala sc:compile * ("""[a-z]""".r findFirstMatchIn "A simple example.") map (_.start) // returns `Some(2)`, the index of the first match in the text * ``` */ @@ -449,7 +459,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * @param source The text to match against. * @return A [[scala.Option]] of the matched prefix. * @example - * ``` + * ```scala sc:compile * """\p{Lower}""".r findPrefixOf "A simple example." // returns `None`, since the text does not begin with a lowercase letter * ``` */ @@ -468,7 +478,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * @param source The text to match against. * @return A [[scala.Option]] of the [[scala.util.matching.Regex.Match]] of the matched string. * @example - * ``` + * ```scala sc:compile * """\w+""".r findPrefixMatchOf "A simple example." map (_.after) // returns `Some(" simple example.")` * ``` */ @@ -485,7 +495,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * @return true if and only if `source` matches this `Regex`. * @see [[Regex#unanchored]] * @example - * ``` + * ```scala sc:compile * """\d+""".r matches "123" // returns true * ``` */ @@ -500,7 +510,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * @param replacement The string that will replace each match * @return The resulting string * @example - * ``` + * ```scala sc:compile * """\d+""".r replaceAllIn ("July 15", "") // returns "July " * ``` */ @@ -513,7 +523,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * [[scala.util.matching.Regex.Match]] so that extra information can be obtained * from the match. For example: * - * ``` + * ```scala sc:compile * import scala.util.matching.Regex * val datePattern = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") * val text = "From 2011-07-15 to 2011-07-17" @@ -537,7 +547,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * The replacer function takes a [[scala.util.matching.Regex.Match]] so that extra * information can be obtained from the match. For example: * - * ``` + * ```scala sc:compile * import scala.util.matching.Regex._ * * val vars = Map("x" -> "a var", "y" -> """some \$ and \ signs""") @@ -594,7 +604,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * * Calling `anchored` returns the original `Regex`. * - * ``` + * ```scala sc:compile * val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored * * val date(year, month, day) = "Date 2011-07-15" // OK @@ -655,6 +665,8 @@ object Regex { /** The index of the first matched character in group `i`, * or -1 if nothing was matched for that group. + * + * @param i the index of the capturing group */ def start(i: Int): Int @@ -663,6 +675,8 @@ object Regex { /** The index following the last matched character in group `i`, * or -1 if nothing was matched for that group. + * + * @param i the index of the capturing group */ def end(i: Int): Int @@ -673,6 +687,8 @@ object Regex { /** The matched string in group `i`, * or `null` if nothing was matched. + * + * @param i the index of the capturing group */ def group(i: Int): String | Null = if (start(i) >= 0) source.subSequence(start(i), end(i)).toString @@ -690,6 +706,8 @@ object Regex { /** The char sequence before first character of match in group `i`, * or `null` if nothing was matched for that group. + * + * @param i the index of the capturing group */ def before(i: Int): CharSequence | Null = if (start(i) >= 0) source.subSequence(0, start(i)) @@ -704,6 +722,8 @@ object Regex { /** The char sequence after last character of match in group `i`, * or `null` if nothing was matched for that group. + * + * @param i the index of the capturing group */ def after(i: Int): CharSequence | Null = if (end(i) >= 0) source.subSequence(end(i), source.length) @@ -739,7 +759,11 @@ object Regex { override def toString(): String = matched.nn } - /** Provides information about a successful match. */ + /** Provides information about a successful match. + * + * @param source the source character sequence that was matched against + * @param matcher the underlying `Matcher` that performed the match + */ class Match(val source: CharSequence, protected[matching] val matcher: Matcher, _groupNames: Seq[String]) extends MatchData { @@ -761,10 +785,16 @@ object Regex { private lazy val ends: Array[Int] = Array.tabulate(groupCount + 1) { matcher.end } - /** The index of the first matched character in group `i`. */ + /** The index of the first matched character in group `i`. + * + * @param i the index of the capturing group + */ def start(i: Int): Int = starts(i) - /** The index following the last matched character in group `i`. */ + /** The index following the last matched character in group `i`. + * + * @param i the index of the capturing group + */ def end(i: Int): Int = ends(i) /** The match itself with matcher-dependent lazy vals forced, @@ -778,7 +808,7 @@ object Regex { * This can be used to help writing replacer functions when you * are not interested in match data. For example: * - * ``` + * ```scala sc:compile * import scala.util.matching.Regex.Match * """\w+""".r replaceAllIn ("A simple example.", _ match { case Match(s) => s.toUpperCase }) * ``` @@ -790,7 +820,7 @@ object Regex { /** An extractor object that yields the groups in the match. Using this extractor * rather than the original `Regex` ensures that the match is not recomputed. * - * ``` + * ```scala sc:compile * import scala.util.matching.Regex.Groups * * val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r @@ -818,6 +848,10 @@ object Regex { * [[java.lang.IllegalStateException]]. * * @see [[java.util.regex.Matcher]] + * + * @param source the character sequence being matched against + * @param regex the `Regex` whose pattern is used for matching + * @param _groupNames the names of the capturing groups, if any */ class MatchIterator(val source: CharSequence, val regex: Regex, private[Regex] val _groupNames: Seq[String]) extends AbstractIterator[String] with MatchData { self => @@ -871,13 +905,19 @@ object Regex { /** The index of the first matched character. */ def start: Int = { ensure() ; matcher.start } - /** The index of the first matched character in group `i`. */ + /** The index of the first matched character in group `i`. + * + * @param i the index of the capturing group + */ def start(i: Int): Int = { ensure() ; matcher.start(i) } /** The index of the last matched character. */ def end: Int = { ensure() ; matcher.end } - /** The index following the last matched character in group `i`. */ + /** The index following the last matched character in group `i`. + * + * @param i the index of the capturing group + */ def end(i: Int): Int = { ensure() ; matcher.end(i) } /** The number of subgroups. */ @@ -918,9 +958,12 @@ object Regex { * All regex metacharacters in the input match themselves literally in the output. * * @example - * ``` + * ```scala sc:compile * List("US\$", "CAN\$").map(Regex.quote).mkString("|").r * ``` + * + * @param text the string to quote as a literal pattern + * @return a regex pattern string that matches `text` literally */ def quote(text: String): String = Pattern.quote(text) @@ -935,7 +978,7 @@ object Regex { * @param text The string one wishes to use as literal replacement. * @return A string that can be used to replace matches with `text`. * @example - * ``` + * ```scala sc:compile * "CURRENCY".r.replaceAllIn(input, Regex quoteReplacement "US\$") * ``` */ diff --git a/library/src/scala/util/package.scala b/library/src/scala/util/package.scala index 7d1fe27bdde8..9c45e2ae5df7 100644 --- a/library/src/scala/util/package.scala +++ b/library/src/scala/util/package.scala @@ -13,6 +13,7 @@ package scala import scala.language.`2.13` +import language.experimental.captureChecking package object util { /** diff --git a/library/test/scala/collection/IteratorProperties.scala b/library/test/scala/collection/IteratorProperties.scala index f1b495fad175..9f4156972c8d 100644 --- a/library/test/scala/collection/IteratorProperties.scala +++ b/library/test/scala/collection/IteratorProperties.scala @@ -19,19 +19,19 @@ object IteratorProperties extends Properties("Iterator") { property("take") = check(_ take _) property("takeRight") = check((it, n) => it match { - case it: Iterable[Int] => it.takeRight(n) - case it: Iterator[Int] => View.takeRightIterator(it, n) + case it: Iterable[Int @unchecked] => it.takeRight(n) + case it: Iterator[Int @unchecked] => View.takeRightIterator(it, n) case x => throw new MatchError(x) }) property("drop") = check(_ drop _) property("dropRight") = check((it, n) => it match { - case it: Iterable[Int] => it.dropRight(n) - case it: Iterator[Int] => View.dropRightIterator(it, n) + case it: Iterable[Int @unchecked] => it.dropRight(n) + case it: Iterator[Int @unchecked] => View.dropRightIterator(it, n) case x => throw new MatchError(x) }) property("patch") = check((it, n) => it match { - case it: Iterable[Int] => it.iterator.patch(1, Iterator.empty, n) - case it: Iterator[Int] => it.patch(1, Iterator.empty, n) + case it: Iterable[Int @unchecked] => it.iterator.patch(1, Iterator.empty, n) + case it: Iterator[Int @unchecked] => it.patch(1, Iterator.empty, n) case x => throw new MatchError(x) }) diff --git a/library/test/scala/collection/MapTest.scala b/library/test/scala/collection/MapTest.scala index d5f6df087e8b..45a5cfcf0862 100644 --- a/library/test/scala/collection/MapTest.scala +++ b/library/test/scala/collection/MapTest.scala @@ -87,7 +87,7 @@ class MapTest { assertEquals(1, i) m match { - case im: immutable.Map[Int, Int] => + case im: immutable.Map[Int @unchecked, Int @unchecked] => checkImmutable(im) case _ => () diff --git a/library/test/scala/collection/immutable/RangeProps.scala b/library/test/scala/collection/immutable/RangeProps.scala index 2a05638994e6..eb443f65b8e8 100644 --- a/library/test/scala/collection/immutable/RangeProps.scala +++ b/library/test/scala/collection/immutable/RangeProps.scala @@ -162,7 +162,7 @@ abstract class RangeProps(kind: String) extends Properties("Range "+kind) { def compare(x: Int, y: Int): Int = ??? } - val rSum = r.sum(mynum) + val rSum = r.sum(using mynum) val expected = mynum.toInt(r.sum) (rSum == expected) :| str(r) @@ -238,7 +238,7 @@ object NormalRangeTest extends RangeProps("normal") { start <- arbitrary[Int] end <- arbitrary[Int] if (start.toLong - end.toLong).abs < Int.MaxValue.toLong - } yield Range(start, end, if (start < end) 1 else - 1) + } yield Range(start, end, if (start < end) 1 else -1) property("by 1.size + 1 == inclusive.size") = forAll(genOne) { r => (r.size + 1 == r.inclusive.size) :| str(r) } diff --git a/library/test/scala/collection/immutable/RedBlackTreeProps.scala b/library/test/scala/collection/immutable/RedBlackTreeProps.scala index 9d1dcbe5dc5a..68d2365c199a 100644 --- a/library/test/scala/collection/immutable/RedBlackTreeProps.scala +++ b/library/test/scala/collection/immutable/RedBlackTreeProps.scala @@ -97,12 +97,14 @@ trait RedBlackTreeInvariants[K, V] { case RedTree(_, _, left, right) => List(left, right).forall(t => isBlack(t) && areRedNodeChildrenBlack(t)) case BlackTree(_, _, left, right) => List(left, right).forall(areRedNodeChildrenBlack) case null => true + case _ => assert(false, "unreachable") } def blackNodesToLeaves[A](t: Tree[K, V] | Null): List[Int] = t match { case null => List(1) case BlackTree(_, _, left, right) => List(left, right).flatMap(blackNodesToLeaves).map(_ + 1) case RedTree(_, _, left, right) => List(left, right).flatMap(blackNodesToLeaves) + case _ => assert(false, "unreachable") } def areBlackNodesToLeavesEqual[A](t: Tree[K, V] | Null): Boolean = t match { diff --git a/library/test/scala/lang/RicherTest.scala b/library/test/scala/lang/RicherTest.scala index ccf707dea0d9..49f20b1e31a3 100644 --- a/library/test/scala/lang/RicherTest.scala +++ b/library/test/scala/lang/RicherTest.scala @@ -24,7 +24,7 @@ class RicherTest { assertEqualTo("1" * 24 + x"1000_0000")(extended.toBinaryString) assertEqualTo(x"ffff_ff80")(extended.toHexString) assertEqualTo("37777777600")(extended.toOctalString) - val neg = -1.toByte.toInt + val neg = (-1).toByte.toInt assertEqualTo("1" * 32)(neg.toBinaryString) assertEqualTo("f" * 8)(neg.toHexString) assertEqualTo("3" + "7" * 10)(neg.toOctalString) @@ -42,7 +42,7 @@ class RicherTest { assertEqualTo(x"1111_1111_1111_1111_1000_0000_0000_0000")(extended.toBinaryString) assertEqualTo(x"ffff_8000")(extended.toHexString) assertEqualTo(x"37777700000")(extended.toOctalString) - val neg = -1.toShort.toInt + val neg = (-1).toShort.toInt assertEqualTo("1" * 32)(neg.toBinaryString) assertEqualTo(x"ffff_ffff")(neg.toHexString) assertEqualTo(x"37777777777")(neg.toOctalString) @@ -61,7 +61,7 @@ class RicherTest { assertEqualTo(x"1000_0000_0000_0000")(extended.toBinaryString) assertEqualTo("8000")(extended.toHexString) assertEqualTo(x"10_0000")(extended.toOctalString) - val neg = -1.toChar.toInt + val neg = (-1).toChar.toInt assertEqualTo("1" * 16)(neg.toBinaryString) assertEqualTo("ffff")(neg.toHexString) assertEqualTo(x"17_7777")(neg.toOctalString) @@ -83,7 +83,7 @@ class RicherTest { assertEqualTo("10")(16.toHexString) assertEqualTo("20")(16.toOctalString) assertEqualTo("10001")(65537.toHexString) - assertEqualTo("f" * 8)(-1.toHexString) + assertEqualTo("f" * 8)((-1).toHexString) } // see also StringLikeTest diff --git a/library/test/scala/math/DoubleTest.scala b/library/test/scala/math/DoubleTest.scala index d0ff619eea7e..cd01c617b6b4 100644 --- a/library/test/scala/math/DoubleTest.scala +++ b/library/test/scala/math/DoubleTest.scala @@ -15,7 +15,7 @@ class DoubleTest { assertEquals(doubleToLongBits(-1.0), doubleToLongBits(Double.MinValue.sign)) assertEquals(doubleToLongBits(-1.0), doubleToLongBits(Double.NegativeInfinity.sign)) assertEquals(doubleToLongBits(0.0), doubleToLongBits(0.0.sign)) - assertEquals(doubleToLongBits(-0.0), doubleToLongBits(-0.0.sign)) + assertEquals(doubleToLongBits(-0.0), doubleToLongBits((-0.0).sign)) } @deprecated("Tests deprecated API", since="2.13") @@ -27,6 +27,6 @@ class DoubleTest { assertEquals(-1, Double.MinValue.signum) assertEquals(-1, Double.NegativeInfinity.signum) assertEquals(0, 0.0.signum) - assertEquals(0, -0.0.signum) + assertEquals(0, (-0.0).signum) } } diff --git a/library/test/scala/math/NumericTest.scala b/library/test/scala/math/NumericTest.scala index 5365112fd770..83c5c67edb8a 100644 --- a/library/test/scala/math/NumericTest.scala +++ b/library/test/scala/math/NumericTest.scala @@ -8,8 +8,8 @@ class NumericTest { /* Test for scala/bug#8102 */ @Test def testAbs(): Unit = { - assertTrue(-0.0.abs.equals(0.0)) - assertTrue(-0.0f.abs.equals(0.0f)) + assertTrue((-0.0).abs.equals(0.0)) + assertTrue((-0.0f).abs.equals(0.0f)) } /* Test for scala/bug#9348 */ diff --git a/library/test/scala/math/OrderingTest.scala b/library/test/scala/math/OrderingTest.scala index ea5228472d01..edcdfdef76f5 100644 --- a/library/test/scala/math/OrderingTest.scala +++ b/library/test/scala/math/OrderingTest.scala @@ -70,8 +70,8 @@ class OrderingTest { } checkAll[Unit](()) checkAll[Boolean](true, false) - checkAll[Byte](Byte.MinValue, -1.toByte, 0.toByte, 1.toByte, Byte.MaxValue) - checkAll[Char](Char.MinValue, -1.toChar, 0.toChar, 1.toChar, Char.MaxValue) + checkAll[Byte](Byte.MinValue, (-1).toByte, 0.toByte, 1.toByte, Byte.MaxValue) + checkAll[Char](Char.MinValue, (-1).toChar, 0.toChar, 1.toChar, Char.MaxValue) checkAll[Short](Short.MinValue, -1, 0, 1, Short.MaxValue) checkAll[Int](Int.MinValue, -1, 0, 1, Int.MaxValue) checkAll[Double](doubles*) diff --git a/library/test/scala/runtime/BoxesRunTimeTest.scala b/library/test/scala/runtime/BoxesRunTimeTest.scala new file mode 100644 index 000000000000..b8c99e875ebe --- /dev/null +++ b/library/test/scala/runtime/BoxesRunTimeTest.scala @@ -0,0 +1,9 @@ +package scala.runtime + +import org.junit.Assert.* +import org.junit.Test + +class BoxesRunTimeTest { + @Test def `compare null Num and Char`: Unit = + assertFalse("null", BoxesRunTime.equalsNumChar(null, 'A')) +} diff --git a/out/.keep b/out/.keep new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/presentation-compiler/src/main/dotty/tools/pc/ApplyArgsExtractor.scala b/presentation-compiler/src/main/dotty/tools/pc/ApplyArgsExtractor.scala index 094cd66ea17c..34266eb7244f 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/ApplyArgsExtractor.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/ApplyArgsExtractor.scala @@ -14,7 +14,6 @@ import dotty.tools.dotc.core.Names.Name import dotty.tools.dotc.core.StdNames.* import dotty.tools.dotc.core.Symbols.NoSymbol import dotty.tools.dotc.core.Symbols.Symbol -import dotty.tools.dotc.core.Symbols.defn import dotty.tools.dotc.core.SymDenotations.NoDenotation import dotty.tools.dotc.core.Types.* import dotty.tools.dotc.util.Spans.Span @@ -82,7 +81,7 @@ object ApplyArgsExtractor: method match case Ident(name) => indexedContext.findSymbol(name).getOrElse(Nil) case Select(This(_), name) => indexedContext.findSymbol(name).getOrElse(Nil) - case sel @ Select(from, name) => + case Select(from, name) => val symbol = from.symbol val ownerSymbol = if symbol.is(Method) && symbol.owner.isClass then diff --git a/presentation-compiler/src/main/dotty/tools/pc/AutoImports.scala b/presentation-compiler/src/main/dotty/tools/pc/AutoImports.scala index 8025b5aaf43a..23de25921d5c 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/AutoImports.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/AutoImports.scala @@ -9,7 +9,6 @@ import dotty.tools.dotc.ast.tpd.* import dotty.tools.dotc.core.Comments.Comment import dotty.tools.dotc.core.Contexts.* import dotty.tools.dotc.core.Flags.* -import dotty.tools.dotc.core.Names.* import dotty.tools.dotc.core.Symbols.* import dotty.tools.dotc.util.SourcePosition import dotty.tools.dotc.util.Spans @@ -37,7 +36,7 @@ object AutoImports: case class Select(qual: SymbolIdent, name: String) extends SymbolIdent: def value: String = s"${qual.value}.$name" - def direct(name: String)(using Context): SymbolIdent = Direct(name) + def direct(name: String): SymbolIdent = Direct(name) def fullIdent(symbol: Symbol)(using Context): SymbolIdent = val symbols = symbol.ownersIterator.toList @@ -67,7 +66,7 @@ object AutoImports: importSel: Option[ImportSel] ): - def name(using Context): String = ident.value + def name: String = ident.value object SymbolImport: @@ -222,10 +221,6 @@ object AutoImports: ) case None => - val reverse = symbol.ownersIterator.toList.reverse - val fullName = reverse.drop(1).foldLeft(SymbolIdent.direct(reverse.head.nameBackticked)) { - case (acc, sym) => SymbolIdent.Select(acc, sym.nameBackticked(false)) - } SymbolImport( symbol, SymbolIdent.Direct(symbol.fullNameBackticked), @@ -365,9 +360,9 @@ object AutoImports: case None => val scriptOffset = if path.isAmmoniteGeneratedFile - then ScriptFirstImportPosition.ammoniteScStartOffset(text, comments) + then ScriptFirstImportPosition.ammoniteScStartOffset(comments) else if path.isScalaCLIGeneratedFile - then ScriptFirstImportPosition.scalaCliScStartOffset(text, comments) + then ScriptFirstImportPosition.scalaCliScStartOffset(comments) else Some(skipUsingDirectivesOffset(tmpl.span.start)) scriptOffset.getOrElse { diff --git a/presentation-compiler/src/main/dotty/tools/pc/AutoImportsProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/AutoImportsProvider.scala index fc0db9f9dc59..8e79b2f046e7 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/AutoImportsProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/AutoImportsProvider.scala @@ -1,6 +1,7 @@ package dotty.tools.pc import java.nio.file.Paths +import java.util.Optional import scala.collection.mutable import scala.jdk.CollectionConverters.* @@ -43,10 +44,7 @@ final class AutoImportsProvider( val newctx = driver.currentCtx.fresh.setCompilationUnit(unit) val path = Interactive.pathTo(newctx.compilationUnit.tpdTree, pos.span)(using newctx) - - val indexedContext = IndexedContext(pos)( - using Interactive.contextOfPath(path)(using newctx) - ) + val indexedContext = IndexedContext(pos, path, newctx) import indexedContext.ctx def correctInTreeContext(sym: Symbol) = path match @@ -108,7 +106,8 @@ final class AutoImportsProvider( yield ( AutoImportsResultImpl( sym.owner.showFullName, - edits.asJava + edits.asJava, + Optional.of(SemanticdbSymbols.symbolName(sym)) ), sym ) diff --git a/presentation-compiler/src/main/dotty/tools/pc/CachingDriver.scala b/presentation-compiler/src/main/dotty/tools/pc/CachingDriver.scala index 0a7f1aab6ae0..352157bd8fb7 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/CachingDriver.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/CachingDriver.scala @@ -1,11 +1,19 @@ package dotty.tools.pc +import java.io.File import java.net.URI +import java.nio.file.Path import java.util as ju import scala.compiletime.uninitialized +import scala.jdk.CollectionConverters.* +import scala.meta.pc.SemanticdbFileManager +import scala.meta.pc.SourcePathMode import dotty.tools.dotc.interactive.InteractiveDriver +import dotty.tools.dotc.interactive.LogicalPackage +import dotty.tools.dotc.interactive.LogicalPackagesProvider +import dotty.tools.dotc.interactive.ParsedLogicalPackage import dotty.tools.dotc.reporting.Diagnostic import dotty.tools.dotc.util.SourceFile @@ -27,7 +35,10 @@ import dotty.tools.dotc.util.SourceFile * the complexity related to currentCtx, we decided to cache only when the * target URI only if the same as the previous run. */ -class CachingDriver(override val settings: List[String]) extends InteractiveDriver(settings): +class CachingDriver private ( + override val settings: List[String], + precomputedSourcePackages: Option[LogicalPackage] +) extends InteractiveDriver(settings, precomputedSourcePackages): private var lastCompiledURI: URI = uninitialized private var previousDiags = List.empty[Diagnostic] @@ -46,3 +57,20 @@ class CachingDriver(override val settings: List[String]) extends InteractiveDriv previousDiags end CachingDriver + +object CachingDriver: + def apply( + settings: List[String], + sourcePath: ju.function.Supplier[ju.List[Path]], + semanticdbFileManager: SemanticdbFileManager, + sourcePathMode: SourcePathMode + ): CachingDriver = + val precomputedSourcePackages = sourcePathMode match + case SourcePathMode.DISABLED => None + case SourcePathMode.PRUNED | SourcePathMode.FULL => + val sourcePathFiles = sourcePath.get().asScala.toSeq + val logicalSourcePath = sourcePathFiles.mkString(File.pathSeparator) + if sourcePathFiles.nonEmpty then Some(new LogicalPackagesProvider(logicalSourcePath).root) else None + case SourcePathMode.MBT => + Some(ParsedLogicalPackage.fromMbtIndex(semanticdbFileManager.listAllPackages())) + new CachingDriver(settings, precomputedSourcePackages) diff --git a/presentation-compiler/src/main/dotty/tools/pc/CompletionItemResolver.scala b/presentation-compiler/src/main/dotty/tools/pc/CompletionItemResolver.scala index 595c5f1b0c65..1a63627a303b 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/CompletionItemResolver.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/CompletionItemResolver.scala @@ -2,7 +2,6 @@ package dotty.tools.pc import scala.meta.internal.pc.ItemResolver import scala.meta.pc.PresentationCompilerConfig -import scala.meta.pc.SymbolDocumentation import scala.meta.pc.SymbolSearch import dotty.tools.dotc.core.Contexts.Context @@ -61,7 +60,7 @@ object CompletionItemResolver extends ItemResolver: fullDocstring(gsym.info.deepDealiasAndSimplify.typeSymbol, search) else if gsym.is(Method) then gsym.info.finalResultType match - case tr @ TermRef(_, sym) => + case tr: TermRef => fullDocstring(tr.symbol, search) case _ => "" diff --git a/presentation-compiler/src/main/dotty/tools/pc/ExtractMethodProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/ExtractMethodProvider.scala index 392e6726eb17..ee5d7c24b7e5 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/ExtractMethodProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/ExtractMethodProvider.scala @@ -6,13 +6,10 @@ import scala.meta.internal.pc.ExtractMethodUtils import scala.meta.pc.OffsetParams import scala.meta.pc.RangeParams import scala.meta.pc.SymbolSearch -import scala.meta.pc.reports.ReportContext -import scala.meta as m import dotty.tools.dotc.ast.Trees.* import dotty.tools.dotc.ast.tpd import dotty.tools.dotc.ast.tpd.DeepFolder -import dotty.tools.dotc.core.Contexts.* import dotty.tools.dotc.core.Flags import dotty.tools.dotc.core.Symbols.Symbol import dotty.tools.dotc.core.Types.MethodType @@ -35,8 +32,7 @@ final class ExtractMethodProvider( driver: InteractiveDriver, search: SymbolSearch, noIndent: Boolean -)(using ReportContext) - extends ExtractMethodUtils: +) extends ExtractMethodUtils: def extractMethod(): List[TextEdit] = val text = range.text().nn @@ -48,16 +44,15 @@ final class ExtractMethodProvider( val pos = driver.sourcePosition(range).startPos val path = Interactive.pathTo(driver.openedTrees(uri), pos)(using driver.currentCtx) - given locatedCtx: Context = - val newctx = driver.currentCtx.fresh.setCompilationUnit(unit) - Interactive.contextOfPath(path)(using newctx) - val indexedCtx = IndexedContext(pos)(using locatedCtx) + val newctx = driver.currentCtx.fresh.setCompilationUnit(unit) + val indexedContext = IndexedContext(pos, path, newctx) + import indexedContext.ctx val printer = - ShortenedTypePrinter(search, IncludeDefaultParam.Never)(using indexedCtx) + ShortenedTypePrinter(search, IncludeDefaultParam.Never)(using indexedContext) def prettyPrint(tpe: Type) = def prettyPrintReturnType(tpe: Type): String = tpe match - case mt: (MethodType | PolyType) => + case _: (MethodType | PolyType) => prettyPrintReturnType(tpe.resultType) case tpe => printer.tpe(tpe) def printParams(params: List[Type]) = @@ -135,7 +130,7 @@ final class ExtractMethodProvider( val extractedPos = head.sourcePos.withEnd(expr.sourcePos.end) val exprType = prettyPrint(expr.typeOpt.widen) val name = - genName(indexedCtx.scopeSymbols.map(_.decodedName).toSet, "newMethod") + genName(indexedContext.scopeSymbols.map(_.decodedName).toSet, "newMethod") val (allMethodParams, typeParams) = localRefs(extracted, stat.sourcePos, extractedPos) val (methodParams, implicitParams) = allMethodParams.partition(!_.isOneOf(Flags.GivenOrImplicit)) diff --git a/presentation-compiler/src/main/dotty/tools/pc/HoverProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/HoverProvider.scala index f5240fd96683..cae32298fdde 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/HoverProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/HoverProvider.scala @@ -11,12 +11,10 @@ import scala.meta.pc.SymbolSearch import scala.meta.pc.reports.ReportContext import dotty.tools.dotc.ast.tpd.* -import dotty.tools.dotc.ast.untpd.InferredTypeTree +import dotty.tools.dotc.ast.untpd import dotty.tools.dotc.core.Constants.* import dotty.tools.dotc.core.Contexts.* -import dotty.tools.dotc.core.Decorators.* import dotty.tools.dotc.core.Flags.* -import dotty.tools.dotc.core.Names.* import dotty.tools.dotc.core.StdNames import dotty.tools.dotc.core.StdNames.* import dotty.tools.dotc.core.Symbols.* @@ -50,7 +48,7 @@ object HoverProvider: val path = unit .map(unit => Interactive.pathTo(unit.tpdTree, pos.span)) .getOrElse(Interactive.pathTo(driver.openedTrees(uri), pos)) - val indexedContext = IndexedContext(pos)(using ctx) + val indexedContext = IndexedContext(pos, path, ctx) def typeFromPath(path: List[Tree]) = if path.isEmpty then NoType else path.head.typeOpt @@ -60,8 +58,80 @@ object HoverProvider: // For expression we need to find all enclosing applies to get the exact generic type val enclosing = path.expandRangeToEnclosingApply(pos) + lazy val printer = ShortenedTypePrinter(search, IncludeDefaultParam.Include)( + using indexedContext + ) + + def hoverSignature( + symbol: Symbol, + symbolTpes: Seq[(Symbol, Type, Option[String])], + tpe: Type + ): ju.Optional[HoverSignature] = { + val exprTpw = tpe.widenTermRefExpr.deepDealiasAndSimplify + val hoverString = + tpw match + // https://github.com/scala/scala3/issues/8891 + case tpw: ImportType => + printer.hoverSymbol(symbol, symbol.paramRef) + case _ => + val (innerTpe, sym) = + if symbol.isType then (symbol.typeRef, symbol) + else enclosing.head.seenFrom(symbol) + + val finalTpe = + if tpe.isNamedTupleType then tpe.widenTermRefExpr + else if innerTpe != NoType then innerTpe + else tpw + + printer.hoverSymbol(sym, finalTpe.deepDealiasAndSimplify) + end match + end hoverString + + val docString = symbolTpes + .flatMap(symTpe => search.symbolDocumentation(symTpe._1, contentType)) + .map(_.docstring()) + .mkString("\n") + + val expresionTypeOpt = + if symbol.name == StdNames.nme.??? then + InferExpectedType(search, driver, params).infer() + else printer.expressionType(exprTpw) + expresionTypeOpt match + case Some(expressionType) => + val forceExpressionType = + !pos.span.isZeroExtent || ( + !hoverString.endsWith(expressionType) && + !symbol.isType && + !symbol.is(Module) && + !symbol.flags.isAllOf(EnumCase) + ) + ju.Optional.of( + new ScalaHover( + expressionType = Some(expressionType), + symbolSignature = Some(hoverString), + docstring = Some(docString), + forceExpressionType = forceExpressionType, + contextInfo = printer.getUsedRenamesInfo, + contentType = contentType + ) + ).nn + case _ => + ju.Optional.empty().nn + } + if tp.isError || tpw == NoType || tpw.isError || path.isEmpty then + val untpdPath = Interactive.resolveTypedOrUntypedPath(enclosing, pos)(using ctx) + val derivesClauseSymbolOpt = untpdPath match + /* In case of `class X derives TC@@` we shouldn't add `[]` + */ + case Ident(_) :: (templ: untpd.DerivingTemplate) :: _ => + templ.derived.find(_.sourcePos.contains(pos)).collect { + case ident if ident.tpe != null => ident.symbol -> ident.tpe.nn + } + case _ => + None + def report = val posId = if path.isEmpty || !path.head.sourcePos.exists @@ -88,15 +158,19 @@ object HoverProvider: |""".stripMargin, s"$uri::$posId" ) - reportContext.unsanitized.create(() => report, /*ifVerbose =*/ true) - ju.Optional.empty().nn + + derivesClauseSymbolOpt match + case Some((symbol, tpe)) => + hoverSignature(symbol, List((symbol, tpe, None)), tpe) + case None => + reportContext.unsanitized.create(() => report, /*ifVerbose =*/ true) + ju.Optional.empty().nn else val skipCheckOnName = !pos.isPoint // don't check isHoveringOnName for RangeHover - val printerCtx = Interactive.contextOfPath(path) val printer = ShortenedTypePrinter(search, IncludeDefaultParam.Include)( - using IndexedContext(pos)(using printerCtx) + using indexedContext ) MetalsInteractive.enclosingSymbolsWithExpressionType( enclosing, @@ -106,60 +180,11 @@ object HoverProvider: ) match case Nil => fallbackToDynamics(path, printer, contentType) - case (symbol, tpe, _) :: _ + case (symbol, _, _) :: _ if symbol.name == nme.selectDynamic || symbol.name == nme.applyDynamic => fallbackToDynamics(path, printer, contentType) case symbolTpes @ ((symbol, tpe, None) :: _) => - val exprTpw = tpe.widenTermRefExpr.deepDealiasAndSimplify - val hoverString = - tpw match - // https://github.com/scala/scala3/issues/8891 - case tpw: ImportType => - printer.hoverSymbol(symbol, symbol.paramRef) - case _ => - val (innerTpe, sym) = - if symbol.isType then (symbol.typeRef, symbol) - else enclosing.head.seenFrom(symbol) - - val finalTpe = - if tpe.isNamedTupleType then tpe.widenTermRefExpr - else if innerTpe != NoType then innerTpe - else tpw - - printer.hoverSymbol(sym, finalTpe.deepDealiasAndSimplify) - end match - end hoverString - - val docString = symbolTpes - .flatMap(symTpe => search.symbolDocumentation(symTpe._1, contentType)) - .map(_.docstring()) - .mkString("\n") - - val expresionTypeOpt = - if symbol.name == StdNames.nme.??? then - InferExpectedType(search, driver, params).infer() - else printer.expressionType(exprTpw) - expresionTypeOpt match - case Some(expressionType) => - val forceExpressionType = - !pos.span.isZeroExtent || ( - !hoverString.endsWith(expressionType) && - !symbol.isType && - !symbol.is(Module) && - !symbol.flags.isAllOf(EnumCase) - ) - ju.Optional.of( - new ScalaHover( - expressionType = Some(expressionType), - symbolSignature = Some(hoverString), - docstring = Some(docString), - forceExpressionType = forceExpressionType, - contextInfo = printer.getUsedRenamesInfo, - contentType = contentType - ) - ).nn - case _ => - ju.Optional.empty().nn + hoverSignature(symbol, symbolTpes, tpe) case (_, tpe, Some(namedTupleArg)) :: _ => val exprTpw = tpe.widenTermRefExpr.deepDealiasAndSimplify printer.expressionType(exprTpw) match @@ -175,7 +200,6 @@ object HoverProvider: ) ).nn case _ => ju.Optional.empty().nn - end match end if end hover diff --git a/presentation-compiler/src/main/dotty/tools/pc/IndexedContext.scala b/presentation-compiler/src/main/dotty/tools/pc/IndexedContext.scala index 298ff8fe5435..0bb4d1e8a959 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/IndexedContext.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/IndexedContext.scala @@ -1,26 +1,26 @@ package dotty.tools.pc import scala.annotation.tailrec -import scala.util.control.NonFatal +import dotty.tools.dotc.ast.tpd import dotty.tools.dotc.core.Contexts.* import dotty.tools.dotc.core.Denotations.PreDenotation import dotty.tools.dotc.core.Denotations.SingleDenotation import dotty.tools.dotc.core.Flags.* -import dotty.tools.dotc.core.NameOps.* import dotty.tools.dotc.core.Names.* -import dotty.tools.dotc.core.Scopes.EmptyScope +import dotty.tools.dotc.core.Phases import dotty.tools.dotc.core.Symbols.* import dotty.tools.dotc.core.Types.* import dotty.tools.dotc.interactive.Completion +import dotty.tools.dotc.interactive.Completion.CompletionResult import dotty.tools.dotc.interactive.Interactive -import dotty.tools.dotc.typer.ImportInfo import dotty.tools.dotc.util.SourcePosition import dotty.tools.pc.IndexedContext.Result import dotty.tools.pc.utils.InteractiveEnrichments.* sealed trait IndexedContext: given ctx: Context + def scopeContext: CompletionResult def scopeSymbols: List[Symbol] def rename(sym: Symbol): Option[String] def findSymbol(name: Name, fromPrefix: Option[Type] = None): Option[List[Symbol]] @@ -36,7 +36,7 @@ sealed trait IndexedContext: case Some(symbols) if symbols.map(_.dealiasType).exists(isRelated) => Result.InScope case Some(symbols) if symbols.nonEmpty && symbols.forall(_.isStale) => Result.Missing case Some(symbols) if symbols.exists(rename(_).isEmpty) => Result.Conflict - case Some(symbols) => Result.InScope + case Some(_) => Result.InScope case _ => Result.Missing final def hasRename(sym: Symbol, as: String): Boolean = @@ -74,24 +74,28 @@ end IndexedContext object IndexedContext: - def apply(pos: SourcePosition)(using Context): IndexedContext = - ctx match + def apply(pos: SourcePosition, tpdPath: List[tpd.Tree], driverCtx: Context): IndexedContext = + driverCtx match case NoContext => Empty - case _ => LazyWrapper(pos)(using ctx) + case _ => + val typerCtx: Context = Interactive + .contextOfPath(tpdPath)(using driverCtx).withPhase(Phases.typerPhase(using driverCtx)) + LazyWrapper(pos, tpdPath)(using typerCtx) case object Empty extends IndexedContext: given ctx: Context = NoContext + def scopeContext: CompletionResult = CompletionResult(Map.empty, Map.empty) def findSymbol(name: Name, fromPrefix: Option[Type]): Option[List[Symbol]] = None def findSymbolInLocalScope(name: String): Option[List[Symbol]] = None def scopeSymbols: List[Symbol] = List.empty def rename(sym: Symbol): Option[String] = None - class LazyWrapper(pos: SourcePosition)(using val ctx: Context) extends IndexedContext: + class LazyWrapper(pos: SourcePosition, tpdPath: List[tpd.Tree])(using val ctx: Context) extends IndexedContext: - val completionContext = Completion.scopeContext(pos) - val names: Map[String, Seq[SingleDenotation]] = completionContext.names.toList.groupBy(_._1.show).map { + val scopeContext: CompletionResult = Completion.scopeContext(pos, tpdPath, ctx) + val names: Map[String, Seq[SingleDenotation]] = scopeContext.names.toList.groupBy(_._1.show).map { case (name, denotations) => - val denots = denotations.flatMap(_._2) + val denots = denotations.flatMap(_._2.denots) val nonRoot = denots.filter(!_.symbol.owner.isRoot) val (importedByDefault, conflictingValue) = denots.partition(denot => Interactive.isImportedByDefault(denot.symbol)) @@ -100,7 +104,7 @@ object IndexedContext: else name.trim -> nonRoot } - val renames = completionContext.renames + val renames = scopeContext.renames def defaultScopes(name: Name): Option[List[Symbol]] = List(defn.ScalaPredefModuleClass, defn.ScalaPackageClass, defn.JavaLangPackageClass) diff --git a/presentation-compiler/src/main/dotty/tools/pc/InferExpectedType.scala b/presentation-compiler/src/main/dotty/tools/pc/InferExpectedType.scala index daf38856b290..ab3bad986a6f 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/InferExpectedType.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/InferExpectedType.scala @@ -2,12 +2,9 @@ package dotty.tools.pc import scala.meta.pc.OffsetParams import scala.meta.pc.SymbolSearch -import scala.meta.pc.reports.ReportContext import dotty.tools.dotc.ast.tpd.* import dotty.tools.dotc.core.Contexts.Context -import dotty.tools.dotc.core.Flags -import dotty.tools.dotc.core.StdNames import dotty.tools.dotc.core.Symbols.defn import dotty.tools.dotc.core.Types.* import dotty.tools.dotc.interactive.Interactive @@ -25,7 +22,7 @@ class InferExpectedType( search: SymbolSearch, driver: InteractiveDriver, params: OffsetParams -)(implicit rc: ReportContext): +): val uri: java.net.URI = params.uri() val code: String = params.text() @@ -40,14 +37,12 @@ class InferExpectedType( case Some(unit) => val path = Interactive.pathTo(driver.openedTrees(uri), pos)(using ctx) - val newctx = ctx.fresh.setCompilationUnit(unit) + val newctx = driver.currentCtx.fresh.setCompilationUnit(unit) val tpdPath = Interactive.pathTo(newctx.compilationUnit.tpdTree, pos.span)(using newctx) - val locatedCtx = - Interactive.contextOfPath(tpdPath)(using newctx) - val indexedCtx = IndexedContext(pos)(using locatedCtx) + val indexedContext = IndexedContext(pos, tpdPath, newctx) val printer = - ShortenedTypePrinter(search, IncludeDefaultParam.ResolveLater)(using indexedCtx) + ShortenedTypePrinter(search, IncludeDefaultParam.ResolveLater)(using indexedContext) InferCompletionType.inferType(path)(using newctx).map { tpe => printer.tpe(tpe) } @@ -72,14 +67,14 @@ object InferCompletionType: case CaseDef(_, _, body) :: Try(_, cases, _) :: rest if body.span.contains(span) && cases.exists(_.span.contains(span)) => inferType(rest, span) case If(cond, _, _) :: rest if !cond.span.contains(span) => inferType(rest, span) - case If(cond, _, _) :: rest if cond.span.contains(span) => Some(defn.BooleanType) + case If(cond, _, _) :: _ if cond.span.contains(span) => Some(defn.BooleanType) case CaseDef(_, _, body) :: Match(_, cases) :: rest if body.span.contains(span) && cases.exists(_.span.contains(span)) => inferType(rest, span) case NamedArg(_, arg) :: rest if arg.span.contains(span) => inferType(rest, span) // x match // case @@ - case CaseDef(pat, _, _) :: Match(sel, cases) :: rest + case CaseDef(pat, _, _) :: Match(sel, cases) :: _ if pat.span.contains(span) && cases.exists(_.span.contains(span)) && !sel.tpe.isErroneous => sel.tpe match case tpe: TermRef => Some(tpe.symbol.info).filterNot(_.isErroneous) @@ -89,7 +84,7 @@ object InferCompletionType: Some(tpe.tpe) // val _: T = @@ // def _: T = @@ - case (defn: ValOrDefDef) :: rest if !defn.tpt.tpe.isErroneous => Some(defn.tpt.tpe) + case (defn: ValOrDefDef) :: _ if !defn.tpt.tpe.isErroneous => Some(defn.tpt.tpe) case UnApply(fun, _, pats) :: _ => val ind = pats.indexWhere(_.span.contains(span)) if ind < 0 then None diff --git a/presentation-compiler/src/main/dotty/tools/pc/InferredMethodProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/InferredMethodProvider.scala index 705220b067b2..1d05e6e89015 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/InferredMethodProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/InferredMethodProvider.scala @@ -6,10 +6,8 @@ import scala.annotation.tailrec import scala.meta.pc.OffsetParams import scala.meta.pc.PresentationCompilerConfig import scala.meta.pc.SymbolSearch -import scala.meta.pc.reports.ReportContext import dotty.tools.dotc.ast.tpd.* -import dotty.tools.dotc.core.Contexts.* import dotty.tools.dotc.core.Names.Name import dotty.tools.dotc.core.Symbols.* import dotty.tools.dotc.core.Symbols.defn @@ -45,7 +43,7 @@ final class InferredMethodProvider( driver: InteractiveDriver, config: PresentationCompilerConfig, symbolSearch: SymbolSearch -)(using ReportContext): +): case class AdjustTypeOpts( text: String, @@ -67,15 +65,16 @@ final class InferredMethodProvider( val path = Interactive.pathTo(driver.openedTrees(uri), pos)(using driver.currentCtx) - given locatedCtx: Context = driver.localContext(params) - val indexedCtx = IndexedContext(pos)(using locatedCtx) + val newctx = driver.currentCtx.fresh.setCompilationUnit(unit) + val indexedContext = IndexedContext(pos, path, newctx) + import indexedContext.ctx val autoImportsGen = AutoImports.generator( pos, sourceText, unit.tpdTree, unit.comments, - indexedCtx, + indexedContext, config ) @@ -83,7 +82,7 @@ final class InferredMethodProvider( symbolSearch, includeDefaultParam = IncludeDefaultParam.ResolveLater, isTextEdit = true - )(using indexedCtx) + )(using indexedContext) def imports: List[TextEdit] = printer.imports(autoImportsGen) @@ -94,7 +93,7 @@ final class InferredMethodProvider( def printName(name: Name): String = printer.nameString(name) - def printParams(params: List[Type], startIndex: Int = 0): String = + def printParams(params: List[Type], startIndex: Int): String = params.zipWithIndex .map { case (p, index) => s"arg${index + startIndex}: ${printType(p)}" @@ -186,7 +185,7 @@ final class InferredMethodProvider( */ def extractParameterTypeInfo(methodType: Type, argIndex: Int): (Option[List[Type]], Option[Type]) = methodType match - case m @ MethodType(param) => + case m @ MethodType(_) => val expectedFunctionType = m.paramInfos(argIndex) if defn.isFunctionType(expectedFunctionType) then expectedFunctionType match @@ -336,7 +335,7 @@ final class InferredMethodProvider( * ``` */ case (id @ Ident(errorMethod)) :: - (apply @ Apply(func, args)) :: + (Apply(func, args)) :: _ if id.symbol == NoSymbol && func == id => val argTypes = args.map(_.typeOpt.widenDealias) @@ -359,7 +358,7 @@ final class InferredMethodProvider( * ``` */ case (select @ Select(container, errorMethod)) :: - (apply @ Apply(func, args)) :: + (Apply(func, args)) :: _ if select.symbol == NoSymbol && func == select => val argTypes = args.map(_.typeOpt.widenDealias) diff --git a/presentation-compiler/src/main/dotty/tools/pc/InferredTypeProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/InferredTypeProvider.scala index e60d21339415..208e6d865d98 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/InferredTypeProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/InferredTypeProvider.scala @@ -6,22 +6,18 @@ import scala.annotation.tailrec import scala.meta.pc.OffsetParams import scala.meta.pc.PresentationCompilerConfig import scala.meta.pc.SymbolSearch -import scala.meta.pc.reports.ReportContext -import scala.meta as m import dotty.tools.dotc.ast.Trees.* import dotty.tools.dotc.ast.untpd import dotty.tools.dotc.core.Contexts.* import dotty.tools.dotc.core.Flags.* import dotty.tools.dotc.core.NameOps.* -import dotty.tools.dotc.core.Names.* import dotty.tools.dotc.core.Symbols.* import dotty.tools.dotc.core.Types.* import dotty.tools.dotc.interactive.Interactive import dotty.tools.dotc.interactive.InteractiveDriver import dotty.tools.dotc.util.SourceFile import dotty.tools.dotc.util.SourcePosition -import dotty.tools.dotc.util.Spans import dotty.tools.dotc.util.Spans.Span import dotty.tools.pc.printer.ShortenedTypePrinter import dotty.tools.pc.printer.ShortenedTypePrinter.IncludeDefaultParam @@ -51,7 +47,7 @@ final class InferredTypeProvider( driver: InteractiveDriver, config: PresentationCompilerConfig, symbolSearch: SymbolSearch -)(using ReportContext): +): case class AdjustTypeOpts( text: String, @@ -61,7 +57,6 @@ final class InferredTypeProvider( def inferredTypeEdits( adjustOpt: Option[AdjustTypeOpts] = None ): List[TextEdit] = - val retryType = adjustOpt.isEmpty val uri = params.uri().nn val filePath = Paths.get(uri).nn @@ -71,11 +66,11 @@ final class InferredTypeProvider( driver.run(uri, source) val unit = driver.currentCtx.run.nn.units.head val pos = driver.sourcePosition(params) + val newctx = driver.currentCtx.fresh.setCompilationUnit(unit) val path = - Interactive.pathTo(driver.openedTrees(uri), pos)(using driver.currentCtx) - - given locatedCtx: Context = driver.localContext(params) - val indexedCtx = IndexedContext(pos)(using locatedCtx) + Interactive.pathTo(newctx.compilationUnit.tpdTree, pos.span)(using newctx) + val indexedCtx = IndexedContext(pos, path, newctx) + import indexedCtx.ctx val autoImportsGen = AutoImports.generator( pos, sourceText, @@ -118,7 +113,7 @@ final class InferredTypeProvider( def imports: List[TextEdit] = printer.imports(autoImportsGen) - def printTypeAscription(tpe: Type, spaceBefore: Boolean = false): String = + def printTypeAscription(tpe: Type, spaceBefore: Boolean): String = (if spaceBefore then " : " else ": ") + printer.tpe(tpe) path.headOption match @@ -133,7 +128,7 @@ final class InferredTypeProvider( case Some(vl @ ValDef(name, tpt, rhs)) => val isParam = path match case head :: next :: _ if next.symbol.isAnonymousFunction => true - case head :: (b @ Block(stats, expr)) :: next :: _ + case head :: Block(_, _) :: next :: _ if next.symbol.isAnonymousFunction => true case _ => false @@ -177,7 +172,7 @@ final class InferredTypeProvider( // labda `map{a => ???}` apply // Ensures that this becomes {(a: Int) => ???} since parentheses // are required around the parameter of a lambda in Scala 3 - case valDef :: defDef :: (block: untpd.Block) :: (_: untpd.Block) :: (appl: untpd.Apply) :: _ + case _ :: _ :: (block: untpd.Block) :: (_: untpd.Block) :: (appl: untpd.Apply) :: _ if isParam => checkForParensAndEdit(appl.fun.endPos.end, '{', block.startPos) @@ -188,7 +183,7 @@ final class InferredTypeProvider( typeNameEdit ::: imports rhs match - case t: Tree[?] if !tpt.sourcePos.span.isZeroExtent => + case _: Tree[?] if !tpt.sourcePos.span.isZeroExtent => inferredTypeEdits( Some( AdjustTypeOpts( @@ -227,7 +222,7 @@ final class InferredTypeProvider( while i >= 0 && sourceText(i) != ':' do i -= 1 i rhs match - case t: Tree[?] if !tpt.sourcePos.span.isZeroExtent => + case _: Tree[?] if !tpt.sourcePos.span.isZeroExtent => inferredTypeEdits( Some( AdjustTypeOpts( @@ -257,7 +252,7 @@ final class InferredTypeProvider( * we need to add () for example in: * case (head : Int) :: tail => */ - case _ :: (unappl @ UnApply(_, _, patterns)) :: _ + case _ :: (UnApply(_, _, patterns)) :: _ if patterns.size > 1 => val firstEnd = patterns(0).endPos.end val secondStart = patterns(1).startPos.start diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcCollector.scala b/presentation-compiler/src/main/dotty/tools/pc/PcCollector.scala index 70b78d124030..172915335f96 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/PcCollector.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/PcCollector.scala @@ -1,29 +1,17 @@ package dotty.tools.pc -import java.nio.file.Paths - -import scala.meta.internal.metals.CompilerOffsetParams import scala.meta.pc.OffsetParams import scala.meta.pc.VirtualFileParams -import scala.meta as m -import dotty.tools.dotc.ast.NavigateAST -import dotty.tools.dotc.ast.Positioned -import dotty.tools.dotc.ast.tpd import dotty.tools.dotc.ast.tpd.* import dotty.tools.dotc.ast.untpd -import dotty.tools.dotc.ast.untpd.ExtMethods import dotty.tools.dotc.ast.untpd.ImportSelector import dotty.tools.dotc.core.Contexts.* import dotty.tools.dotc.core.Flags import dotty.tools.dotc.core.NameOps.* import dotty.tools.dotc.core.Names.* -import dotty.tools.dotc.core.StdNames.* import dotty.tools.dotc.core.Symbols.* -import dotty.tools.dotc.core.Types.* -import dotty.tools.dotc.interactive.Interactive import dotty.tools.dotc.interactive.InteractiveDriver -import dotty.tools.dotc.util.SourceFile import dotty.tools.dotc.util.SourcePosition import dotty.tools.dotc.util.Spans.Span import dotty.tools.pc.PcSymbolSearch.* @@ -278,7 +266,7 @@ trait PcCollector[T]: trees.foldLeft(occurrences) { case (set, tree) => traverser(set, tree) } - case o => + case _ => occurrences end match end collectNamesWithParent @@ -322,9 +310,7 @@ object EndMarker: * ``` */ private val endMarkerRegex = """.*end(/\*.*\*/|\s)+""".r - def getPosition(df: NamedDefTree, pos: SourcePosition, sourceText: String)( - implicit ct: Context - ): Option[SourcePosition] = + def getPosition(df: NamedDefTree, pos: SourcePosition, sourceText: String): Option[SourcePosition] = val name = df.name.toString().stripSuffix("$") val lines = sourceText.slice(df.span.start, df.span.end).split('\n') diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcConvertToNamedLambdaParameters.scala b/presentation-compiler/src/main/dotty/tools/pc/PcConvertToNamedLambdaParameters.scala index c8b140d64680..aaf1edce416f 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/PcConvertToNamedLambdaParameters.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/PcConvertToNamedLambdaParameters.scala @@ -36,12 +36,12 @@ final class PcConvertToNamedLambdaParameters( uri, SourceFile.virtual(filePath.toString, params.text) ) - given newctx: Context = driver.localContext(params) + given ctx: Context = driver.currentCtx val pos = driver.sourcePosition(params) val trees = driver.openedTrees(uri) val treeList = Interactive.pathTo(trees, pos) // Extractor for a lambda function (needs context, so has to be defined here) - val LambdaExtractor = Lambda(using newctx) + val LambdaExtractor = Lambda(using ctx) // select the most inner wildcard lambda val firstLambda = treeList.collectFirst { case LambdaExtractor(params, rhsFn) if params.forall(isWildcardParam) => @@ -119,7 +119,7 @@ object PcConvertToNamedLambdaParameters: else List(param) -> body case _ => List(param) -> body - def isWildcardParam(param: tpd.ValDef)(using Context): Boolean = + def isWildcardParam(param: tpd.ValDef): Boolean = param.name.toString.startsWith("_$") def findParamReferencePosition(param: tpd.ValDef, lambda: tpd.Tree)(using Context): Option[SourcePosition] = diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala index a1c73c8c9d1b..88b688868364 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala @@ -2,7 +2,6 @@ package dotty.tools.pc import java.net.URI import java.nio.file.Paths -import java.util.ArrayList import scala.jdk.CollectionConverters.* import scala.meta.internal.pc.DefinitionResultImpl @@ -50,8 +49,10 @@ class PcDefinitionProvider( val path = Interactive.pathTo(driver.openedTrees(uri), pos)(using driver.currentCtx) - given ctx: Context = driver.localContext(params) - val indexedContext = IndexedContext(pos)(using ctx) + val unit = driver.currentCtx.run.nn.units.head + val newctx = driver.currentCtx.fresh.setCompilationUnit(unit) + val indexedContext = IndexedContext(pos, path, newctx) + import indexedContext.ctx val result = if findTypeDef then findTypeDefinitions(path, pos, indexedContext, uri) else findDefinitions(path, pos, indexedContext, uri) @@ -122,7 +123,7 @@ class PcDefinitionProvider( )(using ctx: Context): DefinitionResult = semanticSymbolsSorted(symbols) match case Nil => DefinitionResultImpl.empty - case syms @ ((_, headSym) :: tail) => + case syms @ ((_, headSym) :: _) => val locations = syms.flatMap: case (sym, semanticdbSymbol) => locationsForSymbol(sym, semanticdbSymbol, uri, pos) diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcInlayHintsProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/PcInlayHintsProvider.scala index 1dd4c6a9f061..4e969e24795f 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/PcInlayHintsProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/PcInlayHintsProvider.scala @@ -9,7 +9,6 @@ import scala.meta.internal.pc.LabelPart import scala.meta.internal.pc.LabelPart.* import scala.meta.pc.InlayHintsParams import scala.meta.pc.SymbolSearch -import scala.meta.pc.reports.ReportContext import dotty.tools.dotc.ast.tpd.* import dotty.tools.dotc.core.Contexts.Context @@ -30,13 +29,12 @@ import dotty.tools.pc.utils.InteractiveEnrichments.* import org.eclipse.lsp4j.InlayHint import org.eclipse.lsp4j.InlayHintKind -import org.eclipse.lsp4j as l class PcInlayHintsProvider( driver: InteractiveDriver, params: InlayHintsParams, symbolSearch: SymbolSearch -)(using ReportContext): +): val uri: java.net.URI = params.uri() val filePath: java.nio.file.Path = Paths.get(uri) @@ -135,7 +133,7 @@ class PcInlayHintsProvider( InlayHintKind.Type, InlayHintOrigin.TypeParameters ) - case InferredType(tpe, pos, defTree) + case InferredType(tpe, pos, _) if !isErrorTpe(tpe) => val adjustedPos = adjustPos(pos).endPos withClosingLabels @@ -190,10 +188,10 @@ class PcInlayHintsProvider( tpe: Type, pos: SourcePosition ): List[LabelPart] = - val tpdPath = - Interactive.pathTo(unit.tpdTree, pos.span) - - val indexedCtx = IndexedContext(pos)(using Interactive.contextOfPath(tpdPath)) + val tpdPath = Interactive.pathTo(unit.tpdTree, pos.span) + val newctx = driver.currentCtx.fresh.setCompilationUnit(unit) + val indexedCtx = IndexedContext(pos, tpdPath, newctx) + import indexedCtx.ctx val printer = ShortenedTypePrinter( symbolSearch )(using indexedCtx) @@ -215,13 +213,11 @@ class PcInlayHintsProvider( val usedRenames = printer.getUsedRenames val parts = partsFromType(dealiased, usedRenames) InlayHints.makeLabelParts(parts, tpeStr) - end toLabelParts - private val definitions = IndexedContext(pos)(using ctx).ctx.definitions private def syntheticTupleApply(tree: Tree): Boolean = tree match case sel: Select => - if definitions.isTupleNType(sel.symbol.info.finalResultType) then + if ctx.definitions.isTupleNType(sel.symbol.info.finalResultType) then sel match case Select(tupleClass: Ident, _) if !tupleClass.span.isZeroExtent && @@ -372,7 +368,7 @@ object ValueOf: def unapply(tree: Tree)(using params: InlayHintsParams, ctx: Context) = if params.implicitParameters() then tree match - case Apply(ta @ TypeApply(fun, _), _) + case Apply(TypeApply(fun, _), _) if fun.span.isSynthetic && isValueOf(fun) => Some( "new " + tpnme.valueOf.decoded.capitalize + "(...)", diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcInlineValueProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/PcInlineValueProvider.scala index 5c0f3a06e437..559d0d0a5345 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/PcInlineValueProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/PcInlineValueProvider.scala @@ -1,10 +1,6 @@ package dotty.tools.pc -import scala.meta.internal.pc.Definition -import scala.meta.internal.pc.InlineValueProvider import scala.meta.internal.pc.InlineValueProvider.Errors -import scala.meta.internal.pc.RangeOffset -import scala.meta.internal.pc.Reference import scala.meta.pc.OffsetParams import dotty.tools.dotc.ast.NavigateAST @@ -16,9 +12,7 @@ import dotty.tools.dotc.core.StdNames import dotty.tools.dotc.core.Symbols.Symbol import dotty.tools.dotc.interactive.Interactive import dotty.tools.dotc.interactive.InteractiveDriver -import dotty.tools.dotc.util.SourceFile import dotty.tools.dotc.util.SourcePosition -import dotty.tools.pc.IndexedContext.Result import dotty.tools.pc.utils.InteractiveEnrichments.* import org.eclipse.lsp4j as l @@ -71,7 +65,7 @@ final class PcInlineValueProvider( endOffset: Int, range: l.Range ): l.Range = - val (startWithSpace, endWithSpace): (Int, Int) = + val (startWithSpace: Int, endWithSpace: Int) = extendRangeToIncludeWhiteCharsAndTheFollowingNewLine( text )(startOffset, endOffset) @@ -113,7 +107,7 @@ final class PcInlineValueProvider( } .toRight(Errors.didNotFindDefinition) path = Interactive.pathTo(unit.tpdTree, definition.tree.rhs.span)(using newctx) - indexedContext = IndexedContext(definition.tree.namePos)(using Interactive.contextOfPath(path)(using newctx)) + indexedContext = IndexedContext(definition.tree.namePos, path, newctx) symbols = symbolsUsedInDefn(definition.tree.rhs, indexedContext) references <- getReferencesToInline(definition, allOccurences, symbols) yield @@ -140,7 +134,7 @@ final class PcInlineValueProvider( ): String = val rhsLines = rhs.split("\n").toList rhsLines match - case h :: Nil => rhs + case _ :: Nil => rhs case h :: t => val header = if !hasNextLineAfterEqualsSign then h else "\n" ++ refIndent ++ " " ++ h header ++ t.map(refIndent ++ _.stripPrefix(defIndent)).mkString("\n", "\n", "") @@ -239,7 +233,7 @@ final class PcInlineValueProvider( then if defIsLocal then inlineAll() else Left(Errors.notLocal) else allreferences match - case ref :: Nil if defIsLocal => inlineAll() + case _ :: Nil if defIsLocal => inlineAll() case list => for ref <- list @@ -268,9 +262,7 @@ final class PcInlineValueProvider( def buildRef(occurrence: Occurence): Either[String, Reference] = val path = Interactive.pathTo(unit.tpdTree, occurrence.pos.span)(using newctx) - val indexedContext = IndexedContext(pos)( - using Interactive.contextOfPath(path)(using newctx) - ) + val indexedContext = IndexedContext(pos, path, newctx) import indexedContext.ctx val conflictingSymbols = symbols .withFilter { diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcReferencesProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/PcReferencesProvider.scala index ce892afc237a..dac5e74372ee 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/PcReferencesProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/PcReferencesProvider.scala @@ -7,7 +7,6 @@ import scala.meta.internal.pc.PcReferencesResult import scala.meta.pc.ReferencesRequest import scala.meta.pc.ReferencesResult -import dotty.tools.dotc.ast.tpd import dotty.tools.dotc.ast.tpd.* import dotty.tools.dotc.core.Symbols.* import dotty.tools.dotc.interactive.InteractiveDriver diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcSemanticTokensProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/PcSemanticTokensProvider.scala index 39d5d62ab7a2..deba54e9a3a0 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/PcSemanticTokensProvider.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/PcSemanticTokensProvider.scala @@ -48,7 +48,7 @@ final class PcSemanticTokensProvider( */ private def isDefinition(tree: Tree | EndMarker) = tree match case _: EndMarker => true - case df: Bind => true + case _: Bind => true case df: ValOrDefDef => !df.rhs.isEmpty && !df.symbol.isAllOf(Flags.EnumCase) case df: TypeDef => diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcSymbolSearch.scala b/presentation-compiler/src/main/dotty/tools/pc/PcSymbolSearch.scala index 15a2cdd5cfe0..1937edcaaf92 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/PcSymbolSearch.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/PcSymbolSearch.scala @@ -12,7 +12,6 @@ import dotty.tools.dotc.core.NameOps.* import dotty.tools.dotc.core.Names.* import dotty.tools.dotc.core.StdNames.* import dotty.tools.dotc.core.Symbols.* -import dotty.tools.dotc.core.Types.* import dotty.tools.dotc.interactive.Interactive import dotty.tools.dotc.util.SourcePosition import dotty.tools.dotc.util.Spans.Span @@ -41,7 +40,7 @@ trait PcSymbolSearch: lazy val path = rawPath match // For type it will sometimes go into the wrong tree since TypeTree also contains the same span // https://github.com/lampepfl/dotty/issues/15937 - case TypeApply(sel: Select, _) :: tail if sel.span.contains(pos.span) => + case TypeApply(sel: Select, _) :: _ if sel.span.contains(pos.span) => Interactive.pathTo(sel, pos.span) ::: rawPath case _ => rawPath @@ -65,7 +64,7 @@ trait PcSymbolSearch: * val x = new <>(1) * ``` */ - case t :: (n: New) :: (sel: Select) :: _ + case t :: (_: New) :: (sel: Select) :: _ if t.symbol == NoSymbol && sel.symbol.isConstructor => Some(symbolAlternatives(sel.symbol.owner), namePos(t)) diff --git a/presentation-compiler/src/main/dotty/tools/pc/RawScalaPresentationCompiler.scala b/presentation-compiler/src/main/dotty/tools/pc/RawScalaPresentationCompiler.scala index a3b05a701990..14a90c15cd6e 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/RawScalaPresentationCompiler.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/RawScalaPresentationCompiler.scala @@ -8,8 +8,6 @@ import java.util as ju import scala.jdk.CollectionConverters.* import scala.language.unsafeNulls -import scala.meta.internal.metals.CompilerVirtualFileParams -import scala.meta.internal.metals.PcQueryContext import scala.meta.internal.metals.ReportLevel import scala.meta.internal.mtags.CommonMtagsEnrichments.* import scala.meta.internal.pc.EmptySymbolSearch @@ -46,7 +44,9 @@ case class RawScalaPresentationCompiler( folderPath: Option[Path] = None, reportsLevel: ReportLevel = ReportLevel.Info, completionItemPriority: CompletionItemPriority = (_: String) => 0, - reportContext: ReportContext = EmptyReportContext() + reportContext: ReportContext = EmptyReportContext(), + sourcePath: ju.function.Supplier[ju.List[Path]] = () => Nil.asJava, + semanticdbFileManager: SemanticdbFileManager = SemanticdbFileManager.EMPTY ) extends RawPresentationCompiler: def this() = this("uninitialized-presentation-compiler") @@ -68,15 +68,22 @@ case class RawScalaPresentationCompiler( private val forbiddenOptions = Set("-print-tasty") private val forbiddenDoubleOptions = Set.empty[String] - val driverSettings = + val driverSettings: List[String] = val implicitSuggestionTimeout = List("-Ximport-suggestion-timeout", "0") val defaultFlags = List("-color:never") val filteredOptions = removeDoubleOptions(options.filterNot(forbiddenOptions)) - - filteredOptions ::: defaultFlags ::: implicitSuggestionTimeout ::: "-classpath" :: classpath - .mkString(File.pathSeparator) :: Nil - - lazy val driver: InteractiveDriver = CachingDriver(driverSettings) + val classpathFlags = List("-classpath", classpath.mkString(File.pathSeparator)) + val sourcePathFlags = if config.sourcePathMode() != SourcePathMode.DISABLED then + List("-Ylogical-package-loading") + else Nil + filteredOptions ++ + defaultFlags ++ + implicitSuggestionTimeout ++ + classpathFlags ++ + sourcePathFlags + + lazy val driver: InteractiveDriver = + CachingDriver(driverSettings, sourcePath, semanticdbFileManager, config.sourcePathMode()) override def codeAction[T]( params: OffsetParams, @@ -147,7 +154,7 @@ case class RawScalaPresentationCompiler( CompletionProvider( search, driver, - () => InteractiveDriver(driverSettings), + () => InteractiveDriver(driverSettings, driver.logicalRootPackage), params, config, buildTargetIdentifier, @@ -302,6 +309,20 @@ case class RawScalaPresentationCompiler( ): ju.List[l.TextEdit] = PcRenameProvider(driver, params, Some(name)).rename().asJava + override def newInstance( + buildTargetIdentifier: String, + classpath: ju.List[Path], + options: ju.List[String], + sourcePath: ju.function.Supplier[ju.List[Path]] + ): RawPresentationCompiler = { + copy( + buildTargetIdentifier = buildTargetIdentifier, + classpath = classpath.asScala.toSeq, + options = options.asScala.toList, + sourcePath = sourcePath + ) + } + override def newInstance( buildTargetIdentifier: String, classpath: ju.List[Path], @@ -341,4 +362,9 @@ case class RawScalaPresentationCompiler( override def withWorkspace(workspace: Path): RawPresentationCompiler = copy(folderPath = Some(workspace)) + override def withSemanticdbFileManager( + semanticdbFileManager: SemanticdbFileManager + ): RawPresentationCompiler = + copy(semanticdbFileManager = semanticdbFileManager) + end RawScalaPresentationCompiler diff --git a/presentation-compiler/src/main/dotty/tools/pc/Scala3CompilerAccess.scala b/presentation-compiler/src/main/dotty/tools/pc/Scala3CompilerAccess.scala index d3fedca5b81d..5c246863e54c 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/Scala3CompilerAccess.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/Scala3CompilerAccess.scala @@ -5,7 +5,6 @@ import java.util.concurrent.ScheduledExecutorService import scala.concurrent.ExecutionContextExecutor import scala.meta.internal.pc.CompilerAccess import scala.meta.pc.PresentationCompilerConfig -import scala.meta.pc.reports.ReportContext import dotty.tools.dotc.interactive.InteractiveDriver import dotty.tools.dotc.reporting.StoreReporter @@ -14,7 +13,7 @@ class Scala3CompilerAccess( config: PresentationCompilerConfig, sh: Option[ScheduledExecutorService], newCompiler: () => Scala3CompilerWrapper -)(using ec: ExecutionContextExecutor, rc: ReportContext) +)(using ec: ExecutionContextExecutor) extends CompilerAccess[StoreReporter, InteractiveDriver]( config, sh, diff --git a/presentation-compiler/src/main/dotty/tools/pc/ScalaPresentationCompiler.scala b/presentation-compiler/src/main/dotty/tools/pc/ScalaPresentationCompiler.scala index 69d45e6563db..ac06183bb9d4 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/ScalaPresentationCompiler.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/ScalaPresentationCompiler.scala @@ -52,7 +52,9 @@ case class ScalaPresentationCompiler( folderPath: Option[Path] = None, reportsLevel: ReportLevel = ReportLevel.Info, completionItemPriority: CompletionItemPriority = (_: String) => 0, - reportContext: ReportContext = EmptyReportContext() + reportContext: ReportContext = EmptyReportContext(), + sourcePath: ju.function.Supplier[ju.List[Path]] = () => Nil.asJava, + semanticdbFileManager: SemanticdbFileManager = SemanticdbFileManager.EMPTY ) extends PresentationCompiler: given ReportContext = reportContext @@ -103,7 +105,7 @@ case class ScalaPresentationCompiler( case (PcConvertToNamedLambdaParameters.codeActionId, _) => compilerAccess.withNonInterruptableCompiler(List.empty[l.TextEdit].asJava, params.token) { access => PcConvertToNamedLambdaParameters(access.compiler(), params).convertToNamedLambdaParameters - }(params.toQueryContext) + }(using params.toQueryContext) case (id, _) => failedFuture(new IllegalArgumentException(s"Unsupported action id $id")) private def failedFuture[T](e: Throwable): CompletableFuture[T] = @@ -122,20 +124,37 @@ case class ScalaPresentationCompiler( override def withReportsLoggerLevel(level: String): PresentationCompiler = copy(reportsLevel = ReportLevel.fromString(level)) + override def withSemanticdbFileManager( + semanticdbFileManager: SemanticdbFileManager + ): PresentationCompiler = + copy(semanticdbFileManager = semanticdbFileManager) + val compilerAccess: CompilerAccess[StoreReporter, InteractiveDriver] = Scala3CompilerAccess( config, sh, - () => new Scala3CompilerWrapper(CachingDriver(driverSettings)) + () => + new Scala3CompilerWrapper(CachingDriver( + driverSettings, + sourcePath, + semanticdbFileManager, + config.sourcePathMode() + )) )(using ec) - val driverSettings = + val driverSettings: List[String] = val implicitSuggestionTimeout = List("-Ximport-suggestion-timeout", "0") val defaultFlags = List("-color:never") val filteredOptions = removeDoubleOptions(options.filterNot(forbiddenOptions)) - - filteredOptions ::: defaultFlags ::: implicitSuggestionTimeout ::: "-classpath" :: classpath - .mkString(File.pathSeparator) :: Nil + val classpathFlags = List("-classpath", classpath.mkString(File.pathSeparator)) + val sourcePathFlags = if config.sourcePathMode() != SourcePathMode.DISABLED then + List("-Ylogical-package-loading") + else Nil + filteredOptions ++ + defaultFlags ++ + implicitSuggestionTimeout ++ + classpathFlags ++ + sourcePathFlags private def removeDoubleOptions(options: List[String]): List[String] = options match @@ -153,7 +172,7 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() new PcSemanticTokensProvider(driver, params).provide().asJava - }(params.toQueryContext) + }(using params.toQueryContext) override def inlayHints( params: InlayHintsParams @@ -166,7 +185,7 @@ case class ScalaPresentationCompiler( new PcInlayHintsProvider(driver, params, search) .provide() .asJava - }(params.toQueryContext) + }(using params.toQueryContext) override def getTasty( targetUri: URI, @@ -185,14 +204,14 @@ case class ScalaPresentationCompiler( new CompletionProvider( search, driver, - () => InteractiveDriver(driverSettings), + () => InteractiveDriver(driverSettings, driver.logicalRootPackage), params, config, buildTargetIdentifier, folderPath, completionItemPriority ).completions() - }(params.toQueryContext) + }(using params.toQueryContext) def definition(params: OffsetParams): CompletableFuture[DefinitionResult] = compilerAccess.withInterruptableCompiler( @@ -201,7 +220,7 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() PcDefinitionProvider(driver, params, search).definitions() - }(params.toQueryContext) + }(using params.toQueryContext) override def typeDefinition( params: OffsetParams @@ -212,7 +231,7 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() PcDefinitionProvider(driver, params, search).typeDefinitions() - }(params.toQueryContext) + }(using params.toQueryContext) def documentHighlight( params: OffsetParams @@ -223,7 +242,7 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() PcDocumentHighlightProvider(driver, params).highlights.asJava - }(params.toQueryContext) + }(using params.toQueryContext) override def references( params: ReferencesRequest @@ -236,7 +255,7 @@ case class ScalaPresentationCompiler( PcReferencesProvider(driver, params) .references() .asJava - }(params.file().toQueryContext) + }(using params.file().toQueryContext) def inferExpectedType(params: OffsetParams): CompletableFuture[ju.Optional[String]] = compilerAccess.withInterruptableCompiler( @@ -245,7 +264,7 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() new InferExpectedType(search, driver, params).infer().asJava - }(params.toQueryContext) + }(using params.toQueryContext) def shutdown(): Unit = compilerAccess.shutdown() @@ -267,7 +286,7 @@ case class ScalaPresentationCompiler( .info(symbol) .map(_.asJava) .asJava - }(emptyQueryContext) + }(using emptyQueryContext) def semanticdbTextDocument( filename: URI, @@ -281,7 +300,7 @@ case class ScalaPresentationCompiler( val driver = access.compiler() val provider = SemanticdbTextDocumentProvider(driver, folderPath) provider.textDocument(filename, code) - }(virtualFile.toQueryContext) + }(using virtualFile.toQueryContext) def completionItemResolve( item: l.CompletionItem, @@ -293,7 +312,7 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() CompletionItemResolver.resolve(item, symbol, search, config)(using driver.currentCtx) - }(emptyQueryContext) + }(using emptyQueryContext) def autoImports( name: String, @@ -317,7 +336,7 @@ case class ScalaPresentationCompiler( ) .autoImports(isExtension) .asJava - }(params.toQueryContext) + }(using params.toQueryContext) def implementAbstractMembers( params: OffsetParams @@ -334,7 +353,7 @@ case class ScalaPresentationCompiler( search, config ) - }(params.toQueryContext) + }(using params.toQueryContext) override def insertInferredType( params: OffsetParams @@ -347,7 +366,7 @@ case class ScalaPresentationCompiler( new InferredTypeProvider(params, pc.compiler(), config, search) .inferredTypeEdits() .asJava - }(params.toQueryContext) + }(using params.toQueryContext) def insertInferredMethod( params: OffsetParams @@ -360,7 +379,7 @@ case class ScalaPresentationCompiler( new InferredMethodProvider(params, pc.compiler(), config, search) .inferredMethodEdits() .asJava - }(params.toQueryContext) + }(using params.toQueryContext) override def inlineValue( params: OffsetParams @@ -370,7 +389,7 @@ case class ScalaPresentationCompiler( .withInterruptableCompiler(empty, params.token()) { pc => new PcInlineValueProvider(pc.compiler(), params) .getInlineTextEdits() - }(params.toQueryContext)) + }(using params.toQueryContext)) .thenApply { case Right(edits: List[TextEdit]) => edits.asJava case Left(error: String) => throw new DisplayableException(error) @@ -392,7 +411,7 @@ case class ScalaPresentationCompiler( ) .extractMethod() .asJava - }(range.toQueryContext) + }(using range.toQueryContext) override def convertToNamedArguments( params: OffsetParams, @@ -412,7 +431,7 @@ case class ScalaPresentationCompiler( params, argIndices ).convertToNamedArguments - }(params.toQueryContext)) + }(using params.toQueryContext)) .thenApplyAsync { case Left(error: String) => throw new DisplayableException(error) case Right(edits: List[l.TextEdit]) => edits.asJava @@ -428,7 +447,7 @@ case class ScalaPresentationCompiler( pc.compiler(), params ).selectionRange().asJava - }(params.asScala.headOption.map(_.toQueryContext).getOrElse(emptyQueryContext)) + }(using params.asScala.headOption.map(_.toQueryContext).getOrElse(emptyQueryContext)) } end selectionRange @@ -441,7 +460,7 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() HoverProvider.hover(params, driver, search, config.hoverContentType()) - }(params.toQueryContext) + }(using params.toQueryContext) end hover def prepareRename( @@ -455,7 +474,7 @@ case class ScalaPresentationCompiler( Optional.ofNullable( PcRenameProvider(driver, params, None).prepareRename().orNull ) - }(params.toQueryContext) + }(using params.toQueryContext) def rename( params: OffsetParams, @@ -467,9 +486,23 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() PcRenameProvider(driver, params, Some(name)).rename().asJava - }(params.toQueryContext) + }(using params.toQueryContext) + + override def newInstance( + buildTargetIdentifier: String, + classpath: ju.List[Path], + options: ju.List[String], + sourcePath: ju.function.Supplier[ju.List[Path]] + ): PresentationCompiler = { + copy( + buildTargetIdentifier = buildTargetIdentifier, + classpath = classpath.asScala.toSeq, + options = options.asScala.toList, + sourcePath = sourcePath + ) + } - def newInstance( + override def newInstance( buildTargetIdentifier: String, classpath: ju.List[Path], options: ju.List[String] @@ -487,7 +520,7 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() SignatureHelpProvider.signatureHelp(driver, params, search) - }(params.toQueryContext) + }(using params.toQueryContext) override def didChange( params: VirtualFileParams @@ -498,13 +531,13 @@ case class ScalaPresentationCompiler( ) { access => val driver = access.compiler() DiagnosticProvider(driver, params).diagnostics().asJava - }(params.toQueryContext) + }(using params.toQueryContext) override def didClose(uri: URI): Unit = compilerAccess.withNonInterruptableCompiler( (), EmptyCancelToken - ) { access => access.compiler().close(uri) }(emptyQueryContext) + ) { access => access.compiler().close(uri) }(using emptyQueryContext) override def withExecutorService( executorService: ExecutorService diff --git a/presentation-compiler/src/main/dotty/tools/pc/ScriptFirstImportPosition.scala b/presentation-compiler/src/main/dotty/tools/pc/ScriptFirstImportPosition.scala index 5a4c135fdc4c..451acea16987 100644 --- a/presentation-compiler/src/main/dotty/tools/pc/ScriptFirstImportPosition.scala +++ b/presentation-compiler/src/main/dotty/tools/pc/ScriptFirstImportPosition.scala @@ -8,24 +8,20 @@ object ScriptFirstImportPosition: val ammHeaders: List[String] = List("// scala", "// ammonite") def ammoniteScStartOffset( - text: String, comments: List[Comment] ): Option[Int] = - findStartOffset(text, comments, commentQuery = "/**/", ammHeaders) + findStartOffset(comments, commentQuery = "/**/", ammHeaders) def scalaCliScStartOffset( - text: String, comments: List[Comment] ): Option[Int] = findStartOffset( - text, comments, commentQuery = "/* */ +class Script + +/** < script >alert('hello') */ +class ScriptWithSpaces + +/**  */ +class FakeSafeScript + +/** Example < Second <: Third <= Fourth */ +class NotATag + +/** Example < Second >: Third */ +class NotATagButHasGreaterThan + +/** aalert('hello') + */ +class TagOutsideCode + +/** + * see [[<:<]], or [[>:>]] + */ +class LinkToTagLike \ No newline at end of file diff --git a/scaladoc/resources/dotty_res/styles/theme/components/code-snippet.css b/scaladoc/resources/dotty_res/styles/theme/components/code-snippet.css index 99010c5db5d1..2b654500d442 100644 --- a/scaladoc/resources/dotty_res/styles/theme/components/code-snippet.css +++ b/scaladoc/resources/dotty_res/styles/theme/components/code-snippet.css @@ -75,32 +75,34 @@ dd .snippet { } .snippet-showhide { - visibility: hidden; - white-space: nowrap; + position: absolute; + opacity: 0; + width: 0; + height: 0; + margin: 0; + pointer-events: none; } -.snippet-showhide::after { - margin-left: calc(5 * var(--base-spacing)); - visibility: visible; - content: "Show all lines"; +.snippet-showhide-text { + white-space: nowrap; color: var(--action-primary-content-default); text-decoration: none; cursor: pointer; } -.snippet-showhide:checked::after { - visibility: visible; +.snippet-showhide-text::before { + content: "Show all lines"; +} + +.snippet-showhide:checked + .snippet-showhide-text::before { content: "Hide"; - color: var(--action-primary-content-default); - text-decoration: none; - cursor: pointer; } -.snippet-showhide-label:hover::before { +.snippet-showhide-button:hover .snippet-showhide-text { color: var(--action-primary-content-hover); } -.snippet-showhide-label:active::before { +.snippet-showhide-button:active .snippet-showhide-text { color: var(--action-primary-content-active); } @@ -145,7 +147,8 @@ dd .snippet { top: 20%; left: 50%; margin-left: -25%; - background-color: rgba(245, 245, 245, 1); + background-color: var(--action-primary-background-default-solid); + color: var(--text-primary); padding: calc(2 * var(--base-spacing)); border-radius: 4px; width: 50%; @@ -165,6 +168,270 @@ dd .snippet { width: unset !important; } +/* Make the embedded Scastie popup follow the scaladoc document theme rather + * than its hard-coded light theme. Scastie currently uses CodeMirror 6, so + * we target the cm-* / tok-* class names (not the CodeMirror 5 names). All + * selectors are scoped under .snippet-popup so nothing leaks to non-popup + * content. See scala/scala3#25414. */ +.snippet-popup .cm-editor, +.snippet-popup .cm-scroller, +.snippet-popup .cm-content, +.snippet-popup .cm-line, +.snippet-popup .cm-gutters, +.snippet-popup .cm-gutter, +.snippet-popup .cm-foldGutter, +.snippet-popup .cm-panels, +.snippet-popup .cm-panel, +.snippet-popup .cm-tooltip { + background-color: var(--action-primary-background-default-solid) !important; + color: var(--code-syntax-highlighting-code-fg) !important; +} + +.snippet-popup .cm-gutters { + border-right: 1px solid var(--action-primary-border-default) !important; +} + +.snippet-popup .cm-lineNumbers .cm-gutterElement, +.snippet-popup .cm-foldGutter .cm-gutterElement { + color: var(--code-syntax-highlighting-line-number) !important; +} + +.snippet-popup .cm-activeLine, +.snippet-popup .cm-activeLineGutter { + background-color: var(--action-primary-background-hover) !important; +} + +.snippet-popup .cm-cursor, +.snippet-popup .cm-cursor-primary { + border-left-color: var(--text-primary) !important; +} + +.snippet-popup .cm-selectionBackground, +.snippet-popup .cm-focused .cm-selectionBackground, +.snippet-popup .cm-selectionMatch { + background-color: var(--action-primary-background-selected) !important; +} + +.snippet-popup .cm-matchingBracket { + outline: 1px solid var(--action-primary-border-default) !important; + background-color: transparent !important; + color: inherit !important; +} + +/* Scastie applies syntax highlighting via Tree-sitter scope class names + * (not CodeMirror's .tok-* names). The actual selectors live in scastie's + * embedded.css as `.scastie .app.{light,dark} .cm-s-solarized .X`. We + * override those with scaladoc's theme colors so the popup matches the + * surrounding document instead of staying solarized. Most Scastie rules + * lack !important, so ours wins regardless of order; for the two that DO + * use !important (.method-call, .constructor) we add higher-specificity + * rules below. */ +/* Tree-sitter via CodeMirror 6 tags finer-grained scopes than scaladoc's + * hljs renderer does (e.g. it tags package-path segments as .type-qualifier, + * decorators as .attribute, etc.). Rather than collapse them all back into + * scaladoc's smaller semantic palette, give each Tree-sitter category its + * own hue drawn from scaladoc's underlying Radix-style color tokens. The + * *11 variants are theme-aware (light/dark adapt automatically via + * :root.theme-dark in colors.css), so this gives a richer-than-hljs popup + * theme that still tracks the document's light/dark mode. */ + +/* Map every Tree-sitter scope class Scastie uses to scaladoc's semantic + * highlight variables so the popup's palette tracks the document's hljs + * palette exactly (light & dark adapt automatically via colors.css). We + * never demote a Tree-sitter highlight to the default code color — every + * scope keeps its own color, the colors just shift to scaladoc's tones. */ + +/* Keywords + control flow. */ +.snippet-popup .keyword, +.snippet-popup .keyword-function, +.snippet-popup .keyword-operator, +.snippet-popup .keyword-return, +.snippet-popup .conditional, +.snippet-popup .repeat, +.snippet-popup .include, +.snippet-popup .exception, +.snippet-popup .tag, +.snippet-popup .tag-delimiter { color: var(--code-syntax-highlighting-keyword) !important; } + +/* All "type"-shaped scopes share scaladoc's type teal. Tree-sitter tags + * package-path segments, builtins, and user types with .type / .type-builtin + * / .namespace / .symbol; keeping them uniform here matches hljs's + * --code-syntax-highlighting-type for `Int`, `Mutable`, etc., and the same + * teal carries the visual cue Tree-sitter intends for namespaces. */ +.snippet-popup .type, +.snippet-popup .type-builtin, +.snippet-popup .namespace, +.snippet-popup .symbol { color: var(--code-syntax-highlighting-type) !important; } + +/* "Title" tokens — class/trait/object definition heads AND function/method + * declarations and call sites. Mapped to scaladoc's --code-syntax-highlighting-title + * (--grass9), which is darker than --grass11 and matches how hljs colors + * class/method names in the document. */ +.snippet-popup .type-definition, +.snippet-popup .function, +.snippet-popup .function-builtin, +.snippet-popup .function-macro, +.snippet-popup .function-call, +.snippet-popup .method, +.snippet-popup .method-call, +.snippet-popup .constructor { color: var(--code-syntax-highlighting-title) !important; } + +/* Type modifiers (`inline`, `transparent`, etc.). Distinct purple so they + * don't blur into either keywords or type names. */ +.snippet-popup .type-qualifier { color: var(--code-syntax-highlighting-meta) !important; } + +/* Strings and string-shaped literals. */ +.snippet-popup .string, +.snippet-popup .character, +.snippet-popup .text-literal { color: var(--code-syntax-highlighting-string) !important; } +.snippet-popup .string-escape, +.snippet-popup .string-regex { color: var(--code-syntax-highlighting-subst) !important; } + +/* Numeric literals and symbolic constants. */ +.snippet-popup .number, +.snippet-popup .float, +.snippet-popup .boolean, +.snippet-popup .constant, +.snippet-popup .constant-builtin, +.snippet-popup .constant-macro { color: var(--code-syntax-highlighting-literal) !important; } + +/* Comments. */ +.snippet-popup .comment { color: var(--code-syntax-highlighting-comment) !important; font-style: italic; } + +/* Identifier-like scopes Tree-sitter colors but hljs would leave plain — + * route them through scaladoc's `--code-syntax-highlighting-variable` so they + * stay highlighted (rich Tree-sitter coloring preserved) but in the + * document's variable hue rather than Scastie's solarized red. */ +.snippet-popup .variable, +.snippet-popup .property, +.snippet-popup .field { color: var(--code-syntax-highlighting-variable) !important; } + +/* Built-in "magic" identifiers (`this`, `super`, …) — same family as + * variables, italicized to distinguish. */ +.snippet-popup .variable-builtin { color: var(--code-syntax-highlighting-variable) !important; font-style: italic; } + +/* Annotations / decorators / labels — share scaladoc's `--meta` slot + * (yellow). */ +.snippet-popup .attribute, +.snippet-popup .tag-attribute, +.snippet-popup .label { color: var(--code-syntax-highlighting-meta) !important; } + +/* Errors. */ +.snippet-popup .error { color: var(--code-syntax-highlighting-deletion) !important; text-decoration: underline wavy; } + +/* Plain function-parameter names and prose tokens — kept at default code + * color since Tree-sitter only weakly distinguishes these. */ +.snippet-popup .parameter, +.snippet-popup .active-parameter, +.snippet-popup .text, +.snippet-popup .text-reference, +.snippet-popup .operator, +.snippet-popup .punctuation-bracket, +.snippet-popup .punctuation-delimiter, +.snippet-popup .punctuation-special { color: var(--code-syntax-highlighting-code-fg) !important; } + +/* Markdown / docstring-style text tokens. */ +.snippet-popup .text-emphasis { font-style: italic !important; color: var(--code-syntax-highlighting-code-fg) !important; } +.snippet-popup .text-strong { font-weight: bold !important; color: var(--code-syntax-highlighting-code-fg) !important; } +.snippet-popup .text-title { font-weight: bold !important; color: var(--code-syntax-highlighting-title) !important; } + +/* Scastie sets !important on .method-call and .constructor with the selector + * `.scastie .app.{light,dark} .cm-s-solarized .X` (specificity 0,5,0). Match + * that with 6 classes so we win the !important-vs-!important tiebreak. */ +.snippet-popup .scastie.embedded .app .cm-s-solarized .method-call, +.snippet-popup .scastie.embedded .app .cm-s-solarized .constructor { + color: var(--code-syntax-highlighting-title) !important; +} + +/* Keep CodeMirror's `.tok-*` overrides as a fallback: any HighlightStyle that + * was configured with `class: "tok-X"` (rather than a Tree-sitter scope) will + * still hit these rules. */ +.snippet-popup .tok-keyword { color: var(--code-syntax-highlighting-keyword) !important; } +.snippet-popup .tok-string, +.snippet-popup .tok-string2 { color: var(--code-syntax-highlighting-string) !important; } +.snippet-popup .tok-number, +.snippet-popup .tok-atom, +.snippet-popup .tok-bool, +.snippet-popup .tok-literal { color: var(--code-syntax-highlighting-literal) !important; } +.snippet-popup .tok-comment { color: var(--code-syntax-highlighting-comment) !important; font-style: italic; } +.snippet-popup .tok-variableName, +.snippet-popup .tok-propertyName { color: var(--code-syntax-highlighting-variable) !important; } +.snippet-popup .tok-typeName, +.snippet-popup .tok-className, +.snippet-popup .tok-namespace { color: var(--code-syntax-highlighting-type) !important; } +.snippet-popup .tok-definition, +.snippet-popup .tok-labelName { color: var(--code-syntax-highlighting-title) !important; } +.snippet-popup .tok-meta, +.snippet-popup .tok-macroName { color: var(--code-syntax-highlighting-meta) !important; } +.snippet-popup .tok-operator, +.snippet-popup .tok-punctuation { color: var(--code-syntax-highlighting-code-fg) !important; } +.snippet-popup .tok-deleted { color: var(--code-syntax-highlighting-deletion) !important; } +.snippet-popup .tok-inserted { color: var(--code-syntax-highlighting-addition) !important; } +.snippet-popup .tok-invalid { color: var(--code-syntax-highlighting-deletion) !important; text-decoration: underline wavy; } + +/* Force the popup's editor to use the exact same font (and weight) scaladoc + * uses for in-document snippets. Without this Scastie's CodeMirror falls + * back to whatever Fira Code variant is on the system, which renders with + * subtly different stroke weight than scaladoc's `FiraCode-Regular`, making + * identical CSS colors look brighter or thinner side-by-side. */ +.snippet-popup .scastie .cm-editor, +.snippet-popup .scastie .cm-scroller, +.snippet-popup .scastie .cm-content, +.snippet-popup .scastie .cm-line, +.snippet-popup .scastie .inline { + font-family: "FiraCode-Regular", "Fira Code", ui-monospace, monospace !important; + font-weight: 400 !important; +} + +/* Scastie UI chrome: the Run button, Console pane, top bar, resize handler, + * and editor-buttons icons all default to solarized blue/teal. Re-theme them + * to scaladoc variables so the whole popup is consistent. */ +.snippet-popup .scastie .console-container .run-button, +.snippet-popup .scastie .console-container .run-button:hover { + background: var(--action-primary-background-default-solid) !important; + color: var(--action-primary-content-default) !important; + border: 1px solid var(--action-primary-border-default) !important; +} +.snippet-popup .scastie .console-container .run-button:hover { + background: var(--action-primary-background-hover) !important; + color: var(--action-primary-content-hover) !important; +} + +.snippet-popup .scastie .editor-container .console, +.snippet-popup .scastie .editor-container .switcher-show, +.snippet-popup .scastie .editor-container .switcher-hide, +.snippet-popup .scastie .console-container { + background: var(--action-primary-background-default-solid) !important; + color: var(--text-primary) !important; +} + +.snippet-popup .scastie .editor-container .handler { + background: var(--action-primary-border-default) !important; +} + +.snippet-popup .scastie .editor-topbar, +.snippet-popup .scastie .editor-mobile { + background: var(--action-primary-background-default-solid) !important; + box-shadow: none !important; +} + +.snippet-popup .scastie .editor-buttons .btn, +.snippet-popup .scastie .editor-buttons .btn:hover { + background: transparent !important; +} +.snippet-popup .scastie .editor-buttons .btn { color: var(--action-primary-content-default) !important; } +.snippet-popup .scastie .editor-buttons .btn:hover { color: var(--action-primary-content-hover) !important; } +.snippet-popup .scastie .editor-buttons .btn.disabled { color: var(--text-secondary, var(--code-syntax-highlighting-comment)) !important; } + +/* The main scastie panel and editor wrapper background. Match the popup. */ +.snippet-popup .scastie .main-panel, +.snippet-popup .scastie .code .editor-wrapper, +.snippet-popup .scastie .code .editor-wrapper .cm-s-solarized, +.snippet-popup .scastie .code .editor-wrapper .cm-s-solarized .cm-gutters { + background: var(--action-primary-background-default-solid) !important; + color: var(--code-syntax-highlighting-code-fg) !important; +} + .tooltip-container { display: none; } @@ -199,64 +466,98 @@ dd .snippet { border-bottom: 2px dotted pink; } +/* !important here is load-bearing. Scastie's embedded.css (loaded into + * when the user clicks Run on a snippet) overrides hljs-* rules with its + * solarized palette, which would otherwise re-theme every code block on the + * page. See scala/scala3#25414. */ .hljs-keyword { - color: var(--code-method-highlighting-keyword); + color: var(--code-method-highlighting-keyword) !important; } .hljs-comment { - color: var(--code-syntax-highlighting-comment); + color: var(--code-syntax-highlighting-comment) !important; } .hljs-quote { - color: var(--code-syntax-highlighting-quote); + color: var(--code-syntax-highlighting-quote) !important; } .hljs-line-number { - color: var(--code-syntax-highlighting-line-number); + color: var(--code-syntax-highlighting-line-number) !important; } .hljs-title { - color: var(--code-syntax-highlighting-title); + color: var(--code-syntax-highlighting-title) !important; } .hljs-keyword { - color: var(--code-syntax-highlighting-keyword); + color: var(--code-syntax-highlighting-keyword) !important; } .hljs-code-fg { - color: var(--code-syntax-highlighting-code-fg); + color: var(--code-syntax-highlighting-code-fg) !important; } .hljs-literal { - color: var(--code-syntax-highlighting-literal); + color: var(--code-syntax-highlighting-literal) !important; } .hljs-type { - color: var(--code-syntax-highlighting-type); + color: var(--code-syntax-highlighting-type) !important; } .hljs-subst { - color: var(--code-syntax-highlighting-subst); + color: var(--code-syntax-highlighting-subst) !important; } .hljs-meta { - color: var(--code-syntax-highlighting-meta); + color: var(--code-syntax-highlighting-meta) !important; } .hljs-string { - color: var(--code-syntax-highlighting-string); + color: var(--code-syntax-highlighting-string) !important; } .hljs-deletion { - color: var(--code-syntax-highlighting-deletion); + color: var(--code-syntax-highlighting-deletion) !important; } .hljs-addition { - color: var(--code-syntax-highlighting-addition); + color: var(--code-syntax-highlighting-addition) !important; } .hljs-variable { - color: var(--code-syntax-highlighting-variable); + color: var(--code-syntax-highlighting-variable) !important; +} + +/* Scastie's embedded.css ships solarized colors for additional hljs classes + * scaladoc doesn't style itself; neutralize them so Scala snippets retain + * the document theme while the Scastie popup is open. */ +.hljs, +.hljs-tag, +.hljs-name, +.hljs-bullet, +.hljs-template-variable, +.hljs-selector-tag, +.hljs-symbol, +.hljs-number, +.hljs-link, +.hljs-attr, +.hljs-built_in, +.hljs-doctag, +.hljs-regexp, +.hljs-attribute, +.hljs-template-tag, +.hljs-operator, +.hljs-punctuation, +.hljs-section, +.hljs-strong, +.hljs-emphasis, +.hljs-code { + color: inherit !important; + background: transparent !important; + font-weight: inherit !important; + font-style: inherit !important; } /* Scrollbar */ diff --git a/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala b/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala index 536d759388f3..e381404ec446 100644 --- a/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala +++ b/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala @@ -22,7 +22,7 @@ object ExternalDocLink: private def tryParse[T](mapping: String, descr: String)(op: => T): Either[String, T] = Try(op) match { case Success(v) => Right(v) - case Failure(e) => fail(mapping, s"Unable to parse $descr. Exception $e occured") + case Failure(e) => fail(mapping, s"Unable to parse $descr. Exception $e occurred") } private def stripIndex(url: String): String = url.stripSuffix("index.html").stripSuffix("/") + "/" diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala index 7dff3e5637c6..60d6c1854358 100644 --- a/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala +++ b/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala @@ -52,20 +52,20 @@ class HtmlRenderer(rootPackage: Member, members: Map[DRI, Member])(using ctx: Do super.render() private def serializeSideMenu() = - import com.fasterxml.jackson.databind.* - import com.fasterxml.jackson.databind.node.ObjectNode - import com.fasterxml.jackson.databind.node.TextNode - val mapper = new ObjectMapper(); + import _root_.tools.jackson.databind.json.JsonMapper + import _root_.tools.jackson.databind.node.ObjectNode + import _root_.tools.jackson.databind.node.StringNode + val mapper = JsonMapper.builder().build() def serializePage(page: Page): ObjectNode = import scala.jdk.CollectionConverters.SeqHasAsJava val children = mapper.createArrayNode().addAll(page.children.filterNot(_.hidden).map(serializePage).asJava) - val location = mapper.createArrayNode().addAll(rawLocation(page.link.dri).map(TextNode(_)).asJava) + val location = mapper.createArrayNode().addAll(rawLocation(page.link.dri).map(StringNode(_)).asJava) val obj = mapper.createObjectNode() - obj.set("name", new TextNode(page.link.name)) + obj.set("name", new StringNode(page.link.name)) obj.set("location", location) obj.set("kind", page.content match - case m: Member if m.needsOwnPage => new TextNode(m.kind.name) + case m: Member if m.needsOwnPage => new StringNode(m.kind.name) case _ => null ) obj.set("children", children) @@ -92,7 +92,7 @@ class HtmlRenderer(rootPackage: Member, members: Map[DRI, Member])(using ctx: Do .map(from => Resource.File(resourceFile.toPath.relativize(from).toString, from)) }.fold ( { t => - report.warn(s"Error occured while processing _assets file.", t) + report.warn(s"Error occurred while processing _assets file.", t) Seq.empty }, identity diff --git a/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala b/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala index 04a9ee7d9084..c46aae6b45b9 100644 --- a/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala +++ b/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala @@ -1,8 +1,7 @@ package dotty.tools.scaladoc.site -import com.fasterxml.jackson.databind.ObjectMapper -import com.fasterxml.jackson.dataformat.yaml.YAMLFactory -import com.fasterxml.jackson.databind.DeserializationFeature +import _root_.tools.jackson.databind.DeserializationFeature +import _root_.tools.jackson.dataformat.yaml.YAMLMapper import java.io.File import scala.beans.{BooleanBeanProperty, BeanProperty} import scala.util.Try @@ -16,8 +15,9 @@ case class BlogConfig( object BlogParser: def readYml(content: File | String): BlogConfig = - val mapper = ObjectMapper(YAMLFactory()) - .findAndRegisterModules() + val mapper = YAMLMapper.builder() + .disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES) + .build() content match case f: File => diff --git a/scaladoc/src/dotty/tools/scaladoc/site/LoadedTemplate.scala b/scaladoc/src/dotty/tools/scaladoc/site/LoadedTemplate.scala index b23e5647f6fb..15e168467c8a 100644 --- a/scaladoc/src/dotty/tools/scaladoc/site/LoadedTemplate.scala +++ b/scaladoc/src/dotty/tools/scaladoc/site/LoadedTemplate.scala @@ -11,7 +11,7 @@ import scala.jdk.CollectionConverters._ case class LazyEntry(getKey: String, value: () => String) extends JMapEntry[String, Object]: lazy val getValue: Object = value() - def setValue(x$0: Object): Object = ??? + def setValue(`x$0`: Object): Object = ??? case class LoadedTemplate( templateFile: TemplateFile, diff --git a/scaladoc/src/dotty/tools/scaladoc/site/SidebarParser.scala b/scaladoc/src/dotty/tools/scaladoc/site/SidebarParser.scala index d9dc9983a270..599d531613ca 100644 --- a/scaladoc/src/dotty/tools/scaladoc/site/SidebarParser.scala +++ b/scaladoc/src/dotty/tools/scaladoc/site/SidebarParser.scala @@ -1,9 +1,9 @@ package dotty.tools.scaladoc package site -import com.fasterxml.jackson.dataformat.yaml.YAMLFactory; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.core.`type`.TypeReference; +import _root_.tools.jackson.databind.DeserializationFeature; +import _root_.tools.jackson.dataformat.yaml.YAMLMapper; +import _root_.tools.jackson.core.`type`.TypeReference; import scala.jdk.CollectionConverters._ import java.util.Optional import scala.beans._ @@ -32,6 +32,15 @@ object Sidebar: private object RawInputTypeRef extends TypeReference[RawInput] + /** Jackson 3 leaves absent YAML scalars as `null`; this code expects "" / empty list. */ + private def coalesceRawInputNulls(r: RawInput): Unit = + if r.title == null then r.title = "" + if r.page == null then r.page = "" + if r.index == null then r.index = "" + if r.directory == null then r.directory = "" + if r.subsection == null then r.subsection = JList() + else r.subsection.asScala.foreach(coalesceRawInputNulls) + private def toSidebar(r: RawInput, content: String | java.io.File)(using CompilerContext): Sidebar = r match case RawInput(title, page, index, subsection, dir, hidden) if page.nonEmpty && index.isEmpty && subsection.isEmpty() => val pagePath = content match @@ -79,7 +88,9 @@ object Sidebar: def load(content: String | java.io.File)(using CompilerContext): Sidebar.Category = import scala.util.Try - val mapper = ObjectMapper(YAMLFactory()) + val mapper = YAMLMapper.builder() + .disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES) + .build() def readValue = content match case s: String => mapper.readValue(s, RawInputTypeRef) case f: java.io.File => mapper.readValue(f, RawInputTypeRef) @@ -90,7 +101,7 @@ object Sidebar: report.warn(schemaMessage, e) new RawInput() }, - identity + r => { coalesceRawInputNulls(r); r } ) toSidebar(root, content) match case c: Sidebar.Category => c diff --git a/scaladoc/src/dotty/tools/scaladoc/site/templates.scala b/scaladoc/src/dotty/tools/scaladoc/site/templates.scala index d9c72c909680..ad3ca68ab113 100644 --- a/scaladoc/src/dotty/tools/scaladoc/site/templates.scala +++ b/scaladoc/src/dotty/tools/scaladoc/site/templates.scala @@ -13,8 +13,7 @@ import com.vladsch.flexmark.ext.yaml.front.matter.{AbstractYamlFrontMatterVisito import com.vladsch.flexmark.parser.{Parser, ParserEmulationProfile} import com.vladsch.flexmark.html.HtmlRenderer import com.vladsch.flexmark.formatter.Formatter -import liqp.Template -import liqp.ParseSettings +import liqp.TemplateParser import liqp.parser.Flavor import liqp.TemplateContext import liqp.tags.Tag @@ -76,24 +75,24 @@ case class TemplateFile( def isIndexPage() = file.isFile && (file.getName == "index.md" || file.getName == "index.html") private[site] def resolveInner(ctx: RenderingContext)(using ssctx: StaticSiteContext): ResolvedPage = - lazy val snippetCheckingFunc: SnippetChecker.SnippetCheckingFunc = val path = Some(Paths.get(file.getAbsolutePath)) val pathBasedArg = ssctx.snippetCompilerArgs.get(path) - val sourceFile = dotty.tools.dotc.util.SourceFile(dotty.tools.io.AbstractFile.getFile(path.get), scala.io.Codec.UTF8) - (snippet: SnippetSource, argOverride: Option[SnippetCompilerArg]) => { - val arg = argOverride.fold(pathBasedArg)(pathBasedArg.merge(_)) - val compilerData = SnippetCompilerData( - "staticsitesnippet", - SnippetCompilerData.Position(configOffset - 1, 0) - ) - ssctx.snippetChecker.checkSnippet(snippet, Some(compilerData), arg, sourceFile, 0).collect { - case r: SnippetCompilationResult if !r.isSuccessful => - ssctx.bufferSnippetMessages(r.messages) - r - case r => r - } - } + val sourceFile = dotty.tools.dotc.util.SourceFile(dotty.tools.io.AbstractFile.getFile(path.get).nn, scala.io.Codec.UTF8) + (snippet: SnippetSource, argOverride: Option[SnippetCompilerArg]) => + val arg = argOverride.fold(pathBasedArg)(pathBasedArg.merge(_)) + val compilerData = SnippetCompilerData("staticsitesnippet", SnippetCompilerData.Position(configOffset - 1, 0)) + val result = ssctx.snippetChecker.checkSnippet( + snippet, + Some(compilerData), + arg, + sourceFile, + 0 + ) + result.foreach: r => + if !r.isSuccessful then + ssctx.bufferSnippetMessages(r.messages) + result if (ctx.resolving.contains(file.getAbsolutePath)) throw new RuntimeException(s"Cycle in templates involving $file: ${ctx.resolving}") @@ -110,9 +109,8 @@ case class TemplateFile( // Library requires mutable maps.. val mutableProperties = new JHashMap(ctx.properties.transform((_, v) => asJavaElement(v)).asJava) - val parseSettings = ParseSettings.Builder().withFlavor(Flavor.JEKYLL).build() - - val rendered = Template.parse(this.rawCode, parseSettings).render(mutableProperties) + val parser = new TemplateParser.Builder().build() + val rendered = parser.parse(this.rawCode).render(mutableProperties) // We want to render markdown only if next template is html val code = if (isHtml || layoutTemplate.exists(!_.isHtml)) rendered else diff --git a/scaladoc/src/dotty/tools/scaladoc/snippets/FlexmarkSnippetProcessor.scala b/scaladoc/src/dotty/tools/scaladoc/snippets/FlexmarkSnippetProcessor.scala index 810746bac753..9a8fffa8fbd4 100644 --- a/scaladoc/src/dotty/tools/scaladoc/snippets/FlexmarkSnippetProcessor.scala +++ b/scaladoc/src/dotty/tools/scaladoc/snippets/FlexmarkSnippetProcessor.scala @@ -3,7 +3,6 @@ package snippets import com.vladsch.flexmark.util.{ast => mdu, sequence} import com.vladsch.flexmark.{ast => mda} -import com.vladsch.flexmark.formatter.Formatter import scala.jdk.CollectionConverters._ import dotty.tools.scaladoc.tasty.comments.markdown.ExtendedFencedCodeBlock @@ -20,7 +19,7 @@ object FlexmarkSnippetProcessor: nodes.foldLeft[Map[String, SnippetSource]](Map()) { (snippetMap, node) => val lineOffset = node.getStartLineNumber + preparsed.fold(0)(_.strippedLinesBeforeNo) val codeStartLine = lineOffset + SnippetChecker.codeFenceContentLineOffset - val info = node.getInfo.toString.split(" ") + val info = node.getInfo.toString.split(" ").filter(_.nonEmpty) if info.contains("scala") then { val flagOverride = info .find(_.startsWith("sc:")) @@ -30,7 +29,7 @@ object FlexmarkSnippetProcessor: case Right(flags) => Some(flags) case Left(error) => report.warning( - s"""|Error occured during parsing flags in snippet: + s"""|Error occurred during parsing flags in snippet: |$error""".stripMargin ) None @@ -63,7 +62,7 @@ object FlexmarkSnippetProcessor: val snippet = snippetMap.get(id) if snippet.isEmpty then report.warning( - s"""|Error occured during parsing compile-with in snippet: + s"""|Error occurred during parsing compile-with in snippet: |Snippet with id: $id not found. |Remember that you cannot use forward reference to snippets""".stripMargin ) diff --git a/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetChecker.scala b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetChecker.scala index ec845670e7c2..3150335e8d95 100644 --- a/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetChecker.scala +++ b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetChecker.scala @@ -1,15 +1,10 @@ package dotty.tools.scaladoc package snippets -import dotty.tools.scaladoc.DocContext -import java.nio.file.Paths -import java.io.File - +import dotty.tools.dotc.config.Settings._ +import dotty.tools.dotc.fromtasty.TastyFileUtil import dotty.tools.dotc.util.SourceFile import dotty.tools.io.AbstractFile -import dotty.tools.dotc.fromtasty.TastyFileUtil -import dotty.tools.dotc.config.Settings._ -import dotty.tools.dotc.config.ScalaSettings class SnippetChecker(val args: Scaladoc.Args)(using cctx: CompilerContext): private val sep = System.getProperty("path.separator") @@ -17,16 +12,20 @@ class SnippetChecker(val args: Scaladoc.Args)(using cctx: CompilerContext): private val fullClasspath = List( args.tastyFiles .map(_.getAbsolutePath()) - .map(AbstractFile.getFile(_)) - .flatMap(t => try { TastyFileUtil.getClassPath(t) } catch { case e: AssertionError => Seq() }) - .distinct.mkString(sep), + .map(AbstractFile.getFile(_).nn) + .flatMap(t => try TastyFileUtil.getClassPath(t) catch case _: AssertionError => Seq.empty) + .distinct + .mkString(sep), args.classpath ).mkString(sep) - private val snippetCompilerSettings: Seq[SnippetCompilerSetting[?]] = cctx.settings.userSetSettings(cctx.settingsState).filter(_ != cctx.settings.classpath) - .map[SnippetCompilerSetting[?]]( s => - SnippetCompilerSetting(s, s.valueIn(cctx.settingsState)) - ) :+ SnippetCompilerSetting(cctx.settings.classpath, fullClasspath) + private val snippetCompilerSettings: Seq[SnippetCompilerSetting[?]] = + val userSetSettings = + cctx.settings.userSetSettings(cctx.settingsState) + .filter(_ != cctx.settings.classpath) + .map[SnippetCompilerSetting[?]]: setting => + SnippetCompilerSetting(setting, setting.valueIn(cctx.settingsState)) + userSetSettings :+ SnippetCompilerSetting(cctx.settings.classpath, fullClasspath) private val compiler: SnippetCompiler = SnippetCompiler(snippetCompilerSettings = snippetCompilerSettings) @@ -36,23 +35,31 @@ class SnippetChecker(val args: Scaladoc.Args)(using cctx: CompilerContext): arg: SnippetCompilerArg, sourceFile: SourceFile, sourceColumnOffset: Int - ): Option[SnippetCompilationResult] = { + ): Option[SnippetCompilationResult] = if arg.flag != SCFlags.NoCompile then val baseLineOffset = data.fold(0)(_.position.line) val baseColumnOffset = data.fold(0)(_.position.column) + sourceColumnOffset + val sourceLines = snippet.sourceLines.map(_.map(_ + baseLineOffset)) + val adjustedSnippet = snippet.copy( + sourceLines = sourceLines, + outerLineOffset = snippet.outerLineOffset + baseLineOffset + ) val wrapped = WrappedSnippet( snippet.snippet, data.map(_.packageName), snippet.outerLineOffset + baseLineOffset, baseColumnOffset, - snippet.sourceLines.map(_.map(_ + baseLineOffset)) + sourceLines ) - Some(compiler.compile(wrapped, arg, sourceFile)) + Some(compiler.compile( + adjustedSnippet, + wrapped, + arg, + sourceFile + )) else None - } - object SnippetChecker: // The first line of snippet content is two lines below the opening code fence. val codeFenceContentLineOffset = 2 diff --git a/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilationResult.scala b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilationResult.scala index b7cafacc684d..c134f49f7755 100644 --- a/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilationResult.scala +++ b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilationResult.scala @@ -8,6 +8,7 @@ case class Position(srcPos: SourcePosition, relativeLine: Int) case class SnippetCompilerMessage(position: Option[Position], message: String, level: MessageLevel): def emit()(using CompilerContext): Unit = + given CompilerContext = position.fold(summon[CompilerContext])(pos => summon[CompilerContext].withSource(pos.srcPos.source)) val pos: SrcPos = position.fold(dotty.tools.dotc.util.NoSourcePosition)(_.srcPos) level match case MessageLevel.Info => report.log(message, pos) diff --git a/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompiler.scala b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompiler.scala index bca2a8c89da6..9fd6cb880cb6 100644 --- a/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompiler.scala +++ b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompiler.scala @@ -7,19 +7,10 @@ import dotty.tools.dotc.core.Contexts.Context import dotty.tools.dotc.core.Mode import dotty.tools.dotc.core.MacroClassLoader import dotty.tools.dotc.config.Settings.Setting._ -import dotty.tools.dotc.interfaces.{ SourcePosition => ISourcePosition } -import dotty.tools.dotc.ast.Trees.Tree -import dotty.tools.dotc.interfaces.{SourceFile => ISourceFile} -import dotty.tools.dotc.reporting.{ Diagnostic, StoreReporter } -import dotty.tools.dotc.parsing.Parsers.Parser +import dotty.tools.dotc.reporting.StoreReporter import dotty.tools.dotc.{ Compiler, Run } -import dotty.tools.io.{AbstractFile, VirtualDirectory} -import dotty.tools.io.AbstractFileClassLoader -import dotty.tools.dotc.util.Spans._ -import dotty.tools.dotc.interfaces.Diagnostic._ -import dotty.tools.dotc.util.{ SourcePosition, NoSourcePosition, SourceFile } - -import scala.util.{ Try, Success, Failure } +import dotty.tools.dotc.util.{SourceFile, SourcePosition} +import dotty.tools.dotc.util.Spans.NoSpan class SnippetCompiler( val snippetCompilerSettings: Seq[SnippetCompilerSetting[?]], @@ -49,49 +40,12 @@ class SnippetCompiler( private def newRun(using ctx: Context): Run = scala3Compiler.newRun - private def nullableMessage(msgOrNull: String | Null): String = - if (msgOrNull == null) "" else msgOrNull - - private def createReportMessage(wrappedSnippet: WrappedSnippet, diagnostics: Seq[Diagnostic], sourceFile: SourceFile): Seq[SnippetCompilerMessage] = { - val infos = diagnostics.toSeq.sortBy(_.pos.source.path) - val errorMessages = infos.map { - case diagnostic if diagnostic.position.isPresent => - val diagPos = diagnostic.position.get match - case s: SourcePosition => s - case _ => NoSourcePosition - val pos = wrappedSnippet.sourcePosition(diagPos, sourceFile) - val dmsg = Try(diagnostic.message) match { - case Success(msg) => msg - case Failure(ex) => ex.getMessage - } - val msg = nullableMessage(dmsg) - val level = MessageLevel.fromOrdinal(diagnostic.level) - SnippetCompilerMessage(pos, msg, level) - case d => - val level = MessageLevel.fromOrdinal(d.level) - SnippetCompilerMessage(None, nullableMessage(d.message), level) - } - errorMessages - } - - private def additionalMessages(wrappedSnippet: WrappedSnippet, arg: SnippetCompilerArg, sourceFile: SourceFile, context: Context): Seq[SnippetCompilerMessage] = { - Option.when(arg.flag == SCFlags.Fail && !context.reporter.hasErrors)( - SnippetCompilerMessage( - Some(Position(SourcePosition(sourceFile, NoSpan), wrappedSnippet.outerLineOffset)), - "Snippet should not compile but compiled successfully", MessageLevel.Error) - ).toList - } - - private def isSuccessful(arg: SnippetCompilerArg, context: Context): Boolean = { - if arg.flag == SCFlags.Fail then context.reporter.hasErrors - else !context.reporter.hasErrors - } - def compile( + snippet: SnippetSource, wrappedSnippet: WrappedSnippet, arg: SnippetCompilerArg, sourceFile: SourceFile - ): SnippetCompilationResult = { + ): SnippetCompilationResult = val baseContext = SnippetDriver.currentCtx.fresh .setSetting( SnippetDriver.currentCtx.settings.outputDir, @@ -108,10 +62,36 @@ class SnippetCompiler( val run = newRun(using context) run.compileFromStrings(List(wrappedSnippet.snippet)) - val messages = - createReportMessage(wrappedSnippet, context.reporter.pendingMessages(using context), sourceFile) ++ - additionalMessages(wrappedSnippet, arg, sourceFile, context) + val diagnostics = context.reporter.pendingMessages(using context) + val observed = SnippetExpectations.observe(diagnostics, wrappedSnippet, sourceFile) + + val (messages, succeeded) = + if arg.verifyDiagnostics then + val expected = SnippetExpectations.parse(snippet, sourceFile) + val validation = SnippetExpectations.validate(expected, observed, sourceFile) + val failCheck = + if arg.flag == SCFlags.Fail && expected.expectedErrors == 0 && !context.reporter.hasErrors then + List(SnippetCompilerMessage(None, s"No errors found when compiling snippet in $sourceFile:\n${wrappedSnippet.snippet}", MessageLevel.Error)) + else Nil + val errors = validation ++ failCheck + val hasMismatches = errors.exists(_.level == MessageLevel.Error) + val msgs = + if hasMismatches then errors + else observed.map(_.message) ++ errors + val ok = !hasMismatches + && (arg.flag != SCFlags.Fail || context.reporter.hasErrors || expected.expectedErrors > 0) + (msgs, ok) + else + val failMsg = Option.when(arg.flag == SCFlags.Fail && !context.reporter.hasErrors)( + SnippetCompilerMessage( + Some(Position(SourcePosition(sourceFile, NoSpan), wrappedSnippet.outerLineOffset)), + s"Snippet should not compile but compiled successfully in $sourceFile:\n${wrappedSnippet.snippet}", MessageLevel.Error) + ) + val msgs = observed.map(_.message) ++ failMsg + val ok = + if arg.flag == SCFlags.Fail then context.reporter.hasErrors + else !context.reporter.hasErrors + (msgs, ok) val t = Option.when(!context.reporter.hasErrors)(target) - SnippetCompilationResult(wrappedSnippet, isSuccessful(arg, context), t, messages) - } + SnippetCompilationResult(wrappedSnippet, succeeded, t, messages) diff --git a/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilerArgs.scala b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilerArgs.scala index 78641d4a2ff0..9f7366d00812 100644 --- a/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilerArgs.scala +++ b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetCompilerArgs.scala @@ -3,11 +3,19 @@ package snippets import java.nio.file.Path -case class SnippetCompilerArg(flag: SCFlags, scalacOptions: Seq[String] = Seq.empty): +case class SnippetCompilerArg( + flag: SCFlags, + scalacOptions: Seq[String] = Seq.empty, + verifyDiagnostics: Boolean = false +): def overrideFlag(f: SCFlags): SnippetCompilerArg = copy(flag = f) def withScalacOptions(opts: Seq[String]): SnippetCompilerArg = copy(scalacOptions = scalacOptions ++ opts) def merge(other: SnippetCompilerArg): SnippetCompilerArg = - SnippetCompilerArg(other.flag, scalacOptions ++ other.scalacOptions) + SnippetCompilerArg( + other.flag, + scalacOptions ++ other.scalacOptions, + verifyDiagnostics || other.verifyDiagnostics + ) enum SCFlags(val flagName: String): case Compile extends SCFlags("compile") @@ -27,22 +35,27 @@ case class SnippetCompilerArgs(scArgs: PathBased[SnippetCompilerArg], defaultFla object SnippetCompilerArgs: + /** Enables inline diagnostic expectation checking (`// error`, `// warn`). */ + val TestModifier = "test" + val usage = - """ + s""" |Snippet compiler arguments provide a way to configure snippet type checking. | - |This setting accept list of arguments in format: + |This setting accepts a list of arguments in format: |args := arg{,arg} - |arg := [path=]flag[|scalacOption]* - |where `path` is a prefix of the path to source files where snippets are located, `flag` is the mode in which snippets will be type checked, and optional `scalacOption`s (separated by `|`) are passed to the compiler. + |arg := [path=]flag[+modifier]*[|scalacOption]* + |where `path` is a prefix of the path to source files where snippets are located, `flag` is the mode in which snippets will be type checked, optional `modifier`s tweak snippet assertions, and optional `scalacOption`s (separated by `|`) are passed to the compiler. | - |If the path is not present, the argument will be used as the default for all unmatched paths.. + |If the path is not present, the argument will be used as the default for all unmatched paths. | |Available flags: |compile - Enables snippet checking. |nocompile - Disables snippet checking. |fail - Enables snippet checking, asserts that snippet doesn't compile. | + |Available modifiers: + |$TestModifier - Enables inline diagnostic expectation checking (`// error`, `// warn`). """.stripMargin def load(args: List[String], defaultFlag: SCFlags = SCFlags.NoCompile)(using CompilerContext): SnippetCompilerArgs = { @@ -68,5 +81,13 @@ object SCFlagsParser extends ArgParser[SCFlags]: object SnippetCompilerArgParser extends ArgParser[SnippetCompilerArg]: def parse(s: String): Either[String, SnippetCompilerArg] = val parts = s.split("\\|") - SCFlagsParser.parse(parts(0)).map: flag => - SnippetCompilerArg(flag, parts.drop(1).toSeq) + val flagAndModifiers = parts.head.split("\\+").toList + val flagText = flagAndModifiers.head + val modifiers = flagAndModifiers.tail + val unknownModifiers = modifiers.filterNot(_ == SnippetCompilerArgs.TestModifier) + val verifyDiagnostics = modifiers.contains(SnippetCompilerArgs.TestModifier) + if unknownModifiers.nonEmpty then + Left(s"${unknownModifiers.mkString(", ")}: Unknown snippet compiler modifier(s).") + else + SCFlagsParser.parse(flagText).map: flag => + SnippetCompilerArg(flag, parts.drop(1).toSeq, verifyDiagnostics) diff --git a/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetExpectations.scala b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetExpectations.scala new file mode 100644 index 000000000000..216355c679a0 --- /dev/null +++ b/scaladoc/src/dotty/tools/scaladoc/snippets/SnippetExpectations.scala @@ -0,0 +1,170 @@ +package dotty.tools.scaladoc +package snippets + +import dotty.tools.dotc.reporting.Diagnostic +import dotty.tools.dotc.util.{SourceFile, SourcePosition} +import dotty.tools.dotc.util.Spans.Span + +import scala.collection.mutable.ListBuffer + +object SnippetExpectations: + // Mirrors the compiler test suite (ParallelTesting.scala): space after `//` is optional. + // Only `// error` and `// warn` are supported; `// anypos-*` is rejected. + private val annotation = + raw"""// *(anypos-)?(error|warn)\b""".r + + private def adjustAtEOF(pos: SourcePosition): SourcePosition = + if pos.span.isSynthetic + && pos.span.isZeroExtent + && pos.span.exists + && pos.source.exists + && pos.span.start == pos.source.length + && pos.span.start > 0 + && pos.source(pos.span.start - 1) == '\n' + then pos.withSpan(pos.span.shift(-1)) + else pos + + private def linePosition(sourceFile: SourceFile, sourceLine: Option[Int], relativeLine: Int): Option[Position] = + sourceLine + .flatMap(sourceFile.lineToOffsetOpt) + .map(offset => Position(SourcePosition(sourceFile, Span(offset, offset)), relativeLine)) + + case class ExpectedDiagnostic( + level: MessageLevel, + sourceLine: Option[Int], + relativeLine: Int + ): + def position(sourceFile: SourceFile): Option[Position] = + linePosition(sourceFile, sourceLine, relativeLine) + + def description: String = + s"${level.text.toLowerCase} on line ${sourceLine.fold(relativeLine + 1)(_ + 1)}" + + // Matching is line-based only; column position is not checked. + // Diagnostic message content is intentionally ignored. + def matches(observed: ObservedDiagnostic): Boolean = + observed.message.level == level && sourceLine == observed.sourceLine + + case class Parsed( + expectations: Seq[ExpectedDiagnostic], + parserErrors: Seq[SnippetCompilerMessage] + ): + def hasExpectations: Boolean = expectations.nonEmpty + def expectedErrors: Int = expectations.count(_.level == MessageLevel.Error) + + case class ObservedDiagnostic( + message: SnippetCompilerMessage, + renderPosition: Option[Position], + sourceLine: Option[Int] + ) + + /** Validates `observed` diagnostics of the given `level` against `expectations`. + * Returns error messages describing any mismatches, or `Nil` if everything matches. */ + private def validateLevel( + level: MessageLevel, + expectations: Seq[ExpectedDiagnostic], + observed: Seq[ObservedDiagnostic], + sourceFile: SourceFile + ): Seq[SnippetCompilerMessage] = + val levelName = level.text.toLowerCase + if expectations.isEmpty then + if observed.isEmpty then Nil + else + val ann = if level == MessageLevel.Warning then "warn" else "error" + val summary = SnippetCompilerMessage(None, + s"No expected ${levelName}s marked in snippet -- use // $ann\nactual $levelName count: ${observed.size}", + MessageLevel.Error) + summary +: observed.map(o => + SnippetCompilerMessage(o.message.position, s"Unexpected ${describeObserved(o)}", MessageLevel.Error)) + else + val matched = Array.fill(observed.size)(false) + val errors = ListBuffer.empty[SnippetCompilerMessage] + + for expectation <- expectations.sortBy(_.relativeLine) do + observed.indices.find(i => !matched(i) && expectation.matches(observed(i))) match + case Some(i) => matched(i) = true + case None => + errors += SnippetCompilerMessage( + expectation.position(sourceFile), s"Unfulfilled expectation: ${expectation.description}", MessageLevel.Error) + + for i <- observed.indices if !matched(i) do + errors += SnippetCompilerMessage( + observed(i).message.position, s"Unexpected ${describeObserved(observed(i))}", MessageLevel.Error) + + if errors.isEmpty then Nil + else + val summary = + if expectations.size != observed.size then + s"Wrong number of ${levelName}s encountered when compiling snippet\nexpected: ${expectations.size}, actual: ${observed.size}" + else + s"${level.text}s found on incorrect row numbers when compiling snippet" + SnippetCompilerMessage(None, summary, MessageLevel.Error) +: errors.toSeq + + private def describeObserved(o: ObservedDiagnostic): String = + val name = o.message.level.text.toLowerCase + o.sourceLine match + case Some(line) => s"$name on line ${line + 1}" + case None => s"$name at an unknown position" + + /** Scans `snippet` for inline diagnostic annotations (`// error`, `// warn`). + * Returns parsed expectations together with any parse-level errors. */ + def parse(snippet: SnippetSource, sourceFile: SourceFile): Parsed = + val expectations = ListBuffer.empty[ExpectedDiagnostic] + val parserErrors = ListBuffer.empty[SnippetCompilerMessage] + + for ((line, sourceLine), relativeLine) <- snippet.snippet.linesIterator.zip(snippet.sourceLines).zipWithIndex do + for m <- annotation.findAllMatchIn(line) do + val isAnypos = m.group(1) != null + val level = if m.group(2) == "warn" then MessageLevel.Warning else MessageLevel.Error + if isAnypos then + val ann = if level == MessageLevel.Warning then "warn" else "error" + parserErrors += SnippetCompilerMessage( + linePosition(sourceFile, sourceLine, relativeLine), + s"Unsupported snippet diagnostic annotation `// anypos-$ann`; use `// $ann`", + MessageLevel.Error) + else + expectations += ExpectedDiagnostic(level, sourceLine, relativeLine) + + Parsed(expectations.toList, parserErrors.toList) + + /** Converts raw compiler diagnostics into [[ObservedDiagnostic]]s by mapping + * positions back from the synthetic wrapper to the original snippet source. */ + def observe( + diagnostics: Seq[Diagnostic], + wrappedSnippet: WrappedSnippet, + sourceFile: SourceFile + ): Seq[ObservedDiagnostic] = + diagnostics.toSeq.map: diagnostic => + val msg = try diagnostic.message catch case _: Exception => "" + // Relies on MessageLevel ordinals matching dotty.tools.dotc.interfaces.Diagnostic + // integer constants: INFO=0, WARNING=1, ERROR=2. + val level = MessageLevel.fromOrdinal(diagnostic.level) + val rawPos = adjustAtEOF(diagnostic.pos.nonInlined) + val mappedPos = + if rawPos.exists then wrappedSnippet.sourcePosition(rawPos, sourceFile) + else None + val renderPos = + if rawPos.exists then wrappedSnippet.sourceSpanPosition(rawPos, sourceFile) + else None + ObservedDiagnostic( + SnippetCompilerMessage(mappedPos, msg, level), + renderPos, + mappedPos.map(_.srcPos.line) + ) + + /** Matches observed diagnostics against parsed expectations. + * Returns error messages for any mismatches, or `Nil` when all match. */ + def validate( + parsed: Parsed, + observed: Seq[ObservedDiagnostic], + sourceFile: SourceFile + ): Seq[SnippetCompilerMessage] = + val errorExpectations = parsed.expectations.filter(_.level == MessageLevel.Error) + val warningExpectations = parsed.expectations.filter(_.level == MessageLevel.Warning) + val errorDiagnostics = observed.filter(_.message.level == MessageLevel.Error) + val warningDiagnostics = observed.filter(_.message.level == MessageLevel.Warning) + + parsed.parserErrors + ++ validateLevel(MessageLevel.Error, errorExpectations, errorDiagnostics, sourceFile) + ++ validateLevel(MessageLevel.Warning, warningExpectations, warningDiagnostics, + sourceFile) diff --git a/scaladoc/src/dotty/tools/scaladoc/snippets/WrappedSnippet.scala b/scaladoc/src/dotty/tools/scaladoc/snippets/WrappedSnippet.scala index 1ea1f2bb9bb9..2ef42b3d84a8 100644 --- a/scaladoc/src/dotty/tools/scaladoc/snippets/WrappedSnippet.scala +++ b/scaladoc/src/dotty/tools/scaladoc/snippets/WrappedSnippet.scala @@ -21,6 +21,12 @@ case class WrappedSnippet( .flatten .flatMap(_.sourcePosition(diagPos, sourceFile, outerColumnOffset)) + def sourceSpanPosition(diagPos: SourcePosition, sourceFile: SourceFile): Option[Position] = + lineMappings + .lift(diagPos.line) + .flatten + .flatMap(_.sourceSpanPosition(diagPos, sourceFile, outerColumnOffset)) + object WrappedSnippet: // `wrappedColumnOffset` accounts for indentation added by the synthetic wrapper. case class WrappedLineMapping(sourceLine: Int, relativeLine: Int, wrappedColumnOffset: Int): @@ -28,13 +34,33 @@ object WrappedSnippet: diagPos: SourcePosition, sourceFile: SourceFile, outerColumnOffset: Int + ): Option[Position] = + mapPosition(diagPos, sourceFile, outerColumnOffset, diagPos.column, diagPos.column) + + def sourceSpanPosition( + diagPos: SourcePosition, + sourceFile: SourceFile, + outerColumnOffset: Int + ): Option[Position] = + val endColumn = + if diagPos.startLine == diagPos.endLine then diagPos.endColumn + else diagPos.startColumn + mapPosition(diagPos, sourceFile, outerColumnOffset, diagPos.startColumn, endColumn) + + private def mapPosition( + diagPos: SourcePosition, + sourceFile: SourceFile, + outerColumnOffset: Int, + startBase: Int, + endBase: Int ): Option[Position] = val lineOffset = sourceFile match case NoSource => Some(0) case sf: SourceFile => sf.lineToOffsetOpt(sourceLine) lineOffset.map: offset => - val sourceColumn = (diagPos.column + outerColumnOffset - wrappedColumnOffset).max(0) - val span = Span(offset + sourceColumn, offset + sourceColumn) + val startColumn = (startBase + outerColumnOffset - wrappedColumnOffset).max(0) + val endColumn = (endBase + outerColumnOffset - wrappedColumnOffset).max(startColumn) + val span = Span(offset + startColumn, offset + endColumn) Position(SourcePosition(sourceFile, span), relativeLine) val indent: Int = 2 diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala index 832d8a691ef8..20d913857232 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala @@ -198,7 +198,7 @@ trait ClassLikeSupport: // First one doesn't always work because .tpe in some cases causes type lambda reductions, eg: // def foo[T : ([X] =>> String)] // after desugaring: - // def foo[T](implicit ecidence$1 : ([X] =>> String)[T]) + // def foo[T](implicit evidence$1 : ([X] =>> String)[T]) // tree for this evidence looks like: ([X] =>> String)[T] // but type repr looks like: String // (see scaladoc-testcases/src/tests/contextBounds.scala) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/InkuireSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/InkuireSupport.scala index dc1e967c619f..72072d7b9d03 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/InkuireSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/InkuireSupport.scala @@ -95,7 +95,7 @@ trait InkuireSupport(using DocContext) extends Resources: case TypeDef(name, _) => name } val vars = variableNames ++ methodVars - val (receiver, preArgs): (Option[Inkuire.TypeLike], Seq[Inkuire.TypeLike]) = Some(classType).filter(_ => !isModule) match { + val (receiver: Option[Inkuire.TypeLike], preArgs: Seq[Inkuire.TypeLike]) = Some(classType).filter(_ => !isModule) match { case None => (methodSymbol.extendedSymbol.flatMap(s => partialAsInkuire(vars).lift(s.tpt)), Seq.empty) case rcvr => (rcvr, methodSymbol.extendedSymbol.flatMap(s => partialAsInkuire(vars).lift(s.tpt)).toSeq) } diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Cleaner.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Cleaner.scala index 88ca3534fcee..b812414cf873 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Cleaner.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Cleaner.scala @@ -1,10 +1,91 @@ package dotty.tools.scaladoc package tasty.comments +/** + * Removes HTML tags except simple ones that can be translated or that are definitely harmless, + * translates Scala/Javadoc tags, and generally cleans the input. + * Not the fastest code in the world, and should eventually be replaced by a real parser, + * but works fine for now. */ object Cleaner { import Regexes._ import java.util.regex.Matcher + // Tags that are considered safe enough and do not need escaping + private val SafeTags = Set( + "a", "abbr", "address", "area", "blockquote", "br", "b", "caption", "cite", "code", "col", "colgroup", + "dd", "del", "dfn", "em", "hr", "img", "ins", "i", "kbd", "label", "legend", "pre", "q", "samp", + "small", "span", "strong", "sub", "sup", "table", "tbody", "td", "tfoot", "th", "thead", "tr", "var" + ) + + private def cleanHtml(text: String): String = { + val result = StringBuilder() + var index = 0 + var insideCode = false + var insideLink = false + while (index < text.length) { + if (insideCode) { + result.append(text(index)) + if (index >= 2 && text(index) == '`' && text(index - 1) == '`' && text(index - 2) == '`') { + insideCode = false + } + index += 1 + } else if (insideLink) { + result.append(text(index)) + if (index >= 1 && text(index) == ']' && text(index - 1) == ']') { + insideLink = false + } + index += 1 + } else if (index <= text.length - 3 && text(index) == '`' && text(index + 1) == '`' && text(index + 2) == '`') { + result.append("```") + insideCode = true + index += 3 + } else if (index <= text.length - 2 && text(index) == '[' && text(index + 1) == '[') { + result.append("[[") + insideLink = true + index += 2 + } else if (text(index) == safeTagMarker) { + // ignore it, it's a character that should never appear in everyday text anyway + index += 1 + } else if (text(index) == '<') { + val endOfNameIndex = text.indexOf(' ', index) + val endOfTagIndex = text.indexOf('>', index) + if (endOfNameIndex == -1 || endOfNameIndex == index + 1 || endOfTagIndex == -1) { + // not actually a tag, e.g., "< hello >", "a "<" // not actually a tag + case "p" | "div" => "\n\n" + case "h1" => "\n= " + case "/h1" => " =\n" + case "h2" => "\n== " + case "/h2" => " ==\n" + case "h3" => "\n=== " + case "/h3" => " ===\n" + case "h4" | "h5" | "h6" => "\n==== " + case "/h4" | "/h5" | "/h6" => " ====\n" + case "li" => "\n * - " + case "/li" => "" + case other => + val simple = if (other(0) == '/') other.substring(1) else other + if (SafeTags(simple)) { + s"$safeTagMarker${text.substring(index, endOfTagIndex + 1)}$safeTagMarker" + } else { + "" + } + }) + index = endOfTagIndex + 1 + } + } else { + result.append(text(index)) + index += 1 + } + } + result.toString + } + /** Prepares the comment for pre-parsing: removes documentation markers and * extra whitespace, removes dangerous HTML and Javadoc tags, and splits it * into lines. @@ -18,12 +99,8 @@ object Cleaner { } } val strippedComment = comment.trim.stripPrefix("/*").stripSuffix("*/") - val safeComment = DangerousTags.replaceAllIn(strippedComment, { htmlReplacement(_) }) - val javadoclessComment = JavadocTags.replaceAllIn(safeComment, { javadocReplacement(_) }) - val markedTagComment = - SafeTags.replaceAllIn(javadoclessComment, { mtch => - Matcher.quoteReplacement(s"$safeTagMarker${mtch.matched}$safeTagMarker") - }) - markedTagComment.linesIterator.toList map (cleanLine) + val safeComment = cleanHtml(strippedComment) + val javadoclessComment = JavadocTags.replaceAllIn(safeComment, javadocReplacement) + javadoclessComment.linesIterator.toList.map(cleanLine) } } diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/CommentRegex.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/CommentRegex.scala index 3ff022198446..4de66d04ec2f 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/CommentRegex.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/CommentRegex.scala @@ -12,12 +12,6 @@ object Regexes { val CleanCommentLine = new Regex("""(?:\s*\*\s?\s?)?(.*)""") - /** Dangerous HTML tags that should be replaced by something safer, - * such as wiki syntax, or that should be dropped - */ - val DangerousTags = - new Regex("""<(/?(div|ol|ul|li|h[1-6]|p))( [^>]*)?/?>|""") - /** Javadoc tags that should be replaced by something useful, such as wiki * syntax, or that should be dropped. */ val JavadocTags = @@ -36,27 +30,7 @@ object Regexes { } } - /** Maps a dangerous HTML tag to a safe wiki replacement, or an empty string - * if it cannot be salvaged. */ - def htmlReplacement(mtch: Regex.Match): String = mtch.group(1) match { - case "p" | "div" => "\n\n" - case "h1" => "\n= " - case "/h1" => " =\n" - case "h2" => "\n== " - case "/h2" => " ==\n" - case "h3" => "\n=== " - case "/h3" => " ===\n" - case "h4" | "h5" | "h6" => "\n==== " - case "/h4" | "/h5" | "/h6" => " ====\n" - case "li" => "\n * - " - case _ => "" - } - - /** Safe HTML tags that can be kept. */ - val SafeTags = - new Regex("""((&\w+;)|(&#\d+;)|(]*)?/?>))""") - - val safeTagMarker = '\u000E' + val safeTagMarker = '\u000E' // IMPORTANT: Only change if you've updated the sanitization tests to match val endOfLine = '\u000A' val endOfText = '\u0003' diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala index 40da87cb33a3..9c164f07223f 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala @@ -89,7 +89,7 @@ abstract class MarkupConversion[T](val repr: Repr)(using dctx: DocContext) { private given qctx.type = qctx lazy val srcPos = if owner == qctx.reflect.defn.RootClass then { - val sourceFile = dctx.args.rootDocPath.map(p => dotty.tools.dotc.util.SourceFile(dotty.tools.io.AbstractFile.getFile(p), scala.io.Codec.UTF8)) + val sourceFile = dctx.args.rootDocPath.map(p => dotty.tools.dotc.util.SourceFile(dotty.tools.io.AbstractFile.getFile(p).nn, scala.io.Codec.UTF8)) sourceFile.fold(dotty.tools.dotc.util.NoSourcePosition)(sf => dotty.tools.dotc.util.SourcePosition(sf, dotty.tools.dotc.util.Spans.NoSpan)) } else owner.pos.get.asInstanceOf[dotty.tools.dotc.util.SrcPos] diff --git a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala index 574d94a7e064..0f2616a5d5c7 100644 --- a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala +++ b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala @@ -1,7 +1,10 @@ package dotty.tools.scaladoc package translators +import dotty.tools.dotc.util.chaining.* + case class SignatureBuilder(content: Signature = Nil) extends ScalaSignatureUtils: + assert(content != null) def plain(str: String): SignatureBuilder = copy(content = content :+ Plain(str)) def name(str: String, dri: DRI, isCaptureVar: Boolean = false/*under CC*/): SignatureBuilder = val suffix = if isCaptureVar then List(Keyword("^")) else Nil @@ -24,7 +27,10 @@ case class SignatureBuilder(content: Signature = Nil) extends ScalaSignatureUtil ): SignatureBuilder = elements match { case Nil => if forcePrefixAndSuffix then signature(prefix).signature(suffix) else this case head :: tail => - tail.foldLeft(elemOp(signature(prefix), head))((b, e) => elemOp(b.signature(separator), e)).signature(suffix) + tail.foldLeft(elemOp(signature(prefix), head)): (b, e) => + val sepped = b.signature(separator) + elemOp(sepped, e) + .signature(suffix) } def annotationsBlock(d: Member): SignatureBuilder = @@ -92,9 +98,13 @@ case class SignatureBuilder(content: Signature = Nil) extends ScalaSignatureUtil def termParamList(params: TermParameterList) = this.list(params.parameters, prefix = List(Plain("("), Keyword(params.modifiers)), suffix = List(Plain(")")), forcePrefixAndSuffix = true) { (bld, p) => - val annotationsAndModifiers = bld.annotationsInline(p) - .keyword(p.modifiers) - val name = p.name.fold(annotationsAndModifiers)(annotationsAndModifiers.name(_, p.dri).plain(": ")) + val annotationsAndModifiers = + bld.annotationsInline(p) + .keyword(p.modifiers) + val name = p.name match { + case Some(name) => annotationsAndModifiers.name(name, p.dri).plain(": ") + case none => annotationsAndModifiers + } name.signature(p.signature) } diff --git a/scaladoc/test/dotty/tools/scaladoc/BaseHtmlTest.scala b/scaladoc/test/dotty/tools/scaladoc/BaseHtmlTest.scala index e8567193c312..6392c44730f7 100644 --- a/scaladoc/test/dotty/tools/scaladoc/BaseHtmlTest.scala +++ b/scaladoc/test/dotty/tools/scaladoc/BaseHtmlTest.scala @@ -70,3 +70,19 @@ class BaseHtmlTest: assertTrue(s"File at $path does not exisits!", Files.exists(path)) val document = Jsoup.parse(IO.read(path)) op(DocumentContext(document, path)) + + def docHtml(dir: String, cls: String, syntax: String): String = + val dest = Files.createTempDirectory("test-doc").toFile + try + val args = Scaladoc.Args( + name = projectName, + tastyFiles = tastyFiles(dir), + output = dest, + projectVersion = Some(projectVersion), + defaultSyntax = List(syntax), + ) + Scaladoc.run(args)(using testContext) + val path = dest.toPath.resolve(s"tests/$dir/$cls.html") + val doc = org.jsoup.Jsoup.parse(dotty.tools.scaladoc.util.IO.read(path)) + doc.select(".doc").html() + finally dotty.tools.scaladoc.util.IO.delete(dest) \ No newline at end of file diff --git a/scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala b/scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala index 6440794da5cd..9b4e68ac974f 100644 --- a/scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala +++ b/scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala @@ -88,7 +88,7 @@ abstract class ExternalLocationProviderIntegrationTest( } IO.foreachFileIn(output, processFile) - val links = linksBuilder.result + val links = linksBuilder.result() val errors = expectedLinks.flatMap(expect => Option.when(!links.contains(expect))(expect)) if !errors.isEmpty then { val reportMessage = diff --git a/scaladoc/test/dotty/tools/scaladoc/signatures/AbstractMemberSignaturesTest.scala b/scaladoc/test/dotty/tools/scaladoc/signatures/AbstractMemberSignaturesTest.scala index 72124ab2fbcc..09b1ea3fbaf9 100644 --- a/scaladoc/test/dotty/tools/scaladoc/signatures/AbstractMemberSignaturesTest.scala +++ b/scaladoc/test/dotty/tools/scaladoc/signatures/AbstractMemberSignaturesTest.scala @@ -42,4 +42,4 @@ class AbstractMembers extends ScaladocTest("abstractmembersignatures"): } } IO.foreachFileIn(output, processFile) - signatures.result.groupMap(_._1)(_._2) + signatures.result().groupMap(_._1)(_._2) diff --git a/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala b/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala index 9dc24169b65e..54b9cc321f9b 100644 --- a/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala +++ b/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala @@ -92,7 +92,7 @@ abstract class SignatureTest( yield name private def signaturesFromSources(source: Source, kinds: Seq[String]): Seq[SignatureRes] = - source.getLines.map(_.trim) + source.getLines().map(_.trim) .filterNot(_.isEmpty) .filterNot(l => l.startWithAnyOfThese("=",":","{","}", "//") && !l.startsWith("//expected:")) .toSeq @@ -129,7 +129,7 @@ abstract class SignatureTest( } IO.foreachFileIn(output, processFile) - signatures.result + signatures.result() object SignatureTest { val classlikeKinds = Seq("class", "object", "trait", "enum") // TODO add docs for packages diff --git a/scaladoc/test/dotty/tools/scaladoc/site/TemplateFileTests.scala b/scaladoc/test/dotty/tools/scaladoc/site/TemplateFileTests.scala index 1e8a9259818d..3544b4bcca52 100644 --- a/scaladoc/test/dotty/tools/scaladoc/site/TemplateFileTests.scala +++ b/scaladoc/test/dotty/tools/scaladoc/site/TemplateFileTests.scala @@ -344,8 +344,6 @@ class TemplateFileTests: loadTemplateFile(first).resolveInner(RenderingContext(Map.empty)) loadTemplateFile(second).resolveInner(RenderingContext(Map.empty)) - assertEquals(0, dctx.compilerContext.reportedDiagnostics.errors.size) - summon[StaticSiteContext].reportSnippetMessages() val diagnostics = dctx.compilerContext.reportedDiagnostics @@ -356,6 +354,40 @@ class TemplateFileTests: ) finally IO.delete(tmpRoot) + @Test + def markdownInlineExpectationsCanValidateFailingSnippets(): Unit = + val tmpRoot = Files.createTempDirectory("snippet-inline-checks").toFile() + val tmpDocs = File(tmpRoot, "_docs") + val tmpFile = File(tmpDocs, "checks.md") + try + Files.createDirectories(tmpDocs.toPath) + Files.write( + tmpFile.toPath, + """--- + |title: "Snippet inline checks" + |--- + | + |```scala sc:fail + |val x = 1.missing // error + |``` + |""".stripMargin.getBytes + ) + + val dctx = DocContext( + testArgs().copy( + docsRoot = Some(tmpRoot.getAbsolutePath), + snippetCompiler = List(s"${tmpFile.getAbsolutePath}=compile+test") + ), + testContext + ) + given StaticSiteContext = dctx.staticSiteContext.get + + loadTemplateFile(tmpFile).resolveInner(RenderingContext(Map.empty)) + summon[StaticSiteContext].reportSnippetMessages() + + assertEquals(0, dctx.compilerContext.reportedDiagnostics.errors.size) + finally IO.delete(tmpRoot) + private def renderNamedSnippet(relativePath: String, noSnippetNamesFor: List[String] = Nil): String = val tmpRoot = Files.createTempDirectory("snippet-name-rendering").toFile() val tmpFile = File(tmpRoot, relativePath) diff --git a/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetCompilerTest.scala b/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetCompilerTest.scala index 3b7631a87191..256b91855953 100644 --- a/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetCompilerTest.scala +++ b/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetCompilerTest.scala @@ -3,7 +3,6 @@ package snippets import org.junit.Test import org.junit.Assert._ -import dotty.tools.io.{AbstractFile, VirtualDirectory} class SnippetCompilerTest { val compiler = SnippetCompiler( @@ -16,7 +15,14 @@ class SnippetCompilerTest { 0, ) - def runTest(str: String) = compiler.compile(wrapFn(str), SnippetCompilerArg(SCFlags.Compile), dotty.tools.dotc.util.SourceFile.virtual("test", str)) + private def sourceFile(str: String) = + dotty.tools.dotc.util.SourceFile.virtual("test", str) + + def runTest( + str: String, + arg: SnippetCompilerArg = SnippetCompilerArg(SCFlags.Compile) + ) = + compiler.compile(SnippetSource(str, 0), wrapFn(str), arg, sourceFile(str)) private def assertSuccessfulCompilation(res: SnippetCompilationResult): Unit = res match { case r @ SnippetCompilationResult(_, isSuccessful, _, messages) => assert(isSuccessful, r.messages.map(_.message).mkString("\n")) @@ -84,4 +90,182 @@ class SnippetCompilerTest { |def foo[C^](x: AnyRef^{C}): AnyRef^{x} = x |""".stripMargin) } + + @Test + def inlineExpectedErrorsCanDriveNegativeSnippets: Unit = { + val snippet = + """|val x = 1.missing // error + |""".stripMargin + + val result = runTest(snippet, SnippetCompilerArg(SCFlags.Compile, verifyDiagnostics = true)) + assertSuccessfulCompilation(result) + assertMessageLevelPresent(result, MessageLevel.Error) + } + + @Test + def testedSnippetsWithoutDiagnosticsPass: Unit = { + val snippet = + """|val x = 1 + 1 + |""".stripMargin + + assertSuccessfulCompilation(runTest(snippet, SnippetCompilerArg(SCFlags.Compile, verifyDiagnostics = true))) + } + + @Test + def testedSnippetsRequireErrorAnnotations: Unit = { + val snippet = + """|val x = 1.missing + |""".stripMargin + + val result = runTest(snippet, SnippetCompilerArg(SCFlags.Compile, verifyDiagnostics = true)) + assertFailedCompilation(result) + assertEquals(2, result.messages.count(_.level == MessageLevel.Error)) + assertTrue(result.messages.exists(_.message.contains("No expected errors marked in snippet -- use // error"))) + assertTrue(result.messages.exists(_.message.contains("Unexpected error on line 1"))) + } + + @Test + def testedSnippetsRequireWarningAnnotations: Unit = { + val snippet = + """|val a: Int = try { 5 } + |""".stripMargin + + val result = runTest(snippet, SnippetCompilerArg(SCFlags.Compile, verifyDiagnostics = true)) + assertFailedCompilation(result) + assertEquals(2, result.messages.count(_.level == MessageLevel.Error)) + assertTrue(result.messages.exists(_.message.contains("No expected warnings marked in snippet -- use // warn"))) + assertTrue(result.messages.exists(_.message.contains("Unexpected warning on line 1"))) + } + + @Test + def inlineExpectedErrorsWorkWithFailFlag: Unit = { + val snippet = + """|val x = 1.missing // error + |""".stripMargin + + assertSuccessfulCompilation(runTest(snippet, SnippetCompilerArg(SCFlags.Fail, verifyDiagnostics = true))) + } + + @Test + def testedFailSnippetsNeedExpectedErrors: Unit = { + val snippet = + """|val x = 1 + 1 + |""".stripMargin + + val result = runTest(snippet, SnippetCompilerArg(SCFlags.Fail, verifyDiagnostics = true)) + assertFailedCompilation(result) + assertTrue(result.messages.exists(_.message.contains("No errors found when compiling snippet"))) + } + + @Test + def inlineExpectedDiagnosticMessagesAreIgnored: Unit = { + val snippet = + """|val x = 1.missing // error: /totally different/ + |""".stripMargin + + assertSuccessfulCompilation(runTest(snippet, SnippetCompilerArg(SCFlags.Compile, verifyDiagnostics = true))) + } + + @Test + def inlineExpectationRowMismatchesUseNegTestWording: Unit = { + val snippet = + """|val x = 1.missing + |val y = 1 + 1 // error + |""".stripMargin + + val result = runTest(snippet, SnippetCompilerArg(SCFlags.Compile, verifyDiagnostics = true)) + assertFailedCompilation(result) + assertEquals(3, result.messages.count(_.level == MessageLevel.Error)) + assertTrue(result.messages.exists(_.message.contains("Errors found on incorrect row numbers when compiling snippet"))) + assertTrue(result.messages.exists(_.message.contains("Unfulfilled expectation: error on line 2"))) + assertTrue(result.messages.exists(_.message.contains("Unexpected error on line 1"))) + } + + @Test + def inlineExpectationCountMismatchesUseNegTestWording: Unit = { + val snippet = + """|val x = 1.missing // error + |val y = 1 + 1 // error + |""".stripMargin + + val result = runTest(snippet, SnippetCompilerArg(SCFlags.Compile, verifyDiagnostics = true)) + assertFailedCompilation(result) + assertEquals(2, result.messages.count(_.level == MessageLevel.Error)) + assertTrue(result.messages.exists(_.message.contains("Wrong number of errors encountered when compiling snippet"))) + assertTrue(result.messages.exists(_.message.contains("expected: 2, actual: 1"))) + assertTrue(result.messages.exists(_.message.contains("Unfulfilled expectation: error on line 2"))) + } + + @Test + def inlineExpectationParserAcceptsTrailingProseAndWarnings: Unit = { + val snippet = + """|val x = 1.missing // error // explanatory prose + |val y: Int = try { 5 } // warn // more prose + |val z = 1.missing // error: not a member + |""".stripMargin + + val parsed = SnippetExpectations.parse(SnippetSource(snippet, 0), sourceFile(snippet)) + assertTrue(parsed.parserErrors.isEmpty) + assertEquals(3, parsed.expectations.size) + assertEquals(2, parsed.expectedErrors) + assertEquals(1, parsed.expectations.count(_.level == MessageLevel.Warning)) + } + + @Test + def inlineExpectationParserRejectsAnyposAnnotations: Unit = { + val snippet = + """|val x = 1.missing // anypos-error + |val y: Int = try { 5 } // anypos-warn + |""".stripMargin + + val parsed = SnippetExpectations.parse(SnippetSource(snippet, 0), sourceFile(snippet)) + val errors = parsed.parserErrors.map(_.message) + assertEquals(2, parsed.parserErrors.size) + assertEquals(0, parsed.expectations.size) + assertTrue(errors.exists(_.contains("Unsupported snippet diagnostic annotation `// anypos-error`; use `// error`"))) + assertTrue(errors.exists(_.contains("Unsupported snippet diagnostic annotation `// anypos-warn`; use `// warn`"))) + } + + @Test + def inlineExpectedWarningsAreChecked: Unit = { + val warningSnippet = + """|val a: Int = try { 5 } // warn + |""".stripMargin + + val result = runTest(warningSnippet, SnippetCompilerArg(SCFlags.Compile, verifyDiagnostics = true)) + assertSuccessfulCompilation(result) + assertMessageLevelPresent(result, MessageLevel.Warning) + } + + @Test + def inlineExpectationWarnRowMismatch: Unit = { + // Warning occurs on line 1, but annotation is on line 2 — should fail. + val snippet = + """|val a: Int = try { 5 } + |val b = 1 + 1 // warn + |""".stripMargin + + val result = runTest(snippet, SnippetCompilerArg(SCFlags.Compile, verifyDiagnostics = true)) + assertFailedCompilation(result) + assertTrue(result.messages.exists(_.message.contains("Warnings found on incorrect row numbers when compiling snippet"))) + assertTrue(result.messages.exists(_.message.contains("Unfulfilled expectation: warning on line 2"))) + assertTrue(result.messages.exists(_.message.contains("Unexpected warning on line 1"))) + } + + @Test + def multilineInlineExpectationsAreChecked: Unit = { + val snippet = + """|import language.experimental.captureChecking + |import caps.* + | + |trait File extends SharedCapability + |def withFile[T](path: String)(block: File^ => T): T = ??? + | + |withFile[() => File^]("test.txt"): f => + | () => f // error // error // error + |""".stripMargin + + assertSuccessfulCompilation(runTest(snippet, SnippetCompilerArg(SCFlags.Fail, verifyDiagnostics = true))) + } + } diff --git a/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetsE2eTest.scala b/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetsE2eTest.scala index 2ac4f9cb268b..a55cd2ce92ec 100644 --- a/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetsE2eTest.scala +++ b/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetsE2eTest.scala @@ -23,7 +23,7 @@ abstract class SnippetsE2eTest(testName: String, flag: SCFlags) extends Scaladoc val source = Source.fromFile(s"${BuildInfo.test_testcasesSourceRoot}/tests/$testName.scala") - val snippetsCount = source.getLines.filter(l => l.indexOf("```scala") != -1 && !l.contains("sc-hidden")).size + val snippetsCount = source.getLines().filter(l => l.indexOf("```scala") != -1 && !l.contains("sc-hidden")).size def report(str: String) = s"""|In test $testName: |$str""".stripMargin diff --git a/scaladoc/test/dotty/tools/scaladoc/source-links/SourceLinksTest.scala b/scaladoc/test/dotty/tools/scaladoc/source-links/SourceLinksTest.scala index 1cc4d9c7a7ab..d3fab17b47e0 100644 --- a/scaladoc/test/dotty/tools/scaladoc/source-links/SourceLinksTest.scala +++ b/scaladoc/test/dotty/tools/scaladoc/source-links/SourceLinksTest.scala @@ -50,7 +50,7 @@ class SourceLinkTest: class SourceLinksTest: // TODO (https://github.com/lampepfl/scaladoc/issues/240): configure source root - val projectRoot = Paths.get("").toAbsolutePath() + val projectRoot: Path = Paths.get("").toAbsolutePath() val edit: Operation = "edit" // union types need explicit singletons diff --git a/scaladoc/test/dotty/tools/scaladoc/tasty/comments/CaretTest.scala b/scaladoc/test/dotty/tools/scaladoc/tasty/comments/CaretTest.scala index 645e2d10bfa1..6ec8f1b5ba3a 100644 --- a/scaladoc/test/dotty/tools/scaladoc/tasty/comments/CaretTest.scala +++ b/scaladoc/test/dotty/tools/scaladoc/tasty/comments/CaretTest.scala @@ -13,21 +13,8 @@ import java.nio.file.Files */ class CaretTest extends BaseHtmlTest: - private def docHtml(cls: String, syntax: String = "markdown"): String = - val dest = Files.createTempDirectory("test-doc").toFile - try - val args = Scaladoc.Args( - name = projectName, - tastyFiles = tastyFiles("i25517"), - output = dest, - projectVersion = Some(projectVersion), - defaultSyntax = List(syntax), - ) - Scaladoc.run(args)(using testContext) - val path = dest.toPath.resolve(s"tests/i25517/$cls.html") - val doc = org.jsoup.Jsoup.parse(dotty.tools.scaladoc.util.IO.read(path)) - doc.select(".doc").html() - finally dotty.tools.scaladoc.util.IO.delete(dest) + private def docHtml(cls: String, syntax: String): String = + super.docHtml("i25517", cls, syntax) @Test def supTagsInMarkdown(): Unit = val html = docHtml("SupDefault", "markdown") diff --git a/scaladoc/test/dotty/tools/scaladoc/tasty/comments/TagSanitizationTest.scala b/scaladoc/test/dotty/tools/scaladoc/tasty/comments/TagSanitizationTest.scala new file mode 100644 index 000000000000..d29b6fdba3ed --- /dev/null +++ b/scaladoc/test/dotty/tools/scaladoc/tasty/comments/TagSanitizationTest.scala @@ -0,0 +1,46 @@ +package dotty.tools.scaladoc +package tasty +package comments + +import org.junit.Test +import org.junit.Assert.* + +import java.nio.file.Files + +class TagSanitizationTest extends BaseHtmlTest: + private def docHtml(cls: String): String = + super.docHtml("sanitization", cls, "markdown") + + @Test def scriptTag(): Unit = + val html = docHtml("Script") + assertEquals("

alert('hello')

", html) + + @Test def scriptTagWithSpaces(): Unit = + val html = docHtml("ScriptWithSpaces") + assertEquals("

< script >alert('hello')

", html) + + @Test def scriptTagWithSafeChar(): Unit = + val html = docHtml("FakeSafeScript") + assertEquals("

alert('hello')

", html) + + @Test def notATag(): Unit = + val html = docHtml("NotATag") + assertEquals("

Example < Second <: Third <= Fourth

", html) + + @Test def notATagButHasGreaterThan(): Unit = + val html = docHtml("NotATagButHasGreaterThan") + assertEquals("

Example < Second >: Third

", html) + + @Test def notATagButNoSpaces(): Unit = + val html = docHtml("NotATagButNoSpaces") + assertEquals("

a<b

", html) + + @Test def tagOutsideCode(): Unit = + val html = docHtml("TagOutsideCode") + assertFalse(html, html.contains("")) + + @Test def linkToTagLike(): Unit = + val html = docHtml("LinkToTagLike") + // ensure we don't treat the text between <:< and >:> as a tag content + assertTrue(html, html.contains("or")) diff --git a/scaladoc/test/dotty/tools/scaladoc/tasty/util/TestUtils.scala b/scaladoc/test/dotty/tools/scaladoc/tasty/util/TestUtils.scala index 356268c44b3a..4c5e747fe9c1 100644 --- a/scaladoc/test/dotty/tools/scaladoc/tasty/util/TestUtils.scala +++ b/scaladoc/test/dotty/tools/scaladoc/tasty/util/TestUtils.scala @@ -20,7 +20,7 @@ object TestUtils { if classRoot.isDirectory then val bld = new ListBuffer[String] go(bld)(classRoot) - bld.result + bld.result() else sys.error(s"Class root could not be found: $classRoot") diff --git a/scaladoc/test/dotty/tools/scaladoc/testUtils.scala b/scaladoc/test/dotty/tools/scaladoc/testUtils.scala index cb27623a6e2c..cda989b63a2b 100644 --- a/scaladoc/test/dotty/tools/scaladoc/testUtils.scala +++ b/scaladoc/test/dotty/tools/scaladoc/testUtils.scala @@ -7,7 +7,7 @@ import dotty.tools.dotc.interfaces.Diagnostic.{ERROR, INFO, WARNING} import dotty.tools.scaladoc.test.BuildInfo import org.junit.Assert._ import java.io.File -import java.nio.file.Paths +import java.nio.file.{Path, Paths} case class ReportedDiagnostics(errors: List[Diagnostic], warnings: List[Diagnostic], infos: List[Diagnostic]): @@ -18,7 +18,7 @@ case class ReportedDiagnostics(errors: List[Diagnostic], warnings: List[Diagnost extension (c: CompilerContext) def reportedDiagnostics: ReportedDiagnostics = val t = c.reporter.asInstanceOf[TestReporter] - ReportedDiagnostics(t.errors.result, t.warnings.result, t.infos.result) + ReportedDiagnostics(t.errors.result(), t.warnings.result(), t.infos.result()) def assertNoWarning(diag: ReportedDiagnostics) = assertEquals("Warnings should be empty", Nil, diag.warningMsgs) def assertNoErrors(diag: ReportedDiagnostics) = assertEquals("Erros should be empty", Nil, diag.errorMsgs) @@ -79,4 +79,4 @@ def tastyFiles(name: String, allowEmpty: Boolean = false, rootPck: String = "tes assert(files.nonEmpty || allowEmpty) files.toSeq -def testDocPath = Paths.get(BuildInfo.testDocumentationRoot) \ No newline at end of file +def testDocPath: Path = Paths.get(BuildInfo.testDocumentationRoot) \ No newline at end of file diff --git a/sjs-compiler-tests/test/scala/dotty/tools/dotc/ScalaJSCompilationTests.scala b/sjs-compiler-tests/test/scala/dotty/tools/dotc/ScalaJSCompilationTests.scala index b5eaaa04e6cb..22f41f962a4d 100644 --- a/sjs-compiler-tests/test/scala/dotty/tools/dotc/ScalaJSCompilationTests.scala +++ b/sjs-compiler-tests/test/scala/dotty/tools/dotc/ScalaJSCompilationTests.scala @@ -53,7 +53,8 @@ object ScalaJSCompilationTests extends ParallelTesting { // Run tests ----------------------------------------------------------------- override protected def shouldSkipTestSource(testSource: TestSource): Boolean = - testSource.allToolArgs.get(ToolName.ScalaJS).exists(_.contains("--skip")) + testSource.sourceFiles.exists(_.getName.endsWith(".java")) + || testSource.allToolArgs.get(ToolName.ScalaJS).exists(_.contains("--skip")) || super.shouldSkipTestSource(testSource) override protected def testPlatform: TestPlatform = TestPlatform.ScalaJS diff --git a/tasty/src/dotty/tools/tasty/TastyBuffer.scala b/tasty/src/dotty/tools/tasty/TastyBuffer.scala index b27a5b8878ab..1ffbdc6fab6e 100644 --- a/tasty/src/dotty/tools/tasty/TastyBuffer.scala +++ b/tasty/src/dotty/tools/tasty/TastyBuffer.scala @@ -64,25 +64,32 @@ class TastyBuffer(initialSize: Int) { length += n } - /** Write a natural number in big endian format, base 128. - * All but the last digits have bit 0x80 set. + /** Write a 31-bit natural (nonnegative) integer number in big endian format, base 128, each digit being a byte. + * All bytes except the last one have bit 0x80 unset. */ - def writeNat(x: Int): Unit = + def writeNat(x: Int): Unit = { + if (x < 0) { + throw new IllegalArgumentException(s"Expected a natural (nonnegative) number to write, but got: $x") + } writeLongNat(x.toLong & 0x00000000FFFFFFFFL) + } - /** Write a natural number in 2's complement big endian format, base 128. - * All but the last digits have bit 0x80 set. + /** Write a 32-bit integer number in 2's complement big endian format, base 128, each digit being a byte. + * All bytes except the last one have bit 0x80 unset. */ def writeInt(x: Int): Unit = writeLongInt(x) /** - * Like writeNat, but for longs. Note that the - * binary representation of LongNat is identical to Nat - * if the long value is in the range Int.MIN_VALUE to - * Int.MAX_VALUE. + * Write a 63-bit natural (nonnegative) number in big endian format, base 128, each digit being a byte. + * All bytes except the last one have bit 0x80 unset. + * Note that the binary representation of LongNat is identical to Nat + * if the long value is in the range 0 to Int.MAX_VALUE. */ def writeLongNat(x: Long): Unit = { + if (x < 0) { + throw new IllegalArgumentException(s"Expected a natural (nonnegative) number to write, but got: $x") + } def writePrefix(x: Long): Unit = { val y = x >>> 7 if (y != 0L) writePrefix(y) @@ -93,7 +100,8 @@ class TastyBuffer(initialSize: Int) { writeByte(((x & 0x7f) | 0x80).toInt) } - /** Like writeInt, but for longs */ + /** Write a 64-bit long integer number in 2's complement big endian format, base 128, each digit being a byte. + * All bytes except the last one have bit 0x80 unset. */ def writeLongInt(x: Long): Unit = { def writePrefix(x: Long): Unit = { val y = x >> 7 diff --git a/tasty/src/dotty/tools/tasty/TastyFormat.scala b/tasty/src/dotty/tools/tasty/TastyFormat.scala index fa98704a1036..7cf51420a9cf 100644 --- a/tasty/src/dotty/tools/tasty/TastyFormat.scala +++ b/tasty/src/dotty/tools/tasty/TastyFormat.scala @@ -325,7 +325,7 @@ object TastyFormat { * compatibility, but remains backwards compatible, with all * preceding `MinorVersion`. */ - final val MinorVersion: Int = 9 + final val MinorVersion: Int = 10 /** Natural Number. The `ExperimentalVersion` allows for * experimentation with changes to TASTy without committing diff --git a/tasty/src/dotty/tools/tasty/TastyReader.scala b/tasty/src/dotty/tools/tasty/TastyReader.scala index d4374a76ff99..090d46c120da 100644 --- a/tasty/src/dotty/tools/tasty/TastyReader.scala +++ b/tasty/src/dotty/tools/tasty/TastyReader.scala @@ -28,7 +28,7 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int = /** The address of the next byte to read */ def currentAddr: Addr = addr(bp) - /** the address one greater than the last brte to read */ + /** the address one greater than the last byte to read */ def endAddr: Addr = addr(end) /** Have all bytes been read? */ @@ -58,20 +58,34 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int = result } - /** Read a natural number fitting in an Int in big endian format, base 128. - * All but the last digits have bit 0x80 set. + /** Read a 31-bit natural (nonnegative) integer number in big endian format, base 128, each digit being a byte. + * All bytes except the last one have bit 0x80 unset. */ - def readNat(): Int = readLongNat().toInt + def readNat(): Int = { + val l = readLongNat() + if (l > Int.MaxValue) { + throw new UnpickleException(s"Expected a 31-bit nat, got: $l") + } + l.toInt + } - /** Read an integer number in 2's complement big endian format, base 128. - * All but the last digits have bit 0x80 set. + /** Read a 32-bit integer number in 2's complement big endian format, base 128, each digit being a byte. + * All bytes except the last one have bit 0x80 unset. */ - def readInt(): Int = readLongInt().toInt + def readInt(): Int = { + val l = readLongInt() + val i = l.toInt + if (i.toLong != l) { + throw new UnpickleException(s"Expected a 32-bit int, got: $l") + } + i + } - /** Read a natural number fitting in a Long in big endian format, base 128. - * All but the last digits have bit 0x80 set. + /** Read a 63-bit natural (nonnegative) number in big endian format, base 128, each digit being a byte. + * All bytes except the last one have bit 0x80 unset. */ def readLongNat(): Long = { + val ogBp = bp var b = 0L var x = 0L while ({ @@ -79,13 +93,19 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int = x = (x << 7) | (b & 0x7f) bp += 1 (b & 0x80) == 0 - }) - () + }) () + if (bp - ogBp > 9) { + throw new UnpickleException(s"Expected a long nat, but read too many bytes (${bp - ogBp})") + } + assert(x >= 0, "We read <= 9 groups of 7 bits so x must be nonnegative here") x } - /** Read a long integer number in 2's complement big endian format, base 128. */ + /** Read a 64-bit long integer number in 2's complement big endian format, base 128, each digit being a byte. + * All bytes except the last one have bit 0x80 unset. + */ def readLongInt(): Long = { + val ogBp = bp var b = bytes(bp) var x: Long = (b << 1).toByte >> 1 // sign extend with bit 6. bp += 1 @@ -94,6 +114,9 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int = x = (x << 7) | (b & 0x7f) bp += 1 } + if (bp - ogBp > 10) { + throw new UnpickleException(s"Expected a long int, but read too many bytes (${bp - ogBp})") + } x } diff --git a/tests/coverage/pos/SimpleMethods.scoverage.check b/tests/coverage/pos/SimpleMethods.scoverage.check index efd410be5bca..3a5e66dcc538 100644 --- a/tests/coverage/pos/SimpleMethods.scoverage.check +++ b/tests/coverage/pos/SimpleMethods.scoverage.check @@ -229,23 +229,6 @@ C Class covtest.C cond -195 -200 -15 - -Literal -false -0 -false -false - -13 -SimpleMethods.scala -covtest -C -Class -covtest.C -cond 206 210 15 @@ -256,7 +239,7 @@ false false true -14 +13 SimpleMethods.scala covtest C @@ -273,7 +256,7 @@ true false true -15 +14 SimpleMethods.scala covtest C @@ -290,7 +273,7 @@ false false false -16 +15 SimpleMethods.scala covtest C @@ -307,7 +290,7 @@ true false false -17 +16 SimpleMethods.scala covtest C @@ -324,24 +307,7 @@ false false def cond -18 -SimpleMethods.scala -covtest -C -Class -covtest.C -partialCond -260 -265 -19 - -Literal -false -0 -false -false - -19 +17 SimpleMethods.scala covtest C @@ -358,7 +324,7 @@ false false () -20 +18 SimpleMethods.scala covtest C @@ -375,7 +341,7 @@ true false () -21 +19 SimpleMethods.scala covtest C @@ -392,7 +358,7 @@ true false -22 +20 SimpleMethods.scala covtest C @@ -409,7 +375,7 @@ false false def partialCond -23 +21 SimpleMethods.scala covtest C @@ -426,7 +392,7 @@ false false new {} -24 +22 SimpleMethods.scala covtest C @@ -443,7 +409,7 @@ false false def new1 -25 +23 SimpleMethods.scala covtest C @@ -460,7 +426,7 @@ false false () -26 +24 SimpleMethods.scala covtest C @@ -477,7 +443,7 @@ true false () -27 +25 SimpleMethods.scala covtest C @@ -494,7 +460,7 @@ false false 1 -28 +26 SimpleMethods.scala covtest C @@ -511,7 +477,7 @@ true false => 1 -29 +27 SimpleMethods.scala covtest C diff --git a/tests/coverage/pos/SimpleMethodsIgnoredLocally.scoverage.check b/tests/coverage/pos/SimpleMethodsIgnoredLocally.scoverage.check index 71d21df39318..1e7751945ebc 100644 --- a/tests/coverage/pos/SimpleMethodsIgnoredLocally.scoverage.check +++ b/tests/coverage/pos/SimpleMethodsIgnoredLocally.scoverage.check @@ -229,23 +229,6 @@ C Class covtest.C cond -215 -220 -16 - -Literal -false -0 -true -false - -13 -SimpleMethodsIgnoredLocally.scala -covtest -C -Class -covtest.C -cond 226 230 16 @@ -256,7 +239,7 @@ false true true -14 +13 SimpleMethodsIgnoredLocally.scala covtest C @@ -273,7 +256,7 @@ true true true -15 +14 SimpleMethodsIgnoredLocally.scala covtest C @@ -290,7 +273,7 @@ false true false -16 +15 SimpleMethodsIgnoredLocally.scala covtest C @@ -307,7 +290,7 @@ true true false -17 +16 SimpleMethodsIgnoredLocally.scala covtest C @@ -324,24 +307,7 @@ false true def cond -18 -SimpleMethodsIgnoredLocally.scala -covtest -C -Class -covtest.C -partialCond -280 -285 -20 - -Literal -false -0 -true -false - -19 +17 SimpleMethodsIgnoredLocally.scala covtest C @@ -358,7 +324,7 @@ false true () -20 +18 SimpleMethodsIgnoredLocally.scala covtest C @@ -375,7 +341,7 @@ true true () -21 +19 SimpleMethodsIgnoredLocally.scala covtest C @@ -392,7 +358,7 @@ true true -22 +20 SimpleMethodsIgnoredLocally.scala covtest C @@ -409,7 +375,7 @@ false true def partialCond -23 +21 SimpleMethodsIgnoredLocally.scala covtest C @@ -426,7 +392,7 @@ false false new {} -24 +22 SimpleMethodsIgnoredLocally.scala covtest C @@ -443,7 +409,7 @@ false false def new1 -25 +23 SimpleMethodsIgnoredLocally.scala covtest C @@ -460,7 +426,7 @@ false false () -26 +24 SimpleMethodsIgnoredLocally.scala covtest C @@ -477,7 +443,7 @@ true false () -27 +25 SimpleMethodsIgnoredLocally.scala covtest C @@ -494,7 +460,7 @@ false false 1 -28 +26 SimpleMethodsIgnoredLocally.scala covtest C @@ -511,7 +477,7 @@ true false => 1 -29 +27 SimpleMethodsIgnoredLocally.scala covtest C diff --git a/tests/debug-custom-args/eval-syntax.check b/tests/debug-custom-args/eval-syntax.check new file mode 100644 index 000000000000..189dd3c6a114 --- /dev/null +++ b/tests/debug-custom-args/eval-syntax.check @@ -0,0 +1,3 @@ +break Test$ 5 +eval a + 1 +result 7 diff --git a/tests/debug-custom-args/eval-syntax.scala b/tests/debug-custom-args/eval-syntax.scala new file mode 100644 index 000000000000..72ba95b2b97c --- /dev/null +++ b/tests/debug-custom-args/eval-syntax.scala @@ -0,0 +1,8 @@ +object Test { + + def main(args: Array[String]): Unit = { + val a = 4 + 2 + println(a) + } + +} diff --git a/tests/disabled/macro/pos/t8013/inpervolated_2.scala b/tests/disabled/macro/pos/t8013/inpervolated_2.scala index d2cacd86e1ea..370d78742fed 100644 --- a/tests/disabled/macro/pos/t8013/inpervolated_2.scala +++ b/tests/disabled/macro/pos/t8013/inpervolated_2.scala @@ -1,4 +1,4 @@ -//> using options -Werror -Xlint +//> using options -Werror -Wshadow package t8013 // unsuspecting user of perverse macro diff --git a/tests/disabled/macro/pos/t8013/inpervolator_1.scala b/tests/disabled/macro/pos/t8013/inpervolator_1.scala index 612e1d727df8..719f219bd19f 100644 --- a/tests/disabled/macro/pos/t8013/inpervolator_1.scala +++ b/tests/disabled/macro/pos/t8013/inpervolator_1.scala @@ -1,7 +1,7 @@ package t8013 -// perverse macro to confuse Xlint +// perverse macro to confuse Wshadow import scala.language.experimental.macros import scala.reflect.macros.blackbox.Context diff --git a/tests/disabled/partest/run/t7711-script-args.scala b/tests/disabled/partest/run/t7711-script-args.scala index 02535aa9549d..7c7427c95c7c 100644 --- a/tests/disabled/partest/run/t7711-script-args.scala +++ b/tests/disabled/partest/run/t7711-script-args.scala @@ -2,6 +2,6 @@ import scala.tools.partest.ScriptTest object Test extends ScriptTest { - override def extraSettings = s"${super.extraSettings} -Xlint" + override def extraSettings = s"${super.extraSettings} -Wshadow" override def argv = Seq("good", "news") } diff --git a/tests/disabled/pos/inline-trait-4-inner-class.scala b/tests/disabled/pos/inline-trait-4-inner-class.scala new file mode 100644 index 000000000000..b3c25e75de4c --- /dev/null +++ b/tests/disabled/pos/inline-trait-4-inner-class.scala @@ -0,0 +1,20 @@ +inline trait Options[+T]: + sealed trait Option: + def get: T + def isEmpty: Boolean + + class Some(x: T) extends Option: + def get: T = x + def isEmpty: Boolean = false + + object None extends Option: + def get: T = throw new NoSuchElementException("None.get") + def isEmpty: Boolean = true +end Options + +object IntOptions extends Options[Int] +import IntOptions._ + +val o1: Option = Some(1) // specialized +val o2: Option = None +val x1: Int = o1.get // no unboxing diff --git a/tests/disabled/pos/inline-trait-body-class-abstract.scala b/tests/disabled/pos/inline-trait-body-class-abstract.scala new file mode 100644 index 000000000000..4704b324e26d --- /dev/null +++ b/tests/disabled/pos/inline-trait-body-class-abstract.scala @@ -0,0 +1,10 @@ +inline trait A: + class InnerA: + def foo(): Int + def bar = foo() + 1 + +class B extends A: + class InnerB extends InnerA: + def foo(): Int = -23 + + def f = InnerB().bar \ No newline at end of file diff --git a/tests/disabled/pos/inline-trait-body-class-enum.scala b/tests/disabled/pos/inline-trait-body-class-enum.scala new file mode 100644 index 000000000000..a114ff396067 --- /dev/null +++ b/tests/disabled/pos/inline-trait-body-class-enum.scala @@ -0,0 +1,6 @@ +inline trait A: + enum Inner: + case A, B, C + +class B extends A: + def f = Inner.B \ No newline at end of file diff --git a/tests/disabled/pos/inline-trait-body-class-object.scala b/tests/disabled/pos/inline-trait-body-class-object.scala new file mode 100644 index 000000000000..dc990c69573c --- /dev/null +++ b/tests/disabled/pos/inline-trait-body-class-object.scala @@ -0,0 +1,6 @@ +inline trait A[T]: + object Inner: + val x: T = ??? + +class B extends A[Int]: + def i: Int = Inner.x diff --git a/tests/disabled/pos/inline-trait-body-trait-generic.scala b/tests/disabled/pos/inline-trait-body-trait-generic.scala new file mode 100644 index 000000000000..999dd0c8c1ea --- /dev/null +++ b/tests/disabled/pos/inline-trait-body-trait-generic.scala @@ -0,0 +1,6 @@ +inline trait A[T]: + trait InnerA[U]: + def x: (T, U) = ??? + +class B extends A[Int]: + class InnerB extends InnerA[String] \ No newline at end of file diff --git a/tests/disabled/reflect/run/primitive-sigs-2-new.flags b/tests/disabled/reflect/run/primitive-sigs-2-new.flags deleted file mode 100644 index 2349d8294d80..000000000000 --- a/tests/disabled/reflect/run/primitive-sigs-2-new.flags +++ /dev/null @@ -1 +0,0 @@ --Ydelambdafy:inline diff --git a/tests/disabled/reflect/run/primitive-sigs-2-old.flags b/tests/disabled/reflect/run/primitive-sigs-2-old.flags deleted file mode 100644 index ac96850b69b5..000000000000 --- a/tests/disabled/reflect/run/primitive-sigs-2-old.flags +++ /dev/null @@ -1 +0,0 @@ --Ydelambdafy:inline \ No newline at end of file diff --git a/tests/explicit-nulls/pos/flow-stable.scala.disabled b/tests/explicit-nulls/pos/flow-stable.scala similarity index 93% rename from tests/explicit-nulls/pos/flow-stable.scala.disabled rename to tests/explicit-nulls/pos/flow-stable.scala index 155247e73a52..54b3834670a6 100644 --- a/tests/explicit-nulls/pos/flow-stable.scala.disabled +++ b/tests/explicit-nulls/pos/flow-stable.scala @@ -1,4 +1,3 @@ -// TODO: temporarily disable, // in the if expression, `x.type` becomes `((x : T | Null) & T).type` due to `x != null` // We need to make sure `(x : T | Null) & T` stable and concrete in order to use `.type` diff --git a/tests/explicit-nulls/pos/lub/J.java b/tests/explicit-nulls/pos/lub/J.java new file mode 100644 index 000000000000..f521a92453f3 --- /dev/null +++ b/tests/explicit-nulls/pos/lub/J.java @@ -0,0 +1,9 @@ +// Minimized from https://scala3.westeurope.cloudapp.azure.com/dashboard/projects/greenfossil/thorium/builds/HarrisL2%2Fscala3%3Aunsafe-explicit-nulls%3A2026-04-01/logs + +import java.util.function.Function; +public class J { + + public U execute(Function function, T input) { + return function.apply(input); + } +} \ No newline at end of file diff --git a/tests/explicit-nulls/pos/lub/S.scala b/tests/explicit-nulls/pos/lub/S.scala new file mode 100644 index 000000000000..44f5d5f840c4 --- /dev/null +++ b/tests/explicit-nulls/pos/lub/S.scala @@ -0,0 +1,9 @@ +// Minimized from https://scala3.westeurope.cloudapp.azure.com/dashboard/projects/greenfossil/thorium/builds/HarrisL2%2Fscala3%3Aunsafe-explicit-nulls%3A2026-04-01/logs + +class A +class B + +def foo(fn: A => A | B): A | B = + val v: J[A] = ??? + val resp = v.execute(fn(_), ???) + resp \ No newline at end of file diff --git a/tests/explicit-nulls/pos/opt.scala b/tests/explicit-nulls/pos/opt.scala new file mode 100644 index 000000000000..619dd1dd849e --- /dev/null +++ b/tests/explicit-nulls/pos/opt.scala @@ -0,0 +1,9 @@ + +type Opt[+A] = A | Null +object Opt: + + def unapply[A](o: Opt[A]): Option[A] = + if o != null then Some(o.asInstanceOf[o.type & A]) + else None + +end Opt \ No newline at end of file diff --git a/tests/explicit-nulls/pos/option-ornull.scala b/tests/explicit-nulls/pos/option-ornull.scala new file mode 100644 index 000000000000..d17b7356a1d7 --- /dev/null +++ b/tests/explicit-nulls/pos/option-ornull.scala @@ -0,0 +1,6 @@ +import java.util.Optional + +class CheckResult(result: Option[Unit]): + def foo = + val x: Optional[Unit] = Optional.ofNullable(result.orNull) + 42 diff --git a/tests/explicit-nulls/special/25722/jstubs/jstubs/lib/Foo.java b/tests/explicit-nulls/special/25722/jstubs/jstubs/lib/Foo.java new file mode 100644 index 000000000000..7cdc9b038502 --- /dev/null +++ b/tests/explicit-nulls/special/25722/jstubs/jstubs/lib/Foo.java @@ -0,0 +1,9 @@ +package lib; + +import org.jetbrains.annotations.Nullable; + +public class Foo { + public interface Bar { + @Nullable Object execute(); + } +} diff --git a/tests/explicit-nulls/special/25722/jstubs/jstubs/org/jetbrains/annotations/Nullable.java b/tests/explicit-nulls/special/25722/jstubs/jstubs/org/jetbrains/annotations/Nullable.java new file mode 100644 index 000000000000..64c2177c1f37 --- /dev/null +++ b/tests/explicit-nulls/special/25722/jstubs/jstubs/org/jetbrains/annotations/Nullable.java @@ -0,0 +1,3 @@ +package org.jetbrains.annotations; + +public @interface Nullable {} diff --git a/tests/explicit-nulls/special/25722/scala/A.scala b/tests/explicit-nulls/special/25722/scala/A.scala new file mode 100644 index 000000000000..6f8be647e951 --- /dev/null +++ b/tests/explicit-nulls/special/25722/scala/A.scala @@ -0,0 +1 @@ +def a = new java.util.Random() diff --git a/tests/explicit-nulls/special/25722/scala/B.scala b/tests/explicit-nulls/special/25722/scala/B.scala new file mode 100644 index 000000000000..1518cf4ee321 --- /dev/null +++ b/tests/explicit-nulls/special/25722/scala/B.scala @@ -0,0 +1 @@ +abstract class B extends lib.Foo.Bar diff --git a/tests/generic-java-signatures/24270.check b/tests/generic-java-signatures/24270.check new file mode 100644 index 000000000000..c18de2db3927 --- /dev/null +++ b/tests/generic-java-signatures/24270.check @@ -0,0 +1,6 @@ +bar: +public static java.lang.Object bar.foo(java.lang.Object) +public static A bar.foo(A) +bar$: +public java.lang.Object bar$.foo(java.lang.Object) +public A bar$.foo(A) diff --git a/tests/generic-java-signatures/24270.scala b/tests/generic-java-signatures/24270.scala new file mode 100644 index 000000000000..76c8f98ae647 --- /dev/null +++ b/tests/generic-java-signatures/24270.scala @@ -0,0 +1,19 @@ +final class Box[A](value: A) extends AnyVal + +trait Foo: + def foo[A](a: A): Box[A] = Box(a) + +object bar extends Foo + +object Test: + def main(args: Array[String]): Unit = + println("bar:") + Class.forName("bar").getMethods.sortBy(_.getName).filter(_.getName.contains("foo")).foreach(m => { + println(m) + println(m.toGenericString) + }) + println("bar$:") + Class.forName("bar$").getMethods.sortBy(_.getName).filter(_.getName.contains("foo")).foreach(m => { + println(m) + println(m.toGenericString) + }) diff --git a/tests/generic-java-signatures/derivedNames.scala b/tests/generic-java-signatures/derivedNames.scala index 0cc5bc8a1ab7..f1da9c2828d5 100644 --- a/tests/generic-java-signatures/derivedNames.scala +++ b/tests/generic-java-signatures/derivedNames.scala @@ -7,9 +7,9 @@ object Test { val out1 = "Test$Foo.Test$Foo$A.B$>" // Windows val out2 = "Test$Foo$A$B$>" // Linux, OSX and sometimes Windows if (scala.util.Properties.isWin) - assert(returnType.toString == out1 || returnType.toString == out2) + assert(returnType.toString == out1 || returnType.toString == out2, s"returnType $returnType but expected one of '$out1' or '$out2'") else - assert(returnType.toString == out2) + assert(returnType.toString == out2, s"returnType $returnType but expected $out2") } class Foo[T1] { class A[T2] diff --git a/tests/run/generic-java-signatures-erased.check b/tests/generic-java-signatures/generic-java-signatures-erased.check similarity index 100% rename from tests/run/generic-java-signatures-erased.check rename to tests/generic-java-signatures/generic-java-signatures-erased.check diff --git a/tests/run/generic-java-signatures-erased.scala b/tests/generic-java-signatures/generic-java-signatures-erased.scala similarity index 95% rename from tests/run/generic-java-signatures-erased.scala rename to tests/generic-java-signatures/generic-java-signatures-erased.scala index 31c6e07599ad..0ba6e30792ee 100644 --- a/tests/run/generic-java-signatures-erased.scala +++ b/tests/generic-java-signatures/generic-java-signatures-erased.scala @@ -1,5 +1,4 @@ //> using options -language:experimental.erasedDefinitions -// scalajs: --skip object MyErased { def f1[U](erased a: Int): Int = 0 diff --git a/tests/generic-java-signatures/hkt-bounds-sig.check b/tests/generic-java-signatures/hkt-bounds-sig.check new file mode 100644 index 000000000000..5df7466cb6f1 --- /dev/null +++ b/tests/generic-java-signatures/hkt-bounds-sig.check @@ -0,0 +1,4 @@ +public Category1Hi C.funcA() +public Category1Hi C.funcA() +public Category1LoHi C.funcB() +public Category1LoHi C.funcB() diff --git a/tests/generic-java-signatures/hkt-bounds-sig.scala b/tests/generic-java-signatures/hkt-bounds-sig.scala new file mode 100644 index 000000000000..e47ee70e7bff --- /dev/null +++ b/tests/generic-java-signatures/hkt-bounds-sig.scala @@ -0,0 +1,16 @@ +case class Box[A](value: A) + +class Category1Hi[F[_ <: AnyRef]] +class Category1LoHi[F[_ >: String <: AnyRef]] + +class C { + def funcA: Category1Hi[[X <: AnyRef] =>> Box[X]] = null + def funcB: Category1LoHi[[X >: String <: AnyRef] =>> Box[X]] = null +} + +object Test: + def main(args: Array[String]): Unit = + classOf[C].getMethods.filter(_.getName.startsWith("func")).sortBy(_.getName).foreach(m => + println(m) + println(m.toGenericString) + ) diff --git a/tests/run/i10846.check b/tests/generic-java-signatures/i10846.check similarity index 100% rename from tests/run/i10846.check rename to tests/generic-java-signatures/i10846.check diff --git a/tests/run/i10846/i10846.scala b/tests/generic-java-signatures/i10846.scala similarity index 97% rename from tests/run/i10846/i10846.scala rename to tests/generic-java-signatures/i10846.scala index 8ece0caca402..2610f5f241fa 100644 --- a/tests/run/i10846/i10846.scala +++ b/tests/generic-java-signatures/i10846.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - package i10846 { final class V(val x: Int) extends AnyVal object V { def get: Option[V] = null } diff --git a/tests/run/i21346.check b/tests/generic-java-signatures/i21346.check similarity index 100% rename from tests/run/i21346.check rename to tests/generic-java-signatures/i21346.check diff --git a/tests/run/i21346.scala b/tests/generic-java-signatures/i21346.scala similarity index 91% rename from tests/run/i21346.scala rename to tests/generic-java-signatures/i21346.scala index 40999c3e27dc..13ff2253c494 100644 --- a/tests/run/i21346.scala +++ b/tests/generic-java-signatures/i21346.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Foo: def foo[X, Y, Z](x: X, y: Y)[A](z: Z, a: A): (X, Y, Z, A) = (x, y, z, a) def bar[X](x: X)[Y <: x.type](y: Y): (X, Y) = (x, y) @@ -11,4 +9,4 @@ object Foo: println(mtd.getTypeParameters().mkString("<", ";", ">")) println(mtd.getGenericParameterTypes().mkString("(", ",", ")")) println(mtd.getGenericReturnType()) - println("============") \ No newline at end of file + println("============") diff --git a/tests/generic-java-signatures/i21576.check b/tests/generic-java-signatures/i21576.check new file mode 100644 index 000000000000..288d24b89115 --- /dev/null +++ b/tests/generic-java-signatures/i21576.check @@ -0,0 +1,3 @@ +public SubFlow(SubFlowDef,SubFlowDef) +public SubFlowDef SubFlow.delegate1() +public SubFlowDef SubFlow.delegate2() diff --git a/tests/generic-java-signatures/i21576.scala b/tests/generic-java-signatures/i21576.scala new file mode 100644 index 000000000000..8a15f3cef413 --- /dev/null +++ b/tests/generic-java-signatures/i21576.scala @@ -0,0 +1,30 @@ +import scala.annotation.unchecked.uncheckedVariance + +trait SubFlowDef[+F[+_]] +final class Flow1[-In]{ + type Repr[+O] = Flow1[In @uncheckedVariance] +} +final class Flow2[+Out]{ + type Repr[+O] = Flow2[O] +} +class SubFlow[In, Out]( + val delegate1: SubFlowDef[Flow1[In]#Repr], + val delegate2: SubFlowDef[Flow2[Out]#Repr] +) + +object Test { + def main(args: Array[String]): Unit = { + classOf[SubFlow[?, ?]] + .getConstructors() + .map(_.toGenericString()) + .sorted + .foreach(println) + + classOf[SubFlow[?, ?]] + .getMethods() + .filter(_.getName().startsWith("delegate")) + .map(_.toGenericString()) + .sorted + .foreach(println) + } +} diff --git a/tests/run/i23882.check b/tests/generic-java-signatures/i23882.check similarity index 100% rename from tests/run/i23882.check rename to tests/generic-java-signatures/i23882.check diff --git a/tests/run/i23882.scala b/tests/generic-java-signatures/i23882.scala similarity index 98% rename from tests/run/i23882.scala rename to tests/generic-java-signatures/i23882.scala index 46d647e3cbb5..697a3ce7be3e 100644 --- a/tests/run/i23882.scala +++ b/tests/generic-java-signatures/i23882.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - import scala.collection.* import scala.caps.Pure diff --git a/tests/run/i24272.check b/tests/generic-java-signatures/i24272.check similarity index 100% rename from tests/run/i24272.check rename to tests/generic-java-signatures/i24272.check diff --git a/tests/run/i24272.scala b/tests/generic-java-signatures/i24272.scala similarity index 88% rename from tests/run/i24272.scala rename to tests/generic-java-signatures/i24272.scala index 8c314195b626..66aaa9b76282 100644 --- a/tests/run/i24272.scala +++ b/tests/generic-java-signatures/i24272.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class Foo: def bar[B](x: B): x.type = x diff --git a/tests/generic-java-signatures/i24276.check b/tests/generic-java-signatures/i24276.check new file mode 100644 index 000000000000..3312043abb41 --- /dev/null +++ b/tests/generic-java-signatures/i24276.check @@ -0,0 +1,102 @@ +public scala.Option Foo.bar1(scala.Option) +public scala.Option> Foo.bar1(scala.Option>) +--- +public scala.Option Foo.bar2(scala.Option) +public scala.Option Foo.bar2(scala.Option) +--- +public scala.Option Foo.bar3(scala.Option) +public scala.Option Foo.bar3(scala.Option) +--- +public scala.Option Foo.bar4(scala.Option) +public scala.Option> Foo.bar4(scala.Option>) +--- +public scala.Option Foo.bar5(scala.Option) +public scala.Option> Foo.bar5(scala.Option>) +--- +public scala.Option Foo.bar6(scala.Option) +public scala.Option> Foo.bar6(scala.Option>) +--- +public scala.Option Foo.bar7(scala.Option) +public scala.Option> Foo.bar7(scala.Option>) +--- +public java.lang.Object Foo.foo1(java.lang.Object) +public A Foo.foo1(A) +--- +public int Foo.foo2(int) +public int Foo.foo2(int) +--- +public java.lang.String Foo.foo3(java.lang.String) +public java.lang.String Foo.foo3(java.lang.String) +--- +public java.lang.Integer Foo.foo4(java.lang.Integer) +public java.lang.Integer Foo.foo4(java.lang.Integer) +--- +public java.lang.String Foo.foo5(java.lang.String) +public java.lang.String Foo.foo5(java.lang.String) +--- +public java.lang.Object Foo.foo6(java.lang.Object) +public java.lang.Object Foo.foo6(java.lang.Object) +--- +public java.lang.Object[] Foo.foo6b(java.lang.Object[]) +public java.lang.Object[] Foo.foo6b(java.lang.Object[]) +--- +public java.lang.Object Foo.foo7(java.lang.Object) +public java.lang.Object Foo.foo7(java.lang.Object) +--- +public int[] Foo.foo8(int[]) +public int[] Foo.foo8(int[]) +--- +public java.lang.String[] Foo.foo9(java.lang.String[]) +public java.lang.String[] Foo.foo9(java.lang.String[]) +--- +public static scala.Option Foo.sbar1(scala.Option) +public static scala.Option> Foo.sbar1(scala.Option>) +--- +public static scala.Option Foo.sbar2(scala.Option) +public static scala.Option Foo.sbar2(scala.Option) +--- +public static scala.Option Foo.sbar3(scala.Option) +public static scala.Option Foo.sbar3(scala.Option) +--- +public static scala.Option Foo.sbar4(scala.Option) +public static scala.Option> Foo.sbar4(scala.Option>) +--- +public static scala.Option Foo.sbar5(scala.Option) +public static scala.Option> Foo.sbar5(scala.Option>) +--- +public static scala.Option Foo.sbar6(scala.Option) +public static scala.Option> Foo.sbar6(scala.Option>) +--- +public static scala.Option Foo.sbar7(scala.Option) +public static scala.Option> Foo.sbar7(scala.Option>) +--- +public static java.lang.Object Foo.sfoo1(java.lang.Object) +public static A Foo.sfoo1(A) +--- +public static int Foo.sfoo2(int) +public static int Foo.sfoo2(int) +--- +public static java.lang.String Foo.sfoo3(java.lang.String) +public static java.lang.String Foo.sfoo3(java.lang.String) +--- +public static java.lang.Integer Foo.sfoo4(java.lang.Integer) +public static java.lang.Integer Foo.sfoo4(java.lang.Integer) +--- +public static java.lang.String Foo.sfoo5(java.lang.String) +public static java.lang.String Foo.sfoo5(java.lang.String) +--- +public static java.lang.Object Foo.sfoo6(java.lang.Object) +public static java.lang.Object Foo.sfoo6(java.lang.Object) +--- +public static java.lang.Object[] Foo.sfoo6b(java.lang.Object[]) +public static java.lang.Object[] Foo.sfoo6b(java.lang.Object[]) +--- +public static java.lang.Object Foo.sfoo7(java.lang.Object) +public static java.lang.Object Foo.sfoo7(java.lang.Object) +--- +public static int[] Foo.sfoo8(int[]) +public static int[] Foo.sfoo8(int[]) +--- +public static java.lang.String[] Foo.sfoo9(java.lang.String[]) +public static java.lang.String[] Foo.sfoo9(java.lang.String[]) +--- diff --git a/tests/generic-java-signatures/i24276.scala b/tests/generic-java-signatures/i24276.scala new file mode 100644 index 000000000000..e02bbb3c7609 --- /dev/null +++ b/tests/generic-java-signatures/i24276.scala @@ -0,0 +1,49 @@ +class Box[A](value: A) extends AnyVal +class IBox(value: Int) extends AnyVal +class SBox(value: String) extends AnyVal +class Arr[A](value: Array[A]) extends AnyVal +class ArrR[A <: AnyRef](value: Array[A]) extends AnyVal + +class Foo: + def foo1[A](a: A): Box[A] = Box(a) + def foo2(a: IBox): IBox = a + def foo3(a: SBox): SBox = a + def foo4(a: Box[Int]): Box[Int] = a + def foo5(a: Box[String]): Box[String] = a + def foo6(a: Arr[Int]): Arr[Int] = a + def foo6b(a: ArrR[java.lang.Integer]): ArrR[java.lang.Integer] = a + def foo7(a: Arr[String]): Arr[String] = a + def foo8(a: Box[Array[Int]]): Box[Array[Int]] = a + def foo9(a: Box[Array[String]]): Box[Array[String]] = a + def bar1[A](opt: Option[Box[A]]): Option[Box[A]] = opt + def bar2(opt: Option[IBox]): Option[IBox] = opt + def bar3(opt: Option[SBox]): Option[SBox] = opt + def bar4(opt: Option[Box[Int]]): Option[Box[Int]] = opt + def bar5(opt: Option[Box[String]]): Option[Box[String]] = opt + def bar6(opt: Option[Arr[Int]]): Option[Arr[Int]] = opt + def bar7(opt: Option[Arr[String]]): Option[Arr[String]] = opt + +object Foo: + def sfoo1[A](a: A): Box[A] = Box(a) + def sfoo2(a: IBox): IBox = a + def sfoo3(a: SBox): SBox = a + def sfoo4(a: Box[Int]): Box[Int] = a + def sfoo5(a: Box[String]): Box[String] = a + def sfoo6(a: Arr[Int]): Arr[Int] = a + def sfoo6b(a: ArrR[java.lang.Integer]): ArrR[java.lang.Integer] = a + def sfoo7(a: Arr[String]): Arr[String] = a + def sfoo8(a: Box[Array[Int]]): Box[Array[Int]] = a + def sfoo9(a: Box[Array[String]]): Box[Array[String]] = a + def sbar1[A](opt: Option[Box[A]]): Option[Box[A]] = opt + def sbar2(opt: Option[IBox]): Option[IBox] = opt + def sbar3(opt: Option[SBox]): Option[SBox] = opt + def sbar4(opt: Option[Box[Int]]): Option[Box[Int]] = opt + def sbar5(opt: Option[Box[String]]): Option[Box[String]] = opt + def sbar6(opt: Option[Arr[Int]]): Option[Arr[Int]] = opt + def sbar7(opt: Option[Arr[String]]): Option[Arr[String]] = opt + +@main def Test = + for mtd <- classOf[Foo].getDeclaredMethods.sortBy(_.getName) do + println(mtd) + println(mtd.toGenericString) + println("---") diff --git a/tests/run/i24553.check b/tests/generic-java-signatures/i24553.check similarity index 100% rename from tests/run/i24553.check rename to tests/generic-java-signatures/i24553.check diff --git a/tests/run/i24553.scala b/tests/generic-java-signatures/i24553.scala similarity index 91% rename from tests/run/i24553.scala rename to tests/generic-java-signatures/i24553.scala index 910c287c5c7f..5a2f78a3d198 100644 --- a/tests/run/i24553.scala +++ b/tests/generic-java-signatures/i24553.scala @@ -1,4 +1,3 @@ -// scalajs: --skip class Foo: val hello = 1337 val x: hello.type = ??? diff --git a/tests/generic-java-signatures/inner-of-generic.check b/tests/generic-java-signatures/inner-of-generic.check new file mode 100644 index 000000000000..79ebd0860f49 --- /dev/null +++ b/tests/generic-java-signatures/inner-of-generic.check @@ -0,0 +1,2 @@ +ok +ok diff --git a/tests/generic-java-signatures/inner-of-generic/Defs_1.scala b/tests/generic-java-signatures/inner-of-generic/Defs_1.scala new file mode 100644 index 000000000000..cceebb49835a --- /dev/null +++ b/tests/generic-java-signatures/inner-of-generic/Defs_1.scala @@ -0,0 +1,10 @@ +package genericouterinnermember + +class Outer[A]: + class Inner: + def use(a: A): A = a + @annotation.targetName("InnerX") + class Inner2: + def use(a: A): A = a + def inner: Inner = new Inner + def inner2: Inner2 = new Inner2 diff --git a/tests/generic-java-signatures/inner-of-generic/Test_3.scala b/tests/generic-java-signatures/inner-of-generic/Test_3.scala new file mode 100644 index 000000000000..6d82ef765b11 --- /dev/null +++ b/tests/generic-java-signatures/inner-of-generic/Test_3.scala @@ -0,0 +1,8 @@ +import genericouterinnermember.* + +object Test: + def main(args: Array[String]): Unit = + val outer = new Outer[String] + println(Use_2.use(outer)) + println(Use_2.use2(outer)) + diff --git a/tests/generic-java-signatures/inner-of-generic/Use_2.java b/tests/generic-java-signatures/inner-of-generic/Use_2.java new file mode 100644 index 000000000000..5ca6e8dd0f27 --- /dev/null +++ b/tests/generic-java-signatures/inner-of-generic/Use_2.java @@ -0,0 +1,10 @@ +package genericouterinnermember; + +public class Use_2 { + public static String use(Outer outer) { + return outer.inner().use("ok"); + } + public static String use2(Outer outer) { + return outer.inner2().use("ok"); + } +} diff --git a/tests/run/mixin-signatures.check b/tests/generic-java-signatures/mixin-signatures.check similarity index 100% rename from tests/run/mixin-signatures.check rename to tests/generic-java-signatures/mixin-signatures.check diff --git a/tests/run/mixin-signatures.scala b/tests/generic-java-signatures/mixin-signatures.scala similarity index 99% rename from tests/run/mixin-signatures.scala rename to tests/generic-java-signatures/mixin-signatures.scala index 2c6d0101b1c3..48e345e8c645 100644 --- a/tests/run/mixin-signatures.scala +++ b/tests/generic-java-signatures/mixin-signatures.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - trait Base[T, R] { def f(x: T): R def g(x: T): R diff --git a/tests/run/parameterized-type.check b/tests/generic-java-signatures/parameterized-type.check similarity index 100% rename from tests/run/parameterized-type.check rename to tests/generic-java-signatures/parameterized-type.check diff --git a/tests/run/parameterized-type.scala b/tests/generic-java-signatures/parameterized-type.scala similarity index 94% rename from tests/run/parameterized-type.scala rename to tests/generic-java-signatures/parameterized-type.scala index 9708c41f751e..6fa595206237 100644 --- a/tests/run/parameterized-type.scala +++ b/tests/generic-java-signatures/parameterized-type.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class ClassWithOption extends WithMap { val optionInClass: Option[String] = None } diff --git a/tests/generic-java-signatures/preserve-raw-sig.check b/tests/generic-java-signatures/preserve-raw-sig.check new file mode 100644 index 000000000000..8a7ec80dee0d --- /dev/null +++ b/tests/generic-java-signatures/preserve-raw-sig.check @@ -0,0 +1,5 @@ +public default Factory Map.mapFactory() +public default Factory Map.mapFactory() +--- +public Factory Other.tupleFactory() +public Factory Other.tupleFactory() diff --git a/tests/generic-java-signatures/preserve-raw-sig.scala b/tests/generic-java-signatures/preserve-raw-sig.scala new file mode 100644 index 000000000000..ddafdd8d5d17 --- /dev/null +++ b/tests/generic-java-signatures/preserve-raw-sig.scala @@ -0,0 +1,20 @@ +trait Factory[+CC[_, _]] + +trait Map[K, +V]: + def mapFactory: Factory[Map] = ??? + +class Other: + def tupleFactory: Factory[Tuple2] = ??? + +object Test: + def main(args: Array[String]): Unit = + classOf[Map[Int, String]].getMethods.filter(_.getName == "mapFactory").foreach(m => + println(m) + println(m.toGenericString) + ) + println("---") + classOf[Other].getMethods.filter(_.getName == "tupleFactory").foreach(m => + println(m) + println(m.toGenericString) + ) + diff --git a/tests/disabled/reflect/run/primitive-sigs-2-new.check b/tests/generic-java-signatures/primitive-sigs-2-new.check similarity index 60% rename from tests/disabled/reflect/run/primitive-sigs-2-new.check rename to tests/generic-java-signatures/primitive-sigs-2-new.check index 59d864947c00..64c958040946 100644 --- a/tests/disabled/reflect/run/primitive-sigs-2-new.check +++ b/tests/generic-java-signatures/primitive-sigs-2-new.check @@ -1,6 +1,9 @@ T List(A, char, class java.lang.Object) a +private static final float Arr.arr3$$anonfun$1(float[]) +private static final java.lang.Object Arr.arr4$$anonfun$1(java.lang.Object) +private static java.lang.Object Arr.$deserializeLambda$(java.lang.invoke.SerializedLambda) public java.lang.Object Arr.arr4(java.lang.Object[],scala.reflect.ClassTag) public float[] Arr.arr3(float[][]) public scala.collection.immutable.List Arr.arr2(java.lang.Character[]) diff --git a/tests/disabled/reflect/run/primitive-sigs-2-new.scala b/tests/generic-java-signatures/primitive-sigs-2-new.scala similarity index 97% rename from tests/disabled/reflect/run/primitive-sigs-2-new.scala rename to tests/generic-java-signatures/primitive-sigs-2-new.scala index 1f39667b18f1..f375a19a5331 100644 --- a/tests/disabled/reflect/run/primitive-sigs-2-new.scala +++ b/tests/generic-java-signatures/primitive-sigs-2-new.scala @@ -1,4 +1,3 @@ - import scala.language.{ postfixOps } import scala.reflect.{ClassTag, classTag} import java.{ lang => jl } @@ -28,7 +27,7 @@ object Test { def main(args: Array[String]): Unit = { println(c2.getGenericInterfaces.map(_.toString).sorted mkString " ") println(c1m ++ c2m sorted) - println(new C f) + println((new C()).f()) c3m.sorted foreach println } } diff --git a/tests/disabled/reflect/run/primitive-sigs-2-old.check b/tests/generic-java-signatures/primitive-sigs-2-old.check similarity index 60% rename from tests/disabled/reflect/run/primitive-sigs-2-old.check rename to tests/generic-java-signatures/primitive-sigs-2-old.check index feb06195256f..c7a472a542cf 100644 --- a/tests/disabled/reflect/run/primitive-sigs-2-old.check +++ b/tests/generic-java-signatures/primitive-sigs-2-old.check @@ -1,6 +1,9 @@ T List(A, char, class java.lang.Object) a +private static final float Arr.arr3$$anonfun$1(float[]) +private static final java.lang.Object Arr.arr4$$anonfun$1(java.lang.Object) +private static java.lang.Object Arr.$deserializeLambda$(java.lang.invoke.SerializedLambda) public java.lang.Object Arr.arr4(java.lang.Object[],scala.reflect.Manifest) public float[] Arr.arr3(float[][]) public scala.collection.immutable.List Arr.arr2(java.lang.Character[]) diff --git a/tests/disabled/reflect/run/primitive-sigs-2-old.scala b/tests/generic-java-signatures/primitive-sigs-2-old.scala similarity index 97% rename from tests/disabled/reflect/run/primitive-sigs-2-old.scala rename to tests/generic-java-signatures/primitive-sigs-2-old.scala index 16fe5ae55563..0ab0a63bfdf2 100644 --- a/tests/disabled/reflect/run/primitive-sigs-2-old.scala +++ b/tests/generic-java-signatures/primitive-sigs-2-old.scala @@ -1,4 +1,3 @@ - import scala.language.{ postfixOps } import java.{ lang => jl } @@ -35,7 +34,7 @@ object Test { def main(args: Array[String]): Unit = { println(c2.getGenericInterfaces.map(_.toString).sorted mkString " ") println(c1m ++ c2m sorted) - println(new C f) + println((new C()).f()) c3m.sorted foreach println } } diff --git a/tests/run/refined-signature.check b/tests/generic-java-signatures/refined-signature.check similarity index 100% rename from tests/run/refined-signature.check rename to tests/generic-java-signatures/refined-signature.check diff --git a/tests/run/refined-signature.scala b/tests/generic-java-signatures/refined-signature.scala similarity index 84% rename from tests/run/refined-signature.scala rename to tests/generic-java-signatures/refined-signature.scala index 09b773ad2f02..d639dca1840f 100644 --- a/tests/run/refined-signature.scala +++ b/tests/generic-java-signatures/refined-signature.scala @@ -1,6 +1,3 @@ -// scalajs: --skip -// (this is a JVM-only test) - trait B trait Cov[+T] diff --git a/tests/run/returned-context-function-signature.check b/tests/generic-java-signatures/returned-context-function-signature.check similarity index 100% rename from tests/run/returned-context-function-signature.check rename to tests/generic-java-signatures/returned-context-function-signature.check diff --git a/tests/run/returned-context-function-signature.scala b/tests/generic-java-signatures/returned-context-function-signature.scala similarity index 93% rename from tests/run/returned-context-function-signature.scala rename to tests/generic-java-signatures/returned-context-function-signature.scala index a732e22369a1..3366c0da4b5e 100644 --- a/tests/run/returned-context-function-signature.scala +++ b/tests/generic-java-signatures/returned-context-function-signature.scala @@ -1,6 +1,3 @@ -// scalajs: --skip -// (this is a JVM-only test) - import language.experimental.erasedDefinitions class CanSerialize extends compiletime.Erased diff --git a/tests/generic-java-signatures/superClassParams.check b/tests/generic-java-signatures/superClassParams.check index 83245dabac73..52ac4a3814e6 100644 --- a/tests/generic-java-signatures/superClassParams.check +++ b/tests/generic-java-signatures/superClassParams.check @@ -1,4 +1,4 @@ B: A C: A -D: A -E: A \ No newline at end of file +D: A> +E: A> diff --git a/tests/generic-java-signatures/superClassParams.scala b/tests/generic-java-signatures/superClassParams.scala index 730f3ab684a3..4c2ab7a4589d 100644 --- a/tests/generic-java-signatures/superClassParams.scala +++ b/tests/generic-java-signatures/superClassParams.scala @@ -7,7 +7,7 @@ object Test { def main(args: Array[String]): Unit = { println("B: " + classOf[B].getGenericSuperclass.getTypeName) println("C: " + classOf[C].getGenericSuperclass.getTypeName) - println("D: " + classOf[B].getGenericSuperclass.getTypeName) - println("E: " + classOf[C].getGenericSuperclass.getTypeName) + println("D: " + classOf[D].getGenericSuperclass.getTypeName) + println("E: " + classOf[E].getGenericSuperclass.getTypeName) } -} \ No newline at end of file +} diff --git a/tests/generic-java-signatures/t11321.check b/tests/generic-java-signatures/t11321.check new file mode 100644 index 000000000000..9f0979ba1dab --- /dev/null +++ b/tests/generic-java-signatures/t11321.check @@ -0,0 +1,3 @@ +t11321.V: scala.Option +t11321.U: scala.Option +t11321.W: scala.Option>> diff --git a/tests/generic-java-signatures/t11321.scala b/tests/generic-java-signatures/t11321.scala new file mode 100644 index 000000000000..a64aadb140a5 --- /dev/null +++ b/tests/generic-java-signatures/t11321.scala @@ -0,0 +1,26 @@ +package t11321 { + final class V(val x: Int) extends AnyVal + object V { def get: Option[V] = null } + + final class U(val y: String) extends AnyVal + object U { def get: Option[U] = null } + + final class W[T](val z: T) extends AnyVal + object W { def get: Option[W[Int => String]] = null } +} + + +object Test extends App { + def check[T](implicit tt: reflect.ClassTag[T]): Unit = { + val companion = tt.runtimeClass.getClassLoader.loadClass(tt.runtimeClass.getName + '$') + val get = companion.getMethod("get") + assert(get.getReturnType == classOf[Option[_]]) + println(s"${tt.runtimeClass.getName}: ${get.getGenericReturnType}") + } + + import t11321._ + + check[V] + check[U] + check[W[_]] +} diff --git a/tests/generic-java-signatures/t11321b.check b/tests/generic-java-signatures/t11321b.check new file mode 100644 index 000000000000..e008cea3575a --- /dev/null +++ b/tests/generic-java-signatures/t11321b.check @@ -0,0 +1,2 @@ +minnow +class java.lang.String diff --git a/tests/generic-java-signatures/t11321b/Foo_1.scala b/tests/generic-java-signatures/t11321b/Foo_1.scala new file mode 100644 index 000000000000..cb0acf5e8a85 --- /dev/null +++ b/tests/generic-java-signatures/t11321b/Foo_1.scala @@ -0,0 +1,4 @@ +package t11321 + +class X(val x: String) extends AnyVal +class Foo { def b = Option(new X("minnow")); def get = b.get } diff --git a/tests/generic-java-signatures/t11321b/Test_2.java b/tests/generic-java-signatures/t11321b/Test_2.java new file mode 100644 index 000000000000..67de3c58089b --- /dev/null +++ b/tests/generic-java-signatures/t11321b/Test_2.java @@ -0,0 +1,9 @@ +package t11321; + +public class Test_2 { + public static void main(String ...args) { + scala.Option b = new Foo().b(); + System.out.println(b.get().x()); + System.out.println(b.get().x().getClass()); + } +} diff --git a/tests/generic-java-signatures/t11321b/Test_3.scala b/tests/generic-java-signatures/t11321b/Test_3.scala new file mode 100644 index 000000000000..3eecd2a76cd5 --- /dev/null +++ b/tests/generic-java-signatures/t11321b/Test_3.scala @@ -0,0 +1,5 @@ +import t11321.* + +object Test: + def main(args: Array[String]): Unit = + Test_2.main() diff --git a/tests/generic-java-signatures/t1461.scala b/tests/generic-java-signatures/t1461.scala new file mode 100644 index 000000000000..642e0535b78c --- /dev/null +++ b/tests/generic-java-signatures/t1461.scala @@ -0,0 +1,16 @@ +object Test { + def main(args: Array[String]): Unit = { + val jl = classOf[Foo].getMethod("jl", classOf[Baz[_]]) + jl.getGenericParameterTypes // works fine + + val l = classOf[Foo].getMethod("l", classOf[Baz[_]]) + l.getGenericParameterTypes // works fine + } +} + +class Baz[T] + +class Foo { + def l(b: Baz[Long]): Unit = { } + def jl(b: Baz[java.lang.Long]): Unit = { } +} diff --git a/tests/disabled/reflect/run/t6344.check b/tests/generic-java-signatures/t6344.check similarity index 80% rename from tests/disabled/reflect/run/t6344.check rename to tests/generic-java-signatures/t6344.check index 8d9adac849d4..7b1cf719a29a 100644 --- a/tests/disabled/reflect/run/t6344.check +++ b/tests/generic-java-signatures/t6344.check @@ -1,76 +1,76 @@ C0 public int C0.v1(int) public int C0.v1(int) -public int C0.v3() -public int C0.v3() -public int C0.v4(int,scala.collection.immutable.List) -public int C0.v4(int,scala.collection.immutable.List>) public scala.collection.immutable.List C0.v2() public scala.collection.immutable.List> C0.v2() +public int C0.v3() +public int C0.v3() +public int C0.v4(int,scala.collection.immutable.List) +public int C0.v4(int,scala.collection.immutable.List>) C1 public java.lang.Object C1.v1(java.lang.Object) public java.lang.Object C1.v1(java.lang.Object) +public scala.collection.immutable.List C1.v2() +public scala.collection.immutable.List> C1.v2() public java.lang.Object C1.v3() public java.lang.Object C1.v3() public java.lang.Object C1.v4(java.lang.Object,scala.collection.immutable.List) -public java.lang.Object C1.v4(java.lang.Object,scala.collection.immutable.List) -public scala.collection.immutable.List C1.v2() -public scala.collection.immutable.List C1.v2() +public java.lang.Object C1.v4(java.lang.Object,scala.collection.immutable.List>) C2 public java.lang.String C2.v1(java.lang.String) public java.lang.String C2.v1(java.lang.String) +public scala.collection.immutable.List C2.v2() +public scala.collection.immutable.List> C2.v2() public java.lang.String C2.v3() public java.lang.String C2.v3() public java.lang.String C2.v4(java.lang.String,scala.collection.immutable.List) -public java.lang.String C2.v4(java.lang.String,scala.collection.immutable.List) -public scala.collection.immutable.List C2.v2() -public scala.collection.immutable.List C2.v2() +public java.lang.String C2.v4(java.lang.String,scala.collection.immutable.List>) C3 public java.lang.Object C3.v1(java.lang.Object) public A C3.v1(A) +public scala.collection.immutable.List C3.v2() +public scala.collection.immutable.List> C3.v2() public java.lang.Object C3.v3() public A C3.v3() public java.lang.Object C3.v4(java.lang.Object,scala.collection.immutable.List) -public A C3.v4(A,scala.collection.immutable.List) +public A C3.v4(A,scala.collection.immutable.List>) public java.lang.Object C3.x() public A C3.x() -public scala.collection.immutable.List C3.v2() -public scala.collection.immutable.List C3.v2() C4 public java.lang.Integer C4.v1(java.lang.Integer) -public int C4.v1(int) -public java.lang.Integer C4.v3() -public int C4.v3() -public java.lang.Integer C4.v4(java.lang.Integer,scala.collection.immutable.List) -public int C4.v4(int,scala.collection.immutable.List>) +public java.lang.Integer C4.v1(java.lang.Integer) public scala.collection.immutable.List C4.v2() public scala.collection.immutable.List> C4.v2() +public java.lang.Integer C4.v3() +public java.lang.Integer C4.v3() +public java.lang.Integer C4.v4(java.lang.Integer,scala.collection.immutable.List) +public java.lang.Integer C4.v4(java.lang.Integer,scala.collection.immutable.List>) C4B public java.lang.String C4B.v1(java.lang.String) public java.lang.String C4B.v1(java.lang.String) +public scala.collection.immutable.List C4B.v2() +public scala.collection.immutable.List> C4B.v2() public java.lang.String C4B.v3() public java.lang.String C4B.v3() public java.lang.String C4B.v4(java.lang.String,scala.collection.immutable.List) -public java.lang.String C4B.v4(java.lang.String,scala.collection.immutable.List) -public scala.collection.immutable.List C4B.v2() -public scala.collection.immutable.List C4B.v2() +public java.lang.String C4B.v4(java.lang.String,scala.collection.immutable.List>) C5 +public java.lang.Object C5.f1(int,java.lang.Object,java.lang.String,java.lang.Object) +public A C5.f1(int,java.lang.Object,java.lang.String,A) public double C5.f2(int,java.lang.Object,java.lang.String,double) public double C5.f2(int,java.lang.Object,java.lang.String,double) public int C5.f3(java.lang.Integer) -public int C5.f3(int) +public int C5.f3(java.lang.Integer) +public int C5.f4(java.lang.Integer) public int C5.f4(java.lang.Integer) -public int C5.f4(int) public int C5.f5(java.lang.Integer) -public int C5.f5(int) -public java.lang.Object C5.f1(int,java.lang.Object,java.lang.String,java.lang.Object) -public A C5.f1(int,java.lang.Object,java.lang.String,A) +public int C5.f5(java.lang.Integer) C6 public java.lang.Object C6.f1(int,java.lang.Object,java.lang.String,java.lang.Object) @@ -78,7 +78,7 @@ public A C6.f1(int,java.lang.Object,java.lang.String,A) C7 public java.lang.Integer C7.f1(int,java.lang.Object,java.lang.String,java.lang.Integer) -public int C7.f1(int,java.lang.Object,java.lang.String,int) +public java.lang.Integer C7.f1(int,java.lang.Object,java.lang.String,java.lang.Integer) public java.lang.Object C7.f1(int,java.lang.Object,java.lang.String,java.lang.Object) public java.lang.Object C7.f1(int,java.lang.Object,java.lang.String,java.lang.Object) @@ -89,26 +89,26 @@ public abstract java.lang.Object Gen.x() public abstract A Gen.x() ValueInt -public Gen ValueInt.plus(Gen,Gen) -public Gen ValueInt.plus(Gen,Gen) +public static boolean ValueInt.equals$extension(int,java.lang.Object) +public static boolean ValueInt.equals$extension(int,java.lang.Object) public boolean ValueInt.equals(java.lang.Object) public boolean ValueInt.equals(java.lang.Object) +public static int ValueInt.hashCode$extension(int) +public static int ValueInt.hashCode$extension(int) public int ValueInt.hashCode() public int ValueInt.hashCode() +public static int ValueInt.iplus$extension(int,int,int) +public static int ValueInt.iplus$extension(int,int,int) public int ValueInt.iplus(int,int) public int ValueInt.iplus(int,int) +public static Gen ValueInt.plus$extension(int,Gen,Gen) +public static Gen ValueInt.plus$extension(int,Gen,Gen) +public Gen ValueInt.plus(Gen,Gen) +public Gen ValueInt.plus(Gen,Gen) public int ValueInt.x() public int ValueInt.x() public java.lang.Object ValueInt.x() public java.lang.Object ValueInt.x() -public static Gen ValueInt.plus$extension(int,Gen,Gen) -public static Gen ValueInt.plus$extension(int,Gen,Gen) -public static boolean ValueInt.equals$extension(int,java.lang.Object) -public static boolean ValueInt.equals$extension(int,java.lang.Object) -public static int ValueInt.hashCode$extension(int) -public static int ValueInt.hashCode$extension(int) -public static int ValueInt.iplus$extension(int,int,int) -public static int ValueInt.iplus$extension(int,int,int) RefInt public Gen RefInt.plus(Gen,Gen) @@ -121,10 +121,10 @@ public java.lang.Object RefInt.x() public java.lang.Object RefInt.x() RefInteger -public Gen RefInteger.plus(Gen,Gen) -public Gen RefInteger.plus(Gen,Gen) public RefInteger RefInteger.bplus(RefInteger,RefInteger) public RefInteger RefInteger.bplus(RefInteger,RefInteger) +public Gen RefInteger.plus(Gen,Gen) +public Gen RefInteger.plus(Gen,Gen) public java.lang.Integer RefInteger.x() public java.lang.Integer RefInteger.x() public java.lang.Object RefInteger.x() diff --git a/tests/disabled/reflect/run/t6344.scala b/tests/generic-java-signatures/t6344.scala similarity index 95% rename from tests/disabled/reflect/run/t6344.scala rename to tests/generic-java-signatures/t6344.scala index 6f82e4ba51c9..a2cc5084d75a 100644 --- a/tests/disabled/reflect/run/t6344.scala +++ b/tests/generic-java-signatures/t6344.scala @@ -84,7 +84,7 @@ class C7 extends C6[Int] { object Test { def show[A: ClassTag] = { println(classTag[A].runtimeClass.getName) - classTag[A].runtimeClass.getDeclaredMethods.toList.sortBy(_.toString).flatMap(m => List(m.toString, m.toGenericString)) foreach println + classTag[A].runtimeClass.getDeclaredMethods.toList.sortBy(m => m.getName + m.toString).flatMap(m => List(m.toString, m.toGenericString)).foreach(println) println("") } diff --git a/tests/run/t7932.check b/tests/generic-java-signatures/t7932.check similarity index 76% rename from tests/run/t7932.check rename to tests/generic-java-signatures/t7932.check index b7e516d73a41..0afbb6325884 100644 --- a/tests/run/t7932.check +++ b/tests/generic-java-signatures/t7932.check @@ -1,11 +1,14 @@ -public Category C.category() +public Category C.category() public Category C.category1() +public Category C.category1b() public abstract Category M2.category3() public abstract Category M2.category2() public default Category M1.category() public default Category M1.category1() +public default Category M1.category1b() public static Category M1.category$(M1) public static Category M1.category1$(M1) +public static Category M1.category1b$(M1) public abstract Category M2.category3() public abstract Category M2.category2() public default Category M2.category() diff --git a/tests/run/t7932.scala b/tests/generic-java-signatures/t7932.scala similarity index 84% rename from tests/run/t7932.scala rename to tests/generic-java-signatures/t7932.scala index 243e50245c0c..514cb7c9131e 100644 --- a/tests/run/t7932.scala +++ b/tests/generic-java-signatures/t7932.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - import scala.language.higherKinds class Category[M[_, _]] @@ -8,6 +6,8 @@ trait M1[F] { type X[a, b] = F def category: Category[X] = null def category1: Category[Tuple2] = null + type Tuple2Alias = Tuple2 + def category1b: Category[Tuple2Alias] = null } // The second trait is needed to make sure there's a forwarder generated in C. @@ -24,13 +24,13 @@ trait M2[F] { self: M1[F] => abstract class C extends M1[Float] with M2[Float] object Test { - def t(c: Class[_]) = { + def t(c: Class[?]) = { val ms = c.getMethods.filter(_.getName.startsWith("category")) println(ms.map(_.toGenericString).sorted.mkString("\n")) } def main(args: Array[String]): Unit = { t(classOf[C]) - t(classOf[M1[_]]) - t(classOf[M2[_]]) + t(classOf[M1[?]]) + t(classOf[M2[?]]) } } diff --git a/tests/run/t8177f.scala b/tests/generic-java-signatures/t8177f.scala similarity index 96% rename from tests/run/t8177f.scala rename to tests/generic-java-signatures/t8177f.scala index ba4bbd82f3b4..f50a5d98d649 100644 --- a/tests/run/t8177f.scala +++ b/tests/generic-java-signatures/t8177f.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - trait Thing { type A; var p: A = _ } class A[T](final val x: Thing { type A = T }) { type Q = T diff --git a/tests/run/t8931.check b/tests/generic-java-signatures/t8931.check similarity index 100% rename from tests/run/t8931.check rename to tests/generic-java-signatures/t8931.check diff --git a/tests/run/t8931.scala b/tests/generic-java-signatures/t8931.scala similarity index 93% rename from tests/run/t8931.scala rename to tests/generic-java-signatures/t8931.scala index 04f5d8cd9ba0..a9a7d6240b30 100644 --- a/tests/run/t8931.scala +++ b/tests/generic-java-signatures/t8931.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - trait A trait B extends A diff --git a/tests/generic-java-signatures/targetName.check b/tests/generic-java-signatures/targetName.check new file mode 100644 index 000000000000..d68d943f780a --- /dev/null +++ b/tests/generic-java-signatures/targetName.check @@ -0,0 +1,17 @@ +fooClass +Foo$A +Foo$A +--- +fooComplex +Foo$A> +Foo$B> +--- +fooObj +class Foo$C$ +Foo$A +class Foo$C$ +--- +fooTrait +Foo$B +Foo$B +--- diff --git a/tests/generic-java-signatures/targetName.scala b/tests/generic-java-signatures/targetName.scala new file mode 100644 index 000000000000..d0232698f86b --- /dev/null +++ b/tests/generic-java-signatures/targetName.scala @@ -0,0 +1,28 @@ +import scala.annotation.targetName + +class Foo { + @targetName("A") + class X[T] + + @targetName("B") + trait XT[T] + + @targetName("C") + object XO + + def fooClass(a: X[Object]): X[String] = ??? + def fooTrait(a: XT[Object]): XT[String] = ??? + def fooObj(a: XO.type, b: X[String]): XO.type = ??? + def fooComplex(a: X[XT[XO.type]]): XT[X[String]] = ??? +} + +object Test { + def main(args: Array[String]): Unit = { + classOf[Foo].getMethods.filter(_.getName.startsWith("foo")).sortBy(_.getName).foreach(m => + println(m.getName) + m.getGenericParameterTypes.foreach(println) + println(m.getGenericReturnType) + println("---") + ) + } +} diff --git a/tests/generic-java-signatures/trait-field-generic-signature-class.check b/tests/generic-java-signatures/trait-field-generic-signature-class.check new file mode 100644 index 000000000000..328192ed99b3 --- /dev/null +++ b/tests/generic-java-signatures/trait-field-generic-signature-class.check @@ -0,0 +1,4 @@ +public void Bar.Foo$_setter_$foo_$eq(scala.Option) +public void Bar.Foo$_setter_$foo_$eq(scala.Option) +public scala.Option Bar.foo() +public scala.Option Bar.foo() diff --git a/tests/generic-java-signatures/trait-field-generic-signature-class.scala b/tests/generic-java-signatures/trait-field-generic-signature-class.scala new file mode 100644 index 000000000000..1661f815cb85 --- /dev/null +++ b/tests/generic-java-signatures/trait-field-generic-signature-class.scala @@ -0,0 +1,11 @@ +trait Foo { + val foo: Option[String] = ??? +} +class Bar extends Foo + +object Test: + def main(args: Array[String]): Unit = + classOf[Bar].getMethods.sortBy(_.getName).filter(_.getName.contains("foo")).foreach(m => { + println(m) + println(m.toGenericString) + }) diff --git a/tests/generic-java-signatures/trait-field-generic-signature-object.check b/tests/generic-java-signatures/trait-field-generic-signature-object.check new file mode 100644 index 000000000000..3750293180e2 --- /dev/null +++ b/tests/generic-java-signatures/trait-field-generic-signature-object.check @@ -0,0 +1,10 @@ +Foo: +public abstract void Foo.Foo$_setter_$foo_$eq(scala.Option) +public abstract void Foo.Foo$_setter_$foo_$eq(scala.Option) +public abstract scala.Option Foo.foo() +public abstract scala.Option Foo.foo() +bar: +public void bar$.Foo$_setter_$foo_$eq(scala.Option) +public void bar$.Foo$_setter_$foo_$eq(scala.Option) +public scala.Option bar$.foo() +public scala.Option bar$.foo() diff --git a/tests/generic-java-signatures/trait-field-generic-signature-object.scala b/tests/generic-java-signatures/trait-field-generic-signature-object.scala new file mode 100644 index 000000000000..d5acf79d061f --- /dev/null +++ b/tests/generic-java-signatures/trait-field-generic-signature-object.scala @@ -0,0 +1,18 @@ +trait Foo { + val foo: Option[String] = ??? +} +object bar extends Foo + +object Test: + def main(args: Array[String]): Unit = + println("Foo:") + classOf[Foo].getMethods.sortBy(_.getName).filter(_.getName.contains("foo")).foreach(m => { + println(m) + println(m.toGenericString) + }) + println("bar:") + classOf[bar.type].getMethods.sortBy(_.getName).filter(_.getName.contains("foo")).foreach(m => { + println(m) + println(m.toGenericString) + }) + diff --git a/tests/run/unit_erasure.scala b/tests/generic-java-signatures/unit_erasure.scala similarity index 95% rename from tests/run/unit_erasure.scala rename to tests/generic-java-signatures/unit_erasure.scala index ccc130164c8b..aa51d3035dcc 100644 --- a/tests/run/unit_erasure.scala +++ b/tests/generic-java-signatures/unit_erasure.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class A { def foo1[T]: Unit = {} def foo2[T](): Unit = {} @@ -15,4 +13,4 @@ object Test { assert(m.getGenericReturnType == Void.TYPE, s"Method does not return void: `${m}`") } } -} \ No newline at end of file +} diff --git a/tests/run/value-class-array-signature.check b/tests/generic-java-signatures/value-class-array-signature.check similarity index 100% rename from tests/run/value-class-array-signature.check rename to tests/generic-java-signatures/value-class-array-signature.check diff --git a/tests/run/value-class-array-signature.scala b/tests/generic-java-signatures/value-class-array-signature.scala similarity index 85% rename from tests/run/value-class-array-signature.scala rename to tests/generic-java-signatures/value-class-array-signature.scala index cdb8d14f9256..80c3981cc28e 100644 --- a/tests/run/value-class-array-signature.scala +++ b/tests/generic-java-signatures/value-class-array-signature.scala @@ -1,6 +1,3 @@ -// scalajs: --skip -// (this is a JVM-only test) - trait A class VC(val self: A) extends AnyVal class Z { diff --git a/tests/init/pos/i10549a.scala b/tests/init/pos/i10549a.scala index 23ccbff747f4..f235e060006f 100644 --- a/tests/init/pos/i10549a.scala +++ b/tests/init/pos/i10549a.scala @@ -2,6 +2,6 @@ class Wrap { class E object E { final val A = new E {} - val $values = Array(A) + val `$values` = Array(A) } } diff --git a/tests/init/pos/i9664.scala b/tests/init/pos/i9664.scala index 34bcd84e6ee9..334c77342938 100644 --- a/tests/init/pos/i9664.scala +++ b/tests/init/pos/i9664.scala @@ -2,7 +2,7 @@ object Wrap1 { class E object E { final val A = E() - val $values = Array(A) + val `$values` = Array(A) } } object Wrap2 { diff --git a/tests/init/warn/java1.scala b/tests/init/warn/java1.scala index 36044413d2ea..51cf32275aeb 100644 --- a/tests/init/warn/java1.scala +++ b/tests/init/warn/java1.scala @@ -5,7 +5,7 @@ class A extends Spliterator.OfDouble: def characteristics() = 10 def estimateSize() = 10 def trySplit() = ??? - def tryAdvance(x$0: java.util.function.DoubleConsumer): Boolean = false + def tryAdvance(`x$0`: java.util.function.DoubleConsumer): Boolean = false val m = n + 1 val n = 10 // warn diff --git a/tests/neg-custom-args/captures/any-rd.scala b/tests/neg-custom-args/captures/any-rd.scala new file mode 100644 index 000000000000..413360eae53b --- /dev/null +++ b/tests/neg-custom-args/captures/any-rd.scala @@ -0,0 +1,14 @@ +import caps.* + +class Shared extends SharedCapability + +abstract class Mut extends Mutable: + def get: Int + update def set(x: Int): Unit + +def Test(c: Shared, m: Mut) = + val f = () => println(c) + val _: () ->{any.rd} Unit = f // error + val g = () => m.get + val _: () ->{any.rd} Int = g // ok + diff --git a/tests/neg-custom-args/captures/assumesafe-emptypkg.check b/tests/neg-custom-args/captures/assumesafe-emptypkg.check new file mode 100644 index 000000000000..5d4a66f7062d --- /dev/null +++ b/tests/neg-custom-args/captures/assumesafe-emptypkg.check @@ -0,0 +1,9 @@ +-- [E223] CaptureChecking Error: tests/neg-custom-args/captures/assumesafe-emptypkg.scala:8:27 ------------------------- +8 | def println(s: String) = Console.println(s) // error + | ^^^^^^^ + | Reference `Console` is not included in the allowed capture set {} + | of the enclosing object A. + | + | External uses should be declared explicitly with a uses clause in object A: + | + | uses Console diff --git a/tests/neg-custom-args/captures/assumesafe-emptypkg.scala b/tests/neg-custom-args/captures/assumesafe-emptypkg.scala new file mode 100644 index 000000000000..225fe50d1fb4 --- /dev/null +++ b/tests/neg-custom-args/captures/assumesafe-emptypkg.scala @@ -0,0 +1,9 @@ +import caps.* +class Text + +object Console extends SharedCapability: + def println(s: String): Unit = () + +@assumeSafe object A: + def println(s: String) = Console.println(s) // error + diff --git a/tests/neg-custom-args/captures/boundary.check b/tests/neg-custom-args/captures/boundary.check index df0efcc21e7b..14863eb1b562 100644 --- a/tests/neg-custom-args/captures/boundary.check +++ b/tests/neg-custom-args/captures/boundary.check @@ -18,8 +18,8 @@ |-------------------------------------------------------------------------------------------------------------------- |Inline stack trace |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |This location contains code that was inlined from boundary.scala:72 -72 | val local = Label[T]() + |This location contains code that was inlined from boundary.scala:86 +86 | val local = Label[T]() | ^^^^^^^^^^ -------------------------------------------------------------------------------------------------------------------- | @@ -58,8 +58,8 @@ |-------------------------------------------------------------------------------------------------------------------- |Inline stack trace |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |This location contains code that was inlined from boundary.scala:74 -74 | catch case ex: Break[T] @unchecked => + |This location contains code that was inlined from boundary.scala:88 +88 | catch case ex: Break[T] @unchecked => | ^ -------------------------------------------------------------------------------------------------------------------- | diff --git a/tests/neg-custom-args/captures/box-adapt-typefun.check b/tests/neg-custom-args/captures/box-adapt-typefun.check new file mode 100644 index 000000000000..555229b0b313 --- /dev/null +++ b/tests/neg-custom-args/captures/box-adapt-typefun.check @@ -0,0 +1,18 @@ +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/box-adapt-typefun.scala:6:27 ----------------------------- +6 | val op: Op[Cap^{io}] = Op(f) // error + | ^^^^^ + | Found: Op[Cap^'s1]^'s2 + | Required: Op[Cap^{io}] + | + | Note that capability `io` cannot flow into capture set {}. + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/box-adapt-typefun.scala:12:42 ---------------------------- +12 | val test: [T] -> Unit -> (Cap^{io}) = f.value // error + | ^^^^^^^ + | Found: [T] => ((x$1: Unit): Cap^{io})^{io} + | Required: [T] => (x$1: Unit) -> Cap^{io} + | + | Note that capability `io` cannot flow into capture set {}. + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/box-adapt-typefun.scala b/tests/neg-custom-args/captures/box-adapt-typefun.scala index 76da047f42a9..afa86ab6b9ac 100644 --- a/tests/neg-custom-args/captures/box-adapt-typefun.scala +++ b/tests/neg-custom-args/captures/box-adapt-typefun.scala @@ -3,7 +3,7 @@ trait Cap { def use(): Int } def test1(io: Cap^): Unit = { class Op[X](val value: [T] -> X -> Unit) val f: [T] -> (Cap^{io}) -> Unit = ??? - val op: Op[Cap^{io}] = Op(f) // was error, now ok + val op: Op[Cap^{io}] = Op(f) // error } def test2(io: Cap^): Unit = { diff --git a/tests/neg-custom-args/captures/capt1.check b/tests/neg-custom-args/captures/capt1.check index eb7ce4437cfa..480d8176fa6c 100644 --- a/tests/neg-custom-args/captures/capt1.check +++ b/tests/neg-custom-args/captures/capt1.check @@ -49,7 +49,7 @@ 38 | val z3 = h[(() -> Cap) @retains[x.type]](() => x)(() => C()) // error | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | Separation failure: Illegal access to {x} which is hidden by the previous definition - | of value z2 with type () ->{} C^. + | of value z2 with type () -> C^. | This type hides capabilities {any, x} | | where: ^ refers to a root capability in the type of value z2 diff --git a/tests/neg-custom-args/captures/check-inferred.check b/tests/neg-custom-args/captures/check-inferred.check index d880d93e73f7..e0d0c852e5aa 100644 --- a/tests/neg-custom-args/captures/check-inferred.check +++ b/tests/neg-custom-args/captures/check-inferred.check @@ -2,11 +2,6 @@ 35 |class A: // error | ^ | class A needs to extend Capability since it has a field `x` with `any` in its type. --- Error: tests/neg-custom-args/captures/check-inferred.scala:39:6 ----------------------------------------------------- -39 |class B extends caps.Control: // error - | ^ - | class B is classied as scala.caps.Control but has a field x of unclassified type test.A^. - | Field classifiers have to conform to the classifier of the containing class. -- Error: tests/neg-custom-args/captures/check-inferred.scala:43:6 ----------------------------------------------------- 43 |class C: // error | ^ @@ -49,6 +44,14 @@ | subsumed by the computed capability of the enclosing class. | | where: ^ refers to a root capability in the type of value count +-- Error: tests/neg-custom-args/captures/check-inferred.scala:40:6 ----------------------------------------------------- +40 | val x: A^ = ??? // error + | ^ + | value x's type test.A^ is unclassified, + | but it is a field of class B which is classied as scala.caps.Control. + | Field classifiers have to conform to the classifier of the containing class. + | + | where: ^ refers to a root capability in the type of value x -- Error: tests/neg-custom-args/captures/check-inferred.scala:45:15 ---------------------------------------------------- 45 | private val y = ??? : A^ // error | ^ diff --git a/tests/neg-custom-args/captures/check-inferred.scala b/tests/neg-custom-args/captures/check-inferred.scala index 4ab12d109edc..6606276a8521 100644 --- a/tests/neg-custom-args/captures/check-inferred.scala +++ b/tests/neg-custom-args/captures/check-inferred.scala @@ -36,8 +36,8 @@ class A: // error val x: A^{any.only[caps.Control]} = ??? private val y = ??? : A^{any.only[caps.Control]} // ok -class B extends caps.Control: // error - val x: A^ = ??? +class B extends caps.Control: + val x: A^ = ??? // error private val y = ??? : A^{any.only[caps.Control]} // ok class C: // error diff --git a/tests/neg-custom-args/captures/fresh-fields.check b/tests/neg-custom-args/captures/fresh-fields.check index 8c66f6ca3396..843576cafd66 100644 --- a/tests/neg-custom-args/captures/fresh-fields.check +++ b/tests/neg-custom-args/captures/fresh-fields.check @@ -45,11 +45,11 @@ -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/fresh-fields.scala:33:13 --------------------------------- 33 | val _: F = f // error | ^ - | Found: (f : F^{any}) - | Required: F + |Found: (f : F^{any}) + |Required: F | - | Note that capability `any` cannot flow into capture set {}. + |Note that capability `any` cannot flow into capture set {}. | - | where: any is a root capability in the type of value f with contributing fields value b, value e + |where: any is a root capability classified as SharedCapability in the type of value f with contributing fields value b, value e | | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/i25464.check b/tests/neg-custom-args/captures/i25464.check new file mode 100644 index 000000000000..b0be7d10a0c7 --- /dev/null +++ b/tests/neg-custom-args/captures/i25464.check @@ -0,0 +1,28 @@ +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i25464.scala:15:6 ---------------------------------------- +15 | f(c.cf1) // error + | ^^^^^ + | Found: (c.cf1 : CF1) + | Required: Object^{any.only[CF2]} + | + | Note that capability `c.cf1` cannot flow into capture set {any.only[CF2]}. + | + | where: any is a root capability created in method test when checking argument to parameter x of method f + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i25464.scala:17:12 --------------------------------------- +17 | f(c.cf2.a.cf1) // error + | ^^^^^^^^^^^ + | Found: (c.cf2.a.cf1 : CF1) + | Required: Object^{any.only[CF2]} + | + | Note that capability `c.cf2.a.cf1` cannot flow into capture set {any.only[CF2]}. + | + | where: any is a root capability created in method test when checking argument to parameter x of method f + | + | longer explanation available when compiling with `-explain` +-- Error: tests/neg-custom-args/captures/i25464.scala:8:17 ------------------------------------------------------------- +8 | class Impl(val a: C^{C.this}) extends CF2 // error + | ^ + | value a's type C^{C.this} captures C.this which is unclassified, + | but it is a field of class Impl which is classied as CF2. + | Field classifiers have to conform to the classifier of the containing class. diff --git a/tests/neg-custom-args/captures/i25464.scala b/tests/neg-custom-args/captures/i25464.scala new file mode 100644 index 000000000000..64ab3d44e542 --- /dev/null +++ b/tests/neg-custom-args/captures/i25464.scala @@ -0,0 +1,20 @@ +import language.experimental.captureChecking +import caps.* + +trait CF1 extends Classifier, SharedCapability +trait CF2 extends CF1, Classifier + +class C: + class Impl(val a: C^{C.this}) extends CF2 // error + val cf1: CF1 = ??? + val cf2 = new Impl(this) + +def f(x: AnyRef^{any.only[CF2]}): Unit = () + +def test(c: C): Unit = + f(c.cf1) // error + f(c.cf2) // ok + f(c.cf2.a.cf1) // error + val d: AnyRef^{c.cf2} = c.cf2.a.cf1 + f(d) // wrong, passing CF1 to CF2 only + diff --git a/tests/neg-custom-args/captures/i25758-in-package.check b/tests/neg-custom-args/captures/i25758-in-package.check new file mode 100644 index 000000000000..a0cd89eb771f --- /dev/null +++ b/tests/neg-custom-args/captures/i25758-in-package.check @@ -0,0 +1,16 @@ +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i25758-in-package/B_2.scala:4:31 ------------------------- +4 | val leak: String -> Unit = (secret: String) => // error + | ^ + | Found: (secret: String) ->{ttt.A} Unit + | Required: String -> Unit + | + | Note that capability `any` cannot flow into capture set {}. + | + | Note that capability `ttt.A` cannot flow into capture set {}. + | Note that object A is a capability because it uses capabilities {ttt.Console} + | + | where: any is a root capability classified as SharedCapability in the type of object Console + | +5 | A.println(secret) + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/i25758-in-package/A_1.scala b/tests/neg-custom-args/captures/i25758-in-package/A_1.scala new file mode 100644 index 000000000000..598969567690 --- /dev/null +++ b/tests/neg-custom-args/captures/i25758-in-package/A_1.scala @@ -0,0 +1,10 @@ +package ttt +import caps.* +class Text + +object Console extends SharedCapability: + def println(s: String): Unit = () + +object A uses Console: + def println(s: String) = Console.println(s) + diff --git a/tests/neg-custom-args/captures/i25758-in-package/B_2.scala b/tests/neg-custom-args/captures/i25758-in-package/B_2.scala new file mode 100644 index 000000000000..951822253486 --- /dev/null +++ b/tests/neg-custom-args/captures/i25758-in-package/B_2.scala @@ -0,0 +1,5 @@ +package ttt +object Test uses A, Console: + def test = + val leak: String -> Unit = (secret: String) => // error + A.println(secret) diff --git a/tests/neg-custom-args/captures/i25758.scala b/tests/neg-custom-args/captures/i25758.scala new file mode 100644 index 000000000000..5ee0df547018 --- /dev/null +++ b/tests/neg-custom-args/captures/i25758.scala @@ -0,0 +1,28 @@ +package test +import caps.* +object o extends SharedCapability: + class IO extends SharedCapability: + def println(msg: String): Unit = () + val io: IO^ = new IO + def assertPure(op: () -> Unit): Unit = () + +import o.* +object Test uses test.o: + def test1(): Unit = + assertPure(() => io.println("hello")) // error, as expected + def test(): Unit = io.println("hello") + def test2(): Unit = + val f = () => this.test() + assertPure(f) // error, as expected + assertPure: () => // error + this.test() + assertPure: () => // error + test() + def test3(): Unit = + def test(): Unit = io.println("hello") + val f = () => this.test() + assertPure(f) // error, as expected + assertPure: () => // error + this.test() + assertPure: () => // error + test() diff --git a/tests/neg-custom-args/captures/i25758a.check b/tests/neg-custom-args/captures/i25758a.check new file mode 100644 index 000000000000..568bc0ca2f83 --- /dev/null +++ b/tests/neg-custom-args/captures/i25758a.check @@ -0,0 +1,20 @@ +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i25758a/Test_2.scala:6:15 -------------------------------- +6 | assertPure(() => IO.io.println("hello")) // error, as expected + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | Found: () ->{test.IO.io} Unit + | Required: () -> Unit + | + | Note that capability `test.IO.io` cannot flow into capture set {}. + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i25758a/Test_2.scala:9:16 -------------------------------- + 9 | assertPure: () => // error + | ^ + | Found: () ->{test.IO.io} Unit + | Required: () -> Unit + | + | Note that capability `test.IO.io` cannot flow into capture set {}. + | +10 | test() + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/i25758a/IO_1.scala b/tests/neg-custom-args/captures/i25758a/IO_1.scala new file mode 100644 index 000000000000..733e279876d8 --- /dev/null +++ b/tests/neg-custom-args/captures/i25758a/IO_1.scala @@ -0,0 +1,7 @@ +package test +import caps.* +class IO extends SharedCapability: + def println(msg: String): Unit = () +object IO extends SharedCapability: + val io: IO = new IO + def assertPure(op: () -> Unit): Unit = () diff --git a/tests/neg-custom-args/captures/i25758a/Test_2.scala b/tests/neg-custom-args/captures/i25758a/Test_2.scala new file mode 100644 index 000000000000..9da844acae64 --- /dev/null +++ b/tests/neg-custom-args/captures/i25758a/Test_2.scala @@ -0,0 +1,10 @@ +package test +import caps.* +import IO.* +object Test uses IO: + def test1(): Unit = + assertPure(() => IO.io.println("hello")) // error, as expected + def test2(): Unit = + def test(): Unit = IO.io.println("hello") + assertPure: () => // error + test() diff --git a/tests/neg-custom-args/captures/i25758b/IO_1.scala b/tests/neg-custom-args/captures/i25758b/IO_1.scala new file mode 100644 index 000000000000..059c337650b3 --- /dev/null +++ b/tests/neg-custom-args/captures/i25758b/IO_1.scala @@ -0,0 +1,6 @@ +import caps.* +class IO extends SharedCapability: + def println(msg: String): Unit = () +object IO extends SharedCapability: + val io: IO = new IO + def assertPure(op: () -> Unit): Unit = () diff --git a/tests/neg-custom-args/captures/i25758b/Test_2.scala b/tests/neg-custom-args/captures/i25758b/Test_2.scala new file mode 100644 index 000000000000..11dbb2514479 --- /dev/null +++ b/tests/neg-custom-args/captures/i25758b/Test_2.scala @@ -0,0 +1,8 @@ +import caps.* +import IO.* +def test1(): Unit = + assertPure(() => IO.io.println("hello")) // error, as expected +def test2(): Unit = + def test(): Unit = IO.io.println("hello") + assertPure: () => // error + test() diff --git a/tests/neg-custom-args/captures/i25759.check b/tests/neg-custom-args/captures/i25759.check index 00f5fa4aa280..d79c1580235f 100644 --- a/tests/neg-custom-args/captures/i25759.check +++ b/tests/neg-custom-args/captures/i25759.check @@ -1,16 +1,16 @@ --- Error: tests/neg-custom-args/captures/i25759.scala:4:14 ------------------------------------------------------------- +-- Error: tests/neg-custom-args/captures/i25759.scala:4:35 ------------------------------------------------------------- 4 | val q = new java.util.concurrent.ConcurrentLinkedQueue[String]() // error - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |Cannot refer to class ConcurrentLinkedQueue in package java.util.concurrent from safe code since it is neither compiled in safe mode nor tagged with @assumedSafe --- Error: tests/neg-custom-args/captures/i25759.scala:9:15 ------------------------------------------------------------- +-- Error: tests/neg-custom-args/captures/i25759.scala:9:25 ------------------------------------------------------------- 9 | val xs = new java.util.ArrayList[String]() // error - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^ |Cannot refer to class ArrayList in package java.util from safe code since it is neither compiled in safe mode nor tagged with @assumedSafe --- Error: tests/neg-custom-args/captures/i25759.scala:14:14 ------------------------------------------------------------ +-- Error: tests/neg-custom-args/captures/i25759.scala:14:24 ------------------------------------------------------------ 14 | val m = new java.util.HashMap[String, String]() // error - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^ |Cannot refer to class HashMap in package java.util from safe code since it is neither compiled in safe mode nor tagged with @assumedSafe --- Error: tests/neg-custom-args/captures/i25759.scala:19:15 ------------------------------------------------------------ +-- Error: tests/neg-custom-args/captures/i25759.scala:19:25 ------------------------------------------------------------ 19 | val dq = new java.util.ArrayDeque[String]() // error - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^ |Cannot refer to class ArrayDeque in package java.util from safe code since it is neither compiled in safe mode nor tagged with @assumedSafe diff --git a/tests/neg-custom-args/captures/i25830-nicolas-lambda.scala b/tests/neg-custom-args/captures/i25830-nicolas-lambda.scala new file mode 100644 index 000000000000..2a27d923cb3a --- /dev/null +++ b/tests/neg-custom-args/captures/i25830-nicolas-lambda.scala @@ -0,0 +1,24 @@ +import language.experimental.captureChecking +import caps.* + +// Soundness regression: for nicolas1-shape poly-fn lambdas with capset +// binder `B^`, applying with `B := {seed}` must propagate `^{seed}` into +// the result. Assigning the result to a strict pure-bound (`Rand -> Int`) +// must be rejected. + +trait Rand extends SharedCapability: + def range(min: Int, max: Int): Int + +val pickFirst = + [A, B^] => (head: Rand ->{B} A, tail: Rand ->{B} A) => head + +val oneOf = + [A, B^] => (head: Rand ->{B} A, tail: Seq[Rand ->{B} A]) => + val all: Seq[Rand ->{B} A] = head +: tail + all.head + +def check = + val seed: Rand = ??? + val f: Rand ->{seed} Int = (r: Rand) => r.range(0, 10) + val r2: Rand -> Int = pickFirst[Int, {seed}](f, f) // error + val r4: Rand -> Int = oneOf[Int, {seed}](f, Seq(f, f)) // error diff --git a/tests/neg-custom-args/captures/i25830-soundness.scala b/tests/neg-custom-args/captures/i25830-soundness.scala new file mode 100644 index 000000000000..769e0263cd01 --- /dev/null +++ b/tests/neg-custom-args/captures/i25830-soundness.scala @@ -0,0 +1,16 @@ +import language.experimental.captureChecking +import caps.* + +class File extends SharedCapability + +// Soundness regression test: applying an identity poly-fn must not +// erase the captures of its argument. If the lambda's stored result +// type were scrubbed to `^{}`, an impure value could be claimed pure +// and leaked past a strict capture-set bound. + +object Test: + val id = [C^] => (x: File^{C}) => x + + def check(): Unit = + val a = File() + val r: File^{} = id[{a}](a) // error diff --git a/tests/neg-custom-args/captures/i25863.check b/tests/neg-custom-args/captures/i25863.check new file mode 100644 index 000000000000..77f37ee7534b --- /dev/null +++ b/tests/neg-custom-args/captures/i25863.check @@ -0,0 +1,31 @@ +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i25863.scala:13:34 --------------------------------------- +13 | val error = make[File^{file}](fun, file) // error, which is expected + | ^^^ + | Found: File^ ->{file} Unit + | Required: File^{file} -> Unit + | + | Note that capability `file` cannot flow into capture set {}. + | + | where: ^ refers to the root capability caps.any + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i25863.scala:14:23 --------------------------------------- +14 | val ok = make(fun, file) // error, as expected + | ^^^^ + | Found: File^{file} + | Required: File^'s1 + | + | Note that capability `file` cannot flow into capture set {}. + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i25863.scala:15:26 --------------------------------------- +15 | val ok1 = make1(file, fun) // error + | ^^^ + | Found: File^ ->{file} Unit + | Required: File^{file} -> Unit + | + | Note that capability `file` cannot flow into capture set {}. + | + | where: ^ refers to the root capability caps.any + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/i25863.scala b/tests/neg-custom-args/captures/i25863.scala new file mode 100644 index 000000000000..1acd137e3d8e --- /dev/null +++ b/tests/neg-custom-args/captures/i25863.scala @@ -0,0 +1,16 @@ +import language.experimental.captureChecking +import scala.caps.* + +trait File: + def write(s: String): Unit +def usingFile[A](f: File^ => A): A = ??? +def make[A](f: A -> Unit, x: A): () -> Unit = () => f(x) +def make1[A](x: A, f: A -> Unit): () -> Unit = () => f(x) + +def leakTest(): Unit = + val leaked = usingFile: file => + val fun: File^ -> Unit = f => f.write("") + val error = make[File^{file}](fun, file) // error, which is expected + val ok = make(fun, file) // error, as expected + val ok1 = make1(file, fun) // error + ok diff --git a/tests/neg-custom-args/captures/i25863a.check b/tests/neg-custom-args/captures/i25863a.check new file mode 100644 index 000000000000..220b1dda6652 --- /dev/null +++ b/tests/neg-custom-args/captures/i25863a.check @@ -0,0 +1,12 @@ +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i25863a.scala:16:28 -------------------------------------- +16 | make[File^{file}](file, fun) // error + | ^^^ + |Found: File^{any} ->{file} Unit + |Required: File^{file} => Unit + | + |Note that capability `file` cannot flow into capture set {any}. + | + |where: => refers to a root capability created in anonymous function of type (file²: File): () -> Unit when checking argument to parameter f of method make + | any is the root capability caps.any + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/i25863a.scala b/tests/neg-custom-args/captures/i25863a.scala new file mode 100644 index 000000000000..f7584b2db47b --- /dev/null +++ b/tests/neg-custom-args/captures/i25863a.scala @@ -0,0 +1,18 @@ +import language.experimental.captureChecking +import scala.caps.SharedCapability + +trait File extends SharedCapability { + def write(s: String): Unit +} +def usingFile[A](f: File => A): A = ??? + +def make[A](x: A, f: A => Unit): () ->{f} Unit = { + () => f(x) +} + +def leak: () -> Unit = { + val fun: File -> Unit = { f => f.write("") } + usingFile { file => + make[File^{file}](file, fun) // error + } +} \ No newline at end of file diff --git a/tests/neg-custom-args/captures/i26035.check b/tests/neg-custom-args/captures/i26035.check new file mode 100644 index 000000000000..b2fa931c3cb9 --- /dev/null +++ b/tests/neg-custom-args/captures/i26035.check @@ -0,0 +1,5 @@ +-- Error: tests/neg-custom-args/captures/i26035.scala:8:22 ------------------------------------------------------------- +8 |case class Foo(f: [A] => () => Unit) // error + | ^ + |Implementation restriction: polymorphic function types cannot wrap impure function types if capture checking is enabled. + |Workaround: introduce an empty term-parameter list right after the type binder, e.g. `[A] => () -> B => C`. diff --git a/tests/neg-custom-args/captures/i26035.scala b/tests/neg-custom-args/captures/i26035.scala new file mode 100644 index 000000000000..1913ffcc8ee8 --- /dev/null +++ b/tests/neg-custom-args/captures/i26035.scala @@ -0,0 +1,13 @@ +import language.experimental.captureChecking +import scala.caps.SharedCapability +class File() { + def write(s: String): Unit = ??? +} +def usingFile[A](f: File^ => A): A = ??? + +case class Foo(f: [A] => () => Unit) // error +def leak = { + usingFile(f => + Foo([A] => () => f.write("")) + ).f[Nothing]() +} \ No newline at end of file diff --git a/tests/neg-custom-args/captures/ident-inherited.check b/tests/neg-custom-args/captures/ident-inherited.check new file mode 100644 index 000000000000..9ea704e753ac --- /dev/null +++ b/tests/neg-custom-args/captures/ident-inherited.check @@ -0,0 +1,56 @@ +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/ident-inherited/Test_2.scala:6:22 ------------------------ +6 | val a: () -> Unit = () => this.println() // error + | ^^^^^^^^^^^^^^^^^^^^ + | Found: () ->{test.Test} Unit + | Required: () -> Unit + | + | Note that capability `any` cannot flow into capture set {}. + | + | Note that capability `test.Test` cannot flow into capture set {}. + | Note that object Test is a capability because it uses capabilities {test.Consol} + | + | where: any is a root capability classified as SharedCapability in the type of object Consol + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/ident-inherited/Test_2.scala:7:22 ------------------------ +7 | val b: () -> Unit = () => this.print // error + | ^^^^^^^^^^^^^^^^ + | Found: () ->{test.Test} Unit + | Required: () -> Unit + | + | Note that capability `any` cannot flow into capture set {}. + | + | Note that capability `test.Test` cannot flow into capture set {}. + | Note that object Test is a capability because it uses capabilities {test.Consol} + | + | where: any is a root capability classified as SharedCapability in the type of object Consol + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/ident-inherited/Test_2.scala:8:22 ------------------------ +8 | val c: () -> Unit = () => println() // error + | ^^^^^^^^^^^^^^^ + | Found: () ->{test.Test} Unit + | Required: () -> Unit + | + | Note that capability `any` cannot flow into capture set {}. + | + | Note that capability `test.Test` cannot flow into capture set {}. + | Note that object Test is a capability because it uses capabilities {test.Consol} + | + | where: any is a root capability classified as SharedCapability in the type of object Consol + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/ident-inherited/Test_2.scala:9:22 ------------------------ +9 | val d: () -> Unit = () => print // error + | ^^^^^^^^^^^ + | Found: () ->{test.Test} Unit + | Required: () -> Unit + | + | Note that capability `any` cannot flow into capture set {}. + | + | Note that capability `test.Test` cannot flow into capture set {}. + | Note that object Test is a capability because it uses capabilities {test.Consol} + | + | where: any is a root capability classified as SharedCapability in the type of object Consol + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/ident-inherited/A_1.scala b/tests/neg-custom-args/captures/ident-inherited/A_1.scala new file mode 100644 index 000000000000..e0c3f8e0c53b --- /dev/null +++ b/tests/neg-custom-args/captures/ident-inherited/A_1.scala @@ -0,0 +1,11 @@ +package test + +import caps.* + +object Consol extends SharedCapability: + def println(s: String) = () + +trait A uses Consol: + def println(): Unit = Consol.println("hello") + def print: Unit = println() + diff --git a/tests/neg-custom-args/captures/ident-inherited/Test_2.scala b/tests/neg-custom-args/captures/ident-inherited/Test_2.scala new file mode 100644 index 000000000000..d5f4fcd4f87d --- /dev/null +++ b/tests/neg-custom-args/captures/ident-inherited/Test_2.scala @@ -0,0 +1,9 @@ +package test + +import caps.* + +object Test extends A uses Consol: + val a: () -> Unit = () => this.println() // error + val b: () -> Unit = () => this.print // error + val c: () -> Unit = () => println() // error + val d: () -> Unit = () => print // error diff --git a/tests/neg-custom-args/captures/implied-capability.check b/tests/neg-custom-args/captures/implied-capability.check index fd13b392ec52..b25619e06cf0 100644 --- a/tests/neg-custom-args/captures/implied-capability.check +++ b/tests/neg-custom-args/captures/implied-capability.check @@ -3,8 +3,11 @@ | ^ | Mutable variable x is defined in a class that does not extend `Stateful` or `Mutable`. | The variable needs to be annotated with `untrackedCaptures` to allow this. --- Error: tests/neg-custom-args/captures/implied-capability.scala:8:6 -------------------------------------------------- -8 |class C2 extends SharedCapability: // error +-- Error: tests/neg-custom-args/captures/implied-capability.scala:9:6 -------------------------------------------------- +9 | val r: Ref = Ref() // error | ^ - | class C2 is classied as scala.caps.SharedCapability but has a field r classified as scala.caps.Unscoped. + | value r's type Ref^{any.rd} is classified as scala.caps.Unscoped, + | but it is a field of class C2 which is classied as scala.caps.SharedCapability. | Field classifiers have to conform to the classifier of the containing class. + | + | where: any is a root capability classified as Unscoped in the type of value r diff --git a/tests/neg-custom-args/captures/implied-capability.scala b/tests/neg-custom-args/captures/implied-capability.scala index 997b292d35cf..d02ce7a4ca5e 100644 --- a/tests/neg-custom-args/captures/implied-capability.scala +++ b/tests/neg-custom-args/captures/implied-capability.scala @@ -5,5 +5,5 @@ class C1 extends SharedCapability: class Ref extends Mutable -class C2 extends SharedCapability: // error - val r: Ref = Ref() +class C2 extends SharedCapability: + val r: Ref = Ref() // error diff --git a/tests/neg-custom-args/captures/impure-fresh.check b/tests/neg-custom-args/captures/impure-fresh.check new file mode 100644 index 000000000000..9844d99e8e14 --- /dev/null +++ b/tests/neg-custom-args/captures/impure-fresh.check @@ -0,0 +1,13 @@ +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/impure-fresh.scala:6:25 ---------------------------------- +6 |val y: () -> A^{fresh} = x // error + | ^ + | Found: (x : () => A^{fresh}) + | Required: () -> A^{fresh²} + | + | Note that capability `x` cannot flow into capture set {}. + | + | where: => refers to a root capability in the type of value x + | fresh is a root capability associated with the result type of (): A^{fresh} + | fresh² is a root capability associated with the result type of (): A^{fresh²} + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/impure-fresh.scala b/tests/neg-custom-args/captures/impure-fresh.scala new file mode 100644 index 000000000000..566b06fff63b --- /dev/null +++ b/tests/neg-custom-args/captures/impure-fresh.scala @@ -0,0 +1,7 @@ +import caps.fresh + +class A + +val x: () => A^{fresh} = ??? +val y: () -> A^{fresh} = x // error + diff --git a/tests/neg-custom-args/captures/levels.check b/tests/neg-custom-args/captures/levels.check index f4038941ef85..baf69c965828 100644 --- a/tests/neg-custom-args/captures/levels.check +++ b/tests/neg-custom-args/captures/levels.check @@ -1,7 +1,7 @@ -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/levels.scala:19:33 --------------------------------------- 19 | val _: Ref[String -> String] = r // error | ^ - | Found: Ref[String ->{} String]^{r.rd} + | Found: Ref[String -> String]^{r.rd} | Required: Ref[String -> String] | | Note that capability `r.rd` cannot flow into capture set {}. diff --git a/tests/neg-custom-args/captures/rand.check b/tests/neg-custom-args/captures/rand.check new file mode 100644 index 000000000000..10df04ec2823 --- /dev/null +++ b/tests/neg-custom-args/captures/rand.check @@ -0,0 +1,27 @@ +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/rand.scala:14:14 ----------------------------------------- +14 |val _: Rand = rand // error + | ^^^^ + | Found: Rand{val self: JavaRand^{rand*}}^{rand} + | Required: Rand + | + | Note that capability `rand` cannot flow into capture set {}. + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/rand.scala:17:14 ----------------------------------------- +17 |val _: Rand = rand1 // error + | ^^^^^ + | Found: (rand1 : Rand{val self: JavaRand^{jrand}}^{jrand}) + | Required: Rand + | + | Note that capability `jrand` cannot flow into capture set {}. + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/rand.scala:20:14 ----------------------------------------- +20 |val _: Rand = rand2 // error + | ^^^^^ + | Found: (rand2 : Rand{val self: JavaRand^{jrand}}^{jrand}) + | Required: Rand + | + | Note that capability `jrand` cannot flow into capture set {}. + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/rand.scala b/tests/neg-custom-args/captures/rand.scala new file mode 100644 index 000000000000..2367c0a0952a --- /dev/null +++ b/tests/neg-custom-args/captures/rand.scala @@ -0,0 +1,23 @@ +import caps.internal.paramAlias + +class JavaRand() + +val jrand: JavaRand^ = JavaRand() + +class Rand(val self: JavaRand^): + def this() = this(jrand) + def this(s: JavaRand^, dummy: Int) = this(s) + def this(d1: Int, s: JavaRand^) = this(s, d1) + +val rand = Rand() +val _: Rand{val self: JavaRand^}^ = rand +val _: Rand = rand // error +val rand1 = Rand(jrand, 0) +val _: Rand{val self: JavaRand^{jrand}}^{jrand} = rand1 +val _: Rand = rand1 // error +val rand2 = Rand(0, jrand) +val _: Rand{val self: JavaRand^{jrand}}^{jrand} = rand2 +val _: Rand = rand2 // error +val rand3 = Rand(JavaRand(): JavaRand^) +val rand4 = Rand(jrand) + diff --git a/tests/neg-custom-args/captures/safemode-1.check b/tests/neg-custom-args/captures/safemode-1.check index d9a08f4d0fd6..1b213520e052 100644 --- a/tests/neg-custom-args/captures/safemode-1.check +++ b/tests/neg-custom-args/captures/safemode-1.check @@ -10,9 +10,9 @@ 16 | Unsafe.foo() // error | ^^^^^^^^^^ |Cannot refer to method foo in object Unsafe from safe code since it is neither compiled in safe mode nor tagged with @assumedSafe --- Error: tests/neg-custom-args/captures/safemode-1/safe_2.scala:18:8 -------------------------------------------------- +-- Error: tests/neg-custom-args/captures/safemode-1/safe_2.scala:18:16 ------------------------------------------------- 18 | scala.Console.out.println("!") // error - | ^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^ | Cannot refer to object Console in package scala from safe code since it is tagged @rejectSafe -- Error: tests/neg-custom-args/captures/safemode-1/safe_2.scala:22:6 -------------------------------------------------- 22 | x.a.foo() // error diff --git a/tests/neg-custom-args/captures/safemode-2.check b/tests/neg-custom-args/captures/safemode-2.check index c9de31c203d1..85df694131bb 100644 --- a/tests/neg-custom-args/captures/safemode-2.check +++ b/tests/neg-custom-args/captures/safemode-2.check @@ -1,6 +1,6 @@ --- Error: tests/neg-custom-args/captures/safemode-2.scala:8:15 --------------------------------------------------------- +-- Error: tests/neg-custom-args/captures/safemode-2.scala:8:22 --------------------------------------------------------- 8 | val x = caps.unsafe.unsafeErasedValue[String] // error - | ^^^^^^^^^^^ + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | Cannot refer to object unsafe in package scala.caps from safe code since it is unavailable in safe mode -- Error: tests/neg-custom-args/captures/safemode-2.scala:10:2 --------------------------------------------------------- 10 | @caps.unsafe.untrackedCaptures var y = 1 // error diff --git a/tests/neg-custom-args/captures/safemode-3.check b/tests/neg-custom-args/captures/safemode-3.check index b7f768f63344..b4fa73344867 100644 --- a/tests/neg-custom-args/captures/safemode-3.check +++ b/tests/neg-custom-args/captures/safemode-3.check @@ -1,8 +1,4 @@ --- Error: tests/neg-custom-args/captures/safemode-3.scala:10:21 -------------------------------------------------------- -10 | case x: List[Int @unchecked] => x.head // error - | ^^^^^^^^^^ - | Cannot refer to class unchecked in package scala from safe code since it is tagged @rejectSafe --- Error: tests/neg-custom-args/captures/safemode-3.scala:18:32 -------------------------------------------------------- -18 | def h(x: Any) = x.asInstanceOf[String] // error - | ^^^^^^^^^^^^^^^^^^^^^^ - | Cannot use asInstanceOf in safe mode +-- Error: tests/neg-custom-args/captures/safemode-3.scala:7:21 --------------------------------------------------------- +7 | case x: List[Int @unchecked] => x.head // error + | ^^^^^^^^^^ + | Cannot refer to class unchecked in package scala from safe code since it is tagged @rejectSafe diff --git a/tests/neg-custom-args/captures/safemode-3.scala b/tests/neg-custom-args/captures/safemode-3.scala index 78b5a330819c..00de4ec321f8 100644 --- a/tests/neg-custom-args/captures/safemode-3.scala +++ b/tests/neg-custom-args/captures/safemode-3.scala @@ -1,8 +1,5 @@ package test import language.experimental.safe -import caps.unsafe.untrackedCaptures -import scala.annotation.unchecked.{uncheckedCaptures, uncheckedVariance} - object Test: @@ -15,4 +12,3 @@ object Test: case x: String => x.length case _ => 0 - def h(x: Any) = x.asInstanceOf[String] // error \ No newline at end of file diff --git a/tests/neg-custom-args/captures/safemode-4.check b/tests/neg-custom-args/captures/safemode-4.check new file mode 100644 index 000000000000..013412838f3b --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-4.check @@ -0,0 +1,12 @@ +-- Error: tests/neg-custom-args/captures/safemode-4.scala:10:15 -------------------------------------------------------- +10 | Properties.clearProp("foo") // error + | ^^^^^^^^^^^^^^^^^^^^ + | Cannot refer to method clearProp in trait PropertiesTrait from safe code since it is tagged @rejectSafe +-- Error: tests/neg-custom-args/captures/safemode-4.scala:11:15 -------------------------------------------------------- +11 | Properties.setProp("foo", "invalid") // error + | ^^^^^^^^^^^^^^^^^^ + | Cannot refer to method setProp in trait PropertiesTrait from safe code since it is tagged @rejectSafe +-- Error: tests/neg-custom-args/captures/safemode-4.scala:13:13 -------------------------------------------------------- +13 | Properties.main(Array()) // error + | ^^^^^^^^^^^^^^^ + | Cannot refer to method main in trait PropertiesTrait from safe code since it is tagged @rejectSafe diff --git a/tests/neg-custom-args/captures/safemode-4.scala b/tests/neg-custom-args/captures/safemode-4.scala new file mode 100644 index 000000000000..94d5a5c46b11 --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-4.scala @@ -0,0 +1,14 @@ +package test +import language.experimental.safe +import caps.unsafe.untrackedCaptures +import scala.annotation.unchecked.{uncheckedCaptures, uncheckedVariance} +import scala.util.{Random, Properties} + +object Test: + + if Properties.propIsSet("foo") then + Properties.clearProp("foo") // error + Properties.setProp("foo", "invalid") // error + + Properties.main(Array()) // error + diff --git a/tests/neg-custom-args/captures/safemode-5.check b/tests/neg-custom-args/captures/safemode-5.check new file mode 100644 index 000000000000..64d042054863 --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-5.check @@ -0,0 +1,4 @@ +-- Error: tests/neg-custom-args/captures/safemode-5.scala:5:32 --------------------------------------------------------- +5 | def h(x: Any) = x.asInstanceOf[String] // error + | ^^^^^^^^^^^^^^^^^^^^^^ + | Cannot use asInstanceOf in safe mode diff --git a/tests/neg-custom-args/captures/safemode-5.scala b/tests/neg-custom-args/captures/safemode-5.scala new file mode 100644 index 000000000000..33ef8e71e5dd --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-5.scala @@ -0,0 +1,5 @@ +package test +import language.experimental.safe + +object Test: + def h(x: Any) = x.asInstanceOf[String] // error \ No newline at end of file diff --git a/tests/neg-custom-args/captures/safemode-emptypkg.check b/tests/neg-custom-args/captures/safemode-emptypkg.check new file mode 100644 index 000000000000..c2baf2405041 --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-emptypkg.check @@ -0,0 +1,9 @@ +-- [E223] CaptureChecking Error: tests/neg-custom-args/captures/safemode-emptypkg.scala:9:27 --------------------------- +9 | def println(s: String) = Console.println(s) // error + | ^^^^^^^ + | Reference `Console` is not included in the allowed capture set {} + | of the enclosing object A. + | + | External uses should be declared explicitly with a uses clause in object A: + | + | uses Console diff --git a/tests/neg-custom-args/captures/safemode-emptypkg.scala b/tests/neg-custom-args/captures/safemode-emptypkg.scala new file mode 100644 index 000000000000..629648bae5a8 --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-emptypkg.scala @@ -0,0 +1,10 @@ +import language.experimental.safe +import caps.* +class Text + +object Console extends SharedCapability: + def println(s: String): Unit = () + +object A: + def println(s: String) = Console.println(s) // error + diff --git a/tests/neg-custom-args/captures/safemode-inline.check b/tests/neg-custom-args/captures/safemode-inline.check new file mode 100644 index 000000000000..604d8dffb3fa --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-inline.check @@ -0,0 +1,8 @@ +-- Error: tests/neg-custom-args/captures/safemode-inline/B.scala:5:10 -------------------------------------------------- +5 | val _ = f(0) // error + | ^ + |Cannot refer to method f in object A from safe code since it is neither compiled in safe mode nor tagged with @assumedSafe +-- Error: tests/neg-custom-args/captures/safemode-inline/B.scala:7:10 -------------------------------------------------- +7 | val _ = f2(0) // error + | ^^ + |Cannot refer to method f2 in object A from safe code since it is neither compiled in safe mode nor tagged with @assumedSafe diff --git a/tests/neg-custom-args/captures/safemode-inline/A.scala b/tests/neg-custom-args/captures/safemode-inline/A.scala new file mode 100644 index 000000000000..93e0e988609e --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-inline/A.scala @@ -0,0 +1,8 @@ +import caps.assumeSafe + +object A: + inline def f(x: Int) = x + @assumeSafe inline def g(x: Any) = x.asInstanceOf[Int] + transparent inline def f2(x: Int) = x + @assumeSafe transparent inline def g2(x: Any) = x.asInstanceOf[Int] + diff --git a/tests/neg-custom-args/captures/safemode-inline/B.scala b/tests/neg-custom-args/captures/safemode-inline/B.scala new file mode 100644 index 000000000000..c1a8ef47fe60 --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-inline/B.scala @@ -0,0 +1,8 @@ +import language.experimental.safe +import A.* + +object Test: + val _ = f(0) // error + val _ = g(0) + val _ = f2(0) // error + val _ = g2(0) diff --git a/tests/neg-custom-args/captures/safemode-inline2.check b/tests/neg-custom-args/captures/safemode-inline2.check new file mode 100644 index 000000000000..02315a820885 --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-inline2.check @@ -0,0 +1,8 @@ +-- Error: tests/neg-custom-args/captures/safemode-inline2/B.scala:5:29 ------------------------------------------------- +5 | val _ = g2("a".asInstanceOf[Int]) // error + | ^^^^^^^^^^^^^^^^^^^^^ + | Cannot use asInstanceOf in safe mode +-- Error: tests/neg-custom-args/captures/safemode-inline2/B.scala:6:29 ------------------------------------------------- +6 | val _ = g2("a".asInstanceOf[Int]) // error + | ^^^^^^^^^^^^^^^^^^^^^ + | Cannot use asInstanceOf in safe mode diff --git a/tests/neg-custom-args/captures/safemode-inline2/A.scala b/tests/neg-custom-args/captures/safemode-inline2/A.scala new file mode 100644 index 000000000000..15bf5f1a7a57 --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-inline2/A.scala @@ -0,0 +1,6 @@ +import caps.assumeSafe + +object A: + @assumeSafe inline def g(x: Any) = x + @assumeSafe transparent inline def g2(x: Any) = x + diff --git a/tests/neg-custom-args/captures/safemode-inline2/B.scala b/tests/neg-custom-args/captures/safemode-inline2/B.scala new file mode 100644 index 000000000000..99a30b0e86d8 --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-inline2/B.scala @@ -0,0 +1,6 @@ +import language.experimental.safe +import A.* + +object Test: + val _ = g2("a".asInstanceOf[Int]) // error + val _ = g2("a".asInstanceOf[Int]) // error diff --git a/tests/neg-custom-args/captures/safemode-pkg-inherit.check b/tests/neg-custom-args/captures/safemode-pkg-inherit.check new file mode 100644 index 000000000000..f3c49c0e476b --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-pkg-inherit.check @@ -0,0 +1,4 @@ +-- Error: tests/neg-custom-args/captures/safemode-pkg-inherit.scala:4:13 ----------------------------------------------- +4 |val result = Seq("sh", "-c", "echo 'oh no'").!! // error + | ^ + |Cannot refer to method stringSeqToProcess in trait ProcessImplicits from safe code since it is neither compiled in safe mode nor tagged with @assumedSafe diff --git a/tests/neg-custom-args/captures/safemode-pkg-inherit.scala b/tests/neg-custom-args/captures/safemode-pkg-inherit.scala new file mode 100644 index 000000000000..683b28fc7cd6 --- /dev/null +++ b/tests/neg-custom-args/captures/safemode-pkg-inherit.scala @@ -0,0 +1,5 @@ +import scala.language.experimental.safe +import scala.sys.process.* + +val result = Seq("sh", "-c", "echo 'oh no'").!! // error + diff --git a/tests/neg-custom-args/captures/scope-extrusions.check b/tests/neg-custom-args/captures/scope-extrusions.check index 8639157cd3de..0465ae07edd1 100644 --- a/tests/neg-custom-args/captures/scope-extrusions.check +++ b/tests/neg-custom-args/captures/scope-extrusions.check @@ -142,7 +142,7 @@ -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/scope-extrusions.scala:33:21 ----------------------------- 33 | val f4: IO => IO = f3 // error | ^^ - | Found: (f3 : (x$0: IO) ->{} IO^{x$0}) + | Found: (f3 : (x$0: IO) -> IO^{x$0}) | Required: IO^ => IO^{any} | | Note that capability `x$0` cannot flow into capture set {any} diff --git a/tests/neg-custom-args/captures/sep-curried-par.check b/tests/neg-custom-args/captures/sep-curried-par.check index b16102a735af..1aa50d1bd62b 100644 --- a/tests/neg-custom-args/captures/sep-curried-par.check +++ b/tests/neg-custom-args/captures/sep-curried-par.check @@ -27,23 +27,23 @@ |on line 18 and therefore is no longer available. | |where: => refers to a root capability in the type of value p --- Error: tests/neg-custom-args/captures/sep-curried-par.scala:21:9 ---------------------------------------------------- +-- Error: tests/neg-custom-args/captures/sep-curried-par.scala:21:6 ---------------------------------------------------- 21 | foo(c)(c) // error: separation - | ^ + | ^ |Separation failure: argument of type (c : () => Unit) - |to a function of type (() => Unit) ->{c} Unit - |corresponds to capture-polymorphic formal parameter v1 of type () =>² Unit + |to a function of type (x$0: () => Unit) -> (() ->{c, any} Unit) ->{x$0} Unit + |corresponds to capture-polymorphic formal parameter x$0 of type () =>² Unit |and hides capabilities {c}. - |Some of these overlap with the captures of the function prefix. + |Some of these overlap with the captures of the function result with type (() ->{c, any} Unit) ->{c} Unit. | | Hidden set of current argument : {c} | Hidden footprint of current argument : {c} - | Capture set of function prefix : {c} - | Footprint set of function prefix : {c} + | Capture set of function result : {c} + | Footprint set of function result : {c} | The two sets overlap at : {c} | |where: => refers to a root capability in the type of parameter c - | =>² refers to a root capability created in method test when checking argument to parameter v1 of method apply + | =>² refers to a root capability created in method test when checking argument to parameter x$0 of method apply -- Error: tests/neg-custom-args/captures/sep-curried-par.scala:23:65 --------------------------------------------------- 23 | val bar = (p1: () => Unit) => (p2: () ->{p1, any} Unit) => par(p1, p2) // error separation | ^^ @@ -61,20 +61,3 @@ | |where: => refers to a root capability in the type of parameter p1 | =>² refers to a root capability created in anonymous function of type (p2²: () ->{p1, any} Unit): Unit when checking argument to parameter p1 of method par --- Error: tests/neg-custom-args/captures/sep-curried-par.scala:24:9 ---------------------------------------------------- -24 | bar(c)(c) // error separation - | ^ - |Separation failure: argument of type (c : () => Unit) - |to a function of type (() => Unit) ->{c} Unit - |corresponds to capture-polymorphic formal parameter v1 of type () =>² Unit - |and hides capabilities {c}. - |Some of these overlap with the captures of the function prefix. - | - | Hidden set of current argument : {c} - | Hidden footprint of current argument : {c} - | Capture set of function prefix : {c} - | Footprint set of function prefix : {c} - | The two sets overlap at : {c} - | - |where: => refers to a root capability in the type of parameter c - | =>² refers to a root capability created in method test when checking argument to parameter v1 of method apply diff --git a/tests/neg-custom-args/captures/sep-curried-par.scala b/tests/neg-custom-args/captures/sep-curried-par.scala index da574cc55f1e..9e1d0a069a84 100644 --- a/tests/neg-custom-args/captures/sep-curried-par.scala +++ b/tests/neg-custom-args/captures/sep-curried-par.scala @@ -21,7 +21,7 @@ def test(c: () => Unit) = foo(c)(c) // error: separation val bar = (p1: () => Unit) => (p2: () ->{p1, any} Unit) => par(p1, p2) // error separation - bar(c)(c) // error separation + bar(c)(c) diff --git a/tests/neg-custom-args/captures/try-boundary.check b/tests/neg-custom-args/captures/try-boundary.check index 21837815e65b..6181441d32a2 100644 --- a/tests/neg-custom-args/captures/try-boundary.check +++ b/tests/neg-custom-args/captures/try-boundary.check @@ -16,12 +16,12 @@ |-------------------------------------------------------------------------------------------------------------------- |Inline stack trace |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |This location contains code that was inlined from boundary.scala:71 -71 | inline def apply[T](inline body: Label[T] ?=> T): T = + |This location contains code that was inlined from boundary.scala:85 +85 | inline def apply[T](inline body: Label[T] ?=> T): T = | ^ -72 | val local = Label[T]() -73 |... -76 | else throw ex +86 | val local = Label[T]() +87 |... +90 | else throw ex -------------------------------------------------------------------------------------------------------------------- | | longer explanation available when compiling with `-explain` diff --git a/tests/neg-custom-args/captures/unscoped-classifier-global.scala b/tests/neg-custom-args/captures/unscoped-classifier-global.scala index 6e960c098417..e83e0f3ebda1 100644 --- a/tests/neg-custom-args/captures/unscoped-classifier-global.scala +++ b/tests/neg-custom-args/captures/unscoped-classifier-global.scala @@ -4,13 +4,13 @@ trait Async extends Control class A(a: Async) extends caps.Unscoped // error but msg could be better -class B extends caps.Unscoped: // error - val a: Async^ = new Async {} +class B extends caps.Unscoped: + val a: Async^ = new Async {} // error class C(f: () => Unit) extends caps.Unscoped // error but msg could be better -class D extends caps.Unscoped: // error - val f: () => Unit = ??? +class D extends caps.Unscoped: + val f: () => Unit = ??? // error val g: () => Unit = () => () diff --git a/tests/neg-custom-args/captures/unscoped-classifier.check b/tests/neg-custom-args/captures/unscoped-classifier.check index b1c7c410c3d2..0f98828330ad 100644 --- a/tests/neg-custom-args/captures/unscoped-classifier.check +++ b/tests/neg-custom-args/captures/unscoped-classifier.check @@ -4,22 +4,12 @@ | Reference `A.this.a` is not included in the allowed capture set {any} of the self type of class A. | | where: any is a root capability classified as Unscoped in the type of class A --- Error: tests/neg-custom-args/captures/unscoped-classifier.scala:7:6 ------------------------------------------------- -7 |class B extends caps.Unscoped: // error - | ^ - | class B is classied as scala.caps.Unscoped but has a field a classified as scala.caps.Control. - | Field classifiers have to conform to the classifier of the containing class. -- [E223] CaptureChecking Error: tests/neg-custom-args/captures/unscoped-classifier.scala:10:8 ------------------------- 10 |class C(f: () => Unit) extends caps.Unscoped // error but msg could be better | ^ | Reference `C.this.f` is not included in the allowed capture set {any} of the self type of class C. | | where: any is a root capability classified as Unscoped in the type of class C --- Error: tests/neg-custom-args/captures/unscoped-classifier.scala:12:6 ------------------------------------------------ -12 |class D extends caps.Unscoped: // error - | ^ - | class D is classied as scala.caps.Unscoped but has a field f of unclassified type () => Unit. - | Field classifiers have to conform to the classifier of the containing class. -- [E223] CaptureChecking Error: tests/neg-custom-args/captures/unscoped-classifier.scala:17:15 ------------------------ 17 | def gg() = g() // error but msg could be better | ^ @@ -27,3 +17,19 @@ | | where: any is a root capability classified as Unscoped in the type of class E | any² is a root capability classified as Unscoped created in class E when constructing instance E +-- Error: tests/neg-custom-args/captures/unscoped-classifier.scala:8:6 ------------------------------------------------- +8 | val a: Async^ = new Async {} // error + | ^ + | value a's type Async^ is classified as scala.caps.Control, + | but it is a field of class B which is classied as scala.caps.Unscoped. + | Field classifiers have to conform to the classifier of the containing class. + | + | where: ^ refers to a root capability classified as Control in the type of value a +-- Error: tests/neg-custom-args/captures/unscoped-classifier.scala:13:6 ------------------------------------------------ +13 | val f: () => Unit = ??? // error + | ^ + | value f's type () => Unit is unclassified, + | but it is a field of class D which is classied as scala.caps.Unscoped. + | Field classifiers have to conform to the classifier of the containing class. + | + | where: => refers to a root capability in the type of value f diff --git a/tests/neg-custom-args/captures/unscoped-classifier.scala b/tests/neg-custom-args/captures/unscoped-classifier.scala index 066b350617e9..77fd8d0565b8 100644 --- a/tests/neg-custom-args/captures/unscoped-classifier.scala +++ b/tests/neg-custom-args/captures/unscoped-classifier.scala @@ -4,13 +4,13 @@ trait Async extends Control class A(a: Async) extends caps.Unscoped // error but msg could be better -class B extends caps.Unscoped: // error - val a: Async^ = new Async {} +class B extends caps.Unscoped: + val a: Async^ = new Async {} // error class C(f: () => Unit) extends caps.Unscoped // error but msg could be better -class D extends caps.Unscoped: // error - val f: () => Unit = ??? +class D extends caps.Unscoped: + val f: () => Unit = ??? // error def test(g: () => Unit) = class E extends caps.Unscoped: diff --git a/tests/neg-custom-args/captures/use-capset.check b/tests/neg-custom-args/captures/use-capset.check index 0ab35941c85d..45cf1631a64c 100644 --- a/tests/neg-custom-args/captures/use-capset.check +++ b/tests/neg-custom-args/captures/use-capset.check @@ -1,5 +1,5 @@ --- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:11:22 ----------------------------------- -11 | val _: () -> Unit = h // error: should be ->{io} +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:15:22 ----------------------------------- +15 | val _: () -> Unit = h // error: should be ->{io} | ^ | Found: (h : () ->{io} Unit) | Required: () -> Unit @@ -7,10 +7,10 @@ | Note that capability `io` cannot flow into capture set {}. | | longer explanation available when compiling with `-explain` --- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:13:50 ----------------------------------- -13 | val _: () -> List[Object^{io}] -> Object^{io} = h2 // error, should be ->{io} +-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:17:50 ----------------------------------- +17 | val _: () -> List[Object^{io}] -> Object^{io} = h2 // error, should be ->{io} | ^^ - | Found: (h2 : () ->{} List[Object^{io}] ->{io} Object^{io}) + | Found: (h2 : () -> List[Object^{io}] ->{io} Object^{io}) | Required: () -> List[Object^{io}] -> Object^{io} | | Note that capability `io` cannot flow into capture set {}. diff --git a/tests/neg-custom-args/captures/use-capset.scala b/tests/neg-custom-args/captures/use-capset.scala index c478a88b3086..a60553455a03 100644 --- a/tests/neg-custom-args/captures/use-capset.scala +++ b/tests/neg-custom-args/captures/use-capset.scala @@ -3,8 +3,12 @@ import caps.{use, CapSet} def f[C^](xs: List[Object^{C}]): Unit = ??? private def g[C^] = (xs: List[Object^{C}]) => xs.head // error TODO: allow this - // This fails currently since `C^` is not classified as used. To classify it we'd also have to look on the - // RHS. But this would change again if we go to non-monotonic currying. + // This fails currently since `C^` is not classified as used since it does + // not appear in the deep capture set of a term parameter of `g`. See CaptureOps.isUseParam. + // To classify it as used we'd also have to look at the RHS. But this would change again + // if we go to non-monotonic currying. + +private def g2[C^](xs: List[Object^{C}]) = xs.head // ok def test(io: Object^)(xs: List[Object^{io}]): Unit = val h = () => f(xs) diff --git a/tests/neg-macros/annot-crash.check b/tests/neg-macros/annot-crash.check index 3928956add76..a3ee9992fe60 100644 --- a/tests/neg-macros/annot-crash.check +++ b/tests/neg-macros/annot-crash.check @@ -3,5 +3,5 @@ |^^^^^^ |Failed to evaluate macro annotation '@crash'. | Caused by class scala.NotImplementedError: an implementation is missing - | scala.Predef$.$qmark$qmark$qmark(Predef.scala:383) + | scala.Predef$.$qmark$qmark$qmark(Predef.scala:396) | crash.transform(Macro_1.scala:7) diff --git a/tests/neg-macros/i15159.check b/tests/neg-macros/i15159.check index ed309627862e..824d68a4583f 100644 --- a/tests/neg-macros/i15159.check +++ b/tests/neg-macros/i15159.check @@ -4,7 +4,7 @@ | Exception occurred while executing macro expansion. | java.lang.AssertionError: class X is not a member of A | at TestMacro$.testImpl$$anonfun$1(Macro_1.scala:8) - | at scala.collection.immutable.List.map(List.scala:240) + | at scala.collection.immutable.List.map(List.scala:244) | at TestMacro$.testImpl(Macro_1.scala:7) | |--------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg-macros/i19842-a.check b/tests/neg-macros/i19842-a.check index 0ea422a69981..64e526d6301a 100644 --- a/tests/neg-macros/i19842-a.check +++ b/tests/neg-macros/i19842-a.check @@ -2,15 +2,11 @@ 9 |@main def Test = summon[Serializer[ValidationCls]] // error | ^ |Exception occurred while executing macro expansion. - |java.lang.AssertionError: assertion failed: Parents of class symbol differs from the parents in the tree for object objectSerializer$macro$1 + |java.lang.AssertionError: Parents of class symbol differs from the parents in the tree for object objectSerializer$macro$1 | |Parents in symbol: [class Object, trait Serializer] |Parents in tree: [trait Serializer] | - | at scala.runtime.Scala3RunTime$.assertFailed(Scala3RunTime.scala:10) - | at dotty.tools.dotc.transform.TreeChecker$.checkParents(TreeChecker.scala:208) - | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:286) - | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:285) | at Macros$.makeSerializer(Macro.scala:23) | |--------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg-macros/i19842-b.check b/tests/neg-macros/i19842-b.check index c7b5508b9563..98c8858ed33e 100644 --- a/tests/neg-macros/i19842-b.check +++ b/tests/neg-macros/i19842-b.check @@ -2,15 +2,11 @@ 9 |@main def Test = summon[Serializer[ValidationCls]] // error | ^ |Exception occurred while executing macro expansion. - |java.lang.AssertionError: assertion failed: Parents of class symbol differs from the parents in the tree for object objectSerializer$macro$1 + |java.lang.AssertionError: Parents of class symbol differs from the parents in the tree for object objectSerializer$macro$1 | |Parents in symbol: [class Object, trait Serializer] |Parents in tree: [class Object, trait Serializer, trait Foo] | - | at scala.runtime.Scala3RunTime$.assertFailed(Scala3RunTime.scala:10) - | at dotty.tools.dotc.transform.TreeChecker$.checkParents(TreeChecker.scala:208) - | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:286) - | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:285) | at Macros$.makeSerializer(Macro.scala:25) | |--------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg/25198.check b/tests/neg/25198.check new file mode 100644 index 000000000000..f48dc5497280 --- /dev/null +++ b/tests/neg/25198.check @@ -0,0 +1,15 @@ +-- Error: tests/neg/25198/Main_2.scala:5:11 ---------------------------------------------------------------------------- +5 | Macros.foo // error - the closure does not refer to an anonymous function + | ^^^^^^^^^^ + | Exception occurred while executing macro expansion. + | java.lang.AssertionError: Closures must refer to anonymous functions + | at Macros$.fooImpl(Macros_1.scala:32) + | at Macros$.inline$fooImpl(Macros_1.scala:8) + | + |--------------------------------------------------------------------------------------------------------------------- + |Inline stack trace + |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + |This location contains code that was inlined from Macros_1.scala:5 +5 | ${ fooImpl } + | ^^^^^^^^^^^^ + --------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg/25198/Macros_1.scala b/tests/neg/25198/Macros_1.scala new file mode 100644 index 000000000000..80f1970ebd6a --- /dev/null +++ b/tests/neg/25198/Macros_1.scala @@ -0,0 +1,33 @@ +import scala.quoted.* + +object Macros: + transparent inline def foo: String => String = + ${ fooImpl } + + // Synthesizes x => x + private def fooImpl(using Quotes): Expr[String => String] = + import quotes.reflect.* + + val methSym = + Symbol.newMethod( + Symbol.spliceOwner, + name = "fooImpl", + tpe = MethodType(List("x"))( + _ => List(TypeRepr.of[String]), + _ => TypeRepr.of[String], + ), + ) + + val meth = + DefDef( + methSym, + rhsFn = { argss => + val List(List(x)) = argss + Some(x.asInstanceOf[Term]) + } + ) + + Block( + List(meth), + Closure(Ident(methSym.termRef), tpe = None), + ).asExprOf[String => String] diff --git a/tests/neg/25198/Main_2.scala b/tests/neg/25198/Main_2.scala new file mode 100644 index 000000000000..23fd7e796209 --- /dev/null +++ b/tests/neg/25198/Main_2.scala @@ -0,0 +1,8 @@ +//> using options -Xcheck-macros + +object Main: + val f: String => String = + Macros.foo // error - the closure does not refer to an anonymous function + + @main def go = + println(f("Hello")) diff --git a/tests/neg/6314-6.check b/tests/neg/6314-6.check index 7d6bd182173d..9acbf513038e 100644 --- a/tests/neg/6314-6.check +++ b/tests/neg/6314-6.check @@ -1,4 +1,4 @@ --- Error: tests/neg/6314-6.scala:26:3 ---------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/6314-6.scala:26:3 --------------------------------------------------------------- 26 | (new YY {}).boom // error: object creation impossible | ^ |object creation impossible, since def apply(fa: String): Int in trait XX in object Test3 is not defined @@ -6,7 +6,7 @@ | parameter String in def apply(fa: String): Int in trait XX in object Test3 does not match | parameter Test3.Bar[X & Object with Test3.YY {...}#Foo] in def apply(fa: Test3.Bar[X & YY.this.Foo]): Test3.Bar[Y & YY.this.Foo] in trait YY in object Test3 | ) --- Error: tests/neg/6314-6.scala:52:3 ---------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/6314-6.scala:52:3 --------------------------------------------------------------- 52 | (new YY {}).boom // error: object creation impossible | ^ |object creation impossible, since def apply(fa: String): Int in trait XX in object Test4 is not defined diff --git a/tests/neg/abstract-givens.check b/tests/neg/abstract-givens.check index 51f50db266c2..e241e438e9d9 100644 --- a/tests/neg/abstract-givens.check +++ b/tests/neg/abstract-givens.check @@ -1,7 +1,7 @@ --- Error: tests/neg/abstract-givens.scala:11:8 ------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/abstract-givens.scala:11:8 ------------------------------------------------------ 11 | given s: [T] => T => Seq[T]: // error | ^ - |instance cannot be created, since def iterator: Iterator[A] in trait IterableOnce in package scala.collection is not defined + |instance cannot be created, since def iterator: Iterator[T] in trait IterableOnce in package scala.collection is not defined -- [E164] Declaration Error: tests/neg/abstract-givens.scala:8:8 ------------------------------------------------------- 8 | given y(using Int): String = summon[Int].toString * 22 // error | ^ diff --git a/tests/neg/duplicate-enum.scala b/tests/neg/duplicate-enum.scala new file mode 100644 index 000000000000..5e27caf78010 --- /dev/null +++ b/tests/neg/duplicate-enum.scala @@ -0,0 +1,7 @@ +object Test { + enum E { // error + case K0 + } + enum E: // error + case K0(v0: Long) +} diff --git a/tests/neg/i10666.check b/tests/neg/i10666.check index 491b88f1ffa5..1270d32e60ce 100644 --- a/tests/neg/i10666.check +++ b/tests/neg/i10666.check @@ -1,4 +1,4 @@ --- Error: tests/neg/i10666.scala:8:6 ----------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i10666.scala:8:6 ---------------------------------------------------------------- 8 |class Bar extends Foo { // error | ^^^ | class Bar needs to be abstract, since def foo[T <: B](tx: T): Unit in trait Foo is not defined diff --git a/tests/neg/i12828.check b/tests/neg/i12828.check index e2a1cdb92dcd..76d542b46529 100644 --- a/tests/neg/i12828.check +++ b/tests/neg/i12828.check @@ -1,7 +1,7 @@ --- Error: tests/neg/i12828.scala:7:7 ----------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i12828.scala:7:7 ---------------------------------------------------------------- 7 |object Baz extends Bar[Int] // error: not implemented | ^^^ - | object creation impossible, since def foo(x: A): Unit in trait Foo is not defined + | object creation impossible, since def foo(x: Int): Unit in trait Foo is not defined | (Note that | parameter A in def foo(x: A): Unit in trait Foo does not match | parameter Int & String in def foo(x: A & String): Unit in trait Bar diff --git a/tests/neg/i13076.check b/tests/neg/i13076.check index 641bf5aa2677..5c23a99d01f5 100644 --- a/tests/neg/i13076.check +++ b/tests/neg/i13076.check @@ -1,10 +1,8 @@ --- Error: tests/neg/i13076.scala:6:6 ----------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i13076.scala:6:6 ---------------------------------------------------------------- 6 |class C[X, Y] extends T[X, Y] {} // error | ^ - | class C needs to be abstract, since: - | it has 2 unimplemented members. - | /** As seen from class C, the missing signatures are as follows. - | * For convenience, these are usable as stub implementations. - | */ - | def f(a: X): Y = ??? - | def g(a: X, b: Y): Unit = ??? + | class C needs to be abstract, since it has 2 unimplemented members. + | + | Members declared in T: + | - def f(a: X): Y + | - def g(a: X, b: Y): Unit diff --git a/tests/neg/i13466.check b/tests/neg/i13466.check index ad097ddae96b..89c26d5bfa78 100644 --- a/tests/neg/i13466.check +++ b/tests/neg/i13466.check @@ -1,11 +1,9 @@ --- Error: tests/neg/i13466.scala:9:6 ----------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i13466.scala:9:6 ---------------------------------------------------------------- 9 |given none: SomeTrait[Finally] with {} // error | ^^^^ - | object creation impossible, since: - | it has 3 unimplemented members. - | /** As seen from module class none$, the missing signatures are as follows. - | * For convenience, these are usable as stub implementations. - | */ - | def foo: Finally[Unit] = ??? - | def withTV[A]: Finally[A] = ??? - | def withTV2[A, B]: Finally[(A, B)] = ??? + | object creation impossible, since it has 3 unimplemented members. + | + | Members declared in SomeTrait: + | - def foo: Finally[Unit] + | - def withTV[A]: Finally[A] + | - def withTV2[A, B]: Finally[(A, B)] diff --git a/tests/neg/i15381.scala b/tests/neg/i15381.scala index a0328931b36e..ab8909a35658 100644 --- a/tests/neg/i15381.scala +++ b/tests/neg/i15381.scala @@ -1,6 +1,6 @@ //> using options -Vprint:parser -case class $[A](value: A) +case class `$`[A](value: A) def g: Int = $ // error diff --git a/tests/neg/i15784.check b/tests/neg/i15784.check index d8c9c193c7dc..c1540b33d956 100644 --- a/tests/neg/i15784.check +++ b/tests/neg/i15784.check @@ -10,17 +10,3 @@ | Not found: A | | longer explanation available when compiling with `-explain` --- Warning: tests/neg/i15784.scala:7:7 --------------------------------------------------------------------------------- -7 | case X: Int => X // warn - | ^ - | Type ascriptions after patterns other than: - | * variable pattern, e.g. `case x: String =>` - | * number literal pattern, e.g. `case 10.5: Double =>` - | are no longer supported. Remove the type ascription or move it to a separate variable pattern. --- Warning: tests/neg/i15784.scala:10:7 -------------------------------------------------------------------------------- -10 | case `Int`: Int => `Int` // warn - | ^^^^^ - | Type ascriptions after patterns other than: - | * variable pattern, e.g. `case x: String =>` - | * number literal pattern, e.g. `case 10.5: Double =>` - | are no longer supported. Remove the type ascription or move it to a separate variable pattern. diff --git a/tests/neg/i15784.scala b/tests/neg/i15784.scala index 4be909198eaa..edf69d32f95a 100644 --- a/tests/neg/i15784.scala +++ b/tests/neg/i15784.scala @@ -2,9 +2,3 @@ def i15784 = List(42) match case List(_, Rest @ `a`) => Rest // error case List(_, Rest @ A) => Rest // error case _ => ??? - -def case2 = 42 match - case X: Int => X // warn - -def case3 = 42 match - case `Int`: Int => `Int` // warn diff --git a/tests/neg/i16072.scala b/tests/neg/i16072.scala new file mode 100644 index 000000000000..870a9710c9b9 --- /dev/null +++ b/tests/neg/i16072.scala @@ -0,0 +1,3 @@ + +enum Oops_: + case Z // error // error expected { and } diff --git a/tests/neg/i16842.check b/tests/neg/i16842.check index 9a77e194add0..885e965df28f 100644 --- a/tests/neg/i16842.check +++ b/tests/neg/i16842.check @@ -1,4 +1,7 @@ --- Error: tests/neg/i16842.scala:24:7 ---------------------------------------------------------------------------------- +-- [E007] Type Mismatch Error: tests/neg/i16842.scala:24:8 ------------------------------------------------------------- 24 | Liter(SemanticArray[SemanticInt.type], x) // error - | ^ - |invalid new prefix (dim: Int): SemanticArray[SemanticInt.type] cannot replace (ty : SemanticArray[SemanticType]) in type ty.T + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | Found: Int => SemanticArray[SemanticInt.type] + | Required: SemanticArray[SemanticType] + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg/i18020b.check b/tests/neg/i18020b.check new file mode 100644 index 000000000000..1e2d22cacf99 --- /dev/null +++ b/tests/neg/i18020b.check @@ -0,0 +1,26 @@ +-- [E040] Syntax Error: tests/neg/i18020b.scala:2:17 ------------------------------------------------------------------- +2 |class i18020(a_: Int): // error + | ^^^ + | ':' expected, but identifier found +-- [E040] Syntax Error: tests/neg/i18020b.scala:3:12 ------------------------------------------------------------------- +3 | def f(b_: Int) = 42 // error + | ^^^ + | ':' expected, but identifier found +-- [E040] Syntax Error: tests/neg/i18020b.scala:4:10 ------------------------------------------------------------------- +4 | def g_: Int = 27 // error + | ^^^ + | '=' expected, but identifier found; identifier ends in colon, did you mean `g_`: in backticks? +-- [E040] Syntax Error: tests/neg/i18020b.scala:6:12 ------------------------------------------------------------------- +6 | val x_: Int = 1 // error + | ^^^ + | '=' expected, but identifier found; identifier ends in colon, did you mean `x_`: in backticks? +-- [E040] Syntax Error: tests/neg/i18020b.scala:7:12 ------------------------------------------------------------------- +7 | val y_: Int = 2 // error + | ^^^ + | '=' expected, but identifier found; identifier ends in colon, did you mean `y_`: in backticks? +-- [E006] Not Found Error: tests/neg/i18020b.scala:8:4 ----------------------------------------------------------------- +8 | x_ + y_ // error + | ^^ + | Not found: x_ - did you mean x_:? + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg/i18020b.scala b/tests/neg/i18020b.scala new file mode 100644 index 000000000000..76aff27380f9 --- /dev/null +++ b/tests/neg/i18020b.scala @@ -0,0 +1,8 @@ +// problems with colon fusion, a harder challenge than cold fusion +class i18020(a_: Int): // error + def f(b_: Int) = 42 // error + def g_: Int = 27 // error + def k = + val x_: Int = 1 // error + val y_: Int = 2 // error + x_ + y_ // error diff --git a/tests/neg/i18234.scala b/tests/neg/i18234.scala new file mode 100755 index 000000000000..a4c04d506b17 --- /dev/null +++ b/tests/neg/i18234.scala @@ -0,0 +1,172 @@ +//> using options -Wconf:name=IllegalIdentifier&msg=reserved:e -source:3.9 +/* vals */ +val goodVal = 1 +val $startVal = 1 // error +val mid$dleVal = 1 // error +val endVal$ = 1 // error + +def testValUsage = + $startVal + endVal$ // ok, should only warn on declaration not on usage + +/* functions */ +def $funcStart() = 3 // error +def func$Middle() = 3 // error +def funcEnd$() = 3 // error + +def func1badArg(goodArg: Int, bad$Arg: Int) = 5 // error +def func1badArgAndUsageDoesNotThrowWarning(goodArg: Int, bad$Arg: Int) = bad$Arg // error +def func2badArgs(goodArg: Int, bad$Arg: Int, bad$arg2: String) = 5 // error // error +def multilineFunc( + goodArg: Int, + badAr$g: Int // error +) = 1 + +def testFuncUsaage = + $funcStart() + func1badArg(1, 2) // ok, should only warn on declaration not on usage + +/* types */ +type GoodType = Int +type $StartType = Int // error +type Middle$Type = Int // error +type EndType$ = Int // error + +val typedVal: Middle$Type = 2 // ok, should only warn on declaration not on usage +def funcWithDollarTypes(foo: $StartType): Middle$Type = 2 // ok, should only warn on declaration not on usage + +class `Check$Me$Not` + +/* enums */ +enum GoodEnum: + case GoodCase + case $BadCaseStart // error + case BadCase$Middle // error + case BadCaseEnd$ // error + +enum $BadEnumStart: // error + case GoodCase + case $BadCase // error + +enum BadEnum$Middle: // error + case GoodCase + case Bad$Case // error + +enum BadEnumEnd$: // error + case GoodCase + case BadCase$ // error + +enum E$numWithEndKeyword: // error + case SomeCase +end E$numWithEndKeyword // ok + +def TestEnumUsage(a: $BadEnumStart): Int = // ok, should only warn on declaration not on usage + a match + case $BadEnumStart.GoodCase => 1 + case $BadEnumStart.$BadCase => 2 // ok, should only warn on declaration not on usage + +/* objects */ +object $ObjectStart: // error + val goodVal = 1 + val $badVal = 2 // error + +object Object$Middle: // error + val goodVal = 1 + val bad$Val = 2 // error + +object ObjectEnd$: // error + val goodVal = 1 + val badVal$ = 2 // error + +object GoodObject: + val goodVal = 1 + val b$adVal = 2 // error + +object Ob$jectWithEndKeyword: // error + val someVal = 1 +end Ob$jectWithEndKeyword // ok + +val testObjectUsage = ObjectEnd$.badVal$ // ok, should only warn on declaration not on usage + +/* case classes */ +case class $InlineCaseClassStart(someField: Int) // error +case class InlineCaseClass$Middle(someField: Int) // error +case class InlineCaseClassEnd$(someField: Int) // error + +case class InlineCaseClass(goodField: Int, badFiel$d: Int) // error + +case class $CaseClassStart( // error + somefield: Int, + b$adfield: Int // error +) + +case class CaseClass$Middle( // error + somefield: Int, + bad$Field: Int // error +) +object CaseClass$Middle // error + +case class CaseClassEnd$( // error + somefield: Int, + badField$: Int // error +) + +// companion oject +object CaseClassEnd$: // error + val food = 1 + +val testCaseClassUsage = CaseClass$Middle(somefield = 1, bad$Field = 2) // ok, should only warn on declaration not on usage + +/* classes */ +class GoodClass +class $StartClass // error +class Middle$Class // error +class EndClass$ // error + +class Cla$$( // error + var goodMember: Int, + var badM$ember: Int // error +): + def goodMethod(x: Int) = badM$ember // ok, only checking if the method name does not contain a dollar sign + def bad$Method(y: Int) = goodMember // error + def methodWithBadArgNames(b$ad$arg: Int) = goodMember // error + def method$WithEndKeyword() = // error + 3 + end method$WithEndKeyword +end Cla$$ // ok + +def testUsage = + val instantiation = new Cla$$(goodMember = 1, badM$ember = 2) // ok, should only warn on declaration not on usage + instantiation.bad$Method(1) // ok, should only warn on declaration not on usage + instantiation.methodWithBadArgNames(2) // ok, should only warn on declaration not on usage + + +/* traits */ +trait GoodTrait +trait $BadTraitStart // error +trait BadTrait$Middle // error +trait BadTraitEnd$ // error + +class TestTraitUsage extends $BadTraitStart // ok, should only warn on declaration not on usage + +package GoodPackage: + val goodVal = 1 + val b$adVal = 2 // error + +package $BadPackageStart: // error + val goodVal = 1 + val $badVal = 2 // error + +package BadPackage$Middle: // error + val goodVal = 1 + val bad$Val = 2 // error + +package BadPackageEnd$ : // error + val goodVal = 1 + val badVal$ = 2 // error + +class BadConstructor: + def ``() = () // error // error + +def patvar[A](x: Option[A]) = + x match + case Some(funky$thing) => true // error + case _ => false diff --git a/tests/neg/i19100.check b/tests/neg/i19100.check index e6ff80e450ab..e540d0af2f57 100644 --- a/tests/neg/i19100.check +++ b/tests/neg/i19100.check @@ -1,15 +1,15 @@ --- Error: tests/neg/i19100.scala:4:3 ----------------------------------------------------------------------------------- +-- Error: tests/neg/i19100.scala:4:2 ----------------------------------------------------------------------------------- 4 | match // error - | ^^^^^ - | XML literals are no longer supported. - | See https://docs.scala-lang.org/scala3/reference/dropped-features/xml.html --- Error: tests/neg/i19100.scala:5:10 ---------------------------------------------------------------------------------- + | ^^^^^^ + | XML literals are no longer supported. + | See https://docs.scala-lang.org/scala3/reference/dropped-features/xml.html +-- Error: tests/neg/i19100.scala:5:9 ----------------------------------------------------------------------------------- 5 | case => 1 // error - | ^^^^^ - | XML literals are no longer supported. - | See https://docs.scala-lang.org/scala3/reference/dropped-features/xml.html --- Error: tests/neg/i19100.scala:6:3 ----------------------------------------------------------------------------------- + | ^^^^^^ + | XML literals are no longer supported. + | See https://docs.scala-lang.org/scala3/reference/dropped-features/xml.html +-- Error: tests/neg/i19100.scala:6:2 ----------------------------------------------------------------------------------- 6 | // error - | ^^^^^^^^^^ - | XML literals are no longer supported. - | See https://docs.scala-lang.org/scala3/reference/dropped-features/xml.html + | ^^^^^^^^^^^ + | XML literals are no longer supported. + | See https://docs.scala-lang.org/scala3/reference/dropped-features/xml.html diff --git a/tests/neg/i19731.check b/tests/neg/i19731.check index 5c6ef5246b1d..9111ee1f754e 100644 --- a/tests/neg/i19731.check +++ b/tests/neg/i19731.check @@ -1,27 +1,22 @@ --- Error: tests/neg/i19731.scala:4:6 ----------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i19731.scala:4:6 ---------------------------------------------------------------- 4 |class F1 extends Foo: // error | ^^ - | class F1 needs to be abstract, since def foo(): Unit in class F1 is not defined --- Error: tests/neg/i19731.scala:7:6 ----------------------------------------------------------------------------------- + | class F1 needs to be abstract, since def foo(): Unit in class F1 is not defined +-- [E231] Declaration Error: tests/neg/i19731.scala:7:6 ---------------------------------------------------------------- 7 |class F2 extends Foo: // error | ^^ - | class F2 needs to be abstract, since: - | it has 2 unimplemented members. - | /** As seen from class F2, the missing signatures are as follows. - | * For convenience, these are usable as stub implementations. - | */ - | def foo(): Unit = ??? - | def foo(x: Int): Unit = ??? --- Error: tests/neg/i19731.scala:16:6 ---------------------------------------------------------------------------------- + | class F2 needs to be abstract, since it has 2 unimplemented members. + | + | Members declared in F2: + | - def foo(): Unit + | - def foo(x: Int): Unit +-- [E231] Declaration Error: tests/neg/i19731.scala:16:6 --------------------------------------------------------------- 16 |class B1 extends Bar: // error | ^^ - | class B1 needs to be abstract, since: - | it has 2 unimplemented members. - | /** As seen from class B1, the missing signatures are as follows. - | * For convenience, these are usable as stub implementations. - | */ - | // Members declared in B1 - | def foo(x: Int): Unit = ??? - | - | // Members declared in Bar - | def foo(): Unit = ??? + | class B1 needs to be abstract, since it has 2 unimplemented members. + | + | Members declared in B1: + | - def foo(x: Int): Unit + | + | Members declared in Bar: + | - def foo(): Unit diff --git a/tests/neg/i21335.check b/tests/neg/i21335.check index ae2e09df1f61..90236ebe26b0 100644 --- a/tests/neg/i21335.check +++ b/tests/neg/i21335.check @@ -1,8 +1,8 @@ --- Error: tests/neg/i21335.scala:7:6 ----------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i21335.scala:7:6 ---------------------------------------------------------------- 7 |class Z1 extends Bar1 // error | ^^ - | class Z1 needs to be abstract, since override def bar(): Bar1 in trait Bar1 is not defined --- Error: tests/neg/i21335.scala:12:6 ---------------------------------------------------------------------------------- + | class Z1 needs to be abstract, since override def bar(): Bar1 in trait Bar1 is not defined +-- [E231] Declaration Error: tests/neg/i21335.scala:12:6 --------------------------------------------------------------- 12 |class Z2 extends Bar2 // error | ^^ - | class Z2 needs to be abstract, since def bar(): Bar2 in trait Bar2 is not defined + | class Z2 needs to be abstract, since def bar(): Bar2 in trait Bar2 is not defined diff --git a/tests/neg/i22734.check b/tests/neg/i22734.check new file mode 100644 index 000000000000..b4cfcb8a898a --- /dev/null +++ b/tests/neg/i22734.check @@ -0,0 +1,24 @@ +-- [E231] Declaration Error: tests/neg/i22734.scala:4:7 ---------------------------------------------------------------- +4 |object X extends T // error via refchecks + | ^ + | object creation impossible, since def item: String in trait T is not defined +-- [E231] Declaration Error: tests/neg/i22734.scala:9:7 ---------------------------------------------------------------- +9 | case NonItem(other: String) // error + | ^^^^^^^ + | class NonItem needs to be abstract, since def item: String in class Foo is not defined +-- [E231] Declaration Error: tests/neg/i22734.scala:11:7 --------------------------------------------------------------- +11 | case AlsoT extends Foo, T // error missing error + | ^ + | object creation impossible, since def item: String in trait T is not defined +-- [E231] Declaration Error: tests/neg/i22734.scala:12:7 --------------------------------------------------------------- +12 | case Another extends Foo // error missing error + | ^ + | object creation impossible, since def item: String in class Foo is not defined +-- [E231] Declaration Error: tests/neg/i22734.scala:7:7 ---------------------------------------------------------------- +7 | case Empty // error via refchecks + | ^ + | object creation impossible, since def item: String in class Foo is not defined +-- [E231] Declaration Error: tests/neg/i22734.scala:13:7 --------------------------------------------------------------- +13 | case Decoy // error missing error + | ^ + | object creation impossible, since def item: String in class Foo is not defined diff --git a/tests/neg/i22734.scala b/tests/neg/i22734.scala new file mode 100644 index 000000000000..2c6bbb4daf45 --- /dev/null +++ b/tests/neg/i22734.scala @@ -0,0 +1,28 @@ +trait T: + def item: String + +object X extends T // error via refchecks + +enum Foo { + case Empty // error via refchecks + case NonEmpty(item: String) + case NonItem(other: String) // error + case Extender extends Foo, TCell + case AlsoT extends Foo, T // error missing error + case Another extends Foo // error missing error + case Decoy // error missing error + case NotSimple(item: String) + + def item: String +} + +trait TCell extends T: + override def item: String = "tcell" + +enum Bar: + case Baz extends Bar, TCell // simple case inherits definition + def item: String + +@main def test = + println: + Bar.Baz.item diff --git a/tests/neg/i22941.check b/tests/neg/i22941.check index 81edebd098d3..5ae7d37e0d6c 100644 --- a/tests/neg/i22941.check +++ b/tests/neg/i22941.check @@ -1,4 +1,4 @@ --- Error: tests/neg/i22941.scala:4:6 ----------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i22941.scala:4:6 ---------------------------------------------------------------- 4 |class Baz extends Foo: // error | ^^^ - | class Baz needs to be abstract, since def bar: String in trait Foo is not defined + | class Baz needs to be abstract, since def bar: String in trait Foo is not defined diff --git a/tests/neg/i22979.scala b/tests/neg/i22979.scala new file mode 100644 index 000000000000..1f3175e80b03 --- /dev/null +++ b/tests/neg/i22979.scala @@ -0,0 +1,11 @@ + +import annotation.* + +class C(@constructorOnly s: String): // error + def g: Any => String = _ => s + def f[A](xs: List[A]): List[String] = xs.map(g) + +import scala.util.boundary + +class Leak()(using @constructorOnly l: boundary.Label[String]): // error + lazy val broken = Option("stop").foreach(boundary.break(_)) diff --git a/tests/neg/i23400.scala b/tests/neg/i23400.scala index 1956385a1adc..0e37ff9a4bf5 100644 --- a/tests/neg/i23400.scala +++ b/tests/neg/i23400.scala @@ -1,5 +1,5 @@ -//> using options -preview -// preview needed for into in 3.8 +// placeholder for directives line +// import Conversion.into @@ -26,4 +26,4 @@ def test = val bazMirror = summon[Mirror.Of[Baz]] summon[bazMirror.MirroredElemTypes =:= (MyInto[Foo] *: EmptyTuple.type)] // ok - summon[bazMirror.MirroredElemTypes =:= (Foo *: EmptyTuple.type)] // error \ No newline at end of file + summon[bazMirror.MirroredElemTypes =:= (Foo *: EmptyTuple.type)] // error diff --git a/tests/neg/i23474.check b/tests/neg/i23474.check index 441978be6809..cd85c97e5102 100644 --- a/tests/neg/i23474.check +++ b/tests/neg/i23474.check @@ -1,9 +1,9 @@ --- Error: tests/neg/i23474.scala:5:11 ---------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i23474.scala:5:11 --------------------------------------------------------------- 5 |case class Y(val comment: String) extends Comment // error | ^ | class Y needs to be abstract, since var comment_=(x$1: String): Unit in trait Comment is not defined | (Note that an abstract var requires a setter in addition to the getter) --- Error: tests/neg/i23474.scala:7:6 ----------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i23474.scala:7:6 ---------------------------------------------------------------- 7 |class Z extends Comment: // error | ^ | class Z needs to be abstract, since var comment_=(x$1: String): Unit in trait Comment is not defined @@ -13,12 +13,12 @@ | ^ | error overriding variable comment in trait Comment of type String; | method comment of type => String cannot override a mutable variable --- Error: tests/neg/i23474.scala:10:6 ---------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i23474.scala:10:6 --------------------------------------------------------------- 10 |class X extends Comment: // error | ^ | class X needs to be abstract, since var comment_=(x$1: String): Unit in trait Comment is not defined | (Note that an abstract var requires a setter in addition to the getter) --- Error: tests/neg/i23474.scala:13:6 ---------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i23474.scala:13:6 --------------------------------------------------------------- 13 |class W extends Comment // error | ^ | class W needs to be abstract, since var comment: String in trait Comment is not defined diff --git a/tests/neg/i24037.scala b/tests/neg/i24037.scala new file mode 100644 index 000000000000..f8e978bd384d --- /dev/null +++ b/tests/neg/i24037.scala @@ -0,0 +1,28 @@ +// Test for issue #24037: Illegal applyDynamic signature should give error, not StackOverflowError +// https://github.com/scala/scala3/issues/24037 + +// Case 1: Original issue - illegal applyDynamic signature (only one parameter list) +object Test1: + val s = new Selectable: + type Fields = (f: Int) + def selectDynamic(f: String): Any = 1 + def applyDynamic(f: String): Any = 1 // illegal: missing second parameter list for args + + val x = s.f // error + +// Case 2: Another variant - missing varargs parameter +object Test2: + val s = new Selectable: + type Fields = (m: (x: Int) => Int) + def selectDynamic(name: String): Any = ??? + def applyDynamic(name: String): Any = ??? // illegal: should take (String)(Any*) or similar + + val y = s.m(42) // error + +// Case 3: Wrong return type but should still not crash +object Test3: + val s = new Selectable: + type Fields = (g: Int) + def selectDynamic(name: String): String = "wrong" // returns String not Any + + val z = s.g // error: type mismatch diff --git a/tests/neg/i24162.scala b/tests/neg/i24162.scala new file mode 100644 index 000000000000..22d97ce99521 --- /dev/null +++ b/tests/neg/i24162.scala @@ -0,0 +1,5 @@ + +def test(x: Int) = + x match + case `-`42 => true // error => expected + case _ => false // error unindent expected, case found diff --git a/tests/neg/i2421.scala b/tests/neg/i2421.scala index dc8e229f38f0..bcf3da6dbb36 100644 --- a/tests/neg/i2421.scala +++ b/tests/neg/i2421.scala @@ -1,7 +1,6 @@ inline object Foo // OK (error would be detected later, in PostTyper) inline class Bar // error: modifier(s) `inline' incompatible with type definition inline abstract class Baz // error: modifier(s) `inline' incompatible with type definition -inline trait Qux // error: modifier(s) `inline' incompatible with type definition object Quux { inline type T // error: modifier(s) `inline' incompatible with type definition diff --git a/tests/neg/i24460.check b/tests/neg/i24460.check index a990d518272d..e28509addfd6 100644 --- a/tests/neg/i24460.check +++ b/tests/neg/i24460.check @@ -6,13 +6,13 @@ |------------------------------------------------------------------------------------------------------------------- |Inline stack trace |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |This location contains code that was inlined from Predef.scala:151 -151 | inline def valueOf[T]: T = summonFrom { + |This location contains code that was inlined from Predef.scala:160 +160 | inline def valueOf[T]: T = summonFrom { | ^ -152 | case ev: ValueOf[T] => ev.value -153 | } +161 | case ev: ValueOf[T] => ev.value +162 | } |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |This location contains code that was inlined from Predef.scala:151 + |This location contains code that was inlined from Predef.scala:160 7 | case _: (h *: t) => valueOf[`h` & T] +: singletons[T, t] | ^^^^^^^^^^^^^^^^ ------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg/i24914.scala b/tests/neg/i24914.scala new file mode 100644 index 000000000000..e83359400845 --- /dev/null +++ b/tests/neg/i24914.scala @@ -0,0 +1,31 @@ +// Regression test for #24914: make sure that a forest of sibling givens +// sharing the same signature cannot blow up the implicit search into +// factorial territory. Before the divergence check considered candidates +// with identical declared types equivalent, this compiled for tens of +// seconds and eventually failed with a "search problem too large" warning. +// The search should now be cut short by ordinary divergence detection. + +trait Functor[F[_]] +trait Monad[F[_]] extends Functor[F] + +class T[F[_], A, X] + +object Functor: + given t1[F[_]: Functor, A]: Functor[[X] =>> T[F, A, X]] = ??? + given t2[F[_]: Functor, A]: Functor[[X] =>> T[F, A, X]] = ??? + given t3[F[_]: Functor, A]: Functor[[X] =>> T[F, A, X]] = ??? + given t4[F[_]: Monad, A]: Functor[[X] =>> T[F, A, X]] = ??? + given t5[F[_]: Functor, A]: Functor[[X] =>> T[F, A, X]] = ??? + given t6[F[_]: Functor, A]: Functor[[X] =>> T[F, A, X]] = ??? + +object Monad: + given t1[F[_]: Monad, A]: Monad[[X] =>> T[F, A, X]] = ??? + given t2[F[_]: Monad, A]: Monad[[X] =>> T[F, A, X]] = ??? + given t3[F[_]: Monad, A]: Monad[[X] =>> T[F, A, X]] = ??? + given t4[F[_]: Monad, A]: Monad[[X] =>> T[F, A, X]] = ??? + given t5[F[_]: Monad, A]: Monad[[X] =>> T[F, A, X]] = ??? + given t6[F[_]: Monad, A]: Monad[[X] =>> T[F, A, X]] = ??? + +def m[F[_]: Functor]: F[String] = ??? + +val x = for _ <- m yield () // error diff --git a/tests/neg/i25456.check b/tests/neg/i25456.check new file mode 100644 index 000000000000..4c06b4278527 --- /dev/null +++ b/tests/neg/i25456.check @@ -0,0 +1,22 @@ +-- [E040] Syntax Error: tests/neg/i25456.scala:6:41 -------------------------------------------------------------------- +6 | def generate[F[_]: { ApplicativeError[_[?], ?] }]: Int = 1 // error // error // error // nopos-error + | ^ + | ']' expected, but '[' found +-- [E035] Syntax Error: tests/neg/i25456.scala:6:46 -------------------------------------------------------------------- +6 | def generate[F[_]: { ApplicativeError[_[?], ?] }]: Int = 1 // error // error // error // nopos-error + | ^ + | Unbound wildcard type + | + | longer explanation available when compiling with `-explain` +-- [E019] Syntax Error: tests/neg/i25456.scala:6:48 -------------------------------------------------------------------- +6 | def generate[F[_]: { ApplicativeError[_[?], ?] }]: Int = 1 // error // error // error // nopos-error + | ^ + | Missing return type + | + | longer explanation available when compiling with `-explain` +-- Warning: tests/neg/i25456.scala:6:40 -------------------------------------------------------------------------------- +6 | def generate[F[_]: { ApplicativeError[_[?], ?] }]: Int = 1 // error // error // error // nopos-error + | ^ + | `_` is deprecated for wildcard arguments of types: use `?` instead + | This construct can be rewritten automatically under -rewrite -source 3.4-migration. +No warnings can be incurred under -Werror diff --git a/tests/neg/i25456.scala b/tests/neg/i25456.scala index 8d5e160cf653..dd2680306249 100644 --- a/tests/neg/i25456.scala +++ b/tests/neg/i25456.scala @@ -1,4 +1,12 @@ +//> using options -Werror + trait ApplicativeError[F[_], E] object A: - def generate[F[_]: { ApplicativeError[_[?], ?] }]: Int = 1 // error // error // error // error + def generate[F[_]: { ApplicativeError[_[?], ?] }]: Int = 1 // error // error // error // nopos-error + +/* Previous spurious error +4 | def generate[F[_]: { ApplicativeError[_[?], ?] }]: Int = 1 + | ^ + | Illegal context bound: Any does not take type parameters. +*/ diff --git a/tests/neg/i25531.check b/tests/neg/i25531.check index e6fa22598a82..23996ed1d0fc 100644 --- a/tests/neg/i25531.check +++ b/tests/neg/i25531.check @@ -1,13 +1,11 @@ --- Error: tests/neg/i25531.scala:3:6 ----------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i25531.scala:3:6 ---------------------------------------------------------------- 3 |class Walker extends FileVisitor[Path] {} // error | ^^^^^^ - |class Walker needs to be abstract, since: - |it has 4 unimplemented members. - |/** As seen from class Walker, the missing signatures are as follows. - | * For convenience, these are usable as stub implementations. - | */ - | def postVisitDirectory(x0: java.nio.file.Path, x1: java.io.IOException): java.nio.file.FileVisitResult = ??? - | def preVisitDirectory - | (x0: java.nio.file.Path, x1: java.nio.file.attribute.BasicFileAttributes): java.nio.file.FileVisitResult = ??? - | def visitFile(x0: java.nio.file.Path, x1: java.nio.file.attribute.BasicFileAttributes): java.nio.file.FileVisitResult = ??? - | def visitFileFailed(x0: java.nio.file.Path, x1: java.io.IOException): java.nio.file.FileVisitResult = ??? + |class Walker needs to be abstract, since it has 4 unimplemented members. + | + |Members declared in java.nio.file.FileVisitor: + |- def postVisitDirectory(x0: java.nio.file.Path, x1: java.io.IOException): java.nio.file.FileVisitResult + |- def preVisitDirectory + | (x0: java.nio.file.Path, x1: java.nio.file.attribute.BasicFileAttributes): java.nio.file.FileVisitResult + |- def visitFile(x0: java.nio.file.Path, x1: java.nio.file.attribute.BasicFileAttributes): java.nio.file.FileVisitResult + |- def visitFileFailed(x0: java.nio.file.Path, x1: java.io.IOException): java.nio.file.FileVisitResult diff --git a/tests/neg/i25531b.check b/tests/neg/i25531b.check index 0c00d53d1ae6..39225b7bf65b 100644 --- a/tests/neg/i25531b.check +++ b/tests/neg/i25531b.check @@ -1,4 +1,4 @@ --- Error: tests/neg/i25531b.scala:1:6 ---------------------------------------------------------------------------------- +-- [E231] Declaration Error: tests/neg/i25531b.scala:1:6 --------------------------------------------------------------- 1 |class Rble extends Readable // error | ^^^^ - |class Rble needs to be abstract, since def read(x0: java.nio.CharBuffer): Int in trait Readable in package java.lang is not defined + |class Rble needs to be abstract, since def read(x0: java.nio.CharBuffer): Int in trait Readable in package java.lang is not defined diff --git a/tests/neg/i25595.check b/tests/neg/i25595.check new file mode 100644 index 000000000000..5c3255ecc740 --- /dev/null +++ b/tests/neg/i25595.check @@ -0,0 +1,7 @@ +-- Error: tests/neg/i25595.scala:5:4 ----------------------------------------------------------------------------------- +5 |val ((x1, f1), (x2, f2)): ( // error + | ^^^^^^^^^^^^^^^^^^^^ + | Type ascriptions after patterns other than: + | * variable pattern, e.g. `case x: String =>` + | * number literal pattern, e.g. `case 10.5: Double =>` + | are no longer supported. Remove the type ascription or move it to a separate variable pattern. diff --git a/tests/neg/i25595.scala b/tests/neg/i25595.scala new file mode 100644 index 000000000000..7f99ec96634b --- /dev/null +++ b/tests/neg/i25595.scala @@ -0,0 +1,8 @@ +//> using options -source:future + +val avs = ((0d, BigDecimal(1)), (1d, BigDecimal(2))) + +val ((x1, f1), (x2, f2)): ( // error + (Double, BigDecimal), + (Double, BigDecimal) +) = avs diff --git a/tests/neg/i25702.scala b/tests/neg/i25702.scala new file mode 100644 index 000000000000..71da2de30ac2 --- /dev/null +++ b/tests/neg/i25702.scala @@ -0,0 +1,14 @@ +// https://github.com/scala/scala3/issues/25702 +// Regression test: a concrete class missing trait methods must produce a clean +// diagnostic, not a compiler crash. The original crash needed a stale +// `scala3-library` where `scala.caps.internal.consume` was missing, which made +// `requiredClass` fall back to `defn.AnyClass`. We can't reproduce the +// stale-classpath setup in the standard test framework, but the underlying fix +// is exercised by the `RequiredClassTest` unit test; this file guards the +// "missing-method" diagnostic. + +trait Storage: + def resolve(address: String): String + def create(data: List[Byte], owner: Option[String] = None): String + +final class InMemoryStorage extends Storage // error diff --git a/tests/neg/i25716.scala b/tests/neg/i25716.scala new file mode 100644 index 000000000000..276fa26c58f1 --- /dev/null +++ b/tests/neg/i25716.scala @@ -0,0 +1,8 @@ +def g[@inline x: _](y: x): Unit = () // error: Unbound wildcard type + +trait F[A] +trait G[A] +def ok[A: {F, G}](a: A): Unit = () // pos is start of A | F +def f0[A: {F, _}](a: A): Unit = () // error +def f1[A: {_, G}](a: A): Unit = () // error +def f2[A: {_, _}](a: A): Unit = () // error // error diff --git a/tests/neg/i25717.scala b/tests/neg/i25717.scala new file mode 100644 index 000000000000..4755cea51e31 --- /dev/null +++ b/tests/neg/i25717.scala @@ -0,0 +1,9 @@ +import scala.quoted.* + +object Crash { + def macroImpl(using Quotes)(q"a: String"): Expr[Boolean] = ??? // error + + def f(s"a: String") = ??? // error + + def softie(into q"a: String") = ??? // error +} diff --git a/tests/neg/i25856.scala b/tests/neg/i25856.scala new file mode 100644 index 000000000000..b1c09d83fe7a --- /dev/null +++ b/tests/neg/i25856.scala @@ -0,0 +1,5 @@ +// https://github.com/scala/scala3/issues/25856 +object parser: + def parse(input: String): Int = ??? + +import parser.parse.decode // error // error diff --git a/tests/neg/i4986c.scala b/tests/neg/i4986c.scala index 13b608a69707..41b473f3ed8f 100644 --- a/tests/neg/i4986c.scala +++ b/tests/neg/i4986c.scala @@ -14,7 +14,7 @@ class Outer[A] { } } -trait X$Y +trait `X$Y` @implicitNotFound(msg = "There's no U[${X}, ${Y}, ${Z}]") trait U[X, Y[_], Z[_, ZZ]] { diff --git a/tests/neg/i5525.scala b/tests/neg/i5525.scala index 8cdde2cab3df..3f0b96d25a62 100644 --- a/tests/neg/i5525.scala +++ b/tests/neg/i5525.scala @@ -1,5 +1,5 @@ -//> using options -preview -// preview needed for into in 3.8 +// placeholder for directives line +// abstract enum Foo1 { case C } // error: only access modifiers allowed final enum Foo2 { case C } // error: only access modifiers allowed diff --git a/tests/neg/i7137.scala b/tests/neg/i7137.scala index 5b7ec3a36e5d..5192a91d7cff 100644 --- a/tests/neg/i7137.scala +++ b/tests/neg/i7137.scala @@ -3,5 +3,5 @@ object App { val any: Any = 3 val str: String = any + "a" // error val str2: String = any2stringadd(any) + "a" // error - val str3: String = Predef.any2stringadd(any) + "a" + val str3: String = Predef.any2stringadd(any) + "a" // error } diff --git a/tests/neg/i9329.check b/tests/neg/i9329.check index e604a1b22888..18cf5712c2ae 100644 --- a/tests/neg/i9329.check +++ b/tests/neg/i9329.check @@ -1,4 +1,4 @@ --- Error: tests/neg/i9329.scala:8:6 ------------------------------------------------------------------------------------ +-- [E231] Declaration Error: tests/neg/i9329.scala:8:6 ----------------------------------------------------------------- 8 |class GrandSon extends Son // error | ^^^^^^^^ |class GrandSon needs to be abstract, since def name: String in trait Parent is not defined diff --git a/tests/neg/inline-def-into-inline-val.scala b/tests/neg/inline-def-into-inline-val.scala new file mode 100644 index 000000000000..50a5b921e2b6 --- /dev/null +++ b/tests/neg/inline-def-into-inline-val.scala @@ -0,0 +1,5 @@ +object O1: + inline def x = 10 + +object O2: + inline val y = O1.x // error: inline value must have a literal constant type diff --git a/tests/neg/inline-trait-body-class-case.scala b/tests/neg/inline-trait-body-class-case.scala new file mode 100644 index 000000000000..20a58fd4b267 --- /dev/null +++ b/tests/neg/inline-trait-body-class-case.scala @@ -0,0 +1,5 @@ +inline trait A: + case class Inner(val x: Int) // error + +class B extends A: + def f = Inner(17).x \ No newline at end of file diff --git a/tests/neg/inline-trait-body-class-extends-inline-trait.scala b/tests/neg/inline-trait-body-class-extends-inline-trait.scala new file mode 100644 index 000000000000..0e52135b3bd6 --- /dev/null +++ b/tests/neg/inline-trait-body-class-extends-inline-trait.scala @@ -0,0 +1,11 @@ +inline trait A: + class Inner extends Trait[Int]: // error: Inline traits may not define inner classes or traits. + val x = 1 + +inline trait Trait[T]: + def f(x: T): T = x + +class B extends A: + val inner = Inner() + def x = inner.x + def f = inner.f(x) \ No newline at end of file diff --git a/tests/neg/inline-trait-body-class-generic.scala b/tests/neg/inline-trait-body-class-generic.scala new file mode 100644 index 000000000000..bd0fc5f3de42 --- /dev/null +++ b/tests/neg/inline-trait-body-class-generic.scala @@ -0,0 +1,6 @@ +inline trait A[T]: + class Inner[U](u: U): // error + val x: (T, U) = (???, u) + def f: (T, String) = Inner("U").x + +class B extends A[Int] \ No newline at end of file diff --git a/tests/neg/inline-trait-body-class-params.scala b/tests/neg/inline-trait-body-class-params.scala new file mode 100644 index 000000000000..e60da2536a69 --- /dev/null +++ b/tests/neg/inline-trait-body-class-params.scala @@ -0,0 +1,5 @@ +inline trait A: + class Inner(val x: Int) // error + +class B extends A: + def f = Inner(17).x \ No newline at end of file diff --git a/tests/neg/inline-trait-body-class-return.scala b/tests/neg/inline-trait-body-class-return.scala new file mode 100644 index 000000000000..8e3bbd32e3d7 --- /dev/null +++ b/tests/neg/inline-trait-body-class-return.scala @@ -0,0 +1,7 @@ +inline trait A: + sealed class InnerA: // error: Inline traits may not define inner classes or traits. + val x = 1 + def generate(x: Int) = new InnerA() {} + +class B extends A: + val y = generate(7) diff --git a/tests/neg/inline-trait-body-class-sealed.scala b/tests/neg/inline-trait-body-class-sealed.scala new file mode 100644 index 000000000000..737e36fba960 --- /dev/null +++ b/tests/neg/inline-trait-body-class-sealed.scala @@ -0,0 +1,7 @@ +inline trait A: + sealed class InnerA: // error: Inline traits may not define inner classes or traits. + val x = 1 + +class B extends A: + class InnerB extends InnerA + def f = InnerB().x \ No newline at end of file diff --git a/tests/neg/inline-trait-body-class-simple.scala b/tests/neg/inline-trait-body-class-simple.scala new file mode 100644 index 000000000000..8c3ee234310a --- /dev/null +++ b/tests/neg/inline-trait-body-class-simple.scala @@ -0,0 +1,6 @@ +inline trait A: + class Inner: // error: Inline traits may not define inner classes or traits. + val x = 1 + +class B extends A: + def f = Inner().x \ No newline at end of file diff --git a/tests/neg/inline-trait-body-override-def-final.scala b/tests/neg/inline-trait-body-override-def-final.scala new file mode 100644 index 000000000000..c67540a09924 --- /dev/null +++ b/tests/neg/inline-trait-body-override-def-final.scala @@ -0,0 +1,5 @@ +inline trait A: + final def f(x: Int) = x + +class B extends A: + override final def f(x: Int) = x + 1 // error \ No newline at end of file diff --git a/tests/neg/inline-trait-body-override-val-final.scala b/tests/neg/inline-trait-body-override-val-final.scala new file mode 100644 index 000000000000..32d20c4b6696 --- /dev/null +++ b/tests/neg/inline-trait-body-override-val-final.scala @@ -0,0 +1,5 @@ +inline trait A: + final val x = 1 + +class B extends A: + override final val x = 2 // error \ No newline at end of file diff --git a/tests/neg/inline-trait-body-override-var.scala b/tests/neg/inline-trait-body-override-var.scala new file mode 100644 index 000000000000..4ad8b79db477 --- /dev/null +++ b/tests/neg/inline-trait-body-override-var.scala @@ -0,0 +1,5 @@ +inline trait A: + var x: Int = 1 + +class B extends A: + override var x = 2 // error diff --git a/tests/neg/inline-trait-body-private-name-collision.scala b/tests/neg/inline-trait-body-private-name-collision.scala new file mode 100644 index 000000000000..c0f6624fd707 --- /dev/null +++ b/tests/neg/inline-trait-body-private-name-collision.scala @@ -0,0 +1,3 @@ +inline trait A: + private val x: Int = 1 // error: inline traits cannot have non-local private members + def eq(o: A) = o.x == x diff --git a/tests/neg/inline-trait-body-trait-inline.scala b/tests/neg/inline-trait-body-trait-inline.scala new file mode 100644 index 000000000000..82144e4c9c4d --- /dev/null +++ b/tests/neg/inline-trait-body-trait-inline.scala @@ -0,0 +1,7 @@ +inline trait A[T]: + inline trait InnerA[U]: // error + val x: (T, U) = ??? + +class B extends A[Int]: + class InnerB extends InnerA[String] + def f: (Int, String) = InnerB().x \ No newline at end of file diff --git a/tests/neg/inline-trait-body-trait-parameter.scala b/tests/neg/inline-trait-body-trait-parameter.scala new file mode 100644 index 000000000000..ec11c5b9052e --- /dev/null +++ b/tests/neg/inline-trait-body-trait-parameter.scala @@ -0,0 +1,7 @@ +inline trait A[T]: + trait InnerAType[T >: Int <: AnyVal] + trait InnerATypes[T <: AnyVal, U <: T] + trait InnerATerm(i: Int) // error + trait InnerATerms(i: Int, j: Double) // error + trait InnerATermsCurried(i: Int, j: Double)(k: String) // error + trait InnerAAllCurried[T, U](i: T, j: U)(k: (T, U)) // error \ No newline at end of file diff --git a/tests/neg/inline-trait-body-trait-simple.scala b/tests/neg/inline-trait-body-trait-simple.scala new file mode 100644 index 000000000000..91b5bc380543 --- /dev/null +++ b/tests/neg/inline-trait-body-trait-simple.scala @@ -0,0 +1,6 @@ +inline trait A[T]: + trait InnerA: // error: Inline traits may not contain inner classes. + def x: T = ??? + +class B extends A[Int]: + class InnerB extends InnerA \ No newline at end of file diff --git a/tests/neg/inline-trait-body-trait-term-parameters.scala b/tests/neg/inline-trait-body-trait-term-parameters.scala new file mode 100644 index 000000000000..ef7c96baf6c4 --- /dev/null +++ b/tests/neg/inline-trait-body-trait-term-parameters.scala @@ -0,0 +1,7 @@ + +inline trait A[T]: + trait InnerA(t: T): // error + def x: T = t + +class B extends A[Int]: + class InnerB extends InnerA(???) \ No newline at end of file diff --git a/tests/neg/inline-trait-child-overrides-parent-missing-override.scala b/tests/neg/inline-trait-child-overrides-parent-missing-override.scala new file mode 100644 index 000000000000..18aabebbcde0 --- /dev/null +++ b/tests/neg/inline-trait-child-overrides-parent-missing-override.scala @@ -0,0 +1,5 @@ + +inline trait A(val x: Int) + +class C extends A(10): + val x = 1000 // error: Needs override modifier diff --git a/tests/neg/inline-trait-clash-method-method-needs-override.scala b/tests/neg/inline-trait-clash-method-method-needs-override.scala new file mode 100644 index 000000000000..61e94c7f5020 --- /dev/null +++ b/tests/neg/inline-trait-clash-method-method-needs-override.scala @@ -0,0 +1,9 @@ +inline trait A: + def x(y: String) = "Hello world" + +class C extends A: + def x(y: String) = "Hello world2" // error: Needs override + +@main def Test = + val v = C() + assert(v.x("Hello World") == "Hello world2") diff --git a/tests/neg/inline-trait-clash-method-param.scala b/tests/neg/inline-trait-clash-method-param.scala new file mode 100644 index 000000000000..2142bf3f4a6b --- /dev/null +++ b/tests/neg/inline-trait-clash-method-param.scala @@ -0,0 +1,11 @@ +inline trait A: + def x(b: Int) = "Hello world" + def z = "Hello world" + +class C(x: String, z: String) extends A: // error: Inlining of inline trait created name conflict on z. + val y = x + val w = z + +@main def Test = + val v = C("Overridden", "Overridden2") + assert(v.y == "Overridden") diff --git a/tests/neg/inline-trait-clash-method-val-param-needs-override.scala b/tests/neg/inline-trait-clash-method-val-param-needs-override.scala new file mode 100644 index 000000000000..82d7d0093972 --- /dev/null +++ b/tests/neg/inline-trait-clash-method-val-param-needs-override.scala @@ -0,0 +1,9 @@ +inline trait A: + def x = "Hello world" + +class C extends A: + val x = "Overridden" // error: Needs override + +@main def Test = + val v = C() + assert(v.x == "Overridden") diff --git a/tests/neg/inline-trait-clash-method-var-param-missing-override.scala b/tests/neg/inline-trait-clash-method-var-param-missing-override.scala new file mode 100644 index 000000000000..70077210d794 --- /dev/null +++ b/tests/neg/inline-trait-clash-method-var-param-missing-override.scala @@ -0,0 +1,9 @@ +inline trait A: + def x = "Hello world" + +class C extends A: + var x = "Overridden" // error: Needs override + +@main def Test = + val v = C() + assert(v.x == "Overridden") diff --git a/tests/neg/inline-trait-clash-method-var-param.scala b/tests/neg/inline-trait-clash-method-var-param.scala new file mode 100644 index 000000000000..18caa31af679 --- /dev/null +++ b/tests/neg/inline-trait-clash-method-var-param.scala @@ -0,0 +1,9 @@ +inline trait A: + def x = "Hello world" + +class C extends A: + override var x = "Overridden" // error: Setter x_= overrides nothing + +@main def Test = + val v = C() + assert(v.x == "Overridden") diff --git a/tests/neg/inline-trait-clash-val-param-method-2.scala b/tests/neg/inline-trait-clash-val-param-method-2.scala new file mode 100644 index 000000000000..a7a87b4d8bf7 --- /dev/null +++ b/tests/neg/inline-trait-clash-val-param-method-2.scala @@ -0,0 +1,4 @@ +inline trait A(val x: Int) + +class C extends A(10): + def x = 1000 // error: Needs override marker diff --git a/tests/neg/inline-trait-clash-val-param-method.scala b/tests/neg/inline-trait-clash-val-param-method.scala new file mode 100644 index 000000000000..697b82f28721 --- /dev/null +++ b/tests/neg/inline-trait-clash-val-param-method.scala @@ -0,0 +1,4 @@ +inline trait A(val x: Int) + +class D extends A(10): + override def x = 1000 // error: needs to be a stable, immutable value diff --git a/tests/neg/inline-trait-clash-val-param-param.scala b/tests/neg/inline-trait-clash-val-param-param.scala new file mode 100644 index 000000000000..b3225b0d93fd --- /dev/null +++ b/tests/neg/inline-trait-clash-val-param-param.scala @@ -0,0 +1,15 @@ +// Not allowed due to name clash + +inline trait A(val x: Int): + val y = x + +class C(x: Int) extends A(10): // error: Inlining of inline trait created name conflict on x. Constructor parameters of inline receivers may not collide with members of inline traits. + val z = x + +@main def Test = + val v = C(5) + assert(v.y == 10) + assert(v.x == 10) + assert(v.z == 5) + println(v.y) + println(v.x) diff --git a/tests/neg/inline-trait-clash-val-param-val-param-missing-override.scala b/tests/neg/inline-trait-clash-val-param-val-param-missing-override.scala new file mode 100644 index 000000000000..917e0dbb3d8d --- /dev/null +++ b/tests/neg/inline-trait-clash-val-param-val-param-missing-override.scala @@ -0,0 +1,4 @@ + +inline trait A(val x: Int, val y: Int) +class C(val y: Int) extends A(10, 54): // error: Needs override + val x = 1000 // error: Needs override diff --git a/tests/neg/inline-trait-clash-var-param-method-2.scala b/tests/neg/inline-trait-clash-var-param-method-2.scala new file mode 100644 index 000000000000..494e30d9dd52 --- /dev/null +++ b/tests/neg/inline-trait-clash-var-param-method-2.scala @@ -0,0 +1,4 @@ +inline trait A(var x: Int) + +class D extends A(10): + override def x = 1000 // error: cannot override a mutable value diff --git a/tests/neg/inline-trait-clash-var-param-method.scala b/tests/neg/inline-trait-clash-var-param-method.scala new file mode 100644 index 000000000000..8b90379516b4 --- /dev/null +++ b/tests/neg/inline-trait-clash-var-param-method.scala @@ -0,0 +1,4 @@ +inline trait A(var x: Int) + +class C extends A(10): + def x = 1000 // error: Needs override marker diff --git a/tests/neg/inline-trait-clash-var-param-param.scala b/tests/neg/inline-trait-clash-var-param-param.scala new file mode 100644 index 000000000000..3147ebfeb368 --- /dev/null +++ b/tests/neg/inline-trait-clash-var-param-param.scala @@ -0,0 +1,15 @@ +// Not allowed due to name clash + +inline trait A(var x: Int): + val y = x + +class C(x: Int) extends A(10): // error: Inlining of inline trait created name conflict on x. Constructor parameters of inline receivers may not collide with members of inline traits. + val z = x + +@main def Test = + val v = C(5) + assert(v.y == 10) + assert(v.x == 10) + assert(v.z == 5) + println(v.y) + println(v.x) diff --git a/tests/neg/inline-trait-clash-var-param-var-param.scala b/tests/neg/inline-trait-clash-var-param-var-param.scala new file mode 100644 index 000000000000..64173b7321a6 --- /dev/null +++ b/tests/neg/inline-trait-clash-var-param-var-param.scala @@ -0,0 +1,8 @@ +inline trait A(val x: Int, var y: Int) +class C(override var y: Int) extends A(10, 54): // error: Cannot override a mutable variable + override val x = 1000 + +@main def Test = + val v = C(44) + assert(v.x == 1000) + assert(v.y == 44) diff --git a/tests/neg/inline-trait-clashing-parent-members.scala b/tests/neg/inline-trait-clashing-parent-members.scala new file mode 100644 index 000000000000..e217baf4c70a --- /dev/null +++ b/tests/neg/inline-trait-clashing-parent-members.scala @@ -0,0 +1,11 @@ +inline trait A: + val x = 10 + +inline trait B: + val x = 11 + +class C extends A, B // error: C inherits conflicting members x from A and B + +@main def Test = + val v = C() + assert(v.x == 11) diff --git a/tests/neg/inline-trait-clashing-parent-methods.scala b/tests/neg/inline-trait-clashing-parent-methods.scala new file mode 100644 index 000000000000..002014e88417 --- /dev/null +++ b/tests/neg/inline-trait-clashing-parent-methods.scala @@ -0,0 +1,7 @@ +inline trait A: + def foo = "Hello World" + +inline trait B: + def foo = "Bonjour" + +class C extends A, B // error: C inherits conflicting members diff --git a/tests/neg/inline-trait-clashing-parent-val-params.scala b/tests/neg/inline-trait-clashing-parent-val-params.scala new file mode 100644 index 000000000000..e803c42d9312 --- /dev/null +++ b/tests/neg/inline-trait-clashing-parent-val-params.scala @@ -0,0 +1,9 @@ +inline trait A(val x: Int) + +inline trait B(val x: Int) + +class C extends A(10), B(11) // error: C inherits conflicting members + +@main def Test = + val v = C() + assert(v.x == 11) diff --git a/tests/neg/inline-trait-co-nested.scala b/tests/neg/inline-trait-co-nested.scala new file mode 100644 index 000000000000..fb600bcdd3a0 --- /dev/null +++ b/tests/neg/inline-trait-co-nested.scala @@ -0,0 +1,9 @@ +inline trait A: // At the moment this works with an ordinary trait but throws a TypeError with inline traits + sealed class InnerA: // error: Inline traits may not define inner classes or traits. + val x = new InnerB + + sealed class InnerB: // error: Inline traits may not define inner classes or traits. + val x = new InnerA + +class B extends A: + val y = 10 diff --git a/tests/neg/inline-trait-cross-reference-defined-after.scala b/tests/neg/inline-trait-cross-reference-defined-after.scala new file mode 100644 index 000000000000..eb3fb51f4450 --- /dev/null +++ b/tests/neg/inline-trait-cross-reference-defined-after.scala @@ -0,0 +1,9 @@ +inline trait A: // At the moment this works with an ordinary trait but throws a TypeError with inline traits + sealed class InnerA: // error: Inline traits may not define inner classes or traits. + val x = new InnerB + + sealed class InnerB: // error: Inline traits may not define inner classes or traits. + val x = 10 + +class B extends A: + val y = 10 diff --git a/tests/neg/inline-trait-double-nested-class.scala b/tests/neg/inline-trait-double-nested-class.scala new file mode 100644 index 000000000000..c8352791bfb6 --- /dev/null +++ b/tests/neg/inline-trait-double-nested-class.scala @@ -0,0 +1,13 @@ +inline trait A: + sealed class InnerA: // error: Inline traits may not define inner classes or traits. + sealed class InnerInnerA: + val x = 1 + +class B extends A: + class InnerB extends InnerA { + class InnerInnerB extends InnerInnerA + } + def f = + val a = new InnerB() + val b = a.InnerInnerB() + b.x diff --git a/tests/neg/inline-trait-infinite-inline-triangle-cycle.scala b/tests/neg/inline-trait-infinite-inline-triangle-cycle.scala new file mode 100644 index 000000000000..2f506c96871f --- /dev/null +++ b/tests/neg/inline-trait-infinite-inline-triangle-cycle.scala @@ -0,0 +1,9 @@ +inline trait C[S]: + def v(x: S): S = x + def w: Unit = + val x = new D[S] {} + println("w") + +inline trait D[S] extends C[S] + +class Cl[T] extends D[T] // error: Inlining of inline traits looped, which will create an infinitely long program. This is not allowed. diff --git a/tests/neg/inline-trait-inline-overrides-non-inline-retained-inline.scala b/tests/neg/inline-trait-inline-overrides-non-inline-retained-inline.scala new file mode 100644 index 000000000000..3d400831c81b --- /dev/null +++ b/tests/neg/inline-trait-inline-overrides-non-inline-retained-inline.scala @@ -0,0 +1,9 @@ +inline trait A: + def x: Int + +inline trait B extends A: + override inline def x = 10 // error: implementation restriction: inline traits cannot have non-local private members. This also means no retained inline methods. + +@main def Test = + val x: A = new B() {} + assert(x.x == 10) diff --git a/tests/neg/inline-trait-inline-val-constant-value.scala b/tests/neg/inline-trait-inline-val-constant-value.scala new file mode 100644 index 000000000000..7984686e9d98 --- /dev/null +++ b/tests/neg/inline-trait-inline-val-constant-value.scala @@ -0,0 +1,2 @@ +inline trait A[T](x: T): + inline val property = x // error: inline value must have a literal constant type diff --git a/tests/neg/inline-trait-nested-class-outside-ref.scala b/tests/neg/inline-trait-nested-class-outside-ref.scala new file mode 100644 index 000000000000..6a432cec3ecf --- /dev/null +++ b/tests/neg/inline-trait-nested-class-outside-ref.scala @@ -0,0 +1,11 @@ +inline trait A: + class InnerA: // error: Inline traits may not define inner classes or traits. + val x = 10 + +class B extends A: + def foo = 10 + +def x = + val b = B() + val c = b.InnerA() + c diff --git a/tests/neg/inline-trait-nested-class-parameter-passing.scala b/tests/neg/inline-trait-nested-class-parameter-passing.scala new file mode 100644 index 000000000000..651e306e1089 --- /dev/null +++ b/tests/neg/inline-trait-nested-class-parameter-passing.scala @@ -0,0 +1,18 @@ +inline trait A: + sealed class InnerA: // error: Inline traits may not define inner classes or traits. + val x = 1 + +class B extends A: + class InnerB extends InnerA: + override val x = 2 + +def foo(x: A#InnerA) = println(x.x) + +@main def main = + val a = new A() {} + val inner_a = a.InnerA() + foo(inner_a) + + val b = B() + val inner_b = b.InnerB() + foo(inner_b) diff --git a/tests/neg/inline-trait-opaque-type-fail.scala b/tests/neg/inline-trait-opaque-type-fail.scala new file mode 100644 index 000000000000..126404829191 --- /dev/null +++ b/tests/neg/inline-trait-opaque-type-fail.scala @@ -0,0 +1,14 @@ +inline trait A[T](val x: T): + opaque type Special = T + type Ordinary = T + opaque type Special2 = Int + + def foo1: Special = 10 // error: 10 does not conform to T + def bar1: Ordinary = 10 // error: 10 does not conform to T + def baz1: Special2 = 10 // This one is fine + +class B extends A[Int](100): + def foo2: Special = 10 // error: 10 does not conform to Special (same behaviour as ordinary traits) + def bar2: Ordinary = 10 // This one is fine + def baz2: Special2 = 10 // error: 10 does not conform to Special (same behaviour as ordinary traits) + \ No newline at end of file diff --git a/tests/neg/inline-trait-override-private-member-deleted.scala b/tests/neg/inline-trait-override-private-member-deleted.scala new file mode 100644 index 000000000000..6ef7c6c0ee8d --- /dev/null +++ b/tests/neg/inline-trait-override-private-member-deleted.scala @@ -0,0 +1,5 @@ +inline trait Foo: + private def foo = 10 + +class A extends Foo: + override def foo = 11 // error: method foo overrides nothing diff --git a/tests/neg/inline-trait-parent-trait-param-access.scala b/tests/neg/inline-trait-parent-trait-param-access.scala new file mode 100644 index 000000000000..e283a5f90bd1 --- /dev/null +++ b/tests/neg/inline-trait-parent-trait-param-access.scala @@ -0,0 +1,4 @@ +inline trait A(x: Int) + +class C extends A(10): + val y = x // error: Not Found Error diff --git a/tests/neg/inline-trait-self-inline-anonymous-class.scala b/tests/neg/inline-trait-self-inline-anonymous-class.scala new file mode 100644 index 000000000000..b916ac476992 --- /dev/null +++ b/tests/neg/inline-trait-self-inline-anonymous-class.scala @@ -0,0 +1,7 @@ +inline trait C[S]: + def v(x: S): S = x + def w: Unit = + val x = new C[S] {} + println("w") + +class T extends C[Int] // error: Inlining of inline traits looped. diff --git a/tests/neg/inline-trait-self-inline-three-cycle.scala b/tests/neg/inline-trait-self-inline-three-cycle.scala new file mode 100644 index 000000000000..4f54945e81ec --- /dev/null +++ b/tests/neg/inline-trait-self-inline-three-cycle.scala @@ -0,0 +1,20 @@ +inline trait C[S]: + def v(x: S): S = x + def w: Unit = + val x = new D[S] {} + println("w") + +inline trait D[S]: + def v(x: S): S = x + def w: Unit = + val x = new E[S] {} + println("w") + +inline trait E[S]: + def v(x: S): S = x + def w: Unit = + val x = new C[S] {} + println("w") + +def main = + val x = new C[Int] {} // error: Inlining of inline traits looped. diff --git a/tests/neg/inline-trait-self-inline-two-cycle.scala b/tests/neg/inline-trait-self-inline-two-cycle.scala new file mode 100644 index 000000000000..98da6c2455a1 --- /dev/null +++ b/tests/neg/inline-trait-self-inline-two-cycle.scala @@ -0,0 +1,14 @@ +inline trait C[S]: + def v(x: S): S = x + def w: Unit = + val x = new D[S] {} + println("w") + +inline trait D[S]: + def v(x: S): S = x + def w: Unit = + val x = new C[S] {} + println("w") + +def main = + val x = new C[Int] {} // error: Inlining of inline traits looped. diff --git a/tests/neg/inline-trait-self-specialization-loop.scala b/tests/neg/inline-trait-self-specialization-loop.scala new file mode 100644 index 000000000000..6c986eb241dc --- /dev/null +++ b/tests/neg/inline-trait-self-specialization-loop.scala @@ -0,0 +1,10 @@ +//> using options -language:experimental.specializedTraits + +inline trait C[S]: + def v(x: S): S = x + def w: Unit = + val x = new C[Int] {} + println("w") + +def main = + val y = new C[Int] {} // error: Inlining of inline traits loops which would create an infinitely long program. This is not allowed. diff --git a/tests/neg/inline-trait-self-type-missing-parent.scala b/tests/neg/inline-trait-self-type-missing-parent.scala new file mode 100644 index 000000000000..33b781ac026b --- /dev/null +++ b/tests/neg/inline-trait-self-type-missing-parent.scala @@ -0,0 +1,6 @@ +trait T1 +inline trait A[T]: + this: T1 => + +class B extends A[Int] // error: illegal inheritance: class B does not conform to self type +class C extends A, T1 diff --git a/tests/neg/inline-trait-self-type-problems.scala b/tests/neg/inline-trait-self-type-problems.scala new file mode 100644 index 000000000000..317620f27fbd --- /dev/null +++ b/tests/neg/inline-trait-self-type-problems.scala @@ -0,0 +1,23 @@ +trait T1 +trait T2 +trait T3 +class Test + +inline trait A[T]: + this: T1 => + +inline trait D extends A[Int] // error: self type of D does not conform to that of A +inline trait E extends D + +inline trait B[T]: + this: T2 & T1 => + +inline trait F extends A[Int], B[Int] // error: self type of F does not conform to that of A + +inline trait C[T]: + this: T => + +inline trait H extends C[Test]: // error self type of H does not conform to that of C + this: T3 => + +class Cl2 extends Test with H with T3 diff --git a/tests/neg/inline-trait-supercall-into-trait.scala b/tests/neg/inline-trait-supercall-into-trait.scala new file mode 100644 index 000000000000..1c71df5cc554 --- /dev/null +++ b/tests/neg/inline-trait-supercall-into-trait.scala @@ -0,0 +1,7 @@ +trait A: + def foo = "A" + +inline trait B extends A: + override def foo = super.foo // error: Inline traits may not contain superclass references to classes or non-inline traits + +class C1 extends B diff --git a/tests/neg/inline-trait-uninitialized-value-should-warn.scala b/tests/neg/inline-trait-uninitialized-value-should-warn.scala new file mode 100644 index 000000000000..2a605f38a71f --- /dev/null +++ b/tests/neg/inline-trait-uninitialized-value-should-warn.scala @@ -0,0 +1,7 @@ +//> using options -Werror -Wsafe-init + +inline trait A(val x: Int): + val f = z + val z: Int // nopos-error: This should warn with -Wsafe-init +class C extends A(10): + val z = 10 diff --git a/tests/neg/into-inferred.scala b/tests/neg/into-inferred.scala index 1ced0bd3ef3a..2990fbcc27b2 100644 --- a/tests/neg/into-inferred.scala +++ b/tests/neg/into-inferred.scala @@ -1,4 +1,4 @@ -//> using options -feature -preview +//> using options -feature import Conversion.{into, underlying} trait Token @@ -32,5 +32,3 @@ object Test: val l = List(ifKW) val l1: List[into[Keyword]] = l :+ "then" :+ "else" // error val l2: List[into[Keyword]] = l ++ List("then", "else") // warn // warn - - diff --git a/tests/neg/into-mods.scala b/tests/neg/into-mods.scala index ed6200d2f65c..b6f69c4801e1 100644 --- a/tests/neg/into-mods.scala +++ b/tests/neg/into-mods.scala @@ -1,5 +1,5 @@ -//> using options -preview -// preview needed for into in 3.8 +// placeholder for directives line +// into class Test @@ -12,4 +12,3 @@ object Test: into val x = 33 // error into type T = Int // error into opaque type U = Int // ok - diff --git a/tests/neg/into-override.scala b/tests/neg/into-override.scala index f5f6db4da169..53593a71e13a 100644 --- a/tests/neg/into-override.scala +++ b/tests/neg/into-override.scala @@ -1,4 +1,4 @@ -//> using options -Werror -preview +//> using options -Werror import Conversion.into @@ -19,5 +19,3 @@ class D[X] extends B[X], C[X] // error trait E[X] extends C[X]: // error override def f(x: X) = super.f(x) - - diff --git a/tests/neg/invalid-opaque.check b/tests/neg/invalid-opaque.check new file mode 100644 index 000000000000..b81dc83c7027 --- /dev/null +++ b/tests/neg/invalid-opaque.check @@ -0,0 +1,6 @@ +-- [E095] Syntax Error: tests/neg/invalid-opaque.scala:2:23 ------------------------------------------------------------ +2 | opaque type TestCases: Int // error: used to crash the compiler + | ^ + | =, >:, or <: expected, but ':' found + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg/invalid-opaque.scala b/tests/neg/invalid-opaque.scala new file mode 100644 index 000000000000..5e1e544e0fb2 --- /dev/null +++ b/tests/neg/invalid-opaque.scala @@ -0,0 +1,2 @@ +package somepackage: + opaque type TestCases: Int // error: used to crash the compiler diff --git a/tests/neg/specialized-trait-anonymous-class-breaks-rules.scala b/tests/neg/specialized-trait-anonymous-class-breaks-rules.scala new file mode 100644 index 000000000000..0ef65ba4c3dd --- /dev/null +++ b/tests/neg/specialized-trait-anonymous-class-breaks-rules.scala @@ -0,0 +1,27 @@ +//> using options -language:experimental.specializedTraits + +inline trait Baz[T: Specialized]: + def foo = "hello world" + +inline trait Foo[T: Specialized] extends Baz[T]: + val bar = 10 + +inline trait Bar[T: Specialized]: + val baz = 100 + +trait MyTrait[T](val x: T) + +@main def main = + val w = new Foo[Int] {} // ok + + val x = new Foo[Int] { // error: Anonymous classes acting as instances of Specialized traits may not have additional members; you can make a named object instead if you like. + val y = 10 + } + + val y = new Foo[Int] with MyTrait(10) with Bar {} // error: Anonymous classes acting as instances of Specialized traits may not mix in other traits; you can make a named object instead if you like. + + val z = new Foo[Int] with Bar {} // error: Anonymous classes acting as instances of Specialized traits may not mix in other traits; you can make a named object instead if you like. + + val a = new Foo[Int] with Baz[Int] {} // ok: We have to allow this because it desugars to the same thing as the new Foo[Int] {} case; it will have the same behaviour when compiled; + + val b = new Baz[Int] with Foo[Int] {} // ok: We have to allow this because it desugars to the same thing as the new Foo[Int] {} case; it will have the same behaviour when compiled; diff --git a/tests/neg/specialized-trait-banned-covariance.scala b/tests/neg/specialized-trait-banned-covariance.scala new file mode 100644 index 000000000000..4afee41a7617 --- /dev/null +++ b/tests/neg/specialized-trait-banned-covariance.scala @@ -0,0 +1,9 @@ +//> using options -language:experimental.specializedTraits + +inline trait List[+T: Specialized] +case object Nil extends List[Nothing] + +def foo(x: List[Int]) = println("Foo") + +def main = + foo(Nil) // error: This use of variance is incompatible with specialized traits. diff --git a/tests/neg/specialized-trait-drops-specialized-qualifier.scala b/tests/neg/specialized-trait-drops-specialized-qualifier.scala new file mode 100644 index 000000000000..e3ae8727cc90 --- /dev/null +++ b/tests/neg/specialized-trait-drops-specialized-qualifier.scala @@ -0,0 +1,7 @@ +//> using options -language:experimental.specializedTraits +inline trait T1[T: Specialized] +inline trait T2[S] extends T1[S] // error: type S used in a Specialized position, so it must be marked as Specialized at its definition. + +inline def foo[E](x: T1[E]) = 100 // error: type E used in a Specialized position, so it must be marked as Specialized at its definition. + +inline def foo[F] = new T1[F]() {} // error: type F used in a Specialized position, so it must be marked as Specialized at its definition. diff --git a/tests/neg/specialized-trait-exhaustivity-check-2.scala b/tests/neg/specialized-trait-exhaustivity-check-2.scala new file mode 100644 index 000000000000..e77c49d546eb --- /dev/null +++ b/tests/neg/specialized-trait-exhaustivity-check-2.scala @@ -0,0 +1,13 @@ +//> using options -language:experimental.specializedTraits -Werror + +// nopos-error: (warning) non-exhaustive pattern match + +sealed inline trait Foo[S: Specialized] +sealed inline trait Baz[S: Specialized] extends Foo[S] +inline trait Bar extends Foo[Int] + +def doMatch(x: Foo[Int]) = x match { + case x: Baz[_] => println("Hello World") +} + + diff --git a/tests/neg/specialized-trait-exhaustivity-check.scala b/tests/neg/specialized-trait-exhaustivity-check.scala new file mode 100644 index 000000000000..0d6d3c8b9889 --- /dev/null +++ b/tests/neg/specialized-trait-exhaustivity-check.scala @@ -0,0 +1,16 @@ +//> using options -language:experimental.specializedTraits -Werror + +// nopos-error: (warning) non-exhaustive pattern match + +sealed inline trait Foo[S: Specialized] +inline trait Bar extends Foo[Int] + +def doMatch(x: Foo[Int]) = x match { + case x: Bar => println("Hello World") +} + +def main = + val x = new Foo[Int]() {} + doMatch(x) + + diff --git a/tests/neg/specialized-trait-infinite-inline.scala b/tests/neg/specialized-trait-infinite-inline.scala new file mode 100644 index 000000000000..37a8d0c09db8 --- /dev/null +++ b/tests/neg/specialized-trait-infinite-inline.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits + +inline trait Foo[T: Specialized]: + inline def a[S: Specialized](b: S): Boolean = a[S](b) + +@main def main = + val x = new Foo[Int]() {} + x.a(100) // error: inline limit exceeded diff --git a/tests/neg/specialized-trait-inline-method-missing-specialized.scala b/tests/neg/specialized-trait-inline-method-missing-specialized.scala new file mode 100644 index 000000000000..0b3f9fffb882 --- /dev/null +++ b/tests/neg/specialized-trait-inline-method-missing-specialized.scala @@ -0,0 +1,2 @@ +inline trait Vec[T: Specialized](val xs: List[T]): + def method[S: Specialized](other: Vec[S]): Vec[(T, S)] // error: Only inline traits and inline functions may take specialized type parameters diff --git a/tests/neg/specialized-trait-inlining-causes-implementation-required-loop-bad-manual.scala b/tests/neg/specialized-trait-inlining-causes-implementation-required-loop-bad-manual.scala new file mode 100644 index 000000000000..5201e6a602e3 --- /dev/null +++ b/tests/neg/specialized-trait-inlining-causes-implementation-required-loop-bad-manual.scala @@ -0,0 +1,23 @@ +//> using options -language:experimental.specializedTraits + +// Contrast with specialized-trait-inlining-causes-implementation-required-loop-bad.scala. +// and specialized-trait-inlining-causes-implementation-required-loop-without-implementation-fine.scala +// This one is not allowed because it will loop forever when specializing. The $impl$ class will +// get a loop when the body of w is inlined. + +// A[Char] => A$sp$Char, but only once we inline the body of A$sp$Char do we realise that we need +// C$impl$Char as well. + +inline trait C[S: Specialized]: + def v(x: S): S = x + def w: Unit = + class D extends C[S] + println("w") + +inline trait A[T: Specialized]: + def x(y: C[T]): Unit = + val x = new C[T]() {} // error: Inlining of inline traits looped + println("x") + +def main = + val y = new A[Char] {} diff --git a/tests/neg/specialized-trait-nested-specialized.scala b/tests/neg/specialized-trait-nested-specialized.scala new file mode 100644 index 000000000000..54d2753a9bcb --- /dev/null +++ b/tests/neg/specialized-trait-nested-specialized.scala @@ -0,0 +1,24 @@ +//> using options -language:experimental.specializedTraits +inline trait T1[T: Specialized] + +inline trait T2 extends T1[List[Int]] // ok +inline trait T3[S] extends T1[List[S]] // error: S should be specialized +inline trait T4[S] extends T1[List[List[S]]] // error: S should be specialized +inline trait T5[S: Specialized] extends T1[List[S]] // ok; should only specialize later +inline trait T6[T[_], S] extends T1[T[S]] // error: T should be specialized // error: S should be specialized +inline trait T7[T[_]] extends T1[T[Int]] // error: T should be specialized + +inline def foo1[S](x: T1[List[S]]): Int = 10 // error: S should be specialized +inline def foo2(x: T1[List[Int]]): Int = 10 // ok +inline def foo3[S](x: T1[List[List[S]]]): Int = 10 // error: S should be specialized +inline def foo4[S: Specialized](x: T1[List[List[S]]]): Int = 10 // ok + +inline def bar1[S] = new T1[List[S]]() {} // error: S should be specialized +inline def bar2 = new T1[List[Int]]() {} // ok +inline def bar3[S] = new T1[List[List[S]]]() {} // error: S should be specialized +inline def bar4[S: Specialized] = new T1[List[List[S]]]() {} // ok + +inline def baz1[T] = new T1[T1[T]]() {} // error: T should be Specialized +inline def baz2[T](x: T1[T1[T]]) = 1 // error: T should be Specialized +inline def baz3[T: Specialized] = new T1[T1[T]]() {} // ok +inline def baz4[T: Specialized](x: T1[T1[T]]) = 1 // ok diff --git a/tests/neg/specialized-trait-no-path-dependent.scala b/tests/neg/specialized-trait-no-path-dependent.scala new file mode 100644 index 000000000000..04c2f4f14d87 --- /dev/null +++ b/tests/neg/specialized-trait-no-path-dependent.scala @@ -0,0 +1,4 @@ +//> using options -language:experimental.specializedTraits +trait T1: + inline trait Foo[T: Specialized]: // error: May not define specialized traits inside traits or classes so as to make them path-dependent + def bar = "Bar" diff --git a/tests/neg/specialized-trait-no-regression-overrides-nothing.scala b/tests/neg/specialized-trait-no-regression-overrides-nothing.scala new file mode 100644 index 000000000000..3028d1fee92e --- /dev/null +++ b/tests/neg/specialized-trait-no-regression-overrides-nothing.scala @@ -0,0 +1,11 @@ +trait A1: + def foo = "A" + +trait B1: + override def foo = "B" // error: foo overrides nothing + +inline trait A2: + def foo = "A" + +inline trait B2: + override def foo = "B" // error: foo overrides nothing diff --git a/tests/neg/specialized-trait-not-inline.scala b/tests/neg/specialized-trait-not-inline.scala new file mode 100644 index 000000000000..a9c710115752 --- /dev/null +++ b/tests/neg/specialized-trait-not-inline.scala @@ -0,0 +1,3 @@ +//> using options -language:experimental.specializedTraits +trait Trait[T: Specialized] // error: Only inline traits and inline functions may take Specialized type parameters +def t[T: Specialized](a: T) = "Output" // error: Only inline traits and inline functions may take Specialized type parameters diff --git a/tests/neg/specialized-trait-opaque-type-fail.scala b/tests/neg/specialized-trait-opaque-type-fail.scala new file mode 100644 index 000000000000..68a4e67530a4 --- /dev/null +++ b/tests/neg/specialized-trait-opaque-type-fail.scala @@ -0,0 +1,16 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T: Specialized](val x: T): + opaque type Special = T + type Ordinary = T + opaque type Special2 = Int + + def foo1: Special = 10 // error: 10 does not conform to T + def bar1: Ordinary = 10 // error: 10 does not conform to T + def baz1: Special2 = 10 // This one is fine + +class B extends A[Int](100): + def foo2: Special = 10 // error: 10 does not conform to Special (same behaviour as ordinary traits) + def bar2: Ordinary = 10 // This one is fine + def baz2: Special2 = 10 // error: 10 does not conform to Special (same behaviour as ordinary traits) + \ No newline at end of file diff --git a/tests/neg/specialized-trait-overload.scala b/tests/neg/specialized-trait-overload.scala new file mode 100644 index 000000000000..32e973b5c6a9 --- /dev/null +++ b/tests/neg/specialized-trait-overload.scala @@ -0,0 +1,18 @@ +//> using options -language:experimental.specializedTraits + +// In principle we might be able to allow this because after erasure we will have different +// classes. The problem is we don't know the classes at the beginning of compilation +// so until erasure these overloads will be the same. It depends on to what extent the +// pre-erasure phases rely on "pre-computing" post-erasure signatures. For now we block +// it as it's not a requirement for specialized traits to work. + +inline trait Foo[T: Specialized]: + def foo(x: Foo[T]): Foo[T] + +class Bar: + def method1(x: Foo[Int]) = 10 + def method1(x: Foo[String]) = 10 // error: Conflicting definitions + +@main def Test = + val x = Bar() + diff --git a/tests/neg/specialized-trait-question-mark-in-inheritance.scala b/tests/neg/specialized-trait-question-mark-in-inheritance.scala new file mode 100644 index 000000000000..a72f21e5c7c9 --- /dev/null +++ b/tests/neg/specialized-trait-question-mark-in-inheritance.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits +inline trait T1[T: Specialized] +inline trait T2[T: Specialized] extends T1[?] // error: Wildcard types may not be substituted for Specialized type parameters. + +inline trait T3[T: Specialized, E, F: Numeric] +inline trait T4 extends T3[?, ?, ?] // error: Wildcard types may not be substituted for Specialized type parameters. diff --git a/tests/neg/specialized-trait-question-mark-interface.scala b/tests/neg/specialized-trait-question-mark-interface.scala new file mode 100644 index 000000000000..4df161f111e7 --- /dev/null +++ b/tests/neg/specialized-trait-question-mark-interface.scala @@ -0,0 +1,17 @@ +//> using options -language:experimental.specializedTraits +inline trait Trait[S: Specialized] + +def foo(x: Trait[?], y: Trait[? <: Long]) = // error: Wildcard types may not be substituted for Specialized type parameters. // error: Wildcard types may not be substituted for Specialized type parameters. + println("HELLO WORLD") + +def bar(x: Trait[_]) = // error: Wildcard types may not be substituted for Specialized type parameters. + println("HELLO WORLD") + +def baz(x: Trait[? >: Long]) = // error: Wildcard types may not be substituted for Specialized type parameters. + println("HELLO WORLD") + +def foo2(x: Trait[? >: Long <: Long]) = // error: Wildcard types may not be substituted for Specialized type parameters. + println("HELLO WORLD") + +def main = + foo(new Trait[Int]() {}, new Trait[Long]() {}) diff --git a/tests/neg/specialized-trait-question-mark.scala b/tests/neg/specialized-trait-question-mark.scala new file mode 100644 index 000000000000..67d2594249b9 --- /dev/null +++ b/tests/neg/specialized-trait-question-mark.scala @@ -0,0 +1,5 @@ +//> using options -language:experimental.specializedTraits +inline trait Trait[S: Specialized] + +def main = + val x = new Trait[?] {} // error: Type argument must be fully defined diff --git a/tests/neg/specialized-trait-scoped-inside-object-deep-nesting.scala b/tests/neg/specialized-trait-scoped-inside-object-deep-nesting.scala new file mode 100644 index 000000000000..b3dff60d4e4d --- /dev/null +++ b/tests/neg/specialized-trait-scoped-inside-object-deep-nesting.scala @@ -0,0 +1,18 @@ +//> using options -language:experimental.specializedTraits + +package p1: + package p2: + object O1: + class C1: + trait T1: + object O2: + inline trait Foo[T: Specialized]: // error: May not define specialized traits inside traits or classes so as to make them path-dependent + def bar = "Bar" + + class F extends Foo + + val v = O1.C1() + val w = new v.T1 {} + def foo = new w.O2.Foo[Int] {} + +@main def Test = p1.p2.foo.bar diff --git a/tests/neg/specialized-trait-sealed-cross-file/A_1.scala b/tests/neg/specialized-trait-sealed-cross-file/A_1.scala new file mode 100644 index 000000000000..567107fb9c42 --- /dev/null +++ b/tests/neg/specialized-trait-sealed-cross-file/A_1.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits + +sealed inline trait Foo[T: Specialized] +inline trait Bar[T: Specialized] extends Foo[T] + +def foo(x: Foo[Int]) = x match { + case y: Bar[Int] => println("ok boomer") +} diff --git a/tests/neg/specialized-trait-sealed-cross-file/B_2.scala b/tests/neg/specialized-trait-sealed-cross-file/B_2.scala new file mode 100644 index 000000000000..bfde7e71d826 --- /dev/null +++ b/tests/neg/specialized-trait-sealed-cross-file/B_2.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits + +object x extends Bar[Int] // Fine because it extends Bar which is not sealed + +def foo(x: Foo[Int]) = println("hello world") // Generates $sp$ trait but actually fine + +@main def main = ??? + val z = new Foo[Int]() {} // error: Extending sealed trait diff --git a/tests/neg/specialized-trait-self-type-problems.scala b/tests/neg/specialized-trait-self-type-problems.scala new file mode 100644 index 000000000000..60aa4708005f --- /dev/null +++ b/tests/neg/specialized-trait-self-type-problems.scala @@ -0,0 +1,25 @@ +//> using options -language:experimental.specializedTraits + +trait T1 +trait T2 +trait T3 +class Test + +inline trait A[T: Specialized]: + this: T1 => + +inline trait D extends A[Int] // error: self type of D does not conform to that of A +inline trait E extends D + +inline trait B[T: Specialized]: + this: T2 & T1 => + +inline trait F extends A[Int], B[Int] // error: self type of F does not conform to that of A + +inline trait C[T: Specialized]: + this: T => + +inline trait H extends C[Test]: // error self type of H does not conform to that of C + this: T3 => + +class Cl2 extends Test with H with T3 diff --git a/tests/neg/specialized-trait-specialized-incorrect-usage.scala b/tests/neg/specialized-trait-specialized-incorrect-usage.scala new file mode 100644 index 000000000000..629b8379a96f --- /dev/null +++ b/tests/neg/specialized-trait-specialized-incorrect-usage.scala @@ -0,0 +1,9 @@ +//> using options -language:experimental.specializedTraits +trait Illegal: + def x: Int = + new Specialized[Int] {} // error: Cannot extend sealed trait Specialized in a different source file + 10 + + class Baz extends Specialized[Int] // error: Cannot extend sealed trait Specialized in a different source file + + trait A[T] extends Specialized[T] // error: Cannot extend sealed trait Specialized in a different source file diff --git a/tests/neg/specialized-trait-specialized-incorrect-usage2.scala b/tests/neg/specialized-trait-specialized-incorrect-usage2.scala new file mode 100644 index 000000000000..7bcecede6038 --- /dev/null +++ b/tests/neg/specialized-trait-specialized-incorrect-usage2.scala @@ -0,0 +1,24 @@ +//> using options -language:experimental.specializedTraits +trait Illegal: + def foo: Specialized[Int] // error: Specialized may only be used as a context bound + + def bar(x: Specialized[Int]): Int // error: Specialized may only be used as a context bound + + class Foo(x: Specialized[Int]) // error: Specialized may only be used as a context bound + + class Bar(val x: Specialized[Int]) // error: Specialized may only be used as a context bound + + val y: Specialized[Char] // error: Specialized may only be used as a context bound + + val v = Specialized.apply[Int] // error: Specialized may only be used as a context bound + + def z = + println(Specialized.apply[Float]) // error: Specialized may only be used as a context bound + + def a = Specialized.apply // error: Specialized may only be used as a context bound + + type V = Specialized // error: Specialized may only be used as a context bound + + type W = Specialized[Int] // error: Specialized may only be used as a context bound + + val b = Specialized // error: Specialized may only be used as a context bound diff --git a/tests/neg/specialized-trait-specialized-incorrect-usage3.scala b/tests/neg/specialized-trait-specialized-incorrect-usage3.scala new file mode 100644 index 000000000000..011390a3fb70 --- /dev/null +++ b/tests/neg/specialized-trait-specialized-incorrect-usage3.scala @@ -0,0 +1,3 @@ +//> using options -language:experimental.specializedTraits +trait Illegal: + def x(v: Specialized) = 10 // error: Missing type parameter for Specialized diff --git a/tests/neg/specialized-trait-trait-extends-specialized-trait-no-param.scala b/tests/neg/specialized-trait-trait-extends-specialized-trait-no-param.scala new file mode 100644 index 000000000000..9a747d7daf79 --- /dev/null +++ b/tests/neg/specialized-trait-trait-extends-specialized-trait-no-param.scala @@ -0,0 +1,5 @@ +//> using options -language:experimental.specializedTraits +inline trait Foo[T: Specialized] + +trait Bar extends Foo[Int]: // error: Specialized traits may not be extended by ordinary traits. They may only be extended by classes, objects or inline/specialized traits. + def myMethod = "Hello I am a method" diff --git a/tests/neg/specialized-trait-trait-extends-specialized-trait.scala b/tests/neg/specialized-trait-trait-extends-specialized-trait.scala new file mode 100644 index 000000000000..246da494f134 --- /dev/null +++ b/tests/neg/specialized-trait-trait-extends-specialized-trait.scala @@ -0,0 +1,12 @@ +//> using options -language:experimental.specializedTraits +inline trait Foo[T: Specialized](x: T): + def foo = x + +trait Bar extends Foo[Int]: // error: Specialized traits may not be extended by ordinary traits. They may only be extended by classes, objects or inline/specialized traits. + def myMethod = "Hello I am a method" + +def f(b: Foo[Int]) = println(s"We found the following value of foo ${b.foo}") + +@main def main = + val x = new Bar with Foo(19) {} + f(x) diff --git a/tests/neg/specialized-trait-variance-not-allowed.scala b/tests/neg/specialized-trait-variance-not-allowed.scala new file mode 100644 index 000000000000..1ddc0ddcaeda --- /dev/null +++ b/tests/neg/specialized-trait-variance-not-allowed.scala @@ -0,0 +1,49 @@ +//> using options -language:experimental.specializedTraits + +trait Animal: + def makeNoise: String +class Lion extends Animal: + override def makeNoise = "ROAR!" +class Dog extends Animal: + override def makeNoise: String = "BARK!" + +trait Material +class Paper extends Material +class Newspaper extends Paper + +inline trait MyList[+T: Specialized](val xs: List[T]): + def map[S](f: T => S) = xs.map(f) +inline trait Bin[-T: Specialized]: + def throwAway(x: T) = println(s"Throwing away ${x}") + +def sound(dogs: MyList[Dog]) = + dogs.map(_.makeNoise) + +def throwAwayGeneralPaper(bin: Bin[Paper]) = + val a4 = Paper() + bin.throwAway(a4) + +def main = + /* These ones are not allowed normally */ + val myAnimals: MyList[Animal] = new MyList(List(Dog(), Dog(), Lion())) {} + sound(myAnimals) // error: MyList[Animal] can be interpreted as MyList[Dog] due to covariance + + val myNewspaperWasteBin = new Bin[Newspaper]() {} + throwAwayGeneralPaper(myNewspaperWasteBin) // error: Bin[Newspaper] cannot be interpreted as Bin[Paper] due to contravariance + + /* These ones are specifically banned for specialized traits: */ + val myObjectBin = new Bin[Object]() {} + throwAwayTheNewspaper(myObjectBin) // error: This use of contravariance is not compatible with specialized traits. + + val myAnyBin = new Bin[Any]() {} + throwAwayTheNewspaper(myAnyBin) // error: This use of contravariance is not compatible with specialized traits. + + throwAwayAnInteger(myAnyBin) // error: This use of contravariance is not compatible with specialized traits. + + val myAnyRefBin = new Bin[AnyRef]() {} + val myAnyValBin = new Bin[AnyVal]() {} + + throwAwayTheNewspaper(myAnyRefBin) // error: This use of contravariance is not compatible with specialized traits + throwAwayAnInteger(myAnyValBin) // error: This use of contravariance is not compatible with specialized traits + + diff --git a/tests/neg/specialized-trait-variance-nothing.scala b/tests/neg/specialized-trait-variance-nothing.scala new file mode 100644 index 000000000000..a299828d04cf --- /dev/null +++ b/tests/neg/specialized-trait-variance-nothing.scala @@ -0,0 +1,12 @@ +//> using options -language:experimental.specializedTraits + +inline trait Box[+T: Specialized] + +def checkNothingInt(x: Box[Int]) = println("Good morning") +def checkNothingString(x: Box[String]) = println("Good afternoon") + +@main def Test = + val x = new Box[Nothing] {} + + checkNothingInt(x) // error: Illegal variance in specialized traits + checkNothingString(x) // error: Illegal variance in specialized traits diff --git a/tests/neg/specialized-trait-variant-warns.scala b/tests/neg/specialized-trait-variant-warns.scala new file mode 100644 index 000000000000..b4aa67f047f8 --- /dev/null +++ b/tests/neg/specialized-trait-variant-warns.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits -Werror + +// nopos-error: no warnings under Werror + +inline trait Bin[-T: Specialized] // warn +inline trait List[+T: Specialized] // warn diff --git a/tests/neg/t750.check b/tests/neg/t750.check new file mode 100644 index 000000000000..60208079ce1f --- /dev/null +++ b/tests/neg/t750.check @@ -0,0 +1,32 @@ +-- [E007] Type Mismatch Error: tests/neg/t750/Test_2.scala:3:9 --------------------------------------------------------- +3 | AO_1.f(a) // error + | ^ + | Found: (a : Array[Int]) + | Required: Array[Object & T] + | + | where: T is a type variable + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg/t750/Test_2.scala:4:14 -------------------------------------------------------- +4 | AO_1.f[Int](a) // error + | ^ + | Found: (a : Array[Int]) + | Required: Array[Object & Int] + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg/t750/Test_2.scala:5:9 --------------------------------------------------------- +5 | AO_2.f(a) // error + | ^ + | Found: (a : Array[Int]) + | Required: Array[Object & T] + | + | where: T is a type variable + | + | longer explanation available when compiling with `-explain` +-- [E007] Type Mismatch Error: tests/neg/t750/Test_2.scala:6:14 -------------------------------------------------------- +6 | AO_2.f[Int](a) // error + | ^ + | Found: (a : Array[Int]) + | Required: Array[Object & Int] + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg/t750/AO_1.java b/tests/neg/t750/AO_1.java new file mode 100644 index 000000000000..994f0c101a25 --- /dev/null +++ b/tests/neg/t750/AO_1.java @@ -0,0 +1,7 @@ +public class AO_1 { + public static void f(T[] ar0) { + if (ar0.length > 0) { + System.out.println("hello, world"); + } + } +} diff --git a/tests/neg/t750/AO_2.java b/tests/neg/t750/AO_2.java new file mode 100644 index 000000000000..ac26d74e731a --- /dev/null +++ b/tests/neg/t750/AO_2.java @@ -0,0 +1,7 @@ +public class AO_2 { + public static void f(T[] ar0) { + if (ar0.length > 0) { + System.out.println("hello, world"); + } + } +} diff --git a/tests/neg/t750/Test_2.scala b/tests/neg/t750/Test_2.scala new file mode 100644 index 000000000000..9ffb98780484 --- /dev/null +++ b/tests/neg/t750/Test_2.scala @@ -0,0 +1,6 @@ +def test = + val a = Array(1, 2, 3) + AO_1.f(a) // error + AO_1.f[Int](a) // error + AO_2.f(a) // error + AO_2.f[Int](a) // error diff --git a/tests/neg/trait-extends-inline-trait-indirectly.scala b/tests/neg/trait-extends-inline-trait-indirectly.scala new file mode 100644 index 000000000000..70977dd3105b --- /dev/null +++ b/tests/neg/trait-extends-inline-trait-indirectly.scala @@ -0,0 +1,8 @@ +inline trait A[T](x: T): + val y = x +inline trait B extends A[Int] +class C extends B // error: parameterized trait A is indirectly implemented, needs to be implemented directly so that arguments can be passed + +object Test: + def main(args: Array[String]): Unit = + val z = new C diff --git a/tests/neg/trait-extends-inline-trait-with-params-uninitialized.scala b/tests/neg/trait-extends-inline-trait-with-params-uninitialized.scala new file mode 100644 index 000000000000..37646bc9b7da --- /dev/null +++ b/tests/neg/trait-extends-inline-trait-with-params-uninitialized.scala @@ -0,0 +1,4 @@ +inline trait A[T](x: T): + val y = x +trait B extends A[Int] // error: only parameterless inline traits may be extended by ordinary traits. +class C extends B, A[Int](4) diff --git a/tests/neg/trait-inline-trait-clashing.scala b/tests/neg/trait-inline-trait-clashing.scala new file mode 100644 index 000000000000..3d862d975805 --- /dev/null +++ b/tests/neg/trait-inline-trait-clashing.scala @@ -0,0 +1,8 @@ +trait Foo: + def foo = 10 + +inline trait Bar: + def foo = 10 + +class C extends Bar, Foo // error: C inherits conflicting members +class D extends Foo, Bar // error: D inherits conflicting members diff --git a/tests/neg/unroll-abstractMethod.scala b/tests/neg/unroll-abstractMethod.scala index 8f30fb63b20f..6ee0e00565b8 100644 --- a/tests/neg/unroll-abstractMethod.scala +++ b/tests/neg/unroll-abstractMethod.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/neg/unroll-clash.scala b/tests/neg/unroll-clash.scala index 79a75c2ba785..a3a072c95157 100644 --- a/tests/neg/unroll-clash.scala +++ b/tests/neg/unroll-clash.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/neg/unroll-clause-interleaving.scala b/tests/neg/unroll-clause-interleaving.scala index c40941320db1..eadbdd48abc8 100644 --- a/tests/neg/unroll-clause-interleaving.scala +++ b/tests/neg/unroll-clause-interleaving.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/neg/unroll-duped.scala b/tests/neg/unroll-duped.scala index a578fc837628..cbb81b58bb3e 100644 --- a/tests/neg/unroll-duped.scala +++ b/tests/neg/unroll-duped.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/neg/unroll-illegal.scala b/tests/neg/unroll-illegal.scala index 0b40a1c33c03..3f0c2b5642f5 100644 --- a/tests/neg/unroll-illegal.scala +++ b/tests/neg/unroll-illegal.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/neg/unroll-illegal2.scala b/tests/neg/unroll-illegal2.scala index ad7284506bbf..60d8c3a058b5 100644 --- a/tests/neg/unroll-illegal2.scala +++ b/tests/neg/unroll-illegal2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/neg/unroll-illegal3.scala b/tests/neg/unroll-illegal3.scala index 22a53bd04de6..15ecd2b9dd57 100644 --- a/tests/neg/unroll-illegal3.scala +++ b/tests/neg/unroll-illegal3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/neg/unroll-multipleParams.scala b/tests/neg/unroll-multipleParams.scala index 80371fec74c4..a9ac6ccb3e70 100644 --- a/tests/neg/unroll-multipleParams.scala +++ b/tests/neg/unroll-multipleParams.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/neg/unroll-no-default.scala b/tests/neg/unroll-no-default.scala index 4529bc79f815..85b4ea3d1801 100644 --- a/tests/neg/unroll-no-default.scala +++ b/tests/neg/unroll-no-default.scala @@ -1,4 +1,4 @@ -//> using options -experimental -Vprint:unrollDefs +//> using options -preview -Vprint:unrollDefs import scala.annotation.unroll diff --git a/tests/neg/unroll-traitConstructor.scala b/tests/neg/unroll-traitConstructor.scala index 3c48852d8303..84e8b3766cc7 100644 --- a/tests/neg/unroll-traitConstructor.scala +++ b/tests/neg/unroll-traitConstructor.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/neg/unsafe-dollar-in-name-2.check b/tests/neg/unsafe-dollar-in-name-2.check new file mode 100644 index 000000000000..b8926a0bc821 --- /dev/null +++ b/tests/neg/unsafe-dollar-in-name-2.check @@ -0,0 +1,8 @@ +-- Error: tests/neg/unsafe-dollar-in-name-2.scala:3:7 ------------------------------------------------------------------ +3 |object Foo$ // error + | ^ + | Identifier may not contain '$' in safe mode +-- Error: tests/neg/unsafe-dollar-in-name-2.scala:5:6 ------------------------------------------------------------------ +5 |class `Bar$` // error + | ^ + | Identifier may not contain '$' in safe mode diff --git a/tests/neg/unsafe-dollar-in-name-2.scala b/tests/neg/unsafe-dollar-in-name-2.scala new file mode 100644 index 000000000000..787c696e5d02 --- /dev/null +++ b/tests/neg/unsafe-dollar-in-name-2.scala @@ -0,0 +1,5 @@ +//> using options -language:experimental.safe + +object Foo$ // error + +class `Bar$` // error diff --git a/tests/neg/unsafe-dollar-in-name.check b/tests/neg/unsafe-dollar-in-name.check new file mode 100644 index 000000000000..e0c1f179e284 --- /dev/null +++ b/tests/neg/unsafe-dollar-in-name.check @@ -0,0 +1,8 @@ +-- Error: tests/neg/unsafe-dollar-in-name.scala:3:7 -------------------------------------------------------------------- +3 |object Foo$ // error + | ^ + | Identifier may not contain '$' in safe mode +-- Error: tests/neg/unsafe-dollar-in-name.scala:5:6 -------------------------------------------------------------------- +5 |class `Bar$` // error + | ^ + | Identifier may not contain '$' in safe mode diff --git a/tests/neg/unsafe-dollar-in-name.scala b/tests/neg/unsafe-dollar-in-name.scala new file mode 100644 index 000000000000..687479164c9c --- /dev/null +++ b/tests/neg/unsafe-dollar-in-name.scala @@ -0,0 +1,5 @@ +import language.experimental.safe + +object Foo$ // error + +class `Bar$` // error diff --git a/tests/neg/wildcard-imports.check b/tests/neg/wildcard-imports.check new file mode 100644 index 000000000000..96f35062844d --- /dev/null +++ b/tests/neg/wildcard-imports.check @@ -0,0 +1,8 @@ +-- [E049] Reference Error: tests/neg/wildcard-imports/Test.scala:7:12 -------------------------------------------------- +7 | val bar = foo // error + | ^^^ + | Reference to foo is ambiguous. + | It is both imported by import test.A._ + | and imported subsequently by import test.B._ + | + | longer explanation available when compiling with `-explain` diff --git a/tests/neg/wildcard-imports/A.scala b/tests/neg/wildcard-imports/A.scala new file mode 100644 index 000000000000..9ee9e1fddec3 --- /dev/null +++ b/tests/neg/wildcard-imports/A.scala @@ -0,0 +1,4 @@ +package test + +object A: + def foo: Int = 0 diff --git a/tests/neg/wildcard-imports/B.scala b/tests/neg/wildcard-imports/B.scala new file mode 100644 index 000000000000..036822c1e34c --- /dev/null +++ b/tests/neg/wildcard-imports/B.scala @@ -0,0 +1,4 @@ +package test + +object B: + def foo: Int = 0 diff --git a/tests/neg/wildcard-imports/Test.scala b/tests/neg/wildcard-imports/Test.scala new file mode 100644 index 000000000000..022654e3f71e --- /dev/null +++ b/tests/neg/wildcard-imports/Test.scala @@ -0,0 +1,8 @@ +package test + +import A.* +import B.* + +object Test: + val bar = foo // error + diff --git a/tests/new/test.scala b/tests/new/test.scala index f1193138b1e1..513aba7825b9 100644 --- a/tests/new/test.scala +++ b/tests/new/test.scala @@ -1,12 +1,14 @@ -package test - -object Console: - val out: java.io.PrintStream^ = System.out - def println(s: String) = out.println(s) - - -object Test:// uses Console uses_init Console: - Console.println("hello") - - def f() = - Console.println("hello") +trait TC[X] +object TC { + given t2[T]: TC[T] = ??? + given t1[T]: TC[T] = ??? +} +class Seq2[T] { + def sorted(using TC[T]): Seq2[T] = ??? +} +extension [T](s: Seq2[T]) + def f[G](c: Seq2[G]): Unit = ??? +object Crash { + val s: Seq2[Int] = ??? + s.sorted.f(Seq2()) +} \ No newline at end of file diff --git a/tests/pos-custom-args/captures/caps-universal.scala b/tests/pos-custom-args/captures/caps-universal.scala index 2537b1e4bd18..725e53bb484c 100644 --- a/tests/pos-custom-args/captures/caps-universal.scala +++ b/tests/pos-custom-args/captures/caps-universal.scala @@ -1,7 +1,8 @@ import annotation.retains -val foo: Int => Int = x => x -val bar: (Int -> Int) @retains[caps.any.type] = foo -val baz: Int => Int = bar +def test = + val foo: Int => Int = x => x + val bar: (Int -> Int) @retains[caps.any.type] = foo + val baz: Int => Int = bar diff --git a/tests/pos-custom-args/captures/coverage-arrayops-array-cap.scala b/tests/pos-custom-args/captures/coverage-arrayops-array-cap.scala new file mode 100644 index 000000000000..06d6510065c0 --- /dev/null +++ b/tests/pos-custom-args/captures/coverage-arrayops-array-cap.scala @@ -0,0 +1,11 @@ +//> using options -Yexplicit-nulls -Wsafe-init -language:experimental.captureChecking + +abstract class CoverageArraySeq[+A]: + def unsafeArray: Array[?] + + def reverseArray: CoverageArraySeq[A] = + CoverageArraySeq.unsafeWrapArray(new scala.collection.ArrayOps(unsafeArray).reverse).asInstanceOf[CoverageArraySeq[A]] + +object CoverageArraySeq: + def unsafeWrapArray[T](x: Array[T]): CoverageArraySeq[T] = + null.asInstanceOf[CoverageArraySeq[T]] diff --git a/tests/pos-custom-args/captures/coverage-binarytree-stepper.scala b/tests/pos-custom-args/captures/coverage-binarytree-stepper.scala new file mode 100644 index 000000000000..f9f2f99b3ad8 --- /dev/null +++ b/tests/pos-custom-args/captures/coverage-binarytree-stepper.scala @@ -0,0 +1,36 @@ +//> using options -Yexplicit-nulls -Wsafe-init + +object RedBlackTree: + final class Tree[K, +V]( + private val _value: AnyRef | Null, + private val _left: Tree[K, ?] | Null, + private val _right: Tree[K, ?] | Null): + + final def value = _value.asInstanceOf[V] + final def left = _left.asInstanceOf[Tree[K, V] | Null] + final def right = _right.asInstanceOf[Tree[K, V] | Null] + +trait Stepper[+A] +trait EfficientSplit + +object IntTreeStepper: + def from[T]( + maxLength: Int, + tree: T | Null, + left: T => T | Null, + right: T => T | Null, + extract: T => Int): Stepper[Int] & EfficientSplit = + new Stepper[Int] with EfficientSplit {} + +final class TreeSteppers[K, V](tree: RedBlackTree.Tree[K, V] | Null): + type T = RedBlackTree.Tree[K, V] + + def size: Int = 0 + + def valueStepper: Stepper[Int] & EfficientSplit = + IntTreeStepper.from[T]( + size, + tree, + _.left, + _ => null, + _.value.asInstanceOf[Int]) diff --git a/tests/pos-custom-args/captures/coverage-listbuffer-tail-isempty.scala b/tests/pos-custom-args/captures/coverage-listbuffer-tail-isempty.scala new file mode 100644 index 000000000000..4818431c79b1 --- /dev/null +++ b/tests/pos-custom-args/captures/coverage-listbuffer-tail-isempty.scala @@ -0,0 +1,13 @@ +import scala.language.experimental.captureChecking + +final class MiniListBuffer[A]: + @caps.unsafe.untrackedCaptures private var first: List[A] = Nil + + def subtractOne(elem: A): this.type = + if first.isEmpty then () + else + var cursor = first + while !cursor.tail.isEmpty && cursor.tail.head != elem do + cursor = cursor.tail + if !cursor.tail.isEmpty then () + this diff --git a/tests/pos-custom-args/captures/i16871.scala b/tests/pos-custom-args/captures/i16871.scala index 3251a7135346..73b947ff7691 100644 --- a/tests/pos-custom-args/captures/i16871.scala +++ b/tests/pos-custom-args/captures/i16871.scala @@ -1,3 +1,3 @@ import scala.language.experimental.captureChecking -val f: [X] => Int => Int = [X] => (x: Int) => x \ No newline at end of file +val f: [X] => Int -> Int = [X] => (x: Int) => x \ No newline at end of file diff --git a/tests/pos-custom-args/captures/i24309-region.scala b/tests/pos-custom-args/captures/i24309-region.scala index 61f79894419f..6bc9f40d614b 100644 --- a/tests/pos-custom-args/captures/i24309-region.scala +++ b/tests/pos-custom-args/captures/i24309-region.scala @@ -13,16 +13,26 @@ object Regions: region: Region[R]^ => def alloc(value: Int): Ref^{R} = Ref(value) - def subregion[T](f: [R2^ >: R] => (Region[R2]) => T): T = + def subregion[T](f: [R2^ >: R] => (Region[R2]) -> T): T = val r = new Region[R] {} f(r) + // Workaround variant: an empty term-parameter after the type binder + // permits an impure inner function type. + def subregion2[T](f: [R2^ >: R] => () -> (Region[R2]) => T): T = + val r = new Region[R] {} + f()(r) + object Region: - def apply[T](f: [R^] => Region[R] => T): T = + def apply[T](f: [R^] => Region[R] -> T): T = val r = new Region[{}] {} f(r) + def apply2[T](f: [R^] => () -> Region[R] => T): T = + val r = new Region[{}] {} + f()(r) + @main def main() = import Region.* Region: [R^] => @@ -32,4 +42,10 @@ object Regions: val a = r1.alloc(0) val b = r2.alloc(0) a + val y = r1.subregion2: [R2^ >: R] => + () => + r2 => + val a = r1.alloc(0) + val b = r2.alloc(0) + a 0 diff --git a/tests/pos-custom-args/captures/i24901.scala b/tests/pos-custom-args/captures/i24901.scala index d8172ee6edc7..0c8200f69b65 100644 --- a/tests/pos-custom-args/captures/i24901.scala +++ b/tests/pos-custom-args/captures/i24901.scala @@ -11,6 +11,10 @@ object Plan: test => execute(test) // was error +object PlanC: + def execute(test: Rand => Unit): Boolean = + true + val err: (Rand => Unit) => Boolean = test => execute(r => test(r)) // was error diff --git a/tests/pos-custom-args/captures/i25387.scala b/tests/pos-custom-args/captures/i25387.scala new file mode 100644 index 000000000000..ae95a1527d88 --- /dev/null +++ b/tests/pos-custom-args/captures/i25387.scala @@ -0,0 +1,5 @@ +package example +import scala.language.experimental.safe +import scala.util.boundary + +def main() = boundary(23) \ No newline at end of file diff --git a/tests/pos-custom-args/captures/i25388.scala b/tests/pos-custom-args/captures/i25388.scala new file mode 100644 index 000000000000..b9648c0ee987 --- /dev/null +++ b/tests/pos-custom-args/captures/i25388.scala @@ -0,0 +1,9 @@ +import scala.language.experimental.safe + +case class A(i: Int) extends AnyVal: + def addOne: A = A(i + 1) + +def test: Int = + val a = A(1) + val b = a.addOne + b.i diff --git a/tests/pos-custom-args/captures/i25830-apply-workaround.scala b/tests/pos-custom-args/captures/i25830-apply-workaround.scala new file mode 100644 index 000000000000..745fd5674c5f --- /dev/null +++ b/tests/pos-custom-args/captures/i25830-apply-workaround.scala @@ -0,0 +1,18 @@ +import language.experimental.captureChecking +import caps.* + +class File extends SharedCapability + +def test() = + val external = File() + class Convert: + def apply[C^, D^ <: {C}, E^ >: {C} <: {C, external}]( + xs: List[File^{C, external}], + ys: List[File^{D, external}])( + zs: List[File^{E, external}]): List[File^{E, external}] = zs + val x = File() + val files1: List[File^{x, external}] = List(x) + val files2: List[File^{x, external}] = List(x) + val files3: List[File^{x, external}] = List(x) + val _ : List[File^{x, external}] = + Convert()[{x}, {x}, {x, external}](files1, files2)(files3) diff --git a/tests/pos-custom-args/captures/i25830-bounded.scala b/tests/pos-custom-args/captures/i25830-bounded.scala new file mode 100644 index 000000000000..68949afce5bd --- /dev/null +++ b/tests/pos-custom-args/captures/i25830-bounded.scala @@ -0,0 +1,27 @@ +import language.experimental.captureChecking +import caps.* + +class File extends ExclusiveCapability + +def testFlat() = + val f = { [C^, D^ <: {C}] => (xs: List[File^{D}]) => xs } + val a = File() + val _ : List[File^{a}] = f[{a}, {a}](List[File^{a}](a)) + +def testLowerBound() = + val f = { [C^, D^ >: {C}] => (xs: List[File^{D}]) => xs } + val a = File() + val _ : List[File^{a}] = f[{a}, {a}](List[File^{a}](a)) + +def testCurriedBounded() = + val f = + { [C^, D^ <: {C}, E^ >: {C} <: {C, D}] => + (xs: List[File^{D}], ys: List[File^{C}]) => + (zs: List[File^{E}], ws: List[File^{C, D}]) => () + } + val a = File() + val xs: List[File^{a}] = List(a) + val ys: List[File^{a}] = List(a) + val zs: List[File^{a}] = List(a) + val ws: List[File^{a}] = List(a) + val _ : Unit = f[{a}, {a}, {a}](xs, ys)(zs, ws) diff --git a/tests/pos-custom-args/captures/i25830-external.scala b/tests/pos-custom-args/captures/i25830-external.scala new file mode 100644 index 000000000000..fb9aeb76c346 --- /dev/null +++ b/tests/pos-custom-args/captures/i25830-external.scala @@ -0,0 +1,58 @@ +import language.experimental.captureChecking +import caps.* + +class File extends ExclusiveCapability + +// Capture-polymorphic lambdas whose retains mention enclosing capabilities +// in addition to (or instead of) the lambda's own capset binders. Because +// PostTyper now keeps the user-written parameter types and binder bounds +// verbatim ("explicify"), Setup processes them through transformExplicitType +// which preserves @retains. Only the inferred result type is cleaned up. + +def mixedExternal() = + val external = File() + val f = + { [C^] => (xs: List[File^{C, external}]) => xs } + +def externalOnly() = + val external = File() + val f = + { [C^] => (xs: List[File^{external}]) => xs } + +def mixedExternalWithLowerBoundedParam() = + val external = File() + val f = + { [C^, D^ >: {C}] => (xs: List[File^{D, external}]) => xs } + +def mixedExternalInLaterParamList() = + val external = File() + val f = + { [C^] => (xs: List[File^{C}]) => (ys: List[File^{C, external}]) => ys } + +def enclosingParam(external: File^) = + val f = + { [C^] => (xs: List[File^{C}]) => (ys: List[File^{external}]) => ys } + +def supportedDef() = + val external = File() + def f = + { [C^] => (xs: List[File^{C, external}]) => xs } + +def insideAnonymousFunction() = + List(File()).map: external => + val f = + { [C^] => (xs: List[File^{C}]) => (ys: List[File^{external}]) => ys } + +def externalInBound() = + val external = File() + val f = + { [C^, D^ <: {C, external}] => (xs: List[File^{D}]) => xs } + +def nestedCapsetBinders() = + val f = + { [C^] => (xs: List[File^{C}]) => [D^] => (ys: List[File^{C, D}]) => ys } + +def literalNestedInFunction1() = + val external = File() + val f = + (i: Int) => { [C^] => (xs: List[File^{C, external}]) => xs } diff --git a/tests/pos-custom-args/captures/i25830-nicolas-lambda.scala b/tests/pos-custom-args/captures/i25830-nicolas-lambda.scala new file mode 100644 index 000000000000..7e8af5027283 --- /dev/null +++ b/tests/pos-custom-args/captures/i25830-nicolas-lambda.scala @@ -0,0 +1,24 @@ +import language.experimental.captureChecking +import caps.* + +// Lambda forms of the nicolas1 patterns: capset binder `B^` parameterising +// regular function types `Rand ->{B} A`. Verifies the explicify pipeline +// keeps `^{B}` flowing through to the result so the lambda can be applied +// with `B := {seed}` and used at the strict bound `Rand ->{seed} Int`. + +trait Rand extends SharedCapability: + def range(min: Int, max: Int): Int + +val pickFirst = + [A, B^] => (head: Rand ->{B} A, tail: Rand ->{B} A) => head + +val oneOf = + [A, B^] => (head: Rand ->{B} A, tail: Seq[Rand ->{B} A]) => + val all: Seq[Rand ->{B} A] = head +: tail + all.head + +def use = + val seed: Rand = ??? + val f: Rand ->{seed} Int = (r: Rand) => r.range(0, 10) + val r1: Rand ->{seed} Int = pickFirst[Int, {seed}](f, f) + val r3: Rand ->{seed} Int = oneOf[Int, {seed}](f, Seq(f, f)) diff --git a/tests/pos-custom-args/captures/i25830.scala b/tests/pos-custom-args/captures/i25830.scala new file mode 100644 index 000000000000..fa443f3029e0 --- /dev/null +++ b/tests/pos-custom-args/captures/i25830.scala @@ -0,0 +1,66 @@ +import language.experimental.captureChecking +import caps.* + +class File + +@main def test = + val convert = { [C^] => (xs: List[File^{C}]) => xs.map(_ => ()) } + val x: File^ = File() + val files: List[File^{x}] = List(x) + val result = convert[{x}](files) + + val globalFile: File^ = File() + + val convertCurried = + { [C^] => (xs: List[File^{C}]) => (ys: List[File^{C}]) => + println(globalFile) + xs.map(_ => ()) ++ ys.map(_ => ()) + } + val resultCurried = convertCurried[{x}](files)(files) + + def convertDef = + { [C^] => (xs: List[File^{C}]) => xs.map(_ => ()) } + val resultDef = convertDef[{x}](files) + + val resultInAnonymousFunction = + files.map: file => + val localFiles: List[File^{file}] = List(file) + val localConvert = + { [C^] => (xs: List[File^{C}]) => xs } + localConvert[{file}](localFiles) + + // Poly-fn literal nested inside a Function1: fine as long as retains + // only mention the literal's own capset binders. + val nestedInFunction1 = (i: Int) => { [C^] => (xs: List[File^{C}]) => xs } + val resultNested = nestedInFunction1(0)[{x}](files) + + // Capset binders interleaved with regular type binders. + val interleaved1 = { [C^, A] => (xs: List[A]) => (ys: List[File^{C}]) => ys } + val resultInterleaved1 = interleaved1[{x}, Int](List(1))(files) + + val interleaved2 = { [A, C^] => (xs: List[A]) => (ys: List[File^{C}]) => ys } + val resultInterleaved2 = interleaved2[Int, {x}](List(1))(files) + + val interleaved3 = + { [A, C^, B, D^] => (xs: List[A], ys: List[B]) => + (zs: List[File^{C}], ws: List[File^{D}]) => zs + } + val resultInterleaved3 = interleaved3[Int, {x}, String, {x}](List(1), List("a"))(files, files) + + // Multiple capset binder blocks separated by term-parameter lists. + val multi1 = + { [C^] => (xs: List[File^{C}]) => [D^] => (ys: List[File^{D}]) => (xs, ys) } + val resultMulti1 = multi1[{x}](files)[{x}](files) + + val multi2 = + { [C^] => (xs: List[File^{C}]) => [A] => (zs: List[A]) => [D^] => (ws: List[File^{D}]) => (xs, zs, ws) } + val resultMulti2 = multi2[{x}](files)[Int](List(1))[{x}](files) + + // Non-capset block first, then capset block. + val multi3 = { [A] => (zs: List[A]) => [C^] => (xs: List[File^{C}]) => (zs, xs) } + val resultMulti3 = multi3[Int](List(1))[{x}](files) + + // Inner block references both capset binders. + val multi4 = + { [C^] => (xs: List[File^{C}]) => [D^] => (ys: List[File^{C, D}]) => ys } + val resultMulti4 = multi4[{x}](files)[{x}](files) diff --git a/tests/pos-custom-args/captures/i25847.scala b/tests/pos-custom-args/captures/i25847.scala new file mode 100644 index 000000000000..2a268612fff6 --- /dev/null +++ b/tests/pos-custom-args/captures/i25847.scala @@ -0,0 +1,3 @@ +import language.experimental.safe +enum Foo: + case A, B, C \ No newline at end of file diff --git a/tests/pos-custom-args/captures/i25849.scala b/tests/pos-custom-args/captures/i25849.scala new file mode 100644 index 000000000000..4caa1a34b694 --- /dev/null +++ b/tests/pos-custom-args/captures/i25849.scala @@ -0,0 +1,16 @@ +import language.experimental.captureChecking + +sealed trait Res[+T]: + def toOption: Option[T] = this match + case Ok(value) => Some(value) + case _ => None + +case class Ok[+T](value: T) extends Res[T] +case object Bad extends Res[Nothing] + +def check[A](obtained: A, clue: => Any = "not equal"): Unit = + assert(obtained != null, clue) + +def test(): Unit = + val evens = (1 to 5).map(v => if v % 2 == 0 then Ok(v) else Bad).flatMap(_.toOption) + check(evens) \ No newline at end of file diff --git a/tests/pos-custom-args/captures/i25932.scala b/tests/pos-custom-args/captures/i25932.scala new file mode 100644 index 000000000000..b0c4e97ad9fc --- /dev/null +++ b/tests/pos-custom-args/captures/i25932.scala @@ -0,0 +1,30 @@ +import language.experimental.captureChecking +import caps.* + +trait Ctx extends SharedCapability + +class C[T]: + def value(using Ctx): T = ??? + +trait F1[T]: + def f(x: C[T]): T + +trait F2[T]: + self => + def f(x: C[T]): T + +object C: + given [T](using ctx: Ctx): (Conversion[C[T], T]^{ctx}) = _.value // error + +def getF1[T](using ctx: Ctx): F1[T]^{ctx} = new F1[T]: + def f(c: C[T]): T = c.value + +def getF2[T](using ctx: Ctx): F2[T]^{ctx} = new F2[T]: + def f(c: C[T]): T = c.value // error + +def test(using Ctx): Unit = + val c = new C[Int] + val n1: Int = c + val n2: Int = getF1.f(c) + val n3: Int = getF2.f(c) + diff --git a/tests/pos-custom-args/captures/i26186.scala b/tests/pos-custom-args/captures/i26186.scala new file mode 100644 index 000000000000..9470760e131f --- /dev/null +++ b/tests/pos-custom-args/captures/i26186.scala @@ -0,0 +1,27 @@ +package experiments.issues.suspendparams + +import language.experimental.captureChecking + +trait State[S, R] { + def get(resume: S => R): R + def put(newState: S, resume: Unit => R): R^{resume} +} + +type R = (Int, Long) +def run[S1 <: State[?, R], S2 <: State[?, R]](s1: S1, s2: S2)(prog: (S1, S2) => R): R = prog(s1, s2) + +inline def program(sum: State[Long, R]): R = { + def rec(x: Int): R = { + sum.get { s0 => + val s = s0 + x + sum.put(s, _ => { + if x > 0 then rec(x - 1) else (x, s) + }) + } + } + rec(10) +} + +def runProgram(other: State[?, R], sum: State[Long, R]) = { + run(other, sum)((_, s) => program(s)) +} \ No newline at end of file diff --git a/tests/pos-custom-args/captures/impure-conversion.scala b/tests/pos-custom-args/captures/impure-conversion.scala new file mode 100644 index 000000000000..7e14ad26127f --- /dev/null +++ b/tests/pos-custom-args/captures/impure-conversion.scala @@ -0,0 +1,14 @@ +import language.experimental.captureChecking +import caps.* + +trait Ctx extends SharedCapability + +class C[T]: + def value(using Ctx): T = ??? + +object C: + given [T](using ctx: Ctx): (Conversion[C[T], T]^{ctx}) = _.value + +def test(using Ctx): Unit = + val c = new C[Int] + val n: Int = c \ No newline at end of file diff --git a/tests/pos-custom-args/captures/safemode-synthetic/A_1.scala b/tests/pos-custom-args/captures/safemode-synthetic/A_1.scala new file mode 100644 index 000000000000..b28a1a4df0cb --- /dev/null +++ b/tests/pos-custom-args/captures/safemode-synthetic/A_1.scala @@ -0,0 +1,11 @@ +import language.experimental.captureChecking +import caps.assumeSafe + +@assumeSafe +object A: + // get @uncheckedVariance on the types + def f( + a: List[String] = List.empty, + b: Option[String] = None, + c: Long = 30000 + ) = () diff --git a/tests/pos-custom-args/captures/safemode-synthetic/B_2.scala b/tests/pos-custom-args/captures/safemode-synthetic/B_2.scala new file mode 100644 index 000000000000..a3626ccc0c76 --- /dev/null +++ b/tests/pos-custom-args/captures/safemode-synthetic/B_2.scala @@ -0,0 +1,9 @@ +import language.experimental.safe + +def test(i: Int, j: (String, Int)) = + // desugared to: + // val a$1: List[String] = List.apply[String](["bar" : String]*) + // val b$1: Option[String] @uncheckedVariance = A.f$default$2 + // A.f(a = a$1, b$1, c = 1000L) + // We need to skip annotation check for the synthetic b$1 in safe mode + A.f(a = List("bar"), c = 1000) diff --git a/tests/pos-custom-args/captures/secondary-constrs2.scala b/tests/pos-custom-args/captures/secondary-constrs2.scala new file mode 100644 index 000000000000..1053767c2b74 --- /dev/null +++ b/tests/pos-custom-args/captures/secondary-constrs2.scala @@ -0,0 +1,11 @@ +import language.experimental.captureChecking + +class T extends caps.SharedCapability + +class A(val x: T, val y: T): + def this(v: T) = this(v, v) + +def f(x: T^) = + val a = A(x) + val b: T^{x} = a.x + val c: T^{x} = a.y \ No newline at end of file diff --git a/tests/pos-macros/i12309/Macro_1.scala b/tests/pos-macros/i12309/Macro_1.scala index 91c0932682bb..10c6afbeefc6 100644 --- a/tests/pos-macros/i12309/Macro_1.scala +++ b/tests/pos-macros/i12309/Macro_1.scala @@ -12,7 +12,7 @@ object TestMacro { val result: String = "xxx" result }.asTerm - val resultDefSymbol = Symbol.newMethod(Symbol.spliceOwner, "getResult", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[String])) + val resultDefSymbol = Symbol.newMethod(Symbol.spliceOwner, "$anonfun$getResult", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[String])) val resultDef = DefDef(resultDefSymbol, { case _ => Some(resultDefBody().changeOwner(resultDefSymbol)) }) val resultExpr = Block(List(resultDef), Closure(Ref(resultDefSymbol), None)).asExprOf[() => String] diff --git a/tests/pos-macros/i21383/Macro_1.scala b/tests/pos-macros/i21383/Macro_1.scala new file mode 100644 index 000000000000..d6c71c7f576a --- /dev/null +++ b/tests/pos-macros/i21383/Macro_1.scala @@ -0,0 +1,17 @@ +import scala.quoted.* + +class MyAnnot(val name: String) extends scala.annotation.StaticAnnotation + +@MyAnnot("hello") +class Foo + +object Macro: + transparent inline def annotOf[T]: String = + ${ annotOfImpl[T] } + + def annotOfImpl[T: Type](using Quotes): Expr[String] = + import quotes.reflect.* + val annTerm = TypeRepr.of[T].typeSymbol.annotations + .find(_.tpe =:= TypeRepr.of[MyAnnot]).get + val annExpr = annTerm.asExprOf[MyAnnot] + '{ $annExpr.name } diff --git a/tests/pos-macros/i21383/Test_2.scala b/tests/pos-macros/i21383/Test_2.scala new file mode 100644 index 000000000000..9a2b51438373 --- /dev/null +++ b/tests/pos-macros/i21383/Test_2.scala @@ -0,0 +1 @@ +val x = Macro.annotOf[Foo] diff --git a/tests/pos-macros/i25541/Macro_1.scala b/tests/pos-macros/i25541/Macro_1.scala new file mode 100644 index 000000000000..8be7560df288 --- /dev/null +++ b/tests/pos-macros/i25541/Macro_1.scala @@ -0,0 +1,24 @@ +import scala.deriving.Mirror +import scala.quoted.* + +object LocalMacros: + def macroRWImpl[T: Type](using Quotes): Expr[Unit] = + import quotes.reflect.* + + def inspect(tpe: TypeRepr, typeArgs: List[TypeRepr]): Unit = + val constructorSym = tpe.typeSymbol.primaryConstructor + val constructorParamSymss = constructorSym.paramSymss + val (tparams0, params0) = constructorParamSymss.flatten.partition(_.isType) + val constructorTpe = tpe.memberType(constructorSym).widen + params0.foreach { param => + constructorTpe.memberType(param).substituteTypes(tparams0, typeArgs) + } + + TypeRepr.of[T] match + case applied: AppliedType => inspect(TypeRepr.of[T], applied.args) + case _ => inspect(TypeRepr.of[T], Nil) + + '{ () } + +trait Custom: + inline def macroRW[T](using Mirror.Of[T]): Unit = ${ LocalMacros.macroRWImpl[T] } diff --git a/tests/pos-macros/i25541/Test_2.scala b/tests/pos-macros/i25541/Test_2.scala new file mode 100644 index 000000000000..e5178ed304de --- /dev/null +++ b/tests/pos-macros/i25541/Test_2.scala @@ -0,0 +1,5 @@ +final case class MessageError[Node](message: Option[String], code: Option[Int], data: Option[Node]) + +object Test: + def readWriter(custom: Custom): Unit = + custom.macroRW[MessageError[Int]] diff --git a/tests/pos-macros/i26015/Converters.scala b/tests/pos-macros/i26015/Converters.scala new file mode 100644 index 000000000000..43d63eaf2a40 --- /dev/null +++ b/tests/pos-macros/i26015/Converters.scala @@ -0,0 +1,6 @@ +package repro + +// Not imported in Test.scala — serves as an import-suggestion candidate. +// importSuggestions finds it via rootsOnPath(repro.Crash.type) -> repro -> repro.Converters. +object Converters: + given Conversion[Int, String] = _.toString diff --git a/tests/pos-macros/i26015/Crash.scala b/tests/pos-macros/i26015/Crash.scala new file mode 100644 index 000000000000..13b2ccaff2c1 --- /dev/null +++ b/tests/pos-macros/i26015/Crash.scala @@ -0,0 +1,14 @@ +package repro + +import scala.quoted.* + +object Crash: + inline def trigger: Any = ${ triggerImpl } + + private def triggerImpl(using q: Quotes): Expr[Any] = + import q.reflect.* + // Build `{ val x: String = 1; x }` with all-NoSpan positions. + // NoSpan propagates into importSuggestions.deepTest's argument span, + // triggering the crash in adaptToArgs fallBack via union.startLine. + val sym = Symbol.newVal(Symbol.spliceOwner, "x", TypeRepr.of[String], Flags.EmptyFlags, Symbol.noSymbol) + Block(List(ValDef(sym, Some(Literal(IntConstant(1))))), Ref(sym)).asExpr diff --git a/tests/pos-macros/i26015/Test.scala b/tests/pos-macros/i26015/Test.scala new file mode 100644 index 000000000000..a162f1255afc --- /dev/null +++ b/tests/pos-macros/i26015/Test.scala @@ -0,0 +1,11 @@ +package mytest + +import repro.Crash + +// Should not crash with AssertionError: start of NoSpan. +// typeCheckErrors is inline -> InlineTyper (ReTyper) is active. +// TypeMismatch lazy message -> importSuggestions.deepTest -> +// typedImplicit -> adaptToArgs fallBack -> union.startLine on NoSpan. +@main def Test() = + val errors = scala.compiletime.testing.typeCheckErrors("repro.Crash.trigger") + println(s"errors: ${errors.length}") diff --git a/tests/pos-special/i24719/Tuple1.scala b/tests/pos-special/i24719/Tuple1.scala new file mode 100644 index 000000000000..22c4b8e866fa --- /dev/null +++ b/tests/pos-special/i24719/Tuple1.scala @@ -0,0 +1,2 @@ +package scala +final case class Tuple1[+T1](_1: T1) extends Product1[T1] diff --git a/tests/pos-special/i24719/Tuple22.scala b/tests/pos-special/i24719/Tuple22.scala new file mode 100644 index 000000000000..720739146e79 --- /dev/null +++ b/tests/pos-special/i24719/Tuple22.scala @@ -0,0 +1,5 @@ +package scala +final case class Tuple22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22]( + _1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, + _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20, _21: T21, _22: T22) + extends Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] diff --git a/tests/pos-with-compiler/Fileish.scala b/tests/pos-with-compiler/Fileish.scala index 9fdced47608b..a4ae8569b4a5 100644 --- a/tests/pos-with-compiler/Fileish.scala +++ b/tests/pos-with-compiler/Fileish.scala @@ -10,8 +10,9 @@ import language.postfixOps /** A common interface for File-based things and Stream-based things. * (In particular, io.File and JarEntry.) */ -class Fileish(val path: Path, val input: () => InputStream) extends Streamable.Chars { +class Fileish(val path: Path, val input: () => InputStream) { def inputStream() = input() + def lines(): Iterable[String] = ??? def parent = path.parent def name = path.name @@ -22,8 +23,9 @@ class Fileish(val path: Path, val input: () => InputStream) extends Streamable.C override def toString = path.path } -class Fileish2(val path: Path, val input: () => InputStream) extends Streamable.Chars { +class Fileish2(val path: Path, val input: () => InputStream) { def inputStream() = input() + def lines(): Iterable[String] = ??? def parent = path.parent def name = path.name @@ -35,8 +37,9 @@ class Fileish2(val path: Path, val input: () => InputStream) extends Streamable. override def toString = path.path } -class Fileish3(val path: Path, val input: () => InputStream) extends Streamable.Chars { +class Fileish3(val path: Path, val input: () => InputStream) { def inputStream() = input() + def lines(): Iterable[String] = ??? def parent = path.parent def name = path.name diff --git a/tests/pos/24707/BuggyClass.scala b/tests/pos/24707/BuggyClass.scala new file mode 100644 index 000000000000..988370442d3e --- /dev/null +++ b/tests/pos/24707/BuggyClass.scala @@ -0,0 +1,16 @@ +import scala.language.implicitConversions + +class RichComposite(val comp: MockComposite) extends AnyVal { + def setRowLayout(margin: Int, spacing: Int, vertical: Boolean = false): MockLayout = ??? +} + +object Implicits { + implicit def toRichComposite(c: MockComposite): RichComposite = new RichComposite(c) +} + +import Implicits.* + +class BuggyClass(parent: MockComposite) { + val comp = new MockComposite(parent, 0) + comp.setRowLayout(5, 5).wrap = false // This triggers the bug +} diff --git a/tests/pos/24707/MockComposite.java b/tests/pos/24707/MockComposite.java new file mode 100644 index 000000000000..0883c7ea0122 --- /dev/null +++ b/tests/pos/24707/MockComposite.java @@ -0,0 +1,6 @@ +// Mock Java class replacing SWT Composite +public class MockComposite { + public MockComposite(MockComposite parent, int style) { + // Constructor that mimics SWT's Composite(Composite, int) + } +} diff --git a/tests/pos/24707/MockLayout.java b/tests/pos/24707/MockLayout.java new file mode 100644 index 000000000000..1da943fb4a64 --- /dev/null +++ b/tests/pos/24707/MockLayout.java @@ -0,0 +1,4 @@ +// Mock Java class replacing SWT RowLayout +public class MockLayout { + public boolean wrap; // The mutable field that triggers the bug +} diff --git a/tests/pos/25198/Macros_1.scala b/tests/pos/25198/Macros_1.scala new file mode 100644 index 000000000000..80087e64fe10 --- /dev/null +++ b/tests/pos/25198/Macros_1.scala @@ -0,0 +1,33 @@ +import scala.quoted.* + +object Macros: + transparent inline def foo: String => String = + ${ fooImpl } + + // Synthesizes x => x + private def fooImpl(using Quotes): Expr[String => String] = + import quotes.reflect.* + + val methSym = + Symbol.newMethod( + Symbol.spliceOwner, + name = "$anonfun$fooImpl", + tpe = MethodType(List("x"))( + _ => List(TypeRepr.of[String]), + _ => TypeRepr.of[String], + ), + ) + + val meth = + DefDef( + methSym, + rhsFn = { argss => + val List(List(x)) = argss + Some(x.asInstanceOf[Term]) + } + ) + + Block( + List(meth), + Closure(Ident(methSym.termRef), tpe = None), + ).asExprOf[String => String] diff --git a/tests/pos/25198/Main_2.scala b/tests/pos/25198/Main_2.scala new file mode 100644 index 000000000000..d93c651df7f7 --- /dev/null +++ b/tests/pos/25198/Main_2.scala @@ -0,0 +1,8 @@ +//> using options -Xcheck-macros + +object Main: + val f: String => String = + Macros.foo + + @main def go = + println(f("Hello")) diff --git a/tests/pos/HelloWorld.scala b/tests/pos/HelloWorld.scala index 0f260a77dc93..a7d4682eea76 100644 --- a/tests/pos/HelloWorld.scala +++ b/tests/pos/HelloWorld.scala @@ -1,3 +1,5 @@ +// This test is used by end-to-end compiler tests. Do not delete it or change what it prints. + object HelloWorld { def main(args: Array[String]): Unit = println("hello world") } diff --git a/tests/pos/i15050.scala b/tests/pos/i15050.scala new file mode 100644 index 000000000000..e9d792bb26fb --- /dev/null +++ b/tests/pos/i15050.scala @@ -0,0 +1,7 @@ +import OpaqueBug.* +def g(n: Counter): Counter = n +object OpaqueBug: + opaque type Counter = Int + val initial: Counter = 42 + def f(n: Int): Int = g(n) + initial + @main def run = println(f(21)) diff --git a/tests/pos/i18099.scala b/tests/pos/i18099.scala new file mode 100644 index 000000000000..c2c3a300ae8c --- /dev/null +++ b/tests/pos/i18099.scala @@ -0,0 +1,7 @@ +class Foo[A] + +object Test { + class Bar[F[_]](val underlying: Any) extends AnyVal { + def foo = new Foo[F[Any]] {} + } +} diff --git a/tests/pos/i18234.scala b/tests/pos/i18234.scala new file mode 100644 index 000000000000..4359b5b656ef --- /dev/null +++ b/tests/pos/i18234.scala @@ -0,0 +1,12 @@ +//> using options -Werror + +class `C$Z`: + override def toString = "C$Z" + + def patvar[A](x: Option[A]) = + x match + case Some(`funky$thing` @ _) => true + case _ => false + +class $ +object $ diff --git a/tests/pos/i18533/Cat.java b/tests/pos/i18533/Cat.java index 56b5e0296043..fec994ca2a0a 100644 --- a/tests/pos/i18533/Cat.java +++ b/tests/pos/i18533/Cat.java @@ -1,6 +1,3 @@ -//> using javacOpt --enable-preview --source 17 -// test: -jvm 17 - package i18533; public final class Cat extends Pet { diff --git a/tests/pos/i19642/i19642.java b/tests/pos/i19642/i19642.java index c7d8ba9f0e72..07907f985502 100644 --- a/tests/pos/i19642/i19642.java +++ b/tests/pos/i19642/i19642.java @@ -6,4 +6,5 @@ public class i19642 { private String @lib.Valid [] flatArray; private String @lib.Valid [] @lib.Valid [] nestedArray; + void varargs(String @lib.Valid ... values) {} } diff --git a/tests/pos/i22833-unroll-final-class.scala b/tests/pos/i22833-unroll-final-class.scala index 1c5ef8cf0673..577e25dc8848 100644 --- a/tests/pos/i22833-unroll-final-class.scala +++ b/tests/pos/i22833-unroll-final-class.scala @@ -1,5 +1,6 @@ -import scala.annotation.{experimental,unroll} +//> using options -preview +import scala.annotation.unroll -@experimental final class Foo { +final class Foo { def bar(@unroll x: Int = 0) = x + 1 -} \ No newline at end of file +} diff --git a/tests/pos/i22979.scala b/tests/pos/i22979.scala new file mode 100644 index 000000000000..c6599acfab48 --- /dev/null +++ b/tests/pos/i22979.scala @@ -0,0 +1,29 @@ + +import annotation.* + +class C(@constructorOnly s: String): + val g: Any => String = _ => s + def f[A](xs: List[A]): List[String] = xs.map(g) + + val gg: Any => Any = (x: Any) => (y: Any) => s + + (y => s): (Any => Any) // pure expr + println(s) +end C + +import scala.util.boundary + +class Leak()(using @constructorOnly l: boundary.Label[String]): + Option("stop").foreach(boundary.break(_)) + + +class Lapse: + def f = Lapse.DefaultSentinelFn() +object Lapse: + private val DefaultSentinel: AnyRef = new AnyRef + private val DefaultSentinelFn: () => AnyRef = () => DefaultSentinel + +class scalafan(@constructorOnly str: String) { + val scream = Array.fill(10)(str + "!") + def screamTenTimes: Unit = scream.foreach(println) +} diff --git a/tests/pos/i23398.scala b/tests/pos/i23398.scala index 4d6be7248c5d..622d08617cae 100644 --- a/tests/pos/i23398.scala +++ b/tests/pos/i23398.scala @@ -1,4 +1,4 @@ -//> using options -feature -Werror -preview +//> using options -feature -Werror import Conversion.into diff --git a/tests/pos/i23774.scala b/tests/pos/i23774.scala new file mode 100644 index 000000000000..e4200ed2993e --- /dev/null +++ b/tests/pos/i23774.scala @@ -0,0 +1,35 @@ +trait Iterable[+A] + +enum Expr { + case Case[T, C <: Iterable[T]]() +} +object Expr { + val m = summon[scala.deriving.Mirror.SumOf[Expr]] + summon[m.MirroredElemTypes =:= Expr.Case[Any, Iterable[Any]] *: EmptyTuple] +} + +enum Trait { + case Upcast[Base, Case <: Base]() +} + +object Trait { + val m = summon[scala.deriving.Mirror.SumOf[Trait]] + summon[m.MirroredElemTypes =:= Trait.Upcast[Any, Any] *: EmptyTuple] +} + +enum MoreDeps { + case Case[T, C <: Iterable[T], D <: Iterable[C]]() +} +object MoreDeps { + val m = summon[scala.deriving.Mirror.SumOf[MoreDeps]] + summon[m.MirroredElemTypes =:= MoreDeps.Case[Any, Iterable[Any], Iterable[Iterable[Any]]] *: EmptyTuple] +} + +enum Circular { + case Case[C <: Iterable[D], D <: C]() +} +object Circular { + val m = summon[scala.deriving.Mirror.SumOf[Circular]] + summon[m.MirroredElemTypes =:= Circular.Case[Iterable[Nothing], Nothing] *: EmptyTuple] +} + diff --git a/tests/pos/i23774typeclass.scala b/tests/pos/i23774typeclass.scala new file mode 100644 index 000000000000..b2831a379c27 --- /dev/null +++ b/tests/pos/i23774typeclass.scala @@ -0,0 +1,74 @@ +import scala.compiletime.{erasedValue, summonInline} +import scala.deriving.Mirror + +enum Expr[+T]: + case UpcastToIterable[T, C <: Iterable[T]](v: Expr[C]) extends Expr[Iterable[T]] + case Seq[T](elements: Expr[T]*) extends Expr[scala.Seq[T]] + case Const(value: T) + +trait Fold[E]: + def apply[Acc](acc: Acc, expr: E, f: [t] => (Acc, Expr[t]) => Acc): Acc + +object Fold: + private inline def summonAll[Elems <: Tuple]: List[Fold[?]] = + inline erasedValue[Elems] match + case _: (h *: tail) => summonInline[Fold[h]] :: summonAll[tail] + case _: EmptyTuple => Nil + + final class Leaf[E] extends Fold[E]: + def apply[Acc](acc: Acc, expr: E, f: [t] => (Acc, Expr[t]) => Acc): Acc = acc + + given [T: Fold as fold] => Fold[Seq[T]] = new Fold[Seq[T]] { + def apply[Acc](acc: Acc, expr: Seq[T], f: [t] => (Acc, Expr[t]) => Acc): Acc = + expr.foldLeft(acc)((a, e) => fold(a, e, f)) + } + + given Fold[EmptyTuple] = new Fold[EmptyTuple]: + def apply[Acc](acc: Acc, expr: EmptyTuple, f: [t] => (Acc, Expr[t]) => Acc): Acc = acc + + given [H: Fold as h, T <: Tuple: Fold as t] => Fold[H *: T] = + new Fold[H *: T]: + def apply[Acc](acc: Acc, expr: H *: T, f: [t] => (Acc, Expr[t]) => Acc): Acc = + val acc1 = h(acc, expr.head, f) + t(acc1, expr.tail, f) + + private def product[E](m: Mirror.ProductOf[E], tupleFold: Fold[m.MirroredElemTypes]): Fold[E] = + new Fold[E]: + def apply[Acc](acc: Acc, expr: E, f: [t] => (Acc, Expr[t]) => Acc): Acc = + // The mirror makes this safe according to https://github.com/scala/scala3/issues/22382#issuecomment-2613187822 + tupleFold(acc, Tuple.fromProduct(expr.asInstanceOf[Product]).asInstanceOf[m.MirroredElemTypes], f) + + private def sum[E](m: Mirror.SumOf[E], cases0: () => List[Fold[?]]): Fold[E] = + new Fold[E]: + lazy val cases = cases0() + def apply[Acc](acc: Acc, expr: E, f: [t] => (Acc, Expr[t]) => Acc): Acc = + val ord = m.ordinal(expr) + val caseFold = cases.apply(ord) + caseFold.apply(acc, expr.asInstanceOf, f) + + inline given derived[E](using m: Mirror.Of[E]): Fold[E] = + inline m match + case m: Mirror.SumOf[E] => sum(m, () => summonAll[m.MirroredElemTypes]) + case m: Mirror.ProductOf[E] => product[E](m, summonInline[Fold[m.MirroredElemTypes]]) + + given [T] => Fold[Expr.Const[T]] = Leaf() + given Fold[Expr.UpcastToIterable[Any, Iterable[Any]]] = derived + given [T] => Fold[Expr[T]] = new Fold[Expr[T]]: + val default = derived[Expr[T]] + def apply[Acc](acc: Acc, expr: Expr[T], f: [t] => (Acc, Expr[t]) => Acc): Acc = + default(f(acc, expr), expr, f) + +@main def test(): Unit = + def count[T](expr: Expr[T], f: [t] => Expr[t] => Boolean)(using fold: Fold[Expr[T]]): Int = + fold(0, expr, [t] => (acc, e) => if f(e) then acc + 1 else acc) + + val ast: Expr[Iterable[Int]] = Expr.UpcastToIterable(Expr.Seq(Expr.Const(1), Expr.Const(2), Expr.Const(3))) + val constCount = count( + ast, + [t] => + _ match { + case Expr.Const(_) => true + case _ => false + } + ) + println(s"Number of Const nodes: $constCount") diff --git a/tests/pos/i24056.scala b/tests/pos/i24056.scala new file mode 100644 index 000000000000..f25a3547f0d3 --- /dev/null +++ b/tests/pos/i24056.scala @@ -0,0 +1,8 @@ +trait DFBit +final class DFVal[+T, +M](val value: Int) extends AnyVal +type DFValOf[+T] = DFVal[T, Any] + +class Top: + val dmn1 = new scala.reflect.Selectable: + val o: DFValOf[DFBit] = ??? + val x = dmn1.o diff --git a/tests/pos/i24765.scala b/tests/pos/i24765.scala new file mode 100644 index 000000000000..78c67123fc0f --- /dev/null +++ b/tests/pos/i24765.scala @@ -0,0 +1,12 @@ +import language.experimental.modularity + +trait A[T]: + extension(t: T) def foo: T + +trait B: + type Self + extension(t: Self) def foo: Self + +given A[Int] = x => x // ok before + +given Int is B = x => x // was: "cannot override an extension method" diff --git a/tests/pos/i25542.scala b/tests/pos/i25542.scala new file mode 100644 index 000000000000..590d7ba5d62e --- /dev/null +++ b/tests/pos/i25542.scala @@ -0,0 +1,16 @@ +class PartialRequest: + protected def handle(i: Int): Int = i + +object PartialRequest: + trait Bundler: + def bundle(req: PartialRequest): Int => Int + + object Bundler: + inline given Bundler = new Bundler: + def bundle(req: PartialRequest): Int => Int = + (i: Int) => req.handle(i) + + def apply()(using bundler: Bundler): Int => Int = + bundler.bundle(new PartialRequest) + +val request = PartialRequest() diff --git a/tests/pos/i25557.scala b/tests/pos/i25557.scala new file mode 100644 index 000000000000..6ac921b3bf74 --- /dev/null +++ b/tests/pos/i25557.scala @@ -0,0 +1,7 @@ +sealed trait Parent: + sealed trait Inner[T] +object ConcreteParent extends Parent: + val myInner: Inner[Boolean] = ??? + def foo(parent: Parent, isFoo: Boolean)(f: parent.type => parent.Inner[Boolean]) = ??? + foo(parent = ConcreteParent, isFoo = true)(_.myInner) + foo(isFoo = true, parent = ConcreteParent)(_.myInner) diff --git a/tests/pos/i25600.scala b/tests/pos/i25600.scala new file mode 100644 index 000000000000..e8875f84e564 --- /dev/null +++ b/tests/pos/i25600.scala @@ -0,0 +1,5 @@ +trait T: + @annotation.varargs + def t(s: String, a: Any*): String + +val x: T = (s, a) => s diff --git a/tests/pos/i25726.scala b/tests/pos/i25726.scala new file mode 100644 index 000000000000..d81b573e0b4c --- /dev/null +++ b/tests/pos/i25726.scala @@ -0,0 +1,48 @@ +import scala.language.experimental.erasedDefinitions + +class Ev + +trait Svc[A]: + def run(using erased Ev)(a: A): String +class ISvc extends Svc[Int]: + def run(using erased Ev)(a: Int): String = a.toString + +// More than one pre-erasure parameter list with an all-erased prefix +class Token +trait Store[A]: + def put(using erased Token)(key: String)(value: A): String +class IntStore extends Store[Int]: + def put(using erased Token)(key: String)(value: Int): String = s"$key=$value" + +// Trailing all-erased list (worked before the fix; must not regress) +trait Trail[A]: + def id(a: A)(using erased Ev): A +class IntTrail extends Trail[Int]: + def id(a: Int)(using erased Ev): Int = a + +// Erased-first inside a single parameter list +trait Single[A]: + def run(erased a: Ev, b: A): String +class IntSingle extends Single[Int]: + def run(erased a: Ev, b: Int): String = b.toString + +// Erased-first within a non-trailing parameter list +trait Mixed[A]: + def run(erased e: Ev, a: A)(b: Int): String +class IntMixed extends Mixed[Int]: + def run(erased e: Ev, a: Int)(b: Int): String = s"$a+$b" + + trait Eta[A]: + def f(using erased Ev)(a: A): String ?=> Int + + class IntEta extends Eta[Int]: + def f(using erased Ev)(a: Int): String ?=> Int = a + summon[String].length + +// generated bridge: +// def f(a: Object): Function1[String, Int] = // beridge +// new Function1[String, Int]: +// def apply(s: String): Int = this$IntEta.f(a, s) +trait Closure[A]: + def f(using erased Ev)(a: A): String ?=> Int +class IntClosure extends Closure[Int]: + def f(using erased Ev)(a: Int): String ?=> Int = a + summon[String].length diff --git a/tests/pos/i25801/Lib_1.scala b/tests/pos/i25801/Lib_1.scala new file mode 100644 index 000000000000..8cfa291569cc --- /dev/null +++ b/tests/pos/i25801/Lib_1.scala @@ -0,0 +1,10 @@ +// https://github.com/scala/scala3/issues/25801 +package i25801 + +trait A { self: B => + type X +} + +trait B extends A { + type X +} diff --git a/tests/pos/i25801/Use_2.scala b/tests/pos/i25801/Use_2.scala new file mode 100644 index 000000000000..df8c754b3774 --- /dev/null +++ b/tests/pos/i25801/Use_2.scala @@ -0,0 +1,4 @@ +// https://github.com/scala/scala3/issues/25801 +package i25801 + +def foo: B = ??? diff --git a/tests/pos/i25894/DFVal_1.scala b/tests/pos/i25894/DFVal_1.scala new file mode 100644 index 000000000000..855e5a15f0b8 --- /dev/null +++ b/tests/pos/i25894/DFVal_1.scala @@ -0,0 +1,15 @@ +package dfhdl + +final class DFVal[+T <: DFType, +M] + +type DFValAny = DFVal[DFType, ModifierAny] +type DFConstOf[+T <: DFType] = DFVal[T, Modifier.CONST] +type DFValTP[+T <: DFType] = DFVal[T, Modifier] + +inline def x = ${ ??? } + +object DFVal: + export DFXInt.Ops.{c1, c2} + object Ops: + type BoolOnlyOp + type CarryOp diff --git a/tests/pos/i25894/MutableDB_1.scala b/tests/pos/i25894/MutableDB_1.scala new file mode 100644 index 000000000000..eee22bdccdcc --- /dev/null +++ b/tests/pos/i25894/MutableDB_1.scala @@ -0,0 +1,2 @@ +package dfhdl +class MutableDB diff --git a/tests/pos/i25894/hdl_1.scala b/tests/pos/i25894/hdl_1.scala new file mode 100644 index 000000000000..9e072f2d03e5 --- /dev/null +++ b/tests/pos/i25894/hdl_1.scala @@ -0,0 +1,6 @@ +package dfhdl +object hdl: + export DFBoolOrBit.given + export DFDecimal.Ops.* + +export hdl.* diff --git a/tests/pos/i25894/stubs_1.scala b/tests/pos/i25894/stubs_1.scala new file mode 100644 index 000000000000..ddd100937475 --- /dev/null +++ b/tests/pos/i25894/stubs_1.scala @@ -0,0 +1,34 @@ +package dfhdl +import DFVal.Ops.CarryOp +import DFVal.Ops.BoolOnlyOp + +trait ExactOp2Aux[Op, C, O] + +trait Modifier +type ModifierAny = Modifier +object Modifier: + type CONST = Modifier + +class DFType + +class DFC(mutableDB: MutableDB) + +object DFBoolOrBit: + given bl[Op, O](using + ExactOp2Aux[Op, DFC, O] + ): ExactOp2Aux[BoolOnlyOp, DFC, O] = ??? + +object DFDecimal: + object Ops: + export DFXInt.Ops.* + +object DFXInt: + object Ops: + type A = Int + type B = String + given arith1[Op <: A]: ExactOp2Aux[Op, DFC, DFValTP[DFType]] = ??? + given arith2[Op <: B]: ExactOp2Aux[Op, DFC, DFValTP[DFType]] = ??? + given c1: ExactOp2Aux[CarryOp, DFC, DFValTP[DFType]] = ??? + given c2: ExactOp2Aux[CarryOp, DFC, DFValTP[DFType]] = ??? + +type DFConstInt32 = DFConstOf[DFType] diff --git a/tests/pos/i25894/stubs_2.scala b/tests/pos/i25894/stubs_2.scala new file mode 100644 index 000000000000..ddd100937475 --- /dev/null +++ b/tests/pos/i25894/stubs_2.scala @@ -0,0 +1,34 @@ +package dfhdl +import DFVal.Ops.CarryOp +import DFVal.Ops.BoolOnlyOp + +trait ExactOp2Aux[Op, C, O] + +trait Modifier +type ModifierAny = Modifier +object Modifier: + type CONST = Modifier + +class DFType + +class DFC(mutableDB: MutableDB) + +object DFBoolOrBit: + given bl[Op, O](using + ExactOp2Aux[Op, DFC, O] + ): ExactOp2Aux[BoolOnlyOp, DFC, O] = ??? + +object DFDecimal: + object Ops: + export DFXInt.Ops.* + +object DFXInt: + object Ops: + type A = Int + type B = String + given arith1[Op <: A]: ExactOp2Aux[Op, DFC, DFValTP[DFType]] = ??? + given arith2[Op <: B]: ExactOp2Aux[Op, DFC, DFValTP[DFType]] = ??? + given c1: ExactOp2Aux[CarryOp, DFC, DFValTP[DFType]] = ??? + given c2: ExactOp2Aux[CarryOp, DFC, DFValTP[DFType]] = ??? + +type DFConstInt32 = DFConstOf[DFType] diff --git a/tests/pos/i25943.scala b/tests/pos/i25943.scala new file mode 100644 index 000000000000..bd4ef3a0cec4 --- /dev/null +++ b/tests/pos/i25943.scala @@ -0,0 +1,26 @@ +// https://github.com/scala/scala3/issues/25943 +class C25943(a: Any) + +def compilerThrows25943(): Unit = + val a2 = new Object + + new : + class S extends C25943(a2) + new S{} + +val outsideA25943 = new Object + +def noThrow25943(): Unit = + val a2 = new Object + + val _ = + class S extends C25943(a2) + new S {} + + new : + class S extends C25943(a2) + + class S_outsideA extends C25943(outsideA25943) + new S_outsideA {} + + new C25943(a2) {} diff --git a/tests/pos/i25979.scala b/tests/pos/i25979.scala new file mode 100644 index 000000000000..9d1270bfd5bc --- /dev/null +++ b/tests/pos/i25979.scala @@ -0,0 +1,10 @@ +import scala.language.strictEquality +import scala.language.experimental.strictEqualityPatternMatching + +sealed trait Foo[A] +object Foo: + object Bar extends Foo[Int] + +def a[A](a: Foo[A]) = + a match + case Foo.Bar => diff --git a/tests/pos/i26026.scala b/tests/pos/i26026.scala new file mode 100644 index 000000000000..695465bcd4a7 --- /dev/null +++ b/tests/pos/i26026.scala @@ -0,0 +1,3 @@ +object Repro: + val opt: Option[String] = Some("hi") + val a: String = opt.orNull[String] diff --git a/tests/pos/i26190.scala b/tests/pos/i26190.scala new file mode 100644 index 000000000000..63cbb8207945 --- /dev/null +++ b/tests/pos/i26190.scala @@ -0,0 +1,11 @@ +import language.experimental.erasedDefinitions + +object Foo: + private erased val evidence: Boolean = true + inline def foo = Bar.bar(evidence) + +object Bar: + def bar(erased x: Boolean) = println("Hello World") + +def main = + Foo.foo diff --git a/tests/pos/i7910.scala b/tests/pos/i7910.scala new file mode 100644 index 000000000000..5ffaa30cc2d3 --- /dev/null +++ b/tests/pos/i7910.scala @@ -0,0 +1,13 @@ + +class C { + def k = { + object + extends Function1[Int, Int] { def apply(i: Int): Int = i + 1 } + val g: Int => Int = + + g(1) + } + def ok = { + val i = 42 + val n = +i + n + } +} diff --git a/tests/pos/inline-trait-1-simple-trait.scala b/tests/pos/inline-trait-1-simple-trait.scala new file mode 100644 index 000000000000..5a58b7ea2d4c --- /dev/null +++ b/tests/pos/inline-trait-1-simple-trait.scala @@ -0,0 +1,36 @@ +inline trait A: + type X = String + + val x: Int = 3 + val y: Int = x + z + private val z: Int = 1 + + def f: Int = g + def f(x: Int): Int = x + def f[T](x: T): Int = 2 + + private def g = 1 + protected[this] def p = 123 + private[this] def pp = 123456 + + def xx: X = "foo".asInstanceOf[X] +end A + +class B extends A: + /* + override type X = String + + override val x: Int = 3 + override val y: Int = this.x.+(this.z) + + private[this] val z: Int = 1 + + override def f: Int = this.g + override def f(x: Int): Int = x + override def f[T](x: T): Int = 2 + + private[this] def g: Int = 1 + + override def xx: X = "foo".asInstanceOf[X] + */ +end B diff --git a/tests/pos/inline-trait-2-generic-trait.scala b/tests/pos/inline-trait-2-generic-trait.scala new file mode 100644 index 000000000000..0df576c9c124 --- /dev/null +++ b/tests/pos/inline-trait-2-generic-trait.scala @@ -0,0 +1,13 @@ +inline trait A[T]: + def f: T = f + def f(x: T): T = x + def f[U <: T](x: U, y: T): T = x +end A + +class B extends A[Int]: + /* + override def f: Int = this.f + override def f(x: Int): Int = x + override def f[U <: Int](x: U, y: Int): Int = x + */ +end B diff --git a/tests/pos/inline-trait-3-trait-params.scala b/tests/pos/inline-trait-3-trait-params.scala new file mode 100644 index 000000000000..e2119bf9757b --- /dev/null +++ b/tests/pos/inline-trait-3-trait-params.scala @@ -0,0 +1,12 @@ +inline trait A(a: Int): + def f: Int = a + def g(b: Int): Int = a + b +end A + +class B extends A(4): + /* + private val a: Int = 4 + override def f: Int = this.a + override def g(x: Int): Int = this.a.+(b) + */ +end B diff --git a/tests/pos/inline-trait-3-trait-with-params.scala b/tests/pos/inline-trait-3-trait-with-params.scala new file mode 100644 index 000000000000..a497ebbcb7c1 --- /dev/null +++ b/tests/pos/inline-trait-3-trait-with-params.scala @@ -0,0 +1,13 @@ +inline trait A[T](a: T): + def f: T = a + def f(x: T): T = x + def f[U <: T](x: U, y: T): T = x +end A + +class B extends A[Int](3): + /* + override def f: Int = ??? + override def f(x: Int): Int = ??? + override def f[U <: Int](x: U, y: Int): Int = ??? + */ +end B diff --git a/tests/pos/inline-trait-4-no-inner-class.scala b/tests/pos/inline-trait-4-no-inner-class.scala new file mode 100644 index 000000000000..063f8e654fe5 --- /dev/null +++ b/tests/pos/inline-trait-4-no-inner-class.scala @@ -0,0 +1,24 @@ +inline trait Option[+T]: + def get: T + def isEmpty: Boolean +end Option + +inline trait Some[+T](x: T) extends Option[T]: + def get: T = x + def isEmpty: Boolean = false +end Some + +inline trait None extends Option[Nothing]: + def get: Nothing = throw new NoSuchElementException("None.get") + def isEmpty: Boolean = true +end None + +sealed trait IntOption extends Option[Int] +class IntSome(i: Int) extends IntOption, Some[Int](i) +object IntNone extends IntOption, None + +val o1: IntOption = IntSome(1) // specialized +val o2: IntOption = IntNone +val o3: Some[Int] = IntSome(1) // non-specialized +val x1: Int = o1.get // no unboxing +val x3: Int = o3.get // unboxing diff --git a/tests/pos/inline-trait-accesses-parent-val-param.scala b/tests/pos/inline-trait-accesses-parent-val-param.scala new file mode 100644 index 000000000000..9e337435e728 --- /dev/null +++ b/tests/pos/inline-trait-accesses-parent-val-param.scala @@ -0,0 +1,9 @@ +//> using options -Werror -Wsafe-init + +inline trait A[T](val x: T): + val v = x + +inline trait B extends A[Int]: + val z = x + +class C extends B, A[Int](10) diff --git a/tests/pos/inline-trait-body-abstract-def.scala b/tests/pos/inline-trait-body-abstract-def.scala new file mode 100644 index 000000000000..5b675a845236 --- /dev/null +++ b/tests/pos/inline-trait-body-abstract-def.scala @@ -0,0 +1,6 @@ +inline trait A[T]: + def x: T + +class B extends A[Int]: + def x = 1 + def f: Int = x \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-context-bound.scala b/tests/pos/inline-trait-body-def-context-bound.scala new file mode 100644 index 000000000000..c932500b62c5 --- /dev/null +++ b/tests/pos/inline-trait-body-def-context-bound.scala @@ -0,0 +1,6 @@ +inline trait A: + given List[String] = "AAA" :: Nil + def foo[T: List](x: T): T = summon[List[T]].headOption.getOrElse(x) + +class B extends A: + def f = foo("BBB") \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-curried-params.scala b/tests/pos/inline-trait-body-def-curried-params.scala new file mode 100644 index 000000000000..d253aa035331 --- /dev/null +++ b/tests/pos/inline-trait-body-def-curried-params.scala @@ -0,0 +1,8 @@ +inline trait A: + def x(foo: Int)(bar: Int) = + foo + bar + + def y(foo: Int) = x(foo)(foo) + +class B extends A: + def f = x(1)(2) diff --git a/tests/pos/inline-trait-body-def-extension-method.scala b/tests/pos/inline-trait-body-def-extension-method.scala new file mode 100644 index 000000000000..77b39dc502aa --- /dev/null +++ b/tests/pos/inline-trait-body-def-extension-method.scala @@ -0,0 +1,6 @@ +inline trait A: + extension [T](x: T) + def foo[U](y: U)(z: T): (T, U, T) = (x, y, z) + +class B extends A: + def f = 1.foo("2")(3) \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-final.scala b/tests/pos/inline-trait-body-def-final.scala new file mode 100644 index 000000000000..18bdeed55a1f --- /dev/null +++ b/tests/pos/inline-trait-body-def-final.scala @@ -0,0 +1,4 @@ +inline trait A: + final def f(x: Int) = x + +class B extends A \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-generic-singleton.scala b/tests/pos/inline-trait-body-def-generic-singleton.scala new file mode 100644 index 000000000000..2862ff3b1e93 --- /dev/null +++ b/tests/pos/inline-trait-body-def-generic-singleton.scala @@ -0,0 +1,7 @@ +inline trait A: + def foo: 3 = 3 + def bar[T](x: T): T = x + +class B extends A: + def f: "A" = bar("A") + def g: 3 = foo \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-generic.scala b/tests/pos/inline-trait-body-def-generic.scala new file mode 100644 index 000000000000..75d932f2f04a --- /dev/null +++ b/tests/pos/inline-trait-body-def-generic.scala @@ -0,0 +1,6 @@ +inline trait A: + def foo[T] = 1 + def bar: [U <: A] => U => Int = [U <: A] => (x: U) => x.foo + +class B extends A: + def f = foo[String] + bar(this) \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-implicit.scala b/tests/pos/inline-trait-body-def-implicit.scala new file mode 100644 index 000000000000..51381b394cef --- /dev/null +++ b/tests/pos/inline-trait-body-def-implicit.scala @@ -0,0 +1,6 @@ +inline trait A: + implicit val x: String = "AAA" + def foo(implicit s: String): String = s + s + +class B extends A: + def f = foo \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-inline-abstract.scala b/tests/pos/inline-trait-body-def-inline-abstract.scala new file mode 100644 index 000000000000..c385c397a3f0 --- /dev/null +++ b/tests/pos/inline-trait-body-def-inline-abstract.scala @@ -0,0 +1,6 @@ +inline trait A: + inline def x: Int + +class B extends A: + inline def x = 1 + def f = x \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-inline-compiletime.scala b/tests/pos/inline-trait-body-def-inline-compiletime.scala new file mode 100644 index 000000000000..975bffc76ac2 --- /dev/null +++ b/tests/pos/inline-trait-body-def-inline-compiletime.scala @@ -0,0 +1,9 @@ +import scala.compiletime.* + +inline trait A: + inline def f[T <: String] = + inline if constValue[T] == "I consent" then "All is OK!" + else error("You must consent!") + +class B extends A: + val x = f["I consent"] \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-inline-transparent.scala b/tests/pos/inline-trait-body-def-inline-transparent.scala new file mode 100644 index 000000000000..7e48cdec1e0f --- /dev/null +++ b/tests/pos/inline-trait-body-def-inline-transparent.scala @@ -0,0 +1,5 @@ +inline trait A: + transparent inline def x = 1 + +class B extends A: + def f: 1 = x \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-inline.scala b/tests/pos/inline-trait-body-def-inline.scala new file mode 100644 index 000000000000..8b3751398365 --- /dev/null +++ b/tests/pos/inline-trait-body-def-inline.scala @@ -0,0 +1,5 @@ +inline trait A: + inline def x = 1 + +class B extends A: + def f = x \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-lambda.scala b/tests/pos/inline-trait-body-def-lambda.scala new file mode 100644 index 000000000000..4eec58d40749 --- /dev/null +++ b/tests/pos/inline-trait-body-def-lambda.scala @@ -0,0 +1,5 @@ +inline trait A: + def f = (i: Int) => i + +class B extends A: + def g = f \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-local-val.scala b/tests/pos/inline-trait-body-def-local-val.scala new file mode 100644 index 000000000000..c503432ec175 --- /dev/null +++ b/tests/pos/inline-trait-body-def-local-val.scala @@ -0,0 +1,7 @@ +inline trait A: + def f = + val foo = 1 + foo + +class B extends A: + def g = f \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-params.scala b/tests/pos/inline-trait-body-def-params.scala new file mode 100644 index 000000000000..79018db761a3 --- /dev/null +++ b/tests/pos/inline-trait-body-def-params.scala @@ -0,0 +1,7 @@ +inline trait A: + def x(foo: Int, bar: Unit) = + bar + foo + +class B extends A: + def f = x(1, ()) \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-parens.scala b/tests/pos/inline-trait-body-def-parens.scala new file mode 100644 index 000000000000..17c80e9d8ab7 --- /dev/null +++ b/tests/pos/inline-trait-body-def-parens.scala @@ -0,0 +1,5 @@ +inline trait A: + def x() = 1 + +class B extends A: + def f = x() \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-simple.scala b/tests/pos/inline-trait-body-def-simple.scala new file mode 100644 index 000000000000..edffe37168be --- /dev/null +++ b/tests/pos/inline-trait-body-def-simple.scala @@ -0,0 +1,5 @@ +inline trait A: + def x = 1 + +class B extends A: + def f = x \ No newline at end of file diff --git a/tests/pos/inline-trait-body-def-using.scala b/tests/pos/inline-trait-body-def-using.scala new file mode 100644 index 000000000000..1436962f6b48 --- /dev/null +++ b/tests/pos/inline-trait-body-def-using.scala @@ -0,0 +1,6 @@ +inline trait A: + given String = "AAA" + def foo(using s: String): String = s + s + +class B extends A: + def f = foo \ No newline at end of file diff --git a/tests/pos/inline-trait-body-lazy-val.scala b/tests/pos/inline-trait-body-lazy-val.scala new file mode 100644 index 000000000000..37ab5c249375 --- /dev/null +++ b/tests/pos/inline-trait-body-lazy-val.scala @@ -0,0 +1,5 @@ +inline trait A: + lazy val x = 1 + +class B extends A: + def f = x \ No newline at end of file diff --git a/tests/pos/inline-trait-body-macro-suspend/Macro.scala b/tests/pos/inline-trait-body-macro-suspend/Macro.scala new file mode 100644 index 000000000000..8aa252d8b7d0 --- /dev/null +++ b/tests/pos/inline-trait-body-macro-suspend/Macro.scala @@ -0,0 +1,10 @@ +import scala.quoted.* + +inline def foo(): Int = + ${fooImpl} + +def fooImpl(using Quotes): Expr[Int] = + '{3} + +inline trait A: + val i: Int = foo() diff --git a/tests/pos/inline-trait-body-macro-suspend/Test.scala b/tests/pos/inline-trait-body-macro-suspend/Test.scala new file mode 100644 index 000000000000..5079eecd497d --- /dev/null +++ b/tests/pos/inline-trait-body-macro-suspend/Test.scala @@ -0,0 +1,2 @@ +class B extends A: + def test = foo() \ No newline at end of file diff --git a/tests/pos/inline-trait-body-macro/Macro_1.scala b/tests/pos/inline-trait-body-macro/Macro_1.scala new file mode 100644 index 000000000000..8aa252d8b7d0 --- /dev/null +++ b/tests/pos/inline-trait-body-macro/Macro_1.scala @@ -0,0 +1,10 @@ +import scala.quoted.* + +inline def foo(): Int = + ${fooImpl} + +def fooImpl(using Quotes): Expr[Int] = + '{3} + +inline trait A: + val i: Int = foo() diff --git a/tests/pos/inline-trait-body-macro/Test_2.scala b/tests/pos/inline-trait-body-macro/Test_2.scala new file mode 100644 index 000000000000..26e47fd25fdb --- /dev/null +++ b/tests/pos/inline-trait-body-macro/Test_2.scala @@ -0,0 +1 @@ +class B extends A \ No newline at end of file diff --git a/tests/pos/inline-trait-body-rhs-type.scala b/tests/pos/inline-trait-body-rhs-type.scala new file mode 100644 index 000000000000..5b439ddf0c19 --- /dev/null +++ b/tests/pos/inline-trait-body-rhs-type.scala @@ -0,0 +1,6 @@ +inline trait A[T](x: T): + def f: T = x: T + def g: T = identity[T](x) + def h: this.type = this: this.type + +class B extends A("Hello") diff --git a/tests/pos/inline-trait-body-setter.scala b/tests/pos/inline-trait-body-setter.scala new file mode 100644 index 000000000000..f1fcf528da9f --- /dev/null +++ b/tests/pos/inline-trait-body-setter.scala @@ -0,0 +1,6 @@ +inline trait A: + def x = 1 + def x_= (x: Int) = ??? + var y = 1 + +class B extends A \ No newline at end of file diff --git a/tests/pos/inline-trait-body-type.scala b/tests/pos/inline-trait-body-type.scala new file mode 100644 index 000000000000..35cad5c81c99 --- /dev/null +++ b/tests/pos/inline-trait-body-type.scala @@ -0,0 +1,5 @@ +inline trait A[T]: + type U = String + +class B extends A[Int]: + def f: U = "ABD" \ No newline at end of file diff --git a/tests/pos/inline-trait-body-val-inline.scala b/tests/pos/inline-trait-body-val-inline.scala new file mode 100644 index 000000000000..37f76fbd915c --- /dev/null +++ b/tests/pos/inline-trait-body-val-inline.scala @@ -0,0 +1,5 @@ +inline trait A: + inline val x = 1 + +class B extends A: + def f = x diff --git a/tests/pos/inline-trait-body-val.scala b/tests/pos/inline-trait-body-val.scala new file mode 100644 index 000000000000..33552386cf79 --- /dev/null +++ b/tests/pos/inline-trait-body-val.scala @@ -0,0 +1,5 @@ +inline trait A: + val x = 1 + +class B extends A: + def f = x diff --git a/tests/pos/inline-trait-clash-type-type.scala b/tests/pos/inline-trait-clash-type-type.scala new file mode 100644 index 000000000000..4e71330d4a69 --- /dev/null +++ b/tests/pos/inline-trait-clash-type-type.scala @@ -0,0 +1,8 @@ +trait One +trait Two extends One + +inline trait A: + type T <: One + +class C extends A: + type T = Two diff --git a/tests/pos/inline-trait-class-type-generic.scala b/tests/pos/inline-trait-class-type-generic.scala new file mode 100644 index 000000000000..572e88c34ae1 --- /dev/null +++ b/tests/pos/inline-trait-class-type-generic.scala @@ -0,0 +1,9 @@ +object MyObject + +inline trait A[T](x: T): + def foo: T = x + +class B extends A[MyObject.type](MyObject): + val y = 1 + +def h(x: B) = x.foo diff --git a/tests/pos/inline-trait-extends-abstract-class.scala b/tests/pos/inline-trait-extends-abstract-class.scala new file mode 100644 index 000000000000..ce1b2c1a10af --- /dev/null +++ b/tests/pos/inline-trait-extends-abstract-class.scala @@ -0,0 +1,8 @@ +abstract class A: + def foo: Int + +inline trait B(x: Int) extends A: + val y = x + override def foo = 10 + +class C extends B(15) diff --git a/tests/pos/inline-trait-extends-class.scala b/tests/pos/inline-trait-extends-class.scala new file mode 100644 index 000000000000..46cfce7da628 --- /dev/null +++ b/tests/pos/inline-trait-extends-class.scala @@ -0,0 +1,8 @@ +class A: + def foo: Int = 12 + +inline trait B(x: Int) extends A: + val y = x + override def foo = 10 + +class C extends B(15) diff --git a/tests/pos/inline-trait-extends-non-inline.scala b/tests/pos/inline-trait-extends-non-inline.scala new file mode 100644 index 000000000000..f66746b7dfeb --- /dev/null +++ b/tests/pos/inline-trait-extends-non-inline.scala @@ -0,0 +1,6 @@ +trait A: + def foo = "Hello World" + +inline trait B extends A + +trait C extends B diff --git a/tests/pos/inline-trait-extends-trait-with-parameters.scala b/tests/pos/inline-trait-extends-trait-with-parameters.scala new file mode 100644 index 000000000000..63ea6b9f0b3b --- /dev/null +++ b/tests/pos/inline-trait-extends-trait-with-parameters.scala @@ -0,0 +1,8 @@ +trait A(val z: Int): + def foo: Int + +inline trait B(x: Int) extends A: + val y = x + z + override def foo = 10 + +class C extends B(15), A(10) diff --git a/tests/pos/inline-trait-extends-trait.scala b/tests/pos/inline-trait-extends-trait.scala new file mode 100644 index 000000000000..0977d7faa67a --- /dev/null +++ b/tests/pos/inline-trait-extends-trait.scala @@ -0,0 +1,8 @@ +trait A: + def foo: Int + +inline trait B(x: Int) extends A: + val y = x + override def foo = 10 + +class C extends B(15) diff --git a/tests/pos/inline-trait-inheritance-multiple-override.scala b/tests/pos/inline-trait-inheritance-multiple-override.scala new file mode 100644 index 000000000000..8a429deb5101 --- /dev/null +++ b/tests/pos/inline-trait-inheritance-multiple-override.scala @@ -0,0 +1,20 @@ +inline trait IT1: + def i: Int = 1 + def f[T](x: T): T = x + +inline trait IT2: + def j: String = "inline" + def g(x: Int): String = x.toString() + +trait T: + def k: List[Nothing] + def h(x: Int, y: Double): Double = x + y + +class C1 extends IT1, T: + override def i: Int = 123456 + def k = Nil + override def h(x: Int, y: Double): Double = 1.0 + +class C2 extends IT1, IT2: + override def i: Int = 567890 + override def f[T](x: T): T = ??? \ No newline at end of file diff --git a/tests/pos/inline-trait-inheritance-multiple.scala b/tests/pos/inline-trait-inheritance-multiple.scala new file mode 100644 index 000000000000..15013572f9b7 --- /dev/null +++ b/tests/pos/inline-trait-inheritance-multiple.scala @@ -0,0 +1,17 @@ +object InlineTraits: + inline trait IT1: + def i: Int = 1 + def f[T](x: T): T = x + + inline trait IT2: + def j: String = "inline" + def g(x: Int): String = x.toString() + +trait T: + def k: List[Nothing] + def h(x: Int, y: Double): Double = x + y + +class C1 extends InlineTraits.IT1, T: + def k = Nil + +class C2 extends InlineTraits.IT1, InlineTraits.IT2 \ No newline at end of file diff --git a/tests/pos/inline-trait-inheritance-single-abstract-class-override.scala b/tests/pos/inline-trait-inheritance-single-abstract-class-override.scala new file mode 100644 index 000000000000..7baaf3885d6b --- /dev/null +++ b/tests/pos/inline-trait-inheritance-single-abstract-class-override.scala @@ -0,0 +1,7 @@ +inline trait IT: + def i: Int = 1 + def f[T](x: T): T = x + +abstract class AC extends IT: + override def i: Int = 123456 + def j: Int diff --git a/tests/pos/inline-trait-inheritance-single-abstract-class.scala b/tests/pos/inline-trait-inheritance-single-abstract-class.scala new file mode 100644 index 000000000000..49243dfd56ec --- /dev/null +++ b/tests/pos/inline-trait-inheritance-single-abstract-class.scala @@ -0,0 +1,6 @@ +inline trait IT: + def i: Int = 1 + def f[T](x: T): T = x + +abstract class AC extends IT: + def j: Int diff --git a/tests/pos/inline-trait-inheritance-single-object-override.scala b/tests/pos/inline-trait-inheritance-single-object-override.scala new file mode 100644 index 000000000000..7e7726e0e8bb --- /dev/null +++ b/tests/pos/inline-trait-inheritance-single-object-override.scala @@ -0,0 +1,6 @@ +inline trait IT: + def i: Int = 1 + def f[T](x: T): T = x + +object O extends IT: + override def i: Int = 123456 diff --git a/tests/pos/inline-trait-inheritance-single-object.scala b/tests/pos/inline-trait-inheritance-single-object.scala new file mode 100644 index 000000000000..3916f2e3dc36 --- /dev/null +++ b/tests/pos/inline-trait-inheritance-single-object.scala @@ -0,0 +1,5 @@ +inline trait IT: + def i: Int = 1 + def f[T](x: T): T = x + +object O extends IT diff --git a/tests/pos/inline-trait-inter-trait-inlining-no-cycle.scala b/tests/pos/inline-trait-inter-trait-inlining-no-cycle.scala new file mode 100644 index 000000000000..31da912767e7 --- /dev/null +++ b/tests/pos/inline-trait-inter-trait-inlining-no-cycle.scala @@ -0,0 +1,16 @@ +inline trait F: + def i = println("HELLO WORLD") + +inline trait E: + def h = + new F() {} + +inline trait D: + def g = + new E() {} + +inline trait C: + def f = + new D() {} + +class MyClass extends C, D, E, F diff --git a/tests/pos/inline-trait-multiple-files/A.scala b/tests/pos/inline-trait-multiple-files/A.scala new file mode 100644 index 000000000000..a137403cdf53 --- /dev/null +++ b/tests/pos/inline-trait-multiple-files/A.scala @@ -0,0 +1,2 @@ +inline trait A: + val i: Int = 1 \ No newline at end of file diff --git a/tests/pos/inline-trait-multiple-files/B.scala b/tests/pos/inline-trait-multiple-files/B.scala new file mode 100644 index 000000000000..26e47fd25fdb --- /dev/null +++ b/tests/pos/inline-trait-multiple-files/B.scala @@ -0,0 +1 @@ +class B extends A \ No newline at end of file diff --git a/tests/pos/inline-trait-multiple-stages-defs/A_1.scala b/tests/pos/inline-trait-multiple-stages-defs/A_1.scala new file mode 100644 index 000000000000..28781c194dd1 --- /dev/null +++ b/tests/pos/inline-trait-multiple-stages-defs/A_1.scala @@ -0,0 +1,11 @@ +inline trait A(x: Int): + def f: Int = 1 + def g(a: Int): Int = 2 + def h: Int + val i: Int = 3 + val j: Int + var k: Int = 4 + + inline val a = 5 + inline val b = a + inline def b(a: Int): Int = 6 diff --git a/tests/pos/inline-trait-multiple-stages-defs/B_2.scala b/tests/pos/inline-trait-multiple-stages-defs/B_2.scala new file mode 100644 index 000000000000..b1a1d7d6af3d --- /dev/null +++ b/tests/pos/inline-trait-multiple-stages-defs/B_2.scala @@ -0,0 +1,3 @@ +class B extends A(10): + def h: Int = 11 + val j: Int = 12 diff --git a/tests/pos/inline-trait-multiple-stages-generic-defs/A_1.scala b/tests/pos/inline-trait-multiple-stages-generic-defs/A_1.scala new file mode 100644 index 000000000000..3660b1e933ce --- /dev/null +++ b/tests/pos/inline-trait-multiple-stages-generic-defs/A_1.scala @@ -0,0 +1,9 @@ +inline trait A[T](x: T): + def f: T = x + def g(a: T): T = a + def h: T + val i: T = x + val j: T + var k: T = x + + inline def method(a: T): T = x diff --git a/tests/pos/inline-trait-multiple-stages-generic-defs/B_2.scala b/tests/pos/inline-trait-multiple-stages-generic-defs/B_2.scala new file mode 100644 index 000000000000..b595626379b8 --- /dev/null +++ b/tests/pos/inline-trait-multiple-stages-generic-defs/B_2.scala @@ -0,0 +1,3 @@ +class B extends A[Int](10): + def h: Int = 11 + val j: Int = 12 diff --git a/tests/pos/inline-trait-multiple-stages-inline-traits/A_1.scala b/tests/pos/inline-trait-multiple-stages-inline-traits/A_1.scala new file mode 100644 index 000000000000..2c130a7d8613 --- /dev/null +++ b/tests/pos/inline-trait-multiple-stages-inline-traits/A_1.scala @@ -0,0 +1,3 @@ +inline trait A: + def foo = "hello world" + \ No newline at end of file diff --git a/tests/pos/inline-trait-multiple-stages-inline-traits/B_2.scala b/tests/pos/inline-trait-multiple-stages-inline-traits/B_2.scala new file mode 100644 index 000000000000..68b16caeff9b --- /dev/null +++ b/tests/pos/inline-trait-multiple-stages-inline-traits/B_2.scala @@ -0,0 +1,2 @@ +inline trait B extends A: + def bar = "Good morning world" diff --git a/tests/pos/inline-trait-multiple-stages-inline-traits/C_3.scala b/tests/pos/inline-trait-multiple-stages-inline-traits/C_3.scala new file mode 100644 index 000000000000..da7b94cef862 --- /dev/null +++ b/tests/pos/inline-trait-multiple-stages-inline-traits/C_3.scala @@ -0,0 +1,6 @@ +class C extends B + +@main def main = + val x = C() + println(x.foo) + println(x.bar) diff --git a/tests/pos/inline-trait-multiple-stages/A_1.scala b/tests/pos/inline-trait-multiple-stages/A_1.scala new file mode 100644 index 000000000000..3596275f0498 --- /dev/null +++ b/tests/pos/inline-trait-multiple-stages/A_1.scala @@ -0,0 +1,2 @@ +inline trait A: + val i: Int = 1 diff --git a/tests/pos/inline-trait-multiple-stages/B_2.scala b/tests/pos/inline-trait-multiple-stages/B_2.scala new file mode 100644 index 000000000000..a18aec3dbe9b --- /dev/null +++ b/tests/pos/inline-trait-multiple-stages/B_2.scala @@ -0,0 +1 @@ +class B extends A diff --git a/tests/pos/inline-trait-nested-expansion.scala b/tests/pos/inline-trait-nested-expansion.scala new file mode 100644 index 000000000000..4035f91b9867 --- /dev/null +++ b/tests/pos/inline-trait-nested-expansion.scala @@ -0,0 +1,14 @@ +inline trait I1: + def foo = "foo" + +inline trait I2: + def bar = "bar" + +trait T1 extends I1: + trait T2 extends I2 + +def main = + val a = new T1() {} + val b = new a.T2() {} + a.foo + b.bar diff --git a/tests/pos/inline-trait-object-not-primitive.scala b/tests/pos/inline-trait-object-not-primitive.scala new file mode 100644 index 000000000000..7f155af53b62 --- /dev/null +++ b/tests/pos/inline-trait-object-not-primitive.scala @@ -0,0 +1,9 @@ +object Hop + +inline trait A[T](x: T): + def foo: T = x + +class B extends A[Hop.type](Hop): + val y = 1 + +def h(x: B) = x.foo diff --git a/tests/pos/inline-trait-opaque-type.scala b/tests/pos/inline-trait-opaque-type.scala new file mode 100644 index 000000000000..a922fb2033e9 --- /dev/null +++ b/tests/pos/inline-trait-opaque-type.scala @@ -0,0 +1,11 @@ +inline trait A[T](val x: T): + opaque type Special = T + + def getSpecial: Special = x + def eatSpecial(y: Special) = "Mmm, that was tasty!" + +class B extends A[Int](100) + +def foo = + val b = B() + println(b.eatSpecial(b.getSpecial)) diff --git a/tests/pos/inline-trait-override-overload.scala b/tests/pos/inline-trait-override-overload.scala new file mode 100644 index 000000000000..644de0420212 --- /dev/null +++ b/tests/pos/inline-trait-override-overload.scala @@ -0,0 +1,10 @@ +inline trait Foo[T]: + def foo(x: T) = x + def foo(x: String) = "Test" + +class Bar extends Foo[Int] + +@main def main = + val x = Bar() + println(x.foo(10)) + println(x.foo("Hello world")) \ No newline at end of file diff --git a/tests/pos/inline-trait-pair-example.scala b/tests/pos/inline-trait-pair-example.scala new file mode 100644 index 000000000000..733749aa516c --- /dev/null +++ b/tests/pos/inline-trait-pair-example.scala @@ -0,0 +1,7 @@ +package inlinetrait + +inline trait Pair[+T1, +T2](val _1: T1, val _2: T2) +class IntDoublePair(override val _1: Int, override val _2: Double) extends Pair[Int, Double](_1, _2) +class CharShortPair(override val _1: Char, override val _2: Short) extends Pair[Char, Short](_1, _2) + +def foo(i: IntDoublePair) = i._1 + i._2 diff --git a/tests/pos/inline-trait-parameter-passing.scala b/tests/pos/inline-trait-parameter-passing.scala new file mode 100644 index 000000000000..c5bba6b831b4 --- /dev/null +++ b/tests/pos/inline-trait-parameter-passing.scala @@ -0,0 +1,12 @@ +inline trait A: + def foo() = 10 + +class B extends A: + def bar() = 1000 + +def some_function(x: A) = + x.foo() + +@main def main = + val b = B() + some_function(b) diff --git a/tests/pos/inline-trait-parent-method-call.scala b/tests/pos/inline-trait-parent-method-call.scala new file mode 100644 index 000000000000..ad519a55ebfe --- /dev/null +++ b/tests/pos/inline-trait-parent-method-call.scala @@ -0,0 +1,5 @@ +inline trait A: + def generate(x: Int) = x + 1 + +class B extends A: + val y = generate(7) diff --git a/tests/pos/inline-trait-parent-ref.scala b/tests/pos/inline-trait-parent-ref.scala new file mode 100644 index 000000000000..d200f205df51 --- /dev/null +++ b/tests/pos/inline-trait-parent-ref.scala @@ -0,0 +1,7 @@ +inline trait A[T](x: T): + def foo: T = x + +class B extends A[Int](15): + val y = 1 + +def h(x: B) = x.foo diff --git a/tests/pos/inline-trait-private-evidence.scala b/tests/pos/inline-trait-private-evidence.scala new file mode 100644 index 000000000000..8cd7a5112a17 --- /dev/null +++ b/tests/pos/inline-trait-private-evidence.scala @@ -0,0 +1,13 @@ +/* + This is a special case for inline traits because the summon method is defined inline. We don't evaluate it until after + we've inlined it into child traits, but this means it can hang around in the original inline trait, which is a problem because + it throws a compiler error "method should have been inlined but was not". We need to make sure we prune it out, which initially + was missing for private fields (since it wasn't clear that this was necessary, but it is). +*/ + +inline trait A[T: Numeric]: + private val v = summon[Numeric[T]] + +inline trait B[T: Numeric] extends A[T] + +class C extends B[Int], A[Int] diff --git a/tests/pos/inline-trait-private-nested-inline-must-delete.scala b/tests/pos/inline-trait-private-nested-inline-must-delete.scala new file mode 100644 index 000000000000..5528543aee4d --- /dev/null +++ b/tests/pos/inline-trait-private-nested-inline-must-delete.scala @@ -0,0 +1,5 @@ +inline trait A[T: Numeric]: + private val num = summon[Numeric[T]] + private val x = 1 + +class B extends A[Float] diff --git a/tests/pos/inline-trait-return-ref.scala b/tests/pos/inline-trait-return-ref.scala new file mode 100644 index 000000000000..3b04ac346fee --- /dev/null +++ b/tests/pos/inline-trait-return-ref.scala @@ -0,0 +1,5 @@ +inline trait A[T](val x: T): + def foo: T = x + +class B extends A[Int](1): + def bar: Int = foo diff --git a/tests/pos/inline-trait-self-inline-two-cycle-no-use.scala b/tests/pos/inline-trait-self-inline-two-cycle-no-use.scala new file mode 100644 index 000000000000..6185497a39de --- /dev/null +++ b/tests/pos/inline-trait-self-inline-two-cycle-no-use.scala @@ -0,0 +1,15 @@ +// We throw the error only when someone tries to use the traits, because +// the theoretical infinite inlining is only an intermediate state before pruning anyway. +// At the end these traits can be pruned. + +inline trait C[S]: + def v(x: S): S = x + def w: Unit = + val x = new D[S] {} + println("w") + +inline trait D[S]: + def v(x: S): S = x + def w: Unit = + val x = new C[S] {} + println("w") diff --git a/tests/pos/inline-trait-self-type.scala b/tests/pos/inline-trait-self-type.scala new file mode 100644 index 000000000000..bf57e7b3d3e1 --- /dev/null +++ b/tests/pos/inline-trait-self-type.scala @@ -0,0 +1,26 @@ +trait T1 +trait T2 +trait T3 +class Test + +inline trait A[T]: + this: T1 => + +inline trait D extends A[Int]: + this: T1 => +inline trait E extends D: + this: T1 => + +inline trait B[T]: + this: T2 & T1 => + +inline trait F extends A[Int], B[Int]: + this: T2 & T1 => + +inline trait C[T]: + this: T => + +inline trait H extends C[Test]: + this: T3 & Test => + +class Cl2 extends Test with H with T3 diff --git a/tests/pos/inline-trait-signature-generic-context-bound.scala b/tests/pos/inline-trait-signature-generic-context-bound.scala new file mode 100644 index 000000000000..f3587911f168 --- /dev/null +++ b/tests/pos/inline-trait-signature-generic-context-bound.scala @@ -0,0 +1,4 @@ +inline trait A[T: List] + +given List[Int] = Nil +class B extends A \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-generic-inferred-type.scala b/tests/pos/inline-trait-signature-generic-inferred-type.scala new file mode 100644 index 000000000000..275ed0c7ec5b --- /dev/null +++ b/tests/pos/inline-trait-signature-generic-inferred-type.scala @@ -0,0 +1,5 @@ +inline trait A[T](val x: T): + def f: T = x + +class B extends A(1): + val y: Int = f diff --git a/tests/pos/inline-trait-signature-generic-invariant.scala b/tests/pos/inline-trait-signature-generic-invariant.scala new file mode 100644 index 000000000000..cc20461e716e --- /dev/null +++ b/tests/pos/inline-trait-signature-generic-invariant.scala @@ -0,0 +1,4 @@ +inline trait A[T]: + def f(x: T): T = x + +class B extends A[Int] diff --git a/tests/pos/inline-trait-signature-generic-parameter.scala b/tests/pos/inline-trait-signature-generic-parameter.scala new file mode 100644 index 000000000000..174ceba06a8c --- /dev/null +++ b/tests/pos/inline-trait-signature-generic-parameter.scala @@ -0,0 +1,5 @@ +inline trait A[T](val x: T): + def f: T = x + +class B extends A[Int](1): + val y: Int = f diff --git a/tests/pos/inline-trait-signature-generic-refinement-type.scala b/tests/pos/inline-trait-signature-generic-refinement-type.scala new file mode 100644 index 000000000000..3683c55a4d02 --- /dev/null +++ b/tests/pos/inline-trait-signature-generic-refinement-type.scala @@ -0,0 +1,9 @@ +import reflect.Selectable.reflectiveSelectable + +class C[T](x: T): + def foo(): T = x + +inline trait A[T, U[T]](u: U[T]{ def foo(): T }): + def f: T = u.foo() + +class B extends A(C(1)) diff --git a/tests/pos/inline-trait-signature-generic-singleton.scala b/tests/pos/inline-trait-signature-generic-singleton.scala new file mode 100644 index 000000000000..c5d0cf2fcfb1 --- /dev/null +++ b/tests/pos/inline-trait-signature-generic-singleton.scala @@ -0,0 +1,4 @@ +inline trait A[T](x: T): + def f: T = x + +class B extends A[1](1) diff --git a/tests/pos/inline-trait-signature-generic-type-bounds.scala b/tests/pos/inline-trait-signature-generic-type-bounds.scala new file mode 100644 index 000000000000..9cf4a00c80d7 --- /dev/null +++ b/tests/pos/inline-trait-signature-generic-type-bounds.scala @@ -0,0 +1,4 @@ +inline trait A[T >: Int <: AnyVal]: + def f(x: T): T = x + +class B extends A[Int] diff --git a/tests/pos/inline-trait-signature-generic-variant.scala b/tests/pos/inline-trait-signature-generic-variant.scala new file mode 100644 index 000000000000..201a9254c47a --- /dev/null +++ b/tests/pos/inline-trait-signature-generic-variant.scala @@ -0,0 +1,8 @@ +inline trait Cov[+T]: + def f: T = ??? + +inline trait Contr[-T]: + def f(x: T) = ??? + +class A extends Cov[AnyVal] +class B extends Contr[Int] \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-parameters-currying.scala b/tests/pos/inline-trait-signature-parameters-currying.scala new file mode 100644 index 000000000000..9d98e0596408 --- /dev/null +++ b/tests/pos/inline-trait-signature-parameters-currying.scala @@ -0,0 +1,4 @@ +inline trait A(i: Int)(j: Double): + def f: Double = i + j + +class B extends A(1)(1.0) diff --git a/tests/pos/inline-trait-signature-parameters-default-value.scala b/tests/pos/inline-trait-signature-parameters-default-value.scala new file mode 100644 index 000000000000..f76056ba70df --- /dev/null +++ b/tests/pos/inline-trait-signature-parameters-default-value.scala @@ -0,0 +1,4 @@ +inline trait A(val x: Int = 4) + +class B extends A(1) +class C extends A() \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-parameters-implicit.scala b/tests/pos/inline-trait-signature-parameters-implicit.scala new file mode 100644 index 000000000000..df091c0cc7e6 --- /dev/null +++ b/tests/pos/inline-trait-signature-parameters-implicit.scala @@ -0,0 +1,4 @@ +inline trait A(implicit val imp: Int) + +implicit val x: Int = 1 +class B extends A \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-parameters-using-nameless.scala b/tests/pos/inline-trait-signature-parameters-using-nameless.scala new file mode 100644 index 000000000000..1882b0348488 --- /dev/null +++ b/tests/pos/inline-trait-signature-parameters-using-nameless.scala @@ -0,0 +1,4 @@ +inline trait A(using Int) // error + +given x: Int = 1 +class B extends A \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-parameters-using.scala b/tests/pos/inline-trait-signature-parameters-using.scala new file mode 100644 index 000000000000..5438359370f8 --- /dev/null +++ b/tests/pos/inline-trait-signature-parameters-using.scala @@ -0,0 +1,4 @@ +inline trait A(using usng: Int) + +given x: Int = 1 +class B extends A \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-parameters-val-private.scala b/tests/pos/inline-trait-signature-parameters-val-private.scala new file mode 100644 index 000000000000..9306e0152f05 --- /dev/null +++ b/tests/pos/inline-trait-signature-parameters-val-private.scala @@ -0,0 +1,3 @@ +inline trait A(x: Int) + +class B extends A(1) \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-parameters-val-protected.scala b/tests/pos/inline-trait-signature-parameters-val-protected.scala new file mode 100644 index 000000000000..4127d45e9002 --- /dev/null +++ b/tests/pos/inline-trait-signature-parameters-val-protected.scala @@ -0,0 +1,3 @@ +inline trait A(protected val x: Int) + +class B extends A(1) \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-parameters-val.scala b/tests/pos/inline-trait-signature-parameters-val.scala new file mode 100644 index 000000000000..8372baa0b810 --- /dev/null +++ b/tests/pos/inline-trait-signature-parameters-val.scala @@ -0,0 +1,3 @@ +inline trait A(val x: Int) + +class B extends A(1) \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-parameters-var.scala b/tests/pos/inline-trait-signature-parameters-var.scala new file mode 100644 index 000000000000..590d273f81b6 --- /dev/null +++ b/tests/pos/inline-trait-signature-parameters-var.scala @@ -0,0 +1,3 @@ +inline trait A(var x: Int) + +class B extends A(1) \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-parentheses.scala b/tests/pos/inline-trait-signature-parentheses.scala new file mode 100644 index 000000000000..8e9c674edad6 --- /dev/null +++ b/tests/pos/inline-trait-signature-parentheses.scala @@ -0,0 +1,4 @@ +inline trait A(): + def i: Int = 1 + +class B extends A diff --git a/tests/pos/inline-trait-signature-sealed.scala b/tests/pos/inline-trait-signature-sealed.scala new file mode 100644 index 000000000000..db9d6a260ad3 --- /dev/null +++ b/tests/pos/inline-trait-signature-sealed.scala @@ -0,0 +1,4 @@ +inline sealed trait A: + final def f(x: Int) = x + +class B extends A \ No newline at end of file diff --git a/tests/pos/inline-trait-signature-simple.scala b/tests/pos/inline-trait-signature-simple.scala new file mode 100644 index 000000000000..6734a69a488c --- /dev/null +++ b/tests/pos/inline-trait-signature-simple.scala @@ -0,0 +1,4 @@ +inline trait A: + def i: Int = 1 + +class B extends A diff --git a/tests/pos/inline-trait-super-call-non-overridden.scala b/tests/pos/inline-trait-super-call-non-overridden.scala new file mode 100644 index 000000000000..ffd37cca62f0 --- /dev/null +++ b/tests/pos/inline-trait-super-call-non-overridden.scala @@ -0,0 +1,5 @@ +inline trait A: + def foo = 10 + +inline trait B extends A: + def bar = super.foo diff --git a/tests/pos/inline-trait-usage-anonymous-class.scala b/tests/pos/inline-trait-usage-anonymous-class.scala new file mode 100644 index 000000000000..c51dd05a6907 --- /dev/null +++ b/tests/pos/inline-trait-usage-anonymous-class.scala @@ -0,0 +1,4 @@ +inline trait A[T]: + val x: T = ??? + +val a = new A[Int] {} \ No newline at end of file diff --git a/tests/pos/inline-trait-usage-extension.scala b/tests/pos/inline-trait-usage-extension.scala new file mode 100644 index 000000000000..f9f5d87d2ceb --- /dev/null +++ b/tests/pos/inline-trait-usage-extension.scala @@ -0,0 +1,3 @@ +inline trait A + +class B extends A diff --git a/tests/pos/inline-trait-usage-inner.scala b/tests/pos/inline-trait-usage-inner.scala new file mode 100644 index 000000000000..3ed7869f0016 --- /dev/null +++ b/tests/pos/inline-trait-usage-inner.scala @@ -0,0 +1,5 @@ +object O: + inline trait A[T]: + def t: T = ??? + +class B extends O.A[Int] diff --git a/tests/pos/inline-trait-usage-param-type.scala b/tests/pos/inline-trait-usage-param-type.scala new file mode 100644 index 000000000000..e04f885f1e65 --- /dev/null +++ b/tests/pos/inline-trait-usage-param-type.scala @@ -0,0 +1,3 @@ +inline trait A + +def f(a: A) = ??? diff --git a/tests/pos/inline-trait-usage-return-type.scala b/tests/pos/inline-trait-usage-return-type.scala new file mode 100644 index 000000000000..e8015b065552 --- /dev/null +++ b/tests/pos/inline-trait-usage-return-type.scala @@ -0,0 +1,3 @@ +inline trait A + +def f: A = ??? diff --git a/tests/pos/inline-trait-usage-type-bound.scala b/tests/pos/inline-trait-usage-type-bound.scala new file mode 100644 index 000000000000..52b57f6acfa5 --- /dev/null +++ b/tests/pos/inline-trait-usage-type-bound.scala @@ -0,0 +1,3 @@ +inline trait A + +type T >: A <: A \ No newline at end of file diff --git a/tests/pos/inline-trait-usage-type.scala b/tests/pos/inline-trait-usage-type.scala new file mode 100644 index 000000000000..1c1ae110c367 --- /dev/null +++ b/tests/pos/inline-trait-usage-type.scala @@ -0,0 +1,3 @@ +inline trait A + +type T = List[A] \ No newline at end of file diff --git a/tests/pos/inline-trait-val-def-inner-class-inner-class-owners-init.scala b/tests/pos/inline-trait-val-def-inner-class-inner-class-owners-init.scala new file mode 100644 index 000000000000..3296df058706 --- /dev/null +++ b/tests/pos/inline-trait-val-def-inner-class-inner-class-owners-init.scala @@ -0,0 +1,16 @@ +inline trait Trait[T](x: Any): + def do_something() = println("Good morning") + +trait Trait2: + def bar() = println("bar") + +inline trait A[T]: + def foo: Trait[T] + +inline trait B extends A[Int]: + override def foo = new Trait[Int](new Trait2() {}) {} + +@main def Test = + val b = new B() {} + val f = b.foo + f.do_something() diff --git a/tests/pos/inline-trait-val-def-inner-class-inner-class-owners.scala b/tests/pos/inline-trait-val-def-inner-class-inner-class-owners.scala new file mode 100644 index 000000000000..91362304819f --- /dev/null +++ b/tests/pos/inline-trait-val-def-inner-class-inner-class-owners.scala @@ -0,0 +1,18 @@ +inline trait Trait[T]: + def do_something() = println("Good morning") + +trait Trait2: + def bar() = println("bar") + +inline trait A[T]: + def foo: Trait[T] + +inline trait B extends A[Int]: + override def foo = new Trait[Int] { + val x = new Trait2() {} + } + +@main def Test = + val b = new B() {} + val f = b.foo + f.do_something() diff --git a/tests/pos/inline-trait-y-equals-x-inlined-nowarn.scala b/tests/pos/inline-trait-y-equals-x-inlined-nowarn.scala new file mode 100644 index 000000000000..f0712d6518f6 --- /dev/null +++ b/tests/pos/inline-trait-y-equals-x-inlined-nowarn.scala @@ -0,0 +1,11 @@ +//> using options -Werror -Wsafe-init + +inline trait A(val x: Int): + val y = x // We need to be careful not to warn on this when we inline it but leave the body in the parent, because in the child the access is fine as we inline the parameter value, + // while the rhs of val y in the parent inline trait is going to be pruned out later so the illegal access won't be possible. +class C extends A(10) + +@main def Test = + val v = C() + println(v.y) + println(v.x) diff --git a/tests/pos/into-bigint.scala b/tests/pos/into-bigint.scala index 928cfb2261ac..b13f15b32a8d 100644 --- a/tests/pos/into-bigint.scala +++ b/tests/pos/into-bigint.scala @@ -1,4 +1,3 @@ -//> using options -preview import Conversion.into class BigInt(x: Int): @@ -19,4 +18,3 @@ object BigInt: val a2 = y * x // uses conversion on `y` val a3 = x * x val a4 = y + y - diff --git a/tests/pos/into-class.scala b/tests/pos/into-class.scala index 652b167000ae..0dbff7301c16 100644 --- a/tests/pos/into-class.scala +++ b/tests/pos/into-class.scala @@ -1,4 +1,3 @@ -//> using options -preview import Conversion.into class Text(str: String) diff --git a/tests/pos/into-expr.scala b/tests/pos/into-expr.scala index ecb057622f32..6529576d8e45 100644 --- a/tests/pos/into-expr.scala +++ b/tests/pos/into-expr.scala @@ -1,5 +1,5 @@ -//> using options -feature -Werror -preview +//> using options -feature -Werror import Conversion.into diff --git a/tests/pos/into-sam.scala b/tests/pos/into-sam.scala index c887a824f2b8..55b895c8088b 100644 --- a/tests/pos/into-sam.scala +++ b/tests/pos/into-sam.scala @@ -1,5 +1,5 @@ -//> using options -feature -Werror -preview +//> using options -feature -Werror import Conversion.into diff --git a/tests/pos/into-separate/Test_2.scala b/tests/pos/into-separate/Test_2.scala index 3b25fe907feb..f8dcadff8760 100644 --- a/tests/pos/into-separate/Test_2.scala +++ b/tests/pos/into-separate/Test_2.scala @@ -1,4 +1,4 @@ -//> using options -feature -preview +//> using options -feature package test object Test: @@ -11,5 +11,3 @@ object Test: val dclKeywords = Set[Keyword]("def", "val") // ok val keywords = dclKeywords + "if" + "then" + "else" // ok - - diff --git a/tests/pos/into-separate/classes_1.scala b/tests/pos/into-separate/classes_1.scala index 8d005234aa8e..0afb26d2b0cc 100644 --- a/tests/pos/into-separate/classes_1.scala +++ b/tests/pos/into-separate/classes_1.scala @@ -1,5 +1,3 @@ -//> using options -preview - package test into trait T diff --git a/tests/pos/java-annotated-wildcards/Nullable.java b/tests/pos/java-annotated-wildcards/Nullable.java new file mode 100644 index 000000000000..d0cf0816de91 --- /dev/null +++ b/tests/pos/java-annotated-wildcards/Nullable.java @@ -0,0 +1,5 @@ +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +@Target(ElementType.TYPE_USE) +public @interface Nullable {} diff --git a/tests/pos/java-annotated-wildcards/Test.java b/tests/pos/java-annotated-wildcards/Test.java new file mode 100644 index 000000000000..8a04d293675e --- /dev/null +++ b/tests/pos/java-annotated-wildcards/Test.java @@ -0,0 +1,5 @@ +import java.util.function.Function; + +public interface Test { + Function<@Nullable ? super String, @Nullable ? extends Object> mappingFunction(); +} diff --git a/tests/pos/packageObjectValues.scala b/tests/pos/packageObjectValues.scala index 7133c6a01471..db5d5175b381 100644 --- a/tests/pos/packageObjectValues.scala +++ b/tests/pos/packageObjectValues.scala @@ -1,4 +1,4 @@ -//> using options -language:experimental.packageObjectValues +//> using options -preview package object p { } diff --git a/tests/pos/pos_valueclasses/xlint1.flags b/tests/pos/pos_valueclasses/xlint1.flags index 7949c2afa212..00aabec7a65a 100644 --- a/tests/pos/pos_valueclasses/xlint1.flags +++ b/tests/pos/pos_valueclasses/xlint1.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings +-Wshadow -Xfatal-warnings diff --git a/tests/pos/private-class-in-trait.scala b/tests/pos/private-class-in-trait.scala new file mode 100644 index 000000000000..108abf4d3a9d --- /dev/null +++ b/tests/pos/private-class-in-trait.scala @@ -0,0 +1,12 @@ +trait T { + private val classValue = new PrivateClass + private val objectValue = PrivateObject + + private val classOption: Option[PrivateClass] = Some(new PrivateClass) + private val objectOption: Option[PrivateObject.type] = Some(PrivateObject) + + private class PrivateClass + private object PrivateObject +} + +object Test extends T diff --git a/tests/pos/seqliteral-union-singletons.scala b/tests/pos/seqliteral-union-singletons.scala new file mode 100644 index 000000000000..45d23624b6d7 --- /dev/null +++ b/tests/pos/seqliteral-union-singletons.scala @@ -0,0 +1,3 @@ +// Regression test for a crash in tpd.wrapArray when the SeqLiteral +// element type is a union of singleton primitive types (e.g. `1 | 2 | 3`). +def test: List[1 | 2 | 3] = List(1, 2, 3) diff --git a/tests/pos/source-import-3-10-migration.scala b/tests/pos/source-import-3-10-migration.scala new file mode 100644 index 000000000000..367b66822be8 --- /dev/null +++ b/tests/pos/source-import-3-10-migration.scala @@ -0,0 +1 @@ +import language.`3.10-migration` diff --git a/tests/pos/source-import-3-10.scala b/tests/pos/source-import-3-10.scala new file mode 100644 index 000000000000..03e5493f5239 --- /dev/null +++ b/tests/pos/source-import-3-10.scala @@ -0,0 +1 @@ +import language.`3.10` diff --git a/tests/pos/source-import-3-11-migration.scala b/tests/pos/source-import-3-11-migration.scala new file mode 100644 index 000000000000..02c93e5954b4 --- /dev/null +++ b/tests/pos/source-import-3-11-migration.scala @@ -0,0 +1 @@ +import language.`3.11-migration` diff --git a/tests/pos/source-import-3-11.scala b/tests/pos/source-import-3-11.scala new file mode 100644 index 000000000000..c1efbfbce5c7 --- /dev/null +++ b/tests/pos/source-import-3-11.scala @@ -0,0 +1 @@ +import language.`3.11` diff --git a/tests/pos/source-import-3-8-migration.scala b/tests/pos/source-import-3-8-migration.scala new file mode 100644 index 000000000000..693f8680f0f1 --- /dev/null +++ b/tests/pos/source-import-3-8-migration.scala @@ -0,0 +1 @@ +import language.`3.8-migration` diff --git a/tests/pos/source-import-3-8.scala b/tests/pos/source-import-3-8.scala new file mode 100644 index 000000000000..f01af0f243f4 --- /dev/null +++ b/tests/pos/source-import-3-8.scala @@ -0,0 +1 @@ +import language.`3.8` diff --git a/tests/pos/source-import-3-9-migration.scala b/tests/pos/source-import-3-9-migration.scala new file mode 100644 index 000000000000..6a9efb72c750 --- /dev/null +++ b/tests/pos/source-import-3-9-migration.scala @@ -0,0 +1 @@ +import language.`3.9-migration` diff --git a/tests/pos/source-import-3-9.scala b/tests/pos/source-import-3-9.scala new file mode 100644 index 000000000000..f9da68efc3af --- /dev/null +++ b/tests/pos/source-import-3-9.scala @@ -0,0 +1 @@ +import language.`3.9` diff --git a/tests/pos/specialized-trait-anonymous-class-as-param.scala b/tests/pos/specialized-trait-anonymous-class-as-param.scala new file mode 100644 index 000000000000..c0f7ce1ea8bc --- /dev/null +++ b/tests/pos/specialized-trait-anonymous-class-as-param.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits +inline trait Trait[T: Specialized](x: Any): + def do_something() = println("Good morning") + +trait Trait2 + +@main def Test = + val b = new Trait(new Trait2() {}) {} diff --git a/tests/pos/specialized-trait-body-macro/Macro_1.scala b/tests/pos/specialized-trait-body-macro/Macro_1.scala new file mode 100644 index 000000000000..9bc4f7301e70 --- /dev/null +++ b/tests/pos/specialized-trait-body-macro/Macro_1.scala @@ -0,0 +1,11 @@ +//> using options -language:experimental.specializedTraits +import scala.quoted.* + +inline def foo(): Int = + ${fooImpl} + +def fooImpl(using Quotes): Expr[Int] = + '{3} + +inline trait A[T: Specialized]: + val i: Int = foo() diff --git a/tests/pos/specialized-trait-body-macro/Test_2.scala b/tests/pos/specialized-trait-body-macro/Test_2.scala new file mode 100644 index 000000000000..ba4e4b643cf8 --- /dev/null +++ b/tests/pos/specialized-trait-body-macro/Test_2.scala @@ -0,0 +1,2 @@ +//> using options -language:experimental.specializedTraits +class B extends A[Int] \ No newline at end of file diff --git a/tests/pos/specialized-trait-class-extends-specialized-trait.scala b/tests/pos/specialized-trait-class-extends-specialized-trait.scala new file mode 100644 index 000000000000..f2ba081e5ecc --- /dev/null +++ b/tests/pos/specialized-trait-class-extends-specialized-trait.scala @@ -0,0 +1,12 @@ +//> using options -language:experimental.specializedTraits +inline trait Foo[T: Specialized](x: T): + def foo = x + +class Bar extends Foo(10): + def myMethod = "Hello I am a method" + +def f(b: Foo[Int]) = println(s"We found the following value of foo ${b.foo}") + +@main def main = + val x = Bar() + f(x) diff --git a/tests/pos/specialized-trait-exhaustivity-no-problem.scala b/tests/pos/specialized-trait-exhaustivity-no-problem.scala new file mode 100644 index 000000000000..6f244a31617a --- /dev/null +++ b/tests/pos/specialized-trait-exhaustivity-no-problem.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits -Werror + +sealed inline trait Foo[S: Specialized] +inline trait Bar extends Foo[Int] + +def doMatch(x: Foo[Int]) = x match { + case x: Bar => println("Hello World") +} diff --git a/tests/pos/specialized-trait-function-takes-specialized-trait.scala b/tests/pos/specialized-trait-function-takes-specialized-trait.scala new file mode 100644 index 000000000000..6cf930cf0134 --- /dev/null +++ b/tests/pos/specialized-trait-function-takes-specialized-trait.scala @@ -0,0 +1,14 @@ +//> using options -language:experimental.specializedTraits + +inline trait Container[T: Specialized](val elem: T) + +def apply(f: Container[Int] => Unit, v: Container[Int]) = + f(v) + +def f(e: Container[Int]) = + println(e.elem) + +@main def Test = + val v = new Container(10) {} + apply(f, v) + apply((e: Container[Int]) => println(e), v) diff --git a/tests/pos/specialized-trait-inline-anonymous-class-defn-nowarn.scala b/tests/pos/specialized-trait-inline-anonymous-class-defn-nowarn.scala new file mode 100644 index 000000000000..01ecce142333 --- /dev/null +++ b/tests/pos/specialized-trait-inline-anonymous-class-defn-nowarn.scala @@ -0,0 +1,7 @@ +//> using options -language:experimental.specializedTraits -Werror +inline trait T1[T: Specialized] +inline trait T2[T: Specialized, E] + +inline def foo[F: Specialized] = new T1[F]() {} // By default this warns Anonymous class will be defined at each use site, which may lead to a larger number of classfiles. This is not true for Specialized traits as we share the $impl$ class instances. + +inline def foo[F: Specialized, E] = new T2[F, E]() {} // This should also not warn even though E is not specialized diff --git a/tests/pos/specialized-trait-inline-def-specialized.scala b/tests/pos/specialized-trait-inline-def-specialized.scala new file mode 100644 index 000000000000..98332c74994e --- /dev/null +++ b/tests/pos/specialized-trait-inline-def-specialized.scala @@ -0,0 +1,9 @@ +//> using options -language:experimental.specializedTraits + +inline trait Vec[T: Specialized](val x: T) + +inline def foo[T: Specialized](v: Vec[T]) = v.x + +@main def Test = + val v = new Vec[Int](10) {} + println(foo(v)) diff --git a/tests/pos/specialized-trait-inlining-causes-implementation-required-loop-bad-manual-no-usage.scala b/tests/pos/specialized-trait-inlining-causes-implementation-required-loop-bad-manual-no-usage.scala new file mode 100644 index 000000000000..87948cffb8c9 --- /dev/null +++ b/tests/pos/specialized-trait-inlining-causes-implementation-required-loop-bad-manual-no-usage.scala @@ -0,0 +1,12 @@ +//> using options -language:experimental.specializedTraits + +// No usage of the spec traits so this is fine. + +inline trait C[S: Specialized]: + def v(x: S): S = x + def w: Unit = + class D extends C[S] + println("w") + +inline trait A[T: Specialized]: + def x(y: C[T]): Unit = println("x") diff --git a/tests/pos/specialized-trait-inlining-causes-implementation-required-loop-bad.scala b/tests/pos/specialized-trait-inlining-causes-implementation-required-loop-bad.scala new file mode 100644 index 000000000000..281c1beee93a --- /dev/null +++ b/tests/pos/specialized-trait-inlining-causes-implementation-required-loop-bad.scala @@ -0,0 +1,16 @@ +//> using options -language:experimental.specializedTraits + +// A[Char] => A$sp$Char => C$sp$Char, but only once we inline the body of C$sp$Char do we realise that we need +// C$impl$Char as well. + +inline trait C[S: Specialized]: + def v(x: S): S = x + def w: Unit = + val x = new C[S] {} // Actually ok because $impl$ classes are generated outside of the inline trait; class C$impl$Char will just create an instance of itself (this is allowed) + println("w") + +inline trait A[T: Specialized]: + def x(y: C[T]): Unit = println("x") + +def main = + val y = new A[Char] {} diff --git a/tests/pos/specialized-trait-inlining-causes-implementation-required-loop-without-implementation-fine.scala b/tests/pos/specialized-trait-inlining-causes-implementation-required-loop-without-implementation-fine.scala new file mode 100644 index 000000000000..61c4e83cba56 --- /dev/null +++ b/tests/pos/specialized-trait-inlining-causes-implementation-required-loop-without-implementation-fine.scala @@ -0,0 +1,15 @@ +//> using options -language:experimental.specializedTraits + +// This one is fine because we only ask for an $sp$ trait interface in C and not an $impl$ class + +inline trait C[S: Specialized]: + def v(x: S): S = x + def w: Unit = + class D extends C[S] + println("w") + +inline trait A[T: Specialized]: + def x(y: C[T]): Unit = println("x") + +def main = + val y = new A[Char] {} diff --git a/tests/pos/specialized-trait-inlining-causes-implementation-required.scala b/tests/pos/specialized-trait-inlining-causes-implementation-required.scala new file mode 100644 index 000000000000..01859563a2a3 --- /dev/null +++ b/tests/pos/specialized-trait-inlining-causes-implementation-required.scala @@ -0,0 +1,53 @@ +//> using options -language:experimental.specializedTraits + +// A[Char] => A$sp$Char, A$impl$Char => C$sp$Char, but only once we inline the body of C$sp$Char do we realise that we need +// B$impl$Char as well. + +// TODO: However, arguably we don't actually need B$impl$Char + +inline trait B[E: Specialized] + +inline trait C[S: Specialized]: + def v(x: S): S = x + def w: Unit = + val x = new B[S] {} + println("w") + +inline trait A[T: Specialized]: + def x(y: C[T]): Unit = println("x") + +def foo(x: B[Char]) = "A" + +def main = + val y = new A[Char] {} + +/* +inline trait B[E: Specialized] + +inline trait C[S: Specialized]: + def v(x: S): S + def w: Unit + +inline trait A[T: Specialized]: + def x(y: C[T]): Unit + +inline trait A$sp$Char: + def x(y: C$sp$Char): Unit + +class A$impl$Char: + def x(y: C$sp$Char): Unit = println("x") + +inline trait B$sp$Char + +class B$impl$Char + +inline trait C$sp$Char: + def v(x: Char): Char + def w: Unit + +def foo(x: B$sp$Char) = "A" + +def main = + val y = new A$impl$Char() {} + +*/ diff --git a/tests/pos/specialized-trait-inlining-causes-specialization.scala b/tests/pos/specialized-trait-inlining-causes-specialization.scala new file mode 100644 index 000000000000..d99267f5b9fa --- /dev/null +++ b/tests/pos/specialized-trait-inlining-causes-specialization.scala @@ -0,0 +1,12 @@ +//> using options -language:experimental.specializedTraits + +inline trait D[R: Specialized] + +inline trait C[S: Specialized]: + def w(y: D[S]): Unit = println("w") + +inline trait A[T: Specialized]: + def x(y: C[T]): Unit = println("x") + +def main = + val b = new A[Char] {} diff --git a/tests/pos/specialized-trait-multiple-stages-specialized-numeric.scala b/tests/pos/specialized-trait-multiple-stages-specialized-numeric.scala new file mode 100644 index 000000000000..40211f2b8729 --- /dev/null +++ b/tests/pos/specialized-trait-multiple-stages-specialized-numeric.scala @@ -0,0 +1,22 @@ +//> using options -language:experimental.specializedTraits +// This shouldn't generate any boxing thanks to the specialized version of Numeric + +inline def foo[T: {Specialized, Numeric2}](x: T): T = + val num = summon[Numeric2[T]] + num.plus(x, num.fromInt(1)) + +inline trait A[T: {Numeric2, Specialized}]: + def bar(x: T): T = foo(x) + +class B extends A[Int]: + def baz(x: Int): Int = foo(x) + +inline trait Numeric2[T: Specialized]: + def fromInt(x: Int): T + def plus(x: T, y: T): T + def times(x: T, y: T): T + +implicit object IntIsIntegral extends Numeric2[Int]: + override def fromInt(x: Int): Int = x + override def plus(x: Int, y: Int): Int = x + y + override def times(x: Int, y: Int): Int = x * y diff --git a/tests/pos/specialized-trait-object-extends-specialized-trait.scala b/tests/pos/specialized-trait-object-extends-specialized-trait.scala new file mode 100644 index 000000000000..0ba1fa4a42e8 --- /dev/null +++ b/tests/pos/specialized-trait-object-extends-specialized-trait.scala @@ -0,0 +1,9 @@ +//> using options -language:experimental.specializedTraits + +inline trait MyInterface[T: Specialized]: + def fromInt(x: Int): T + def plus(x: T, y: T): T + +implicit object Implementation extends MyInterface[Int]: + override def fromInt(x: Int): Int = x + override def plus(x: Int, y: Int): Int = x + y diff --git a/tests/pos/specialized-trait-opaque-type.scala b/tests/pos/specialized-trait-opaque-type.scala new file mode 100644 index 000000000000..d82ec5e1aebd --- /dev/null +++ b/tests/pos/specialized-trait-opaque-type.scala @@ -0,0 +1,13 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T](val x: T): + opaque type Special = T + + def getSpecial: Special = x + def eatSpecial(y: Special) = "Mmm, that was tasty!" + +class B extends A[Int](100) + +def foo = + val b = B() + println(b.eatSpecial(b.getSpecial)) diff --git a/tests/pos/specialized-trait-original-diamond.scala b/tests/pos/specialized-trait-original-diamond.scala new file mode 100644 index 000000000000..525f338ffe2f --- /dev/null +++ b/tests/pos/specialized-trait-original-diamond.scala @@ -0,0 +1,9 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T: Specialized]: + def foo = 10 + +inline trait B extends A[Int] +inline trait C extends A[Int] + +class Bar extends B with C diff --git a/tests/pos/specialized-trait-parameter-passing-as-named.scala b/tests/pos/specialized-trait-parameter-passing-as-named.scala new file mode 100644 index 000000000000..ac9cd596069b --- /dev/null +++ b/tests/pos/specialized-trait-parameter-passing-as-named.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits +inline trait A[T: Specialized](parameter: Int): + val x = parameter + +def main = + val y = new A[Int](parameter = 1000) {} diff --git a/tests/pos/specialized-trait-partial-complete-specialization-with-return-type.scala b/tests/pos/specialized-trait-partial-complete-specialization-with-return-type.scala new file mode 100644 index 000000000000..f2d1d71c051b --- /dev/null +++ b/tests/pos/specialized-trait-partial-complete-specialization-with-return-type.scala @@ -0,0 +1,14 @@ +//> using options -language:experimental.specializedTraits +inline trait Trait[T: Specialized]: + def do_something() = println("Good morning") + +inline trait A[T: Specialized]: + def foo: Trait[T] + +inline trait B extends A[Int]: + override def foo = new Trait[Int] {} + +@main def Test = + val b = new B() {} + val f = b.foo + f.do_something() diff --git a/tests/pos/specialized-trait-partial-specialization-self-type.scala b/tests/pos/specialized-trait-partial-specialization-self-type.scala new file mode 100644 index 000000000000..2c7ddeb66579 --- /dev/null +++ b/tests/pos/specialized-trait-partial-specialization-self-type.scala @@ -0,0 +1,16 @@ +//> using options -language:experimental.specializedTraits + +trait T1 +trait T2 +trait T3 +trait Test1 +trait Test2 + +inline trait A[T: Specialized, S: Specialized, Z]: + this: T1 & T & S => + +inline trait B[W: Specialized] extends A[W, Test2, Int]: + this: T1 & W & Test2 => + +class Cl2 extends B[Test1] with Test1 with Test2 with T1 + diff --git a/tests/pos/specialized-trait-partial-specialization.scala b/tests/pos/specialized-trait-partial-specialization.scala new file mode 100644 index 000000000000..7faa5eaa345a --- /dev/null +++ b/tests/pos/specialized-trait-partial-specialization.scala @@ -0,0 +1,7 @@ +//> using options -language:experimental.specializedTraits + +inline trait Map[K: Specialized, V: Specialized] +inline trait MapFromInt[V: Specialized] extends Map[Int, V] +inline trait MapToInt[K: Specialized] extends Map[K, Int] +inline trait MapIntInt1 extends MapFromInt[Int] +inline trait MapIntInt2 extends MapToInt[Int] diff --git a/tests/pos/specialized-trait-processing-order-matters.scala b/tests/pos/specialized-trait-processing-order-matters.scala new file mode 100644 index 000000000000..132652152c7e --- /dev/null +++ b/tests/pos/specialized-trait-processing-order-matters.scala @@ -0,0 +1,16 @@ +//> using options -language:experimental.specializedTraits + +// It's important to update the symbol infos for methods whose type interface changes due to specialization +// before we update any code that uses these symbols so that we type their uses' Apply nodes correctly. +// This only becomes clear when the user is in another object (and not a top-level main method) +// because otherwise the processing follows source code ordering. + +inline trait Trait[T: Specialized]: + def bar = "bar" + +def foo(v: Trait[Int]) = v + +object Test: + def main(args: Array[String]): Unit = + val a = new Trait[Int] {} + foo(a).bar diff --git a/tests/pos/specialized-trait-question-mark-non-specialized-allowed.scala b/tests/pos/specialized-trait-question-mark-non-specialized-allowed.scala new file mode 100644 index 000000000000..74aadecea4e4 --- /dev/null +++ b/tests/pos/specialized-trait-question-mark-non-specialized-allowed.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits +inline trait T3[T: Specialized, E, F: Numeric] +def foo(v: T3[Int, ?, ?]) = + println("HELLO") + +def main = + val x = new T3[Int, String, Float] {} + foo(x) diff --git a/tests/pos/specialized-trait-self-as-param.scala b/tests/pos/specialized-trait-self-as-param.scala new file mode 100644 index 000000000000..2dce27ad5c53 --- /dev/null +++ b/tests/pos/specialized-trait-self-as-param.scala @@ -0,0 +1,10 @@ +//> using options -language:experimental.specializedTraits +inline trait Trait[T: Specialized](x: Trait[T] | Int): + def do_something(): Unit = + assert(Thread.currentThread.getStackTrace()(1).getClassName().contains("$impl$")) + if x.isInstanceOf[Trait[T]] then + x.asInstanceOf[Trait[T]].do_something() + +@main def Test = + val b = new Trait(new Trait(10) {}) {} + b.do_something() diff --git a/tests/pos/specialized-trait-self-type.scala b/tests/pos/specialized-trait-self-type.scala new file mode 100644 index 000000000000..4fc2105626ac --- /dev/null +++ b/tests/pos/specialized-trait-self-type.scala @@ -0,0 +1,28 @@ +//> using options -language:experimental.specializedTraits + +trait T1 +trait T2 +trait T3 +class Test + +inline trait A[T: Specialized]: + this: T1 => + +inline trait D extends A[Int]: + this: T1 => +inline trait E extends D: + this: T1 => + +inline trait B[T: Specialized]: + this: T2 & T1 => + +inline trait F extends A[Int], B[Int]: + this: T2 & T1 => + +inline trait C[T: Specialized]: + this: T => + +inline trait H extends C[Test]: + this: T3 & Test => + +class Cl2 extends Test with H with T3 diff --git a/tests/pos/specialized-trait-simplest-implicit-type-name.scala b/tests/pos/specialized-trait-simplest-implicit-type-name.scala new file mode 100644 index 000000000000..39ca98b6456f --- /dev/null +++ b/tests/pos/specialized-trait-simplest-implicit-type-name.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits + +inline trait Foo[T: Specialized](val x: T) +inline trait Bar[T: Specialized] + +@main def main = + val x = new Foo(10) {} // Type name not provided explicitly; this should still be specialized to Int. + val y = new Bar() {} // This will be specialized to Nothing. diff --git a/tests/pos/specialized-trait-simplest.scala b/tests/pos/specialized-trait-simplest.scala new file mode 100644 index 000000000000..7c230c58c2bd --- /dev/null +++ b/tests/pos/specialized-trait-simplest.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits + +inline trait Foo[T: Specialized] + +@main def main = + val x = new Foo[Int] {} diff --git a/tests/pos/specialized-trait-specialized-context-bound.scala b/tests/pos/specialized-trait-specialized-context-bound.scala new file mode 100644 index 000000000000..fb2022eaee63 --- /dev/null +++ b/tests/pos/specialized-trait-specialized-context-bound.scala @@ -0,0 +1,11 @@ +//> using options -language:experimental.specializedTraits + +inline trait Numeric2[T: Specialized] + +inline trait A[T: {Numeric2, Specialized}]: + def bar(x: T): T = x + +given Numeric2[Int] = new Numeric2[Int] {} + +class B extends A[Int]: + def baz(x: Int): Int = x diff --git a/tests/pos/specialized-trait-supercall-non-overridden.scala b/tests/pos/specialized-trait-supercall-non-overridden.scala new file mode 100644 index 000000000000..d4f8a9c46c5c --- /dev/null +++ b/tests/pos/specialized-trait-supercall-non-overridden.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits +inline trait A[T: Specialized]: + def foo = 10 + +inline trait B extends A[Int]: + def bar = super.foo diff --git a/tests/pos/specialized-trait-val-parameter.scala b/tests/pos/specialized-trait-val-parameter.scala new file mode 100644 index 000000000000..403561ec0794 --- /dev/null +++ b/tests/pos/specialized-trait-val-parameter.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits + +inline trait Vec[T: Specialized](val x: T) + +def main = + val v = new Vec[Int](10) {} diff --git a/tests/pos/specialized-trait-var-parameter.scala b/tests/pos/specialized-trait-var-parameter.scala new file mode 100644 index 000000000000..31207dd8d58e --- /dev/null +++ b/tests/pos/specialized-trait-var-parameter.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits + +inline trait Vec[T: Specialized](var x: T) + +def main = + val v = new Vec[Int](10) {} diff --git a/tests/pos/specialized-trait-very-specialized-list.scala b/tests/pos/specialized-trait-very-specialized-list.scala new file mode 100644 index 000000000000..7bef9c3786a0 --- /dev/null +++ b/tests/pos/specialized-trait-very-specialized-list.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits +inline trait Foo[T: Specialized] + +abstract class VerySpecializedList extends Seq[Foo[Int]] + +def main = + val x: VerySpecializedList = null + val y: Foo[Int] = x(1) diff --git a/tests/pos/specialized-trait-with-param.scala b/tests/pos/specialized-trait-with-param.scala new file mode 100644 index 000000000000..aa9cba4bf7c3 --- /dev/null +++ b/tests/pos/specialized-trait-with-param.scala @@ -0,0 +1,10 @@ +//> using options -language:experimental.specializedTraits + +inline trait Foo[T: Specialized](x: T): + def foo = x + +def f(b: Foo[Int]) = 37 + b.foo + +@main def main = + val x = new Foo[Int](42) {} + f(x) diff --git a/tests/pos/t6675.scala b/tests/pos/t6675.scala index f3bebea5be94..4e21428afa0a 100644 --- a/tests/pos/t6675.scala +++ b/tests/pos/t6675.scala @@ -7,14 +7,14 @@ object LeftOrRight { object Test { (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { - case LeftOrRight(pair @ (a, b)) => a // false -Xlint warning: "extractor pattern binds a single value to a Product2 of type (Int, Int)" + case LeftOrRight(pair @ (a, b)) => a // false -Wshadow warning: "extractor pattern binds a single value to a Product2 of type (Int, Int)" } (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { - case LeftOrRight((a, b)) => a // false -Xlint warning: "extractor pattern binds a single value to a Product2 of type (Int, Int)" + case LeftOrRight((a, b)) => a // false -Wshadow warning: "extractor pattern binds a single value to a Product2 of type (Int, Int)" } (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { - case LeftOrRight(a, b) => a // false -Xlint warning: "extractor pattern binds a single value to a Product2 of type (Int, Int)" + case LeftOrRight(a, b) => a // false -Wshadow warning: "extractor pattern binds a single value to a Product2 of type (Int, Int)" } } diff --git a/tests/pos/trait-extends-inline-trait.scala b/tests/pos/trait-extends-inline-trait.scala new file mode 100644 index 000000000000..8aa4040aadc4 --- /dev/null +++ b/tests/pos/trait-extends-inline-trait.scala @@ -0,0 +1,3 @@ +inline trait A: + def x = 1 +trait B extends A // This is fine as long as A has no parameters. diff --git a/tests/printing/transformed/lazy-vals-legacy.check b/tests/printing/transformed/lazy-vals-legacy.check index 61879ac3a1f2..76a7dc3863c2 100644 --- a/tests/printing/transformed/lazy-vals-legacy.check +++ b/tests/printing/transformed/lazy-vals-legacy.check @@ -1,4 +1,4 @@ -[[syntax trees at end of MegaPhase{dropOuterAccessors, dropParentRefinements, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-legacy.scala +[[syntax trees at end of MegaPhase{dropOuterAccessors, dropParentRefinements, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-legacy.scala package { @SourceFile("tests/printing/transformed/lazy-vals-legacy.scala") final module class A extends Object { diff --git a/tests/printing/transformed/lazy-vals-new.check b/tests/printing/transformed/lazy-vals-new.check index 8ded581dbce2..01be05c1889c 100644 --- a/tests/printing/transformed/lazy-vals-new.check +++ b/tests/printing/transformed/lazy-vals-new.check @@ -1,4 +1,4 @@ -[[syntax trees at end of MegaPhase{dropOuterAccessors, dropParentRefinements, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-new.scala +[[syntax trees at end of MegaPhase{dropOuterAccessors, dropParentRefinements, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-new.scala package { @SourceFile("tests/printing/transformed/lazy-vals-new.scala") final module class A extends Object { @@ -19,7 +19,7 @@ package { classOf[Object {...}], "x$lzy1", classOf[Object]) private def writeReplace(): Object = new scala.runtime.ModuleSerializationProxy(classOf[A]) - @volatile private lazy var x$lzy1: Object = null + @volatile private lazy var x$lzy1: Object = null.asInstanceOf[Object] lazy def x(): Int = { val result: Object = A.x$lzy1 diff --git a/tests/rewrites/i18234.check b/tests/rewrites/i18234.check new file mode 100644 index 000000000000..39f120a101e0 --- /dev/null +++ b/tests/rewrites/i18234.check @@ -0,0 +1,166 @@ +//> using options -source:3.9-migration +/* vals */ +val goodVal = 1 +val `$startVal` = 1 // error +val `mid$dleVal` = 1 // error +val `endVal$` = 1 // error + +def testValUsage = + $startVal + endVal$ // ok, should only warn on declaration not on usage + +/* functions */ +def `$funcStart`() = 3 // error +def `func$Middle`() = 3 // error +def `funcEnd$`() = 3 // error + +def func1badArg(goodArg: Int, `bad$Arg`: Int) = 5 // error +def func1badArgAndUsageDoesNotThrowWarning(goodArg: Int, `bad$Arg`: Int) = bad$Arg // error +def func2badArgs(goodArg: Int, `bad$Arg`: Int, `bad$arg2`: String) = 5 // error // error +def multilineFunc( + goodArg: Int, + `badAr$g`: Int // error +) = 1 + +def testFuncUsaage = + $funcStart() + func1badArg(1, 2) // ok, should only warn on declaration not on usage + +/* types */ +type GoodType = Int +type `$StartType` = Int // error +type `Middle$Type` = Int // error +type `EndType$` = Int // error + +val typedVal: Middle$Type = 2 // ok, should only warn on declaration not on usage +def funcWithDollarTypes(foo: $StartType): Middle$Type = 2 // ok, should only warn on declaration not on usage + +/* enums */ +enum GoodEnum: + case GoodCase + case `$BadCaseStart` // error + case `BadCase$Middle` // error + case `BadCaseEnd$` // error + +enum `$BadEnumStart`: // error + case GoodCase + case `$BadCase` // error + +enum `BadEnum$Middle`: // error + case GoodCase + case `Bad$Case` // error + +enum `BadEnumEnd$`: // error + case GoodCase + case `BadCase$` // error + +enum `E$numWithEndKeyword`: // error + case SomeCase +end E$numWithEndKeyword // ok + +def TestEnumUsage(a: $BadEnumStart): Int = // ok, should only warn on declaration not on usage + a match + case $BadEnumStart.GoodCase => 1 + case $BadEnumStart.$BadCase => 2 // ok, should only warn on declaration not on usage + +/* objects */ +object `$ObjectStart`: // error + val goodVal = 1 + val `$badVal` = 2 // error + +object `Object$Middle`: // error + val goodVal = 1 + val `bad$Val` = 2 // error + +object `ObjectEnd$`: // error + val goodVal = 1 + val `badVal$` = 2 // error + +object GoodObject: + val goodVal = 1 + val `b$adVal` = 2 // error + +object `Ob$jectWithEndKeyword`: // error + val someVal = 1 +end Ob$jectWithEndKeyword // ok + +val testObjectUsage = ObjectEnd$.badVal$ // ok, should only warn on declaration not on usage + +/* case classes */ +case class `$InlineCaseClassStart`(someField: Int) // error +case class `InlineCaseClass$Middle`(someField: Int) // error +case class `InlineCaseClassEnd$`(someField: Int) // error + +case class InlineCaseClass(goodField: Int, `badFiel$d`: Int) // error + +case class `$CaseClassStart`( // error + somefield: Int, + `b$adfield`: Int // error +) + +case class `CaseClass$Middle`( // error + somefield: Int, + `bad$Field`: Int // error +) + +case class `CaseClassEnd$`( // error + somefield: Int, + `badField$`: Int // error +) + +// companion object +object `CaseClassEnd$`: // error + val food = 1 + +val testCaseClassUsage = CaseClass$Middle(somefield = 1, bad$Field = 2) // ok, should only warn on declaration not on usage + +/* classes */ +class GoodClass +class `$StartClass` // error +class `Middle$Class` // error +class `EndClass$` // error + +class `Cla$$`( // error + var goodMember: Int, + var `badM$ember`: Int // error +): + def goodMethod(x: Int) = badM$ember // ok, only checking if the method name does not contain a dollar sign + def `bad$Method`(y: Int) = goodMember // error + def methodWithBadArgNames(`b$ad$arg`: Int) = goodMember // error + def `method$WithEndKeyword`() = // error + 3 + end method$WithEndKeyword +end Cla$$ // ok + +def testUsage = + val instantiation = new Cla$$(goodMember = 1, badM$ember = 2) // ok, should only warn on declaration not on usage + instantiation.bad$Method(1) // ok, should only warn on declaration not on usage + instantiation.methodWithBadArgNames(2) // ok, should only warn on declaration not on usage + + +/* traits */ +trait GoodTrait +trait `$BadTraitStart` // error +trait `BadTrait$Middle` // error +trait `BadTraitEnd$` // error + +class TestTraitUsage extends $BadTraitStart // ok, should only warn on declaration not on usage + +package GoodPackage: + val goodVal = 1 + val `b$adVal` = 2 // error + +package `$BadPackageStart`: // error + val goodVal = 1 + val `$badVal` = 2 // error + +package `BadPackage$Middle`: // error + val goodVal = 1 + val `bad$Val` = 2 // error + +package `BadPackageEnd$` : // error + val goodVal = 1 + val `badVal$` = 2 // error + +def patvar[A](x: Option[A]) = + x match + case Some(funky$thing) => true // error + case _ => false diff --git a/tests/rewrites/i18234.scala b/tests/rewrites/i18234.scala new file mode 100755 index 000000000000..fa8e1cf3bd1f --- /dev/null +++ b/tests/rewrites/i18234.scala @@ -0,0 +1,166 @@ +//> using options -source:3.9-migration +/* vals */ +val goodVal = 1 +val $startVal = 1 // error +val mid$dleVal = 1 // error +val endVal$ = 1 // error + +def testValUsage = + $startVal + endVal$ // ok, should only warn on declaration not on usage + +/* functions */ +def $funcStart() = 3 // error +def func$Middle() = 3 // error +def funcEnd$() = 3 // error + +def func1badArg(goodArg: Int, bad$Arg: Int) = 5 // error +def func1badArgAndUsageDoesNotThrowWarning(goodArg: Int, bad$Arg: Int) = bad$Arg // error +def func2badArgs(goodArg: Int, bad$Arg: Int, bad$arg2: String) = 5 // error // error +def multilineFunc( + goodArg: Int, + badAr$g: Int // error +) = 1 + +def testFuncUsaage = + $funcStart() + func1badArg(1, 2) // ok, should only warn on declaration not on usage + +/* types */ +type GoodType = Int +type $StartType = Int // error +type Middle$Type = Int // error +type EndType$ = Int // error + +val typedVal: Middle$Type = 2 // ok, should only warn on declaration not on usage +def funcWithDollarTypes(foo: $StartType): Middle$Type = 2 // ok, should only warn on declaration not on usage + +/* enums */ +enum GoodEnum: + case GoodCase + case $BadCaseStart // error + case BadCase$Middle // error + case BadCaseEnd$ // error + +enum $BadEnumStart: // error + case GoodCase + case $BadCase // error + +enum BadEnum$Middle: // error + case GoodCase + case Bad$Case // error + +enum BadEnumEnd$: // error + case GoodCase + case BadCase$ // error + +enum E$numWithEndKeyword: // error + case SomeCase +end E$numWithEndKeyword // ok + +def TestEnumUsage(a: $BadEnumStart): Int = // ok, should only warn on declaration not on usage + a match + case $BadEnumStart.GoodCase => 1 + case $BadEnumStart.$BadCase => 2 // ok, should only warn on declaration not on usage + +/* objects */ +object $ObjectStart: // error + val goodVal = 1 + val $badVal = 2 // error + +object Object$Middle: // error + val goodVal = 1 + val bad$Val = 2 // error + +object ObjectEnd$: // error + val goodVal = 1 + val badVal$ = 2 // error + +object GoodObject: + val goodVal = 1 + val b$adVal = 2 // error + +object Ob$jectWithEndKeyword: // error + val someVal = 1 +end Ob$jectWithEndKeyword // ok + +val testObjectUsage = ObjectEnd$.badVal$ // ok, should only warn on declaration not on usage + +/* case classes */ +case class $InlineCaseClassStart(someField: Int) // error +case class InlineCaseClass$Middle(someField: Int) // error +case class InlineCaseClassEnd$(someField: Int) // error + +case class InlineCaseClass(goodField: Int, badFiel$d: Int) // error + +case class $CaseClassStart( // error + somefield: Int, + b$adfield: Int // error +) + +case class CaseClass$Middle( // error + somefield: Int, + bad$Field: Int // error +) + +case class CaseClassEnd$( // error + somefield: Int, + badField$: Int // error +) + +// companion object +object CaseClassEnd$: // error + val food = 1 + +val testCaseClassUsage = CaseClass$Middle(somefield = 1, bad$Field = 2) // ok, should only warn on declaration not on usage + +/* classes */ +class GoodClass +class $StartClass // error +class Middle$Class // error +class EndClass$ // error + +class Cla$$( // error + var goodMember: Int, + var badM$ember: Int // error +): + def goodMethod(x: Int) = badM$ember // ok, only checking if the method name does not contain a dollar sign + def bad$Method(y: Int) = goodMember // error + def methodWithBadArgNames(b$ad$arg: Int) = goodMember // error + def method$WithEndKeyword() = // error + 3 + end method$WithEndKeyword +end Cla$$ // ok + +def testUsage = + val instantiation = new Cla$$(goodMember = 1, badM$ember = 2) // ok, should only warn on declaration not on usage + instantiation.bad$Method(1) // ok, should only warn on declaration not on usage + instantiation.methodWithBadArgNames(2) // ok, should only warn on declaration not on usage + + +/* traits */ +trait GoodTrait +trait $BadTraitStart // error +trait BadTrait$Middle // error +trait BadTraitEnd$ // error + +class TestTraitUsage extends $BadTraitStart // ok, should only warn on declaration not on usage + +package GoodPackage: + val goodVal = 1 + val b$adVal = 2 // error + +package $BadPackageStart: // error + val goodVal = 1 + val $badVal = 2 // error + +package BadPackage$Middle: // error + val goodVal = 1 + val bad$Val = 2 // error + +package BadPackageEnd$ : // error + val goodVal = 1 + val badVal$ = 2 // error + +def patvar[A](x: Option[A]) = + x match + case Some(funky$thing) => true // error + case _ => false diff --git a/tests/rewrites/unary-minus.check b/tests/rewrites/unary-minus.check new file mode 100644 index 000000000000..4918c41d9b20 --- /dev/null +++ b/tests/rewrites/unary-minus.check @@ -0,0 +1,8 @@ + +import util.chaining.* + +def f = -42 +def g = (-42).abs +def h = (-42).abs +def i = (-42) + .pipe(_.abs) diff --git a/tests/rewrites/unary-minus.scala b/tests/rewrites/unary-minus.scala new file mode 100644 index 000000000000..249e590bb850 --- /dev/null +++ b/tests/rewrites/unary-minus.scala @@ -0,0 +1,8 @@ + +import util.chaining.* + +def f = - 42 +def g = -42.abs +def h = - 42.abs +def i = - 42 + .pipe(_.abs) diff --git a/tests/run-macros/tasty-create-method-symbol/Macro_1.scala b/tests/run-macros/tasty-create-method-symbol/Macro_1.scala index b5953e55402b..fd524b25c7d5 100644 --- a/tests/run-macros/tasty-create-method-symbol/Macro_1.scala +++ b/tests/run-macros/tasty-create-method-symbol/Macro_1.scala @@ -94,7 +94,7 @@ object Macros { Some { val sym51 : Symbol = Symbol.newMethod( sym5, - "sym51", + "$anonfun$sym51", MethodType(List("x"))( _ => List(TypeRepr.of[Int]), _ => TypeRepr.of[Int])) diff --git a/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala b/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala index 6be6a35662fd..810b6935faad 100644 --- a/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala +++ b/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala @@ -100,9 +100,6 @@ val experimentalDefinitionInLibrary = Set( // Need quotedPatternsWithPolymorphicFunctions enabled. "scala.quoted.runtime.Patterns$.higherOrderHoleWithTypes", - // New feature: SIP 61 - @unroll annotation - "scala.annotation.unroll", - // New feature: Erased trait "scala.compiletime.Erased", ) diff --git a/tests/run-tasty-inspector/tastyPaths.scala b/tests/run-tasty-inspector/tastyPaths.scala index b20831d5ad50..cbaddd669948 100644 --- a/tests/run-tasty-inspector/tastyPaths.scala +++ b/tests/run-tasty-inspector/tastyPaths.scala @@ -1,7 +1,10 @@ import scala.quoted.* import scala.tasty.inspector.* -import java.io.File.separatorChar +import java.io.File.{pathSeparator, separatorChar} + +import dotty.tools.dotc.util.ClasspathFromClassloader +import dotty.tools.io.{FileExtension, Path} opaque type PhoneNumber = String @@ -14,8 +17,12 @@ object Test { def main(args: Array[String]): Unit = { // Artefact of the current test infrastructure // TODO improve infrastructure to avoid needing this code on each test - val classpath = dotty.tools.dotc.util.ClasspathFromClassloader(this.getClass.getClassLoader).split(java.io.File.pathSeparator).find(_.contains("runWithCompiler")).get - val allTastyFiles = dotty.tools.io.Path(classpath).walkFilter(_.ext == dotty.tools.io.FileExtension.Tasty).map(_.toString).toList + val classpath = + ClasspathFromClassloader(getClass.getClassLoader) + .split(pathSeparator) + .find(_.contains("runWithCompiler")) + .get + val allTastyFiles = Path(classpath).walkFilter(_.ext == FileExtension.Tasty).map(_.toString).toList val tastyFiles = allTastyFiles.filter(_.contains("I8163")) TastyInspector.inspectTastyFiles(tastyFiles)(new TestInspector()) @@ -30,4 +37,4 @@ class TestInspector() extends Inspector: quotes.reflect.SourceFile.current assert(false) catch case ex: java.lang.UnsupportedOperationException => - println(ex.getMessage) // ok \ No newline at end of file + println(ex.getMessage) // ok diff --git a/tests/run/10838/Test.scala b/tests/run/10838/Test.scala index 581250c44e2c..ebcf8298faf2 100644 --- a/tests/run/10838/Test.scala +++ b/tests/run/10838/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { val a = new A diff --git a/tests/run/1938.scala b/tests/run/1938.scala index 95e94678d988..24986f5b3268 100644 --- a/tests/run/1938.scala +++ b/tests/run/1938.scala @@ -39,7 +39,8 @@ object Test { l.productElement(23) ??? } catch { - case e: IndexOutOfBoundsException => assert(e.getMessage == "23") + case e: IndexOutOfBoundsException => assert(e.getMessage.contains("23")) + case _ => assert(false) } } } diff --git a/tests/run/25-1/Test.java b/tests/run/25-1/Test.java index df8319fd97d5..8eeeaa258455 100644 --- a/tests/run/25-1/Test.java +++ b/tests/run/25-1/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public class Test { public static void main(String[] args) { p.StringSearch.search("test"); diff --git a/tests/run/25-2/Test.java b/tests/run/25-2/Test.java index d4f260b74c0b..38911374b69c 100644 --- a/tests/run/25-2/Test.java +++ b/tests/run/25-2/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public class Test { public static void main(String[] args) { p.Bar.f(""); diff --git a/tests/run/25333/Macro.scala b/tests/run/25333/Macro.scala new file mode 100644 index 000000000000..26286cc82c5c --- /dev/null +++ b/tests/run/25333/Macro.scala @@ -0,0 +1,15 @@ +package vendor + +import scala.quoted.* + +trait Callback: + def run(): Any + +object Macro: + inline def make: Callback = ${makeImpl} + + def makeImpl(using Quotes): Expr[Callback] = '{ + new Callback: + class Worker // inner class inside quote — position from macro JAR → NoSource + def run(): Any = new Worker + } diff --git a/tests/run/25333/Main.scala b/tests/run/25333/Main.scala new file mode 100644 index 000000000000..872a83369763 --- /dev/null +++ b/tests/run/25333/Main.scala @@ -0,0 +1,2 @@ +object Test: + def main(args: Array[String]): Unit = println(vendor.Macro.make.run()) diff --git a/tests/run/26071.scala b/tests/run/26071.scala new file mode 100644 index 000000000000..f56e75f7f54f --- /dev/null +++ b/tests/run/26071.scala @@ -0,0 +1,10 @@ +abstract class OutPort { self: Outlet => + override def hashCode: Int = super.hashCode +} + +class Outlet extends OutPort + +object Test: + def main(args: Array[String]): Unit = + val myPort = Outlet() + println(myPort.hashCode) diff --git a/tests/run/Parser.scala b/tests/run/Parser.scala index e6e5c7556569..64fceb58d049 100644 --- a/tests/run/Parser.scala +++ b/tests/run/Parser.scala @@ -1,4 +1,3 @@ -//> using options -preview import Conversion.into type Input = List[String] diff --git a/tests/run/annotation-info-not-erased/Test.scala b/tests/run/annotation-info-not-erased/Test.scala index 0320458bc128..6e18fdc44137 100644 --- a/tests/run/annotation-info-not-erased/Test.scala +++ b/tests/run/annotation-info-not-erased/Test.scala @@ -1,4 +1,3 @@ -// scalajs: --skip import scala.annotation.meta.getter class C { diff --git a/tests/run/arrays-from-java/Test_2.scala b/tests/run/arrays-from-java/Test_2.scala index 92747f471469..c906f4fc0e8e 100644 --- a/tests/run/arrays-from-java/Test_2.scala +++ b/tests/run/arrays-from-java/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = C_2.test() diff --git a/tests/run/beans/Test_4.scala b/tests/run/beans/Test_4.scala index 640bb6ad7b82..4307b8454fc4 100644 --- a/tests/run/beans/Test_4.scala +++ b/tests/run/beans/Test_4.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test: def main(args: Array[String]) = val a = JavaTest().run() diff --git a/tests/run/block-field.check b/tests/run/block-field.check new file mode 100644 index 000000000000..4aeda1fdd2f7 --- /dev/null +++ b/tests/run/block-field.check @@ -0,0 +1,4 @@ +nested +42 +m +1 diff --git a/tests/run/block-field.scala b/tests/run/block-field.scala new file mode 100644 index 000000000000..a8a01f16b8e9 --- /dev/null +++ b/tests/run/block-field.scala @@ -0,0 +1,11 @@ +case class C(i: Int) + +class M: + var i: Int = 0 + +object Test: + def main(args: Array[String]): Unit = + println({ val c = C(42); println("nested"); c}.i) + val m = M() + { println("m"); m }.i = 1 + println(m.i) diff --git a/tests/run/complex-outer/Defs_1.scala b/tests/run/complex-outer/Defs_1.scala new file mode 100644 index 000000000000..7560825cc23c --- /dev/null +++ b/tests/run/complex-outer/Defs_1.scala @@ -0,0 +1,5 @@ +object Outer: + class Foo[T1]: + class A[T2] + object B + diff --git a/tests/run/complex-outer/Main_3.scala b/tests/run/complex-outer/Main_3.scala new file mode 100644 index 000000000000..268f09abca5d --- /dev/null +++ b/tests/run/complex-outer/Main_3.scala @@ -0,0 +1,5 @@ +object Test: + def main(args: Array[String]) = + assert(Use_2.testA() != null) + assert(Use_2.testB() != null) + diff --git a/tests/run/complex-outer/Use_2.java b/tests/run/complex-outer/Use_2.java new file mode 100644 index 000000000000..2b3da33c7ccb --- /dev/null +++ b/tests/run/complex-outer/Use_2.java @@ -0,0 +1,10 @@ +class Use_2 { + static Object testA() { + var foo = new Outer.Foo(); + return foo.new A(); + } + + static Object testB() { + return new Outer.Foo.B$(); + } +} diff --git a/tests/run/convertible.scala b/tests/run/convertible.scala index 4525e52e654e..4e3fbb5d8511 100644 --- a/tests/run/convertible.scala +++ b/tests/run/convertible.scala @@ -1,4 +1,4 @@ -//> using options -feature -Werror -preview +//> using options -feature -Werror import Conversion.into @@ -26,5 +26,3 @@ trait C[X]: class D[X] extends C[X] def f = new D[Text].f("abc") - - diff --git a/tests/run/enum-java-scala/Test.java b/tests/run/enum-java-scala/Test.java index 7d059e592098..cf2ab3802845 100644 --- a/tests/run/enum-java-scala/Test.java +++ b/tests/run/enum-java-scala/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - // see: https://github.com/scala/scala3/issues/12637 public class Test { public static void main(String[] args) { diff --git a/tests/run/enum-java/Test.java b/tests/run/enum-java/Test.java index 7932832182f6..d58e3cc418b8 100644 --- a/tests/run/enum-java/Test.java +++ b/tests/run/enum-java/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public class Test { public static void log(String x) { System.out.println(x); } public static void check(Boolean p, String message) { diff --git a/tests/run/errorhandling.check b/tests/run/errorhandling.check index 882ca57f5022..2732870f10bc 100644 --- a/tests/run/errorhandling.check +++ b/tests/run/errorhandling.check @@ -2,3 +2,19 @@ breakTest optTest resultTest Person(Kostas,5) +validateTest +ok: Form(Bob,Email(Bob@example.com),21) +err: [0]: Missing name +err: [0]: bob does not start with uppercase letter +err: [0]: Invalid email bad-email +err: [0]: Age 16 is below minimum age 18 +err: [0]: Missing confirmation +err: [0]: bob does not start with uppercase letter, [1]: Invalid email bad-email, [2]: Age 16 is below minimum age 18, [3]: Missing confirmation +---- +ok: Invoice(c1,100) +ok: Refund(i1,bad product) +err: [0]: Missing customerId, [1]: Missing amount +err: [0]: Invalid amount: For input string: "b" +err: [0]: Missing invoiceId, [1]: Missing reason +err: [0]: invalid 'kind' other +err: [0]: missing 'kind' diff --git a/tests/run/errorhandling/Result.scala b/tests/run/errorhandling/Result.scala index 07d7a9f90c8a..8a200c790489 100644 --- a/tests/run/errorhandling/Result.scala +++ b/tests/run/errorhandling/Result.scala @@ -1,7 +1,7 @@ package scala.util import boundary.{Label, break} -abstract class Result[+T, +E] +sealed abstract class Result[+T, +E] case class Ok[+T](value: T) extends Result[T, Nothing] case class Err[+E](value: E) extends Result[Nothing, E] @@ -18,6 +18,11 @@ object Result: case err: Err[_] => Err(f(err.value)) case ok: Ok[_] => ok + /** Replace OK values, propagate Errs */ + def ifOK[U](u: => U): Result[U, E] = r match + case ok: Ok[_] => Ok(u) + case err: Err[_] => err + /** Map Ok values, propagate Errs */ def map[U](f: T => U): Result[U, E] = r match case Ok(x) => Ok(f(x)) @@ -55,6 +60,11 @@ object Result: /** Right unit for chains of `*:`s. Returns an `Ok` with an `EmotyTuple` value. */ def empty: Result[EmptyTuple, Nothing] = Ok(EmptyTuple) + + /** scala.Option (for collection interop), not the one from `tests/run/errorhandling/optional.scala` */ + inline def fromOption[T, E](opt: scala.Option[T], inline ifNone: E): Result[T, E] = opt match + case scala.Some(x) => Ok(x) + case scala.None => Err(ifNone) end Result /** A prompt for `_.?`. It establishes a boundary to which `_.?` returns */ @@ -63,5 +73,3 @@ object respond: boundary: val result = body Ok(result) - - diff --git a/tests/run/errorhandling/Test.scala b/tests/run/errorhandling/Test.scala index 4aa1cd28c5aa..9f379828aa9a 100644 --- a/tests/run/errorhandling/Test.scala +++ b/tests/run/errorhandling/Test.scala @@ -1,5 +1,7 @@ import scala.util.*, boundary.break +import caps.any + /** boundary/break as a replacement for non-local returns */ def indexOf[T](xs: List[T], elem: T): Int = boundary: @@ -54,7 +56,7 @@ def sumRoots(xs: List[String]) = // inferred: Result[Double, String] val ys = parseDoubles(xs).mapErr(_.toString).? // direct jump ys.reduce((x, y) => x + trySqrt(y).?) // need exception to propagate `Err` -def resultTest() = +def resultTest() = { println("resultTest") def assertFail(value: Any, s: String) = value match case Err(msg: String) => assert(msg.contains(s)) @@ -62,17 +64,112 @@ def resultTest() = assertFail(sumRoots(List("1", "-2", "4")), "cannot take sqrt of negative") assertFail(sumRoots(List()), "list is empty") assertFail(sumRoots(List("1", "3ab")), "NumberFormatException") + val xs = sumRoots(List("1", "-2", "4")) *: sumRoots(List()) *: sumRoots(List("1", "3ab")) *: Result.empty xs match case Err(msgs) => assert(msgs.length == 3) case _ => assert(false) + val ys = sumRoots(List("1", "2", "4")) *: sumRoots(List("1")) *: sumRoots(List("2")) *: Result.empty ys match case Ok((a, b, c)) => // ok case _ => assert(false) +} + +def validateTest() = { + println("validateTest") + import Validation.validate + + case class Email private (value: String) + object Email: + def from(raw: String): Result[Email, String] = + if raw.contains("@") then Ok(Email(raw)) // demo!! + else Err(s"Invalid email ${raw}") + case class Form(name: String, email: Email, age: Int) + + def validatedForm(name: String, rawEmail: String, age: Int, confirmed: Boolean): Result[Form, List[String]] = + validate: v => + v.require(!name.isEmpty, "Missing name") + v.test(name.head.isUpper, s"${name} does not start with uppercase letter") + val email = v.test(Email.from(rawEmail)) + v.test(age >= 18, s"Age ${age} is below minimum age 18") + v.test(confirmed, "Missing confirmation") + Form(name, email.valid, age) + + // Good stuff: can no longer edit the scope if you leak it + // def leak(): Unit = + // val leaked: Result[Validation[String]^, List[String]] = Validation.validate: v => + // v + // leaked match + // case Ok(scope) => + // scope.appendOne("leaked error") // error + // ??? + // case Err(errs) => () + + type JsonDict = Map[String, String] + def jsonDict(elems: (String, String)*): JsonDict = Map(elems*) + + enum InvoiceOrRefund: + case Invoice(customerId: String, amount: BigInt) + case Refund(invoiceId: String, reason: String) + + def validateJson(json: JsonDict): Result[InvoiceOrRefund, List[String]] = + validate: v => + val kind = v.require(Result.fromOption(json.get("kind"), "missing 'kind'")) + v.require(kind == "invoice" || kind == "refund", s"invalid 'kind' ${kind}") + if kind == "invoice" then + val customerId = v.test(Result.fromOption(json.get("customerId"), s"Missing customerId")) + val amount = v.test { + respond: + val amount = Result.fromOption(json.get("amount"), s"Missing amount").? + Result(BigInt(amount)).mapErr(err => s"Invalid amount: ${err.getMessage}").? + } + InvoiceOrRefund.Invoice(customerId.valid, amount.valid) + else + val invoiceId = v.test(Result.fromOption(json.get("invoiceId"), s"Missing invoiceId")) + val reason = v.test(Result.fromOption(json.get("reason"), s"Missing reason")) + InvoiceOrRefund.Refund(invoiceId.valid, reason.valid) + + def printResult[T, E](result: Result[T, List[E]]): Unit = result match + case Ok(value) => println(s"ok: $value") + case Err(errs) => println(s"err: ${errs.zipWithIndex.map { case (e, i) => s"[$i]: $e" }.mkString(", ")}") + + val p1 = validatedForm("Bob", "Bob@example.com", 21, true) // TTTT + val p2 = validatedForm("", "Bob@example.com", 21, true) // F (abort early) + val p3 = validatedForm("bob", "Bob@example.com", 21, true) // FTTT + val p4 = validatedForm("Bob", "bad-email", 21, true) // TFTT + val p5 = validatedForm("Bob", "Bob@example.com", 16, true) // TTFT + val p6 = validatedForm("Bob", "Bob@example.com", 21, false) // TTTF + val p7 = validatedForm("bob", "bad-email", 16, false) // FFFF + printResult(p1) + printResult(p2) + printResult(p3) + printResult(p4) + printResult(p5) + printResult(p6) + printResult(p7) + + println("----") + + val j1 = validateJson(jsonDict("kind" -> "invoice", "customerId" -> "c1", "amount" -> "100")) // ok + val j2 = validateJson(jsonDict("kind" -> "refund", "invoiceId" -> "i1", "reason" -> "bad product")) // ok + val j3 = validateJson(jsonDict("kind" -> "invoice")) // [0]: missing customerId, [1]: missing amount + val j4 = validateJson(jsonDict("kind" -> "invoice", "customerId" -> "c1", "amount" -> "bad amount")) // bad amount + val j5 = validateJson(jsonDict("kind" -> "refund")) // [0]: missing invoiceId, [1]: missing reason + val j6 = validateJson(jsonDict("kind" -> "other")) // invalid kind + val j7= validateJson(jsonDict()) // missing kind + printResult(j1) + printResult(j2) + printResult(j3) + printResult(j4) + printResult(j5) + printResult(j6) + printResult(j7) +} @main def Test = breakTest() optTest() resultTest() - parseCsvIgnoreErrors() \ No newline at end of file + parseCsvIgnoreErrors() + validateTest() diff --git a/tests/run/errorhandling/Validator.scala b/tests/run/errorhandling/Validator.scala new file mode 100644 index 000000000000..b9fc2f661b04 --- /dev/null +++ b/tests/run/errorhandling/Validator.scala @@ -0,0 +1,74 @@ +//> using options -language:experimental.captureChecking,experimental.separationChecking +package scala.util +import boundary.{break, Label} +import collection.mutable +import caps.Control +import caps.fresh +import caps.any +import caps.Control + +import Validation.{Validated, Checked} + +object Validation { + object Abort + type Abort = Abort.type + + type Checked[+T] = Label[Abort] ?-> T + + inline def validate[T, E](inline op: Validation[E]^ -> Checked[T]): Result[T, List[E]] = + val scope: Validation[E]^ = new Validation[E] + val userResult = + boundary[Validated[T]]: + Validated.success(op(scope)) + caps.freeze(scope) + val errors = scope.snapshot + userResult match + case ok: Ok[?] if errors.isEmpty => ok + case _ => Err(errors) + + + opaque type Validated[+A] = Ok[A] | Abort + object Validated: + def failure: Validated[Nothing] = Abort + def success[A](value: A): Validated[A] = Ok(value) + def fromOk[A](value: Ok[A]): Validated[A] = value + extension [A](c: Validated[A]) + inline def valid: Checked[A] = c match + case ok: Ok[?] => ok.value + case _ => scala.util.boundary.break(Abort) +} + +class Validation[E] extends caps.Mutable: + self: Validation[E]^{any} => + + private val errors = mutable.ListBuffer[E]() + + def snapshot: List[E] = errors.toList + + update def appendOne(e: E): Unit = + errors += e + + update inline def test(inline cond: Boolean, inline error: E): Unit = + if !cond then + appendOne(error) + + update inline def test[A](inline cond: Result[A, E]): Validated[A] = + cond match + case ok: Ok[?] => + Validated.fromOk(ok) + case Err(e) => + appendOne(e) + Validated.failure + + update inline def require(inline cond: Boolean, inline error: E): Checked[Unit] = + if !cond then + appendOne(error) + break(Validation.Abort) + + update inline def require[A](inline cond: Result[A, E]): Checked[A] = + cond match + case ok: Ok[?] => + ok.value + case Err(e) => + appendOne(e) + break(Validation.Abort) diff --git a/tests/run/forwarder-java-package-private/Test_2.scala b/tests/run/forwarder-java-package-private/Test_2.scala index f73d1b32c1b5..546356b07c56 100644 --- a/tests/run/forwarder-java-package-private/Test_2.scala +++ b/tests/run/forwarder-java-package-private/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - package scalapackage: object Foo extends javapackage.Base_1 end scalapackage diff --git a/tests/run/i10884/Test_2.scala b/tests/run/i10884/Test_2.scala index 526bf4523dbc..84111522b2ca 100644 --- a/tests/run/i10884/Test_2.scala +++ b/tests/run/i10884/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Exporter: export JavaExporter_1._ diff --git a/tests/run/i12086/Test_3.scala b/tests/run/i12086/Test_3.scala index d5711147a9cf..818332073db2 100644 --- a/tests/run/i12086/Test_3.scala +++ b/tests/run/i12086/Test_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { val c = new C diff --git a/tests/run/i12204/Test_3.scala b/tests/run/i12204/Test_3.scala index b9968332445f..51ec04559ca7 100644 --- a/tests/run/i12204/Test_3.scala +++ b/tests/run/i12204/Test_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { B_2.test() diff --git a/tests/run/i12492/Test.scala b/tests/run/i12492/Test.scala index 190b84fd66f5..9cf6a779ddb8 100644 --- a/tests/run/i12492/Test.scala +++ b/tests/run/i12492/Test.scala @@ -1,4 +1,3 @@ -// scalajs: --skip object Test: def main(args: Array[String]): Unit = go(classOf[MyTable]) diff --git a/tests/run/i12753/Test.java b/tests/run/i12753/Test.java index 87a8d92a2542..2a0bd9480b9c 100644 --- a/tests/run/i12753/Test.java +++ b/tests/run/i12753/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public class Test { public static void s(Object s) { System.out.println(s); diff --git a/tests/run/i15199/Test_2.scala b/tests/run/i15199/Test_2.scala index 80106b727fe3..9684d6fb2655 100644 --- a/tests/run/i15199/Test_2.scala +++ b/tests/run/i15199/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class ScalaChild extends Child_1 @main def Test(): Unit = diff --git a/tests/run/i15318/Test.scala b/tests/run/i15318/Test.scala index 1669a3f25e1d..5961f481ca9f 100644 --- a/tests/run/i15318/Test.scala +++ b/tests/run/i15318/Test.scala @@ -1,4 +1,3 @@ -// scalajs: --skip object Test: def main(args: Array[String]): Unit = go(classOf[Bean]) diff --git a/tests/run/i15903.check b/tests/run/i15903.check new file mode 100644 index 000000000000..b87ad2f0d655 --- /dev/null +++ b/tests/run/i15903.check @@ -0,0 +1 @@ +scala.collection.Iterable> diff --git a/tests/run/i15903.scala b/tests/run/i15903.scala new file mode 100644 index 000000000000..5cadd05d4754 --- /dev/null +++ b/tests/run/i15903.scala @@ -0,0 +1,10 @@ +// scalajs: --skip +// (JVM-only, generic signatures) + +trait Working: + type M[X,Y] = Iterable[(X, Y)] + def example[K, A, T[X,Y] <: M[X,Y]](ab: String): T[K,A] = ??? + +object Test: + def main(args: Array[String]): Unit = + classOf[Working].getMethods.filter(_.getName == "example").map(_.getGenericReturnType).foreach(println) diff --git a/tests/run/i15903b.check b/tests/run/i15903b.check new file mode 100644 index 000000000000..b87ad2f0d655 --- /dev/null +++ b/tests/run/i15903b.check @@ -0,0 +1 @@ +scala.collection.Iterable> diff --git a/tests/run/i15903b.scala b/tests/run/i15903b.scala new file mode 100644 index 000000000000..9afb2bbd3239 --- /dev/null +++ b/tests/run/i15903b.scala @@ -0,0 +1,9 @@ +// scalajs: --skip +// (JVM-only, generic signatures) + +trait NotWorking: + def example[K, A, T[X,Y] <: Iterable[(X, Y)]](ab: String): T[K,A] = ??? + +object Test: + def main(args: Array[String]): Unit = + classOf[NotWorking].getMethods.filter(_.getName == "example").map(_.getGenericReturnType).foreach(println) diff --git a/tests/run/i15903c.check b/tests/run/i15903c.check new file mode 100644 index 000000000000..802b4d822f7a --- /dev/null +++ b/tests/run/i15903c.check @@ -0,0 +1 @@ +scala.collection.Iterable> diff --git a/tests/run/i15903c.scala b/tests/run/i15903c.scala new file mode 100644 index 000000000000..15950d0a5f5d --- /dev/null +++ b/tests/run/i15903c.scala @@ -0,0 +1,10 @@ +// scalajs: --skip +// (JVM-only, generic signatures) + +trait NotWorking: + // return type args reversed compared to test case (b) + def example[K, A, T[X,Y] <: Iterable[(X, Y)]](ab: String): T[A,K] = ??? + +object Test: + def main(args: Array[String]): Unit = + classOf[NotWorking].getMethods.filter(_.getName == "example").map(_.getGenericReturnType).foreach(println) diff --git a/tests/run/i15903d.check b/tests/run/i15903d.check new file mode 100644 index 000000000000..725b2a507393 --- /dev/null +++ b/tests/run/i15903d.check @@ -0,0 +1 @@ +interface scala.collection.Iterable diff --git a/tests/run/i15903d.scala b/tests/run/i15903d.scala new file mode 100644 index 000000000000..3c16cab56c42 --- /dev/null +++ b/tests/run/i15903d.scala @@ -0,0 +1,9 @@ +// scalajs: --skip +// (JVM-only, generic signatures) + +trait NotWorking: + def example[A, X[T] <: Iterable[X[List[T]]]](s: String): X[A] = ??? + +object Test: + def main(args: Array[String]): Unit = + classOf[NotWorking].getMethods.filter(_.getName == "example").map(_.getGenericReturnType).foreach(println) diff --git a/tests/run/i16474/test.scala b/tests/run/i16474/test.scala index 2dc2900dd2a8..339c7a6acfad 100644 --- a/tests/run/i16474/test.scala +++ b/tests/run/i16474/test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip -// test.scala import repro.* import scala.util.Try diff --git a/tests/run/i17021.ext-java/Test.scala b/tests/run/i17021.ext-java/Test.scala index 2cca286c3801..3741fa2dfadb 100644 --- a/tests/run/i17021.ext-java/Test.scala +++ b/tests/run/i17021.ext-java/Test.scala @@ -1,4 +1,3 @@ -// scalajs: --skip // Derives from run/i17021.defs // but with a Java protected member // and fixed calling code, that uses super diff --git a/tests/run/i17255/Module.scala b/tests/run/i17255/Module.scala index 9b7153edbfd1..936e78e8e4ce 100644 --- a/tests/run/i17255/Module.scala +++ b/tests/run/i17255/Module.scala @@ -1,4 +1,3 @@ -// scalajs: --skip package p { object Module { override def toString = "Module" diff --git a/tests/run/i19619/Test.scala b/tests/run/i19619/Test.scala index 871e7a490ea0..8e8def4994db 100644 --- a/tests/run/i19619/Test.scala +++ b/tests/run/i19619/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - import lib.InnerClass import lib.InnerClassGen import lib.RawTypes diff --git a/tests/run/i22628/Test.scala b/tests/run/i22628/Test.scala index 4ff3d4e0a2ee..4542fd01e489 100644 --- a/tests/run/i22628/Test.scala +++ b/tests/run/i22628/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test extends App { new mycode.MyServerCall().close() } diff --git a/tests/run/i22979/Leak.scala b/tests/run/i22979/Leak.scala new file mode 100644 index 000000000000..792473e333d7 --- /dev/null +++ b/tests/run/i22979/Leak.scala @@ -0,0 +1,13 @@ +import annotation.* + +class Leak()(using @constructorOnly l: boundary.Label[String]) { + Seq("a", "b").foreach(_ => boundary.break("stop")) +} + +object boundary { + final class Break[T] private[boundary](val label: Label[T], val value: T) + extends RuntimeException( + /*message*/ null, /*cause*/ null, /*enableSuppression=*/ false, /*writableStackTrace*/ false) + final class Label[-T] + def break[T](value: T)(using label: Label[T]): Nothing = throw new Break(label, value) +} diff --git a/tests/run/i22979/test.scala b/tests/run/i22979/test.scala new file mode 100644 index 000000000000..2dd3bec1aab0 --- /dev/null +++ b/tests/run/i22979/test.scala @@ -0,0 +1,23 @@ +// scalajs: --skip + +import util.Try + +@main def Test = + assert(Try(classOf[Leak].getDeclaredField("l")).isFailure) + assert(classOf[Leak].getFields.length == 0) + //classOf[Leak].getFields.map(_.getName).foreach(println) //DEBUG + assert(classOf[C].getFields.length == 0) + //classOf[Lapse.type].getFields.map(_.getName).foreach(println) //DEBUG + +class C: + private val x = 42 + println(x) + println(List(27).map(_ + x)) + +// The easy tweak for lambdas does not work for module owner. +// The lambdalifted anonfun is not transformed correctly. +class Lapse: + def f = Lapse.DefaultSentinelFn() +object Lapse: + private val DefaultSentinel: AnyRef = new AnyRef + private val DefaultSentinelFn: () => AnyRef = () => DefaultSentinel diff --git a/tests/run/i22991/Test.scala b/tests/run/i22991/Test.scala index e1de929db7b3..9d2342136c79 100644 --- a/tests/run/i22991/Test.scala +++ b/tests/run/i22991/Test.scala @@ -1,4 +1,3 @@ -// scalajs: --skip //Test java runtime reflection access to @Runtime annotations on method parameters. @main def Test = def check(actual: Int)(expect: Int)(msg: => String): Unit = diff --git a/tests/run/i2314.scala b/tests/run/i2314.scala index 37e52a1368c5..a5fc2c029b35 100644 --- a/tests/run/i2314.scala +++ b/tests/run/i2314.scala @@ -18,15 +18,15 @@ object Test { a.productElement(-1) ??? } catch { - case e: IndexOutOfBoundsException => - assert(e.getMessage == "-1") + case e: IndexOutOfBoundsException => assert(e.getMessage().contains("-1")) + case _ => assert(false) } try { a.productElement(2) ??? } catch { - case e: IndexOutOfBoundsException => - assert(e.getMessage == "2") + case e: IndexOutOfBoundsException => assert(e.getMessage().contains("2")) + case _ => assert(false) } val b = B(1, "s") diff --git a/tests/run/i23479/NonSeal.java b/tests/run/i23479/NonSeal.java index 214ff5e58fc6..db3a9c9a4280 100644 --- a/tests/run/i23479/NonSeal.java +++ b/tests/run/i23479/NonSeal.java @@ -1,3 +1,2 @@ -// test: -jvm 17+ public non-sealed interface NonSeal extends Seal { } diff --git a/tests/run/i23479/test.scala b/tests/run/i23479/test.scala index 7380afe564d7..30c0a4b1db3d 100644 --- a/tests/run/i23479/test.scala +++ b/tests/run/i23479/test.scala @@ -1,4 +1,3 @@ -// scalajs: --skip class C() extends NonSeal @main def Test = C() diff --git a/tests/run/i24056.scala b/tests/run/i24056.scala new file mode 100644 index 000000000000..2eb2b9a4e6b7 --- /dev/null +++ b/tests/run/i24056.scala @@ -0,0 +1,13 @@ +trait DFBit +final class DFVal[+T, +M](val value: Int) extends AnyVal +type DFValOf[+T] = DFVal[T, Any] + +class Top: + val dmn1 = new scala.reflect.Selectable: + val o: DFValOf[DFBit] = DFVal(42) + val x: DFValOf[DFBit] = dmn1.o + +object Test: + def main(args: Array[String]): Unit = + val t = Top() + assert(t.x.value == 42) diff --git a/tests/run/i24507/test.scala b/tests/run/i24507/test.scala index 38f1e6465f98..a93fc758e343 100644 --- a/tests/run/i24507/test.scala +++ b/tests/run/i24507/test.scala @@ -1,4 +1,3 @@ -// scalajs: --skip import a._ class T extends A { diff --git a/tests/run/i24653.check b/tests/run/i24653.check new file mode 100644 index 000000000000..9eab6ed1daac --- /dev/null +++ b/tests/run/i24653.check @@ -0,0 +1,5 @@ +public void Foo.bar() +public scala.runtime.BoxedUnit Foo.classTypeParam() +public void Foo.foobar(scala.runtime.BoxedUnit) +public scala.runtime.BoxedUnit Foo.generic() +public scala.runtime.BoxedUnit Foo.typeMember() diff --git a/tests/run/i24653.scala b/tests/run/i24653.scala new file mode 100644 index 000000000000..8fc057e99f7e --- /dev/null +++ b/tests/run/i24653.scala @@ -0,0 +1,24 @@ +// scalajs: --skip + +object UnitAlias: + type U = Unit + +class Foo[W <: UnitAlias.U] { + import UnitAlias.* + + type M <: U + + def bar(): U = () + def foobar(x: U): U = () + + def generic[T <: U](): T = ??? + def classTypeParam(): W = ??? + def typeMember(): M = ??? +} + +object Test { + def main(args: Array[String]): UnitAlias.U = + val ms = classOf[Foo[Unit]].getDeclaredMethods().sortBy(_.getName()) + for m <- ms do + println(m) +} diff --git a/tests/run/i25943.scala b/tests/run/i25943.scala new file mode 100644 index 000000000000..5de4594daebf --- /dev/null +++ b/tests/run/i25943.scala @@ -0,0 +1,19 @@ +// https://github.com/scala/scala3/issues/25943 +class C25943(val a: AnyRef) + +trait Probe25943: + def aField: AnyRef + +def runIt(): Boolean = + val a2 = new Object + + val obj: Probe25943 = + new Probe25943: + class S extends C25943(a2) + val s = new S{} + def aField = s.a + + obj.aField eq a2 + +@main def Test = + assert(runIt(), "captured value should propagate through super-call") diff --git a/tests/run/i26176-with-implicits.scala b/tests/run/i26176-with-implicits.scala new file mode 100644 index 000000000000..3333e3334fd6 --- /dev/null +++ b/tests/run/i26176-with-implicits.scala @@ -0,0 +1,10 @@ +trait Sp[T] + +class C[T](val xs: List[T])(using ev: Sp[T]): + inline def m: C[T] = new C[T](xs) {} + +object Test: + given Sp[Int] = new Sp[Int] {} + def main(args: Array[String]): Unit = + val c = new C[Int](List(1, 2, 3)) + c.m diff --git a/tests/run/i26176.scala b/tests/run/i26176.scala new file mode 100644 index 000000000000..1e7befd70800 --- /dev/null +++ b/tests/run/i26176.scala @@ -0,0 +1,8 @@ +class C: + private def secret = 42 + def foo = 10 + inline def m = new C { override def foo = secret } + +@main def Test = + val e = new C().m + assert(e.foo == 42) diff --git a/tests/run/i2760/Test.scala b/tests/run/i2760/Test.scala index 615fb611b545..f2322b528f78 100644 --- a/tests/run/i2760/Test.scala +++ b/tests/run/i2760/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - @Fork(value = 16) class HasFork object Test { diff --git a/tests/run/i2780/Test.scala b/tests/run/i2780/Test.scala index 290cef2082d1..fefa9a3537f4 100644 --- a/tests/run/i2780/Test.scala +++ b/tests/run/i2780/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class Foo extends bla.Base { class Inner { println(foo()) diff --git a/tests/run/i533/Test.scala b/tests/run/i533/Test.scala index 115b80ebbb6f..a05a438c81a0 100644 --- a/tests/run/i533/Test.scala +++ b/tests/run/i533/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { val x = new Array[Integer](1) diff --git a/tests/run/i7212/Test.java b/tests/run/i7212/Test.java index d85b9ea220ad..e2d21bd76dfd 100644 --- a/tests/run/i7212/Test.java +++ b/tests/run/i7212/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public class Test { public static void main(String[] args) { CompatVargs c = new CompatVargs(); diff --git a/tests/run/i7990/Test_2.scala b/tests/run/i7990/Test_2.scala index 28a72f4505ac..baca4b8c4066 100644 --- a/tests/run/i7990/Test_2.scala +++ b/tests/run/i7990/Test_2.scala @@ -1,3 +1 @@ -// scalajs: --skip - @main def Test = Exception_1("error") diff --git a/tests/run/i8001/B_2.java b/tests/run/i8001/B_2.java index bde79bae36fb..31346721ca36 100644 --- a/tests/run/i8001/B_2.java +++ b/tests/run/i8001/B_2.java @@ -16,7 +16,7 @@ public static void test() { a.arr1(intArr); a.arr2(stringArr); - a.arr3(intArr); + a.arr3(intArr2); a.arr4(stringArr2); a.arrRef1(integerArr); diff --git a/tests/run/i8001/Test_3.scala b/tests/run/i8001/Test_3.scala index 287cf716cfdb..b397d63ff166 100644 --- a/tests/run/i8001/Test_3.scala +++ b/tests/run/i8001/Test_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = B_2.test() diff --git a/tests/run/i8101/Test.scala b/tests/run/i8101/Test.scala index 179271bffaf2..8ac8bf705ad2 100644 --- a/tests/run/i8101/Test.scala +++ b/tests/run/i8101/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class Bar extends JavaFoo with Foo { def read(): Int = ??? } diff --git a/tests/run/i8531/Test.scala b/tests/run/i8531/Test.scala index e5eea9a4cb88..918f6f2a41d2 100644 --- a/tests/run/i8531/Test.scala +++ b/tests/run/i8531/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class Foo(@Named s: String) object Test { diff --git a/tests/run/i8599/Test_3.scala b/tests/run/i8599/Test_3.scala index cbd4e591e818..144d2126667d 100644 --- a/tests/run/i8599/Test_3.scala +++ b/tests/run/i8599/Test_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = val obj = new JavaClass_2 diff --git a/tests/run/i8602/Test_3.scala b/tests/run/i8602/Test_3.scala index 07eeed5a7b0f..7b1797f8e586 100644 --- a/tests/run/i8602/Test_3.scala +++ b/tests/run/i8602/Test_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = val child = new ChildClass_2() diff --git a/tests/run/i8661/Test.scala b/tests/run/i8661/Test.scala index 21ee287263ec..eaf9bc1e8aa7 100644 --- a/tests/run/i8661/Test.scala +++ b/tests/run/i8661/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - import pk.C object Test { def main(args: Array[String]): Unit = { diff --git a/tests/run/inline-trait-body-lazy-val.scala b/tests/run/inline-trait-body-lazy-val.scala new file mode 100644 index 000000000000..68a9c9fd8697 --- /dev/null +++ b/tests/run/inline-trait-body-lazy-val.scala @@ -0,0 +1,9 @@ +inline trait A: + lazy val x = + throw new Exception + 1 + +class B extends A + +@main def Test: Unit = + val b = B() \ No newline at end of file diff --git a/tests/run/inline-trait-body-override-def.scala b/tests/run/inline-trait-body-override-def.scala new file mode 100644 index 000000000000..2ec53e02e669 --- /dev/null +++ b/tests/run/inline-trait-body-override-def.scala @@ -0,0 +1,9 @@ +inline trait A: + def foo: Unit = throw Exception("I should not be run!") + +class B extends A: + override def foo: Unit = () + +@main def Test = + val b = B() + b.foo diff --git a/tests/run/inline-trait-body-override-val.check b/tests/run/inline-trait-body-override-val.check new file mode 100644 index 000000000000..0cfbf08886fc --- /dev/null +++ b/tests/run/inline-trait-body-override-val.check @@ -0,0 +1 @@ +2 diff --git a/tests/run/inline-trait-body-override-val.scala b/tests/run/inline-trait-body-override-val.scala new file mode 100644 index 000000000000..ffd71ca0df56 --- /dev/null +++ b/tests/run/inline-trait-body-override-val.scala @@ -0,0 +1,9 @@ +inline trait A: + val x: Int = 1 + +class B extends A: + override val x = 2 + +@main def Test = + val b = B() + println(b.x) diff --git a/tests/run/inline-trait-body-statements.check b/tests/run/inline-trait-body-statements.check new file mode 100644 index 000000000000..73b256c35fd0 --- /dev/null +++ b/tests/run/inline-trait-body-statements.check @@ -0,0 +1,8 @@ +1 +foo +foo +1 +foo +bar +bar +bar diff --git a/tests/run/inline-trait-body-statements.scala b/tests/run/inline-trait-body-statements.scala new file mode 100644 index 000000000000..5da24022e99d --- /dev/null +++ b/tests/run/inline-trait-body-statements.scala @@ -0,0 +1,22 @@ +inline trait A[T]: + var x = 1 + def foo = + if x == 1 then println("1") + x = 1 - x + println("foo") + + foo + foo + foo + +class B extends A[Int]: + def bar = + if x == 1 then println("1") + println("bar") + + bar + bar + bar + +@main def Test = + B() \ No newline at end of file diff --git a/tests/run/inline-trait-body-var.check b/tests/run/inline-trait-body-var.check new file mode 100644 index 000000000000..94ebaf900161 --- /dev/null +++ b/tests/run/inline-trait-body-var.check @@ -0,0 +1,4 @@ +1 +2 +3 +4 diff --git a/tests/run/inline-trait-body-var.scala b/tests/run/inline-trait-body-var.scala new file mode 100644 index 000000000000..fda8fc3109b7 --- /dev/null +++ b/tests/run/inline-trait-body-var.scala @@ -0,0 +1,15 @@ +inline trait A: + var x = 1 + +class B extends A: + def f = + val old = x + x += 1 + old + +@main def Test = + val b = B() + println(b.f) + println(b.f) + println(b.f) + println(b.f) diff --git a/tests/run/inline-trait-child-and-grandchild-override.scala b/tests/run/inline-trait-child-and-grandchild-override.scala new file mode 100644 index 000000000000..f2b0b72e9aa3 --- /dev/null +++ b/tests/run/inline-trait-child-and-grandchild-override.scala @@ -0,0 +1,11 @@ +inline trait GreatGrandParent: + val x = 10 +inline trait GrandParent extends GreatGrandParent: + override val x = 11 +inline trait Parent extends GrandParent: + override val x = 12 +class C extends Parent + +@main def Test = + val x = C() + assert(x.x == 12) diff --git a/tests/run/inline-trait-clash-method-method.scala b/tests/run/inline-trait-clash-method-method.scala new file mode 100644 index 000000000000..8871681d977e --- /dev/null +++ b/tests/run/inline-trait-clash-method-method.scala @@ -0,0 +1,9 @@ +inline trait A: + def x(y: String) = "Hello world" + +class C extends A: + override def x(y: String) = "Hello world2" + +@main def Test = + val v = C() + assert(v.x("Hello World") == "Hello world2") diff --git a/tests/run/inline-trait-clash-method-val-param.scala b/tests/run/inline-trait-clash-method-val-param.scala new file mode 100644 index 000000000000..7e7ebab600cb --- /dev/null +++ b/tests/run/inline-trait-clash-method-val-param.scala @@ -0,0 +1,9 @@ +inline trait A: + def x = "Hello world" + +class C extends A: + override val x = "Overridden" + +@main def Test = + val v = C() + assert(v.x == "Overridden") diff --git a/tests/run/inline-trait-clash-param-method.scala b/tests/run/inline-trait-clash-param-method.scala new file mode 100644 index 000000000000..23bb7565b3bd --- /dev/null +++ b/tests/run/inline-trait-clash-param-method.scala @@ -0,0 +1,8 @@ +inline trait A(x: Int) + +class C extends A(10): + def x = 1000 + +@main def Test = + val v = C() + assert(v.x == 1000) diff --git a/tests/run/inline-trait-clash-param-param.scala b/tests/run/inline-trait-clash-param-param.scala new file mode 100644 index 000000000000..4f4c0776a83b --- /dev/null +++ b/tests/run/inline-trait-clash-param-param.scala @@ -0,0 +1,10 @@ +// Param x in A will be renamed so it doesn't clash. + +inline trait A(x: Int) + +class C(x: String) extends A(10): + val y = x + +@main def Test = + val v = C("Hello World") + assert(v.y == "Hello World") diff --git a/tests/run/inline-trait-clash-param-val-param.scala b/tests/run/inline-trait-clash-param-val-param.scala new file mode 100644 index 000000000000..30807db9553e --- /dev/null +++ b/tests/run/inline-trait-clash-param-val-param.scala @@ -0,0 +1,11 @@ +// Allowed. We rename A.x, A.y to avoid a clash. + +inline trait A(x: Int, y: Int) + +class C(val x: Int) extends A(10, 100): + val y: Int = 10 + +@main def Test = + val v = C(5) + assert(v.x == 5) + assert(v.y == 10) diff --git a/tests/run/inline-trait-clash-param-var-param.scala b/tests/run/inline-trait-clash-param-var-param.scala new file mode 100644 index 000000000000..c2514fb686d0 --- /dev/null +++ b/tests/run/inline-trait-clash-param-var-param.scala @@ -0,0 +1,11 @@ +// Allowed. We rename A.x, A.y to avoid a clash. + +inline trait A(x: Int, y: Int) + +class C(var x: Int) extends A(10, 100): + val y: Int = 10 + +@main def Test = + val v = C(5) + assert(v.x == 5) + assert(v.y == 10) diff --git a/tests/run/inline-trait-clash-val-param-val-param.scala b/tests/run/inline-trait-clash-val-param-val-param.scala new file mode 100644 index 000000000000..e1f46052c9fb --- /dev/null +++ b/tests/run/inline-trait-clash-val-param-val-param.scala @@ -0,0 +1,8 @@ +inline trait A(val x: Int, val y: Int) +class C(override val y: Int) extends A(10, 54): + override val x = 1000 + +@main def Test = + val v = C(44) + assert(v.x == 1000) + assert(v.y == 44) diff --git a/tests/run/inline-trait-clashing-parent-params.scala b/tests/run/inline-trait-clashing-parent-params.scala new file mode 100644 index 000000000000..5103ff6291dc --- /dev/null +++ b/tests/run/inline-trait-clashing-parent-params.scala @@ -0,0 +1,14 @@ +// These params should be renamed (as they are private) so no clash + +inline trait A(x: Int): + val y = x + +inline trait B(x: Int): + val z = x + +class C extends A(10), B(11) + +@main def Test = + val v = C() + assert(v.y == 10) + assert(v.z == 11) diff --git a/tests/run/inline-trait-enclosing-super-call.scala b/tests/run/inline-trait-enclosing-super-call.scala new file mode 100644 index 000000000000..2016de44b827 --- /dev/null +++ b/tests/run/inline-trait-enclosing-super-call.scala @@ -0,0 +1,14 @@ +inline trait A: + def bar = "A" + +class E: + def bar = "E" + +class D extends E: + class C extends A: + def foo = D.super.bar // We shouldn't touch this super call when inlining A + +@main def Test = + val d = D() + val c = d.C() + assert(c.foo == "E") diff --git a/tests/run/inline-trait-enclosing-supercall-in-inline-trait.scala b/tests/run/inline-trait-enclosing-supercall-in-inline-trait.scala new file mode 100644 index 000000000000..ba2627b8dab0 --- /dev/null +++ b/tests/run/inline-trait-enclosing-supercall-in-inline-trait.scala @@ -0,0 +1,13 @@ +trait A: + def foo = 10 + +class B extends A: + inline trait T: + def foo = B.super.foo + + class C2 extends T + +@main def Test = + val x = new B() + val y = new x.C2() + assert(y.foo == 10) diff --git a/tests/run/inline-trait-indirect-with-params.scala b/tests/run/inline-trait-indirect-with-params.scala new file mode 100644 index 000000000000..fccd89cf9db4 --- /dev/null +++ b/tests/run/inline-trait-indirect-with-params.scala @@ -0,0 +1,11 @@ +inline trait A[T](x: T): + val y = x + def foo() = x +inline trait B extends A[Int] +class C extends A[Int](10), B + +object Test: + def main(args: Array[String]): Unit = + val z: B = new C + assert(z.foo() == 10) + assert(z.y == 10) \ No newline at end of file diff --git a/tests/run/inline-trait-inheritance-diamond-simple-trait.check b/tests/run/inline-trait-inheritance-diamond-simple-trait.check new file mode 100644 index 000000000000..adbdca39e3a4 --- /dev/null +++ b/tests/run/inline-trait-inheritance-diamond-simple-trait.check @@ -0,0 +1,4 @@ +1 +2 +999 +4 diff --git a/tests/run/inline-trait-inheritance-diamond-simple-trait.scala b/tests/run/inline-trait-inheritance-diamond-simple-trait.scala new file mode 100644 index 000000000000..0bb66f48b739 --- /dev/null +++ b/tests/run/inline-trait-inheritance-diamond-simple-trait.scala @@ -0,0 +1,22 @@ +trait TGP[T]: + def i: T + def f(x: T): T = x + +inline trait IT1[T](x: T) extends TGP[T]: + override def i: T = x + +inline trait IT2 extends TGP[Int]: + override def i: Int = 999 + def j: String = "inline" + def g(x: Int): String = x.toString() + +trait T extends TGP[Int] + +class C1 extends T, IT1[Int](1) +class C2 extends IT1[Int](2), T +class C3 extends IT1[Int](3), IT2 +class C4 extends IT2, IT1[Int](4) + +@main def Test: Unit = + for c <- List(C1(), C2(), C3(), C4()) + do println(c.i) \ No newline at end of file diff --git a/tests/run/inline-trait-inheritance-inline-ancestors/inlinetraits.scala b/tests/run/inline-trait-inheritance-inline-ancestors/inlinetraits.scala new file mode 100644 index 000000000000..e695ef3efd1a --- /dev/null +++ b/tests/run/inline-trait-inheritance-inline-ancestors/inlinetraits.scala @@ -0,0 +1,47 @@ +package inlinetraits + +val inlineValues: List[Int] = + val c = C() + List(c.zero, c.eleven, c.twelve, c.thirteen, c.twentyOne, c.twentyTwo, c.thirty) + +inline trait T0: + def zero: Int = 0 + def eleven: Int = 0 + def twelve: Int = 0 + def twentyOne: Int = 0 + def thirteen: Int = 0 + def twentyTwo: Int = 0 + def thirty: Int = 0 + +inline trait T11 extends T0: + override def eleven: Int = 11 + override def twelve: Int = 11 + override def twentyOne: Int = 11 + override def thirteen: Int = 11 + override def twentyTwo: Int = 11 + override def thirty: Int = 11 + +inline trait T12 extends T0: + override def twelve: Int = 12 + override def twentyOne: Int = 12 + override def thirteen: Int = 12 + override def twentyTwo: Int = 12 + override def thirty: Int = 12 + +inline trait T21 extends T11, T12: + override def twentyOne: Int = 21 + override def thirteen: Int = 21 + override def twentyTwo: Int = 21 + override def thirty: Int = 21 + +inline trait T13 extends T0: + override def thirteen: Int = 13 + override def twentyTwo: Int = 13 + override def thirty: Int = 13 + +inline trait T22 extends T12, T13: + override def twentyTwo: Int = 22 + override def thirty: Int = 22 + +class C extends T21, T22: + override def thirty: Int = 30 diff --git a/tests/run/inline-trait-inheritance-inline-ancestors/normaltraits.scala b/tests/run/inline-trait-inheritance-inline-ancestors/normaltraits.scala new file mode 100644 index 000000000000..ba128145c793 --- /dev/null +++ b/tests/run/inline-trait-inheritance-inline-ancestors/normaltraits.scala @@ -0,0 +1,47 @@ +package normaltraits + +val normalValues: List[Int] = + val c = C() + List(c.zero, c.eleven, c.twelve, c.thirteen, c.twentyOne, c.twentyTwo, c.thirty) + +trait T0: + def zero: Int = 0 + def eleven: Int = 0 + def twelve: Int = 0 + def twentyOne: Int = 0 + def thirteen: Int = 0 + def twentyTwo: Int = 0 + def thirty: Int = 0 + +trait T11 extends T0: + override def eleven: Int = 11 + override def twelve: Int = 11 + override def twentyOne: Int = 11 + override def thirteen: Int = 11 + override def twentyTwo: Int = 11 + override def thirty: Int = 11 + +trait T12 extends T0: + override def twelve: Int = 12 + override def twentyOne: Int = 12 + override def thirteen: Int = 12 + override def twentyTwo: Int = 12 + override def thirty: Int = 12 + +trait T21 extends T11, T12: + override def twentyOne: Int = 21 + override def thirteen: Int = 21 + override def twentyTwo: Int = 21 + override def thirty: Int = 21 + +trait T13 extends T0: + override def thirteen: Int = 13 + override def twentyTwo: Int = 13 + override def thirty: Int = 13 + +trait T22 extends T12, T13: + override def twentyTwo: Int = 22 + override def thirty: Int = 22 + +class C extends T21, T22: + override def thirty: Int = 30 \ No newline at end of file diff --git a/tests/run/inline-trait-inheritance-inline-ancestors/test.scala b/tests/run/inline-trait-inheritance-inline-ancestors/test.scala new file mode 100644 index 000000000000..5f7a9be7a41b --- /dev/null +++ b/tests/run/inline-trait-inheritance-inline-ancestors/test.scala @@ -0,0 +1,5 @@ +import normaltraits.normalValues +import inlinetraits.inlineValues + +@main def Test = + assert(normalValues == inlineValues) \ No newline at end of file diff --git a/tests/run/inline-trait-inheritance-inline-grandparent.check b/tests/run/inline-trait-inheritance-inline-grandparent.check new file mode 100644 index 000000000000..02a3fcae5b4e --- /dev/null +++ b/tests/run/inline-trait-inheritance-inline-grandparent.check @@ -0,0 +1,6 @@ +0 +(Test SimpleC,Hello) + +5678 +(Test C,Hello,9) +5678 diff --git a/tests/run/inline-trait-inheritance-inline-grandparent.scala b/tests/run/inline-trait-inheritance-inline-grandparent.scala new file mode 100644 index 000000000000..91d1486d31f8 --- /dev/null +++ b/tests/run/inline-trait-inheritance-inline-grandparent.scala @@ -0,0 +1,33 @@ +package simpleGrandParent: + inline trait SimpleGrandParent[T]: + def foo(): Int = 0 + def foooo(): T = ??? + + inline trait SimpleParent[T, U](x: T, z: U) extends SimpleGrandParent[U]: + def bar(a: T) = (a, x) + + class SimpleC extends SimpleParent("Hello", 1234) + +package grandParentWithArgs: + inline trait GrandParent[T](val x: T, val y: T): + def foo(): T = x + def foooo(): T = y + + inline trait Parent[T, U](w: T, z: U) extends GrandParent[U]: + def bar(a: T) = (a, w, y) + + class C extends Parent("Hello", 1234), GrandParent(5678, 9) + +@main def Test = + import simpleGrandParent.SimpleC + import grandParentWithArgs.C + + val simpleC = SimpleC() + println(simpleC.foo()) + println(simpleC.bar("Test SimpleC")) + println() + + val c = C() + println(c.foo()) + println(c.bar("Test C")) + println(c.x) \ No newline at end of file diff --git a/tests/run/inline-trait-maximum-name-clash.scala b/tests/run/inline-trait-maximum-name-clash.scala new file mode 100644 index 000000000000..c37e995636ca --- /dev/null +++ b/tests/run/inline-trait-maximum-name-clash.scala @@ -0,0 +1,17 @@ +inline trait A(x: Int): + val z = x +inline trait B(x: Int): + val y = x +inline trait C(val x: Int) + +class D extends A(314), B(1200), C(12): + override val x = 1 + override val y = x + val w = y + +@main def Test = + val v = D() + assert(v.y == 1) + assert(v.w == 1) + assert(v.z == 314) + assert(v.x == 1) diff --git a/tests/run/inline-trait-nested.scala b/tests/run/inline-trait-nested.scala new file mode 100644 index 000000000000..a3727e9aeb2a --- /dev/null +++ b/tests/run/inline-trait-nested.scala @@ -0,0 +1,16 @@ +// While we don't allow inner nested classes inside inline traits, we do allow creation of anonymous classes inside methods +// inside inline traits - after all these are just ordinary methods. + +inline trait Trait[T]: + def do_something() = println("Good morning") + +inline trait A[T]: + def foo: Trait[T] + +inline trait B extends A[Int]: + override def foo = new Trait[Int] {} + +@main def Test = + val b = new B() {} + val f = b.foo + f.do_something() diff --git a/tests/run/inline-trait-override-in-parent-triangle.scala b/tests/run/inline-trait-override-in-parent-triangle.scala new file mode 100644 index 000000000000..bbf06a8244a5 --- /dev/null +++ b/tests/run/inline-trait-override-in-parent-triangle.scala @@ -0,0 +1,14 @@ +inline trait Foo: + def foo = "Foo" + +inline trait Bar extends Foo: + override def foo = "Bar" + +class C extends Bar, Foo +class D extends Foo, Bar + +@main def Test = + val c = C() + val d = D() + assert(c.foo == "Bar") + assert(d.foo == "Bar") diff --git a/tests/run/inline-trait-param-shadows-parent-indirect.scala b/tests/run/inline-trait-param-shadows-parent-indirect.scala new file mode 100644 index 000000000000..964b95f5acfb --- /dev/null +++ b/tests/run/inline-trait-param-shadows-parent-indirect.scala @@ -0,0 +1,15 @@ +inline trait A[T](x: T): + def y = x + +inline trait B extends A[Int] +inline trait D extends A[Int] + +inline trait E extends B +inline trait F extends D + +class C extends E, F, A[Int](100) + +object Test: + def main(args: Array[String]): Unit = + val z = new C + assert(z.y == 100) diff --git a/tests/run/inline-trait-signature-parameters-val-block.check b/tests/run/inline-trait-signature-parameters-val-block.check new file mode 100644 index 000000000000..063724ea6c43 --- /dev/null +++ b/tests/run/inline-trait-signature-parameters-val-block.check @@ -0,0 +1,4 @@ +I am a B! +1 +1 +1 diff --git a/tests/run/inline-trait-signature-parameters-val-block.scala b/tests/run/inline-trait-signature-parameters-val-block.scala new file mode 100644 index 000000000000..794a6071d073 --- /dev/null +++ b/tests/run/inline-trait-signature-parameters-val-block.scala @@ -0,0 +1,10 @@ +inline trait A(val x: Int) + +class B extends A({ println("I am a B!"); 1 }) + +@main() def Test: Unit = { + val b = B() + println(b.x) + println(b.x) + println(b.x) +} \ No newline at end of file diff --git a/tests/run/inline-trait-signature-side-effects-1.check b/tests/run/inline-trait-signature-side-effects-1.check new file mode 100644 index 000000000000..4df3c9a85d7f --- /dev/null +++ b/tests/run/inline-trait-signature-side-effects-1.check @@ -0,0 +1,6 @@ +0 +0 +1 +0 +1 +2 diff --git a/tests/run/inline-trait-signature-side-effects-1.scala b/tests/run/inline-trait-signature-side-effects-1.scala new file mode 100644 index 000000000000..61c348eb48d1 --- /dev/null +++ b/tests/run/inline-trait-signature-side-effects-1.scala @@ -0,0 +1,27 @@ +inline trait A(i: Int): + val x = i + val y = i + +class B(i: Int) extends A(i) + +@main def Test = + var c = 0 + + val b1 = new B({ + for i <- 0 to c + do println(i) + c += 1 + c + }) + val b2 = new B({ + for i <- 0 to c + do println(i) + c += 1 + c + }) + val b3 = new B({ + for i <- 0 to c + do println(i) + c += 1 + c + }) \ No newline at end of file diff --git a/tests/run/inline-trait-signature-side-effects-2.check b/tests/run/inline-trait-signature-side-effects-2.check new file mode 100644 index 000000000000..4df3c9a85d7f --- /dev/null +++ b/tests/run/inline-trait-signature-side-effects-2.check @@ -0,0 +1,6 @@ +0 +0 +1 +0 +1 +2 diff --git a/tests/run/inline-trait-signature-side-effects-2.scala b/tests/run/inline-trait-signature-side-effects-2.scala new file mode 100644 index 000000000000..19dcad0681a3 --- /dev/null +++ b/tests/run/inline-trait-signature-side-effects-2.scala @@ -0,0 +1,16 @@ +inline trait A(i: Int): + val x = i + val y = i + +class B(i: Int) extends A(i) + +@main def Test = + var c = 0 + + for _ <- 0 until 3 + do new B({ + for i <- 0 to c + do println(i) + c += 1 + c + }) \ No newline at end of file diff --git a/tests/run/inline-trait-specialized-desugar.scala b/tests/run/inline-trait-specialized-desugar.scala new file mode 100644 index 000000000000..ee8f57ddc91d --- /dev/null +++ b/tests/run/inline-trait-specialized-desugar.scala @@ -0,0 +1,43 @@ +// User code does this: (with Specialized type class) +inline trait Iterator[T]: + def hasNext: Boolean + def next(): T + +// User code does this: (with Specialized type class) +inline trait ArrayIterator[T](elems: Array[T]) extends Iterator[T]: + private var current: Int = 0 + def hasNext: Boolean = current < elems.length + def next(): T = try elems(current) finally current += 1 + + +// Specialized traits generates these signatures: +inline trait Iterator_sp_Int extends Iterator[Int] +inline trait ArrayIterator_sp_Int extends ArrayIterator[Int], Iterator_sp_Int +class ArrayIterator_impl_Int(elems: Array[Int]) extends ArrayIterator_sp_Int, ArrayIterator[Int](elems) + +// User code does this: +def foo(x: ArrayIterator[Int]): Int = x.next() + +// Specialized traits converts this to +def foo(x: ArrayIterator_sp_Int): Int = x.next() + +// User code does this: +/* class MyClassA + class MyClassB extends MyClassA, ArrayIterator[Int](Array.from(Seq(1, 5))) */ + +// We convert this to: +class MyClassA +class MyClassB extends MyClassA, ArrayIterator_sp_Int, ArrayIterator[Int](Array.from(Seq(1, 5))) + +@main def Test = + val xs: Array[Int] = Array(1, 2, 3) + + // User code does this: + /* val ai = new ArrayIterator[Int](xs) {} */ + + // We convert this to: + val ai = ArrayIterator_impl_Int(xs) + + val mcb = MyClassB() + assert(mcb.hasNext) + assert(ai.next() == 1) diff --git a/tests/run/inline-trait-super-call.scala b/tests/run/inline-trait-super-call.scala new file mode 100644 index 000000000000..e2e335799599 --- /dev/null +++ b/tests/run/inline-trait-super-call.scala @@ -0,0 +1,24 @@ +inline trait A: + def foo = "A" + def bar = "bar" + +inline trait B: + def foo = "B" + +class C extends A, B: + override def foo = super.foo + +class D extends A, B: + override def foo = super[A].foo + +class E extends A, B: + override def foo = super[B].foo + def baz = super[A].bar // No override; this also needs to work + +@main def Test: Unit = + val c = C() + assert(c.foo == "B") + val d = D() + assert(d.foo == "A") + val e = E() + assert(e.foo == "B") diff --git a/tests/run/inline-trait-super-chain.scala b/tests/run/inline-trait-super-chain.scala new file mode 100644 index 000000000000..53ba24d8aa72 --- /dev/null +++ b/tests/run/inline-trait-super-chain.scala @@ -0,0 +1,23 @@ +inline trait A: + def foo = "A" + +inline trait B extends A: + override def foo = super.foo + +inline trait C extends B: + override def foo = "B" + +inline trait D extends C: + override def foo = super.foo + +inline trait E extends D: + override def foo = super.foo + +inline trait F extends E: + override def foo = super.foo + +class C1 extends F + +@main def Test = + val cl = C1() + assert(cl.foo == "B") diff --git a/tests/run/inline-trait-varargs.scala b/tests/run/inline-trait-varargs.scala new file mode 100644 index 000000000000..e88d1cd8f96c --- /dev/null +++ b/tests/run/inline-trait-varargs.scala @@ -0,0 +1,7 @@ +inline trait ListA[T](vals: T*): + def printVals() = + vals.foreach(println(_)) + +@main def Test = + val x = new ListA[Short](4, 6, 7, 8, 10, 5, 11, 100) {} + x.printVals() diff --git a/tests/run/java-ann-super-class-separate/Test_2.scala b/tests/run/java-ann-super-class-separate/Test_2.scala index 77da86b4f057..73260c43570c 100644 --- a/tests/run/java-ann-super-class-separate/Test_2.scala +++ b/tests/run/java-ann-super-class-separate/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class Foo extends Ann_1 { override def bar = 3 override def baz = 4 diff --git a/tests/run/java-ann-super-class/Test.scala b/tests/run/java-ann-super-class/Test.scala index 7c5040552cc4..2d3f7d21eb7a 100644 --- a/tests/run/java-ann-super-class/Test.scala +++ b/tests/run/java-ann-super-class/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class Foo extends Ann { override def bar = 3 override def baz = 4 diff --git a/tests/run/java-annot-params/Test_1.scala b/tests/run/java-annot-params/Test_1.scala index 36201691d382..7ffbb0835e55 100644 --- a/tests/run/java-annot-params/Test_1.scala +++ b/tests/run/java-annot-params/Test_1.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test: def main(args: Array[String]): Unit = annots.runTest(classOf[annots.Use_0]) diff --git a/tests/run/java-intersection/Test_2.scala b/tests/run/java-intersection/Test_2.scala index 2e9ab1296e15..a3d7b11fce12 100644 --- a/tests/run/java-intersection/Test_2.scala +++ b/tests/run/java-intersection/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - import java.io.Serializable class Sub extends A_1 { diff --git a/tests/run/java-longnames/Test_2.scala b/tests/run/java-longnames/Test_2.scala index 556a800cba54..b03954825173 100644 --- a/tests/run/java-longnames/Test_2.scala +++ b/tests/run/java-longnames/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - import p._ object Test extends App { diff --git a/tests/run/java-no-scala-import/Test.scala b/tests/run/java-no-scala-import/Test.scala index cf8a2249a404..cdc46d2b3e0e 100644 --- a/tests/run/java-no-scala-import/Test.scala +++ b/tests/run/java-no-scala-import/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test extends App { val c = new Config() c.setLongObj(10) diff --git a/tests/run/java-package-private-bridge/Test.scala b/tests/run/java-package-private-bridge/Test.scala index 7df6b3a2a639..7aa8a250669d 100644 --- a/tests/run/java-package-private-bridge/Test.scala +++ b/tests/run/java-package-private-bridge/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { val hasBridge1 = classOf[other.ScalaChild].getDeclaredMethods.exists { m => diff --git a/tests/run/java-package-protected/Test.scala b/tests/run/java-package-protected/Test.scala index a7036a36d4ae..40faeaa51d70 100644 --- a/tests/run/java-package-protected/Test.scala +++ b/tests/run/java-package-protected/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test extends App: assert(b.C.m == 0) end Test diff --git a/tests/run/java-varargs-2/Test.scala b/tests/run/java-varargs-2/Test.scala index 0277146ec24c..21087f82eb77 100644 --- a/tests/run/java-varargs-2/Test.scala +++ b/tests/run/java-varargs-2/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { A.foo(1) diff --git a/tests/run/java-varargs-3/Test.scala b/tests/run/java-varargs-3/Test.scala index 884801d21805..4c00e491a6ad 100644 --- a/tests/run/java-varargs-3/Test.scala +++ b/tests/run/java-varargs-3/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { val ai = new A[Int] diff --git a/tests/run/java-varargs/Test_2.scala b/tests/run/java-varargs/Test_2.scala index 912470ed8f19..11bab5b39ac7 100644 --- a/tests/run/java-varargs/Test_2.scala +++ b/tests/run/java-varargs/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { A_1.foo(1) diff --git a/tests/run/java-vc-overload/Test_3.scala b/tests/run/java-vc-overload/Test_3.scala index 7993d00f16ea..34669f91f7f8 100644 --- a/tests/run/java-vc-overload/Test_3.scala +++ b/tests/run/java-vc-overload/Test_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { val a = new A_2 diff --git a/tests/run/junitForwarders/Test.java b/tests/run/junitForwarders/Test.java index 450b38401494..57c4d5b544d8 100644 --- a/tests/run/junitForwarders/Test.java +++ b/tests/run/junitForwarders/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - package org.junit; import java.lang.annotation.ElementType; diff --git a/tests/run/lazy-threadUnsafe-transient.scala b/tests/run/lazy-threadUnsafe-transient.scala new file mode 100644 index 000000000000..a08982dae33f --- /dev/null +++ b/tests/run/lazy-threadUnsafe-transient.scala @@ -0,0 +1,51 @@ +// scalajs: --skip +// https://github.com/scala/scala3/issues/23487 +import java.io.* +import scala.annotation.threadUnsafe + +def serialize[T <: Serializable](obj: T): Array[Byte] = { + val byteArrayOutputStream = new ByteArrayOutputStream() + val objectOutputStream = new ObjectOutputStream(byteArrayOutputStream) + + try { + objectOutputStream.writeObject(obj) + byteArrayOutputStream.toByteArray + } finally { + objectOutputStream.close() + byteArrayOutputStream.close() + } +} + +def deserialize[T](bytes: Array[Byte]): T = { + val byteArrayInputStream = new ByteArrayInputStream(bytes) + val objectInputStream = new ObjectInputStream(byteArrayInputStream) + + try { + objectInputStream.readObject().asInstanceOf[T] + } finally { + objectInputStream.close() + byteArrayInputStream.close() + } +} + +case class Foo() { + @transient + lazy val value: Long = System.nanoTime() +} + +case class Bar() { + @transient @threadUnsafe + lazy val value: Long = System.nanoTime() +} + +@main def Test() = { + val foo1 = Foo() + foo1.value // init lazy val + val foo2 = deserialize[Foo](serialize(foo1)) + assert(foo1.value != foo2.value, "Foo#value is not transient") + + val bar1 = Bar() + bar1.value // init lazy val + val bar2 = deserialize[Bar](serialize(bar1)) + assert(bar1.value != bar2.value, "Bar#value is not transient") +} diff --git a/tests/run/lazyVals_c3.0.0.scala b/tests/run/lazyVals_c3.0.0.scala index 5df4069bc94c..e909c2c8e680 100644 --- a/tests/run/lazyVals_c3.0.0.scala +++ b/tests/run/lazyVals_c3.0.0.scala @@ -1,3 +1,4 @@ +// scalajs: --skip // Compiled with 3.0.0 and run with current compiler class Foo: lazy val x = diff --git a/tests/run/lazyVals_c3.1.0.scala b/tests/run/lazyVals_c3.1.0.scala index 8d36bd4a8825..f53ceddb840b 100644 --- a/tests/run/lazyVals_c3.1.0.scala +++ b/tests/run/lazyVals_c3.1.0.scala @@ -1,3 +1,4 @@ +// scalajs: --skip // Compiled with 3.1.0 and run with current compiler class Foo: lazy val x = diff --git a/tests/run/overload_repeated/B_2.scala b/tests/run/overload_repeated/B_2.scala index c80b308a9185..4b0430ef46a0 100644 --- a/tests/run/overload_repeated/B_2.scala +++ b/tests/run/overload_repeated/B_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def bar1(x: Any) = 1 def bar1(x: String*) = 2 diff --git a/tests/run/pkgobjvals.scala b/tests/run/pkgobjvals.scala index 8df1a984642c..f16241ed6d13 100644 --- a/tests/run/pkgobjvals.scala +++ b/tests/run/pkgobjvals.scala @@ -1,4 +1,4 @@ -import language.experimental.packageObjectValues +//> using options -preview package a: package object b: diff --git a/tests/run/repeatable/Test_1.scala b/tests/run/repeatable/Test_1.scala index 281f91262cce..77ffd29ffefa 100644 --- a/tests/run/repeatable/Test_1.scala +++ b/tests/run/repeatable/Test_1.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - import repeatable._ @Plain_0(1) diff --git a/tests/run/specialized-trait-all-general-raw.scala b/tests/run/specialized-trait-all-general-raw.scala new file mode 100644 index 000000000000..f63bdc6d2565 --- /dev/null +++ b/tests/run/specialized-trait-all-general-raw.scala @@ -0,0 +1,21 @@ +//> using options -language:experimental.specializedTraits +inline trait Foo[A: Specialized, B: Specialized, C: Specialized, D: Specialized, E: Specialized]: + def foo = Thread.currentThread.getStackTrace()(1).getClassName() + +inline trait Bar[A: Specialized, B, E]: + def foo = Thread.currentThread.getStackTrace()(1).getClassName() + +inline trait Baz[A: Specialized]: + def foo = Thread.currentThread.getStackTrace()(1).getClassName() + +@main def Test = + val foo = new Foo[Any, AnyVal, Object, AnyRef, Nothing]() {} + println(foo.foo) + assert(foo.foo == "Foo$impl") + + val bar = new Bar[AnyVal, Int, String]() {} + assert(bar.foo == "Bar$impl") + + val baz = new Baz[(Int, String)]() {} + + assert(baz.foo == "Baz$impl") diff --git a/tests/run/specialized-trait-argument-specializes-current-trait.scala b/tests/run/specialized-trait-argument-specializes-current-trait.scala new file mode 100644 index 000000000000..b3e067793f2c --- /dev/null +++ b/tests/run/specialized-trait-argument-specializes-current-trait.scala @@ -0,0 +1,16 @@ +//> using options -language:experimental.specializedTraits + +inline trait Vec[T: Specialized](elems: Array[T]): + def length = elems.length + + def apply(i: Int): T = elems(i) + + def lengthOfOtherVector(other: Vec[Int]): Int = + other.length + +object Test: + def main(args: Array[String]) = + val x = new Vec[Int](Array(1, 2, 3, 4, 5)) {} + val y = new Vec[Int](Array(3, 4, 5, 6, 7, 9)) {} + assert(x.lengthOfOtherVector(y) == 6) + assert(y.lengthOfOtherVector(x) == 5) diff --git a/tests/run/specialized-trait-as-parameter.scala b/tests/run/specialized-trait-as-parameter.scala new file mode 100644 index 000000000000..ac5eb130a89b --- /dev/null +++ b/tests/run/specialized-trait-as-parameter.scala @@ -0,0 +1,10 @@ +//> using options -language:experimental.specializedTraits +inline trait Trait[T: Specialized]: + def do_something() = println("Good morning") + +inline trait A[T: Specialized]: + def foo(x: Trait[T]) = x + +@main def Test = + val b = new A[Long]() {} + b.foo(new Trait[Long] {}).do_something() diff --git a/tests/run/specialized-trait-as-return-type.scala b/tests/run/specialized-trait-as-return-type.scala new file mode 100644 index 000000000000..2307b766eb0b --- /dev/null +++ b/tests/run/specialized-trait-as-return-type.scala @@ -0,0 +1,14 @@ +//> using options -language:experimental.specializedTraits +inline trait Trait[T: Specialized]: + def do_something() = println("Good morning") + +inline trait A[T: Specialized]: + def foo: Trait[T] + +inline trait B[S: Specialized] extends A[S]: + override def foo = new Trait[S] {} + +@main def Test = + val b = new B[Int]() {} + val f = b.foo + f.do_something() diff --git a/tests/run/specialized-trait-as-val.scala b/tests/run/specialized-trait-as-val.scala new file mode 100644 index 000000000000..dcbc06aa2585 --- /dev/null +++ b/tests/run/specialized-trait-as-val.scala @@ -0,0 +1,10 @@ +//> using options -language:experimental.specializedTraits +inline trait Trait[T: Specialized]: + def do_something() = println("Good morning") + +inline trait A[T: Specialized]: + val t = new Trait[T] {} + +@main def Test = + val b = new A[Int]() {} + b.t.do_something() diff --git a/tests/run/specialized-trait-body-macro-uses-type-param/Macro_1.scala b/tests/run/specialized-trait-body-macro-uses-type-param/Macro_1.scala new file mode 100644 index 000000000000..593623d38800 --- /dev/null +++ b/tests/run/specialized-trait-body-macro-uses-type-param/Macro_1.scala @@ -0,0 +1,10 @@ +//> using options -language:experimental.specializedTraits +import scala.quoted.* + +inline def describe[T]: String = ${ describeImpl[T] } + +def describeImpl[T: Type](using Quotes): Expr[String] = + Expr(Type.show[T]) + +inline trait A[T: Specialized]: + val name: String = describe[T] diff --git a/tests/run/specialized-trait-body-macro-uses-type-param/Test_2.scala b/tests/run/specialized-trait-body-macro-uses-type-param/Test_2.scala new file mode 100644 index 000000000000..6d122f4d491e --- /dev/null +++ b/tests/run/specialized-trait-body-macro-uses-type-param/Test_2.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits + +class B extends A[Int] +class C extends A[String] + +@main def Test = + assert(B().name == "scala.Int", B().name) + assert(C().name == "scala.Predef.String", C().name) diff --git a/tests/run/specialized-trait-check-bridge-exists-hidden-by-inline.scala b/tests/run/specialized-trait-check-bridge-exists-hidden-by-inline.scala new file mode 100644 index 000000000000..249b41341139 --- /dev/null +++ b/tests/run/specialized-trait-check-bridge-exists-hidden-by-inline.scala @@ -0,0 +1,16 @@ +//> using options -language:experimental.specializedTraits +inline trait Trait[T: Specialized]: + def do_something() = println("Good morning") + +inline trait A[T: Specialized]: + def foo(x: Trait[T]): Unit + +inline trait B extends A[Int]: + override def foo(x: Trait[Int]): Unit = x.do_something() + +class C extends B // Should have a bridge for the specialized foo + +@main def Test = + val fooMethods = classOf[C].getDeclaredMethods.filter(_.getName == "foo") + assert(fooMethods.length == 2, s"expected 2 `foo` methods on Bar (real + bridge), found ${fooMethods.length}: ${fooMethods.mkString(", ")}") + diff --git a/tests/run/specialized-trait-check-bridge-exists.scala b/tests/run/specialized-trait-check-bridge-exists.scala new file mode 100644 index 000000000000..8142f1e69592 --- /dev/null +++ b/tests/run/specialized-trait-check-bridge-exists.scala @@ -0,0 +1,13 @@ +//> using options -language:experimental.specializedTraits + +inline trait Foo[T: Specialized]: + def foo(x: Foo[T]): Foo[T] + +class Bar extends Foo[Int]: + override def foo(x: Foo[Int]): Foo[Int] = x + +@main def Test = + val x = Bar() + val fooMethods = classOf[Bar].getDeclaredMethods.filter(_.getName == "foo") + assert(fooMethods.length == 2, s"expected 2 `foo` methods on Bar (real + bridge), found ${fooMethods.length}: ${fooMethods.mkString(", ")}") + diff --git a/tests/run/specialized-trait-check-specialized-method-called.scala b/tests/run/specialized-trait-check-specialized-method-called.scala new file mode 100644 index 000000000000..16f2b0714016 --- /dev/null +++ b/tests/run/specialized-trait-check-specialized-method-called.scala @@ -0,0 +1,26 @@ +//> using options -language:experimental.specializedTraits + +// Check we actually call the specialized method that we should be calling +// We can't easily check the return type, but we can check that we are calling a method +// on Foo$impl$Int$ directly, with no bridge methods in between (this means it's the correct +// method without boxing / unboxing). + +inline trait Foo[T: Specialized](x: T): + def foo = + val stackTrace = Thread.currentThread.getStackTrace() + + // No bridge methods; we call foo directly + assert(stackTrace.toList.tail.takeWhile(call => call.getMethodName().startsWith("foo")).length == 1) + + // We call this method on the correct impl class + assert(Thread.currentThread.getStackTrace()(1).getClassName() == "Foo$impl$scala$Int") + x + +def f(b: Foo[Int]) = + 37 + b.foo + +object Test: + def main(args: Array[String]): Unit = { + val x = new Foo[Int](42) {} + f(x) + } diff --git a/tests/run/specialized-trait-class-extends-specialized-trait-check-specialized.scala b/tests/run/specialized-trait-class-extends-specialized-trait-check-specialized.scala new file mode 100644 index 000000000000..bd717c0545f8 --- /dev/null +++ b/tests/run/specialized-trait-class-extends-specialized-trait-check-specialized.scala @@ -0,0 +1,19 @@ +//> using options -language:experimental.specializedTraits +inline trait Foo[T: Specialized](x: T): + def foo = x + +class Bar extends Foo[Int](10): + def myMethod = "Hello I am a method" + +class Bar2 extends Foo(10): + def myMethod = "Hello I am a method" + +@main def Test = + val y = new Foo(10) {} + val x = Bar() + val traits = classOf[Bar].getInterfaces() + + assert(traits.exists(cl => cl.getName() == "Foo$sp$scala$Int")) + + val traits2 = classOf[Bar2].getInterfaces() + assert(traits2.exists(cl => cl.getName() == "Foo$sp$scala$Int")) diff --git a/tests/run/specialized-trait-collections-example.scala b/tests/run/specialized-trait-collections-example.scala new file mode 100644 index 000000000000..3f7e5d7bb099 --- /dev/null +++ b/tests/run/specialized-trait-collections-example.scala @@ -0,0 +1,28 @@ +//> using options -language:experimental.specializedTraits + +inline trait Iterator[T: Specialized]: + def hasNext: Boolean + def next(): T + +inline trait ArrayIterator[T: Specialized](elems: Array[T]) extends Iterator[T]: + private var current = 0 + def hasNext: Boolean = current < elems.length + def next(): T = try elems(current) finally current += 1 + +inline trait Iterable[T: Specialized]: + def iterator: Iterator[T] + def forall(f: T => Unit): Unit = + val it = iterator + while it.hasNext do f(it.next()) + +inline trait Seq[T: Specialized](elems: Array[T]) extends Iterable[T]: + def length: Int = elems.length + def apply(i: Int): T = elems(i) + def iterator: Iterator[T] = new ArrayIterator[T](elems) {} + +@main def Test = + val elems = Array.from(scala.collection.immutable.Seq(1, 2, 3, 4, 5)) + val seq = new Seq[Int](elems) {} + var x = 0 + seq.forall(v => x += v) + assert(x == 15) diff --git a/tests/run/specialized-trait-diamond/A_1.scala b/tests/run/specialized-trait-diamond/A_1.scala new file mode 100644 index 000000000000..f7d8db67febf --- /dev/null +++ b/tests/run/specialized-trait-diamond/A_1.scala @@ -0,0 +1,7 @@ +//> using options -language:experimental.specializedTraits + +// Lib1 and Lib2 both specialize A, can we share their specializations? +// At the moment we don't. Do we still avoid symbol collisions? + +inline trait A[T: Specialized]: + def foo = Thread.currentThread.getStackTrace()(1).getClassName() diff --git a/tests/run/specialized-trait-diamond/B_2.scala b/tests/run/specialized-trait-diamond/B_2.scala new file mode 100644 index 000000000000..7e8ebb7f03e0 --- /dev/null +++ b/tests/run/specialized-trait-diamond/B_2.scala @@ -0,0 +1,4 @@ +//> using options -language:experimental.specializedTraits + +object B: + val a = new A[Int]() {} \ No newline at end of file diff --git a/tests/run/specialized-trait-diamond/C_3.scala b/tests/run/specialized-trait-diamond/C_3.scala new file mode 100644 index 000000000000..49d99c8c73da --- /dev/null +++ b/tests/run/specialized-trait-diamond/C_3.scala @@ -0,0 +1,4 @@ +//> using options -language:experimental.specializedTraits + +object C: + val a = new A[Int]() {} \ No newline at end of file diff --git a/tests/run/specialized-trait-diamond/D_4.scala b/tests/run/specialized-trait-diamond/D_4.scala new file mode 100644 index 000000000000..7561c8d2f064 --- /dev/null +++ b/tests/run/specialized-trait-diamond/D_4.scala @@ -0,0 +1,5 @@ +//> using options -language:experimental.specializedTraits + +@main def Test = + assert(B.a.foo == "A$impl$scala$Int") + assert(C.a.foo == "A$impl$scala$Int") diff --git a/tests/run/specialized-trait-erasure-impl-classes.scala b/tests/run/specialized-trait-erasure-impl-classes.scala new file mode 100644 index 000000000000..1b850f0aad3f --- /dev/null +++ b/tests/run/specialized-trait-erasure-impl-classes.scala @@ -0,0 +1,50 @@ +//> using options -language:experimental.specializedTraits + +class Animal +class BigCat extends Animal +class Lion extends BigCat + +inline trait A[T: Specialized]: + def foo = Thread.currentThread.getStackTrace()(1).getClassName() + +abstract class methods: + // Specialization takes place + def bar1(a: A[Int]): Unit = assert(a.foo == "A$impl$scala$Int", a.foo) + def bar2(a: A[String]): Unit = assert(a.foo == "A$impl$java$lang$String", a.foo) + def bar3(a: A[Lion]): Unit = assert(a.foo == "A$impl$Animal", a.foo) + def bar4(a: A[BigCat]): Unit = assert(a.foo == "A$impl$Animal", a.foo) + def bar5(a: A[Animal]): Unit = assert(a.foo == "A$impl$Animal", a.foo) + def bar11(a: A[Boolean]): Unit = assert(a.foo == "A$impl$scala$Boolean", a.foo) + def bar12(a: A[Byte]): Unit = assert(a.foo == "A$impl$scala$Byte", a.foo) + def bar13(a: A[Short]): Unit = assert(a.foo == "A$impl$scala$Short", a.foo) + def bar14(a: A[Long]): Unit = assert(a.foo == "A$impl$scala$Long", a.foo) + def bar15(a: A[Float]): Unit = assert(a.foo == "A$impl$scala$Float", a.foo) + def bar16(a: A[Double]): Unit = assert(a.foo == "A$impl$scala$Double", a.foo) + def bar17(a: A[Char]): Unit = assert(a.foo == "A$impl$scala$Char", a.foo) + + // SpecType is a top class -> no $impl$ class generated, just an anonymous class. + def bar6(a: A[List[Int]]): Unit = assert(!a.foo.contains("$impl$"), a.foo) + def bar7(a: A[IArray[Boolean]]): Unit = assert(!a.foo.contains("$impl$"), a.foo) + def bar8(a: A[Object]): Unit = assert(!a.foo.contains("$impl$"), a.foo) + def bar9(a: A[AnyVal]): Unit = assert(!a.foo.contains("$impl$"), a.foo) + def bar10(a: A[AnyRef]): Unit = assert(!a.foo.contains("$impl$"), a.foo) + +@main def Test = + val m = new methods {} + m.bar1(new A[Int]() {}) + m.bar2(new A[String]() {}) + m.bar3(new A[Lion]() {}) + m.bar4(new A[BigCat]() {}) + m.bar5(new A[Animal]() {}) + m.bar6(new A[List[Int]]() {}) + m.bar7(new A[IArray[Boolean]]() {}) + m.bar8(new A[Object]() {}) + m.bar9(new A[AnyVal]() {}) + m.bar10(new A[AnyRef]() {}) + m.bar11(new A[Boolean]() {}) + m.bar12(new A[Byte]() {}) + m.bar13(new A[Short]() {}) + m.bar14(new A[Long]() {}) + m.bar15(new A[Float]() {}) + m.bar16(new A[Double]() {}) + m.bar17(new A[Char]() {}) diff --git a/tests/run/specialized-trait-erasure.scala b/tests/run/specialized-trait-erasure.scala new file mode 100644 index 000000000000..d731b6c30fc1 --- /dev/null +++ b/tests/run/specialized-trait-erasure.scala @@ -0,0 +1,45 @@ +//> using options -language:experimental.specializedTraits + +class Animal +class BigCat extends Animal +class Lion extends BigCat + +inline trait A[T: Specialized]: + def foo = Thread.currentThread.getStackTrace()(1).getClassName() + +abstract class methods: + def bar1(a: A[Int]): Int // A[Int] -> A$sp$Int + def bar2(a: A[String]): String // A[String] -> A$sp$String + def bar3(a: A[Lion]): Lion // A[Lion] -> A$sp$Animal + def bar4(a: A[BigCat]): Lion // A[BigCat] -> A$sp$Animal + def bar5(a: A[Animal]): Lion // A[Animal] -> A$sp$Animal + + def bar6(a: A[List[Int]]): Lion // A[List[Int]] -> A + def bar7(a: A[IArray[Boolean]]): Lion // A[IArray[Bool]] -> A + def bar8(a: A[Object]): Lion // A[Object] -> A + def bar9(a: A[AnyVal]): Lion // A[AnyVal] -> A + def bar10(a: A[AnyRef]): Lion // A[AnyRef] -> A + +@main def Test = + val expectedParamErasure = Map( + "bar1" -> "A$sp$scala$Int", + "bar2" -> "A$sp$java$lang$String", + "bar3" -> "A$sp$Animal", + "bar4" -> "A$sp$Animal", + "bar5" -> "A$sp$Animal", + "bar6" -> "A", + "bar7" -> "A", + "bar8" -> "A", + "bar9" -> "A", + "bar10" -> "A", + ) + + val actualParamErasure = classOf[methods].getDeclaredMethods.iterator + .filter(_.getName.startsWith("bar")) + .map(m => m.getName -> m.getParameterTypes.head.getName) + .toMap + + for (name, expected) <- expectedParamErasure do + val actual = actualParamErasure.getOrElse( + name, sys.error(s"method $name not found on class methods")) + assert(actual == expected, s"$name: expected param type $expected, got $actual") diff --git a/tests/run/specialized-trait-inline-specialization-macro/Macro_1.scala b/tests/run/specialized-trait-inline-specialization-macro/Macro_1.scala new file mode 100644 index 000000000000..3bcdbf6dd476 --- /dev/null +++ b/tests/run/specialized-trait-inline-specialization-macro/Macro_1.scala @@ -0,0 +1,16 @@ +//> using options -language:experimental.specializedTraits +import scala.quoted.* + +inline def foo(): Unit = + ${fooImpl} + +def fooImpl(using Quotes): Expr[Unit] = + '{ + val x = new A[Int]() {} + assert(x.foo(15) == 10) + assert(x.bar == "A$impl$scala$Int") + } + +inline trait A[T: Specialized]: + def foo(x: T) = 10 + def bar = Thread.currentThread.getStackTrace()(1).getClassName() diff --git a/tests/run/specialized-trait-inline-specialization-macro/Test_2.scala b/tests/run/specialized-trait-inline-specialization-macro/Test_2.scala new file mode 100644 index 000000000000..527d156fc648 --- /dev/null +++ b/tests/run/specialized-trait-inline-specialization-macro/Test_2.scala @@ -0,0 +1,4 @@ +//> using options -language:experimental.specializedTraits + +@main def Test = + foo() \ No newline at end of file diff --git a/tests/run/specialized-trait-inline-specialized-instance-hidden/A_1.scala b/tests/run/specialized-trait-inline-specialized-instance-hidden/A_1.scala new file mode 100644 index 000000000000..f6ca2ab21d07 --- /dev/null +++ b/tests/run/specialized-trait-inline-specialized-instance-hidden/A_1.scala @@ -0,0 +1,9 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T: Specialized]: + def foo() = assert(Thread.currentThread.getStackTrace()(1).getClassName() == "A$impl$scala$Int") + +inline def bar = + val x = new A[Int]() {} + x.foo() + 5 diff --git a/tests/run/specialized-trait-inline-specialized-instance-hidden/B_2.scala b/tests/run/specialized-trait-inline-specialized-instance-hidden/B_2.scala new file mode 100644 index 000000000000..d57d993d3053 --- /dev/null +++ b/tests/run/specialized-trait-inline-specialized-instance-hidden/B_2.scala @@ -0,0 +1,4 @@ +//> using options -language:experimental.specializedTraits + +@main def Test = + assert(bar == 5) diff --git a/tests/run/specialized-trait-inline-specialized-instance-with-specialization/A_1.scala b/tests/run/specialized-trait-inline-specialized-instance-with-specialization/A_1.scala new file mode 100644 index 000000000000..4026e3488c96 --- /dev/null +++ b/tests/run/specialized-trait-inline-specialized-instance-with-specialization/A_1.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T: Specialized]: + def foo() = assert(Thread.currentThread.getStackTrace()(1).getClassName() == "A$impl$scala$Int") + +inline def bar[T: Specialized] = new A[T]() {} diff --git a/tests/run/specialized-trait-inline-specialized-instance-with-specialization/B_2.scala b/tests/run/specialized-trait-inline-specialized-instance-with-specialization/B_2.scala new file mode 100644 index 000000000000..305743252757 --- /dev/null +++ b/tests/run/specialized-trait-inline-specialized-instance-with-specialization/B_2.scala @@ -0,0 +1,4 @@ +//> using options -language:experimental.specializedTraits + +@main def Test = + bar[Int].foo() diff --git a/tests/run/specialized-trait-inline-specialized-instance/A_1.scala b/tests/run/specialized-trait-inline-specialized-instance/A_1.scala new file mode 100644 index 000000000000..35220628cef2 --- /dev/null +++ b/tests/run/specialized-trait-inline-specialized-instance/A_1.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T: Specialized]: + def foo() = assert(Thread.currentThread.getStackTrace()(1).getClassName() == "A$impl$scala$Int") + +inline def bar = new A[Int]() {} diff --git a/tests/run/specialized-trait-inline-specialized-instance/B_2.scala b/tests/run/specialized-trait-inline-specialized-instance/B_2.scala new file mode 100644 index 000000000000..b9cb802a15a1 --- /dev/null +++ b/tests/run/specialized-trait-inline-specialized-instance/B_2.scala @@ -0,0 +1,4 @@ +//> using options -language:experimental.specializedTraits + +@main def Test = + bar.foo() diff --git a/tests/run/specialized-trait-inlining-loop.scala b/tests/run/specialized-trait-inlining-loop.scala new file mode 100644 index 000000000000..034c1cc256b1 --- /dev/null +++ b/tests/run/specialized-trait-inlining-loop.scala @@ -0,0 +1,25 @@ +//> using options -language:experimental.specializedTraits +inline trait T1[T: Specialized]: + def bar1 = myInlineMethod1[T] + +inline trait T2[T: Specialized]: + def bar2 = myInlineMethod2[T] + +inline trait T3[T: Specialized]: + def foo(x: T): T = x + +inline def myInlineMethod1[T: Specialized] = new T2[T]() {} +inline def myInlineMethod2[T: Specialized] = new T3[T]() {} + +@main def Test = + val x = new T1[Int]() {} + assert(x.bar1.bar2.foo(10) == 10) + +// Need to: +// 1) Create T1$impl$Int$ and inline `def bar1 = myInlineMethod1[Int]` (desugarSpecializedTraits) +// 2) Inline myInlineMethod1 into bar1 inside T1$impl$Int (inlining) +// 3) Create T2$impl$Int and fix the inlined definition of bar1/myInlineMethod1 (desugarSpecializedTraits) +// 4) Inline myInlineMethod2 into bar2 inside T2$impl$Int +// 5) Create T3$impl$Int and fix the inlined definition of bar2/myInlineMethod2 (desugarSpecializedTraits) + +// This can continue for arbitrarily many inlines and you don't know in advance that any of these specializations need to be created. diff --git a/tests/run/specialized-trait-list-of-specialized-trait.scala b/tests/run/specialized-trait-list-of-specialized-trait.scala new file mode 100644 index 000000000000..446276c0e8c7 --- /dev/null +++ b/tests/run/specialized-trait-list-of-specialized-trait.scala @@ -0,0 +1,9 @@ +//> using options -language:experimental.specializedTraits +inline trait Foo[T: Specialized]: + def foo = Thread.currentThread.getStackTrace()(1).getClassName() + +def bar(xs: List[Foo[Int]]) = xs.head + +@main def Test = + val myList = List(new Foo[Int]() {}, new Foo[Int]() {}) + assert(bar(myList).foo == "Foo$impl$scala$Int") diff --git a/tests/run/specialized-trait-list-zip-example.check b/tests/run/specialized-trait-list-zip-example.check new file mode 100644 index 000000000000..d12f0d8f3af1 --- /dev/null +++ b/tests/run/specialized-trait-list-zip-example.check @@ -0,0 +1,4 @@ +The population of Switzerland is 9.1 million and its capital is Bern +The population of France is 68.52 million and its capital is Paris +The population of The Netherlands is 18.4 million and its capital is Berlin +The population of Germany is 83.5 million and its capital is The Hague diff --git a/tests/run/specialized-trait-list-zip-example.scala b/tests/run/specialized-trait-list-zip-example.scala new file mode 100644 index 000000000000..b75eb7848c9b --- /dev/null +++ b/tests/run/specialized-trait-list-zip-example.scala @@ -0,0 +1,45 @@ +//> using options -language:experimental.specializedTraits + +import scala.annotation.nowarn + +@nowarn("id=E233") +sealed inline trait List[+T: Specialized]: + inline def zip[S: Specialized](other: List[S]): List[(T, S)] = + def zip(xxs: List[T], yys: List[S]): List[(T, S)] = (xxs, yys) match { + case (_: Nill[_], _) => Nill() + case (_, _: Nill[_]) => Nill() + case (xxs: :+:[T @unchecked], yys: :+:[S @unchecked]) => :+:((xxs.head, yys.head), zip(xxs.tail, yys.tail)) + } + zip(this, other) + + def foreach[S](f: T => Unit): Unit = (this: List[T]) match { // TODO: Can we avoid the need to cast this to List[T] here? Should it not already be of that type? + case xs: :+:[T @unchecked] => f(xs.head); xs.tail.foreach(f) + case _: Nill[_] => + } + + +sealed inline trait Nill[T: Specialized] extends List[T] +sealed inline trait :+:[T: Specialized](val head: T, val tail: List[T]) extends List[T] + +object Nill { + inline def apply[T: Specialized]() = new Nill[T]() {} +} + +object :+: { + inline def apply[T: Specialized](head: T, tail: List[T]): List[T] = + new :+:[T](head, tail) {} +} + +object List: + inline def apply[T: Specialized](values: T*) = + values.foldRight[List[T]](Nill())(:+:.apply) + +@main def Test = + val xs: List[Double] = :+:(9.1, :+:(68.52, :+:(18.4, :+:(83.5, Nill[Double]())))) // TODO : Can we prevent the need for an explicit type here or at least make it clearer + val ys = List("Switzerland", "France", "The Netherlands", "Germany") + val zs = List("Bern", "Paris", "Berlin", "The Hague") + + xs.zip(ys).zip(zs).foreach( (numberCountry, capital) => + val (number, country) = numberCountry + println(s"The population of ${country} is ${number} million and its capital is ${capital}") + ) diff --git a/tests/run/specialized-trait-manual-class-extend-not-top-of-hierarchy.scala b/tests/run/specialized-trait-manual-class-extend-not-top-of-hierarchy.scala new file mode 100644 index 000000000000..8ab8450dbdae --- /dev/null +++ b/tests/run/specialized-trait-manual-class-extend-not-top-of-hierarchy.scala @@ -0,0 +1,13 @@ +//> using options -language:experimental.specializedTraits + +class Animal +class Mammal extends Animal +class Binturong extends Mammal + +inline trait A[T: Specialized] + +class B extends A[Binturong] + +@main def Test = + val traits = classOf[B].getInterfaces() + assert(traits.exists(cl => cl.getName() == "A$sp$Animal")) diff --git a/tests/run/specialized-trait-masked-inline-specialization-via-inlining.scala b/tests/run/specialized-trait-masked-inline-specialization-via-inlining.scala new file mode 100644 index 000000000000..5b21dbe9d3b9 --- /dev/null +++ b/tests/run/specialized-trait-masked-inline-specialization-via-inlining.scala @@ -0,0 +1,13 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T: Specialized]: + def foo() = assert(Thread.currentThread.getStackTrace()(1).getClassName() == "A$impl$scala$Int") + +inline def myMethod0[T: Specialized] = new A[T]() {} +inline def myMethod1 = myMethod0[Int] +inline def myMethod2 = myMethod1 +inline def myMethod3 = myMethod2 + +@main def Test = + val v = myMethod3 + v.foo() diff --git a/tests/run/specialized-trait-masked-inline-specialized.scala b/tests/run/specialized-trait-masked-inline-specialized.scala new file mode 100644 index 000000000000..69f1618b8480 --- /dev/null +++ b/tests/run/specialized-trait-masked-inline-specialized.scala @@ -0,0 +1,12 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T: Specialized]: + def foo() = assert(Thread.currentThread.getStackTrace()(1).getClassName() == "A$impl$scala$Int") + +inline def myMethod1 = new A[Int]() {} +inline def myMethod2 = myMethod1 +inline def myMethod3 = myMethod2 + +@main def Test = + val v = myMethod3 + v.foo() diff --git a/tests/run/specialized-trait-maths.scala b/tests/run/specialized-trait-maths.scala new file mode 100644 index 000000000000..25ca7da8ceec --- /dev/null +++ b/tests/run/specialized-trait-maths.scala @@ -0,0 +1,13 @@ +//> using options -language:experimental.specializedTraits + +inline trait Foo[T: Specialized](x: T): + def foo = x + +def f(b: Foo[Int]) = 37 + b.foo + +object Test: + def main(args: Array[String]): Unit = { + val x = new Foo[Int](42) {} + val y = f(x) + assert(y == 79) + } diff --git a/tests/run/specialized-trait-multiple-files/A_1.scala b/tests/run/specialized-trait-multiple-files/A_1.scala new file mode 100644 index 000000000000..9fb078f6bccf --- /dev/null +++ b/tests/run/specialized-trait-multiple-files/A_1.scala @@ -0,0 +1,6 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T: Specialized]: + def foo(x: T):T = x + +class B extends A[Int] diff --git a/tests/run/specialized-trait-multiple-files/B_2.scala b/tests/run/specialized-trait-multiple-files/B_2.scala new file mode 100644 index 000000000000..7843ebadf48f --- /dev/null +++ b/tests/run/specialized-trait-multiple-files/B_2.scala @@ -0,0 +1,10 @@ +//> using options -language:experimental.specializedTraits + +class C extends A[Int] + +@main def Test = + val b = B() + val c = C() + + println(b.foo(10)) + println(c.foo(10)) \ No newline at end of file diff --git a/tests/run/specialized-trait-multiple-package-same-file-nested.scala b/tests/run/specialized-trait-multiple-package-same-file-nested.scala new file mode 100644 index 000000000000..d44ba22053cc --- /dev/null +++ b/tests/run/specialized-trait-multiple-package-same-file-nested.scala @@ -0,0 +1,30 @@ +//> using options -language:experimental.specializedTraits +package owner { + package package1 { + inline trait A[T: Specialized]: + def foo(x: T) = "Package 1!" + def bar = Thread.currentThread.getStackTrace()(1).getClassName() + class B extends A[Int] + class C extends A[String] + } + + package package2 { + inline trait A[T: Specialized]: + def foo(x: T) = "Package 2!" + def bar = Thread.currentThread.getStackTrace()(1).getClassName() + class B extends A[Int] + class C extends A[String] + } +} + +@main def Test = + val b = owner.package1.B() + val c = owner.package2.C() + assert(b.foo(10) == "Package 1!") + assert(c.foo("Hello World") == "Package 2!") + + val d = new owner.package1.A[Int]() {} + val e = new owner.package2.A[Int]() {} + assert(d.bar == "owner.package1.A$impl$scala$Int") + assert(e.bar == "owner.package2.A$impl$scala$Int") + diff --git a/tests/run/specialized-trait-multiple-package-same-file.scala b/tests/run/specialized-trait-multiple-package-same-file.scala new file mode 100644 index 000000000000..be6b83aa5465 --- /dev/null +++ b/tests/run/specialized-trait-multiple-package-same-file.scala @@ -0,0 +1,28 @@ +//> using options -language:experimental.specializedTraits + +package package1 { + inline trait A[T: Specialized]: + def foo(x: T) = "Package 1!" + def bar = Thread.currentThread.getStackTrace()(1).getClassName() + class B extends A[Int] + class C extends A[String] +} + +package package2 { + inline trait A[T: Specialized]: + def foo(x: T) = "Package 2!" + def bar = Thread.currentThread.getStackTrace()(1).getClassName() + class B extends A[Int] + class C extends A[String] +} + +@main def Test = + val b = package1.B() + val c = package2.C() + assert(b.foo(10) == "Package 1!") + assert(c.foo("Hello World") == "Package 2!") + + val d = new package1.A[Int]() {} + val e = new package2.A[Int]() {} + assert(d.bar == "package1.A$impl$scala$Int") + assert(e.bar == "package2.A$impl$scala$Int") diff --git a/tests/run/specialized-trait-multiple-parameter-packs-method.scala b/tests/run/specialized-trait-multiple-parameter-packs-method.scala new file mode 100644 index 000000000000..f03d2302ce02 --- /dev/null +++ b/tests/run/specialized-trait-multiple-parameter-packs-method.scala @@ -0,0 +1,20 @@ +//> using options -language:experimental.specializedTraits + + +inline trait A[T: Specialized, S: Numeric](val x: T)(val y: T)(val z: S)(p: S): + def getArgs = (x, y, z, p) + +inline def foo[P: Specialized](x: P)[Q: {Specialized, Numeric}](y: P, z: Q, p: Q) = new A[P, Q](x)(y)(z)(p) {} + +inline trait B[T: Specialized](val w: T): + inline def foo[P: Specialized](x: P, z: P)[Q: Specialized](y: Q, f: P) = + val b = new B[P](x) {} + val c = new B[Q](y) {} + c + +@main def Test = + val a = foo[String]("Good evening")[Long]("Good morning", 1_000_000_000_000_000L, 1_000_000_000_000_001L) + assert(a.getArgs == ("Good evening", "Good morning", 1_000_000_000_000_000L, 1_000_000_000_000_001L)) + + val b = new B[Boolean](true) {} + assert(b.foo[Float](1.1, 2.2)[Short](1, 3.3).w == 1) diff --git a/tests/run/specialized-trait-multiple-parameter-packs.scala b/tests/run/specialized-trait-multiple-parameter-packs.scala new file mode 100644 index 000000000000..eb7710b00601 --- /dev/null +++ b/tests/run/specialized-trait-multiple-parameter-packs.scala @@ -0,0 +1,14 @@ +//> using options -language:experimental.specializedTraits + +inline trait A[T: Specialized, S: Numeric](val x: T)(val y: T)(val z: S)(p: S): + val p2 = p + def getArgs = (x, y, z, p2) + +class B(w: Int)(e: String) extends A[String, Int](e)("Y")(100)(w) + +@main def Test = + val b = B(41)("Good Morning") + assert(b.getArgs == ("Good Morning", "Y", 100, 41)) + + val a = new A[Boolean, Long](true)(false)(1000000000)(-10) {} + assert(a.getArgs == (true, false, 1000000000, -10)) diff --git a/tests/run/specialized-trait-one-parent-is-inline.scala b/tests/run/specialized-trait-one-parent-is-inline.scala new file mode 100644 index 000000000000..e9a6fd56f831 --- /dev/null +++ b/tests/run/specialized-trait-one-parent-is-inline.scala @@ -0,0 +1,15 @@ +//> using options -language:experimental.specializedTraits + +inline trait Foo[T: Specialized] +inline trait A[T](x: T): + def foo: T = x + +class B extends A[Int](15), Foo: + val y = 1 + +def h(x: B) = x.foo + +@main def Test = + val b = B() + assert(h(b) == 15) + assert(b.y == 1) diff --git a/tests/run/specialized-trait-package-contains-object-multi-file/A_1.scala b/tests/run/specialized-trait-package-contains-object-multi-file/A_1.scala new file mode 100644 index 000000000000..0810149ba75e --- /dev/null +++ b/tests/run/specialized-trait-package-contains-object-multi-file/A_1.scala @@ -0,0 +1,11 @@ +//> using options -language:experimental.specializedTraits +package package1 { + object Outer: + object Inner: + inline trait A[T: Specialized]: + def foo(x: T) = "Package 1!" + def bar = Thread.currentThread.getStackTrace()(1).getClassName() + class B extends Outer.Inner.A[Int] + class C extends Outer.Inner.A[String] +} + diff --git a/tests/run/specialized-trait-package-contains-object-multi-file/B_2.scala b/tests/run/specialized-trait-package-contains-object-multi-file/B_2.scala new file mode 100644 index 000000000000..b7984b4d8708 --- /dev/null +++ b/tests/run/specialized-trait-package-contains-object-multi-file/B_2.scala @@ -0,0 +1,11 @@ +//> using options -language:experimental.specializedTraits + +@main def Test = + val b = package1.B() + val c = package1.C() + assert(b.foo(10) == "Package 1!") + assert(c.foo("Hello World") == "Package 1!") + + val d = new package1.Outer.Inner.A[Int]() {} + println(d.bar) + assert(d.bar == "package1.Outer$Inner$$A$impl$scala$Int") diff --git a/tests/run/specialized-trait-package-contains-object.scala b/tests/run/specialized-trait-package-contains-object.scala new file mode 100644 index 000000000000..0489a1e9baa8 --- /dev/null +++ b/tests/run/specialized-trait-package-contains-object.scala @@ -0,0 +1,20 @@ +//> using options -language:experimental.specializedTraits +package package1 { + object Outer: + object Inner: + inline trait A[T: Specialized]: + def foo(x: T) = "Package 1!" + def bar = Thread.currentThread.getStackTrace()(1).getClassName() + class B extends Outer.Inner.A[Int] + class C extends Outer.Inner.A[String] +} + +@main def Test = + val b = package1.B() + val c = package1.C() + assert(b.foo(10) == "Package 1!") + assert(c.foo("Hello World") == "Package 1!") + + val d = new package1.Outer.Inner.A[Int]() {} + assert(d.bar == "package1.Outer$Inner$$A$impl$scala$Int") + diff --git a/tests/run/specialized-trait-package/A_1.scala b/tests/run/specialized-trait-package/A_1.scala new file mode 100644 index 000000000000..57eecffa6c17 --- /dev/null +++ b/tests/run/specialized-trait-package/A_1.scala @@ -0,0 +1,8 @@ +//> using options -language:experimental.specializedTraits + +package package1 + +inline trait A[T: Specialized]: + def foo(x: T) = "Package 1!" + def bar = Thread.currentThread.getStackTrace()(1).getClassName() + \ No newline at end of file diff --git a/tests/run/specialized-trait-package/A_2.scala b/tests/run/specialized-trait-package/A_2.scala new file mode 100644 index 000000000000..268ee13bffe8 --- /dev/null +++ b/tests/run/specialized-trait-package/A_2.scala @@ -0,0 +1,7 @@ +//> using options -language:experimental.specializedTraits + +package package2 + +inline trait A[T: Specialized]: + def foo(x: T) = "Package 2!" + def bar = Thread.currentThread.getStackTrace()(1).getClassName() diff --git a/tests/run/specialized-trait-package/B_3.scala b/tests/run/specialized-trait-package/B_3.scala new file mode 100644 index 000000000000..93a5c9ba801b --- /dev/null +++ b/tests/run/specialized-trait-package/B_3.scala @@ -0,0 +1,21 @@ +//> using options -language:experimental.specializedTraits +class B extends package1.A[Int] +class C extends package2.A[Int] + +@main def Test = + val b = B() + val c = C() + assert(b.foo(10) == "Package 1!") + assert(c.foo(11) == "Package 2!") + + val d = new package1.A[Int]() {} + val e = new package2.A[Int]() {} + assert(d.bar == "package1.A$impl$scala$Int") + assert(e.bar == "package2.A$impl$scala$Int") + + import package1.A + import package2.A as A2 + val f = new A[Int]() {} + val g = new A2[Int]() {} + assert(d.bar == "package1.A$impl$scala$Int") + assert(e.bar == "package2.A$impl$scala$Int") diff --git a/tests/run/specialized-trait-pathological-context-bounds.scala b/tests/run/specialized-trait-pathological-context-bounds.scala new file mode 100644 index 000000000000..d299704034eb --- /dev/null +++ b/tests/run/specialized-trait-pathological-context-bounds.scala @@ -0,0 +1,16 @@ +//> using options -language:experimental.specializedTraits + +trait A[T, R, Q] + +inline trait Trait[T: {Specialized, Numeric}, S <: Object, Q: Numeric, R: Specialized, D: {Numeric, Specialized}](a: Int) extends A[S, Char, T] { + def bar = "Buna saira" +} + +def foo(v: Trait[Int, String, Int, Int, Int]) = v + +object Test: + def main(args: Array[String]): Unit = { + val a = new Trait[Int, String, Int, Int, Int](5) {} + assert(foo(a).bar == "Buna saira") + } + diff --git a/tests/run/specialized-trait-requires-inline-trait-inlining.scala b/tests/run/specialized-trait-requires-inline-trait-inlining.scala new file mode 100644 index 000000000000..2f5532f93e7c --- /dev/null +++ b/tests/run/specialized-trait-requires-inline-trait-inlining.scala @@ -0,0 +1,12 @@ +//> using options -language:experimental.specializedTraits + +inline trait T1[T]: + def boo(x: T): T = x + +inline trait T[T: Specialized]: + def ff = new T1[T]() { + def id(x: T): T = x + } + +@main def Test = + val a = new T[Int]() {} diff --git a/tests/run/specialized-trait-scoped-inside-object-2.scala b/tests/run/specialized-trait-scoped-inside-object-2.scala new file mode 100644 index 000000000000..d6c53971f589 --- /dev/null +++ b/tests/run/specialized-trait-scoped-inside-object-2.scala @@ -0,0 +1,12 @@ +//> using options -language:experimental.specializedTraits + +object MySpecializedStuff: + inline trait Foo[T: Specialized]: + def bar = "Bar" + + class Bar extends Foo[Char] + def foo(x: Foo[Char]) = x.bar + +@main def Test = + val x = new MySpecializedStuff.Bar() + assert(MySpecializedStuff.foo(x) == "Bar") diff --git a/tests/run/specialized-trait-scoped-inside-object-3.scala b/tests/run/specialized-trait-scoped-inside-object-3.scala new file mode 100644 index 000000000000..adec56fcfd66 --- /dev/null +++ b/tests/run/specialized-trait-scoped-inside-object-3.scala @@ -0,0 +1,13 @@ +//> using options -language:experimental.specializedTraits + +object MySpecializedStuff: + inline trait Foo[T: Specialized]: + def bar = "Bar" + +object MySpecializedStuff2: + class Bar extends MySpecializedStuff.Foo[Char] + def foo(x: MySpecializedStuff.Foo[Char]) = x.bar + +@main def Test = + val x = new MySpecializedStuff2.Bar() + assert(MySpecializedStuff2.foo(x) == "Bar") diff --git a/tests/run/specialized-trait-scoped-inside-object.scala b/tests/run/specialized-trait-scoped-inside-object.scala new file mode 100644 index 000000000000..ec14264a72a7 --- /dev/null +++ b/tests/run/specialized-trait-scoped-inside-object.scala @@ -0,0 +1,9 @@ +//> using options -language:experimental.specializedTraits + +object MySpecializedStuff: + inline trait Foo[T: Specialized]: + def bar = "Bar" + + def foo = new Foo[Int] {} + +@main def Test = MySpecializedStuff.foo.bar diff --git a/tests/run/specialized-trait-self-inline.check b/tests/run/specialized-trait-self-inline.check new file mode 100644 index 000000000000..303f1addebc6 --- /dev/null +++ b/tests/run/specialized-trait-self-inline.check @@ -0,0 +1,6 @@ +5.0 +4.0 +3.0 +2.0 +1.0 +Lift Off! diff --git a/tests/run/specialized-trait-self-inline.scala b/tests/run/specialized-trait-self-inline.scala new file mode 100644 index 000000000000..044ff505178f --- /dev/null +++ b/tests/run/specialized-trait-self-inline.scala @@ -0,0 +1,17 @@ +//> using options -language:experimental.specializedTraits +//> using scala 3.9.0-RC1-bin-SNAPSHOT-nonbootstrapped + +import math.Numeric.Implicits.infixNumericOps +import math.Ordering.Implicits.infixOrderingOps + +inline trait Foo[T: {Specialized, Numeric}]: + inline def foo[S: Specialized](inline x: Int, inline y: Int, inline w: T, inline z: S): S = + inline if x < y then + z + else + println(w) + foo(x - 1, y, w - summon[Numeric[T]].one, z) + +@main def Test = + val x = new Foo[Double] {} + println(x.foo(10, 6, 5, "Lift Off!")) diff --git a/tests/run/specialized-trait-subtyping-once-specialized.scala b/tests/run/specialized-trait-subtyping-once-specialized.scala new file mode 100644 index 000000000000..9ae5fbd742fa --- /dev/null +++ b/tests/run/specialized-trait-subtyping-once-specialized.scala @@ -0,0 +1,9 @@ +//> using options -language:experimental.specializedTraits +inline trait T1[T: Specialized] +inline trait T2[T: Specialized] extends T1[T] + +def foo(x: T1[Int]) = println("foo") + +@main def Test = + val x = new T2[Int]() {} + foo(x) diff --git a/tests/run/specialized-trait-super-chain.scala b/tests/run/specialized-trait-super-chain.scala new file mode 100644 index 000000000000..73bd635f83e9 --- /dev/null +++ b/tests/run/specialized-trait-super-chain.scala @@ -0,0 +1,46 @@ +//> using options -language:experimental.specializedTraits +var hops = 0 + +inline trait A[T: Specialized]: + def foo() = + hops += 1 + "A" + +inline trait B[T: Specialized] extends A[T]: + override def foo() = + hops += 1 + super.foo() + +inline trait C[T: Specialized] extends B[T]: + override def foo() = + hops += 1 + "B" + +inline trait D[T: Specialized] extends C[T]: + override def foo() = + hops += 1 + super.foo() + +inline trait E[T: Specialized] extends D[T]: + override def foo() = + hops += 1 + super.foo() + +inline trait F[T: Specialized] extends E[T]: + override def foo() = + hops += 1 + super.foo() + +class C1 extends F[Int] + +@main def Test = + hops = 0 + val cl = C1() + assert(cl.foo() == "B") + assert(hops == 4) + + hops = 0 + val cl2 = new F[String]() {} + assert(cl.foo() == "B") + assert(hops == 4) + diff --git a/tests/run/specialized-trait-varargs.scala b/tests/run/specialized-trait-varargs.scala new file mode 100644 index 000000000000..ca5affc8fa2f --- /dev/null +++ b/tests/run/specialized-trait-varargs.scala @@ -0,0 +1,10 @@ +//> using options -language:experimental.specializedTraits + +inline trait ListA[T: Specialized](vals: T*): + def printVals() = + vals.foreach(println(_)) + +@main def Test = + val bungle: List[Short] = List(4123, 6, 7, 8, 10, 5, 11, 100) + val x = new ListA[Short](bungle*) {} + x.printVals() diff --git a/tests/run/specialized-trait-variance.scala b/tests/run/specialized-trait-variance.scala new file mode 100644 index 000000000000..e10d5caf8a0b --- /dev/null +++ b/tests/run/specialized-trait-variance.scala @@ -0,0 +1,53 @@ +//> using options -language:experimental.specializedTraits + +import scala.annotation.nowarn + +trait Animal: + def makeNoise: String +class Lion extends Animal: + override def makeNoise = "ROAR!" +class Dog extends Animal: + override def makeNoise: String = "BARK!" + +trait Material +class Paper extends Material +class Newspaper extends Paper + +inline trait MyList[+T: Specialized](val xs: List[T]): + def map[S](f: T => S) = xs.map(f) + +inline trait Bin[-T: Specialized]: + def throwAway(x: T) = println(s"Throwing away ${x}") + +def sound(animals: MyList[Animal]) = + animals.map(_.makeNoise) + +def throwAwayTheNewspaper(bin: Bin[Newspaper]) = + val newspaper = Newspaper() + bin.throwAway(newspaper) + +def throwAwayAnInteger(bin: Bin[Int]) = + val integer = 100 + bin.throwAway(integer) + +def throwAwayAnObject(bin: Bin[Object]) = + val obj = "good morning" + bin.throwAway(obj) + +def throwAwayAnAnyVal(bin: Bin[AnyVal]) = + val bc: AnyVal = 400 + bin.throwAway(bc) + +@main def Test = + val myDogs: MyList[Dog] = new MyList(List(Dog(), Dog(), Dog())) {} + sound(myDogs) // MyList[Dog] can be interpreted as MyList[Animal] due to covariance + + val myWastepaperBasket = new Bin[Paper]() {} + throwAwayTheNewspaper(myWastepaperBasket) // Bin[Paper] can be interpreted as Bin[Newspaper] due to contravariance + + // Fine; same erasure bucket + val myAnyBin = new Bin[Any] {} + val myAnyRefBin = new Bin[Any] {} + throwAwayAnObject(myAnyBin) + throwAwayAnObject(myAnyRefBin) + throwAwayAnAnyVal(myAnyBin) diff --git a/tests/run/specialized-trait-vector-dot-product.scala b/tests/run/specialized-trait-vector-dot-product.scala new file mode 100644 index 000000000000..4d2112f2b185 --- /dev/null +++ b/tests/run/specialized-trait-vector-dot-product.scala @@ -0,0 +1,38 @@ +//> using options -language:experimental.specializedTraits + +inline trait Vec[T: {Specialized, Numeric2}](elems: Array[T]): + private val num = summon[Numeric2[T]] + + def length = elems.length + + def apply(i: Int): T = elems(i) + + def scalarProduct(other: Vec[T]): T = + require(this.length == other.length) + var result = num.fromInt(0) + for i <- 0 until length do + result = num.plus(result, num.times(this(i), other(i))) + result + +object Vec: + inline def apply[T: {Specialized, Numeric2}](elems: Array[T]) = new Vec[T](elems) {} +end Vec + +object Test: + def main(args: Array[String]) = + implicit val v: Numeric2[Int] = new IntIsIntegral() {} + val x = Vec[Int](Array(1, 2, 3, 4, 5)) + val y = Vec[Int](Array(3, 4, 5, 6, 7)) + val z = x.scalarProduct(y) + assert(z == 85) + +inline trait Numeric2[T: Specialized]: + def fromInt(x: Int): T + def plus(x: T, y: T): T + def times(x: T, y: T): T + +class IntIsIntegral extends Numeric2[Int]: + override def fromInt(x: Int): Int = x + override def plus(x: Int, y: Int): Int = x + y + override def times(x: Int, y: Int): Int = x * y + diff --git a/tests/run/specialized-trait-vector-zip.check b/tests/run/specialized-trait-vector-zip.check new file mode 100644 index 000000000000..d017a5333fe6 --- /dev/null +++ b/tests/run/specialized-trait-vector-zip.check @@ -0,0 +1,4 @@ +The population of Switzerland is 9.1 million and its capital is Bern +The population of France is 68.52 million and its capital is Paris +The population of The Netherlands is 18.4 million and its capital is The Hague +The population of Germany is 83.5 million and its capital is Berlin diff --git a/tests/run/specialized-trait-vector-zip.scala b/tests/run/specialized-trait-vector-zip.scala new file mode 100644 index 000000000000..b9b4bddcef57 --- /dev/null +++ b/tests/run/specialized-trait-vector-zip.scala @@ -0,0 +1,15 @@ +//> using options -language:experimental.specializedTraits + +inline trait Vec[T: Specialized](val xs: List[T]): + inline def zip[S: Specialized](other: Vec[S]): Vec[(T, S)] = + new Vec[(T, S)](xs.zip(other.xs)) {} + +@main def Test = + val xs = new Vec[Double](List(9.1, 68.52, 18.4, 83.5)) {} + val ys = new Vec[String](List("Switzerland", "France", "The Netherlands", "Germany")) {} + val zs = new Vec[String](List("Bern", "Paris", "The Hague", "Berlin")) {} + + xs.zip(ys).zip(zs).xs.map( (numberCountry, capital) => + val (number, country) = numberCountry + println(s"The population of ${country} is ${number} million and its capital is ${capital}") + ) diff --git a/tests/run/t10889/Test.java b/tests/run/t10889/Test.java index 8f62838fc513..ae4237986bdd 100644 --- a/tests/run/t10889/Test.java +++ b/tests/run/t10889/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public class Test { public static void main(String[] args) { p.O l = new p.O("o"); diff --git a/tests/run/t12290/TextBlocks.java b/tests/run/t12290/TextBlocks.java index 9dd34e1546a5..8e04a5745413 100644 --- a/tests/run/t12290/TextBlocks.java +++ b/tests/run/t12290/TextBlocks.java @@ -1,4 +1,3 @@ -// test: -jvm 15+ class TextBlocks { final static String aText = """ diff --git a/tests/run/t12300/Test_2.scala b/tests/run/t12300/Test_2.scala index 346e4c27a636..1aa121dda490 100644 --- a/tests/run/t12300/Test_2.scala +++ b/tests/run/t12300/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = B_2.foo() diff --git a/tests/run/t3452a/S_3.scala b/tests/run/t3452a/S_3.scala index a925e57cc70e..aaa898dcde94 100644 --- a/tests/run/t3452a/S_3.scala +++ b/tests/run/t3452a/S_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { J_2.main(args) diff --git a/tests/run/t3452b-bcode/S_3.scala b/tests/run/t3452b-bcode/S_3.scala index 6373d39e9137..102b433f478c 100644 --- a/tests/run/t3452b-bcode/S_3.scala +++ b/tests/run/t3452b-bcode/S_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { J_2.j() diff --git a/tests/run/t3452b/S_3.scala b/tests/run/t3452b/S_3.scala index 6373d39e9137..102b433f478c 100644 --- a/tests/run/t3452b/S_3.scala +++ b/tests/run/t3452b/S_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { J_2.j() diff --git a/tests/run/t3452d/Test.java b/tests/run/t3452d/Test.java index 5760bc6460eb..ccdbe7799d0c 100644 --- a/tests/run/t3452d/Test.java +++ b/tests/run/t3452d/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public class Test { public static void main(String[] args) { C c = new C(); diff --git a/tests/run/t3452e/Test.scala b/tests/run/t3452e/Test.scala index 91cd9cdb5d17..fc175bf94a3a 100644 --- a/tests/run/t3452e/Test.scala +++ b/tests/run/t3452e/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test extends App { new B } diff --git a/tests/run/t3452g/Test.java b/tests/run/t3452g/Test.java index 8f4cf96e45c8..78dc648778aa 100644 --- a/tests/run/t3452g/Test.java +++ b/tests/run/t3452g/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public class Test { public static void main(String[] args) { // To get better types here, we would need to diff --git a/tests/run/t4119/S.scala b/tests/run/t4119/S.scala index b532df7eedcb..d6ae5f1b8726 100644 --- a/tests/run/t4119/S.scala +++ b/tests/run/t4119/S.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class S extends foo.bar.J { sss => diff --git a/tests/run/t4238/s_2.scala b/tests/run/t4238/s_2.scala index d6914b0eedca..a6e9bd11dedc 100644 --- a/tests/run/t4238/s_2.scala +++ b/tests/run/t4238/s_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { val x = new J_1 diff --git a/tests/run/t4317/S_3.scala b/tests/run/t4317/S_3.scala index 0797d3952b53..358fdda90c0f 100644 --- a/tests/run/t4317/S_3.scala +++ b/tests/run/t4317/S_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = { val j = new J_2() diff --git a/tests/run/t6138-2/ScalaClass.scala b/tests/run/t6138-2/ScalaClass.scala index c73189e9e02a..44ee3c3c4f4c 100644 --- a/tests/run/t6138-2/ScalaClass.scala +++ b/tests/run/t6138-2/ScalaClass.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - /* Similar to t10490 -- but defines `Foo` in the object. * Placing this test within t10490 makes it work without a fix, that's why it's independent. * Note that this was already working, we add it to make sure we don't regress diff --git a/tests/run/t6138/ScalaClass.scala b/tests/run/t6138/ScalaClass.scala index 561832e667c2..3bc29e268fa6 100644 --- a/tests/run/t6138/ScalaClass.scala +++ b/tests/run/t6138/ScalaClass.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class Foo { class Bar { override def toString: String = "Foo$Bar was instantiated!" diff --git a/tests/run/t6168/main.scala b/tests/run/t6168/main.scala index 2e30a32f8056..526f19e8e90c 100644 --- a/tests/run/t6168/main.scala +++ b/tests/run/t6168/main.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test extends App { JavaTest.main(null) diff --git a/tests/run/t6168b/main.scala b/tests/run/t6168b/main.scala index b11c8ef7a533..6f1f58023b22 100644 --- a/tests/run/t6168b/main.scala +++ b/tests/run/t6168b/main.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test extends App { JavaTest.main(null) diff --git a/tests/run/t7374/Test.java b/tests/run/t7374/Test.java index 9d106ee301ed..52010858d802 100644 --- a/tests/run/t7374/Test.java +++ b/tests/run/t7374/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public class Test { public static void main(String[] args) { System.out.println(SomeScala.list().tail()); diff --git a/tests/run/t8601e/Test.scala b/tests/run/t8601e/Test.scala index 9a90be815c7b..838114f6a7eb 100644 --- a/tests/run/t8601e/Test.scala +++ b/tests/run/t8601e/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - class C { def foo: Unit = {StaticInit.fld} } diff --git a/tests/run/t9915/Test_2.scala b/tests/run/t9915/Test_2.scala index f71eddc155d2..64dc4fd50728 100644 --- a/tests/run/t9915/Test_2.scala +++ b/tests/run/t9915/Test_2.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test extends App { private def dump(s: String) = s.map(c => f"${c.toInt}%02X").mkString(" ") def assertEqualStrings(expected: String)(actual: String) = diff --git a/tests/run/targetName-interop/Test_3.scala b/tests/run/targetName-interop/Test_3.scala index 85811346744f..bc7780f8b199 100644 --- a/tests/run/targetName-interop/Test_3.scala +++ b/tests/run/targetName-interop/Test_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = alpha.Test_2.main(args) diff --git a/tests/run/targetName-modules-1/Test_2.java b/tests/run/targetName-modules-1/Test_2.java index e92e602362c6..d5181234393f 100644 --- a/tests/run/targetName-modules-1/Test_2.java +++ b/tests/run/targetName-modules-1/Test_2.java @@ -3,7 +3,6 @@ public class Test_2 { public static void main(String[] args) { - assert Outer$.A.foo() == 23; - assert Outer$A$.MODULE$.foo() == 23; + assert Outer.A$.MODULE$.foo() == 23; } } diff --git a/tests/run/targetName-modules-1/Test_3.scala b/tests/run/targetName-modules-1/Test_3.scala index 85811346744f..bc7780f8b199 100644 --- a/tests/run/targetName-modules-1/Test_3.scala +++ b/tests/run/targetName-modules-1/Test_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = alpha.Test_2.main(args) diff --git a/tests/run/targetName-modules-2/Test_2.java b/tests/run/targetName-modules-2/Test_2.java index 7d48407a6ded..a387509f7952 100644 --- a/tests/run/targetName-modules-2/Test_2.java +++ b/tests/run/targetName-modules-2/Test_2.java @@ -3,8 +3,8 @@ public class Test_2 { public static void main(String[] args) { - assert new Outer$A(101).i() == 101; - assert new Outer$A(Outer$A.$lessinit$greater$default$1()).i() == 101; - assert new Outer$A(Outer$A$.MODULE$.$lessinit$greater$default$1()).i() == 101; + assert new Outer.A(101).i() == 101; + assert new Outer.A(Outer.A.$lessinit$greater$default$1()).i() == 1; + assert new Outer.A(Outer.A$.MODULE$.$lessinit$greater$default$1()).i() == 1; } } diff --git a/tests/run/targetName-modules-2/Test_3.scala b/tests/run/targetName-modules-2/Test_3.scala index 85811346744f..bc7780f8b199 100644 --- a/tests/run/targetName-modules-2/Test_3.scala +++ b/tests/run/targetName-modules-2/Test_3.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - object Test { def main(args: Array[String]): Unit = alpha.Test_2.main(args) diff --git a/tests/run/trait-static-forwarder/Test.java b/tests/run/trait-static-forwarder/Test.java index 7733c2775d6d..89012c016209 100644 --- a/tests/run/trait-static-forwarder/Test.java +++ b/tests/run/trait-static-forwarder/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - public final class Test { public static void main(String... args) { System.out.println(T.foo()); diff --git a/tests/run/unroll-caseclass-integration/Unrolled_2.scala b/tests/run/unroll-caseclass-integration/Unrolled_2.scala index cb2232a57726..bb8f7c456213 100644 --- a/tests/run/unroll-caseclass-integration/Unrolled_2.scala +++ b/tests/run/unroll-caseclass-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-caseclass-integration/Unrolled_3.scala b/tests/run/unroll-caseclass-integration/Unrolled_3.scala index 66b4981660df..b13afde9c118 100644 --- a/tests/run/unroll-caseclass-integration/Unrolled_3.scala +++ b/tests/run/unroll-caseclass-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-classMethod-integration/Unrolled_2.scala b/tests/run/unroll-classMethod-integration/Unrolled_2.scala index 2091bb4c5a9e..a67535d9a22f 100644 --- a/tests/run/unroll-classMethod-integration/Unrolled_2.scala +++ b/tests/run/unroll-classMethod-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-classMethod-integration/Unrolled_3.scala b/tests/run/unroll-classMethod-integration/Unrolled_3.scala index 8991bda3aeb7..c2642545d486 100644 --- a/tests/run/unroll-classMethod-integration/Unrolled_3.scala +++ b/tests/run/unroll-classMethod-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-clause-interleaving/Unrolled_2.scala b/tests/run/unroll-clause-interleaving/Unrolled_2.scala index 5adc2bc924ec..4d4236d6aeb4 100644 --- a/tests/run/unroll-clause-interleaving/Unrolled_2.scala +++ b/tests/run/unroll-clause-interleaving/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/run/unroll-clause-interleaving/Unrolled_3.scala b/tests/run/unroll-clause-interleaving/Unrolled_3.scala index e23b9d12843a..8fd826cdb07c 100644 --- a/tests/run/unroll-clause-interleaving/Unrolled_3.scala +++ b/tests/run/unroll-clause-interleaving/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/run/unroll-curriedMethod-integration/Unrolled_2.scala b/tests/run/unroll-curriedMethod-integration/Unrolled_2.scala index 5a526bf6eeb2..6cc9624fb96e 100644 --- a/tests/run/unroll-curriedMethod-integration/Unrolled_2.scala +++ b/tests/run/unroll-curriedMethod-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-curriedMethod-integration/Unrolled_3.scala b/tests/run/unroll-curriedMethod-integration/Unrolled_3.scala index 008576a9a5c3..b49d66a9ff3a 100644 --- a/tests/run/unroll-curriedMethod-integration/Unrolled_3.scala +++ b/tests/run/unroll-curriedMethod-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-genericMethod-integration/Unrolled_2.scala b/tests/run/unroll-genericMethod-integration/Unrolled_2.scala index e5970388fff8..3c0f36097b8b 100644 --- a/tests/run/unroll-genericMethod-integration/Unrolled_2.scala +++ b/tests/run/unroll-genericMethod-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-genericMethod-integration/Unrolled_3.scala b/tests/run/unroll-genericMethod-integration/Unrolled_3.scala index 2ababa300ed1..af528e278ac6 100644 --- a/tests/run/unroll-genericMethod-integration/Unrolled_3.scala +++ b/tests/run/unroll-genericMethod-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-inferredFinal.scala b/tests/run/unroll-inferredFinal.scala index b4e1ccd9f011..e85362374ac6 100644 --- a/tests/run/unroll-inferredFinal.scala +++ b/tests/run/unroll-inferredFinal.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/run/unroll-methodWithImplicit-integration/Unrolled_2.scala b/tests/run/unroll-methodWithImplicit-integration/Unrolled_2.scala index 01a5d2fb037a..141daba42af5 100644 --- a/tests/run/unroll-methodWithImplicit-integration/Unrolled_2.scala +++ b/tests/run/unroll-methodWithImplicit-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-methodWithImplicit-integration/Unrolled_3.scala b/tests/run/unroll-methodWithImplicit-integration/Unrolled_3.scala index 07627f604d76..b00a8c6a09c7 100644 --- a/tests/run/unroll-methodWithImplicit-integration/Unrolled_3.scala +++ b/tests/run/unroll-methodWithImplicit-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-multiple.scala b/tests/run/unroll-multiple.scala index e1790be26395..eee06e37f9c6 100644 --- a/tests/run/unroll-multiple.scala +++ b/tests/run/unroll-multiple.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll import scala.deriving.Mirror diff --git a/tests/run/unroll-objectMethod-integration/Unrolled_2.scala b/tests/run/unroll-objectMethod-integration/Unrolled_2.scala index bfef86beb6b2..cc41553c0f49 100644 --- a/tests/run/unroll-objectMethod-integration/Unrolled_2.scala +++ b/tests/run/unroll-objectMethod-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-objectMethod-integration/Unrolled_3.scala b/tests/run/unroll-objectMethod-integration/Unrolled_3.scala index c76521e731d8..bb61878e8a05 100644 --- a/tests/run/unroll-objectMethod-integration/Unrolled_3.scala +++ b/tests/run/unroll-objectMethod-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-primaryConstructor-integration/Unrolled_2.scala b/tests/run/unroll-primaryConstructor-integration/Unrolled_2.scala index c8558df1af55..afb1ca847591 100644 --- a/tests/run/unroll-primaryConstructor-integration/Unrolled_2.scala +++ b/tests/run/unroll-primaryConstructor-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-primaryConstructor-integration/Unrolled_3.scala b/tests/run/unroll-primaryConstructor-integration/Unrolled_3.scala index c6be439e1dec..65a3fa7ac8ac 100644 --- a/tests/run/unroll-primaryConstructor-integration/Unrolled_3.scala +++ b/tests/run/unroll-primaryConstructor-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-secondParameterList-integration/Unrolled_2.scala b/tests/run/unroll-secondParameterList-integration/Unrolled_2.scala index 68c4170f6f6e..b3480251b58b 100644 --- a/tests/run/unroll-secondParameterList-integration/Unrolled_2.scala +++ b/tests/run/unroll-secondParameterList-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-secondParameterList-integration/Unrolled_3.scala b/tests/run/unroll-secondParameterList-integration/Unrolled_3.scala index ddbe8c4cfaf4..4e56b4ad16f6 100644 --- a/tests/run/unroll-secondParameterList-integration/Unrolled_3.scala +++ b/tests/run/unroll-secondParameterList-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-secondaryConstructor-integration/Unrolled_2.scala b/tests/run/unroll-secondaryConstructor-integration/Unrolled_2.scala index b8f1f4f28328..741950afb060 100644 --- a/tests/run/unroll-secondaryConstructor-integration/Unrolled_2.scala +++ b/tests/run/unroll-secondaryConstructor-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-secondaryConstructor-integration/Unrolled_3.scala b/tests/run/unroll-secondaryConstructor-integration/Unrolled_3.scala index 1da3e0d69ec6..38c18b6279c6 100644 --- a/tests/run/unroll-secondaryConstructor-integration/Unrolled_3.scala +++ b/tests/run/unroll-secondaryConstructor-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-traitMethod-integration/Unrolled_2.scala b/tests/run/unroll-traitMethod-integration/Unrolled_2.scala index 242054d41be4..4a1250ce62c0 100644 --- a/tests/run/unroll-traitMethod-integration/Unrolled_2.scala +++ b/tests/run/unroll-traitMethod-integration/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-traitMethod-integration/Unrolled_3.scala b/tests/run/unroll-traitMethod-integration/Unrolled_3.scala index 398ddbb4da22..26ab13a8fbec 100644 --- a/tests/run/unroll-traitMethod-integration/Unrolled_3.scala +++ b/tests/run/unroll-traitMethod-integration/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview package unroll import scala.annotation.unroll diff --git a/tests/run/unroll-value-class/Unrolled_2.scala b/tests/run/unroll-value-class/Unrolled_2.scala index 1be3f4ee38b6..06237865931e 100644 --- a/tests/run/unroll-value-class/Unrolled_2.scala +++ b/tests/run/unroll-value-class/Unrolled_2.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/run/unroll-value-class/Unrolled_3.scala b/tests/run/unroll-value-class/Unrolled_3.scala index 05e5399bbe53..872504b998db 100644 --- a/tests/run/unroll-value-class/Unrolled_3.scala +++ b/tests/run/unroll-value-class/Unrolled_3.scala @@ -1,4 +1,4 @@ -//> using options -experimental +//> using options -preview import scala.annotation.unroll diff --git a/tests/run/varargs-abstract/Test.java b/tests/run/varargs-abstract/Test.java index 3b6523596155..3233d2412894 100644 --- a/tests/run/varargs-abstract/Test.java +++ b/tests/run/varargs-abstract/Test.java @@ -1,5 +1,3 @@ -// scalajs: --skip - import java.util.Comparator; public class Test { diff --git a/tests/run/varargs-extend-java-2/Test.scala b/tests/run/varargs-extend-java-2/Test.scala index 09d01c74503b..94fd48477c39 100644 --- a/tests/run/varargs-extend-java-2/Test.scala +++ b/tests/run/varargs-extend-java-2/Test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - import base.* object Test extends App { diff --git a/tests/run/varargs-extend-java/test.scala b/tests/run/varargs-extend-java/test.scala index 94e334bf4c34..39e3c632124c 100644 --- a/tests/run/varargs-extend-java/test.scala +++ b/tests/run/varargs-extend-java/test.scala @@ -1,5 +1,3 @@ -// scalajs: --skip - import scala.annotation.varargs class VarargImpl extends VarargAbstract { diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 971ff1d9f329..2c97be5ed2b7 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -5304,8 +5304,8 @@ local1 => val local p: N$1 local2 => type N$2 <: Nat local3 => val local p: N$2 local4 => val local Nat_this: Zero.type -local5 => val local Nat_this: Succ[Zero.type] -local6 => val local Nat_this: Succ[_] forSome { type _ <: Succ[Zero.type] } +local5 => val local Nat_this: Succ[Nat_this.type] +local6 => val local Nat_this: Succ[Nat_this.type] recursion/Nats. => final object Nats extends Object { self: Nats.type => +9 decls } recursion/Nats.Nat# => sealed trait Nat extends Object { self: Nat => +3 decls } recursion/Nats.Nat#`++`(). => inline transparent macro ++ => Succ[Nat.this.type] diff --git a/tests/untried/neg/abstract-inaccessible.flags b/tests/untried/neg/abstract-inaccessible.flags index 6c1dd108aea5..1cebc83b8ca6 100644 --- a/tests/untried/neg/abstract-inaccessible.flags +++ b/tests/untried/neg/abstract-inaccessible.flags @@ -1 +1 @@ --Xfatal-warnings -Xlint \ No newline at end of file +-Xfatal-warnings -Wshadow \ No newline at end of file diff --git a/tests/untried/neg/delayed-init-ref.flags b/tests/untried/neg/delayed-init-ref.flags index 88a3e4c676eb..f7497dbedf9d 100644 --- a/tests/untried/neg/delayed-init-ref.flags +++ b/tests/untried/neg/delayed-init-ref.flags @@ -1 +1 @@ --deprecation -Xlint -Xfatal-warnings +-deprecation -Wshadow -Xfatal-warnings diff --git a/tests/untried/neg/forgot-interpolator.flags b/tests/untried/neg/forgot-interpolator.flags index 7949c2afa212..00aabec7a65a 100644 --- a/tests/untried/neg/forgot-interpolator.flags +++ b/tests/untried/neg/forgot-interpolator.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings +-Wshadow -Xfatal-warnings diff --git a/tests/untried/neg/nullary-override.flags b/tests/untried/neg/nullary-override.flags index 6c1dd108aea5..1cebc83b8ca6 100644 --- a/tests/untried/neg/nullary-override.flags +++ b/tests/untried/neg/nullary-override.flags @@ -1 +1 @@ --Xfatal-warnings -Xlint \ No newline at end of file +-Xfatal-warnings -Wshadow \ No newline at end of file diff --git a/tests/untried/neg/overloaded-implicit.flags b/tests/untried/neg/overloaded-implicit.flags index 9c1e74e4ef84..5611bb96f132 100644 --- a/tests/untried/neg/overloaded-implicit.flags +++ b/tests/untried/neg/overloaded-implicit.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings -Xdev +-Wshadow -Xfatal-warnings -Xdev diff --git a/tests/untried/neg/t1503.flags b/tests/untried/neg/t1503.flags index e93641e9319e..2033e17ef588 100644 --- a/tests/untried/neg/t1503.flags +++ b/tests/untried/neg/t1503.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings \ No newline at end of file +-Wshadow -Xfatal-warnings \ No newline at end of file diff --git a/tests/untried/neg/t1980.flags b/tests/untried/neg/t1980.flags index 7949c2afa212..00aabec7a65a 100644 --- a/tests/untried/neg/t1980.flags +++ b/tests/untried/neg/t1980.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings +-Wshadow -Xfatal-warnings diff --git a/tests/untried/neg/t4762.flags b/tests/untried/neg/t4762.flags index e93641e9319e..2033e17ef588 100644 --- a/tests/untried/neg/t4762.flags +++ b/tests/untried/neg/t4762.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings \ No newline at end of file +-Wshadow -Xfatal-warnings \ No newline at end of file diff --git a/tests/untried/neg/t4877.flags b/tests/untried/neg/t4877.flags index 7ccd56103ae5..aa4ac6d21493 100644 --- a/tests/untried/neg/t4877.flags +++ b/tests/untried/neg/t4877.flags @@ -1 +1 @@ --Xlint \ No newline at end of file +-Wshadow \ No newline at end of file diff --git a/tests/untried/neg/t6534.flags b/tests/untried/neg/t6534.flags index 1008b0a70c76..befb74f87f69 100644 --- a/tests/untried/neg/t6534.flags +++ b/tests/untried/neg/t6534.flags @@ -1 +1 @@ --Xlint +-Wshadow diff --git a/tests/untried/neg/t6567.flags b/tests/untried/neg/t6567.flags index e93641e9319e..2033e17ef588 100644 --- a/tests/untried/neg/t6567.flags +++ b/tests/untried/neg/t6567.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings \ No newline at end of file +-Wshadow -Xfatal-warnings \ No newline at end of file diff --git a/tests/untried/neg/t6675.check b/tests/untried/neg/t6675.check index aecf04cb6813..160e62469395 100644 --- a/tests/untried/neg/t6675.check +++ b/tests/untried/neg/t6675.check @@ -1,5 +1,5 @@ t6675.scala:10: warning: object X expects 3 patterns to hold (Int, Int, Int) but crushing into 3-tuple to fit single pattern (SI-6675) - "" match { case X(b) => b } // should warn under -Xlint. Not an error because of SI-6111 + "" match { case X(b) => b } // should warn under -Wshadow. Not an error because of SI-6111 ^ error: No warnings can be incurred under -Xfatal-warnings. one warning found diff --git a/tests/untried/neg/t6675.flags b/tests/untried/neg/t6675.flags index 2843ea9efc98..864d9355ea52 100644 --- a/tests/untried/neg/t6675.flags +++ b/tests/untried/neg/t6675.flags @@ -1 +1 @@ --deprecation -Xlint -Xfatal-warnings \ No newline at end of file +-deprecation -Wshadow -Xfatal-warnings \ No newline at end of file diff --git a/tests/untried/neg/t6675.scala b/tests/untried/neg/t6675.scala index 4d500b77badc..5994e5d93430 100644 --- a/tests/untried/neg/t6675.scala +++ b/tests/untried/neg/t6675.scala @@ -7,7 +7,7 @@ object Y { } object Test { - "" match { case X(b) => b } // should warn under -Xlint. Not an error because of SI-6111 + "" match { case X(b) => b } // should warn under -Wshadow. Not an error because of SI-6111 "" match { case Y(b) => b } // no warning } diff --git a/tests/untried/neg/t6675b.flags b/tests/untried/neg/t6675b.flags index 2fcfa0cddb13..e7ae127fdfe7 100644 --- a/tests/untried/neg/t6675b.flags +++ b/tests/untried/neg/t6675b.flags @@ -1 +1 @@ --deprecation -Xlint +-deprecation -Wshadow diff --git a/tests/untried/neg/t750/AO_1.java b/tests/untried/neg/t750/AO_1.java deleted file mode 100644 index 4c7360ec6fc6..000000000000 --- a/tests/untried/neg/t750/AO_1.java +++ /dev/null @@ -1,5 +0,0 @@ -public class AO_1 { - public static void f(T[] ar0) { - System.out.println(ar0); - } -} \ No newline at end of file diff --git a/tests/untried/neg/t750/Test_2.scala b/tests/untried/neg/t750/Test_2.scala deleted file mode 100644 index 80977431c54e..000000000000 --- a/tests/untried/neg/t750/Test_2.scala +++ /dev/null @@ -1,6 +0,0 @@ -// t750 -object Test extends App { - val a = Array(1, 2, 3) - AO_1.f(a) - AO_1.f[Int](a) -} diff --git a/tests/untried/neg/t750b/AO.java b/tests/untried/neg/t750b/AO.java deleted file mode 100644 index 060baf9a3cf8..000000000000 --- a/tests/untried/neg/t750b/AO.java +++ /dev/null @@ -1,5 +0,0 @@ -public class AO { - public static void f(T[] ar0) { - System.out.println(ar0); - } -} \ No newline at end of file diff --git a/tests/untried/neg/t750b/Test.scala b/tests/untried/neg/t750b/Test.scala deleted file mode 100644 index 5f792a7be860..000000000000 --- a/tests/untried/neg/t750b/Test.scala +++ /dev/null @@ -1,6 +0,0 @@ -// t750 -object Test extends App { - val a = Array(1, 2, 3) - AO.f(a) - AO.f[Int](a) -} diff --git a/tests/untried/neg/t7848-interp-warn.flags b/tests/untried/neg/t7848-interp-warn.flags index 7949c2afa212..00aabec7a65a 100644 --- a/tests/untried/neg/t7848-interp-warn.flags +++ b/tests/untried/neg/t7848-interp-warn.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings +-Wshadow -Xfatal-warnings diff --git a/tests/untried/neg/t8015-ffb.flags b/tests/untried/neg/t8015-ffb.flags index 7949c2afa212..00aabec7a65a 100644 --- a/tests/untried/neg/t8015-ffb.flags +++ b/tests/untried/neg/t8015-ffb.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings +-Wshadow -Xfatal-warnings diff --git a/tests/warn/convertible.scala b/tests/warn/convertible.scala index 86a82445a58c..dd232d4c4afa 100644 --- a/tests/warn/convertible.scala +++ b/tests/warn/convertible.scala @@ -1,4 +1,4 @@ -//> using options -feature -preview +//> using options -feature import Conversion.into @@ -41,4 +41,4 @@ object Test: def h(x: into[Text]) = val y = h1(x) - y("abc") // ok \ No newline at end of file + y("abc") // ok diff --git a/tests/warn/i16072.check b/tests/warn/i16072.check new file mode 100644 index 000000000000..d34f8aa1dff8 --- /dev/null +++ b/tests/warn/i16072.check @@ -0,0 +1,28 @@ +-- [E229] Syntax Warning: tests/warn/i16072.scala:4:2 ------------------------------------------------------------------ +4 | def x = 1 // warn too far right + | ^ + | Line is indented too far to the right, or a '{' or ':' is missing + | + | longer explanation available when compiling with `-explain` +-- [E228] Syntax Warning: tests/warn/i16072.scala:3:7 ------------------------------------------------------------------ +3 |object Hello_: // warn colon in name without backticks because the body is empty + | ^^^^^^^ + | name `Hello_:` should be enclosed in backticks + | + | longer explanation available when compiling with `-explain` +-- Deprecation Warning: tests/warn/i16072.scala:12:10 ------------------------------------------------------------------ +12 |object :: : // warn deprecated colon without backticks for operator name + | ^ + | `:` after symbolic operator is deprecated; use backticks around operator instead +-- [E229] Syntax Warning: tests/warn/i16072.scala:21:2 ----------------------------------------------------------------- +21 | def y = 1 // warn + | ^ + | Line is indented too far to the right, or a '{' or ':' is missing + | + | longer explanation available when compiling with `-explain` +-- [E228] Syntax Warning: tests/warn/i16072.scala:20:6 ----------------------------------------------------------------- +20 |class Uhoh_: // warn + | ^^^^^^ + | name `Uhoh_:` should be enclosed in backticks + | + | longer explanation available when compiling with `-explain` diff --git a/tests/warn/i16072.scala b/tests/warn/i16072.scala new file mode 100644 index 000000000000..7bfdbbe3813d --- /dev/null +++ b/tests/warn/i16072.scala @@ -0,0 +1,26 @@ +//> using options -deprecation + +object Hello_: // warn colon in name without backticks because the body is empty + def x = 1 // warn too far right + +object Goodbye_: : // nowarn if non-empty body without nit-picking about backticks + def x = 2 + +object `Byte_`: + def x = 3 + +object :: : // warn deprecated colon without backticks for operator name + def x = 42 + +object ::: // nowarn + +object Braces_: { // nowarn because body is non-empty with an EmptyTree +} + +class Uhoh_: // warn + def y = 1 // warn + +@main def hello = + println(Byte_) + println(Hello_:) // apparently user did forget a colon, see https://youforgotapercentagesignoracolon.com/ + println(x) diff --git a/tests/pos/i16639false-pos-on-trait.scala b/tests/warn/i16639false-pos-on-trait.scala similarity index 91% rename from tests/pos/i16639false-pos-on-trait.scala rename to tests/warn/i16639false-pos-on-trait.scala index 67e304f556e1..b5213b1926df 100644 --- a/tests/pos/i16639false-pos-on-trait.scala +++ b/tests/warn/i16639false-pos-on-trait.scala @@ -1,8 +1,8 @@ -// scalac -Wunsued:all +//> using options -Wunused:all //Avoid warning on setter in trait Regression test : issue10154 scala trait T { - private var x: String = _ + private var x: String = compiletime.uninitialized def y: String = { if (x eq null) x = "hello, world" diff --git a/tests/warn/i17266.check b/tests/warn/i17266.check index ce8626b14225..fe2483fb7448 100644 --- a/tests/warn/i17266.check +++ b/tests/warn/i17266.check @@ -1,7 +1,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17266.scala:4:2 --------------------------------------------------------- 4 | synchronized { // warn | ^^^^^^^^^^^^ - | Suspicious top-level unqualified call to synchronized + | Universal method synchronized does not resolve to the enclosing class |--------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -12,7 +12,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17266.scala:17:2 -------------------------------------------------------- 17 | synchronized { // warn | ^^^^^^^^^^^^ - | Suspicious top-level unqualified call to synchronized + | Universal method synchronized does not resolve to the enclosing class |-------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -33,7 +33,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17266.scala:108:2 ------------------------------------------------------- 108 | wait() // warn | ^^^^ - | Suspicious top-level unqualified call to wait + | Universal method wait does not resolve to the enclosing class |------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -44,7 +44,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17266.scala:115:2 ------------------------------------------------------- 115 | wait() // warn | ^^^^ - | Suspicious top-level unqualified call to wait + | Universal method wait does not resolve to the enclosing class |------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -55,7 +55,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17266.scala:121:2 ------------------------------------------------------- 121 | wait(10) // warn | ^^^^ - | Suspicious top-level unqualified call to wait + | Universal method wait does not resolve to the enclosing class |------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -66,7 +66,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17266.scala:128:2 ------------------------------------------------------- 128 | wait(10) // warn | ^^^^ - | Suspicious top-level unqualified call to wait + | Universal method wait does not resolve to the enclosing class |------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -77,7 +77,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17266.scala:134:2 ------------------------------------------------------- 134 | hashCode() // warn | ^^^^^^^^ - | Suspicious top-level unqualified call to hashCode + | Universal method hashCode does not resolve to the enclosing class |------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -88,7 +88,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17266.scala:141:2 ------------------------------------------------------- 141 | hashCode() // warn | ^^^^^^^^ - | Suspicious top-level unqualified call to hashCode + | Universal method hashCode does not resolve to the enclosing class |------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -99,7 +99,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17266.scala:148:2 ------------------------------------------------------- 148 | synchronized { // warn | ^^^^^^^^^^^^ - | Suspicious top-level unqualified call to synchronized + | Universal method synchronized does not resolve to the enclosing class |------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/tests/warn/i17493.check b/tests/warn/i17493.check index 8a4c102980fe..a86ef09d9be9 100644 --- a/tests/warn/i17493.check +++ b/tests/warn/i17493.check @@ -1,7 +1,7 @@ -- [E181] Potential Issue Warning: tests/warn/i17493.scala:4:10 -------------------------------------------------------- 4 | def g = synchronized { println("hello, world") } // warn | ^^^^^^^^^^^^ - | Suspicious top-level unqualified call to synchronized + | Universal method synchronized does not resolve to the enclosing class |--------------------------------------------------------------------------------------------------------------------- | Explanation (enabled by `-explain`) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/tests/warn/i18234.scala b/tests/warn/i18234.scala new file mode 100755 index 000000000000..e6184d56ef42 --- /dev/null +++ b/tests/warn/i18234.scala @@ -0,0 +1,166 @@ +//> using options -source:3.9 +/* vals */ +val goodVal = 1 +val $startVal = 1 // warn +val mid$dleVal = 1 // warn +val endVal$ = 1 // warn + +def testValUsage = + $startVal + endVal$ // ok, should only warn on declaration not on usage + +/* functions */ +def $funcStart() = 3 // warn +def func$Middle() = 3 // warn +def funcEnd$() = 3 // warn + +def func1badArg(goodArg: Int, bad$Arg: Int) = 5 // warn +def func1badArgAndUsageDoesNotThrowWarning(goodArg: Int, bad$Arg: Int) = bad$Arg // warn +def func2badArgs(goodArg: Int, bad$Arg: Int, bad$arg2: String) = 5 // warn // warn +def multilineFunc( + goodArg: Int, + badAr$g: Int // warn +) = 1 + +def testFuncUsaage = + $funcStart() + func1badArg(1, 2) // ok, should only warn on declaration not on usage + +/* types */ +type GoodType = Int +type $StartType = Int // warn +type Middle$Type = Int // warn +type EndType$ = Int // warn + +val typedVal: Middle$Type = 2 // ok, should only warn on declaration not on usage +def funcWithDollarTypes(foo: $StartType): Middle$Type = 2 // ok, should only warn on declaration not on usage + +/* enums */ +enum GoodEnum: + case GoodCase + case $BadCaseStart // warn + case BadCase$Middle // warn + case BadCaseEnd$ // warn + +enum $BadEnumStart: // warn + case GoodCase + case $BadCase // warn + +enum BadEnum$Middle: // warn + case GoodCase + case Bad$Case // warn + +enum BadEnumEnd$: // warn + case GoodCase + case BadCase$ // warn + +enum E$numWithEndKeyword: // warn + case SomeCase +end E$numWithEndKeyword // ok + +def TestEnumUsage(a: $BadEnumStart): Int = // ok, should only warn on declaration not on usage + a match + case $BadEnumStart.GoodCase => 1 + case $BadEnumStart.$BadCase => 2 // ok, should only warn on declaration not on usage + +/* objects */ +object $ObjectStart: // warn + val goodVal = 1 + val $badVal = 2 // warn + +object Object$Middle: // warn + val goodVal = 1 + val bad$Val = 2 // warn + +object ObjectEnd$: // warn + val goodVal = 1 + val badVal$ = 2 // warn + +object GoodObject: + val goodVal = 1 + val b$adVal = 2 // warn + +object Ob$jectWithEndKeyword: // warn + val someVal = 1 +end Ob$jectWithEndKeyword // ok + +val testObjectUsage = ObjectEnd$.badVal$ // ok, should only warn on declaration not on usage + +/* case classes */ +case class $InlineCaseClassStart(someField: Int) // warn +case class InlineCaseClass$Middle(someField: Int) // warn +case class InlineCaseClassEnd$(someField: Int) // warn + +case class InlineCaseClass(goodField: Int, badFiel$d: Int) // warn + +case class $CaseClassStart( // warn + somefield: Int, + b$adfield: Int // warn +) + +case class CaseClass$Middle( // warn + somefield: Int, + bad$Field: Int // warn +) + +case class CaseClassEnd$( // warn + somefield: Int, + badField$: Int // warn +) + +// companion oject +object CaseClassEnd$: // warn + val food = 1 + +val testCaseClassUsage = CaseClass$Middle(somefield = 1, bad$Field = 2) // ok, should only warn on declaration not on usage + +/* classes */ +class GoodClass +class $StartClass // warn +class Middle$Class // warn +class EndClass$ // warn + +class Cla$$( // warn + var goodMember: Int, + var badM$ember: Int // warn +): + def goodMethod(x: Int) = badM$ember // ok, only checking if the method name does not contain a dollar sign + def bad$Method(y: Int) = goodMember // warn + def methodWithBadArgNames(b$ad$arg: Int) = goodMember // warn + def method$WithEndKeyword() = // warn + 3 + end method$WithEndKeyword +end Cla$$ // ok + +def testUsage = + val instantiation = new Cla$$(goodMember = 1, badM$ember = 2) // ok, should only warn on declaration not on usage + instantiation.bad$Method(1) // ok, should only warn on declaration not on usage + instantiation.methodWithBadArgNames(2) // ok, should only warn on declaration not on usage + + +/* traits */ +trait GoodTrait +trait $BadTraitStart // warn +trait BadTrait$Middle // warn +trait BadTraitEnd$ // warn + +class TestTraitUsage extends $BadTraitStart // ok, should only warn on declaration not on usage + +package GoodPackage: + val goodVal = 1 + val b$adVal = 2 // warn + +package $BadPackageStart: // warn + val goodVal = 1 + val $badVal = 2 // warn + +package BadPackage$Middle: // warn + val goodVal = 1 + val bad$Val = 2 // warn + +package BadPackageEnd$ : // warn + val goodVal = 1 + val badVal$ = 2 // warn + +def patvar[A](x: Option[A]) = + x match + case Some(funky$thing) => true // warn + case _ => false diff --git a/tests/warn/i20651.scala b/tests/warn/i20651.scala new file mode 100644 index 000000000000..15e7386944e5 --- /dev/null +++ b/tests/warn/i20651.scala @@ -0,0 +1,21 @@ +package example + +class B(val x: String) + +class C: + def wasBad = new B(getClass.getName){}.x // nowarn ever C.this.getClass + def neverBad = new B(getClass.getName).x // nowarn ever + +def alwaysBad = new B(getClass.getName).x // warn Predef.getClass not `package`.getClass +def alwaysGood = new B(this.getClass.getName).x // nowarn + +object A: + def main(args: Array[String]): Unit = + println(new B(getClass.getName){}.x) // nowarn was warn bc A is not $anon + println(new B(getClass.getName).x) // nowarn A.getClass + +trait T(val x: String) + +object U: + def main(args: Array[String]): Unit = + println(new T(getClass.getName){}.x) // nowarn diff --git a/tests/warn/i22298_joint/AbstractSealed.java b/tests/warn/i22298_joint/AbstractSealed.java new file mode 100644 index 000000000000..b9fbd7d997b4 --- /dev/null +++ b/tests/warn/i22298_joint/AbstractSealed.java @@ -0,0 +1,9 @@ +package tests.warn.i22298_joint; + +public sealed abstract class AbstractSealed permits A, B, C {} + +final class A extends AbstractSealed {} + +final class B extends AbstractSealed {} + +final class C extends AbstractSealed {} \ No newline at end of file diff --git a/tests/warn/i22298_joint/i22298.scala b/tests/warn/i22298_joint/i22298.scala new file mode 100644 index 000000000000..e4de8bcc3093 --- /dev/null +++ b/tests/warn/i22298_joint/i22298.scala @@ -0,0 +1,10 @@ +package tests.warn.i22298_joint; + +object Tester { + + val abstractSealed: AbstractSealed = new A() + + abstractSealed match { // warn + case _: B => () + } +} \ No newline at end of file diff --git a/tests/warn/i22298_separ/AbstractSealed_1.java b/tests/warn/i22298_separ/AbstractSealed_1.java new file mode 100644 index 000000000000..251c36eca450 --- /dev/null +++ b/tests/warn/i22298_separ/AbstractSealed_1.java @@ -0,0 +1,9 @@ +package tests.warn.i22298_separ; + +public sealed abstract class AbstractSealed_1 permits A, B, C {} + +final class A extends AbstractSealed_1 {} + +final class B extends AbstractSealed_1 {} + +final class C extends AbstractSealed_1 {} diff --git a/tests/warn/i22298_separ/i22298_2.scala b/tests/warn/i22298_separ/i22298_2.scala new file mode 100644 index 000000000000..e9bb096b4e06 --- /dev/null +++ b/tests/warn/i22298_separ/i22298_2.scala @@ -0,0 +1,10 @@ +package tests.warn.i22298_separ; + +object Tester { + + val abstractSealed: AbstractSealed_1 = new A() + + abstractSealed match { // warn + case _: B => () + } +} \ No newline at end of file diff --git a/tests/warn/i23704.check b/tests/warn/i23704.check index 71a69aefef11..76c7c82f6071 100644 --- a/tests/warn/i23704.check +++ b/tests/warn/i23704.check @@ -6,6 +6,10 @@ 16 | private var myvar: Int = 0 // warn for the same case with simpler syntax | ^^^^^ | private variable was mutated but not read +-- [E198] Unused Symbol Warning: tests/warn/i23704.scala:22:14 --------------------------------------------------------- +22 | private var myvar: Int = 0 // warn (because read is in RHS of assignment; see incr) + | ^^^^^ + | private variable was mutated but not read -- [E198] Unused Symbol Warning: tests/warn/i23704.scala:26:8 ---------------------------------------------------------- 26 | var localvar = 0 // warn local variable was mutated but not read | ^^^^^^^^ diff --git a/tests/warn/i23704.scala b/tests/warn/i23704.scala index 9cfaae3278c1..6a6e2d36b703 100644 --- a/tests/warn/i23704.scala +++ b/tests/warn/i23704.scala @@ -19,7 +19,7 @@ class C: 27 class D: - private var myvar: Int = 0 // nowarn (although read is RHS of assignment) + private var myvar: Int = 0 // warn (because read is in RHS of assignment; see incr) def incr(): Unit = myvar = myvar + 1 def local(): Unit = diff --git a/tests/warn/i24280.scala b/tests/warn/i24280.scala new file mode 100644 index 000000000000..f82f6b610081 --- /dev/null +++ b/tests/warn/i24280.scala @@ -0,0 +1,32 @@ +//> using options -Wunused:all + +class Foo { + def foo(): Any = { + var i = 0 // warn mutated but not read + val f = () => i += 1 + f + } + def bar(): Any = { + var i = 0 // warn + val g = () => i = i + 1 + g + } + object Select: + private var i = 0 // warn + class Select: + def test = Select.i += 1 + + def nested(): Any = + var i = 0 // warn, read of i is in RHS of assign to i + i = + var j = 0 // nowarn, j is assigned to and read + j = i + 1 + j + + def escaped(): Any = + var i = 0 // warn, read of i is in RHS of assign to i, but should nowarn because assigned to j + var j = 0 // nowarn, j is assigned to and read + i = + j = i + 1 + j +} diff --git a/tests/warn/i25004/test_2.scala b/tests/warn/i25004/test_2.scala index 5b22b772421f..5dc65537523a 100644 --- a/tests/warn/i25004/test_2.scala +++ b/tests/warn/i25004/test_2.scala @@ -1,6 +1,6 @@ //> using options -Werror -Wunused:all -Xcheck-macros @main def Test = TestBuilder.test: - val start @ _: String = "" // Converting this to a match expression resolves the error + val start @ (_: String) = "" // Converting this to a match expression resolves the error // Alternative: val Seq(start) = Seq("") print(start) diff --git a/tests/warn/i25004b/test_2.scala b/tests/warn/i25004b/test_2.scala index baef613c2b47..bf6944fbd618 100644 --- a/tests/warn/i25004b/test_2.scala +++ b/tests/warn/i25004b/test_2.scala @@ -1,6 +1,6 @@ //> using options -Werror -Wunused:all @main def Test = TestBuilder.test: - val start @ _: String = "" // Converting this to a match expression resolves the error + val start @ (_: String) = "" // Converting this to a match expression resolves the error // Alternative: val Seq(start) = Seq("") print(start) diff --git a/tests/warn/i25595.check b/tests/warn/i25595.check new file mode 100644 index 000000000000..13d9f037af25 --- /dev/null +++ b/tests/warn/i25595.check @@ -0,0 +1,15 @@ +-- Warning: tests/warn/i25595.scala:3:4 -------------------------------------------------------------------------------- +3 |val ((x1, f1), (x2, f2)): ( // warn + | ^^^^^^^^^^^^^^^^^^^^ + | Type ascriptions after patterns other than: + | * variable pattern, e.g. `case x: String =>` + | * number literal pattern, e.g. `case 10.5: Double =>` + | are no longer supported. Remove the type ascription or move it to a separate variable pattern. +-- Warning: tests/warn/i25595.scala:9:7 -------------------------------------------------------------------------------- +9 | case X: Int => X // warn + | ^ + | Typed pattern is not a variable pattern but could be written `X @ (_: Int)` +-- Warning: tests/warn/i25595.scala:12:7 ------------------------------------------------------------------------------- +12 | case `Int`: Int => `Int` // warn + | ^^^^^ + | Typed pattern is not a variable pattern but could be written `Int @ (_: Int)` diff --git a/tests/warn/i25595.scala b/tests/warn/i25595.scala new file mode 100644 index 000000000000..5fce45a97c1b --- /dev/null +++ b/tests/warn/i25595.scala @@ -0,0 +1,12 @@ +val avs = ((0d, BigDecimal(1)), (1d, BigDecimal(2))) + +val ((x1, f1), (x2, f2)): ( // warn + (Double, BigDecimal), + (Double, BigDecimal) +) = avs + +def notVar(i: Int) = i match + case X: Int => X // warn + +def notVarBackquoted(i: Int) = i match + case `Int`: Int => `Int` // warn diff --git a/tests/warn/i25928.scala b/tests/warn/i25928.scala new file mode 100644 index 000000000000..760d783f9671 --- /dev/null +++ b/tests/warn/i25928.scala @@ -0,0 +1,13 @@ +sealed trait X[R] +case class Foo() extends X[Nothing] +case class Bar[A]() extends X[A] + +def test[A](x: X[A]) = { + x match { + case Foo() => + case Bar() => + } +} + +def call = + test(Foo()) diff --git a/tests/warn/i25977.scala b/tests/warn/i25977.scala new file mode 100644 index 000000000000..fa5b89f49e4d --- /dev/null +++ b/tests/warn/i25977.scala @@ -0,0 +1,6 @@ +sealed trait T +case class C[A](x: A) extends T + +def f(t: T) = t match { // warn + case C(_: Int) => ??? +} diff --git a/tests/warn/into-as-mod.scala b/tests/warn/into-as-mod.scala index 02edb7a737e4..3bf228d4670f 100644 --- a/tests/warn/into-as-mod.scala +++ b/tests/warn/into-as-mod.scala @@ -1,4 +1,4 @@ -//> using options -feature -preview +//> using options -feature import Conversion.into diff --git a/tests/warn/multiple-entry-points/1_First.scala b/tests/warn/multiple-entry-points/1_First.scala deleted file mode 100644 index 940dd7d324f9..000000000000 --- a/tests/warn/multiple-entry-points/1_First.scala +++ /dev/null @@ -1,6 +0,0 @@ -//> using option -Ylog:genBCode - -object First { - def main(args: Array[String]): Unit = - println("first") -} diff --git a/tests/warn/multiple-entry-points/2_Second.scala b/tests/warn/multiple-entry-points/2_Second.scala deleted file mode 100644 index 2107a606c994..000000000000 --- a/tests/warn/multiple-entry-points/2_Second.scala +++ /dev/null @@ -1,4 +0,0 @@ -object Second { - def main(args: Array[String]): Unit = - println("second") -} diff --git a/tests/warn/scala2-t11681.scala b/tests/warn/t11681.scala similarity index 99% rename from tests/warn/scala2-t11681.scala rename to tests/warn/t11681.scala index adbf5ea41299..063c7e93703e 100644 --- a/tests/warn/scala2-t11681.scala +++ b/tests/warn/t11681.scala @@ -106,4 +106,4 @@ object Answers { def answer: Int = 42 } -val a$1 = 2 +val `a$1` = 2 diff --git a/tests/warn/unary-minus.scala b/tests/warn/unary-minus.scala new file mode 100644 index 000000000000..b169ced1260c --- /dev/null +++ b/tests/warn/unary-minus.scala @@ -0,0 +1,13 @@ +//> using options -Wnonunit-statement + +class C { + def f1 = -2.abs // warn funky precedence + def f2 = - 2.abs // warn meaningless space + def f3 = - 2 // warn meaningless space + def f4 = 42 + -2.abs // warn precedence // hides warn unused expression + def f5 = 42 + - 2.abs // nowarn infix + def f6 = (-2).abs // nowarn explicit precedence + def f7 = -3.14 // nowarn decimal point +}