From 6b8afe73161ba9e8fcd8e8cf09728193dc45b7b2 Mon Sep 17 00:00:00 2001 From: Tomasz Godzik Date: Thu, 12 Aug 2021 11:38:42 +0200 Subject: [PATCH 1/2] Enable semanticdb by default --- compiler/src/dotty/tools/dotc/config/ScalaSettings.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala index f3a2d1f2f31f..8f7bee8e03c8 100644 --- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala +++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala @@ -153,7 +153,7 @@ private sealed trait XSettings: val XverifySignatures: Setting[Boolean] = BooleanSetting("-Xverify-signatures", "Verify generic signatures in generated bytecode.") val XignoreScala2Macros: Setting[Boolean] = BooleanSetting("-Xignore-scala2-macros", "Ignore errors when compiling code that calls Scala2 macros, these will fail at runtime.") val XimportSuggestionTimeout: Setting[Int] = IntSetting("-Ximport-suggestion-timeout", "Timeout (in ms) for searching for import suggestions when errors are reported.", 8000) - val Xsemanticdb: Setting[Boolean] = BooleanSetting("-Xsemanticdb", "Store information in SemanticDB.", aliases = List("-Ysemanticdb")) + val Xsemanticdb: Setting[Boolean] = BooleanSetting("-Xsemanticdb", "Store information in SemanticDB.", aliases = List("-Ysemanticdb"), initialValue = true) val Xtarget: Setting[String] = ChoiceSetting("-Xtarget", "target", "Emit bytecode for the specified version of the Java platform. This might produce bytecode that will break at runtime. When on JDK 9+, consider -release as a safer alternative.", ScalaSettings.supportedTargetVersions, "", aliases = List("--Xtarget")) val XcheckMacros: Setting[Boolean] = BooleanSetting("-Xcheck-macros", "Check some invariants of macro generated code while expanding macros", aliases = List("--Xcheck-macros")) From 98604b30c4d66effac4d827ad498126bbd87822c Mon Sep 17 00:00:00 2001 From: tanishiking Date: Sun, 20 Jun 2021 12:53:32 +0900 Subject: [PATCH 2/2] Add Singature information for Semanticdb Reset local symbol index for each TextDocument, updateExpect PrettyPrint signature and update metac.expect Integrate SymbolInformationOps into Scala3#SymbolOps Model WithType for AndType https://github.com/lampepfl/dotty/pull/12885#discussion_r655372990 Resolve ParamRef by constructing SymbolTable To construct symbol table before referring the ParamRef it's required to traverse the child trees before registering the symbol. Lookup symbols for refinements in RefinedType and RecType Re-insert assertion to localIdx Previously, there were the risks that localIdx receives the symbol that doens't have `span` because `TypeOps` generates dummy symbols for refinements in `RefinedType` and `RecType`. However, with the following commits, https://github.com/lampepfl/dotty/pull/12885/commits/7dd91ad1f8cc1cc3247a8522d9230e91db193548 https://github.com/lampepfl/dotty/pull/12885/commits/226e26f8b2f5481729cab745f27b0873a634cab3 now we never generate dummy symbol in `TypeOps`. So re-insert the assertion we deleted when copying this method from `ExtractSemanticDB`. see: https://github.com/lampepfl/dotty/pull/12885/files#r658150249 Convert AndType to IntersectionType Refactor enterRefined Refactor: move all extension (of Symbol) method into Scala3 Don't add type parameters as parameters to MethodSignature Refactor not to use isInstanceOf for designator of TypeRef and TermRef Use intersection type for the parent of RefinedType Convert wildcard type as ExistentialType For wildcard type `C[_ <: T]`, it's internal type representation will be `AppliedType(TypeBounds(lo = , hi = ))`. As scalameta for Scala2 does, we'll convert the wildcard type to `ExistentialType(TypeRef(NoPrefix, C, ), Scope(hardlinks = List()))` where `` has - display_name: "_" and, - signature: type_signature(..., lo = , hi = ) See: https://github.com/lampepfl/dotty/pull/12885/files#r663797616 https://scalameta.org/docs/semanticdb/specification.html#type-2 Now, when we compile the following Scala program to semanticdb ```scala class Wildcards { def e1: List[_ <: Int] = ??? } ``` The semanticdb's SymbolInformation for `e1` looks like: From scala3 ``` symbols { symbol: "advanced/Wildcards#e1()." kind: METHOD display_name: "e1" language: SCALA signature { value_signature { tpe { by_name_type { tpe { existential_type { tpe { type_ref { symbol: "scala/collection/immutable/List#" type_arguments { type_ref { symbol: "local0" } } } } declarations { hardlinks { symbol: "local0" kind: TYPE display_name: "_" language: SCALA signature { type_signature { type_parameters { } lower_bound { type_ref { symbol: "scala/Nothing#" } } upper_bound { type_ref { symbol: "scala/Int#" } } } } } } } } } } } } } ``` On the other hand, generated from scalameta's metac with scalac 2.13.6 ```sh $ metac --version Scala compiler version 2.13.6 -- Copyright 2002-2021, LAMP/EPFL and Lightbend, Inc. ``` ``` symbols { symbol: "advanced/Wildcards#e()." kind: METHOD display_name: "e" language: SCALA signature { method_signature { type_parameters { } return_type { existential_type { tpe { type_ref { symbol: "scala/package.List#" type_arguments { type_ref { symbol: "local0" } } } } declarations { hardlinks { symbol: "local0" kind: TYPE properties: 4 display_name: "_" language: SCALA signature { type_signature { type_parameters { } lower_bound { type_ref { symbol: "scala/Nothing#" } } upper_bound { type_ref { symbol: "scala/Int#" } } } } access { public_access { } } } } } } } } access { public_access { } } } ``` Use finalResultType for MethodSignature to get actual return type. Register the symbol of nested method with "actual" binder For example: `def foo(x: T)(y: T): T` and for `.owner.info` would be like `MethodType(..., resType = MethodType(..., resType = ))`. (Let's say the outer `MethodType` "outer", and `MethodType` who is `resType` of outer "inner") Before this commit, we register to the symbol table with `(, outer)`, which should be `(, inner)`. For such a nested method signature, we have to find the "actual" binder for parameters and register them to the symbol table. Remove unused parameter sym from toSemanticType Fix pprint issue for SingleType When the prefix of SingleType is Type.Emtpy, we had been printing them as `.sym.type`, but it should be `sym.type` Convert symbols to local index for funParamSymbol Refactor style of if Co-authored-by: Jamie Thompson Fix printing upper type bounds Add evidence params to SemanticDB Add refinements to RefinedType generated by opaque types Fix empty refinement for RefinedType for the result of polymorphic method Print definition of ExistentialType instead of displaySymbol Update comment Co-authored-by: Jamie Thompson None for empty decls Warn if symbol lookup failed for paramRef and RefinedType Workaround symbol not found for higher kinded type param Suppress warning for known issue of exporting Polymorphic type Support multiple type param clauses for extension method By combining two type param clause into one Exclude synthetic symbols from occurrences Fallback to Type.member for refinements who can't access to the tree For example, ```scala trait SpecialRefinement { def pickOne(as: String*): Option[Any] } class PickOneRefinement_1[S <: SpecialRefinement { def pickOne(as: String*): Option[String] }] { def run(s: S, as: String*): Option[String] = s.pickOne(as:_*) } ``` In the typed AST, the SpecialRefinement is inside of the TypeTree and cannot access to the refinement (pickOne) from tree, therefore we can't register the symbol of pickOne to symbol table. In this case, fallback to `Type.member` to find the symbol of `pickOne`. Fallback to Type.member for ParamRef Workaround symbol not found for HKTypeLambda in upper bounds and fix type for curried applied type Remove unnecessary comment Do not create newSymbol for wildcard type symbol instead, create a proxy data that will be converted to semanticdb symbol who represents wildcard symbol Warn if unexpected type appear while converting type to SemanticDB type Dealias LazyRef while converting types to SemanticDB Do not emit warning for unexpected type Because there could be an unexpected types for incompilable sources and if we show the warning for uncompilable sources, it could be confusing. Do not create a newSymbol for ParamRef Make wildcard type symbol global Hardlink fake symbols Excude symbols that doesn't present in source from occurrence Make namePresenInSource safe for IndexOutOfRange Make package objects present in source Fallback to fake symbol for refinements in RefinedType of upper bound see: https://github.com/lampepfl/dotty/pull/12885#issuecomment-886838483 https://github.com/lampepfl/dotty/pull/12885#discussion_r677483330 Add occurrences of secondary constructors Add fakeSymbols to symbol section and don't hardlink fake syms Convert tp <:< FromJavaObject to tp <:< Any Do not add wildcard symbol of existential type to symbol section Refactor styles --- .../tools/dotc/semanticdb/ConstantOps.scala | 25 + .../tools/dotc/semanticdb/Descriptor.scala | 120 + .../dotc/semanticdb/ExtractSemanticDB.scala | 365 +- .../tools/dotc/semanticdb/LinkMode.scala | 4 + .../dotty/tools/dotc/semanticdb/PPrint.scala | 279 ++ .../dotty/tools/dotc/semanticdb/Scala3.scala | 206 +- .../semanticdb/SemanticSymbolBuilder.scala | 151 + .../dotty/tools/dotc/semanticdb/Tools.scala | 63 +- .../dotty/tools/dotc/semanticdb/TypeOps.scala | 441 ++ tests/semanticdb/expect/Advanced.expect.scala | 22 +- tests/semanticdb/expect/Advanced.scala | 8 + tests/semanticdb/expect/Classes.expect.scala | 12 +- .../semanticdb/expect/EndMarkers.expect.scala | 4 +- tests/semanticdb/expect/Enums.expect.scala | 10 +- .../expect/EtaExpansion.expect.scala | 4 +- tests/semanticdb/expect/Example.expect.scala | 4 +- .../semanticdb/expect/Extension.expect.scala | 13 +- tests/semanticdb/expect/Extension.scala | 11 +- .../expect/ForComprehension.expect.scala | 40 +- tests/semanticdb/expect/Givens.expect.scala | 8 +- .../expect/ImplicitConversion.expect.scala | 20 +- .../expect/InstrumentTyper.expect.scala | 4 +- .../expect/InventedNames.expect.scala | 14 +- .../semanticdb/expect/Issue1749.expect.scala | 6 +- tests/semanticdb/expect/Local.expect.scala | 4 +- tests/semanticdb/expect/Locals.expect.scala | 2 +- .../semanticdb/expect/MetacJava.expect.scala | 18 +- .../expect/MethodUsages.expect.scala | 6 +- tests/semanticdb/expect/Methods.expect.scala | 3 +- tests/semanticdb/expect/Methods.scala | 1 + .../expect/NamedApplyBlock.expect.scala | 4 +- .../expect/NamedArguments.expect.scala | 2 +- .../expect/NewModifiers.expect.scala | 13 + tests/semanticdb/expect/NewModifiers.scala | 13 + .../expect/RecOrRefined.expect.scala | 34 + tests/semanticdb/expect/RecOrRefined.scala | 34 + .../RightAssociativeExtension.expect.scala | 2 +- .../semanticdb/expect/Synthetic.expect.scala | 48 +- tests/semanticdb/expect/Traits.expect.scala | 2 +- .../semanticdb/expect/ValPattern.expect.scala | 30 +- tests/semanticdb/expect/Vals.expect.scala | 2 +- .../expect/exports-example-Codec.expect.scala | 4 +- tests/semanticdb/expect/i9782.expect.scala | 20 + tests/semanticdb/expect/i9782.scala | 20 + .../semanticdb/expect/inlinedefs.expect.scala | 4 +- tests/semanticdb/expect/nullary.expect.scala | 20 + tests/semanticdb/expect/nullary.scala | 20 + .../semanticdb/expect/recursion.expect.scala | 8 +- .../expect/semanticdb-Flags.expect.scala | 4 +- .../expect/semanticdb-Types.expect.scala | 6 +- .../expect/semanticdb-extract.expect.scala | 2 +- tests/semanticdb/expect/toplevel.expect.scala | 4 +- tests/semanticdb/metac.expect | 3566 +++++++++-------- 53 files changed, 3501 insertions(+), 2229 deletions(-) create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/ConstantOps.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/Descriptor.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/LinkMode.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala create mode 100644 tests/semanticdb/expect/RecOrRefined.expect.scala create mode 100644 tests/semanticdb/expect/RecOrRefined.scala create mode 100644 tests/semanticdb/expect/i9782.expect.scala create mode 100644 tests/semanticdb/expect/i9782.scala create mode 100644 tests/semanticdb/expect/nullary.expect.scala create mode 100644 tests/semanticdb/expect/nullary.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ConstantOps.scala b/compiler/src/dotty/tools/dotc/semanticdb/ConstantOps.scala new file mode 100644 index 000000000000..975d5480fe9b --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/ConstantOps.scala @@ -0,0 +1,25 @@ +package dotty.tools +package dotc +package semanticdb + +import dotty.tools.dotc.{semanticdb => s} + +import core.Contexts.Context +import core.Constants._ + +object ConstantOps: + extension (const: Constant) + def toSemanticConst(using Context): s.Constant = const.tag match { + case UnitTag => s.UnitConstant() + case BooleanTag => s.BooleanConstant(const.booleanValue) + case ByteTag => s.ByteConstant(const.byteValue) + case ShortTag => s.ShortConstant(const.shortValue) + case CharTag => s.CharConstant(const.charValue) + case IntTag => s.IntConstant(const.intValue) + case LongTag => s.LongConstant(const.longValue) + case FloatTag => s.FloatConstant(const.floatValue) + case DoubleTag => s.DoubleConstant(const.doubleValue) + case StringTag => s.StringConstant(const.stringValue) + case NullTag => s.NullConstant() + case _ => throw new Error(s"Constant ${const} can't be converted to Semanticdb Constant.") + } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Descriptor.scala b/compiler/src/dotty/tools/dotc/semanticdb/Descriptor.scala new file mode 100644 index 000000000000..a93b99df602c --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Descriptor.scala @@ -0,0 +1,120 @@ +package dotty.tools.dotc.semanticdb + +import java.lang.System.{lineSeparator => EOL} +import dotty.tools.dotc.semanticdb.{Descriptor => d} + +class DescriptorParser(s: String) { + var i = s.length + def fail() = { + val message = "invalid symbol format" + val caret = " " * i + "^" + sys.error(s"$message$EOL$s$EOL$caret") + } + + val BOF = '\u0000' + val EOF = '\u001A' + var currChar = EOF + def readChar(): Char = { + if (i <= 0) { + if (i == 0) { + i -= 1 + currChar = BOF + currChar + } else { + fail() + } + } else { + i -= 1 + currChar = s(i) + currChar + } + } + + def parseValue(): String = { + if (currChar == '`') { + val end = i + while (readChar() != '`') {} + readChar() + s.substring(i + 2, end) + } else { + val end = i + 1 + if (!Character.isJavaIdentifierPart(currChar)) fail() + while (Character.isJavaIdentifierPart(readChar()) && currChar != BOF) {} + s.substring(i + 1, end) + } + } + + def parseDisambiguator(): String = { + val end = i + 1 + if (currChar != ')') fail() + while (readChar() != '(') {} + readChar() + s.substring(i + 1, end) + } + + def parseDescriptor(): Descriptor = { + if (currChar == '.') { + readChar() + if (currChar == ')') { + val disambiguator = parseDisambiguator() + val value = parseValue() + d.Method(value, disambiguator) + } else { + d.Term(parseValue()) + } + } else if (currChar == '#') { + readChar() + d.Type(parseValue()) + } else if (currChar == '/') { + readChar() + d.Package(parseValue()) + } else if (currChar == ')') { + readChar() + val value = parseValue() + if (currChar != '(') fail() + else readChar() + d.Parameter(value) + } else if (currChar == ']') { + readChar() + val value = parseValue() + if (currChar != '[') fail() + else readChar() + d.TypeParameter(value) + } else { + fail() + } + } + + def entryPoint(): (Descriptor, String) = { + readChar() + val desc = parseDescriptor() + (desc, s.substring(0, i + 1)) + } +} + +object DescriptorParser { + def apply(symbol: String): (Descriptor, String) = { + val parser = new DescriptorParser(symbol) + parser.entryPoint() + } +} + +sealed trait Descriptor { + def isNone: Boolean = this == d.None + def isTerm: Boolean = this.isInstanceOf[d.Term] + def isMethod: Boolean = this.isInstanceOf[d.Method] + def isType: Boolean = this.isInstanceOf[d.Type] + def isPackage: Boolean = this.isInstanceOf[d.Package] + def isParameter: Boolean = this.isInstanceOf[d.Parameter] + def isTypeParameter: Boolean = this.isInstanceOf[d.TypeParameter] + def value: String +} +object Descriptor { + case object None extends Descriptor { def value: String = "" } + final case class Term(value: String) extends Descriptor + final case class Method(value: String, disambiguator: String) extends Descriptor + final case class Type(value: String) extends Descriptor + final case class Package(value: String) extends Descriptor + final case class Parameter(value: String) extends Descriptor + final case class TypeParameter(value: String) extends Descriptor +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 710f3493b418..3925ab2d4132 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -23,6 +23,7 @@ import scala.collection.mutable import scala.annotation.{ threadUnsafe => tu, tailrec } import scala.PartialFunction.condOpt +import dotty.tools.dotc.{semanticdb => s} /** Extract symbol references and uses to semanticdb files. * See https://scalameta.org/docs/semanticdb/specification.html#symbol-1 @@ -43,25 +44,18 @@ class ExtractSemanticDB extends Phase: override def run(using Context): Unit = val unit = ctx.compilationUnit - val extract = Extractor() - extract.traverse(unit.tpdTree) - ExtractSemanticDB.write(unit.source, extract.occurrences.toList, extract.symbolInfos.toList) + val extractor = Extractor() + extractor.extract(unit.tpdTree) + ExtractSemanticDB.write(unit.source, extractor.occurrences.toList, extractor.symbolInfos.toList) /** Extractor of symbol occurrences from trees */ class Extractor extends TreeTraverser: - - private var nextLocalIdx: Int = 0 - - /** The index of a local symbol */ - private val locals = mutable.HashMap[Symbol, Int]() + given s.SemanticSymbolBuilder = s.SemanticSymbolBuilder() + val converter = s.TypeOps() /** 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]](): - override def default(key: Int) = Set[Symbol]() - /** The extracted symbol occurrences */ val occurrences = new mutable.ListBuffer[SymbolOccurrence]() @@ -74,6 +68,11 @@ class ExtractSemanticDB extends Phase: /** The symbol occurrences generated so far, as a set */ private val generated = new mutable.HashSet[SymbolOccurrence] + def extract(tree: Tree)(using Context): Unit = + traverse(tree) + val fakeSyms = converter.fakeSymbols.map(_.symbolInfo(Set.empty)(using LinkMode.SymlinkChildren, converter)) + symbolInfos.appendAll(fakeSyms) + /** Definitions of this symbol should be excluded from semanticdb */ private def excludeDef(sym: Symbol)(using Context): Boolean = !sym.exists @@ -131,61 +130,52 @@ class ExtractSemanticDB extends Phase: tree match case tree: PackageDef => - if !excludeDef(tree.pid.symbol) - && tree.pid.span.hasLength then - tree.pid match - case tree: Select => - registerDefinition(tree.symbol, selectSpan(tree), Set.empty, tree.source) - traverse(tree.qualifier) - case tree => registerDefinition(tree.symbol, tree.span, Set.empty, tree.source) tree.stats.foreach(traverse) + if !excludeDef(tree.pid.symbol) && tree.pid.span.hasLength then + tree.pid match + case tree: Select => + traverse(tree.qualifier) + registerDefinition(tree.symbol, selectSpan(tree), Set.empty, tree.source) + case tree => registerDefinition(tree.symbol, tree.span, Set.empty, tree.source) case tree: NamedDefTree => if !tree.symbol.isAllOf(ModuleValCreationFlags) then - if !excludeDef(tree.symbol) - && tree.span.hasLength then + 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.filter(!_.span.isZeroExtent).foreach(traverse) + case _ => // calls $new + case tree: ValDef if tree.symbol.isSelfSym => + if tree.tpt.span.hasLength then + traverse(tree.tpt) + case tree: DefDef if tree.symbol.isConstructor => // ignore typeparams for secondary ctors + tree.trailingParamss.foreach(_.foreach(traverse)) + traverse(tree.rhs) + case tree: (DefDef | ValDef) if tree.symbol.isSyntheticWithIdent => + tree match + case tree: DefDef => + tree.paramss.foreach(_.foreach(param => registerSymbolSimple(param.symbol))) + case tree: ValDef if tree.symbol.is(Given) => traverse(tree.tpt) + case _ => + if !tree.symbol.isGlobal then + localBodies(tree.symbol) = tree.rhs + // ignore rhs + case PatternValDef(pat, rhs) => + traverse(rhs) + PatternValDef.collectPats(pat).foreach(traverse) + case tree => + if !excludeChildren(tree.symbol) then + traverseChildren(tree) + } + if !excludeDef(tree.symbol) && tree.span.hasLength then registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree), tree.source) val privateWithin = tree.symbol.privateWithin if privateWithin.exists then registerUseGuarded(None, privateWithin, spanOfSymbol(privateWithin, tree.span, tree.source), tree.source) else if !excludeSymbol(tree.symbol) then - 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.filter(!_.span.isZeroExtent).foreach(traverse) - case _ => // calls $new - case tree: ValDef - if tree.symbol.isSelfSym => - if tree.tpt.span.hasLength then - traverse(tree.tpt) - case tree: DefDef - if tree.symbol.isConstructor => // ignore typeparams for secondary ctors - tree.trailingParamss.foreach(_.foreach(traverse)) - traverse(tree.rhs) - case tree: (DefDef | ValDef) - if tree.symbol.isSyntheticWithIdent => - tree match - case tree: DefDef => - tree.paramss.foreach(_.foreach(param => registerSymbolSimple(param.symbol))) - case tree: ValDef if tree.symbol.is(Given) => traverse(tree.tpt) - case _ => - if !tree.symbol.isGlobal then - localBodies(tree.symbol) = tree.rhs - // ignore rhs - case PatternValDef(pat, rhs) => - traverse(rhs) - PatternValDef.collectPats(pat).foreach(traverse) - case tree => - if !excludeChildren(tree.symbol) then - traverseChildren(tree) + registerSymbol(tree.symbol, symbolKinds(tree)) case tree: Template => val ctorSym = tree.constr.symbol - if !excludeDef(ctorSym) then - traverseAnnotsOfDefinition(ctorSym) - registerDefinition(ctorSym, tree.constr.nameSpan.startPos, Set.empty, tree.source) - ctorParams(tree.constr.termParamss, tree.body) for parent <- tree.parentsOrDerived if parent.span.hasLength do traverse(parent) val selfSpan = tree.self.span @@ -195,14 +185,18 @@ class ExtractSemanticDB extends Phase: tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement else tree.body.foreach(traverse) + if !excludeDef(ctorSym) then + traverseAnnotsOfDefinition(ctorSym) + ctorParams(tree.constr.termParamss, tree.body) + registerDefinition(ctorSym, tree.constr.nameSpan.startPos, Set.empty, tree.source) case tree: Apply => - @tu lazy val genParamSymbol: Name => String = funParamSymbol(tree.fun.symbol) + @tu lazy val genParamSymbol: Name => String = tree.fun.symbol.funParamSymbol traverse(tree.fun) for arg <- tree.args do arg match case tree @ NamedArg(name, arg) => - registerUse(genParamSymbol(name), tree.span.startPos.withEnd(tree.span.start + name.toString.length), tree.source) traverse(localBodies.get(arg.symbol).getOrElse(arg)) + registerUse(genParamSymbol(name), tree.span.startPos.withEnd(tree.span.start + name.toString.length), tree.source) case _ => traverse(arg) case tree: Assign => val qualSym = condOpt(tree.lhs) { case Select(qual, _) if qual.symbol.exists => qual.symbol } @@ -222,11 +216,12 @@ class ExtractSemanticDB extends Phase: val qual = tree.qualifier val qualSpan = qual.span val sym = tree.symbol.adjustIfCtorTyparam - registerUseGuarded(qual.symbol.ifExists, sym, selectSpan(tree), tree.source) if qualSpan.exists && qualSpan.hasLength then traverse(qual) + registerUseGuarded(qual.symbol.ifExists, sym, selectSpan(tree), tree.source) case tree: Import => if tree.span.exists && tree.span.hasLength then + traverseChildren(tree) for sel <- tree.selectors do val imported = sel.imported.name if imported != nme.WILDCARD then @@ -234,7 +229,6 @@ class ExtractSemanticDB extends Phase: registerUseGuarded(None, alt.symbol, sel.imported.span, tree.source) if (alt.symbol.companionClass.exists) registerUseGuarded(None, alt.symbol.companionClass, sel.imported.span, tree.source) - traverseChildren(tree) case tree: Inlined => traverse(tree.call) case _ => @@ -249,14 +243,6 @@ class ExtractSemanticDB extends Phase: end traverse - private def funParamSymbol(funSym: Symbol)(using 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: def unapply(tree: ValDef)(using Context): Option[(Tree, Tree)] = tree.rhs match @@ -290,92 +276,6 @@ class ExtractSemanticDB extends Phase: end PatternValDef - /** Add semanticdb name of the given symbol to string builder */ - private def addSymName(b: StringBuilder, sym: Symbol)(using 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) then - decls0 ++ sym.owner.companionClass.info.decls.lookupAll(sym.name) - else - decls0 - end decls - val alts = decls.filter(_.isOneOf(Method | Mutable)).toList.reverse - def find(filter: Symbol => Boolean) = alts match - case notSym :: rest if !filter(notSym) => - val idx = rest.indexWhere(filter).ensuring(_ >= 0) - b.append('+').append(idx + 1) - case _ => - end find - val sig = sym.signature - find(_.signature == sig) - - 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)(using Context): Int = - val startPos = - assert(sym.span.exists, s"$sym should have a span") - sym.span.start - @tailrec - def computeLocalIdx(sym: Symbol): Int = locals get sym match - case Some(idx) => idx - case None => symsAtOffset(startPos).find(_.name == sym.name) match - case Some(other) => computeLocalIdx(other) - case None => - val idx = nextLocalIdx - nextLocalIdx += 1 - locals(sym) = idx - symsAtOffset(startPos) += sym - idx - end computeLocalIdx - computeLocalIdx(sym) - end localIdx - - 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)(using Context): String = - val b = StringBuilder(20) - addSymName(b, sym) - b.toString private def range(span: Span, treeSource: SourceFile)(using Context): Option[Range] = def lineCol(offset: Int) = (treeSource.offsetToLine(offset), treeSource.column(offset)) @@ -383,124 +283,17 @@ class ExtractSemanticDB extends Phase: val (endLine, endCol) = lineCol(span.end) Some(Range(startLine, startCol, endLine, endCol)) - private def symbolKind(sym: Symbol, symkinds: Set[SymbolKind])(using Context): SymbolInformation.Kind = - if sym.isTypeParam then - SymbolInformation.Kind.TYPE_PARAMETER - else if sym.is(TermParam) then - SymbolInformation.Kind.PARAMETER - else if sym.isTerm && sym.owner.isTerm then - SymbolInformation.Kind.LOCAL - else if sym.isInlineMethod || sym.is(Macro) then - SymbolInformation.Kind.MACRO - else if sym.isConstructor then - SymbolInformation.Kind.CONSTRUCTOR - else if sym.isSelfSym then - SymbolInformation.Kind.SELF_PARAMETER - else if sym.isOneOf(Method) || symkinds.exists(_.isVarOrVal) then - SymbolInformation.Kind.METHOD - else if sym.isPackageObject then - SymbolInformation.Kind.PACKAGE_OBJECT - else if sym.is(Module) then - SymbolInformation.Kind.OBJECT - else if sym.is(Package) then - SymbolInformation.Kind.PACKAGE - else if sym.isAllOf(JavaInterface) then - SymbolInformation.Kind.INTERFACE - else if sym.is(Trait) then - SymbolInformation.Kind.TRAIT - else if sym.isClass then - SymbolInformation.Kind.CLASS - else if sym.isType then - SymbolInformation.Kind.TYPE - else if sym.is(ParamAccessor) then - SymbolInformation.Kind.FIELD - else - SymbolInformation.Kind.UNKNOWN_KIND - - private def symbolProps(sym: Symbol, symkinds: Set[SymbolKind])(using Context): Int = - if sym.is(ModuleClass) then - return symbolProps(sym.sourceModule, symkinds) - var props = 0 - if sym.isPrimaryConstructor then - props |= SymbolInformation.Property.PRIMARY.value - if sym.is(Abstract) || symkinds.contains(SymbolKind.Abstract) then - props |= SymbolInformation.Property.ABSTRACT.value - if sym.is(Final) then - props |= SymbolInformation.Property.FINAL.value - if sym.is(Sealed) then - props |= SymbolInformation.Property.SEALED.value - if sym.is(Implicit) then - props |= SymbolInformation.Property.IMPLICIT.value - if sym.is(Lazy, butNot=Module) then - props |= SymbolInformation.Property.LAZY.value - if sym.isAllOf(Case | Module) || sym.is(CaseClass) || sym.isAllOf(EnumCase) then - props |= SymbolInformation.Property.CASE.value - if sym.is(Covariant) then - props |= SymbolInformation.Property.COVARIANT.value - if sym.is(Contravariant) then - props |= SymbolInformation.Property.CONTRAVARIANT.value - if sym.isAllOf(DefaultMethod | JavaDefined) || sym.is(Accessor) && sym.name.is(NameKinds.DefaultGetterName) then - props |= SymbolInformation.Property.DEFAULT.value - if symkinds.exists(_.isVal) then - props |= SymbolInformation.Property.VAL.value - if symkinds.exists(_.isVar) then - props |= SymbolInformation.Property.VAR.value - if sym.is(JavaStatic) then - props |= SymbolInformation.Property.STATIC.value - if sym.is(Enum) then - props |= SymbolInformation.Property.ENUM.value - if sym.is(Given) then - props |= SymbolInformation.Property.GIVEN.value - if sym.is(Inline) then - props |= SymbolInformation.Property.INLINE.value - if sym.is(Open) then - props |= SymbolInformation.Property.OPEN.value - if sym.is(Open) then - props |= SymbolInformation.Property.OPEN.value - if sym.is(Transparent) then - props |= SymbolInformation.Property.TRANSPARENT.value - if sym.is(Infix) then - props |= SymbolInformation.Property.INFIX.value - if sym.is(Opaque) then - props |= SymbolInformation.Property.OPAQUE.value - props - - private def symbolAccess(sym: Symbol, kind: SymbolInformation.Kind)(using Context): Access = - kind match - case k.LOCAL | k.PARAMETER | k.SELF_PARAMETER | k.TYPE_PARAMETER | k.PACKAGE | k.PACKAGE_OBJECT => - Access.Empty - case _ => - if (sym.privateWithin == NoSymbol) - if (sym.isAllOf(PrivateLocal)) PrivateThisAccess() - else if (sym.is(Private)) PrivateAccess() - else if (sym.isAllOf(ProtectedLocal)) ProtectedThisAccess() - else if (sym.is(Protected)) ProtectedAccess() - else PublicAccess() - else - val ssym = symbolName(sym.privateWithin) - if (sym.is(Protected)) ProtectedWithinAccess(ssym) - else PrivateWithinAccess(ssym) - - private def symbolInfo(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(using Context): SymbolInformation = - val kind = symbolKind(sym, symkinds) - SymbolInformation( - symbol = symbolName, - language = Language.SCALA, - kind = kind, - properties = symbolProps(sym, symkinds), - displayName = Symbols.displaySymbol(sym), - access = symbolAccess(sym, kind), - ) - private def registerSymbol(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(using Context): Unit = - val isLocal = symbolName.isLocal - if !isLocal || !localNames.contains(symbolName) then + private def registerSymbol(sym: Symbol, symkinds: Set[SymbolKind])(using Context): Unit = + val sname = sym.symbolName + val isLocal = sname.isLocal + if !isLocal || !localNames.contains(sname) then if isLocal then - localNames += symbolName - symbolInfos += symbolInfo(sym, symbolName, symkinds) + localNames += sname + symbolInfos += sym.symbolInfo(symkinds)(using LinkMode.SymlinkChildren, converter) private def registerSymbolSimple(sym: Symbol)(using Context): Unit = - registerSymbol(sym, symbolName(sym), Set.empty) + registerSymbol(sym, Set.empty) private def registerOccurrence(symbol: String, span: Span, role: SymbolOccurrence.Role, treeSource: SourceFile)(using Context): Unit = val occ = SymbolOccurrence(range(span, treeSource), symbol, role) @@ -509,30 +302,44 @@ class ExtractSemanticDB extends Phase: generated += occ private def registerUseGuarded(qualSym: Option[Symbol], sym: Symbol, span: Span, treeSource: SourceFile)(using Context) = - if !excludeUse(qualSym, sym) then + if !excludeUse(qualSym, sym) && namePresentInSource(sym, span, treeSource) then registerUse(sym, span, treeSource) private def registerUse(sym: Symbol, span: Span, treeSource: SourceFile)(using Context): Unit = - registerUse(symbolName(sym), span, treeSource) + registerUse(sym.symbolName, span, treeSource) private def registerUse(symbol: String, span: Span, treeSource: SourceFile)(using Context): Unit = registerOccurrence(symbol, span, SymbolOccurrence.Role.REFERENCE, treeSource) private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind], treeSource: SourceFile)(using Context) = - val symbol = symbolName(sym) + val sname = sym.symbolName val finalSpan = if !span.hasLength || !sym.is(Given) || namePresentInSource(sym, span, treeSource) then span else Span(span.start) - registerOccurrence(symbol, finalSpan, SymbolOccurrence.Role.DEFINITION, treeSource) + if namePresentInSource(sym, span, treeSource) then + registerOccurrence(sname, finalSpan, SymbolOccurrence.Role.DEFINITION, treeSource) if !sym.is(Package) then - registerSymbol(sym, symbol, symkinds) + registerSymbol(sym, symkinds) private def namePresentInSource(sym: Symbol, span: Span, source:SourceFile)(using Context): Boolean = - val content = source.content() - val (start, end) = if content(span.end - 1) == '`' then (span.start + 1, span.end - 1) else (span.start, span.end) - content.slice(start, end).mkString == sym.name.stripModuleClassSuffix.lastPart.toString + if !span.exists then false + else + val content = source.content() + val (start, end) = + if content.lift(span.end - 1).exists(_ == '`') then + (span.start + 1, span.end - 1) + else (span.start, span.end) + val nameInSource = content.slice(start, end).mkString + // for secondary constructors `this` + if sym.isConstructor && nameInSource == nme.THISkw.toString then + true + else + val target = + if sym.isPackageObject then sym.owner + else sym + nameInSource == target.name.stripModuleClassSuffix.lastPart.toString private def spanOfSymbol(sym: Symbol, span: Span, treeSource: SourceFile)(using Context): Span = val contents = if treeSource.exists then treeSource.content() else Array.empty[Char] @@ -625,13 +432,13 @@ class ExtractSemanticDB extends Phase: vparams <- vparamss vparam <- vparams do + traverse(vparam.tpt) if !excludeSymbol(vparam.symbol) then traverseAnnotsOfDefinition(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) - traverse(vparam.tpt) + registerSymbol(vparam.symbol, symkinds) object ExtractSemanticDB: import java.nio.file.Path diff --git a/compiler/src/dotty/tools/dotc/semanticdb/LinkMode.scala b/compiler/src/dotty/tools/dotc/semanticdb/LinkMode.scala new file mode 100644 index 000000000000..aac4c1254892 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/LinkMode.scala @@ -0,0 +1,4 @@ +package dotty.tools.dotc.semanticdb + +enum LinkMode: + case SymlinkChildren, HardlinkChildren diff --git a/compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala b/compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala new file mode 100644 index 000000000000..48ff5d885187 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala @@ -0,0 +1,279 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.{semanticdb => s} + +import scala.collection.mutable +import dotty.tools.dotc.semanticdb.Scala3.{_, given} +import SymbolInformation.Kind._ + +class SymbolInfomationPrinter (symtab: PrinterSymtab): + val notes = InfoNotes() + val infoPrinter = InfoPrinter(notes) + + def pprintSymbolInformation(info: SymbolInformation): String = + val sb = new StringBuilder() + sb.append(info.symbol).append(" => ") + sb.append(infoPrinter.pprint(info)) + sb.toString + + class InfoNotes: + private val noteSymtab = mutable.Map[String, SymbolInformation]() + def enter(info: SymbolInformation) = + if (symtab.info(info.symbol).isEmpty && info.kind != UNKNOWN_KIND) + noteSymtab(info.symbol) = info + + def visit(sym: String): SymbolInformation = + val symtabInfo = noteSymtab.get(sym).orElse(symtab.info(sym)) + symtabInfo.getOrElse { + val displayName = if sym.isGlobal then sym.desc.value else sym + SymbolInformation(symbol = sym, displayName = displayName) + } + + class InfoPrinter(notes: InfoNotes) { + private enum SymbolStyle: + case Reference, Definition + def pprint(info: SymbolInformation): String = + val sb = new StringBuilder() + sb.append(accessString(info.access)) + 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 ") + if info.isGiven then sb.append("given ") + if info.isInline then sb.append("inline ") + if info.isOpen then sb.append("open ") + if info.isTransparent then sb.append("transparent ") + if info.isInfix then sb.append("infix ") + if info.isOpaque then sb.append("opaque ") + 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(s"${info.displayName}${info.prefixBeforeTpe}${pprint(info.signature)}") + sb.toString + + private def pprintDef(info: SymbolInformation) = + notes.enter(info) + pprint(info.symbol, SymbolStyle.Definition) + private def pprintRef(sym: String): String = pprint(sym, SymbolStyle.Reference) + private def pprintDef(sym: String): String = pprint(sym, SymbolStyle.Definition) + private def pprint(sym: String, style: SymbolStyle): String = + val info = notes.visit(sym) + style match + case SymbolStyle.Reference => + info.displayName + case SymbolStyle.Definition => + pprint(info) + + + private def pprint(sig: Signature): String = + sig match + case ClassSignature(tparams, parents, self, decls) => + val sb = new StringBuilder() + if (tparams.infos.nonEmpty) + sb.append(tparams.infos.map(pprintDef).mkString("[", ", ", "] ")) + if (parents.nonEmpty) + sb.append(parents.map(pprint).mkString("extends ", " with ", " ")) + if (self.isDefined || decls.infos.nonEmpty) { + val selfStr = if (self.isDefined) s"self: ${pprint(self)} =>" else "" + val declsStr = if (decls.infos.nonEmpty) s"+${decls.infos.length} decls" else "" + sb.append(s"{ ${selfStr} ${declsStr} }") + } + sb.toString + case MethodSignature(tparams, paramss, res) => + val sb = new StringBuilder() + if (tparams.infos.nonEmpty) + sb.append(tparams.infos.map(pprintDef).mkString("[", ", ", "]")) + paramss.foreach { params => + val paramsStr = params.infos.map(pprintDef).mkString("(", ", ", ")") + sb.append(paramsStr) + } + sb.append(s": ${pprint(res)}") + sb.toString + case TypeSignature(tparams, lo, hi) => + val sb = new StringBuilder() + if (tparams.infos.nonEmpty) + sb.append(tparams.infos.map(pprintDef).mkString("[", ", ", "]")) + if (lo == hi) { + sb.append(s" = ${pprint(lo)}") + } else { + lo match + case TypeRef(Type.Empty, "scala/Nothing#", Nil) => () + case lo => sb.append(s" >: ${pprint(lo)}") + hi match + case TypeRef(Type.Empty, "scala/Any#", Nil) => () + case TypeRef(Type.Empty, "java/lang/Object#", Nil) => () + case hi => sb.append(s" <: ${pprint(hi)}") + } + sb.toString + case ValueSignature(tpe) => + pprint(tpe) + case _ => + "" + + private def pprint(tpe: Type): String = { + def prefix(tpe: Type): String = tpe match + case TypeRef(pre, sym, args) => + val preStr = pre match { + case _: SingleType | _: ThisType | _: SuperType => + s"${prefix(pre)}." + case Type.Empty => "" + case _ => + s"${prefix(pre)}#" + } + val argsStr = if (args.nonEmpty) args.map(normal).mkString("[", ", ", "]") else "" + s"${preStr}${pprintRef(sym)}${argsStr}" + case SingleType(pre, sym) => + pre match { + case Type.Empty => pprintRef(sym) + case _ => + s"${prefix(pre)}.${pprintRef(sym)}" + } + case ThisType(sym) => + s"${pprintRef(sym)}.this" + case SuperType(pre, sym) => + s"${prefix(pre)}.super[${pprintRef(sym)}]" + case ConstantType(const) => + pprint(const) + case IntersectionType(types) => + types.map(normal).mkString(" & ") + case UnionType(types) => + types.map(normal).mkString(" | ") + case WithType(types) => + types.map(normal).mkString(" with ") + case StructuralType(utpe, decls) => + val declsStr = + if (decls.infos.nonEmpty) + s"{ ${decls.infos.map(pprintDef).mkString("; ")} }" + else "{}" + s"${normal(utpe)} ${declsStr}" + case AnnotatedType(anns, utpe) => + s"${normal(utpe)} ${anns.map(pprint).mkString(" ")}" + case ExistentialType(utpe, decls) => + val sdecls = decls.infos.map(pprintDef).mkString("; ") + val sutpe = normal(utpe) + s"${sutpe} forSome { ${sdecls} }" + case UniversalType(tparams, utpe) => + val params = tparams.infos.map(_.displayName).mkString("[", ", ", "]") + val resType = normal(utpe) + s"${params} => ${resType}" + case ByNameType(utpe) => + s"=> ${normal(utpe)}" + case RepeatedType(utpe) => + s"${normal(utpe)}*" + case _ => + "" + + def normal(tpe: Type): String = tpe match + case _: SingleType | _: ThisType | _: SuperType => + s"${prefix(tpe)}.type" + case _ => + prefix(tpe) + normal(tpe) + } + + private def pprint(ann: Annotation): String = + ann.tpe match { + case Type.Empty => s"@" + case tpe => s"@${pprint(tpe)}" + } + + private def pprint(const: Constant): String = const match { + case Constant.Empty => + "" + case UnitConstant() => + "()" + case BooleanConstant(true) => + "true" + case BooleanConstant(false) => + "false" + case ByteConstant(value) => + value.toByte.toString + case ShortConstant(value) => + value.toShort.toString + case CharConstant(value) => + s"'${value.toChar.toString}'" + case IntConstant(value) => + value.toString + case LongConstant(value) => + s"${value.toString}L" + case FloatConstant(value) => + s"${value.toString}f" + case DoubleConstant(value) => + value.toString + case StringConstant(value) => + "\"" + value + "\"" + case NullConstant() => + "null" + } + + private def accessString(access: Access): String = + access match + case Access.Empty => "" + case _: PublicAccess => "" + case _: PrivateAccess => "private " + case _: ProtectedAccess => "protected " + case _: PrivateThisAccess => "private[this] " + case _: ProtectedThisAccess => "protected[this] " + case PrivateWithinAccess(ssym) => + s"private[${ssym}] " + case ProtectedWithinAccess(ssym) => + s"protected[${ssym}] " + + extension (scope: Scope) + private def infos: List[SymbolInformation] = + if (scope.symlinks.nonEmpty) + scope.symlinks.map(symbol => SymbolInformation(symbol = symbol)).toList + else + scope.hardlinks.toList + + extension (scope: Option[Scope]) + private def infos: List[SymbolInformation] = scope match { + case Some(s) => s.infos + case None => Nil + } + } +end SymbolInfomationPrinter + +extension (info: SymbolInformation) + def prefixBeforeTpe: String = { + info.kind match { + case LOCAL | FIELD | PARAMETER | SELF_PARAMETER | UNKNOWN_KIND | Unrecognized(_) => + ": " + case METHOD | CONSTRUCTOR | MACRO | TYPE | TYPE_PARAMETER | OBJECT | PACKAGE | + PACKAGE_OBJECT | CLASS | TRAIT | INTERFACE => + " " + } + } + +trait PrinterSymtab: + def info(symbol: String): Option[SymbolInformation] +object PrinterSymtab: + def fromTextDocument(doc: TextDocument): PrinterSymtab = + val map = doc.symbols.map(info => (info.symbol, info)).toMap + new PrinterSymtab { + override def info(symbol: String): Option[SymbolInformation] = map.get(symbol) + } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index fb01e6fff488..6ca728616cda 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -1,14 +1,15 @@ package dotty.tools.dotc.semanticdb import dotty.tools.dotc.core -import core.Symbols.{ Symbol , defn } +import core.Symbols.{ Symbol , defn, NoSymbol } import core.Contexts._ import core.Names import core.Names.Name -import core.Types.Type +import core.Types.{Type, TypeBounds} import core.Flags._ import core.NameKinds import core.StdNames.nme +import SymbolInformation.{Kind => k} import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} @@ -25,6 +26,98 @@ object Scala3: private val WILDCARDTypeName = nme.WILDCARD.toTypeName + sealed trait FakeSymbol { + private[Scala3] var sname: Option[String] = None + } + + /** Fake symbol that represents wildcard symbol which will be converted to + * semanticdb symbol with + * - name: local... + * - SymbolInformation with signature TypeSignature of given type bound. + */ + case class WildcardTypeSymbol(owner: Symbol, bounds: TypeBounds) extends FakeSymbol + + case class TermParamRefSymbol(owner: Symbol, name: Name, tp: Type) extends FakeSymbol + case class TypeParamRefSymbol(owner: Symbol, name: Name, tp: TypeBounds) extends FakeSymbol + case class RefinementSymbol(owner: Symbol, name: Name, tp: Type) extends FakeSymbol + type SemanticSymbol = Symbol | FakeSymbol + + given SemanticSymbolOps : AnyRef with + extension (sym: SemanticSymbol) + def name(using Context): Name = sym match + case s: Symbol => s.name + case s: WildcardTypeSymbol => nme.WILDCARD + case s: TermParamRefSymbol => s.name + case s: TypeParamRefSymbol => s.name + case s: RefinementSymbol => s.name + + def symbolName(using builder: SemanticSymbolBuilder)(using Context): String = + sym match + case s: Symbol => builder.symbolName(s) + case s: FakeSymbol => + s.sname.getOrElse { + val sname = builder.symbolName(s) + s.sname = Some(sname) + sname + } + + def symbolInfo(symkinds: Set[SymbolKind])(using LinkMode, TypeOps, SemanticSymbolBuilder, Context): SymbolInformation = + sym match + case s: Symbol => + val kind = s.symbolKind(symkinds) + val sname = sym.symbolName + val signature = s.info.toSemanticSig(s) + SymbolInformation( + symbol = sname, + language = Language.SCALA, + kind = kind, + properties = s.symbolProps(symkinds), + displayName = Symbols.displaySymbol(s), + signature = signature, + access = s.symbolAccess(kind), + ) + case s: WildcardTypeSymbol => + SymbolInformation( + symbol = symbolName, + language = Language.SCALA, + kind = SymbolInformation.Kind.TYPE, + displayName = nme.WILDCARD.show, + signature = s.bounds.toSemanticSig(s.owner), + ) + case s: TermParamRefSymbol => + SymbolInformation( + symbol = symbolName, + language = Language.SCALA, + kind = SymbolInformation.Kind.PARAMETER, + displayName = s.name.show.unescapeUnicode, + signature = s.tp.toSemanticSig(s.owner), + ) + case s: TypeParamRefSymbol => + SymbolInformation( + symbol = symbolName, + language = Language.SCALA, + kind = SymbolInformation.Kind.TYPE_PARAMETER, + displayName = s.name.show.unescapeUnicode, + signature = s.tp.toSemanticSig(s.owner), + ) + case s: RefinementSymbol => + val signature = s.tp.toSemanticSig(s.owner) + val kind = signature match + case _: TypeSignature => SymbolInformation.Kind.TYPE + case _: MethodSignature => SymbolInformation.Kind.METHOD + case _: ValueSignature => SymbolInformation.Kind.FIELD + case _ => SymbolInformation.Kind.UNKNOWN_KIND + SymbolInformation( + symbol = symbolName, + language = Language.SCALA, + kind = kind, + displayName = s.name.show.unescapeUnicode, + properties = + SymbolInformation.Property.ABSTRACT.value, + signature = signature, + ) + end SemanticSymbolOps + enum SymbolKind derives CanEqual: kind => @@ -83,6 +176,7 @@ object Scala3: def isEmptyNumbered: Boolean = !name.is(NameKinds.WildcardParamName) + && !name.is(NameKinds.EvidenceParamName) && { name match case NameKinds.AnyNumberedName(nme.EMPTY, _) => true case _ => false @@ -126,6 +220,110 @@ object Scala3: def isSyntheticWithIdent(using Context): Boolean = sym.is(Synthetic) && !sym.isAnonymous && !sym.name.isEmptyNumbered + /** The semanticdb name of the given symbol */ + def symbolName(using builder: SemanticSymbolBuilder)(using Context): String = + builder.symbolName(sym) + + def funParamSymbol(using builder: SemanticSymbolBuilder)(using Context): Name => String = + builder.funParamSymbol(sym) + + def symbolKind(symkinds: Set[SymbolKind])(using Context): SymbolInformation.Kind = + if sym.isTypeParam then + SymbolInformation.Kind.TYPE_PARAMETER + else if sym.is(TermParam) then + SymbolInformation.Kind.PARAMETER + else if sym.isTerm && sym.owner.isTerm then + SymbolInformation.Kind.LOCAL + else if sym.isInlineMethod || sym.is(Macro) then + SymbolInformation.Kind.MACRO + else if sym.isConstructor then + SymbolInformation.Kind.CONSTRUCTOR + else if sym.isSelfSym then + SymbolInformation.Kind.SELF_PARAMETER + else if sym.isOneOf(Method) || symkinds.exists(_.isVarOrVal) then + SymbolInformation.Kind.METHOD + else if sym.isPackageObject then + SymbolInformation.Kind.PACKAGE_OBJECT + else if sym.is(Module) then + SymbolInformation.Kind.OBJECT + else if sym.is(Package) then + SymbolInformation.Kind.PACKAGE + else if sym.isAllOf(JavaInterface) then + SymbolInformation.Kind.INTERFACE + else if sym.is(Trait) then + SymbolInformation.Kind.TRAIT + else if sym.isClass then + SymbolInformation.Kind.CLASS + else if sym.isType then + SymbolInformation.Kind.TYPE + else if sym.is(ParamAccessor) then + SymbolInformation.Kind.FIELD + else + SymbolInformation.Kind.UNKNOWN_KIND + + def symbolProps(symkinds: Set[SymbolKind])(using Context): Int = + if sym.is(ModuleClass) then + return sym.sourceModule.symbolProps(symkinds) + var props = 0 + if sym.isPrimaryConstructor then + props |= SymbolInformation.Property.PRIMARY.value + if sym.is(Abstract) || symkinds.contains(SymbolKind.Abstract) then + props |= SymbolInformation.Property.ABSTRACT.value + if sym.is(Final) then + props |= SymbolInformation.Property.FINAL.value + if sym.is(Sealed) then + props |= SymbolInformation.Property.SEALED.value + if sym.isOneOf(GivenOrImplicit) then + props |= SymbolInformation.Property.IMPLICIT.value + if sym.is(Lazy, butNot=Module) then + props |= SymbolInformation.Property.LAZY.value + if sym.isAllOf(Case | Module) || sym.is(CaseClass) || sym.isAllOf(EnumCase) then + props |= SymbolInformation.Property.CASE.value + if sym.is(Covariant) then + props |= SymbolInformation.Property.COVARIANT.value + if sym.is(Contravariant) then + props |= SymbolInformation.Property.CONTRAVARIANT.value + if sym.isAllOf(DefaultMethod | JavaDefined) || sym.is(Accessor) && sym.name.is(NameKinds.DefaultGetterName) then + props |= SymbolInformation.Property.DEFAULT.value + if symkinds.exists(_.isVal) then + props |= SymbolInformation.Property.VAL.value + if symkinds.exists(_.isVar) then + props |= SymbolInformation.Property.VAR.value + if sym.is(JavaStatic) then + props |= SymbolInformation.Property.STATIC.value + if sym.is(Enum) then + props |= SymbolInformation.Property.ENUM.value + if sym.is(Given) then + props |= SymbolInformation.Property.GIVEN.value + if sym.is(Inline) then + props |= SymbolInformation.Property.INLINE.value + if sym.is(Open) then + props |= SymbolInformation.Property.OPEN.value + if sym.is(Open) then + props |= SymbolInformation.Property.OPEN.value + if sym.is(Transparent) then + props |= SymbolInformation.Property.TRANSPARENT.value + if sym.is(Infix) then + props |= SymbolInformation.Property.INFIX.value + if sym.is(Opaque) then + props |= SymbolInformation.Property.OPAQUE.value + props + + def symbolAccess(kind: SymbolInformation.Kind)(using Context, SemanticSymbolBuilder): Access = + kind match + case k.LOCAL | k.PARAMETER | k.SELF_PARAMETER | k.TYPE_PARAMETER | k.PACKAGE | k.PACKAGE_OBJECT => + Access.Empty + case _ => + if (sym.privateWithin == NoSymbol) + if (sym.isAllOf(PrivateLocal)) PrivateThisAccess() + else if (sym.is(Private)) PrivateAccess() + else if (sym.isAllOf(ProtectedLocal)) ProtectedThisAccess() + else if (sym.is(Protected)) ProtectedAccess() + else PublicAccess() + else + val ssym = sym.privateWithin.symbolName + if (sym.is(Protected)) ProtectedWithinAccess(ssym) + else PrivateWithinAccess(ssym) end SymbolOps object LocalSymbol: @@ -164,6 +362,10 @@ object Scala3: def isTypeParameter: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == ']' def isParameter: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == ')' + def desc: Descriptor = + if isGlobal then DescriptorParser(symbol)._1 + else Descriptor.None + def unescapeUnicode = unicodeEscape.replaceAllIn(symbol, m => String.valueOf(Integer.parseInt(m.group(1), 16).toChar)) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala b/compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala new file mode 100644 index 000000000000..8743fd04d651 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala @@ -0,0 +1,151 @@ +package dotty.tools +package dotc +package semanticdb + +import core._ +import Contexts._ +import Symbols._ +import Flags._ +import Names.Name + +import scala.annotation.tailrec +import scala.collection.mutable +import dotty.tools.dotc.core.Types.TypeParamRef + +class SemanticSymbolBuilder: + import Scala3.{_, given} + + private var nextLocalIdx: Int = 0 + + /** The index of a local symbol */ + private val locals = mutable.HashMap[Symbol, Int]() + + /** The local symbol(s) starting at given offset */ + private val symsAtOffset = new mutable.HashMap[Int, Set[Symbol]](): + override def default(key: Int) = Set[Symbol]() + + + def symbolName(sym: Symbol)(using Context): String = + val b = StringBuilder(20) + addSymName(b, sym) + b.toString + def symbolName(sym: FakeSymbol)(using Context): String = + sym match + case sym: WildcardTypeSymbol => + val b = StringBuilder(20) + addSymName(b, sym.owner) + b.append('['); addName(b, sym.name); b.append(']') + b.toString + case sym: TermParamRefSymbol => + val b = StringBuilder(20) + addSymName(b, sym.owner) + b.append('('); addName(b, sym.name); b.append(')') + b.toString + case sym: TypeParamRefSymbol => + val b = StringBuilder(20) + addSymName(b, sym.owner) + b.append('['); addName(b, sym.name); b.append(']') + b.toString + case sym: RefinementSymbol => + val b = StringBuilder(20) + addLocalSymName(b) + b.toString + + def funParamSymbol(sym: Symbol)(using Context): Name => String = + if sym.isGlobal then + val funSymbol = symbolName(sym) + name => s"$funSymbol($name)" + else + name => locals.keys.find(local => local.isTerm && local.owner == sym && local.name == name) + .fold("")(Symbols.LocalPrefix + locals(_)) + + private def addName(b: StringBuilder, name: Name): Unit = + val str = name.toString.unescapeUnicode + if str.isJavaIdent then b append str + else b append '`' append str append '`' + + private def addLocalSymName(b: StringBuilder): Unit = + val idx = nextLocalIdx + nextLocalIdx += 1 + b.append(Symbols.LocalPrefix).append(idx) + + /** Add semanticdb name of the given symbol to string builder */ + private def addSymName(b: StringBuilder, sym: Symbol)(using Context): Unit = + + 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) then + decls0 ++ sym.owner.companionClass.info.decls.lookupAll(sym.name) + else + decls0 + end decls + val alts = decls.filter(_.isOneOf(Method | Mutable)).toList.reverse + def find(filter: Symbol => Boolean) = alts match + case notSym :: rest if !filter(notSym) => + val idx = rest.indexWhere(filter).ensuring(_ >= 0) + b.append('+').append(idx + 1) + case _ => + end find + val sig = sym.signature + find(_.signature == sig) + + def addDescriptor(sym: Symbol): Unit = + if sym.is(ModuleClass) then + addDescriptor(sym.sourceModule) + else if sym.is(TypeParam) then + b.append('['); addName(b, sym.name); b.append(']') + else if sym.is(Param) then + b.append('('); addName(b, 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(b, 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)(using Context): Int = + val startPos = + // assert(sym.span.exists, s"$sym should have a span") + if (sym.span.exists) Some(sym.span.start) else None + @tailrec + def computeLocalIdx(sym: Symbol): Int = locals get sym match + case Some(idx) => idx + case None => + (for { + pos <- startPos + syms <- symsAtOffset.get(pos) + found <- syms.find(_.name == sym.name) + } yield found) match + case Some(other) => computeLocalIdx(other) + case None => + val idx = nextLocalIdx + nextLocalIdx += 1 + locals(sym) = idx + startPos.foreach(pos => symsAtOffset(pos) += sym) + idx + end computeLocalIdx + computeLocalIdx(sym) + end localIdx + + if sym.exists then + if sym.isGlobal then + addOwner(sym.owner); addDescriptor(sym) + else + b.append(Symbols.LocalPrefix).append(localIdx(sym)) + + end addSymName diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala index ae3d34357734..a7bfdcefc047 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala @@ -47,6 +47,8 @@ object Tools: TextDocuments.parseFrom(bytes) def metac(doc: TextDocument, realPath: Path)(using sb: StringBuilder): StringBuilder = + val symtab = PrinterSymtab.fromTextDocument(doc) + val symPrinter = SymbolInfomationPrinter(symtab) val realURI = realPath.toString given SourceFile = SourceFile.virtual(doc.uri, doc.text) sb.append(realURI).nl @@ -61,7 +63,7 @@ object Tools: sb.append("Occurrences => ").append(doc.occurrences.length).append(" entries").nl sb.nl sb.append("Symbols:").nl - doc.symbols.sorted.foreach(processSymbol) + doc.symbols.sorted.foreach(s => processSymbol(s, symPrinter)) sb.nl sb.append("Occurrences:").nl doc.occurrences.sorted.foreach(processOccurrence) @@ -85,63 +87,8 @@ object Tools: case UNKNOWN_LANGUAGE | Unrecognized(_) => "unknown" end languageString - private def accessString(access: Access): String = - access match - case Access.Empty => "" - case _: PublicAccess => "" - case _: PrivateAccess => "private " - case _: ProtectedAccess => "protected " - case _: PrivateThisAccess => "private[this] " - case _: ProtectedThisAccess => "protected[this] " - case PrivateWithinAccess(ssym) => - s"private[${ssym}] " - case ProtectedWithinAccess(ssym) => - s"protected[${ssym}] " - - - private def processSymbol(info: SymbolInformation)(using sb: StringBuilder): Unit = - import SymbolInformation.Kind._ - sb.append(info.symbol).append(" => ") - sb.append(accessString(info.access)) - 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 ") - if info.isGiven then sb.append("given ") - if info.isInline then sb.append("inline ") - if info.isOpen then sb.append("open ") - if info.isTransparent then sb.append("transparent ") - if info.isInfix then sb.append("infix ") - if info.isOpaque then sb.append("opaque ") - 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 processSymbol(info: SymbolInformation, printer: SymbolInfomationPrinter)(using sb: StringBuilder): Unit = + sb.append(printer.pprintSymbolInformation(info)).nl private def processOccurrence(occ: SymbolOccurrence)(using sb: StringBuilder, sourceFile: SourceFile): Unit = occ.range match diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala b/compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala new file mode 100644 index 000000000000..b71327b4c28a --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala @@ -0,0 +1,441 @@ +package dotty.tools +package dotc +package semanticdb + +import core.Symbols._ +import core.Contexts.Context +import core.Types._ +import core.Annotations.Annotation +import core.Flags +import core.Names.Name +import core.StdNames.tpnme +import ast.tpd._ +import scala.util.chaining.scalaUtilChainingOps + +import collection.mutable + +import dotty.tools.dotc.{semanticdb => s} +import Scala3.{FakeSymbol, SemanticSymbol, WildcardTypeSymbol, TypeParamRefSymbol, TermParamRefSymbol, RefinementSymbol} + +class TypeOps: + import SymbolScopeOps._ + import Scala3.given + private val paramRefSymtab = mutable.Map[(LambdaType, Name), Symbol]() + private val refinementSymtab = mutable.Map[(RefinedType, Name), Symbol]() + + // save generated fake symbols so we can insert them into symbols section of SemanticDB + val fakeSymbols = mutable.Set[FakeSymbol]() + given typeOps: TypeOps = this + + extension [T <: LambdaType | RefinedType](symtab: mutable.Map[(T, Name), Symbol]) + private def lookup( + binder: T, + name: Name, + )(using Context): Option[Symbol] = + symtab.get((binder, name)) + + extension [T <: LambdaType](symtab: mutable.Map[(T, Name), Symbol]) + private def lookupOrErr( + binder: T, + name: Name, + parent: Symbol, + )(using Context): Option[Symbol] = + // In case refinement or type param cannot be accessed from traverser and + // no symbols are registered to the symbol table, fall back to Type.member + symtab.lookup(binder, name) match + case found @ Some(_) => found + case None => + val member = binder.member(name).symbol + if !member.exists then + symbolNotFound(binder, name, parent) + None + else + Some(member) + + private def symbolNotFound(binder: Type, name: Name, parent: Symbol)(using ctx: Context): Unit = + warn(s"Ignoring ${name} of symbol ${parent}, type ${binder}") + + private def warn(msg: String)(using ctx: Context): Unit = + report.warning( + s"Internal error in extracting SemanticDB while compiling ${ctx.compilationUnit.source}: ${msg}" + ) + + private def registerFakeSymbol(sym: FakeSymbol)(using Context, SemanticSymbolBuilder): Unit = + fakeSymbols.add(sym) + + extension (tpe: Type) + def toSemanticSig(using LinkMode, Context, SemanticSymbolBuilder)(sym: Symbol): s.Signature = + def enterParamRef(tpe: Type): Unit = + tpe match { + case lam: LambdaType => + // Find the "actual" binder type for nested LambdaType + // For example, `def foo(x: T)(y: T): T` and for `.owner.info` would be like + // `MethodType(..., resType = MethodType(..., resType = ))`. + // (Let's say the outer `MethodType` "outer", and `MethodType` who is + // `resType` of outer "inner") + // + // We try to find the "actual" binder of : `inner`, + // and register them to the symbol table with `(, inner) -> ` + // instead of `("y", outer) -> ` + if lam.paramNames.contains(sym.name) then + paramRefSymtab((lam, sym.name)) = sym + else + enterParamRef(lam.resType) + + // for class constructor + // class C[T] { ... } + case cls: ClassInfo if sym.info.isInstanceOf[LambdaType] => + val lam = sym.info.asInstanceOf[LambdaType] + cls.cls.typeParams.foreach { param => + paramRefSymtab((lam, param.name)) = param + } + + // type X[T] = ... + case tb: TypeBounds => + enterParamRef(tb.lo) + enterParamRef(tb.hi) + + case _ => () + } + + def enterRefined(tpe: Type): Unit = + tpe match { + case refined: RefinedType => + val key = (refined, sym.name) + refinementSymtab(key) = sym + + case rec: RecType => + enterRefined(rec.parent) + + // Register symbol for opaque type, + // opaque type alias will be stored into the refinement of + // the self type of the enclosing class. + // Key: the tuple of + // - self-type of enclosing class + // - name of the opaque type + // Value: the symbol of the opaque type + // See: SymDenotation.opaqueToBounds + case cls: ClassInfo if sym.is(Flags.Opaque) => + cls.classSymbol.asClass.givenSelfType match + case rt: RefinedType => + refinementSymtab((rt, sym.name)) = sym + case _ => () + + case cls: ClassInfo if (cls.cls.name == tpnme.REFINE_CLASS) => + enterRefined(sym.owner.owner.info) + + // type x = Person { refinement } + case tb: TypeBounds => + // tb = TypeBounds( + // lo = RefinedType(...) + // hi = RefinedType(...) + // ) + enterRefined(tb.lo) + enterRefined(tb.hi) + + // def s(x: Int): { refinement } = ... + case expr: ExprType => + enterRefined(expr.resType) + case m: LambdaType => + enterRefined(m.resType) + case _ => () + } + if sym.exists && sym.owner.exists then + enterParamRef(sym.owner.info) + enterRefined(sym.owner.info) + + def loop(tpe: Type): s.Signature = tpe match { + case mp: MethodOrPoly => + def flatten( + t: Type, + paramss: List[List[SemanticSymbol]], + tparams: List[SemanticSymbol] + ): (Type, List[List[SemanticSymbol]], List[SemanticSymbol]) = t match { + case mt: MethodType => + val syms: List[SemanticSymbol] = mt.paramNames.zip(mt.paramInfos).map { (name, info) => + paramRefSymtab.lookup(mt, name).getOrElse { + TermParamRefSymbol(sym, name, info).tap(registerFakeSymbol) + } + } + flatten(mt.resType, paramss :+ syms, tparams) + case pt: PolyType => + val syms: List[SemanticSymbol] = pt.paramNames.zip(pt.paramInfos).map { (name, info) => + paramRefSymtab.lookup(pt, name).getOrElse { + TypeParamRefSymbol(sym, name, info).tap(registerFakeSymbol) + } + } + flatten(pt.resType, paramss, tparams ++ syms) + case other => + (other, paramss, tparams) + } + val (resType, paramss, tparams) = flatten(mp, Nil, Nil) + + val sparamss = paramss.map(_.sscope) + val stparams = tparams.sscopeOpt + s.MethodSignature( + stparams, + sparamss, + resType.toSemanticType(sym) + ) + + case cls: ClassInfo => + val stparams = cls.cls.typeParams.sscopeOpt + val sparents = cls.parents.map(_.toSemanticType(sym)) + val sself = cls.selfType.toSemanticType(sym) + val decls = cls.decls.toList.sscopeOpt + s.ClassSignature(stparams, sparents, sself, decls) + + case TypeBounds(lo, hi) => + // for `type X[T] = T` is equivalent to `[T] =>> T` + def tparams(tpe: Type): (Type, List[SemanticSymbol]) = tpe match { + case lambda: HKTypeLambda => + val paramSyms: List[SemanticSymbol] = lambda.paramNames.zip(lambda.paramInfos).map { (paramName, bounds) => + // def x[T[_]] = ??? + if paramName.isWildcard then + WildcardTypeSymbol(sym, bounds).tap(registerFakeSymbol) + else + paramRefSymtab.lookup(lambda, paramName).getOrElse { + TypeParamRefSymbol(sym, paramName, bounds).tap(registerFakeSymbol) + } + } + (lambda.resType, paramSyms) + case _ => (tpe, Nil) + } + val (loRes, loParams) = tparams(lo) + val (hiRes, hiParams) = tparams(hi) + val stparams = (loParams ++ hiParams).distinctBy(_.name).sscopeOpt + val slo = loRes.toSemanticType(sym) + val shi = hiRes.toSemanticType(sym) + s.TypeSignature(stparams, slo, shi) + + case other => + s.ValueSignature( + other.toSemanticType(sym) + ) + } + loop(tpe) + + private def toSemanticType(sym: Symbol)(using LinkMode, SemanticSymbolBuilder, Context): s.Type = + import ConstantOps._ + def loop(tpe: Type): s.Type = tpe match { + case t if t.isFromJavaObject => + loop(defn.AnyType) + case ExprType(tpe) => + val stpe = loop(tpe) + s.ByNameType(stpe) + + case TypeRef(pre, sym: Symbol) => + val spre = if tpe.hasTrivialPrefix then s.Type.Empty else loop(pre) + val ssym = sym.symbolName + s.TypeRef(spre, ssym, Seq.empty) + + case TermRef(pre, sym: Symbol) => + val spre = if(tpe.hasTrivialPrefix) s.Type.Empty else loop(pre) + val ssym = sym.symbolName + s.SingleType(spre, ssym) + + case ThisType(TypeRef(_, sym: Symbol)) => + s.ThisType(sym.symbolName) + + case tref: TermParamRef => + paramRefSymtab.lookupOrErr( + tref.binder, tref.paramName, sym + ) match + case Some(ref) => + val ssym = ref.symbolName + s.SingleType(s.Type.Empty, ssym) + case None => + s.Type.Empty + + case tref: TypeParamRef => + val tsym = paramRefSymtab.lookup(tref.binder, tref.paramName) match + case found @ Some(sym) => found + case None => + tref.binder.typeParams.find(param => param.paramName == tref.paramName) match + case Some(param) => + val info = param.paramInfo + Some(TypeParamRefSymbol(sym, tref.paramName, info).tap(registerFakeSymbol)) + case None => + symbolNotFound(tref.binder, tref.paramName, sym) + None + tsym match + case Some(sym) => + val ssym = sym.symbolName + s.TypeRef(s.Type.Empty, ssym, Seq.empty) + case None => + s.Type.Empty + + case SuperType(thistpe, supertpe) => + val spre = loop(thistpe.typeSymbol.info) + val ssym = supertpe.typeSymbol.symbolName + s.SuperType(spre, ssym) + + // val clazzOf = classOf[...] + case ConstantType(const) if const.tag == core.Constants.ClazzTag => + loop(const.typeValue) + + case ConstantType(const) => + s.ConstantType(const.toSemanticConst) + + case rt @ RefinedType(parent, name, info) => + // `X { def x: Int; def y: Int }` + // RefinedType( + // parent = RefinedType( + // parent = TypeRef(..., X) + // ... + // ) + // refinedName = x + // refinedInfo = TypeRef(..., Int) + // ) + type RefinedInfo = (core.Names.Name, Type) + def flatten(tpe: Type, acc: List[RefinedInfo]): (Type, List[RefinedInfo]) = tpe match { + case RefinedType(parent, name, info) => + flatten(parent, acc :+ (name, info)) + case _ => + (tpe, acc) + } + + // flatten parent types to list + // e.g. `X with Y with Z { refined }` + // RefinedType(parent = AndType(X, AndType(Y, Z)), ...) + // => List(X, Y, Z) + def flattenParent(parent: Type): List[s.Type] = parent match { + case AndType(tp1, tp2) => + flattenParent(tp1) ++ flattenParent(tp2) + case _ => List(loop(parent)) + } + + val (parent, refinedInfos) = flatten(rt, List.empty) + val stpe = s.IntersectionType(flattenParent(parent)) + + val decls: List[SemanticSymbol] = refinedInfos.map { (name, info) => + refinementSymtab.lookup(rt, name).getOrElse { + RefinementSymbol(sym, name, info).tap(registerFakeSymbol) + } + } + val sdecls = decls.sscopeOpt(using LinkMode.HardlinkChildren) + s.StructuralType(stpe, sdecls) + + case rec: RecType => + loop(rec.parent) // should be handled as RefinedType + + // repeated params: e.g. `Int*`, which is the syntax sugar of + // `Seq[Int] @Repeated` (or `Array[Int] @Repeated`) + // See: Desugar.scala and TypeApplications.scala + case AnnotatedType(AppliedType(_, targs), annot) + if (annot matches defn.RepeatedAnnot) && (targs.length == 1) => + val stpe = loop(targs(0)) + s.RepeatedType(stpe) + + case ann: AnnotatedType if ann.annot.symbol.info.isInstanceOf[ClassInfo] => + def flatten(tpe: Type, annots: List[Annotation]): (Type, List[Annotation]) = tpe match + case AnnotatedType(parent, annot) if annot.symbol.info.isInstanceOf[ClassInfo] => + flatten(parent, annot +: annots) + case other => (other, annots) + + val (parent, annots) = flatten(ann, List.empty) + val sparent = loop(parent) + val sannots = annots.map(a => + s.Annotation(loop(a.symbol.info.asInstanceOf[ClassInfo].selfType)) + ) + s.AnnotatedType(sannots, sparent) + + case AppliedType(tycon, args) if tycon == defn.RepeatedParamType && args.length == 1 => + val stpe = loop(args(0)) + s.RepeatedType(stpe) + + case app @ AppliedType(tycon, args) => + val targs = args.map { arg => + arg match + // For wildcard type C[_ <: T], it's internal type representation will be + // `AppliedType(TypeBounds(lo = , hi = ))`. + // + // As scalameta for Scala2 does, we'll convert the wildcard type to + // `ExistentialType(TypeRef(NoPrefix, C, ), Scope(hardlinks = List()))` + // where `` has + // display_name: "_" and, + // signature: type_signature(..., lo = , hi = ) + case bounds: TypeBounds => + val wildcardSym = WildcardTypeSymbol(sym, bounds) + // DO NOT register the wildcard symbol to symbol section here + // since it's not a symbol definition + // registerFakeSymbol(wildcardSym) + val ssym = wildcardSym.symbolName + (Some(wildcardSym), s.TypeRef(s.Type.Empty, ssym, Seq.empty)) + case other => + val sarg = loop(other) + (None, sarg) + } + val wildcardSyms = targs.flatMap(_._1) + val sargs = targs.map(_._2) + + val applied = loop(tycon) match + case ref @ s.TypeRef(_, _, targs) => + // For curried applied type `F[T][U]` and tycon is also an `AppliedType` + // Convert it to TypeRef(..., targs = List(T, U)) + ref.copy(typeArguments = targs ++ sargs) + case _ => + s.Type.Empty + + if (wildcardSyms.isEmpty) applied + else s.ExistentialType( + applied, + wildcardSyms.sscopeOpt(using LinkMode.HardlinkChildren) + ) + + case and: AndType => + def flatten(child: Type): List[Type] = child match + case AndType(ct1, ct2) => flatten(ct1) ++ flatten(ct2) + case other => List(other) + val stpes = flatten(and).map(loop) + s.IntersectionType(stpes) + + case or: OrType => + def flatten(child: Type): List[Type] = child match + case OrType(ct1, ct2) => flatten(ct1) ++ flatten(ct2) + case other => List(other) + val stpes = flatten(or).map(loop) + s.UnionType(stpes) + + case l: LazyRef => + loop(l.ref) + + case NoPrefix => + s.Type.Empty + + // Not yet supported + case _: HKTypeLambda => + s.Type.Empty + case _: MatchType => + s.Type.Empty + + case _ => + s.Type.Empty + } + loop(tpe) + + /** Return true if the prefix is like `_root_.this` */ + private def hasTrivialPrefix(using Context): Boolean = + def checkTrivialPrefix(pre: Type, sym: Symbol)(using Context): Boolean = + pre =:= sym.owner.thisType + tpe match { + case TypeRef(pre, sym: Symbol) => + checkTrivialPrefix(pre, sym) + case TermRef(pre, sym: Symbol) => + checkTrivialPrefix(pre, sym) + case _ => false + } + + +object SymbolScopeOps: + import Scala3.{_, given} + extension (syms: List[SemanticSymbol]) + def sscope(using linkMode: LinkMode)(using SemanticSymbolBuilder, TypeOps, Context): s.Scope = + linkMode match + case LinkMode.SymlinkChildren => + s.Scope(symlinks = syms.map(_.symbolName)) + case LinkMode.HardlinkChildren => + s.Scope(hardlinks = syms.map(_.symbolInfo(Set.empty))) + + def sscopeOpt(using LinkMode, SemanticSymbolBuilder, TypeOps, Context): Option[s.Scope] = + if syms.nonEmpty then Some(syms.sscope) else None diff --git a/tests/semanticdb/expect/Advanced.expect.scala b/tests/semanticdb/expect/Advanced.expect.scala index d52b8cecf668..a7c85be0e550 100644 --- a/tests/semanticdb/expect/Advanced.expect.scala +++ b/tests/semanticdb/expect/Advanced.expect.scala @@ -11,22 +11,24 @@ class C/*<-advanced::C#*/[T/*<-advanced::C#[T]*/] { 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.`???`().*/ } + def s2/*<-advanced::Structural#s2().*/: { val x/*<-local1*/: Int/*->scala::Int#*/ } = new { val x/*<-local2*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + def s3/*<-advanced::Structural#s3().*/: { def m/*<-local6*/(x/*<-local5*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ } = new { def m/*<-local8*/(x/*<-local7*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + def s4/*<-advanced::Structural#s4().*/(a/*<-advanced::Structural#s4().(a)*/: Int/*->scala::Int#*/): { val x/*<-local11*/: Int/*->scala::Int#*/ } = ???/*->scala::Predef.`???`().*/ } class Wildcards/*<-advanced::Wildcards#*/ { def e1/*<-advanced::Wildcards#e1().*/: List/*->scala::package.List#*/[_] = ???/*->scala::Predef.`???`().*/ + def e2/*<-advanced::Wildcards#e2().*/: List/*->scala::package.List#*/[_ <: Int/*->scala::Int#*/] = ???/*->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::reflect::Selectable#selectDynamic().*/.x + val s1x/*<-advanced::Test.s1x.*/ = s/*->advanced::Test.s.*/.s1/*->advanced::Structural#s1().*/.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::reflect::Selectable#selectDynamic().*/.x + val s2x/*<-advanced::Test.s2x.*/ = s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*/.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::reflect::Selectable#applyDynamic().*/.m(???/*->scala::Predef.`???`().*/) + val s3x/*<-advanced::Test.s3x.*/ = s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*/.m(???/*->scala::Predef.`???`().*/) val e/*<-advanced::Test.e.*/ = new Wildcards/*->advanced::Wildcards#*/ val e1/*<-advanced::Test.e1.*/ = e/*->advanced::Test.e.*/.e1/*->advanced::Wildcards#e1().*/ @@ -34,9 +36,15 @@ object Test/*<-advanced::Test.*/ { { (???/*->scala::Predef.`???`().*/ : Any/*->scala::Any#*/) match { - case e3/*<-local9*/: List/*->scala::package.List#*/[_] => - val e3x/*<-local10*/ = e3/*->local9*/.head/*->scala::collection::IterableOps#head().*/ + case e3/*<-local12*/: List/*->scala::package.List#*/[_] => + val e3x/*<-local14*/ = e3/*->local12*/.head/*->scala::collection::IterableOps#head().*/ () } } } + + +// Curried Type Application +class HKClass/*<-advanced::HKClass#*/[F/*<-advanced::HKClass#[F]*/ <: [T] =>> [U] =>> (U, T)] { + def foo/*<-advanced::HKClass#foo().*/[T/*<-advanced::HKClass#foo().[T]*/,U/*<-advanced::HKClass#foo().[U]*/](x/*<-advanced::HKClass#foo().(x)*/: F/*->advanced::HKClass#[F]*/[T/*->advanced::HKClass#foo().[T]*/][U/*->advanced::HKClass#foo().[U]*/]): String/*->scala::Predef.String#*/ = x/*->advanced::HKClass#foo().(x)*/.toString/*->scala::Tuple2#toString().*/() +} diff --git a/tests/semanticdb/expect/Advanced.scala b/tests/semanticdb/expect/Advanced.scala index 3e14a46cb194..e0439d911c36 100644 --- a/tests/semanticdb/expect/Advanced.scala +++ b/tests/semanticdb/expect/Advanced.scala @@ -13,10 +13,12 @@ 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 = ??? } + def s4(a: Int): { val x: Int } = ??? } class Wildcards { def e1: List[_] = ??? + def e2: List[_ <: Int] = ??? } object Test { @@ -40,3 +42,9 @@ object Test { } } } + + +// Curried Type Application +class HKClass[F <: [T] =>> [U] =>> (U, T)] { + def foo[T,U](x: F[T][U]): String = x.toString() +} diff --git a/tests/semanticdb/expect/Classes.expect.scala b/tests/semanticdb/expect/Classes.expect.scala index af092703c250..a4015d7aa150 100644 --- a/tests/semanticdb/expect/Classes.expect.scala +++ b/tests/semanticdb/expect/Classes.expect.scala @@ -1,8 +1,8 @@ package classes import scala.language/*->scala::language.*/.experimental/*->scala::language.experimental.*/.macros/*->scala::language.experimental.macros.*/ -class C1/*<-classes::C1#*/(val x1/*<-classes::C1#x1.*/: Int/*->scala::Int#*/) extends AnyVal/*->scala::AnyVal#*//*->scala::AnyVal#``().*/ +class C1/*<-classes::C1#*/(val x1/*<-classes::C1#x1.*/: Int/*->scala::Int#*/) extends AnyVal/*->scala::AnyVal#*/ -class C2/*<-classes::C2#*/(val x2/*<-classes::C2#x2.*/: 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#*/ object C2/*<-classes::C2.*/ case class C3/*<-classes::C3#*/(x/*<-classes::C3#x.*/: Int/*->scala::Int#*/) @@ -47,10 +47,10 @@ class C12/*<-classes::C12#*/ { object N/*<-classes::N.*/ { val anonClass/*<-classes::N.anonClass.*/ = new C7/*->classes::C7#*/(42) { - val local/*<-local1*/ = ???/*->scala::Predef.`???`().*/ + val local/*<-local0*/ = ???/*->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 + val anonFun/*<-classes::N.anonFun.*/ = List/*->scala::package.List.*/(1).map/*->scala::collection::immutable::List#map().*/ { i/*<-local3*/ => + val local/*<-local4*/ = 2 + local/*->local4*/ +/*->scala::Int#`+`(+4).*/ 2 } } diff --git a/tests/semanticdb/expect/EndMarkers.expect.scala b/tests/semanticdb/expect/EndMarkers.expect.scala index 76d43a91127c..7ace3ceae22f 100644 --- a/tests/semanticdb/expect/EndMarkers.expect.scala +++ b/tests/semanticdb/expect/EndMarkers.expect.scala @@ -21,11 +21,11 @@ package endmarkers: class Container/*<-endmarkers::Container#*/: def foo/*<-endmarkers::Container#foo().*/ = - (/*->scala::Tuple3.apply().*/1,2,3) + (1,2,3) end foo/*->endmarkers::Container#foo().*/ val bar/*<-endmarkers::Container#bar.*/ = - (/*->scala::Tuple3.apply().*/4,5,6) + (4,5,6) end bar/*->endmarkers::Container#bar.*/ var baz/*<-endmarkers::Container#baz().*/ = diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index 8d99d98fc6da..3e1dc9087db7 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -8,7 +8,7 @@ object Enums/*<-_empty_::Enums.*/: enum Directions/*<-_empty_::Enums.Directions#*/: 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::CanEqual.derived.*/CanEqual: + enum Suits/*<-_empty_::Enums.Suits#*/ derives CanEqual: 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.*/: @@ -47,14 +47,14 @@ object Enums/*<-_empty_::Enums.*/: case Refl/*<-_empty_::Enums.`<:<`.Refl#*/[C/*<-_empty_::Enums.`<:<`.Refl#[C]*/]() extends (C/*->_empty_::Enums.`<:<`.Refl#[C]*/ <:_empty_::Enums.`<:<`#*/ C/*->_empty_::Enums.`<:<`.Refl#[C]*/) object <:_empty_::Enums.`<:<`.`given_<:<_T_T`().[T]*/ <:_empty_::Enums.`<:<`#*/ T/*->_empty_::Enums.`<:<`.`given_<:<_T_T`().[T]*/) = Refl/*->_empty_::Enums.`<:<`.Refl.*//*->_empty_::Enums.`<:<`.Refl.apply().*/() + given [T/*<-_empty_::Enums.`<:<`.`given_<:<_T_T`().[T]*/]: (T/*->_empty_::Enums.`<:<`.`given_<:<_T_T`().[T]*/ <:_empty_::Enums.`<:<`#*/ T/*->_empty_::Enums.`<:<`.`given_<:<_T_T`().[T]*/) = Refl/*->_empty_::Enums.`<:<`.Refl.*/() extension [A/*<-_empty_::Enums.unwrap().[A]*/, B/*<-_empty_::Enums.unwrap().[B]*/](opt/*<-_empty_::Enums.unwrap().(opt)*/: Option/*->scala::Option#*/[A/*->_empty_::Enums.unwrap().[A]*/]) def unwrap/*<-_empty_::Enums.unwrap().*/(using 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]*/]]) + case Refl/*->_empty_::Enums.`<:<`.Refl.*/() => opt/*->_empty_::Enums.unwrap().(opt)*/.flatMap/*->scala::Option#flatMap().*/(identity/*->scala::Predef.identity().*/[Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]]) - val some1/*<-_empty_::Enums.some1.*/ = Some/*->scala::Some.*//*->scala::Some.apply().*/(Some/*->scala::Some.*//*->scala::Some.apply().*/(1)).unwrap/*->_empty_::Enums.unwrap().*//*->_empty_::Enums.`<:<`.`given_<:<_T_T`().*/ + val some1/*<-_empty_::Enums.some1.*/ = Some/*->scala::Some.*/(Some/*->scala::Some.*/(1)).unwrap/*->_empty_::Enums.unwrap().*/ - enum Planet/*<-_empty_::Enums.Planet#*/(mass/*<-_empty_::Enums.Planet#mass.*/: Double/*->scala::Double#*/, radius/*<-_empty_::Enums.Planet#radius.*/: Double/*->scala::Double#*/) extends Enum/*->java::lang::Enum#*/[Planet/*->_empty_::Enums.Planet#*/]/*->java::lang::Enum#``().*/: + enum Planet/*<-_empty_::Enums.Planet#*/(mass/*<-_empty_::Enums.Planet#mass.*/: Double/*->scala::Double#*/, radius/*<-_empty_::Enums.Planet#radius.*/: Double/*->scala::Double#*/) extends Enum/*->java::lang::Enum#*/[Planet/*->_empty_::Enums.Planet#*/]: 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().*/ diff --git a/tests/semanticdb/expect/EtaExpansion.expect.scala b/tests/semanticdb/expect/EtaExpansion.expect.scala index 55207ffa5ff2..76a99f66ad1b 100644 --- a/tests/semanticdb/expect/EtaExpansion.expect.scala +++ b/tests/semanticdb/expect/EtaExpansion.expect.scala @@ -1,6 +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#`+`().*/ _) + Some/*->scala::Some.*/(1).map/*->scala::Option#map().*/(identity/*->scala::Predef.identity().*/) + List/*->scala::package.List.*/(1).foldLeft/*->scala::collection::LinearSeqOps#foldLeft().*/("")(_ +/*->java::lang::String#`+`().*/ _) } diff --git a/tests/semanticdb/expect/Example.expect.scala b/tests/semanticdb/expect/Example.expect.scala index 8ee4cedeae41..5a6513ce1645 100644 --- a/tests/semanticdb/expect/Example.expect.scala +++ b/tests/semanticdb/expect/Example.expect.scala @@ -3,9 +3,9 @@ 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).*/() + new scala.collection.mutable.Stack/*->scala::collection::mutable::Stack#*/[Int/*->scala::Int#*/]() 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().*/ + val x/*<-example::Example.x.*/ = scala.reflect.classTag/*->scala::reflect::package.classTag().*/[Int/*->scala::Int#*/] } diff --git a/tests/semanticdb/expect/Extension.expect.scala b/tests/semanticdb/expect/Extension.expect.scala index 536886368502..b40e965d4885 100644 --- a/tests/semanticdb/expect/Extension.expect.scala +++ b/tests/semanticdb/expect/Extension.expect.scala @@ -2,8 +2,17 @@ package ext extension (s/*<-ext::Extension$package.foo().(s)*//*<-ext::Extension$package.`#*#`().(s)*/: String/*->scala::Predef.String#*/) def foo/*<-ext::Extension$package.foo().*/: Int/*->scala::Int#*/ = 42 - def #*#/*<-ext::Extension$package.`#*#`().*/ (i/*<-ext::Extension$package.`#*#`().(i)*/: Int/*->scala::Int#*/): (String/*->scala::Predef.String#*/, Int/*->scala::Int#*/) = (/*->scala::Tuple2.apply().*/s/*->ext::Extension$package.`#*#`().(s)*/, i/*->ext::Extension$package.`#*#`().(i)*/) + def #*#/*<-ext::Extension$package.`#*#`().*/ (i/*<-ext::Extension$package.`#*#`().(i)*/: Int/*->scala::Int#*/): (String/*->scala::Predef.String#*/, Int/*->scala::Int#*/) = (s/*->ext::Extension$package.`#*#`().(s)*/, i/*->ext::Extension$package.`#*#`().(i)*/) val a/*<-ext::Extension$package.a.*/ = "asd".foo/*->ext::Extension$package.foo().*/ -val c/*<-ext::Extension$package.c.*/ = "foo" #*#/*->ext::Extension$package.`#*#`().*/ 23 \ No newline at end of file +val c/*<-ext::Extension$package.c.*/ = "foo" #*#/*->ext::Extension$package.`#*#`().*/ 23 + +trait Read/*<-ext::Read#*/[+T/*<-ext::Read#[T]*/]: + def fromString/*<-ext::Read#fromString().*/(s/*<-ext::Read#fromString().(s)*/: String/*->scala::Predef.String#*/): Option/*->scala::Option#*/[T/*->ext::Read#[T]*/] + +extension (s/*<-ext::Extension$package.readInto().(s)*/: String/*->scala::Predef.String#*/) + def readInto/*<-ext::Extension$package.readInto().*/[T/*<-ext::Extension$package.readInto().[T]*/](using Read/*->ext::Read#*/[T/*->ext::Extension$package.readInto().[T]*/]): Option/*->scala::Option#*/[T/*->ext::Extension$package.readInto().[T]*/] = summon/*->scala::Predef.summon().*/[Read/*->ext::Read#*/[T/*->ext::Extension$package.readInto().[T]*/]].fromString/*->ext::Read#fromString().*/(s/*->ext::Extension$package.readInto().(s)*/) + +trait Functor/*<-ext::Functor#*/[F/*<-ext::Functor#[F]*/[_]]: + extension [T/*<-ext::Functor#map().[T]*/](t/*<-ext::Functor#map().(t)*/: F/*->ext::Functor#[F]*/[T/*->ext::Functor#map().[T]*/]) def map/*<-ext::Functor#map().*/[U/*<-ext::Functor#map().[U]*/](f/*<-ext::Functor#map().(f)*/: T/*->ext::Functor#map().[T]*/ => U/*->ext::Functor#map().[U]*/): F/*->ext::Functor#[F]*/[U/*->ext::Functor#map().[U]*/] diff --git a/tests/semanticdb/expect/Extension.scala b/tests/semanticdb/expect/Extension.scala index 5b9c3e5f21ab..c204b1ff7fcc 100644 --- a/tests/semanticdb/expect/Extension.scala +++ b/tests/semanticdb/expect/Extension.scala @@ -6,4 +6,13 @@ extension (s: String) val a = "asd".foo -val c = "foo" #*# 23 \ No newline at end of file +val c = "foo" #*# 23 + +trait Read[+T]: + def fromString(s: String): Option[T] + +extension (s: String) + def readInto[T](using Read[T]): Option[T] = summon[Read[T]].fromString(s) + +trait Functor[F[_]]: + extension [T](t: F[T]) def map[U](f: T => U): F[U] diff --git a/tests/semanticdb/expect/ForComprehension.expect.scala b/tests/semanticdb/expect/ForComprehension.expect.scala index c4d3340bc84c..815b7a93518d 100644 --- a/tests/semanticdb/expect/ForComprehension.expect.scala +++ b/tests/semanticdb/expect/ForComprehension.expect.scala @@ -2,39 +2,39 @@ 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*/) + a/*<-local0*/ <- List/*->scala::package.List.*/(1) + b/*<-local1*//*->local1*/ <- List/*->scala::package.List.*/(1) + if b/*->local1*/ >/*->scala::Int#`>`(+3).*/ 1 + c/*<-local2*//*->local2*/ = a/*->local0*/ +/*->scala::Int#`+`(+4).*/ b/*->local1*/ + } yield (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().*/ + a/*<-local4*/ <- List/*->scala::package.List.*/(1) + b/*<-local5*/ <- List/*->scala::package.List.*/(a/*->local4*/) if ( - /*->scala::Tuple2.apply().*/a/*->local4*/, + a/*->local4*/, b/*->local5*/ - ) ==/*->scala::Any#`==`().*/ (/*->scala::Tuple2.apply().*/1, 2)/*->scala::collection::WithFilter#flatMap().*/ - /*->local6*//*->scala::Tuple2.unapply().*/( - /*->scala::Tuple2.unapply().*/c/*<-local7*/, + ) ==/*->scala::Any#`==`().*/ (1, 2) + ( + 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().*/ + ) <- List/*->scala::package.List.*/((a/*->local4*/, b/*->local5*/)) if ( - /*->scala::Tuple4.apply().*/a/*->local4*/, + 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*/, + ) ==/*->scala::Any#`==`().*/ (1, 2, 3, 4) + e/*<-local9*//*->local9*/ = ( + 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().*/ + ) + if e/*->local9*/ ==/*->scala::Any#`==`().*/ (1, 2, 3, 4) + f/*<-local10*/ <- List/*->scala::package.List.*/(e/*->local9*/) } yield { ( - /*->scala::Tuple6.apply().*/a/*->local4*/, + a/*->local4*/, b/*->local5*/, c/*->local7*/, d/*->local8*/, diff --git a/tests/semanticdb/expect/Givens.expect.scala b/tests/semanticdb/expect/Givens.expect.scala index 35ef1d7c3cf9..5045a25c39cd 100644 --- a/tests/semanticdb/expect/Givens.expect.scala +++ b/tests/semanticdb/expect/Givens.expect.scala @@ -4,11 +4,11 @@ package b object Givens/*<-a::b::Givens.*/: extension [A/*<-a::b::Givens.sayHello().[A]*/](any/*<-a::b::Givens.sayHello().(any)*/: A/*->a::b::Givens.sayHello().[A]*/) - def sayHello/*<-a::b::Givens.sayHello().*/ = s"/*->scala::StringContext.apply().*/Hello, I am $any/*->a::b::Givens.sayHello().(any)*/"/*->scala::StringContext#s().*/ + def sayHello/*<-a::b::Givens.sayHello().*/ = s"Hello, I am $any/*->a::b::Givens.sayHello().(any)*/" extension [B/*<-a::b::Givens.sayGoodbye().[B]*//*<-a::b::Givens.saySoLong().[B]*/](any/*<-a::b::Givens.sayGoodbye().(any)*//*<-a::b::Givens.saySoLong().(any)*/: B/*->a::b::Givens.sayGoodbye().[B]*//*->a::b::Givens.saySoLong().[B]*/) - def sayGoodbye/*<-a::b::Givens.sayGoodbye().*/ = s"/*->scala::StringContext.apply().*/Goodbye, from $any/*->a::b::Givens.sayGoodbye().(any)*/"/*->scala::StringContext#s().*/ - def saySoLong/*<-a::b::Givens.saySoLong().*/ = s"/*->scala::StringContext.apply().*/So Long, from $any/*->a::b::Givens.saySoLong().(any)*/"/*->scala::StringContext#s().*/ + def sayGoodbye/*<-a::b::Givens.sayGoodbye().*/ = s"Goodbye, from $any/*->a::b::Givens.sayGoodbye().(any)*/" + def saySoLong/*<-a::b::Givens.saySoLong().*/ = s"So Long, from $any/*->a::b::Givens.saySoLong().(any)*/" val hello1/*<-a::b::Givens.hello1.*/ = 1.sayHello/*->a::b::Givens.sayHello().*/ val goodbye1/*<-a::b::Givens.goodbye1.*/ = 1.sayGoodbye/*->a::b::Givens.sayGoodbye().*/ @@ -18,7 +18,7 @@ object Givens/*<-a::b::Givens.*/: def empty/*<-a::b::Givens.Monoid#empty().*/: A/*->a::b::Givens.Monoid#[A]*/ extension (x/*<-a::b::Givens.Monoid#combine().(x)*/: A/*->a::b::Givens.Monoid#[A]*/) def combine/*<-a::b::Givens.Monoid#combine().*/(y/*<-a::b::Givens.Monoid#combine().(y)*/: A/*->a::b::Givens.Monoid#[A]*/): A/*->a::b::Givens.Monoid#[A]*/ - given Monoid[String] with/*<-a::b::Givens.given_Monoid_String.*//*->a::b::Givens.Monoid#*//*->scala::Predef.String#*/ + given Monoid/*->a::b::Givens.Monoid#*/[String/*->scala::Predef.String#*/] with def empty/*<-a::b::Givens.given_Monoid_String.empty().*/ = "" extension (x/*<-a::b::Givens.given_Monoid_String.combine().(x)*/: String/*->scala::Predef.String#*/) def combine/*<-a::b::Givens.given_Monoid_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)*/ diff --git a/tests/semanticdb/expect/ImplicitConversion.expect.scala b/tests/semanticdb/expect/ImplicitConversion.expect.scala index e5309ca26467..b96bac5d4981 100644 --- a/tests/semanticdb/expect/ImplicitConversion.expect.scala +++ b/tests/semanticdb/expect/ImplicitConversion.expect.scala @@ -9,29 +9,29 @@ class ImplicitConversion/*<-example::ImplicitConversion#*/ { ): 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 tuple/*<-example::ImplicitConversion#tuple.*/ = (1, 2) val char/*<-example::ImplicitConversion#char.*/: Char/*->scala::Char#*/ = 'a' // extension methods - /*->scala::Predef.augmentString().*/message/*->example::ImplicitConversion#message.*/ + message/*->example::ImplicitConversion#message.*/ .stripSuffix/*->scala::collection::StringOps#stripSuffix().*/("h") - /*->example::ImplicitConversion.newAny2stringadd().*/tuple/*->example::ImplicitConversion#tuple.*/ +/*->example::ImplicitConversion.newAny2stringadd#`+`().*/ "Hello" + 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.*/ + val x/*<-example::ImplicitConversion#x.*/: Int/*->scala::Int#*/ = 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 + s"Hello $message/*->example::ImplicitConversion#message.*/ $number/*->example::ImplicitConversion#number.*/" + s"""Hello |$message/*->example::ImplicitConversion#message.*/ - |$number/*->example::ImplicitConversion#number.*/"""/*->scala::StringContext#s().*/.stripMargin/*->scala::collection::StringOps#stripMargin(+1).*/ + |$number/*->example::ImplicitConversion#number.*/""".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.*/ + val a/*<-example::ImplicitConversion#a.*/: Int/*->scala::Int#*/ = char/*->example::ImplicitConversion#char.*/ + val b/*<-example::ImplicitConversion#b.*/: Long/*->scala::Long#*/ = 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#``().*/ { + 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#*/ { 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/InstrumentTyper.expect.scala b/tests/semanticdb/expect/InstrumentTyper.expect.scala index fdce47af0a20..5ed05aa56192 100644 --- a/tests/semanticdb/expect/InstrumentTyper.expect.scala +++ b/tests/semanticdb/expect/InstrumentTyper.expect.scala @@ -6,7 +6,7 @@ import scala.language/*->scala::language.*/.higherKinds/*->scala::language.highe 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().*/( + def all/*<-example::InstrumentTyper#all().*/ = List/*->scala::package.List.*/( 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.*/, @@ -18,7 +18,7 @@ class InstrumentTyper/*<-example::InstrumentTyper#*/ { self/*<-local0*/: AnyRef/ 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().*/() + List/*->scala::package.List.*/() ) 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.`???`().*/ diff --git a/tests/semanticdb/expect/InventedNames.expect.scala b/tests/semanticdb/expect/InventedNames.expect.scala index f1ac3a4ae0cb..131d4304da31 100644 --- a/tests/semanticdb/expect/InventedNames.expect.scala +++ b/tests/semanticdb/expect/InventedNames.expect.scala @@ -12,15 +12,15 @@ trait Z/*<-givens::Z#*/[T/*<-givens::Z#[T]*/]: given intValue/*<-givens::InventedNames$package.intValue.*/: Int/*->scala::Int#*/ = 4 -given /*<-givens::InventedNames$package.given_String.*/String/*->scala::Predef.String#*/ = "str" -given /*<-givens::InventedNames$package.given_Double().*/(using Int/*->scala::Int#*/): Double/*->scala::Double#*/ = 4.0 -given /*<-givens::InventedNames$package.given_List_T().*/[T/*<-givens::InventedNames$package.given_List_T().[T]*/]: List/*->scala::package.List#*/[T/*->givens::InventedNames$package.given_List_T().[T]*/] = Nil/*->scala::package.Nil.*/ +given String/*->scala::Predef.String#*/ = "str" +given (using Int/*->scala::Int#*/): Double/*->scala::Double#*/ = 4.0 +given [T/*<-givens::InventedNames$package.given_List_T().[T]*/]: List/*->scala::package.List#*/[T/*->givens::InventedNames$package.given_List_T().[T]*/] = Nil/*->scala::package.Nil.*/ given given_Char/*<-givens::InventedNames$package.given_Char.*/: Char/*->scala::Char#*/ = '?' given `given_Float/*<-givens::InventedNames$package.given_Float.*/`: Float/*->scala::Float#*/ = 3.0 given `* */*<-givens::InventedNames$package.`* *`.*/`: Long/*->scala::Long#*/ = 5 -given X with -/*<-givens::InventedNames$package.given_X.*//*->givens::X#*/ def doX/*<-givens::InventedNames$package.given_X.doX().*/ = 7 +given X/*->givens::X#*/ with + def doX/*<-givens::InventedNames$package.given_X.doX().*/ = 7 given (using X/*->givens::X#*/): Y/*->givens::Y#*/ with def doY/*<-givens::InventedNames$package.given_Y#doY().*/ = "7" @@ -32,11 +32,11 @@ given [T/*<-givens::InventedNames$package.given_Z_T#[T]*/]: Z/*->givens::Z#*/[T/ val a/*<-givens::InventedNames$package.a.*/ = intValue/*->givens::InventedNames$package.intValue.*/ val b/*<-givens::InventedNames$package.b.*/ = given_String/*->givens::InventedNames$package.given_String.*/ -val c/*<-givens::InventedNames$package.c.*/ = given_Double/*->givens::InventedNames$package.given_Double().*//*->givens::InventedNames$package.intValue.*/ +val c/*<-givens::InventedNames$package.c.*/ = given_Double/*->givens::InventedNames$package.given_Double().*/ val d/*<-givens::InventedNames$package.d.*/ = given_List_T/*->givens::InventedNames$package.given_List_T().*/[Int/*->scala::Int#*/] val e/*<-givens::InventedNames$package.e.*/ = given_Char/*->givens::InventedNames$package.given_Char.*/ val f/*<-givens::InventedNames$package.f.*/ = given_Float/*->givens::InventedNames$package.given_Float.*/ val g/*<-givens::InventedNames$package.g.*/ = `* *`/*->givens::InventedNames$package.`* *`.*/ val x/*<-givens::InventedNames$package.x.*/ = given_X/*->givens::InventedNames$package.given_X.*/ -val y/*<-givens::InventedNames$package.y.*/ = given_Y/*->givens::InventedNames$package.given_Y().*//*->givens::InventedNames$package.given_X.*/ +val y/*<-givens::InventedNames$package.y.*/ = given_Y/*->givens::InventedNames$package.given_Y().*/ val z/*<-givens::InventedNames$package.z.*/ = given_Z_T/*->givens::InventedNames$package.given_Z_T().*/[String/*->scala::Predef.String#*/] \ No newline at end of file diff --git a/tests/semanticdb/expect/Issue1749.expect.scala b/tests/semanticdb/expect/Issue1749.expect.scala index b047b771e9ea..19fe1a14ad36 100644 --- a/tests/semanticdb/expect/Issue1749.expect.scala +++ b/tests/semanticdb/expect/Issue1749.expect.scala @@ -6,11 +6,11 @@ import scala.math.Ordered/*->scala::math::Ordered.*/.orderingToOrdered/*->scala: 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.*/)) + (x1/*->example::Issue1749#x1.*/, x1/*->example::Issue1749#x1.*/) + .compare/*->scala::math::Ordered#compare().*/((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" + map/*->example::Issue1854#map.*/("a") = "b" } diff --git a/tests/semanticdb/expect/Local.expect.scala b/tests/semanticdb/expect/Local.expect.scala index 6c1aa8440b23..e6dfc04f5422 100644 --- a/tests/semanticdb/expect/Local.expect.scala +++ b/tests/semanticdb/expect/Local.expect.scala @@ -2,7 +2,7 @@ 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) + def id/*<-local2*/[A/*<-local0*/](a/*<-local1*/: A/*->local0*/): A/*->local0*/ = a/*->local1*/ + id/*->local2*/(1) } } diff --git a/tests/semanticdb/expect/Locals.expect.scala b/tests/semanticdb/expect/Locals.expect.scala index 7a8fdf0dd432..8cc14786f7ed 100644 --- a/tests/semanticdb/expect/Locals.expect.scala +++ b/tests/semanticdb/expect/Locals.expect.scala @@ -3,6 +3,6 @@ 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*/) + List/*->scala::package.List.*/(x/*->local0*/) } } diff --git a/tests/semanticdb/expect/MetacJava.expect.scala b/tests/semanticdb/expect/MetacJava.expect.scala index f95f82d787eb..08e787ce4b8a 100644 --- a/tests/semanticdb/expect/MetacJava.expect.scala +++ b/tests/semanticdb/expect/MetacJava.expect.scala @@ -4,16 +4,16 @@ 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#``().*/() + new javacp.MetacJava/*->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#*/() + val overload1/*<-example::MetacJava#overload1.*/ = new inner/*->example::MetacJava#inner.*/.Overload1/*->com::javacp::MetacJava#Overload1#*/() + val overload2/*<-example::MetacJava#overload2.*/ = new inner/*->example::MetacJava#inner.*/.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#*/()) + inner/*->example::MetacJava#inner.*/.overload/*->com::javacp::MetacJava#overload(+1).*/(new overload2/*->example::MetacJava#overload2.*/.A/*->com::javacp::MetacJava#Overload2#A#*/()) + val staticInner/*<-example::MetacJava#staticInner.*/ = new javacp.MetacJava/*->com::javacp::MetacJava#*/.StaticInner/*->com::javacp::MetacJava#StaticInner#*/() + val nonStatic/*<-example::MetacJava#nonStatic.*/ = new staticInner/*->example::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#``().*/()) + 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#*/()) 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/MethodUsages.expect.scala b/tests/semanticdb/expect/MethodUsages.expect.scala index d202e21ec851..e6963465c97e 100644 --- a/tests/semanticdb/expect/MethodUsages.expect.scala +++ b/tests/semanticdb/expect/MethodUsages.expect.scala @@ -1,7 +1,7 @@ package example class MethodUsages/*<-example::MethodUsages#*/ { - val m/*<-example::MethodUsages#m.*/ = new Methods/*->example::Methods#*/[Int/*->scala::Int#*/]/*->example::Methods#``().*/ + val m/*<-example::MethodUsages#m.*/ = new Methods/*->example::Methods#*/[Int/*->scala::Int#*/] 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) @@ -9,9 +9,9 @@ class MethodUsages/*<-example::MethodUsages#*/ { 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(+1).*/(new m/*->example::MethodUsages#m.*/.List/*->example::Methods#List#*/[Int/*->scala::Int#*/]) 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.*/.m7/*->example::Methods#m7().*/(m/*->example::MethodUsages#m.*/, new m/*->example::MethodUsages#m.*/.List/*->example::Methods#List#*/[Int/*->scala::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) diff --git a/tests/semanticdb/expect/Methods.expect.scala b/tests/semanticdb/expect/Methods.expect.scala index 8190bf0308d1..f34c657b2f6d 100644 --- a/tests/semanticdb/expect/Methods.expect.scala +++ b/tests/semanticdb/expect/Methods.expect.scala @@ -15,7 +15,7 @@ class Methods/*<-example::Methods#*/[T/*<-example::Methods#[T]*/] { 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 m7/*<-example::Methods#m7().*/[U/*<-example::Methods#m7().[U]*//*<-example::Methods#m7().(evidence$1)*/: Ordering/*->scala::math::Ordering#*/](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.`???`().*/ @@ -24,6 +24,7 @@ class Methods/*<-example::Methods#*/[T/*<-example::Methods#[T]*/] { 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 m12c/*<-example::Methods#m12c().*/(x/*<-example::Methods#m12c().(x)*/: { val x/*<-local1*/: Int/*->scala::Int#*/; def y/*<-local2*/: 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.`???`().*/ diff --git a/tests/semanticdb/expect/Methods.scala b/tests/semanticdb/expect/Methods.scala index d588d3df2e55..f07dea11752d 100644 --- a/tests/semanticdb/expect/Methods.scala +++ b/tests/semanticdb/expect/Methods.scala @@ -24,6 +24,7 @@ class Methods[T] { def m11(x: Example.type) = ??? def m12a(x: {}) = ??? def m12b(x: { val x: Int }) = ??? + def m12c(x: { val x: Int; def y: Int }) = ??? def m13(x: Int @unchecked) = ??? def m15(x: => Int) = ??? def m16(x: Int*) = ??? diff --git a/tests/semanticdb/expect/NamedApplyBlock.expect.scala b/tests/semanticdb/expect/NamedApplyBlock.expect.scala index db1311082bad..f47393b0322a 100644 --- a/tests/semanticdb/expect/NamedApplyBlock.expect.scala +++ b/tests/semanticdb/expect/NamedApplyBlock.expect.scala @@ -4,11 +4,11 @@ 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().*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = 3) - def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local1*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = foo/*->example::NamedApplyBlockMethods.foo().*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = 3)) + def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = foo/*->example::NamedApplyBlockMethods.foo().*/(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.*//*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail/*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().(tail)*/ = "tail") + val msg/*<-example::NamedApplyBlockCaseClassConstruction.msg.*/ = Msg/*->example::NamedApplyBlockCaseClassConstruction.Msg.*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail/*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().(tail)*/ = "tail") } diff --git a/tests/semanticdb/expect/NamedArguments.expect.scala b/tests/semanticdb/expect/NamedArguments.expect.scala index 1d478decc4b4..454a2b6d6281 100644 --- a/tests/semanticdb/expect/NamedArguments.expect.scala +++ b/tests/semanticdb/expect/NamedArguments.expect.scala @@ -2,6 +2,6 @@ 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.*/(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/NewModifiers.expect.scala b/tests/semanticdb/expect/NewModifiers.expect.scala index bc0d1dcf71e7..cc93048214bb 100644 --- a/tests/semanticdb/expect/NewModifiers.expect.scala +++ b/tests/semanticdb/expect/NewModifiers.expect.scala @@ -2,3 +2,16 @@ object NewModifiers/*<-_empty_::NewModifiers.*/ { inline val foo/*<-_empty_::NewModifiers.foo.*/ = "foo" opaque type A/*<-_empty_::NewModifiers.A#*/ = Int/*->scala::Int#*/ } + +opaque type OpaqueB/*<-_empty_::NewModifiers$package.OpaqueB#*/ = Int/*->scala::Int#*/ + +class NewModifiersClass/*<-_empty_::NewModifiersClass#*/ { + opaque type C/*<-_empty_::NewModifiersClass#C#*/ = Int/*->scala::Int#*/ + class Nested/*<-_empty_::NewModifiersClass#Nested#*/ { + opaque type NestedOpaque/*<-_empty_::NewModifiersClass#Nested#NestedOpaque#*/ = Int/*->scala::Int#*/ + } +} + +trait NewModifiersTrait/*<-_empty_::NewModifiersTrait#*/ { + opaque type D/*<-_empty_::NewModifiersTrait#D#*/ = Int/*->scala::Int#*/ +} diff --git a/tests/semanticdb/expect/NewModifiers.scala b/tests/semanticdb/expect/NewModifiers.scala index 2d5e82551b02..07b47ad8fb02 100644 --- a/tests/semanticdb/expect/NewModifiers.scala +++ b/tests/semanticdb/expect/NewModifiers.scala @@ -2,3 +2,16 @@ object NewModifiers { inline val foo = "foo" opaque type A = Int } + +opaque type OpaqueB = Int + +class NewModifiersClass { + opaque type C = Int + class Nested { + opaque type NestedOpaque = Int + } +} + +trait NewModifiersTrait { + opaque type D = Int +} diff --git a/tests/semanticdb/expect/RecOrRefined.expect.scala b/tests/semanticdb/expect/RecOrRefined.expect.scala new file mode 100644 index 000000000000..12c2bd884bb8 --- /dev/null +++ b/tests/semanticdb/expect/RecOrRefined.expect.scala @@ -0,0 +1,34 @@ +package example + +def m1/*<-example::RecOrRefined$package.m1().*/(a/*<-example::RecOrRefined$package.m1().(a)*/: Int/*->scala::Int#*/ { val x/*<-local1*/: Int/*->scala::Int#*/ }) = ???/*->scala::Predef.`???`().*/ +def m2/*<-example::RecOrRefined$package.m2().*/(x/*<-example::RecOrRefined$package.m2().(x)*/: { val x/*<-local2*/: Int/*->scala::Int#*/; def y/*<-local3*/: Int/*->scala::Int#*/ }) = ???/*->scala::Predef.`???`().*/ +def m3/*<-example::RecOrRefined$package.m3().*/(x/*<-example::RecOrRefined$package.m3().(x)*/: { val x/*<-local4*/: Int/*->scala::Int#*/; def y/*<-local5*/: Int/*->scala::Int#*/; type z/*<-local6*/ }) = ???/*->scala::Predef.`???`().*/ +trait PolyHolder/*<-example::PolyHolder#*/ { + def foo/*<-example::PolyHolder#foo().*/[T/*<-example::PolyHolder#foo().[T]*/](t/*<-example::PolyHolder#foo().(t)*/: T/*->example::PolyHolder#foo().[T]*/): Any/*->scala::Any#*/ +} + +def m4/*<-example::RecOrRefined$package.m4().*/(x/*<-example::RecOrRefined$package.m4().(x)*/: PolyHolder/*->example::PolyHolder#*/ { def foo/*<-local9*/[T/*<-local7*/](t/*<-local8*/: T/*->local7*/): T/*->local7*/ }) = ???/*->scala::Predef.`???`().*/ +def m5/*<-example::RecOrRefined$package.m5().*/[Z/*<-example::RecOrRefined$package.m5().[Z]*/](x/*<-example::RecOrRefined$package.m5().(x)*/: Int/*->scala::Int#*/): PolyHolder/*->example::PolyHolder#*/ { def foo/*<-local12*/[T/*<-local10*/](t/*<-local11*/: T/*->local10*/): T/*->local10*/ } = ???/*->scala::Predef.`???`().*/ + +type m6/*<-example::RecOrRefined$package.m6#*/ = [X/*<-example::RecOrRefined$package.m6#[X]*/] =>> PolyHolder/*->example::PolyHolder#*/ { def foo/*<-local15*/[T/*<-local13*/](t/*<-local14*/: T/*->local13*/): T/*->local13*/ } + +class Record/*<-example::Record#*/(elems/*<-example::Record#elems.*/: (String/*->scala::Predef.String#*/, Any/*->scala::Any#*/)*) extends Selectable/*->scala::Selectable#*/: + private val fields/*<-example::Record#fields.*/ = elems/*->example::Record#elems.*/.toMap/*->scala::collection::IterableOnceOps#toMap().*/ + def selectDynamic/*<-example::Record#selectDynamic().*/(name/*<-example::Record#selectDynamic().(name)*/: String/*->scala::Predef.String#*/): Any/*->scala::Any#*/ = fields/*->example::Record#fields.*/(name/*->example::Record#selectDynamic().(name)*/) + +type Person/*<-example::RecOrRefined$package.Person#*/ = Record/*->example::Record#*/ { + val name/*<-local16*/: String/*->scala::Predef.String#*/ + val age/*<-local17*/: Int/*->scala::Int#*/ +} + +// RecType +class C/*<-example::C#*/ { type T1/*<-example::C#T1#*/; type T2/*<-example::C#T2#*/ } +type C2/*<-example::RecOrRefined$package.C2#*/ = C/*->example::C#*/ { type T1/*<-local18*/; type T2/*<-local19*/ = T1/*->local18*/ } + +trait SpecialRefinement/*<-example::SpecialRefinement#*/ { + def pickOne/*<-example::SpecialRefinement#pickOne().*/[T/*<-example::SpecialRefinement#pickOne().[T]*/](as/*<-example::SpecialRefinement#pickOne().(as)*/: T/*->example::SpecialRefinement#pickOne().[T]*/*): Option/*->scala::Option#*/[Any/*->scala::Any#*/] +} + +class PickOneRefinement_1/*<-example::PickOneRefinement_1#*/[S/*<-example::PickOneRefinement_1#[S]*/ <: SpecialRefinement { def pickOne[T](as: T*): Option[String] }] { + def run/*<-example::PickOneRefinement_1#run().*/(s/*<-example::PickOneRefinement_1#run().(s)*/: S/*->example::PickOneRefinement_1#[S]*/, as/*<-example::PickOneRefinement_1#run().(as)*/: String/*->scala::Predef.String#*/*): Option/*->scala::Option#*/[String/*->scala::Predef.String#*/] = s/*->example::PickOneRefinement_1#run().(s)*/.pickOne/*->example::SpecialRefinement#pickOne().*/(as/*->example::PickOneRefinement_1#run().(as)*/:_*) +} diff --git a/tests/semanticdb/expect/RecOrRefined.scala b/tests/semanticdb/expect/RecOrRefined.scala new file mode 100644 index 000000000000..06292435a91e --- /dev/null +++ b/tests/semanticdb/expect/RecOrRefined.scala @@ -0,0 +1,34 @@ +package example + +def m1(a: Int { val x: Int }) = ??? +def m2(x: { val x: Int; def y: Int }) = ??? +def m3(x: { val x: Int; def y: Int; type z }) = ??? +trait PolyHolder { + def foo[T](t: T): Any +} + +def m4(x: PolyHolder { def foo[T](t: T): T }) = ??? +def m5[Z](x: Int): PolyHolder { def foo[T](t: T): T } = ??? + +type m6 = [X] =>> PolyHolder { def foo[T](t: T): T } + +class Record(elems: (String, Any)*) extends Selectable: + private val fields = elems.toMap + def selectDynamic(name: String): Any = fields(name) + +type Person = Record { + val name: String + val age: Int +} + +// RecType +class C { type T1; type T2 } +type C2 = C { type T1; type T2 = T1 } + +trait SpecialRefinement { + def pickOne[T](as: T*): Option[Any] +} + +class PickOneRefinement_1[S <: SpecialRefinement { def pickOne[T](as: T*): Option[String] }] { + def run(s: S, as: String*): Option[String] = s.pickOne(as:_*) +} diff --git a/tests/semanticdb/expect/RightAssociativeExtension.expect.scala b/tests/semanticdb/expect/RightAssociativeExtension.expect.scala index c32fd1becfda..9d8271a43685 100644 --- a/tests/semanticdb/expect/RightAssociativeExtension.expect.scala +++ b/tests/semanticdb/expect/RightAssociativeExtension.expect.scala @@ -1,6 +1,6 @@ package ext extension (s/*<-ext::RightAssociativeExtension$package.`:*:`().(s)*/: String/*->scala::Predef.String#*/) - def :*:/*<-ext::RightAssociativeExtension$package.`:*:`().*/ (i/*<-ext::RightAssociativeExtension$package.`:*:`().(i)*/: Int/*->scala::Int#*/): (String/*->scala::Predef.String#*/, Int/*->scala::Int#*/) = (/*->scala::Tuple2.apply().*/s/*->ext::RightAssociativeExtension$package.`:*:`().(s)*/, i/*->ext::RightAssociativeExtension$package.`:*:`().(i)*/) + def :*:/*<-ext::RightAssociativeExtension$package.`:*:`().*/ (i/*<-ext::RightAssociativeExtension$package.`:*:`().(i)*/: Int/*->scala::Int#*/): (String/*->scala::Predef.String#*/, Int/*->scala::Int#*/) = (s/*->ext::RightAssociativeExtension$package.`:*:`().(s)*/, i/*->ext::RightAssociativeExtension$package.`:*:`().(i)*/) val b/*<-ext::RightAssociativeExtension$package.b.*/ = "foo" :*:/*->ext::RightAssociativeExtension$package.`:*:`().*/ 23 \ No newline at end of file diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala index 0f95d9d0b01f..271d3013c0ae 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -3,48 +3,48 @@ package example import scala.language/*->scala::language.*/.implicitConversions/*->scala::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().*/.headOption/*->scala::collection::ArrayOps#headOption().*/ - /*->scala::Predef.augmentString().*/"fooo".stripPrefix/*->scala::collection::StringOps#stripPrefix().*/("o") + List/*->scala::package.List.*/(1).map/*->scala::collection::immutable::List#map().*/(_ +/*->scala::Int#`+`(+4).*/ 2) + Array/*->scala::Array.*/.empty/*->scala::Array.empty().*/[Int/*->scala::Int#*/].headOption/*->scala::collection::ArrayOps#headOption().*/ + "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 Name/*<-example::Synthetic#Name.*/ = "name:(.*)".r/*->scala::collection::StringOps#r().*/ + val x/*<-example::Synthetic#x.*/ #::/*->scala::package.`#::`.*/ xs/*<-example::Synthetic#xs.*/ = LazyList/*->scala::package.LazyList.*/(1, 2) + val Name/*->example::Synthetic#Name.*/(name/*<-example::Synthetic#name.*/) = "name:foo" + 1 #:: 2 #:: LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*/ - 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 a1/*<-example::Synthetic#a1.*/ #::/*->scala::package.`#::`.*/ a2/*<-example::Synthetic#a2.*/ #::/*->scala::package.`#::`.*/ as/*<-example::Synthetic#as.*/ = LazyList/*->scala::package.LazyList.*/(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#`#::`().*/ + val lst/*<-example::Synthetic#lst.*/ = 1 #:: 2 #:: LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*/ - 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*/) + for (x/*<-local0*/ <- 1 to/*->scala::runtime::RichInt#to().*/ 10; y/*<-local1*/ <- 0 until/*->scala::runtime::RichInt#until().*/ 10) println/*->scala::Predef.println(+1).*/(x/*->local0*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local0*/) + for (i/*<-local2*/ <- 1 to/*->scala::runtime::RichInt#to().*/ 10; j/*<-local3*/ <- 0 until/*->scala::runtime::RichInt#until().*/ 10) yield (i/*->local2*/, j/*->local3*/) + for (i/*<-local4*/ <- 1 to/*->scala::runtime::RichInt#to().*/ 10; j/*<-local5*/ <- 0 until/*->scala::runtime::RichInt#until().*/ 10 if i/*->local4*/ %/*->scala::Int#`%`(+3).*/ 2 ==/*->scala::Int#`==`(+3).*/ 0) yield (i/*->local4*/, j/*->local5*/) object s/*<-example::Synthetic#s.*/ { def apply/*<-example::Synthetic#s.apply().*/() = 2 - s/*->example::Synthetic#s.apply().*/() + s() 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) + Bar/*->example::Synthetic#s.Bar.*/() + null.asInstanceOf/*->scala::Any#asInstanceOf().*/[Int/*->scala::Int#*/ => Int/*->scala::Int#*/](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 J/*<-example::Synthetic#J#*/[T/*<-example::Synthetic#J#[T]*//*<-example::Synthetic#J#evidence$1.*/: Manifest/*->scala::Predef.Manifest#*/] { val arr/*<-example::Synthetic#J#arr.*/ = Array/*->scala::Array.*/.empty/*->scala::Array.empty().*/[T/*->example::Synthetic#J#[T]*/]/*->example::Synthetic#J#evidence$1.*/ } 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.*/ + val f/*<-example::Synthetic#f.*/: Ordered/*->scala::package.Ordered#*/[F/*->example::Synthetic#F#*/] = new F/*->example::Synthetic#F#*/ 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().*/ + a/*<-local6*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1) + b/*<-local7*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2) + } println/*->scala::Predef.println(+1).*/(a/*->local6*/) 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().*/ + a/*<-local8*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1) + b/*<-local9*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2) + if a/*->local8*/ scala::Int#`<`(+3).*/ b/*->local9*/ + } yield a/*->local8*/ } diff --git a/tests/semanticdb/expect/Traits.expect.scala b/tests/semanticdb/expect/Traits.expect.scala index 193390b38826..4cb0d6d65b22 100644 --- a/tests/semanticdb/expect/Traits.expect.scala +++ b/tests/semanticdb/expect/Traits.expect.scala @@ -10,5 +10,5 @@ object U/*<-traits::U.*/ { } class C/*<-traits::C#*/ -trait V/*<-traits::V#*/ { self/*<-local1*/: C/*->traits::C#*/ => +trait V/*<-traits::V#*/ { self/*<-local2*/: C/*->traits::C#*/ => } diff --git a/tests/semanticdb/expect/ValPattern.expect.scala b/tests/semanticdb/expect/ValPattern.expect.scala index f89133f6ef5b..8eac1dc87d87 100644 --- a/tests/semanticdb/expect/ValPattern.expect.scala +++ b/tests/semanticdb/expect/ValPattern.expect.scala @@ -2,20 +2,20 @@ 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 (left/*<-example::ValPattern#left.*/, right/*<-example::ValPattern#right.*/) = (1, 2) + val Some/*->scala::Some.*/(number1/*<-example::ValPattern#number1.*/) = + Some/*->scala::Some.*/(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.`???`().*/ + val List/*->scala::package.List.*/(Some/*->scala::Some.*/(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) + var (leftVar/*<-example::ValPattern#leftVar().*/, rightVar/*<-example::ValPattern#rightVar().*/) = (1, 2) + var Some/*->scala::Some.*/(number1Var/*<-example::ValPattern#number1Var().*/) = + Some/*->scala::Some.*/(1) def app/*<-example::ValPattern#app().*/(): Unit/*->scala::Unit#*/ = { println/*->scala::Predef.println(+1).*/( ( - /*->scala::Tuple6.apply().*/number1/*->example::ValPattern#number1.*/, + number1/*->example::ValPattern#number1.*/, left/*->example::ValPattern#left.*/, right/*->example::ValPattern#right.*/, number1Var/*->example::ValPattern#number1Var().*/, @@ -24,16 +24,16 @@ class ValPattern/*<-example::ValPattern#*/ { ) ) locally/*->scala::Predef.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) + val (left/*<-local0*/, right/*<-local1*/) = (1, 2) + val Some/*->scala::Some.*/(number1/*<-local2*/) = + Some/*->scala::Some.*/(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) + var (leftVar/*<-local3*/, rightVar/*<-local4*/) = (1, 2) + var Some/*->scala::Some.*/(number1Var/*<-local5*/) = + Some/*->scala::Some.*/(1) println/*->scala::Predef.println(+1).*/( ( - /*->scala::Tuple6.apply().*/number1/*->local2*/, + number1/*->local2*/, left/*->local0*/, right/*->local1*/, number1Var/*->local5*/, diff --git a/tests/semanticdb/expect/Vals.expect.scala b/tests/semanticdb/expect/Vals.expect.scala index d3c865665813..bcbb0f1ae84b 100644 --- a/tests/semanticdb/expect/Vals.expect.scala +++ b/tests/semanticdb/expect/Vals.expect.scala @@ -47,5 +47,5 @@ object ValUsages/*<-example::ValUsages.*/ { 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 + v/*->example::ValUsages.v.*/.explicitSetter = 25 } diff --git a/tests/semanticdb/expect/exports-example-Codec.expect.scala b/tests/semanticdb/expect/exports-example-Codec.expect.scala index b2afc55a75f0..712bb96fccc9 100644 --- a/tests/semanticdb/expect/exports-example-Codec.expect.scala +++ b/tests/semanticdb/expect/exports-example-Codec.expect.scala @@ -10,6 +10,6 @@ trait Encoder/*<-exports::example::Encoder#*/[-T/*<-exports::example::Encoder#[T trait Codec/*<-exports::example::Codec#*/[T/*<-exports::example::Codec#[T]*/](decode/*<-exports::example::Codec#decode.*/: Decoder/*->exports::example::Decoder#*/[T/*->exports::example::Codec#[T]*/], encode/*<-exports::example::Codec#encode.*/: Encoder/*->exports::example::Encoder#*/[T/*->exports::example::Codec#[T]*/]) extends Decoder/*->exports::example::Decoder#*/[T/*->exports::example::Codec#[T]*/] with Encoder/*->exports::example::Encoder#*/[T/*->exports::example::Codec#[T]*/] { - export decode/*->exports::example::Codec#decode.*//*->exports::example::Decoder#decode().*//*->exports::example::Codec#decode().(a)*/./*<-exports::example::Codec#decode().*/_ - export encode/*->exports::example::Codec#encode.*//*->exports::example::Encoder#encode().*//*->exports::example::Codec#encode().(t)*/./*<-exports::example::Codec#encode().*/_ + export decode/*->exports::example::Codec#decode.*/._ + export encode/*->exports::example::Codec#encode.*/._ } diff --git a/tests/semanticdb/expect/i9782.expect.scala b/tests/semanticdb/expect/i9782.expect.scala new file mode 100644 index 000000000000..49165ca0ff8e --- /dev/null +++ b/tests/semanticdb/expect/i9782.expect.scala @@ -0,0 +1,20 @@ +// LazyRef +trait Txn/*<-_empty_::Txn#*/[T/*<-_empty_::Txn#[T]*/ <: Txn[T]] + +trait Elem/*<-_empty_::Elem#*/[T/*<-_empty_::Elem#[T]*/ <: Txn[T]] + +trait Obj/*<-_empty_::Obj#*/[T/*<-_empty_::Obj#[T]*/ <: Txn[T]] extends Elem/*->_empty_::Elem#*/[T/*->_empty_::Obj#[T]*/] + +trait Copy/*<-_empty_::Copy#*/[In/*<-_empty_::Copy#[In]*/ <: Txn[In], Out/*<-_empty_::Copy#[Out]*/ <: Txn[Out]] { + def copyImpl/*<-_empty_::Copy#copyImpl().*/[Repr/*<-_empty_::Copy#copyImpl().[Repr]*/[~ <: Txn[~]] <: Elem[~]](in/*<-_empty_::Copy#copyImpl().(in)*/: Repr/*->_empty_::Copy#copyImpl().[Repr]*/[In/*->_empty_::Copy#[In]*/]): Repr/*->_empty_::Copy#copyImpl().[Repr]*/[Out/*->_empty_::Copy#[Out]*/] + + def apply/*<-_empty_::Copy#apply().*/[Repr/*<-_empty_::Copy#apply().[Repr]*/[~ <: Txn[~]] <: Elem[~]](in/*<-_empty_::Copy#apply().(in)*/: Repr/*->_empty_::Copy#apply().[Repr]*/[In/*->_empty_::Copy#[In]*/]): Repr/*->_empty_::Copy#apply().[Repr]*/[Out/*->_empty_::Copy#[Out]*/] = { + val out/*<-local0*/ = copyImpl/*->_empty_::Copy#copyImpl().*/[Repr/*->_empty_::Copy#apply().[Repr]*/](in/*->_empty_::Copy#apply().(in)*/) + (in/*->_empty_::Copy#apply().(in)*/, out/*->local0*/) match { + case (inObj/*<-local1*/: Obj/*->_empty_::Obj#*/[In/*->_empty_::Copy#[In]*/], outObj/*<-local2*/: Obj/*->_empty_::Obj#*/[Out/*->_empty_::Copy#[Out]*/]) => // problem here + println/*->scala::Predef.println(+1).*/("copy the attributes") + case _ => + } + out/*->local0*/ + } +} diff --git a/tests/semanticdb/expect/i9782.scala b/tests/semanticdb/expect/i9782.scala new file mode 100644 index 000000000000..8004300491cd --- /dev/null +++ b/tests/semanticdb/expect/i9782.scala @@ -0,0 +1,20 @@ +// LazyRef +trait Txn[T <: Txn[T]] + +trait Elem[T <: Txn[T]] + +trait Obj[T <: Txn[T]] extends Elem[T] + +trait Copy[In <: Txn[In], Out <: Txn[Out]] { + def copyImpl[Repr[~ <: Txn[~]] <: Elem[~]](in: Repr[In]): Repr[Out] + + def apply[Repr[~ <: Txn[~]] <: Elem[~]](in: Repr[In]): Repr[Out] = { + val out = copyImpl[Repr](in) + (in, out) match { + case (inObj: Obj[In], outObj: Obj[Out]) => // problem here + println("copy the attributes") + case _ => + } + out + } +} diff --git a/tests/semanticdb/expect/inlinedefs.expect.scala b/tests/semanticdb/expect/inlinedefs.expect.scala index c0e1a8913c0a..390bec22e632 100644 --- a/tests/semanticdb/expect/inlinedefs.expect.scala +++ b/tests/semanticdb/expect/inlinedefs.expect.scala @@ -12,6 +12,6 @@ object FakePredef/*<-inlinedefs::FakePredef.*/: * sunt in culpa qui officia deserunt mollit anim id est laborum. */ transparent inline final def assert/*<-inlinedefs::FakePredef.assert().*/(inline assertion/*<-inlinedefs::FakePredef.assert().(assertion)*/: Boolean/*->scala::Boolean#*/): Unit/*->scala::Unit#*/ = { - if (!assertion/*->inlinedefs::FakePredef.assert().(assertion)*//*->scala::Boolean#`unary_!`().*/) - throw new java.lang.AssertionError/*->java::lang::AssertionError#*//*->java::lang::AssertionError#``(+2).*/("assertion failed") + if (!assertion/*->inlinedefs::FakePredef.assert().(assertion)*/) + throw new java.lang.AssertionError/*->java::lang::AssertionError#*/("assertion failed") } diff --git a/tests/semanticdb/expect/nullary.expect.scala b/tests/semanticdb/expect/nullary.expect.scala new file mode 100644 index 000000000000..fe791ae2f1f7 --- /dev/null +++ b/tests/semanticdb/expect/nullary.expect.scala @@ -0,0 +1,20 @@ +abstract class NullaryTest/*<-_empty_::NullaryTest#*/[T/*<-_empty_::NullaryTest#[T]*/, m/*<-_empty_::NullaryTest#[m]*/[s]] { + def nullary/*<-_empty_::NullaryTest#nullary().*/: String/*->scala::Predef.String#*/ = "a" + val x/*<-_empty_::NullaryTest#x.*/ = nullary/*->_empty_::NullaryTest#nullary().*/ + + def nullary2/*<-_empty_::NullaryTest#nullary2().*/: T/*->_empty_::NullaryTest#[T]*/ + val x2/*<-_empty_::NullaryTest#x2.*/ = nullary2/*->_empty_::NullaryTest#nullary2().*/ + + def nullary3/*<-_empty_::NullaryTest#nullary3().*/: m/*->_empty_::NullaryTest#[m]*/[T/*->_empty_::NullaryTest#[T]*/] + val x3/*<-_empty_::NullaryTest#x3.*/ = nullary3/*->_empty_::NullaryTest#nullary3().*/ +} + +class Concrete/*<-_empty_::Concrete#*/ extends NullaryTest/*->_empty_::NullaryTest#*/[Int/*->scala::Int#*/, List/*->scala::package.List#*/] { + def nullary2/*<-_empty_::Concrete#nullary2().*/ = 1 + def nullary3/*<-_empty_::Concrete#nullary3().*/ = List/*->scala::package.List.*/(1,2,3) +} + +object test/*<-_empty_::test.*/ { + (new Concrete/*->_empty_::Concrete#*/).nullary2/*->_empty_::Concrete#nullary2().*/ + (new Concrete/*->_empty_::Concrete#*/).nullary3/*->_empty_::Concrete#nullary3().*/ +} diff --git a/tests/semanticdb/expect/nullary.scala b/tests/semanticdb/expect/nullary.scala new file mode 100644 index 000000000000..d3b5b67ea53e --- /dev/null +++ b/tests/semanticdb/expect/nullary.scala @@ -0,0 +1,20 @@ +abstract class NullaryTest[T, m[s]] { + def nullary: String = "a" + val x = nullary + + def nullary2: T + val x2 = nullary2 + + def nullary3: m[T] + val x3 = nullary3 +} + +class Concrete extends NullaryTest[Int, List] { + def nullary2 = 1 + def nullary3 = List(1,2,3) +} + +object test { + (new Concrete).nullary2 + (new Concrete).nullary3 +} diff --git a/tests/semanticdb/expect/recursion.expect.scala b/tests/semanticdb/expect/recursion.expect.scala index aba74b1b032e..84ca66787350 100644 --- a/tests/semanticdb/expect/recursion.expect.scala +++ b/tests/semanticdb/expect/recursion.expect.scala @@ -3,12 +3,12 @@ package recursion object Nats/*<-recursion::Nats.*/ { sealed trait Nat/*<-recursion::Nats.Nat#*/ { - transparent inline def ++/*<-recursion::Nats.Nat#`++`().*/ : Succ/*->recursion::Nats.Succ#*/[this.type] = Succ/*->recursion::Nats.Succ.*//*->recursion::Nats.Succ.apply().*/(this) + transparent inline def ++/*<-recursion::Nats.Nat#`++`().*/ : Succ/*->recursion::Nats.Succ#*/[this.type] = Succ/*->recursion::Nats.Succ.*/(this) transparent inline def +/*<-recursion::Nats.Nat#`+`().*/(inline that/*<-recursion::Nats.Nat#`+`().(that)*/: Nat/*->recursion::Nats.Nat#*/): Nat/*->recursion::Nats.Nat#*/ = inline this match { case Zero/*->recursion::Nats.Zero.*/ => that/*->recursion::Nats.Nat#`+`().(that)*/ - case Succ/*->recursion::Nats.Succ.*//*->recursion::Nats.Succ.unapply().*//*->local0*/(p/*<-local1*/) => p/*->local1*/ +/*->recursion::Nats.Nat#`+`().*/ that/*->recursion::Nats.Nat#`+`().(that)*/.++/*->recursion::Nats.Nat#`++`().*/ + case Succ/*->recursion::Nats.Succ.*/(p/*<-local1*/) => p/*->local1*/ +/*->recursion::Nats.Nat#`+`().*/ that/*->recursion::Nats.Nat#`+`().(that)*/.++/*->recursion::Nats.Nat#`++`().*/ } } @@ -18,8 +18,8 @@ object Nats/*<-recursion::Nats.*/ { transparent inline def toIntg/*<-recursion::Nats.toIntg().*/(inline n/*<-recursion::Nats.toIntg().(n)*/: Nat/*->recursion::Nats.Nat#*/): Int/*->scala::Int#*/ = inline n/*->recursion::Nats.toIntg().(n)*/ match { case Zero/*->recursion::Nats.Zero.*/ => 0 - case Succ/*->recursion::Nats.Succ.*//*->recursion::Nats.Succ.unapply().*//*->local2*/(p/*<-local3*/) => toIntg/*->recursion::Nats.toIntg().*/(p/*->local3*/) +/*->scala::Int#`+`(+4).*/ 1 + case Succ/*->recursion::Nats.Succ.*/(p/*<-local3*/) => toIntg/*->recursion::Nats.toIntg().*/(p/*->local3*/) +/*->scala::Int#`+`(+4).*/ 1 } - val j31/*<-recursion::Nats.j31.*/ = toIntg/*->recursion::Nats.toIntg().*/(Zero/*->recursion::Nats.Zero.*/.++.++.++/*<-local4*//*->recursion::Nats.Zero.*//*->recursion::Nats.Nat#`++`().*/ + /*<-local5*//*->recursion::Nats.Nat#`++`().*/Zer/*<-local6*//*->recursion::Nats.Nat#`++`().*//*->recursion::Nats.Nat#`+`().*/o/*->recursion::Nats.Zero.*/.++/*->recursion::Nats.Nat#`++`().*/) + val j31/*<-recursion::Nats.j31.*/ = toIntg/*->recursion::Nats.toIntg().*/(Zero/*->recursion::Nats.Zero.*/.++/*->recursion::Nats.Nat#`++`().*/.++/*->recursion::Nats.Nat#`++`().*/.++/*->recursion::Nats.Nat#`++`().*/ +/*->recursion::Nats.Nat#`+`().*/ Zero/*->recursion::Nats.Zero.*/.++/*->recursion::Nats.Nat#`++`().*/) } diff --git a/tests/semanticdb/expect/semanticdb-Flags.expect.scala b/tests/semanticdb/expect/semanticdb-Flags.expect.scala index 7166a5da9859..99a7cbdddfb6 100644 --- a/tests/semanticdb/expect/semanticdb-Flags.expect.scala +++ b/tests/semanticdb/expect/semanticdb-Flags.expect.scala @@ -21,7 +21,7 @@ package object p/*<-flags::p::package.*/ { 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.`???`().*/ } + val List/*->scala::package.List.*/(xs1/*<-flags::p::package.xs1.*/) = ???/*->scala::Predef.`???`().*/ + ???/*->scala::Predef.`???`().*/ match { case List/*->scala::package.List.*/(xs2/*<-local0*/) => ???/*->scala::Predef.`???`().*/ } ???/*->scala::Predef.`???`().*/ match { case _: List/*->scala::package.List#*/[t/*<-local1*/] => ???/*->scala::Predef.`???`().*/ } } diff --git a/tests/semanticdb/expect/semanticdb-Types.expect.scala b/tests/semanticdb/expect/semanticdb-Types.expect.scala index 122579d42a9e..b39d7aad59af 100644 --- a/tests/semanticdb/expect/semanticdb-Types.expect.scala +++ b/tests/semanticdb/expect/semanticdb-Types.expect.scala @@ -62,9 +62,9 @@ object Test/*<-types::Test.*/ { 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 compoundType4/*<-types::Test.C#compoundType4.*/ = new { def k/*<-local2*/: 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 compoundType6/*<-types::Test.C#compoundType6.*/ = new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ { def k/*<-local7*/: 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.`???`().*/ @@ -74,7 +74,7 @@ object Test/*<-types::Test.*/ { 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] + typeLambda1/*->types::Test.C#typeLambda1().*/[({ type L/*<-local11*/[T/*<-local10*/] = List/*->scala::package.List#*/[T/*->local10*/] })#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 } diff --git a/tests/semanticdb/expect/semanticdb-extract.expect.scala b/tests/semanticdb/expect/semanticdb-extract.expect.scala index 02bd562a718b..a601b65218a9 100644 --- a/tests/semanticdb/expect/semanticdb-extract.expect.scala +++ b/tests/semanticdb/expect/semanticdb-extract.expect.scala @@ -9,7 +9,7 @@ object AnObject/*<-_empty_::AnObject.*/ { "".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.*/(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) diff --git a/tests/semanticdb/expect/toplevel.expect.scala b/tests/semanticdb/expect/toplevel.expect.scala index dfb0cc5de508..67164c326def 100644 --- a/tests/semanticdb/expect/toplevel.expect.scala +++ b/tests/semanticdb/expect/toplevel.expect.scala @@ -3,5 +3,5 @@ extension (x/*<-_empty_::toplevel$package.combine().(x)*/: Int/*->scala::Int#*/) 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" -/*<-_empty_::MyProgram#*//*->_empty_::toplevel$package.MyProgram().*//*->scala::util::CommandLineParser.parseArgument().*//*->_empty_::MyProgram#main().(args)*//*->scala::util::CommandLineParser.FromString.given_FromString_Int.*//*->scala::util::CommandLineParser.showError().*//*->local0*/@main/*->scala::main#*/ def MyProgram/*<-_empty_::toplevel$package.MyProgram().*/(times/*<-_empty_::toplevel$package.MyProgram().(times)*/: Int/*->scala::Int#*/): Unit/*->scala::Unit#*/ = (/*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ times/*->_empty_::toplevel$package.MyProgram().(times)*/) foreach/*->scala::collection::immutable::Range#foreach().*/ (_ => println/*->scala::Predef.println(+1).*/("hello")) -def fooRef/*<-_empty_::toplevel$package.fooRef().*/ = toplevel$package/*->_empty_::toplevel$package.*/.foo/*->_empty_::toplevel$package.foo().*/ +@main/*->scala::main#*/ def MyProgram/*<-_empty_::toplevel$package.MyProgram().*/(times/*<-_empty_::toplevel$package.MyProgram().(times)*/: Int/*->scala::Int#*/): Unit/*->scala::Unit#*/ = (1 to/*->scala::runtime::RichInt#to().*/ times/*->_empty_::toplevel$package.MyProgram().(times)*/) foreach/*->scala::collection::immutable::Range#foreach().*/ (_ => println/*->scala::Predef.println(+1).*/("hello")) +def fooRef/*<-_empty_::toplevel$package.fooRef().*/ = toplevel$package.foo/*->_empty_::toplevel$package.foo().*/ diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index ff519d6b832d..7c431ae29972 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -7,23 +7,22 @@ Uri => Access.scala Text => empty Language => Scala Symbols => 9 entries -Occurrences => 19 entries +Occurrences => 18 entries Symbols: -example/Access# => class Access -example/Access#``(). => primary ctor -example/Access#m1(). => private[this] method m1 -example/Access#m2(). => private[this] method m2 -example/Access#m3(). => private[example/Access#] method m3 -example/Access#m4(). => protected method m4 -example/Access#m5(). => protected[this] method m5 -example/Access#m6(). => protected[example/] method m6 -example/Access#m7(). => method m7 +example/Access# => class Access extends Object { self: Access => +8 decls } +example/Access#``(). => primary ctor (): Access +example/Access#m1(). => private[this] method m1 => Nothing +example/Access#m2(). => private[this] method m2 => Nothing +example/Access#m3(). => private[example/Access#] method m3 => Nothing +example/Access#m4(). => protected method m4 => Nothing +example/Access#m5(). => protected[this] method m5 => Nothing +example/Access#m6(). => protected[example/] method m6 => Nothing +example/Access#m7(). => method m7 => Nothing 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(). @@ -49,44 +48,56 @@ Schema => SemanticDB v4 Uri => Advanced.scala Text => empty Language => Scala -Symbols => 34 entries -Occurrences => 90 entries +Symbols => 46 entries +Occurrences => 101 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 +advanced/C# => class C [typeparam T ] extends Object { self: C[T] => +3 decls } +advanced/C#[T] => typeparam T +advanced/C#``(). => primary ctor [typeparam T ](): C[T] +advanced/C#t(). => method t => T +advanced/HKClass# => class HKClass [typeparam F [typeparam T ] <: ] extends Object { self: HKClass[F] => +3 decls } +advanced/HKClass#[F] => typeparam F [typeparam T ] <: +advanced/HKClass#[F][T] => typeparam T +advanced/HKClass#``(). => primary ctor [typeparam F [typeparam T ] <: ](): HKClass[F] +advanced/HKClass#foo(). => method foo [typeparam T , typeparam U ](param x: F[T, U]): String +advanced/HKClass#foo().(x) => param x: F[T, U] +advanced/HKClass#foo().[T] => typeparam T +advanced/HKClass#foo().[U] => typeparam U +advanced/Structural# => class Structural extends Object { self: Structural => +5 decls } +advanced/Structural#``(). => primary ctor (): Structural +advanced/Structural#s1(). => method s1 => Object { abstract val method x Int } +advanced/Structural#s2(). => method s2 => Object { abstract val method x Int } +advanced/Structural#s3(). => method s3 => Object { abstract method m (param x: Int): Int } +advanced/Structural#s4(). => method s4 (param a: Int): Object { abstract val method x Int } +advanced/Structural#s4().(a) => param a: Int +advanced/Test. => final object Test extends Object { self: Test.type => +11 decls } +advanced/Test.e. => val method e Wildcards +advanced/Test.e1. => val method e1 List[_] forSome { type _ } +advanced/Test.e1x. => val method e1x Any +advanced/Test.s. => val method s Structural +advanced/Test.s1. => val method s1 Object { abstract val method x Int } +advanced/Test.s1x. => val method s1x Int +advanced/Test.s2. => val method s2 Object { abstract val method x Int } +advanced/Test.s2x. => val method s2x Int +advanced/Test.s3. => val method s3 Object { abstract method m (param x: Int): Int } +advanced/Test.s3x. => val method s3x Int +advanced/Wildcards# => class Wildcards extends Object { self: Wildcards => +3 decls } +advanced/Wildcards#``(). => primary ctor (): Wildcards +advanced/Wildcards#e1(). => method e1 => List[_] forSome { type _ } +advanced/Wildcards#e2(). => method e2 => List[_] forSome { type _ <: Int } +local0 => abstract val method x Int +local1 => abstract val method x Int +local2 => val method x Int +local3 => final class $anon extends Object { self: $anon => +2 decls } +local5 => param x: Int +local6 => abstract method m (param x: Int): Int +local7 => param x: Int +local8 => method m (param x: Int): Int +local9 => final class $anon extends Object { self: $anon => +2 decls } +local11 => abstract val method x Int +local12 => val local e3: List[local13] +local14 => val local e3x: local13 Occurrences: [0:8..0:16): advanced <- advanced/ @@ -101,13 +112,11 @@ Occurrences: [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:7): <- 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# @@ -115,70 +124,83 @@ Occurrences: [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:37..13:38): x <- local2 [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:16..14:17): m <- local6 [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:45..14:46): m <- local8 +[14:47..14:48): x <- local7 [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/reflect/Selectable#selectDynamic(). -[25:6..25:8): s2 <- advanced/Test.s2. +[15:6..15:8): s4 <- advanced/Structural#s4(). +[15:9..15:10): a <- advanced/Structural#s4().(a) +[15:12..15:15): Int -> scala/Int# +[15:24..15:25): x <- local11 +[15:27..15:30): Int -> scala/Int# +[15:35..15:38): ??? -> scala/Predef.`???`(). +[18:6..18:15): Wildcards <- advanced/Wildcards# +[19:6..19:8): e1 <- advanced/Wildcards#e1(). +[19:10..19:14): List -> scala/package.List# +[19:20..19:23): ??? -> scala/Predef.`???`(). +[20:6..20:8): e2 <- advanced/Wildcards#e2(). +[20:10..20:14): List -> scala/package.List# +[20:20..20:23): Int -> scala/Int# +[20:27..20:30): ??? -> scala/Predef.`???`(). +[23:7..23:11): Test <- advanced/Test. +[24:6..24:7): s <- advanced/Test.s. +[24:14..24:24): Structural -> advanced/Structural# +[25:6..25:8): s1 <- advanced/Test.s1. [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(). +[25:13..25:15): s1 -> advanced/Structural#s1(). +[26:6..26:9): s1x <- advanced/Test.s1x. [26:12..26:13): s -> advanced/Test.s. -[26:14..26:16): s2 -> advanced/Structural#s2(). -[26:16..26:16): -> scala/reflect/Selectable#selectDynamic(). -[27:6..27:8): s3 <- advanced/Test.s3. +[26:14..26:16): s1 -> advanced/Structural#s1(). +[27:6..27:8): s2 <- advanced/Test.s2. [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(). +[27:13..27:15): s2 -> advanced/Structural#s2(). +[28:6..28:9): s2x <- advanced/Test.s2x. [28:12..28:13): s -> advanced/Test.s. -[28:14..28:16): s3 -> advanced/Structural#s3(). -[28:16..28:16): -> scala/reflect/Selectable#applyDynamic(). -[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(). +[28:14..28:16): s2 -> advanced/Structural#s2(). +[29:6..29:8): s3 <- advanced/Test.s3. +[29:11..29:12): s -> advanced/Test.s. +[29:13..29:15): s3 -> advanced/Structural#s3(). +[30:6..30:9): s3x <- advanced/Test.s3x. +[30:12..30:13): s -> advanced/Test.s. +[30:14..30:16): s3 -> advanced/Structural#s3(). +[30:19..30:22): ??? -> scala/Predef.`???`(). +[32:6..32:7): e <- advanced/Test.e. +[32:14..32:23): Wildcards -> advanced/Wildcards# +[33:6..33:8): e1 <- advanced/Test.e1. +[33:11..33:12): e -> advanced/Test.e. +[33:13..33:15): e1 -> advanced/Wildcards#e1(). +[34:6..34:9): e1x <- advanced/Test.e1x. +[34:12..34:13): e -> advanced/Test.e. +[34:14..34:16): e1 -> advanced/Wildcards#e1(). +[34:17..34:21): head -> scala/collection/IterableOps#head(). +[37:5..37:8): ??? -> scala/Predef.`???`(). +[37:11..37:14): Any -> scala/Any# +[38:11..38:13): e3 <- local12 +[38:15..38:19): List -> scala/package.List# +[39:12..39:15): e3x <- local14 +[39:18..39:20): e3 -> local12 +[39:21..39:25): head -> scala/collection/IterableOps#head(). +[47:6..47:13): HKClass <- advanced/HKClass# +[47:14..47:15): F <- advanced/HKClass#[F] +[48:6..48:9): foo <- advanced/HKClass#foo(). +[48:10..48:11): T <- advanced/HKClass#foo().[T] +[48:12..48:13): U <- advanced/HKClass#foo().[U] +[48:15..48:16): x <- advanced/HKClass#foo().(x) +[48:18..48:19): F -> advanced/HKClass#[F] +[48:20..48:21): T -> advanced/HKClass#foo().[T] +[48:23..48:24): U -> advanced/HKClass#foo().[U] +[48:28..48:34): String -> scala/Predef.String# +[48:37..48:38): x -> advanced/HKClass#foo().(x) +[48:39..48:47): toString -> scala/Tuple2#toString(). expect/Annotations.scala ------------------------ @@ -189,31 +211,31 @@ Uri => Annotations.scala Text => empty Language => Scala Symbols => 22 entries -Occurrences => 52 entries +Occurrences => 48 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. => private[this] val method x -annot/B# => class B -annot/B#``(). => primary ctor -annot/B#``().(x) => param x -annot/B#``(+1). => ctor -annot/B#x. => private[this] val method x -annot/M. => final object M -annot/M.m(). => macro m -annot/M.m().[TT] => typeparam TT -annot/T# => trait T -annot/T#``(). => primary ctor -local0 => selfparam self -local1 => val local local +annot/Alias. => final object Alias extends Object { self: Alias.type => +2 decls } +annot/Alias.A# => type A = ClassAnnotation @param +annot/Annotations# => class Annotations [typeparam T ] extends Object { self: AnyRef & Annotations[T] => +6 decls } +annot/Annotations#S# => type S +annot/Annotations#[T] => typeparam T +annot/Annotations#``(). => primary ctor [typeparam T ](param x: T): Annotations[T] +annot/Annotations#``().(x) => param x: T +annot/Annotations#field. => val method field Int +annot/Annotations#method(). => method method => Int +annot/Annotations#x. => private[this] val method x T +annot/B# => class B extends Object { self: B => +3 decls } +annot/B#``(). => primary ctor (param x: Int): B +annot/B#``().(x) => param x: Int +annot/B#``(+1). => ctor (): B +annot/B#x. => private[this] val method x Int +annot/M. => final object M extends Object { self: M.type => +1 decls } +annot/M.m(). => macro m [typeparam TT ]: Int +annot/M.m().[TT] => typeparam TT +annot/T# => trait T extends Object { self: T => +1 decls } +annot/T#``(). => primary ctor (): T +local0 => selfparam self: AnyRef +local1 => val local local: Int Occurrences: [0:8..0:13): annot <- annot/ @@ -229,7 +251,6 @@ Occurrences: [4:35..4:41): macros -> scala/language.experimental.macros. [6:1..6:16): ClassAnnotation -> com/javacp/annot/ClassAnnotation# [7:6..7:17): Annotations <- annot/Annotations# -[7:17..7:17): <- 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# @@ -247,13 +268,11 @@ Occurrences: [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:7): <- 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:10): <- 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# @@ -261,7 +280,6 @@ Occurrences: [29:8..29:10): TT <- annot/M.m().[TT] [29:13..29:16): Int -> scala/Int# [29:25..29:28): ??? -> 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. @@ -277,23 +295,24 @@ Schema => SemanticDB v4 Uri => Anonymous.scala Text => empty Language => Scala -Symbols => 13 entries -Occurrences => 32 entries +Symbols => 14 entries +Occurrences => 30 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 +example/Anonymous# => class Anonymous extends Object { self: Anonymous & Anonymous => +6 decls } +example/Anonymous#Foo# => trait Foo extends Object { self: Foo => +1 decls } +example/Anonymous#Foo#``(). => primary ctor (): Foo +example/Anonymous#``(). => primary ctor (): Anonymous +example/Anonymous#foo. => val method foo Foo +example/Anonymous#locally(). => method locally [typeparam A ](param x: A): A +example/Anonymous#locally().(x) => param x: A +example/Anonymous#locally().[A] => typeparam A +example/Anonymous#m1(). => method m1 [typeparam T [type _ ]]: Nothing +example/Anonymous#m1().[T] => typeparam T [type _ ] +example/Anonymous#m1().[T][_] => type _ +example/Anonymous#m2(). => method m2 => Map[_, List[_] forSome { type _ }] forSome { type _ } +local0 => val local x: Function1[Int, Int] +local1 => final class $anon extends Object with Foo { self: $anon => +1 decls } Occurrences: [0:8..0:15): example <- example/ @@ -301,7 +320,6 @@ Occurrences: [1:13..1:21): language -> scala/language. [1:22..1:33): higherKinds -> scala/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] @@ -324,7 +342,6 @@ Occurrences: [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# @@ -338,18 +355,17 @@ Uri => AnonymousGiven.scala Text => empty Language => Scala Symbols => 5 entries -Occurrences => 5 entries +Occurrences => 4 entries Symbols: -angiven/AnonymousGiven$package. => final package object angiven -angiven/AnonymousGiven$package.bar(). => method bar -angiven/AnonymousGiven$package.bar().(x$1) => given param x$1 -angiven/Foo# => trait Foo -angiven/Foo#``(). => primary ctor +angiven/AnonymousGiven$package. => final package object angiven extends Object { self: angiven.type => +2 decls } +angiven/AnonymousGiven$package.bar(). => method bar (implicit given param x$1: Foo): Int +angiven/AnonymousGiven$package.bar().(x$1) => implicit given param x$1: Foo +angiven/Foo# => trait Foo extends Object { self: Foo => +1 decls } +angiven/Foo#``(). => primary ctor (): Foo Occurrences: [0:8..0:15): angiven <- angiven/ -[2:0..2:0): <- angiven/Foo#``(). [2:6..2:9): Foo <- angiven/Foo# [4:4..4:7): bar <- angiven/AnonymousGiven$package.bar(). [4:14..4:17): Foo -> angiven/Foo# @@ -363,118 +379,118 @@ Uri => Classes.scala Text => empty Language => Scala Symbols => 109 entries -Occurrences => 130 entries +Occurrences => 113 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.toString(). => method toString -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.toString(). => method toString -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. => private val method x -classes/C6. => final object C6 -classes/C6.apply(). => method apply -classes/C6.apply().(x) => param x -classes/C6.toString(). => method toString -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. => private[this] val method x -classes/C8# => class C8 -classes/C8#``(). => primary ctor -classes/C8#``().(x) => param x -classes/C8#x. => private[this] val method x -classes/C9# => class C9 -classes/C9#``(). => primary ctor -classes/C9#``().(x) => param x -classes/C9#x(). => private[this] var method x -classes/C10# => class C10 -classes/C10#``(). => primary ctor -classes/C10#``().(s) => param s -classes/C10#s. => private[this] val method s -classes/C11# => class C11 -classes/C11#``(). => primary ctor -classes/C11#foo(). => macro foo -classes/C11#foo(). => inline macro foo -classes/C12# => class C12 -classes/C12#Context# => class Context -classes/C12#Context#Expr# => type Expr -classes/C12#Context#Expr#[T] => typeparam T -classes/C12#Context#``(). => primary ctor -classes/C12#``(). => primary ctor -classes/C12#foo1(). => macro foo1 -classes/C12#foo1(). => method foo1 -classes/C12#foo1().(x) => param x -classes/C12#foo1().(x) => param x -classes/C12#foo1Impl(). => method foo1Impl -classes/C12#foo1Impl().(context) => param context -classes/C12#foo1Impl().(x) => param x -classes/C12#foo2(). => macro foo2 -classes/C12#foo2(). => method foo2 -classes/C12#foo2().(x) => param x -classes/C12#foo2().(x) => param x -classes/C12#foo2().(y) => param y -classes/C12#foo2().(y) => param y -classes/C12#foo2Impl(). => method foo2Impl -classes/C12#foo2Impl().(context) => param context -classes/C12#foo2Impl().(x) => param x -classes/C12#foo2Impl().(y) => param y -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. => private[this] 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 +classes/C1# => final class C1 extends AnyVal { self: C1 => +2 decls } +classes/C1#``(). => primary ctor (val param x1: Int): C1 +classes/C1#``().(x1) => val param x1: Int +classes/C1#x1. => val method x1 Int +classes/C1. => final object C1 extends Object { self: C1.type => +2 decls } +classes/C2# => final class C2 extends AnyVal { self: C2 => +2 decls } +classes/C2#``(). => primary ctor (val param x2: Int): C2 +classes/C2#``().(x2) => val param x2: Int +classes/C2#x2. => val method x2 Int +classes/C2. => final object C2 extends Object { self: C2.type => +2 decls } +classes/C3# => case class C3 extends Object with Product with Serializable { self: C3 => +5 decls } +classes/C3#_1(). => method _1 => Int +classes/C3#``(). => primary ctor (val param x: Int): C3 +classes/C3#``().(x) => val param x: Int +classes/C3#copy$default$1(). => method copy$default$1 => Int @uncheckedVariance +classes/C3#copy(). => method copy (param x: Int): C3 +classes/C3#copy().(x) => param x: Int +classes/C3#x. => val method x Int +classes/C3. => final object C3 extends Object { self: C3.type => +4 decls } +classes/C3.apply(). => method apply (param x: Int): C3 +classes/C3.apply().(x) => param x: Int +classes/C3.toString(). => method toString => String +classes/C3.unapply(). => method unapply (param x$1: C3): C3 +classes/C3.unapply().(x$1) => param x$1: C3 +classes/C4# => case class C4 extends Object with Product with Serializable { self: C4 => +5 decls } +classes/C4#_1(). => method _1 => Int +classes/C4#``(). => primary ctor (val param x: Int): C4 +classes/C4#``().(x) => val param x: Int +classes/C4#copy$default$1(). => method copy$default$1 => Int @uncheckedVariance +classes/C4#copy(). => method copy (param x: Int): C4 +classes/C4#copy().(x) => param x: Int +classes/C4#x. => val method x Int +classes/C4. => final object C4 extends Object { self: C4.type => +4 decls } +classes/C4.apply(). => method apply (param x: Int): C4 +classes/C4.apply().(x) => param x: Int +classes/C4.toString(). => method toString => String +classes/C4.unapply(). => method unapply (param x$1: C4): C4 +classes/C4.unapply().(x$1) => param x$1: C4 +classes/C6# => case class C6 extends Object with Product with Serializable { self: C6 => +5 decls } +classes/C6#_1(). => method _1 => Int +classes/C6#``(). => primary ctor (param x: Int): C6 +classes/C6#``().(x) => param x: Int +classes/C6#copy$default$1(). => method copy$default$1 => Int @uncheckedVariance +classes/C6#copy(). => method copy (param x: Int): C6 +classes/C6#copy().(x) => param x: Int +classes/C6#x. => private val method x Int +classes/C6. => final object C6 extends Object { self: C6.type => +4 decls } +classes/C6.apply(). => method apply (param x: Int): C6 +classes/C6.apply().(x) => param x: Int +classes/C6.toString(). => method toString => String +classes/C6.unapply(). => method unapply (param x$1: C6): C6 +classes/C6.unapply().(x$1) => param x$1: C6 +classes/C7# => class C7 extends Object { self: C7 => +2 decls } +classes/C7#``(). => primary ctor (param x: Int): C7 +classes/C7#``().(x) => param x: Int +classes/C7#x. => private[this] val method x Int +classes/C8# => class C8 extends Object { self: C8 => +2 decls } +classes/C8#``(). => primary ctor (param x: Int): C8 +classes/C8#``().(x) => param x: Int +classes/C8#x. => private[this] val method x Int +classes/C9# => class C9 extends Object { self: C9 => +2 decls } +classes/C9#``(). => primary ctor (param x: Int): C9 +classes/C9#``().(x) => param x: Int +classes/C9#x(). => private[this] var method x Int +classes/C10# => class C10 extends Object { self: C10 => +2 decls } +classes/C10#``(). => primary ctor (param s: => String): C10 +classes/C10#``().(s) => param s: => String +classes/C10#s. => private[this] val method s => String +classes/C11# => class C11 extends Object { self: C11 => +2 decls } +classes/C11#``(). => primary ctor (): C11 +classes/C11#foo(). => macro foo => Int +classes/C11#foo(). => inline macro foo => Int +classes/C12# => class C12 extends Object { self: C12 => +8 decls } +classes/C12#Context# => class Context extends Object { self: Context => +2 decls } +classes/C12#Context#Expr# => type Expr [typeparam T ] +classes/C12#Context#Expr#[T] => typeparam T +classes/C12#Context#``(). => primary ctor (): Context +classes/C12#``(). => primary ctor (): C12 +classes/C12#foo1(). => macro foo1 (param x: Int): Int +classes/C12#foo1(). => method foo1 (param x: Int): Int +classes/C12#foo1().(x) => param x: Int +classes/C12#foo1().(x) => param x: Int +classes/C12#foo1Impl(). => method foo1Impl (param context: Context)(param x: context.Expr[Int]): context.Expr[Int] +classes/C12#foo1Impl().(context) => param context: Context +classes/C12#foo1Impl().(x) => param x: context.Expr[Int] +classes/C12#foo2(). => macro foo2 (param x: Int, param y: String): Int +classes/C12#foo2(). => method foo2 (param x: Int, param y: String): Int +classes/C12#foo2().(x) => param x: Int +classes/C12#foo2().(x) => param x: Int +classes/C12#foo2().(y) => param y: String +classes/C12#foo2().(y) => param y: String +classes/C12#foo2Impl(). => method foo2Impl (param context: Context)(param x: context.Expr[Int], param y: context.Expr[String]): context.Expr[Int] +classes/C12#foo2Impl().(context) => param context: Context +classes/C12#foo2Impl().(x) => param x: context.Expr[Int] +classes/C12#foo2Impl().(y) => param y: context.Expr[String] +classes/M. => final object M extends Object { self: M.type => +3 decls } +classes/M.C5# => class C5 extends Object { self: C5 => +2 decls } +classes/M.C5#``(). => primary ctor (param x: Int): C5 +classes/M.C5#``().(x) => param x: Int +classes/M.C5#x. => private[this] val method x Int +classes/M.C5(). => final implicit method C5 (param x: Int): C5 +classes/M.C5().(x) => param x: Int +classes/N. => final object N extends Object { self: N.type => +3 decls } +classes/N.anonClass. => val method anonClass C7 +classes/N.anonFun. => val method anonFun List[Int] +local0 => val method local Nothing +local1 => final class $anon extends C7 { self: $anon => +2 decls } +local3 => param i: Int +local4 => val local local: Int Occurrences: [0:8..0:15): classes <- classes/ @@ -483,54 +499,41 @@ Occurrences: [1:22..1:34): experimental -> scala/language.experimental. [1:35..1:41): macros -> scala/language.experimental.macros. [2:6..2:8): C1 <- classes/C1# -[2:8..2:8): <- 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:8): <- 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:13): <- 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:13): <- 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:19): <- 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:13): <- 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:8): <- 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:8): <- 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:8): <- classes/C9#``(). [22:27..22:28): x <- classes/C9#x(). [22:30..22:33): Int -> scala/Int# [24:6..24:9): C10 <- classes/C10# -[24:9..24:9): <- classes/C10#``(). [24:10..24:11): s <- classes/C10#s. [24:16..24:22): String -> scala/Predef.String# [26:6..26:9): C11 <- classes/C11# -[27:2..27:2): <- classes/C11#``(). [27:6..27:9): foo <- classes/C11#foo(). [27:11..27:14): Int -> scala/Int# [27:23..27:26): ??? -> scala/Predef.`???`(). @@ -538,9 +541,7 @@ Occurrences: [28:18..28:21): Int -> scala/Int# [28:24..28:27): ??? -> scala/Predef.`???`(). [31:6..31:9): C12 <- classes/C12# -[33:2..33:2): <- classes/C12#``(). [33:8..33:15): Context <- classes/C12#Context# -[34:4..34:4): <- classes/C12#Context#``(). [34:9..34:13): Expr <- classes/C12#Context#Expr# [34:14..34:15): T <- classes/C12#Context#Expr#[T] [36:6..36:10): foo1 <- classes/C12#foo1(). @@ -596,16 +597,14 @@ Occurrences: [47:7..47:8): N <- classes/N. [48:6..48:15): anonClass <- classes/N.anonClass. [48:22..48:24): C7 -> classes/C7# -[48:24..48:24): -> classes/C7#``(). -[49:8..49:13): local <- local1 +[49:8..49:13): local <- local0 [49:16..49:19): ??? -> scala/Predef.`???`(). [51:6..51:13): anonFun <- classes/N.anonFun. [51:16..51:20): List -> scala/package.List. -[51:20..51:20): -> scala/collection/IterableFactory#apply(). [51:24..51:27): map -> scala/collection/immutable/List#map(). -[51:30..51:31): i <- local2 -[52:8..52:13): local <- local3 -[53:4..53:9): local -> local3 +[51:30..51:31): i <- local3 +[52:8..52:13): local <- local4 +[53:4..53:9): local -> local4 [53:10..53:11): + -> scala/Int#`+`(+4). expect/Empty.scala @@ -617,24 +616,22 @@ Uri => Empty.scala Text => empty Language => Scala Symbols => 6 entries -Occurrences => 10 entries +Occurrences => 8 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 +_empty_/A# => class A extends Object { self: A => +2 decls } +_empty_/A#``(). => primary ctor (): A +_empty_/A#b(). => method b => B +_empty_/B# => class B extends Object { self: B => +2 decls } +_empty_/B#``(). => primary ctor (): B +_empty_/B#a(). => method a => 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.`???`(). @@ -651,7 +648,7 @@ Symbols => 1 entries Occurrences => 2 entries Symbols: -example/EmptyObject. => final object EmptyObject +example/EmptyObject. => final object EmptyObject extends Object { self: EmptyObject.type => +1 decls } Occurrences: [0:8..0:15): example <- example/ @@ -666,42 +663,40 @@ Uri => EndMarkers.scala Text => empty Language => Scala Symbols => 24 entries -Occurrences => 42 entries +Occurrences => 37 entries Symbols: -endmarkers/Container# => class Container -endmarkers/Container#``(). => primary ctor -endmarkers/Container#`baz_=`(). => var method baz_= -endmarkers/Container#`baz_=`().(x$1) => param x$1 -endmarkers/Container#bar. => val method bar -endmarkers/Container#baz(). => var method baz -endmarkers/Container#foo(). => method foo -endmarkers/EndMarkers$package. => final package object endmarkers -endmarkers/EndMarkers$package.`topLevelVar_=`(). => var method topLevelVar_= -endmarkers/EndMarkers$package.`topLevelVar_=`().(x$1) => param x$1 -endmarkers/EndMarkers$package.topLevelMethod(). => method topLevelMethod -endmarkers/EndMarkers$package.topLevelVal. => val method topLevelVal -endmarkers/EndMarkers$package.topLevelVar(). => var method topLevelVar -endmarkers/EndMarkers$package.topLevelWithLocals(). => method topLevelWithLocals -endmarkers/MultiCtor# => class MultiCtor -endmarkers/MultiCtor#``(). => primary ctor -endmarkers/MultiCtor#``().(i) => val param i -endmarkers/MultiCtor#``(+1). => ctor -endmarkers/MultiCtor#i. => val method i -endmarkers/TestObj. => final object TestObj -endmarkers/TestObj.foo(). => method foo -local0 => val local localVal -local1 => var local localVar -local2 => local localDef +endmarkers/Container# => class Container extends Object { self: Container => +5 decls } +endmarkers/Container#``(). => primary ctor (): Container +endmarkers/Container#`baz_=`(). => var method baz_= (param x$1: Int): Unit +endmarkers/Container#`baz_=`().(x$1) => param x$1: Int +endmarkers/Container#bar. => val method bar Tuple3[Int, Int, Int] +endmarkers/Container#baz(). => var method baz Int +endmarkers/Container#foo(). => method foo => Tuple3[Int, Int, Int] +endmarkers/EndMarkers$package. => final package object endmarkers extends Object { self: endmarkers.type => +6 decls } +endmarkers/EndMarkers$package.`topLevelVar_=`(). => var method topLevelVar_= (param x$1: String): Unit +endmarkers/EndMarkers$package.`topLevelVar_=`().(x$1) => param x$1: String +endmarkers/EndMarkers$package.topLevelMethod(). => method topLevelMethod => String +endmarkers/EndMarkers$package.topLevelVal. => val method topLevelVal Int +endmarkers/EndMarkers$package.topLevelVar(). => var method topLevelVar String +endmarkers/EndMarkers$package.topLevelWithLocals(). => method topLevelWithLocals => Unit +endmarkers/MultiCtor# => class MultiCtor extends Object { self: MultiCtor => +3 decls } +endmarkers/MultiCtor#``(). => primary ctor (val param i: Int): MultiCtor +endmarkers/MultiCtor#``().(i) => val param i: Int +endmarkers/MultiCtor#``(+1). => ctor (): MultiCtor +endmarkers/MultiCtor#i. => val method i Int +endmarkers/TestObj. => final object TestObj extends Object { self: TestObj.type => +2 decls } +endmarkers/TestObj.foo(). => method foo => Int +local0 => val local localVal: Int +local1 => var local localVar: Int +local2 => local localDef: => Int Occurrences: [0:8..0:18): endmarkers <- endmarkers/ [2:8..2:17): MultiCtor <- endmarkers/MultiCtor# -[2:17..2:17): <- endmarkers/MultiCtor#``(). [2:22..2:23): i <- endmarkers/MultiCtor#i. [2:25..2:28): Int -> scala/Int# [3:8..3:12): <- endmarkers/MultiCtor#``(+1). -[4:11..4:11): -> endmarkers/MultiCtor#``(). [5:8..5:12): this -> endmarkers/MultiCtor#``(+1). [6:6..6:15): MultiCtor -> endmarkers/MultiCtor# [8:6..8:20): topLevelMethod <- endmarkers/EndMarkers$package.topLevelMethod(). @@ -714,12 +709,9 @@ Occurrences: [16:19..16:25): String -> scala/Predef.String# [18:6..18:17): topLevelVar -> endmarkers/EndMarkers$package.topLevelVar(). [20:8..20:17): Container <- endmarkers/Container# -[22:4..22:4): <- endmarkers/Container#``(). [22:8..22:11): foo <- endmarkers/Container#foo(). -[23:7..23:7): -> scala/Tuple3.apply(). [24:8..24:11): foo -> endmarkers/Container#foo(). [26:8..26:11): bar <- endmarkers/Container#bar. -[27:7..27:7): -> scala/Tuple3.apply(). [28:8..28:11): bar -> endmarkers/Container#bar. [30:8..30:11): baz <- endmarkers/Container#baz(). [32:8..32:11): baz -> endmarkers/Container#baz(). @@ -750,8 +742,8 @@ Symbols => 2 entries Occurrences => 5 entries Symbols: -endmarkers2/package. => final package object endmarkers2 -endmarkers2/package.Foo# => type Foo +endmarkers2/package. => final package object endmarkers2 extends Object { self: endmarkers2.type => +2 decls } +endmarkers2/package.Foo# => type Foo = Unit Occurrences: [0:15..0:26): endmarkers2 <- endmarkers2/package. @@ -769,48 +761,43 @@ Uri => EnumVal.scala Text => empty Language => Scala Symbols => 16 entries -Occurrences => 21 entries +Occurrences => 16 entries Symbols: -enumVal/A# => trait A -enumVal/A#``(). => primary ctor -enumVal/Color# => abstract sealed enum class Color -enumVal/Color#``(). => primary ctor -enumVal/Color#``().(rgb) => val param rgb -enumVal/Color#rgb. => val method rgb -enumVal/Color. => final object Color -enumVal/Color.$values. => private[this] val method $values -enumVal/Color.Blue. => case val static enum method Blue -enumVal/Color.Green. => case val static enum method Green -enumVal/Color.Red. => case val static enum method Red -enumVal/Color.fromOrdinal(). => method fromOrdinal -enumVal/Color.fromOrdinal().(ordinal) => param ordinal -enumVal/Color.valueOf(). => method valueOf -enumVal/Color.valueOf().($name) => param $name -enumVal/Color.values(). => method values +enumVal/A# => trait A extends Object { self: A => +1 decls } +enumVal/A#``(). => primary ctor (): A +enumVal/Color# => abstract sealed enum class Color extends Object with Enum { self: Color => +2 decls } +enumVal/Color#``(). => primary ctor (val param rgb: Int): Color +enumVal/Color#``().(rgb) => val param rgb: Int +enumVal/Color#rgb. => val method rgb Int +enumVal/Color. => final object Color extends Object { self: Color.type => +8 decls } +enumVal/Color.$values. => private[this] val method $values Array[Color] +enumVal/Color.Blue. => case val static enum method Blue Color +enumVal/Color.Green. => case val static enum method Green Color & A +enumVal/Color.Red. => case val static enum method Red Color +enumVal/Color.fromOrdinal(). => method fromOrdinal (param ordinal: Int): Color +enumVal/Color.fromOrdinal().(ordinal) => param ordinal: Int +enumVal/Color.valueOf(). => method valueOf (param $name: String): Color +enumVal/Color.valueOf().($name) => param $name: String +enumVal/Color.values(). => method values => Array[Color] Occurrences: [0:8..0:15): enumVal <- enumVal/ [2:7..2:12): scala -> scala/ [2:13..2:20): runtime -> scala/runtime/ [2:21..2:30): EnumValue -> scala/runtime/EnumValue. -[5:0..5:0): <- enumVal/A#``(). [5:6..5:7): A <- enumVal/A# [7:5..7:10): Color <- enumVal/Color# -[7:10..7:10): <- enumVal/Color#``(). [7:15..7:18): rgb <- enumVal/Color#rgb. [7:20..7:23): Int -> scala/Int# [8:7..8:10): Red <- enumVal/Color.Red. [8:21..8:26): Color -> enumVal/Color# -[8:26..8:26): -> enumVal/Color#``(). [8:42..8:51): EnumValue -> scala/runtime/EnumValue# [9:7..9:12): Green <- enumVal/Color.Green. [9:21..9:26): Color -> enumVal/Color# -[9:26..9:26): -> enumVal/Color#``(). [9:42..9:43): A -> enumVal/A# [10:7..10:11): Blue <- enumVal/Color.Blue. [10:21..10:26): Color -> enumVal/Color# -[10:26..10:26): -> enumVal/Color#``(). expect/Enums.scala ------------------ @@ -821,210 +808,206 @@ Uri => Enums.scala Text => empty Language => Scala Symbols => 181 entries -Occurrences => 184 entries +Occurrences => 148 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. => private[this] val method value -_empty_/Enums.Coin. => final object Coin -_empty_/Enums.Coin.$values. => private[this] 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.fromOrdinal(). => method fromOrdinal -_empty_/Enums.Coin.fromOrdinal().(ordinal) => param ordinal -_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(). => private[this] method $new -_empty_/Enums.Colour.$new().($name) => param $name -_empty_/Enums.Colour.$new().(_$ordinal) => param _$ordinal -_empty_/Enums.Colour.$values. => private[this] 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.fromOrdinal(). => method fromOrdinal -_empty_/Enums.Colour.fromOrdinal().(ordinal) => param ordinal -_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(). => private[this] method $new -_empty_/Enums.Directions.$new().($name) => param $name -_empty_/Enums.Directions.$new().(_$ordinal) => param _$ordinal -_empty_/Enums.Directions.$values. => private[this] 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.fromOrdinal(). => method fromOrdinal -_empty_/Enums.Directions.fromOrdinal().(ordinal) => param ordinal -_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#[A] => covariant 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#ordinal(). => method ordinal -_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.toString(). => method toString -_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.Maybe.fromOrdinal(). => method fromOrdinal -_empty_/Enums.Maybe.fromOrdinal().(ordinal) => param ordinal -_empty_/Enums.Planet# => abstract sealed enum class Planet -_empty_/Enums.Planet#G. => private[this] 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. => private[this] val method mass -_empty_/Enums.Planet#radius. => private[this] 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. => private[this] 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.fromOrdinal(). => method fromOrdinal -_empty_/Enums.Planet.fromOrdinal().(ordinal) => param ordinal -_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(). => private[this] method $new -_empty_/Enums.Suits.$new().($name) => param $name -_empty_/Enums.Suits.$new().(_$ordinal) => param _$ordinal -_empty_/Enums.Suits.$values. => private[this] 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$CanEqual. => lazy val given method derived$CanEqual -_empty_/Enums.Suits.fromOrdinal(). => method fromOrdinal -_empty_/Enums.Suits.fromOrdinal().(ordinal) => param ordinal -_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.$values. => private[this] val method $values -_empty_/Enums.Tag.BooleanTag. => case val static enum method BooleanTag -_empty_/Enums.Tag.IntTag. => case val static enum method IntTag -_empty_/Enums.Tag.fromOrdinal(). => method fromOrdinal -_empty_/Enums.Tag.fromOrdinal().(ordinal) => param ordinal -_empty_/Enums.Tag.valueOf(). => method valueOf -_empty_/Enums.Tag.valueOf().($name) => param $name -_empty_/Enums.Tag.values(). => method values -_empty_/Enums.WeekDays# => abstract sealed enum class WeekDays -_empty_/Enums.WeekDays#``(). => primary ctor -_empty_/Enums.WeekDays. => final object WeekDays -_empty_/Enums.WeekDays.$new(). => private[this] method $new -_empty_/Enums.WeekDays.$new().($name) => param $name -_empty_/Enums.WeekDays.$new().(_$ordinal) => param _$ordinal -_empty_/Enums.WeekDays.$values. => private[this] 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.fromOrdinal(). => method fromOrdinal -_empty_/Enums.WeekDays.fromOrdinal().(ordinal) => param ordinal -_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#[C] => typeparam C -_empty_/Enums.`<:<`.Refl#``(). => primary ctor -_empty_/Enums.`<:<`.Refl#copy(). => method copy -_empty_/Enums.`<:<`.Refl#copy().[C] => typeparam C -_empty_/Enums.`<:<`.Refl#ordinal(). => method ordinal -_empty_/Enums.`<:<`.Refl. => final object Refl -_empty_/Enums.`<:<`.Refl.apply(). => method apply -_empty_/Enums.`<:<`.Refl.apply().[C] => typeparam C -_empty_/Enums.`<:<`.Refl.toString(). => method toString -_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_T`(). => final given method given_<:<_T_T -_empty_/Enums.`<:<`.`given_<:<_T_T`().[T] => typeparam T -_empty_/Enums.`<:<`.fromOrdinal(). => method fromOrdinal -_empty_/Enums.`<:<`.fromOrdinal().(ordinal) => param ordinal -_empty_/Enums.some1. => val method some1 -_empty_/Enums.unwrap(). => method unwrap -_empty_/Enums.unwrap().(ev) => given param ev -_empty_/Enums.unwrap().(opt) => param opt -_empty_/Enums.unwrap().[A] => typeparam A -_empty_/Enums.unwrap().[B] => typeparam B -local0 => param x +_empty_/Enums. => final object Enums extends Object { self: Enums.type => +30 decls } +_empty_/Enums.Coin# => abstract sealed enum class Coin extends Object with Enum { self: Coin => +2 decls } +_empty_/Enums.Coin#``(). => primary ctor (param value: Int): Coin +_empty_/Enums.Coin#``().(value) => param value: Int +_empty_/Enums.Coin#value. => private[this] val method value Int +_empty_/Enums.Coin. => final object Coin extends Object { self: Coin.type => +10 decls } +_empty_/Enums.Coin.$values. => private[this] val method $values Array[Coin] +_empty_/Enums.Coin.Dime. => case val static enum method Dime Coin +_empty_/Enums.Coin.Dollar. => case val static enum method Dollar Coin +_empty_/Enums.Coin.Nickel. => case val static enum method Nickel Coin +_empty_/Enums.Coin.Penny. => case val static enum method Penny Coin +_empty_/Enums.Coin.Quarter. => case val static enum method Quarter Coin +_empty_/Enums.Coin.fromOrdinal(). => method fromOrdinal (param ordinal: Int): Coin +_empty_/Enums.Coin.fromOrdinal().(ordinal) => param ordinal: Int +_empty_/Enums.Coin.valueOf(). => method valueOf (param $name: String): Coin +_empty_/Enums.Coin.valueOf().($name) => param $name: String +_empty_/Enums.Coin.values(). => method values => Array[Coin] +_empty_/Enums.Colour# => abstract sealed enum class Colour extends Object with Enum { self: Colour => +1 decls } +_empty_/Enums.Colour#``(). => primary ctor (): Colour +_empty_/Enums.Colour. => final object Colour extends Object { self: Colour.type => +9 decls } +_empty_/Enums.Colour.$new(). => private[this] method $new (param _$ordinal: Int, param $name: String): Colour +_empty_/Enums.Colour.$new().($name) => param $name: String +_empty_/Enums.Colour.$new().(_$ordinal) => param _$ordinal: Int +_empty_/Enums.Colour.$values. => private[this] val method $values Array[Colour] +_empty_/Enums.Colour.Blue. => case val static enum method Blue Colour +_empty_/Enums.Colour.Green. => case val static enum method Green Colour +_empty_/Enums.Colour.Red. => case val static enum method Red Colour +_empty_/Enums.Colour.fromOrdinal(). => method fromOrdinal (param ordinal: Int): Colour +_empty_/Enums.Colour.fromOrdinal().(ordinal) => param ordinal: Int +_empty_/Enums.Colour.valueOf(). => method valueOf (param $name: String): Colour +_empty_/Enums.Colour.valueOf().($name) => param $name: String +_empty_/Enums.Colour.values(). => method values => Array[Colour] +_empty_/Enums.Directions# => abstract sealed enum class Directions extends Object with Enum { self: Directions => +1 decls } +_empty_/Enums.Directions#``(). => primary ctor (): Directions +_empty_/Enums.Directions. => final object Directions extends Object { self: Directions.type => +10 decls } +_empty_/Enums.Directions.$new(). => private[this] method $new (param _$ordinal: Int, param $name: String): Directions +_empty_/Enums.Directions.$new().($name) => param $name: String +_empty_/Enums.Directions.$new().(_$ordinal) => param _$ordinal: Int +_empty_/Enums.Directions.$values. => private[this] val method $values Array[Directions] +_empty_/Enums.Directions.East. => case val static enum method East Directions +_empty_/Enums.Directions.North. => case val static enum method North Directions +_empty_/Enums.Directions.South. => case val static enum method South Directions +_empty_/Enums.Directions.West. => case val static enum method West Directions +_empty_/Enums.Directions.fromOrdinal(). => method fromOrdinal (param ordinal: Int): Directions +_empty_/Enums.Directions.fromOrdinal().(ordinal) => param ordinal: Int +_empty_/Enums.Directions.valueOf(). => method valueOf (param $name: String): Directions +_empty_/Enums.Directions.valueOf().($name) => param $name: String +_empty_/Enums.Directions.values(). => method values => Array[Directions] +_empty_/Enums.Maybe# => abstract sealed enum class Maybe [covariant typeparam A ] extends Object with Enum { self: Maybe[A] => +2 decls } +_empty_/Enums.Maybe#[A] => covariant typeparam A +_empty_/Enums.Maybe#``(). => primary ctor [covariant typeparam A ](): Maybe[A] +_empty_/Enums.Maybe. => final object Maybe extends Object { self: Maybe.type => +6 decls } +_empty_/Enums.Maybe.Just# => final case enum class Just [covariant typeparam A ] extends Maybe[A] { self: Just[A] => +7 decls } +_empty_/Enums.Maybe.Just#[A] => covariant typeparam A +_empty_/Enums.Maybe.Just#_1(). => method _1 => A +_empty_/Enums.Maybe.Just#``(). => primary ctor [covariant typeparam A ](val param value: A): Just[A] +_empty_/Enums.Maybe.Just#``().(value) => val param value: A +_empty_/Enums.Maybe.Just#copy$default$1(). => method copy$default$1 [covariant typeparam A ]: A +_empty_/Enums.Maybe.Just#copy$default$1().[A] => typeparam A +_empty_/Enums.Maybe.Just#copy(). => method copy [covariant typeparam A ](param value: A): Just[A] +_empty_/Enums.Maybe.Just#copy().(value) => param value: A +_empty_/Enums.Maybe.Just#copy().[A] => typeparam A +_empty_/Enums.Maybe.Just#ordinal(). => method ordinal => Int +_empty_/Enums.Maybe.Just#value. => val method value A +_empty_/Enums.Maybe.Just. => final object Just extends Object { self: Just.type => +4 decls } +_empty_/Enums.Maybe.Just.apply(). => method apply [typeparam A ](param value: A): Just[A] +_empty_/Enums.Maybe.Just.apply().(value) => param value: A +_empty_/Enums.Maybe.Just.apply().[A] => typeparam A +_empty_/Enums.Maybe.Just.toString(). => method toString => String +_empty_/Enums.Maybe.Just.unapply(). => method unapply [typeparam A ](param x$1: Just[A]): Just[A] +_empty_/Enums.Maybe.Just.unapply().(x$1) => param x$1: Just[A] +_empty_/Enums.Maybe.Just.unapply().[A] => typeparam A +_empty_/Enums.Maybe.None. => case val static enum method None Maybe[Nothing] +_empty_/Enums.Maybe.fromOrdinal(). => method fromOrdinal (param ordinal: Int): Maybe[_] forSome { type _ } +_empty_/Enums.Maybe.fromOrdinal().(ordinal) => param ordinal: Int +_empty_/Enums.Planet# => abstract sealed enum class Planet extends Enum[Planet] with Enum { self: Planet => +6 decls } +_empty_/Enums.Planet#G. => private[this] final val method G 6.673E-11 +_empty_/Enums.Planet#``(). => primary ctor (param mass: Double, param radius: Double): Planet +_empty_/Enums.Planet#``().(mass) => param mass: Double +_empty_/Enums.Planet#``().(radius) => param radius: Double +_empty_/Enums.Planet#mass. => private[this] val method mass Double +_empty_/Enums.Planet#radius. => private[this] val method radius Double +_empty_/Enums.Planet#surfaceGravity(). => method surfaceGravity => Double +_empty_/Enums.Planet#surfaceWeight(). => method surfaceWeight (param otherMass: Double): Double +_empty_/Enums.Planet#surfaceWeight().(otherMass) => param otherMass: Double +_empty_/Enums.Planet. => final object Planet extends Object { self: Planet.type => +13 decls } +_empty_/Enums.Planet.$values. => private[this] val method $values Array[Planet] +_empty_/Enums.Planet.Earth. => case val static enum method Earth Planet +_empty_/Enums.Planet.Jupiter. => case val static enum method Jupiter Planet +_empty_/Enums.Planet.Mars. => case val static enum method Mars Planet +_empty_/Enums.Planet.Mercury. => case val static enum method Mercury Planet +_empty_/Enums.Planet.Neptune. => case val static enum method Neptune Planet +_empty_/Enums.Planet.Saturn. => case val static enum method Saturn Planet +_empty_/Enums.Planet.Uranus. => case val static enum method Uranus Planet +_empty_/Enums.Planet.Venus. => case val static enum method Venus Planet +_empty_/Enums.Planet.fromOrdinal(). => method fromOrdinal (param ordinal: Int): Planet +_empty_/Enums.Planet.fromOrdinal().(ordinal) => param ordinal: Int +_empty_/Enums.Planet.valueOf(). => method valueOf (param $name: String): Planet +_empty_/Enums.Planet.valueOf().($name) => param $name: String +_empty_/Enums.Planet.values(). => method values => Array[Planet] +_empty_/Enums.Suits# => abstract sealed enum class Suits extends Object with Enum { self: Suits => +1 decls } +_empty_/Enums.Suits#``(). => primary ctor (): Suits +_empty_/Enums.Suits. => final object Suits extends Object { self: Suits.type => +13 decls } +_empty_/Enums.Suits.$new(). => private[this] method $new (param _$ordinal: Int, param $name: String): Suits +_empty_/Enums.Suits.$new().($name) => param $name: String +_empty_/Enums.Suits.$new().(_$ordinal) => param _$ordinal: Int +_empty_/Enums.Suits.$values. => private[this] val method $values Array[Suits] +_empty_/Enums.Suits.Clubs. => case val static enum method Clubs Suits +_empty_/Enums.Suits.Diamonds. => case val static enum method Diamonds Suits +_empty_/Enums.Suits.Hearts. => case val static enum method Hearts Suits +_empty_/Enums.Suits.Spades. => case val static enum method Spades Suits +_empty_/Enums.Suits.derived$CanEqual. => implicit lazy val given method derived$CanEqual CanEqual[Suits, Suits] +_empty_/Enums.Suits.fromOrdinal(). => method fromOrdinal (param ordinal: Int): Suits +_empty_/Enums.Suits.fromOrdinal().(ordinal) => param ordinal: Int +_empty_/Enums.Suits.isBlack(). => method isBlack (param suit: Suits): Boolean +_empty_/Enums.Suits.isBlack().(suit) => param suit: Suits +_empty_/Enums.Suits.isRed(). => method isRed (param suit: Suits): Boolean +_empty_/Enums.Suits.isRed().(suit) => param suit: Suits +_empty_/Enums.Suits.valueOf(). => method valueOf (param $name: String): Suits +_empty_/Enums.Suits.valueOf().($name) => param $name: String +_empty_/Enums.Suits.values(). => method values => Array[Suits] +_empty_/Enums.Tag# => abstract sealed enum class Tag [typeparam A ] extends Object with Enum { self: Tag[A] => +2 decls } +_empty_/Enums.Tag#[A] => typeparam A +_empty_/Enums.Tag#``(). => primary ctor [typeparam A ](): Tag[A] +_empty_/Enums.Tag. => final object Tag extends Object { self: Tag.type => +7 decls } +_empty_/Enums.Tag.$values. => private[this] val method $values Array[Tag[_] forSome { type _ }] +_empty_/Enums.Tag.BooleanTag. => case val static enum method BooleanTag Tag[Boolean] +_empty_/Enums.Tag.IntTag. => case val static enum method IntTag Tag[Int] +_empty_/Enums.Tag.fromOrdinal(). => method fromOrdinal (param ordinal: Int): Tag[_] forSome { type _ } +_empty_/Enums.Tag.fromOrdinal().(ordinal) => param ordinal: Int +_empty_/Enums.Tag.valueOf(). => method valueOf (param $name: String): Tag[_] forSome { type _ >: Int & Boolean <: Int | Boolean } +_empty_/Enums.Tag.valueOf().($name) => param $name: String +_empty_/Enums.Tag.values(). => method values => Array[Tag[_] forSome { type _ }] +_empty_/Enums.WeekDays# => abstract sealed enum class WeekDays extends Object with Enum { self: WeekDays => +1 decls } +_empty_/Enums.WeekDays#``(). => primary ctor (): WeekDays +_empty_/Enums.WeekDays. => final object WeekDays extends Object { self: WeekDays.type => +13 decls } +_empty_/Enums.WeekDays.$new(). => private[this] method $new (param _$ordinal: Int, param $name: String): WeekDays +_empty_/Enums.WeekDays.$new().($name) => param $name: String +_empty_/Enums.WeekDays.$new().(_$ordinal) => param _$ordinal: Int +_empty_/Enums.WeekDays.$values. => private[this] val method $values Array[WeekDays] +_empty_/Enums.WeekDays.Friday. => case val static enum method Friday WeekDays +_empty_/Enums.WeekDays.Monday. => case val static enum method Monday WeekDays +_empty_/Enums.WeekDays.Saturday. => case val static enum method Saturday WeekDays +_empty_/Enums.WeekDays.Sunday. => case val static enum method Sunday WeekDays +_empty_/Enums.WeekDays.Thursday. => case val static enum method Thursday WeekDays +_empty_/Enums.WeekDays.Tuesday. => case val static enum method Tuesday WeekDays +_empty_/Enums.WeekDays.Wednesday. => case val static enum method Wednesday WeekDays +_empty_/Enums.WeekDays.fromOrdinal(). => method fromOrdinal (param ordinal: Int): WeekDays +_empty_/Enums.WeekDays.fromOrdinal().(ordinal) => param ordinal: Int +_empty_/Enums.WeekDays.valueOf(). => method valueOf (param $name: String): WeekDays +_empty_/Enums.WeekDays.valueOf().($name) => param $name: String +_empty_/Enums.WeekDays.values(). => method values => Array[WeekDays] +_empty_/Enums.`<:<`# => abstract sealed enum class <:< [contravariant typeparam A , typeparam B ] extends Object with Enum { self: <:<[A, B] => +3 decls } +_empty_/Enums.`<:<`#[A] => contravariant typeparam A +_empty_/Enums.`<:<`#[B] => typeparam B +_empty_/Enums.`<:<`#``(). => primary ctor [contravariant typeparam A , typeparam B ](): <:<[A, B] +_empty_/Enums.`<:<`. => final object <:< extends Object { self: <:<.type => +6 decls } +_empty_/Enums.`<:<`.Refl# => final case enum class Refl [typeparam C ] extends <:<[C, C] { self: Refl[C] => +4 decls } +_empty_/Enums.`<:<`.Refl#[C] => typeparam C +_empty_/Enums.`<:<`.Refl#``(). => primary ctor [typeparam C ](): Refl[C] +_empty_/Enums.`<:<`.Refl#copy(). => method copy [typeparam C ](): Refl[C] +_empty_/Enums.`<:<`.Refl#copy().[C] => typeparam C +_empty_/Enums.`<:<`.Refl#ordinal(). => method ordinal => Int +_empty_/Enums.`<:<`.Refl. => final object Refl extends Object { self: Refl.type => +4 decls } +_empty_/Enums.`<:<`.Refl.apply(). => method apply [typeparam C ](): Refl[C] +_empty_/Enums.`<:<`.Refl.apply().[C] => typeparam C +_empty_/Enums.`<:<`.Refl.toString(). => method toString => String +_empty_/Enums.`<:<`.Refl.unapply(). => method unapply [typeparam C ](param x$1: Refl[C]): true +_empty_/Enums.`<:<`.Refl.unapply().(x$1) => param x$1: Refl[C] +_empty_/Enums.`<:<`.Refl.unapply().[C] => typeparam C +_empty_/Enums.`<:<`.`given_<:<_T_T`(). => final implicit given method given_<:<_T_T [typeparam T ]: <:<[T, T] +_empty_/Enums.`<:<`.`given_<:<_T_T`().[T] => typeparam T +_empty_/Enums.`<:<`.fromOrdinal(). => method fromOrdinal (param ordinal: Int): <:<[_, _] forSome { type _ ; type _ } +_empty_/Enums.`<:<`.fromOrdinal().(ordinal) => param ordinal: Int +_empty_/Enums.some1. => val method some1 Option[Int] +_empty_/Enums.unwrap(). => method unwrap [typeparam A , typeparam B ](param opt: Option[A])(implicit given param ev: <:<[A, Option[B]]): Option[B] +_empty_/Enums.unwrap().(ev) => implicit given param ev: <:<[A, Option[B]] +_empty_/Enums.unwrap().(opt) => param opt: Option[A] +_empty_/Enums.unwrap().[A] => typeparam A +_empty_/Enums.unwrap().[B] => typeparam B +local0 => param x: Option[B] 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/CanEqual.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. @@ -1049,7 +1032,6 @@ Occurrences: [18:11..18:17): Spades -> _empty_/Enums.Suits.Spades. [18:20..18:25): Clubs -> _empty_/Enums.Suits.Clubs. [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. @@ -1058,62 +1040,46 @@ Occurrences: [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:11): <- _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:12): <- _empty_/Enums.Maybe#``(). [37:14..37:15): A <- _empty_/Enums.Maybe#[A] [38:9..38:13): Just <- _empty_/Enums.Maybe.Just# -[38:13..38:13): <- _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:9..39:13): None <- _empty_/Enums.Maybe.None. [41:7..41:10): Tag <- _empty_/Enums.Tag# -[41:10..41:10): <- _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:10): <- _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:13): <- _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:10): <- _empty_/Enums.`<:<`.`given_<:<_T_T`(). [49:11..49:12): T <- _empty_/Enums.`<:<`.`given_<:<_T_T`().[T] [49:16..49:17): T -> _empty_/Enums.`<:<`.`given_<:<_T_T`().[T] [49:18..49:21): <:< -> _empty_/Enums.`<:<`# [49:22..49:23): T -> _empty_/Enums.`<:<`.`given_<:<_T_T`().[T] [49:27..49:31): Refl -> _empty_/Enums.`<:<`.Refl. -[49:31..49:31): -> _empty_/Enums.`<:<`.Refl.apply(). [51:13..51:14): A <- _empty_/Enums.unwrap().[A] [51:16..51:17): B <- _empty_/Enums.unwrap().[B] [51:19..51:22): opt <- _empty_/Enums.unwrap().(opt) @@ -1129,29 +1095,22 @@ Occurrences: [51:81..51:82): B -> _empty_/Enums.unwrap().[B] [51:86..51:88): 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: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:28..54:34): unwrap -> _empty_/Enums.unwrap(). -[54:34..54:34): -> _empty_/Enums.`<:<`.`given_<:<_T_T`(). [56:7..56:13): Planet <- _empty_/Enums.Planet# -[56:13..56:13): <- _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): Enum -> java/lang/Enum# [56:57..56:63): Planet -> _empty_/Enums.Planet# -[56:64..56:64): -> 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. @@ -1169,28 +1128,20 @@ Occurrences: [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 ------------------------- @@ -1201,24 +1152,20 @@ Uri => EtaExpansion.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 12 entries +Occurrences => 8 entries Symbols: -example/EtaExpansion# => class EtaExpansion -example/EtaExpansion#``(). => primary ctor -local0 => param x +example/EtaExpansion# => class EtaExpansion extends Object { self: EtaExpansion => +1 decls } +example/EtaExpansion#``(). => primary ctor (): EtaExpansion +local0 => param x: Int 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#`+`(). @@ -1231,14 +1178,14 @@ Uri => Example.scala Text => empty Language => Scala Symbols => 5 entries -Occurrences => 25 entries +Occurrences => 23 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 +example/Example. => final object Example extends Object { self: Example.type => +3 decls } +example/Example.main(). => method main (param args: Array[String]): Unit +example/Example.main().(args) => param args: Array[String] +example/Example.x. => val method x ClassTag[Int] +local0 => selfparam self: Example.type Occurrences: [0:8..0:15): example <- example/ @@ -1253,7 +1200,6 @@ Occurrences: [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# @@ -1265,7 +1211,6 @@ Occurrences: [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(). expect/Extension.scala ---------------------- @@ -1275,18 +1220,36 @@ Schema => SemanticDB v4 Uri => Extension.scala Text => empty Language => Scala -Symbols => 8 entries -Occurrences => 18 entries +Symbols => 26 entries +Occurrences => 50 entries Symbols: -ext/Extension$package. => final package object ext -ext/Extension$package.`#*#`(). => method #*# -ext/Extension$package.`#*#`().(i) => param i -ext/Extension$package.`#*#`().(s) => param s -ext/Extension$package.a. => val method a -ext/Extension$package.c. => val method c -ext/Extension$package.foo(). => method foo -ext/Extension$package.foo().(s) => param s +ext/Extension$package. => final package object ext extends Object { self: ext.type => +6 decls } +ext/Extension$package.`#*#`(). => method #*# (param s: String)(param i: Int): Tuple2[String, Int] +ext/Extension$package.`#*#`().(i) => param i: Int +ext/Extension$package.`#*#`().(s) => param s: String +ext/Extension$package.a. => val method a Int +ext/Extension$package.c. => val method c Tuple2[String, Int] +ext/Extension$package.foo(). => method foo (param s: String): Int +ext/Extension$package.foo().(s) => param s: String +ext/Extension$package.readInto(). => method readInto [typeparam T ](param s: String)(implicit given param x$2: Read[T]): Option[T] +ext/Extension$package.readInto().(s) => param s: String +ext/Extension$package.readInto().(x$2) => implicit given param x$2: Read[T] +ext/Extension$package.readInto().[T] => typeparam T +ext/Functor# => trait Functor [typeparam F [type _ ]] extends Object { self: Functor[F] => +3 decls } +ext/Functor#[F] => typeparam F [type _ ] +ext/Functor#[F][_] => type _ +ext/Functor#``(). => primary ctor [typeparam F [type _ ]](): Functor[F] +ext/Functor#map(). => abstract method map [typeparam T , typeparam U ](param t: F[T])(param f: Function1[T, U]): F[U] +ext/Functor#map().(f) => param f: Function1[T, U] +ext/Functor#map().(t) => param t: F[T] +ext/Functor#map().[T] => typeparam T +ext/Functor#map().[U] => typeparam U +ext/Read# => trait Read [covariant typeparam T ] extends Object { self: Read[T] => +3 decls } +ext/Read#[T] => covariant typeparam T +ext/Read#``(). => primary ctor [covariant typeparam T ](): Read[T] +ext/Read#fromString(). => abstract method fromString (param s: String): Option[T] +ext/Read#fromString().(s) => param s: String Occurrences: [0:8..0:11): ext <- ext/ @@ -1300,13 +1263,45 @@ Occurrences: [4:14..4:17): Int -> scala/Int# [4:21..4:27): String -> scala/Predef.String# [4:29..4:32): Int -> scala/Int# -[4:37..4:37): -> scala/Tuple2.apply(). [4:37..4:38): s -> ext/Extension$package.`#*#`().(s) [4:40..4:41): i -> ext/Extension$package.`#*#`().(i) [6:4..6:5): a <- ext/Extension$package.a. [6:14..6:17): foo -> ext/Extension$package.foo(). [8:4..8:5): c <- ext/Extension$package.c. [8:14..8:17): #*# -> ext/Extension$package.`#*#`(). +[10:6..10:10): Read <- ext/Read# +[10:12..10:13): T <- ext/Read#[T] +[11:6..11:16): fromString <- ext/Read#fromString(). +[11:17..11:18): s <- ext/Read#fromString().(s) +[11:20..11:26): String -> scala/Predef.String# +[11:29..11:35): Option -> scala/Option# +[11:36..11:37): T -> ext/Read#[T] +[13:11..13:12): s <- ext/Extension$package.readInto().(s) +[13:14..13:20): String -> scala/Predef.String# +[14:6..14:14): readInto <- ext/Extension$package.readInto(). +[14:15..14:16): T <- ext/Extension$package.readInto().[T] +[14:24..14:28): Read -> ext/Read# +[14:29..14:30): T -> ext/Extension$package.readInto().[T] +[14:34..14:40): Option -> scala/Option# +[14:41..14:42): T -> ext/Extension$package.readInto().[T] +[14:46..14:52): summon -> scala/Predef.summon(). +[14:53..14:57): Read -> ext/Read# +[14:58..14:59): T -> ext/Extension$package.readInto().[T] +[14:62..14:72): fromString -> ext/Read#fromString(). +[14:73..14:74): s -> ext/Extension$package.readInto().(s) +[16:6..16:13): Functor <- ext/Functor# +[16:14..16:15): F <- ext/Functor#[F] +[17:13..17:14): T <- ext/Functor#map().[T] +[17:16..17:17): t <- ext/Functor#map().(t) +[17:19..17:20): F -> ext/Functor#[F] +[17:21..17:22): T -> ext/Functor#map().[T] +[17:29..17:32): map <- ext/Functor#map(). +[17:33..17:34): U <- ext/Functor#map().[U] +[17:36..17:37): f <- ext/Functor#map().(f) +[17:39..17:40): T -> ext/Functor#map().[T] +[17:44..17:45): U -> ext/Functor#map().[U] +[17:48..17:49): F -> ext/Functor#[F] +[17:50..17:51): U -> ext/Functor#map().[U] expect/ForComprehension.scala ----------------------------- @@ -1317,106 +1312,70 @@ Uri => ForComprehension.scala Text => empty Language => Scala Symbols => 13 entries -Occurrences => 88 entries +Occurrences => 52 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 +example/ForComprehension# => class ForComprehension extends Object { self: ForComprehension => +1 decls } +example/ForComprehension#``(). => primary ctor (): ForComprehension +local0 => param a: Int +local1 => param b: Int +local2 => val local c: Int +local3 => param x$1: Tuple2[Int, Int] +local4 => param a: Int +local5 => param b: Int +local6 => param x$1: Tuple2[Int, Int] +local7 => val local c: Int +local8 => val local d: Int +local9 => val local e: Tuple4[Int, Int, Int, Int] +local10 => param f: Tuple4[Int, Int, Int, Int] 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 @@ -1433,38 +1392,38 @@ Uri => Givens.scala Text => empty Language => Scala Symbols => 29 entries -Occurrences => 70 entries +Occurrences => 62 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) => given param A -a/b/Givens.foo().[A] => typeparam A -a/b/Givens.given_Monoid_String. => final given 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.goodbye1. => val method goodbye1 -a/b/Givens.hello1. => val method hello1 -a/b/Givens.int2String(). => final given inline macro int2String -a/b/Givens.sayGoodbye(). => method sayGoodbye -a/b/Givens.sayGoodbye().(any) => param any -a/b/Givens.sayGoodbye().[B] => typeparam B -a/b/Givens.sayHello(). => method sayHello -a/b/Givens.sayHello().(any) => param any -a/b/Givens.sayHello().[A] => typeparam A -a/b/Givens.saySoLong(). => method saySoLong -a/b/Givens.saySoLong().(any) => param any -a/b/Givens.saySoLong().[B] => typeparam B -a/b/Givens.soLong1. => val method soLong1 +a/b/Givens. => final object Givens extends Object { self: Givens.type => +12 decls } +a/b/Givens.Monoid# => trait Monoid [typeparam A ] extends Object { self: Monoid[A] => +4 decls } +a/b/Givens.Monoid#[A] => typeparam A +a/b/Givens.Monoid#``(). => primary ctor [typeparam A ](): Monoid[A] +a/b/Givens.Monoid#combine(). => abstract method combine (param x: A)(param y: A): A +a/b/Givens.Monoid#combine().(x) => param x: A +a/b/Givens.Monoid#combine().(y) => param y: A +a/b/Givens.Monoid#empty(). => abstract method empty => A +a/b/Givens.foo(). => method foo [typeparam A ](implicit given param A: Monoid[A]): A +a/b/Givens.foo().(A) => implicit given param A: Monoid[A] +a/b/Givens.foo().[A] => typeparam A +a/b/Givens.given_Monoid_String. => final implicit given object given_Monoid_String extends Object with Monoid[String] { self: given_Monoid_String.type => +3 decls } +a/b/Givens.given_Monoid_String.combine(). => method combine (param x: String)(param y: String): String +a/b/Givens.given_Monoid_String.combine().(x) => param x: String +a/b/Givens.given_Monoid_String.combine().(y) => param y: String +a/b/Givens.given_Monoid_String.empty(). => method empty => String +a/b/Givens.goodbye1. => val method goodbye1 String +a/b/Givens.hello1. => val method hello1 String +a/b/Givens.int2String(). => final implicit given inline macro int2String => Conversion[Int, String] +a/b/Givens.sayGoodbye(). => method sayGoodbye [typeparam B ](param any: B): String +a/b/Givens.sayGoodbye().(any) => param any: B +a/b/Givens.sayGoodbye().[B] => typeparam B +a/b/Givens.sayHello(). => method sayHello [typeparam A ](param any: A): String +a/b/Givens.sayHello().(any) => param any: A +a/b/Givens.sayHello().[A] => typeparam A +a/b/Givens.saySoLong(). => method saySoLong [typeparam B ](param any: B): String +a/b/Givens.saySoLong().(any) => param any: B +a/b/Givens.saySoLong().[B] => typeparam B +a/b/Givens.soLong1. => val method soLong1 String Occurrences: [0:8..0:9): a <- a/ @@ -1474,9 +1433,7 @@ Occurrences: [5:16..5:19): any <- a/b/Givens.sayHello().(any) [5:21..5:22): A -> a/b/Givens.sayHello().[A] [6:8..6:16): sayHello <- a/b/Givens.sayHello(). -[6:21..6:21): -> scala/StringContext.apply(). [6:34..6:37): any -> a/b/Givens.sayHello().(any) -[6:37..6:38): " -> scala/StringContext#s(). [8:13..8:14): B <- a/b/Givens.sayGoodbye().[B] [8:13..8:14): B <- a/b/Givens.saySoLong().[B] [8:16..8:19): any <- a/b/Givens.sayGoodbye().(any) @@ -1484,13 +1441,9 @@ Occurrences: [8:21..8:22): B -> a/b/Givens.sayGoodbye().[B] [8:21..8:22): B -> a/b/Givens.saySoLong().[B] [9:8..9:18): sayGoodbye <- a/b/Givens.sayGoodbye(). -[9:23..9:23): -> scala/StringContext.apply(). [9:38..9:41): any -> a/b/Givens.sayGoodbye().(any) -[9:41..9:42): " -> scala/StringContext#s(). [10:8..10:17): saySoLong <- a/b/Givens.saySoLong(). -[10:22..10:22): -> scala/StringContext.apply(). [10:37..10:40): any -> a/b/Givens.saySoLong().(any) -[10:40..10:41): " -> scala/StringContext#s(). [12:6..12:12): hello1 <- a/b/Givens.hello1. [12:17..12:25): sayHello -> a/b/Givens.sayHello(). [13:6..13:14): goodbye1 <- a/b/Givens.goodbye1. @@ -1498,7 +1451,6 @@ Occurrences: [14:6..14:13): soLong1 <- a/b/Givens.soLong1. [14:18..14:27): saySoLong -> a/b/Givens.saySoLong(). [16:8..16:14): Monoid <- a/b/Givens.Monoid# -[16:14..16:14): <- 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] @@ -1508,7 +1460,6 @@ Occurrences: [18:33..18:34): y <- a/b/Givens.Monoid#combine().(y) [18:36..18:37): A -> a/b/Givens.Monoid#[A] [18:40..18:41): A -> a/b/Givens.Monoid#[A] -[20:8..20:27): Monoid[String] with <- 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(). @@ -1547,32 +1498,32 @@ Uri => ImplicitConversion.scala Text => empty Language => Scala Symbols => 23 entries -Occurrences => 62 entries +Occurrences => 48 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. => private 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 +example/ImplicitConversion# => class ImplicitConversion extends Object { self: ImplicitConversion => +9 decls } +example/ImplicitConversion#``(). => primary ctor (): ImplicitConversion +example/ImplicitConversion#a. => val method a Int +example/ImplicitConversion#b. => val method b Long +example/ImplicitConversion#char. => val method char Char +example/ImplicitConversion#message. => val method message String +example/ImplicitConversion#number. => val method number Int +example/ImplicitConversion#string2Number(). => implicit method string2Number (param string: String): Int +example/ImplicitConversion#string2Number().(string) => param string: String +example/ImplicitConversion#tuple. => val method tuple Tuple2[Int, Int] +example/ImplicitConversion#x. => val method x Int +example/ImplicitConversion. => final object ImplicitConversion extends Object { self: ImplicitConversion.type => +6 decls } +example/ImplicitConversion.newAny2stringadd# => final class newAny2stringadd [typeparam A ] extends AnyVal { self: newAny2stringadd[A] => +4 decls } +example/ImplicitConversion.newAny2stringadd#[A] => typeparam A +example/ImplicitConversion.newAny2stringadd#`+`(). => method + (param other: String): String +example/ImplicitConversion.newAny2stringadd#`+`().(other) => param other: String +example/ImplicitConversion.newAny2stringadd#``(). => primary ctor [typeparam A ](param self: A): newAny2stringadd[A] +example/ImplicitConversion.newAny2stringadd#``().(self) => param self: A +example/ImplicitConversion.newAny2stringadd#self. => private val method self A +example/ImplicitConversion.newAny2stringadd(). => final implicit method newAny2stringadd [typeparam A ](param self: A): newAny2stringadd[A] +example/ImplicitConversion.newAny2stringadd().(self) => param self: A +example/ImplicitConversion.newAny2stringadd().[A] => typeparam A +example/ImplicitConversion.newAny2stringadd. => final object newAny2stringadd extends Object { self: newAny2stringadd.type => +2 decls } Occurrences: [0:8..0:15): example <- example/ @@ -1580,7 +1531,6 @@ Occurrences: [2:13..2:21): language -> scala/language. [2:22..2:41): implicitConversions -> scala/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) @@ -1589,45 +1539,32 @@ Occurrences: [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:27): " -> 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:15..26:16): " -> 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:39): <- 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# @@ -1666,17 +1603,17 @@ Uri => InstrumentTyper.scala Text => empty Language => Scala Symbols => 8 entries -Occurrences => 55 entries +Occurrences => 52 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 +example/InstrumentTyper# => class InstrumentTyper extends Object { self: AnyRef & InstrumentTyper => +5 decls } +example/InstrumentTyper#AnnotatedType# => type AnnotatedType = Int @param +example/InstrumentTyper#``(). => primary ctor (): InstrumentTyper +example/InstrumentTyper#all(). => method all => List[Matchable] +example/InstrumentTyper#clazzOf. => final val method clazzOf Option[Int] +example/InstrumentTyper#singletonType(). => method singletonType (param x: Predef.type): Nothing +example/InstrumentTyper#singletonType().(x) => param x: Predef.type +local0 => selfparam self: AnyRef Occurrences: [0:8..0:15): example <- example/ @@ -1693,12 +1630,10 @@ Occurrences: [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. @@ -1722,7 +1657,6 @@ Occurrences: [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# @@ -1744,79 +1678,73 @@ Uri => InventedNames.scala Text => empty Language => Scala Symbols => 45 entries -Occurrences => 72 entries +Occurrences => 61 entries Symbols: -givens/InventedNames$package. => final package object givens -givens/InventedNames$package.`* *`. => final lazy val given method * * -givens/InventedNames$package.a. => val method a -givens/InventedNames$package.b. => val method b -givens/InventedNames$package.c. => val method c -givens/InventedNames$package.d. => val method d -givens/InventedNames$package.e. => val method e -givens/InventedNames$package.f. => val method f -givens/InventedNames$package.g. => val method g -givens/InventedNames$package.given_Char. => final lazy val given method given_Char -givens/InventedNames$package.given_Double(). => final given method given_Double -givens/InventedNames$package.given_Double().(x$1) => given param x$1 -givens/InventedNames$package.given_Float. => final lazy val given method given_Float -givens/InventedNames$package.given_List_T(). => final given method given_List_T -givens/InventedNames$package.given_List_T().[T] => typeparam T -givens/InventedNames$package.given_String. => final lazy val given method given_String -givens/InventedNames$package.given_X. => final given object given_X -givens/InventedNames$package.given_X.doX(). => method doX -givens/InventedNames$package.given_Y# => class given_Y -givens/InventedNames$package.given_Y#``(). => primary ctor -givens/InventedNames$package.given_Y#``().(x$1) => val given param x$1 -givens/InventedNames$package.given_Y#doY(). => method doY -givens/InventedNames$package.given_Y#x$1. => protected val given method x$1 -givens/InventedNames$package.given_Y(). => final given method given_Y -givens/InventedNames$package.given_Y().(x$1) => given param x$1 -givens/InventedNames$package.given_Z_T# => class given_Z_T -givens/InventedNames$package.given_Z_T#[T] => typeparam T -givens/InventedNames$package.given_Z_T#``(). => primary ctor -givens/InventedNames$package.given_Z_T#doZ(). => method doZ -givens/InventedNames$package.given_Z_T(). => final given method given_Z_T -givens/InventedNames$package.given_Z_T().[T] => typeparam T -givens/InventedNames$package.intValue. => final lazy val given method intValue -givens/InventedNames$package.x. => val method x -givens/InventedNames$package.y. => val method y -givens/InventedNames$package.z. => val method z -givens/X# => trait X -givens/X#``(). => primary ctor -givens/X#doX(). => abstract method doX -givens/Y# => trait Y -givens/Y#``(). => primary ctor -givens/Y#doY(). => abstract method doY -givens/Z# => trait Z -givens/Z#[T] => typeparam T -givens/Z#``(). => primary ctor -givens/Z#doZ(). => abstract method doZ +givens/InventedNames$package. => final package object givens extends Object { self: givens.type => +24 decls } +givens/InventedNames$package.`* *`. => final implicit lazy val given method * * Long +givens/InventedNames$package.a. => val method a Int +givens/InventedNames$package.b. => val method b String +givens/InventedNames$package.c. => val method c Double +givens/InventedNames$package.d. => val method d List[Int] +givens/InventedNames$package.e. => val method e Char +givens/InventedNames$package.f. => val method f Float +givens/InventedNames$package.g. => val method g Long +givens/InventedNames$package.given_Char. => final implicit lazy val given method given_Char Char +givens/InventedNames$package.given_Double(). => final implicit given method given_Double (implicit given param x$1: Int): Double +givens/InventedNames$package.given_Double().(x$1) => implicit given param x$1: Int +givens/InventedNames$package.given_Float. => final implicit lazy val given method given_Float Float +givens/InventedNames$package.given_List_T(). => final implicit given method given_List_T [typeparam T ]: List[T] +givens/InventedNames$package.given_List_T().[T] => typeparam T +givens/InventedNames$package.given_String. => final implicit lazy val given method given_String String +givens/InventedNames$package.given_X. => final implicit given object given_X extends Object with X { self: given_X.type => +2 decls } +givens/InventedNames$package.given_X.doX(). => method doX => Int +givens/InventedNames$package.given_Y# => class given_Y extends Object with Y { self: given_Y => +3 decls } +givens/InventedNames$package.given_Y#``(). => primary ctor ()(implicit val given param x$1: X): given_Y +givens/InventedNames$package.given_Y#``().(x$1) => implicit val given param x$1: X +givens/InventedNames$package.given_Y#doY(). => method doY => String +givens/InventedNames$package.given_Y#x$1. => protected implicit val given method x$1 X +givens/InventedNames$package.given_Y(). => final implicit given method given_Y (implicit given param x$1: X): given_Y +givens/InventedNames$package.given_Y().(x$1) => implicit given param x$1: X +givens/InventedNames$package.given_Z_T# => class given_Z_T [typeparam T ] extends Object with Z[T] { self: given_Z_T[T] => +3 decls } +givens/InventedNames$package.given_Z_T#[T] => typeparam T +givens/InventedNames$package.given_Z_T#``(). => primary ctor [typeparam T ](): given_Z_T[T] +givens/InventedNames$package.given_Z_T#doZ(). => method doZ => List[T] +givens/InventedNames$package.given_Z_T(). => final implicit given method given_Z_T [typeparam T ]: given_Z_T[T] +givens/InventedNames$package.given_Z_T().[T] => typeparam T +givens/InventedNames$package.intValue. => final implicit lazy val given method intValue Int +givens/InventedNames$package.x. => val method x given_X.type +givens/InventedNames$package.y. => val method y given_Y +givens/InventedNames$package.z. => val method z given_Z_T[String] +givens/X# => trait X extends Object { self: X => +2 decls } +givens/X#``(). => primary ctor (): X +givens/X#doX(). => abstract method doX => Int +givens/Y# => trait Y extends Object { self: Y => +2 decls } +givens/Y#``(). => primary ctor (): Y +givens/Y#doY(). => abstract method doY => String +givens/Z# => trait Z [typeparam T ] extends Object { self: Z[T] => +3 decls } +givens/Z#[T] => typeparam T +givens/Z#``(). => primary ctor [typeparam T ](): Z[T] +givens/Z#doZ(). => abstract method doZ => List[T] Occurrences: [0:8..0:14): givens <- givens/ [2:6..2:7): X <- givens/X# -[3:2..3:2): <- givens/X#``(). [3:6..3:9): doX <- givens/X#doX(). [3:11..3:14): Int -> scala/Int# [5:6..5:7): Y <- givens/Y# -[6:2..6:2): <- givens/Y#``(). [6:6..6:9): doY <- givens/Y#doY(). [6:11..6:17): String -> scala/Predef.String# [8:6..8:7): Z <- givens/Z# -[8:7..8:7): <- givens/Z#``(). [8:8..8:9): T <- givens/Z#[T] [9:6..9:9): doZ <- givens/Z#doZ(). [9:11..9:15): List -> scala/package.List# [9:16..9:17): T -> givens/Z#[T] [13:6..13:14): intValue <- givens/InventedNames$package.intValue. [13:16..13:19): Int -> scala/Int# -[14:6..14:6): <- givens/InventedNames$package.given_String. [14:6..14:12): String -> scala/Predef.String# -[15:6..15:6): <- givens/InventedNames$package.given_Double(). [15:13..15:16): Int -> scala/Int# [15:19..15:25): Double -> scala/Double# -[16:6..16:6): <- givens/InventedNames$package.given_List_T(). [16:7..16:8): T <- givens/InventedNames$package.given_List_T().[T] [16:11..16:15): List -> scala/package.List# [16:16..16:17): T -> givens/InventedNames$package.given_List_T().[T] @@ -1827,14 +1755,11 @@ Occurrences: [18:21..18:26): Float -> scala/Float# [19:7..19:10): * * <- givens/InventedNames$package.`* *`. [19:13..19:17): Long -> scala/Long# -[21:6..22:0): <- givens/InventedNames$package.given_X. [21:6..21:7): X -> givens/X# [22:6..22:9): doX <- givens/InventedNames$package.given_X.doX(). -[24:13..24:13): <- givens/InventedNames$package.given_Y#``(). [24:13..24:14): X -> givens/X# [24:17..24:18): Y -> givens/Y# [25:6..25:9): doY <- givens/InventedNames$package.given_Y#doY(). -[27:7..27:7): <- givens/InventedNames$package.given_Z_T#``(). [27:7..27:8): T <- givens/InventedNames$package.given_Z_T#[T] [27:11..27:12): Z -> givens/Z# [27:13..27:14): T -> givens/InventedNames$package.given_Z_T#[T] @@ -1848,7 +1773,6 @@ Occurrences: [33:8..33:20): given_String -> givens/InventedNames$package.given_String. [34:4..34:5): c <- givens/InventedNames$package.c. [34:8..34:20): given_Double -> givens/InventedNames$package.given_Double(). -[34:20..34:20): -> givens/InventedNames$package.intValue. [35:4..35:5): d <- givens/InventedNames$package.d. [35:8..35:20): given_List_T -> givens/InventedNames$package.given_List_T(). [35:21..35:24): Int -> scala/Int# @@ -1862,7 +1786,6 @@ Occurrences: [39:8..39:15): given_X -> givens/InventedNames$package.given_X. [40:4..40:5): y <- givens/InventedNames$package.y. [40:8..40:15): given_Y -> givens/InventedNames$package.given_Y(). -[40:15..40:15): -> givens/InventedNames$package.given_X. [41:4..41:5): z <- givens/InventedNames$package.z. [41:8..41:17): given_Z_T -> givens/InventedNames$package.given_Z_T(). [41:18..41:24): String -> scala/Predef.String# @@ -1876,16 +1799,16 @@ Uri => Issue1749.scala Text => empty Language => Scala Symbols => 7 entries -Occurrences => 30 entries +Occurrences => 22 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 +example/Issue1749# => class Issue1749 extends Object { self: Issue1749 => +3 decls } +example/Issue1749#``(). => primary ctor (): Issue1749 +example/Issue1749#x1. => val method x1 Int +example/Issue1749#x2. => val method x2 Int +example/Issue1854# => class Issue1854 extends Object { self: Issue1854 => +2 decls } +example/Issue1854#``(). => primary ctor (): Issue1854 +example/Issue1854#map. => val method map Map[String, String] Occurrences: [1:8..1:15): example <- example/ @@ -1894,21 +1817,14 @@ Occurrences: [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/ @@ -1917,7 +1833,6 @@ Occurrences: [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 ------------------ @@ -1928,28 +1843,27 @@ Uri => Local.scala Text => empty Language => Scala Symbols => 6 entries -Occurrences => 11 entries +Occurrences => 10 entries Symbols: -example/Local# => class Local -example/Local#``(). => primary ctor -example/Local#a(). => method a -local0 => local id -local1 => typeparam A -local2 => param a +example/Local# => class Local extends Object { self: Local => +2 decls } +example/Local#``(). => primary ctor (): Local +example/Local#a(). => method a (): Int +local0 => typeparam A +local1 => param a: A +local2 => local id: [typeparam A ](param a: A): 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 +[4:8..4:10): id <- local2 +[4:11..4:12): A <- local0 +[4:14..4:15): a <- local1 +[4:17..4:18): A -> local0 +[4:21..4:22): A -> local0 +[4:25..4:26): a -> local1 +[5:4..5:6): id -> local2 expect/Locals.scala ------------------- @@ -1960,12 +1874,12 @@ Uri => Locals.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 7 entries +Occurrences => 6 entries Symbols: -local0 => val local x -locals/Test. => final object Test -locals/Test.xs. => val method xs +local0 => val local x: Int +locals/Test. => final object Test extends Object { self: Test.type => +2 decls } +locals/Test.xs. => val method xs List[Int] Occurrences: [0:8..0:14): locals <- locals/ @@ -1973,7 +1887,6 @@ Occurrences: [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 @@ -1985,26 +1898,25 @@ Uri => MetacJava.scala Text => empty Language => Scala Symbols => 10 entries -Occurrences => 72 entries +Occurrences => 62 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 +example/MetacJava# => class MetacJava extends Object { self: MetacJava => +9 decls } +example/MetacJava#``(). => primary ctor (): MetacJava +example/MetacJava#coin. => val method coin Coin +example/MetacJava#entry. => val method entry Entry[Int, Int] +example/MetacJava#inner. => val method inner MetacJava +example/MetacJava#interface. => val method interface Interface +example/MetacJava#nonStatic. => val method nonStatic staticInner.NonStatic +example/MetacJava#overload1. => val method overload1 inner.Overload1 +example/MetacJava#overload2. => val method overload2 inner.Overload2 +example/MetacJava#staticInner. => val method staticInner 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# @@ -2012,39 +1924,31 @@ Occurrences: [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. @@ -2055,7 +1959,6 @@ Occurrences: [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# @@ -2082,21 +1985,19 @@ Uri => MethodUsages.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 85 entries +Occurrences => 80 entries Symbols: -example/MethodUsages# => class MethodUsages -example/MethodUsages#``(). => primary ctor -example/MethodUsages#m. => val method m +example/MethodUsages# => class MethodUsages extends Object { self: MethodUsages => +2 decls } +example/MethodUsages#``(). => primary ctor (): MethodUsages +example/MethodUsages#m. => val method m Methods[Int] 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. @@ -2116,7 +2017,6 @@ Occurrences: [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. @@ -2126,8 +2026,6 @@ Occurrences: [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. @@ -2184,87 +2082,92 @@ Schema => SemanticDB v4 Uri => Methods.scala Text => empty Language => Scala -Symbols => 77 entries -Occurrences => 149 entries +Symbols => 82 entries +Occurrences => 153 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#`m20_=`(). => var method m20_= -example/Methods#`m20_=`().(x$1) => param x$1 -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 -example/Methods#m20(). => method m20 -example/Methods#m20().(a) => param a -example/Methods#m20(+1). => method m20 -example/Methods#m20(+1).(b) => param b -example/Methods#m20(+2). => var method m20 -local0 => abstract val method x +example/Methods# => class Methods [typeparam T ] extends Object { self: Methods[T] => +44 decls } +example/Methods#AList# => type AList [typeparam T ] = List[T] +example/Methods#AList#[T] => typeparam T +example/Methods#List# => class List [typeparam T ] extends Object { self: List[T] => +2 decls } +example/Methods#List#[T] => typeparam T +example/Methods#List#``(). => primary ctor [typeparam T ](): List[T] +example/Methods#[T] => typeparam T +example/Methods#``(). => primary ctor [typeparam T ](): Methods[T] +example/Methods#`m8().`(). => method m8(). (): Nothing +example/Methods#`m9().`# => class m9(). extends Object { self: m9(). => +1 decls } +example/Methods#`m9().`#``(). => primary ctor (): m9(). +example/Methods#`m20_=`(). => var method m20_= (param x$1: m17.type): Unit +example/Methods#`m20_=`().(x$1) => param x$1: m17.type +example/Methods#m1(). => method m1 => Nothing +example/Methods#m2(). => method m2 (): Nothing +example/Methods#m3(). => method m3 (param x: Int): Nothing +example/Methods#m3().(x) => param x: Int +example/Methods#m4(). => method m4 (param x: Int)(param y: Int): Nothing +example/Methods#m4().(x) => param x: Int +example/Methods#m4().(y) => param y: Int +example/Methods#m5(). => method m5 (param x: String): Nothing +example/Methods#m5().(x) => param x: String +example/Methods#m5(+1). => method m5 (param x: Int): Nothing +example/Methods#m5(+1).(x) => param x: Int +example/Methods#m6(). => method m6 (param x: Int): Nothing +example/Methods#m6().(x) => param x: Int +example/Methods#m6(+1). => method m6 (param x: List[T]): Nothing +example/Methods#m6(+1).(x) => param x: List[T] +example/Methods#m6(+2). => method m6 (param x: List[T]): Nothing +example/Methods#m6(+2).(x) => param x: List[T] +example/Methods#m7(). => method m7 [typeparam U ](param c: Methods[T], param l: List[U])(implicit param evidence$1: Ordering[U]): Nothing +example/Methods#m7().(c) => param c: Methods[T] +example/Methods#m7().(evidence$1) => implicit param evidence$1: Ordering[U] +example/Methods#m7().(l) => param l: List[U] +example/Methods#m7().[U] => typeparam U +example/Methods#m9(). => method m9 (param x: m9().): Nothing +example/Methods#m9().(x) => param x: m9(). +example/Methods#m10(). => method m10 (param x: List[T]): Nothing +example/Methods#m10().(x) => param x: List[T] +example/Methods#m11(). => method m11 (param x: Predef.type): Nothing +example/Methods#m11().(x) => param x: Predef.type +example/Methods#m11(+1). => method m11 (param x: Example.type): Nothing +example/Methods#m11(+1).(x) => param x: Example.type +example/Methods#m12a(). => method m12a (param x: Object): Nothing +example/Methods#m12a().(x) => param x: Object +example/Methods#m12b(). => method m12b (param x: Object { abstract val method x Int }): Nothing +example/Methods#m12b().(x) => param x: Object { abstract val method x Int } +example/Methods#m12c(). => method m12c (param x: Object { abstract method y => Int; abstract val method x Int }): Nothing +example/Methods#m12c().(x) => param x: Object { abstract method y => Int; abstract val method x Int } +example/Methods#m13(). => method m13 (param x: Int @unchecked): Nothing +example/Methods#m13().(x) => param x: Int @unchecked +example/Methods#m15(). => method m15 (param x: => Int): Nothing +example/Methods#m15().(x) => param x: => Int +example/Methods#m16(). => method m16 (param x: Int*): Nothing +example/Methods#m16().(x) => param x: Int* +example/Methods#m17(). => method m17 (param a: Int): Nothing +example/Methods#m17().(a) => param a: Int +example/Methods#m17(+1). => method m17 (param b: String): Nothing +example/Methods#m17(+1).(b) => param b: String +example/Methods#m17. => final object m17 extends Object { self: m17.type => +2 decls } +example/Methods#m17.m(). => method m (): Nothing +example/Methods#m18(). => method m18 (param a: Int): Nothing +example/Methods#m18().(a) => param a: Int +example/Methods#m18(+1). => method m18 (param b: String): Nothing +example/Methods#m18(+1).(b) => param b: String +example/Methods#m18. => val method m18 m17.type +example/Methods#m19$default$2(). => method m19$default$2 => Int @uncheckedVariance +example/Methods#m19$default$3(). => method m19$default$3 (param x: Int, param y: Int): Int @uncheckedVariance +example/Methods#m19$default$3().(x) => param x: Int +example/Methods#m19$default$3().(y) => param y: Int +example/Methods#m19(). => method m19 (param x: Int, param y: Int)(param z: Int): Nothing +example/Methods#m19().(x) => param x: Int +example/Methods#m19().(y) => param y: Int +example/Methods#m19().(z) => param z: Int +example/Methods#m20(). => method m20 (param a: Int): Nothing +example/Methods#m20().(a) => param a: Int +example/Methods#m20(+1). => method m20 (param b: String): Nothing +example/Methods#m20(+1).(b) => param b: String +example/Methods#m20(+2). => var method m20 m17.type +local0 => abstract val method x Int +local1 => abstract val method x Int +local2 => abstract method y => Int Occurrences: [0:8..0:15): example <- example/ @@ -2276,10 +2179,8 @@ Occurrences: [3:13..3:21): language -> scala/language. [3:22..3:34): existentials -> scala/language.existentials. [5:6..5:13): Methods <- example/Methods# -[5:13..5:13): <- example/Methods#``(). [5:14..5:15): T <- example/Methods#[T] [6:8..6:12): List <- example/Methods#List# -[6:12..6:12): <- 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] @@ -2324,8 +2225,8 @@ Occurrences: [16:29..16:32): ??? -> scala/Predef.`???`(). [17:6..17:8): m7 <- example/Methods#m7(). [17:9..17:10): U <- example/Methods#m7().[U] +[17:10..17:10): <- example/Methods#m7().(evidence$1) [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] @@ -2335,7 +2236,6 @@ Occurrences: [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) @@ -2362,60 +2262,67 @@ Occurrences: [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.`???`(). -[36:6..36:9): m20 <- example/Methods#m20(). -[36:10..36:11): a <- example/Methods#m20().(a) +[26:6..26:10): m12c <- example/Methods#m12c(). +[26:11..26:12): x <- example/Methods#m12c().(x) +[26:20..26:21): x <- local1 +[26:23..26:26): Int -> scala/Int# +[26:32..26:33): y <- local2 +[26:35..26:38): Int -> scala/Int# +[26:44..26:47): ??? -> scala/Predef.`???`(). +[27:6..27:9): m13 <- example/Methods#m13(). +[27:10..27:11): x <- example/Methods#m13().(x) +[27:13..27:16): Int -> scala/Int# +[27:18..27:27): unchecked -> scala/unchecked# +[27:31..27:34): ??? -> scala/Predef.`???`(). +[28:6..28:9): m15 <- example/Methods#m15(). +[28:10..28:11): x <- example/Methods#m15().(x) +[28:16..28:19): Int -> scala/Int# +[28:23..28:26): ??? -> scala/Predef.`???`(). +[29:6..29:9): m16 <- example/Methods#m16(). +[29:10..29:11): x <- example/Methods#m16().(x) +[29:13..29:16): Int -> scala/Int# +[29:21..29:24): ??? -> scala/Predef.`???`(). +[30:9..30:12): m17 <- example/Methods#m17. +[30:19..30:20): m <- example/Methods#m17.m(). +[30:25..30:28): ??? -> scala/Predef.`???`(). +[31:6..31:9): m17 <- example/Methods#m17(). +[31:10..31:11): a <- example/Methods#m17().(a) +[31:13..31:16): Int -> scala/Int# +[31:20..31:23): ??? -> scala/Predef.`???`(). +[32:6..32:9): m17 <- example/Methods#m17(+1). +[32:10..32:11): b <- example/Methods#m17(+1).(b) +[32:13..32:19): String -> scala/Predef.String# +[32:23..32:26): ??? -> scala/Predef.`???`(). +[33:6..33:9): m18 <- example/Methods#m18. +[33:12..33:15): m17 -> example/Methods#m17. +[34:6..34:9): m18 <- example/Methods#m18(). +[34:10..34:11): a <- example/Methods#m18().(a) +[34:13..34:16): Int -> scala/Int# +[34:20..34:23): ??? -> scala/Predef.`???`(). +[35:6..35:9): m18 <- example/Methods#m18(+1). +[35:10..35:11): b <- example/Methods#m18(+1).(b) +[35:13..35:19): String -> scala/Predef.String# +[35:23..35:26): ??? -> scala/Predef.`???`(). +[36:6..36:9): m19 <- example/Methods#m19(). +[36:10..36:11): x <- example/Methods#m19().(x) +[36:10..36:11): x <- example/Methods#m19$default$3().(x) [36:13..36:16): Int -> scala/Int# -[36:20..36:23): ??? -> scala/Predef.`???`(). -[37:6..37:9): m20 <- example/Methods#m20(+1). -[37:10..37:11): b <- example/Methods#m20(+1).(b) -[37:13..37:19): String -> scala/Predef.String# -[37:23..37:26): ??? -> scala/Predef.`???`(). -[38:6..38:9): m20 <- example/Methods#m20(+2). -[38:12..38:15): m17 -> example/Methods#m17. +[36:18..36:19): y <- example/Methods#m19().(y) +[36:18..36:19): y <- example/Methods#m19$default$3().(y) +[36:21..36:24): Int -> scala/Int# +[36:30..36:31): z <- example/Methods#m19().(z) +[36:33..36:36): Int -> scala/Int# +[36:44..36:47): ??? -> scala/Predef.`???`(). +[37:6..37:9): m20 <- example/Methods#m20(). +[37:10..37:11): a <- example/Methods#m20().(a) +[37:13..37:16): Int -> scala/Int# +[37:20..37:23): ??? -> scala/Predef.`???`(). +[38:6..38:9): m20 <- example/Methods#m20(+1). +[38:10..38:11): b <- example/Methods#m20(+1).(b) +[38:13..38:19): String -> scala/Predef.String# +[38:23..38:26): ??? -> scala/Predef.`???`(). +[39:6..39:9): m20 <- example/Methods#m20(+2). +[39:12..39:15): m17 -> example/Methods#m17. expect/NamedApplyBlock.scala ---------------------------- @@ -2426,52 +2333,52 @@ Uri => NamedApplyBlock.scala Text => empty Language => Scala Symbols => 43 entries -Occurrences => 43 entries +Occurrences => 40 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.toString(). => method toString -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 c$1 -local1 => val local b$1 +example/NamedApplyBlockCaseClassConstruction. => final object NamedApplyBlockCaseClassConstruction extends Object { self: NamedApplyBlockCaseClassConstruction.type => +6 decls } +example/NamedApplyBlockCaseClassConstruction.Msg# => case class Msg extends Object with Product with Serializable { self: Msg => +11 decls } +example/NamedApplyBlockCaseClassConstruction.Msg#_1(). => method _1 => String +example/NamedApplyBlockCaseClassConstruction.Msg#_2(). => method _2 => String +example/NamedApplyBlockCaseClassConstruction.Msg#_3(). => method _3 => String +example/NamedApplyBlockCaseClassConstruction.Msg#``(). => primary ctor (val param body: String, val param head: String, val param tail: String): Msg +example/NamedApplyBlockCaseClassConstruction.Msg#``().(body) => val param body: String +example/NamedApplyBlockCaseClassConstruction.Msg#``().(head) => val param head: String +example/NamedApplyBlockCaseClassConstruction.Msg#``().(tail) => val param tail: String +example/NamedApplyBlockCaseClassConstruction.Msg#body. => val method body String +example/NamedApplyBlockCaseClassConstruction.Msg#copy$default$1(). => method copy$default$1 => String @uncheckedVariance +example/NamedApplyBlockCaseClassConstruction.Msg#copy$default$2(). => method copy$default$2 => String @uncheckedVariance +example/NamedApplyBlockCaseClassConstruction.Msg#copy$default$3(). => method copy$default$3 => String @uncheckedVariance +example/NamedApplyBlockCaseClassConstruction.Msg#copy(). => method copy (param body: String, param head: String, param tail: String): Msg +example/NamedApplyBlockCaseClassConstruction.Msg#copy().(body) => param body: String +example/NamedApplyBlockCaseClassConstruction.Msg#copy().(head) => param head: String +example/NamedApplyBlockCaseClassConstruction.Msg#copy().(tail) => param tail: String +example/NamedApplyBlockCaseClassConstruction.Msg#head. => val method head String +example/NamedApplyBlockCaseClassConstruction.Msg#tail. => val method tail String +example/NamedApplyBlockCaseClassConstruction.Msg. => final object Msg extends Object { self: Msg.type => +5 decls } +example/NamedApplyBlockCaseClassConstruction.Msg.$lessinit$greater$default$2(). => method $lessinit$greater$default$2 => String @uncheckedVariance +example/NamedApplyBlockCaseClassConstruction.Msg.apply(). => method apply (param body: String, param head: String, param tail: String): Msg +example/NamedApplyBlockCaseClassConstruction.Msg.apply().(body) => param body: String +example/NamedApplyBlockCaseClassConstruction.Msg.apply().(head) => param head: String +example/NamedApplyBlockCaseClassConstruction.Msg.apply().(tail) => param tail: String +example/NamedApplyBlockCaseClassConstruction.Msg.toString(). => method toString => String +example/NamedApplyBlockCaseClassConstruction.Msg.unapply(). => method unapply (param x$1: Msg): Msg +example/NamedApplyBlockCaseClassConstruction.Msg.unapply().(x$1) => param x$1: Msg +example/NamedApplyBlockCaseClassConstruction.bodyText. => val method bodyText String +example/NamedApplyBlockCaseClassConstruction.msg. => val method msg Msg +example/NamedApplyBlockMethods. => final object NamedApplyBlockMethods extends Object { self: NamedApplyBlockMethods.type => +8 decls } +example/NamedApplyBlockMethods.baseCase(). => method baseCase => Int +example/NamedApplyBlockMethods.foo$default$1(). => method foo$default$1 => Int @uncheckedVariance +example/NamedApplyBlockMethods.foo$default$2(). => method foo$default$2 => Int @uncheckedVariance +example/NamedApplyBlockMethods.foo$default$3(). => method foo$default$3 => Int @uncheckedVariance +example/NamedApplyBlockMethods.foo(). => method foo (param a: Int, param b: Int, param c: Int): Int +example/NamedApplyBlockMethods.foo().(a) => param a: Int +example/NamedApplyBlockMethods.foo().(b) => param b: Int +example/NamedApplyBlockMethods.foo().(c) => param c: Int +example/NamedApplyBlockMethods.local. => val method local Int +example/NamedApplyBlockMethods.recursive(). => method recursive => Int +local0 => val local c$1: Int +local1 => val local b$1: Int @uncheckedVariance Occurrences: [0:8..0:15): example <- example/ @@ -2496,7 +2403,6 @@ Occurrences: [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): -> local1 [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(). @@ -2504,7 +2410,6 @@ Occurrences: [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:16): <- 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. @@ -2514,7 +2419,6 @@ Occurrences: [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: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) @@ -2527,36 +2431,33 @@ Uri => NamedArguments.scala Text => empty Language => Scala Symbols => 16 entries -Occurrences => 13 entries +Occurrences => 10 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.toString(). => method toString -example/NamedArguments#User.unapply(). => method unapply -example/NamedArguments#User.unapply().(x$1) => param x$1 -example/NamedArguments#``(). => primary ctor +example/NamedArguments# => class NamedArguments extends Object { self: NamedArguments => +4 decls } +example/NamedArguments#User# => case class User extends Object with Product with Serializable { self: User => +5 decls } +example/NamedArguments#User#_1(). => method _1 => String +example/NamedArguments#User#``(). => primary ctor (val param name: String): User +example/NamedArguments#User#``().(name) => val param name: String +example/NamedArguments#User#copy$default$1(). => method copy$default$1 => String @uncheckedVariance +example/NamedArguments#User#copy(). => method copy (param name: String): User +example/NamedArguments#User#copy().(name) => param name: String +example/NamedArguments#User#name. => val method name String +example/NamedArguments#User. => final object User extends Object { self: User.type => +4 decls } +example/NamedArguments#User.apply(). => method apply (param name: String): User +example/NamedArguments#User.apply().(name) => param name: String +example/NamedArguments#User.toString(). => method toString => String +example/NamedArguments#User.unapply(). => method unapply (param x$1: User): User +example/NamedArguments#User.unapply().(x$1) => param x$1: User +example/NamedArguments#``(). => primary ctor (): NamedArguments 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:17): <- 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(). @@ -2570,19 +2471,41 @@ Schema => SemanticDB v4 Uri => NewModifiers.scala Text => empty Language => Scala -Symbols => 3 entries -Occurrences => 4 entries +Symbols => 14 entries +Occurrences => 15 entries Symbols: -_empty_/NewModifiers. => final object NewModifiers -_empty_/NewModifiers.A# => opaque type A -_empty_/NewModifiers.foo. => val inline method foo +_empty_/NewModifiers$package. => final package object _empty_ extends Object { self: _empty_.type { opaque type OpaqueB } => +2 decls } +_empty_/NewModifiers$package.OpaqueB# => opaque type OpaqueB +_empty_/NewModifiers. => final object NewModifiers extends Object { self: NewModifiers.type { opaque type A } => +3 decls } +_empty_/NewModifiers.A# => opaque type A +_empty_/NewModifiers.foo. => val inline method foo "foo" +_empty_/NewModifiersClass# => opaque class NewModifiersClass extends Object { self: Any { opaque type C } & NewModifiersClass => +5 decls } +_empty_/NewModifiersClass#C# => opaque type C +_empty_/NewModifiersClass#Nested# => opaque class Nested extends Object { self: Any { opaque type NestedOpaque } & Nested => +2 decls } +_empty_/NewModifiersClass#Nested#NestedOpaque# => opaque type NestedOpaque +_empty_/NewModifiersClass#Nested#``(). => primary ctor (): Nested +_empty_/NewModifiersClass#``(). => primary ctor (): NewModifiersClass +_empty_/NewModifiersTrait# => opaque trait NewModifiersTrait extends Object { self: Any { opaque type D } & NewModifiersTrait => +2 decls } +_empty_/NewModifiersTrait#D# => opaque type D +_empty_/NewModifiersTrait#``(). => primary ctor (): NewModifiersTrait 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# +[5:12..5:19): OpaqueB <- _empty_/NewModifiers$package.OpaqueB# +[5:22..5:25): Int -> scala/Int# +[7:6..7:23): NewModifiersClass <- _empty_/NewModifiersClass# +[8:14..8:15): C <- _empty_/NewModifiersClass#C# +[8:18..8:21): Int -> scala/Int# +[9:8..9:14): Nested <- _empty_/NewModifiersClass#Nested# +[10:16..10:28): NestedOpaque <- _empty_/NewModifiersClass#Nested#NestedOpaque# +[10:31..10:34): Int -> scala/Int# +[14:6..14:23): NewModifiersTrait <- _empty_/NewModifiersTrait# +[15:14..15:15): D <- _empty_/NewModifiersTrait#D# +[15:18..15:21): Int -> scala/Int# expect/Objects.scala -------------------- @@ -2596,8 +2519,8 @@ Symbols => 2 entries Occurrences => 3 entries Symbols: -objects/X. => final object X -objects/X.Y. => final object Y +objects/X. => final object X extends Object { self: X.type => +3 decls } +objects/X.Y. => final object Y extends Object { self: Y.type => +1 decls } Occurrences: [0:8..0:15): objects <- objects/ @@ -2613,24 +2536,22 @@ Uri => Overrides.scala Text => empty Language => Scala Symbols => 6 entries -Occurrences => 10 entries +Occurrences => 8 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 +example/A# => trait A extends Object { self: A => +2 decls } +example/A#``(). => primary ctor (): A +example/A#foo(). => abstract method foo => Int +example/B# => class B extends Object with A { self: B => +2 decls } +example/B#``(). => primary ctor (): B +example/B#foo(). => method foo => Int 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:7): <- example/B#``(). [3:18..3:19): A -> example/A# [3:26..3:29): foo <- example/B#foo(). [3:31..3:34): Int -> scala/Int# @@ -2644,33 +2565,32 @@ Uri => Prefixes.scala Text => empty Language => Scala Symbols => 19 entries -Occurrences => 49 entries +Occurrences => 47 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 +prefixes/C# => class C extends Object { self: C => +6 decls } +prefixes/C#N. => final object N extends Object { self: N.type => +2 decls } +prefixes/C#N.U# => type U +prefixes/C#T# => type T +prefixes/C#``(). => primary ctor (): C +prefixes/C#k1(). => method k1 => U +prefixes/C#m1(). => method m1 => T +prefixes/M. => final object M extends Object { self: M.type => +3 decls } +prefixes/M.T# => type T +prefixes/M.n1(). => method n1 => T +prefixes/O. => final object O extends C { self: O.type => +2 decls } +prefixes/O.o1(). => method o1 => O.this.T +prefixes/Test. => final object Test extends Object { self: Test.type => +7 decls } +prefixes/Test.c. => val method c C +prefixes/Test.k2(). => method k2 => c.N.U +prefixes/Test.k3(). => method k3 => c.N.U +prefixes/Test.m2(). => method m2 => c.T +prefixes/Test.n2(). => method n2 => T +prefixes/Test.n3(). => method n3 => T 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# @@ -2688,7 +2608,6 @@ Occurrences: [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.`???`(). @@ -2718,6 +2637,189 @@ Occurrences: [31:10..31:11): T -> prefixes/M.T# [31:14..31:17): ??? -> scala/Predef.`???`(). +expect/RecOrRefined.scala +------------------------- + +Summary: +Schema => SemanticDB v4 +Uri => RecOrRefined.scala +Text => empty +Language => Scala +Symbols => 65 entries +Occurrences => 103 entries + +Symbols: +example/C# => class C extends Object { self: C => +3 decls } +example/C#T1# => type T1 +example/C#T2# => type T2 +example/C#``(). => primary ctor (): C +example/PickOneRefinement_1# => class PickOneRefinement_1 [typeparam S <: SpecialRefinement { abstract method pickOne [typeparam T ](param as: T*): Option[String] }] extends Object { self: PickOneRefinement_1[S] => +3 decls } +example/PickOneRefinement_1#[S] => typeparam S <: SpecialRefinement { abstract method pickOne [typeparam T ](param as: T*): Option[String] } +example/PickOneRefinement_1#[S](as) => param as: T* +example/PickOneRefinement_1#[S][T] => typeparam T +example/PickOneRefinement_1#``(). => primary ctor [typeparam S <: SpecialRefinement { abstract method pickOne [typeparam T ](param as: T*): Option[String] }](): PickOneRefinement_1[S] +example/PickOneRefinement_1#run(). => method run (param s: S, param as: String*): Option[String] +example/PickOneRefinement_1#run().(as) => param as: String* +example/PickOneRefinement_1#run().(s) => param s: S +example/PolyHolder# => trait PolyHolder extends Object { self: PolyHolder => +2 decls } +example/PolyHolder#``(). => primary ctor (): PolyHolder +example/PolyHolder#foo(). => abstract method foo [typeparam T ](param t: T): Any +example/PolyHolder#foo().(t) => param t: T +example/PolyHolder#foo().[T] => typeparam T +example/RecOrRefined$package. => final package object example extends Object { self: example.type => +9 decls } +example/RecOrRefined$package.C2# => type C2 = C { type T2 = T1; type T1 } +example/RecOrRefined$package.Person# => type Person = Record { abstract val method age Int; abstract val method name String } +example/RecOrRefined$package.m1(). => method m1 (param a: Int { abstract val method x Int }): Nothing +example/RecOrRefined$package.m1().(a) => param a: Int { abstract val method x Int } +example/RecOrRefined$package.m2(). => method m2 (param x: Object { abstract method y => Int; abstract val method x Int }): Nothing +example/RecOrRefined$package.m2().(x) => param x: Object { abstract method y => Int; abstract val method x Int } +example/RecOrRefined$package.m3(). => method m3 (param x: Object { type z ; abstract method y => Int; abstract val method x Int }): Nothing +example/RecOrRefined$package.m3().(x) => param x: Object { type z ; abstract method y => Int; abstract val method x Int } +example/RecOrRefined$package.m4(). => method m4 (param x: PolyHolder { abstract method foo [typeparam T ](param t: T): T }): Nothing +example/RecOrRefined$package.m4().(x) => param x: PolyHolder { abstract method foo [typeparam T ](param t: T): T } +example/RecOrRefined$package.m5(). => method m5 [typeparam Z ](param x: Int): PolyHolder { abstract method foo [typeparam T ](param t: T): T } +example/RecOrRefined$package.m5().(x) => param x: Int +example/RecOrRefined$package.m5().[Z] => typeparam Z +example/RecOrRefined$package.m6# => type m6 [typeparam X ] = PolyHolder { abstract method foo [typeparam T ](param t: T): T } +example/RecOrRefined$package.m6#[X] => typeparam X +example/Record# => class Record extends Object with Selectable { self: Record => +4 decls } +example/Record#``(). => primary ctor (param elems: Tuple2[String, Any]*): Record +example/Record#``().(elems) => param elems: Tuple2[String, Any]* +example/Record#elems. => private[this] val method elems Tuple2[String, Any]* +example/Record#fields. => private[this] val method fields Map[String, Any] +example/Record#selectDynamic(). => method selectDynamic (param name: String): Any +example/Record#selectDynamic().(name) => param name: String +example/SpecialRefinement# => trait SpecialRefinement extends Object { self: SpecialRefinement => +2 decls } +example/SpecialRefinement#``(). => primary ctor (): SpecialRefinement +example/SpecialRefinement#pickOne(). => abstract method pickOne [typeparam T ](param as: T*): Option[Any] +example/SpecialRefinement#pickOne().(as) => param as: T* +example/SpecialRefinement#pickOne().[T] => typeparam T +local0 => abstract method pickOne [typeparam T ](param as: T*): Option[String] +local1 => abstract val method x Int +local2 => abstract val method x Int +local3 => abstract method y => Int +local4 => abstract val method x Int +local5 => abstract method y => Int +local6 => type z +local7 => typeparam T +local8 => param t: T +local9 => abstract method foo [typeparam T ](param t: T): T +local10 => typeparam T +local11 => param t: T +local12 => abstract method foo [typeparam T ](param t: T): T +local13 => typeparam T +local14 => param t: T +local15 => abstract method foo [typeparam T ](param t: T): T +local16 => abstract val method name String +local17 => abstract val method age Int +local18 => type T1 +local19 => type T2 = T1 + +Occurrences: +[0:8..0:15): example <- example/ +[2:4..2:6): m1 <- example/RecOrRefined$package.m1(). +[2:7..2:8): a <- example/RecOrRefined$package.m1().(a) +[2:10..2:13): Int -> scala/Int# +[2:20..2:21): x <- local1 +[2:23..2:26): Int -> scala/Int# +[2:32..2:35): ??? -> scala/Predef.`???`(). +[3:4..3:6): m2 <- example/RecOrRefined$package.m2(). +[3:7..3:8): x <- example/RecOrRefined$package.m2().(x) +[3:16..3:17): x <- local2 +[3:19..3:22): Int -> scala/Int# +[3:28..3:29): y <- local3 +[3:31..3:34): Int -> scala/Int# +[3:40..3:43): ??? -> scala/Predef.`???`(). +[4:4..4:6): m3 <- example/RecOrRefined$package.m3(). +[4:7..4:8): x <- example/RecOrRefined$package.m3().(x) +[4:16..4:17): x <- local4 +[4:19..4:22): Int -> scala/Int# +[4:28..4:29): y <- local5 +[4:31..4:34): Int -> scala/Int# +[4:41..4:42): z <- local6 +[4:48..4:51): ??? -> scala/Predef.`???`(). +[5:6..5:16): PolyHolder <- example/PolyHolder# +[6:6..6:9): foo <- example/PolyHolder#foo(). +[6:10..6:11): T <- example/PolyHolder#foo().[T] +[6:13..6:14): t <- example/PolyHolder#foo().(t) +[6:16..6:17): T -> example/PolyHolder#foo().[T] +[6:20..6:23): Any -> scala/Any# +[9:4..9:6): m4 <- example/RecOrRefined$package.m4(). +[9:7..9:8): x <- example/RecOrRefined$package.m4().(x) +[9:10..9:20): PolyHolder -> example/PolyHolder# +[9:27..9:30): foo <- local9 +[9:31..9:32): T <- local7 +[9:34..9:35): t <- local8 +[9:37..9:38): T -> local7 +[9:41..9:42): T -> local7 +[9:48..9:51): ??? -> scala/Predef.`???`(). +[10:4..10:6): m5 <- example/RecOrRefined$package.m5(). +[10:7..10:8): Z <- example/RecOrRefined$package.m5().[Z] +[10:10..10:11): x <- example/RecOrRefined$package.m5().(x) +[10:13..10:16): Int -> scala/Int# +[10:19..10:29): PolyHolder -> example/PolyHolder# +[10:36..10:39): foo <- local12 +[10:40..10:41): T <- local10 +[10:43..10:44): t <- local11 +[10:46..10:47): T -> local10 +[10:50..10:51): T -> local10 +[10:56..10:59): ??? -> scala/Predef.`???`(). +[12:5..12:7): m6 <- example/RecOrRefined$package.m6# +[12:11..12:12): X <- example/RecOrRefined$package.m6#[X] +[12:18..12:28): PolyHolder -> example/PolyHolder# +[12:35..12:38): foo <- local15 +[12:39..12:40): T <- local13 +[12:42..12:43): t <- local14 +[12:45..12:46): T -> local13 +[12:49..12:50): T -> local13 +[14:6..14:12): Record <- example/Record# +[14:13..14:18): elems <- example/Record#elems. +[14:21..14:27): String -> scala/Predef.String# +[14:29..14:32): Any -> scala/Any# +[14:44..14:54): Selectable -> scala/Selectable# +[15:14..15:20): fields <- example/Record#fields. +[15:23..15:28): elems -> example/Record#elems. +[15:29..15:34): toMap -> scala/collection/IterableOnceOps#toMap(). +[16:6..16:19): selectDynamic <- example/Record#selectDynamic(). +[16:20..16:24): name <- example/Record#selectDynamic().(name) +[16:26..16:32): String -> scala/Predef.String# +[16:35..16:38): Any -> scala/Any# +[16:41..16:47): fields -> example/Record#fields. +[16:48..16:52): name -> example/Record#selectDynamic().(name) +[18:5..18:11): Person <- example/RecOrRefined$package.Person# +[18:14..18:20): Record -> example/Record# +[19:6..19:10): name <- local16 +[19:12..19:18): String -> scala/Predef.String# +[20:6..20:9): age <- local17 +[20:11..20:14): Int -> scala/Int# +[24:6..24:7): C <- example/C# +[24:15..24:17): T1 <- example/C#T1# +[24:24..24:26): T2 <- example/C#T2# +[25:5..25:7): C2 <- example/RecOrRefined$package.C2# +[25:10..25:11): C -> example/C# +[25:19..25:21): T1 <- local18 +[25:28..25:30): T2 <- local19 +[25:33..25:35): T1 -> local18 +[27:6..27:23): SpecialRefinement <- example/SpecialRefinement# +[28:6..28:13): pickOne <- example/SpecialRefinement#pickOne(). +[28:14..28:15): T <- example/SpecialRefinement#pickOne().[T] +[28:17..28:19): as <- example/SpecialRefinement#pickOne().(as) +[28:21..28:22): T -> example/SpecialRefinement#pickOne().[T] +[28:26..28:32): Option -> scala/Option# +[28:33..28:36): Any -> scala/Any# +[31:6..31:25): PickOneRefinement_1 <- example/PickOneRefinement_1# +[31:26..31:27): S <- example/PickOneRefinement_1#[S] +[32:6..32:9): run <- example/PickOneRefinement_1#run(). +[32:10..32:11): s <- example/PickOneRefinement_1#run().(s) +[32:13..32:14): S -> example/PickOneRefinement_1#[S] +[32:16..32:18): as <- example/PickOneRefinement_1#run().(as) +[32:20..32:26): String -> scala/Predef.String# +[32:30..32:36): Option -> scala/Option# +[32:37..32:43): String -> scala/Predef.String# +[32:47..32:48): s -> example/PickOneRefinement_1#run().(s) +[32:49..32:56): pickOne -> example/SpecialRefinement#pickOne(). +[32:57..32:59): as -> example/PickOneRefinement_1#run().(as) + expect/RightAssociativeExtension.scala -------------------------------------- @@ -2727,14 +2829,14 @@ Uri => RightAssociativeExtension.scala Text => empty Language => Scala Symbols => 5 entries -Occurrences => 13 entries +Occurrences => 12 entries Symbols: -ext/RightAssociativeExtension$package. => final package object ext -ext/RightAssociativeExtension$package.`:*:`(). => method :*: -ext/RightAssociativeExtension$package.`:*:`().(i) => param i -ext/RightAssociativeExtension$package.`:*:`().(s) => param s -ext/RightAssociativeExtension$package.b. => val method b +ext/RightAssociativeExtension$package. => final package object ext extends Object { self: ext.type => +3 decls } +ext/RightAssociativeExtension$package.`:*:`(). => method :*: (param i: Int)(param s: String): Tuple2[String, Int] +ext/RightAssociativeExtension$package.`:*:`().(i) => param i: Int +ext/RightAssociativeExtension$package.`:*:`().(s) => param s: String +ext/RightAssociativeExtension$package.b. => val method b Tuple2[String, Int] Occurrences: [0:8..0:11): ext <- ext/ @@ -2745,7 +2847,6 @@ Occurrences: [3:14..3:17): Int -> scala/Int# [3:21..3:27): String -> scala/Predef.String# [3:29..3:32): Int -> scala/Int# -[3:37..3:37): -> scala/Tuple2.apply(). [3:37..3:38): s -> ext/RightAssociativeExtension$package.`:*:`().(s) [3:40..3:41): i -> ext/RightAssociativeExtension$package.`:*:`().(i) [5:4..5:5): b <- ext/RightAssociativeExtension$package.b. @@ -2760,49 +2861,40 @@ Uri => Selfs.scala Text => empty Language => Scala Symbols => 13 entries -Occurrences => 26 entries +Occurrences => 17 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 +local0 => selfparam self: C1 +local1 => selfparam self: B +local2 => selfparam self: B & C1 +selfs/B# => class B extends Object { self: B => +1 decls } +selfs/B#``(). => primary ctor (): B +selfs/C1# => class C1 extends B { self: C1 & C1 => +1 decls } +selfs/C1#``(). => primary ctor (): C1 +selfs/C2# => class C2 extends B { self: B & C2 => +1 decls } +selfs/C2#``(). => primary ctor (): C2 +selfs/C3# => class C3 extends B { self: B & C1 & C3 => +1 decls } +selfs/C3#``(). => primary ctor (): C3 +selfs/C6# => class C6 extends B { self: B & C6 => +1 decls } +selfs/C6#``(). => primary ctor (): C6 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 @@ -2813,48 +2905,50 @@ Schema => SemanticDB v4 Uri => Synthetic.scala Text => empty Language => Scala -Symbols => 38 entries -Occurrences => 162 entries +Symbols => 40 entries +Occurrences => 112 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.toString(). => method toString -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 +example/Synthetic# => class Synthetic extends Object { self: Synthetic => +21 decls } +example/Synthetic#F# => class F extends Object { self: F => +1 decls } +example/Synthetic#F#``(). => primary ctor (): F +example/Synthetic#J# => class J [typeparam T ] extends Object { self: J[T] => +4 decls } +example/Synthetic#J#[T] => typeparam T +example/Synthetic#J#``(). => primary ctor [typeparam T ]()(implicit param evidence$1: Manifest[T]): J[T] +example/Synthetic#J#``().(evidence$1) => implicit param evidence$1: Manifest[T] +example/Synthetic#J#arr. => val method arr Array[T] +example/Synthetic#J#evidence$1. => private[this] implicit val method evidence$1 Manifest[T] +example/Synthetic#Name. => val method Name Regex +example/Synthetic#``(). => primary ctor (): Synthetic +example/Synthetic#a1. => val method a1 Int +example/Synthetic#a2. => val method a2 Int +example/Synthetic#as. => val method as LazyList[Int] +example/Synthetic#f. => val method f Ordered[F] +example/Synthetic#lst. => val method lst LazyList[Int] +example/Synthetic#name. => val method name String +example/Synthetic#ordering. => implicit val method ordering Ordering[F] +example/Synthetic#s. => final object s extends Object { self: s.type => +5 decls } +example/Synthetic#s.Bar# => case class Bar extends Object with Product with Serializable { self: Bar => +2 decls } +example/Synthetic#s.Bar#``(). => primary ctor (): Bar +example/Synthetic#s.Bar#copy(). => method copy (): Bar +example/Synthetic#s.Bar. => final object Bar extends Object { self: Bar.type => +4 decls } +example/Synthetic#s.Bar.apply(). => method apply (): Bar +example/Synthetic#s.Bar.toString(). => method toString => String +example/Synthetic#s.Bar.unapply(). => method unapply (param x$1: Bar): true +example/Synthetic#s.Bar.unapply().(x$1) => param x$1: Bar +example/Synthetic#s.apply(). => method apply (): Int +example/Synthetic#x. => val method x Int +example/Synthetic#xs. => val method xs LazyList[Int] +local0 => param x: Int +local1 => param y: Int +local2 => param i: Int +local3 => param j: Int +local4 => param i: Int +local5 => param j: Int +local6 => param a: Int +local7 => param b: Int +local8 => param a: Int +local9 => param b: Int Occurrences: [0:8..0:15): example <- example/ @@ -2862,112 +2956,73 @@ Occurrences: [2:13..2:21): language -> scala/language. [2:22..2:41): implicitConversions -> scala/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: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:18): <- 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:9): <- example/Synthetic#J#``(). [32:10..32:11): T <- example/Synthetic#J#[T] +[32:11..32:11): <- example/Synthetic#J#evidence$1. [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#``(). +[32:49..32:49): -> example/Synthetic#J#evidence$1. [34:8..34:9): F <- example/Synthetic#F# [35:15..35:23): ordering <- example/Synthetic#ordering. [35:25..35:33): Ordering -> scala/package.Ordering# @@ -2976,10 +3031,7 @@ Occurrences: [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. @@ -2990,35 +3042,27 @@ Occurrences: [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 ------------------- @@ -3029,39 +3073,35 @@ Uri => Traits.scala Text => empty Language => Scala Symbols => 13 entries -Occurrences => 16 entries +Occurrences => 12 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 +local0 => final class $anon extends Object with U { self: $anon => +1 decls } +local2 => selfparam self: C +traits/C# => class C extends Object { self: C => +1 decls } +traits/C#``(). => primary ctor (): C +traits/T# => trait T extends Object { self: T => +2 decls } +traits/T#``(). => primary ctor (): T +traits/T#x(). => method x => Int +traits/U# => sealed trait U extends Object { self: U => +1 decls } +traits/U#``(). => primary ctor (): U +traits/U. => final object U extends Object { self: U.type => +2 decls } +traits/U.u(). => method u => U +traits/V# => trait V extends Object { self: C & V => +1 decls } +traits/V#``(). => primary ctor (): V 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:10..12:14): self <- local2 [12:16..12:17): C -> traits/C# expect/ValPattern.scala @@ -3073,48 +3113,42 @@ Uri => ValPattern.scala Text => empty Language => Scala Symbols => 22 entries -Occurrences => 63 entries +Occurrences => 46 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 +example/ValPattern# => class ValPattern extends Object { self: ValPattern => +14 decls } +example/ValPattern#``(). => primary ctor (): ValPattern +example/ValPattern#`leftVar_=`(). => var method leftVar_= (param x$1: Int): Unit +example/ValPattern#`leftVar_=`().(x$1) => param x$1: Int +example/ValPattern#`number1Var_=`(). => var method number1Var_= (param x$1: Int): Unit +example/ValPattern#`number1Var_=`().(x$1) => param x$1: Int +example/ValPattern#`rightVar_=`(). => var method rightVar_= (param x$1: Int): Unit +example/ValPattern#`rightVar_=`().(x$1) => param x$1: Int +example/ValPattern#app(). => method app (): Unit +example/ValPattern#left. => val method left Int +example/ValPattern#leftVar(). => var method leftVar Int +example/ValPattern#number1. => val method number1 Int +example/ValPattern#number1Var(). => var method number1Var Int +example/ValPattern#q1. => val method q1 Nothing +example/ValPattern#right. => val method right Int +example/ValPattern#rightVar(). => var method rightVar Int +local0 => val local left: Int +local1 => val local right: Int +local2 => val local number1: Int +local3 => var local leftVar: Int +local4 => var local rightVar: Int +local5 => var local number1Var: Int 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. @@ -3122,16 +3156,12 @@ Occurrences: [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. @@ -3141,22 +3171,15 @@ Occurrences: [25:4..25:11): locally -> scala/Predef.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 @@ -3173,56 +3196,55 @@ Uri => Vals.scala Text => empty Language => Scala Symbols => 42 entries -Occurrences => 129 entries +Occurrences => 127 entries Symbols: -example/ValUsages. => final object ValUsages -example/ValUsages.v. => val method v -example/Vals# => abstract class Vals -example/Vals#_explicitSetter(). => private[this] 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. => private[this] 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. => private[this] val method xlm -example/Vals#xm. => val method xm -example/Vals#xp. => val method xp -example/Vals#xzlm. => private[this] 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(). => private[this] 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 +example/ValUsages. => final object ValUsages extends Object { self: ValUsages.type => +2 decls } +example/ValUsages.v. => val method v Vals +example/Vals# => abstract class Vals extends Object { self: Vals => +25 decls } +example/Vals#_explicitSetter(). => private[this] var method _explicitSetter Int +example/Vals#``(). => primary ctor (param p: Int, val param xp: Int, var param yp: Int): Vals +example/Vals#``().(p) => param p: Int +example/Vals#``().(xp) => val param xp: Int +example/Vals#``().(yp) => var param yp: Int +example/Vals#`explicitSetter_=`(). => method explicitSetter_= (param x: Int): Unit +example/Vals#`explicitSetter_=`().(x) => param x: Int +example/Vals#`yam_=`(). => var method yam_= (param x$1: Int): Unit +example/Vals#`yam_=`().(x$1) => param x$1: Int +example/Vals#`yfm_=`(). => final var method yfm_= (param x$1: Int): Unit +example/Vals#`yfm_=`().(x$1) => param x$1: Int +example/Vals#`yim_=`(). => var method yim_= (param x$1: Int): Unit +example/Vals#`yim_=`().(x$1) => param x$1: Int +example/Vals#`ym_=`(). => var method ym_= (param x$1: Int): Unit +example/Vals#`ym_=`().(x$1) => param x$1: Int +example/Vals#`yp_=`(). => var method yp_= (param x$1: Int): Unit +example/Vals#`yp_=`().(x$1) => param x$1: Int +example/Vals#explicitSetter(). => method explicitSetter => Int +example/Vals#m(). => method m => Unit +example/Vals#p. => private[this] val method p Int +example/Vals#xam. => abstract val method xam Int +example/Vals#xfm. => final val method xfm Int +example/Vals#xim. => implicit val method xim Int +example/Vals#xlm. => private[this] val method xlm Int +example/Vals#xm. => val method xm Int +example/Vals#xp. => val method xp Int +example/Vals#xzlm. => private[this] lazy val method xzlm Int +example/Vals#xzm. => lazy val method xzm Int +example/Vals#yam(). => abstract var method yam Int +example/Vals#yfm(). => final var method yfm Int +example/Vals#yim(). => implicit var method yim Int +example/Vals#ylm(). => private[this] var method ylm Int +example/Vals#ym(). => var method ym Int +example/Vals#yp(). => var method yp Int +local0 => val local xl: Int +local1 => lazy val local xzl: Int +local2 => implicit val local xil: Int +local3 => var local yl: Int +local4 => implicit var local yil: Int Occurrences: [0:8..0:15): example <- example/ [2:15..2:19): Vals <- example/Vals# -[2:19..2:19): <- 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. @@ -3348,7 +3370,6 @@ Occurrences: [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 ------------------- @@ -3359,20 +3380,19 @@ Uri => Vararg.scala Text => empty Language => Scala Symbols => 6 entries -Occurrences => 11 entries +Occurrences => 10 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 +example/Vararg# => class Vararg extends Object { self: Vararg => +3 decls } +example/Vararg#``(). => primary ctor (): Vararg +example/Vararg#add1(). => method add1 (param a: Int*): Unit +example/Vararg#add1().(a) => param a: Int* +example/Vararg#add2(). => method add2 (param a: Seq[Int]*): Unit +example/Vararg#add2().(a) => param a: Seq[Int]* 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# @@ -3391,36 +3411,35 @@ Uri => exports-example-Codec.scala Text => empty Language => Scala Symbols => 21 entries -Occurrences => 39 entries +Occurrences => 30 entries Symbols: -exports/example/Codec# => trait Codec -exports/example/Codec#[T] => typeparam T -exports/example/Codec#``(). => primary ctor -exports/example/Codec#``().(decode) => param decode -exports/example/Codec#``().(encode) => param encode -exports/example/Codec#decode(). => final method decode -exports/example/Codec#decode().(a) => param a -exports/example/Codec#decode. => private[this] val method decode -exports/example/Codec#encode(). => final method encode -exports/example/Codec#encode().(t) => param t -exports/example/Codec#encode. => private[this] val method encode -exports/example/Decoder# => trait Decoder -exports/example/Decoder#[T] => covariant typeparam T -exports/example/Decoder#``(). => primary ctor -exports/example/Decoder#decode(). => abstract method decode -exports/example/Decoder#decode().(a) => param a -exports/example/Encoder# => trait Encoder -exports/example/Encoder#[T] => contravariant typeparam T -exports/example/Encoder#``(). => primary ctor -exports/example/Encoder#encode(). => abstract method encode -exports/example/Encoder#encode().(t) => param t +exports/example/Codec# => trait Codec [typeparam T ] extends Object with Decoder[T] with Encoder[T] { self: Codec[T] => +6 decls } +exports/example/Codec#[T] => typeparam T +exports/example/Codec#``(). => primary ctor [typeparam T ](param decode: Decoder[T], param encode: Encoder[T]): Codec[T] +exports/example/Codec#``().(decode) => param decode: Decoder[T] +exports/example/Codec#``().(encode) => param encode: Encoder[T] +exports/example/Codec#decode(). => final method decode (param a: Array[Byte]): T +exports/example/Codec#decode().(a) => param a: Array[Byte] +exports/example/Codec#decode. => private[this] val method decode Decoder[T] +exports/example/Codec#encode(). => final method encode (param t: T): Array[Byte] +exports/example/Codec#encode().(t) => param t: T +exports/example/Codec#encode. => private[this] val method encode Encoder[T] +exports/example/Decoder# => trait Decoder [covariant typeparam T ] extends Object { self: Decoder[T] => +3 decls } +exports/example/Decoder#[T] => covariant typeparam T +exports/example/Decoder#``(). => primary ctor [covariant typeparam T ](): Decoder[T] +exports/example/Decoder#decode(). => abstract method decode (param a: Array[Byte]): T +exports/example/Decoder#decode().(a) => param a: Array[Byte] +exports/example/Encoder# => trait Encoder [contravariant typeparam T ] extends Object { self: Encoder[T] => +3 decls } +exports/example/Encoder#[T] => contravariant typeparam T +exports/example/Encoder#``(). => primary ctor [contravariant typeparam T ](): Encoder[T] +exports/example/Encoder#encode(). => abstract method encode (param t: T): Array[Byte] +exports/example/Encoder#encode().(t) => param t: T Occurrences: [0:8..0:15): exports -> exports/ [0:16..0:23): example <- exports/example/ [2:6..2:13): Decoder <- exports/example/Decoder# -[2:13..2:13): <- exports/example/Decoder#``(). [2:15..2:16): T <- exports/example/Decoder#[T] [3:6..3:12): decode <- exports/example/Decoder#decode(). [3:13..3:14): a <- exports/example/Decoder#decode().(a) @@ -3428,7 +3447,6 @@ Occurrences: [3:22..3:26): Byte -> scala/Byte# [3:30..3:31): T -> exports/example/Decoder#[T] [6:6..6:13): Encoder <- exports/example/Encoder# -[6:13..6:13): <- exports/example/Encoder#``(). [6:15..6:16): T <- exports/example/Encoder#[T] [7:6..7:12): encode <- exports/example/Encoder#encode(). [7:13..7:14): t <- exports/example/Encoder#encode().(t) @@ -3436,7 +3454,6 @@ Occurrences: [7:20..7:25): Array -> scala/Array# [7:26..7:30): Byte -> scala/Byte# [10:6..10:11): Codec <- exports/example/Codec# -[10:11..10:11): <- exports/example/Codec#``(). [10:12..10:13): T <- exports/example/Codec#[T] [10:15..10:21): decode <- exports/example/Codec#decode. [10:23..10:30): Decoder -> exports/example/Decoder# @@ -3449,13 +3466,7 @@ Occurrences: [11:26..11:33): Encoder -> exports/example/Encoder# [11:34..11:35): T -> exports/example/Codec#[T] [12:9..12:15): decode -> exports/example/Codec#decode. -[12:15..12:15): -> exports/example/Decoder#decode(). -[12:15..12:15): -> exports/example/Codec#decode().(a) -[12:16..12:16): <- exports/example/Codec#decode(). [13:9..13:15): encode -> exports/example/Codec#encode. -[13:15..13:15): -> exports/example/Encoder#encode(). -[13:15..13:15): -> exports/example/Codec#encode().(t) -[13:16..13:16): <- exports/example/Codec#encode(). expect/exports-package.scala ---------------------------- @@ -3465,14 +3476,17 @@ Schema => SemanticDB v4 Uri => exports-package.scala Text => empty Language => Scala -Symbols => 4 entries +Symbols => 7 entries Occurrences => 5 entries Symbols: -exports/`exports-package$package`. => final package object exports -exports/`exports-package$package`.Codec# => final type Codec -exports/`exports-package$package`.Decoder# => final type Decoder -exports/`exports-package$package`.Encoder# => final type Encoder +exports/`exports-package$package`. => final package object exports extends Object { self: exports.type => +4 decls } +exports/`exports-package$package`.Codec# => final type Codec [typeparam T ] = Codec[T] +exports/`exports-package$package`.Codec#[T] => typeparam T +exports/`exports-package$package`.Decoder# => final type Decoder [typeparam T ] = Decoder[T] +exports/`exports-package$package`.Decoder#[T] => typeparam T +exports/`exports-package$package`.Encoder# => final type Encoder [typeparam T ] = Encoder[T] +exports/`exports-package$package`.Encoder#[T] => typeparam T Occurrences: [0:8..0:15): exports <- exports/ @@ -3490,15 +3504,14 @@ Uri => filename%20with%20spaces.scala Text => empty Language => Scala Symbols => 2 entries -Occurrences => 3 entries +Occurrences => 2 entries Symbols: -example/FilenameWithSpaces# => class FilenameWithSpaces -example/FilenameWithSpaces#``(). => primary ctor +example/FilenameWithSpaces# => class FilenameWithSpaces extends Object { self: FilenameWithSpaces => +1 decls } +example/FilenameWithSpaces#``(). => primary ctor (): FilenameWithSpaces Occurrences: [0:8..0:15): example <- example/ -[2:0..2:0): <- example/FilenameWithSpaces#``(). [2:6..2:24): FilenameWithSpaces <- example/FilenameWithSpaces# expect/i9727.scala @@ -3510,29 +3523,104 @@ Uri => i9727.scala Text => empty Language => Scala Symbols => 7 entries -Occurrences => 11 entries +Occurrences => 8 entries Symbols: -i9727/Test# => class Test -i9727/Test#``(). => primary ctor -i9727/Test#``().(a) => param a -i9727/Test#a. => private[this] val method a -i9727/i9727$package. => final package object i9727 -i9727/i9727$package.a. => val method a -i9727/i9727$package.b. => val method b +i9727/Test# => class Test extends Object { self: Test => +2 decls } +i9727/Test#``(). => primary ctor (param a: Int): Test +i9727/Test#``().(a) => param a: Int +i9727/Test#a. => private[this] val method a Int +i9727/i9727$package. => final package object i9727 extends Object { self: i9727.type => +3 decls } +i9727/i9727$package.a. => val method a Test +i9727/i9727$package.b. => val method b Test Occurrences: [0:8..0:13): i9727 <- i9727/ [2:6..2:10): Test <- i9727/Test# -[2:10..2:10): <- i9727/Test#``(). [2:11..2:12): a <- i9727/Test#a. [2:14..2:17): Int -> scala/Int# [3:4..3:5): a <- i9727/i9727$package.a. [3:12..3:16): Test -> i9727/Test# -[3:16..3:16): -> i9727/Test#``(). [4:4..4:5): b <- i9727/i9727$package.b. [4:12..4:16): Test -> i9727/Test# -[4:16..4:16): -> i9727/Test#``(). + +expect/i9782.scala +------------------ + +Summary: +Schema => SemanticDB v4 +Uri => i9782.scala +Text => empty +Language => Scala +Symbols => 24 entries +Occurrences => 39 entries + +Symbols: +_empty_/Copy# => trait Copy [typeparam In <: Txn[In], typeparam Out <: Txn[Out]] extends Object { self: Copy[In, Out] => +5 decls } +_empty_/Copy#[In] => typeparam In <: Txn[In] +_empty_/Copy#[Out] => typeparam Out <: Txn[Out] +_empty_/Copy#``(). => primary ctor [typeparam In <: Txn[In], typeparam Out <: Txn[Out]](): Copy[In, Out] +_empty_/Copy#apply(). => method apply [typeparam Repr [typeparam ~ <: Txn[~]] <: Elem[~]](param in: Repr[In]): Repr[Out] +_empty_/Copy#apply().(in) => param in: Repr[In] +_empty_/Copy#apply().[Repr] => typeparam Repr [typeparam ~ <: Txn[~]] <: Elem[~] +_empty_/Copy#apply().[Repr][`~`] => typeparam ~ <: Txn[~] +_empty_/Copy#copyImpl(). => abstract method copyImpl [typeparam Repr [typeparam ~ <: Txn[~]] <: Elem[~]](param in: Repr[In]): Repr[Out] +_empty_/Copy#copyImpl().(in) => param in: Repr[In] +_empty_/Copy#copyImpl().[Repr] => typeparam Repr [typeparam ~ <: Txn[~]] <: Elem[~] +_empty_/Copy#copyImpl().[Repr][`~`] => typeparam ~ <: Txn[~] +_empty_/Elem# => trait Elem [typeparam T <: Txn[T]] extends Object { self: Elem[T] => +2 decls } +_empty_/Elem#[T] => typeparam T <: Txn[T] +_empty_/Elem#``(). => primary ctor [typeparam T <: Txn[T]](): Elem[T] +_empty_/Obj# => trait Obj [typeparam T <: Txn[T]] extends Object with Elem[T] { self: Obj[T] => +2 decls } +_empty_/Obj#[T] => typeparam T <: Txn[T] +_empty_/Obj#``(). => primary ctor [typeparam T <: Txn[T]](): Obj[T] +_empty_/Txn# => trait Txn [typeparam T <: Txn[T]] extends Object { self: Txn[T] => +2 decls } +_empty_/Txn#[T] => typeparam T <: Txn[T] +_empty_/Txn#``(). => primary ctor [typeparam T <: Txn[T]](): Txn[T] +local0 => val local out: Repr[Out] +local1 => val local inObj: Repr[In] & Obj[In] +local2 => val local outObj: Repr[Out] & Obj[Out] + +Occurrences: +[1:6..1:9): Txn <- _empty_/Txn# +[1:10..1:11): T <- _empty_/Txn#[T] +[3:6..3:10): Elem <- _empty_/Elem# +[3:11..3:12): T <- _empty_/Elem#[T] +[5:6..5:9): Obj <- _empty_/Obj# +[5:10..5:11): T <- _empty_/Obj#[T] +[5:31..5:35): Elem -> _empty_/Elem# +[5:36..5:37): T -> _empty_/Obj#[T] +[7:6..7:10): Copy <- _empty_/Copy# +[7:11..7:13): In <- _empty_/Copy#[In] +[7:26..7:29): Out <- _empty_/Copy#[Out] +[8:6..8:14): copyImpl <- _empty_/Copy#copyImpl(). +[8:15..8:19): Repr <- _empty_/Copy#copyImpl().[Repr] +[8:45..8:47): in <- _empty_/Copy#copyImpl().(in) +[8:49..8:53): Repr -> _empty_/Copy#copyImpl().[Repr] +[8:54..8:56): In -> _empty_/Copy#[In] +[8:60..8:64): Repr -> _empty_/Copy#copyImpl().[Repr] +[8:65..8:68): Out -> _empty_/Copy#[Out] +[10:6..10:11): apply <- _empty_/Copy#apply(). +[10:12..10:16): Repr <- _empty_/Copy#apply().[Repr] +[10:42..10:44): in <- _empty_/Copy#apply().(in) +[10:46..10:50): Repr -> _empty_/Copy#apply().[Repr] +[10:51..10:53): In -> _empty_/Copy#[In] +[10:57..10:61): Repr -> _empty_/Copy#apply().[Repr] +[10:62..10:65): Out -> _empty_/Copy#[Out] +[11:8..11:11): out <- local0 +[11:14..11:22): copyImpl -> _empty_/Copy#copyImpl(). +[11:23..11:27): Repr -> _empty_/Copy#apply().[Repr] +[11:29..11:31): in -> _empty_/Copy#apply().(in) +[12:5..12:7): in -> _empty_/Copy#apply().(in) +[12:9..12:12): out -> local0 +[13:12..13:17): inObj <- local1 +[13:19..13:22): Obj -> _empty_/Obj# +[13:23..13:25): In -> _empty_/Copy#[In] +[13:28..13:34): outObj <- local2 +[13:36..13:39): Obj -> _empty_/Obj# +[13:40..13:43): Out -> _empty_/Copy#[Out] +[14:8..14:15): println -> scala/Predef.println(+1). +[17:4..17:7): out -> local0 expect/inlineconsume.scala -------------------------- @@ -3543,12 +3631,12 @@ Uri => inlineconsume.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 9 entries +Occurrences => 8 entries Symbols: -inlineconsume/Foo# => class Foo -inlineconsume/Foo#``(). => primary ctor -inlineconsume/Foo#test(). => method test +inlineconsume/Foo# => class Foo extends Object { self: Foo => +2 decls } +inlineconsume/Foo#``(). => primary ctor (): Foo +inlineconsume/Foo#test(). => method test => Unit Occurrences: [0:8..0:21): inlineconsume <- inlineconsume/ @@ -3556,7 +3644,6 @@ Occurrences: [2:18..2:28): FakePredef -> inlinedefs/FakePredef. [2:29..2:35): assert -> inlinedefs/FakePredef.assert(). [4:6..4:9): Foo <- inlineconsume/Foo# -[5:2..5:2): <- inlineconsume/Foo#``(). [5:6..5:10): test <- inlineconsume/Foo#test(). [5:13..5:19): assert -> inlinedefs/FakePredef.assert(). [5:22..5:23): > -> scala/Int#`>`(+3). @@ -3570,12 +3657,12 @@ Uri => inlinedefs.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 12 entries +Occurrences => 10 entries Symbols: -inlinedefs/FakePredef. => final object FakePredef -inlinedefs/FakePredef.assert(). => final inline transparent macro assert -inlinedefs/FakePredef.assert().(assertion) => inline param assertion +inlinedefs/FakePredef. => final object FakePredef extends Object { self: FakePredef.type => +2 decls } +inlinedefs/FakePredef.assert(). => final inline transparent macro assert (inline param assertion: Boolean): Unit +inlinedefs/FakePredef.assert().(assertion) => inline param assertion: Boolean Occurrences: [0:8..0:18): inlinedefs <- inlinedefs/ @@ -3585,11 +3672,9 @@ Occurrences: [13:56..13:63): Boolean -> scala/Boolean# [13:66..13:70): Unit -> scala/Unit# [14:9..14:18): assertion -> inlinedefs/FakePredef.assert().(assertion) -[14:18..14:18): -> scala/Boolean#`unary_!`(). [15:16..15:20): java -> java/ [15:21..15:25): lang -> java/lang/ [15:26..15:40): AssertionError -> java/lang/AssertionError# -[15:40..15:40): -> java/lang/AssertionError#``(+2). expect/local-file.scala ----------------------- @@ -3600,22 +3685,80 @@ Uri => local-file.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 7 entries +Occurrences => 6 entries Symbols: -example/`local-file`# => class local-file -example/`local-file`#``(). => primary ctor -local0 => val local local +example/`local-file`# => class local-file extends Object { self: local-file => +1 decls } +example/`local-file`#``(). => primary ctor (): local-file +local0 => val local local: Int 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 -> scala/Predef.locally(). [4:8..4:13): local <- local0 [5:4..5:9): local -> local0 [5:10..5:11): + -> scala/Int#`+`(+4). +expect/nullary.scala +-------------------- + +Summary: +Schema => SemanticDB v4 +Uri => nullary.scala +Text => empty +Language => Scala +Symbols => 16 entries +Occurrences => 28 entries + +Symbols: +_empty_/Concrete# => class Concrete extends NullaryTest[Int, List] { self: Concrete => +3 decls } +_empty_/Concrete#``(). => primary ctor (): Concrete +_empty_/Concrete#nullary2(). => method nullary2 => Int +_empty_/Concrete#nullary3(). => method nullary3 => List[Int] +_empty_/NullaryTest# => abstract class NullaryTest [typeparam T , typeparam m [typeparam s ]] extends Object { self: NullaryTest[T, m] => +9 decls } +_empty_/NullaryTest#[T] => typeparam T +_empty_/NullaryTest#[m] => typeparam m [typeparam s ] +_empty_/NullaryTest#[m][s] => typeparam s +_empty_/NullaryTest#``(). => primary ctor [typeparam T , typeparam m [typeparam s ]](): NullaryTest[T, m] +_empty_/NullaryTest#nullary(). => method nullary => String +_empty_/NullaryTest#nullary2(). => abstract method nullary2 => T +_empty_/NullaryTest#nullary3(). => abstract method nullary3 => m[T] +_empty_/NullaryTest#x. => val method x String +_empty_/NullaryTest#x2. => val method x2 T +_empty_/NullaryTest#x3. => val method x3 m[T] +_empty_/test. => final object test extends Object { self: test.type => +1 decls } + +Occurrences: +[0:15..0:26): NullaryTest <- _empty_/NullaryTest# +[0:27..0:28): T <- _empty_/NullaryTest#[T] +[0:30..0:31): m <- _empty_/NullaryTest#[m] +[1:6..1:13): nullary <- _empty_/NullaryTest#nullary(). +[1:15..1:21): String -> scala/Predef.String# +[2:6..2:7): x <- _empty_/NullaryTest#x. +[2:10..2:17): nullary -> _empty_/NullaryTest#nullary(). +[4:6..4:14): nullary2 <- _empty_/NullaryTest#nullary2(). +[4:16..4:17): T -> _empty_/NullaryTest#[T] +[5:6..5:8): x2 <- _empty_/NullaryTest#x2. +[5:11..5:19): nullary2 -> _empty_/NullaryTest#nullary2(). +[7:6..7:14): nullary3 <- _empty_/NullaryTest#nullary3(). +[7:16..7:17): m -> _empty_/NullaryTest#[m] +[7:18..7:19): T -> _empty_/NullaryTest#[T] +[8:6..8:8): x3 <- _empty_/NullaryTest#x3. +[8:11..8:19): nullary3 -> _empty_/NullaryTest#nullary3(). +[11:6..11:14): Concrete <- _empty_/Concrete# +[11:23..11:34): NullaryTest -> _empty_/NullaryTest# +[11:35..11:38): Int -> scala/Int# +[11:40..11:44): List -> scala/package.List# +[12:6..12:14): nullary2 <- _empty_/Concrete#nullary2(). +[13:6..13:14): nullary3 <- _empty_/Concrete#nullary3(). +[13:17..13:21): List -> scala/package.List. +[16:7..16:11): test <- _empty_/test. +[17:7..17:15): Concrete -> _empty_/Concrete# +[17:17..17:25): nullary2 -> _empty_/Concrete#nullary2(). +[18:7..18:15): Concrete -> _empty_/Concrete# +[18:17..18:25): nullary3 -> _empty_/Concrete#nullary3(). + expect/recursion.scala ---------------------- @@ -3625,55 +3768,53 @@ Uri => recursion.scala Text => empty Language => Scala Symbols => 36 entries -Occurrences => 56 entries +Occurrences => 45 entries Symbols: -local0 => case val method N$1 -local1 => val local p -local2 => case val method N$2 -local3 => val local p -local4 => val local Nat_this -local5 => val local Nat_this -local6 => val local Nat_this -recursion/Nats. => final object Nats -recursion/Nats.Nat# => sealed trait Nat -recursion/Nats.Nat#`++`(). => inline transparent macro ++ -recursion/Nats.Nat#`+`(). => inline transparent macro + -recursion/Nats.Nat#`+`().(that) => inline param that -recursion/Nats.Nat#``(). => primary ctor -recursion/Nats.Succ# => case class Succ -recursion/Nats.Succ#[N] => typeparam N -recursion/Nats.Succ#_1(). => method _1 -recursion/Nats.Succ#``(). => primary ctor -recursion/Nats.Succ#``().(p) => val param p -recursion/Nats.Succ#copy$default$1(). => method copy$default$1 -recursion/Nats.Succ#copy$default$1().[N] => typeparam N -recursion/Nats.Succ#copy(). => method copy -recursion/Nats.Succ#copy().(p) => param p -recursion/Nats.Succ#copy().[N] => typeparam N -recursion/Nats.Succ#p. => val method p -recursion/Nats.Succ. => final object Succ -recursion/Nats.Succ.apply(). => method apply -recursion/Nats.Succ.apply().(p) => param p -recursion/Nats.Succ.apply().[N] => typeparam N -recursion/Nats.Succ.toString(). => method toString -recursion/Nats.Succ.unapply(). => method unapply -recursion/Nats.Succ.unapply().(x$1) => param x$1 -recursion/Nats.Succ.unapply().[N] => typeparam N -recursion/Nats.Zero. => final case object Zero -recursion/Nats.j31. => val method j31 -recursion/Nats.toIntg(). => inline transparent macro toIntg -recursion/Nats.toIntg().(n) => inline param n +local0 => case val method N$1 <: Nat +local1 => val local p: N$1 +local2 => case val method N$2 <: Nat +local3 => val local p: N$2 +local4 => val local Nat_this: Zero.type +local5 => val local Nat_this: Succ[Zero.type] +local6 => val local Nat_this: Succ[_] forSome { type _ <: Succ[Zero.type] } +recursion/Nats. => final object Nats extends Object { self: Nats.type => +9 decls } +recursion/Nats.Nat# => sealed trait Nat extends Object { self: Nat => +3 decls } +recursion/Nats.Nat#`++`(). => inline transparent macro ++ => Succ[Nat.this.type] +recursion/Nats.Nat#`+`(). => inline transparent macro + (inline param that: Nat): Nat +recursion/Nats.Nat#`+`().(that) => inline param that: Nat +recursion/Nats.Nat#``(). => primary ctor (): Nat +recursion/Nats.Succ# => case class Succ [typeparam N <: Nat] extends Object with Nat with Product with Serializable { self: Succ[N] => +6 decls } +recursion/Nats.Succ#[N] => typeparam N <: Nat +recursion/Nats.Succ#_1(). => method _1 => N +recursion/Nats.Succ#``(). => primary ctor [typeparam N <: Nat](val param p: N): Succ[N] +recursion/Nats.Succ#``().(p) => val param p: N +recursion/Nats.Succ#copy$default$1(). => method copy$default$1 [typeparam N <: Nat]: N +recursion/Nats.Succ#copy$default$1().[N] => typeparam N <: Nat +recursion/Nats.Succ#copy(). => method copy [typeparam N <: Nat](param p: N): Succ[N] +recursion/Nats.Succ#copy().(p) => param p: N +recursion/Nats.Succ#copy().[N] => typeparam N <: Nat +recursion/Nats.Succ#p. => val method p N +recursion/Nats.Succ. => final object Succ extends Object { self: Succ.type => +4 decls } +recursion/Nats.Succ.apply(). => method apply [typeparam N <: Nat](param p: N): Succ[N] +recursion/Nats.Succ.apply().(p) => param p: N +recursion/Nats.Succ.apply().[N] => typeparam N <: Nat +recursion/Nats.Succ.toString(). => method toString => String +recursion/Nats.Succ.unapply(). => method unapply [typeparam N <: Nat](param x$1: Succ[N]): Succ[N] +recursion/Nats.Succ.unapply().(x$1) => param x$1: Succ[N] +recursion/Nats.Succ.unapply().[N] => typeparam N <: Nat +recursion/Nats.Zero. => final case object Zero extends Object with Nat with Product with Serializable { self: Zero.type => +1 decls } +recursion/Nats.j31. => val method j31 Int +recursion/Nats.toIntg(). => inline transparent macro toIntg (inline param n: Nat): Int +recursion/Nats.toIntg().(n) => inline param n: Nat Occurrences: [1:8..1:17): recursion <- recursion/ [3:7..3:11): Nats <- recursion/Nats. [4:15..4:18): Nat <- recursion/Nats.Nat# -[5:4..5:4): <- recursion/Nats.Nat#``(). [5:27..5:29): ++ <- recursion/Nats.Nat#`++`(). [5:32..5:36): Succ -> recursion/Nats.Succ# [5:50..5:54): Succ -> recursion/Nats.Succ. -[5:54..5:54): -> recursion/Nats.Succ.apply(). [7:27..7:28): + <- recursion/Nats.Nat#`+`(). [7:36..7:40): that <- recursion/Nats.Nat#`+`().(that) [7:42..7:45): Nat -> recursion/Nats.Nat# @@ -3681,8 +3822,6 @@ Occurrences: [9:13..9:17): Zero -> recursion/Nats.Zero. [9:24..9:28): that -> recursion/Nats.Nat#`+`().(that) [10:13..10:17): Succ -> recursion/Nats.Succ. -[10:17..10:17): -> recursion/Nats.Succ.unapply(). -[10:17..10:17): -> local0 [10:18..10:19): p <- local1 [10:24..10:25): p -> local1 [10:26..10:27): + -> recursion/Nats.Nat#`+`(). @@ -3691,7 +3830,6 @@ Occurrences: [14:14..14:18): Zero <- recursion/Nats.Zero. [14:27..14:30): Nat -> recursion/Nats.Nat# [15:13..15:17): Succ <- recursion/Nats.Succ# -[15:17..15:17): <- recursion/Nats.Succ#``(). [15:18..15:19): N <- recursion/Nats.Succ#[N] [15:28..15:29): p <- recursion/Nats.Succ#p. [15:31..15:32): N -> recursion/Nats.Succ#[N] @@ -3703,8 +3841,6 @@ Occurrences: [18:11..18:12): n -> recursion/Nats.toIntg().(n) [19:11..19:15): Zero -> recursion/Nats.Zero. [20:11..20:15): Succ -> recursion/Nats.Succ. -[20:15..20:15): -> recursion/Nats.Succ.unapply(). -[20:15..20:15): -> local2 [20:16..20:17): p <- local3 [20:22..20:28): toIntg -> recursion/Nats.toIntg(). [20:29..20:30): p -> local3 @@ -3712,12 +3848,8 @@ Occurrences: [23:6..23:9): j31 <- recursion/Nats.j31. [23:12..23:18): toIntg -> recursion/Nats.toIntg(). [23:19..23:23): Zero -> recursion/Nats.Zero. -[23:24..23:32): ++.++.++ <- local4 -[23:24..23:24): -> recursion/Nats.Zero. [23:24..23:26): ++ -> recursion/Nats.Nat#`++`(). -[23:27..23:35): ++.++ + <- local5 [23:27..23:29): ++ -> recursion/Nats.Nat#`++`(). -[23:30..23:38): ++ + Zer <- local6 [23:30..23:32): ++ -> recursion/Nats.Nat#`++`(). [23:33..23:34): + -> recursion/Nats.Nat#`+`(). [23:35..23:39): Zero -> recursion/Nats.Zero. @@ -3732,19 +3864,19 @@ Uri => semanticdb-Definitions.scala Text => empty Language => Scala Symbols => 10 entries -Occurrences => 9 entries +Occurrences => 7 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 +a/Definitions. => final object Definitions extends Object { self: Definitions.type => +9 decls } +a/Definitions.D# => class D extends Object { self: D => +1 decls } +a/Definitions.D#``(). => primary ctor (): D +a/Definitions.E# => trait E extends Object { self: E => +1 decls } +a/Definitions.E#``(). => primary ctor (): E +a/Definitions.`b_=`(). => var method b_= (param x$1: Int): Unit +a/Definitions.`b_=`().(x$1) => param x$1: Int +a/Definitions.a. => val method a Int +a/Definitions.b(). => var method b Int +a/Definitions.c(). => method c => Int Occurrences: [0:8..0:9): a <- a/ @@ -3752,9 +3884,7 @@ Occurrences: [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/semanticdb-Flags.scala @@ -3766,59 +3896,59 @@ Uri => semanticdb-Flags.scala Text => empty Language => Scala Symbols => 50 entries -Occurrences => 82 entries +Occurrences => 73 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. => private[this] 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. => private[this] val method x -flags/p/package.C#y. => private[this] val method y -flags/p/package.C#z. => private[this] 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_=`(). => protected var method y_= -flags/p/package.`y_=`().(x$1) => param x$1 -flags/p/package.m(). => macro m -flags/p/package.m().[TT] => typeparam TT -flags/p/package.x. => private[flags/p/] lazy val method x -flags/p/package.xs1. => val method xs1 -flags/p/package.y(). => protected 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 +flags/p/package. => final package object p extends Object { self: p.type => +23 decls } +flags/p/package.AA# => class AA extends Object { self: AA => +5 decls } +flags/p/package.AA#``(). => primary ctor (param x: Int, val param y: Int, var param z: Int): AA +flags/p/package.AA#``().(x) => param x: Int +flags/p/package.AA#``().(y) => val param y: Int +flags/p/package.AA#``().(z) => var param z: Int +flags/p/package.AA#`z_=`(). => var method z_= (param x$1: Int): Unit +flags/p/package.AA#`z_=`().(x$1) => param x$1: Int +flags/p/package.AA#x. => private[this] val method x Int +flags/p/package.AA#y. => val method y Int +flags/p/package.AA#z(). => var method z Int +flags/p/package.C# => abstract class C [covariant typeparam T , contravariant typeparam U , typeparam V ] extends Object { self: C[T, U, V] => +10 decls } +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 [covariant typeparam T , contravariant typeparam U , typeparam V ](param x: T, param y: U, param z: V): C[T, U, V] +flags/p/package.C#``().(x) => param x: T +flags/p/package.C#``().(y) => param y: U +flags/p/package.C#``().(z) => param z: V +flags/p/package.C#``(+1). => ctor [covariant typeparam T , contravariant typeparam U , typeparam V ](): C[T, U, V] +flags/p/package.C#``(+2). => ctor [covariant typeparam T , contravariant typeparam U , typeparam V ](param t: T): C[T, U, V] +flags/p/package.C#``(+2).(t) => param t: T +flags/p/package.C#w(). => abstract method w => Int +flags/p/package.C#x. => private[this] val method x T +flags/p/package.C#y. => private[this] val method y U +flags/p/package.C#z. => private[this] val method z V +flags/p/package.S# => class S [typeparam T ] extends Object { self: S[T] => +2 decls } +flags/p/package.S#[T] => typeparam T +flags/p/package.S#``(). => primary ctor [typeparam T ](): S[T] +flags/p/package.T1# => type T1 = Int +flags/p/package.T2# => type T2 [typeparam T ] = S[T] +flags/p/package.T2#[T] => typeparam T +flags/p/package.U# => type U <: Int +flags/p/package.V# => type V >: Int +flags/p/package.X. => final case object X extends Object with Product with Serializable { self: X.type => +1 decls } +flags/p/package.Y# => final class Y extends Object { self: Y => +1 decls } +flags/p/package.Y#``(). => primary ctor (): Y +flags/p/package.Z# => sealed trait Z extends Object { self: Z => +1 decls } +flags/p/package.Z#``(). => primary ctor (): Z +flags/p/package.`y_=`(). => protected var method y_= (param x$1: Int): Unit +flags/p/package.`y_=`().(x$1) => param x$1: Int +flags/p/package.m(). => macro m [typeparam TT ]: Int +flags/p/package.m().[TT] => typeparam TT +flags/p/package.x. => private[flags/p/] lazy val method x Int +flags/p/package.xs1. => val method xs1 Nothing +flags/p/package.y(). => protected implicit var method y Int +flags/p/package.z(). => method z (param pp: Int): Int +flags/p/package.z().(pp) => param pp: Int +local0 => val local xs2: Nothing +local1 => case val method t Occurrences: [0:8..0:13): flags <- flags/ @@ -3839,7 +3969,6 @@ Occurrences: [8:13..8:16): Int -> scala/Int# [8:25..8:28): ??? -> scala/Predef.`???`(). [9:17..9:18): C <- flags/p/package.C# -[9:18..9:18): <- 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] @@ -3850,14 +3979,12 @@ Occurrences: [9:42..9:43): z <- flags/p/package.C#z. [9:45..9:46): V -> flags/p/package.C#[V] [10:8..10:12): <- 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:12): <- 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.`???`(). @@ -3874,12 +4001,9 @@ Occurrences: [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:10): <- 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. @@ -3887,16 +4011,13 @@ Occurrences: [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:9): <- 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.`???`(). @@ -3912,152 +4033,154 @@ Schema => SemanticDB v4 Uri => semanticdb-Types.scala Text => empty Language => Scala -Symbols => 142 entries -Occurrences => 250 entries +Symbols => 144 entries +Occurrences => 225 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/Foo# => case class Foo -types/Foo#_1(). => method _1 -types/Foo#``(). => primary ctor -types/Foo#``().(s) => val param s -types/Foo#copy$default$1(). => method copy$default$1 -types/Foo#copy(). => method copy -types/Foo#copy().(s) => param s -types/Foo#s. => val method s -types/Foo. => final object Foo -types/Foo.apply(). => method apply -types/Foo.apply().(s) => param s -types/Foo.toString(). => method toString -types/Foo.unapply(). => method unapply -types/Foo.unapply().(x$1) => param x$1 -types/Foo.x. => val method x -types/Foo.y. => val method y -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.toString(). => method toString -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. => private[this] val method x -types/ann1# => class ann1 -types/ann1#``(). => primary ctor -types/ann2# => class ann2 -types/ann2#``(). => primary ctor +local0 => abstract method k => Int +local1 => abstract method k => Int +local2 => method k => Int +local3 => final class $anon extends Object { self: $anon => +2 decls } +local5 => final class $anon extends M with N { self: $anon => +1 decls } +local7 => method k => Int +local8 => final class $anon extends M with N { self: $anon => +2 decls } +local10 => typeparam T +local11 => type L [typeparam T ] = List[T] +types/B# => class B extends Object { self: B => +1 decls } +types/B#``(). => primary ctor (): B +types/C# => class C extends Object { self: C => +1 decls } +types/C#``(). => primary ctor (): C +types/Foo# => case class Foo extends Object with Product with Serializable { self: Foo => +5 decls } +types/Foo#_1(). => method _1 => "abc" +types/Foo#``(). => primary ctor (val param s: "abc"): Foo +types/Foo#``().(s) => val param s: "abc" +types/Foo#copy$default$1(). => method copy$default$1 => "abc" @uncheckedVariance +types/Foo#copy(). => method copy (param s: "abc"): Foo +types/Foo#copy().(s) => param s: "abc" +types/Foo#s. => val method s "abc" +types/Foo. => final object Foo extends Object { self: Foo.type => +6 decls } +types/Foo.apply(). => method apply (param s: "abc"): Foo +types/Foo.apply().(s) => param s: "abc" +types/Foo.toString(). => method toString => String +types/Foo.unapply(). => method unapply (param x$1: Foo): Foo +types/Foo.unapply().(x$1) => param x$1: Foo +types/Foo.x. => val method x "abc" @deprecated +types/Foo.y. => val method y "abc" +types/P# => class P extends Object { self: P => +8 decls } +types/P#C# => class C extends Object { self: C => +1 decls } +types/P#C#``(). => primary ctor (): C +types/P#X# => class X extends Object { self: X => +1 decls } +types/P#X#``(). => primary ctor (): X +types/P#``(). => primary ctor (): P +types/P#x. => val method x X +types/T# => class T extends Object { self: T => +8 decls } +types/T#C# => class C extends Object { self: C => +1 decls } +types/T#C#``(). => primary ctor (): C +types/T#X# => class X extends Object { self: X => +1 decls } +types/T#X#``(). => primary ctor (): X +types/T#``(). => primary ctor (): T +types/T#x. => val method x X +types/Test. => final object Test extends Object { self: Test.type => +10 decls } +types/Test.C# => class C extends M { self: C => +42 decls } +types/Test.C#ByNameType. => final object ByNameType extends Object { self: ByNameType.type => +2 decls } +types/Test.C#ByNameType.m1(). => method m1 (param x: => Int): Int +types/Test.C#ByNameType.m1().(x) => param x: => Int +types/Test.C#ClassInfoType1. => final object ClassInfoType1 extends Object { self: ClassInfoType1.type => +1 decls } +types/Test.C#ClassInfoType2# => class ClassInfoType2 extends B { self: ClassInfoType2 => +2 decls } +types/Test.C#ClassInfoType2#``(). => primary ctor (): ClassInfoType2 +types/Test.C#ClassInfoType2#x(). => method x => Int +types/Test.C#ClassInfoType3# => trait ClassInfoType3 [typeparam T ] extends Object { self: ClassInfoType3[T] => +2 decls } +types/Test.C#ClassInfoType3#[T] => typeparam T +types/Test.C#ClassInfoType3#``(). => primary ctor [typeparam T ](): ClassInfoType3[T] +types/Test.C#Either. => val method Either Either.type +types/Test.C#MethodType. => final object MethodType extends Object { self: MethodType.type => +7 decls } +types/Test.C#MethodType.m3(). => method m3 => Int +types/Test.C#MethodType.m4(). => method m4 (): Int +types/Test.C#MethodType.m5(). => method m5 (param x: Int): Int +types/Test.C#MethodType.m5().(x) => param x: Int +types/Test.C#MethodType.m6(). => method m6 [typeparam T ](param x: T): T +types/Test.C#MethodType.m6().(x) => param x: T +types/Test.C#MethodType.m6().[T] => typeparam T +types/Test.C#MethodType.x1(). => method x1 => Int +types/Test.C#MethodType.x2(). => method x2 => Int +types/Test.C#RepeatedType# => case class RepeatedType extends Object with Product with Serializable { self: RepeatedType => +4 decls } +types/Test.C#RepeatedType#_1(). => method _1 => String* +types/Test.C#RepeatedType#``(). => primary ctor (val param s: String*): RepeatedType +types/Test.C#RepeatedType#``().(s) => val param s: String* +types/Test.C#RepeatedType#m1(). => method m1 (param x: Int*): Int +types/Test.C#RepeatedType#m1().(x) => param x: Int* +types/Test.C#RepeatedType#s. => val method s String* +types/Test.C#RepeatedType. => final object RepeatedType extends Object { self: RepeatedType.type => +4 decls } +types/Test.C#RepeatedType.apply(). => method apply (param s: String*): RepeatedType +types/Test.C#RepeatedType.apply().(s) => param s: String* +types/Test.C#RepeatedType.toString(). => method toString => String +types/Test.C#RepeatedType.unapplySeq(). => method unapplySeq (param x$1: RepeatedType): RepeatedType +types/Test.C#RepeatedType.unapplySeq().(x$1) => param x$1: RepeatedType +types/Test.C#TypeType. => final object TypeType extends Object { self: TypeType.type => +6 decls } +types/Test.C#TypeType.T1# => type T1 +types/Test.C#TypeType.T4# => type T4 = C +types/Test.C#TypeType.T5# => type T5 [typeparam U ] = U +types/Test.C#TypeType.T5#[U] => typeparam U +types/Test.C#TypeType.m2(). => method m2 [typeparam T2 = C]: Nothing +types/Test.C#TypeType.m2().[T2] => typeparam T2 = C +types/Test.C#TypeType.m3(). => method m3 [typeparam M3 [type _ ]]: Nothing +types/Test.C#TypeType.m3().[M3] => typeparam M3 [type _ ] +types/Test.C#TypeType.m3().[M3][_] => type _ +types/Test.C#``(). => primary ctor (): C +types/Test.C#annType1. => val method annType1 T @ann[T] +types/Test.C#annType2. => val method annType2 T @ann1 @ann2 +types/Test.C#compoundType1. => val method compoundType1 Object { abstract method k => Int } +types/Test.C#compoundType2. => val method compoundType2 M & N +types/Test.C#compoundType3. => val method compoundType3 M & N { abstract method k => Int } +types/Test.C#compoundType4. => val method compoundType4 Object +types/Test.C#compoundType5. => val method compoundType5 M & N +types/Test.C#compoundType6. => val method compoundType6 M & N +types/Test.C#existentialType2. => val method existentialType2 List[_] forSome { type _ } +types/Test.C#existentialType3. => val method existentialType3 Class[_] forSome { type _ } +types/Test.C#existentialType4. => val method existentialType4 Class[_] forSome { type _ } +types/Test.C#p. => val method p P +types/Test.C#singleType1. => val method singleType1 x.type +types/Test.C#singleType2. => val method singleType2 p.x.type +types/Test.C#superType1. => val method superType1 Int +types/Test.C#superType2. => val method superType2 Int +types/Test.C#superType3. => val method superType3 Int +types/Test.C#thisType1. => val method thisType1 C.this.type +types/Test.C#thisType2. => val method thisType2 C.this.type +types/Test.C#typeLambda1(). => method typeLambda1 [typeparam M [type _ ]]: Nothing +types/Test.C#typeLambda1().[M] => typeparam M [type _ ] +types/Test.C#typeLambda1().[M][_] => type _ +types/Test.C#typeRef1. => val method typeRef1 C +types/Test.C#typeRef2. => val method typeRef2 p.C +types/Test.C#typeRef3. => val method typeRef3 T#C +types/Test.C#typeRef4. => val method typeRef4 List[Int] +types/Test.C#x. => val method x p.X +types/Test.Literal. => final object Literal extends Object { self: Literal.type => +12 decls } +types/Test.Literal.bool. => final val method bool true +types/Test.Literal.char. => final val method char 'a' +types/Test.Literal.clazzOf. => final val method clazzOf Option[Int] +types/Test.Literal.double. => final val method double 2.0 +types/Test.Literal.float. => final val method float 1.0f +types/Test.Literal.int. => final val method int 1 +types/Test.Literal.javaEnum. => final val method javaEnum LinkOption +types/Test.Literal.long. => final val method long 1L +types/Test.Literal.nil. => final val method nil Null +types/Test.Literal.string. => final val method string "a" +types/Test.Literal.unit. => final val method unit Unit +types/Test.M# => class M extends Object { self: M => +2 decls } +types/Test.M#``(). => primary ctor (): M +types/Test.M#m(). => method m => Int +types/Test.N# => trait N extends Object { self: N => +2 decls } +types/Test.N#``(). => primary ctor (): N +types/Test.N#n(). => method n => Int +types/ann# => class ann [typeparam T ] extends Annotation with StaticAnnotation { self: ann[T] => +3 decls } +types/ann#[T] => typeparam T +types/ann#``(). => primary ctor [typeparam T ](param x: T): ann[T] +types/ann#``().(x) => param x: T +types/ann#x. => private[this] val method x T +types/ann1# => class ann1 extends Annotation with StaticAnnotation { self: ann1 => +1 decls } +types/ann1#``(). => primary ctor (): ann1 +types/ann2# => class ann2 extends Annotation with StaticAnnotation { self: ann2 => +1 decls } +types/ann2#``(). => primary ctor (): ann2 Occurrences: [0:8..0:13): types <- types/ @@ -4068,7 +4191,6 @@ Occurrences: [3:13..3:21): language -> scala/language. [3:22..3:33): higherKinds -> scala/language.higherKinds. [5:6..5:9): ann <- types/ann# -[5:9..5:9): <- 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] @@ -4076,39 +4198,26 @@ Occurrences: [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:11..25:14): Foo <- types/Foo# -[25:14..25:14): <- types/Foo#``(). [25:15..25:16): s <- types/Foo#s. [27:7..27:10): Foo <- types/Foo. [28:6..28:7): x <- types/Foo.x. @@ -4117,22 +4226,17 @@ Occurrences: [29:17..29:18): x -> types/Foo.x. [32:7..32:11): Test <- types/Test. [33:8..33:9): M <- types/Test.M# -[34:4..34:4): <- types/Test.M#``(). [34:8..34:9): m <- types/Test.M#m(). [34:11..34:14): Int -> scala/Int# [34:17..34:20): ??? -> scala/Predef.`???`(). [37:8..37:9): N <- types/Test.N# -[38:4..38:4): <- types/Test.N#``(). [38:8..38:9): n <- types/Test.N#n(). [38:11..38:14): Int -> scala/Int# [38:17..38:20): ??? -> scala/Predef.`???`(). [41:8..41:9): C <- types/Test.C# -[41:18..41:18): <- types/Test.C#``(). [41:18..41:19): M -> types/Test.M# -[41:19..41:19): -> types/Test.M#``(). [42:8..42:9): p <- types/Test.C#p. [42:16..42:17): P -> types/P# -[42:17..42:17): -> types/P#``(). [43:8..43:9): x <- types/Test.C#x. [43:12..43:13): p -> types/Test.C#p. [43:14..43:15): x -> types/P#x. @@ -4187,18 +4291,16 @@ Occurrences: [63:41..63:44): Int -> scala/Int# [63:49..63:52): ??? -> scala/Predef.`???`(). [64:8..64:21): compoundType4 <- types/Test.C#compoundType4. -[64:34..64:35): k <- local3 +[64:34..64:35): k <- local2 [64:37..64:40): Int -> scala/Int# [64:43..64:46): ??? -> scala/Predef.`???`(). [65:8..65:21): compoundType5 <- types/Test.C#compoundType5. [65:28..65:29): M -> types/Test.M# -[65:29..65:29): -> types/Test.M#``(). [65:35..65:36): N -> types/Test.N# [66:8..66:21): compoundType6 <- types/Test.C#compoundType6. [66:28..66:29): M -> types/Test.M# -[66:29..66:29): -> types/Test.M#``(). [66:35..66:36): N -> types/Test.N# -[66:43..66:44): k <- local6 +[66:43..66:44): k <- local7 [66:46..66:49): Int -> scala/Int# [66:52..66:55): ??? -> scala/Predef.`???`(). [68:8..68:16): annType1 <- types/Test.C#annType1. @@ -4222,18 +4324,15 @@ Occurrences: [75:20..75:21): M <- types/Test.C#typeLambda1().[M] [75:28..75:31): ??? -> scala/Predef.`???`(). [76:4..76:15): typeLambda1 -> types/Test.C#typeLambda1(). -[76:24..76:25): L <- local7 -[76:26..76:27): T <- local8 +[76:24..76:25): L <- local11 +[76:26..76:27): T <- local10 [76:31..76:35): List -> scala/package.List# -[76:36..76:37): T -> local8 +[76:36..76:37): T -> local10 [78:11..78:25): ClassInfoType1 <- types/Test.C#ClassInfoType1. [79:10..79:24): ClassInfoType2 <- types/Test.C#ClassInfoType2# -[79:33..79:33): <- types/Test.C#ClassInfoType2#``(). [79:33..79:34): B -> types/B# -[79:34..79:34): -> types/B#``(). [79:41..79:42): x <- types/Test.C#ClassInfoType2#x(). [80:10..80:24): ClassInfoType3 <- types/Test.C#ClassInfoType3# -[80:24..80:24): <- types/Test.C#ClassInfoType3#``(). [80:25..80:26): T <- types/Test.C#ClassInfoType3#[T] [82:11..82:21): MethodType <- types/Test.C#MethodType. [83:10..83:12): x1 <- types/Test.C#MethodType.x1(). @@ -4266,7 +4365,6 @@ Occurrences: [92:25..92:28): Int -> scala/Int# [92:31..92:34): ??? -> scala/Predef.`???`(). [95:15..95:27): RepeatedType <- types/Test.C#RepeatedType# -[95:27..95:27): <- types/Test.C#RepeatedType#``(). [95:28..95:29): s <- types/Test.C#RepeatedType#s. [95:31..95:37): String -> scala/Predef.String# [96:10..96:12): m1 <- types/Test.C#RepeatedType#m1(). @@ -4320,27 +4418,27 @@ Uri => semanticdb-extract.scala Text => empty Language => Scala Symbols => 18 entries -Occurrences => 22 entries +Occurrences => 20 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.toString(). => method toString -_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 +_empty_/AnObject. => final object AnObject extends Object { self: AnObject.type => +6 decls } +_empty_/AnObject.Foo# => case class Foo extends Object with Product with Serializable { self: Foo => +5 decls } +_empty_/AnObject.Foo#_1(). => method _1 => Int +_empty_/AnObject.Foo#``(). => primary ctor (val param x: Int): Foo +_empty_/AnObject.Foo#``().(x) => val param x: Int +_empty_/AnObject.Foo#copy$default$1(). => method copy$default$1 => Int @uncheckedVariance +_empty_/AnObject.Foo#copy(). => method copy (param x: Int): Foo +_empty_/AnObject.Foo#copy().(x) => param x: Int +_empty_/AnObject.Foo#x. => val method x Int +_empty_/AnObject.Foo. => final object Foo extends Object { self: Foo.type => +4 decls } +_empty_/AnObject.Foo.apply(). => method apply (param x: Int): Foo +_empty_/AnObject.Foo.apply().(x) => param x: Int +_empty_/AnObject.Foo.toString(). => method toString => String +_empty_/AnObject.Foo.unapply(). => method unapply (param x$1: Foo): Foo +_empty_/AnObject.Foo.unapply().(x$1) => param x$1: Foo +_empty_/AnObject.foo(). => method foo (param x: Int): Unit +_empty_/AnObject.foo().(x) => param x: Int +_empty_/AnObject.foo(+1). => method foo (): Unit Occurrences: [0:7..0:15): AnObject <- _empty_/AnObject. @@ -4354,7 +4452,6 @@ Occurrences: [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. @@ -4362,7 +4459,6 @@ Occurrences: [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:16): <- _empty_/AnObject.Foo#``(). [16:17..16:18): x <- _empty_/AnObject.Foo#x. [16:20..16:23): Int -> scala/Int# @@ -4375,28 +4471,28 @@ Uri => toplevel.scala Text => empty Language => Scala Symbols => 19 entries -Occurrences => 44 entries +Occurrences => 34 entries Symbols: -_empty_/MyProgram# => final class MyProgram -_empty_/MyProgram#``(). => primary ctor -_empty_/MyProgram#main(). => static method main -_empty_/MyProgram#main().(args) => param args -_empty_/toplevel$package. => final package object _empty_ -_empty_/toplevel$package.MyProgram(). => method MyProgram -_empty_/toplevel$package.MyProgram().(times) => param times -_empty_/toplevel$package.a. => val inline 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 -_empty_/toplevel$package.fooRef(). => method fooRef -local0 => val local error +_empty_/MyProgram# => final class MyProgram extends Object { self: MyProgram => +2 decls } +_empty_/MyProgram#``(). => primary ctor (): MyProgram +_empty_/MyProgram#main(). => static method main (param args: Array[String]): Unit +_empty_/MyProgram#main().(args) => param args: Array[String] +_empty_/toplevel$package. => final package object _empty_ extends Object { self: _empty_.type => +8 decls } +_empty_/toplevel$package.MyProgram(). => method MyProgram (param times: Int): Unit +_empty_/toplevel$package.MyProgram().(times) => param times: Int +_empty_/toplevel$package.a. => val inline method a "" +_empty_/toplevel$package.combine(). => method combine (param x: Int)(param y: Int): Int +_empty_/toplevel$package.combine().(x) => param x: Int +_empty_/toplevel$package.combine().(y) => param y: Int +_empty_/toplevel$package.combine(+1). => method combine (param x: Int, param y: Int, param z: Int): Int +_empty_/toplevel$package.combine(+1).(x) => param x: Int +_empty_/toplevel$package.combine(+1).(y) => param y: Int +_empty_/toplevel$package.combine(+1).(z) => param z: Int +_empty_/toplevel$package.combine(+2). => method combine => Int +_empty_/toplevel$package.foo(). => method foo => String +_empty_/toplevel$package.fooRef(). => method fooRef => String +local0 => val local error: ParseError Occurrences: [0:11..0:12): a <- _empty_/toplevel$package.a. @@ -4422,25 +4518,15 @@ Occurrences: [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(). -[5:0..5:0): <- _empty_/MyProgram# -[5:0..5:0): <- _empty_/MyProgram#``(). -[5:0..5:0): -> _empty_/toplevel$package.MyProgram(). -[5:0..5:0): -> scala/util/CommandLineParser.parseArgument(). -[5:0..5:0): -> _empty_/MyProgram#main().(args) -[5:0..5:0): -> scala/util/CommandLineParser.FromString.given_FromString_Int. -[5:0..5:0): -> scala/util/CommandLineParser.showError(). -[5:0..5:0): -> local0 [5:1..5:5): main -> scala/main# [5:10..5:19): MyProgram <- _empty_/toplevel$package.MyProgram(). [5:20..5:25): times <- _empty_/toplevel$package.MyProgram().(times) [5:27..5:30): Int -> scala/Int# [5:33..5:37): Unit -> scala/Unit# -[5:41..5:41): -> scala/LowPriorityImplicits#intWrapper(). [5:43..5:45): to -> scala/runtime/RichInt#to(). [5:46..5:51): times -> _empty_/toplevel$package.MyProgram().(times) [5:53..5:60): foreach -> scala/collection/immutable/Range#foreach(). [5:67..5:74): println -> scala/Predef.println(+1). [6:4..6:10): fooRef <- _empty_/toplevel$package.fooRef(). -[6:13..6:29): toplevel$package -> _empty_/toplevel$package. [6:30..6:33): foo -> _empty_/toplevel$package.foo().