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..1519ef6b5448 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -16,13 +16,14 @@ import NameOps._ import util.Spans.Span import util.{SourceFile, SourcePosition} import transform.SymUtils._ -import SymbolInformation.{Kind => k} +import dotty.tools.dotc.{semanticdb => s} import scala.jdk.CollectionConverters._ 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,37 +44,39 @@ 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.synthetics.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 builder: s.SemanticSymbolBuilder = s.SemanticSymbolBuilder() + val synth = SyntheticsExtractor() + given converter: s.TypeOps = 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]() /** The extracted symbol infos */ val symbolInfos = new mutable.ListBuffer[SymbolInformation]() + val synthetics = new mutable.ListBuffer[s.Synthetic]() + /** A cache of localN names */ val localNames = new mutable.HashSet[String]() + /** The symbol occurrences generated so far, as a set */ private val generated = new mutable.HashSet[SymbolOccurrence] + 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 +134,63 @@ 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) => + synth.tryFindSynthetic(tree).foreach { synth => + synthetics += synth + } + traverse(tree.tpt) + case _ => + if !tree.symbol.isGlobal then + localBodies(tree.symbol) = tree.rhs + // ignore rhs + + // `given Int` (syntax sugar of `given given_Int: Int`) + case tree: ValDef if tree.symbol.isInventedGiven => + synth.tryFindSynthetic(tree).foreach { synth => + synthetics += synth + } + traverse(tree.tpt) + 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 +200,22 @@ 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) + synth.tryFindSynthetic(tree).foreach { synth => + synthetics += synth + } + 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 +235,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 +248,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 +262,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,217 +295,18 @@ 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)) - val (startLine, startCol) = lineCol(span.start) - val (endLine, endCol) = lineCol(span.end) - Some(Range(startLine, startCol, endLine, endCol)) - - private def symbolKind(sym: Symbol, symkinds: Set[SymbolKind])(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 +315,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 +445,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 @@ -641,7 +461,12 @@ object ExtractSemanticDB: val name: String = "extractSemanticDB" - def write(source: SourceFile, occurrences: List[SymbolOccurrence], symbolInfos: List[SymbolInformation])(using Context): Unit = + def write( + source: SourceFile, + occurrences: List[SymbolOccurrence], + symbolInfos: List[SymbolInformation], + synthetics: List[Synthetic], + )(using Context): Unit = def absolutePath(path: Path): Path = path.toAbsolutePath.normalize val semanticdbTarget = val semanticdbTargetSetting = ctx.settings.semanticdbTarget.value @@ -663,7 +488,8 @@ object ExtractSemanticDB: text = "", md5 = internal.MD5.compute(String(source.content)), symbols = symbolInfos, - occurrences = occurrences + occurrences = occurrences, + synthetics = synthetics, ) val docs = TextDocuments(List(doc)) val out = Files.newOutputStream(outpath) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSynthetics.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSynthetics.scala new file mode 100644 index 000000000000..52ce542cdbe8 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSynthetics.scala @@ -0,0 +1,90 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.ast.tpd._ +import dotty.tools.dotc.core.Contexts._ +import dotty.tools.dotc.core.Flags._ +import dotty.tools.dotc.core.StdNames.nme +import dotty.tools.dotc.{semanticdb => s} + +import scala.collection.mutable + +class SyntheticsExtractor: + import Scala3.{_, given} + + def tryFindSynthetic(tree: Tree)(using Context, SemanticSymbolBuilder, TypeOps): Option[s.Synthetic] = + extension (synth: s.Synthetic) + def toOpt: Some[s.Synthetic] = Some(synth) + + if tree.span.isSynthetic || tree.symbol.isInventedGiven then + tree match + case tree: Apply if isForSynthetic(tree) => + None // not yet supported (for synthetics) + case tree: Apply + if tree.args.nonEmpty && + tree.args.forall(arg => + arg.symbol.isOneOf(GivenOrImplicit) && + arg.span.isSynthetic + ) => + s.Synthetic( + range(tree.span, tree.source), + s.ApplyTree( + tree.fun.toSemanticOriginal, + tree.args.map(_.toSemanticTree) + ) + ).toOpt + + // Anonymous context parameter + case tree: ValDef if tree.symbol.is(Given) => + s.Synthetic( + range(tree.span, tree.source), + tree.toSemanticId + ).toOpt + case _ => None + else None + + extension (tree: Tree) + private def toSemanticTree(using Context, SemanticSymbolBuilder, TypeOps): s.Tree = + tree match + case tree: Apply => + s.ApplyTree( + tree.fun.toSemanticQualifierTree, + tree.args.map(_.toSemanticTree) + ) + case tree: TypeApply => + s.TypeApplyTree( + tree.fun.toSemanticQualifierTree, + tree.args.map { targ => + targ.tpe.toSemanticType(targ.symbol)(using LinkMode.SymlinkChildren) + } + ) + case tree: Ident => tree.toSemanticId + case tree: Select => tree.toSemanticId + case _ => s.Tree.defaultInstance + + private def toSemanticQualifierTree(using Context, SemanticSymbolBuilder): s.Tree = tree match + case sel @ Select(qual, _) if sel.symbol.owner != qual.symbol => + s.SelectTree(qual.toSemanticId, Some(sel.toSemanticId)) + case fun => fun.toSemanticId + + private def toSemanticId(using Context, SemanticSymbolBuilder) = + s.IdTree(tree.symbol.symbolName) + + private def toSemanticOriginal(using Context) = + s.OriginalTree(range(tree.span, tree.source)) + + + def isForSynthetic(tree: Tree): Boolean = + def isForComprehensionSyntheticName(select: Select): Boolean = + select.span.toSynthetic == select.qualifier.span.toSynthetic && ( + select.name == nme.map || + select.name == nme.flatMap || + select.name == nme.withFilter || + select.name == nme.foreach + ) + tree match + case Apply(fun, _) => isForSynthetic(fun) + case TypeApply(fun, _) => isForSynthetic(fun) + case select: Select => isForComprehensionSyntheticName(select) + case _ => false + +end SyntheticsExtractor 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..0917d5a8452a --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala @@ -0,0 +1,399 @@ +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._ +import dotty.tools.dotc.util.SourceFile +class SymbolInformationPrinter (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) + } + end InfoNotes + + 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 pprintAccess(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[${pprintRef(ssym)}] " + case ProtectedWithinAccess(ssym) => + s"protected[${pprintRef(ssym)}] " + + private def pprintDef(info: SymbolInformation) = + notes.enter(info) + pprint(info.symbol, SymbolStyle.Definition) + 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 _ => + "" + + protected 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)}" + } + + protected 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 InfoPrinter +end SymbolInformationPrinter + +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) + } + +def processRange(sb: StringBuilder, range: Range): Unit = + sb.append('[') + .append(range.startLine).append(':').append(range.startCharacter) + .append("..") + .append(range.endLine).append(':').append(range.endCharacter) + .append("):") + + + +class SyntheticPrinter(symtab: PrinterSymtab, source: SourceFile) extends SymbolInformationPrinter(symtab): + + def pprint(synth: Synthetic): String = + val sb = new StringBuilder() + val notes = InfoNotes() + val treePrinter = TreePrinter(source, synth.range, notes) + + synth.range match + case Some(range) => + processRange(sb, range) + sb.append(source.substring(range)) + case None => + sb.append("[):") + sb.append(" => ") + sb.append(treePrinter.pprint(synth.tree)) + sb.toString + + extension (source: SourceFile) + private def substring(range: Option[s.Range]): String = + range match + case Some(range) => source.substring(range) + case None => "" + private def substring(range: s.Range): String = + /** get the line length of a given line */ + def lineLength(line: Int): Int = + val isLastLine = source.lineToOffsetOpt(line).nonEmpty && source.lineToOffsetOpt(line + 1).isEmpty + if isLastLine then source.content.length - source.lineToOffset(line) - 1 + else source.lineToOffset(line + 1) - source.lineToOffset(line) - 1 // -1 for newline char + + val start = source.lineToOffset(range.startLine) + + math.min(range.startCharacter, lineLength(range.startLine)) + val end = source.lineToOffset(range.endLine) + + math.min(range.endCharacter, lineLength(range.endLine)) + new String(source.content, start, end - start) + + + // def pprint(tree: s.Tree, range: Option[Range]): String = + class TreePrinter(source: SourceFile, originalRange: Option[Range], notes: InfoNotes) extends InfoPrinter(notes): + def pprint(tree: Tree): String = + val sb = new StringBuilder() + processTree(tree)(using sb) + sb.toString + + + private def rep[T](xs: Seq[T], seq: String)(f: T => Unit)(using sb: StringBuilder): Unit = + xs.zipWithIndex.foreach { (x, i) => + if i != 0 then sb.append(seq) + f(x) + } + + private def processTree(tree: Tree)(using sb: StringBuilder): Unit = + tree match { + case tree: ApplyTree => + processTree(tree.function) + sb.append("(") + rep(tree.arguments, ", ")(processTree) + sb.append(")") + case tree: FunctionTree => + sb.append("{") + sb.append("(") + rep(tree.parameters, ", ")(processTree) + sb.append(") =>") + processTree(tree.body) + sb.append("}") + case tree: IdTree => + sb.append(pprintRef(tree.symbol)) + case tree: LiteralTree => + sb.append(pprint(tree.constant)) + case tree: MacroExpansionTree => + sb.append("(`macro-expandee` : `") + sb.append(pprint(tree.tpe)) + sb.append(")") + case tree: OriginalTree => + if (tree.range == originalRange && originalRange.nonEmpty) then + sb.append("*") + else + sb.append("orig(") + sb.append(source.substring(tree.range)) + sb.append(")") + case tree: SelectTree => + processTree(tree.qualifier) + sb.append(".") + tree.id match + case Some(tree) => processTree(tree) + case None => () + case tree: TypeApplyTree => + processTree(tree.function) + sb.append("[") + rep(tree.typeArguments, ", ")((t) => sb.append(pprint(t))) + sb.append("]") + + case _ => + sb.append("") + } + + +end SyntheticPrinter diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index fb01e6fff488..07d31e1e3eb6 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -1,14 +1,19 @@ 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 dotty.tools.dotc.util.SourceFile +import dotty.tools.dotc.util.Spans.Span +import dotty.tools.dotc.ast.tpd +import dotty.tools.dotc.{semanticdb => s} import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} @@ -25,6 +30,104 @@ object Scala3: private val WILDCARDTypeName = nme.WILDCARD.toTypeName + def range(span: Span, treeSource: SourceFile)(using Context): Option[Range] = + def lineCol(offset: Int) = (treeSource.offsetToLine(offset), treeSource.column(offset)) + val (startLine, startCol) = lineCol(span.start) + val (endLine, endCol) = lineCol(span.end) + Some(Range(startLine, startCol, endLine, endCol)) + + 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 +186,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 +230,131 @@ object Scala3: def isSyntheticWithIdent(using Context): Boolean = sym.is(Synthetic) && !sym.isAnonymous && !sym.name.isEmptyNumbered + /** Check if the symbol is invented by Desugar.inventGivenOrExtensionName + * return true if the symbol is defined as `given Int = ...` and name is invented as "given_Int" + */ + def isInventedGiven(using Context): Boolean = + sym.is(Given) && sym.name.startsWith("given_") + + + def symbolInfo(symkinds: Set[SymbolKind])(using LinkMode, TypeOps, SemanticSymbolBuilder, Context): SymbolInformation = + val kind = sym.symbolKind(symkinds) + val sname = sym.symbolName + val signature = sym.info.toSemanticSig(sym) + SymbolInformation( + symbol = symbolName, + language = Language.SCALA, + kind = kind, + properties = sym.symbolProps(symkinds), + displayName = Symbols.displaySymbol(sym), + signature = signature, + access = sym.symbolAccess(kind), + ) + + /** 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 +393,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)) @@ -217,9 +450,7 @@ object Scala3: def hasLength = range.endLine > range.startLine || range.endCharacter > range.startCharacter end RangeOps - /** Sort symbol occurrences by their start position. */ - given OccurrenceOrdering: Ordering[SymbolOccurrence] = (x, y) => - x.range -> y.range match + private def compareRange(x: Option[Range], y: Option[Range]): Int = x -> y match case None -> _ | _ -> None => 0 case Some(a) -> Some(b) => val byLine = Integer.compare(a.startLine, b.startLine) @@ -227,10 +458,14 @@ object Scala3: byLine else // byCharacter Integer.compare(a.startCharacter, b.startCharacter) - end OccurrenceOrdering + + /** Sort symbol occurrences by their start position. */ + given Ordering[SymbolOccurrence] = (x, y) => compareRange(x.range, y.range) given Ordering[SymbolInformation] = Ordering.by[SymbolInformation, String](_.symbol)(IdentifierOrdering()) + given Ordering[Synthetic] = (x, y) => compareRange(x.range, y.range) + /** * A comparator for identifier like "Predef" or "Function10". * 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..45965b5ebb90 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala @@ -47,8 +47,11 @@ object Tools: TextDocuments.parseFrom(bytes) def metac(doc: TextDocument, realPath: Path)(using sb: StringBuilder): StringBuilder = + val symtab = PrinterSymtab.fromTextDocument(doc) + val symPrinter = SymbolInformationPrinter(symtab) val realURI = realPath.toString - given SourceFile = SourceFile.virtual(doc.uri, doc.text) + given sourceFile: SourceFile = SourceFile.virtual(doc.uri, doc.text) + val synthPrinter = SyntheticPrinter(symtab, sourceFile) sb.append(realURI).nl sb.append("-" * realURI.length).nl sb.nl @@ -59,13 +62,20 @@ object Tools: sb.append("Language => ").append(languageString(doc.language)).nl sb.append("Symbols => ").append(doc.symbols.length).append(" entries").nl sb.append("Occurrences => ").append(doc.occurrences.length).append(" entries").nl + if doc.synthetics.nonEmpty then + sb.append("Synthetics => ").append(doc.synthetics.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) sb.nl + if doc.synthetics.nonEmpty then + sb.append("Synthetics:").nl + doc.synthetics.sorted.foreach(s => processSynth(s, synthPrinter)) + sb.nl + sb end metac private def schemaString(schema: Schema) = @@ -85,72 +95,16 @@ 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, printer: SymbolInformationPrinter)(using sb: StringBuilder): Unit = + sb.append(printer.pprintSymbolInformation(info)).nl - - 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 processSynth(synth: Synthetic, printer: SyntheticPrinter)(using sb: StringBuilder): Unit = + sb.append(printer.pprint(synth)).nl private def processOccurrence(occ: SymbolOccurrence)(using sb: StringBuilder, sourceFile: SourceFile): Unit = occ.range match case Some(range) => - sb.append('[') - .append(range.startLine).append(':').append(range.startCharacter) - .append("..") - .append(range.endLine).append(':').append(range.endCharacter) - .append("):") + processRange(sb, range) if range.endLine == range.startLine && range.startCharacter != range.endCharacter && !(occ.symbol.isConstructor && occ.role.isDefinition) then 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..963a153388a3 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala @@ -0,0 +1,444 @@ +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) + + 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 tvar: TypeVar => + loop(tvar.stripped) + + 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..b6b14fe6de81 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -3,48 +3,59 @@ 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*/ + + object Contexts/*<-example::Synthetic#Contexts.*/ { + def foo/*<-example::Synthetic#Contexts.foo().*/(x/*<-example::Synthetic#Contexts.foo().(x)*/: Int/*->scala::Int#*/)(using Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m1/*<-example::Synthetic#Contexts.m1().*/(using Int/*->scala::Int#*/) = foo/*->example::Synthetic#Contexts.foo().*/(0) + def m2/*<-example::Synthetic#Contexts.m2().*/(using x/*<-example::Synthetic#Contexts.m2().(x)*/: Int/*->scala::Int#*/) = foo/*->example::Synthetic#Contexts.foo().*/(0) + def m3/*<-example::Synthetic#Contexts.m3().*/ = + given x/*<-local10*/: Int/*->scala::Int#*/ = 1 + foo/*->example::Synthetic#Contexts.foo().*/(x/*->local10*/) + def m4/*<-example::Synthetic#Contexts.m4().*/ = + given Int/*->scala::Int#*/ = 1 + foo/*->example::Synthetic#Contexts.foo().*/(0) + } } diff --git a/tests/semanticdb/expect/Synthetic.scala b/tests/semanticdb/expect/Synthetic.scala index 484e07098877..10d13e936468 100644 --- a/tests/semanticdb/expect/Synthetic.scala +++ b/tests/semanticdb/expect/Synthetic.scala @@ -47,4 +47,15 @@ class Synthetic { if a < b } yield a + object Contexts { + def foo(x: Int)(using Int) = ??? + def m1(using Int) = foo(0) + def m2(using x: Int) = foo(0) + def m3 = + given x: Int = 1 + foo(x) + def m4 = + given Int = 1 + foo(0) + } } 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..fd5b1ee2f81b 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,22 +355,25 @@ Uri => AnonymousGiven.scala Text => empty Language => Scala Symbols => 5 entries -Occurrences => 5 entries +Occurrences => 4 entries +Synthetics => 1 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# +Synthetics: +[4:14..4:17):Foo => x$1 + expect/Classes.scala -------------------- @@ -363,118 +383,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 +503,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 +545,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 +601,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 +620,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 +652,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 +667,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 +713,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 +746,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 +765,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 +812,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 +1036,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 +1044,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 +1099,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 +1132,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 +1156,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 +1182,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 +1204,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 +1215,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 +1224,37 @@ Schema => SemanticDB v4 Uri => Extension.scala Text => empty Language => Scala -Symbols => 8 entries -Occurrences => 18 entries +Symbols => 26 entries +Occurrences => 50 entries +Synthetics => 2 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 +1268,49 @@ 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] + +Synthetics: +[14:24..14:31):Read[T] => x$2 +[14:46..14:61):summon[Read[T]] => *(x$2) expect/ForComprehension.scala ----------------------------- @@ -1317,106 +1321,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 +1401,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 +1442,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 +1450,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 +1460,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 +1469,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 +1507,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 +1540,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 +1548,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 +1612,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 +1639,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 +1666,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 +1687,74 @@ Uri => InventedNames.scala Text => empty Language => Scala Symbols => 45 entries -Occurrences => 72 entries +Occurrences => 61 entries +Synthetics => 7 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 +1765,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 +1783,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,11 +1796,19 @@ 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# +Synthetics: +[14:0..14:20):given String = "str" => given_String +[15:13..15:16):Int => x$1 +[17:0..17:28):given given_Char: Char = '?' => given_Char +[18:0..18:32):given `given_Float`: Float = 3.0 => given_Float +[24:13..24:14):X => x$1 +[34:8..34:20):given_Double => *(intValue) +[40:8..40:15):given_Y => *(given_X) + expect/Issue1749.scala ---------------------- @@ -1876,16 +1818,17 @@ Uri => Issue1749.scala Text => empty Language => Scala Symbols => 7 entries -Occurrences => 30 entries +Occurrences => 22 entries +Synthetics => 2 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 +1837,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 +1853,10 @@ 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(). + +Synthetics: +[8:2..8:10):(x1, x1) => *(Tuple2(Int, Int)) +[8:10..8:10): => *(Int, Int) expect/Local.scala ------------------ @@ -1928,28 +1867,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 +1898,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 +1911,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 +1922,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 +1948,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 +1983,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 +2009,20 @@ Uri => MethodUsages.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 85 entries +Occurrences => 80 entries +Synthetics => 1 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 +2042,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 +2051,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. @@ -2176,6 +2099,9 @@ Occurrences: [34:4..34:7): m20 -> example/Methods#m20(+2). [34:8..34:9): m -> example/Methods#m17.m(). +Synthetics: +[13:2..13:26):m.m7(m, new m.List[Int]) => *(Int) + expect/Methods.scala -------------------- @@ -2184,87 +2110,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 +2207,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 +2253,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 +2264,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 +2290,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 +2361,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 +2431,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 +2438,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 +2447,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 +2459,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 +2499,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 +2547,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 +2564,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 +2593,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 +2636,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 +2665,193 @@ 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 +Synthetics => 1 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) + +Synthetics: +[15:23..15:34):elems.toMap => *(refl[Tuple2[String, Any]]) + expect/RightAssociativeExtension.scala -------------------------------------- @@ -2727,14 +2861,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 +2879,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 +2893,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 +2937,63 @@ Schema => SemanticDB v4 Uri => Synthetic.scala Text => empty Language => Scala -Symbols => 38 entries -Occurrences => 162 entries +Symbols => 52 entries +Occurrences => 133 entries +Synthetics => 9 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 => +23 decls } +example/Synthetic#Contexts. => final object Contexts extends Object { self: Contexts.type => +6 decls } +example/Synthetic#Contexts.foo(). => method foo (param x: Int)(implicit given param x$2: Int): Nothing +example/Synthetic#Contexts.foo().(x$2) => implicit given param x$2: Int +example/Synthetic#Contexts.foo().(x) => param x: Int +example/Synthetic#Contexts.m1(). => method m1 (implicit given param x$1: Int): Nothing +example/Synthetic#Contexts.m1().(x$1) => implicit given param x$1: Int +example/Synthetic#Contexts.m2(). => method m2 (implicit given param x: Int): Nothing +example/Synthetic#Contexts.m2().(x) => implicit given param x: Int +example/Synthetic#Contexts.m3(). => method m3 => Nothing +example/Synthetic#Contexts.m4(). => method m4 => Nothing +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 +local10 => final implicit lazy val given local x: Int +local11 => final implicit lazy val given local given_Int: Int Occurrences: [0:8..0:15): example <- example/ @@ -2862,112 +3001,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 +3076,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 +3087,59 @@ 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(). +[49:9..49:17): Contexts <- example/Synthetic#Contexts. +[50:8..50:11): foo <- example/Synthetic#Contexts.foo(). +[50:12..50:13): x <- example/Synthetic#Contexts.foo().(x) +[50:15..50:18): Int -> scala/Int# +[50:26..50:29): Int -> scala/Int# +[50:33..50:36): ??? -> scala/Predef.`???`(). +[51:8..51:10): m1 <- example/Synthetic#Contexts.m1(). +[51:17..51:20): Int -> scala/Int# +[51:24..51:27): foo -> example/Synthetic#Contexts.foo(). +[52:8..52:10): m2 <- example/Synthetic#Contexts.m2(). +[52:17..52:18): x <- example/Synthetic#Contexts.m2().(x) +[52:20..52:23): Int -> scala/Int# +[52:27..52:30): foo -> example/Synthetic#Contexts.foo(). +[53:8..53:10): m3 <- example/Synthetic#Contexts.m3(). +[54:12..54:13): x <- local10 +[54:15..54:18): Int -> scala/Int# +[55:6..55:9): foo -> example/Synthetic#Contexts.foo(). +[55:10..55:11): x -> local10 +[56:8..56:10): m4 <- example/Synthetic#Contexts.m4(). +[57:12..57:15): Int -> scala/Int# +[58:6..58:9): foo -> example/Synthetic#Contexts.foo(). + +Synthetics: +[32:35..32:49):Array.empty[T] => *(evidence$1) +[36:22..36:27):new F => *(ordering) +[50:26..50:29):Int => x$2 +[51:17..51:20):Int => x$1 +[51:24..51:30):foo(0) => *(x$1) +[52:27..52:33):foo(0) => *(x) +[55:6..55:12):foo(x) => *(x) +[57:6..57:19):given Int = 1 => given_Int +[58:6..58:12):foo(0) => *(given_Int) expect/Traits.scala ------------------- @@ -3029,39 +3150,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 +3190,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 +3233,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 +3248,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 +3273,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 +3447,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 +3457,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 +3488,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 +3524,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 +3531,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 +3543,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 +3553,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 +3581,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 +3600,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 +3708,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 +3721,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 +3734,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 +3749,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 +3762,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 +3845,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 +3899,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 +3907,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 +3918,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 +3925,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 +3941,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 +3961,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 +3973,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 +4046,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 +4056,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 +4078,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 +4088,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 +4110,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 +4268,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 +4275,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 +4303,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 +4368,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 +4401,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 +4442,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 +4495,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 +4529,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 +4536,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 +4548,29 @@ Uri => toplevel.scala Text => empty Language => Scala Symbols => 19 entries -Occurrences => 44 entries +Occurrences => 34 entries +Synthetics => 1 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 +4596,18 @@ 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(). +Synthetics: +[5:0..5:0): => *(given_FromString_Int) +