diff --git a/NOTICE.md b/NOTICE.md new file mode 100644 index 000000000000..790dcd4dc2e9 --- /dev/null +++ b/NOTICE.md @@ -0,0 +1,209 @@ +# License notice for the ScalaPB protobuf library + +The Dotty codebase contains parts which are derived from +[the ScalaPB protobuf library](https://github.com/scalapb/scalapb). +We include the text of the original license below: + +``` + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +``` diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala index 94c2b6fa786e..80ed4109f4f7 100644 --- a/compiler/src/dotty/tools/dotc/Compiler.scala +++ b/compiler/src/dotty/tools/dotc/Compiler.scala @@ -40,6 +40,7 @@ class Compiler { List(new YCheckPositions) :: // YCheck positions List(new Staging) :: // Check PCP, heal quoted types and expand macros List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks + List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files List(new PostTyper) :: // Additional checks and cleanups after type checking List(new sbt.ExtractAPI) :: // Sends a representation of the API of classes to sbt via callbacks List(new SetRootTree) :: // Set the `rootTreeOrProvider` on class symbols diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala index 38914097cc6f..7c2e63b85257 100644 --- a/compiler/src/dotty/tools/dotc/ast/Trees.scala +++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala @@ -332,26 +332,15 @@ object Trees { def namedType: NamedType = tpe.asInstanceOf[NamedType] } - /** Tree defines a new symbol and carries modifiers. - * The position of a MemberDef contains only the defined identifier or pattern. - * The envelope of a MemberDef contains the whole definition and has its point - * on the opening keyword (or the next token after that if keyword is missing). - */ - abstract class MemberDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] with DefTree[T] { - type ThisTree[-T >: Untyped] <: MemberDef[T] - - def rawComment: Option[Comment] = getAttachment(DocComment) - - def setComment(comment: Option[Comment]): this.type = { - comment.map(putAttachment(DocComment, _)) - this - } + abstract class NamedDefTree[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] with DefTree[T] { + type ThisTree[-T >: Untyped] <: NamedDefTree[T] /** The position of the name defined by this definition. * This is a point position if the definition is synthetic, or a range position * if the definition comes from source. * It might also be that the definition does not have a position (for instance when synthesized by * a calling chain from `viewExists`), in that case the return position is NoSpan. + * Overridden in Bind */ def nameSpan: Span = if (span.exists) { @@ -359,26 +348,28 @@ object Trees { if (rawMods.is(Synthetic) || name.toTermName == nme.ERROR) Span(point) else { val realName = name.stripModuleClassSuffix.lastPart.toString - val nameStart = - if (point != span.start) point - else { - // Point might be too far away from start to be recorded. In this case we fall back to scanning - // forwards from the start offset for the name. - // Note: This might be inaccurate since scanning might hit accidentally the same - // name (e.g. in a comment) before finding the real definition. - // To make this behavior more robust we'd have to change the trees for definitions to contain - // a fully positioned Ident in place of a name. - val contents = if source.exists then source.content() else Array.empty[Char] - val idx = contents.indexOfSlice(realName, point) - if (idx >= 0) idx - else point // use `point` anyway. This is important if no source exists so scanning fails - } Span(point, point + realName.length, point) } } else span } + /** Tree defines a new symbol and carries modifiers. + * The position of a MemberDef contains only the defined identifier or pattern. + * The envelope of a MemberDef contains the whole definition and has its point + * on the opening keyword (or the next token after that if keyword is missing). + */ + abstract class MemberDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NamedDefTree[T] { + type ThisTree[-T >: Untyped] <: MemberDef[T] + + def rawComment: Option[Comment] = getAttachment(DocComment) + + def setComment(comment: Option[Comment]): this.type = { + comment.map(putAttachment(DocComment, _)) + this + } + } + /** A ValDef or DefDef tree */ abstract class ValOrDefDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends MemberDef[T] with WithLazyField[Tree[T]] { type ThisTree[-T >: Untyped] <: ValOrDefDef[T] @@ -705,10 +696,13 @@ object Trees { /** name @ body */ case class Bind[-T >: Untyped] private[ast] (name: Name, body: Tree[T])(implicit @constructorOnly src: SourceFile) - extends NameTree[T] with DefTree[T] with PatternTree[T] { + extends NamedDefTree[T] with PatternTree[T] { type ThisTree[-T >: Untyped] = Bind[T] override def isType: Boolean = name.isTypeName override def isTerm: Boolean = name.isTermName + + override def nameSpan: Span = + if span.exists then Span(span.start, span.start + name.toString.length) else span } /** tree_1 | ... | tree_n */ @@ -938,6 +932,7 @@ object Trees { type NameTree = Trees.NameTree[T] type RefTree = Trees.RefTree[T] type DefTree = Trees.DefTree[T] + type NamedDefTree = Trees.NamedDefTree[T] type MemberDef = Trees.MemberDef[T] type ValOrDefDef = Trees.ValOrDefDef[T] type LazyTree = Trees.LazyTree[T] @@ -1439,13 +1434,13 @@ object Trees { this(x, trees) case UnApply(fun, implicits, patterns) => this(this(this(x, fun), implicits), patterns) - case tree @ ValDef(name, tpt, _) => + case tree @ ValDef(_, tpt, _) => implicit val ctx = localCtx this(this(x, tpt), tree.rhs) - case tree @ DefDef(name, tparams, vparamss, tpt, _) => + case tree @ DefDef(_, tparams, vparamss, tpt, _) => implicit val ctx = localCtx this(this(vparamss.foldLeft(this(x, tparams))(apply), tpt), tree.rhs) - case TypeDef(name, rhs) => + case TypeDef(_, rhs) => implicit val ctx = localCtx this(x, rhs) case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty => diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala index bcbbfcca1e47..9353a1aa4c29 100644 --- a/compiler/src/dotty/tools/dotc/ast/untpd.scala +++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala @@ -111,6 +111,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { case class Export(expr: Tree, selectors: List[ImportSelector])(implicit @constructorOnly src: SourceFile) extends Tree case class ImportSelector(imported: Ident, renamed: Tree = EmptyTree, bound: Tree = EmptyTree)(implicit @constructorOnly src: SourceFile) extends Tree { + // TODO: Make bound a typed tree? /** It's a `given` selector */ val isGiven: Boolean = imported.name.isEmpty diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala index 13099076f9b5..643e69aa2471 100644 --- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala +++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala @@ -17,6 +17,8 @@ class ScalaSettings extends Settings.SettingGroup { val javabootclasspath: Setting[String] = PathSetting("-javabootclasspath", "Override java boot classpath.", Defaults.javaBootClassPath) withAbbreviation "--java-boot-class-path" val javaextdirs: Setting[String] = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs) withAbbreviation "--java-extension-directories" val sourcepath: Setting[String] = PathSetting("-sourcepath", "Specify location(s) of source files.", Defaults.scalaSourcePath) withAbbreviation "--source-path" + val sourceroot: Setting[String] = PathSetting("-sourceroot", "Specify workspace root directory", ".") + val semanticdbTarget: Setting[String] = PathSetting("-semanticdb-target", "Specify an alternative output directory for SemanticDB files", "") val classpath: Setting[String] = PathSetting("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp" withAbbreviation "--class-path" val outputDir: Setting[AbstractFile] = OutputSetting("-d", "directory|jar", "destination for generated classfiles.", @@ -150,6 +152,7 @@ class ScalaSettings extends Settings.SettingGroup { val YdumpSbtInc: Setting[Boolean] = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.") val YcheckAllPatmat: Setting[Boolean] = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)") val YretainTrees: Setting[Boolean] = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree") + val Ysemanticdb: Setting[Boolean] = BooleanSetting("-Ysemanticdb", "Store information in SemanticDB") val YshowTreeIds: Setting[Boolean] = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.") val YprofileEnabled: Setting[Boolean] = BooleanSetting("-Yprofile-enabled", "Enable profiling.") diff --git a/compiler/src/dotty/tools/dotc/interactive/Interactive.scala b/compiler/src/dotty/tools/dotc/interactive/Interactive.scala index 7255ce81272b..a8e7305f1add 100644 --- a/compiler/src/dotty/tools/dotc/interactive/Interactive.scala +++ b/compiler/src/dotty/tools/dotc/interactive/Interactive.scala @@ -67,7 +67,7 @@ object Interactive { /** Does this tree define a symbol ? */ def isDefinition(tree: Tree): Boolean = - tree.isInstanceOf[DefTree with NameTree] + tree.isInstanceOf[NamedDefTree] /** The type of the closest enclosing tree with a type containing position `pos`. */ def enclosingType(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): Type = { diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala index fa342d56e6af..3b0de7e93ea7 100644 --- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala +++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala @@ -2526,16 +2526,16 @@ object Parsers { case t => simplePatternRest(t) } case USCORE => - val wildIndent = wildcardIdent() + val wildIdent = wildcardIdent() // compatibility for Scala2 `x @ _*` and `_*` syntax // `x: _*' is parsed in `ascription' if (isIdent(nme.raw.STAR)) { in.nextToken() - if (in.token != RPAREN) syntaxError(SeqWildcardPatternPos(), wildIndent.span) - atSpan(wildIndent.span) { Ident(tpnme.WILDCARD_STAR) } + if (in.token != RPAREN) syntaxError(SeqWildcardPatternPos(), wildIdent.span) + atSpan(wildIdent.span) { Ident(tpnme.WILDCARD_STAR) } } - else wildIndent + else wildIdent case LPAREN => atSpan(in.offset) { makeTupleOrParens(inParens(patternsOpt())) } case QUOTE => diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala new file mode 100644 index 000000000000..57f92a71d640 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -0,0 +1,614 @@ +package dotty.tools +package dotc +package semanticdb + +import core._ +import Phases._ +import ast.tpd._ +import Contexts._ +import Symbols._ +import Flags._ +import Names.Name +import StdNames.nme +import util.Spans.Span +import util.{SourceFile, SourcePosition} +import collection.mutable +import java.nio.file.Paths + +import PartialFunction.condOpt + +import ast.untpd.given +import NameOps.given + +import scala.annotation.{ threadUnsafe => tu, tailrec } + +/** Extract symbol references and uses to semanticdb files. + * See https://scalameta.org/docs/semanticdb/specification.html#symbol-1 + * for a description of the format. + * TODO: Also extract type information + */ +class ExtractSemanticDB extends Phase with + import Scala3.{_, given} + import Symbols.given + + override val phaseName: String = ExtractSemanticDB.name + + override def isRunnable(implicit ctx: Context) = + super.isRunnable && ctx.settings.Ysemanticdb.value + + // Check not needed since it does not transform trees + override def isCheckable: Boolean = false + + override def run(implicit ctx: Context): Unit = + val unit = ctx.compilationUnit + val extract = Extractor() + extract.traverse(unit.tpdTree) + ExtractSemanticDB.write(unit.source, extract.occurrences.toList, extract.symbolInfos.toList) + + /** Extractor of symbol occurrences from trees */ + class Extractor extends TreeTraverser with + + private var nextLocalIdx: Int = 0 + + /** The index of a local symbol */ + private val locals = mutable.HashMap[Symbol, Int]() + + /** The bodies of synthetic locals */ + private val localBodies = mutable.HashMap[Symbol, Tree]() + + /** The local symbol(s) starting at given offset */ + private val symsAtOffset = new mutable.HashMap[Int, Set[Symbol]]() with + override def default(key: Int) = Set[Symbol]() + + /** The extracted symbol occurrences */ + val occurrences = new mutable.ListBuffer[SymbolOccurrence]() + + /** The extracted symbol infos */ + val symbolInfos = new mutable.HashSet[SymbolInformation]() + + /** A cache of localN names */ + val localNames = new mutable.HashSet[String]() + + /** The symbol occurrences generated so far, as a set */ + private val generated = new mutable.HashSet[SymbolOccurrence] + + /** Definitions of this symbol should be excluded from semanticdb */ + private def excludeDef(sym: Symbol)(given Context): Boolean = + !sym.exists + || sym.isLocalDummy + || sym.is(Synthetic) + || sym.isSetter + || excludeDefOrUse(sym) + + private def excludeDefOrUse(sym: Symbol)(given Context): Boolean = + sym.name.is(NameKinds.DefaultGetterName) + || sym.isConstructor && (sym.owner.is(ModuleClass) || !sym.isGlobal) + || excludeSymbol(sym) + + private def excludeSymbol(sym: Symbol)(given Context): Boolean = + sym.name.isWildcard + || excludeQual(sym) + + private def excludeQual(sym: Symbol)(given Context): Boolean = + sym.isAnonymousFunction + || sym.isAnonymousModuleVal + || sym.name.isEmptyNumbered + + private def excludeChildren(sym: Symbol)(given Context): Boolean = + sym.isAllOf(HigherKinded | Param) + + /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ + private def excludeUse(qualifier: Option[Symbol], sym: Symbol)(given Context): Boolean = + excludeDefOrUse(sym) + || sym.isConstructor && sym.owner.isAnnotation + || sym == defn.Any_typeCast + || qualifier.exists(excludeQual) + + override def traverse(tree: Tree)(given Context): Unit = + + inline def traverseCtorParamTpt(ctorSym: Symbol, tpt: Tree): Unit = + val tptSym = tpt.symbol + if tptSym.owner == ctorSym + val found = matchingMemberType(tptSym, ctorSym.owner) + if tpt.span.hasLength + registerUseGuarded(None, found, tpt.span) + else + traverse(tpt) + + for annot <- tree.symbol.annotations do + if annot.tree.span.exists + && annot.tree.span.hasLength + annot.tree match + case tree: Typed => () // hack for inline code + case tree => traverse(tree) + + tree match + case tree: PackageDef => + if !excludeDef(tree.pid.symbol) + && tree.pid.span.hasLength + tree.pid match + case tree @ Select(qual, name) => + registerDefinition(tree.symbol, adjustSpanToName(tree.span, qual.span, name), Set.empty) + traverse(qual) + case tree => registerDefinition(tree.symbol, tree.span, Set.empty) + tree.stats.foreach(traverse) + case tree: NamedDefTree => + if tree.symbol.isAllOf(ModuleValCreationFlags) + return + if !excludeDef(tree.symbol) + && tree.span.hasLength + registerDefinition(tree.symbol, tree.adjustedNameSpan, symbolKinds(tree)) + val privateWithin = tree.symbol.privateWithin + if privateWithin.exists + registerUseGuarded(None, privateWithin, spanOfSymbol(privateWithin, tree.span)) + else if !excludeSymbol(tree.symbol) + registerSymbol(tree.symbol, symbolName(tree.symbol), symbolKinds(tree)) + tree match + case tree: ValDef + if tree.symbol.isAllOf(EnumValue) => + tree.rhs match + case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause + template.parents.foreach(traverse) + case _ => // calls $new + case tree: ValDef + if tree.symbol.isSelfSym => + if tree.tpt.span.hasLength + traverse(tree.tpt) + case tree: DefDef + if tree.symbol.isConstructor => // ignore typeparams for secondary ctors + tree.vparamss.foreach(_.foreach(traverse)) + traverse(tree.rhs) + case tree: (DefDef | ValDef) + if tree.symbol.isSyntheticWithIdent => + tree match + case tree: DefDef => + tree.tparams.foreach(tparam => registerSymbolSimple(tparam.symbol)) + tree.vparamss.foreach(_.foreach(vparam => registerSymbolSimple(vparam.symbol))) + case _ => + if !tree.symbol.isGlobal + localBodies(tree.symbol) = tree.rhs + // ignore rhs + case PatternValDef(pat, rhs) => + traverse(rhs) + PatternValDef.collectPats(pat).foreach(traverse) + case tree => + if !excludeChildren(tree.symbol) + traverseChildren(tree) + case tree: Template => + val ctorSym = tree.constr.symbol + if !excludeDef(ctorSym) + registerDefinition(ctorSym, tree.constr.span, Set.empty) + ctorParams(tree.constr.vparamss, tree.body)(traverseCtorParamTpt(ctorSym, _)) + for parent <- tree.parentsOrDerived if parent.span.hasLength do + traverse(parent) + val selfSpan = tree.self.span + if selfSpan.exists && selfSpan.hasLength then + traverse(tree.self) + if tree.symbol.owner.is(Enum, butNot=Case) + tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement + else + tree.body.foreach(traverse) + case tree: Apply => + @tu lazy val genParamSymbol: Name => String = funParamSymbol(tree.fun.symbol) + traverse(tree.fun) + for arg <- tree.args do + arg match + case arg @ NamedArg(name, value) => + registerUse(genParamSymbol(name), arg.span.startPos.withEnd(arg.span.start + name.toString.length)) + traverse(localBodies.get(value.symbol).getOrElse(value)) + case _ => traverse(arg) + case tree: Assign => + val qualSym = condOpt(tree.lhs) { case Select(qual, _) if qual.symbol.exists => qual.symbol } + if !excludeUse(qualSym, tree.lhs.symbol) + val lhs = tree.lhs.symbol + val setter = lhs.matchingSetter.orElse(lhs) + tree.lhs match + case tree @ Select(qual, name) => registerUse(setter, adjustSpanToName(tree.span, qual.span, name)) + case tree => registerUse(setter, tree.span) + traverseChildren(tree.lhs) + traverse(tree.rhs) + case tree: Ident => + if tree.name != nme.WILDCARD then + val sym = tree.symbol.adjustIfCtorTyparam + registerUseGuarded(None, sym, tree.span) + case tree: Select => + val qualSpan = tree.qualifier.span + val sym = tree.symbol.adjustIfCtorTyparam + registerUseGuarded(tree.qualifier.symbol.ifExists, sym, adjustSpanToName(tree.span, qualSpan, tree.name)) + if qualSpan.exists && qualSpan.hasLength then + traverse(tree.qualifier) + case tree: Import => + if tree.span.exists && tree.span.hasLength then + for sel <- tree.selectors do + val imported = sel.imported.name + if imported != nme.WILDCARD then + for alt <- tree.expr.tpe.member(imported).alternatives do + registerUseGuarded(None, alt.symbol, sel.imported.span) + if (alt.symbol.companionClass.exists) + registerUseGuarded(None, alt.symbol.companionClass, sel.imported.span) + traverseChildren(tree) + case tree: Inlined => + traverse(tree.call) + case _ => + traverseChildren(tree) + + end traverse + + private def funParamSymbol(funSym: Symbol)(given Context): Name => String = + if funSym.isGlobal then + val funSymbol = symbolName(funSym) + name => s"$funSymbol($name)" + else + name => locals.keys.find(local => local.isTerm && local.owner == funSym && local.name == name) + .fold("")(Symbols.LocalPrefix + _) + + private object PatternValDef with + + def unapply(tree: ValDef)(given Context): Option[(Tree, Tree)] = tree.rhs match + + case Match(Typed(selected: Tree, tpt: TypeTree), CaseDef(pat: Tree, _, _) :: Nil) + if tpt.span.exists && !tpt.span.hasLength && tpt.tpe.isAnnotatedByUnchecked => + Some((pat, selected)) + + case _ => None + + private inline def (tpe: Types.Type) isAnnotatedByUnchecked(given Context) = tpe match + case Types.AnnotatedType(_, annot) => annot.symbol == defn.UncheckedAnnot + case _ => false + + def collectPats(pat: Tree): List[Tree] = + + @tailrec + def impl(acc: List[Tree], pats: List[Tree]): List[Tree] = pats match + + case pat::pats => pat match + case Typed(UnApply(fun: Tree, _, args), tpt: Tree) => impl(fun::tpt::acc, args:::pats) + case Typed(obj: Ident, tpt: Tree) => impl(obj::tpt::acc, pats) + case UnApply(fun: Tree, _, args) => impl(fun::acc, args:::pats) + case obj: Ident => impl(obj::acc, pats) + case _ => impl(acc, pats) + + case Nil => acc + + impl(Nil, pat::Nil) + + end PatternValDef + + private def (tree: NamedDefTree) adjustedNameSpan(given Context): Span = + if tree.span.exists && tree.name.isAnonymousFunctionName || tree.name.isAnonymousClassName + Span(tree.span.point) + else + tree.nameSpan + + /** Add semanticdb name of the given symbol to string builder */ + private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = + + def addName(name: Name) = + val str = name.toString.unescapeUnicode + if str.isJavaIdent then b append str + else b append '`' append str append '`' + + def addOwner(owner: Symbol): Unit = + if !owner.isRoot then addSymName(b, owner) + + def addOverloadIdx(sym: Symbol): Unit = + val decls = + val decls0 = sym.owner.info.decls.lookupAll(sym.name) + if sym.owner.isAllOf(JavaModule) + decls0 ++ sym.owner.companionClass.info.decls.lookupAll(sym.name) + else + decls0 + end decls + val alts = decls.filter(_.is(Method)).toList.reverse + alts match + case notSym :: rest if sym != notSym => + val idx = rest.indexOf(sym).ensuring(_ >= 0) + b.append('+').append(idx + 1) + case _ => + + def addDescriptor(sym: Symbol): Unit = + if sym.is(ModuleClass) then + addDescriptor(sym.sourceModule) + else if sym.is(TypeParam) then + b.append('['); addName(sym.name); b.append(']') + else if sym.is(Param) then + b.append('('); addName(sym.name); b.append(')') + else if sym.isRoot then + b.append(Symbols.RootPackage) + else if sym.isEmptyPackage then + b.append(Symbols.EmptyPackage) + else if (sym.isScala2PackageObject) then + b.append(Symbols.PackageObjectDescriptor) + else + addName(sym.name) + if sym.is(Package) then b.append('/') + else if sym.isType || sym.isAllOf(JavaModule) then b.append('#') + else if sym.isOneOf(Method | Mutable) + && (!sym.is(StableRealizable) || sym.isConstructor) then + b.append('('); addOverloadIdx(sym); b.append(").") + else b.append('.') + + /** The index of local symbol `sym`. Symbols with the same name and + * the same starting position have the same index. + */ + def localIdx(sym: Symbol)(given Context): Int = + def computeLocalIdx(): Int = + symsAtOffset(sym.span.start).find(_.name == sym.name) match + case Some(other) => localIdx(other) + case None => + val idx = nextLocalIdx + nextLocalIdx += 1 + locals(sym) = idx + symsAtOffset(sym.span.start) += sym + idx + locals.getOrElseUpdate(sym, computeLocalIdx()) + + if sym.exists then + if sym.isGlobal then + addOwner(sym.owner); addDescriptor(sym) + else + b.append(Symbols.LocalPrefix).append(localIdx(sym)) + + end addSymName + + /** The semanticdb name of the given symbol */ + private def symbolName(sym: Symbol)(given ctx: Context): String = + val b = StringBuilder(20) + addSymName(b, sym) + b.toString + + inline private def source(given ctx: Context) = ctx.compilationUnit.source + + private def range(span: Span)(given ctx: Context): Option[Range] = + def lineCol(offset: Int) = (source.offsetToLine(offset), source.column(offset)) + val (startLine, startCol) = lineCol(span.start) + val (endLine, endCol) = lineCol(span.end) + Some(Range(startLine, startCol, endLine, endCol)) + + private def symbolKind(sym: Symbol, symkinds: Set[SymbolKind])(given Context): SymbolInformation.Kind = + if sym.isTypeParam + SymbolInformation.Kind.TYPE_PARAMETER + else if sym.is(TermParam) + SymbolInformation.Kind.PARAMETER + else if sym.isTerm && sym.owner.isTerm + SymbolInformation.Kind.LOCAL + else if sym.isInlineMethod || sym.is(Macro) + SymbolInformation.Kind.MACRO + else if sym.isConstructor + SymbolInformation.Kind.CONSTRUCTOR + else if sym.isSelfSym + SymbolInformation.Kind.SELF_PARAMETER + else if sym.isOneOf(Method) || symkinds.exists(_.isVarOrVal) + SymbolInformation.Kind.METHOD + else if sym.isPackageObject + SymbolInformation.Kind.PACKAGE_OBJECT + else if sym.is(Module) + SymbolInformation.Kind.OBJECT + else if sym.is(Package) + SymbolInformation.Kind.PACKAGE + else if sym.isAllOf(JavaInterface) + SymbolInformation.Kind.INTERFACE + else if sym.is(Trait) + SymbolInformation.Kind.TRAIT + else if sym.isClass + SymbolInformation.Kind.CLASS + else if sym.isType + SymbolInformation.Kind.TYPE + else if sym.is(ParamAccessor) + SymbolInformation.Kind.FIELD + else + SymbolInformation.Kind.UNKNOWN_KIND + + private def symbolProps(sym: Symbol, symkinds: Set[SymbolKind])(given Context): Int = + if sym.is(ModuleClass) + return symbolProps(sym.sourceModule, symkinds) + var props = 0 + if sym.isPrimaryConstructor + props |= SymbolInformation.Property.PRIMARY.value + if sym.is(Abstract) || symkinds.contains(SymbolKind.Abstract) + props |= SymbolInformation.Property.ABSTRACT.value + if sym.is(Final) + props |= SymbolInformation.Property.FINAL.value + if sym.is(Sealed) + props |= SymbolInformation.Property.SEALED.value + if sym.isOneOf(GivenOrImplicit) + props |= SymbolInformation.Property.IMPLICIT.value + if sym.is(Lazy, butNot=Module) + props |= SymbolInformation.Property.LAZY.value + if sym.isAllOf(Case | Module) || sym.is(CaseClass) || sym.isAllOf(EnumCase) + props |= SymbolInformation.Property.CASE.value + if sym.is(Covariant) + props |= SymbolInformation.Property.COVARIANT.value + if sym.is(Contravariant) + props |= SymbolInformation.Property.CONTRAVARIANT.value + if sym.isAllOf(DefaultMethod | JavaDefined) || sym.is(Accessor) && sym.name.is(NameKinds.DefaultGetterName) + props |= SymbolInformation.Property.DEFAULT.value + if symkinds.exists(_.isVal) + props |= SymbolInformation.Property.VAL.value + if symkinds.exists(_.isVar) + props |= SymbolInformation.Property.VAR.value + if sym.is(JavaStatic) + props |= SymbolInformation.Property.STATIC.value + if sym.is(Enum) + props |= SymbolInformation.Property.ENUM.value + props + + private def symbolInfo(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(given Context): SymbolInformation = + SymbolInformation( + symbol = symbolName, + language = Language.SCALA, + kind = symbolKind(sym, symkinds), + properties = symbolProps(sym, symkinds), + displayName = Symbols.displaySymbol(sym) + ) + + private def registerSymbol(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(given Context): Unit = + val isLocal = symbolName.isLocal + if !isLocal || !localNames.contains(symbolName) + if isLocal + localNames += symbolName + symbolInfos += symbolInfo(sym, symbolName, symkinds) + + private def registerSymbolSimple(sym: Symbol)(given Context): Unit = + registerSymbol(sym, symbolName(sym), Set.empty) + + private def registerOccurrence(symbol: String, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = + val occ = SymbolOccurrence(symbol, range(span), role) + if !generated.contains(occ) && occ.symbol.nonEmpty then + occurrences += occ + generated += occ + + private def registerUseGuarded(qualSym: Option[Symbol], sym: Symbol, span: Span)(given Context) = + if !excludeUse(qualSym, sym) then + registerUse(sym, span) + + private def registerUse(sym: Symbol, span: Span)(given Context): Unit = + registerUse(symbolName(sym), span) + + private def registerUse(symbol: String, span: Span)(given Context): Unit = + registerOccurrence(symbol, span, SymbolOccurrence.Role.REFERENCE) + + private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind])(given Context) = + val symbol = symbolName(sym) + registerOccurrence(symbol, span, SymbolOccurrence.Role.DEFINITION) + if !sym.is(Package) + registerSymbol(sym, symbol, symkinds) + + private def spanOfSymbol(sym: Symbol, span: Span)(given Context): Span = + val contents = if source.exists then source.content() else Array.empty[Char] + val idx = contents.indexOfSlice(sym.name.show, span.start) + val start = if idx >= 0 then idx else span.start + Span(start, start + sym.name.show.length, start) + + private inline def (list: List[List[ValDef]]) isSingleArg = list match + case (_::Nil)::Nil => true + case _ => false + + private def (tree: DefDef) isSetterDef(given Context): Boolean = + tree.name.isSetterName && tree.mods.is(Accessor) && tree.vparamss.isSingleArg + + private def findGetters(ctorParams: Set[Names.TermName], body: List[Tree])(given Context): Map[Names.TermName, ValDef] = + if ctorParams.isEmpty || body.isEmpty then + Map.empty + else + body.collect({ + case tree: ValDef + if ctorParams.contains(tree.name) + && !tree.symbol.isPrivate => + tree.name -> tree + }).toMap + end findGetters + + private def adjustSpanToName(span: Span, qualSpan: Span, name: Name)(given Context) = + val end = span.end + val limit = qualSpan.end + val start = + if limit < end then + val len = name.toString.length + if source.content()(end - 1) == '`' then end - len - 2 else end - len + else limit + Span(start max limit, end) + + private given extension (span: Span) with + def hasLength: Boolean = span.start != span.end + def zeroLength: Boolean = span.start == span.end + end given + + /**Consume head while not an import statement. + * Returns the rest of the list after the first import, or else the empty list + */ + @tailrec + private def (body: List[Tree]) foreachUntilImport(op: Tree => Unit): List[Tree] = body match + case ((_: Import) :: rest) => rest + case stat :: rest => + op(stat) + rest.foreachUntilImport(op) + case Nil => Nil + + private def (sym: Symbol) adjustIfCtorTyparam(given Context) = + if sym.isType && sym.owner.exists && sym.owner.isConstructor + matchingMemberType(sym, sym.owner.owner) + else + sym + + private inline def matchingMemberType(ctorTypeParam: Symbol, classSym: Symbol)(given Context) = + classSym.info.member(ctorTypeParam.name).symbol + + /**Necessary because not all of the eventual flags are propagated from the Tree to the symbol yet. + */ + private def symbolKinds(tree: NamedDefTree)(given Context): Set[SymbolKind] = + if tree.symbol.isSelfSym + Set.empty + else + val symkinds = mutable.HashSet.empty[SymbolKind] + tree match + case tree: ValDef => + if !tree.symbol.is(Param) + symkinds += (if tree.mods is Mutable then SymbolKind.Var else SymbolKind.Val) + if tree.rhs.isEmpty && !tree.symbol.isOneOf(TermParam | CaseAccessor | ParamAccessor) + symkinds += SymbolKind.Abstract + case tree: DefDef => + if tree.isSetterDef + symkinds += SymbolKind.Setter + else if tree.rhs.isEmpty + symkinds += SymbolKind.Abstract + case tree: Bind => + symkinds += SymbolKind.Val + case _ => + symkinds.toSet + + private inline def ctorParams( + vparamss: List[List[ValDef]], body: List[Tree])(traverseTpt: => Tree => Unit)(given Context): Unit = + @tu lazy val getters = findGetters(vparamss.flatMap(_.map(_.name)).toSet, body) + for + vparams <- vparamss + vparam <- vparams + do + if !excludeSymbol(vparam.symbol) + val symkinds = + getters.get(vparam.name).fold(SymbolKind.emptySet)(getter => + if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet) + registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds) + traverseTpt(vparam.tpt) + +object ExtractSemanticDB with + import java.nio.file.Path + import scala.collection.JavaConverters._ + import java.nio.file.Files + + val name: String = "extractSemanticDB" + + def write(source: SourceFile, occurrences: List[SymbolOccurrence], symbolInfos: List[SymbolInformation])(given ctx: Context): Unit = + def absolutePath(path: Path): Path = path.toAbsolutePath.normalize + val sourcePath = absolutePath(source.file.jpath) + val sourceRoot = absolutePath(Paths.get(ctx.settings.sourceroot.value)) + val semanticdbTarget = + val semanticdbTargetSetting = ctx.settings.semanticdbTarget.value + absolutePath( + if semanticdbTargetSetting.isEmpty then ctx.settings.outputDir.value.jpath + else Paths.get(semanticdbTargetSetting) + ) + val relPath = sourceRoot.relativize(sourcePath) + val outpath = semanticdbTarget + .resolve("META-INF") + .resolve("semanticdb") + .resolve(relPath) + .resolveSibling(sourcePath.getFileName().toString() + ".semanticdb") + Files.createDirectories(outpath.getParent()) + val doc: TextDocument = TextDocument( + schema = Schema.SEMANTICDB4, + language = Language.SCALA, + uri = relPath.toString, + text = "", + md5 = internal.MD5.compute(String(source.content)), + symbols = symbolInfos, + occurrences = occurrences + ) + val docs = TextDocuments(List(doc)) + val out = Files.newOutputStream(outpath) + try + val stream = internal.SemanticdbOutputStream.newInstance(out) + docs.writeTo(stream) + stream.flush() + finally + out.close() diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala new file mode 100644 index 000000000000..eeaac6d4e643 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala @@ -0,0 +1,21 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.semanticdb.internal._ + +sealed trait Language(val value: Int) extends SemanticdbEnum derives Eql + +object Language { + + case object UNKNOWN_LANGUAGE extends Language(0) + case object SCALA extends Language(1) + case object JAVA extends Language(2) + final case class Unrecognized(id: Int) extends Language(id) + + def fromValue(value: Int): Language = value match { + case 0 => UNKNOWN_LANGUAGE + case 1 => SCALA + case 2 => JAVA + case id => Unrecognized(id) + } + +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala new file mode 100644 index 000000000000..ad4249d0b53c --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala @@ -0,0 +1,118 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable + +object Range { + val defaultInstance: Range = Range(0, 0, 0, 0) +} + +final case class Range( + startLine: Int, + startCharacter: Int, + endLine: Int, + endCharacter: Int +) extends SemanticdbMessage[Range] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { + var __size = 0 + + { + val __value = startLine + if (__value != 0) { + __size += SemanticdbOutputStream + .computeInt32Size(1, __value) + } + }; + + { + val __value = startCharacter + if (__value != 0) { + __size += SemanticdbOutputStream + .computeInt32Size(2, __value) + } + }; + + { + val __value = endLine + if (__value != 0) { + __size += SemanticdbOutputStream + .computeInt32Size(3, __value) + } + }; + + { + val __value = endCharacter + if (__value != 0) { + __size += SemanticdbOutputStream + .computeInt32Size(4, __value) + } + }; + __size + } + final override def serializedSize: Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo( + `_output__`: SemanticdbOutputStream + ): Unit = { + { + val __v = startLine + if (__v != 0) { + _output__.writeInt32(1, __v) + } + }; + { + val __v = startCharacter + if (__v != 0) { + _output__.writeInt32(2, __v) + } + }; + { + val __v = endLine + if (__v != 0) { + _output__.writeInt32(3, __v) + } + }; + { + val __v = endCharacter + if (__v != 0) { + _output__.writeInt32(4, __v) + } + }; + } + def mergeFrom(`_input__`: SemanticdbInputStream): Range = { + var __startLine = this.startLine + var __startCharacter = this.startCharacter + var __endLine = this.endLine + var __endCharacter = this.endCharacter + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 8 => + __startLine = _input__.readInt32() + case 16 => + __startCharacter = _input__.readInt32() + case 24 => + __endLine = _input__.readInt32() + case 32 => + __endCharacter = _input__.readInt32() + case tag => _input__.skipField(tag) + } + } + Range( + startLine = __startLine, + startCharacter = __startCharacter, + endLine = __endLine, + endCharacter = __endCharacter + ) + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala new file mode 100644 index 000000000000..9d2622183391 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -0,0 +1,275 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.core +import core.Symbols.{ Symbol , defn } +import core.Contexts.Context +import core.Names +import core.Names.Name +import core.Types.Type +import core.Flags._ +import core.NameKinds +import core.StdNames.nme + +import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} + +import scala.annotation.internal.sharable +import scala.annotation.switch + +object Scala3 with + import Symbols._ + import core.NameOps.given + + @sharable private val unicodeEscape = raw"\$$u(\p{XDigit}{4})".r + @sharable private val locals = raw"local(\d+)".r + @sharable private val ctor = raw"[^;].*``\((?:\+\d+)?\)\.".r + + private val WILDCARDTypeName = nme.WILDCARD.toTypeName + + enum SymbolKind derives Eql with + kind => + + case Val, Var, Setter, Abstract + + def isVar: Boolean = kind match + case Var | Setter => true + case _ => false + def isVal: Boolean = kind == Val + def isVarOrVal: Boolean = kind.isVar || kind.isVal + + end SymbolKind + + object SymbolKind with + val ValSet = Set(Val) + val VarSet = Set(Var) + val emptySet = Set.empty[SymbolKind] + end SymbolKind + + object Symbols with + + val RootPackage: String = "_root_/" + val EmptyPackage: String = "_empty_/" + val LocalPrefix: String = "local" + val PackageObjectDescriptor: String = "package." + val s"${RootPackageName @ _}/" = RootPackage + val s"${EmptyPackageName @ _}/" = EmptyPackage + + def displaySymbol(symbol: Symbol)(given Context): String = + if symbol.isPackageObject then + displaySymbol(symbol.owner) + else if symbol.is(ModuleClass) then + displaySymbol(symbol.sourceModule) + else if symbol == defn.RootPackage + RootPackageName + else if symbol.isEmptyPackage + EmptyPackageName + else + symbol.name.show + + end Symbols + + given NameOps: extension (name: Name) with + + def isWildcard = name match + case nme.WILDCARD | WILDCARDTypeName => true + case _ => name.is(NameKinds.WildcardParamName) + + def isScala2PackageObjectName: Boolean = name match + case name: Names.TermName => name == nme.PACKAGE + case name: Names.TypeName => + name.toTermName match + case NameKinds.ModuleClassName(original) => original.isScala2PackageObjectName + case _ => false + + def isEmptyNumbered: Boolean = + !name.is(NameKinds.WildcardParamName) + && { name match + case NameKinds.AnyNumberedName(nme.EMPTY, _) => true + case _ => false + } + + end NameOps + + given SymbolOps: extension (sym: Symbol) with + + def ifExists(given Context): Option[Symbol] = if sym.exists then Some(sym) else None + + def isScala2PackageObject(given Context): Boolean = + sym.name.isScala2PackageObjectName && sym.owner.is(Package) && sym.is(Module) + + def isAnonymous(given Context): Boolean = + sym.isAnonymousClass + || sym.isAnonymousModuleVal + || sym.isAnonymousFunction + + def matchingSetter(given Context): Symbol = + + val setterName = sym.name.toTermName.setterName + + inline def (t: Type) matchingType = t.paramInfoss match + case (arg::Nil)::Nil => t.resultType == defn.UnitType && arg == sym.info + case _ => false + + sym.owner.info.decls.find(s => s.name == setterName && s.info.matchingType) + + /** Is symbol global? Non-global symbols get localN names */ + def isGlobal(given Context): Boolean = + sym.is(Package) + || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && sym.owner.isGlobal + + def isLocalWithinSameName(given Context): Boolean = + sym.exists && !sym.isGlobal && sym.name == sym.owner.name + + /** Synthetic symbols that are not anonymous or numbered empty ident */ + def isSyntheticWithIdent(given Context): Boolean = + sym.is(Synthetic) && !sym.isAnonymous && !sym.name.isEmptyNumbered + + def isAnnotation(given Context): Boolean = + sym.derivesFrom(defn.AnnotationClass) + + end SymbolOps + + object LocalSymbol with + + def unapply(symbolInfo: SymbolInformation): Option[Int] = symbolInfo.symbol match + case locals(ints) => + val bi = BigInt(ints) + if bi.isValidInt + Some(bi.toInt) + else + None + + case _ => None + + end LocalSymbol + + private inline def (char: Char) isGlobalTerminal = (char: @switch) match + case '/' | '.' | '#' | ']' | ')' => true + case _ => false + + given StringOps: extension (symbol: String) with + + def isSymbol: Boolean = !symbol.isEmpty + def isRootPackage: Boolean = RootPackage == symbol + def isEmptyPackage: Boolean = EmptyPackage == symbol + + def isGlobal: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last.isGlobalTerminal + def isLocal: Boolean = !symbol.isEmpty && !symbol.isMulti && !symbol.last.isGlobalTerminal + def isMulti: Boolean = symbol startsWith ";" + + def isConstructor: Boolean = ctor matches symbol + def isPackage: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == '/' + def isTerm: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == '.' + def isType: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == '#' + def isTypeParameter: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == ']' + def isParameter: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == ')' + + def unescapeUnicode = + unicodeEscape.replaceAllIn(symbol, m => String.valueOf(Integer.parseInt(m.group(1), 16).toChar)) + + def isJavaIdent = + isJavaIdentifierStart(symbol.head) && symbol.tail.forall(isJavaIdentifierPart) + + end StringOps + + given InfoOps: extension (info: SymbolInformation) with + + def isAbstract: Boolean = (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0 + def isFinal: Boolean = (info.properties & SymbolInformation.Property.FINAL.value) != 0 + def isSealed: Boolean = (info.properties & SymbolInformation.Property.SEALED.value) != 0 + def isImplicit: Boolean = (info.properties & SymbolInformation.Property.IMPLICIT.value) != 0 + def isLazy: Boolean = (info.properties & SymbolInformation.Property.LAZY.value) != 0 + def isCase: Boolean = (info.properties & SymbolInformation.Property.CASE.value) != 0 + def isCovariant: Boolean = (info.properties & SymbolInformation.Property.COVARIANT.value) != 0 + def isContravariant: Boolean = (info.properties & SymbolInformation.Property.CONTRAVARIANT.value) != 0 + def isPrimary: Boolean = (info.properties & SymbolInformation.Property.PRIMARY.value) != 0 + def isVal: Boolean = (info.properties & SymbolInformation.Property.VAL.value) != 0 + def isVar: Boolean = (info.properties & SymbolInformation.Property.VAR.value) != 0 + def isStatic: Boolean = (info.properties & SymbolInformation.Property.STATIC.value) != 0 + def isEnum: Boolean = (info.properties & SymbolInformation.Property.ENUM.value) != 0 + def isDefault: Boolean = (info.properties & SymbolInformation.Property.DEFAULT.value) != 0 + + def isUnknownKind: Boolean = info.kind.isUnknownKind + def isLocal: Boolean = info.kind.isLocal + def isField: Boolean = info.kind.isField + def isMethod: Boolean = info.kind.isMethod + def isConstructor: Boolean = info.kind.isConstructor + def isMacro: Boolean = info.kind.isMacro + def isType: Boolean = info.kind.isType + def isParameter: Boolean = info.kind.isParameter + def isSelfParameter: Boolean = info.kind.isSelfParameter + def isTypeParameter: Boolean = info.kind.isTypeParameter + def isObject: Boolean = info.kind.isObject + def isPackage: Boolean = info.kind.isPackage + def isPackageObject: Boolean = info.kind.isPackageObject + def isClass: Boolean = info.kind.isClass + def isTrait: Boolean = info.kind.isTrait + def isInterface: Boolean = info.kind.isInterface + + end InfoOps + + given RangeOps: extension (range: Range) with + def hasLength = range.endLine > range.startLine || range.endCharacter > range.startCharacter + end RangeOps + + /** Sort symbol occurrences by their start position. */ + given OccurrenceOrdering: Ordering[SymbolOccurrence] = (x, y) => + x.range -> y.range match + case None -> _ | _ -> None => 0 + case Some(a) -> Some(b) => + val byLine = Integer.compare(a.startLine, b.startLine) + if (byLine != 0) + byLine + else // byCharacter + Integer.compare(a.startCharacter, b.startCharacter) + end OccurrenceOrdering + + given Ordering[SymbolInformation] = Ordering.by[SymbolInformation, String](_.symbol)(IdentifierOrdering()) + + /** + * A comparator for identifier like "Predef" or "Function10". + * + * Differences from the default string comparator: + * - works with CharSequences like compiler `Name` + * - orders numbers by their numerical value instead of lexicographical + * - Good: `Function1`, `Function2`, `Function10` + * - Bad: `Function1`, `Function10`, `Function2` + * + * taken from https://github.com/scalameta/scalameta/blob/master/semanticdb/metap/src/main/scala/scala/meta/internal/metap/IdentifierOrdering.scala + */ + private class IdentifierOrdering[T <: CharSequence] extends Ordering[T] with + + override def compare(o1: T, o2: T): Int = + val len = math.min(o1.length(), o2.length()) + var i = 0 + while i < len do + val a = o1.charAt(i) + val b = o2.charAt(i) + if a.isDigit && b.isDigit + val byDigit = Integer.compare(toDigit(o1, i), toDigit(o2, i)) + if (byDigit != 0) return byDigit + else + i = seekNonDigit(o1, i) + else + val result = Character.compare(a, b) + if result != 0 + return result + i += 1 + end while + Integer.compare(o1.length(), o2.length()) + end compare + + private def seekNonDigit(cs: T, i: Int): Int = + var curr = i + while curr < cs.length && cs.charAt(curr).isDigit do + curr += 1 + curr + end seekNonDigit + + private def toDigit(cs: T, i: Int): Int = + val digit = cs.subSequence(i, seekNonDigit(cs, i)) + Integer.parseUnsignedInt(digit.toString) + end toDigit + + end IdentifierOrdering + +end Scala3 diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala new file mode 100644 index 000000000000..e23f2cccca6d --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala @@ -0,0 +1,21 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.semanticdb.internal._ + +sealed trait Schema(val value: Int) extends SemanticdbEnum derives Eql + +object Schema { + + case object LEGACY extends Schema(0) + case object SEMANTICDB3 extends Schema(3) + case object SEMANTICDB4 extends Schema(4) + final case class Unrecognized(id: Int) extends Schema(id) + + def fromValue(value: Int): Schema = value match { + case 0 => LEGACY + case 3 => SEMANTICDB3 + case 4 => SEMANTICDB4 + case id => Unrecognized(id) + } + +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala new file mode 100644 index 000000000000..5a5f2c0b4e1e --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala @@ -0,0 +1,246 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable + +object SymbolInformation { + + val defaultInstance = SymbolInformation("", Language.UNKNOWN_LANGUAGE, SymbolInformation.Kind.UNKNOWN_KIND, 0, "") + + sealed trait Kind(val value: Int) extends SemanticdbEnum derives Eql { + def isUnknownKind: Boolean = this == Kind.UNKNOWN_KIND + def isLocal: Boolean = this == Kind.LOCAL + def isField: Boolean = this == Kind.FIELD + def isMethod: Boolean = this == Kind.METHOD + def isConstructor: Boolean = this == Kind.CONSTRUCTOR + def isMacro: Boolean = this == Kind.MACRO + def isType: Boolean = this == Kind.TYPE + def isParameter: Boolean = this == Kind.PARAMETER + def isSelfParameter: Boolean = this == Kind.SELF_PARAMETER + def isTypeParameter: Boolean = this == Kind.TYPE_PARAMETER + def isObject: Boolean = this == Kind.OBJECT + def isPackage: Boolean = this == Kind.PACKAGE + def isPackageObject: Boolean = this == Kind.PACKAGE_OBJECT + def isClass: Boolean = this == Kind.CLASS + def isTrait: Boolean = this == Kind.TRAIT + def isInterface: Boolean = this == Kind.INTERFACE + } + + object Kind { + + case object UNKNOWN_KIND extends Kind(0) + case object METHOD extends Kind(3) + case object MACRO extends Kind(6) + case object TYPE extends Kind(7) + case object PARAMETER extends Kind(8) + case object TYPE_PARAMETER extends Kind(9) + case object OBJECT extends Kind(10) + case object PACKAGE extends Kind(11) + case object PACKAGE_OBJECT extends Kind(12) + case object CLASS extends Kind(13) + case object TRAIT extends Kind(14) + case object SELF_PARAMETER extends Kind(17) + case object INTERFACE extends Kind(18) + case object LOCAL extends Kind(19) + case object FIELD extends Kind(20) + case object CONSTRUCTOR extends Kind(21) + final case class Unrecognized(id: Int) extends Kind(id) + + def fromValue(value: Int): Kind = value match { + case 0 => UNKNOWN_KIND + case 3 => METHOD + case 6 => MACRO + case 7 => TYPE + case 8 => PARAMETER + case 9 => TYPE_PARAMETER + case 10 => OBJECT + case 11 => PACKAGE + case 12 => PACKAGE_OBJECT + case 13 => CLASS + case 14 => TRAIT + case 17 => SELF_PARAMETER + case 18 => INTERFACE + case 19 => LOCAL + case 20 => FIELD + case 21 => CONSTRUCTOR + case id => Unrecognized(id) + } + } + + sealed trait Property(val value: Int) extends SemanticdbEnum derives Eql { + def isUnknownProperty: Boolean = this == Property.UNKNOWN_PROPERTY + def isAbstract: Boolean = this == Property.ABSTRACT + def isFinal: Boolean = this == Property.FINAL + def isSealed: Boolean = this == Property.SEALED + def isImplicit: Boolean = this == Property.IMPLICIT + def isLazy: Boolean = this == Property.LAZY + def isCase: Boolean = this == Property.CASE + def isCovariant: Boolean = this == Property.CONTRAVARIANT + def isContravariant: Boolean = this == Property.CONTRAVARIANT + def isVal: Boolean = this == Property.VAL + def isVar: Boolean = this == Property.VAR + def isStatic: Boolean = this == Property.STATIC + def isPrimary: Boolean = this == Property.PRIMARY + def isEnum: Boolean = this == Property.ENUM + def isDefault: Boolean = this == Property.DEFAULT + } + + object Property { + + case object UNKNOWN_PROPERTY extends Property(0) + case object ABSTRACT extends Property(4) + case object FINAL extends Property(8) + case object SEALED extends Property(16) + case object IMPLICIT extends Property(32) + case object LAZY extends Property(64) + case object CASE extends Property(128) + case object COVARIANT extends Property(256) + case object CONTRAVARIANT extends Property(512) + case object VAL extends Property(1024) + case object VAR extends Property(2048) + case object STATIC extends Property(4096) + case object PRIMARY extends Property(8192) + case object ENUM extends Property(16384) + case object DEFAULT extends Property(32768) + final case class Unrecognized(id: Int) extends Property(id) + + def fromValue(value: Int): Property = value match { + case 0x0 => UNKNOWN_PROPERTY + case 0x4 => ABSTRACT + case 0x8 => FINAL + case 0x10 => SEALED + case 0x20 => IMPLICIT + case 0x40 => LAZY + case 0x80 => CASE + case 0x100 => COVARIANT + case 0x200 => CONTRAVARIANT + case 0x400 => VAL + case 0x800 => VAR + case 0x1000 => STATIC + case 0x2000 => PRIMARY + case 0x4000 => ENUM + case 0x8000 => DEFAULT + case id => Unrecognized(id) + } + } +} + +final case class SymbolInformation( + symbol: String, + language: Language, + kind: SymbolInformation.Kind, + properties: Int, + displayName: String +) extends SemanticdbMessage[SymbolInformation] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { + var __size = 0 + + { + val __value = symbol + if (__value != "") { + __size += SemanticdbOutputStream.computeStringSize(1, __value) + } + }; + + { + val __value = language + if (__value != Language.UNKNOWN_LANGUAGE) { + __size += SemanticdbOutputStream.computeEnumSize(16, __value.value) + } + }; + + { + val __value = kind + if (__value != SymbolInformation.Kind.UNKNOWN_KIND) { + __size += SemanticdbOutputStream.computeEnumSize(3, __value.value) + } + }; + + { + val __value = properties + if (__value != 0) { + __size += SemanticdbOutputStream.computeInt32Size(4, __value) + } + }; + + { + val __value = displayName + if (__value != "") { + __size += SemanticdbOutputStream.computeStringSize(5, __value) + } + }; + __size + } + final override def serializedSize: Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo(`_output__`: SemanticdbOutputStream): Unit = { + { + val __v = symbol + if (__v != "") { + _output__.writeString(1, __v) + } + }; + { + val __v = kind + if (__v != SymbolInformation.Kind.UNKNOWN_KIND) { + _output__.writeEnum(3, __v.value) + } + }; + { + val __v = properties + if (__v != 0) { + _output__.writeInt32(4, __v) + } + }; + { + val __v = displayName + if (__v != "") { + _output__.writeString(5, __v) + } + }; + { + val __v = language + if (__v != Language.UNKNOWN_LANGUAGE) { + _output__.writeEnum(16, __v.value) + } + }; + } + def mergeFrom(`_input__`: SemanticdbInputStream): SymbolInformation = { + var __symbol = this.symbol + var __language = this.language + var __kind = this.kind + var __properties = this.properties + var __displayName = this.displayName + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 10 => + __symbol = _input__.readString() + case 24 => + __kind = SymbolInformation.Kind.fromValue(_input__.readEnum()) + case 32 => + __properties = _input__.readInt32() + case 42 => + __displayName = _input__.readString() + case tag => _input__.skipField(tag) + } + } + SymbolInformation( + symbol = __symbol, + language = __language, + kind = __kind, + properties = __properties, + displayName = __displayName + ) + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala new file mode 100644 index 000000000000..594e265fda4d --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala @@ -0,0 +1,117 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable + +object SymbolOccurrence { + + sealed trait Role(val value: Int) extends SemanticdbEnum derives Eql { + def isDefinition: Boolean = this == Role.DEFINITION + def isReference: Boolean = this == Role.REFERENCE + } + + object Role { + + case object UNKNOWN_ROLE extends Role(0) + case object REFERENCE extends Role(1) + case object DEFINITION extends Role(2) + final case class Unrecognized(id: Int) extends Role(id) + + def fromValue(value: Int): Role = value match { + case 0 => UNKNOWN_ROLE + case 1 => REFERENCE + case 2 => DEFINITION + case id => Unrecognized(id) + } + + } + + val defaultInstance: SymbolOccurrence = SymbolOccurrence("", None, Role.UNKNOWN_ROLE) +} + +final case class SymbolOccurrence( + symbol: String, + range: Option[Range], + role: SymbolOccurrence.Role +) extends SemanticdbMessage[SymbolOccurrence] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { + var __size = 0 + if (range.isDefined) { + val __value = range.get + __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag( + __value.serializedSize + ) + __value.serializedSize + }; + + { + val __value = symbol + if (__value != "") { + __size += SemanticdbOutputStream + .computeStringSize(2, __value) + } + }; + + { + val __value = role + if (__value != SymbolOccurrence.Role.UNKNOWN_ROLE) { + __size += SemanticdbOutputStream + .computeEnumSize(3, __value.value) + } + }; + __size + } + final override def serializedSize: Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo(`_output__`: SemanticdbOutputStream): Unit = { + range.foreach { __v => + val __m = __v + _output__.writeTag(1, 2) + _output__.writeUInt32NoTag(__m.serializedSize) + __m.writeTo(_output__) + }; + { + val __v = symbol + if (__v != "") { + _output__.writeString(2, __v) + } + }; + { + val __v = role + if (__v != SymbolOccurrence.Role.UNKNOWN_ROLE) { + _output__.writeEnum(3, __v.value) + } + }; + } + def mergeFrom(`_input__`: SemanticdbInputStream): SymbolOccurrence = { + var __range = this.range + var __symbol = this.symbol + var __role = this.role + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 10 => + __range = Option(LiteParser.readMessage(_input__, __range.getOrElse(Range.defaultInstance))) + case 18 => + __symbol = _input__.readString() + case 24 => + __role = SymbolOccurrence.Role.fromValue(_input__.readEnum()) + case tag => _input__.skipField(tag) + } + } + SymbolOccurrence( + range = __range, + symbol = __symbol, + role = __role + ) + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala new file mode 100644 index 000000000000..b81632bdd12f --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala @@ -0,0 +1,147 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable + +object TextDocument { + val defaultInstance: TextDocument = TextDocument(Schema.LEGACY, Language.UNKNOWN_LANGUAGE, "", "", "", Nil, Nil) +} + +final case class TextDocument( + schema: Schema, + language: Language, + uri: String, + text: String, + md5: String, + symbols: Seq[SymbolInformation], + occurrences: Seq[SymbolOccurrence] +) extends SemanticdbMessage[TextDocument] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { + var __size = 0 + + { + val __value = schema + if (__value != Schema.LEGACY) { + __size += SemanticdbOutputStream.computeEnumSize(1, __value.value) + } + }; + + { + val __value = uri + if (__value != "") { + __size += SemanticdbOutputStream + .computeStringSize(2, __value) + } + }; + + { + val __value = md5 + if (__value != "") { + __size += SemanticdbOutputStream.computeStringSize(11, __value) + } + }; + + { + val __value = language + if (__value != Language.UNKNOWN_LANGUAGE) { + __size += SemanticdbOutputStream.computeEnumSize(10, __value.value) + } + }; + symbols.foreach { __item => + val __value = __item + __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize + } + occurrences.foreach { __item => + val __value = __item + __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag( + __value.serializedSize + ) + __value.serializedSize + } + __size + } + final override def serializedSize: Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo(`_output__`: SemanticdbOutputStream): Unit = { + { + val __v = schema + if (__v != Schema.LEGACY) { + _output__.writeEnum(1, __v.value) + } + }; + { + val __v = uri + if (__v != "") { + _output__.writeString(2, __v) + } + }; + symbols.foreach { __v => + val __m = __v + _output__.writeTag(5, 2) + _output__.writeUInt32NoTag(__m.serializedSize) + __m.writeTo(_output__) + }; + occurrences.foreach { __v => + val __m = __v + _output__.writeTag(6, 2) + _output__.writeUInt32NoTag(__m.serializedSize) + __m.writeTo(_output__) + }; + { + val __v = language + if (__v != Language.UNKNOWN_LANGUAGE) { + _output__.writeEnum(10, __v.value) + } + }; + { + val __v = md5 + if (__v != "") { + _output__.writeString(11, __v) + } + }; + } + def mergeFrom(`_input__`: SemanticdbInputStream): TextDocument = { + var __schema = this.schema + var __uri = this.uri + var __md5 = this.md5 + var __language = this.language + val __symbols = (Vector.newBuilder[SymbolInformation] ++= this.symbols) + val __occurrences = (Vector.newBuilder[SymbolOccurrence] ++= this.occurrences) + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 8 => + __schema = Schema.fromValue(_input__.readEnum()) + case 18 => + __uri = _input__.readString() + case 90 => + __md5 = _input__.readString() + case 80 => + __language = Language.fromValue(_input__.readEnum()) + case 42 => + __symbols += LiteParser.readMessage(_input__, SymbolInformation.defaultInstance) + case 50 => + __occurrences += LiteParser.readMessage(_input__, SymbolOccurrence.defaultInstance) + case tag => _input__.skipField(tag) + } + } + TextDocument( + schema = __schema, + uri = __uri, + text = "", + md5 = __md5, + language = __language, + symbols = __symbols.result(), + occurrences = __occurrences.result(), + ) + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala new file mode 100644 index 000000000000..4e56641fe3c3 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala @@ -0,0 +1,58 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable + +object TextDocuments { + def parseFrom(in: Array[Byte]): TextDocuments = { + parseFrom(SemanticdbInputStream.newInstance(in)) + } + def parseFrom(in: SemanticdbInputStream): TextDocuments = { + defaultInstance.mergeFrom(in) + } + val defaultInstance: TextDocuments = TextDocuments(Nil) +} +final case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage[TextDocuments] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { + var __size = 0 + documents.foreach { __item => + val __value = __item + __size += 1 + + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + + __value.serializedSize + } + __size + } + final override def serializedSize: Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo(`_output__`: SemanticdbOutputStream): Unit = { + documents.foreach { __v => + val __m = __v + _output__.writeTag(1, 2) + _output__.writeUInt32NoTag(__m.serializedSize) + __m.writeTo(_output__) + }; + } + def mergeFrom(`_input__`: SemanticdbInputStream): TextDocuments = { + val __documents = (Vector.newBuilder[TextDocument] ++= this.documents) + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 10 => + __documents += LiteParser.readMessage(_input__, TextDocument.defaultInstance) + case tag => _input__.skipField(tag) + } + } + TextDocuments(documents = __documents.result()) + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala new file mode 100644 index 000000000000..08b1a15590de --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala @@ -0,0 +1,140 @@ +package dotty.tools.dotc.semanticdb + +import java.nio.file._ +import java.nio.charset.StandardCharsets +import scala.collection.JavaConverters._ +import dotty.tools.dotc.util.SourceFile +import dotty.tools.dotc.semanticdb.Scala3.{_, given} + +object Tools with + + /** Load SemanticDB TextDocument for a single Scala source file + * + * @param scalaAbsolutePath Absolute path to a Scala source file. + * @param scalaRelativePath scalaAbsolutePath relativized by the sourceroot. + * @param semanticdbAbsolutePath Absolute path to the SemanticDB file. + */ + def loadTextDocument( + scalaAbsolutePath: Path, + scalaRelativePath: Path, + semanticdbAbsolutePath: Path + ): TextDocument = + val reluri = scalaRelativePath.toString + val sdocs = parseTextDocuments(semanticdbAbsolutePath) + sdocs.documents.find(_.uri == reluri) match + case None => throw new NoSuchElementException(reluri) + case Some(document) => + val text = new String(Files.readAllBytes(scalaAbsolutePath), StandardCharsets.UTF_8) + // Assert the SemanticDB payload is in-sync with the contents of the Scala file on disk. + val md5FingerprintOnDisk = internal.MD5.compute(text) + if document.md5 != md5FingerprintOnDisk + throw new IllegalArgumentException("stale semanticdb: " + reluri) + else + // Update text document to include full text contents of the file. + document.copy(text = text) + end loadTextDocument + + /** Parses SemanticDB text documents from an absolute path to a `*.semanticdb` file. */ + private def parseTextDocuments(path: Path): TextDocuments = + val bytes = Files.readAllBytes(path) // NOTE: a semanticdb file is a TextDocuments message, not TextDocument + TextDocuments.parseFrom(bytes) + + def metac(doc: TextDocument, realPath: Path)(given sb: StringBuilder): StringBuilder = + val realURI = realPath.toString + given SourceFile = SourceFile.virtual(doc.uri, doc.text) + sb.append(realURI).nl + sb.append("-" * realURI.length).nl + sb.nl + sb.append("Summary:").nl + sb.append("Schema => ").append(schemaString(doc.schema)).nl + sb.append("Uri => ").append(doc.uri).nl + sb.append("Text => empty").nl + sb.append("Language => ").append(languageString(doc.language)).nl + sb.append("Symbols => ").append(doc.symbols.length).append(" entries").nl + sb.append("Occurrences => ").append(doc.occurrences.length).append(" entries").nl + sb.nl + sb.append("Symbols:").nl + doc.symbols.sorted.foreach(processSymbol) + sb.nl + sb.append("Occurrences:").nl + doc.occurrences.sorted.foreach(processOccurrence) + sb.nl + end metac + + private def schemaString(schema: Schema) = + import Schema._ + schema match + case SEMANTICDB3 => "SemanticDB v3" + case SEMANTICDB4 => "SemanticDB v4" + case LEGACY => "SemanticDB legacy" + case Unrecognized(_) => "unknown" + end schemaString + + private def languageString(language: Language) = + import Language._ + language match + case SCALA => "Scala" + case JAVA => "Java" + case UNKNOWN_LANGUAGE | Unrecognized(_) => "unknown" + end languageString + + private def processSymbol(info: SymbolInformation)(given sb: StringBuilder): Unit = + import SymbolInformation.Kind._ + sb.append(info.symbol).append(" => ") + if info.isAbstract then sb.append("abstract ") + if info.isFinal then sb.append("final ") + if info.isSealed then sb.append("sealed ") + if info.isImplicit then sb.append("implicit ") + if info.isLazy then sb.append("lazy ") + if info.isCase then sb.append("case ") + if info.isCovariant then sb.append("covariant ") + if info.isContravariant then sb.append("contravariant ") + if info.isVal then sb.append("val ") + if info.isVar then sb.append("var ") + if info.isStatic then sb.append("static ") + if info.isPrimary then sb.append("primary ") + if info.isEnum then sb.append("enum ") + if info.isDefault then sb.append("default ") + info.kind match + case LOCAL => sb.append("local ") + case FIELD => sb.append("field ") + case METHOD => sb.append("method ") + case CONSTRUCTOR => sb.append("ctor ") + case MACRO => sb.append("macro ") + case TYPE => sb.append("type ") + case PARAMETER => sb.append("param ") + case SELF_PARAMETER => sb.append("selfparam ") + case TYPE_PARAMETER => sb.append("typeparam ") + case OBJECT => sb.append("object ") + case PACKAGE => sb.append("package ") + case PACKAGE_OBJECT => sb.append("package object ") + case CLASS => sb.append("class ") + case TRAIT => sb.append("trait ") + case INTERFACE => sb.append("interface ") + case UNKNOWN_KIND | Unrecognized(_) => sb.append("unknown ") + sb.append(info.displayName).nl + end processSymbol + + private def processOccurrence(occ: SymbolOccurrence)(given sb: StringBuilder, sourceFile: SourceFile): Unit = + occ.range match + case Some(range) => + sb.append('[') + .append(range.startLine).append(':').append(range.startCharacter) + .append("..") + .append(range.endLine).append(':').append(range.endCharacter) + .append("):") + if range.endLine == range.startLine + && range.startCharacter != range.endCharacter + && !(occ.symbol.isConstructor && occ.role.isDefinition) + val line = sourceFile.lineContent(sourceFile.lineToOffset(range.startLine)) + assert(range.startCharacter <= line.length && range.endCharacter <= line.length, + s"Line is only ${line.length} - start line was ${range.startLine} in source ${sourceFile.name}" + ) + sb.append(" ").append(line.substring(range.startCharacter, range.endCharacter)) + case _ => + sb.append("[):") + end match + sb.append(if occ.role.isReference then " -> " else " <- ").append(occ.symbol).nl + end processOccurrence + + private inline def (sb: StringBuilder) nl = sb.append(System.lineSeparator) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/InvalidProtocolBufferException.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/InvalidProtocolBufferException.scala new file mode 100644 index 000000000000..886067ed7a43 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/InvalidProtocolBufferException.scala @@ -0,0 +1,55 @@ +package dotty.tools.dotc.semanticdb.internal + +import java.io.IOException + +@SerialVersionUID(-1616151763072450476L) +class InvalidProtocolBufferException(description: String) extends IOException(description) + +object InvalidProtocolBufferException { + + def truncatedMessage(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("While parsing a protocol message, the input ended unexpectedly " + + "in the middle of a field. This could mean either that the " + + "input has been truncated or that an embedded message " + + "misreported its own length.") + } + + def negativeSize(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("SemanticdbInputStream encountered an embedded string or message " + + "which claimed to have negative size.") + } + + def malformedVarint(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("SemanticdbInputStream encountered a malformed varint.") + } + + def invalidTag(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message contained an invalid tag (zero).") + } + + def invalidEndTag(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message end-group tag did not match expected tag.") + } + + def invalidWireType(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message tag had invalid wire type.") + } + + def recursionLimitExceeded(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message had too many levels of nesting. May be malicious. " + + "Use SemanticdbInputStream.setRecursionLimit() to increase the depth limit.") + } + + def sizeLimitExceeded(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message was too large. May be malicious. " + + "Use SemanticdbInputStream.setSizeLimit() to increase the size limit.") + } + + def parseFailure(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Failed to parse the message.") + } + + def invalidUtf8(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message had invalid UTF-8.") + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/LiteParser.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/LiteParser.scala new file mode 100644 index 000000000000..48412fd027b8 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/LiteParser.scala @@ -0,0 +1,19 @@ +package dotty.tools.dotc.semanticdb.internal + +import java.io.InputStream + +object LiteParser { + + def readMessage[A](input: SemanticdbInputStream, message: SemanticdbMessage[A]): A = { + val length = input.readRawVarint32() + val oldLimit = input.pushLimit(length) + val result: A = message.mergeFrom(input) + input.checkLastTagWas(0) + input.popLimit(oldLimit) + result + } + + @inline + def preferredSemanticdbOutputStreamBufferSize(dataLength: Int) = + dataLength min SemanticdbOutputStream.DEFAULT_BUFFER_SIZE +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala new file mode 100644 index 000000000000..01bcc36467f4 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala @@ -0,0 +1,28 @@ +package dotty.tools.dotc.semanticdb.internal + +import java.nio.ByteBuffer +import java.nio.charset.StandardCharsets +import java.security.MessageDigest + +object MD5 { + def compute(string: String): String = { + compute(ByteBuffer.wrap(string.getBytes(StandardCharsets.UTF_8))) + } + def compute(buffer: ByteBuffer): String = { + val md = MessageDigest.getInstance("MD5") + md.update(buffer) + bytesToHex(md.digest()) + } + private val hexArray = "0123456789ABCDEF".toCharArray + def bytesToHex(bytes: Array[Byte]): String = { + val hexChars = new Array[Char](bytes.length * 2) + var j = 0 + while (j < bytes.length) { + val v: Int = bytes(j) & 0xFF + hexChars(j * 2) = hexArray(v >>> 4) + hexChars(j * 2 + 1) = hexArray(v & 0x0F) + j += 1 + } + new String(hexChars) + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbEnum.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbEnum.scala new file mode 100644 index 000000000000..18b8edf8dab0 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbEnum.scala @@ -0,0 +1,5 @@ +package dotty.tools.dotc.semanticdb.internal + +trait SemanticdbEnum { + def value: Int +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala new file mode 100644 index 000000000000..34210965607f --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala @@ -0,0 +1,777 @@ +package dotty.tools.dotc.semanticdb.internal + +import java.io.IOException +import java.io.InputStream +import java.util.Arrays +import SemanticdbInputStream._ + +import scala.collection.mutable + +object SemanticdbInputStream { + + def newInstance(input: InputStream): SemanticdbInputStream = new SemanticdbInputStream(input) + + def newInstance(buf: Array[Byte]): SemanticdbInputStream = newInstance(buf, 0, buf.length) + + def newInstance(buf: Array[Byte], off: Int, len: Int): SemanticdbInputStream = { + val result = new SemanticdbInputStream(buf, off, len) + result.pushLimit(len) + result + } + + @throws[InvalidProtocolBufferException] + def readRawVarint32(input: InputStream): Int = { + val firstByte = input.read() + if (firstByte == -1) { + throw InvalidProtocolBufferException.truncatedMessage() + } + readRawVarint32(firstByte, input) + } + + def readRawVarint32(firstByte: Int, input: InputStream): Int = { + if ((firstByte & 0x80) == 0) { + return firstByte + } + var result = firstByte & 0x7f + var offset = 7 + while (offset < 32) { + val b = input.read() + if (b == -1) { + throw InvalidProtocolBufferException.truncatedMessage() + } + result |= (b & 0x7f) << offset + if ((b & 0x80) == 0) { + return result + } + offset += 7 + } + while (offset < 64) { + val b = input.read() + if (b == -1) { + throw InvalidProtocolBufferException.truncatedMessage() + } + if ((b & 0x80) == 0) { + return result + } + offset += 7 + } + throw InvalidProtocolBufferException.malformedVarint() + } + + def decodeZigZag32(n: Int): Int = (n >>> 1) ^ -(n & 1) + + def decodeZigZag64(n: Long): Long = (n >>> 1) ^ -(n & 1) + + private val DEFAULT_RECURSION_LIMIT = 100 + + private val DEFAULT_SIZE_LIMIT = 64 << 20 + + private val BUFFER_SIZE = 4096 +} + +class SemanticdbInputStream private (buffer: Array[Byte], input: InputStream) { + /** + * The total number of bytes read before the current buffer. The total + * bytes read up to the current position can be computed as + * {@code totalBytesRetired + bufferPos}. This value may be negative if + * reading started in the middle of the current buffer (e.g. if the + * constructor that takes a byte array and an offset was used). + */ + private var totalBytesRetired: Int = 0 + + // Current position in the buffer. + private var bufferPos: Int = 0 + + // How many bytes in the buffer contain actual content (bufferSize <= buffer.length) + private var bufferSize: Int = 0 + + private var currentLimit: Int = Int.MaxValue + + private var sizeLimit = SemanticdbInputStream.DEFAULT_SIZE_LIMIT + + private var bufferSizeAfterLimit = 0 + + private var lastTag = 0 + + def this(buffer: Array[Byte], offset: Int, len: Int) = { + this(buffer, null) + bufferPos = offset + bufferSize = offset + len + totalBytesRetired = -offset + } + + def this(is: InputStream) = { + this(new Array[Byte](SemanticdbInputStream.BUFFER_SIZE), is) + totalBytesRetired = 0 + } + + /** + * Ensures that at least {@code n} bytes are available in the buffer, reading + * more bytes from the input if necessary to make it so. Caller must ensure + * that the requested space is less than BUFFER_SIZE. + */ + private def ensureAvailable(n: Int): Unit = { + if (bufferSize - bufferPos < n) { + refillBuffer(n) + } + } + + /** + * Reads more bytes from the input, making at least {@code n} bytes available + * in the buffer. Caller must ensure that the requested space is not yet + * available, and that the requested space is less than BUFFER_SIZE. + */ + private def refillBuffer(n: Int): Unit = { + if (!tryRefillBuffer(n)) { + throw InvalidProtocolBufferException.truncatedMessage() + } + } + /** + * Tries to read more bytes from the input, making at least {@code n} bytes + * available in the buffer. Caller must ensure that the requested space is + * not yet available, and that the requested space is less than BUFFER_SIZE. + * + * @return { @code true} if the bytes could be made available; { @code false} + * if the end of the stream or the current limit was reached. + */ + private def tryRefillBuffer(n: Int): Boolean = { + if (bufferPos + n <= bufferSize) { + throw new IllegalStateException( + s"refillBuffer() called when $n bytes were already available in buffer") + } + if (totalBytesRetired + bufferPos + n > currentLimit) false + else if (input != null) { + val pos: Int = bufferPos + if (pos > 0) { + if (bufferSize > pos) { + System.arraycopy(buffer, pos, buffer, 0, bufferSize - pos) + } + totalBytesRetired += pos + bufferSize -= pos + bufferPos = 0 + } + val bytesRead: Int = input.read(buffer, bufferSize, buffer.length - bufferSize) + if (bytesRead == 0 || bytesRead < -1 || bytesRead > buffer.length) { + throw new IllegalStateException("InputStream#read(byte[]) returned invalid result: " + bytesRead + "\nThe InputStream implementation is buggy.") + } + if (bytesRead > 0) { + bufferSize += bytesRead + if (totalBytesRetired + n - sizeLimit > 0) { + throw InvalidProtocolBufferException.sizeLimitExceeded() + } + recomputeBufferSizeAfterLimit() + return ((bufferSize >= n) || tryRefillBuffer(n)) + } + } + false + } + + private def recomputeBufferSizeAfterLimit(): Unit = { + bufferSize += bufferSizeAfterLimit + val bufferEnd: Int = totalBytesRetired + bufferSize + if (bufferEnd > currentLimit) { + bufferSizeAfterLimit = bufferEnd - currentLimit + bufferSize -= bufferSizeAfterLimit + } + else { + bufferSizeAfterLimit = 0 + } + } + + /** + * Returns true if the stream has reached the end of the input. This is the + * case if either the end of the underlying input source has been reached or + * if the stream has reached a limit created using {@link #pushLimit(int)}. + */ + def isAtEnd: Boolean = { + bufferPos == bufferSize && !tryRefillBuffer(1) + } + + def getTotalBytesRead() = { + totalBytesRetired + bufferPos + } + + /** + * Sets {@code currentLimit} to (current position) + {@code byteLimit}. This + * is called when descending into a length-delimited embedded message. + * + *

Note that {@code pushLimit()} does NOT affect how many bytes the + * {@code SemanticdbInputStream} reads from an underlying {@code InputStream} when + * refreshing its buffer. If you need to prevent reading past a certain + * point in the underlying {@code InputStream} (e.g. because you expect it to + * contain more data after the end of the message which you need to handle + * differently) then you must place a wrapper around your {@code InputStream} + * which limits the amount of data that can be read from it. + * + * @return the old limit. + */ + def pushLimit(byteLimit0: Int): Int = { + if (byteLimit0 < 0) { + throw InvalidProtocolBufferException.negativeSize() + } + val byteLimit = byteLimit0 + totalBytesRetired + bufferPos + val oldLimit: Int = currentLimit + if (byteLimit > oldLimit) { + throw InvalidProtocolBufferException.truncatedMessage() + } + currentLimit = byteLimit + recomputeBufferSizeAfterLimit() + oldLimit + } + + /** + * Discards the current limit, returning to the previous limit. + * + * @param oldLimit The old limit, as returned by { @code pushLimit}. + */ + def popLimit(oldLimit: Int): Unit = { + currentLimit = oldLimit + recomputeBufferSizeAfterLimit() + } + + /** + * Reads and discards a single field, given its tag value. + * + * @return { @code false} if the tag is an endgroup tag, in which case + * nothing is skipped. Otherwise, returns { @code true}. + */ + @throws(classOf[IOException]) + def skipField(tag: Int): Boolean = { + WireFormat.getTagWireType(tag) match { + case WireFormat.WIRETYPE_VARINT => + skipRawVarint() + true + case WireFormat.WIRETYPE_FIXED64 => + skipRawBytes(8) + true + case WireFormat.WIRETYPE_LENGTH_DELIMITED => + skipRawBytes(readRawVarint32()) + true + case WireFormat.WIRETYPE_START_GROUP => + skipMessage() + checkLastTagWas(WireFormat.makeTag(WireFormat.getTagFieldNumber(tag), WireFormat.WIRETYPE_END_GROUP)) + true + case WireFormat.WIRETYPE_END_GROUP => + false + case WireFormat.WIRETYPE_FIXED32 => + skipRawBytes(4) + true + case _ => + throw InvalidProtocolBufferException.invalidWireType() + } + } + + /** + * Reads and discards an entire message. This will read either until EOF + * or until an endgroup tag, whichever comes first. + */ + def skipMessage(): Unit = { + while (true) { + val tag: Int = readTag() + if (tag == 0 || !skipField(tag)) { + return + } + } + } + + /** + * Reads and discards {@code size} bytes. + */ + def skipRawBytes(size: Int): Unit = { + if (size <= (bufferSize - bufferPos) && size >= 0) { + bufferPos += size + } + else { + skipRawBytesSlowPath(size) + } + } + + /** + * Read a raw Varint from the stream. If larger than 32 bits, discard the + * upper bits. + */ + @throws[InvalidProtocolBufferException] + def readRawVarint32(): Int = { + { + var pos: Int = bufferPos + if (bufferSize == pos) { + return readRawVarint64SlowPath().toInt + } + val buffer: Array[Byte] = this.buffer + var x: Int = 0 + if ((({ + x = buffer(({ + pos += 1; pos - 1 + })); x + })) >= 0) { + bufferPos = pos + return x + } + else if (bufferSize - pos < 9) { + return readRawVarint64SlowPath().toInt + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })) << 7); x + })) < 0) { + x ^= (~0 << 7) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })) << 14); x + })) >= 0) { + x ^= (~0 << 7) ^ (~0 << 14) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })) << 21); x + })) < 0) { + x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21) + } + else { + val y: Int = buffer(({ + pos += 1; pos - 1 + })) + x ^= y << 28 + x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21) ^ (~0 << 28) + if (y < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0) { + return readRawVarint64SlowPath().toInt + } + } + bufferPos = pos + return x + } //todo: labels is not supported + } + + private def skipRawVarint(): Unit = { + if (bufferSize - bufferPos >= 10) { + val buffer: Array[Byte] = this.buffer + var pos: Int = bufferPos + var i: Int = 0 + while (i < 10) { + { + if (buffer(({ + pos += 1; pos - 1 + })) >= 0) { + bufferPos = pos + return + } + } + ({ + i += 1; i - 1 + }) + } + } + skipRawVarintSlowPath + } + + @throws(classOf[IOException]) + private def skipRawVarintSlowPath: Unit = { + var i: Int = 0 + while (i < 10) { + if (readRawByte() >= 0) { + return + } + i += 1; i - 1 + } + throw InvalidProtocolBufferException.malformedVarint() + } + + /** + * Exactly like skipRawBytes, but caller must have already checked the fast + * path: (size <= (bufferSize - pos) && size >= 0) + */ + private def skipRawBytesSlowPath(size: Int): Unit = { + if (size < 0) { + throw InvalidProtocolBufferException.negativeSize() + } + if (totalBytesRetired + bufferPos + size > currentLimit) { + skipRawBytes(currentLimit - totalBytesRetired - bufferPos) + throw InvalidProtocolBufferException.truncatedMessage() + } + var pos: Int = bufferSize - bufferPos + bufferPos = bufferSize + refillBuffer(1) + while (size - pos > bufferSize) { + pos += bufferSize + bufferPos = bufferSize + refillBuffer(1) + } + bufferPos = size - pos + } + + /** + * Attempt to read a field tag, returning zero if we have reached EOF. + * Protocol message parsers use this to read tags, since a protocol message + * may legally end wherever a tag occurs, and zero is not a valid tag number. + */ + @throws[InvalidProtocolBufferException] + def readTag(): Int = { + if (isAtEnd) { + lastTag = 0 + return 0 + } + lastTag = readRawVarint32() + if (WireFormat.getTagFieldNumber(lastTag) == 0) { + throw InvalidProtocolBufferException.invalidTag() + } + lastTag + } + + def readString(): String = { + val size: Int = readRawVarint32() + if (size <= (bufferSize - bufferPos) && size > 0) { + val result: String = new String(buffer, bufferPos, size, Internal.UTF_8) + bufferPos += size + return result + } + else if (size == 0) { + return "" + } + else { + return new String(readRawBytesSlowPath(size), Internal.UTF_8) + } + } + + def checkLastTagWas(value: Int): Unit = { + if (lastTag != value) { + throw InvalidProtocolBufferException.invalidEndTag(); + } + } + + def getBytesUntilLimit: Int = { + if (currentLimit == Integer.MAX_VALUE) { + return -1 + } + + val currentAbsolutePosition: Int = totalBytesRetired + bufferPos + return currentLimit - currentAbsolutePosition + } + + /** Read a {@code double} field value from the stream. */ + def readDouble(): Double = { + return java.lang.Double.longBitsToDouble(readRawLittleEndian64()) + } + + /** Read a {@code float} field value from the stream. */ + def readFloat(): Float = { + java.lang.Float.intBitsToFloat(readRawLittleEndian32()) + } + + /** Read a {@code uint64} field value from the stream. */ + def readUInt64(): Long = { + readRawVarint64() + } + + /** Read an {@code int64} field value from the stream. */ + def readInt64(): Long = { + readRawVarint64() + } + + /** Read an {@code int32} field value from the stream. */ + def readInt32(): Int = { + readRawVarint32() + } + + /** Read a {@code fixed64} field value from the stream. */ + def readFixed64(): Long = { + readRawLittleEndian64() + } + + /** Read a {@code fixed32} field value from the stream. */ + def readFixed32(): Int = { + readRawLittleEndian32() + } + + /** Read a {@code uint32} field value from the stream. */ + def readUInt32(): Int = { + readRawVarint32() + } + + /** + * Read an enum field value from the stream. Caller is responsible + * for converting the numeric value to an actual enum. + */ + def readEnum(): Int = { + readRawVarint32() + } + + /** Read an {@code sfixed32} field value from the stream. */ + def readSFixed32(): Int = { + readRawLittleEndian32() + } + + /** Read an {@code sfixed64} field value from the stream. */ + def readSFixed64(): Long = { + readRawLittleEndian64() + } + + /** Read an {@code sint32} field value from the stream. */ + def readSInt32(): Int = { + decodeZigZag32(readRawVarint32()) + } + + /** Read an {@code sint64} field value from the stream. */ + def readSInt64(): Long = { + decodeZigZag64(readRawVarint64()) + } + + /** Read a {@code bool} field value from the stream. */ + def readBool(): Boolean = { + readRawVarint64() != 0 + } + + /** Read a raw Varint from the stream. */ + @throws[InvalidProtocolBufferException] + def readRawVarint64(): Long = { + var pos: Int = bufferPos + if (bufferSize == pos) { + return readRawVarint64SlowPath() + } + val buffer: Array[Byte] = this.buffer + var x: Long = 0L + var y: Int = 0 + if ((({ + y = buffer(({ + pos += 1; pos - 1 + })); y + })) >= 0) { + bufferPos = pos + return y + } + else if (bufferSize - pos < 9) { + return readRawVarint64SlowPath() + } + else if ((({ + y ^= (buffer(({ + pos += 1; pos - 1 + })) << 7); y + })) < 0) { + x = y ^ (~0 << 7) + } + else if ((({ + y ^= (buffer(({ + pos += 1; pos - 1 + })) << 14); y + })) >= 0) { + x = y ^ ((~0 << 7) ^ (~0 << 14)) + } + else if ((({ + y ^= (buffer(({ + pos += 1; pos - 1 + })) << 21); y + })) < 0) { + x = y ^ ((~0 << 7) ^ (~0 << 14) ^ (~0 << 21)) + } + else if ((({ + x = (y.toLong) ^ (buffer(({ + pos += 1; pos - 1 + })).toLong << 28); x + })) >= 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })).toLong << 35); x + })) < 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })).toLong << 42); x + })) >= 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })).toLong << 49); x + })) < 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42) ^ (~0L << 49) + } + else { + x ^= (buffer(({ + pos += 1; pos - 1 + })).toLong << 56) + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42) ^ (~0L << 49) ^ (~0L << 56) + if (x < 0L) { + if (buffer(({ + pos += 1; pos - 1 + })) < 0L) { + return readRawVarint64SlowPath() + } + } + } + bufferPos = pos + x + } + + /** Variant of readRawVarint64 for when uncomfortably close to the limit. */ + @throws[InvalidProtocolBufferException] + private[semanticdb] def readRawVarint64SlowPath(): Long = { + var result: Long = 0 + var shift: Int = 0 + while (shift < 64) { + val b: Byte = readRawByte() + result |= (b & 0x7F).toLong << shift + if ((b & 0x80) == 0) { + return result + } + shift += 7 + } + throw InvalidProtocolBufferException.malformedVarint() + } + + /** Read a 32-bit little-endian integer from the stream. */ + def readRawLittleEndian32(): Int = { + var pos: Int = bufferPos + if (bufferSize - pos < 4) { + refillBuffer(4) + pos = bufferPos + } + val buffer: Array[Byte] = this.buffer + bufferPos = pos + 4 + (((buffer(pos) & 0xff)) | + ((buffer(pos + 1) & 0xff) << 8) | + ((buffer(pos + 2) & 0xff) << 16) | + ((buffer(pos + 3) & 0xff) << 24)) + } + + /** Read a 64-bit little-endian integer from the stream. */ + def readRawLittleEndian64(): Long = { + var pos: Int = bufferPos + if (bufferSize - pos < 8) { + refillBuffer(8) + pos = bufferPos + } + val buffer: Array[Byte] = this.buffer + bufferPos = pos + 8 + (((buffer(pos).toLong & 0xffL)) | + ((buffer(pos + 1).toLong & 0xffL) << 8) | + ((buffer(pos + 2).toLong & 0xffL) << 16) | + ((buffer(pos + 3).toLong & 0xffL) << 24) | + ((buffer(pos + 4).toLong & 0xffL) << 32) | + ((buffer(pos + 5).toLong & 0xffL) << 40) | + ((buffer(pos + 6).toLong & 0xffL) << 48) | + ((buffer(pos + 7).toLong & 0xffL) << 56)) + } + + /** + * Read one byte from the input. + */ + @throws[InvalidProtocolBufferException] + def readRawByte(): Byte = { + if (bufferPos == bufferSize) { + refillBuffer(1) + } + buffer({ + bufferPos += 1; bufferPos - 1 + }) + } + + /** + * Read a fixed size of bytes from the input. + */ + @throws[InvalidProtocolBufferException] + def readRawBytes(size: Int): Array[Byte] = { + val pos: Int = bufferPos + if (size <= (bufferSize - pos) && size > 0) { + bufferPos = pos + size + Arrays.copyOfRange(buffer, pos, pos + size) + } + else { + readRawBytesSlowPath(size) + } + } + + /** + * Exactly like readRawBytes, but caller must have already checked the fast + * path: (size <= (bufferSize - pos) && size > 0) + */ + private def readRawBytesSlowPath(size: Int): Array[Byte] = { + if (size <= 0) { + if (size == 0) { + return Internal.EMPTY_BYTE_ARRAY + } + else { + throw InvalidProtocolBufferException.negativeSize() + } + } + if (totalBytesRetired + bufferPos + size > currentLimit) { + skipRawBytes(currentLimit - totalBytesRetired - bufferPos) + throw InvalidProtocolBufferException.truncatedMessage() + } + if (size < BUFFER_SIZE) { + val bytes: Array[Byte] = new Array[Byte](size) + val pos: Int = bufferSize - bufferPos + System.arraycopy(buffer, bufferPos, bytes, 0, pos) + bufferPos = bufferSize + ensureAvailable(size - pos) + System.arraycopy(buffer, 0, bytes, pos, size - pos) + bufferPos = size - pos + bytes + } + else { + val originalBufferPos: Int = bufferPos + val originalBufferSize: Int = bufferSize + totalBytesRetired += bufferSize + bufferPos = 0 + bufferSize = 0 + var sizeLeft: Int = size - (originalBufferSize - originalBufferPos) + val chunks: mutable.ArrayBuffer[Array[Byte]] = new mutable.ArrayBuffer[Array[Byte]] + while (sizeLeft > 0) { + val chunk: Array[Byte] = new Array[Byte](Math.min(sizeLeft, BUFFER_SIZE)) + var pos: Int = 0 + while (pos < chunk.length) { + val n: Int = if ((input == null)) -1 else input.read(chunk, pos, chunk.length - pos) + if (n == -1) { + throw InvalidProtocolBufferException.truncatedMessage() + } + totalBytesRetired += n + pos += n + } + sizeLeft -= chunk.length + chunks+=(chunk) + } + val bytes: Array[Byte] = new Array[Byte](size) + var pos: Int = originalBufferSize - originalBufferPos + System.arraycopy(buffer, originalBufferPos, bytes, 0, pos) + for (chunk <- chunks) { + System.arraycopy(chunk, 0, bytes, pos, chunk.length) + pos += chunk.length + } + bytes + } + } + + def enableAliasing(aliasing: Boolean): Unit = {} + + def setSizeLimit(limit: Int): Int = { + if (limit < 0) { + throw new IllegalArgumentException( + "Size limit cannot be negative: " + limit) + } + val oldLimit: Int = sizeLimit + sizeLimit = limit + oldLimit + } + + def resetSizeCounter(): Unit = { + totalBytesRetired = -bufferPos; + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbMessage.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbMessage.scala new file mode 100644 index 000000000000..e20d1691a05d --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbMessage.scala @@ -0,0 +1,7 @@ +package dotty.tools.dotc.semanticdb.internal + +trait SemanticdbMessage[A] { + def serializedSize: Int + def writeTo(out: SemanticdbOutputStream): Unit + def mergeFrom(in: SemanticdbInputStream): A +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala new file mode 100644 index 000000000000..2da5b70cbb91 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala @@ -0,0 +1,607 @@ +package dotty.tools.dotc.semanticdb.internal + +import java.io.IOException +import java.io.OutputStream +import java.nio.ByteBuffer +import SemanticdbOutputStream._ + +object SemanticdbOutputStream { + + val DEFAULT_BUFFER_SIZE = 4096 + + def computePreferredBufferSize(dataLength: Int): Int = { + if (dataLength > DEFAULT_BUFFER_SIZE) return DEFAULT_BUFFER_SIZE + dataLength + } + + def newInstance(output: OutputStream): SemanticdbOutputStream = { + newInstance(output, DEFAULT_BUFFER_SIZE) + } + + def newInstance(output: OutputStream, bufferSize: Int): SemanticdbOutputStream = { + new SemanticdbOutputStream(output, Array.ofDim[Byte](bufferSize)) + } + + def newInstance(byteBuffer: ByteBuffer): SemanticdbOutputStream = { + newInstance(byteBuffer, DEFAULT_BUFFER_SIZE) + } + + def newInstance(b: Array[Byte]): SemanticdbOutputStream = { + new SemanticdbOutputStream(null, b) + } + + def newInstance( + byteBuffer: ByteBuffer, + bufferSize: Int + ): SemanticdbOutputStream = { + newInstance(new ByteBufferOutputStream(byteBuffer), bufferSize) + } + + private class ByteBufferOutputStream(private val byteBuffer: ByteBuffer) + extends OutputStream { + + override def write(b: Int): Unit = { + byteBuffer.put(b.toByte) + } + + override def write(data: Array[Byte], offset: Int, length: Int): Unit = { + byteBuffer.put(data, offset, length) + } + } + + def computeDoubleSize(fieldNumber: Int, value: Double): Int = { + computeTagSize(fieldNumber) + computeDoubleSizeNoTag(value) + } + + def computeFloatSize(fieldNumber: Int, value: Float): Int = { + computeTagSize(fieldNumber) + computeFloatSizeNoTag(value) + } + + def computeUInt64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeUInt64SizeNoTag(value) + } + + def computeInt64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeInt64SizeNoTag(value) + } + + def computeInt32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeInt32SizeNoTag(value) + } + + def computeFixed64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeFixed64SizeNoTag(value) + } + + def computeFixed32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeFixed32SizeNoTag(value) + } + + def computeBoolSize(fieldNumber: Int, value: Boolean): Int = { + computeTagSize(fieldNumber) + computeBoolSizeNoTag(value) + } + + def computeStringSize(fieldNumber: Int, value: String): Int = { + computeTagSize(fieldNumber) + computeStringSizeNoTag(value) + } + + // def computeBytesSize(fieldNumber: Int, value: ByteString): Int = { + // computeTagSize(fieldNumber) + computeBytesSizeNoTag(value) + // } + + def computeByteArraySize(fieldNumber: Int, value: Array[Byte]): Int = { + computeTagSize(fieldNumber) + computeByteArraySizeNoTag(value) + } + + def computeByteBufferSize(fieldNumber: Int, value: ByteBuffer): Int = { + computeTagSize(fieldNumber) + computeByteBufferSizeNoTag(value) + } + + def computeUInt32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeUInt32SizeNoTag(value) + } + + def computeEnumSize(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeEnumSizeNoTag(value) + } + + def computeSFixed32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeSFixed32SizeNoTag(value) + } + + def computeSFixed64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeSFixed64SizeNoTag(value) + } + + def computeSInt32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeSInt32SizeNoTag(value) + } + + def computeSInt64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeSInt64SizeNoTag(value) + } + + def computeDoubleSizeNoTag(value: Double): Int = LITTLE_ENDIAN_64_SIZE + + def computeFloatSizeNoTag(value: Float): Int = LITTLE_ENDIAN_32_SIZE + + def computeUInt64SizeNoTag(value: Long): Int = computeRawVarint64Size(value) + + def computeInt64SizeNoTag(value: Long): Int = computeRawVarint64Size(value) + + def computeInt32SizeNoTag(value: Int): Int = { + if (value >= 0) { + computeRawVarint32Size(value) + } else { + 10 + } + } + + def computeFixed64SizeNoTag(value: Long): Int = LITTLE_ENDIAN_64_SIZE + + def computeFixed32SizeNoTag(value: Int): Int = LITTLE_ENDIAN_32_SIZE + + def computeBoolSizeNoTag(value: Boolean): Int = 1 + + def computeStringSizeNoTag(value: String): Int = { + val bytes = value.getBytes(Internal.UTF_8) + computeRawVarint32Size(bytes.length) + bytes.length + } + + // def computeBytesSizeNoTag(value: ByteString): Int = { + // computeRawVarint32Size(value.size) + value.size + // } + + def computeByteArraySizeNoTag(value: Array[Byte]): Int = { + computeRawVarint32Size(value.length) + value.length + } + + def computeByteBufferSizeNoTag(value: ByteBuffer): Int = { + computeRawVarint32Size(value.capacity()) + value.capacity() + } + + def computeUInt32SizeNoTag(value: Int): Int = computeRawVarint32Size(value) + + def computeEnumSizeNoTag(value: Int): Int = computeInt32SizeNoTag(value) + + def computeSFixed32SizeNoTag(value: Int): Int = LITTLE_ENDIAN_32_SIZE + + def computeSFixed64SizeNoTag(value: Long): Int = LITTLE_ENDIAN_64_SIZE + + def computeSInt32SizeNoTag(value: Int): Int = { + computeRawVarint32Size(encodeZigZag32(value)) + } + + def computeSInt64SizeNoTag(value: Long): Int = { + computeRawVarint64Size(encodeZigZag64(value)) + } + + @SerialVersionUID(-6947486886997889499L) + class OutOfSpaceException() + extends IOException( + "SemanticdbOutputStream was writing to a flat byte array and ran " + + "out of space." + ) + + def computeTagSize(fieldNumber: Int): Int = { + computeRawVarint32Size(WireFormat.makeTag(fieldNumber, 0)) + } + + def computeRawVarint32Size(value: Int): Int = { + if ((value & (0xffffffff << 7)) == 0) return 1 + if ((value & (0xffffffff << 14)) == 0) return 2 + if ((value & (0xffffffff << 21)) == 0) return 3 + if ((value & (0xffffffff << 28)) == 0) return 4 + 5 + } + + def computeRawVarint64Size(value: Long): Int = { + if ((value & (0xFFFFFFFFFFFFFFFFL << 7)) == 0) return 1 + if ((value & (0xFFFFFFFFFFFFFFFFL << 14)) == 0) return 2 + if ((value & (0xFFFFFFFFFFFFFFFFL << 21)) == 0) return 3 + if ((value & (0xFFFFFFFFFFFFFFFFL << 28)) == 0) return 4 + if ((value & (0xFFFFFFFFFFFFFFFFL << 35)) == 0) return 5 + if ((value & (0xFFFFFFFFFFFFFFFFL << 42)) == 0) return 6 + if ((value & (0xFFFFFFFFFFFFFFFFL << 49)) == 0) return 7 + if ((value & (0xFFFFFFFFFFFFFFFFL << 56)) == 0) return 8 + if ((value & (0xFFFFFFFFFFFFFFFFL << 63)) == 0) return 9 + 10 + } + + val LITTLE_ENDIAN_32_SIZE = 4 + + val LITTLE_ENDIAN_64_SIZE = 8 + + def encodeZigZag32(n: Int): Int = (n << 1) ^ (n >> 31) + + def encodeZigZag64(n: Long): Long = (n << 1) ^ (n >> 63) +} + +class SemanticdbOutputStream(output: OutputStream, buffer: Array[Byte]) { + private def refreshBuffer(): Unit = { + if (output == null) { + throw new OutOfSpaceException() + } + output.write(buffer, 0, position) + position = 0 + } + + def flush(): Unit = { + if (output != null) { + refreshBuffer() + } + } + + def spaceLeft(): Int = { + if (output == null) { + limit - position + } else { + throw new UnsupportedOperationException( + "spaceLeft() can only be called on SemanticdbOutputStreams that are " + + "writing to a flat array." + ) + } + } + + def checkNoSpaceLeft(): Unit = { + if (spaceLeft() != 0) { + throw new IllegalStateException("Did not write as much data as expected.") + } + } + + private var position = 0 + private val limit = buffer.length + + private var totalBytesWritten: Int = 0 + + def writeDouble(fieldNumber: Int, value: Double): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64) + writeDoubleNoTag(value) + } + + def writeFloat(fieldNumber: Int, value: Float): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32) + writeFloatNoTag(value) + } + + def writeUInt64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeUInt64NoTag(value) + } + + def writeInt64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeInt64NoTag(value) + } + + def writeInt32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeInt32NoTag(value) + } + + def writeFixed64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64) + writeFixed64NoTag(value) + } + + def writeFixed32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32) + writeFixed32NoTag(value) + } + + def writeBool(fieldNumber: Int, value: Boolean): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeBoolNoTag(value) + } + + def writeString(fieldNumber: Int, value: String): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + writeStringNoTag(value) + } + + // def writeBytes(fieldNumber: Int, value: ByteString): Unit = { + // writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + // writeBytesNoTag(value) + // } + + def writeByteArray(fieldNumber: Int, value: Array[Byte]): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + writeByteArrayNoTag(value) + } + + def writeByteArray( + fieldNumber: Int, + value: Array[Byte], + offset: Int, + length: Int + ): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + writeByteArrayNoTag(value, offset, length) + } + + def writeByteBuffer(fieldNumber: Int, value: ByteBuffer): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + writeByteBufferNoTag(value) + } + + def writeUInt32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeUInt32NoTag(value) + } + + def writeEnum(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeEnumNoTag(value) + } + + def writeSFixed32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32) + writeSFixed32NoTag(value) + } + + def writeSFixed64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64) + writeSFixed64NoTag(value) + } + + def writeSInt32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeSInt32NoTag(value) + } + + def writeSInt64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeSInt64NoTag(value) + } + + def writeDoubleNoTag(value: Double): Unit = { + writeRawLittleEndian64(java.lang.Double.doubleToLongBits(value)) + } + + def writeFloatNoTag(value: Float): Unit = { + writeRawLittleEndian32(java.lang.Float.floatToIntBits(value)) + } + + def writeUInt64NoTag(value: Long): Unit = { + writeRawVarint64(value) + } + + def writeInt64NoTag(value: Long): Unit = { + writeRawVarint64(value) + } + + def writeInt32NoTag(value: Int): Unit = { + if (value >= 0) { + writeRawVarint32(value) + } else { + writeRawVarint64(value) + } + } + + def writeFixed64NoTag(value: Long): Unit = { + writeRawLittleEndian64(value) + } + + def writeFixed32NoTag(value: Int): Unit = { + writeRawLittleEndian32(value) + } + + def writeBoolNoTag(value: Boolean): Unit = { + writeRawByte(if (value) 1 else 0) + } + + def writeStringNoTag(value: String): Unit = { + val bytes = value.getBytes(Internal.UTF_8) + writeRawVarint32(bytes.length) + writeRawBytes(bytes) + } + + def writeTag(fieldNumber: Int, wireType: Int): Unit = { + writeRawVarint32(WireFormat.makeTag(fieldNumber, wireType)) + } + + def writeRawVarint32(value0: Int): Unit = { + var value = value0 + while (true) { + if ((value & ~0x7F) == 0) { + writeRawByte(value) + return + } else { + writeRawByte((value & 0x7F) | 0x80) + value >>>= 7 + } + } + } + + def writeRawVarint64(value0: Long): Unit = { + var value = value0 + while (true) { + if ((value & ~0x7FL) == 0) { + writeRawByte(value.toInt) + return + } else { + writeRawByte((value.toInt & 0x7F) | 0x80) + value >>>= 7 + } + } + } + + def writeRawLittleEndian32(value: Int): Unit = { + writeRawByte((value) & 0xFF) + writeRawByte((value >> 8) & 0xFF) + writeRawByte((value >> 16) & 0xFF) + writeRawByte((value >> 24) & 0xFF) + } + + def writeRawLittleEndian64(value: Long): Unit = { + writeRawByte((value).toInt & 0xFF) + writeRawByte((value >> 8).toInt & 0xFF) + writeRawByte((value >> 16).toInt & 0xFF) + writeRawByte((value >> 24).toInt & 0xFF) + writeRawByte((value >> 32).toInt & 0xFF) + writeRawByte((value >> 40).toInt & 0xFF) + writeRawByte((value >> 48).toInt & 0xFF) + writeRawByte((value >> 56).toInt & 0xFF) + } + + // def writeBytesNoTag(value: ByteString): Unit = { + // writeRawVarint32(value.size) + // writeRawBytes(value) + // } + + def writeByteArrayNoTag(value: Array[Byte]): Unit = { + writeRawVarint32(value.length) + writeRawBytes(value) + } + + def writeByteArrayNoTag( + value: Array[Byte], + offset: Int, + length: Int + ): Unit = { + writeRawVarint32(length) + writeRawBytes(value, offset, length) + } + + def writeByteBufferNoTag(value: ByteBuffer): Unit = { + writeRawVarint32(value.capacity()) + writeRawBytes(value) + } + + def writeUInt32NoTag(value: Int): Unit = { + writeRawVarint32(value) + } + + def writeEnumNoTag(value: Int): Unit = { + writeInt32NoTag(value) + } + + def writeSFixed32NoTag(value: Int): Unit = { + writeRawLittleEndian32(value) + } + + def writeSFixed64NoTag(value: Long): Unit = { + writeRawLittleEndian64(value) + } + + def writeSInt32NoTag(value: Int): Unit = { + writeRawVarint32(encodeZigZag32(value)) + } + + def writeSInt64NoTag(value: Long): Unit = { + writeRawVarint64(encodeZigZag64(value)) + } + + def writeRawByte(value: Byte): Unit = { + if (position == limit) { + refreshBuffer() + } + buffer(position) = value + position += 1 + } + + def writeRawByte(value: Int): Unit = { + writeRawByte(value.toByte) + } + + // def writeRawBytes(value: ByteString): Unit = { + // var offset = 0 + // var length = value.size + // if (limit - position >= length) { + // // We have room in the current buffer. + // value.copyTo(buffer, offset, position, length) + // position += length + // totalBytesWritten += length + // } else { + // // Write extends past current buffer. Fill the rest of this buffer and + // // flush. + // val bytesWritten = limit - position + // value.copyTo(buffer, offset, position, bytesWritten) + // offset += bytesWritten + // length -= bytesWritten + // position = limit + // totalBytesWritten += bytesWritten + // refreshBuffer() + // // Now deal with the rest. + // // Since we have an output stream, this is our buffer + // // and buffer offset == 0 + // if (length <= limit) { + // value.copyTo(buffer, offset, 0, length) + // position = length + // } else { + // value.slice(offset, offset + length).writeTo(output) + // } + // totalBytesWritten += length + // } + // } + + def writeRawBytes(value: Array[Byte]): Unit = { + writeRawBytes(value, 0, value.length) + } + + def writeRawBytes(value: ByteBuffer): Unit = { + if (value.hasArray()) { + writeRawBytes(value.array(), value.arrayOffset(), value.capacity()) + } else { + val duplicated = value.duplicate() + duplicated.clear() + writeRawBytesInternal(duplicated) + } + } + + private def writeRawBytesInternal(value: ByteBuffer): Unit = { + var length = value.remaining() + if (limit - position >= length) { + value.get(buffer, position, length) + position += length + totalBytesWritten += length + } else { + val bytesWritten = limit - position + value.get(buffer, position, bytesWritten) + length -= bytesWritten + position = limit + totalBytesWritten += bytesWritten + refreshBuffer() + while (length > limit) { + value.get(buffer, 0, limit) + output.write(buffer, 0, limit) + length -= limit + totalBytesWritten += limit + } + value.get(buffer, 0, length) + position = length + totalBytesWritten += length + } + } + + def writeRawBytes(value: Array[Byte], offset0: Int, length0: Int): Unit = { + var offset = offset0 + var length = length0 + if (limit - position >= length) { + System.arraycopy(value, offset, buffer, position, length) + position += length + totalBytesWritten += length + } else { + val bytesWritten = limit - position + System.arraycopy(value, offset, buffer, position, bytesWritten) + offset += bytesWritten + length -= bytesWritten + position = limit + totalBytesWritten += bytesWritten + refreshBuffer() + if (length <= limit) { + System.arraycopy(value, offset, buffer, 0, length) + position = length + } else { + output.write(value, offset, length) + } + totalBytesWritten += length + } + } + +} + +object Internal { + val UTF_8 = java.nio.charset.Charset.forName("UTF-8") + val EMPTY_BYTE_ARRAY: Array[Byte] = Array() +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/WireFormat.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/WireFormat.scala new file mode 100644 index 000000000000..1a193fe99ca6 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/WireFormat.scala @@ -0,0 +1,20 @@ +package dotty.tools.dotc.semanticdb.internal + +object WireFormat { + val WIRETYPE_VARINT = 0 + val WIRETYPE_FIXED64 = 1 + val WIRETYPE_LENGTH_DELIMITED = 2 + val WIRETYPE_START_GROUP = 3 + val WIRETYPE_END_GROUP = 4 + val WIRETYPE_FIXED32 = 5 + + val TAG_TYPE_BITS = 3 + val TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1 + + def getTagWireType(tag: Int) = tag & TAG_TYPE_MASK + + def makeTag(fieldNumber: Int, wireType: Int) = + (fieldNumber << TAG_TYPE_BITS) | wireType + + def getTagFieldNumber(tag: Int): Int = tag >>> TAG_TYPE_BITS +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala new file mode 100644 index 000000000000..008b10acdabc --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -0,0 +1,162 @@ +package dotty.tools.dotc.semanticdb + +import java.net.URLClassLoader +import java.util.regex.Pattern +import java.io.File +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 + +import org.junit.Assert._ +import org.junit.Test +import org.junit.experimental.categories.Category + +import dotty.BootstrappedOnlyTests +import dotty.tools.dotc.Main +import dotty.tools.dotc.semanticdb.Scala3.given +import dotty.tools.dotc.util.SourceFile + +@main def updateExpect = + SemanticdbTests().runExpectTest(updateExpectFiles = true) + +@Category(Array(classOf[BootstrappedOnlyTests])) +class SemanticdbTests with + val javaFile = FileSystems.getDefault.getPathMatcher("glob:**.java") + val scalaFile = FileSystems.getDefault.getPathMatcher("glob:**.scala") + val expectFile = FileSystems.getDefault.getPathMatcher("glob:**.expect.scala") + val rootSrc = Paths.get(System.getProperty("dotty.tools.dotc.semanticdb.test")) + val expectSrc = rootSrc.resolve("expect") + val javaRoot = rootSrc.resolve("javacp") + val metacExpectFile = rootSrc.resolve("metac.expect") + + @Category(Array(classOf[dotty.SlowTests])) + @Test def expectTests: Unit = runExpectTest(updateExpectFiles = false) + + def runExpectTest(updateExpectFiles: Boolean): Unit = + val target = generateSemanticdb() + val errors = mutable.ArrayBuffer.empty[Path] + val metacSb: StringBuilder = StringBuilder(5000) + def collectErrorOrUpdate(expectPath: Path, obtained: String) = + if updateExpectFiles + Files.write(expectPath, obtained.getBytes(StandardCharsets.UTF_8)) + println("updated: " + expectPath) + else + val expected = new String(Files.readAllBytes(expectPath), StandardCharsets.UTF_8) + val expectName = expectPath.getFileName + val relExpect = rootSrc.relativize(expectPath) + if expected.trim != obtained.trim then + Files.write(expectPath.resolveSibling("" + expectName + ".out"), obtained.getBytes(StandardCharsets.UTF_8)) + errors += expectPath + for source <- inputFiles().sorted do + val filename = source.getFileName.toString + val relpath = expectSrc.relativize(source) + val semanticdbPath = target + .resolve("META-INF") + .resolve("semanticdb") + .resolve(relpath) + .resolveSibling(filename + ".semanticdb") + val expectPath = source.resolveSibling(filename.replaceAllLiterally(".scala", ".expect.scala")) + val doc = Tools.loadTextDocument(source, relpath, semanticdbPath) + Tools.metac(doc, rootSrc.relativize(source))(given metacSb) + val obtained = trimTrailingWhitespace(SemanticdbTests.printTextDocument(doc)) + collectErrorOrUpdate(expectPath, obtained) + collectErrorOrUpdate(metacExpectFile, metacSb.toString) + for expect <- errors do + def red(msg: String) = Console.RED + msg + Console.RESET + def blue(msg: String) = Console.BLUE + msg + Console.RESET + println(s"""[${red("error")}] check file ${blue(expect.toString)} does not match generated. + |If you meant to make a change, replace the expect file by: + | mv ${expect.resolveSibling("" + expect.getFileName + ".out")} $expect + |Or else update all expect files with + | sbt 'dotty-compiler-bootstrapped/test:runMain dotty.tools.dotc.semanticdb.updateExpect'""".stripMargin) + Files.walk(target).sorted(Comparator.reverseOrder).forEach(Files.delete) + if errors.nonEmpty + fail(s"${errors.size} errors in expect test.") + + def trimTrailingWhitespace(s: String): String = + Pattern.compile(" +$", Pattern.MULTILINE).matcher(s).replaceAll("") + + def inputFiles(): List[Path] = + val ls = Files.walk(expectSrc) + val files = + try ls.filter(p => scalaFile.matches(p) && !expectFile.matches(p)).collect(Collectors.toList).asScala + finally ls.close() + require(files.nonEmpty, s"No input files! $expectSrc") + files.toList + + def javaFiles(): List[Path] = + val ls = Files.walk(javaRoot) + val files = + try ls.filter(p => javaFile.matches(p)).collect(Collectors.toList).asScala + finally ls.close() + require(files.nonEmpty, s"No input files! $expectSrc") + files.toList + + def generateSemanticdb(): Path = + val target = Files.createTempDirectory("semanticdb") + val javaArgs = Array("-d", target.toString) ++ javaFiles().map(_.toString) + val javac = ToolProvider.getSystemJavaCompiler + val exitJava = javac.run(null, null, null, javaArgs:_*) + assert(exitJava == 0, "java compiler has errors") + val args = Array( + "-Ysemanticdb", + "-d", target.toString, + "-feature", + "-deprecation", + // "-Ydebug-flags", + // "-Xprint:extractSemanticDB", + "-sourceroot", expectSrc.toString, + "-classpath", target.toString, + "-usejavacp" + ) ++ inputFiles().map(_.toString) + val exit = Main.process(args) + assertFalse(s"dotc errors: ${exit.errorCount}", exit.hasErrors) + target + +end SemanticdbTests + +object SemanticdbTests with + /** Prettyprint a text document with symbol occurrences next to each resolved identifier. + * + * Useful for testing purposes to ensure that SymbolOccurrence values make sense and are correct. + * Example output (NOTE, slightly modified to avoid "unclosed comment" errors): + * {{{ + * class Example *example/Example#* { + * val a *example/Example#a.* : String *scala/Predef.String#* = "1" + * } + * }}} + **/ + def printTextDocument(doc: TextDocument): String = + val symtab = doc.symbols.iterator.map(info => info.symbol -> info).toMap + val sb = StringBuilder(1000) + val sourceFile = SourceFile.virtual(doc.uri, doc.text) + var offset = 0 + for occ <- doc.occurrences.sorted do + val range = occ.range.get + val end = math.max( + offset, + sourceFile.lineToOffset(range.endLine) + range.endCharacter + ) + val isPrimaryConstructor = + symtab.get(occ.symbol).exists(_.isPrimary) + if !occ.symbol.isPackage && !isPrimaryConstructor + assert(end <= doc.text.length, + s"doc is only ${doc.text.length} - offset=$offset, end=$end , symbol=${occ.symbol} in source ${sourceFile.name}") + sb.append(doc.text.substring(offset, end)) + sb.append("/*") + .append(if (occ.role.isDefinition) "<-" else "->") + .append(occ.symbol.replace("/", "::")) + .append("*/") + offset = end + assert(offset <= doc.text.length, s"absurd offset = $offset when doc is length ${doc.text.length}") + sb.append(doc.text.substring(offset)) + sb.toString + end printTextDocument + +end SemanticdbTests diff --git a/docs/docs/internals/overall-structure.md b/docs/docs/internals/overall-structure.md index 3356854eb102..0783b1b96a66 100644 --- a/docs/docs/internals/overall-structure.md +++ b/docs/docs/internals/overall-structure.md @@ -36,6 +36,7 @@ list of sub-packages and their focus. ├── repl // The interactive REPL ├── reporting // Reporting of error messages, warnings and other info. ├── rewrites // Helpers for rewriting Scala 2's constructs into dotty's. +├── semanticdb // Helpers for exporting semanticdb from trees. ├── transform // Miniphases and helpers for tree transformations. ├── typer // Type-checking and other frontend phases └── util // General purpose utility classes and modules. @@ -100,6 +101,7 @@ phases. The current list of phases is specified in class [Compiler] as follows: List(new YCheckPositions) :: // YCheck positions List(new Staging) :: // Check PCP, heal quoted types and expand macros List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks + List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files List(new PostTyper) :: // Additional checks and cleanups after type checking List(new sbt.ExtractAPI) :: // Sends a representation of the API of classes to sbt via callbacks List(new SetRootTree) :: // Set the `rootTreeOrProvider` on class symbols diff --git a/project/Build.scala b/project/Build.scala index 383d8bb330dc..007d676506e6 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -550,6 +550,10 @@ object Build { ) }, + javaOptions += ( + s"-Ddotty.tools.dotc.semanticdb.test=${(ThisBuild / baseDirectory).value/"tests"/"semanticdb"}" + ), + testCompilation := Def.inputTaskDyn { val args = spaceDelimited("").parsed if (args.contains("--help")) { diff --git a/tests/semanticdb/expect/Access.expect.scala b/tests/semanticdb/expect/Access.expect.scala new file mode 100644 index 000000000000..3186ce2a68c3 --- /dev/null +++ b/tests/semanticdb/expect/Access.expect.scala @@ -0,0 +1,11 @@ +package example + +class Access/*<-example::Access#*/ { + private def m1/*<-example::Access#m1().*/ = ???/*->scala::Predef.`???`().*/ + private[this] def m2/*<-example::Access#m2().*/ = ???/*->scala::Predef.`???`().*/ + private[Access/*->example::Access#*/] def m3/*<-example::Access#m3().*/ = ???/*->scala::Predef.`???`().*/ + protected def m4/*<-example::Access#m4().*/ = ???/*->scala::Predef.`???`().*/ + protected[this] def m5/*<-example::Access#m5().*/ = ???/*->scala::Predef.`???`().*/ + protected[example] def m6/*<-example::Access#m6().*/ = ???/*->scala::Predef.`???`().*/ + def m7/*<-example::Access#m7().*/ = ???/*->scala::Predef.`???`().*/ +} diff --git a/tests/semanticdb/expect/Access.scala b/tests/semanticdb/expect/Access.scala new file mode 100644 index 000000000000..aee3754da66b --- /dev/null +++ b/tests/semanticdb/expect/Access.scala @@ -0,0 +1,11 @@ +package example + +class Access { + private def m1 = ??? + private[this] def m2 = ??? + private[Access] def m3 = ??? + protected def m4 = ??? + protected[this] def m5 = ??? + protected[example] def m6 = ??? + def m7 = ??? +} diff --git a/tests/semanticdb/expect/Advanced.expect.scala b/tests/semanticdb/expect/Advanced.expect.scala new file mode 100644 index 000000000000..e4ae3370cba8 --- /dev/null +++ b/tests/semanticdb/expect/Advanced.expect.scala @@ -0,0 +1,42 @@ +package advanced + +import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ +import scala.language/*->scalaShadowing::language.*/.reflectiveCalls/*->scalaShadowing::language.reflectiveCalls.*/ + +import scala.reflect.Selectable/*->scala::reflect::Selectable.*/.reflectiveSelectable/*->scala::reflect::Selectable.reflectiveSelectable().*/ + +class C/*<-advanced::C#*/[T/*<-advanced::C#[T]*/] { + def t/*<-advanced::C#t().*/: T/*->advanced::C#[T]*/ = ???/*->scala::Predef.`???`().*/ +} + +class Structural/*<-advanced::Structural#*/ { + def s1/*<-advanced::Structural#s1().*/: { val x/*<-local0*/: Int/*->scala::Int#*/ } = ???/*->scala::Predef.`???`().*/ + def s2/*<-advanced::Structural#s2().*/: { val x/*<-local1*/: Int/*->scala::Int#*/ } = new { val x/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + def s3/*<-advanced::Structural#s3().*/: { def m/*<-local4*/(x/*<-local5*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ } = new { def m/*<-local7*/(x/*<-local8*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } +} + +class Wildcards/*<-advanced::Wildcards#*/ { + def e1/*<-advanced::Wildcards#e1().*/: List/*->scala::package.List#*/[_] = ???/*->scala::Predef.`???`().*/ +} + +object Test/*<-advanced::Test.*/ { + val s/*<-advanced::Test.s.*/ = new Structural/*->advanced::Structural#*/ + val s1/*<-advanced::Test.s1.*/ = s/*->advanced::Test.s.*/.s1/*->advanced::Structural#s1().*/ + val s1x/*<-advanced::Test.s1x.*/ = /*->scala::reflect::Selectable.reflectiveSelectable().*/s/*->advanced::Test.s.*/.s1/*->advanced::Structural#s1().*//*->scala::Selectable#selectDynamic().*/.x + val s2/*<-advanced::Test.s2.*/ = s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*/ + val s2x/*<-advanced::Test.s2x.*/ = /*->scala::reflect::Selectable.reflectiveSelectable().*/s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*//*->scala::Selectable#selectDynamic().*/.x + val s3/*<-advanced::Test.s3.*/ = s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*/ + val s3x/*<-advanced::Test.s3x.*/ = /*->scala::reflect::Selectable.reflectiveSelectable().*/s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*//*->scala::Selectable#applyDynamic().*/.m/*->scala::reflect::ClassTag.apply().*//*->java::lang::Integer#TYPE.*/(???/*->scala::Predef.`???`().*/) + + val e/*<-advanced::Test.e.*/ = new Wildcards/*->advanced::Wildcards#*/ + val e1/*<-advanced::Test.e1.*/ = e/*->advanced::Test.e.*/.e1/*->advanced::Wildcards#e1().*/ + val e1x/*<-advanced::Test.e1x.*/ = e/*->advanced::Test.e.*/.e1/*->advanced::Wildcards#e1().*/.head/*->scala::collection::IterableOps#head().*/ + + { + (???/*->scala::Predef.`???`().*/ : Any/*->scala::Any#*/) match { + case e3/*<-local9*/: List/*->scala::package.List#*/[_] => + val e3x/*<-local10*/ = e3/*->local9*/.head/*->scala::collection::IterableOps#head().*/ + () + } + } +} diff --git a/tests/semanticdb/expect/Advanced.scala b/tests/semanticdb/expect/Advanced.scala new file mode 100644 index 000000000000..3e14a46cb194 --- /dev/null +++ b/tests/semanticdb/expect/Advanced.scala @@ -0,0 +1,42 @@ +package advanced + +import scala.language.higherKinds +import scala.language.reflectiveCalls + +import scala.reflect.Selectable.reflectiveSelectable + +class C[T] { + def t: T = ??? +} + +class Structural { + def s1: { val x: Int } = ??? + def s2: { val x: Int } = new { val x: Int = ??? } + def s3: { def m(x: Int): Int } = new { def m(x: Int): Int = ??? } +} + +class Wildcards { + def e1: List[_] = ??? +} + +object Test { + val s = new Structural + val s1 = s.s1 + val s1x = s.s1.x + val s2 = s.s2 + val s2x = s.s2.x + val s3 = s.s3 + val s3x = s.s3.m(???) + + val e = new Wildcards + val e1 = e.e1 + val e1x = e.e1.head + + { + (??? : Any) match { + case e3: List[_] => + val e3x = e3.head + () + } + } +} diff --git a/tests/semanticdb/expect/Annotations.expect.scala b/tests/semanticdb/expect/Annotations.expect.scala new file mode 100644 index 000000000000..08d5fc54806d --- /dev/null +++ b/tests/semanticdb/expect/Annotations.expect.scala @@ -0,0 +1,38 @@ +package annot + +import com.javacp.annot._ +import scala.annotation.meta._ +import scala.language/*->scalaShadowing::language.*/.experimental/*->scalaShadowing::language.experimental.*/.macros/*->scalaShadowing::language.experimental.macros.*/ + +@ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/ +class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => + @FieldAnnotation/*->com::javacp::annot::FieldAnnotation#*/ + val field/*<-annot::Annotations#field.*/ = 42 + + @MethodAnnotation/*->com::javacp::annot::MethodAnnotation#*/ + def method/*<-annot::Annotations#method().*/ = { + @LocalAnnotation/*->com::javacp::annot::LocalAnnotation#*/ + val local/*<-local1*/ = 42 + local/*->local1*/ + } + @TypeAnnotation/*->com::javacp::annot::TypeAnnotation#*/ + type S/*<-annot::Annotations#S#*/ +} + +class B/*<-annot::B#*/ @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/()(x/*<-annot::B#x.*/: Int/*->scala::Int#*/) { + @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/ + def this()/*<-annot::B#``(+1).*/ = this(42) +} + +@ObjectAnnotation/*->com::javacp::annot::ObjectAnnotation#*/ +object M/*<-annot::M.*/ { + @MacroAnnotation/*->com::javacp::annot::MacroAnnotation#*/ + def m/*<-annot::M.m().*/[TT/*<-annot::M.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ??? +} + +@TraitAnnotation/*->com::javacp::annot::TraitAnnotation#*/ +trait T/*<-annot::T#*/ + +object Alias/*<-annot::Alias.*/ { + type A/*<-annot::Alias.A#*/ = ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/ @param/*->scala::annotation::meta::param#*/ +} diff --git a/tests/semanticdb/expect/Annotations.scala b/tests/semanticdb/expect/Annotations.scala new file mode 100644 index 000000000000..c897aa819a58 --- /dev/null +++ b/tests/semanticdb/expect/Annotations.scala @@ -0,0 +1,38 @@ +package annot + +import com.javacp.annot._ +import scala.annotation.meta._ +import scala.language.experimental.macros + +@ClassAnnotation +class Annotations[@TypeParameterAnnotation T](@ParameterAnnotation x: T) { self: AnyRef => + @FieldAnnotation + val field = 42 + + @MethodAnnotation + def method = { + @LocalAnnotation + val local = 42 + local + } + @TypeAnnotation + type S +} + +class B @ConstructorAnnotation()(x: Int) { + @ConstructorAnnotation + def this() = this(42) +} + +@ObjectAnnotation +object M { + @MacroAnnotation + def m[TT]: Int = macro ??? +} + +@TraitAnnotation +trait T + +object Alias { + type A = ClassAnnotation @param +} diff --git a/tests/semanticdb/expect/Anonymous.expect.scala b/tests/semanticdb/expect/Anonymous.expect.scala new file mode 100644 index 000000000000..ee2d433facb5 --- /dev/null +++ b/tests/semanticdb/expect/Anonymous.expect.scala @@ -0,0 +1,20 @@ +package example +import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ + +class Anonymous/*<-example::Anonymous#*/ { + this: Anonymous/*->example::Anonymous#*/ => + + def locally/*<-example::Anonymous#locally().*/[A/*<-example::Anonymous#locally().[A]*/](x/*<-example::Anonymous#locally().(x)*/: A/*->example::Anonymous#locally().[A]*/): A/*->example::Anonymous#locally().[A]*/ = x/*->example::Anonymous#locally().(x)*/ + + def m1/*<-example::Anonymous#m1().*/[T/*<-example::Anonymous#m1().[T]*/[_]] = ???/*->scala::Predef.`???`().*/ + def m2/*<-example::Anonymous#m2().*/: Map/*->scala::Predef.Map#*/[_, List/*->scala::package.List#*/[_]] = ???/*->scala::Predef.`???`().*/ + locally/*->example::Anonymous#locally().*/ { + ???/*->scala::Predef.`???`().*/ match { case _: List/*->scala::package.List#*/[_] => } + } + locally/*->example::Anonymous#locally().*/ { + val x/*<-local0*/: Int/*->scala::Int#*/ => Int/*->scala::Int#*/ = _ => ???/*->scala::Predef.`???`().*/ + } + + trait Foo/*<-example::Anonymous#Foo#*/ + val foo/*<-example::Anonymous#foo.*/ = new Foo/*->example::Anonymous#Foo#*/ {} +} diff --git a/tests/semanticdb/expect/Anonymous.scala b/tests/semanticdb/expect/Anonymous.scala new file mode 100644 index 000000000000..8daeff92bf7f --- /dev/null +++ b/tests/semanticdb/expect/Anonymous.scala @@ -0,0 +1,20 @@ +package example +import scala.language.higherKinds + +class Anonymous { + this: Anonymous => + + def locally[A](x: A): A = x + + def m1[T[_]] = ??? + def m2: Map[_, List[_]] = ??? + locally { + ??? match { case _: List[_] => } + } + locally { + val x: Int => Int = _ => ??? + } + + trait Foo + val foo = new Foo {} +} diff --git a/tests/semanticdb/expect/Classes.expect.scala b/tests/semanticdb/expect/Classes.expect.scala new file mode 100644 index 000000000000..c7418107c372 --- /dev/null +++ b/tests/semanticdb/expect/Classes.expect.scala @@ -0,0 +1,33 @@ +package classes + +class C1/*<-classes::C1#*/(val x1/*<-classes::C1#x1.*/: Int/*->scala::Int#*/) extends AnyVal/*->scala::AnyVal#*//*->scala::AnyVal#``().*/ + +class C2/*<-classes::C2#*/(val x2/*<-classes::C2#x2.*/: Int/*->scala::Int#*/) extends AnyVal/*->scala::AnyVal#*//*->scala::AnyVal#``().*/ +object C2/*<-classes::C2.*/ + +case class C3/*<-classes::C3#*/(x/*<-classes::C3#x.*/: Int/*->scala::Int#*/) + +case class C4/*<-classes::C4#*/(x/*<-classes::C4#x.*/: Int/*->scala::Int#*/) +object C4/*<-classes::C4.*/ + +object M/*<-classes::M.*/ { + implicit class C5/*<-classes::M.C5#*/(x/*<-classes::M.C5#x.*/: Int/*->scala::Int#*/) +} + +case class C6/*<-classes::C6#*/(private val x/*<-classes::C6#x.*/: Int/*->scala::Int#*/) + +class C7/*<-classes::C7#*/(x/*<-classes::C7#x.*/: Int/*->scala::Int#*/) + +class C8/*<-classes::C8#*/(private[this] val x/*<-classes::C8#x.*/: Int/*->scala::Int#*/) + +class C9/*<-classes::C9#*/(private[this] var x/*<-classes::C9#x().*/: Int/*->scala::Int#*/) + +object N/*<-classes::N.*/ { + val anonClass/*<-classes::N.anonClass.*/ = new C7/*->classes::C7#*/(42) { + val local/*<-local1*/ = ???/*->scala::Predef.`???`().*/ + } + val anonFun/*<-classes::N.anonFun.*/ = List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).map/*->scala::collection::immutable::List#map().*/ { i/*<-local2*/ => + val local/*<-local3*/ = 2 + local/*->local3*/ +/*->scala::Int#`+`(+4).*/ 2 + } +} diff --git a/tests/semanticdb/expect/Classes.scala b/tests/semanticdb/expect/Classes.scala new file mode 100644 index 000000000000..a1cfbbd9aee1 --- /dev/null +++ b/tests/semanticdb/expect/Classes.scala @@ -0,0 +1,33 @@ +package classes + +class C1(val x1: Int) extends AnyVal + +class C2(val x2: Int) extends AnyVal +object C2 + +case class C3(x: Int) + +case class C4(x: Int) +object C4 + +object M { + implicit class C5(x: Int) +} + +case class C6(private val x: Int) + +class C7(x: Int) + +class C8(private[this] val x: Int) + +class C9(private[this] var x: Int) + +object N { + val anonClass = new C7(42) { + val local = ??? + } + val anonFun = List(1).map { i => + val local = 2 + local + 2 + } +} diff --git a/tests/semanticdb/expect/Definitions.expect.scala b/tests/semanticdb/expect/Definitions.expect.scala new file mode 100644 index 000000000000..92a956c37c17 --- /dev/null +++ b/tests/semanticdb/expect/Definitions.expect.scala @@ -0,0 +1,8 @@ +package a +object Definitions/*<-a::Definitions.*/ { + val a/*<-a::Definitions.a.*/ = 1 + var b/*<-a::Definitions.b().*/ = 2 + def c/*<-a::Definitions.c().*/ = 3 + class D/*<-a::Definitions.D#*/ + trait E/*<-a::Definitions.E#*/ +} diff --git a/tests/semanticdb/expect/Definitions.scala b/tests/semanticdb/expect/Definitions.scala new file mode 100644 index 000000000000..1d4a94811957 --- /dev/null +++ b/tests/semanticdb/expect/Definitions.scala @@ -0,0 +1,8 @@ +package a +object Definitions { + val a = 1 + var b = 2 + def c = 3 + class D + trait E +} diff --git a/tests/semanticdb/expect/Empty.expect.scala b/tests/semanticdb/expect/Empty.expect.scala new file mode 100644 index 000000000000..808db6ad4ea5 --- /dev/null +++ b/tests/semanticdb/expect/Empty.expect.scala @@ -0,0 +1,7 @@ +class A/*<-_empty_::A#*/ { + def b/*<-_empty_::A#b().*/: B/*->_empty_::B#*/ = ???/*->scala::Predef.`???`().*/ +} + +class B/*<-_empty_::B#*/ { + def a/*<-_empty_::B#a().*/: A/*->_empty_::A#*/ = ???/*->scala::Predef.`???`().*/ +} diff --git a/tests/semanticdb/expect/Empty.scala b/tests/semanticdb/expect/Empty.scala new file mode 100644 index 000000000000..a1288dfd77b6 --- /dev/null +++ b/tests/semanticdb/expect/Empty.scala @@ -0,0 +1,7 @@ +class A { + def b: B = ??? +} + +class B { + def a: A = ??? +} diff --git a/tests/semanticdb/expect/EmptyObject.expect.scala b/tests/semanticdb/expect/EmptyObject.expect.scala new file mode 100644 index 000000000000..0e9fe500adee --- /dev/null +++ b/tests/semanticdb/expect/EmptyObject.expect.scala @@ -0,0 +1,3 @@ +package example + +object EmptyObject/*<-example::EmptyObject.*/ {} diff --git a/tests/semanticdb/expect/EmptyObject.scala b/tests/semanticdb/expect/EmptyObject.scala new file mode 100644 index 000000000000..58773e9bd7eb --- /dev/null +++ b/tests/semanticdb/expect/EmptyObject.scala @@ -0,0 +1,3 @@ +package example + +object EmptyObject {} diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala new file mode 100644 index 000000000000..47e3d493ba28 --- /dev/null +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -0,0 +1,69 @@ +object Enums/*<-_empty_::Enums.*/ with + import <:_empty_::Enums.`<:<`.*/._ + + enum Colour/*<-_empty_::Enums.Colour#*/ with + import Colour/*->_empty_::Enums.Colour.*/.Red/*->_empty_::Enums.Colour.Red.*/ + case Red/*<-_empty_::Enums.Colour.Red.*/, Green/*<-_empty_::Enums.Colour.Green.*/, Blue/*<-_empty_::Enums.Colour.Blue.*/ + + enum Directions/*<-_empty_::Enums.Directions#*/ with + case North/*<-_empty_::Enums.Directions.North.*/, East/*<-_empty_::Enums.Directions.East.*/, South/*<-_empty_::Enums.Directions.South.*/, West/*<-_empty_::Enums.Directions.West.*/ + + enum Suits/*<-_empty_::Enums.Suits#*/ derives /*->scala::Eql.derived.*/Eql with + case Hearts/*<-_empty_::Enums.Suits.Hearts.*/, Spades/*<-_empty_::Enums.Suits.Spades.*/, Clubs/*<-_empty_::Enums.Suits.Clubs.*/, Diamonds/*<-_empty_::Enums.Suits.Diamonds.*/ + + object Suits/*<-_empty_::Enums.Suits.*/ with + def (suit/*<-_empty_::Enums.Suits.isRed().*//*<-_empty_::Enums.Suits.isRed().(suit)*/: Suits/*->_empty_::Enums.Suits#*/) isRed: Boolean/*->scala::Boolean#*/ = + suit/*->_empty_::Enums.Suits.isRed().(suit)*/ ==/*->scala::Any#`==`().*/ Hearts/*->_empty_::Enums.Suits.Hearts.*/ ||/*->scala::Boolean#`||`().*/ suit/*->_empty_::Enums.Suits.isRed().(suit)*/ ==/*->scala::Any#`==`().*/ Diamonds/*->_empty_::Enums.Suits.Diamonds.*/ + + def (suit: /*<-_empty_::Enums.Suits.isBlack().*//*<-_empty_::Enums.Suits.isBlack().(suit)*/Suits/*->_empty_::Enums.Suits#*/) isBlack: Boolean/*->scala::Boolean#*/ = suit/*->_empty_::Enums.Suits.isBlack().(suit)*/ match + case Spades/*->_empty_::Enums.Suits.Spades.*/ | Diamonds/*->_empty_::Enums.Suits.Diamonds.*/ => true + case _ => false + + enum WeekDays/*<-_empty_::Enums.WeekDays#*/ with + case Monday/*<-_empty_::Enums.WeekDays.Monday.*/ + case Tuesday/*<-_empty_::Enums.WeekDays.Tuesday.*/ + case Wednesday/*<-_empty_::Enums.WeekDays.Wednesday.*/ + case Thursday/*<-_empty_::Enums.WeekDays.Thursday.*/ + case Friday/*<-_empty_::Enums.WeekDays.Friday.*/ + case Saturday/*<-_empty_::Enums.WeekDays.Saturday.*/ + case Sunday/*<-_empty_::Enums.WeekDays.Sunday.*/ + + enum Coin/*<-_empty_::Enums.Coin#*/(value/*<-_empty_::Enums.Coin#value.*/: Int/*->scala::Int#*/) with + case Penny/*<-_empty_::Enums.Coin.Penny.*/ extends Coin/*->_empty_::Enums.Coin#*/(1) + case Nickel/*<-_empty_::Enums.Coin.Nickel.*/ extends Coin/*->_empty_::Enums.Coin#*/(5) + case Dime/*<-_empty_::Enums.Coin.Dime.*/ extends Coin/*->_empty_::Enums.Coin#*/(10) + case Quarter/*<-_empty_::Enums.Coin.Quarter.*/ extends Coin/*->_empty_::Enums.Coin#*/(25) + case Dollar/*<-_empty_::Enums.Coin.Dollar.*/ extends Coin/*->_empty_::Enums.Coin#*/(100) + + enum Maybe/*<-_empty_::Enums.Maybe#*/[+A/*<-_empty_::Enums.Maybe#[A]*/] with + case Just/*<-_empty_::Enums.Maybe.Just#*/(value/*<-_empty_::Enums.Maybe.Just#value.*/: A/*->_empty_::Enums.Maybe.Just#[A]*/) + case None/*<-_empty_::Enums.Maybe.None.*/ + + enum Tag/*<-_empty_::Enums.Tag#*/[A/*<-_empty_::Enums.Tag#[A]*/] with + case IntTag/*<-_empty_::Enums.Tag.IntTag.*/ extends Tag/*->_empty_::Enums.Tag#*/[Int/*->scala::Int#*/] + case BooleanTag/*<-_empty_::Enums.Tag.BooleanTag.*/ extends Tag/*->_empty_::Enums.Tag#*/[Boolean/*->scala::Boolean#*/] + + enum <:_empty_::Enums.`<:<`.Refl#[C]*/ <:_empty_::Enums.`<:<`#*/ C/*->_empty_::Enums.`<:<`.Refl#[C]*/) + + object <:_empty_::Enums.`<:<`.given_T().[T]*/ <:_empty_::Enums.`<:<`#*/ T/*->_empty_::Enums.`<:<`.given_T().[T]*/) = Refl/*->_empty_::Enums.`<:<`.Refl.*//*->_empty_::Enums.`<:<`.Refl.apply().*/() + + def [A, B]/*<-_empty_::Enums.unwrap().*//*<-_empty_::Enums.unwrap().[A]*//*<-_empty_::Enums.unwrap().[B]*/(opt/*<-_empty_::Enums.unwrap().(opt)*/: Option/*->scala::Option#*/[A/*->_empty_::Enums.unwrap().[A]*/]) unwrap(given ev/*<-_empty_::Enums.unwrap().(ev)*/: A/*->_empty_::Enums.unwrap().[A]*/ <:_empty_::Enums.`<:<`#*/ Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]): Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/] = ev/*->_empty_::Enums.unwrap().(ev)*/ match + case Refl/*->_empty_::Enums.`<:<`.Refl.*//*->_empty_::Enums.`<:<`.Refl.unapply().*/() => opt/*->_empty_::Enums.unwrap().(opt)*/.flatMap/*->scala::Option#flatMap().*/(identity/*->scala::Predef.identity().*//*->local0*/[Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]]) + + val some1/*<-_empty_::Enums.some1.*/ = /*->_empty_::Enums.unwrap().*/Some/*->scala::Some.*//*->scala::Some.apply().*/(Some/*->scala::Some.*//*->scala::Some.apply().*/(1))/*->_empty_::Enums.`<:<`.given_T().*/.unwrap + + enum Planet/*<-_empty_::Enums.Planet#*/(mass/*<-_empty_::Enums.Planet#mass.*/: Double/*->scala::Double#*/, radius/*<-_empty_::Enums.Planet#radius.*/: Double/*->scala::Double#*/) extends java.lang.Enum/*->java::lang::Enum#*/[Planet/*->_empty_::Enums.Planet#*/]/*->java::lang::Enum#``().*/ with + private final val G/*<-_empty_::Enums.Planet#G.*/ = 6.67300E-11 + def surfaceGravity/*<-_empty_::Enums.Planet#surfaceGravity().*/ = G/*->_empty_::Enums.Planet#G.*/ */*->scala::Double#`*`(+6).*/ mass/*->_empty_::Enums.Planet#mass.*/ //*->scala::Double#`::`(+6).*/ (radius/*->_empty_::Enums.Planet#radius.*/ */*->scala::Double#`*`(+6).*/ radius/*->_empty_::Enums.Planet#radius.*/) + def surfaceWeight/*<-_empty_::Enums.Planet#surfaceWeight().*/(otherMass/*<-_empty_::Enums.Planet#surfaceWeight().(otherMass)*/: Double/*->scala::Double#*/) = otherMass/*->_empty_::Enums.Planet#surfaceWeight().(otherMass)*/ */*->scala::Double#`*`(+6).*/ surfaceGravity/*->_empty_::Enums.Planet#surfaceGravity().*/ + + case Mercury/*<-_empty_::Enums.Planet.Mercury.*/ extends Planet/*->_empty_::Enums.Planet#*/(3.303e+23, 2.4397e6) + case Venus/*<-_empty_::Enums.Planet.Venus.*/ extends Planet/*->_empty_::Enums.Planet#*/(4.869e+24, 6.0518e6) + case Earth/*<-_empty_::Enums.Planet.Earth.*/ extends Planet/*->_empty_::Enums.Planet#*/(5.976e+24, 6.37814e6) + case Mars/*<-_empty_::Enums.Planet.Mars.*/ extends Planet/*->_empty_::Enums.Planet#*/(6.421e+23, 3.3972e6) + case Jupiter/*<-_empty_::Enums.Planet.Jupiter.*/ extends Planet/*->_empty_::Enums.Planet#*/(1.9e+27, 7.1492e7) + case Saturn/*<-_empty_::Enums.Planet.Saturn.*/ extends Planet/*->_empty_::Enums.Planet#*/(5.688e+26, 6.0268e7) + case Uranus/*<-_empty_::Enums.Planet.Uranus.*/ extends Planet/*->_empty_::Enums.Planet#*/(8.686e+25, 2.5559e7) + case Neptune/*<-_empty_::Enums.Planet.Neptune.*/ extends Planet/*->_empty_::Enums.Planet#*/(1.024e+26, 2.4746e7) diff --git a/tests/semanticdb/expect/Enums.scala b/tests/semanticdb/expect/Enums.scala new file mode 100644 index 000000000000..28f2a8a4372e --- /dev/null +++ b/tests/semanticdb/expect/Enums.scala @@ -0,0 +1,69 @@ +object Enums with + import <:<._ + + enum Colour with + import Colour.Red + case Red, Green, Blue + + enum Directions with + case North, East, South, West + + enum Suits derives Eql with + case Hearts, Spades, Clubs, Diamonds + + object Suits with + def (suit: Suits) isRed: Boolean = + suit == Hearts || suit == Diamonds + + def (suit: Suits) isBlack: Boolean = suit match + case Spades | Diamonds => true + case _ => false + + enum WeekDays with + case Monday + case Tuesday + case Wednesday + case Thursday + case Friday + case Saturday + case Sunday + + enum Coin(value: Int) with + case Penny extends Coin(1) + case Nickel extends Coin(5) + case Dime extends Coin(10) + case Quarter extends Coin(25) + case Dollar extends Coin(100) + + enum Maybe[+A] with + case Just(value: A) + case None + + enum Tag[A] with + case IntTag extends Tag[Int] + case BooleanTag extends Tag[Boolean] + + enum <:<[-A, B] with + case Refl[C]() extends (C <:< C) + + object <:< with + given [T]: (T <:< T) = Refl() + + def [A, B](opt: Option[A]) unwrap(given ev: A <:< Option[B]): Option[B] = ev match + case Refl() => opt.flatMap(identity[Option[B]]) + + val some1 = Some(Some(1)).unwrap + + enum Planet(mass: Double, radius: Double) extends java.lang.Enum[Planet] with + private final val G = 6.67300E-11 + def surfaceGravity = G * mass / (radius * radius) + def surfaceWeight(otherMass: Double) = otherMass * surfaceGravity + + case Mercury extends Planet(3.303e+23, 2.4397e6) + case Venus extends Planet(4.869e+24, 6.0518e6) + case Earth extends Planet(5.976e+24, 6.37814e6) + case Mars extends Planet(6.421e+23, 3.3972e6) + case Jupiter extends Planet(1.9e+27, 7.1492e7) + case Saturn extends Planet(5.688e+26, 6.0268e7) + case Uranus extends Planet(8.686e+25, 2.5559e7) + case Neptune extends Planet(1.024e+26, 2.4746e7) diff --git a/tests/semanticdb/expect/EtaExpansion.expect.scala b/tests/semanticdb/expect/EtaExpansion.expect.scala new file mode 100644 index 000000000000..55207ffa5ff2 --- /dev/null +++ b/tests/semanticdb/expect/EtaExpansion.expect.scala @@ -0,0 +1,6 @@ +package example + +class EtaExpansion/*<-example::EtaExpansion#*/ { + Some/*->scala::Some.*//*->scala::Some.apply().*/(1).map/*->scala::Option#map().*/(identity/*->scala::Predef.identity().*//*->local0*/) + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).foldLeft/*->scala::collection::LinearSeqOps#foldLeft().*/("")(_ +/*->java::lang::String#`+`().*/ _) +} diff --git a/tests/semanticdb/expect/EtaExpansion.scala b/tests/semanticdb/expect/EtaExpansion.scala new file mode 100644 index 000000000000..90400bfe1f80 --- /dev/null +++ b/tests/semanticdb/expect/EtaExpansion.scala @@ -0,0 +1,6 @@ +package example + +class EtaExpansion { + Some(1).map(identity) + List(1).foldLeft("")(_ + _) +} diff --git a/tests/semanticdb/expect/Example.expect.scala b/tests/semanticdb/expect/Example.expect.scala new file mode 100644 index 000000000000..aaf344f54a15 --- /dev/null +++ b/tests/semanticdb/expect/Example.expect.scala @@ -0,0 +1,11 @@ +package example + +import scala.concurrent.Future/*->scala::concurrent::Future.*//*->scala::concurrent::Future#*/ + +object Example/*<-example::Example.*/ { self/*<-local0*/ => + new scala.collection.mutable.Stack/*->scala::collection::mutable::Stack#*/[Int/*->scala::Int#*/]/*->scala::collection::mutable::Stack#``(+1).*/() + def main/*<-example::Example.main().*/(args/*<-example::Example.main().(args)*/: Array/*->scala::Array#*/[String/*->scala::Predef.String#*/]): Unit/*->scala::Unit#*/ = { + println/*->scala::Predef.println(+1).*/(1) + } + val x/*<-example::Example.x.*/ = scala.reflect.classTag/*->scala::reflect::package.classTag().*/[Int/*->scala::Int#*/]/*->scala::reflect::ClassTag.apply().*//*->java::lang::Integer#TYPE.*/ +} diff --git a/tests/semanticdb/expect/Example.scala b/tests/semanticdb/expect/Example.scala new file mode 100644 index 000000000000..794ae807ffeb --- /dev/null +++ b/tests/semanticdb/expect/Example.scala @@ -0,0 +1,11 @@ +package example + +import scala.concurrent.Future + +object Example { self => + new scala.collection.mutable.Stack[Int]() + def main(args: Array[String]): Unit = { + println(1) + } + val x = scala.reflect.classTag[Int] +} diff --git a/tests/semanticdb/expect/Flags.expect.scala b/tests/semanticdb/expect/Flags.expect.scala new file mode 100644 index 000000000000..be6660f99c4e --- /dev/null +++ b/tests/semanticdb/expect/Flags.expect.scala @@ -0,0 +1,27 @@ +package flags + +import scala.language/*->scalaShadowing::language.*/.experimental/*->scalaShadowing::language.experimental.*/.macros/*->scalaShadowing::language.experimental.macros.*/ + +package object p { + p/*<-flags::p::package.*/rivate lazy val x/*<-flags::p::package.x.*/ = 1 + protected implicit var y/*<-flags::p::package.y().*/: Int/*->scala::Int#*/ = 2 + def z/*<-flags::p::package.z().*/(pp/*<-flags::p::package.z().(pp)*/: Int/*->scala::Int#*/) = 3 + def m/*<-flags::p::package.m().*/[TT/*<-flags::p::package.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ??? + abstract class C/*<-flags::p::package.C#*/[+T/*<-flags::p::package.C#[T]*/, -U/*<-flags::p::package.C#[U]*/, V/*<-flags::p::package.C#[V]*/](x/*<-flags::p::package.C#x.*/: T/*->flags::p::package.C#[T]*/, y/*<-flags::p::package.C#y.*/: U/*->flags::p::package.C#[U]*/, z/*<-flags::p::package.C#z.*/: V/*->flags::p::package.C#[V]*/) { + def this()/*<-flags::p::package.C#``(+1).*/ = this(???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/) + def this(t/*<-flags::p::package.C#``(+2).*//*<-flags::p::package.C#``(+2).(t)*/: T/*->flags::p::package.C#[T]*/) = this(t/*->flags::p::package.C#``(+2).(t)*/, ???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/) + def w/*<-flags::p::package.C#w().*/: Int/*->scala::Int#*/ + } + type T1/*<-flags::p::package.T1#*/ = Int/*->scala::Int#*/ + type T2/*<-flags::p::package.T2#*/[T/*<-flags::p::package.T2#[T]*/] = S/*->flags::p::package.S#*/[T/*->flags::p::package.T2#[T]*/] + type U/*<-flags::p::package.U#*/ <: Int/*->scala::Int#*/ + type V/*<-flags::p::package.V#*/ >: Int/*->scala::Int#*/ + case object X/*<-flags::p::package.X.*/ + final class Y/*<-flags::p::package.Y#*/ + sealed trait Z/*<-flags::p::package.Z#*/ + class AA/*<-flags::p::package.AA#*/(x/*<-flags::p::package.AA#x.*/: Int/*->scala::Int#*/, val y/*<-flags::p::package.AA#y.*/: Int/*->scala::Int#*/, var z/*<-flags::p::package.AA#z().*/: Int/*->scala::Int#*/) + class S/*<-flags::p::package.S#*/[@specialized/*->scala::specialized#*/ T/*<-flags::p::package.S#[T]*/] + val List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs1/*<-flags::p::package.xs1.*/) = ???/*->scala::Predef.`???`().*/ + ???/*->scala::Predef.`???`().*/ match { case List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs2/*<-local0*/) => ???/*->scala::Predef.`???`().*/ } + ???/*->scala::Predef.`???`().*/ match { case _: List/*->scala::package.List#*/[t/*<-local1*/] => ???/*->scala::Predef.`???`().*/ } +} diff --git a/tests/semanticdb/expect/Flags.scala b/tests/semanticdb/expect/Flags.scala new file mode 100644 index 000000000000..d2e76e0fb956 --- /dev/null +++ b/tests/semanticdb/expect/Flags.scala @@ -0,0 +1,27 @@ +package flags + +import scala.language.experimental.macros + +package object p { + private lazy val x = 1 + protected implicit var y: Int = 2 + def z(pp: Int) = 3 + def m[TT]: Int = macro ??? + abstract class C[+T, -U, V](x: T, y: U, z: V) { + def this() = this(???, ???, ???) + def this(t: T) = this(t, ???, ???) + def w: Int + } + type T1 = Int + type T2[T] = S[T] + type U <: Int + type V >: Int + case object X + final class Y + sealed trait Z + class AA(x: Int, val y: Int, var z: Int) + class S[@specialized T] + val List(xs1) = ??? + ??? match { case List(xs2) => ??? } + ??? match { case _: List[t] => ??? } +} diff --git a/tests/semanticdb/expect/ForComprehension.expect.scala b/tests/semanticdb/expect/ForComprehension.expect.scala new file mode 100644 index 000000000000..c4d3340bc84c --- /dev/null +++ b/tests/semanticdb/expect/ForComprehension.expect.scala @@ -0,0 +1,45 @@ +package example + +class ForComprehension/*<-example::ForComprehension#*/ { + for { + a/*<-local0*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ + b/*<-local1*//*->scala::Tuple2.apply().*//*->local1*//*->local3*//*->scala::Tuple2.unapply().*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::IterableOps#withFilter().*/ + if b/*->local1*/ >/*->scala::Int#`>`(+3).*/ 1/*->scala::collection::WithFilter#map().*/ + c/*<-local2*//*->local2*/ = a/*->local0*/ +/*->scala::Int#`+`(+4).*/ b/*->local1*//*->scala::collection::immutable::List#map().*/ + } yield (/*->scala::Tuple3.apply().*/a/*->local0*/, b/*->local1*/, c/*->local2*/) + for { + a/*<-local4*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ + b/*<-local5*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(a/*->local4*/)/*->scala::collection::IterableOps#withFilter().*/ + if ( + /*->scala::Tuple2.apply().*/a/*->local4*/, + b/*->local5*/ + ) ==/*->scala::Any#`==`().*/ (/*->scala::Tuple2.apply().*/1, 2)/*->scala::collection::WithFilter#flatMap().*/ + /*->local6*//*->scala::Tuple2.unapply().*/( + /*->scala::Tuple2.unapply().*/c/*<-local7*/, + d/*<-local8*/ + ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((/*->scala::Tuple2.apply().*/a/*->local4*/, b/*->local5*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/ + if ( + /*->scala::Tuple4.apply().*/a/*->local4*/, + b/*->local5*/, + c/*->local7*/, + d/*->local8*/ + ) ==/*->scala::Any#`==`().*/ (/*->scala::Tuple4.apply().*/1, 2, 3, 4)/*->scala::collection::WithFilter#map().*/ + e/*<-local9*//*->scala::Tuple2.apply().*//*->local9*/ = ( + /*->scala::Tuple4.apply().*/a/*->local4*/, + b/*->local5*/, + c/*->local7*/, + d/*->local8*/ + )/*->scala::collection::IterableOps#withFilter().*/ + if e/*->local9*/ ==/*->scala::Any#`==`().*/ (/*->scala::Tuple4.apply().*/1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/ + f/*<-local10*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(e/*->local9*/)/*->scala::collection::immutable::List#map().*/ + } yield { + ( + /*->scala::Tuple6.apply().*/a/*->local4*/, + b/*->local5*/, + c/*->local7*/, + d/*->local8*/, + e/*->local9*/, + f/*->local10*/ + ) + } +} diff --git a/tests/semanticdb/expect/ForComprehension.scala b/tests/semanticdb/expect/ForComprehension.scala new file mode 100644 index 000000000000..23cbc1ce9da8 --- /dev/null +++ b/tests/semanticdb/expect/ForComprehension.scala @@ -0,0 +1,45 @@ +package example + +class ForComprehension { + for { + a <- List(1) + b <- List(1) + if b > 1 + c = a + b + } yield (a, b, c) + for { + a <- List(1) + b <- List(a) + if ( + a, + b + ) == (1, 2) + ( + c, + d + ) <- List((a, b)) + if ( + a, + b, + c, + d + ) == (1, 2, 3, 4) + e = ( + a, + b, + c, + d + ) + if e == (1, 2, 3, 4) + f <- List(e) + } yield { + ( + a, + b, + c, + d, + e, + f + ) + } +} diff --git a/tests/semanticdb/expect/Givens.expect.scala b/tests/semanticdb/expect/Givens.expect.scala new file mode 100644 index 000000000000..d827c41f7e86 --- /dev/null +++ b/tests/semanticdb/expect/Givens.expect.scala @@ -0,0 +1,27 @@ +package a +package b + +object Givens/*<-a::b::Givens.*/ + + given extension [A](any: /*<-a::b::Givens.given_sayHello_of_A.*//*<-a::b::Givens.given_sayHello_of_A.sayHello().[A]*//*<-a::b::Givens.given_sayHello_of_A.sayHello().(any)*/A/*->a::b::Givens.given_sayHello_of_A.sayHello().[A]*/) + def sayHello/*<-a::b::Givens.given_sayHello_of_A.sayHello().*/ = s"/*->scala::StringContext.apply().*/Hello, I am $any/*->a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->scala::StringContext#s().*/" + + given extension [B](any: B)/*<-a::b::Givens.given_sayGoodbye_of_B.*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*/ + def sayGoodbye/*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/ = s"/*->scala::StringContext.apply().*/Goodbye, from $any/*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*->scala::StringContext#s().*/" + def saySoLong/*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().*/ = s"/*->scala::StringContext.apply().*/So Long, from $any/*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->scala::StringContext#s().*/" + + val hello1/*<-a::b::Givens.hello1.*/ = /*->a::b::Givens.given_sayHello_of_A.sayHello().*/1.sayHello + val goodbye1/*<-a::b::Givens.goodbye1.*/ = /*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/1.sayGoodbye + val soLong1/*<-a::b::Givens.soLong1.*/ = /*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().*/1.saySoLong + + trait Monoid/*<-a::b::Givens.Monoid#*/[A/*<-a::b::Givens.Monoid#[A]*/] + def empty/*<-a::b::Givens.Monoid#empty().*/: A/*->a::b::Givens.Monoid#[A]*/ + def (x: A) /*<-a::b::Givens.Monoid#combine().*//*<-a::b::Givens.Monoid#combine().(x)*//*->a::b::Givens.Monoid#[A]*/combine (y/*<-a::b::Givens.Monoid#combine().(y)*/: A/*->a::b::Givens.Monoid#[A]*/): A/*->a::b::Givens.Monoid#[A]*/ + + given Monoid[String] + /*<-a::b::Givens.given_Monoid_String.*//*->a::b::Givens.Monoid#*//*->scala::Predef.String#*/def empty/*<-a::b::Givens.given_Monoid_String.empty().*/ = "" + def (x: Str/*<-a::b::Givens.given_Monoid_String.combine().*//*<-a::b::Givens.given_Monoid_String.combine().(x)*/ing/*->scala::Predef.String#*/) combine (y/*<-a::b::Givens.given_Monoid_String.combine().(y)*/: String/*->scala::Predef.String#*/) = x/*->a::b::Givens.given_Monoid_String.combine().(x)*/ +/*->java::lang::String#`+`().*/ y/*->a::b::Givens.given_Monoid_String.combine().(y)*/ + + inline given int2String/*<-a::b::Givens.int2String().*/: Conversion/*->scala::Conversion#*/[Int/*->scala::Int#*/, String/*->scala::Predef.String#*/] = _.toString/*->scala::Any#toString().*/ + + def foo/*<-a::b::Givens.foo().*/[A/*<-a::b::Givens.foo().[A]*/](given A/*<-a::b::Givens.foo().(A)*/: Monoid/*->a::b::Givens.Monoid#*/[A/*->a::b::Givens.foo().[A]*/]): A/*->a::b::Givens.foo().[A]*/ = A/*->a::b::Givens.foo().(A)*/.combine/*->a::b::Givens.Monoid#combine().*/(A/*->a::b::Givens.foo().(A)*/.empty/*->a::b::Givens.Monoid#empty().*/)(A/*->a::b::Givens.foo().(A)*/.empty/*->a::b::Givens.Monoid#empty().*/) diff --git a/tests/semanticdb/expect/Givens.scala b/tests/semanticdb/expect/Givens.scala new file mode 100644 index 000000000000..9460d5cba0fd --- /dev/null +++ b/tests/semanticdb/expect/Givens.scala @@ -0,0 +1,27 @@ +package a +package b + +object Givens + + given extension [A](any: A) + def sayHello = s"Hello, I am $any" + + given extension [B](any: B) + def sayGoodbye = s"Goodbye, from $any" + def saySoLong = s"So Long, from $any" + + val hello1 = 1.sayHello + val goodbye1 = 1.sayGoodbye + val soLong1 = 1.saySoLong + + trait Monoid[A] + def empty: A + def (x: A) combine (y: A): A + + given Monoid[String] + def empty = "" + def (x: String) combine (y: String) = x + y + + inline given int2String: Conversion[Int, String] = _.toString + + def foo[A](given A: Monoid[A]): A = A.combine(A.empty)(A.empty) diff --git a/tests/semanticdb/expect/ImplicitConversion.expect.scala b/tests/semanticdb/expect/ImplicitConversion.expect.scala new file mode 100644 index 000000000000..0d13a0af558c --- /dev/null +++ b/tests/semanticdb/expect/ImplicitConversion.expect.scala @@ -0,0 +1,37 @@ +package example + +import scala.language/*->scalaShadowing::language.*/.implicitConversions/*->scalaShadowing::language.implicitConversions.*/ + +class ImplicitConversion/*<-example::ImplicitConversion#*/ { + import ImplicitConversion/*->example::ImplicitConversion.*/._ + implicit def string2Number/*<-example::ImplicitConversion#string2Number().*/( + string/*<-example::ImplicitConversion#string2Number().(string)*/: String/*->scala::Predef.String#*/ + ): Int/*->scala::Int#*/ = 42 + val message/*<-example::ImplicitConversion#message.*/ = "" + val number/*<-example::ImplicitConversion#number.*/ = 42 + val tuple/*<-example::ImplicitConversion#tuple.*/ = (/*->scala::Tuple2.apply().*/1, 2) + val char/*<-example::ImplicitConversion#char.*/: Char/*->scala::Char#*/ = 'a' + + // extension methods + /*->scala::Predef.augmentString().*/message/*->example::ImplicitConversion#message.*/ + .stripSuffix/*->scala::collection::StringOps#stripSuffix().*/("h") + /*->example::ImplicitConversion.newAny2stringadd().*/tuple/*->example::ImplicitConversion#tuple.*/ +/*->example::ImplicitConversion.newAny2stringadd#`+`().*/ "Hello" + + // implicit conversions + val x/*<-example::ImplicitConversion#x.*/: Int/*->scala::Int#*/ = /*->example::ImplicitConversion#string2Number().*/message/*->example::ImplicitConversion#message.*/ + + // interpolators + s"/*->scala::StringContext.apply().*/Hello $message/*->example::ImplicitConversion#message.*/ $number/*->example::ImplicitConversion#number.*//*->scala::StringContext#s().*/" + /*->scala::Predef.augmentString().*/s"""/*->scala::StringContext.apply().*/Hello + |$message/*->example::ImplicitConversion#message.*/ + |$number/*->example::ImplicitConversion#number.*//*->scala::StringContext#s().*/""".stripMargin/*->scala::collection::StringOps#stripMargin(+1).*/ + + val a/*<-example::ImplicitConversion#a.*/: Int/*->scala::Int#*/ = /*->scala::Char.char2int().*/char/*->example::ImplicitConversion#char.*/ + val b/*<-example::ImplicitConversion#b.*/: Long/*->scala::Long#*/ = /*->scala::Char.char2long().*/char/*->example::ImplicitConversion#char.*/ +} + +object ImplicitConversion/*<-example::ImplicitConversion.*/ { + implicit final class newAny2stringadd/*<-example::ImplicitConversion.newAny2stringadd#*/[A/*<-example::ImplicitConversion.newAny2stringadd#[A]*/](private val self/*<-example::ImplicitConversion.newAny2stringadd#self.*/: A/*->example::ImplicitConversion.newAny2stringadd#[A]*/) extends AnyVal/*->scala::AnyVal#*//*->scala::AnyVal#``().*/ { + def +/*<-example::ImplicitConversion.newAny2stringadd#`+`().*/(other/*<-example::ImplicitConversion.newAny2stringadd#`+`().(other)*/: String/*->scala::Predef.String#*/): String/*->scala::Predef.String#*/ = String/*->java::lang::String#*/.valueOf/*->java::lang::String#valueOf().*/(self/*->example::ImplicitConversion.newAny2stringadd#self.*/) +/*->java::lang::String#`+`().*/ other/*->example::ImplicitConversion.newAny2stringadd#`+`().(other)*/ + } +} diff --git a/tests/semanticdb/expect/ImplicitConversion.scala b/tests/semanticdb/expect/ImplicitConversion.scala new file mode 100644 index 000000000000..fea8daa18bcd --- /dev/null +++ b/tests/semanticdb/expect/ImplicitConversion.scala @@ -0,0 +1,37 @@ +package example + +import scala.language.implicitConversions + +class ImplicitConversion { + import ImplicitConversion._ + implicit def string2Number( + string: String + ): Int = 42 + val message = "" + val number = 42 + val tuple = (1, 2) + val char: Char = 'a' + + // extension methods + message + .stripSuffix("h") + tuple + "Hello" + + // implicit conversions + val x: Int = message + + // interpolators + s"Hello $message $number" + s"""Hello + |$message + |$number""".stripMargin + + val a: Int = char + val b: Long = char +} + +object ImplicitConversion { + implicit final class newAny2stringadd[A](private val self: A) extends AnyVal { + def +(other: String): String = String.valueOf(self) + other + } +} diff --git a/tests/semanticdb/expect/Imports.expect.scala b/tests/semanticdb/expect/Imports.expect.scala new file mode 100644 index 000000000000..87f7d4cb768f --- /dev/null +++ b/tests/semanticdb/expect/Imports.expect.scala @@ -0,0 +1 @@ +import scala.util.control.NonFatal/*->scala::util::control::NonFatal.*/ diff --git a/tests/semanticdb/expect/Imports.scala b/tests/semanticdb/expect/Imports.scala new file mode 100644 index 000000000000..e6a2bef1a5c4 --- /dev/null +++ b/tests/semanticdb/expect/Imports.scala @@ -0,0 +1 @@ +import scala.util.control.NonFatal diff --git a/tests/semanticdb/expect/InstrumentTyper.expect.scala b/tests/semanticdb/expect/InstrumentTyper.expect.scala new file mode 100644 index 000000000000..5cd370ce3b42 --- /dev/null +++ b/tests/semanticdb/expect/InstrumentTyper.expect.scala @@ -0,0 +1,26 @@ +package example + +import scala.annotation.meta.param/*->scala::annotation::meta::param.*/ +import scala.language/*->scalaShadowing::language.*/.existentials/*->scalaShadowing::language.existentials.*/ +import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ +import types.Test/*->types::Test.*/._ + +class InstrumentTyper/*<-example::InstrumentTyper#*/ { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => + def all/*<-example::InstrumentTyper#all().*/ = List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/( + Literal/*->types::Test.Literal.*/.int/*->types::Test.Literal.int.*/, + Literal/*->types::Test.Literal.*/.long/*->types::Test.Literal.long.*/, + Literal/*->types::Test.Literal.*/.float/*->types::Test.Literal.float.*/, + Literal/*->types::Test.Literal.*/.double/*->types::Test.Literal.double.*/, + Literal/*->types::Test.Literal.*/.nil/*->types::Test.Literal.nil.*/, + Literal/*->types::Test.Literal.*/.char/*->types::Test.Literal.char.*/, + Literal/*->types::Test.Literal.*/.string/*->types::Test.Literal.string.*/, + Literal/*->types::Test.Literal.*/.bool/*->types::Test.Literal.bool.*/, + Literal/*->types::Test.Literal.*/.unit/*->types::Test.Literal.unit.*/, + Literal/*->types::Test.Literal.*/.javaEnum/*->types::Test.Literal.javaEnum.*/, + Literal/*->types::Test.Literal.*/.clazzOf/*->types::Test.Literal.clazzOf.*/, + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/() + ) + type AnnotatedType/*<-example::InstrumentTyper#AnnotatedType#*/ = Int/*->scala::Int#*/ @param/*->scala::annotation::meta::param#*/ + def singletonType/*<-example::InstrumentTyper#singletonType().*/(x/*<-example::InstrumentTyper#singletonType().(x)*/: Predef/*->scala::Predef.*/.type) = ???/*->scala::Predef.`???`().*/ + final val clazzOf/*<-example::InstrumentTyper#clazzOf.*/ = classOf/*->scala::Predef.classOf().*/[Option/*->scala::Option#*/[Int/*->scala::Int#*/]] +} diff --git a/tests/semanticdb/expect/InstrumentTyper.scala b/tests/semanticdb/expect/InstrumentTyper.scala new file mode 100644 index 000000000000..2c2ede6f85da --- /dev/null +++ b/tests/semanticdb/expect/InstrumentTyper.scala @@ -0,0 +1,26 @@ +package example + +import scala.annotation.meta.param +import scala.language.existentials +import scala.language.higherKinds +import types.Test._ + +class InstrumentTyper { self: AnyRef => + def all = List( + Literal.int, + Literal.long, + Literal.float, + Literal.double, + Literal.nil, + Literal.char, + Literal.string, + Literal.bool, + Literal.unit, + Literal.javaEnum, + Literal.clazzOf, + List() + ) + type AnnotatedType = Int @param + def singletonType(x: Predef.type) = ??? + final val clazzOf = classOf[Option[Int]] +} diff --git a/tests/semanticdb/expect/Issue1749.expect.scala b/tests/semanticdb/expect/Issue1749.expect.scala new file mode 100644 index 000000000000..b047b771e9ea --- /dev/null +++ b/tests/semanticdb/expect/Issue1749.expect.scala @@ -0,0 +1,16 @@ +// See https://github.com/scalameta/scalameta/issues/1749 +package example + +import scala.math.Ordered/*->scala::math::Ordered.*/.orderingToOrdered/*->scala::math::Ordered.orderingToOrdered().*/ + +class Issue1749/*<-example::Issue1749#*/ { + val x1/*<-example::Issue1749#x1.*/ = 42 + val x2/*<-example::Issue1749#x2.*/ = 42 + /*->scala::math::Ordered.orderingToOrdered().*/(/*->scala::Tuple2.apply().*/x1/*->example::Issue1749#x1.*/, x1/*->example::Issue1749#x1.*/)/*->scala::math::Ordering.Tuple2().*//*->scala::math::Ordering.Int.*/ + .compare/*->scala::math::Ordered#compare().*/((/*->scala::Tuple2.apply().*/x2/*->example::Issue1749#x2.*/, x2/*->example::Issue1749#x2.*/)) +} + +class Issue1854/*<-example::Issue1854#*/ { + val map/*<-example::Issue1854#map.*/ = collection.mutable.Map/*->scala::collection::mutable::Map.*/.empty/*->scala::collection::MapFactory.Delegate#empty().*/[String/*->scala::Predef.String#*/, String/*->scala::Predef.String#*/] + map/*->example::Issue1854#map.*//*->scala::collection::mutable::MapOps#update().*/("a") = "b" +} diff --git a/tests/semanticdb/expect/Issue1749.scala b/tests/semanticdb/expect/Issue1749.scala new file mode 100644 index 000000000000..053bd3d34562 --- /dev/null +++ b/tests/semanticdb/expect/Issue1749.scala @@ -0,0 +1,16 @@ +// See https://github.com/scalameta/scalameta/issues/1749 +package example + +import scala.math.Ordered.orderingToOrdered + +class Issue1749 { + val x1 = 42 + val x2 = 42 + (x1, x1) + .compare((x2, x2)) +} + +class Issue1854 { + val map = collection.mutable.Map.empty[String, String] + map("a") = "b" +} diff --git a/tests/semanticdb/expect/Local.expect.scala b/tests/semanticdb/expect/Local.expect.scala new file mode 100644 index 000000000000..6c1aa8440b23 --- /dev/null +++ b/tests/semanticdb/expect/Local.expect.scala @@ -0,0 +1,8 @@ +package example + +class Local/*<-example::Local#*/ { + def a/*<-example::Local#a().*/() = { + def id/*<-local0*/[A/*<-local1*/](a/*<-local2*/: A/*->local1*/): A/*->local1*/ = a/*->local2*/ + id/*->local0*/(1) + } +} diff --git a/tests/semanticdb/expect/Local.scala b/tests/semanticdb/expect/Local.scala new file mode 100644 index 000000000000..56caf92dd3b8 --- /dev/null +++ b/tests/semanticdb/expect/Local.scala @@ -0,0 +1,8 @@ +package example + +class Local { + def a() = { + def id[A](a: A): A = a + id(1) + } +} diff --git a/tests/semanticdb/expect/Locals.expect.scala b/tests/semanticdb/expect/Locals.expect.scala new file mode 100644 index 000000000000..7a8fdf0dd432 --- /dev/null +++ b/tests/semanticdb/expect/Locals.expect.scala @@ -0,0 +1,8 @@ +package locals + +object Test/*<-locals::Test.*/ { + val xs/*<-locals::Test.xs.*/ = { + val x/*<-local0*/ = 42 + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(x/*->local0*/) + } +} diff --git a/tests/semanticdb/expect/Locals.scala b/tests/semanticdb/expect/Locals.scala new file mode 100644 index 000000000000..a040dddcd786 --- /dev/null +++ b/tests/semanticdb/expect/Locals.scala @@ -0,0 +1,8 @@ +package locals + +object Test { + val xs = { + val x = 42 + List(x) + } +} diff --git a/tests/semanticdb/expect/MetacJava.expect.scala b/tests/semanticdb/expect/MetacJava.expect.scala new file mode 100644 index 000000000000..f95f82d787eb --- /dev/null +++ b/tests/semanticdb/expect/MetacJava.expect.scala @@ -0,0 +1,20 @@ +package example + +import com.javacp + +class MetacJava/*<-example::MetacJava#*/ { + javacp.MetacJava/*->com::javacp::MetacJava#*/.StaticInner/*->com::javacp::MetacJava#StaticInner#*/.isStatic/*->com::javacp::MetacJava#StaticInner#isStatic().*/() + new javacp.MetacJava/*->com::javacp::MetacJava#*/.StaticInner/*->com::javacp::MetacJava#StaticInner#*//*->com::javacp::MetacJava#StaticInner#``().*/().isNotStatic/*->com::javacp::MetacJava#StaticInner#isNotStatic().*/() + val inner/*<-example::MetacJava#inner.*/ = new javacp.MetacJava/*->com::javacp::MetacJava#*//*->com::javacp::MetacJava#``().*/() + val overload1/*<-example::MetacJava#overload1.*/ = new inner/*->example::MetacJava#inner.*/.Overload1/*->com::javacp::MetacJava#Overload1#*//*->com::javacp::MetacJava#Overload1#``().*/() + val overload2/*<-example::MetacJava#overload2.*/ = new inner/*->example::MetacJava#inner.*/.Overload2/*->com::javacp::MetacJava#Overload2#*//*->com::javacp::MetacJava#Overload2#``().*/() + inner/*->example::MetacJava#inner.*/.overload/*->com::javacp::MetacJava#overload().*/(new overload1/*->example::MetacJava#overload1.*/.A/*->com::javacp::MetacJava#Overload1#A#*//*->com::javacp::MetacJava#Overload1#A#``().*/()) + inner/*->example::MetacJava#inner.*/.overload/*->com::javacp::MetacJava#overload(+1).*/(new overload2/*->example::MetacJava#overload2.*/.A/*->com::javacp::MetacJava#Overload2#A#*//*->com::javacp::MetacJava#Overload2#A#``().*/()) + val staticInner/*<-example::MetacJava#staticInner.*/ = new javacp.MetacJava/*->com::javacp::MetacJava#*/.StaticInner/*->com::javacp::MetacJava#StaticInner#*//*->com::javacp::MetacJava#StaticInner#``().*/() + val nonStatic/*<-example::MetacJava#nonStatic.*/ = new staticInner/*->example::MetacJava#staticInner.*/.NonStatic/*->com::javacp::MetacJava#StaticInner#NonStatic#*//*->com::javacp::MetacJava#StaticInner#NonStatic#``().*/() + nonStatic/*->example::MetacJava#nonStatic.*/.method/*->com::javacp::MetacJava#StaticInner#NonStatic#method().*/(nonStatic/*->example::MetacJava#nonStatic.*/) + javacp.MetacJava/*->com::javacp::MetacJava#*/.overload/*->com::javacp::MetacJava#overload(+2).*/(new javacp.MetacJava/*->com::javacp::MetacJava#*/.Overload3/*->com::javacp::MetacJava#Overload3#*/.A/*->com::javacp::MetacJava#Overload3#A#*//*->com::javacp::MetacJava#Overload3#A#``().*/()) + val interface/*<-example::MetacJava#interface.*/: javacp.Interface/*->com::javacp::Interface#*/ = null + val coin/*<-example::MetacJava#coin.*/: javacp.Coin/*->com::javacp::Coin#*/ = javacp.Coin/*->com::javacp::Coin#*/.PENNY/*->com::javacp::Coin#PENNY.*/ + val entry/*<-example::MetacJava#entry.*/: java.util.Map/*->java::util::Map#*/.Entry/*->java::util::Map#Entry#*/[Int/*->scala::Int#*/, Int/*->scala::Int#*/] = null +} diff --git a/tests/semanticdb/expect/MetacJava.scala b/tests/semanticdb/expect/MetacJava.scala new file mode 100644 index 000000000000..8a8f20336a14 --- /dev/null +++ b/tests/semanticdb/expect/MetacJava.scala @@ -0,0 +1,20 @@ +package example + +import com.javacp + +class MetacJava { + javacp.MetacJava.StaticInner.isStatic() + new javacp.MetacJava.StaticInner().isNotStatic() + val inner = new javacp.MetacJava() + val overload1 = new inner.Overload1() + val overload2 = new inner.Overload2() + inner.overload(new overload1.A()) + inner.overload(new overload2.A()) + val staticInner = new javacp.MetacJava.StaticInner() + val nonStatic = new staticInner.NonStatic() + nonStatic.method(nonStatic) + javacp.MetacJava.overload(new javacp.MetacJava.Overload3.A()) + val interface: javacp.Interface = null + val coin: javacp.Coin = javacp.Coin.PENNY + val entry: java.util.Map.Entry[Int, Int] = null +} diff --git a/tests/semanticdb/expect/MethodUsages.expect.scala b/tests/semanticdb/expect/MethodUsages.expect.scala new file mode 100644 index 000000000000..ab1397975510 --- /dev/null +++ b/tests/semanticdb/expect/MethodUsages.expect.scala @@ -0,0 +1,32 @@ +package example + +class MethodUsages/*<-example::MethodUsages#*/ { + val m/*<-example::MethodUsages#m.*/ = new Methods/*->example::Methods#*/[Int/*->scala::Int#*/]/*->example::Methods#``().*/ + m/*->example::MethodUsages#m.*/.m1/*->example::Methods#m1().*/ + m/*->example::MethodUsages#m.*/.m2/*->example::Methods#m2().*/() + m/*->example::MethodUsages#m.*/.m3/*->example::Methods#m3().*/(0) + m/*->example::MethodUsages#m.*/.m4/*->example::Methods#m4().*/(0)(0) + m/*->example::MethodUsages#m.*/.m5/*->example::Methods#m5().*/("") + m/*->example::MethodUsages#m.*/.m5/*->example::Methods#m5(+1).*/(0) + m/*->example::MethodUsages#m.*/.m6/*->example::Methods#m6().*/(0) + m/*->example::MethodUsages#m.*/.m6/*->example::Methods#m6(+1).*/(new m/*->example::MethodUsages#m.*/.List/*->example::Methods#List#*/[Int/*->scala::Int#*/]/*->example::Methods#List#``().*/) + m/*->example::MethodUsages#m.*/.m6/*->example::Methods#m6(+2).*/(Nil/*->scala::package.Nil.*/) + m/*->example::MethodUsages#m.*/.m7/*->example::Methods#m7().*/(m/*->example::MethodUsages#m.*/, new m/*->example::MethodUsages#m.*/.List/*->example::Methods#List#*/[Int/*->scala::Int#*/]/*->example::Methods#List#``().*/)/*->scala::math::Ordering.Int.*/ + m/*->example::MethodUsages#m.*/.`m8().`/*->example::Methods#`m8().`().*/() + m/*->example::MethodUsages#m.*/.m9/*->example::Methods#m9().*/(null) + m/*->example::MethodUsages#m.*/.m10/*->example::Methods#m10().*/(null) + m/*->example::MethodUsages#m.*/.m11/*->example::Methods#m11().*/(Predef/*->scala::Predef.*/) + m/*->example::MethodUsages#m.*/.m11/*->example::Methods#m11(+1).*/(Example/*->example::Example.*/) + m/*->example::MethodUsages#m.*/.m12a/*->example::Methods#m12a().*/(null) + m/*->example::MethodUsages#m.*/.m12b/*->example::Methods#m12b().*/(null) + m/*->example::MethodUsages#m.*/.m13/*->example::Methods#m13().*/(0) + m/*->example::MethodUsages#m.*/.m15/*->example::Methods#m15().*/(0) + m/*->example::MethodUsages#m.*/.m16/*->example::Methods#m16().*/(0) + m/*->example::MethodUsages#m.*/.m16/*->example::Methods#m16().*/(0) + m/*->example::MethodUsages#m.*/.m17/*->example::Methods#m17.*/.m/*->example::Methods#m17.m().*/() + m/*->example::MethodUsages#m.*/.m17/*->example::Methods#m17().*/(1) + m/*->example::MethodUsages#m.*/.m17/*->example::Methods#m17(+1).*/("") + m/*->example::MethodUsages#m.*/.m18/*->example::Methods#m18.*/.m/*->example::Methods#m17.m().*/() + m/*->example::MethodUsages#m.*/.m18/*->example::Methods#m18().*/(1) + m/*->example::MethodUsages#m.*/.m18/*->example::Methods#m18(+1).*/("") +} diff --git a/tests/semanticdb/expect/MethodUsages.scala b/tests/semanticdb/expect/MethodUsages.scala new file mode 100644 index 000000000000..b5982e8563a5 --- /dev/null +++ b/tests/semanticdb/expect/MethodUsages.scala @@ -0,0 +1,32 @@ +package example + +class MethodUsages { + val m = new Methods[Int] + m.m1 + m.m2() + m.m3(0) + m.m4(0)(0) + m.m5("") + m.m5(0) + m.m6(0) + m.m6(new m.List[Int]) + m.m6(Nil) + m.m7(m, new m.List[Int]) + m.`m8().`() + m.m9(null) + m.m10(null) + m.m11(Predef) + m.m11(Example) + m.m12a(null) + m.m12b(null) + m.m13(0) + m.m15(0) + m.m16(0) + m.m16(0) + m.m17.m() + m.m17(1) + m.m17("") + m.m18.m() + m.m18(1) + m.m18("") +} diff --git a/tests/semanticdb/expect/Methods.expect.scala b/tests/semanticdb/expect/Methods.expect.scala new file mode 100644 index 000000000000..58990ecb1401 --- /dev/null +++ b/tests/semanticdb/expect/Methods.expect.scala @@ -0,0 +1,37 @@ +package example + +import scala.math.Ordering/*->scala::math::Ordering.*//*->scala::math::Ordering#*/ +import scala.language/*->scalaShadowing::language.*/.existentials/*->scalaShadowing::language.existentials.*/ + +class Methods/*<-example::Methods#*/[T/*<-example::Methods#[T]*/] { + class List/*<-example::Methods#List#*/[T/*<-example::Methods#List#[T]*/] + type AList/*<-example::Methods#AList#*/[T/*<-example::Methods#AList#[T]*/] = List/*->example::Methods#List#*/[T/*->example::Methods#AList#[T]*/] + def m1/*<-example::Methods#m1().*/ = ???/*->scala::Predef.`???`().*/ + def m2/*<-example::Methods#m2().*/() = ???/*->scala::Predef.`???`().*/ + def m3/*<-example::Methods#m3().*/(x/*<-example::Methods#m3().(x)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m4/*<-example::Methods#m4().*/(x/*<-example::Methods#m4().(x)*/: Int/*->scala::Int#*/)(y/*<-example::Methods#m4().(y)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m5/*<-example::Methods#m5().*/(x/*<-example::Methods#m5().(x)*/: String/*->scala::Predef.String#*/) = ???/*->scala::Predef.`???`().*/ + def m5/*<-example::Methods#m5(+1).*/(x/*<-example::Methods#m5(+1).(x)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m6/*<-example::Methods#m6().*/(x/*<-example::Methods#m6().(x)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m6/*<-example::Methods#m6(+1).*/(x/*<-example::Methods#m6(+1).(x)*/: List/*->example::Methods#List#*/[T/*->example::Methods#[T]*/]) = ???/*->scala::Predef.`???`().*/ + def m6/*<-example::Methods#m6(+2).*/(x/*<-example::Methods#m6(+2).(x)*/: scala.List/*->scala::package.List#*/[T/*->example::Methods#[T]*/]) = ???/*->scala::Predef.`???`().*/ + def m7/*<-example::Methods#m7().*/[U/*<-example::Methods#m7().[U]*/: Ordering/*->scala::math::Ordering#*//*->example::Methods#m7().[U]*/](c/*<-example::Methods#m7().(c)*/: Methods/*->example::Methods#*/[T/*->example::Methods#[T]*/], l/*<-example::Methods#m7().(l)*/: List/*->example::Methods#List#*/[U/*->example::Methods#m7().[U]*/]) = ???/*->scala::Predef.`???`().*/ + def `m8()./*<-example::Methods#`m8().`().*/`() = ???/*->scala::Predef.`???`().*/ + class `m9()./*<-example::Methods#`m9().`#*/` + def m9/*<-example::Methods#m9().*/(x/*<-example::Methods#m9().(x)*/: `m9().`/*->example::Methods#`m9().`#*/) = ???/*->scala::Predef.`???`().*/ + def m10/*<-example::Methods#m10().*/(x/*<-example::Methods#m10().(x)*/: AList/*->example::Methods#AList#*/[T/*->example::Methods#[T]*/]) = ???/*->scala::Predef.`???`().*/ + def m11/*<-example::Methods#m11().*/(x/*<-example::Methods#m11().(x)*/: Predef/*->scala::Predef.*/.type) = ???/*->scala::Predef.`???`().*/ + def m11/*<-example::Methods#m11(+1).*/(x/*<-example::Methods#m11(+1).(x)*/: Example/*->example::Example.*/.type) = ???/*->scala::Predef.`???`().*/ + def m12a/*<-example::Methods#m12a().*/(x/*<-example::Methods#m12a().(x)*/: {}) = ???/*->scala::Predef.`???`().*/ + def m12b/*<-example::Methods#m12b().*/(x/*<-example::Methods#m12b().(x)*/: { val x/*<-local0*/: Int/*->scala::Int#*/ }) = ???/*->scala::Predef.`???`().*/ + def m13/*<-example::Methods#m13().*/(x/*<-example::Methods#m13().(x)*/: Int/*->scala::Int#*/ @unchecked/*->scala::unchecked#*/) = ???/*->scala::Predef.`???`().*/ + def m15/*<-example::Methods#m15().*/(x/*<-example::Methods#m15().(x)*/: => Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m16/*<-example::Methods#m16().*/(x/*<-example::Methods#m16().(x)*/: Int/*->scala::Int#*/*) = ???/*->scala::Predef.`???`().*/ + object m17/*<-example::Methods#m17.*/ { def m/*<-example::Methods#m17.m().*/() = ???/*->scala::Predef.`???`().*/ } + def m17/*<-example::Methods#m17().*/(a/*<-example::Methods#m17().(a)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m17/*<-example::Methods#m17(+1).*/(b/*<-example::Methods#m17(+1).(b)*/: String/*->scala::Predef.String#*/) = ???/*->scala::Predef.`???`().*/ + val m18/*<-example::Methods#m18.*/ = m17/*->example::Methods#m17.*/ + def m18/*<-example::Methods#m18().*/(a/*<-example::Methods#m18().(a)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m18/*<-example::Methods#m18(+1).*/(b/*<-example::Methods#m18(+1).(b)*/: String/*->scala::Predef.String#*/) = ???/*->scala::Predef.`???`().*/ + def m19/*<-example::Methods#m19().*/(x/*<-example::Methods#m19().(x)*//*<-example::Methods#m19$default$3().(x)*/: Int/*->scala::Int#*/, y/*<-example::Methods#m19().(y)*//*<-example::Methods#m19$default$3().(y)*/: Int/*->scala::Int#*/ = 2)(z/*<-example::Methods#m19().(z)*/: Int/*->scala::Int#*/ = 3) = ???/*->scala::Predef.`???`().*/ +} diff --git a/tests/semanticdb/expect/Methods.scala b/tests/semanticdb/expect/Methods.scala new file mode 100644 index 000000000000..0327a3c32279 --- /dev/null +++ b/tests/semanticdb/expect/Methods.scala @@ -0,0 +1,37 @@ +package example + +import scala.math.Ordering +import scala.language.existentials + +class Methods[T] { + class List[T] + type AList[T] = List[T] + def m1 = ??? + def m2() = ??? + def m3(x: Int) = ??? + def m4(x: Int)(y: Int) = ??? + def m5(x: String) = ??? + def m5(x: Int) = ??? + def m6(x: Int) = ??? + def m6(x: List[T]) = ??? + def m6(x: scala.List[T]) = ??? + def m7[U: Ordering](c: Methods[T], l: List[U]) = ??? + def `m8().`() = ??? + class `m9().` + def m9(x: `m9().`) = ??? + def m10(x: AList[T]) = ??? + def m11(x: Predef.type) = ??? + def m11(x: Example.type) = ??? + def m12a(x: {}) = ??? + def m12b(x: { val x: Int }) = ??? + def m13(x: Int @unchecked) = ??? + def m15(x: => Int) = ??? + def m16(x: Int*) = ??? + object m17 { def m() = ??? } + def m17(a: Int) = ??? + def m17(b: String) = ??? + val m18 = m17 + def m18(a: Int) = ??? + def m18(b: String) = ??? + def m19(x: Int, y: Int = 2)(z: Int = 3) = ??? +} diff --git a/tests/semanticdb/expect/NamedApplyBlock.expect.scala b/tests/semanticdb/expect/NamedApplyBlock.expect.scala new file mode 100644 index 000000000000..ef438d0e74f6 --- /dev/null +++ b/tests/semanticdb/expect/NamedApplyBlock.expect.scala @@ -0,0 +1,14 @@ +package example + +object NamedApplyBlockMethods/*<-example::NamedApplyBlockMethods.*/ { + val local/*<-example::NamedApplyBlockMethods.local.*/ = 1 + def foo/*<-example::NamedApplyBlockMethods.foo().*/(a/*<-example::NamedApplyBlockMethods.foo().(a)*/: Int/*->scala::Int#*/ = 1, b/*<-example::NamedApplyBlockMethods.foo().(b)*/: Int/*->scala::Int#*/ = 2, c/*<-example::NamedApplyBlockMethods.foo().(c)*/: Int/*->scala::Int#*/ = 3): Int/*->scala::Int#*/ = a/*->example::NamedApplyBlockMethods.foo().(a)*/ +/*->scala::Int#`+`(+4).*/ b/*->example::NamedApplyBlockMethods.foo().(b)*/ +/*->scala::Int#`+`(+4).*/ c/*->example::NamedApplyBlockMethods.foo().(c)*/ + def baseCase/*<-example::NamedApplyBlockMethods.baseCase().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local0*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = 3) + def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local2*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local3*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = 3)) +} + +object NamedApplyBlockCaseClassConstruction/*<-example::NamedApplyBlockCaseClassConstruction.*/ { + case class Msg/*<-example::NamedApplyBlockCaseClassConstruction.Msg#*/(body/*<-example::NamedApplyBlockCaseClassConstruction.Msg#body.*/: String/*->scala::Predef.String#*/, head/*<-example::NamedApplyBlockCaseClassConstruction.Msg#head.*/: String/*->scala::Predef.String#*/ = "default", tail/*<-example::NamedApplyBlockCaseClassConstruction.Msg#tail.*/: String/*->scala::Predef.String#*/) + val bodyText/*<-example::NamedApplyBlockCaseClassConstruction.bodyText.*/ = "body" + val msg/*<-example::NamedApplyBlockCaseClassConstruction.msg.*/ = Msg/*->example::NamedApplyBlockCaseClassConstruction.Msg.*//*->local4*//*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail/*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().(tail)*/ = "tail") +} diff --git a/tests/semanticdb/expect/NamedApplyBlock.scala b/tests/semanticdb/expect/NamedApplyBlock.scala new file mode 100644 index 000000000000..ac78f248c953 --- /dev/null +++ b/tests/semanticdb/expect/NamedApplyBlock.scala @@ -0,0 +1,14 @@ +package example + +object NamedApplyBlockMethods { + val local = 1 + def foo(a: Int = 1, b: Int = 2, c: Int = 3): Int = a + b + c + def baseCase = foo(local, c = 3) + def recursive = foo(local, c = foo(local, c = 3)) +} + +object NamedApplyBlockCaseClassConstruction { + case class Msg(body: String, head: String = "default", tail: String) + val bodyText = "body" + val msg = Msg(bodyText, tail = "tail") +} diff --git a/tests/semanticdb/expect/NamedArguments.expect.scala b/tests/semanticdb/expect/NamedArguments.expect.scala new file mode 100644 index 000000000000..1d478decc4b4 --- /dev/null +++ b/tests/semanticdb/expect/NamedArguments.expect.scala @@ -0,0 +1,7 @@ +package example + +class NamedArguments/*<-example::NamedArguments#*/ { + case class User/*<-example::NamedArguments#User#*/(name/*<-example::NamedArguments#User#name.*/: String/*->scala::Predef.String#*/) + User/*->example::NamedArguments#User.*//*->example::NamedArguments#User.apply().*/(name/*->example::NamedArguments#User.apply().(name)*/ = "John") + User/*->example::NamedArguments#User.*/.apply/*->example::NamedArguments#User.apply().*/(name/*->example::NamedArguments#User.apply().(name)*/ = "John") +} diff --git a/tests/semanticdb/expect/NamedArguments.scala b/tests/semanticdb/expect/NamedArguments.scala new file mode 100644 index 000000000000..009c4aa6e1ac --- /dev/null +++ b/tests/semanticdb/expect/NamedArguments.scala @@ -0,0 +1,7 @@ +package example + +class NamedArguments { + case class User(name: String) + User(name = "John") + User.apply(name = "John") +} diff --git a/tests/semanticdb/expect/NewModifiers.expect.scala b/tests/semanticdb/expect/NewModifiers.expect.scala new file mode 100644 index 000000000000..bc0d1dcf71e7 --- /dev/null +++ b/tests/semanticdb/expect/NewModifiers.expect.scala @@ -0,0 +1,4 @@ +object NewModifiers/*<-_empty_::NewModifiers.*/ { + inline val foo/*<-_empty_::NewModifiers.foo.*/ = "foo" + opaque type A/*<-_empty_::NewModifiers.A#*/ = Int/*->scala::Int#*/ +} diff --git a/tests/semanticdb/expect/NewModifiers.scala b/tests/semanticdb/expect/NewModifiers.scala new file mode 100644 index 000000000000..2d5e82551b02 --- /dev/null +++ b/tests/semanticdb/expect/NewModifiers.scala @@ -0,0 +1,4 @@ +object NewModifiers { + inline val foo = "foo" + opaque type A = Int +} diff --git a/tests/semanticdb/expect/Objects.expect.scala b/tests/semanticdb/expect/Objects.expect.scala new file mode 100644 index 000000000000..d833d361b9e0 --- /dev/null +++ b/tests/semanticdb/expect/Objects.expect.scala @@ -0,0 +1,5 @@ +package objects + +object X/*<-objects::X.*/ { + object Y/*<-objects::X.Y.*/ +} diff --git a/tests/semanticdb/expect/Objects.scala b/tests/semanticdb/expect/Objects.scala new file mode 100644 index 000000000000..b1be1db1da91 --- /dev/null +++ b/tests/semanticdb/expect/Objects.scala @@ -0,0 +1,5 @@ +package objects + +object X { + object Y +} diff --git a/tests/semanticdb/expect/Overrides.expect.scala b/tests/semanticdb/expect/Overrides.expect.scala new file mode 100644 index 000000000000..21e667b51cba --- /dev/null +++ b/tests/semanticdb/expect/Overrides.expect.scala @@ -0,0 +1,4 @@ +package example + +trait A/*<-example::A#*/ { def foo/*<-example::A#foo().*/: Int/*->scala::Int#*/ } +class B/*<-example::B#*/() extends A/*->example::A#*/ { def foo/*<-example::B#foo().*/: Int/*->scala::Int#*/ = 2 } diff --git a/tests/semanticdb/expect/Overrides.scala b/tests/semanticdb/expect/Overrides.scala new file mode 100644 index 000000000000..3dd04fd0ff1f --- /dev/null +++ b/tests/semanticdb/expect/Overrides.scala @@ -0,0 +1,4 @@ +package example + +trait A { def foo: Int } +class B() extends A { def foo: Int = 2 } diff --git a/tests/semanticdb/expect/Prefixes.expect.scala b/tests/semanticdb/expect/Prefixes.expect.scala new file mode 100644 index 000000000000..0873e23555a7 --- /dev/null +++ b/tests/semanticdb/expect/Prefixes.expect.scala @@ -0,0 +1,33 @@ +package prefixes + +class C/*<-prefixes::C#*/ { + type T/*<-prefixes::C#T#*/ + def m1/*<-prefixes::C#m1().*/: T/*->prefixes::C#T#*/ = ???/*->scala::Predef.`???`().*/ + + object N/*<-prefixes::C#N.*/ { + type U/*<-prefixes::C#N.U#*/ + } + def k1/*<-prefixes::C#k1().*/: N/*->prefixes::C#N.*/.U/*->prefixes::C#N.U#*/ = ???/*->scala::Predef.`???`().*/ +} + +object M/*<-prefixes::M.*/ { + type T/*<-prefixes::M.T#*/ + def n1/*<-prefixes::M.n1().*/: T/*->prefixes::M.T#*/ = ???/*->scala::Predef.`???`().*/ +} + +object O/*<-prefixes::O.*/ extends C/*->prefixes::C#*/ { + def o1/*<-prefixes::O.o1().*/: T/*->prefixes::C#T#*/ = ???/*->scala::Predef.`???`().*/ +} + +object Test/*<-prefixes::Test.*/ { + val c/*<-prefixes::Test.c.*/: C/*->prefixes::C#*/ = ???/*->scala::Predef.`???`().*/ + def m2/*<-prefixes::Test.m2().*/: c/*->prefixes::Test.c.*/.T/*->prefixes::C#T#*/ = ???/*->scala::Predef.`???`().*/ + def k2/*<-prefixes::Test.k2().*/: c/*->prefixes::Test.c.*/.N/*->prefixes::C#N.*/.U/*->prefixes::C#N.U#*/ = ???/*->scala::Predef.`???`().*/ + import c/*->prefixes::Test.c.*/.N/*->prefixes::C#N.*/._ + def k3/*<-prefixes::Test.k3().*/: U = ???/*->scala::Predef.`???`().*/ + + def n2/*<-prefixes::Test.n2().*/: M/*->prefixes::M.*/.T/*->prefixes::M.T#*/ = ???/*->scala::Predef.`???`().*/ + + import M/*->prefixes::M.*/._ + def n3/*<-prefixes::Test.n3().*/: T/*->prefixes::M.T#*/ = ???/*->scala::Predef.`???`().*/ +} diff --git a/tests/semanticdb/expect/Prefixes.scala b/tests/semanticdb/expect/Prefixes.scala new file mode 100644 index 000000000000..11891cb325ec --- /dev/null +++ b/tests/semanticdb/expect/Prefixes.scala @@ -0,0 +1,33 @@ +package prefixes + +class C { + type T + def m1: T = ??? + + object N { + type U + } + def k1: N.U = ??? +} + +object M { + type T + def n1: T = ??? +} + +object O extends C { + def o1: T = ??? +} + +object Test { + val c: C = ??? + def m2: c.T = ??? + def k2: c.N.U = ??? + import c.N._ + def k3: U = ??? + + def n2: M.T = ??? + + import M._ + def n3: T = ??? +} diff --git a/tests/semanticdb/expect/Selfs.expect.scala b/tests/semanticdb/expect/Selfs.expect.scala new file mode 100644 index 000000000000..a8d5cf973d22 --- /dev/null +++ b/tests/semanticdb/expect/Selfs.expect.scala @@ -0,0 +1,15 @@ +package selfs + +class B/*<-selfs::B#*/ + +class C1/*<-selfs::C1#*/ extends B/*->selfs::B#*/ { self/*<-local0*/ => +} + +class C2/*<-selfs::C2#*/ extends B/*->selfs::B#*/ { self/*<-local1*/: B/*->selfs::B#*/ => +} + +class C3/*<-selfs::C3#*/ extends B/*->selfs::B#*/ { self/*<-local2*/: B/*->selfs::B#*/ with C1/*->selfs::C1#*/ => +} + +class C6/*<-selfs::C6#*/ extends B/*->selfs::B#*/ { this: B/*->selfs::B#*/ => +} diff --git a/tests/semanticdb/expect/Selfs.scala b/tests/semanticdb/expect/Selfs.scala new file mode 100644 index 000000000000..4e46793bd783 --- /dev/null +++ b/tests/semanticdb/expect/Selfs.scala @@ -0,0 +1,15 @@ +package selfs + +class B + +class C1 extends B { self => +} + +class C2 extends B { self: B => +} + +class C3 extends B { self: B with C1 => +} + +class C6 extends B { this: B => +} diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala new file mode 100644 index 000000000000..a0c7d6aa1c9a --- /dev/null +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -0,0 +1,50 @@ +package example + +import scala.language/*->scalaShadowing::language.*/.implicitConversions/*->scalaShadowing::language.implicitConversions.*/ + +class Synthetic/*<-example::Synthetic#*/ { + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).map/*->scala::collection::immutable::List#map().*/(_ +/*->scala::Int#`+`(+4).*/ 2) + /*->scala::Predef.intArrayOps().*/Array/*->scala::Array.*/.empty/*->scala::Array.empty().*/[Int/*->scala::Int#*/]/*->scala::reflect::ClassTag.apply().*//*->java::lang::Integer#TYPE.*/.headOption/*->scala::collection::ArrayOps#headOption().*/ + /*->scala::Predef.augmentString().*/"fooo".stripPrefix/*->scala::collection::StringOps#stripPrefix().*/("o") + + // See https://github.com/scalameta/scalameta/issues/977 + val Name/*<-example::Synthetic#Name.*/ = /*->scala::Predef.augmentString().*/"name:(.*)".r/*->scala::collection::StringOps#r().*/ + val x/*<-example::Synthetic#x.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ xs/*<-example::Synthetic#xs.*/ = LazyList/*->scala::package.LazyList.*//*->scala::collection::IterableFactory#apply().*/(1, 2) + val Name/*->example::Synthetic#Name.*//*->scala::util::matching::Regex#unapplySeq().*/(name/*<-example::Synthetic#name.*/) = "name:foo" + 1 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/2 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*//*->scala::collection::immutable::LazyList.Deferrer#`#::`().*/ + + val a1/*<-example::Synthetic#a1.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ a2/*<-example::Synthetic#a2.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ as/*<-example::Synthetic#as.*/ = LazyList/*->scala::package.LazyList.*//*->scala::collection::IterableFactory#apply().*/(1, 2) + + val lst/*<-example::Synthetic#lst.*/ = 1 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/2 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*//*->scala::collection::immutable::LazyList.Deferrer#`#::`().*/ + + for (x/*<-local0*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y/*<-local1*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(/*->scala::Predef.ArrowAssoc().*/x/*->local0*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local0*/) + for (i/*<-local2*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local3*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (/*->scala::Tuple2.apply().*/i/*->local2*/, j/*->local3*/) + for (i/*<-local4*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local5*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::IterableOps#withFilter().*/ if i/*->local4*/ %/*->scala::Int#`%`(+3).*/ 2 ==/*->scala::Int#`==`(+3).*/ 0/*->scala::collection::WithFilter#map().*/) yield (/*->scala::Tuple2.apply().*/i/*->local4*/, j/*->local5*/) + + object s/*<-example::Synthetic#s.*/ { + def apply/*<-example::Synthetic#s.apply().*/() = 2 + s/*->example::Synthetic#s.apply().*/() + s.apply/*->example::Synthetic#s.apply().*/() + case class Bar/*<-example::Synthetic#s.Bar#*/() + Bar/*->example::Synthetic#s.Bar.*//*->example::Synthetic#s.Bar.apply().*/() + null.asInstanceOf/*->scala::Any#asInstanceOf().*/[Int/*->scala::Int#*/ => Int/*->scala::Int#*/]/*->scala::Function1#apply().*/(2) + } + + class J/*<-example::Synthetic#J#*/[T/*<-example::Synthetic#J#[T]*/: Manifest/*->scala::Predef.Manifest#*//*->example::Synthetic#J#[T]*/] { val arr/*<-example::Synthetic#J#arr.*/ = Array/*->scala::Array.*/.empty/*->scala::Array.empty().*/[T/*->example::Synthetic#J#[T]*/] } + + class F/*<-example::Synthetic#F#*/ + implicit val ordering/*<-example::Synthetic#ordering.*/: Ordering/*->scala::package.Ordering#*/[F/*->example::Synthetic#F#*/] = ???/*->scala::Predef.`???`().*/ + val f/*<-example::Synthetic#f.*/: Ordered/*->scala::package.Ordered#*/[F/*->example::Synthetic#F#*/] = /*->scala::math::Ordered.orderingToOrdered().*/new F/*->example::Synthetic#F#*//*->example::Synthetic#ordering.*/ + + import scala.concurrent.ExecutionContext/*->scala::concurrent::ExecutionContext.*/.Implicits/*->scala::concurrent::ExecutionContext.Implicits.*/.global/*->scala::concurrent::ExecutionContext.Implicits.global().*/ + for { + a/*<-local6*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#foreach().*/ + b/*<-local7*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#foreach().*/ + } println/*->scala::Predef.println(+1).*/(a/*->local6*/)/*->scala::concurrent::ExecutionContext.Implicits.global().*/ + for { + a/*<-local8*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#flatMap().*/ + b/*<-local9*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#withFilter().*/ + if a/*->local8*/ scala::Int#`<`(+3).*/ b/*->local9*//*->scala::concurrent::Future#map().*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ + } yield a/*->local8*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ + +} diff --git a/tests/semanticdb/expect/Synthetic.scala b/tests/semanticdb/expect/Synthetic.scala new file mode 100644 index 000000000000..484e07098877 --- /dev/null +++ b/tests/semanticdb/expect/Synthetic.scala @@ -0,0 +1,50 @@ +package example + +import scala.language.implicitConversions + +class Synthetic { + List(1).map(_ + 2) + Array.empty[Int].headOption + "fooo".stripPrefix("o") + + // See https://github.com/scalameta/scalameta/issues/977 + val Name = "name:(.*)".r + val x #:: xs = LazyList(1, 2) + val Name(name) = "name:foo" + 1 #:: 2 #:: LazyList.empty + + val a1 #:: a2 #:: as = LazyList(1, 2) + + val lst = 1 #:: 2 #:: LazyList.empty + + for (x <- 1 to 10; y <- 0 until 10) println(x -> x) + for (i <- 1 to 10; j <- 0 until 10) yield (i, j) + for (i <- 1 to 10; j <- 0 until 10 if i % 2 == 0) yield (i, j) + + object s { + def apply() = 2 + s() + s.apply() + case class Bar() + Bar() + null.asInstanceOf[Int => Int](2) + } + + class J[T: Manifest] { val arr = Array.empty[T] } + + class F + implicit val ordering: Ordering[F] = ??? + val f: Ordered[F] = new F + + import scala.concurrent.ExecutionContext.Implicits.global + for { + a <- scala.concurrent.Future.successful(1) + b <- scala.concurrent.Future.successful(2) + } println(a) + for { + a <- scala.concurrent.Future.successful(1) + b <- scala.concurrent.Future.successful(2) + if a < b + } yield a + +} diff --git a/tests/semanticdb/expect/Traits.expect.scala b/tests/semanticdb/expect/Traits.expect.scala new file mode 100644 index 000000000000..193390b38826 --- /dev/null +++ b/tests/semanticdb/expect/Traits.expect.scala @@ -0,0 +1,14 @@ +package traits + +trait T/*<-traits::T#*/ { + def x/*<-traits::T#x().*/ = 2 +} + +sealed trait U/*<-traits::U#*/ +object U/*<-traits::U.*/ { + def u/*<-traits::U.u().*/: U/*->traits::U#*/ = new U/*->traits::U#*/ {} +} + +class C/*<-traits::C#*/ +trait V/*<-traits::V#*/ { self/*<-local1*/: C/*->traits::C#*/ => +} diff --git a/tests/semanticdb/expect/Traits.scala b/tests/semanticdb/expect/Traits.scala new file mode 100644 index 000000000000..75efd131f04b --- /dev/null +++ b/tests/semanticdb/expect/Traits.scala @@ -0,0 +1,14 @@ +package traits + +trait T { + def x = 2 +} + +sealed trait U +object U { + def u: U = new U {} +} + +class C +trait V { self: C => +} diff --git a/tests/semanticdb/expect/Types.expect.scala b/tests/semanticdb/expect/Types.expect.scala new file mode 100644 index 000000000000..3da1549f3b4b --- /dev/null +++ b/tests/semanticdb/expect/Types.expect.scala @@ -0,0 +1,115 @@ +package types + +import scala.language/*->scalaShadowing::language.*/.existentials/*->scalaShadowing::language.existentials.*/ +import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ + +class ann/*<-types::ann#*/[T/*<-types::ann#[T]*/](x/*<-types::ann#x.*/: T/*->types::ann#[T]*/) extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class ann1/*<-types::ann1#*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class ann2/*<-types::ann2#*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ + +class B/*<-types::B#*/ + +class C/*<-types::C#*/ + +class P/*<-types::P#*/ { + class C/*<-types::P#C#*/ + class X/*<-types::P#X#*/ + val x/*<-types::P#x.*/ = new X/*->types::P#X#*/ +} + +class T/*<-types::T#*/ { + class C/*<-types::T#C#*/ + class X/*<-types::T#X#*/ + val x/*<-types::T#x.*/ = new X/*->types::T#X#*/ +} + +object Test/*<-types::Test.*/ { + class M/*<-types::Test.M#*/ { + def m/*<-types::Test.M#m().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + } + + trait N/*<-types::Test.N#*/ { + def n/*<-types::Test.N#n().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + } + + class C/*<-types::Test.C#*/ extends M/*->types::Test.M#*/ { + val p/*<-types::Test.C#p.*/ = new P/*->types::P#*/ + val x/*<-types::Test.C#x.*/ = p/*->types::Test.C#p.*/.x/*->types::P#x.*/ + + val typeRef1/*<-types::Test.C#typeRef1.*/: C/*->types::Test.C#*/ = ???/*->scala::Predef.`???`().*/ + val typeRef2/*<-types::Test.C#typeRef2.*/: p/*->types::Test.C#p.*/.C/*->types::P#C#*/ = ???/*->scala::Predef.`???`().*/ + val typeRef3/*<-types::Test.C#typeRef3.*/: T/*->types::T#*/#C/*->types::T#C#*/ = ???/*->scala::Predef.`???`().*/ + val typeRef4/*<-types::Test.C#typeRef4.*/: List/*->scala::package.List#*/[Int/*->scala::Int#*/] = ???/*->scala::Predef.`???`().*/ + + val singleType1/*<-types::Test.C#singleType1.*/: x/*->types::Test.C#x.*/.type = ???/*->scala::Predef.`???`().*/ + val singleType2/*<-types::Test.C#singleType2.*/: p/*->types::Test.C#p.*/.x/*->types::P#x.*/.type = ???/*->scala::Predef.`???`().*/ + val Either/*<-types::Test.C#Either.*/ = scala.util.Either/*->scala::util::Either.*/ + + val thisType1/*<-types::Test.C#thisType1.*/: this.type = ???/*->scala::Predef.`???`().*/ + val thisType2/*<-types::Test.C#thisType2.*/: C.this.type = ???/*->scala::Predef.`???`().*/ + + val superType1/*<-types::Test.C#superType1.*/ = super.m/*->types::Test.M#m().*/ + val superType2/*<-types::Test.C#superType2.*/ = super[M].m/*->types::Test.M#m().*/ + val superType3/*<-types::Test.C#superType3.*/ = C.super[M].m/*->types::Test.M#m().*/ + + val compoundType1/*<-types::Test.C#compoundType1.*/: { def k/*<-local0*/: Int/*->scala::Int#*/ } = ???/*->scala::Predef.`???`().*/ + val compoundType2/*<-types::Test.C#compoundType2.*/: M/*->types::Test.M#*/ with N/*->types::Test.N#*/ = ???/*->scala::Predef.`???`().*/ + val compoundType3/*<-types::Test.C#compoundType3.*/: M/*->types::Test.M#*/ with N/*->types::Test.N#*/ { def k/*<-local1*/: Int/*->scala::Int#*/ } = ???/*->scala::Predef.`???`().*/ + val compoundType4/*<-types::Test.C#compoundType4.*/ = new { def k/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + val compoundType5/*<-types::Test.C#compoundType5.*/ = new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ + val compoundType6/*<-types::Test.C#compoundType6.*/ = new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ { def k/*<-local6*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + + val annType1/*<-types::Test.C#annType1.*/: T/*->types::T#*/ @ann(42) = ???/*->scala::Predef.`???`().*/ + val annType2/*<-types::Test.C#annType2.*/: T/*->types::T#*/ @ann1/*->types::ann1#*/ @ann2/*->types::ann2#*/ = ???/*->scala::Predef.`???`().*/ + + val existentialType2/*<-types::Test.C#existentialType2.*/: List/*->scala::package.List#*/[_] = ???/*->scala::Predef.`???`().*/ + val existentialType3/*<-types::Test.C#existentialType3.*/ = Class/*->java::lang::Class#*/.forName/*->java::lang::Class#forName().*/("foo.Bar") + val existentialType4/*<-types::Test.C#existentialType4.*/ = Class/*->java::lang::Class#*/.forName/*->java::lang::Class#forName().*/("foo.Bar") + + def typeLambda1/*<-types::Test.C#typeLambda1().*/[M/*<-types::Test.C#typeLambda1().[M]*/[_]] = ???/*->scala::Predef.`???`().*/ + typeLambda1/*->types::Test.C#typeLambda1().*/[({ type L/*<-local7*/[T/*<-local8*/] = List/*->scala::package.List#*/[T/*->local8*/] })#L] + + object ClassInfoType1/*<-types::Test.C#ClassInfoType1.*/ + class ClassInfoType2/*<-types::Test.C#ClassInfoType2#*/ extends B/*->types::B#*/ { def x/*<-types::Test.C#ClassInfoType2#x().*/ = 42 } + trait ClassInfoType3/*<-types::Test.C#ClassInfoType3#*/[T/*<-types::Test.C#ClassInfoType3#[T]*/] + + object MethodType/*<-types::Test.C#MethodType.*/ { + def x1/*<-types::Test.C#MethodType.x1().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def x2/*<-types::Test.C#MethodType.x2().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m3/*<-types::Test.C#MethodType.m3().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m4/*<-types::Test.C#MethodType.m4().*/(): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m5/*<-types::Test.C#MethodType.m5().*/(x/*<-types::Test.C#MethodType.m5().(x)*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m6/*<-types::Test.C#MethodType.m6().*/[T/*<-types::Test.C#MethodType.m6().[T]*/](x/*<-types::Test.C#MethodType.m6().(x)*/: T/*->types::Test.C#MethodType.m6().[T]*/): T/*->types::Test.C#MethodType.m6().[T]*/ = ???/*->scala::Predef.`???`().*/ + } + + object ByNameType/*<-types::Test.C#ByNameType.*/ { + def m1/*<-types::Test.C#ByNameType.m1().*/(x/*<-types::Test.C#ByNameType.m1().(x)*/: => Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + } + + case class RepeatedType/*<-types::Test.C#RepeatedType#*/(s/*<-types::Test.C#RepeatedType#s.*/: String/*->scala::Predef.String#*/*) { + def m1/*<-types::Test.C#RepeatedType#m1().*/(x/*<-types::Test.C#RepeatedType#m1().(x)*/: Int/*->scala::Int#*/*): Int/*->scala::Int#*/ = s/*->types::Test.C#RepeatedType#s.*/.length/*->scala::collection::SeqOps#length().*/ + } + + object TypeType/*<-types::Test.C#TypeType.*/ { + type T1/*<-types::Test.C#TypeType.T1#*/ + def m2/*<-types::Test.C#TypeType.m2().*/[T2/*<-types::Test.C#TypeType.m2().[T2]*/ >: C/*->types::Test.C#*/ <: C/*->types::Test.C#*/] = ???/*->scala::Predef.`???`().*/ + def m3/*<-types::Test.C#TypeType.m3().*/[M3/*<-types::Test.C#TypeType.m3().[M3]*/[_]] = ???/*->scala::Predef.`???`().*/ + type T4/*<-types::Test.C#TypeType.T4#*/ = C/*->types::Test.C#*/ + type T5/*<-types::Test.C#TypeType.T5#*/[U/*<-types::Test.C#TypeType.T5#[U]*/] = U/*->types::Test.C#TypeType.T5#[U]*/ + } + } + + object Literal/*<-types::Test.Literal.*/ { + final val int/*<-types::Test.Literal.int.*/ = 1 + final val long/*<-types::Test.Literal.long.*/ = 1L + final val float/*<-types::Test.Literal.float.*/ = 1f + final val double/*<-types::Test.Literal.double.*/ = 2d + final val nil/*<-types::Test.Literal.nil.*/ = null + final val char/*<-types::Test.Literal.char.*/ = 'a' + final val string/*<-types::Test.Literal.string.*/ = "a" + final val bool/*<-types::Test.Literal.bool.*/ = true + final val unit/*<-types::Test.Literal.unit.*/ = () + final val javaEnum/*<-types::Test.Literal.javaEnum.*/ = java.nio.file.LinkOption/*->java::nio::file::LinkOption#*/.NOFOLLOW_LINKS/*->java::nio::file::LinkOption#NOFOLLOW_LINKS.*/ + final val clazzOf/*<-types::Test.Literal.clazzOf.*/ = classOf/*->scala::Predef.classOf().*/[Option/*->scala::Option#*/[Int/*->scala::Int#*/]] + } +} diff --git a/tests/semanticdb/expect/Types.scala b/tests/semanticdb/expect/Types.scala new file mode 100644 index 000000000000..b6f5495c9675 --- /dev/null +++ b/tests/semanticdb/expect/Types.scala @@ -0,0 +1,115 @@ +package types + +import scala.language.existentials +import scala.language.higherKinds + +class ann[T](x: T) extends scala.annotation.StaticAnnotation +class ann1 extends scala.annotation.StaticAnnotation +class ann2 extends scala.annotation.StaticAnnotation + +class B + +class C + +class P { + class C + class X + val x = new X +} + +class T { + class C + class X + val x = new X +} + +object Test { + class M { + def m: Int = ??? + } + + trait N { + def n: Int = ??? + } + + class C extends M { + val p = new P + val x = p.x + + val typeRef1: C = ??? + val typeRef2: p.C = ??? + val typeRef3: T#C = ??? + val typeRef4: List[Int] = ??? + + val singleType1: x.type = ??? + val singleType2: p.x.type = ??? + val Either = scala.util.Either + + val thisType1: this.type = ??? + val thisType2: C.this.type = ??? + + val superType1 = super.m + val superType2 = super[M].m + val superType3 = C.super[M].m + + val compoundType1: { def k: Int } = ??? + val compoundType2: M with N = ??? + val compoundType3: M with N { def k: Int } = ??? + val compoundType4 = new { def k: Int = ??? } + val compoundType5 = new M with N + val compoundType6 = new M with N { def k: Int = ??? } + + val annType1: T @ann(42) = ??? + val annType2: T @ann1 @ann2 = ??? + + val existentialType2: List[_] = ??? + val existentialType3 = Class.forName("foo.Bar") + val existentialType4 = Class.forName("foo.Bar") + + def typeLambda1[M[_]] = ??? + typeLambda1[({ type L[T] = List[T] })#L] + + object ClassInfoType1 + class ClassInfoType2 extends B { def x = 42 } + trait ClassInfoType3[T] + + object MethodType { + def x1: Int = ??? + def x2: Int = ??? + def m3: Int = ??? + def m4(): Int = ??? + def m5(x: Int): Int = ??? + def m6[T](x: T): T = ??? + } + + object ByNameType { + def m1(x: => Int): Int = ??? + } + + case class RepeatedType(s: String*) { + def m1(x: Int*): Int = s.length + } + + object TypeType { + type T1 + def m2[T2 >: C <: C] = ??? + def m3[M3[_]] = ??? + type T4 = C + type T5[U] = U + } + } + + object Literal { + final val int = 1 + final val long = 1L + final val float = 1f + final val double = 2d + final val nil = null + final val char = 'a' + final val string = "a" + final val bool = true + final val unit = () + final val javaEnum = java.nio.file.LinkOption.NOFOLLOW_LINKS + final val clazzOf = classOf[Option[Int]] + } +} diff --git a/tests/semanticdb/expect/ValPattern.expect.scala b/tests/semanticdb/expect/ValPattern.expect.scala new file mode 100644 index 000000000000..e50b3f2b502e --- /dev/null +++ b/tests/semanticdb/expect/ValPattern.expect.scala @@ -0,0 +1,47 @@ +package example + +class ValPattern/*<-example::ValPattern#*/ { + + val (left/*<-example::ValPattern#left.*/, right/*<-example::ValPattern#right.*/) = (/*->scala::Tuple2.apply().*/1, 2) + val Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1/*<-example::ValPattern#number1.*/) = + Some/*->scala::Some.*//*->scala::Some.apply().*/(1) + + val List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(Some/*->scala::Some.*//*->scala::Some.unapply().*/(q1/*<-example::ValPattern#q1.*/), None/*->scala::None.*/: None/*->scala::None.*/.type, None/*->scala::None.*/) = ???/*->scala::Predef.`???`().*/ + + var (leftVar/*<-example::ValPattern#leftVar().*/, rightVar/*<-example::ValPattern#rightVar().*/) = (/*->scala::Tuple2.apply().*/1, 2) + var Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1Var/*<-example::ValPattern#number1Var().*/) = + Some/*->scala::Some.*//*->scala::Some.apply().*/(1) + + def app/*<-example::ValPattern#app().*/(): Unit/*->scala::Unit#*/ = { + println/*->scala::Predef.println(+1).*/( + ( + /*->scala::Tuple6.apply().*/number1/*->example::ValPattern#number1.*/, + left/*->example::ValPattern#left.*/, + right/*->example::ValPattern#right.*/, + number1Var/*->example::ValPattern#number1Var().*/, + leftVar/*->example::ValPattern#leftVar().*/, + rightVar/*->example::ValPattern#rightVar().*/ + ) + ) + locally/*->dotty::DottyPredef.locally().*/ { + val (left/*<-local0*/, right/*<-local1*/) = (/*->scala::Tuple2.apply().*/1, 2) + val Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1/*<-local2*/) = + Some/*->scala::Some.*//*->scala::Some.apply().*/(1) + + var (leftVar/*<-local3*/, rightVar/*<-local4*/) = (/*->scala::Tuple2.apply().*/1, 2) + var Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1Var/*<-local5*/) = + Some/*->scala::Some.*//*->scala::Some.apply().*/(1) + println/*->scala::Predef.println(+1).*/( + ( + /*->scala::Tuple6.apply().*/number1/*->local2*/, + left/*->local0*/, + right/*->local1*/, + number1Var/*->local5*/, + leftVar/*->local3*/, + rightVar/*->local4*/ + ) + ) + } + } + +} diff --git a/tests/semanticdb/expect/ValPattern.scala b/tests/semanticdb/expect/ValPattern.scala new file mode 100644 index 000000000000..b4e4ea3363c1 --- /dev/null +++ b/tests/semanticdb/expect/ValPattern.scala @@ -0,0 +1,47 @@ +package example + +class ValPattern { + + val (left, right) = (1, 2) + val Some(number1) = + Some(1) + + val List(Some(q1), None: None.type, None) = ??? + + var (leftVar, rightVar) = (1, 2) + var Some(number1Var) = + Some(1) + + def app(): Unit = { + println( + ( + number1, + left, + right, + number1Var, + leftVar, + rightVar + ) + ) + locally { + val (left, right) = (1, 2) + val Some(number1) = + Some(1) + + var (leftVar, rightVar) = (1, 2) + var Some(number1Var) = + Some(1) + println( + ( + number1, + left, + right, + number1Var, + leftVar, + rightVar + ) + ) + } + } + +} diff --git a/tests/semanticdb/expect/Vals.expect.scala b/tests/semanticdb/expect/Vals.expect.scala new file mode 100644 index 000000000000..d3c865665813 --- /dev/null +++ b/tests/semanticdb/expect/Vals.expect.scala @@ -0,0 +1,51 @@ +package example + +abstract class Vals/*<-example::Vals#*/(p/*<-example::Vals#p.*/: Int/*->scala::Int#*/, val xp/*<-example::Vals#xp.*/: Int/*->scala::Int#*/, var yp/*<-example::Vals#yp().*/: Int/*->scala::Int#*/) { + val xm/*<-example::Vals#xm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + val xam/*<-example::Vals#xam.*/: Int/*->scala::Int#*/ + private[this] val xlm/*<-example::Vals#xlm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + lazy val xzm/*<-example::Vals#xzm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + private[this] lazy val xzlm/*<-example::Vals#xzlm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + final val xfm/*<-example::Vals#xfm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + implicit val xim/*<-example::Vals#xim.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + var ym/*<-example::Vals#ym().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + var yam/*<-example::Vals#yam().*/: Int/*->scala::Int#*/ + private[this] var ylm/*<-example::Vals#ylm().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + private[this] var _explicitSetter/*<-example::Vals#_explicitSetter().*/: Int/*->scala::Int#*/ = 0 + def explicitSetter/*<-example::Vals#explicitSetter().*/ = _explicitSetter/*->example::Vals#_explicitSetter().*/ + def explicitSetter_=/*<-example::Vals#`explicitSetter_=`().*/(x/*<-example::Vals#`explicitSetter_=`().(x)*/: Int/*->scala::Int#*/): Unit/*->scala::Unit#*/ = _explicitSetter/*->example::Vals#_explicitSetter().*/ = x/*->example::Vals#`explicitSetter_=`().(x)*/ + // NOTE: lazy not allowed here. Only vals can be lazy + // lazy var xzm: Int = ??? + // private[this] lazy var yzlm: Int = ??? + final var yfm/*<-example::Vals#yfm().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + implicit var yim/*<-example::Vals#yim().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m/*<-example::Vals#m().*/ = { + val xl/*<-local0*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + lazy val xzl/*<-local1*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + // NOTE: local values cannot be final + // final val xfl: Int = ??? + implicit val xil/*<-local2*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + var yl/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + // NOTE: lazy not allowed here. Only vals can be lazy + // lazy var yzl: Int = ??? + // NOTE: local variables cannot be final + // final var yfl: Int = ??? + implicit var yil/*<-local4*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + yl/*->local3*/ = xl/*->local0*/ +/*->scala::Int#`+`(+4).*/ yl/*->local3*/ + println/*->scala::Predef.println(+1).*/(xzl/*->local1*/) + yil/*->local4*/ = xil/*->local2*/ +/*->scala::Int#`+`(+4).*/ yil/*->local4*/ + } + println/*->scala::Predef.println(+1).*/(xzlm/*->example::Vals#xzlm.*/) + ylm/*->example::Vals#ylm().*/ = xlm/*->example::Vals#xlm.*/ +/*->scala::Int#`+`(+4).*/ ylm/*->example::Vals#ylm().*/ +} + +object ValUsages/*<-example::ValUsages.*/ { + val v/*<-example::ValUsages.v.*/: Vals/*->example::Vals#*/ = ???/*->scala::Predef.`???`().*/ + v/*->example::ValUsages.v.*/.yp/*->example::Vals#`yp_=`().*/ = v/*->example::ValUsages.v.*/.xp/*->example::Vals#xp.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yp/*->example::Vals#yp().*/ + v/*->example::ValUsages.v.*/.ym/*->example::Vals#`ym_=`().*/ = v/*->example::ValUsages.v.*/.xm/*->example::Vals#xm.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.ym/*->example::Vals#ym().*/ + v/*->example::ValUsages.v.*/.yam/*->example::Vals#`yam_=`().*/ = v/*->example::ValUsages.v.*/.xam/*->example::Vals#xam.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yam/*->example::Vals#yam().*/ + println/*->scala::Predef.println(+1).*/(v/*->example::ValUsages.v.*/.xzm/*->example::Vals#xzm.*/) + v/*->example::ValUsages.v.*/.yfm/*->example::Vals#`yfm_=`().*/ = v/*->example::ValUsages.v.*/.xfm/*->example::Vals#xfm.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yfm/*->example::Vals#yfm().*/ + v/*->example::ValUsages.v.*/.yim/*->example::Vals#`yim_=`().*/ = v/*->example::ValUsages.v.*/.xim/*->example::Vals#xim.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yim/*->example::Vals#yim().*/ + v/*->example::ValUsages.v.*/.explicitSetter/*->example::Vals#`explicitSetter_=`().*/ = 25 +} diff --git a/tests/semanticdb/expect/Vals.scala b/tests/semanticdb/expect/Vals.scala new file mode 100644 index 000000000000..2ea132729bb0 --- /dev/null +++ b/tests/semanticdb/expect/Vals.scala @@ -0,0 +1,51 @@ +package example + +abstract class Vals(p: Int, val xp: Int, var yp: Int) { + val xm: Int = ??? + val xam: Int + private[this] val xlm: Int = ??? + lazy val xzm: Int = ??? + private[this] lazy val xzlm: Int = ??? + final val xfm: Int = ??? + implicit val xim: Int = ??? + var ym: Int = ??? + var yam: Int + private[this] var ylm: Int = ??? + private[this] var _explicitSetter: Int = 0 + def explicitSetter = _explicitSetter + def explicitSetter_=(x: Int): Unit = _explicitSetter = x + // NOTE: lazy not allowed here. Only vals can be lazy + // lazy var xzm: Int = ??? + // private[this] lazy var yzlm: Int = ??? + final var yfm: Int = ??? + implicit var yim: Int = ??? + def m = { + val xl: Int = ??? + lazy val xzl: Int = ??? + // NOTE: local values cannot be final + // final val xfl: Int = ??? + implicit val xil: Int = ??? + var yl: Int = ??? + // NOTE: lazy not allowed here. Only vals can be lazy + // lazy var yzl: Int = ??? + // NOTE: local variables cannot be final + // final var yfl: Int = ??? + implicit var yil: Int = ??? + yl = xl + yl + println(xzl) + yil = xil + yil + } + println(xzlm) + ylm = xlm + ylm +} + +object ValUsages { + val v: Vals = ??? + v.yp = v.xp + v.yp + v.ym = v.xm + v.ym + v.yam = v.xam + v.yam + println(v.xzm) + v.yfm = v.xfm + v.yfm + v.yim = v.xim + v.yim + v.explicitSetter = 25 +} diff --git a/tests/semanticdb/expect/Vararg.expect.scala b/tests/semanticdb/expect/Vararg.expect.scala new file mode 100644 index 000000000000..5b82e2f16f25 --- /dev/null +++ b/tests/semanticdb/expect/Vararg.expect.scala @@ -0,0 +1,6 @@ +package example + +class Vararg/*<-example::Vararg#*/ { + def add1/*<-example::Vararg#add1().*/(a/*<-example::Vararg#add1().(a)*/: Int/*->scala::Int#*/*) = {} + def add2/*<-example::Vararg#add2().*/(a/*<-example::Vararg#add2().(a)*/: Seq/*->scala::package.Seq#*/[Int/*->scala::Int#*/]*): Unit/*->scala::Unit#*/ = {} +} diff --git a/tests/semanticdb/expect/Vararg.scala b/tests/semanticdb/expect/Vararg.scala new file mode 100644 index 000000000000..8500289f0d5a --- /dev/null +++ b/tests/semanticdb/expect/Vararg.scala @@ -0,0 +1,6 @@ +package example + +class Vararg { + def add1(a: Int*) = {} + def add2(a: Seq[Int]*): Unit = {} +} diff --git a/tests/semanticdb/expect/filename with spaces.expect.scala b/tests/semanticdb/expect/filename with spaces.expect.scala new file mode 100644 index 000000000000..29a4e899ca31 --- /dev/null +++ b/tests/semanticdb/expect/filename with spaces.expect.scala @@ -0,0 +1,3 @@ +package example + +class FilenameWithSpaces/*<-example::FilenameWithSpaces#*/ diff --git a/tests/semanticdb/expect/filename with spaces.scala b/tests/semanticdb/expect/filename with spaces.scala new file mode 100644 index 000000000000..b7f79c3ecac2 --- /dev/null +++ b/tests/semanticdb/expect/filename with spaces.scala @@ -0,0 +1,3 @@ +package example + +class FilenameWithSpaces diff --git a/tests/semanticdb/expect/local-file.expect.scala b/tests/semanticdb/expect/local-file.expect.scala new file mode 100644 index 000000000000..aa2842dcee28 --- /dev/null +++ b/tests/semanticdb/expect/local-file.expect.scala @@ -0,0 +1,8 @@ +package example + +class `local-file/*<-example::`local-file`#*/` { + locally/*->dotty::DottyPredef.locally().*/ { + val local/*<-local0*/ = 42 + local/*->local0*/ +/*->scala::Int#`+`(+4).*/ 4 + } +} diff --git a/tests/semanticdb/expect/local-file.scala b/tests/semanticdb/expect/local-file.scala new file mode 100644 index 000000000000..ea699bdfff57 --- /dev/null +++ b/tests/semanticdb/expect/local-file.scala @@ -0,0 +1,8 @@ +package example + +class `local-file` { + locally { + val local = 42 + local + 4 + } +} diff --git a/tests/semanticdb/expect/semanticdb-extract.expect.scala b/tests/semanticdb/expect/semanticdb-extract.expect.scala new file mode 100644 index 000000000000..02bd562a718b --- /dev/null +++ b/tests/semanticdb/expect/semanticdb-extract.expect.scala @@ -0,0 +1,18 @@ +object AnObject/*<-_empty_::AnObject.*/ { + + def foo/*<-_empty_::AnObject.foo().*/(x/*<-_empty_::AnObject.foo().(x)*/: Int/*->scala::Int#*/) = () + def foo/*<-_empty_::AnObject.foo(+1).*/(): Unit/*->scala::Unit#*/ = () + + foo/*->_empty_::AnObject.foo().*/(1) + foo/*->_empty_::AnObject.foo(+1).*/() + + "".substring/*->java::lang::String#substring().*/(1) + "".substring/*->java::lang::String#substring(+1).*/(1, 2) + + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1, 2) + List/*->scala::package.List.*/.apply/*->scala::collection::IterableFactory#apply().*/() + List/*->scala::package.List.*/.`apply`/*->scala::collection::IterableFactory#apply().*/() + println/*->scala::Predef.println(+1).*/(1 +/*->scala::Int#`+`(+4).*/ 2) + + case class Foo/*<-_empty_::AnObject.Foo#*/(x/*<-_empty_::AnObject.Foo#x.*/: Int/*->scala::Int#*/) +} diff --git a/tests/semanticdb/expect/semanticdb-extract.scala b/tests/semanticdb/expect/semanticdb-extract.scala new file mode 100644 index 000000000000..6293c97845be --- /dev/null +++ b/tests/semanticdb/expect/semanticdb-extract.scala @@ -0,0 +1,18 @@ +object AnObject { + + def foo(x: Int) = () + def foo(): Unit = () + + foo(1) + foo() + + "".substring(1) + "".substring(1, 2) + + List(1, 2) + List.apply() + List.`apply`() + println(1 + 2) + + case class Foo(x: Int) +} diff --git a/tests/semanticdb/expect/toplevel.expect.scala b/tests/semanticdb/expect/toplevel.expect.scala new file mode 100644 index 000000000000..b61e882fef36 --- /dev/null +++ b/tests/semanticdb/expect/toplevel.expect.scala @@ -0,0 +1,5 @@ +inline val a = "/*<-_empty_::toplevel$package.*//*<-_empty_::toplevel$package.a.*/" +def (x: Int/*<-_empty_::toplevel$package.combine().*//*<-_empty_::toplevel$package.combine().(x)*//*->scala::Int#*/) combine (y/*<-_empty_::toplevel$package.combine().(y)*/: Int/*->scala::Int#*/) = x/*->_empty_::toplevel$package.combine().(x)*/ +/*->scala::Int#`+`(+4).*/ y/*->_empty_::toplevel$package.combine().(y)*/ +def combine/*<-_empty_::toplevel$package.combine(+1).*/(x/*<-_empty_::toplevel$package.combine(+1).(x)*/: Int/*->scala::Int#*/, y/*<-_empty_::toplevel$package.combine(+1).(y)*/: Int/*->scala::Int#*/, z/*<-_empty_::toplevel$package.combine(+1).(z)*/: Int/*->scala::Int#*/) = x/*->_empty_::toplevel$package.combine(+1).(x)*/ +/*->scala::Int#`+`(+4).*/ y/*->_empty_::toplevel$package.combine(+1).(y)*/ +/*->scala::Int#`+`(+4).*/ z/*->_empty_::toplevel$package.combine(+1).(z)*/ +def combine/*<-_empty_::toplevel$package.combine(+2).*/ = 0 +def foo/*<-_empty_::toplevel$package.foo().*/ = "foo" diff --git a/tests/semanticdb/expect/toplevel.scala b/tests/semanticdb/expect/toplevel.scala new file mode 100644 index 000000000000..37ff0172e2aa --- /dev/null +++ b/tests/semanticdb/expect/toplevel.scala @@ -0,0 +1,5 @@ +inline val a = "" +def (x: Int) combine (y: Int) = x + y +def combine(x: Int, y: Int, z: Int) = x + y + z +def combine = 0 +def foo = "foo" diff --git a/tests/semanticdb/javacp/com/javacp/ClassSuffix.java b/tests/semanticdb/javacp/com/javacp/ClassSuffix.java new file mode 100644 index 000000000000..7204ec09f77a --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/ClassSuffix.java @@ -0,0 +1,10 @@ +package com.javacp; + +public class ClassSuffix { + class Inner { + class Bar { + class Fuz {} + } + } + public ClassSuffix.Inner.Bar.Fuz suffix; +} diff --git a/tests/semanticdb/javacp/com/javacp/Coin.java b/tests/semanticdb/javacp/com/javacp/Coin.java new file mode 100644 index 000000000000..b66009fd773a --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/Coin.java @@ -0,0 +1,9 @@ +package com.javacp; + +public enum Coin { + PENNY(1), NICKEL(5), DIME(10), QUARTER(25); + Coin(int value) { this.value = value; } + + private final int value; + public int value() { return value; } +} diff --git a/tests/semanticdb/javacp/com/javacp/Interface.java b/tests/semanticdb/javacp/com/javacp/Interface.java new file mode 100644 index 000000000000..a85b4b795485 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/Interface.java @@ -0,0 +1,7 @@ +package com.javacp; + +public interface Interface { + void a(); + default void d() {} + static void s() {} +} diff --git a/tests/semanticdb/javacp/com/javacp/Logger.java b/tests/semanticdb/javacp/com/javacp/Logger.java new file mode 100644 index 000000000000..6fc9c2525ec7 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/Logger.java @@ -0,0 +1,4 @@ +package com.javacp; + +public class Logger { +} diff --git a/tests/semanticdb/javacp/com/javacp/MetacJava.java b/tests/semanticdb/javacp/com/javacp/MetacJava.java new file mode 100644 index 000000000000..61d86af5117c --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/MetacJava.java @@ -0,0 +1,21 @@ +package com.javacp; + +public class MetacJava { + public static class StaticInner { + public void isNotStatic() {} + public static void isStatic() {} + public class NonStatic { + public void method(NonStatic e) {} + } + } + public class Overload1 { public class A {} } + public static class Overload3 { + public static class A {} + } + public class Overload2 { public class A {} } + public void overload(Overload1.A a) {} + // NOTE: Overload3 is intentionally placed before Overload2 in order to test + // that methods are sorted by whether they're static or not. + public static void overload(Overload3.A a) {} + public void overload(Overload2.A a) {} +} diff --git a/tests/semanticdb/javacp/com/javacp/NonGeneric.java b/tests/semanticdb/javacp/com/javacp/NonGeneric.java new file mode 100644 index 000000000000..78a1ac223e28 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/NonGeneric.java @@ -0,0 +1,9 @@ +package com.javacp; + +import java.io.IOException; +import java.io.Serializable; + +public class NonGeneric extends java.lang.Exception implements Serializable, java.io.Flushable { + @Override + public void flush() throws IOException { } +} diff --git a/tests/semanticdb/javacp/com/javacp/Recursive.java b/tests/semanticdb/javacp/com/javacp/Recursive.java new file mode 100644 index 000000000000..62c749c63ded --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/Recursive.java @@ -0,0 +1,26 @@ +package com.javacp; + +import java.io.Serializable; +import java.util.ArrayList; + +public abstract class Recursive< + A extends Recursive & Serializable, + B extends Recursive.Inner> { + + public abstract static class Inner< + A extends Recursive & Serializable, + B extends Inner> { + } + + public abstract class Inner2> {} + + public ArrayList foo() { + return new ArrayList() { + @Override + public boolean remove(Object o) { + return true; + } + }; + } + +} diff --git a/tests/semanticdb/javacp/com/javacp/Test.java b/tests/semanticdb/javacp/com/javacp/Test.java new file mode 100644 index 000000000000..2ce00f3531e3 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/Test.java @@ -0,0 +1,83 @@ +package com.javacp; + +import javax.naming.Context; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Hashtable; + +public final class Test extends ArrayList implements Comparable, Serializable { + + @Override + public final int compareTo(B b) { + return 0; + } + + public void wildcard(ArrayList wildcard) {} + public void wildcard(Collection a, Collection b) {} + + class InnerShadowTypeParam { + public void move(A a, B b) { } + } + + ArrayList genericField; + final int[] arrayField = null; + + ArrayList genericMethod() { + return null; + } + int[] arrayMethod() { + return new int[0]; + } + void genericParams(A a, B b) { } + void primitiveParams(int a, long b, float c, double d, short e, byte f, boolean g, char h) { } + void typeParams(ArrayList> a, Hashtable b) { } + void methodTypeParams(C c) { } + + public void overload(java.util.logging.Logger a) { } + public void overload(Logger a) { } + + // primitive fields + public int Int; + public long Long; + public float Float; + public short Short; + public byte Byte; + public boolean Boolean; + public char Char; + + + private int privateField; + protected int protectedField; + public int publicField; + int packagePrivateField; + + private void privateMethod() { } + protected void protectedMethod() { } + public void publicMethod() { } + void packagePrivateMethod() { } + + public Serializable anonymous = new Serializable() { }; + + static int staticField; + static void staticMethod() {} + static class StaticClass {} + + void vararg(int a, String... args) {} + + strictfp void strictfpMethod() {} + + void m1() {} + void m2() {} + void m3() {} +} + +interface X { +} + +interface Y { +} + +interface Z { +} diff --git a/tests/semanticdb/javacp/com/javacp/annot/ClassAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/ClassAnnotation.java new file mode 100644 index 000000000000..4d676ab287f3 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/ClassAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface ClassAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/ConstructorAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/ConstructorAnnotation.java new file mode 100644 index 000000000000..454e66d4098c --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/ConstructorAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.CONSTRUCTOR) +public @interface ConstructorAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/FieldAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/FieldAnnotation.java new file mode 100644 index 000000000000..d86048627786 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/FieldAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.FIELD) +public @interface FieldAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/InterfaceAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/InterfaceAnnotation.java new file mode 100644 index 000000000000..a4b76a917588 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/InterfaceAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface InterfaceAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/LocalAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/LocalAnnotation.java new file mode 100644 index 000000000000..833661dc6e0b --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/LocalAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.LOCAL_VARIABLE) +public @interface LocalAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/MacroAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/MacroAnnotation.java new file mode 100644 index 000000000000..e82c63e3f49e --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/MacroAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.METHOD) +public @interface MacroAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/MethodAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/MethodAnnotation.java new file mode 100644 index 000000000000..37ab7a2655ea --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/MethodAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.METHOD) +public @interface MethodAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/ObjectAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/ObjectAnnotation.java new file mode 100644 index 000000000000..ae7cfe8f64ef --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/ObjectAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface ObjectAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/PackageAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/PackageAnnotation.java new file mode 100644 index 000000000000..ec51d2e89e83 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/PackageAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.PACKAGE) +public @interface PackageAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/PackageObjectAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/PackageObjectAnnotation.java new file mode 100644 index 000000000000..50eedab9ed64 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/PackageObjectAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.PACKAGE) +public @interface PackageObjectAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/ParameterAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/ParameterAnnotation.java new file mode 100644 index 000000000000..9ccbdf682fe5 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/ParameterAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.PARAMETER) +public @interface ParameterAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/SelfParameterAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/SelfParameterAnnotation.java new file mode 100644 index 000000000000..e2446aebb22c --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/SelfParameterAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.PARAMETER) +public @interface SelfParameterAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/TraitAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/TraitAnnotation.java new file mode 100644 index 000000000000..9cccb6293489 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/TraitAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface TraitAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/TypeAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/TypeAnnotation.java new file mode 100644 index 000000000000..d3770564771b --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/TypeAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface TypeAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/TypeParameterAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/TypeParameterAnnotation.java new file mode 100644 index 000000000000..05f7af7198fd --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/TypeParameterAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE_PARAMETER) +public @interface TypeParameterAnnotation{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedInterface.java b/tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedInterface.java new file mode 100644 index 000000000000..0f161ae588e8 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedInterface.java @@ -0,0 +1,4 @@ +package com.javacp.annot.usage; + +@com.javacp.annot.InterfaceAnnotation +public @interface AnnotatedInterface{} diff --git a/tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedPackage.java b/tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedPackage.java new file mode 100644 index 000000000000..c3473d17e878 --- /dev/null +++ b/tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedPackage.java @@ -0,0 +1,5 @@ +// compiler crash +// @annot.ParameterAnnotation +package com.javacp.annot.usage; + +public class AnnotatedPackage{} diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect new file mode 100644 index 000000000000..23fce826a326 --- /dev/null +++ b/tests/semanticdb/metac.expect @@ -0,0 +1,3567 @@ +expect/Access.scala +------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Access.scala +Text => empty +Language => Scala +Symbols => 9 entries +Occurrences => 19 entries + +Symbols: +example/Access# => class Access +example/Access#``(). => primary ctor +example/Access#m1(). => method m1 +example/Access#m2(). => method m2 +example/Access#m3(). => method m3 +example/Access#m4(). => method m4 +example/Access#m5(). => method m5 +example/Access#m6(). => method m6 +example/Access#m7(). => method m7 + +Occurrences: +[0:8..0:15): example <- example/ +[2:6..2:12): Access <- example/Access# +[3:2..3:2): <- example/Access#``(). +[3:14..3:16): m1 <- example/Access#m1(). +[3:19..3:22): ??? -> scala/Predef.`???`(). +[4:20..4:22): m2 <- example/Access#m2(). +[4:25..4:28): ??? -> scala/Predef.`???`(). +[5:10..5:16): Access -> example/Access# +[5:22..5:24): m3 <- example/Access#m3(). +[5:27..5:30): ??? -> scala/Predef.`???`(). +[6:16..6:18): m4 <- example/Access#m4(). +[6:21..6:24): ??? -> scala/Predef.`???`(). +[7:22..7:24): m5 <- example/Access#m5(). +[7:27..7:30): ??? -> scala/Predef.`???`(). +[8:12..8:19): example -> example/ +[8:25..8:27): m6 <- example/Access#m6(). +[8:30..8:33): ??? -> scala/Predef.`???`(). +[9:6..9:8): m7 <- example/Access#m7(). +[9:11..9:14): ??? -> scala/Predef.`???`(). + +expect/Advanced.scala +--------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Advanced.scala +Text => empty +Language => Scala +Symbols => 34 entries +Occurrences => 92 entries + +Symbols: +advanced/C# => class C +advanced/C#[T] => typeparam T +advanced/C#``(). => primary ctor +advanced/C#t(). => method t +advanced/Structural# => class Structural +advanced/Structural#``(). => primary ctor +advanced/Structural#s1(). => method s1 +advanced/Structural#s2(). => method s2 +advanced/Structural#s3(). => method s3 +advanced/Test. => final object Test +advanced/Test.e. => val method e +advanced/Test.e1. => val method e1 +advanced/Test.e1x. => val method e1x +advanced/Test.s. => val method s +advanced/Test.s1. => val method s1 +advanced/Test.s1x. => val method s1x +advanced/Test.s2. => val method s2 +advanced/Test.s2x. => val method s2x +advanced/Test.s3. => val method s3 +advanced/Test.s3x. => val method s3x +advanced/Wildcards# => class Wildcards +advanced/Wildcards#``(). => primary ctor +advanced/Wildcards#e1(). => method e1 +local0 => abstract val method x +local1 => abstract val method x +local2 => final class $anon +local3 => val method x +local4 => abstract method m +local5 => param x +local6 => final class $anon +local7 => method m +local8 => param x +local9 => val local e3 +local10 => val local e3x + +Occurrences: +[0:8..0:16): advanced <- advanced/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:33): higherKinds -> scalaShadowing/language.higherKinds. +[3:7..3:12): scala -> scala/ +[3:13..3:21): language -> scalaShadowing/language. +[3:22..3:37): reflectiveCalls -> scalaShadowing/language.reflectiveCalls. +[5:7..5:12): scala -> scala/ +[5:13..5:20): reflect -> scala/reflect/ +[5:21..5:31): Selectable -> scala/reflect/Selectable. +[5:32..5:52): reflectiveSelectable -> scala/reflect/Selectable.reflectiveSelectable(). +[7:6..7:7): C <- advanced/C# +[7:7..7:10): <- advanced/C#``(). +[7:8..7:9): T <- advanced/C#[T] +[8:6..8:7): t <- advanced/C#t(). +[8:9..8:10): T -> advanced/C#[T] +[8:13..8:16): ??? -> scala/Predef.`???`(). +[11:6..11:16): Structural <- advanced/Structural# +[12:2..12:2): <- advanced/Structural#``(). +[12:6..12:8): s1 <- advanced/Structural#s1(). +[12:16..12:17): x <- local0 +[12:19..12:22): Int -> scala/Int# +[12:27..12:30): ??? -> scala/Predef.`???`(). +[13:6..13:8): s2 <- advanced/Structural#s2(). +[13:16..13:17): x <- local1 +[13:19..13:22): Int -> scala/Int# +[13:37..13:38): x <- local3 +[13:40..13:43): Int -> scala/Int# +[13:46..13:49): ??? -> scala/Predef.`???`(). +[14:6..14:8): s3 <- advanced/Structural#s3(). +[14:16..14:17): m <- local4 +[14:18..14:19): x <- local5 +[14:21..14:24): Int -> scala/Int# +[14:27..14:30): Int -> scala/Int# +[14:45..14:46): m <- local7 +[14:47..14:48): x <- local8 +[14:50..14:53): Int -> scala/Int# +[14:56..14:59): Int -> scala/Int# +[14:62..14:65): ??? -> scala/Predef.`???`(). +[17:6..17:15): Wildcards <- advanced/Wildcards# +[18:2..18:2): <- advanced/Wildcards#``(). +[18:6..18:8): e1 <- advanced/Wildcards#e1(). +[18:10..18:14): List -> scala/package.List# +[18:20..18:23): ??? -> scala/Predef.`???`(). +[21:7..21:11): Test <- advanced/Test. +[22:6..22:7): s <- advanced/Test.s. +[22:14..22:24): Structural -> advanced/Structural# +[22:24..22:24): -> advanced/Structural#``(). +[23:6..23:8): s1 <- advanced/Test.s1. +[23:11..23:12): s -> advanced/Test.s. +[23:13..23:15): s1 -> advanced/Structural#s1(). +[24:6..24:9): s1x <- advanced/Test.s1x. +[24:12..24:12): -> scala/reflect/Selectable.reflectiveSelectable(). +[24:12..24:13): s -> advanced/Test.s. +[24:14..24:16): s1 -> advanced/Structural#s1(). +[24:16..24:16): -> scala/Selectable#selectDynamic(). +[25:6..25:8): s2 <- advanced/Test.s2. +[25:11..25:12): s -> advanced/Test.s. +[25:13..25:15): s2 -> advanced/Structural#s2(). +[26:6..26:9): s2x <- advanced/Test.s2x. +[26:12..26:12): -> scala/reflect/Selectable.reflectiveSelectable(). +[26:12..26:13): s -> advanced/Test.s. +[26:14..26:16): s2 -> advanced/Structural#s2(). +[26:16..26:16): -> scala/Selectable#selectDynamic(). +[27:6..27:8): s3 <- advanced/Test.s3. +[27:11..27:12): s -> advanced/Test.s. +[27:13..27:15): s3 -> advanced/Structural#s3(). +[28:6..28:9): s3x <- advanced/Test.s3x. +[28:12..28:12): -> scala/reflect/Selectable.reflectiveSelectable(). +[28:12..28:13): s -> advanced/Test.s. +[28:14..28:16): s3 -> advanced/Structural#s3(). +[28:16..28:16): -> scala/Selectable#applyDynamic(). +[28:18..28:18): -> scala/reflect/ClassTag.apply(). +[28:18..28:18): -> java/lang/Integer#TYPE. +[28:19..28:22): ??? -> scala/Predef.`???`(). +[30:6..30:7): e <- advanced/Test.e. +[30:14..30:23): Wildcards -> advanced/Wildcards# +[30:23..30:23): -> advanced/Wildcards#``(). +[31:6..31:8): e1 <- advanced/Test.e1. +[31:11..31:12): e -> advanced/Test.e. +[31:13..31:15): e1 -> advanced/Wildcards#e1(). +[32:6..32:9): e1x <- advanced/Test.e1x. +[32:12..32:13): e -> advanced/Test.e. +[32:14..32:16): e1 -> advanced/Wildcards#e1(). +[32:17..32:21): head -> scala/collection/IterableOps#head(). +[35:5..35:8): ??? -> scala/Predef.`???`(). +[35:11..35:14): Any -> scala/Any# +[36:11..36:13): e3 <- local9 +[36:15..36:19): List -> scala/package.List# +[37:12..37:15): e3x <- local10 +[37:18..37:20): e3 -> local9 +[37:21..37:25): head -> scala/collection/IterableOps#head(). + +expect/Annotations.scala +------------------------ + +Summary: +Schema => SemanticDB v4 +Uri => Annotations.scala +Text => empty +Language => Scala +Symbols => 22 entries +Occurrences => 52 entries + +Symbols: +annot/Alias. => final object Alias +annot/Alias.A# => type A +annot/Annotations# => class Annotations +annot/Annotations#S# => type S +annot/Annotations#[T] => typeparam T +annot/Annotations#``(). => primary ctor +annot/Annotations#``().(x) => param x +annot/Annotations#field. => val method field +annot/Annotations#method(). => method method +annot/Annotations#x. => val method x +annot/B# => class B +annot/B#``(). => primary ctor +annot/B#``().(x) => param x +annot/B#``(+1). => ctor +annot/B#x. => val method x +annot/M. => final object M +annot/M.m(). => method m +annot/M.m().[TT] => typeparam TT +annot/T# => trait T +annot/T#``(). => primary ctor +local0 => selfparam self +local1 => val local local + +Occurrences: +[0:8..0:13): annot <- annot/ +[2:7..2:10): com -> com/ +[2:11..2:17): javacp -> com/javacp/ +[2:18..2:23): annot -> com/javacp/annot/ +[3:7..3:12): scala -> scala/ +[3:13..3:23): annotation -> scala/annotation/ +[3:24..3:28): meta -> scala/annotation/meta/ +[4:7..4:12): scala -> scala/ +[4:13..4:21): language -> scalaShadowing/language. +[4:22..4:34): experimental -> scalaShadowing/language.experimental. +[4:35..4:41): macros -> scalaShadowing/language.experimental.macros. +[6:1..6:16): ClassAnnotation -> com/javacp/annot/ClassAnnotation# +[7:6..7:17): Annotations <- annot/Annotations# +[7:17..7:72): <- annot/Annotations#``(). +[7:19..7:42): TypeParameterAnnotation -> com/javacp/annot/TypeParameterAnnotation# +[7:43..7:44): T <- annot/Annotations#[T] +[7:47..7:66): ParameterAnnotation -> com/javacp/annot/ParameterAnnotation# +[7:67..7:68): x <- annot/Annotations#x. +[7:70..7:71): T -> annot/Annotations#[T] +[7:75..7:79): self <- local0 +[7:81..7:87): AnyRef -> scala/AnyRef# +[8:3..8:18): FieldAnnotation -> com/javacp/annot/FieldAnnotation# +[9:6..9:11): field <- annot/Annotations#field. +[11:3..11:19): MethodAnnotation -> com/javacp/annot/MethodAnnotation# +[12:6..12:12): method <- annot/Annotations#method(). +[13:5..13:20): LocalAnnotation -> com/javacp/annot/LocalAnnotation# +[14:8..14:13): local <- local1 +[15:4..15:9): local -> local1 +[17:3..17:17): TypeAnnotation -> com/javacp/annot/TypeAnnotation# +[18:7..18:8): S <- annot/Annotations#S# +[21:6..21:7): B <- annot/B# +[21:7..21:40): <- annot/B#``(). +[21:9..21:30): ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# +[21:33..21:34): x <- annot/B#x. +[21:36..21:39): Int -> scala/Int# +[22:3..22:24): ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# +[23:6..23:12): <- annot/B#``(+1). +[23:20..23:20): -> annot/B#``(). +[26:1..26:17): ObjectAnnotation -> com/javacp/annot/ObjectAnnotation# +[27:7..27:8): M <- annot/M. +[28:3..28:18): MacroAnnotation -> com/javacp/annot/MacroAnnotation# +[29:6..29:7): m <- annot/M.m(). +[29:8..29:10): TT <- annot/M.m().[TT] +[29:13..29:16): Int -> scala/Int# +[29:16..29:16): -> scala/Predef.`???`(). +[32:0..32:0): <- annot/T#``(). +[32:1..32:16): TraitAnnotation -> com/javacp/annot/TraitAnnotation# +[33:6..33:7): T <- annot/T# +[35:7..35:12): Alias <- annot/Alias. +[36:7..36:8): A <- annot/Alias.A# +[36:11..36:26): ClassAnnotation -> com/javacp/annot/ClassAnnotation# +[36:28..36:33): param -> scala/annotation/meta/param# + +expect/Anonymous.scala +---------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Anonymous.scala +Text => empty +Language => Scala +Symbols => 13 entries +Occurrences => 32 entries + +Symbols: +example/Anonymous# => class Anonymous +example/Anonymous#Foo# => trait Foo +example/Anonymous#Foo#``(). => primary ctor +example/Anonymous#``(). => primary ctor +example/Anonymous#foo. => val method foo +example/Anonymous#locally(). => method locally +example/Anonymous#locally().(x) => param x +example/Anonymous#locally().[A] => typeparam A +example/Anonymous#m1(). => method m1 +example/Anonymous#m1().[T] => typeparam T +example/Anonymous#m2(). => method m2 +local0 => val local x +local1 => final class $anon + +Occurrences: +[0:8..0:15): example <- example/ +[1:7..1:12): scala -> scala/ +[1:13..1:21): language -> scalaShadowing/language. +[1:22..1:33): higherKinds -> scalaShadowing/language.higherKinds. +[3:6..3:15): Anonymous <- example/Anonymous# +[4:2..4:2): <- example/Anonymous#``(). +[4:8..4:17): Anonymous -> example/Anonymous# +[6:6..6:13): locally <- example/Anonymous#locally(). +[6:14..6:15): A <- example/Anonymous#locally().[A] +[6:17..6:18): x <- example/Anonymous#locally().(x) +[6:20..6:21): A -> example/Anonymous#locally().[A] +[6:24..6:25): A -> example/Anonymous#locally().[A] +[6:28..6:29): x -> example/Anonymous#locally().(x) +[8:6..8:8): m1 <- example/Anonymous#m1(). +[8:9..8:10): T <- example/Anonymous#m1().[T] +[8:17..8:20): ??? -> scala/Predef.`???`(). +[9:6..9:8): m2 <- example/Anonymous#m2(). +[9:10..9:13): Map -> scala/Predef.Map# +[9:17..9:21): List -> scala/package.List# +[9:28..9:31): ??? -> scala/Predef.`???`(). +[10:2..10:9): locally -> example/Anonymous#locally(). +[11:4..11:7): ??? -> scala/Predef.`???`(). +[11:24..11:28): List -> scala/package.List# +[13:2..13:9): locally -> example/Anonymous#locally(). +[14:8..14:9): x <- local0 +[14:11..14:14): Int -> scala/Int# +[14:18..14:21): Int -> scala/Int# +[14:29..14:32): ??? -> scala/Predef.`???`(). +[17:2..17:2): <- example/Anonymous#Foo#``(). +[17:8..17:11): Foo <- example/Anonymous#Foo# +[18:6..18:9): foo <- example/Anonymous#foo. +[18:16..18:19): Foo -> example/Anonymous#Foo# + +expect/Classes.scala +-------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Classes.scala +Text => empty +Language => Scala +Symbols => 75 entries +Occurrences => 58 entries + +Symbols: +classes/C1# => final class C1 +classes/C1#``(). => primary ctor +classes/C1#``().(x1) => val param x1 +classes/C1#x1. => val method x1 +classes/C1. => final object C1 +classes/C2# => final class C2 +classes/C2#``(). => primary ctor +classes/C2#``().(x2) => val param x2 +classes/C2#x2. => val method x2 +classes/C2. => final object C2 +classes/C3# => case class C3 +classes/C3#_1(). => method _1 +classes/C3#``(). => primary ctor +classes/C3#``().(x) => val param x +classes/C3#copy$default$1(). => method copy$default$1 +classes/C3#copy(). => method copy +classes/C3#copy().(x) => param x +classes/C3#x. => val method x +classes/C3. => final object C3 +classes/C3.apply(). => method apply +classes/C3.apply().(x) => param x +classes/C3.unapply(). => method unapply +classes/C3.unapply().(x$1) => param x$1 +classes/C4# => case class C4 +classes/C4#_1(). => method _1 +classes/C4#``(). => primary ctor +classes/C4#``().(x) => val param x +classes/C4#copy$default$1(). => method copy$default$1 +classes/C4#copy(). => method copy +classes/C4#copy().(x) => param x +classes/C4#x. => val method x +classes/C4. => final object C4 +classes/C4.apply(). => method apply +classes/C4.apply().(x) => param x +classes/C4.unapply(). => method unapply +classes/C4.unapply().(x$1) => param x$1 +classes/C6# => case class C6 +classes/C6#_1(). => method _1 +classes/C6#``(). => primary ctor +classes/C6#``().(x) => param x +classes/C6#copy$default$1(). => method copy$default$1 +classes/C6#copy(). => method copy +classes/C6#copy().(x) => param x +classes/C6#x. => val method x +classes/C6. => final object C6 +classes/C6.apply(). => method apply +classes/C6.apply().(x) => param x +classes/C6.unapply(). => method unapply +classes/C6.unapply().(x$1) => param x$1 +classes/C7# => class C7 +classes/C7#``(). => primary ctor +classes/C7#``().(x) => param x +classes/C7#x. => val method x +classes/C8# => class C8 +classes/C8#``(). => primary ctor +classes/C8#``().(x) => param x +classes/C8#x. => val method x +classes/C9# => class C9 +classes/C9#``(). => primary ctor +classes/C9#``().(x) => param x +classes/C9#x(). => var method x +classes/M. => final object M +classes/M.C5# => class C5 +classes/M.C5#``(). => primary ctor +classes/M.C5#``().(x) => param x +classes/M.C5#x. => val method x +classes/M.C5(). => final implicit method C5 +classes/M.C5().(x) => param x +classes/N. => final object N +classes/N.anonClass. => val method anonClass +classes/N.anonFun. => val method anonFun +local0 => final class $anon +local1 => val method local +local2 => param i +local3 => val local local + +Occurrences: +[0:8..0:15): classes <- classes/ +[2:6..2:8): C1 <- classes/C1# +[2:8..2:21): <- classes/C1#``(). +[2:13..2:15): x1 <- classes/C1#x1. +[2:17..2:20): Int -> scala/Int# +[2:30..2:36): AnyVal -> scala/AnyVal# +[2:36..2:36): -> scala/AnyVal#``(). +[4:6..4:8): C2 <- classes/C2# +[4:8..4:21): <- classes/C2#``(). +[4:13..4:15): x2 <- classes/C2#x2. +[4:17..4:20): Int -> scala/Int# +[4:30..4:36): AnyVal -> scala/AnyVal# +[4:36..4:36): -> scala/AnyVal#``(). +[5:7..5:9): C2 <- classes/C2. +[7:11..7:13): C3 <- classes/C3# +[7:13..7:21): <- classes/C3#``(). +[7:14..7:15): x <- classes/C3#x. +[7:17..7:20): Int -> scala/Int# +[9:11..9:13): C4 <- classes/C4# +[9:13..9:21): <- classes/C4#``(). +[9:14..9:15): x <- classes/C4#x. +[9:17..9:20): Int -> scala/Int# +[10:7..10:9): C4 <- classes/C4. +[12:7..12:8): M <- classes/M. +[13:17..13:19): C5 <- classes/M.C5# +[13:19..13:27): <- classes/M.C5#``(). +[13:20..13:21): x <- classes/M.C5#x. +[13:23..13:26): Int -> scala/Int# +[16:11..16:13): C6 <- classes/C6# +[16:13..16:33): <- classes/C6#``(). +[16:26..16:27): x <- classes/C6#x. +[16:29..16:32): Int -> scala/Int# +[18:6..18:8): C7 <- classes/C7# +[18:8..18:16): <- classes/C7#``(). +[18:9..18:10): x <- classes/C7#x. +[18:12..18:15): Int -> scala/Int# +[20:6..20:8): C8 <- classes/C8# +[20:8..20:34): <- classes/C8#``(). +[20:27..20:28): x <- classes/C8#x. +[20:30..20:33): Int -> scala/Int# +[22:6..22:8): C9 <- classes/C9# +[22:8..22:34): <- classes/C9#``(). +[22:27..22:28): x <- classes/C9#x(). +[22:30..22:33): Int -> scala/Int# +[24:7..24:8): N <- classes/N. +[25:6..25:15): anonClass <- classes/N.anonClass. +[25:22..25:24): C7 -> classes/C7# +[25:24..25:24): -> classes/C7#``(). +[26:8..26:13): local <- local1 +[26:16..26:19): ??? -> scala/Predef.`???`(). +[28:6..28:13): anonFun <- classes/N.anonFun. +[28:16..28:20): List -> scala/package.List. +[28:20..28:20): -> scala/collection/IterableFactory#apply(). +[28:24..28:27): map -> scala/collection/immutable/List#map(). +[28:30..28:31): i <- local2 +[29:8..29:13): local <- local3 +[30:4..30:9): local -> local3 +[30:10..30:11): + -> scala/Int#`+`(+4). + +expect/Definitions.scala +------------------------ + +Summary: +Schema => SemanticDB v4 +Uri => Definitions.scala +Text => empty +Language => Scala +Symbols => 10 entries +Occurrences => 9 entries + +Symbols: +a/Definitions. => final object Definitions +a/Definitions.D# => class D +a/Definitions.D#``(). => primary ctor +a/Definitions.E# => trait E +a/Definitions.E#``(). => primary ctor +a/Definitions.`b_=`(). => var method b_= +a/Definitions.`b_=`().(x$1) => param x$1 +a/Definitions.a. => val method a +a/Definitions.b(). => var method b +a/Definitions.c(). => method c + +Occurrences: +[0:8..0:9): a <- a/ +[1:7..1:18): Definitions <- a/Definitions. +[2:6..2:7): a <- a/Definitions.a. +[3:6..3:7): b <- a/Definitions.b(). +[4:6..4:7): c <- a/Definitions.c(). +[5:2..5:2): <- a/Definitions.D#``(). +[5:8..5:9): D <- a/Definitions.D# +[6:2..6:2): <- a/Definitions.E#``(). +[6:8..6:9): E <- a/Definitions.E# + +expect/Empty.scala +------------------ + +Summary: +Schema => SemanticDB v4 +Uri => Empty.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 10 entries + +Symbols: +_empty_/A# => class A +_empty_/A#``(). => primary ctor +_empty_/A#b(). => method b +_empty_/B# => class B +_empty_/B#``(). => primary ctor +_empty_/B#a(). => method a + +Occurrences: +[0:6..0:7): A <- _empty_/A# +[1:2..1:2): <- _empty_/A#``(). +[1:6..1:7): b <- _empty_/A#b(). +[1:9..1:10): B -> _empty_/B# +[1:13..1:16): ??? -> scala/Predef.`???`(). +[4:6..4:7): B <- _empty_/B# +[5:2..5:2): <- _empty_/B#``(). +[5:6..5:7): a <- _empty_/B#a(). +[5:9..5:10): A -> _empty_/A# +[5:13..5:16): ??? -> scala/Predef.`???`(). + +expect/EmptyObject.scala +------------------------ + +Summary: +Schema => SemanticDB v4 +Uri => EmptyObject.scala +Text => empty +Language => Scala +Symbols => 1 entries +Occurrences => 2 entries + +Symbols: +example/EmptyObject. => final object EmptyObject + +Occurrences: +[0:8..0:15): example <- example/ +[2:7..2:18): EmptyObject <- example/EmptyObject. + +expect/Enums.scala +------------------ + +Summary: +Schema => SemanticDB v4 +Uri => Enums.scala +Text => empty +Language => Scala +Symbols => 157 entries +Occurrences => 187 entries + +Symbols: +_empty_/Enums. => final object Enums +_empty_/Enums.Coin# => abstract sealed enum class Coin +_empty_/Enums.Coin#``(). => primary ctor +_empty_/Enums.Coin#``().(value) => param value +_empty_/Enums.Coin#value. => val method value +_empty_/Enums.Coin. => final object Coin +_empty_/Enums.Coin.$values. => val method $values +_empty_/Enums.Coin.Dime. => case val static enum method Dime +_empty_/Enums.Coin.Dollar. => case val static enum method Dollar +_empty_/Enums.Coin.Nickel. => case val static enum method Nickel +_empty_/Enums.Coin.Penny. => case val static enum method Penny +_empty_/Enums.Coin.Quarter. => case val static enum method Quarter +_empty_/Enums.Coin.valueOf(). => method valueOf +_empty_/Enums.Coin.valueOf().($name) => param $name +_empty_/Enums.Coin.values(). => method values +_empty_/Enums.Colour# => abstract sealed enum class Colour +_empty_/Enums.Colour#``(). => primary ctor +_empty_/Enums.Colour. => final object Colour +_empty_/Enums.Colour.$new(). => method $new +_empty_/Enums.Colour.$new().($name) => param $name +_empty_/Enums.Colour.$new().(_$ordinal) => param _$ordinal +_empty_/Enums.Colour.$values. => val method $values +_empty_/Enums.Colour.Blue. => case val static enum method Blue +_empty_/Enums.Colour.Green. => case val static enum method Green +_empty_/Enums.Colour.Red. => case val static enum method Red +_empty_/Enums.Colour.valueOf(). => method valueOf +_empty_/Enums.Colour.valueOf().($name) => param $name +_empty_/Enums.Colour.values(). => method values +_empty_/Enums.Directions# => abstract sealed enum class Directions +_empty_/Enums.Directions#``(). => primary ctor +_empty_/Enums.Directions. => final object Directions +_empty_/Enums.Directions.$new(). => method $new +_empty_/Enums.Directions.$new().($name) => param $name +_empty_/Enums.Directions.$new().(_$ordinal) => param _$ordinal +_empty_/Enums.Directions.$values. => val method $values +_empty_/Enums.Directions.East. => case val static enum method East +_empty_/Enums.Directions.North. => case val static enum method North +_empty_/Enums.Directions.South. => case val static enum method South +_empty_/Enums.Directions.West. => case val static enum method West +_empty_/Enums.Directions.valueOf(). => method valueOf +_empty_/Enums.Directions.valueOf().($name) => param $name +_empty_/Enums.Directions.values(). => method values +_empty_/Enums.Maybe# => abstract sealed enum class Maybe +_empty_/Enums.Maybe#[A] => covariant typeparam A +_empty_/Enums.Maybe#``(). => primary ctor +_empty_/Enums.Maybe. => final object Maybe +_empty_/Enums.Maybe.Just# => final case enum class Just +_empty_/Enums.Maybe.Just#$ordinal(). => method $ordinal +_empty_/Enums.Maybe.Just#[A] => typeparam A +_empty_/Enums.Maybe.Just#_1(). => method _1 +_empty_/Enums.Maybe.Just#``(). => primary ctor +_empty_/Enums.Maybe.Just#``().(value) => val param value +_empty_/Enums.Maybe.Just#copy$default$1(). => method copy$default$1 +_empty_/Enums.Maybe.Just#copy$default$1().[A] => typeparam A +_empty_/Enums.Maybe.Just#copy(). => method copy +_empty_/Enums.Maybe.Just#copy().(value) => param value +_empty_/Enums.Maybe.Just#copy().[A] => typeparam A +_empty_/Enums.Maybe.Just#value. => val method value +_empty_/Enums.Maybe.Just. => final object Just +_empty_/Enums.Maybe.Just.apply(). => method apply +_empty_/Enums.Maybe.Just.apply().(value) => param value +_empty_/Enums.Maybe.Just.apply().[A] => typeparam A +_empty_/Enums.Maybe.Just.unapply(). => method unapply +_empty_/Enums.Maybe.Just.unapply().(x$1) => param x$1 +_empty_/Enums.Maybe.Just.unapply().[A] => typeparam A +_empty_/Enums.Maybe.None. => case val static enum method None +_empty_/Enums.Planet# => abstract sealed enum class Planet +_empty_/Enums.Planet#G. => final val method G +_empty_/Enums.Planet#``(). => primary ctor +_empty_/Enums.Planet#``().(mass) => param mass +_empty_/Enums.Planet#``().(radius) => param radius +_empty_/Enums.Planet#mass. => val method mass +_empty_/Enums.Planet#radius. => val method radius +_empty_/Enums.Planet#surfaceGravity(). => method surfaceGravity +_empty_/Enums.Planet#surfaceWeight(). => method surfaceWeight +_empty_/Enums.Planet#surfaceWeight().(otherMass) => param otherMass +_empty_/Enums.Planet. => final object Planet +_empty_/Enums.Planet.$values. => val method $values +_empty_/Enums.Planet.Earth. => case val static enum method Earth +_empty_/Enums.Planet.Jupiter. => case val static enum method Jupiter +_empty_/Enums.Planet.Mars. => case val static enum method Mars +_empty_/Enums.Planet.Mercury. => case val static enum method Mercury +_empty_/Enums.Planet.Neptune. => case val static enum method Neptune +_empty_/Enums.Planet.Saturn. => case val static enum method Saturn +_empty_/Enums.Planet.Uranus. => case val static enum method Uranus +_empty_/Enums.Planet.Venus. => case val static enum method Venus +_empty_/Enums.Planet.valueOf(). => method valueOf +_empty_/Enums.Planet.valueOf().($name) => param $name +_empty_/Enums.Planet.values(). => method values +_empty_/Enums.Suits# => abstract sealed enum class Suits +_empty_/Enums.Suits#``(). => primary ctor +_empty_/Enums.Suits. => final object Suits +_empty_/Enums.Suits.$new(). => method $new +_empty_/Enums.Suits.$new().($name) => param $name +_empty_/Enums.Suits.$new().(_$ordinal) => param _$ordinal +_empty_/Enums.Suits.$values. => val method $values +_empty_/Enums.Suits.Clubs. => case val static enum method Clubs +_empty_/Enums.Suits.Diamonds. => case val static enum method Diamonds +_empty_/Enums.Suits.Hearts. => case val static enum method Hearts +_empty_/Enums.Suits.Spades. => case val static enum method Spades +_empty_/Enums.Suits.derived$Eql(). => implicit method derived$Eql +_empty_/Enums.Suits.isBlack(). => method isBlack +_empty_/Enums.Suits.isBlack().(suit) => param suit +_empty_/Enums.Suits.isRed(). => method isRed +_empty_/Enums.Suits.isRed().(suit) => param suit +_empty_/Enums.Suits.valueOf(). => method valueOf +_empty_/Enums.Suits.valueOf().($name) => param $name +_empty_/Enums.Suits.values(). => method values +_empty_/Enums.Tag# => abstract sealed enum class Tag +_empty_/Enums.Tag#[A] => typeparam A +_empty_/Enums.Tag#``(). => primary ctor +_empty_/Enums.Tag. => final object Tag +_empty_/Enums.Tag.BooleanTag. => case val static enum method BooleanTag +_empty_/Enums.Tag.IntTag. => case val static enum method IntTag +_empty_/Enums.WeekDays# => abstract sealed enum class WeekDays +_empty_/Enums.WeekDays#``(). => primary ctor +_empty_/Enums.WeekDays. => final object WeekDays +_empty_/Enums.WeekDays.$new(). => method $new +_empty_/Enums.WeekDays.$new().($name) => param $name +_empty_/Enums.WeekDays.$new().(_$ordinal) => param _$ordinal +_empty_/Enums.WeekDays.$values. => val method $values +_empty_/Enums.WeekDays.Friday. => case val static enum method Friday +_empty_/Enums.WeekDays.Monday. => case val static enum method Monday +_empty_/Enums.WeekDays.Saturday. => case val static enum method Saturday +_empty_/Enums.WeekDays.Sunday. => case val static enum method Sunday +_empty_/Enums.WeekDays.Thursday. => case val static enum method Thursday +_empty_/Enums.WeekDays.Tuesday. => case val static enum method Tuesday +_empty_/Enums.WeekDays.Wednesday. => case val static enum method Wednesday +_empty_/Enums.WeekDays.valueOf(). => method valueOf +_empty_/Enums.WeekDays.valueOf().($name) => param $name +_empty_/Enums.WeekDays.values(). => method values +_empty_/Enums.`<:<`# => abstract sealed enum class <:< +_empty_/Enums.`<:<`#[A] => contravariant typeparam A +_empty_/Enums.`<:<`#[B] => typeparam B +_empty_/Enums.`<:<`#``(). => primary ctor +_empty_/Enums.`<:<`. => final object <:< +_empty_/Enums.`<:<`.Refl# => final case enum class Refl +_empty_/Enums.`<:<`.Refl#$ordinal(). => method $ordinal +_empty_/Enums.`<:<`.Refl#[C] => typeparam C +_empty_/Enums.`<:<`.Refl#``(). => primary ctor +_empty_/Enums.`<:<`.Refl#copy(). => method copy +_empty_/Enums.`<:<`.Refl#copy().[C] => typeparam C +_empty_/Enums.`<:<`.Refl. => final object Refl +_empty_/Enums.`<:<`.Refl.apply(). => method apply +_empty_/Enums.`<:<`.Refl.apply().[C] => typeparam C +_empty_/Enums.`<:<`.Refl.unapply(). => method unapply +_empty_/Enums.`<:<`.Refl.unapply().(x$1) => param x$1 +_empty_/Enums.`<:<`.Refl.unapply().[C] => typeparam C +_empty_/Enums.`<:<`.given_T(). => final implicit method given_T +_empty_/Enums.`<:<`.given_T().[T] => typeparam T +_empty_/Enums.some1. => val method some1 +_empty_/Enums.unwrap(). => method unwrap +_empty_/Enums.unwrap().(ev) => implicit param ev +_empty_/Enums.unwrap().(opt) => param opt +_empty_/Enums.unwrap().[A] => typeparam A +_empty_/Enums.unwrap().[B] => typeparam B +local0 => param x + +Occurrences: +[0:7..0:12): Enums <- _empty_/Enums. +[1:9..1:12): <:< -> _empty_/Enums.`<:<`. +[3:7..3:13): Colour <- _empty_/Enums.Colour# +[4:4..4:4): <- _empty_/Enums.Colour#``(). +[4:11..4:17): Colour -> _empty_/Enums.Colour. +[4:18..4:21): Red -> _empty_/Enums.Colour.Red. +[5:9..5:12): Red <- _empty_/Enums.Colour.Red. +[5:14..5:19): Green <- _empty_/Enums.Colour.Green. +[5:21..5:25): Blue <- _empty_/Enums.Colour.Blue. +[7:7..7:17): Directions <- _empty_/Enums.Directions# +[8:4..8:4): <- _empty_/Enums.Directions#``(). +[8:9..8:14): North <- _empty_/Enums.Directions.North. +[8:16..8:20): East <- _empty_/Enums.Directions.East. +[8:22..8:27): South <- _empty_/Enums.Directions.South. +[8:29..8:33): West <- _empty_/Enums.Directions.West. +[10:7..10:12): Suits <- _empty_/Enums.Suits# +[10:21..10:21): <- _empty_/Enums.Suits#``(). +[10:21..10:21): -> scala/Eql.derived. +[11:9..11:15): Hearts <- _empty_/Enums.Suits.Hearts. +[11:17..11:23): Spades <- _empty_/Enums.Suits.Spades. +[11:25..11:30): Clubs <- _empty_/Enums.Suits.Clubs. +[11:32..11:40): Diamonds <- _empty_/Enums.Suits.Diamonds. +[13:9..13:14): Suits <- _empty_/Enums.Suits. +[14:8..14:13): (suit <- _empty_/Enums.Suits.isRed(). +[14:9..14:13): suit <- _empty_/Enums.Suits.isRed().(suit) +[14:15..14:20): Suits -> _empty_/Enums.Suits# +[14:29..14:36): Boolean -> scala/Boolean# +[15:6..15:10): suit -> _empty_/Enums.Suits.isRed().(suit) +[15:11..15:13): == -> scala/Any#`==`(). +[15:14..15:20): Hearts -> _empty_/Enums.Suits.Hearts. +[15:21..15:23): || -> scala/Boolean#`||`(). +[15:24..15:28): suit -> _empty_/Enums.Suits.isRed().(suit) +[15:29..15:31): == -> scala/Any#`==`(). +[15:32..15:40): Diamonds -> _empty_/Enums.Suits.Diamonds. +[17:8..17:15): (suit: <- _empty_/Enums.Suits.isBlack(). +[17:9..17:13): suit <- _empty_/Enums.Suits.isBlack().(suit) +[17:15..17:20): Suits -> _empty_/Enums.Suits# +[17:31..17:38): Boolean -> scala/Boolean# +[17:41..17:45): suit -> _empty_/Enums.Suits.isBlack().(suit) +[18:11..18:17): Spades -> _empty_/Enums.Suits.Spades. +[18:20..18:28): Diamonds -> _empty_/Enums.Suits.Diamonds. +[21:7..21:15): WeekDays <- _empty_/Enums.WeekDays# +[22:4..22:4): <- _empty_/Enums.WeekDays#``(). +[22:9..22:15): Monday <- _empty_/Enums.WeekDays.Monday. +[23:9..23:16): Tuesday <- _empty_/Enums.WeekDays.Tuesday. +[24:9..24:18): Wednesday <- _empty_/Enums.WeekDays.Wednesday. +[25:9..25:17): Thursday <- _empty_/Enums.WeekDays.Thursday. +[26:9..26:15): Friday <- _empty_/Enums.WeekDays.Friday. +[27:9..27:17): Saturday <- _empty_/Enums.WeekDays.Saturday. +[28:9..28:15): Sunday <- _empty_/Enums.WeekDays.Sunday. +[30:7..30:11): Coin <- _empty_/Enums.Coin# +[30:11..30:23): <- _empty_/Enums.Coin#``(). +[30:12..30:17): value <- _empty_/Enums.Coin#value. +[30:19..30:22): Int -> scala/Int# +[31:9..31:14): Penny <- _empty_/Enums.Coin.Penny. +[31:26..31:30): Coin -> _empty_/Enums.Coin# +[31:30..31:30): -> _empty_/Enums.Coin#``(). +[32:9..32:15): Nickel <- _empty_/Enums.Coin.Nickel. +[32:26..32:30): Coin -> _empty_/Enums.Coin# +[32:30..32:30): -> _empty_/Enums.Coin#``(). +[33:9..33:13): Dime <- _empty_/Enums.Coin.Dime. +[33:26..33:30): Coin -> _empty_/Enums.Coin# +[33:30..33:30): -> _empty_/Enums.Coin#``(). +[34:9..34:16): Quarter <- _empty_/Enums.Coin.Quarter. +[34:26..34:30): Coin -> _empty_/Enums.Coin# +[34:30..34:30): -> _empty_/Enums.Coin#``(). +[35:9..35:15): Dollar <- _empty_/Enums.Coin.Dollar. +[35:26..35:30): Coin -> _empty_/Enums.Coin# +[35:30..35:30): -> _empty_/Enums.Coin#``(). +[37:7..37:12): Maybe <- _empty_/Enums.Maybe# +[37:12..37:16): <- _empty_/Enums.Maybe#``(). +[37:14..37:15): A <- _empty_/Enums.Maybe#[A] +[38:9..38:13): Just <- _empty_/Enums.Maybe.Just# +[38:13..38:23): <- _empty_/Enums.Maybe.Just#``(). +[38:14..38:19): value <- _empty_/Enums.Maybe.Just#value. +[38:21..38:22): A -> _empty_/Enums.Maybe.Just#[A] +[39:4..39:4): -> _empty_/Enums.Maybe#``(). +[39:9..39:13): None <- _empty_/Enums.Maybe.None. +[41:7..41:10): Tag <- _empty_/Enums.Tag# +[41:10..41:13): <- _empty_/Enums.Tag#``(). +[41:11..41:12): A <- _empty_/Enums.Tag#[A] +[42:9..42:15): IntTag <- _empty_/Enums.Tag.IntTag. +[42:24..42:27): Tag -> _empty_/Enums.Tag# +[42:28..42:31): Int -> scala/Int# +[42:32..42:32): -> _empty_/Enums.Tag#``(). +[43:9..43:19): BooleanTag <- _empty_/Enums.Tag.BooleanTag. +[43:28..43:31): Tag -> _empty_/Enums.Tag# +[43:32..43:39): Boolean -> scala/Boolean# +[43:40..43:40): -> _empty_/Enums.Tag#``(). +[45:7..45:10): <:< <- _empty_/Enums.`<:<`# +[45:10..45:17): <- _empty_/Enums.`<:<`#``(). +[45:12..45:13): A <- _empty_/Enums.`<:<`#[A] +[45:15..45:16): B <- _empty_/Enums.`<:<`#[B] +[46:9..46:13): Refl <- _empty_/Enums.`<:<`.Refl# +[46:13..46:18): <- _empty_/Enums.`<:<`.Refl#``(). +[46:14..46:15): C <- _empty_/Enums.`<:<`.Refl#[C] +[46:28..46:29): C -> _empty_/Enums.`<:<`.Refl#[C] +[46:30..46:33): <:< -> _empty_/Enums.`<:<`# +[46:34..46:35): C -> _empty_/Enums.`<:<`.Refl#[C] +[46:35..46:35): -> _empty_/Enums.`<:<`#``(). +[48:9..48:12): <:< <- _empty_/Enums.`<:<`. +[49:10..49:17): [T]: (T <- _empty_/Enums.`<:<`.given_T(). +[49:11..49:12): T <- _empty_/Enums.`<:<`.given_T().[T] +[49:16..49:17): T -> _empty_/Enums.`<:<`.given_T().[T] +[49:18..49:21): <:< -> _empty_/Enums.`<:<`# +[49:22..49:23): T -> _empty_/Enums.`<:<`.given_T().[T] +[49:27..49:31): Refl -> _empty_/Enums.`<:<`.Refl. +[49:31..49:31): -> _empty_/Enums.`<:<`.Refl.apply(). +[51:6..51:12): [A, B] <- _empty_/Enums.unwrap(). +[51:7..51:8): A <- _empty_/Enums.unwrap().[A] +[51:10..51:11): B <- _empty_/Enums.unwrap().[B] +[51:13..51:16): opt <- _empty_/Enums.unwrap().(opt) +[51:18..51:24): Option -> scala/Option# +[51:25..51:26): A -> _empty_/Enums.unwrap().[A] +[51:42..51:44): ev <- _empty_/Enums.unwrap().(ev) +[51:46..51:47): A -> _empty_/Enums.unwrap().[A] +[51:48..51:51): <:< -> _empty_/Enums.`<:<`# +[51:52..51:58): Option -> scala/Option# +[51:59..51:60): B -> _empty_/Enums.unwrap().[B] +[51:64..51:70): Option -> scala/Option# +[51:71..51:72): B -> _empty_/Enums.unwrap().[B] +[51:76..51:78): ev -> _empty_/Enums.unwrap().(ev) +[52:9..52:13): Refl -> _empty_/Enums.`<:<`.Refl. +[52:13..52:13): -> _empty_/Enums.`<:<`.Refl.unapply(). +[52:19..52:22): opt -> _empty_/Enums.unwrap().(opt) +[52:23..52:30): flatMap -> scala/Option#flatMap(). +[52:31..52:39): identity -> scala/Predef.identity(). +[52:31..52:31): -> local0 +[52:40..52:46): Option -> scala/Option# +[52:47..52:48): B -> _empty_/Enums.unwrap().[B] +[54:6..54:11): some1 <- _empty_/Enums.some1. +[54:14..54:14): -> _empty_/Enums.unwrap(). +[54:14..54:18): Some -> scala/Some. +[54:18..54:18): -> scala/Some.apply(). +[54:19..54:23): Some -> scala/Some. +[54:23..54:23): -> scala/Some.apply(). +[54:27..54:27): -> _empty_/Enums.`<:<`.given_T(). +[56:7..56:13): Planet <- _empty_/Enums.Planet# +[56:13..56:43): <- _empty_/Enums.Planet#``(). +[56:14..56:18): mass <- _empty_/Enums.Planet#mass. +[56:20..56:26): Double -> scala/Double# +[56:28..56:34): radius <- _empty_/Enums.Planet#radius. +[56:36..56:42): Double -> scala/Double# +[56:52..56:56): java -> java/ +[56:57..56:61): lang -> java/lang/ +[56:62..56:66): Enum -> java/lang/Enum# +[56:67..56:73): Planet -> _empty_/Enums.Planet# +[56:74..56:74): -> java/lang/Enum#``(). +[57:22..57:23): G <- _empty_/Enums.Planet#G. +[58:8..58:22): surfaceGravity <- _empty_/Enums.Planet#surfaceGravity(). +[58:25..58:26): G -> _empty_/Enums.Planet#G. +[58:27..58:28): * -> scala/Double#`*`(+6). +[58:29..58:33): mass -> _empty_/Enums.Planet#mass. +[58:34..58:35): / -> scala/Double#`/`(+6). +[58:37..58:43): radius -> _empty_/Enums.Planet#radius. +[58:44..58:45): * -> scala/Double#`*`(+6). +[58:46..58:52): radius -> _empty_/Enums.Planet#radius. +[59:8..59:21): surfaceWeight <- _empty_/Enums.Planet#surfaceWeight(). +[59:22..59:31): otherMass <- _empty_/Enums.Planet#surfaceWeight().(otherMass) +[59:33..59:39): Double -> scala/Double# +[59:43..59:52): otherMass -> _empty_/Enums.Planet#surfaceWeight().(otherMass) +[59:53..59:54): * -> scala/Double#`*`(+6). +[59:55..59:69): surfaceGravity -> _empty_/Enums.Planet#surfaceGravity(). +[61:9..61:16): Mercury <- _empty_/Enums.Planet.Mercury. +[61:25..61:31): Planet -> _empty_/Enums.Planet# +[61:31..61:31): -> _empty_/Enums.Planet#``(). +[62:9..62:14): Venus <- _empty_/Enums.Planet.Venus. +[62:25..62:31): Planet -> _empty_/Enums.Planet# +[62:31..62:31): -> _empty_/Enums.Planet#``(). +[63:9..63:14): Earth <- _empty_/Enums.Planet.Earth. +[63:25..63:31): Planet -> _empty_/Enums.Planet# +[63:31..63:31): -> _empty_/Enums.Planet#``(). +[64:9..64:13): Mars <- _empty_/Enums.Planet.Mars. +[64:25..64:31): Planet -> _empty_/Enums.Planet# +[64:31..64:31): -> _empty_/Enums.Planet#``(). +[65:9..65:16): Jupiter <- _empty_/Enums.Planet.Jupiter. +[65:25..65:31): Planet -> _empty_/Enums.Planet# +[65:31..65:31): -> _empty_/Enums.Planet#``(). +[66:9..66:15): Saturn <- _empty_/Enums.Planet.Saturn. +[66:25..66:31): Planet -> _empty_/Enums.Planet# +[66:31..66:31): -> _empty_/Enums.Planet#``(). +[67:9..67:15): Uranus <- _empty_/Enums.Planet.Uranus. +[67:25..67:31): Planet -> _empty_/Enums.Planet# +[67:31..67:31): -> _empty_/Enums.Planet#``(). +[68:9..68:16): Neptune <- _empty_/Enums.Planet.Neptune. +[68:25..68:31): Planet -> _empty_/Enums.Planet# +[68:31..68:31): -> _empty_/Enums.Planet#``(). + +expect/EtaExpansion.scala +------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => EtaExpansion.scala +Text => empty +Language => Scala +Symbols => 3 entries +Occurrences => 12 entries + +Symbols: +example/EtaExpansion# => class EtaExpansion +example/EtaExpansion#``(). => primary ctor +local0 => param x + +Occurrences: +[0:8..0:15): example <- example/ +[2:6..2:18): EtaExpansion <- example/EtaExpansion# +[3:2..3:2): <- example/EtaExpansion#``(). +[3:2..3:6): Some -> scala/Some. +[3:6..3:6): -> scala/Some.apply(). +[3:10..3:13): map -> scala/Option#map(). +[3:14..3:22): identity -> scala/Predef.identity(). +[3:14..3:14): -> local0 +[4:2..4:6): List -> scala/package.List. +[4:6..4:6): -> scala/collection/IterableFactory#apply(). +[4:10..4:18): foldLeft -> scala/collection/LinearSeqOps#foldLeft(). +[4:25..4:26): + -> java/lang/String#`+`(). + +expect/Example.scala +-------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Example.scala +Text => empty +Language => Scala +Symbols => 5 entries +Occurrences => 26 entries + +Symbols: +example/Example. => final object Example +example/Example.main(). => method main +example/Example.main().(args) => param args +example/Example.x. => val method x +local0 => selfparam self + +Occurrences: +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:23): concurrent -> scala/concurrent/ +[2:24..2:30): Future -> scala/concurrent/Future. +[2:24..2:30): Future -> scala/concurrent/Future# +[4:7..4:14): Example <- example/Example. +[4:17..4:21): self <- local0 +[5:6..5:11): scala -> scala/ +[5:12..5:22): collection -> scala/collection/ +[5:23..5:30): mutable -> scala/collection/mutable/ +[5:31..5:36): Stack -> scala/collection/mutable/Stack# +[5:37..5:40): Int -> scala/Int# +[5:41..5:41): -> scala/collection/mutable/Stack#``(+1). +[6:6..6:10): main <- example/Example.main(). +[6:11..6:15): args <- example/Example.main().(args) +[6:17..6:22): Array -> scala/Array# +[6:23..6:29): String -> scala/Predef.String# +[6:33..6:37): Unit -> scala/Unit# +[7:4..7:11): println -> scala/Predef.println(+1). +[9:6..9:7): x <- example/Example.x. +[9:10..9:15): scala -> scala/ +[9:16..9:23): reflect -> scala/reflect/ +[9:24..9:32): classTag -> scala/reflect/package.classTag(). +[9:33..9:36): Int -> scala/Int# +[9:37..9:37): -> scala/reflect/ClassTag.apply(). +[9:37..9:37): -> java/lang/Integer#TYPE. + +expect/Flags.scala +------------------ + +Summary: +Schema => SemanticDB v4 +Uri => Flags.scala +Text => empty +Language => Scala +Symbols => 50 entries +Occurrences => 82 entries + +Symbols: +flags/p/package. => final package object p +flags/p/package.AA# => class AA +flags/p/package.AA#``(). => primary ctor +flags/p/package.AA#``().(x) => param x +flags/p/package.AA#``().(y) => val param y +flags/p/package.AA#``().(z) => var param z +flags/p/package.AA#`z_=`(). => var method z_= +flags/p/package.AA#`z_=`().(x$1) => param x$1 +flags/p/package.AA#x. => val method x +flags/p/package.AA#y. => val method y +flags/p/package.AA#z(). => var method z +flags/p/package.C# => abstract class C +flags/p/package.C#[T] => covariant typeparam T +flags/p/package.C#[U] => contravariant typeparam U +flags/p/package.C#[V] => typeparam V +flags/p/package.C#``(). => primary ctor +flags/p/package.C#``().(x) => param x +flags/p/package.C#``().(y) => param y +flags/p/package.C#``().(z) => param z +flags/p/package.C#``(+1). => ctor +flags/p/package.C#``(+2). => ctor +flags/p/package.C#``(+2).(t) => param t +flags/p/package.C#w(). => abstract method w +flags/p/package.C#x. => val method x +flags/p/package.C#y. => val method y +flags/p/package.C#z. => val method z +flags/p/package.S# => class S +flags/p/package.S#[T] => typeparam T +flags/p/package.S#``(). => primary ctor +flags/p/package.T1# => type T1 +flags/p/package.T2# => type T2 +flags/p/package.T2#[T] => typeparam T +flags/p/package.U# => type U +flags/p/package.V# => type V +flags/p/package.X. => final case object X +flags/p/package.Y# => final class Y +flags/p/package.Y#``(). => primary ctor +flags/p/package.Z# => sealed trait Z +flags/p/package.Z#``(). => primary ctor +flags/p/package.`y_=`(). => var method y_= +flags/p/package.`y_=`().(x$1) => param x$1 +flags/p/package.m(). => method m +flags/p/package.m().[TT] => typeparam TT +flags/p/package.x. => lazy val method x +flags/p/package.xs1. => val method xs1 +flags/p/package.y(). => implicit var method y +flags/p/package.z(). => method z +flags/p/package.z().(pp) => param pp +local0 => val local xs2 +local1 => case val method t + +Occurrences: +[0:8..0:13): flags <- flags/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:34): experimental -> scalaShadowing/language.experimental. +[2:35..2:41): macros -> scalaShadowing/language.experimental.macros. +[4:15..5:3): <- flags/p/package. +[5:2..5:3): p -> flags/p/ +[5:19..5:20): x <- flags/p/package.x. +[6:25..6:26): y <- flags/p/package.y(). +[6:28..6:31): Int -> scala/Int# +[7:6..7:7): z <- flags/p/package.z(). +[7:8..7:10): pp <- flags/p/package.z().(pp) +[7:12..7:15): Int -> scala/Int# +[8:6..8:7): m <- flags/p/package.m(). +[8:8..8:10): TT <- flags/p/package.m().[TT] +[8:13..8:16): Int -> scala/Int# +[8:16..8:16): -> scala/Predef.`???`(). +[9:17..9:18): C <- flags/p/package.C# +[9:18..9:47): <- flags/p/package.C#``(). +[9:20..9:21): T <- flags/p/package.C#[T] +[9:24..9:25): U <- flags/p/package.C#[U] +[9:27..9:28): V <- flags/p/package.C#[V] +[9:30..9:31): x <- flags/p/package.C#x. +[9:33..9:34): T -> flags/p/package.C#[T] +[9:36..9:37): y <- flags/p/package.C#y. +[9:39..9:40): U -> flags/p/package.C#[U] +[9:42..9:43): z <- flags/p/package.C#z. +[9:45..9:46): V -> flags/p/package.C#[V] +[10:8..10:14): <- flags/p/package.C#``(+1). +[10:22..10:22): -> flags/p/package.C#``(). +[10:22..10:25): ??? -> scala/Predef.`???`(). +[10:27..10:30): ??? -> scala/Predef.`???`(). +[10:32..10:35): ??? -> scala/Predef.`???`(). +[11:8..11:14): <- flags/p/package.C#``(+2). +[11:13..11:14): t <- flags/p/package.C#``(+2).(t) +[11:16..11:17): T -> flags/p/package.C#[T] +[11:26..11:26): -> flags/p/package.C#``(). +[11:26..11:27): t -> flags/p/package.C#``(+2).(t) +[11:29..11:32): ??? -> scala/Predef.`???`(). +[11:34..11:37): ??? -> scala/Predef.`???`(). +[12:8..12:9): w <- flags/p/package.C#w(). +[12:11..12:14): Int -> scala/Int# +[14:7..14:9): T1 <- flags/p/package.T1# +[14:12..14:15): Int -> scala/Int# +[15:7..15:9): T2 <- flags/p/package.T2# +[15:10..15:11): T <- flags/p/package.T2#[T] +[15:15..15:16): S -> flags/p/package.S# +[15:17..15:18): T -> flags/p/package.T2#[T] +[16:7..16:8): U <- flags/p/package.U# +[16:12..16:15): Int -> scala/Int# +[17:7..17:8): V <- flags/p/package.V# +[17:12..17:15): Int -> scala/Int# +[18:14..18:15): X <- flags/p/package.X. +[19:2..19:2): <- flags/p/package.Y#``(). +[19:14..19:15): Y <- flags/p/package.Y# +[20:2..20:2): <- flags/p/package.Z#``(). +[20:15..20:16): Z <- flags/p/package.Z# +[21:8..21:10): AA <- flags/p/package.AA# +[21:10..21:42): <- flags/p/package.AA#``(). +[21:11..21:12): x <- flags/p/package.AA#x. +[21:14..21:17): Int -> scala/Int# +[21:23..21:24): y <- flags/p/package.AA#y. +[21:26..21:29): Int -> scala/Int# +[21:35..21:36): z <- flags/p/package.AA#z(). +[21:38..21:41): Int -> scala/Int# +[22:8..22:9): S <- flags/p/package.S# +[22:9..22:25): <- flags/p/package.S#``(). +[22:11..22:22): specialized -> scala/specialized# +[22:23..22:24): T <- flags/p/package.S#[T] +[23:6..23:10): List -> scala/package.List. +[23:10..23:10): -> scala/collection/SeqFactory#unapplySeq(). +[23:11..23:14): xs1 <- flags/p/package.xs1. +[23:18..23:21): ??? -> scala/Predef.`???`(). +[24:2..24:5): ??? -> scala/Predef.`???`(). +[24:19..24:23): List -> scala/package.List. +[24:23..24:23): -> scala/collection/SeqFactory#unapplySeq(). +[24:24..24:27): xs2 <- local0 +[24:32..24:35): ??? -> scala/Predef.`???`(). +[25:2..25:5): ??? -> scala/Predef.`???`(). +[25:22..25:26): List -> scala/package.List# +[25:27..25:28): t <- local1 +[25:33..25:36): ??? -> scala/Predef.`???`(). + +expect/ForComprehension.scala +----------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => ForComprehension.scala +Text => empty +Language => Scala +Symbols => 13 entries +Occurrences => 88 entries + +Symbols: +example/ForComprehension# => class ForComprehension +example/ForComprehension#``(). => primary ctor +local0 => param a +local1 => param b +local2 => val local c +local3 => param x$1 +local4 => param a +local5 => param b +local6 => param x$1 +local7 => val local c +local8 => val local d +local9 => val local e +local10 => param f + +Occurrences: +[0:8..0:15): example <- example/ +[2:6..2:22): ForComprehension <- example/ForComprehension# +[3:2..3:2): <- example/ForComprehension#``(). +[4:4..4:5): a <- local0 +[4:9..4:13): List -> scala/package.List. +[4:13..4:13): -> scala/collection/IterableFactory#apply(). +[4:16..4:16): -> scala/collection/immutable/List#flatMap(). +[5:4..5:5): b <- local1 +[5:4..5:4): -> scala/Tuple2.apply(). +[5:4..5:5): b -> local1 +[5:4..5:4): -> local3 +[5:4..5:4): -> scala/Tuple2.unapply(). +[5:9..5:13): List -> scala/package.List. +[5:13..5:13): -> scala/collection/IterableFactory#apply(). +[5:16..5:16): -> scala/collection/IterableOps#withFilter(). +[6:7..6:8): b -> local1 +[6:9..6:10): > -> scala/Int#`>`(+3). +[6:12..6:12): -> scala/collection/WithFilter#map(). +[7:4..7:5): c <- local2 +[7:4..7:5): c -> local2 +[7:8..7:9): a -> local0 +[7:10..7:11): + -> scala/Int#`+`(+4). +[7:12..7:13): b -> local1 +[7:13..7:13): -> scala/collection/immutable/List#map(). +[8:11..8:11): -> scala/Tuple3.apply(). +[8:11..8:12): a -> local0 +[8:14..8:15): b -> local1 +[8:17..8:18): c -> local2 +[10:4..10:5): a <- local4 +[10:9..10:13): List -> scala/package.List. +[10:13..10:13): -> scala/collection/IterableFactory#apply(). +[10:16..10:16): -> scala/collection/immutable/List#flatMap(). +[11:4..11:5): b <- local5 +[11:9..11:13): List -> scala/package.List. +[11:13..11:13): -> scala/collection/IterableFactory#apply(). +[11:14..11:15): a -> local4 +[11:16..11:16): -> scala/collection/IterableOps#withFilter(). +[13:6..13:6): -> scala/Tuple2.apply(). +[13:6..13:7): a -> local4 +[14:6..14:7): b -> local5 +[15:6..15:8): == -> scala/Any#`==`(). +[15:10..15:10): -> scala/Tuple2.apply(). +[15:15..15:15): -> scala/collection/WithFilter#flatMap(). +[16:4..16:4): -> local6 +[16:4..16:4): -> scala/Tuple2.unapply(). +[17:6..17:6): -> scala/Tuple2.unapply(). +[17:6..17:7): c <- local7 +[18:6..18:7): d <- local8 +[19:9..19:13): List -> scala/package.List. +[19:13..19:13): -> scala/collection/IterableFactory#apply(). +[19:15..19:15): -> scala/Tuple2.apply(). +[19:15..19:16): a -> local4 +[19:18..19:19): b -> local5 +[19:21..19:21): -> scala/collection/WithFilter#withFilter(). +[19:21..19:21): -> scala/collection/IterableOps#withFilter(). +[21:6..21:6): -> scala/Tuple4.apply(). +[21:6..21:7): a -> local4 +[22:6..22:7): b -> local5 +[23:6..23:7): c -> local7 +[24:6..24:7): d -> local8 +[25:6..25:8): == -> scala/Any#`==`(). +[25:10..25:10): -> scala/Tuple4.apply(). +[25:21..25:21): -> scala/collection/WithFilter#map(). +[26:4..26:5): e <- local9 +[26:4..26:4): -> scala/Tuple2.apply(). +[26:4..26:5): e -> local9 +[27:6..27:6): -> scala/Tuple4.apply(). +[27:6..27:7): a -> local4 +[28:6..28:7): b -> local5 +[29:6..29:7): c -> local7 +[30:6..30:7): d -> local8 +[31:5..31:5): -> scala/collection/IterableOps#withFilter(). +[32:7..32:8): e -> local9 +[32:9..32:11): == -> scala/Any#`==`(). +[32:13..32:13): -> scala/Tuple4.apply(). +[32:24..32:24): -> scala/collection/WithFilter#flatMap(). +[33:4..33:5): f <- local10 +[33:9..33:13): List -> scala/package.List. +[33:13..33:13): -> scala/collection/IterableFactory#apply(). +[33:14..33:15): e -> local9 +[33:16..33:16): -> scala/collection/immutable/List#map(). +[36:6..36:6): -> scala/Tuple6.apply(). +[36:6..36:7): a -> local4 +[37:6..37:7): b -> local5 +[38:6..38:7): c -> local7 +[39:6..39:7): d -> local8 +[40:6..40:7): e -> local9 +[41:6..41:7): f -> local10 + +expect/Givens.scala +------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Givens.scala +Text => empty +Language => Scala +Symbols => 31 entries +Occurrences => 72 entries + +Symbols: +a/b/Givens. => final object Givens +a/b/Givens.Monoid# => trait Monoid +a/b/Givens.Monoid#[A] => typeparam A +a/b/Givens.Monoid#``(). => primary ctor +a/b/Givens.Monoid#combine(). => abstract method combine +a/b/Givens.Monoid#combine().(x) => param x +a/b/Givens.Monoid#combine().(y) => param y +a/b/Givens.Monoid#empty(). => abstract method empty +a/b/Givens.foo(). => method foo +a/b/Givens.foo().(A) => implicit param A +a/b/Givens.foo().[A] => typeparam A +a/b/Givens.given_Monoid_String. => final implicit object given_Monoid_String +a/b/Givens.given_Monoid_String.combine(). => method combine +a/b/Givens.given_Monoid_String.combine().(x) => param x +a/b/Givens.given_Monoid_String.combine().(y) => param y +a/b/Givens.given_Monoid_String.empty(). => method empty +a/b/Givens.given_sayGoodbye_of_B. => final implicit object given_sayGoodbye_of_B +a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). => method sayGoodbye +a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) => param any +a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] => typeparam B +a/b/Givens.given_sayGoodbye_of_B.saySoLong(). => method saySoLong +a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) => param any +a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] => typeparam B +a/b/Givens.given_sayHello_of_A. => final implicit object given_sayHello_of_A +a/b/Givens.given_sayHello_of_A.sayHello(). => method sayHello +a/b/Givens.given_sayHello_of_A.sayHello().(any) => param any +a/b/Givens.given_sayHello_of_A.sayHello().[A] => typeparam A +a/b/Givens.goodbye1. => val method goodbye1 +a/b/Givens.hello1. => val method hello1 +a/b/Givens.int2String(). => final implicit macro int2String +a/b/Givens.soLong1. => val method soLong1 + +Occurrences: +[0:8..0:9): a <- a/ +[1:8..1:9): b <- a/b/ +[3:7..3:13): Givens <- a/b/Givens. +[5:8..5:27): extension [A](any: <- a/b/Givens.given_sayHello_of_A. +[5:19..5:20): A <- a/b/Givens.given_sayHello_of_A.sayHello().[A] +[5:22..5:25): any <- a/b/Givens.given_sayHello_of_A.sayHello().(any) +[5:27..5:28): A -> a/b/Givens.given_sayHello_of_A.sayHello().[A] +[6:8..6:16): sayHello <- a/b/Givens.given_sayHello_of_A.sayHello(). +[6:21..6:21): -> scala/StringContext.apply(). +[6:34..6:37): any -> a/b/Givens.given_sayHello_of_A.sayHello().(any) +[6:37..6:37): -> scala/StringContext#s(). +[8:8..8:29): extension [B](any: B) <- a/b/Givens.given_sayGoodbye_of_B. +[8:19..8:20): B <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] +[8:19..8:20): B <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] +[8:22..8:25): any <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) +[8:22..8:25): any <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) +[8:27..8:28): B -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] +[8:27..8:28): B -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] +[9:8..9:18): sayGoodbye <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). +[9:23..9:23): -> scala/StringContext.apply(). +[9:38..9:41): any -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) +[9:41..9:41): -> scala/StringContext#s(). +[10:8..10:17): saySoLong <- a/b/Givens.given_sayGoodbye_of_B.saySoLong(). +[10:22..10:22): -> scala/StringContext.apply(). +[10:37..10:40): any -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) +[10:40..10:40): -> scala/StringContext#s(). +[12:6..12:12): hello1 <- a/b/Givens.hello1. +[12:15..12:15): -> a/b/Givens.given_sayHello_of_A.sayHello(). +[13:6..13:14): goodbye1 <- a/b/Givens.goodbye1. +[13:17..13:17): -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). +[14:6..14:13): soLong1 <- a/b/Givens.soLong1. +[14:16..14:16): -> a/b/Givens.given_sayGoodbye_of_B.saySoLong(). +[16:8..16:14): Monoid <- a/b/Givens.Monoid# +[16:14..16:17): <- a/b/Givens.Monoid#``(). +[16:15..16:16): A <- a/b/Givens.Monoid#[A] +[17:8..17:13): empty <- a/b/Givens.Monoid#empty(). +[17:15..17:16): A -> a/b/Givens.Monoid#[A] +[18:8..18:15): (x: A) <- a/b/Givens.Monoid#combine(). +[18:9..18:10): x <- a/b/Givens.Monoid#combine().(x) +[18:12..18:13): A -> a/b/Givens.Monoid#[A] +[18:24..18:25): y <- a/b/Givens.Monoid#combine().(y) +[18:27..18:28): A -> a/b/Givens.Monoid#[A] +[18:31..18:32): A -> a/b/Givens.Monoid#[A] +[20:8..21:4): <- a/b/Givens.given_Monoid_String. +[20:8..20:14): Monoid -> a/b/Givens.Monoid# +[20:15..20:21): String -> scala/Predef.String# +[21:8..21:13): empty <- a/b/Givens.given_Monoid_String.empty(). +[22:8..22:15): (x: Str <- a/b/Givens.given_Monoid_String.combine(). +[22:9..22:10): x <- a/b/Givens.given_Monoid_String.combine().(x) +[22:12..22:18): String -> scala/Predef.String# +[22:29..22:30): y <- a/b/Givens.given_Monoid_String.combine().(y) +[22:32..22:38): String -> scala/Predef.String# +[22:42..22:43): x -> a/b/Givens.given_Monoid_String.combine().(x) +[22:44..22:45): + -> java/lang/String#`+`(). +[22:46..22:47): y -> a/b/Givens.given_Monoid_String.combine().(y) +[24:15..24:25): int2String <- a/b/Givens.int2String(). +[24:27..24:37): Conversion -> scala/Conversion# +[24:38..24:41): Int -> scala/Int# +[24:43..24:49): String -> scala/Predef.String# +[24:55..24:63): toString -> scala/Any#toString(). +[26:6..26:9): foo <- a/b/Givens.foo(). +[26:10..26:11): A <- a/b/Givens.foo().[A] +[26:19..26:20): A <- a/b/Givens.foo().(A) +[26:22..26:28): Monoid -> a/b/Givens.Monoid# +[26:29..26:30): A -> a/b/Givens.foo().[A] +[26:34..26:35): A -> a/b/Givens.foo().[A] +[26:38..26:39): A -> a/b/Givens.foo().(A) +[26:40..26:47): combine -> a/b/Givens.Monoid#combine(). +[26:48..26:49): A -> a/b/Givens.foo().(A) +[26:50..26:55): empty -> a/b/Givens.Monoid#empty(). +[26:57..26:58): A -> a/b/Givens.foo().(A) +[26:59..26:64): empty -> a/b/Givens.Monoid#empty(). + +expect/ImplicitConversion.scala +------------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => ImplicitConversion.scala +Text => empty +Language => Scala +Symbols => 23 entries +Occurrences => 62 entries + +Symbols: +example/ImplicitConversion# => class ImplicitConversion +example/ImplicitConversion#``(). => primary ctor +example/ImplicitConversion#a. => val method a +example/ImplicitConversion#b. => val method b +example/ImplicitConversion#char. => val method char +example/ImplicitConversion#message. => val method message +example/ImplicitConversion#number. => val method number +example/ImplicitConversion#string2Number(). => implicit method string2Number +example/ImplicitConversion#string2Number().(string) => param string +example/ImplicitConversion#tuple. => val method tuple +example/ImplicitConversion#x. => val method x +example/ImplicitConversion. => final object ImplicitConversion +example/ImplicitConversion.newAny2stringadd# => final class newAny2stringadd +example/ImplicitConversion.newAny2stringadd#[A] => typeparam A +example/ImplicitConversion.newAny2stringadd#`+`(). => method + +example/ImplicitConversion.newAny2stringadd#`+`().(other) => param other +example/ImplicitConversion.newAny2stringadd#``(). => primary ctor +example/ImplicitConversion.newAny2stringadd#``().(self) => param self +example/ImplicitConversion.newAny2stringadd#self. => val method self +example/ImplicitConversion.newAny2stringadd(). => final implicit method newAny2stringadd +example/ImplicitConversion.newAny2stringadd().(self) => param self +example/ImplicitConversion.newAny2stringadd().[A] => typeparam A +example/ImplicitConversion.newAny2stringadd. => final object newAny2stringadd + +Occurrences: +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:41): implicitConversions -> scalaShadowing/language.implicitConversions. +[4:6..4:24): ImplicitConversion <- example/ImplicitConversion# +[5:2..5:2): <- example/ImplicitConversion#``(). +[5:9..5:27): ImplicitConversion -> example/ImplicitConversion. +[6:15..6:28): string2Number <- example/ImplicitConversion#string2Number(). +[7:6..7:12): string <- example/ImplicitConversion#string2Number().(string) +[7:14..7:20): String -> scala/Predef.String# +[8:5..8:8): Int -> scala/Int# +[9:6..9:13): message <- example/ImplicitConversion#message. +[10:6..10:12): number <- example/ImplicitConversion#number. +[11:6..11:11): tuple <- example/ImplicitConversion#tuple. +[11:15..11:15): -> scala/Tuple2.apply(). +[12:6..12:10): char <- example/ImplicitConversion#char. +[12:12..12:16): Char -> scala/Char# +[15:2..15:2): -> scala/Predef.augmentString(). +[15:2..15:9): message -> example/ImplicitConversion#message. +[16:5..16:16): stripSuffix -> scala/collection/StringOps#stripSuffix(). +[17:2..17:2): -> example/ImplicitConversion.newAny2stringadd(). +[17:2..17:7): tuple -> example/ImplicitConversion#tuple. +[17:8..17:9): + -> example/ImplicitConversion.newAny2stringadd#`+`(). +[20:6..20:7): x <- example/ImplicitConversion#x. +[20:9..20:12): Int -> scala/Int# +[20:15..20:15): -> example/ImplicitConversion#string2Number(). +[20:15..20:22): message -> example/ImplicitConversion#message. +[23:4..23:4): -> scala/StringContext.apply(). +[23:11..23:18): message -> example/ImplicitConversion#message. +[23:20..23:26): number -> example/ImplicitConversion#number. +[23:26..23:26): -> scala/StringContext#s(). +[24:2..24:2): -> scala/Predef.augmentString(). +[24:6..24:6): -> scala/StringContext.apply(). +[25:7..25:14): message -> example/ImplicitConversion#message. +[26:7..26:13): number -> example/ImplicitConversion#number. +[26:13..26:13): -> scala/StringContext#s(). +[26:17..26:28): stripMargin -> scala/collection/StringOps#stripMargin(+1). +[28:6..28:7): a <- example/ImplicitConversion#a. +[28:9..28:12): Int -> scala/Int# +[28:15..28:15): -> scala/Char.char2int(). +[28:15..28:19): char -> example/ImplicitConversion#char. +[29:6..29:7): b <- example/ImplicitConversion#b. +[29:9..29:13): Long -> scala/Long# +[29:16..29:16): -> scala/Char.char2long(). +[29:16..29:20): char -> example/ImplicitConversion#char. +[32:7..32:25): ImplicitConversion <- example/ImplicitConversion. +[33:23..33:39): newAny2stringadd <- example/ImplicitConversion.newAny2stringadd# +[33:39..33:63): <- example/ImplicitConversion.newAny2stringadd#``(). +[33:40..33:41): A <- example/ImplicitConversion.newAny2stringadd#[A] +[33:55..33:59): self <- example/ImplicitConversion.newAny2stringadd#self. +[33:61..33:62): A -> example/ImplicitConversion.newAny2stringadd#[A] +[33:72..33:78): AnyVal -> scala/AnyVal# +[33:78..33:78): -> scala/AnyVal#``(). +[34:8..34:9): + <- example/ImplicitConversion.newAny2stringadd#`+`(). +[34:10..34:15): other <- example/ImplicitConversion.newAny2stringadd#`+`().(other) +[34:17..34:23): String -> scala/Predef.String# +[34:26..34:32): String -> scala/Predef.String# +[34:35..34:41): String -> java/lang/String# +[34:42..34:49): valueOf -> java/lang/String#valueOf(). +[34:50..34:54): self -> example/ImplicitConversion.newAny2stringadd#self. +[34:56..34:57): + -> java/lang/String#`+`(). +[34:58..34:63): other -> example/ImplicitConversion.newAny2stringadd#`+`().(other) + +expect/Imports.scala +-------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Imports.scala +Text => empty +Language => Scala +Symbols => 0 entries +Occurrences => 4 entries + +Symbols: + +Occurrences: +[0:7..0:12): scala -> scala/ +[0:13..0:17): util -> scala/util/ +[0:18..0:25): control -> scala/util/control/ +[0:26..0:34): NonFatal -> scala/util/control/NonFatal. + +expect/InstrumentTyper.scala +---------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => InstrumentTyper.scala +Text => empty +Language => Scala +Symbols => 8 entries +Occurrences => 55 entries + +Symbols: +example/InstrumentTyper# => class InstrumentTyper +example/InstrumentTyper#AnnotatedType# => type AnnotatedType +example/InstrumentTyper#``(). => primary ctor +example/InstrumentTyper#all(). => method all +example/InstrumentTyper#clazzOf. => final val method clazzOf +example/InstrumentTyper#singletonType(). => method singletonType +example/InstrumentTyper#singletonType().(x) => param x +local0 => selfparam self + +Occurrences: +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:23): annotation -> scala/annotation/ +[2:24..2:28): meta -> scala/annotation/meta/ +[2:29..2:34): param -> scala/annotation/meta/param. +[3:7..3:12): scala -> scala/ +[3:13..3:21): language -> scalaShadowing/language. +[3:22..3:34): existentials -> scalaShadowing/language.existentials. +[4:7..4:12): scala -> scala/ +[4:13..4:21): language -> scalaShadowing/language. +[4:22..4:33): higherKinds -> scalaShadowing/language.higherKinds. +[5:7..5:12): types -> types/ +[5:13..5:17): Test -> types/Test. +[7:6..7:21): InstrumentTyper <- example/InstrumentTyper# +[7:24..7:24): <- example/InstrumentTyper#``(). +[7:24..7:28): self <- local0 +[7:30..7:36): AnyRef -> scala/AnyRef# +[8:6..8:9): all <- example/InstrumentTyper#all(). +[8:12..8:16): List -> scala/package.List. +[8:16..8:16): -> scala/collection/IterableFactory#apply(). +[9:4..9:11): Literal -> types/Test.Literal. +[9:12..9:15): int -> types/Test.Literal.int. +[10:4..10:11): Literal -> types/Test.Literal. +[10:12..10:16): long -> types/Test.Literal.long. +[11:4..11:11): Literal -> types/Test.Literal. +[11:12..11:17): float -> types/Test.Literal.float. +[12:4..12:11): Literal -> types/Test.Literal. +[12:12..12:18): double -> types/Test.Literal.double. +[13:4..13:11): Literal -> types/Test.Literal. +[13:12..13:15): nil -> types/Test.Literal.nil. +[14:4..14:11): Literal -> types/Test.Literal. +[14:12..14:16): char -> types/Test.Literal.char. +[15:4..15:11): Literal -> types/Test.Literal. +[15:12..15:18): string -> types/Test.Literal.string. +[16:4..16:11): Literal -> types/Test.Literal. +[16:12..16:16): bool -> types/Test.Literal.bool. +[17:4..17:11): Literal -> types/Test.Literal. +[17:12..17:16): unit -> types/Test.Literal.unit. +[18:4..18:11): Literal -> types/Test.Literal. +[18:12..18:20): javaEnum -> types/Test.Literal.javaEnum. +[19:4..19:11): Literal -> types/Test.Literal. +[19:12..19:19): clazzOf -> types/Test.Literal.clazzOf. +[20:4..20:8): List -> scala/package.List. +[20:8..20:8): -> scala/collection/IterableFactory#apply(). +[22:7..22:20): AnnotatedType <- example/InstrumentTyper#AnnotatedType# +[22:23..22:26): Int -> scala/Int# +[22:28..22:33): param -> scala/annotation/meta/param# +[23:6..23:19): singletonType <- example/InstrumentTyper#singletonType(). +[23:20..23:21): x <- example/InstrumentTyper#singletonType().(x) +[23:23..23:29): Predef -> scala/Predef. +[23:38..23:41): ??? -> scala/Predef.`???`(). +[24:12..24:19): clazzOf <- example/InstrumentTyper#clazzOf. +[24:22..24:29): classOf -> scala/Predef.classOf(). +[24:30..24:36): Option -> scala/Option# +[24:37..24:40): Int -> scala/Int# + +expect/Issue1749.scala +---------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Issue1749.scala +Text => empty +Language => Scala +Symbols => 7 entries +Occurrences => 30 entries + +Symbols: +example/Issue1749# => class Issue1749 +example/Issue1749#``(). => primary ctor +example/Issue1749#x1. => val method x1 +example/Issue1749#x2. => val method x2 +example/Issue1854# => class Issue1854 +example/Issue1854#``(). => primary ctor +example/Issue1854#map. => val method map + +Occurrences: +[1:8..1:15): example <- example/ +[3:7..3:12): scala -> scala/ +[3:13..3:17): math -> scala/math/ +[3:18..3:25): Ordered -> scala/math/Ordered. +[3:26..3:43): orderingToOrdered -> scala/math/Ordered.orderingToOrdered(). +[5:6..5:15): Issue1749 <- example/Issue1749# +[6:2..6:2): <- example/Issue1749#``(). +[6:6..6:8): x1 <- example/Issue1749#x1. +[7:6..7:8): x2 <- example/Issue1749#x2. +[8:2..8:2): -> scala/math/Ordered.orderingToOrdered(). +[8:3..8:3): -> scala/Tuple2.apply(). +[8:3..8:5): x1 -> example/Issue1749#x1. +[8:7..8:9): x1 -> example/Issue1749#x1. +[8:10..8:10): -> scala/math/Ordering.Tuple2(). +[8:10..8:10): -> scala/math/Ordering.Int. +[9:5..9:12): compare -> scala/math/Ordered#compare(). +[9:14..9:14): -> scala/Tuple2.apply(). +[9:14..9:16): x2 -> example/Issue1749#x2. +[9:18..9:20): x2 -> example/Issue1749#x2. +[12:6..12:15): Issue1854 <- example/Issue1854# +[13:2..13:2): <- example/Issue1854#``(). +[13:6..13:9): map <- example/Issue1854#map. +[13:12..13:22): collection -> scala/collection/ +[13:23..13:30): mutable -> scala/collection/mutable/ +[13:31..13:34): Map -> scala/collection/mutable/Map. +[13:35..13:40): empty -> scala/collection/MapFactory.Delegate#empty(). +[13:41..13:47): String -> scala/Predef.String# +[13:49..13:55): String -> scala/Predef.String# +[14:2..14:5): map -> example/Issue1854#map. +[14:5..14:5): -> scala/collection/mutable/MapOps#update(). + +expect/Local.scala +------------------ + +Summary: +Schema => SemanticDB v4 +Uri => Local.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 11 entries + +Symbols: +example/Local# => class Local +example/Local#``(). => primary ctor +example/Local#a(). => method a +local0 => local id +local1 => typeparam A +local2 => param a + +Occurrences: +[0:8..0:15): example <- example/ +[2:6..2:11): Local <- example/Local# +[3:2..3:2): <- example/Local#``(). +[3:6..3:7): a <- example/Local#a(). +[4:8..4:10): id <- local0 +[4:11..4:12): A <- local1 +[4:14..4:15): a <- local2 +[4:17..4:18): A -> local1 +[4:21..4:22): A -> local1 +[4:25..4:26): a -> local2 +[5:4..5:6): id -> local0 + +expect/Locals.scala +------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Locals.scala +Text => empty +Language => Scala +Symbols => 3 entries +Occurrences => 7 entries + +Symbols: +local0 => val local x +locals/Test. => final object Test +locals/Test.xs. => val method xs + +Occurrences: +[0:8..0:14): locals <- locals/ +[2:7..2:11): Test <- locals/Test. +[3:6..3:8): xs <- locals/Test.xs. +[4:8..4:9): x <- local0 +[5:4..5:8): List -> scala/package.List. +[5:8..5:8): -> scala/collection/IterableFactory#apply(). +[5:9..5:10): x -> local0 + +expect/MetacJava.scala +---------------------- + +Summary: +Schema => SemanticDB v4 +Uri => MetacJava.scala +Text => empty +Language => Scala +Symbols => 10 entries +Occurrences => 72 entries + +Symbols: +example/MetacJava# => class MetacJava +example/MetacJava#``(). => primary ctor +example/MetacJava#coin. => val method coin +example/MetacJava#entry. => val method entry +example/MetacJava#inner. => val method inner +example/MetacJava#interface. => val method interface +example/MetacJava#nonStatic. => val method nonStatic +example/MetacJava#overload1. => val method overload1 +example/MetacJava#overload2. => val method overload2 +example/MetacJava#staticInner. => val method staticInner + +Occurrences: +[0:8..0:15): example <- example/ +[2:7..2:10): com -> com/ +[2:11..2:17): javacp -> com/javacp/ +[4:6..4:15): MetacJava <- example/MetacJava# +[5:2..5:2): <- example/MetacJava#``(). +[5:2..5:8): javacp -> com/javacp/ +[5:9..5:18): MetacJava -> com/javacp/MetacJava# +[5:19..5:30): StaticInner -> com/javacp/MetacJava#StaticInner# +[5:31..5:39): isStatic -> com/javacp/MetacJava#StaticInner#isStatic(). +[6:6..6:12): javacp -> com/javacp/ +[6:13..6:22): MetacJava -> com/javacp/MetacJava# +[6:23..6:34): StaticInner -> com/javacp/MetacJava#StaticInner# +[6:34..6:34): -> com/javacp/MetacJava#StaticInner#``(). +[6:37..6:48): isNotStatic -> com/javacp/MetacJava#StaticInner#isNotStatic(). +[7:6..7:11): inner <- example/MetacJava#inner. +[7:18..7:24): javacp -> com/javacp/ +[7:25..7:34): MetacJava -> com/javacp/MetacJava# +[7:34..7:34): -> com/javacp/MetacJava#``(). +[8:6..8:15): overload1 <- example/MetacJava#overload1. +[8:22..8:27): inner -> example/MetacJava#inner. +[8:28..8:37): Overload1 -> com/javacp/MetacJava#Overload1# +[8:37..8:37): -> com/javacp/MetacJava#Overload1#``(). +[9:6..9:15): overload2 <- example/MetacJava#overload2. +[9:22..9:27): inner -> example/MetacJava#inner. +[9:28..9:37): Overload2 -> com/javacp/MetacJava#Overload2# +[9:37..9:37): -> com/javacp/MetacJava#Overload2#``(). +[10:2..10:7): inner -> example/MetacJava#inner. +[10:8..10:16): overload -> com/javacp/MetacJava#overload(). +[10:21..10:30): overload1 -> example/MetacJava#overload1. +[10:31..10:32): A -> com/javacp/MetacJava#Overload1#A# +[10:32..10:32): -> com/javacp/MetacJava#Overload1#A#``(). +[11:2..11:7): inner -> example/MetacJava#inner. +[11:8..11:16): overload -> com/javacp/MetacJava#overload(+1). +[11:21..11:30): overload2 -> example/MetacJava#overload2. +[11:31..11:32): A -> com/javacp/MetacJava#Overload2#A# +[11:32..11:32): -> com/javacp/MetacJava#Overload2#A#``(). +[12:6..12:17): staticInner <- example/MetacJava#staticInner. +[12:24..12:30): javacp -> com/javacp/ +[12:31..12:40): MetacJava -> com/javacp/MetacJava# +[12:41..12:52): StaticInner -> com/javacp/MetacJava#StaticInner# +[12:52..12:52): -> com/javacp/MetacJava#StaticInner#``(). +[13:6..13:15): nonStatic <- example/MetacJava#nonStatic. +[13:22..13:33): staticInner -> example/MetacJava#staticInner. +[13:34..13:43): NonStatic -> com/javacp/MetacJava#StaticInner#NonStatic# +[13:43..13:43): -> com/javacp/MetacJava#StaticInner#NonStatic#``(). +[14:2..14:11): nonStatic -> example/MetacJava#nonStatic. +[14:12..14:18): method -> com/javacp/MetacJava#StaticInner#NonStatic#method(). +[14:19..14:28): nonStatic -> example/MetacJava#nonStatic. +[15:2..15:8): javacp -> com/javacp/ +[15:9..15:18): MetacJava -> com/javacp/MetacJava# +[15:19..15:27): overload -> com/javacp/MetacJava#overload(+2). +[15:32..15:38): javacp -> com/javacp/ +[15:39..15:48): MetacJava -> com/javacp/MetacJava# +[15:49..15:58): Overload3 -> com/javacp/MetacJava#Overload3# +[15:59..15:60): A -> com/javacp/MetacJava#Overload3#A# +[15:60..15:60): -> com/javacp/MetacJava#Overload3#A#``(). +[16:6..16:15): interface <- example/MetacJava#interface. +[16:17..16:23): javacp -> com/javacp/ +[16:24..16:33): Interface -> com/javacp/Interface# +[17:6..17:10): coin <- example/MetacJava#coin. +[17:12..17:18): javacp -> com/javacp/ +[17:19..17:23): Coin -> com/javacp/Coin# +[17:26..17:32): javacp -> com/javacp/ +[17:33..17:37): Coin -> com/javacp/Coin# +[17:38..17:43): PENNY -> com/javacp/Coin#PENNY. +[18:6..18:11): entry <- example/MetacJava#entry. +[18:13..18:17): java -> java/ +[18:18..18:22): util -> java/util/ +[18:23..18:26): Map -> java/util/Map# +[18:27..18:32): Entry -> java/util/Map#Entry# +[18:33..18:36): Int -> scala/Int# +[18:38..18:41): Int -> scala/Int# + +expect/MethodUsages.scala +------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => MethodUsages.scala +Text => empty +Language => Scala +Symbols => 3 entries +Occurrences => 76 entries + +Symbols: +example/MethodUsages# => class MethodUsages +example/MethodUsages#``(). => primary ctor +example/MethodUsages#m. => val method m + +Occurrences: +[0:8..0:15): example <- example/ +[2:6..2:18): MethodUsages <- example/MethodUsages# +[3:2..3:2): <- example/MethodUsages#``(). +[3:6..3:7): m <- example/MethodUsages#m. +[3:14..3:21): Methods -> example/Methods# +[3:22..3:25): Int -> scala/Int# +[3:26..3:26): -> example/Methods#``(). +[4:2..4:3): m -> example/MethodUsages#m. +[4:4..4:6): m1 -> example/Methods#m1(). +[5:2..5:3): m -> example/MethodUsages#m. +[5:4..5:6): m2 -> example/Methods#m2(). +[6:2..6:3): m -> example/MethodUsages#m. +[6:4..6:6): m3 -> example/Methods#m3(). +[7:2..7:3): m -> example/MethodUsages#m. +[7:4..7:6): m4 -> example/Methods#m4(). +[8:2..8:3): m -> example/MethodUsages#m. +[8:4..8:6): m5 -> example/Methods#m5(). +[9:2..9:3): m -> example/MethodUsages#m. +[9:4..9:6): m5 -> example/Methods#m5(+1). +[10:2..10:3): m -> example/MethodUsages#m. +[10:4..10:6): m6 -> example/Methods#m6(). +[11:2..11:3): m -> example/MethodUsages#m. +[11:4..11:6): m6 -> example/Methods#m6(+1). +[11:11..11:12): m -> example/MethodUsages#m. +[11:13..11:17): List -> example/Methods#List# +[11:18..11:21): Int -> scala/Int# +[11:22..11:22): -> example/Methods#List#``(). +[12:2..12:3): m -> example/MethodUsages#m. +[12:4..12:6): m6 -> example/Methods#m6(+2). +[12:7..12:10): Nil -> scala/package.Nil. +[13:2..13:3): m -> example/MethodUsages#m. +[13:4..13:6): m7 -> example/Methods#m7(). +[13:7..13:8): m -> example/MethodUsages#m. +[13:14..13:15): m -> example/MethodUsages#m. +[13:16..13:20): List -> example/Methods#List# +[13:21..13:24): Int -> scala/Int# +[13:25..13:25): -> example/Methods#List#``(). +[13:26..13:26): -> scala/math/Ordering.Int. +[14:2..14:3): m -> example/MethodUsages#m. +[14:4..14:11): `m8().` -> example/Methods#`m8().`(). +[15:2..15:3): m -> example/MethodUsages#m. +[15:4..15:6): m9 -> example/Methods#m9(). +[16:2..16:3): m -> example/MethodUsages#m. +[16:4..16:7): m10 -> example/Methods#m10(). +[17:2..17:3): m -> example/MethodUsages#m. +[17:4..17:7): m11 -> example/Methods#m11(). +[17:8..17:14): Predef -> scala/Predef. +[18:2..18:3): m -> example/MethodUsages#m. +[18:4..18:7): m11 -> example/Methods#m11(+1). +[18:8..18:15): Example -> example/Example. +[19:2..19:3): m -> example/MethodUsages#m. +[19:4..19:8): m12a -> example/Methods#m12a(). +[20:2..20:3): m -> example/MethodUsages#m. +[20:4..20:8): m12b -> example/Methods#m12b(). +[21:2..21:3): m -> example/MethodUsages#m. +[21:4..21:7): m13 -> example/Methods#m13(). +[22:2..22:3): m -> example/MethodUsages#m. +[22:4..22:7): m15 -> example/Methods#m15(). +[23:2..23:3): m -> example/MethodUsages#m. +[23:4..23:7): m16 -> example/Methods#m16(). +[24:2..24:3): m -> example/MethodUsages#m. +[24:4..24:7): m16 -> example/Methods#m16(). +[25:2..25:3): m -> example/MethodUsages#m. +[25:4..25:7): m17 -> example/Methods#m17. +[25:8..25:9): m -> example/Methods#m17.m(). +[26:2..26:3): m -> example/MethodUsages#m. +[26:4..26:7): m17 -> example/Methods#m17(). +[27:2..27:3): m -> example/MethodUsages#m. +[27:4..27:7): m17 -> example/Methods#m17(+1). +[28:2..28:3): m -> example/MethodUsages#m. +[28:4..28:7): m18 -> example/Methods#m18. +[28:8..28:9): m -> example/Methods#m17.m(). +[29:2..29:3): m -> example/MethodUsages#m. +[29:4..29:7): m18 -> example/Methods#m18(). +[30:2..30:3): m -> example/MethodUsages#m. +[30:4..30:7): m18 -> example/Methods#m18(+1). + +expect/Methods.scala +-------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Methods.scala +Text => empty +Language => Scala +Symbols => 70 entries +Occurrences => 139 entries + +Symbols: +example/Methods# => class Methods +example/Methods#AList# => type AList +example/Methods#AList#[T] => typeparam T +example/Methods#List# => class List +example/Methods#List#[T] => typeparam T +example/Methods#List#``(). => primary ctor +example/Methods#[T] => typeparam T +example/Methods#``(). => primary ctor +example/Methods#`m8().`(). => method m8(). +example/Methods#`m9().`# => class m9(). +example/Methods#`m9().`#``(). => primary ctor +example/Methods#m1(). => method m1 +example/Methods#m2(). => method m2 +example/Methods#m3(). => method m3 +example/Methods#m3().(x) => param x +example/Methods#m4(). => method m4 +example/Methods#m4().(x) => param x +example/Methods#m4().(y) => param y +example/Methods#m5(). => method m5 +example/Methods#m5().(x) => param x +example/Methods#m5(+1). => method m5 +example/Methods#m5(+1).(x) => param x +example/Methods#m6(). => method m6 +example/Methods#m6().(x) => param x +example/Methods#m6(+1). => method m6 +example/Methods#m6(+1).(x) => param x +example/Methods#m6(+2). => method m6 +example/Methods#m6(+2).(x) => param x +example/Methods#m7(). => method m7 +example/Methods#m7().(c) => param c +example/Methods#m7().(l) => param l +example/Methods#m7().[U] => typeparam U +example/Methods#m9(). => method m9 +example/Methods#m9().(x) => param x +example/Methods#m10(). => method m10 +example/Methods#m10().(x) => param x +example/Methods#m11(). => method m11 +example/Methods#m11().(x) => param x +example/Methods#m11(+1). => method m11 +example/Methods#m11(+1).(x) => param x +example/Methods#m12a(). => method m12a +example/Methods#m12a().(x) => param x +example/Methods#m12b(). => method m12b +example/Methods#m12b().(x) => param x +example/Methods#m13(). => method m13 +example/Methods#m13().(x) => param x +example/Methods#m15(). => method m15 +example/Methods#m15().(x) => param x +example/Methods#m16(). => method m16 +example/Methods#m16().(x) => param x +example/Methods#m17(). => method m17 +example/Methods#m17().(a) => param a +example/Methods#m17(+1). => method m17 +example/Methods#m17(+1).(b) => param b +example/Methods#m17. => final object m17 +example/Methods#m17.m(). => method m +example/Methods#m18(). => method m18 +example/Methods#m18().(a) => param a +example/Methods#m18(+1). => method m18 +example/Methods#m18(+1).(b) => param b +example/Methods#m18. => val method m18 +example/Methods#m19$default$2(). => method m19$default$2 +example/Methods#m19$default$3(). => method m19$default$3 +example/Methods#m19$default$3().(x) => param x +example/Methods#m19$default$3().(y) => param y +example/Methods#m19(). => method m19 +example/Methods#m19().(x) => param x +example/Methods#m19().(y) => param y +example/Methods#m19().(z) => param z +local0 => abstract val method x + +Occurrences: +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:17): math -> scala/math/ +[2:18..2:26): Ordering -> scala/math/Ordering. +[2:18..2:26): Ordering -> scala/math/Ordering# +[3:7..3:12): scala -> scala/ +[3:13..3:21): language -> scalaShadowing/language. +[3:22..3:34): existentials -> scalaShadowing/language.existentials. +[5:6..5:13): Methods <- example/Methods# +[5:13..5:16): <- example/Methods#``(). +[5:14..5:15): T <- example/Methods#[T] +[6:8..6:12): List <- example/Methods#List# +[6:12..6:15): <- example/Methods#List#``(). +[6:13..6:14): T <- example/Methods#List#[T] +[7:7..7:12): AList <- example/Methods#AList# +[7:13..7:14): T <- example/Methods#AList#[T] +[7:18..7:22): List -> example/Methods#List# +[7:23..7:24): T -> example/Methods#AList#[T] +[8:6..8:8): m1 <- example/Methods#m1(). +[8:11..8:14): ??? -> scala/Predef.`???`(). +[9:6..9:8): m2 <- example/Methods#m2(). +[9:13..9:16): ??? -> scala/Predef.`???`(). +[10:6..10:8): m3 <- example/Methods#m3(). +[10:9..10:10): x <- example/Methods#m3().(x) +[10:12..10:15): Int -> scala/Int# +[10:19..10:22): ??? -> scala/Predef.`???`(). +[11:6..11:8): m4 <- example/Methods#m4(). +[11:9..11:10): x <- example/Methods#m4().(x) +[11:12..11:15): Int -> scala/Int# +[11:17..11:18): y <- example/Methods#m4().(y) +[11:20..11:23): Int -> scala/Int# +[11:27..11:30): ??? -> scala/Predef.`???`(). +[12:6..12:8): m5 <- example/Methods#m5(). +[12:9..12:10): x <- example/Methods#m5().(x) +[12:12..12:18): String -> scala/Predef.String# +[12:22..12:25): ??? -> scala/Predef.`???`(). +[13:6..13:8): m5 <- example/Methods#m5(+1). +[13:9..13:10): x <- example/Methods#m5(+1).(x) +[13:12..13:15): Int -> scala/Int# +[13:19..13:22): ??? -> scala/Predef.`???`(). +[14:6..14:8): m6 <- example/Methods#m6(). +[14:9..14:10): x <- example/Methods#m6().(x) +[14:12..14:15): Int -> scala/Int# +[14:19..14:22): ??? -> scala/Predef.`???`(). +[15:6..15:8): m6 <- example/Methods#m6(+1). +[15:9..15:10): x <- example/Methods#m6(+1).(x) +[15:12..15:16): List -> example/Methods#List# +[15:17..15:18): T -> example/Methods#[T] +[15:23..15:26): ??? -> scala/Predef.`???`(). +[16:6..16:8): m6 <- example/Methods#m6(+2). +[16:9..16:10): x <- example/Methods#m6(+2).(x) +[16:12..16:17): scala -> scala/ +[16:18..16:22): List -> scala/package.List# +[16:23..16:24): T -> example/Methods#[T] +[16:29..16:32): ??? -> scala/Predef.`???`(). +[17:6..17:8): m7 <- example/Methods#m7(). +[17:9..17:10): U <- example/Methods#m7().[U] +[17:12..17:20): Ordering -> scala/math/Ordering# +[17:20..17:20): -> example/Methods#m7().[U] +[17:22..17:23): c <- example/Methods#m7().(c) +[17:25..17:32): Methods -> example/Methods# +[17:33..17:34): T -> example/Methods#[T] +[17:37..17:38): l <- example/Methods#m7().(l) +[17:40..17:44): List -> example/Methods#List# +[17:45..17:46): U -> example/Methods#m7().[U] +[17:51..17:54): ??? -> scala/Predef.`???`(). +[18:7..18:12): m8(). <- example/Methods#`m8().`(). +[18:18..18:21): ??? -> scala/Predef.`???`(). +[19:2..19:2): <- example/Methods#`m9().`#``(). +[19:9..19:14): m9(). <- example/Methods#`m9().`# +[20:6..20:8): m9 <- example/Methods#m9(). +[20:9..20:10): x <- example/Methods#m9().(x) +[20:12..20:19): `m9().` -> example/Methods#`m9().`# +[20:23..20:26): ??? -> scala/Predef.`???`(). +[21:6..21:9): m10 <- example/Methods#m10(). +[21:10..21:11): x <- example/Methods#m10().(x) +[21:13..21:18): AList -> example/Methods#AList# +[21:19..21:20): T -> example/Methods#[T] +[21:25..21:28): ??? -> scala/Predef.`???`(). +[22:6..22:9): m11 <- example/Methods#m11(). +[22:10..22:11): x <- example/Methods#m11().(x) +[22:13..22:19): Predef -> scala/Predef. +[22:28..22:31): ??? -> scala/Predef.`???`(). +[23:6..23:9): m11 <- example/Methods#m11(+1). +[23:10..23:11): x <- example/Methods#m11(+1).(x) +[23:13..23:20): Example -> example/Example. +[23:29..23:32): ??? -> scala/Predef.`???`(). +[24:6..24:10): m12a <- example/Methods#m12a(). +[24:11..24:12): x <- example/Methods#m12a().(x) +[24:20..24:23): ??? -> scala/Predef.`???`(). +[25:6..25:10): m12b <- example/Methods#m12b(). +[25:11..25:12): x <- example/Methods#m12b().(x) +[25:20..25:21): x <- local0 +[25:23..25:26): Int -> scala/Int# +[25:32..25:35): ??? -> scala/Predef.`???`(). +[26:6..26:9): m13 <- example/Methods#m13(). +[26:10..26:11): x <- example/Methods#m13().(x) +[26:13..26:16): Int -> scala/Int# +[26:18..26:27): unchecked -> scala/unchecked# +[26:31..26:34): ??? -> scala/Predef.`???`(). +[27:6..27:9): m15 <- example/Methods#m15(). +[27:10..27:11): x <- example/Methods#m15().(x) +[27:16..27:19): Int -> scala/Int# +[27:23..27:26): ??? -> scala/Predef.`???`(). +[28:6..28:9): m16 <- example/Methods#m16(). +[28:10..28:11): x <- example/Methods#m16().(x) +[28:13..28:16): Int -> scala/Int# +[28:21..28:24): ??? -> scala/Predef.`???`(). +[29:9..29:12): m17 <- example/Methods#m17. +[29:19..29:20): m <- example/Methods#m17.m(). +[29:25..29:28): ??? -> scala/Predef.`???`(). +[30:6..30:9): m17 <- example/Methods#m17(). +[30:10..30:11): a <- example/Methods#m17().(a) +[30:13..30:16): Int -> scala/Int# +[30:20..30:23): ??? -> scala/Predef.`???`(). +[31:6..31:9): m17 <- example/Methods#m17(+1). +[31:10..31:11): b <- example/Methods#m17(+1).(b) +[31:13..31:19): String -> scala/Predef.String# +[31:23..31:26): ??? -> scala/Predef.`???`(). +[32:6..32:9): m18 <- example/Methods#m18. +[32:12..32:15): m17 -> example/Methods#m17. +[33:6..33:9): m18 <- example/Methods#m18(). +[33:10..33:11): a <- example/Methods#m18().(a) +[33:13..33:16): Int -> scala/Int# +[33:20..33:23): ??? -> scala/Predef.`???`(). +[34:6..34:9): m18 <- example/Methods#m18(+1). +[34:10..34:11): b <- example/Methods#m18(+1).(b) +[34:13..34:19): String -> scala/Predef.String# +[34:23..34:26): ??? -> scala/Predef.`???`(). +[35:6..35:9): m19 <- example/Methods#m19(). +[35:10..35:11): x <- example/Methods#m19().(x) +[35:10..35:11): x <- example/Methods#m19$default$3().(x) +[35:13..35:16): Int -> scala/Int# +[35:18..35:19): y <- example/Methods#m19().(y) +[35:18..35:19): y <- example/Methods#m19$default$3().(y) +[35:21..35:24): Int -> scala/Int# +[35:30..35:31): z <- example/Methods#m19().(z) +[35:33..35:36): Int -> scala/Int# +[35:44..35:47): ??? -> scala/Predef.`???`(). + +expect/NamedApplyBlock.scala +---------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => NamedApplyBlock.scala +Text => empty +Language => Scala +Symbols => 45 entries +Occurrences => 46 entries + +Symbols: +example/NamedApplyBlockCaseClassConstruction. => final object NamedApplyBlockCaseClassConstruction +example/NamedApplyBlockCaseClassConstruction.Msg# => case class Msg +example/NamedApplyBlockCaseClassConstruction.Msg#_1(). => method _1 +example/NamedApplyBlockCaseClassConstruction.Msg#_2(). => method _2 +example/NamedApplyBlockCaseClassConstruction.Msg#_3(). => method _3 +example/NamedApplyBlockCaseClassConstruction.Msg#``(). => primary ctor +example/NamedApplyBlockCaseClassConstruction.Msg#``().(body) => val param body +example/NamedApplyBlockCaseClassConstruction.Msg#``().(head) => val param head +example/NamedApplyBlockCaseClassConstruction.Msg#``().(tail) => val param tail +example/NamedApplyBlockCaseClassConstruction.Msg#body. => val method body +example/NamedApplyBlockCaseClassConstruction.Msg#copy$default$1(). => method copy$default$1 +example/NamedApplyBlockCaseClassConstruction.Msg#copy$default$2(). => method copy$default$2 +example/NamedApplyBlockCaseClassConstruction.Msg#copy$default$3(). => method copy$default$3 +example/NamedApplyBlockCaseClassConstruction.Msg#copy(). => method copy +example/NamedApplyBlockCaseClassConstruction.Msg#copy().(body) => param body +example/NamedApplyBlockCaseClassConstruction.Msg#copy().(head) => param head +example/NamedApplyBlockCaseClassConstruction.Msg#copy().(tail) => param tail +example/NamedApplyBlockCaseClassConstruction.Msg#head. => val method head +example/NamedApplyBlockCaseClassConstruction.Msg#tail. => val method tail +example/NamedApplyBlockCaseClassConstruction.Msg. => final object Msg +example/NamedApplyBlockCaseClassConstruction.Msg.$lessinit$greater$default$2(). => method $lessinit$greater$default$2 +example/NamedApplyBlockCaseClassConstruction.Msg.apply(). => method apply +example/NamedApplyBlockCaseClassConstruction.Msg.apply().(body) => param body +example/NamedApplyBlockCaseClassConstruction.Msg.apply().(head) => param head +example/NamedApplyBlockCaseClassConstruction.Msg.apply().(tail) => param tail +example/NamedApplyBlockCaseClassConstruction.Msg.unapply(). => method unapply +example/NamedApplyBlockCaseClassConstruction.Msg.unapply().(x$1) => param x$1 +example/NamedApplyBlockCaseClassConstruction.bodyText. => val method bodyText +example/NamedApplyBlockCaseClassConstruction.msg. => val method msg +example/NamedApplyBlockMethods. => final object NamedApplyBlockMethods +example/NamedApplyBlockMethods.baseCase(). => method baseCase +example/NamedApplyBlockMethods.foo$default$1(). => method foo$default$1 +example/NamedApplyBlockMethods.foo$default$2(). => method foo$default$2 +example/NamedApplyBlockMethods.foo$default$3(). => method foo$default$3 +example/NamedApplyBlockMethods.foo(). => method foo +example/NamedApplyBlockMethods.foo().(a) => param a +example/NamedApplyBlockMethods.foo().(b) => param b +example/NamedApplyBlockMethods.foo().(c) => param c +example/NamedApplyBlockMethods.local. => val method local +example/NamedApplyBlockMethods.recursive(). => method recursive +local0 => val local b$1 +local1 => val local c$1 +local2 => val local b$3 +local3 => val local b$2 +local4 => val local head$1 + +Occurrences: +[0:8..0:15): example <- example/ +[2:7..2:29): NamedApplyBlockMethods <- example/NamedApplyBlockMethods. +[3:6..3:11): local <- example/NamedApplyBlockMethods.local. +[4:6..4:9): foo <- example/NamedApplyBlockMethods.foo(). +[4:10..4:11): a <- example/NamedApplyBlockMethods.foo().(a) +[4:13..4:16): Int -> scala/Int# +[4:22..4:23): b <- example/NamedApplyBlockMethods.foo().(b) +[4:25..4:28): Int -> scala/Int# +[4:34..4:35): c <- example/NamedApplyBlockMethods.foo().(c) +[4:37..4:40): Int -> scala/Int# +[4:47..4:50): Int -> scala/Int# +[4:53..4:54): a -> example/NamedApplyBlockMethods.foo().(a) +[4:55..4:56): + -> scala/Int#`+`(+4). +[4:57..4:58): b -> example/NamedApplyBlockMethods.foo().(b) +[4:59..4:60): + -> scala/Int#`+`(+4). +[4:61..4:62): c -> example/NamedApplyBlockMethods.foo().(c) +[5:6..5:14): baseCase <- example/NamedApplyBlockMethods.baseCase(). +[5:17..5:20): foo -> example/NamedApplyBlockMethods.foo(). +[5:17..5:17): -> local0 +[5:21..5:26): local -> example/NamedApplyBlockMethods.local. +[5:28..5:29): c -> example/NamedApplyBlockMethods.foo().(c) +[6:6..6:15): recursive <- example/NamedApplyBlockMethods.recursive(). +[6:18..6:21): foo -> example/NamedApplyBlockMethods.foo(). +[6:18..6:18): -> local2 +[6:22..6:27): local -> example/NamedApplyBlockMethods.local. +[6:29..6:30): c -> example/NamedApplyBlockMethods.foo().(c) +[6:33..6:36): foo -> example/NamedApplyBlockMethods.foo(). +[6:33..6:33): -> local3 +[6:37..6:42): local -> example/NamedApplyBlockMethods.local. +[6:44..6:45): c -> example/NamedApplyBlockMethods.foo().(c) +[9:7..9:43): NamedApplyBlockCaseClassConstruction <- example/NamedApplyBlockCaseClassConstruction. +[10:13..10:16): Msg <- example/NamedApplyBlockCaseClassConstruction.Msg# +[10:16..10:70): <- example/NamedApplyBlockCaseClassConstruction.Msg#``(). +[10:17..10:21): body <- example/NamedApplyBlockCaseClassConstruction.Msg#body. +[10:23..10:29): String -> scala/Predef.String# +[10:31..10:35): head <- example/NamedApplyBlockCaseClassConstruction.Msg#head. +[10:37..10:43): String -> scala/Predef.String# +[10:57..10:61): tail <- example/NamedApplyBlockCaseClassConstruction.Msg#tail. +[10:63..10:69): String -> scala/Predef.String# +[11:6..11:14): bodyText <- example/NamedApplyBlockCaseClassConstruction.bodyText. +[12:6..12:9): msg <- example/NamedApplyBlockCaseClassConstruction.msg. +[12:12..12:15): Msg -> example/NamedApplyBlockCaseClassConstruction.Msg. +[12:12..12:12): -> local4 +[12:15..12:15): -> example/NamedApplyBlockCaseClassConstruction.Msg.apply(). +[12:16..12:24): bodyText -> example/NamedApplyBlockCaseClassConstruction.bodyText. +[12:26..12:30): tail -> example/NamedApplyBlockCaseClassConstruction.Msg.apply().(tail) + +expect/NamedArguments.scala +--------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => NamedArguments.scala +Text => empty +Language => Scala +Symbols => 15 entries +Occurrences => 13 entries + +Symbols: +example/NamedArguments# => class NamedArguments +example/NamedArguments#User# => case class User +example/NamedArguments#User#_1(). => method _1 +example/NamedArguments#User#``(). => primary ctor +example/NamedArguments#User#``().(name) => val param name +example/NamedArguments#User#copy$default$1(). => method copy$default$1 +example/NamedArguments#User#copy(). => method copy +example/NamedArguments#User#copy().(name) => param name +example/NamedArguments#User#name. => val method name +example/NamedArguments#User. => final object User +example/NamedArguments#User.apply(). => method apply +example/NamedArguments#User.apply().(name) => param name +example/NamedArguments#User.unapply(). => method unapply +example/NamedArguments#User.unapply().(x$1) => param x$1 +example/NamedArguments#``(). => primary ctor + +Occurrences: +[0:8..0:15): example <- example/ +[2:6..2:20): NamedArguments <- example/NamedArguments# +[3:2..3:2): <- example/NamedArguments#``(). +[3:13..3:17): User <- example/NamedArguments#User# +[3:17..3:31): <- example/NamedArguments#User#``(). +[3:18..3:22): name <- example/NamedArguments#User#name. +[3:24..3:30): String -> scala/Predef.String# +[4:2..4:6): User -> example/NamedArguments#User. +[4:6..4:6): -> example/NamedArguments#User.apply(). +[4:7..4:11): name -> example/NamedArguments#User.apply().(name) +[5:2..5:6): User -> example/NamedArguments#User. +[5:7..5:12): apply -> example/NamedArguments#User.apply(). +[5:13..5:17): name -> example/NamedArguments#User.apply().(name) + +expect/NewModifiers.scala +------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => NewModifiers.scala +Text => empty +Language => Scala +Symbols => 3 entries +Occurrences => 4 entries + +Symbols: +_empty_/NewModifiers. => final object NewModifiers +_empty_/NewModifiers.A# => type A +_empty_/NewModifiers.foo. => val method foo + +Occurrences: +[0:7..0:19): NewModifiers <- _empty_/NewModifiers. +[1:13..1:16): foo <- _empty_/NewModifiers.foo. +[2:14..2:15): A <- _empty_/NewModifiers.A# +[2:18..2:21): Int -> scala/Int# + +expect/Objects.scala +-------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Objects.scala +Text => empty +Language => Scala +Symbols => 2 entries +Occurrences => 3 entries + +Symbols: +objects/X. => final object X +objects/X.Y. => final object Y + +Occurrences: +[0:8..0:15): objects <- objects/ +[2:7..2:8): X <- objects/X. +[3:9..3:10): Y <- objects/X.Y. + +expect/Overrides.scala +---------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Overrides.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 10 entries + +Symbols: +example/A# => trait A +example/A#``(). => primary ctor +example/A#foo(). => abstract method foo +example/B# => class B +example/B#``(). => primary ctor +example/B#foo(). => method foo + +Occurrences: +[0:8..0:15): example <- example/ +[2:6..2:7): A <- example/A# +[2:10..2:10): <- example/A#``(). +[2:14..2:17): foo <- example/A#foo(). +[2:19..2:22): Int -> scala/Int# +[3:6..3:7): B <- example/B# +[3:7..3:9): <- example/B#``(). +[3:18..3:19): A -> example/A# +[3:26..3:29): foo <- example/B#foo(). +[3:31..3:34): Int -> scala/Int# + +expect/Prefixes.scala +--------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Prefixes.scala +Text => empty +Language => Scala +Symbols => 19 entries +Occurrences => 49 entries + +Symbols: +prefixes/C# => class C +prefixes/C#N. => final object N +prefixes/C#N.U# => type U +prefixes/C#T# => type T +prefixes/C#``(). => primary ctor +prefixes/C#k1(). => method k1 +prefixes/C#m1(). => method m1 +prefixes/M. => final object M +prefixes/M.T# => type T +prefixes/M.n1(). => method n1 +prefixes/O. => final object O +prefixes/O.o1(). => method o1 +prefixes/Test. => final object Test +prefixes/Test.c. => val method c +prefixes/Test.k2(). => method k2 +prefixes/Test.k3(). => method k3 +prefixes/Test.m2(). => method m2 +prefixes/Test.n2(). => method n2 +prefixes/Test.n3(). => method n3 + +Occurrences: +[0:8..0:16): prefixes <- prefixes/ +[2:6..2:7): C <- prefixes/C# +[3:2..3:2): <- prefixes/C#``(). +[3:7..3:8): T <- prefixes/C#T# +[4:6..4:8): m1 <- prefixes/C#m1(). +[4:10..4:11): T -> prefixes/C#T# +[4:14..4:17): ??? -> scala/Predef.`???`(). +[6:9..6:10): N <- prefixes/C#N. +[7:9..7:10): U <- prefixes/C#N.U# +[9:6..9:8): k1 <- prefixes/C#k1(). +[9:10..9:11): N -> prefixes/C#N. +[9:12..9:13): U -> prefixes/C#N.U# +[9:16..9:19): ??? -> scala/Predef.`???`(). +[12:7..12:8): M <- prefixes/M. +[13:7..13:8): T <- prefixes/M.T# +[14:6..14:8): n1 <- prefixes/M.n1(). +[14:10..14:11): T -> prefixes/M.T# +[14:14..14:17): ??? -> scala/Predef.`???`(). +[17:7..17:8): O <- prefixes/O. +[17:17..17:18): C -> prefixes/C# +[17:18..17:18): -> prefixes/C#``(). +[18:6..18:8): o1 <- prefixes/O.o1(). +[18:10..18:11): T -> prefixes/C#T# +[18:14..18:17): ??? -> scala/Predef.`???`(). +[21:7..21:11): Test <- prefixes/Test. +[22:6..22:7): c <- prefixes/Test.c. +[22:9..22:10): C -> prefixes/C# +[22:13..22:16): ??? -> scala/Predef.`???`(). +[23:6..23:8): m2 <- prefixes/Test.m2(). +[23:10..23:11): c -> prefixes/Test.c. +[23:12..23:13): T -> prefixes/C#T# +[23:16..23:19): ??? -> scala/Predef.`???`(). +[24:6..24:8): k2 <- prefixes/Test.k2(). +[24:10..24:11): c -> prefixes/Test.c. +[24:12..24:13): N -> prefixes/C#N. +[24:14..24:15): U -> prefixes/C#N.U# +[24:18..24:21): ??? -> scala/Predef.`???`(). +[25:9..25:10): c -> prefixes/Test.c. +[25:11..25:12): N -> prefixes/C#N. +[26:6..26:8): k3 <- prefixes/Test.k3(). +[26:14..26:17): ??? -> scala/Predef.`???`(). +[28:6..28:8): n2 <- prefixes/Test.n2(). +[28:10..28:11): M -> prefixes/M. +[28:12..28:13): T -> prefixes/M.T# +[28:16..28:19): ??? -> scala/Predef.`???`(). +[30:9..30:10): M -> prefixes/M. +[31:6..31:8): n3 <- prefixes/Test.n3(). +[31:10..31:11): T -> prefixes/M.T# +[31:14..31:17): ??? -> scala/Predef.`???`(). + +expect/Selfs.scala +------------------ + +Summary: +Schema => SemanticDB v4 +Uri => Selfs.scala +Text => empty +Language => Scala +Symbols => 13 entries +Occurrences => 26 entries + +Symbols: +local0 => selfparam self +local1 => selfparam self +local2 => selfparam self +selfs/B# => class B +selfs/B#``(). => primary ctor +selfs/C1# => class C1 +selfs/C1#``(). => primary ctor +selfs/C2# => class C2 +selfs/C2#``(). => primary ctor +selfs/C3# => class C3 +selfs/C3#``(). => primary ctor +selfs/C6# => class C6 +selfs/C6#``(). => primary ctor + +Occurrences: +[0:8..0:13): selfs <- selfs/ +[2:0..2:0): <- selfs/B#``(). +[2:6..2:7): B <- selfs/B# +[4:6..4:8): C1 <- selfs/C1# +[4:17..4:17): <- selfs/C1#``(). +[4:17..4:18): B -> selfs/B# +[4:18..4:18): -> selfs/B#``(). +[4:21..4:25): self <- local0 +[7:6..7:8): C2 <- selfs/C2# +[7:17..7:17): <- selfs/C2#``(). +[7:17..7:18): B -> selfs/B# +[7:18..7:18): -> selfs/B#``(). +[7:21..7:25): self <- local1 +[7:27..7:28): B -> selfs/B# +[10:6..10:8): C3 <- selfs/C3# +[10:17..10:17): <- selfs/C3#``(). +[10:17..10:18): B -> selfs/B# +[10:18..10:18): -> selfs/B#``(). +[10:21..10:25): self <- local2 +[10:27..10:28): B -> selfs/B# +[10:34..10:36): C1 -> selfs/C1# +[13:6..13:8): C6 <- selfs/C6# +[13:17..13:17): <- selfs/C6#``(). +[13:17..13:18): B -> selfs/B# +[13:18..13:18): -> selfs/B#``(). +[13:27..13:28): B -> selfs/B# + +expect/Synthetic.scala +---------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Synthetic.scala +Text => empty +Language => Scala +Symbols => 37 entries +Occurrences => 163 entries + +Symbols: +example/Synthetic# => class Synthetic +example/Synthetic#F# => class F +example/Synthetic#F#``(). => primary ctor +example/Synthetic#J# => class J +example/Synthetic#J#[T] => typeparam T +example/Synthetic#J#``(). => primary ctor +example/Synthetic#J#arr. => val method arr +example/Synthetic#Name. => val method Name +example/Synthetic#``(). => primary ctor +example/Synthetic#a1. => val method a1 +example/Synthetic#a2. => val method a2 +example/Synthetic#as. => val method as +example/Synthetic#f. => val method f +example/Synthetic#lst. => val method lst +example/Synthetic#name. => val method name +example/Synthetic#ordering. => implicit val method ordering +example/Synthetic#s. => final object s +example/Synthetic#s.Bar# => case class Bar +example/Synthetic#s.Bar#``(). => primary ctor +example/Synthetic#s.Bar#copy(). => method copy +example/Synthetic#s.Bar. => final object Bar +example/Synthetic#s.Bar.apply(). => method apply +example/Synthetic#s.Bar.unapply(). => method unapply +example/Synthetic#s.Bar.unapply().(x$1) => param x$1 +example/Synthetic#s.apply(). => method apply +example/Synthetic#x. => val method x +example/Synthetic#xs. => val method xs +local0 => param x +local1 => param y +local2 => param i +local3 => param j +local4 => param i +local5 => param j +local6 => param a +local7 => param b +local8 => param a +local9 => param b + +Occurrences: +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:41): implicitConversions -> scalaShadowing/language.implicitConversions. +[4:6..4:15): Synthetic <- example/Synthetic# +[5:2..5:2): <- example/Synthetic#``(). +[5:2..5:6): List -> scala/package.List. +[5:6..5:6): -> scala/collection/IterableFactory#apply(). +[5:10..5:13): map -> scala/collection/immutable/List#map(). +[5:16..5:17): + -> scala/Int#`+`(+4). +[6:2..6:2): -> scala/Predef.intArrayOps(). +[6:2..6:7): Array -> scala/Array. +[6:8..6:13): empty -> scala/Array.empty(). +[6:14..6:17): Int -> scala/Int# +[6:18..6:18): -> scala/reflect/ClassTag.apply(). +[6:18..6:18): -> java/lang/Integer#TYPE. +[6:19..6:29): headOption -> scala/collection/ArrayOps#headOption(). +[7:2..7:2): -> scala/Predef.augmentString(). +[7:9..7:20): stripPrefix -> scala/collection/StringOps#stripPrefix(). +[10:6..10:10): Name <- example/Synthetic#Name. +[10:13..10:13): -> scala/Predef.augmentString(). +[10:25..10:26): r -> scala/collection/StringOps#r(). +[11:6..11:7): x <- example/Synthetic#x. +[11:8..11:11): #:: -> scala/package.`#::`. +[11:11..11:11): -> scala/package.`#::`.unapply(). +[11:12..11:14): xs <- example/Synthetic#xs. +[11:17..11:25): LazyList -> scala/package.LazyList. +[11:25..11:25): -> scala/collection/IterableFactory#apply(). +[12:6..12:10): Name -> example/Synthetic#Name. +[12:10..12:10): -> scala/util/matching/Regex#unapplySeq(). +[12:11..12:15): name <- example/Synthetic#name. +[13:8..13:8): -> scala/collection/immutable/LazyList.toDeferrer(). +[13:14..13:14): -> scala/collection/immutable/LazyList.toDeferrer(). +[13:14..13:22): LazyList -> scala/package.LazyList. +[13:23..13:28): empty -> scala/collection/immutable/LazyList.empty(). +[13:28..13:28): -> scala/collection/immutable/LazyList.Deferrer#`#::`(). +[15:6..15:8): a1 <- example/Synthetic#a1. +[15:9..15:12): #:: -> scala/package.`#::`. +[15:12..15:12): -> scala/package.`#::`.unapply(). +[15:13..15:15): a2 <- example/Synthetic#a2. +[15:16..15:19): #:: -> scala/package.`#::`. +[15:19..15:19): -> scala/package.`#::`.unapply(). +[15:20..15:22): as <- example/Synthetic#as. +[15:25..15:33): LazyList -> scala/package.LazyList. +[15:33..15:33): -> scala/collection/IterableFactory#apply(). +[17:6..17:9): lst <- example/Synthetic#lst. +[17:18..17:18): -> scala/collection/immutable/LazyList.toDeferrer(). +[17:24..17:24): -> scala/collection/immutable/LazyList.toDeferrer(). +[17:24..17:32): LazyList -> scala/package.LazyList. +[17:33..17:38): empty -> scala/collection/immutable/LazyList.empty(). +[17:38..17:38): -> scala/collection/immutable/LazyList.Deferrer#`#::`(). +[19:7..19:8): x <- local0 +[19:12..19:12): -> scala/LowPriorityImplicits#intWrapper(). +[19:14..19:16): to -> scala/runtime/RichInt#to(). +[19:19..19:19): -> scala/collection/immutable/Range#foreach(). +[19:21..19:22): y <- local1 +[19:26..19:26): -> scala/LowPriorityImplicits#intWrapper(). +[19:28..19:33): until -> scala/runtime/RichInt#until(). +[19:36..19:36): -> scala/collection/immutable/Range#foreach(). +[19:38..19:45): println -> scala/Predef.println(+1). +[19:46..19:46): -> scala/Predef.ArrowAssoc(). +[19:46..19:47): x -> local0 +[19:48..19:50): -> -> scala/Predef.ArrowAssoc#`->`(). +[19:51..19:52): x -> local0 +[20:7..20:8): i <- local2 +[20:12..20:12): -> scala/LowPriorityImplicits#intWrapper(). +[20:14..20:16): to -> scala/runtime/RichInt#to(). +[20:19..20:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[20:21..20:22): j <- local3 +[20:26..20:26): -> scala/LowPriorityImplicits#intWrapper(). +[20:28..20:33): until -> scala/runtime/RichInt#until(). +[20:36..20:36): -> scala/collection/immutable/Range#map(). +[20:45..20:45): -> scala/Tuple2.apply(). +[20:45..20:46): i -> local2 +[20:48..20:49): j -> local3 +[21:7..21:8): i <- local4 +[21:12..21:12): -> scala/LowPriorityImplicits#intWrapper(). +[21:14..21:16): to -> scala/runtime/RichInt#to(). +[21:19..21:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[21:21..21:22): j <- local5 +[21:26..21:26): -> scala/LowPriorityImplicits#intWrapper(). +[21:28..21:33): until -> scala/runtime/RichInt#until(). +[21:36..21:36): -> scala/collection/IterableOps#withFilter(). +[21:40..21:41): i -> local4 +[21:42..21:43): % -> scala/Int#`%`(+3). +[21:46..21:48): == -> scala/Int#`==`(+3). +[21:50..21:50): -> scala/collection/WithFilter#map(). +[21:59..21:59): -> scala/Tuple2.apply(). +[21:59..21:60): i -> local4 +[21:62..21:63): j -> local5 +[23:9..23:10): s <- example/Synthetic#s. +[24:8..24:13): apply <- example/Synthetic#s.apply(). +[25:5..25:5): -> example/Synthetic#s.apply(). +[26:6..26:11): apply -> example/Synthetic#s.apply(). +[27:15..27:18): Bar <- example/Synthetic#s.Bar# +[27:18..27:20): <- example/Synthetic#s.Bar#``(). +[28:4..28:7): Bar -> example/Synthetic#s.Bar. +[28:7..28:7): -> example/Synthetic#s.Bar.apply(). +[29:9..29:21): asInstanceOf -> scala/Any#asInstanceOf(). +[29:22..29:25): Int -> scala/Int# +[29:29..29:32): Int -> scala/Int# +[29:33..29:33): -> scala/Function1#apply(). +[32:8..32:9): J <- example/Synthetic#J# +[32:9..32:22): <- example/Synthetic#J#``(). +[32:10..32:11): T <- example/Synthetic#J#[T] +[32:13..32:21): Manifest -> scala/Predef.Manifest# +[32:21..32:21): -> example/Synthetic#J#[T] +[32:29..32:32): arr <- example/Synthetic#J#arr. +[32:35..32:40): Array -> scala/Array. +[32:41..32:46): empty -> scala/Array.empty(). +[32:47..32:48): T -> example/Synthetic#J#[T] +[34:2..34:2): <- example/Synthetic#F#``(). +[34:8..34:9): F <- example/Synthetic#F# +[35:15..35:23): ordering <- example/Synthetic#ordering. +[35:25..35:33): Ordering -> scala/package.Ordering# +[35:34..35:35): F -> example/Synthetic#F# +[35:39..35:42): ??? -> scala/Predef.`???`(). +[36:6..36:7): f <- example/Synthetic#f. +[36:9..36:16): Ordered -> scala/package.Ordered# +[36:17..36:18): F -> example/Synthetic#F# +[36:22..36:22): -> scala/math/Ordered.orderingToOrdered(). +[36:26..36:27): F -> example/Synthetic#F# +[36:27..36:27): -> example/Synthetic#F#``(). +[36:27..36:27): -> example/Synthetic#ordering. +[38:9..38:14): scala -> scala/ +[38:15..38:25): concurrent -> scala/concurrent/ +[38:26..38:42): ExecutionContext -> scala/concurrent/ExecutionContext. +[38:43..38:52): Implicits -> scala/concurrent/ExecutionContext.Implicits. +[38:53..38:59): global -> scala/concurrent/ExecutionContext.Implicits.global(). +[40:4..40:5): a <- local6 +[40:9..40:14): scala -> scala/ +[40:15..40:25): concurrent -> scala/concurrent/ +[40:26..40:32): Future -> scala/concurrent/Future. +[40:33..40:43): successful -> scala/concurrent/Future.successful(). +[40:46..40:46): -> scala/concurrent/Future#foreach(). +[41:4..41:5): b <- local7 +[41:9..41:14): scala -> scala/ +[41:15..41:25): concurrent -> scala/concurrent/ +[41:26..41:32): Future -> scala/concurrent/Future. +[41:33..41:43): successful -> scala/concurrent/Future.successful(). +[41:46..41:46): -> scala/concurrent/Future#foreach(). +[42:4..42:11): println -> scala/Predef.println(+1). +[42:12..42:13): a -> local6 +[42:14..42:14): -> scala/concurrent/ExecutionContext.Implicits.global(). +[44:4..44:5): a <- local8 +[44:9..44:14): scala -> scala/ +[44:15..44:25): concurrent -> scala/concurrent/ +[44:26..44:32): Future -> scala/concurrent/Future. +[44:33..44:43): successful -> scala/concurrent/Future.successful(). +[44:46..44:46): -> scala/concurrent/Future#flatMap(). +[45:4..45:5): b <- local9 +[45:9..45:14): scala -> scala/ +[45:15..45:25): concurrent -> scala/concurrent/ +[45:26..45:32): Future -> scala/concurrent/Future. +[45:33..45:43): successful -> scala/concurrent/Future.successful(). +[45:46..45:46): -> scala/concurrent/Future#withFilter(). +[46:7..46:8): a -> local8 +[46:9..46:10): < -> scala/Int#`<`(+3). +[46:11..46:12): b -> local9 +[46:12..46:12): -> scala/concurrent/Future#map(). +[46:12..46:12): -> scala/concurrent/ExecutionContext.Implicits.global(). +[47:10..47:11): a -> local8 +[47:11..47:11): -> scala/concurrent/ExecutionContext.Implicits.global(). + +expect/Traits.scala +------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Traits.scala +Text => empty +Language => Scala +Symbols => 13 entries +Occurrences => 16 entries + +Symbols: +local0 => final class $anon +local1 => selfparam self +traits/C# => class C +traits/C#``(). => primary ctor +traits/T# => trait T +traits/T#``(). => primary ctor +traits/T#x(). => method x +traits/U# => sealed trait U +traits/U#``(). => primary ctor +traits/U. => final object U +traits/U.u(). => method u +traits/V# => trait V +traits/V#``(). => primary ctor + +Occurrences: +[0:8..0:14): traits <- traits/ +[2:6..2:7): T <- traits/T# +[3:2..3:2): <- traits/T#``(). +[3:6..3:7): x <- traits/T#x(). +[6:0..6:0): <- traits/U#``(). +[6:13..6:14): U <- traits/U# +[7:7..7:8): U <- traits/U. +[8:6..8:7): u <- traits/U.u(). +[8:9..8:10): U -> traits/U# +[8:17..8:18): U -> traits/U# +[11:0..11:0): <- traits/C#``(). +[11:6..11:7): C <- traits/C# +[12:6..12:7): V <- traits/V# +[12:10..12:10): <- traits/V#``(). +[12:10..12:14): self <- local1 +[12:16..12:17): C -> traits/C# + +expect/Types.scala +------------------ + +Summary: +Schema => SemanticDB v4 +Uri => Types.scala +Text => empty +Language => Scala +Symbols => 125 entries +Occurrences => 242 entries + +Symbols: +local0 => abstract method k +local1 => abstract method k +local2 => final class $anon +local3 => method k +local4 => final class $anon +local5 => final class $anon +local6 => method k +local7 => type L +local8 => typeparam T +types/B# => class B +types/B#``(). => primary ctor +types/C# => class C +types/C#``(). => primary ctor +types/P# => class P +types/P#C# => class C +types/P#C#``(). => primary ctor +types/P#X# => class X +types/P#X#``(). => primary ctor +types/P#``(). => primary ctor +types/P#x. => val method x +types/T# => class T +types/T#C# => class C +types/T#C#``(). => primary ctor +types/T#X# => class X +types/T#X#``(). => primary ctor +types/T#``(). => primary ctor +types/T#x. => val method x +types/Test. => final object Test +types/Test.C# => class C +types/Test.C#ByNameType. => final object ByNameType +types/Test.C#ByNameType.m1(). => method m1 +types/Test.C#ByNameType.m1().(x) => param x +types/Test.C#ClassInfoType1. => final object ClassInfoType1 +types/Test.C#ClassInfoType2# => class ClassInfoType2 +types/Test.C#ClassInfoType2#``(). => primary ctor +types/Test.C#ClassInfoType2#x(). => method x +types/Test.C#ClassInfoType3# => trait ClassInfoType3 +types/Test.C#ClassInfoType3#[T] => typeparam T +types/Test.C#ClassInfoType3#``(). => primary ctor +types/Test.C#Either. => val method Either +types/Test.C#MethodType. => final object MethodType +types/Test.C#MethodType.m3(). => method m3 +types/Test.C#MethodType.m4(). => method m4 +types/Test.C#MethodType.m5(). => method m5 +types/Test.C#MethodType.m5().(x) => param x +types/Test.C#MethodType.m6(). => method m6 +types/Test.C#MethodType.m6().(x) => param x +types/Test.C#MethodType.m6().[T] => typeparam T +types/Test.C#MethodType.x1(). => method x1 +types/Test.C#MethodType.x2(). => method x2 +types/Test.C#RepeatedType# => case class RepeatedType +types/Test.C#RepeatedType#_1(). => method _1 +types/Test.C#RepeatedType#``(). => primary ctor +types/Test.C#RepeatedType#``().(s) => val param s +types/Test.C#RepeatedType#m1(). => method m1 +types/Test.C#RepeatedType#m1().(x) => param x +types/Test.C#RepeatedType#s. => val method s +types/Test.C#RepeatedType. => final object RepeatedType +types/Test.C#RepeatedType.apply(). => method apply +types/Test.C#RepeatedType.apply().(s) => param s +types/Test.C#RepeatedType.unapplySeq(). => method unapplySeq +types/Test.C#RepeatedType.unapplySeq().(x$1) => param x$1 +types/Test.C#TypeType. => final object TypeType +types/Test.C#TypeType.T1# => type T1 +types/Test.C#TypeType.T4# => type T4 +types/Test.C#TypeType.T5# => type T5 +types/Test.C#TypeType.T5#[U] => typeparam U +types/Test.C#TypeType.m2(). => method m2 +types/Test.C#TypeType.m2().[T2] => typeparam T2 +types/Test.C#TypeType.m3(). => method m3 +types/Test.C#TypeType.m3().[M3] => typeparam M3 +types/Test.C#``(). => primary ctor +types/Test.C#annType1. => val method annType1 +types/Test.C#annType2. => val method annType2 +types/Test.C#compoundType1. => val method compoundType1 +types/Test.C#compoundType2. => val method compoundType2 +types/Test.C#compoundType3. => val method compoundType3 +types/Test.C#compoundType4. => val method compoundType4 +types/Test.C#compoundType5. => val method compoundType5 +types/Test.C#compoundType6. => val method compoundType6 +types/Test.C#existentialType2. => val method existentialType2 +types/Test.C#existentialType3. => val method existentialType3 +types/Test.C#existentialType4. => val method existentialType4 +types/Test.C#p. => val method p +types/Test.C#singleType1. => val method singleType1 +types/Test.C#singleType2. => val method singleType2 +types/Test.C#superType1. => val method superType1 +types/Test.C#superType2. => val method superType2 +types/Test.C#superType3. => val method superType3 +types/Test.C#thisType1. => val method thisType1 +types/Test.C#thisType2. => val method thisType2 +types/Test.C#typeLambda1(). => method typeLambda1 +types/Test.C#typeLambda1().[M] => typeparam M +types/Test.C#typeRef1. => val method typeRef1 +types/Test.C#typeRef2. => val method typeRef2 +types/Test.C#typeRef3. => val method typeRef3 +types/Test.C#typeRef4. => val method typeRef4 +types/Test.C#x. => val method x +types/Test.Literal. => final object Literal +types/Test.Literal.bool. => final val method bool +types/Test.Literal.char. => final val method char +types/Test.Literal.clazzOf. => final val method clazzOf +types/Test.Literal.double. => final val method double +types/Test.Literal.float. => final val method float +types/Test.Literal.int. => final val method int +types/Test.Literal.javaEnum. => final val method javaEnum +types/Test.Literal.long. => final val method long +types/Test.Literal.nil. => final val method nil +types/Test.Literal.string. => final val method string +types/Test.Literal.unit. => final val method unit +types/Test.M# => class M +types/Test.M#``(). => primary ctor +types/Test.M#m(). => method m +types/Test.N# => trait N +types/Test.N#``(). => primary ctor +types/Test.N#n(). => method n +types/ann# => class ann +types/ann#[T] => typeparam T +types/ann#``(). => primary ctor +types/ann#``().(x) => param x +types/ann#x. => val method x +types/ann1# => class ann1 +types/ann1#``(). => primary ctor +types/ann2# => class ann2 +types/ann2#``(). => primary ctor + +Occurrences: +[0:8..0:13): types <- types/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:34): existentials -> scalaShadowing/language.existentials. +[3:7..3:12): scala -> scala/ +[3:13..3:21): language -> scalaShadowing/language. +[3:22..3:33): higherKinds -> scalaShadowing/language.higherKinds. +[5:6..5:9): ann <- types/ann# +[5:9..5:18): <- types/ann#``(). +[5:10..5:11): T <- types/ann#[T] +[5:13..5:14): x <- types/ann#x. +[5:16..5:17): T -> types/ann#[T] +[5:27..5:32): scala -> scala/ +[5:33..5:43): annotation -> scala/annotation/ +[5:44..5:60): StaticAnnotation -> scala/annotation/StaticAnnotation# +[6:6..6:10): ann1 <- types/ann1# +[6:19..6:19): <- types/ann1#``(). +[6:19..6:24): scala -> scala/ +[6:25..6:35): annotation -> scala/annotation/ +[6:36..6:52): StaticAnnotation -> scala/annotation/StaticAnnotation# +[7:6..7:10): ann2 <- types/ann2# +[7:19..7:19): <- types/ann2#``(). +[7:19..7:24): scala -> scala/ +[7:25..7:35): annotation -> scala/annotation/ +[7:36..7:52): StaticAnnotation -> scala/annotation/StaticAnnotation# +[9:0..9:0): <- types/B#``(). +[9:6..9:7): B <- types/B# +[11:0..11:0): <- types/C#``(). +[11:6..11:7): C <- types/C# +[13:6..13:7): P <- types/P# +[14:2..14:2): <- types/P#``(). +[14:2..14:2): <- types/P#C#``(). +[14:8..14:9): C <- types/P#C# +[15:2..15:2): <- types/P#X#``(). +[15:8..15:9): X <- types/P#X# +[16:6..16:7): x <- types/P#x. +[16:14..16:15): X -> types/P#X# +[16:15..16:15): -> types/P#X#``(). +[19:6..19:7): T <- types/T# +[20:2..20:2): <- types/T#``(). +[20:2..20:2): <- types/T#C#``(). +[20:8..20:9): C <- types/T#C# +[21:2..21:2): <- types/T#X#``(). +[21:8..21:9): X <- types/T#X# +[22:6..22:7): x <- types/T#x. +[22:14..22:15): X -> types/T#X# +[22:15..22:15): -> types/T#X#``(). +[25:7..25:11): Test <- types/Test. +[26:8..26:9): M <- types/Test.M# +[27:4..27:4): <- types/Test.M#``(). +[27:8..27:9): m <- types/Test.M#m(). +[27:11..27:14): Int -> scala/Int# +[27:17..27:20): ??? -> scala/Predef.`???`(). +[30:8..30:9): N <- types/Test.N# +[31:4..31:4): <- types/Test.N#``(). +[31:8..31:9): n <- types/Test.N#n(). +[31:11..31:14): Int -> scala/Int# +[31:17..31:20): ??? -> scala/Predef.`???`(). +[34:8..34:9): C <- types/Test.C# +[34:18..34:18): <- types/Test.C#``(). +[34:18..34:19): M -> types/Test.M# +[34:19..34:19): -> types/Test.M#``(). +[35:8..35:9): p <- types/Test.C#p. +[35:16..35:17): P -> types/P# +[35:17..35:17): -> types/P#``(). +[36:8..36:9): x <- types/Test.C#x. +[36:12..36:13): p -> types/Test.C#p. +[36:14..36:15): x -> types/P#x. +[38:8..38:16): typeRef1 <- types/Test.C#typeRef1. +[38:18..38:19): C -> types/Test.C# +[38:22..38:25): ??? -> scala/Predef.`???`(). +[39:8..39:16): typeRef2 <- types/Test.C#typeRef2. +[39:18..39:19): p -> types/Test.C#p. +[39:20..39:21): C -> types/P#C# +[39:24..39:27): ??? -> scala/Predef.`???`(). +[40:8..40:16): typeRef3 <- types/Test.C#typeRef3. +[40:18..40:19): T -> types/T# +[40:20..40:21): C -> types/T#C# +[40:24..40:27): ??? -> scala/Predef.`???`(). +[41:8..41:16): typeRef4 <- types/Test.C#typeRef4. +[41:18..41:22): List -> scala/package.List# +[41:23..41:26): Int -> scala/Int# +[41:30..41:33): ??? -> scala/Predef.`???`(). +[43:8..43:19): singleType1 <- types/Test.C#singleType1. +[43:21..43:22): x -> types/Test.C#x. +[43:30..43:33): ??? -> scala/Predef.`???`(). +[44:8..44:19): singleType2 <- types/Test.C#singleType2. +[44:21..44:22): p -> types/Test.C#p. +[44:23..44:24): x -> types/P#x. +[44:32..44:35): ??? -> scala/Predef.`???`(). +[45:8..45:14): Either <- types/Test.C#Either. +[45:17..45:22): scala -> scala/ +[45:23..45:27): util -> scala/util/ +[45:28..45:34): Either -> scala/util/Either. +[47:8..47:17): thisType1 <- types/Test.C#thisType1. +[47:31..47:34): ??? -> scala/Predef.`???`(). +[48:8..48:17): thisType2 <- types/Test.C#thisType2. +[48:33..48:36): ??? -> scala/Predef.`???`(). +[50:8..50:18): superType1 <- types/Test.C#superType1. +[50:27..50:28): m -> types/Test.M#m(). +[51:8..51:18): superType2 <- types/Test.C#superType2. +[51:30..51:31): m -> types/Test.M#m(). +[52:8..52:18): superType3 <- types/Test.C#superType3. +[52:32..52:33): m -> types/Test.M#m(). +[54:8..54:21): compoundType1 <- types/Test.C#compoundType1. +[54:29..54:30): k <- local0 +[54:32..54:35): Int -> scala/Int# +[54:40..54:43): ??? -> scala/Predef.`???`(). +[55:8..55:21): compoundType2 <- types/Test.C#compoundType2. +[55:23..55:24): M -> types/Test.M# +[55:30..55:31): N -> types/Test.N# +[55:34..55:37): ??? -> scala/Predef.`???`(). +[56:8..56:21): compoundType3 <- types/Test.C#compoundType3. +[56:23..56:24): M -> types/Test.M# +[56:30..56:31): N -> types/Test.N# +[56:38..56:39): k <- local1 +[56:41..56:44): Int -> scala/Int# +[56:49..56:52): ??? -> scala/Predef.`???`(). +[57:8..57:21): compoundType4 <- types/Test.C#compoundType4. +[57:34..57:35): k <- local3 +[57:37..57:40): Int -> scala/Int# +[57:43..57:46): ??? -> scala/Predef.`???`(). +[58:8..58:21): compoundType5 <- types/Test.C#compoundType5. +[58:28..58:29): M -> types/Test.M# +[58:29..58:29): -> types/Test.M#``(). +[58:35..58:36): N -> types/Test.N# +[59:8..59:21): compoundType6 <- types/Test.C#compoundType6. +[59:28..59:29): M -> types/Test.M# +[59:29..59:29): -> types/Test.M#``(). +[59:35..59:36): N -> types/Test.N# +[59:43..59:44): k <- local6 +[59:46..59:49): Int -> scala/Int# +[59:52..59:55): ??? -> scala/Predef.`???`(). +[61:8..61:16): annType1 <- types/Test.C#annType1. +[61:18..61:19): T -> types/T# +[61:31..61:34): ??? -> scala/Predef.`???`(). +[62:8..62:16): annType2 <- types/Test.C#annType2. +[62:18..62:19): T -> types/T# +[62:21..62:25): ann1 -> types/ann1# +[62:27..62:31): ann2 -> types/ann2# +[62:34..62:37): ??? -> scala/Predef.`???`(). +[64:8..64:24): existentialType2 <- types/Test.C#existentialType2. +[64:26..64:30): List -> scala/package.List# +[64:36..64:39): ??? -> scala/Predef.`???`(). +[65:8..65:24): existentialType3 <- types/Test.C#existentialType3. +[65:27..65:32): Class -> java/lang/Class# +[65:33..65:40): forName -> java/lang/Class#forName(). +[66:8..66:24): existentialType4 <- types/Test.C#existentialType4. +[66:27..66:32): Class -> java/lang/Class# +[66:33..66:40): forName -> java/lang/Class#forName(). +[68:8..68:19): typeLambda1 <- types/Test.C#typeLambda1(). +[68:20..68:21): M <- types/Test.C#typeLambda1().[M] +[68:28..68:31): ??? -> scala/Predef.`???`(). +[69:4..69:15): typeLambda1 -> types/Test.C#typeLambda1(). +[69:24..69:25): L <- local7 +[69:26..69:27): T <- local8 +[69:31..69:35): List -> scala/package.List# +[69:36..69:37): T -> local8 +[71:11..71:25): ClassInfoType1 <- types/Test.C#ClassInfoType1. +[72:10..72:24): ClassInfoType2 <- types/Test.C#ClassInfoType2# +[72:33..72:33): <- types/Test.C#ClassInfoType2#``(). +[72:33..72:34): B -> types/B# +[72:34..72:34): -> types/B#``(). +[72:41..72:42): x <- types/Test.C#ClassInfoType2#x(). +[73:10..73:24): ClassInfoType3 <- types/Test.C#ClassInfoType3# +[73:24..73:27): <- types/Test.C#ClassInfoType3#``(). +[73:25..73:26): T <- types/Test.C#ClassInfoType3#[T] +[75:11..75:21): MethodType <- types/Test.C#MethodType. +[76:10..76:12): x1 <- types/Test.C#MethodType.x1(). +[76:14..76:17): Int -> scala/Int# +[76:20..76:23): ??? -> scala/Predef.`???`(). +[77:10..77:12): x2 <- types/Test.C#MethodType.x2(). +[77:14..77:17): Int -> scala/Int# +[77:20..77:23): ??? -> scala/Predef.`???`(). +[78:10..78:12): m3 <- types/Test.C#MethodType.m3(). +[78:14..78:17): Int -> scala/Int# +[78:20..78:23): ??? -> scala/Predef.`???`(). +[79:10..79:12): m4 <- types/Test.C#MethodType.m4(). +[79:16..79:19): Int -> scala/Int# +[79:22..79:25): ??? -> scala/Predef.`???`(). +[80:10..80:12): m5 <- types/Test.C#MethodType.m5(). +[80:13..80:14): x <- types/Test.C#MethodType.m5().(x) +[80:16..80:19): Int -> scala/Int# +[80:22..80:25): Int -> scala/Int# +[80:28..80:31): ??? -> scala/Predef.`???`(). +[81:10..81:12): m6 <- types/Test.C#MethodType.m6(). +[81:13..81:14): T <- types/Test.C#MethodType.m6().[T] +[81:16..81:17): x <- types/Test.C#MethodType.m6().(x) +[81:19..81:20): T -> types/Test.C#MethodType.m6().[T] +[81:23..81:24): T -> types/Test.C#MethodType.m6().[T] +[81:27..81:30): ??? -> scala/Predef.`???`(). +[84:11..84:21): ByNameType <- types/Test.C#ByNameType. +[85:10..85:12): m1 <- types/Test.C#ByNameType.m1(). +[85:13..85:14): x <- types/Test.C#ByNameType.m1().(x) +[85:19..85:22): Int -> scala/Int# +[85:25..85:28): Int -> scala/Int# +[85:31..85:34): ??? -> scala/Predef.`???`(). +[88:15..88:27): RepeatedType <- types/Test.C#RepeatedType# +[88:27..88:39): <- types/Test.C#RepeatedType#``(). +[88:28..88:29): s <- types/Test.C#RepeatedType#s. +[88:31..88:37): String -> scala/Predef.String# +[89:10..89:12): m1 <- types/Test.C#RepeatedType#m1(). +[89:13..89:14): x <- types/Test.C#RepeatedType#m1().(x) +[89:16..89:19): Int -> scala/Int# +[89:23..89:26): Int -> scala/Int# +[89:29..89:30): s -> types/Test.C#RepeatedType#s. +[89:31..89:37): length -> scala/collection/SeqOps#length(). +[92:11..92:19): TypeType <- types/Test.C#TypeType. +[93:11..93:13): T1 <- types/Test.C#TypeType.T1# +[94:10..94:12): m2 <- types/Test.C#TypeType.m2(). +[94:13..94:15): T2 <- types/Test.C#TypeType.m2().[T2] +[94:19..94:20): C -> types/Test.C# +[94:24..94:25): C -> types/Test.C# +[94:29..94:32): ??? -> scala/Predef.`???`(). +[95:10..95:12): m3 <- types/Test.C#TypeType.m3(). +[95:13..95:15): M3 <- types/Test.C#TypeType.m3().[M3] +[95:22..95:25): ??? -> scala/Predef.`???`(). +[96:11..96:13): T4 <- types/Test.C#TypeType.T4# +[96:16..96:17): C -> types/Test.C# +[97:11..97:13): T5 <- types/Test.C#TypeType.T5# +[97:14..97:15): U <- types/Test.C#TypeType.T5#[U] +[97:19..97:20): U -> types/Test.C#TypeType.T5#[U] +[101:9..101:16): Literal <- types/Test.Literal. +[102:14..102:17): int <- types/Test.Literal.int. +[103:14..103:18): long <- types/Test.Literal.long. +[104:14..104:19): float <- types/Test.Literal.float. +[105:14..105:20): double <- types/Test.Literal.double. +[106:14..106:17): nil <- types/Test.Literal.nil. +[107:14..107:18): char <- types/Test.Literal.char. +[108:14..108:20): string <- types/Test.Literal.string. +[109:14..109:18): bool <- types/Test.Literal.bool. +[110:14..110:18): unit <- types/Test.Literal.unit. +[111:14..111:22): javaEnum <- types/Test.Literal.javaEnum. +[111:25..111:29): java -> java/ +[111:30..111:33): nio -> java/nio/ +[111:34..111:38): file -> java/nio/file/ +[111:39..111:49): LinkOption -> java/nio/file/LinkOption# +[111:50..111:64): NOFOLLOW_LINKS -> java/nio/file/LinkOption#NOFOLLOW_LINKS. +[112:14..112:21): clazzOf <- types/Test.Literal.clazzOf. +[112:24..112:31): classOf -> scala/Predef.classOf(). +[112:32..112:38): Option -> scala/Option# +[112:39..112:42): Int -> scala/Int# + +expect/ValPattern.scala +----------------------- + +Summary: +Schema => SemanticDB v4 +Uri => ValPattern.scala +Text => empty +Language => Scala +Symbols => 22 entries +Occurrences => 63 entries + +Symbols: +example/ValPattern# => class ValPattern +example/ValPattern#``(). => primary ctor +example/ValPattern#`leftVar_=`(). => var method leftVar_= +example/ValPattern#`leftVar_=`().(x$1) => param x$1 +example/ValPattern#`number1Var_=`(). => var method number1Var_= +example/ValPattern#`number1Var_=`().(x$1) => param x$1 +example/ValPattern#`rightVar_=`(). => var method rightVar_= +example/ValPattern#`rightVar_=`().(x$1) => param x$1 +example/ValPattern#app(). => method app +example/ValPattern#left. => val method left +example/ValPattern#leftVar(). => var method leftVar +example/ValPattern#number1. => val method number1 +example/ValPattern#number1Var(). => var method number1Var +example/ValPattern#q1. => val method q1 +example/ValPattern#right. => val method right +example/ValPattern#rightVar(). => var method rightVar +local0 => val local left +local1 => val local right +local2 => val local number1 +local3 => var local leftVar +local4 => var local rightVar +local5 => var local number1Var + +Occurrences: +[0:8..0:15): example <- example/ +[2:6..2:16): ValPattern <- example/ValPattern# +[4:2..4:2): <- example/ValPattern#``(). +[4:7..4:11): left <- example/ValPattern#left. +[4:13..4:18): right <- example/ValPattern#right. +[4:23..4:23): -> scala/Tuple2.apply(). +[5:6..5:10): Some -> scala/Some. +[5:10..5:10): -> scala/Some.unapply(). +[5:11..5:18): number1 <- example/ValPattern#number1. +[6:4..6:8): Some -> scala/Some. +[6:8..6:8): -> scala/Some.apply(). +[8:6..8:10): List -> scala/package.List. +[8:10..8:10): -> scala/collection/SeqFactory#unapplySeq(). +[8:11..8:15): Some -> scala/Some. +[8:15..8:15): -> scala/Some.unapply(). +[8:16..8:18): q1 <- example/ValPattern#q1. +[8:21..8:25): None -> scala/None. +[8:27..8:31): None -> scala/None. +[8:38..8:42): None -> scala/None. +[8:46..8:49): ??? -> scala/Predef.`???`(). +[10:7..10:14): leftVar <- example/ValPattern#leftVar(). +[10:16..10:24): rightVar <- example/ValPattern#rightVar(). +[10:29..10:29): -> scala/Tuple2.apply(). +[11:6..11:10): Some -> scala/Some. +[11:10..11:10): -> scala/Some.unapply(). +[11:11..11:21): number1Var <- example/ValPattern#number1Var(). +[12:4..12:8): Some -> scala/Some. +[12:8..12:8): -> scala/Some.apply(). +[14:6..14:9): app <- example/ValPattern#app(). +[14:13..14:17): Unit -> scala/Unit# +[15:4..15:11): println -> scala/Predef.println(+1). +[17:8..17:8): -> scala/Tuple6.apply(). +[17:8..17:15): number1 -> example/ValPattern#number1. +[18:8..18:12): left -> example/ValPattern#left. +[19:8..19:13): right -> example/ValPattern#right. +[20:8..20:18): number1Var -> example/ValPattern#number1Var(). +[21:8..21:15): leftVar -> example/ValPattern#leftVar(). +[22:8..22:16): rightVar -> example/ValPattern#rightVar(). +[25:4..25:11): locally -> dotty/DottyPredef.locally(). +[26:11..26:15): left <- local0 +[26:17..26:22): right <- local1 +[26:27..26:27): -> scala/Tuple2.apply(). +[27:10..27:14): Some -> scala/Some. +[27:14..27:14): -> scala/Some.unapply(). +[27:15..27:22): number1 <- local2 +[28:8..28:12): Some -> scala/Some. +[28:12..28:12): -> scala/Some.apply(). +[30:11..30:18): leftVar <- local3 +[30:20..30:28): rightVar <- local4 +[30:33..30:33): -> scala/Tuple2.apply(). +[31:10..31:14): Some -> scala/Some. +[31:14..31:14): -> scala/Some.unapply(). +[31:15..31:25): number1Var <- local5 +[32:8..32:12): Some -> scala/Some. +[32:12..32:12): -> scala/Some.apply(). +[33:6..33:13): println -> scala/Predef.println(+1). +[35:10..35:10): -> scala/Tuple6.apply(). +[35:10..35:17): number1 -> local2 +[36:10..36:14): left -> local0 +[37:10..37:15): right -> local1 +[38:10..38:20): number1Var -> local5 +[39:10..39:17): leftVar -> local3 +[40:10..40:18): rightVar -> local4 + +expect/Vals.scala +----------------- + +Summary: +Schema => SemanticDB v4 +Uri => Vals.scala +Text => empty +Language => Scala +Symbols => 42 entries +Occurrences => 129 entries + +Symbols: +example/ValUsages. => final object ValUsages +example/ValUsages.v. => val method v +example/Vals# => abstract class Vals +example/Vals#_explicitSetter(). => var method _explicitSetter +example/Vals#``(). => primary ctor +example/Vals#``().(p) => param p +example/Vals#``().(xp) => val param xp +example/Vals#``().(yp) => var param yp +example/Vals#`explicitSetter_=`(). => method explicitSetter_= +example/Vals#`explicitSetter_=`().(x) => param x +example/Vals#`yam_=`(). => var method yam_= +example/Vals#`yam_=`().(x$1) => param x$1 +example/Vals#`yfm_=`(). => final var method yfm_= +example/Vals#`yfm_=`().(x$1) => param x$1 +example/Vals#`yim_=`(). => var method yim_= +example/Vals#`yim_=`().(x$1) => param x$1 +example/Vals#`ym_=`(). => var method ym_= +example/Vals#`ym_=`().(x$1) => param x$1 +example/Vals#`yp_=`(). => var method yp_= +example/Vals#`yp_=`().(x$1) => param x$1 +example/Vals#explicitSetter(). => method explicitSetter +example/Vals#m(). => method m +example/Vals#p. => val method p +example/Vals#xam. => abstract val method xam +example/Vals#xfm. => final val method xfm +example/Vals#xim. => implicit val method xim +example/Vals#xlm. => val method xlm +example/Vals#xm. => val method xm +example/Vals#xp. => val method xp +example/Vals#xzlm. => lazy val method xzlm +example/Vals#xzm. => lazy val method xzm +example/Vals#yam(). => abstract var method yam +example/Vals#yfm(). => final var method yfm +example/Vals#yim(). => implicit var method yim +example/Vals#ylm(). => var method ylm +example/Vals#ym(). => var method ym +example/Vals#yp(). => var method yp +local0 => val local xl +local1 => lazy val local xzl +local2 => implicit val local xil +local3 => var local yl +local4 => implicit var local yil + +Occurrences: +[0:8..0:15): example <- example/ +[2:15..2:19): Vals <- example/Vals# +[2:19..2:53): <- example/Vals#``(). +[2:20..2:21): p <- example/Vals#p. +[2:23..2:26): Int -> scala/Int# +[2:32..2:34): xp <- example/Vals#xp. +[2:36..2:39): Int -> scala/Int# +[2:45..2:47): yp <- example/Vals#yp(). +[2:49..2:52): Int -> scala/Int# +[3:6..3:8): xm <- example/Vals#xm. +[3:10..3:13): Int -> scala/Int# +[3:16..3:19): ??? -> scala/Predef.`???`(). +[4:6..4:9): xam <- example/Vals#xam. +[4:11..4:14): Int -> scala/Int# +[5:20..5:23): xlm <- example/Vals#xlm. +[5:25..5:28): Int -> scala/Int# +[5:31..5:34): ??? -> scala/Predef.`???`(). +[6:11..6:14): xzm <- example/Vals#xzm. +[6:16..6:19): Int -> scala/Int# +[6:22..6:25): ??? -> scala/Predef.`???`(). +[7:25..7:29): xzlm <- example/Vals#xzlm. +[7:31..7:34): Int -> scala/Int# +[7:37..7:40): ??? -> scala/Predef.`???`(). +[8:12..8:15): xfm <- example/Vals#xfm. +[8:17..8:20): Int -> scala/Int# +[8:23..8:26): ??? -> scala/Predef.`???`(). +[9:15..9:18): xim <- example/Vals#xim. +[9:20..9:23): Int -> scala/Int# +[9:26..9:29): ??? -> scala/Predef.`???`(). +[10:6..10:8): ym <- example/Vals#ym(). +[10:10..10:13): Int -> scala/Int# +[10:16..10:19): ??? -> scala/Predef.`???`(). +[11:6..11:9): yam <- example/Vals#yam(). +[11:11..11:14): Int -> scala/Int# +[12:20..12:23): ylm <- example/Vals#ylm(). +[12:25..12:28): Int -> scala/Int# +[12:31..12:34): ??? -> scala/Predef.`???`(). +[13:20..13:35): _explicitSetter <- example/Vals#_explicitSetter(). +[13:37..13:40): Int -> scala/Int# +[14:6..14:20): explicitSetter <- example/Vals#explicitSetter(). +[14:23..14:38): _explicitSetter -> example/Vals#_explicitSetter(). +[15:6..15:22): explicitSetter_= <- example/Vals#`explicitSetter_=`(). +[15:23..15:24): x <- example/Vals#`explicitSetter_=`().(x) +[15:26..15:29): Int -> scala/Int# +[15:32..15:36): Unit -> scala/Unit# +[15:39..15:54): _explicitSetter -> example/Vals#_explicitSetter(). +[15:57..15:58): x -> example/Vals#`explicitSetter_=`().(x) +[19:12..19:15): yfm <- example/Vals#yfm(). +[19:17..19:20): Int -> scala/Int# +[19:23..19:26): ??? -> scala/Predef.`???`(). +[20:15..20:18): yim <- example/Vals#yim(). +[20:20..20:23): Int -> scala/Int# +[20:26..20:29): ??? -> scala/Predef.`???`(). +[21:6..21:7): m <- example/Vals#m(). +[22:8..22:10): xl <- local0 +[22:12..22:15): Int -> scala/Int# +[22:18..22:21): ??? -> scala/Predef.`???`(). +[23:13..23:16): xzl <- local1 +[23:18..23:21): Int -> scala/Int# +[23:24..23:27): ??? -> scala/Predef.`???`(). +[26:17..26:20): xil <- local2 +[26:22..26:25): Int -> scala/Int# +[26:28..26:31): ??? -> scala/Predef.`???`(). +[27:8..27:10): yl <- local3 +[27:12..27:15): Int -> scala/Int# +[27:18..27:21): ??? -> scala/Predef.`???`(). +[32:17..32:20): yil <- local4 +[32:22..32:25): Int -> scala/Int# +[32:28..32:31): ??? -> scala/Predef.`???`(). +[33:4..33:6): yl -> local3 +[33:9..33:11): xl -> local0 +[33:12..33:13): + -> scala/Int#`+`(+4). +[33:14..33:16): yl -> local3 +[34:4..34:11): println -> scala/Predef.println(+1). +[34:12..34:15): xzl -> local1 +[35:4..35:7): yil -> local4 +[35:10..35:13): xil -> local2 +[35:14..35:15): + -> scala/Int#`+`(+4). +[35:16..35:19): yil -> local4 +[37:2..37:9): println -> scala/Predef.println(+1). +[37:10..37:14): xzlm -> example/Vals#xzlm. +[38:2..38:5): ylm -> example/Vals#ylm(). +[38:8..38:11): xlm -> example/Vals#xlm. +[38:12..38:13): + -> scala/Int#`+`(+4). +[38:14..38:17): ylm -> example/Vals#ylm(). +[41:7..41:16): ValUsages <- example/ValUsages. +[42:6..42:7): v <- example/ValUsages.v. +[42:9..42:13): Vals -> example/Vals# +[42:16..42:19): ??? -> scala/Predef.`???`(). +[43:2..43:3): v -> example/ValUsages.v. +[43:4..43:6): yp -> example/Vals#`yp_=`(). +[43:9..43:10): v -> example/ValUsages.v. +[43:11..43:13): xp -> example/Vals#xp. +[43:14..43:15): + -> scala/Int#`+`(+4). +[43:16..43:17): v -> example/ValUsages.v. +[43:18..43:20): yp -> example/Vals#yp(). +[44:2..44:3): v -> example/ValUsages.v. +[44:4..44:6): ym -> example/Vals#`ym_=`(). +[44:9..44:10): v -> example/ValUsages.v. +[44:11..44:13): xm -> example/Vals#xm. +[44:14..44:15): + -> scala/Int#`+`(+4). +[44:16..44:17): v -> example/ValUsages.v. +[44:18..44:20): ym -> example/Vals#ym(). +[45:2..45:3): v -> example/ValUsages.v. +[45:4..45:7): yam -> example/Vals#`yam_=`(). +[45:10..45:11): v -> example/ValUsages.v. +[45:12..45:15): xam -> example/Vals#xam. +[45:16..45:17): + -> scala/Int#`+`(+4). +[45:18..45:19): v -> example/ValUsages.v. +[45:20..45:23): yam -> example/Vals#yam(). +[46:2..46:9): println -> scala/Predef.println(+1). +[46:10..46:11): v -> example/ValUsages.v. +[46:12..46:15): xzm -> example/Vals#xzm. +[47:2..47:3): v -> example/ValUsages.v. +[47:4..47:7): yfm -> example/Vals#`yfm_=`(). +[47:10..47:11): v -> example/ValUsages.v. +[47:12..47:15): xfm -> example/Vals#xfm. +[47:16..47:17): + -> scala/Int#`+`(+4). +[47:18..47:19): v -> example/ValUsages.v. +[47:20..47:23): yfm -> example/Vals#yfm(). +[48:2..48:3): v -> example/ValUsages.v. +[48:4..48:7): yim -> example/Vals#`yim_=`(). +[48:10..48:11): v -> example/ValUsages.v. +[48:12..48:15): xim -> example/Vals#xim. +[48:16..48:17): + -> scala/Int#`+`(+4). +[48:18..48:19): v -> example/ValUsages.v. +[48:20..48:23): yim -> example/Vals#yim(). +[49:2..49:3): v -> example/ValUsages.v. +[49:3..49:18): .explicitSetter -> example/Vals#`explicitSetter_=`(). + +expect/Vararg.scala +------------------- + +Summary: +Schema => SemanticDB v4 +Uri => Vararg.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 11 entries + +Symbols: +example/Vararg# => class Vararg +example/Vararg#``(). => primary ctor +example/Vararg#add1(). => method add1 +example/Vararg#add1().(a) => param a +example/Vararg#add2(). => method add2 +example/Vararg#add2().(a) => param a + +Occurrences: +[0:8..0:15): example <- example/ +[2:6..2:12): Vararg <- example/Vararg# +[3:2..3:2): <- example/Vararg#``(). +[3:6..3:10): add1 <- example/Vararg#add1(). +[3:11..3:12): a <- example/Vararg#add1().(a) +[3:14..3:17): Int -> scala/Int# +[4:6..4:10): add2 <- example/Vararg#add2(). +[4:11..4:12): a <- example/Vararg#add2().(a) +[4:14..4:17): Seq -> scala/package.Seq# +[4:18..4:21): Int -> scala/Int# +[4:26..4:30): Unit -> scala/Unit# + +expect/filename with spaces.scala +--------------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => filename with spaces.scala +Text => empty +Language => Scala +Symbols => 2 entries +Occurrences => 3 entries + +Symbols: +example/FilenameWithSpaces# => class FilenameWithSpaces +example/FilenameWithSpaces#``(). => primary ctor + +Occurrences: +[0:8..0:15): example <- example/ +[2:0..2:0): <- example/FilenameWithSpaces#``(). +[2:6..2:24): FilenameWithSpaces <- example/FilenameWithSpaces# + +expect/local-file.scala +----------------------- + +Summary: +Schema => SemanticDB v4 +Uri => local-file.scala +Text => empty +Language => Scala +Symbols => 3 entries +Occurrences => 7 entries + +Symbols: +example/`local-file`# => class local-file +example/`local-file`#``(). => primary ctor +local0 => val local local + +Occurrences: +[0:8..0:15): example <- example/ +[2:7..2:17): local-file <- example/`local-file`# +[3:2..3:2): <- example/`local-file`#``(). +[3:2..3:9): locally -> dotty/DottyPredef.locally(). +[4:8..4:13): local <- local0 +[5:4..5:9): local -> local0 +[5:10..5:11): + -> scala/Int#`+`(+4). + +expect/semanticdb-extract.scala +------------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => semanticdb-extract.scala +Text => empty +Language => Scala +Symbols => 17 entries +Occurrences => 22 entries + +Symbols: +_empty_/AnObject. => final object AnObject +_empty_/AnObject.Foo# => case class Foo +_empty_/AnObject.Foo#_1(). => method _1 +_empty_/AnObject.Foo#``(). => primary ctor +_empty_/AnObject.Foo#``().(x) => val param x +_empty_/AnObject.Foo#copy$default$1(). => method copy$default$1 +_empty_/AnObject.Foo#copy(). => method copy +_empty_/AnObject.Foo#copy().(x) => param x +_empty_/AnObject.Foo#x. => val method x +_empty_/AnObject.Foo. => final object Foo +_empty_/AnObject.Foo.apply(). => method apply +_empty_/AnObject.Foo.apply().(x) => param x +_empty_/AnObject.Foo.unapply(). => method unapply +_empty_/AnObject.Foo.unapply().(x$1) => param x$1 +_empty_/AnObject.foo(). => method foo +_empty_/AnObject.foo().(x) => param x +_empty_/AnObject.foo(+1). => method foo + +Occurrences: +[0:7..0:15): AnObject <- _empty_/AnObject. +[2:6..2:9): foo <- _empty_/AnObject.foo(). +[2:10..2:11): x <- _empty_/AnObject.foo().(x) +[2:13..2:16): Int -> scala/Int# +[3:6..3:9): foo <- _empty_/AnObject.foo(+1). +[3:13..3:17): Unit -> scala/Unit# +[5:2..5:5): foo -> _empty_/AnObject.foo(). +[6:2..6:5): foo -> _empty_/AnObject.foo(+1). +[8:5..8:14): substring -> java/lang/String#substring(). +[9:5..9:14): substring -> java/lang/String#substring(+1). +[11:2..11:6): List -> scala/package.List. +[11:6..11:6): -> scala/collection/IterableFactory#apply(). +[12:2..12:6): List -> scala/package.List. +[12:7..12:12): apply -> scala/collection/IterableFactory#apply(). +[13:2..13:6): List -> scala/package.List. +[13:7..13:14): `apply` -> scala/collection/IterableFactory#apply(). +[14:2..14:9): println -> scala/Predef.println(+1). +[14:12..14:13): + -> scala/Int#`+`(+4). +[16:13..16:16): Foo <- _empty_/AnObject.Foo# +[16:16..16:24): <- _empty_/AnObject.Foo#``(). +[16:17..16:18): x <- _empty_/AnObject.Foo#x. +[16:20..16:23): Int -> scala/Int# + +expect/toplevel.scala +--------------------- + +Summary: +Schema => SemanticDB v4 +Uri => toplevel.scala +Text => empty +Language => Scala +Symbols => 11 entries +Occurrences => 24 entries + +Symbols: +_empty_/toplevel$package. => final package object _empty_ +_empty_/toplevel$package.a. => val method a +_empty_/toplevel$package.combine(). => method combine +_empty_/toplevel$package.combine().(x) => param x +_empty_/toplevel$package.combine().(y) => param y +_empty_/toplevel$package.combine(+1). => method combine +_empty_/toplevel$package.combine(+1).(x) => param x +_empty_/toplevel$package.combine(+1).(y) => param y +_empty_/toplevel$package.combine(+1).(z) => param z +_empty_/toplevel$package.combine(+2). => method combine +_empty_/toplevel$package.foo(). => method foo + +Occurrences: +[0:0..0:16): inline val a = " <- _empty_/toplevel$package. +[0:11..0:12): a <- _empty_/toplevel$package.a. +[1:4..1:11): (x: Int <- _empty_/toplevel$package.combine(). +[1:5..1:6): x <- _empty_/toplevel$package.combine().(x) +[1:8..1:11): Int -> scala/Int# +[1:22..1:23): y <- _empty_/toplevel$package.combine().(y) +[1:25..1:28): Int -> scala/Int# +[1:32..1:33): x -> _empty_/toplevel$package.combine().(x) +[1:34..1:35): + -> scala/Int#`+`(+4). +[1:36..1:37): y -> _empty_/toplevel$package.combine().(y) +[2:4..2:11): combine <- _empty_/toplevel$package.combine(+1). +[2:12..2:13): x <- _empty_/toplevel$package.combine(+1).(x) +[2:15..2:18): Int -> scala/Int# +[2:20..2:21): y <- _empty_/toplevel$package.combine(+1).(y) +[2:23..2:26): Int -> scala/Int# +[2:28..2:29): z <- _empty_/toplevel$package.combine(+1).(z) +[2:31..2:34): Int -> scala/Int# +[2:38..2:39): x -> _empty_/toplevel$package.combine(+1).(x) +[2:40..2:41): + -> scala/Int#`+`(+4). +[2:42..2:43): y -> _empty_/toplevel$package.combine(+1).(y) +[2:44..2:45): + -> scala/Int#`+`(+4). +[2:46..2:47): z -> _empty_/toplevel$package.combine(+1).(z) +[3:4..3:11): combine <- _empty_/toplevel$package.combine(+2). +[4:4..4:7): foo <- _empty_/toplevel$package.foo(). diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md new file mode 100644 index 000000000000..ecb5f5da6ff7 --- /dev/null +++ b/tests/semanticdb/todo.md @@ -0,0 +1,24 @@ +# Todo List +Differences between scalameta implementation and dotc. + +- Generally put all zero length method calls or arguments in Synthetics section + - Pattern val defs -- [unapply|unapplySeq is zero-length] + - For comprehensions -- [map|flatMap|withFilter|foreach etc is zero-length]. + - Implicit conversions -- [span of Apply node is same as its single argument (which has a length)]. + - Implicit arguments -- [span of argument is zero length]. +- Record signature information in Symbols section. +- Record access modifier information in Symbols section. + +## Completed + +- [x] Recognise named arguments and traverse their bodies. +- [x] Recognise pattern val definitions. +- [x] Recognise anonymous functions. +- [x] Recognise specialised constant enum values. +- [x] Use setter symbol when assigning to a var. +- [x] Substitute constructor type params for the class parameters. +- [x] Skip the synthetic import statement in an Enum class. +- [x] Do not traverse RHS of synthetic val|var|def unless anonymous. +- [x] Avoid symbols with volatile names. - [$1$, $2$, etc]. +- [x] Skip module val +- [x] Add metac printer.