From 58a572e639692666078d6e1615b7a147fc55461d Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 7 Oct 2019 15:10:38 +0200 Subject: [PATCH 001/107] Add -Ysemanticdb option --- compiler/src/dotty/tools/dotc/config/ScalaSettings.scala | 1 + 1 file changed, 1 insertion(+) diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala index 13099076f9b5..193f3f894d3e 100644 --- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala +++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala @@ -150,6 +150,7 @@ class ScalaSettings extends Settings.SettingGroup { val YdumpSbtInc: Setting[Boolean] = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.") val YcheckAllPatmat: Setting[Boolean] = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)") val YretainTrees: Setting[Boolean] = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree") + val YsemanticDB: Setting[Boolean] = BooleanSetting("-Ysemanticdb", "Store information in SemanticDB") val YshowTreeIds: Setting[Boolean] = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.") val YprofileEnabled: Setting[Boolean] = BooleanSetting("-Yprofile-enabled", "Enable profiling.") From 493aabdea93651128bbb1b921a7e53256b0c2955 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 7 Oct 2019 17:26:26 +0200 Subject: [PATCH 002/107] First version of traverser for SemanticDB extraction --- compiler/src/dotty/tools/dotc/ast/untpd.scala | 1 + .../dotc/semanticdb/ExtractSemanticDB.scala | 110 ++++++++++++++++++ 2 files changed, 111 insertions(+) create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala index bcbbfcca1e47..9353a1aa4c29 100644 --- a/compiler/src/dotty/tools/dotc/ast/untpd.scala +++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala @@ -111,6 +111,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { case class Export(expr: Tree, selectors: List[ImportSelector])(implicit @constructorOnly src: SourceFile) extends Tree case class ImportSelector(imported: Ident, renamed: Tree = EmptyTree, bound: Tree = EmptyTree)(implicit @constructorOnly src: SourceFile) extends Tree { + // TODO: Make bound a typed tree? /** It's a `given` selector */ val isGiven: Boolean = imported.name.isEmpty diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala new file mode 100644 index 000000000000..737ebeb1cead --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -0,0 +1,110 @@ +package dotty.tools.dotc +package semanticdb + +import core._ +import Phases._ +import ast.Trees._ +import ast.untpd +import Contexts._ +import Symbols._ +import Flags._ +import Decorators._ +import Names.Name +import StdNames.nme +import collection.mutable +import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} + +abstract class ExtractSemanticDB extends Phase { + import ast.tpd._ + + override val phaseName: String = ExtractSemanticDB.name + + override def isRunnable(implicit ctx: Context) = + super.isRunnable && ctx.settings.YretainTrees.value + + // Check not needed since it does not transform trees + override def isCheckable: Boolean = false + + override def run(implicit ctx: Context): Unit = + Extractor().traverse(ctx.compilationUnit.tpdTree) + + class Extractor extends TreeTraverser { + + val locals = mutable.HashMap[Symbol, java.lang.Integer]() + + private var myLocalIdx: Int = -1 + private def nextLocalIdx() = + myLocalIdx += 1 + myLocalIdx + + def symbolName(sym: Symbol)(given ctx: Context): String = + + def isJavaIdent(str: String) = + isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) + + def nameToString(name: Name) = + val str = name.toString + if isJavaIdent(str) then str else "`" + str + "`" + + def isGlobal(sym: Symbol): Boolean = + sym.is(Package) + || (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) + + def ownerString(owner: Symbol): String = + if owner.isRoot then "" else symbolName(owner) + "/" + + def overloadIdx(sym: Symbol): String = + val alts = sym.owner.info.decls.lookupAll(sym.name).toList + if alts.tail.isEmpty then "" + else + val idx = alts.indexOf(sym) + assert(idx >= 0) + idx.toString + + def descriptor(sym: Symbol): String = + if sym.is(ModuleClass) then + descriptor(sym.sourceModule) + else + val str = nameToString(sym.name) + if sym.is(Package) then str + else if sym.is(Module) || sym.isGetter && !sym.is(Mutable) then str + "." + else if sym.isType then str + "#" + else if sym.is(Method) then str + "(" + overloadIdx(sym) + ")" + else if sym.is(TermParam) then "(" + str + ")" + else if sym.is(TypeParam) then "[" + str + "]" + else throw new AssertionError(i"unhandled symbol: $sym") + + def localIdx(sym: Symbol): Int = + locals.getOrElseUpdate(sym, nextLocalIdx()) + + if sym.isRoot then "_root_" + else if sym.isEmptyPackage then "_empty_" + else if isGlobal(sym) then ownerString(sym.owner) + descriptor(sym) + else "local" + localIdx(sym) + end symbolName + + def registerUse(sym: Symbol) = ??? + def registerDef(sym: Symbol) = ??? + + override def traverse(tree: Tree)(given ctx: Context): Unit = + tree match + case tree: DefTree => + registerDef(tree.symbol) + traverseChildren(tree) + case tree: RefTree => + registerUse(tree.symbol) + traverseChildren(tree) + case tree: Import => + for sel <- tree.selectors do + val imported = sel.imported.name + if imported != nme.WILDCARD then + for alt <- tree.expr.tpe.member(imported).alternatives do + registerUse(alt.symbol) + case _ => + traverseChildren(tree) + } +} + +object ExtractSemanticDB { + val name: String = "extractSemanticDB" +} From ffa53d0a74c1df7452d4ed6989ba2e4b6bc5c642 Mon Sep 17 00:00:00 2001 From: Olafur Pall Geirsson Date: Mon, 7 Oct 2019 16:54:11 +0200 Subject: [PATCH 003/107] Add dependency-free serializer for SemanticDB symbol occurrences. This commit adds a dependency-free serializer for a subset of the SemanticDB specifiction. Most importantly, `SymbolOccurrence` is used by Metals to power "find references". Other unsupported parts of the SemanticDB specification are left out since they are less important for Metals at the current moment. --- .../tools/dotc/semanticdb/Language.scala | 8 + .../dotty/tools/dotc/semanticdb/Main.scala | 44 ++ .../dotty/tools/dotc/semanticdb/Range.scala | 83 +++ .../dotty/tools/dotc/semanticdb/Schema.scala | 8 + .../tools/dotc/semanticdb/Semanticdb.scala | 33 + .../dotc/semanticdb/SemanticdbEnum.scala | 5 + .../dotc/semanticdb/SemanticdbMessage.scala | 6 + .../semanticdb/SemanticdbOutputStream.scala | 607 ++++++++++++++++++ .../dotc/semanticdb/SymbolOccurrence.scala | 75 +++ .../tools/dotc/semanticdb/TextDocument.scala | 90 +++ .../tools/dotc/semanticdb/TextDocuments.scala | 31 + .../tools/dotc/semanticdb/WireFormat.scala | 20 + 12 files changed, 1010 insertions(+) create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/Language.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/Main.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/Range.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/Schema.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/Semanticdb.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/SemanticdbEnum.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/SemanticdbOutputStream.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/WireFormat.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala new file mode 100644 index 000000000000..10e4107dbb97 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala @@ -0,0 +1,8 @@ +package dotty.tools.dotc.semanticdb + +abstract class Language(val value: Int) extends SemanticdbEnum +object Language { + case object UNKNOWN_LANGUAGE extends Language(0) + case object SCALA extends Language(1) + case object JAVA extends Language(2) +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Main.scala b/compiler/src/dotty/tools/dotc/semanticdb/Main.scala new file mode 100644 index 000000000000..c563d1513a97 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Main.scala @@ -0,0 +1,44 @@ +package dotty.tools.dotc.semanticdb +import java.nio.file.Paths +import java.nio.file.Files +import java.nio.file.StandardOpenOption + +object Main { + def main(args: Array[String]): Unit = { + if (args.isEmpty) { + println("missing ") + } + val docs = TextDocuments( + List( + TextDocument( + Schema.SEMANTICDB3, + Language.SCALA, + uri = "Main.scala", + "md5", + List( + SymbolOccurrence( + "scala/Predef.String#", + Some(Range(0, 0, 1, 1)), + SymbolOccurrence.Role.REFERENCE + ) + ) + ) + ) + ) + println(docs.serializedSize) + val path = Paths.get(args(0)).toAbsolutePath() + val out = Files.newOutputStream( + path, + StandardOpenOption.CREATE, + StandardOpenOption.TRUNCATE_EXISTING + ) + val stream = SemanticdbOutputStream.newInstance(out) + try { + docs.writeTo(stream) + } finally { + stream.flush() + out.close() + } + println(path) + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala new file mode 100644 index 000000000000..ea54f8a68fb5 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala @@ -0,0 +1,83 @@ +package dotty.tools.dotc.semanticdb + +case class Range( + startLine: Int, + startCharacter: Int, + endLine: Int, + endCharacter: Int +) extends SemanticdbMessage { + @transient + private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 + private[this] def __computeSerializedValue(): _root_.scala.Int = { + var __size = 0 + + { + val __value = startLine + if (__value != 0) { + __size += SemanticdbOutputStream + .computeInt32Size(1, __value) + } + }; + + { + val __value = startCharacter + if (__value != 0) { + __size += SemanticdbOutputStream + .computeInt32Size(2, __value) + } + }; + + { + val __value = endLine + if (__value != 0) { + __size += SemanticdbOutputStream + .computeInt32Size(3, __value) + } + }; + + { + val __value = endCharacter + if (__value != 0) { + __size += SemanticdbOutputStream + .computeInt32Size(4, __value) + } + }; + __size + } + final override def serializedSize: _root_.scala.Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo( + `_output__`: SemanticdbOutputStream + ): _root_.scala.Unit = { + { + val __v = startLine + if (__v != 0) { + _output__.writeInt32(1, __v) + } + }; + { + val __v = startCharacter + if (__v != 0) { + _output__.writeInt32(2, __v) + } + }; + { + val __v = endLine + if (__v != 0) { + _output__.writeInt32(3, __v) + } + }; + { + val __v = endCharacter + if (__v != 0) { + _output__.writeInt32(4, __v) + } + }; + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala new file mode 100644 index 000000000000..a61baa2e24c5 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala @@ -0,0 +1,8 @@ +package dotty.tools.dotc.semanticdb + +abstract class Schema(val value: Int) extends SemanticdbEnum +object Schema { + case object LEGACY extends Schema(0) + case object SEMANTICDB3 extends Schema(3) + case object SEMANTICDB4 extends Schema(4) +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Semanticdb.scala b/compiler/src/dotty/tools/dotc/semanticdb/Semanticdb.scala new file mode 100644 index 000000000000..379043d563dc --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Semanticdb.scala @@ -0,0 +1,33 @@ +package dotty.tools.dotc.semanticdb + +import java.nio.file.Path + +object Semanticdb { + case class Range( + startLine: Int, + startCharacter: Int, + endLine: Int, + endCharacter: Int + ) + trait ProtobufMessage { + def writeTo(out: CodedOutputStream): Unit = {} + } + sealed abstract class Role + object Role { + case object Reference extends Role + case object Definition extends Role + } + case class SymbolOccurrence(symbol: String, range: Range, role: Role) extends ProtobufMessage + case class TextDocuments(documents: Seq[TextDocument]) + class CodedOutputStream() { + def writeInt(): Unit = () + // ... + } + case class TextDocument( + uri: String, + md5: String, + occurrences: Seq[SymbolOccurrence] + ) { + def writeTo(out: CodedOutputStream): Unit = {} + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbEnum.scala b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbEnum.scala new file mode 100644 index 000000000000..eae4d818604e --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbEnum.scala @@ -0,0 +1,5 @@ +package dotty.tools.dotc.semanticdb + +trait SemanticdbEnum { + def value: Int +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala new file mode 100644 index 000000000000..bb7678bb0a61 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala @@ -0,0 +1,6 @@ +package dotty.tools.dotc.semanticdb + +trait SemanticdbMessage { + def serializedSize: Int + def writeTo(out: SemanticdbOutputStream): Unit +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbOutputStream.scala b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbOutputStream.scala new file mode 100644 index 000000000000..168c52a96194 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbOutputStream.scala @@ -0,0 +1,607 @@ +package dotty.tools.dotc.semanticdb + +import java.io.IOException +import java.io.OutputStream +import java.nio.ByteBuffer +import SemanticdbOutputStream._ + +object SemanticdbOutputStream { + + val DEFAULT_BUFFER_SIZE = 4096 + + def computePreferredBufferSize(dataLength: Int): Int = { + if (dataLength > DEFAULT_BUFFER_SIZE) return DEFAULT_BUFFER_SIZE + dataLength + } + + def newInstance(output: OutputStream): SemanticdbOutputStream = { + newInstance(output, DEFAULT_BUFFER_SIZE) + } + + def newInstance(output: OutputStream, bufferSize: Int): SemanticdbOutputStream = { + new SemanticdbOutputStream(output, Array.ofDim[Byte](bufferSize)) + } + + def newInstance(byteBuffer: ByteBuffer): SemanticdbOutputStream = { + newInstance(byteBuffer, DEFAULT_BUFFER_SIZE) + } + + def newInstance(b: Array[Byte]): SemanticdbOutputStream = { + new SemanticdbOutputStream(null, b) + } + + def newInstance( + byteBuffer: ByteBuffer, + bufferSize: Int + ): SemanticdbOutputStream = { + newInstance(new ByteBufferOutputStream(byteBuffer), bufferSize) + } + + private class ByteBufferOutputStream(private val byteBuffer: ByteBuffer) + extends OutputStream { + + override def write(b: Int): Unit = { + byteBuffer.put(b.toByte) + } + + override def write(data: Array[Byte], offset: Int, length: Int): Unit = { + byteBuffer.put(data, offset, length) + } + } + + def computeDoubleSize(fieldNumber: Int, value: Double): Int = { + computeTagSize(fieldNumber) + computeDoubleSizeNoTag(value) + } + + def computeFloatSize(fieldNumber: Int, value: Float): Int = { + computeTagSize(fieldNumber) + computeFloatSizeNoTag(value) + } + + def computeUInt64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeUInt64SizeNoTag(value) + } + + def computeInt64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeInt64SizeNoTag(value) + } + + def computeInt32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeInt32SizeNoTag(value) + } + + def computeFixed64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeFixed64SizeNoTag(value) + } + + def computeFixed32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeFixed32SizeNoTag(value) + } + + def computeBoolSize(fieldNumber: Int, value: Boolean): Int = { + computeTagSize(fieldNumber) + computeBoolSizeNoTag(value) + } + + def computeStringSize(fieldNumber: Int, value: String): Int = { + computeTagSize(fieldNumber) + computeStringSizeNoTag(value) + } + + // def computeBytesSize(fieldNumber: Int, value: ByteString): Int = { + // computeTagSize(fieldNumber) + computeBytesSizeNoTag(value) + // } + + def computeByteArraySize(fieldNumber: Int, value: Array[Byte]): Int = { + computeTagSize(fieldNumber) + computeByteArraySizeNoTag(value) + } + + def computeByteBufferSize(fieldNumber: Int, value: ByteBuffer): Int = { + computeTagSize(fieldNumber) + computeByteBufferSizeNoTag(value) + } + + def computeUInt32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeUInt32SizeNoTag(value) + } + + def computeEnumSize(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeEnumSizeNoTag(value) + } + + def computeSFixed32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeSFixed32SizeNoTag(value) + } + + def computeSFixed64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeSFixed64SizeNoTag(value) + } + + def computeSInt32Size(fieldNumber: Int, value: Int): Int = { + computeTagSize(fieldNumber) + computeSInt32SizeNoTag(value) + } + + def computeSInt64Size(fieldNumber: Int, value: Long): Int = { + computeTagSize(fieldNumber) + computeSInt64SizeNoTag(value) + } + + def computeDoubleSizeNoTag(value: Double): Int = LITTLE_ENDIAN_64_SIZE + + def computeFloatSizeNoTag(value: Float): Int = LITTLE_ENDIAN_32_SIZE + + def computeUInt64SizeNoTag(value: Long): Int = computeRawVarint64Size(value) + + def computeInt64SizeNoTag(value: Long): Int = computeRawVarint64Size(value) + + def computeInt32SizeNoTag(value: Int): Int = { + if (value >= 0) { + computeRawVarint32Size(value) + } else { + 10 + } + } + + def computeFixed64SizeNoTag(value: Long): Int = LITTLE_ENDIAN_64_SIZE + + def computeFixed32SizeNoTag(value: Int): Int = LITTLE_ENDIAN_32_SIZE + + def computeBoolSizeNoTag(value: Boolean): Int = 1 + + def computeStringSizeNoTag(value: String): Int = { + val bytes = value.getBytes(Internal.UTF_8) + computeRawVarint32Size(bytes.length) + bytes.length + } + + // def computeBytesSizeNoTag(value: ByteString): Int = { + // computeRawVarint32Size(value.size) + value.size + // } + + def computeByteArraySizeNoTag(value: Array[Byte]): Int = { + computeRawVarint32Size(value.length) + value.length + } + + def computeByteBufferSizeNoTag(value: ByteBuffer): Int = { + computeRawVarint32Size(value.capacity()) + value.capacity() + } + + def computeUInt32SizeNoTag(value: Int): Int = computeRawVarint32Size(value) + + def computeEnumSizeNoTag(value: Int): Int = computeInt32SizeNoTag(value) + + def computeSFixed32SizeNoTag(value: Int): Int = LITTLE_ENDIAN_32_SIZE + + def computeSFixed64SizeNoTag(value: Long): Int = LITTLE_ENDIAN_64_SIZE + + def computeSInt32SizeNoTag(value: Int): Int = { + computeRawVarint32Size(encodeZigZag32(value)) + } + + def computeSInt64SizeNoTag(value: Long): Int = { + computeRawVarint64Size(encodeZigZag64(value)) + } + + @SerialVersionUID(-6947486886997889499L) + class OutOfSpaceException() + extends IOException( + "SemanticdbOutputStream was writing to a flat byte array and ran " + + "out of space." + ) + + def computeTagSize(fieldNumber: Int): Int = { + computeRawVarint32Size(WireFormat.makeTag(fieldNumber, 0)) + } + + def computeRawVarint32Size(value: Int): Int = { + if ((value & (0xffffffff << 7)) == 0) return 1 + if ((value & (0xffffffff << 14)) == 0) return 2 + if ((value & (0xffffffff << 21)) == 0) return 3 + if ((value & (0xffffffff << 28)) == 0) return 4 + 5 + } + + def computeRawVarint64Size(value: Long): Int = { + if ((value & (0xFFFFFFFFFFFFFFFFL << 7)) == 0) return 1 + if ((value & (0xFFFFFFFFFFFFFFFFL << 14)) == 0) return 2 + if ((value & (0xFFFFFFFFFFFFFFFFL << 21)) == 0) return 3 + if ((value & (0xFFFFFFFFFFFFFFFFL << 28)) == 0) return 4 + if ((value & (0xFFFFFFFFFFFFFFFFL << 35)) == 0) return 5 + if ((value & (0xFFFFFFFFFFFFFFFFL << 42)) == 0) return 6 + if ((value & (0xFFFFFFFFFFFFFFFFL << 49)) == 0) return 7 + if ((value & (0xFFFFFFFFFFFFFFFFL << 56)) == 0) return 8 + if ((value & (0xFFFFFFFFFFFFFFFFL << 63)) == 0) return 9 + 10 + } + + val LITTLE_ENDIAN_32_SIZE = 4 + + val LITTLE_ENDIAN_64_SIZE = 8 + + def encodeZigZag32(n: Int): Int = (n << 1) ^ (n >> 31) + + def encodeZigZag64(n: Long): Long = (n << 1) ^ (n >> 63) +} + +class SemanticdbOutputStream(output: OutputStream, buffer: Array[Byte]) { + private def refreshBuffer(): Unit = { + if (output == null) { + throw new OutOfSpaceException() + } + output.write(buffer, 0, position) + position = 0 + } + + def flush(): Unit = { + if (output != null) { + refreshBuffer() + } + } + + def spaceLeft(): Int = { + if (output == null) { + limit - position + } else { + throw new UnsupportedOperationException( + "spaceLeft() can only be called on SemanticdbOutputStreams that are " + + "writing to a flat array." + ) + } + } + + def checkNoSpaceLeft(): Unit = { + if (spaceLeft() != 0) { + throw new IllegalStateException("Did not write as much data as expected.") + } + } + + private var position = 0 + private val limit = buffer.length + + private var totalBytesWritten: Int = 0 + + def writeDouble(fieldNumber: Int, value: Double): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64) + writeDoubleNoTag(value) + } + + def writeFloat(fieldNumber: Int, value: Float): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32) + writeFloatNoTag(value) + } + + def writeUInt64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeUInt64NoTag(value) + } + + def writeInt64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeInt64NoTag(value) + } + + def writeInt32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeInt32NoTag(value) + } + + def writeFixed64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64) + writeFixed64NoTag(value) + } + + def writeFixed32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32) + writeFixed32NoTag(value) + } + + def writeBool(fieldNumber: Int, value: Boolean): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeBoolNoTag(value) + } + + def writeString(fieldNumber: Int, value: String): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + writeStringNoTag(value) + } + + // def writeBytes(fieldNumber: Int, value: ByteString): Unit = { + // writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + // writeBytesNoTag(value) + // } + + def writeByteArray(fieldNumber: Int, value: Array[Byte]): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + writeByteArrayNoTag(value) + } + + def writeByteArray( + fieldNumber: Int, + value: Array[Byte], + offset: Int, + length: Int + ): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + writeByteArrayNoTag(value, offset, length) + } + + def writeByteBuffer(fieldNumber: Int, value: ByteBuffer): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED) + writeByteBufferNoTag(value) + } + + def writeUInt32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeUInt32NoTag(value) + } + + def writeEnum(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeEnumNoTag(value) + } + + def writeSFixed32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32) + writeSFixed32NoTag(value) + } + + def writeSFixed64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64) + writeSFixed64NoTag(value) + } + + def writeSInt32(fieldNumber: Int, value: Int): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeSInt32NoTag(value) + } + + def writeSInt64(fieldNumber: Int, value: Long): Unit = { + writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT) + writeSInt64NoTag(value) + } + + def writeDoubleNoTag(value: Double): Unit = { + writeRawLittleEndian64(java.lang.Double.doubleToLongBits(value)) + } + + def writeFloatNoTag(value: Float): Unit = { + writeRawLittleEndian32(java.lang.Float.floatToIntBits(value)) + } + + def writeUInt64NoTag(value: Long): Unit = { + writeRawVarint64(value) + } + + def writeInt64NoTag(value: Long): Unit = { + writeRawVarint64(value) + } + + def writeInt32NoTag(value: Int): Unit = { + if (value >= 0) { + writeRawVarint32(value) + } else { + writeRawVarint64(value) + } + } + + def writeFixed64NoTag(value: Long): Unit = { + writeRawLittleEndian64(value) + } + + def writeFixed32NoTag(value: Int): Unit = { + writeRawLittleEndian32(value) + } + + def writeBoolNoTag(value: Boolean): Unit = { + writeRawByte(if (value) 1 else 0) + } + + def writeStringNoTag(value: String): Unit = { + val bytes = value.getBytes(Internal.UTF_8) + writeRawVarint32(bytes.length) + writeRawBytes(bytes) + } + + def writeTag(fieldNumber: Int, wireType: Int): Unit = { + writeRawVarint32(WireFormat.makeTag(fieldNumber, wireType)) + } + + def writeRawVarint32(value0: Int): Unit = { + var value = value0 + while (true) { + if ((value & ~0x7F) == 0) { + writeRawByte(value) + return + } else { + writeRawByte((value & 0x7F) | 0x80) + value >>>= 7 + } + } + } + + def writeRawVarint64(value0: Long): Unit = { + var value = value0 + while (true) { + if ((value & ~0x7FL) == 0) { + writeRawByte(value.toInt) + return + } else { + writeRawByte((value.toInt & 0x7F) | 0x80) + value >>>= 7 + } + } + } + + def writeRawLittleEndian32(value: Int): Unit = { + writeRawByte((value) & 0xFF) + writeRawByte((value >> 8) & 0xFF) + writeRawByte((value >> 16) & 0xFF) + writeRawByte((value >> 24) & 0xFF) + } + + def writeRawLittleEndian64(value: Long): Unit = { + writeRawByte((value).toInt & 0xFF) + writeRawByte((value >> 8).toInt & 0xFF) + writeRawByte((value >> 16).toInt & 0xFF) + writeRawByte((value >> 24).toInt & 0xFF) + writeRawByte((value >> 32).toInt & 0xFF) + writeRawByte((value >> 40).toInt & 0xFF) + writeRawByte((value >> 48).toInt & 0xFF) + writeRawByte((value >> 56).toInt & 0xFF) + } + + // def writeBytesNoTag(value: ByteString): Unit = { + // writeRawVarint32(value.size) + // writeRawBytes(value) + // } + + def writeByteArrayNoTag(value: Array[Byte]): Unit = { + writeRawVarint32(value.length) + writeRawBytes(value) + } + + def writeByteArrayNoTag( + value: Array[Byte], + offset: Int, + length: Int + ): Unit = { + writeRawVarint32(length) + writeRawBytes(value, offset, length) + } + + def writeByteBufferNoTag(value: ByteBuffer): Unit = { + writeRawVarint32(value.capacity()) + writeRawBytes(value) + } + + def writeUInt32NoTag(value: Int): Unit = { + writeRawVarint32(value) + } + + def writeEnumNoTag(value: Int): Unit = { + writeInt32NoTag(value) + } + + def writeSFixed32NoTag(value: Int): Unit = { + writeRawLittleEndian32(value) + } + + def writeSFixed64NoTag(value: Long): Unit = { + writeRawLittleEndian64(value) + } + + def writeSInt32NoTag(value: Int): Unit = { + writeRawVarint32(encodeZigZag32(value)) + } + + def writeSInt64NoTag(value: Long): Unit = { + writeRawVarint64(encodeZigZag64(value)) + } + + def writeRawByte(value: Byte): Unit = { + if (position == limit) { + refreshBuffer() + } + buffer(position) = value + position += 1 + } + + def writeRawByte(value: Int): Unit = { + writeRawByte(value.toByte) + } + + // def writeRawBytes(value: ByteString): Unit = { + // var offset = 0 + // var length = value.size + // if (limit - position >= length) { + // // We have room in the current buffer. + // value.copyTo(buffer, offset, position, length) + // position += length + // totalBytesWritten += length + // } else { + // // Write extends past current buffer. Fill the rest of this buffer and + // // flush. + // val bytesWritten = limit - position + // value.copyTo(buffer, offset, position, bytesWritten) + // offset += bytesWritten + // length -= bytesWritten + // position = limit + // totalBytesWritten += bytesWritten + // refreshBuffer() + // // Now deal with the rest. + // // Since we have an output stream, this is our buffer + // // and buffer offset == 0 + // if (length <= limit) { + // value.copyTo(buffer, offset, 0, length) + // position = length + // } else { + // value.slice(offset, offset + length).writeTo(output) + // } + // totalBytesWritten += length + // } + // } + + def writeRawBytes(value: Array[Byte]): Unit = { + writeRawBytes(value, 0, value.length) + } + + def writeRawBytes(value: ByteBuffer): Unit = { + if (value.hasArray()) { + writeRawBytes(value.array(), value.arrayOffset(), value.capacity()) + } else { + val duplicated = value.duplicate() + duplicated.clear() + writeRawBytesInternal(duplicated) + } + } + + private def writeRawBytesInternal(value: ByteBuffer): Unit = { + var length = value.remaining() + if (limit - position >= length) { + value.get(buffer, position, length) + position += length + totalBytesWritten += length + } else { + val bytesWritten = limit - position + value.get(buffer, position, bytesWritten) + length -= bytesWritten + position = limit + totalBytesWritten += bytesWritten + refreshBuffer() + while (length > limit) { + value.get(buffer, 0, limit) + output.write(buffer, 0, limit) + length -= limit + totalBytesWritten += limit + } + value.get(buffer, 0, length) + position = length + totalBytesWritten += length + } + } + + def writeRawBytes(value: Array[Byte], offset0: Int, length0: Int): Unit = { + var offset = offset0 + var length = length0 + if (limit - position >= length) { + System.arraycopy(value, offset, buffer, position, length) + position += length + totalBytesWritten += length + } else { + val bytesWritten = limit - position + System.arraycopy(value, offset, buffer, position, bytesWritten) + offset += bytesWritten + length -= bytesWritten + position = limit + totalBytesWritten += bytesWritten + refreshBuffer() + if (length <= limit) { + System.arraycopy(value, offset, buffer, 0, length) + position = length + } else { + output.write(value, offset, length) + } + totalBytesWritten += length + } + } + +} + +object Internal { + val UTF_8 = java.nio.charset.Charset.forName("UTF-8") + val EMPTY_BYTE_ARRAY: Array[Byte] = Array() +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala new file mode 100644 index 000000000000..0d80ddddfd43 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala @@ -0,0 +1,75 @@ +package dotty.tools.dotc.semanticdb + +object SymbolOccurrence { + sealed abstract class Role(val value: Int) extends SemanticdbEnum + + object Role { + case object UNKNOWN_ROLE extends Role(0) + case object REFERENCE extends Role(1) + case object DEFINITION extends Role(2) + } +} + +case class SymbolOccurrence( + symbol: String, + range: Option[Range], + role: SymbolOccurrence.Role +) extends SemanticdbMessage { + private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 + private[this] def __computeSerializedValue(): _root_.scala.Int = { + var __size = 0 + if (range.isDefined) { + val __value = range.get + __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag( + __value.serializedSize + ) + __value.serializedSize + }; + + { + val __value = symbol + if (__value != "") { + __size += SemanticdbOutputStream + .computeStringSize(2, __value) + } + }; + + { + val __value = role + if (__value != SymbolOccurrence.Role.UNKNOWN_ROLE) { + __size += SemanticdbOutputStream + .computeEnumSize(3, __value.value) + } + }; + __size + } + final override def serializedSize: _root_.scala.Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo( + `_output__`: SemanticdbOutputStream + ): _root_.scala.Unit = { + range.foreach { __v => + val __m = __v + _output__.writeTag(1, 2) + _output__.writeUInt32NoTag(__m.serializedSize) + __m.writeTo(_output__) + }; + { + val __v = symbol + if (__v != "") { + _output__.writeString(2, __v) + } + }; + { + val __v = role + if (__v != SymbolOccurrence.Role.UNKNOWN_ROLE) { + _output__.writeEnum(3, __v.value) + } + }; + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala new file mode 100644 index 000000000000..651b8c4ac4e9 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala @@ -0,0 +1,90 @@ +package dotty.tools.dotc.semanticdb + +case class TextDocument( + schema: Schema, + language: Language, + uri: String, + md5: String, + occurrences: Seq[SymbolOccurrence] +) extends SemanticdbMessage { + private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 + private[this] def __computeSerializedValue(): _root_.scala.Int = { + var __size = 0 + + { + val __value = schema + if (__value != Schema.LEGACY) { + __size += SemanticdbOutputStream.computeEnumSize(1, __value.value) + } + }; + + { + val __value = uri + if (__value != "") { + __size += SemanticdbOutputStream + .computeStringSize(2, __value) + } + }; + + { + val __value = md5 + if (__value != "") { + __size += SemanticdbOutputStream.computeStringSize(11, __value) + } + }; + + { + val __value = language + if (__value != Language.UNKNOWN_LANGUAGE) { + __size += SemanticdbOutputStream.computeEnumSize(10, __value.value) + } + }; + occurrences.foreach { __item => + val __value = __item + __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag( + __value.serializedSize + ) + __value.serializedSize + } + __size + } + final override def serializedSize: _root_.scala.Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = { + { + val __v = schema + if (__v != Schema.LEGACY) { + _output__.writeEnum(1, __v.value) + } + }; + { + val __v = uri + if (__v != "") { + _output__.writeString(2, __v) + } + }; + occurrences.foreach { __v => + val __m = __v + _output__.writeTag(6, 2) + _output__.writeUInt32NoTag(__m.serializedSize) + __m.writeTo(_output__) + }; + { + val __v = language + if (__v != Language.UNKNOWN_LANGUAGE) { + _output__.writeEnum(10, __v.value) + } + }; + { + val __v = md5 + if (__v != "") { + _output__.writeString(11, __v) + } + }; + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala new file mode 100644 index 000000000000..a9402d2fa09c --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala @@ -0,0 +1,31 @@ +package dotty.tools.dotc.semanticdb + +case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage { + private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 + private[this] def __computeSerializedValue(): _root_.scala.Int = { + var __size = 0 + documents.foreach { __item => + val __value = __item + __size += 1 + + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + + __value.serializedSize + } + __size + } + final override def serializedSize: _root_.scala.Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = { + documents.foreach { __v => + val __m = __v + _output__.writeTag(1, 2) + _output__.writeUInt32NoTag(__m.serializedSize) + __m.writeTo(_output__) + }; + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/WireFormat.scala b/compiler/src/dotty/tools/dotc/semanticdb/WireFormat.scala new file mode 100644 index 000000000000..7419a8a17b6d --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/WireFormat.scala @@ -0,0 +1,20 @@ +package dotty.tools.dotc.semanticdb + +object WireFormat { + val WIRETYPE_VARINT = 0 + val WIRETYPE_FIXED64 = 1 + val WIRETYPE_LENGTH_DELIMITED = 2 + val WIRETYPE_START_GROUP = 3 + val WIRETYPE_END_GROUP = 4 + val WIRETYPE_FIXED32 = 5 + + val TAG_TYPE_BITS = 3 + val TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1 + + def getTagWireType(tag: Int) = tag & TAG_TYPE_MASK + + def makeTag(fieldNumber: Int, wireType: Int) = + (fieldNumber << TAG_TYPE_BITS) | wireType + + def getTagFieldNumber(tag: Int): Int = tag >>> TAG_TYPE_BITS +} From 9fbf3f019945285b0f66d829c1a8d6804b92eb00 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 7 Oct 2019 18:17:49 +0200 Subject: [PATCH 004/107] Add ScalaSettings for sourceroot and targetroot --- .../dotc/semanticdb/ExtractSemanticDB.scala | 40 ++++++++++++++----- 1 file changed, 30 insertions(+), 10 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 737ebeb1cead..c25e14e3da1e 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -1,4 +1,5 @@ -package dotty.tools.dotc +package dotty.tools +package dotc package semanticdb import core._ @@ -11,6 +12,7 @@ import Flags._ import Decorators._ import Names.Name import StdNames.nme +import util.SourcePosition import collection.mutable import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} @@ -25,19 +27,25 @@ abstract class ExtractSemanticDB extends Phase { // Check not needed since it does not transform trees override def isCheckable: Boolean = false - override def run(implicit ctx: Context): Unit = - Extractor().traverse(ctx.compilationUnit.tpdTree) + //def genInfo(unit: CompilationUnit, occurrences: List[SymbolOccurrence]) + + override def run(implicit ctx: Context): Unit = { + val extract = Extractor() + val unit = ctx.compilationUnit + extract.traverse(unit.tpdTree) + } class Extractor extends TreeTraverser { - val locals = mutable.HashMap[Symbol, java.lang.Integer]() + private val locals = mutable.HashMap[Symbol, java.lang.Integer]() + val occurrences = new mutable.ListBuffer[SymbolOccurrence]() private var myLocalIdx: Int = -1 private def nextLocalIdx() = myLocalIdx += 1 myLocalIdx - def symbolName(sym: Symbol)(given ctx: Context): String = + private def symbolName(sym: Symbol)(given ctx: Context): String = def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) @@ -83,23 +91,35 @@ abstract class ExtractSemanticDB extends Phase { else "local" + localIdx(sym) end symbolName - def registerUse(sym: Symbol) = ??? - def registerDef(sym: Symbol) = ??? + private def range(pos: SourcePosition)(given Context): Option[Range] = + val src = pos.source + def lineCol(offset: Int) = (src.offsetToLine(offset), src.column(offset)) + val (startLine, startCol) = lineCol(pos.span.start) + val (endLine, endCol) = lineCol(pos.span.end) + Some(Range(startLine, startCol, endLine, endCol)) + + private def registerOccurrence(sym: Symbol, pos: SourcePosition, role: SymbolOccurrence.Role)(given Context): Unit = + occurrences += SymbolOccurrence(symbolName(sym), range(pos), role) + + private def registerUse(sym: Symbol, pos: SourcePosition)(given Context) = + registerOccurrence(sym, pos, SymbolOccurrence.Role.REFERENCE) + private def registerDef(sym: Symbol, pos: SourcePosition)(given Context) = + registerOccurrence(sym, pos, SymbolOccurrence.Role.DEFINITION) override def traverse(tree: Tree)(given ctx: Context): Unit = tree match case tree: DefTree => - registerDef(tree.symbol) + registerDef(tree.symbol, tree.sourcePos) traverseChildren(tree) case tree: RefTree => - registerUse(tree.symbol) + registerUse(tree.symbol, tree.sourcePos) traverseChildren(tree) case tree: Import => for sel <- tree.selectors do val imported = sel.imported.name if imported != nme.WILDCARD then for alt <- tree.expr.tpe.member(imported).alternatives do - registerUse(alt.symbol) + registerUse(alt.symbol, sel.imported.sourcePos) case _ => traverseChildren(tree) } From 6217c298cda54893f88c50f248820e535841f038 Mon Sep 17 00:00:00 2001 From: Olafur Pall Geirsson Date: Mon, 7 Oct 2019 18:07:23 +0200 Subject: [PATCH 005/107] Add helper method to write SemanticDB files --- .../src/dotty/tools/dotc/semanticdb/MD5.scala | 28 +++++++ .../dotty/tools/dotc/semanticdb/Main.scala | 83 ++++++++++++------- .../tools/dotc/semanticdb/Semanticdb.scala | 33 -------- 3 files changed, 81 insertions(+), 63 deletions(-) create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/MD5.scala delete mode 100644 compiler/src/dotty/tools/dotc/semanticdb/Semanticdb.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/MD5.scala b/compiler/src/dotty/tools/dotc/semanticdb/MD5.scala new file mode 100644 index 000000000000..cbbb0f508c87 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/MD5.scala @@ -0,0 +1,28 @@ +package dotty.tools.dotc.semanticdb + +import java.nio.ByteBuffer +import java.nio.charset.StandardCharsets +import java.security.MessageDigest + +object MD5 { + def compute(string: String): String = { + compute(ByteBuffer.wrap(string.getBytes(StandardCharsets.UTF_8))) + } + def compute(buffer: ByteBuffer): String = { + val md = MessageDigest.getInstance("MD5") + md.update(buffer) + bytesToHex(md.digest()) + } + private val hexArray = "0123456789ABCDEF".toCharArray + def bytesToHex(bytes: Array[Byte]): String = { + val hexChars = new Array[Char](bytes.length * 2) + var j = 0 + while (j < bytes.length) { + val v: Int = bytes(j) & 0xFF + hexChars(j * 2) = hexArray(v >>> 4) + hexChars(j * 2 + 1) = hexArray(v & 0x0F) + j += 1 + } + new String(hexChars) + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Main.scala b/compiler/src/dotty/tools/dotc/semanticdb/Main.scala index c563d1513a97..003adb7029d2 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Main.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Main.scala @@ -1,44 +1,67 @@ package dotty.tools.dotc.semanticdb + import java.nio.file.Paths import java.nio.file.Files import java.nio.file.StandardOpenOption +import java.nio.file.Path +import java.security.MessageDigest +import java.nio.charset.StandardCharsets +import scala.collection.JavaConverters._ object Main { - def main(args: Array[String]): Unit = { - if (args.isEmpty) { - println("missing ") - } - val docs = TextDocuments( - List( - TextDocument( - Schema.SEMANTICDB3, - Language.SCALA, - uri = "Main.scala", - "md5", - List( - SymbolOccurrence( - "scala/Predef.String#", - Some(Range(0, 0, 1, 1)), - SymbolOccurrence.Role.REFERENCE - ) - ) - ) - ) - ) - println(docs.serializedSize) - val path = Paths.get(args(0)).toAbsolutePath() - val out = Files.newOutputStream( - path, - StandardOpenOption.CREATE, - StandardOpenOption.TRUNCATE_EXISTING + def write( + source: Path, + contents: String, + sourceroot: Path, + targetroot: Path, + occurrences: Seq[SymbolOccurrence] + ): Unit = { + val relpath = sourceroot.relativize(source) + val reluri = relpath.iterator().asScala.mkString("/") + val outpath = targetroot + .resolve("META-INF") + .resolve("semanticdb") + .resolve(relpath) + .resolveSibling(source.getFileName().toString() + ".semanticdb") + Files.createDirectories(outpath.getParent()) + val doc: TextDocument = TextDocument( + schema = Schema.SEMANTICDB4, + language = Language.SCALA, + uri = reluri, + md5 = MD5.compute(contents), + occurrences = occurrences ) - val stream = SemanticdbOutputStream.newInstance(out) + val docs = TextDocuments(List(doc)) + val out = Files.newOutputStream(outpath) try { + val stream = SemanticdbOutputStream.newInstance(out) docs.writeTo(stream) - } finally { stream.flush() + } finally { out.close() } - println(path) + } + + def main(args: Array[String]): Unit = { + if (args.isEmpty) { + println("missing ") + sys.exit(1) + } + val occurrences = List( + SymbolOccurrence( + "_empty_/Main.", + Some(Range(0, 8, 0, 12)), + SymbolOccurrence.Role.REFERENCE + ) + ) + val sourceroot = Paths.get(args(0)) + val targetroot = sourceroot.resolve("out") + write( + sourceroot.resolve("Main.scala"), + "object Main", + sourceroot, + targetroot, + occurrences + ) } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Semanticdb.scala b/compiler/src/dotty/tools/dotc/semanticdb/Semanticdb.scala deleted file mode 100644 index 379043d563dc..000000000000 --- a/compiler/src/dotty/tools/dotc/semanticdb/Semanticdb.scala +++ /dev/null @@ -1,33 +0,0 @@ -package dotty.tools.dotc.semanticdb - -import java.nio.file.Path - -object Semanticdb { - case class Range( - startLine: Int, - startCharacter: Int, - endLine: Int, - endCharacter: Int - ) - trait ProtobufMessage { - def writeTo(out: CodedOutputStream): Unit = {} - } - sealed abstract class Role - object Role { - case object Reference extends Role - case object Definition extends Role - } - case class SymbolOccurrence(symbol: String, range: Range, role: Role) extends ProtobufMessage - case class TextDocuments(documents: Seq[TextDocument]) - class CodedOutputStream() { - def writeInt(): Unit = () - // ... - } - case class TextDocument( - uri: String, - md5: String, - occurrences: Seq[SymbolOccurrence] - ) { - def writeTo(out: CodedOutputStream): Unit = {} - } -} From fe02843d2176f36869f0eb72a2e57cdd2dc558ca Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 7 Oct 2019 20:05:52 +0200 Subject: [PATCH 006/107] Write SemanticDB file --- .../dotc/semanticdb/ExtractSemanticDB.scala | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index c25e14e3da1e..53d2c955d784 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -15,6 +15,7 @@ import StdNames.nme import util.SourcePosition import collection.mutable import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} +import java.nio.file.Paths abstract class ExtractSemanticDB extends Phase { import ast.tpd._ @@ -33,6 +34,17 @@ abstract class ExtractSemanticDB extends Phase { val extract = Extractor() val unit = ctx.compilationUnit extract.traverse(unit.tpdTree) + val targetRootSetting = ctx.settings.targetroot.value + val targetRoot = + if targetRootSetting.isEmpty then ctx.settings.outputDir.value.jpath + else Paths.get(targetRootSetting) + ExtractSemanticDB.write( + unit.source.file.jpath, + String(unit.source.content), + Paths.get(ctx.settings.sourceroot.value), + Paths.get(ctx.settings.targetroot.value), + extract.occurrences.toList + ) } class Extractor extends TreeTraverser { @@ -126,5 +138,40 @@ abstract class ExtractSemanticDB extends Phase { } object ExtractSemanticDB { + import java.nio.file.Path + import scala.collection.JavaConverters._ + import java.nio.file.Files + val name: String = "extractSemanticDB" + + def write( + source: Path, + contents: String, + sourceroot: Path, + targetroot: Path, + occurrences: Seq[SymbolOccurrence] + ): Unit = + val relpath = sourceroot.relativize(source) + val reluri = relpath.iterator().asScala.mkString("/") + val outpath = targetroot + .resolve("META-INF") + .resolve("semanticdb") + .resolve(relpath) + .resolveSibling(source.getFileName().toString() + ".semanticdb") + Files.createDirectories(outpath.getParent()) + val doc: TextDocument = TextDocument( + schema = Schema.SEMANTICDB4, + language = Language.SCALA, + uri = reluri, + md5 = MD5.compute(contents), + occurrences = occurrences + ) + val docs = TextDocuments(List(doc)) + val out = Files.newOutputStream(outpath) + try + val stream = SemanticdbOutputStream.newInstance(out) + docs.writeTo(stream) + stream.flush() + finally + out.close() } From 39f244bfdb055c34952ea6e2cfa4cac15d953bd5 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 8 Oct 2019 10:40:55 +0200 Subject: [PATCH 007/107] Integrate ExtractSsemanticDB in Compiler --- compiler/src/dotty/tools/dotc/Compiler.scala | 1 + .../dotc/semanticdb/ExtractSemanticDB.scala | 32 ++++++++++++------- 2 files changed, 22 insertions(+), 11 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala index 94c2b6fa786e..82f7242fe98e 100644 --- a/compiler/src/dotty/tools/dotc/Compiler.scala +++ b/compiler/src/dotty/tools/dotc/Compiler.scala @@ -40,6 +40,7 @@ class Compiler { List(new YCheckPositions) :: // YCheck positions List(new Staging) :: // Check PCP, heal quoted types and expand macros List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks + List(new semanticdb.ExtractSemanticDB) :: List(new PostTyper) :: // Additional checks and cleanups after type checking List(new sbt.ExtractAPI) :: // Sends a representation of the API of classes to sbt via callbacks List(new SetRootTree) :: // Set the `rootTreeOrProvider` on class symbols diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 53d2c955d784..6678391ccbcc 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -17,13 +17,13 @@ import collection.mutable import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} import java.nio.file.Paths -abstract class ExtractSemanticDB extends Phase { +class ExtractSemanticDB extends Phase { import ast.tpd._ override val phaseName: String = ExtractSemanticDB.name override def isRunnable(implicit ctx: Context) = - super.isRunnable && ctx.settings.YretainTrees.value + true || super.isRunnable && ctx.settings.YretainTrees.value // Check not needed since it does not transform trees override def isCheckable: Boolean = false @@ -49,9 +49,12 @@ abstract class ExtractSemanticDB extends Phase { class Extractor extends TreeTraverser { - private val locals = mutable.HashMap[Symbol, java.lang.Integer]() + private val locals = mutable.HashMap[Symbol, Int]() + val occurrences = new mutable.ListBuffer[SymbolOccurrence]() + val localIndex = mutable.HashMap[Int, Int]() + private var myLocalIdx: Int = -1 private def nextLocalIdx() = myLocalIdx += 1 @@ -61,6 +64,8 @@ abstract class ExtractSemanticDB extends Phase { def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) + || str == nme.CONSTRUCTOR.toString + || str == nme.STATIC_CONSTRUCTOR.toString def nameToString(name: Name) = val str = name.toString @@ -71,7 +76,7 @@ abstract class ExtractSemanticDB extends Phase { || (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) def ownerString(owner: Symbol): String = - if owner.isRoot then "" else symbolName(owner) + "/" + if owner.isRoot || owner.isEmptyPackage then "" else symbolName(owner) + "/" def overloadIdx(sym: Symbol): String = val alts = sym.owner.info.decls.lookupAll(sym.name).toList @@ -87,15 +92,15 @@ abstract class ExtractSemanticDB extends Phase { else val str = nameToString(sym.name) if sym.is(Package) then str - else if sym.is(Module) || sym.isGetter && !sym.is(Mutable) then str + "." else if sym.isType then str + "#" - else if sym.is(Method) then str + "(" + overloadIdx(sym) + ")" - else if sym.is(TermParam) then "(" + str + ")" + else if sym.isRealMethod then str + "(" + overloadIdx(sym) + ")" + else if sym.is(TermParam) || sym.is(ParamAccessor) then "(" + str + ")" else if sym.is(TypeParam) then "[" + str + "]" - else throw new AssertionError(i"unhandled symbol: $sym") + else if sym.isTerm then str + "." + else throw new AssertionError(i"unhandled symbol: $sym: ${sym.info} with ${sym.flagsString}") - def localIdx(sym: Symbol): Int = - locals.getOrElseUpdate(sym, nextLocalIdx()) + def localIdx(sym: Symbol)(given Context): Int = + localIndex.getOrElseUpdate(sym.span.start, nextLocalIdx()) if sym.isRoot then "_root_" else if sym.isEmptyPackage then "_empty_" @@ -110,8 +115,13 @@ abstract class ExtractSemanticDB extends Phase { val (endLine, endCol) = lineCol(pos.span.end) Some(Range(startLine, startCol, endLine, endCol)) + private def excluded(sym: Symbol)(given Context): Boolean = + !sym.exists || sym.isLocalDummy + private def registerOccurrence(sym: Symbol, pos: SourcePosition, role: SymbolOccurrence.Role)(given Context): Unit = - occurrences += SymbolOccurrence(symbolName(sym), range(pos), role) + if !excluded(sym) then + //println(i"register: ${symbolName(sym)}") + occurrences += SymbolOccurrence(symbolName(sym), range(pos), role) private def registerUse(sym: Symbol, pos: SourcePosition)(given Context) = registerOccurrence(sym, pos, SymbolOccurrence.Role.REFERENCE) From 004b6c4cc3d14c54903ca2a89d6f1772bed073d8 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 8 Oct 2019 11:33:47 +0200 Subject: [PATCH 008/107] Extract only under -Ysemanticdb --- compiler/src/dotty/tools/dotc/config/ScalaSettings.scala | 2 +- .../src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala index 193f3f894d3e..b65e14e01844 100644 --- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala +++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala @@ -150,7 +150,7 @@ class ScalaSettings extends Settings.SettingGroup { val YdumpSbtInc: Setting[Boolean] = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.") val YcheckAllPatmat: Setting[Boolean] = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)") val YretainTrees: Setting[Boolean] = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree") - val YsemanticDB: Setting[Boolean] = BooleanSetting("-Ysemanticdb", "Store information in SemanticDB") + val Ysemanticdb: Setting[Boolean] = BooleanSetting("-Ysemanticdb", "Store information in SemanticDB") val YshowTreeIds: Setting[Boolean] = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.") val YprofileEnabled: Setting[Boolean] = BooleanSetting("-Yprofile-enabled", "Enable profiling.") diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 6678391ccbcc..5c59fcc4bace 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -23,7 +23,7 @@ class ExtractSemanticDB extends Phase { override val phaseName: String = ExtractSemanticDB.name override def isRunnable(implicit ctx: Context) = - true || super.isRunnable && ctx.settings.YretainTrees.value + super.isRunnable && ctx.settings.Ysemanticdb.value // Check not needed since it does not transform trees override def isCheckable: Boolean = false From 8caff2dc763edca488b081822a395bf2a6ee0570 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 8 Oct 2019 12:52:47 +0200 Subject: [PATCH 009/107] Refactor path logic and fix symbol names --- .../dotc/semanticdb/ExtractSemanticDB.scala | 52 ++++++++----------- 1 file changed, 21 insertions(+), 31 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 5c59fcc4bace..b146a79ab434 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -12,7 +12,7 @@ import Flags._ import Decorators._ import Names.Name import StdNames.nme -import util.SourcePosition +import util.{SourceFile, SourcePosition} import collection.mutable import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} import java.nio.file.Paths @@ -34,17 +34,7 @@ class ExtractSemanticDB extends Phase { val extract = Extractor() val unit = ctx.compilationUnit extract.traverse(unit.tpdTree) - val targetRootSetting = ctx.settings.targetroot.value - val targetRoot = - if targetRootSetting.isEmpty then ctx.settings.outputDir.value.jpath - else Paths.get(targetRootSetting) - ExtractSemanticDB.write( - unit.source.file.jpath, - String(unit.source.content), - Paths.get(ctx.settings.sourceroot.value), - Paths.get(ctx.settings.targetroot.value), - extract.occurrences.toList - ) + ExtractSemanticDB.write(unit.source, extract.occurrences.toList) } class Extractor extends TreeTraverser { @@ -64,8 +54,6 @@ class ExtractSemanticDB extends Phase { def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) - || str == nme.CONSTRUCTOR.toString - || str == nme.STATIC_CONSTRUCTOR.toString def nameToString(name: Name) = val str = name.toString @@ -76,7 +64,7 @@ class ExtractSemanticDB extends Phase { || (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) def ownerString(owner: Symbol): String = - if owner.isRoot || owner.isEmptyPackage then "" else symbolName(owner) + "/" + if owner.isRoot || owner.isEmptyPackage then "" else symbolName(owner) def overloadIdx(sym: Symbol): String = val alts = sym.owner.info.decls.lookupAll(sym.name).toList @@ -84,14 +72,14 @@ class ExtractSemanticDB extends Phase { else val idx = alts.indexOf(sym) assert(idx >= 0) - idx.toString + "+" + idx.toString def descriptor(sym: Symbol): String = if sym.is(ModuleClass) then descriptor(sym.sourceModule) else val str = nameToString(sym.name) - if sym.is(Package) then str + if sym.is(Package) then str + "/" else if sym.isType then str + "#" else if sym.isRealMethod then str + "(" + overloadIdx(sym) + ")" else if sym.is(TermParam) || sym.is(ParamAccessor) then "(" + str + ")" @@ -154,26 +142,28 @@ object ExtractSemanticDB { val name: String = "extractSemanticDB" - def write( - source: Path, - contents: String, - sourceroot: Path, - targetroot: Path, - occurrences: Seq[SymbolOccurrence] - ): Unit = - val relpath = sourceroot.relativize(source) - val reluri = relpath.iterator().asScala.mkString("/") - val outpath = targetroot + def write(source: SourceFile, occurrences: List[SymbolOccurrence])(given ctx: Context): Unit = + val sourcePath = source.file.jpath + val sourceRoot = Paths.get(ctx.settings.sourceroot.value) + val targetRoot = + val targetRootSetting = ctx.settings.targetroot.value + if targetRootSetting.isEmpty then ctx.settings.outputDir.value.jpath + else Paths.get(targetRootSetting) + println(i"extract from $sourcePath from $sourceRoot, targetRoot = $targetRoot") + val relPath = sourceRoot.relativize(sourcePath) + println(i"relPath = $relPath") + val relURI = relPath.iterator().asScala.mkString("/") + val outpath = targetRoot .resolve("META-INF") .resolve("semanticdb") - .resolve(relpath) - .resolveSibling(source.getFileName().toString() + ".semanticdb") + .resolve(relPath) + .resolveSibling(sourcePath.getFileName().toString() + ".semanticdb") Files.createDirectories(outpath.getParent()) val doc: TextDocument = TextDocument( schema = Schema.SEMANTICDB4, language = Language.SCALA, - uri = reluri, - md5 = MD5.compute(contents), + uri = relURI, + md5 = MD5.compute(String(source.content)), occurrences = occurrences ) val docs = TextDocuments(List(doc)) From c7e13cf9aea446de8635f48380189b636652973d Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 8 Oct 2019 13:45:36 +0200 Subject: [PATCH 010/107] Fixes to localIdx and more comments --- .../dotc/semanticdb/ExtractSemanticDB.scala | 39 +++++++++++++------ 1 file changed, 27 insertions(+), 12 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index b146a79ab434..76c93b63add2 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -28,8 +28,6 @@ class ExtractSemanticDB extends Phase { // Check not needed since it does not transform trees override def isCheckable: Boolean = false - //def genInfo(unit: CompilationUnit, occurrences: List[SymbolOccurrence]) - override def run(implicit ctx: Context): Unit = { val extract = Extractor() val unit = ctx.compilationUnit @@ -37,19 +35,23 @@ class ExtractSemanticDB extends Phase { ExtractSemanticDB.write(unit.source, extract.occurrences.toList) } + /** Extractor of symbol occurrences from trees */ class Extractor extends TreeTraverser { - private val locals = mutable.HashMap[Symbol, Int]() + private var nextLocalIdx: Int = 0 - val occurrences = new mutable.ListBuffer[SymbolOccurrence]() + /** The index of a local symbol */ + private val locals = mutable.HashMap[Symbol, Int]() - val localIndex = mutable.HashMap[Int, 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]() + } - private var myLocalIdx: Int = -1 - private def nextLocalIdx() = - myLocalIdx += 1 - myLocalIdx + /** The extracted symbol occurrences */ + val occurrences = new mutable.ListBuffer[SymbolOccurrence]() + /** The semanticdb name of the given symbol */ private def symbolName(sym: Symbol)(given ctx: Context): String = def isJavaIdent(str: String) = @@ -59,6 +61,7 @@ class ExtractSemanticDB extends Phase { val str = name.toString if isJavaIdent(str) then str else "`" + str + "`" + /** Is symbol global? Non-global symbols get localX names */ def isGlobal(sym: Symbol): Boolean = sym.is(Package) || (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) @@ -87,8 +90,21 @@ class ExtractSemanticDB extends Phase { else if sym.isTerm then str + "." else throw new AssertionError(i"unhandled symbol: $sym: ${sym.info} with ${sym.flagsString}") - def localIdx(sym: Symbol)(given Context): Int = - localIndex.getOrElseUpdate(sym.span.start, nextLocalIdx()) + /** The index of local symbol `sym`. Symbols with the same name and + * the same starting position have the same index. + */ + def localIdx(sym: Symbol)(given Context): Int = { + def computeLocalIdx(): Int = + symsAtOffset(sym.span.start).find(_.name == sym.name) match + case Some(other) => localIdx(other) + case None => + val idx = nextLocalIdx + nextLocalIdx += 1 + locals(sym) = idx + symsAtOffset(sym.span.start) += sym + idx + locals.getOrElseUpdate(sym, computeLocalIdx()) + } if sym.isRoot then "_root_" else if sym.isEmptyPackage then "_empty_" @@ -108,7 +124,6 @@ class ExtractSemanticDB extends Phase { private def registerOccurrence(sym: Symbol, pos: SourcePosition, role: SymbolOccurrence.Role)(given Context): Unit = if !excluded(sym) then - //println(i"register: ${symbolName(sym)}") occurrences += SymbolOccurrence(symbolName(sym), range(pos), role) private def registerUse(sym: Symbol, pos: SourcePosition)(given Context) = From 53e79186c1089e70b044c65d86a665967a310ce3 Mon Sep 17 00:00:00 2001 From: Olafur Pall Geirsson Date: Tue, 8 Oct 2019 15:19:55 +0200 Subject: [PATCH 011/107] Absolutize and normalize paths before writing SemanticDB. --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 76c93b63add2..3ca05105a92f 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -158,15 +158,16 @@ object ExtractSemanticDB { val name: String = "extractSemanticDB" def write(source: SourceFile, occurrences: List[SymbolOccurrence])(given ctx: Context): Unit = - val sourcePath = source.file.jpath - val sourceRoot = Paths.get(ctx.settings.sourceroot.value) + def absolutePath(path: Path): Path = path.toAbsolutePath.normalize + val sourcePath = absolutePath(source.file.jpath) + val sourceRoot = absolutePath(Paths.get(ctx.settings.sourceroot.value)) val targetRoot = val targetRootSetting = ctx.settings.targetroot.value - if targetRootSetting.isEmpty then ctx.settings.outputDir.value.jpath - else Paths.get(targetRootSetting) - println(i"extract from $sourcePath from $sourceRoot, targetRoot = $targetRoot") + absolutePath( + if targetRootSetting.isEmpty then ctx.settings.outputDir.value.jpath + else Paths.get(targetRootSetting) + ) val relPath = sourceRoot.relativize(sourcePath) - println(i"relPath = $relPath") val relURI = relPath.iterator().asScala.mkString("/") val outpath = targetRoot .resolve("META-INF") From 6921db7daa0f792f46af0b0a5c7b659bcfa74d8f Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 8 Oct 2019 16:46:43 +0200 Subject: [PATCH 012/107] Use buiders instead of String + Using builders avoids temporary copies --- .../dotc/semanticdb/ExtractSemanticDB.scala | 98 +++++++++++-------- 1 file changed, 59 insertions(+), 39 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 3ca05105a92f..6ee856ca9908 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -12,6 +12,7 @@ import Flags._ import Decorators._ import Names.Name import StdNames.nme +import util.Spans.Span import util.{SourceFile, SourcePosition} import collection.mutable import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} @@ -48,52 +49,57 @@ class ExtractSemanticDB extends Phase { override def default(key: Int) = Set[Symbol]() } + private val generated = new mutable.HashSet[SymbolOccurrence] + /** The extracted symbol occurrences */ val occurrences = new mutable.ListBuffer[SymbolOccurrence]() - /** The semanticdb name of the given symbol */ - private def symbolName(sym: Symbol)(given ctx: Context): String = + /** Add semanticdb name of the given symbol to string builder */ + private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) - def nameToString(name: Name) = + def addName(name: Name) = val str = name.toString - if isJavaIdent(str) then str else "`" + str + "`" + if isJavaIdent(str) then b.append(str) + else b.append('`').append(str).append('`') /** Is symbol global? Non-global symbols get localX names */ def isGlobal(sym: Symbol): Boolean = sym.is(Package) || (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) - def ownerString(owner: Symbol): String = - if owner.isRoot || owner.isEmptyPackage then "" else symbolName(owner) + def addOwner(owner: Symbol): Unit = + if !owner.isRoot && !owner.isEmptyPackage then addSymName(b, owner) - def overloadIdx(sym: Symbol): String = + def addOverloadIdx(sym: Symbol): Unit = val alts = sym.owner.info.decls.lookupAll(sym.name).toList - if alts.tail.isEmpty then "" - else + if alts.tail.nonEmpty then val idx = alts.indexOf(sym) assert(idx >= 0) - "+" + idx.toString + b.append('+').append(idx.toString) - def descriptor(sym: Symbol): String = + def addDescriptor(sym: Symbol): Unit = if sym.is(ModuleClass) then - descriptor(sym.sourceModule) + addDescriptor(sym.sourceModule) + else if sym.is(Param) || sym.is(ParamAccessor) then + b.append('('); addName(sym.name); b.append(')') + else if sym.is(TypeParam) then + b.append('['); addName(sym.name); b.append(']') else - val str = nameToString(sym.name) - if sym.is(Package) then str + "/" - else if sym.isType then str + "#" - else if sym.isRealMethod then str + "(" + overloadIdx(sym) + ")" - else if sym.is(TermParam) || sym.is(ParamAccessor) then "(" + str + ")" - else if sym.is(TypeParam) then "[" + str + "]" - else if sym.isTerm then str + "." + addName(sym.name) + if sym.is(Package) then b.append('/') + else if sym.isType then b.append('#') + else if sym.isRealMethod then + b.append('('); addOverloadIdx(sym); b.append(").") + else if sym.isTerm then b.append('.') else throw new AssertionError(i"unhandled symbol: $sym: ${sym.info} with ${sym.flagsString}") /** The index of local symbol `sym`. Symbols with the same name and * the same starting position have the same index. */ - def localIdx(sym: Symbol)(given Context): Int = { + def localIdx(sym: Symbol)(given Context): Int = def computeLocalIdx(): Int = symsAtOffset(sym.span.start).find(_.name == sym.name) match case Some(other) => localIdx(other) @@ -104,47 +110,61 @@ class ExtractSemanticDB extends Phase { symsAtOffset(sym.span.start) += sym idx locals.getOrElseUpdate(sym, computeLocalIdx()) - } - if sym.isRoot then "_root_" - else if sym.isEmptyPackage then "_empty_" - else if isGlobal(sym) then ownerString(sym.owner) + descriptor(sym) - else "local" + localIdx(sym) - end symbolName + if sym.isRoot then + b.append("_root_") + else if sym.isEmptyPackage then + b.append("_empty_") + else if isGlobal(sym) then + addOwner(sym.owner); addDescriptor(sym) + else + b.append("local").append(localIdx(sym)) + end addSymName + + /** The semanticdb name of the given symbol */ + private def symbolName(sym: Symbol)(given ctx: Context): String = + val b = StringBuilder() + addSymName(b, sym) + b.toString - private def range(pos: SourcePosition)(given Context): Option[Range] = - val src = pos.source + private def range(span: Span)(given ctx: Context): Option[Range] = + val src = ctx.compilationUnit.source def lineCol(offset: Int) = (src.offsetToLine(offset), src.column(offset)) - val (startLine, startCol) = lineCol(pos.span.start) - val (endLine, endCol) = lineCol(pos.span.end) + val (startLine, startCol) = lineCol(span.start) + val (endLine, endCol) = lineCol(span.end) Some(Range(startLine, startCol, endLine, endCol)) private def excluded(sym: Symbol)(given Context): Boolean = !sym.exists || sym.isLocalDummy - private def registerOccurrence(sym: Symbol, pos: SourcePosition, role: SymbolOccurrence.Role)(given Context): Unit = + private def registerOccurrence(sym: Symbol, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = if !excluded(sym) then - occurrences += SymbolOccurrence(symbolName(sym), range(pos), role) + val occ = SymbolOccurrence(symbolName(sym), range(span), role) + if !generated.contains(occ) then + occurrences += occ + generated += occ - private def registerUse(sym: Symbol, pos: SourcePosition)(given Context) = - registerOccurrence(sym, pos, SymbolOccurrence.Role.REFERENCE) - private def registerDef(sym: Symbol, pos: SourcePosition)(given Context) = - registerOccurrence(sym, pos, SymbolOccurrence.Role.DEFINITION) + private def registerUse(sym: Symbol, span: Span)(given Context) = + registerOccurrence(sym, span, SymbolOccurrence.Role.REFERENCE) + private def registerDef(sym: Symbol, span: Span)(given Context) = + registerOccurrence(sym, span, SymbolOccurrence.Role.DEFINITION) override def traverse(tree: Tree)(given ctx: Context): Unit = tree match case tree: DefTree => - registerDef(tree.symbol, tree.sourcePos) + registerDef(tree.symbol, tree.span) traverseChildren(tree) case tree: RefTree => - registerUse(tree.symbol, tree.sourcePos) + registerUse(tree.symbol, tree.span) traverseChildren(tree) case tree: Import => for sel <- tree.selectors do val imported = sel.imported.name if imported != nme.WILDCARD then for alt <- tree.expr.tpe.member(imported).alternatives do - registerUse(alt.symbol, sel.imported.sourcePos) + registerUse(alt.symbol, sel.imported.span) + case tree: Inlined => + traverse(tree.call) case _ => traverseChildren(tree) } From fa5009dd14035db54806883cc87c083e2cdf4e32 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Wed, 9 Oct 2019 10:16:32 +0200 Subject: [PATCH 013/107] Refine exclusion criteria --- .../dotc/semanticdb/ExtractSemanticDB.scala | 48 +++++++++++++------ 1 file changed, 33 insertions(+), 15 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 6ee856ca9908..b63df8e8c50e 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -18,6 +18,11 @@ import collection.mutable import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} import java.nio.file.Paths +/** Extract symbol references and uses to semanticdb files. + * See https://scalameta.org/docs/semanticdb/specification.html#symbol-1 + * for a description of the format. + * TODO: Also extract type information + */ class ExtractSemanticDB extends Phase { import ast.tpd._ @@ -127,35 +132,48 @@ class ExtractSemanticDB extends Phase { addSymName(b, sym) b.toString + private def source(given ctx: Context) = ctx.compilationUnit.source + private def range(span: Span)(given ctx: Context): Option[Range] = - val src = ctx.compilationUnit.source - def lineCol(offset: Int) = (src.offsetToLine(offset), src.column(offset)) + def lineCol(offset: Int) = (source.offsetToLine(offset), source.column(offset)) val (startLine, startCol) = lineCol(span.start) val (endLine, endCol) = lineCol(span.end) Some(Range(startLine, startCol, endLine, endCol)) - private def excluded(sym: Symbol)(given Context): Boolean = - !sym.exists || sym.isLocalDummy + private def excludeDef(sym: Symbol)(given Context): Boolean = + !sym.exists || sym.isLocalDummy || sym.is(Synthetic) + + private def excludeUse(sym: Symbol, span: Span)(given Context): Boolean = + excludeDef(sym) && span.start == span.end private def registerOccurrence(sym: Symbol, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = - if !excluded(sym) then - val occ = SymbolOccurrence(symbolName(sym), range(span), role) - if !generated.contains(occ) then - occurrences += occ - generated += occ + val occ = SymbolOccurrence(symbolName(sym), range(span), role) + if !generated.contains(occ) then + occurrences += occ + generated += occ private def registerUse(sym: Symbol, span: Span)(given Context) = - registerOccurrence(sym, span, SymbolOccurrence.Role.REFERENCE) - private def registerDef(sym: Symbol, span: Span)(given Context) = - registerOccurrence(sym, span, SymbolOccurrence.Role.DEFINITION) + if !excludeUse(sym, span) then + registerOccurrence(sym, span, SymbolOccurrence.Role.REFERENCE) override def traverse(tree: Tree)(given ctx: Context): Unit = + //println(i"reg $tree") tree match - case tree: DefTree => - registerDef(tree.symbol, tree.span) + case tree: DefTree if !excludeDef(tree.symbol) => + registerOccurrence(tree.symbol, tree.span, SymbolOccurrence.Role.DEFINITION) traverseChildren(tree) - case tree: RefTree => + case tree: Ident => registerUse(tree.symbol, tree.span) + case tree: Select => + if !excludeUse(tree.symbol, tree.span) then + val end = tree.span.end + val limit = tree.qualifier.span.end + val start = + if limit < end then + val len = tree.name.toString.length + if source.content()(end - 1) == '`' then end - len - 1 else end - len + else limit + registerUse(tree.symbol, Span(start max limit, end)) traverseChildren(tree) case tree: Import => for sel <- tree.selectors do From 163f0865d2f48848406adbb40d18bd2bd344a1f1 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Wed, 9 Oct 2019 10:29:38 +0200 Subject: [PATCH 014/107] Polishings --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index b63df8e8c50e..531aee51843d 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -35,8 +35,8 @@ class ExtractSemanticDB extends Phase { override def isCheckable: Boolean = false override def run(implicit ctx: Context): Unit = { - val extract = Extractor() val unit = ctx.compilationUnit + val extract = Extractor() extract.traverse(unit.tpdTree) ExtractSemanticDB.write(unit.source, extract.occurrences.toList) } @@ -54,11 +54,12 @@ class ExtractSemanticDB extends Phase { override def default(key: Int) = Set[Symbol]() } - private val generated = new mutable.HashSet[SymbolOccurrence] - /** The extracted symbol occurrences */ val occurrences = new mutable.ListBuffer[SymbolOccurrence]() + /** The symbol occurrences generated so far, as a set */ + private val generated = new mutable.HashSet[SymbolOccurrence] + /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = @@ -83,7 +84,7 @@ class ExtractSemanticDB extends Phase { if alts.tail.nonEmpty then val idx = alts.indexOf(sym) assert(idx >= 0) - b.append('+').append(idx.toString) + b.append('+').append(idx) def addDescriptor(sym: Symbol): Unit = if sym.is(ModuleClass) then @@ -98,8 +99,7 @@ class ExtractSemanticDB extends Phase { else if sym.isType then b.append('#') else if sym.isRealMethod then b.append('('); addOverloadIdx(sym); b.append(").") - else if sym.isTerm then b.append('.') - else throw new AssertionError(i"unhandled symbol: $sym: ${sym.info} with ${sym.flagsString}") + else b.append('.') /** The index of local symbol `sym`. Symbols with the same name and * the same starting position have the same index. @@ -140,9 +140,11 @@ class ExtractSemanticDB extends Phase { val (endLine, endCol) = lineCol(span.end) Some(Range(startLine, startCol, endLine, endCol)) + /** Definitions of this symbol should be excluded from semanticdb */ private def excludeDef(sym: Symbol)(given Context): Boolean = !sym.exists || sym.isLocalDummy || sym.is(Synthetic) + /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ private def excludeUse(sym: Symbol, span: Span)(given Context): Boolean = excludeDef(sym) && span.start == span.end @@ -157,7 +159,6 @@ class ExtractSemanticDB extends Phase { registerOccurrence(sym, span, SymbolOccurrence.Role.REFERENCE) override def traverse(tree: Tree)(given ctx: Context): Unit = - //println(i"reg $tree") tree match case tree: DefTree if !excludeDef(tree.symbol) => registerOccurrence(tree.symbol, tree.span, SymbolOccurrence.Role.DEFINITION) From dfe4d92a723e4cb68c9dbc07386d092e795c749c Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Wed, 9 Oct 2019 10:50:58 +0200 Subject: [PATCH 015/107] Add test case --- tests/new/semanticdb-extract.scala | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 tests/new/semanticdb-extract.scala diff --git a/tests/new/semanticdb-extract.scala b/tests/new/semanticdb-extract.scala new file mode 100644 index 000000000000..a7564db67b7d --- /dev/null +++ b/tests/new/semanticdb-extract.scala @@ -0,0 +1,18 @@ +object A { + + def foo(x: Int) = () + def foo(): Unit = () + + foo(1) + foo() + + "".substring(1) + "".substring(1, 2) + + List(1, 2) + List.apply() + List.`apply`() + println(1 + 2) + + case class Foo(x: Int) +} \ No newline at end of file From 1b397e4aa108afc6fbb713b8110c46b98326bb06 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Wed, 9 Oct 2019 10:54:36 +0200 Subject: [PATCH 016/107] Omit definitions with offset positions --- .../src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 531aee51843d..e16d44e322a1 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -160,7 +160,8 @@ class ExtractSemanticDB extends Phase { override def traverse(tree: Tree)(given ctx: Context): Unit = tree match - case tree: DefTree if !excludeDef(tree.symbol) => + case tree: DefTree + if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => registerOccurrence(tree.symbol, tree.span, SymbolOccurrence.Role.DEFINITION) traverseChildren(tree) case tree: Ident => From e9cf5688e4f5462314f93ca553f24c7fb02a2557 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Wed, 9 Oct 2019 15:41:18 +0200 Subject: [PATCH 017/107] Fix variable references --- .../dotc/semanticdb/ExtractSemanticDB.scala | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index e16d44e322a1..58d04ba9062e 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -34,12 +34,11 @@ class ExtractSemanticDB extends Phase { // Check not needed since it does not transform trees override def isCheckable: Boolean = false - override def run(implicit ctx: Context): Unit = { + override def run(implicit ctx: Context): Unit = val unit = ctx.compilationUnit val extract = Extractor() extract.traverse(unit.tpdTree) ExtractSemanticDB.write(unit.source, extract.occurrences.toList) - } /** Extractor of symbol occurrences from trees */ class Extractor extends TreeTraverser { @@ -97,7 +96,7 @@ class ExtractSemanticDB extends Phase { addName(sym.name) if sym.is(Package) then b.append('/') else if sym.isType then b.append('#') - else if sym.isRealMethod then + else if sym.is(Method) && (!sym.is(Accessor) || sym.is(Mutable)) then b.append('('); addOverloadIdx(sym); b.append(").") else b.append('.') @@ -116,14 +115,15 @@ class ExtractSemanticDB extends Phase { idx locals.getOrElseUpdate(sym, computeLocalIdx()) - if sym.isRoot then - b.append("_root_") - else if sym.isEmptyPackage then - b.append("_empty_") - else if isGlobal(sym) then - addOwner(sym.owner); addDescriptor(sym) - else - b.append("local").append(localIdx(sym)) + if sym.exists then + if sym.isRoot then + b.append("_root_") + else if sym.isEmptyPackage then + b.append("_empty_") + else if isGlobal(sym) then + addOwner(sym.owner); addDescriptor(sym) + else + b.append("local").append(localIdx(sym)) end addSymName /** The semanticdb name of the given symbol */ From 5c416d3e6e949f846645fcb500533465826f9244 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Wed, 9 Oct 2019 15:48:15 +0200 Subject: [PATCH 018/107] Factor out NamedDefTrees from DefTrees --- compiler/src/dotty/tools/dotc/Compiler.scala | 2 +- compiler/src/dotty/tools/dotc/ast/Trees.scala | 41 +++++++++++-------- .../tools/dotc/interactive/Interactive.scala | 2 +- .../dotc/semanticdb/ExtractSemanticDB.scala | 2 +- 4 files changed, 28 insertions(+), 19 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala index 82f7242fe98e..80ed4109f4f7 100644 --- a/compiler/src/dotty/tools/dotc/Compiler.scala +++ b/compiler/src/dotty/tools/dotc/Compiler.scala @@ -40,7 +40,7 @@ class Compiler { List(new YCheckPositions) :: // YCheck positions List(new Staging) :: // Check PCP, heal quoted types and expand macros List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks - List(new semanticdb.ExtractSemanticDB) :: + List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files List(new PostTyper) :: // Additional checks and cleanups after type checking List(new sbt.ExtractAPI) :: // Sends a representation of the API of classes to sbt via callbacks List(new SetRootTree) :: // Set the `rootTreeOrProvider` on class symbols diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala index 38914097cc6f..0f68e1a64cbe 100644 --- a/compiler/src/dotty/tools/dotc/ast/Trees.scala +++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala @@ -332,28 +332,17 @@ object Trees { def namedType: NamedType = tpe.asInstanceOf[NamedType] } - /** Tree defines a new symbol and carries modifiers. - * The position of a MemberDef contains only the defined identifier or pattern. - * The envelope of a MemberDef contains the whole definition and has its point - * on the opening keyword (or the next token after that if keyword is missing). - */ - abstract class MemberDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] with DefTree[T] { - type ThisTree[-T >: Untyped] <: MemberDef[T] - - def rawComment: Option[Comment] = getAttachment(DocComment) - - def setComment(comment: Option[Comment]): this.type = { - comment.map(putAttachment(DocComment, _)) - this - } + abstract class NamedDefTree[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NameTree[T] with DefTree[T] { + type ThisTree[-T >: Untyped] <: NamedDefTree[T] /** The position of the name defined by this definition. * This is a point position if the definition is synthetic, or a range position * if the definition comes from source. * It might also be that the definition does not have a position (for instance when synthesized by * a calling chain from `viewExists`), in that case the return position is NoSpan. + * Overridden in Bind */ - def nameSpan: Span = + def nameSpan: Span = if (span.exists) { val point = span.point if (rawMods.is(Synthetic) || name.toTermName == nme.ERROR) Span(point) @@ -379,6 +368,22 @@ object Trees { else span } + /** Tree defines a new symbol and carries modifiers. + * The position of a MemberDef contains only the defined identifier or pattern. + * The envelope of a MemberDef contains the whole definition and has its point + * on the opening keyword (or the next token after that if keyword is missing). + */ + abstract class MemberDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends NamedDefTree[T] { + type ThisTree[-T >: Untyped] <: MemberDef[T] + + def rawComment: Option[Comment] = getAttachment(DocComment) + + def setComment(comment: Option[Comment]): this.type = { + comment.map(putAttachment(DocComment, _)) + this + } + } + /** A ValDef or DefDef tree */ abstract class ValOrDefDef[-T >: Untyped](implicit @constructorOnly src: SourceFile) extends MemberDef[T] with WithLazyField[Tree[T]] { type ThisTree[-T >: Untyped] <: ValOrDefDef[T] @@ -705,10 +710,13 @@ object Trees { /** name @ body */ case class Bind[-T >: Untyped] private[ast] (name: Name, body: Tree[T])(implicit @constructorOnly src: SourceFile) - extends NameTree[T] with DefTree[T] with PatternTree[T] { + extends NamedDefTree[T] with PatternTree[T] { type ThisTree[-T >: Untyped] = Bind[T] override def isType: Boolean = name.isTypeName override def isTerm: Boolean = name.isTermName + + override def nameSpan: Span = + if span.exists then Span(span.start, span.start + name.toString.length) else span } /** tree_1 | ... | tree_n */ @@ -938,6 +946,7 @@ object Trees { type NameTree = Trees.NameTree[T] type RefTree = Trees.RefTree[T] type DefTree = Trees.DefTree[T] + type NamedDefTree = Trees.NamedDefTree[T] type MemberDef = Trees.MemberDef[T] type ValOrDefDef = Trees.ValOrDefDef[T] type LazyTree = Trees.LazyTree[T] diff --git a/compiler/src/dotty/tools/dotc/interactive/Interactive.scala b/compiler/src/dotty/tools/dotc/interactive/Interactive.scala index 7255ce81272b..a8e7305f1add 100644 --- a/compiler/src/dotty/tools/dotc/interactive/Interactive.scala +++ b/compiler/src/dotty/tools/dotc/interactive/Interactive.scala @@ -67,7 +67,7 @@ object Interactive { /** Does this tree define a symbol ? */ def isDefinition(tree: Tree): Boolean = - tree.isInstanceOf[DefTree with NameTree] + tree.isInstanceOf[NamedDefTree] /** The type of the closest enclosing tree with a type containing position `pos`. */ def enclosingType(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): Type = { diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 58d04ba9062e..295c4b45f278 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -160,7 +160,7 @@ class ExtractSemanticDB extends Phase { override def traverse(tree: Tree)(given ctx: Context): Unit = tree match - case tree: DefTree + case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => registerOccurrence(tree.symbol, tree.span, SymbolOccurrence.Role.DEFINITION) traverseChildren(tree) From 71f9451889fabe502a8fc5e453c20236d61273bd Mon Sep 17 00:00:00 2001 From: Olafur Pall Geirsson Date: Wed, 9 Oct 2019 12:55:56 +0200 Subject: [PATCH 019/107] Add test suite for SemanticDB extraction To update the expect tests, run the following sbt command ``` > dotty-compiler/test:runMain dotty.tools.dotc.semanticdb.updateExpect ``` --- NOTICE.md | 209 +++++ .../dotc/semanticdb/ExtractSemanticDB.scala | 3 +- .../InvalidProtocolBufferException.scala | 55 ++ .../tools/dotc/semanticdb/Language.scala | 7 + .../tools/dotc/semanticdb/LiteParser.scala | 20 + .../dotty/tools/dotc/semanticdb/Main.scala | 1 + .../dotty/tools/dotc/semanticdb/Range.scala | 33 +- .../dotty/tools/dotc/semanticdb/Schema.scala | 7 + .../semanticdb/SemanticdbInputStream.scala | 777 ++++++++++++++++++ .../dotc/semanticdb/SemanticdbMessage.scala | 3 +- .../dotc/semanticdb/SymbolOccurrence.scala | 41 +- .../tools/dotc/semanticdb/TextDocument.scala | 39 +- .../tools/dotc/semanticdb/TextDocuments.scala | 27 +- .../dotc/semanticdb/DiffAssertions.scala | 35 + .../dotc/semanticdb/SemanticdbTests.scala | 75 ++ .../tools/dotc/semanticdb/Semanticdbs.scala | 105 +++ project/Build.scala | 1 + tests/semanticdb/Definitions.expect.scala | 8 + tests/semanticdb/Definitions.scala | 8 + 19 files changed, 1447 insertions(+), 7 deletions(-) create mode 100644 NOTICE.md create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/InvalidProtocolBufferException.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/LiteParser.scala create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/SemanticdbInputStream.scala create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala create mode 100644 tests/semanticdb/Definitions.expect.scala create mode 100644 tests/semanticdb/Definitions.scala diff --git a/NOTICE.md b/NOTICE.md new file mode 100644 index 000000000000..790dcd4dc2e9 --- /dev/null +++ b/NOTICE.md @@ -0,0 +1,209 @@ +# License notice for the ScalaPB protobuf library + +The Dotty codebase contains parts which are derived from +[the ScalaPB protobuf library](https://github.com/scalapb/scalapb). +We include the text of the original license below: + +``` + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +``` diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 295c4b45f278..6277f871d238 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -162,7 +162,7 @@ class ExtractSemanticDB extends Phase { tree match case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => - registerOccurrence(tree.symbol, tree.span, SymbolOccurrence.Role.DEFINITION) + registerOccurrence(tree.symbol, tree.nameSpan, SymbolOccurrence.Role.DEFINITION) traverseChildren(tree) case tree: Ident => registerUse(tree.symbol, tree.span) @@ -219,6 +219,7 @@ object ExtractSemanticDB { schema = Schema.SEMANTICDB4, language = Language.SCALA, uri = relURI, + text = "", md5 = MD5.compute(String(source.content)), occurrences = occurrences ) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/InvalidProtocolBufferException.scala b/compiler/src/dotty/tools/dotc/semanticdb/InvalidProtocolBufferException.scala new file mode 100644 index 000000000000..2d2363e53e2c --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/InvalidProtocolBufferException.scala @@ -0,0 +1,55 @@ +package dotty.tools.dotc.semanticdb + +import java.io.IOException + +@SerialVersionUID(-1616151763072450476L) +class InvalidProtocolBufferException(description: String) extends IOException(description) + +object InvalidProtocolBufferException { + + def truncatedMessage(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("While parsing a protocol message, the input ended unexpectedly " + + "in the middle of a field. This could mean either that the " + + "input has been truncated or that an embedded message " + + "misreported its own length.") + } + + def negativeSize(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("SemanticdbInputStream encountered an embedded string or message " + + "which claimed to have negative size.") + } + + def malformedVarint(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("SemanticdbInputStream encountered a malformed varint.") + } + + def invalidTag(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message contained an invalid tag (zero).") + } + + def invalidEndTag(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message end-group tag did not match expected tag.") + } + + def invalidWireType(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message tag had invalid wire type.") + } + + def recursionLimitExceeded(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message had too many levels of nesting. May be malicious. " + + "Use SemanticdbInputStream.setRecursionLimit() to increase the depth limit.") + } + + def sizeLimitExceeded(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message was too large. May be malicious. " + + "Use SemanticdbInputStream.setSizeLimit() to increase the size limit.") + } + + def parseFailure(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Failed to parse the message.") + } + + def invalidUtf8(): InvalidProtocolBufferException = { + new InvalidProtocolBufferException("Protocol message had invalid UTF-8.") + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala index 10e4107dbb97..a2e8404efd1e 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala @@ -5,4 +5,11 @@ object Language { case object UNKNOWN_LANGUAGE extends Language(0) case object SCALA extends Language(1) case object JAVA extends Language(2) + case class Unrecognized(id: Int) extends Language(id) + def fromValue(value: _root_.scala.Int): Language = value match { + case 0 => UNKNOWN_LANGUAGE + case 1 => SCALA + case 2 => JAVA + case __other => Unrecognized(__other) + } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/LiteParser.scala b/compiler/src/dotty/tools/dotc/semanticdb/LiteParser.scala new file mode 100644 index 000000000000..931c7bcc43fb --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/LiteParser.scala @@ -0,0 +1,20 @@ +package dotty.tools.dotc.semanticdb + +import java.io.InputStream + + +object LiteParser { + + def readMessage[A](input: SemanticdbInputStream, message: SemanticdbMessage[A]): A = { + val length = input.readRawVarint32() + val oldLimit = input.pushLimit(length) + val result: A = message.mergeFrom(input) + input.checkLastTagWas(0) + input.popLimit(oldLimit) + result + } + + @inline + def preferredSemanticdbOutputStreamBufferSize(dataLength: Int) = + dataLength min SemanticdbOutputStream.DEFAULT_BUFFER_SIZE +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Main.scala b/compiler/src/dotty/tools/dotc/semanticdb/Main.scala index 003adb7029d2..ab9057d87c7f 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Main.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Main.scala @@ -28,6 +28,7 @@ object Main { schema = Schema.SEMANTICDB4, language = Language.SCALA, uri = reluri, + text = "", md5 = MD5.compute(contents), occurrences = occurrences ) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala index ea54f8a68fb5..74f5dc2e5d94 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala @@ -1,11 +1,14 @@ package dotty.tools.dotc.semanticdb +object Range { + def defaultInstance: Range = Range(0, 0, 0, 0) +} case class Range( startLine: Int, startCharacter: Int, endLine: Int, endCharacter: Int -) extends SemanticdbMessage { +) extends SemanticdbMessage[Range] { @transient private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 private[this] def __computeSerializedValue(): _root_.scala.Int = { @@ -80,4 +83,32 @@ case class Range( } }; } + def mergeFrom(`_input__`: SemanticdbInputStream): Range = { + var __startLine = this.startLine + var __startCharacter = this.startCharacter + var __endLine = this.endLine + var __endCharacter = this.endCharacter + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 8 => + __startLine = _input__.readInt32() + case 16 => + __startCharacter = _input__.readInt32() + case 24 => + __endLine = _input__.readInt32() + case 32 => + __endCharacter = _input__.readInt32() + case tag => _input__.skipField(tag) + } + } + Range( + startLine = __startLine, + startCharacter = __startCharacter, + endLine = __endLine, + endCharacter = __endCharacter + ) + } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala index a61baa2e24c5..4539fb67c8e4 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala @@ -2,7 +2,14 @@ package dotty.tools.dotc.semanticdb abstract class Schema(val value: Int) extends SemanticdbEnum object Schema { + def fromValue(value: _root_.scala.Int): Schema = value match { + case 0 => LEGACY + case 3 => SEMANTICDB3 + case 4 => SEMANTICDB4 + case __other => Unrecognized(__other) + } case object LEGACY extends Schema(0) case object SEMANTICDB3 extends Schema(3) case object SEMANTICDB4 extends Schema(4) + case class Unrecognized(id: Int) extends Schema(id) } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbInputStream.scala b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbInputStream.scala new file mode 100644 index 000000000000..06db54eff96a --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbInputStream.scala @@ -0,0 +1,777 @@ +package dotty.tools.dotc.semanticdb + +import java.io.IOException +import java.io.InputStream +import java.util.Arrays +import SemanticdbInputStream._ + +import scala.collection.mutable + +object SemanticdbInputStream { + + def newInstance(input: InputStream): SemanticdbInputStream = new SemanticdbInputStream(input) + + def newInstance(buf: Array[Byte]): SemanticdbInputStream = newInstance(buf, 0, buf.length) + + def newInstance(buf: Array[Byte], off: Int, len: Int): SemanticdbInputStream = { + val result = new SemanticdbInputStream(buf, off, len) + result.pushLimit(len) + result + } + + @throws[InvalidProtocolBufferException] + def readRawVarint32(input: InputStream): Int = { + val firstByte = input.read() + if (firstByte == -1) { + throw InvalidProtocolBufferException.truncatedMessage() + } + readRawVarint32(firstByte, input) + } + + def readRawVarint32(firstByte: Int, input: InputStream): Int = { + if ((firstByte & 0x80) == 0) { + return firstByte + } + var result = firstByte & 0x7f + var offset = 7 + while (offset < 32) { + val b = input.read() + if (b == -1) { + throw InvalidProtocolBufferException.truncatedMessage() + } + result |= (b & 0x7f) << offset + if ((b & 0x80) == 0) { + return result + } + offset += 7 + } + while (offset < 64) { + val b = input.read() + if (b == -1) { + throw InvalidProtocolBufferException.truncatedMessage() + } + if ((b & 0x80) == 0) { + return result + } + offset += 7 + } + throw InvalidProtocolBufferException.malformedVarint() + } + + def decodeZigZag32(n: Int): Int = (n >>> 1) ^ -(n & 1) + + def decodeZigZag64(n: Long): Long = (n >>> 1) ^ -(n & 1) + + private val DEFAULT_RECURSION_LIMIT = 100 + + private val DEFAULT_SIZE_LIMIT = 64 << 20 + + private val BUFFER_SIZE = 4096 +} + +class SemanticdbInputStream private (buffer: Array[Byte], input: InputStream) { + /** + * The total number of bytes read before the current buffer. The total + * bytes read up to the current position can be computed as + * {@code totalBytesRetired + bufferPos}. This value may be negative if + * reading started in the middle of the current buffer (e.g. if the + * constructor that takes a byte array and an offset was used). + */ + private var totalBytesRetired: Int = 0 + + // Current position in the buffer. + private var bufferPos: Int = 0 + + // How many bytes in the buffer contain actual content (bufferSize <= buffer.length) + private var bufferSize: Int = 0 + + private var currentLimit: Int = Int.MaxValue + + private var sizeLimit = SemanticdbInputStream.DEFAULT_SIZE_LIMIT + + private var bufferSizeAfterLimit = 0 + + private var lastTag = 0 + + def this(buffer: Array[Byte], offset: Int, len: Int) = { + this(buffer, null) + bufferPos = offset + bufferSize = offset + len + totalBytesRetired = -offset + } + + def this(is: InputStream) = { + this(new Array[Byte](SemanticdbInputStream.BUFFER_SIZE), is) + totalBytesRetired = 0 + } + + /** + * Ensures that at least {@code n} bytes are available in the buffer, reading + * more bytes from the input if necessary to make it so. Caller must ensure + * that the requested space is less than BUFFER_SIZE. + */ + private def ensureAvailable(n: Int): Unit = { + if (bufferSize - bufferPos < n) { + refillBuffer(n) + } + } + + /** + * Reads more bytes from the input, making at least {@code n} bytes available + * in the buffer. Caller must ensure that the requested space is not yet + * available, and that the requested space is less than BUFFER_SIZE. + */ + private def refillBuffer(n: Int): Unit = { + if (!tryRefillBuffer(n)) { + throw InvalidProtocolBufferException.truncatedMessage() + } + } + /** + * Tries to read more bytes from the input, making at least {@code n} bytes + * available in the buffer. Caller must ensure that the requested space is + * not yet available, and that the requested space is less than BUFFER_SIZE. + * + * @return { @code true} if the bytes could be made available; { @code false} + * if the end of the stream or the current limit was reached. + */ + private def tryRefillBuffer(n: Int): Boolean = { + if (bufferPos + n <= bufferSize) { + throw new IllegalStateException( + s"refillBuffer() called when $n bytes were already available in buffer") + } + if (totalBytesRetired + bufferPos + n > currentLimit) false + else if (input != null) { + val pos: Int = bufferPos + if (pos > 0) { + if (bufferSize > pos) { + System.arraycopy(buffer, pos, buffer, 0, bufferSize - pos) + } + totalBytesRetired += pos + bufferSize -= pos + bufferPos = 0 + } + val bytesRead: Int = input.read(buffer, bufferSize, buffer.length - bufferSize) + if (bytesRead == 0 || bytesRead < -1 || bytesRead > buffer.length) { + throw new IllegalStateException("InputStream#read(byte[]) returned invalid result: " + bytesRead + "\nThe InputStream implementation is buggy.") + } + if (bytesRead > 0) { + bufferSize += bytesRead + if (totalBytesRetired + n - sizeLimit > 0) { + throw InvalidProtocolBufferException.sizeLimitExceeded() + } + recomputeBufferSizeAfterLimit() + return ((bufferSize >= n) || tryRefillBuffer(n)) + } + } + false + } + + private def recomputeBufferSizeAfterLimit(): Unit = { + bufferSize += bufferSizeAfterLimit + val bufferEnd: Int = totalBytesRetired + bufferSize + if (bufferEnd > currentLimit) { + bufferSizeAfterLimit = bufferEnd - currentLimit + bufferSize -= bufferSizeAfterLimit + } + else { + bufferSizeAfterLimit = 0 + } + } + + /** + * Returns true if the stream has reached the end of the input. This is the + * case if either the end of the underlying input source has been reached or + * if the stream has reached a limit created using {@link #pushLimit(int)}. + */ + def isAtEnd: Boolean = { + bufferPos == bufferSize && !tryRefillBuffer(1) + } + + def getTotalBytesRead() = { + totalBytesRetired + bufferPos + } + + /** + * Sets {@code currentLimit} to (current position) + {@code byteLimit}. This + * is called when descending into a length-delimited embedded message. + * + *

Note that {@code pushLimit()} does NOT affect how many bytes the + * {@code SemanticdbInputStream} reads from an underlying {@code InputStream} when + * refreshing its buffer. If you need to prevent reading past a certain + * point in the underlying {@code InputStream} (e.g. because you expect it to + * contain more data after the end of the message which you need to handle + * differently) then you must place a wrapper around your {@code InputStream} + * which limits the amount of data that can be read from it. + * + * @return the old limit. + */ + def pushLimit(byteLimit0: Int): Int = { + if (byteLimit0 < 0) { + throw InvalidProtocolBufferException.negativeSize() + } + val byteLimit = byteLimit0 + totalBytesRetired + bufferPos + val oldLimit: Int = currentLimit + if (byteLimit > oldLimit) { + throw InvalidProtocolBufferException.truncatedMessage() + } + currentLimit = byteLimit + recomputeBufferSizeAfterLimit() + oldLimit + } + + /** + * Discards the current limit, returning to the previous limit. + * + * @param oldLimit The old limit, as returned by { @code pushLimit}. + */ + def popLimit(oldLimit: Int): Unit = { + currentLimit = oldLimit + recomputeBufferSizeAfterLimit() + } + + /** + * Reads and discards a single field, given its tag value. + * + * @return { @code false} if the tag is an endgroup tag, in which case + * nothing is skipped. Otherwise, returns { @code true}. + */ + @throws(classOf[IOException]) + def skipField(tag: Int): Boolean = { + WireFormat.getTagWireType(tag) match { + case WireFormat.WIRETYPE_VARINT => + skipRawVarint() + true + case WireFormat.WIRETYPE_FIXED64 => + skipRawBytes(8) + true + case WireFormat.WIRETYPE_LENGTH_DELIMITED => + skipRawBytes(readRawVarint32()) + true + case WireFormat.WIRETYPE_START_GROUP => + skipMessage() + checkLastTagWas(WireFormat.makeTag(WireFormat.getTagFieldNumber(tag), WireFormat.WIRETYPE_END_GROUP)) + true + case WireFormat.WIRETYPE_END_GROUP => + false + case WireFormat.WIRETYPE_FIXED32 => + skipRawBytes(4) + true + case _ => + throw InvalidProtocolBufferException.invalidWireType() + } + } + + /** + * Reads and discards an entire message. This will read either until EOF + * or until an endgroup tag, whichever comes first. + */ + def skipMessage(): Unit = { + while (true) { + val tag: Int = readTag() + if (tag == 0 || !skipField(tag)) { + return + } + } + } + + /** + * Reads and discards {@code size} bytes. + */ + def skipRawBytes(size: Int): Unit = { + if (size <= (bufferSize - bufferPos) && size >= 0) { + bufferPos += size + } + else { + skipRawBytesSlowPath(size) + } + } + + /** + * Read a raw Varint from the stream. If larger than 32 bits, discard the + * upper bits. + */ + @throws[InvalidProtocolBufferException] + def readRawVarint32(): Int = { + { + var pos: Int = bufferPos + if (bufferSize == pos) { + return readRawVarint64SlowPath().toInt + } + val buffer: Array[Byte] = this.buffer + var x: Int = 0 + if ((({ + x = buffer(({ + pos += 1; pos - 1 + })); x + })) >= 0) { + bufferPos = pos + return x + } + else if (bufferSize - pos < 9) { + return readRawVarint64SlowPath().toInt + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })) << 7); x + })) < 0) { + x ^= (~0 << 7) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })) << 14); x + })) >= 0) { + x ^= (~0 << 7) ^ (~0 << 14) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })) << 21); x + })) < 0) { + x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21) + } + else { + val y: Int = buffer(({ + pos += 1; pos - 1 + })) + x ^= y << 28 + x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21) ^ (~0 << 28) + if (y < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0 && buffer(({ + pos += 1; pos - 1 + })) < 0) { + return readRawVarint64SlowPath().toInt + } + } + bufferPos = pos + return x + } //todo: labels is not supported + } + + private def skipRawVarint(): Unit = { + if (bufferSize - bufferPos >= 10) { + val buffer: Array[Byte] = this.buffer + var pos: Int = bufferPos + var i: Int = 0 + while (i < 10) { + { + if (buffer(({ + pos += 1; pos - 1 + })) >= 0) { + bufferPos = pos + return + } + } + ({ + i += 1; i - 1 + }) + } + } + skipRawVarintSlowPath + } + + @throws(classOf[IOException]) + private def skipRawVarintSlowPath: Unit = { + var i: Int = 0 + while (i < 10) { + if (readRawByte() >= 0) { + return + } + i += 1; i - 1 + } + throw InvalidProtocolBufferException.malformedVarint() + } + + /** + * Exactly like skipRawBytes, but caller must have already checked the fast + * path: (size <= (bufferSize - pos) && size >= 0) + */ + private def skipRawBytesSlowPath(size: Int): Unit = { + if (size < 0) { + throw InvalidProtocolBufferException.negativeSize() + } + if (totalBytesRetired + bufferPos + size > currentLimit) { + skipRawBytes(currentLimit - totalBytesRetired - bufferPos) + throw InvalidProtocolBufferException.truncatedMessage() + } + var pos: Int = bufferSize - bufferPos + bufferPos = bufferSize + refillBuffer(1) + while (size - pos > bufferSize) { + pos += bufferSize + bufferPos = bufferSize + refillBuffer(1) + } + bufferPos = size - pos + } + + /** + * Attempt to read a field tag, returning zero if we have reached EOF. + * Protocol message parsers use this to read tags, since a protocol message + * may legally end wherever a tag occurs, and zero is not a valid tag number. + */ + @throws[InvalidProtocolBufferException] + def readTag(): Int = { + if (isAtEnd) { + lastTag = 0 + return 0 + } + lastTag = readRawVarint32() + if (WireFormat.getTagFieldNumber(lastTag) == 0) { + throw InvalidProtocolBufferException.invalidTag() + } + lastTag + } + + def readString(): String = { + val size: Int = readRawVarint32() + if (size <= (bufferSize - bufferPos) && size > 0) { + val result: String = new String(buffer, bufferPos, size, Internal.UTF_8) + bufferPos += size + return result + } + else if (size == 0) { + return "" + } + else { + return new String(readRawBytesSlowPath(size), Internal.UTF_8) + } + } + + def checkLastTagWas(value: Int): Unit = { + if (lastTag != value) { + throw InvalidProtocolBufferException.invalidEndTag(); + } + } + + def getBytesUntilLimit: Int = { + if (currentLimit == Integer.MAX_VALUE) { + return -1 + } + + val currentAbsolutePosition: Int = totalBytesRetired + bufferPos + return currentLimit - currentAbsolutePosition + } + + /** Read a {@code double} field value from the stream. */ + def readDouble(): Double = { + return java.lang.Double.longBitsToDouble(readRawLittleEndian64()) + } + + /** Read a {@code float} field value from the stream. */ + def readFloat(): Float = { + java.lang.Float.intBitsToFloat(readRawLittleEndian32()) + } + + /** Read a {@code uint64} field value from the stream. */ + def readUInt64(): Long = { + readRawVarint64() + } + + /** Read an {@code int64} field value from the stream. */ + def readInt64(): Long = { + readRawVarint64() + } + + /** Read an {@code int32} field value from the stream. */ + def readInt32(): Int = { + readRawVarint32() + } + + /** Read a {@code fixed64} field value from the stream. */ + def readFixed64(): Long = { + readRawLittleEndian64() + } + + /** Read a {@code fixed32} field value from the stream. */ + def readFixed32(): Int = { + readRawLittleEndian32() + } + + /** Read a {@code uint32} field value from the stream. */ + def readUInt32(): Int = { + readRawVarint32() + } + + /** + * Read an enum field value from the stream. Caller is responsible + * for converting the numeric value to an actual enum. + */ + def readEnum(): Int = { + readRawVarint32() + } + + /** Read an {@code sfixed32} field value from the stream. */ + def readSFixed32(): Int = { + readRawLittleEndian32() + } + + /** Read an {@code sfixed64} field value from the stream. */ + def readSFixed64(): Long = { + readRawLittleEndian64() + } + + /** Read an {@code sint32} field value from the stream. */ + def readSInt32(): Int = { + decodeZigZag32(readRawVarint32()) + } + + /** Read an {@code sint64} field value from the stream. */ + def readSInt64(): Long = { + decodeZigZag64(readRawVarint64()) + } + + /** Read a {@code bool} field value from the stream. */ + def readBool(): Boolean = { + readRawVarint64() != 0 + } + + /** Read a raw Varint from the stream. */ + @throws[InvalidProtocolBufferException] + def readRawVarint64(): Long = { + var pos: Int = bufferPos + if (bufferSize == pos) { + return readRawVarint64SlowPath() + } + val buffer: Array[Byte] = this.buffer + var x: Long = 0L + var y: Int = 0 + if ((({ + y = buffer(({ + pos += 1; pos - 1 + })); y + })) >= 0) { + bufferPos = pos + return y + } + else if (bufferSize - pos < 9) { + return readRawVarint64SlowPath() + } + else if ((({ + y ^= (buffer(({ + pos += 1; pos - 1 + })) << 7); y + })) < 0) { + x = y ^ (~0 << 7) + } + else if ((({ + y ^= (buffer(({ + pos += 1; pos - 1 + })) << 14); y + })) >= 0) { + x = y ^ ((~0 << 7) ^ (~0 << 14)) + } + else if ((({ + y ^= (buffer(({ + pos += 1; pos - 1 + })) << 21); y + })) < 0) { + x = y ^ ((~0 << 7) ^ (~0 << 14) ^ (~0 << 21)) + } + else if ((({ + x = (y.toLong) ^ (buffer(({ + pos += 1; pos - 1 + })).toLong << 28); x + })) >= 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })).toLong << 35); x + })) < 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })).toLong << 42); x + })) >= 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42) + } + else if ((({ + x ^= (buffer(({ + pos += 1; pos - 1 + })).toLong << 49); x + })) < 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42) ^ (~0L << 49) + } + else { + x ^= (buffer(({ + pos += 1; pos - 1 + })).toLong << 56) + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42) ^ (~0L << 49) ^ (~0L << 56) + if (x < 0L) { + if (buffer(({ + pos += 1; pos - 1 + })) < 0L) { + return readRawVarint64SlowPath() + } + } + } + bufferPos = pos + x + } + + /** Variant of readRawVarint64 for when uncomfortably close to the limit. */ + @throws[InvalidProtocolBufferException] + private[semanticdb] def readRawVarint64SlowPath(): Long = { + var result: Long = 0 + var shift: Int = 0 + while (shift < 64) { + val b: Byte = readRawByte() + result |= (b & 0x7F).toLong << shift + if ((b & 0x80) == 0) { + return result + } + shift += 7 + } + throw InvalidProtocolBufferException.malformedVarint() + } + + /** Read a 32-bit little-endian integer from the stream. */ + def readRawLittleEndian32(): Int = { + var pos: Int = bufferPos + if (bufferSize - pos < 4) { + refillBuffer(4) + pos = bufferPos + } + val buffer: Array[Byte] = this.buffer + bufferPos = pos + 4 + (((buffer(pos) & 0xff)) | + ((buffer(pos + 1) & 0xff) << 8) | + ((buffer(pos + 2) & 0xff) << 16) | + ((buffer(pos + 3) & 0xff) << 24)) + } + + /** Read a 64-bit little-endian integer from the stream. */ + def readRawLittleEndian64(): Long = { + var pos: Int = bufferPos + if (bufferSize - pos < 8) { + refillBuffer(8) + pos = bufferPos + } + val buffer: Array[Byte] = this.buffer + bufferPos = pos + 8 + (((buffer(pos).toLong & 0xffL)) | + ((buffer(pos + 1).toLong & 0xffL) << 8) | + ((buffer(pos + 2).toLong & 0xffL) << 16) | + ((buffer(pos + 3).toLong & 0xffL) << 24) | + ((buffer(pos + 4).toLong & 0xffL) << 32) | + ((buffer(pos + 5).toLong & 0xffL) << 40) | + ((buffer(pos + 6).toLong & 0xffL) << 48) | + ((buffer(pos + 7).toLong & 0xffL) << 56)) + } + + /** + * Read one byte from the input. + */ + @throws[InvalidProtocolBufferException] + def readRawByte(): Byte = { + if (bufferPos == bufferSize) { + refillBuffer(1) + } + buffer({ + bufferPos += 1; bufferPos - 1 + }) + } + + /** + * Read a fixed size of bytes from the input. + */ + @throws[InvalidProtocolBufferException] + def readRawBytes(size: Int): Array[Byte] = { + val pos: Int = bufferPos + if (size <= (bufferSize - pos) && size > 0) { + bufferPos = pos + size + Arrays.copyOfRange(buffer, pos, pos + size) + } + else { + readRawBytesSlowPath(size) + } + } + + /** + * Exactly like readRawBytes, but caller must have already checked the fast + * path: (size <= (bufferSize - pos) && size > 0) + */ + private def readRawBytesSlowPath(size: Int): Array[Byte] = { + if (size <= 0) { + if (size == 0) { + return Internal.EMPTY_BYTE_ARRAY + } + else { + throw InvalidProtocolBufferException.negativeSize() + } + } + if (totalBytesRetired + bufferPos + size > currentLimit) { + skipRawBytes(currentLimit - totalBytesRetired - bufferPos) + throw InvalidProtocolBufferException.truncatedMessage() + } + if (size < BUFFER_SIZE) { + val bytes: Array[Byte] = new Array[Byte](size) + val pos: Int = bufferSize - bufferPos + System.arraycopy(buffer, bufferPos, bytes, 0, pos) + bufferPos = bufferSize + ensureAvailable(size - pos) + System.arraycopy(buffer, 0, bytes, pos, size - pos) + bufferPos = size - pos + bytes + } + else { + val originalBufferPos: Int = bufferPos + val originalBufferSize: Int = bufferSize + totalBytesRetired += bufferSize + bufferPos = 0 + bufferSize = 0 + var sizeLeft: Int = size - (originalBufferSize - originalBufferPos) + val chunks: mutable.ArrayBuffer[Array[Byte]] = new mutable.ArrayBuffer[Array[Byte]] + while (sizeLeft > 0) { + val chunk: Array[Byte] = new Array[Byte](Math.min(sizeLeft, BUFFER_SIZE)) + var pos: Int = 0 + while (pos < chunk.length) { + val n: Int = if ((input == null)) -1 else input.read(chunk, pos, chunk.length - pos) + if (n == -1) { + throw InvalidProtocolBufferException.truncatedMessage() + } + totalBytesRetired += n + pos += n + } + sizeLeft -= chunk.length + chunks+=(chunk) + } + val bytes: Array[Byte] = new Array[Byte](size) + var pos: Int = originalBufferSize - originalBufferPos + System.arraycopy(buffer, originalBufferPos, bytes, 0, pos) + for (chunk <- chunks) { + System.arraycopy(chunk, 0, bytes, pos, chunk.length) + pos += chunk.length + } + bytes + } + } + + def enableAliasing(aliasing: Boolean): Unit = {} + + def setSizeLimit(limit: Int): Int = { + if (limit < 0) { + throw new IllegalArgumentException( + "Size limit cannot be negative: " + limit) + } + val oldLimit: Int = sizeLimit + sizeLimit = limit + oldLimit + } + + def resetSizeCounter(): Unit = { + totalBytesRetired = -bufferPos; + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala index bb7678bb0a61..398230ed41ba 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala @@ -1,6 +1,7 @@ package dotty.tools.dotc.semanticdb -trait SemanticdbMessage { +trait SemanticdbMessage[A] { def serializedSize: Int def writeTo(out: SemanticdbOutputStream): Unit + def mergeFrom(in: SemanticdbInputStream): A } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala index 0d80ddddfd43..fa95bef76f21 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala @@ -1,20 +1,33 @@ package dotty.tools.dotc.semanticdb object SymbolOccurrence { - sealed abstract class Role(val value: Int) extends SemanticdbEnum + sealed abstract class Role(val value: Int) extends SemanticdbEnum { + def isDefinition: Boolean = this == Role.DEFINITION + def isReference: Boolean = this == Role.REFERENCE + } object Role { case object UNKNOWN_ROLE extends Role(0) case object REFERENCE extends Role(1) case object DEFINITION extends Role(2) + case class Unrecognized(id: Int) extends Role(id) + + def fromValue(value: Int): Role = value match { + case 0 => UNKNOWN_ROLE + case 1 => REFERENCE + case 2 => DEFINITION + case __other => Unrecognized(__other) + } } + + def defaultInstance: SymbolOccurrence = SymbolOccurrence("", None, Role.UNKNOWN_ROLE) } case class SymbolOccurrence( symbol: String, range: Option[Range], role: SymbolOccurrence.Role -) extends SemanticdbMessage { +) extends SemanticdbMessage[SymbolOccurrence] { private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 private[this] def __computeSerializedValue(): _root_.scala.Int = { var __size = 0 @@ -72,4 +85,28 @@ case class SymbolOccurrence( } }; } + def mergeFrom(`_input__`: SemanticdbInputStream): SymbolOccurrence = { + var __range = this.range + var __symbol = this.symbol + var __role = this.role + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 10 => + __range = Option(LiteParser.readMessage(_input__, __range.getOrElse(Range.defaultInstance))) + case 18 => + __symbol = _input__.readString() + case 24 => + __role = SymbolOccurrence.Role.fromValue(_input__.readEnum()) + case tag => _input__.skipField(tag) + } + } + SymbolOccurrence( + range = __range, + symbol = __symbol, + role = __role + ) + } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala index 651b8c4ac4e9..1f638332556e 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala @@ -1,12 +1,16 @@ package dotty.tools.dotc.semanticdb +object TextDocument { + def defaultInstance: TextDocument = TextDocument(Schema.LEGACY, Language.UNKNOWN_LANGUAGE, "", "", "", Nil) +} case class TextDocument( schema: Schema, language: Language, uri: String, + text: String, md5: String, occurrences: Seq[SymbolOccurrence] -) extends SemanticdbMessage { +) extends SemanticdbMessage[TextDocument] { private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 private[this] def __computeSerializedValue(): _root_.scala.Int = { var __size = 0 @@ -87,4 +91,37 @@ case class TextDocument( } }; } + def mergeFrom(`_input__`: SemanticdbInputStream): TextDocument = { + var __schema = this.schema + var __uri = this.uri + var __md5 = this.md5 + var __language = this.language + val __occurrences = (_root_.scala.collection.immutable.Vector.newBuilder[SymbolOccurrence] ++= this.occurrences) + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 8 => + __schema = Schema.fromValue(_input__.readEnum()) + case 18 => + __uri = _input__.readString() + case 90 => + __md5 = _input__.readString() + case 80 => + __language = Language.fromValue(_input__.readEnum()) + case 50 => + __occurrences += LiteParser.readMessage(_input__, SymbolOccurrence.defaultInstance) + case tag => _input__.skipField(tag) + } + } + TextDocument( + schema = __schema, + uri = __uri, + text = "", + md5 = __md5, + language = __language, + occurrences = __occurrences.result(), + ) + } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala index a9402d2fa09c..f104480352c2 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala @@ -1,6 +1,15 @@ package dotty.tools.dotc.semanticdb -case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage { +object TextDocuments { + def parseFrom(in: Array[Byte]): TextDocuments = { + parseFrom(SemanticdbInputStream.newInstance(in)) + } + def parseFrom(in: SemanticdbInputStream): TextDocuments = { + defaultInstance.mergeFrom(in) + } + def defaultInstance: TextDocuments = TextDocuments(Nil) +} +case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage[TextDocuments] { private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 private[this] def __computeSerializedValue(): _root_.scala.Int = { var __size = 0 @@ -28,4 +37,20 @@ case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage __m.writeTo(_output__) }; } + def mergeFrom(`_input__`: SemanticdbInputStream): TextDocuments = { + val __documents = (_root_.scala.collection.immutable.Vector.newBuilder[TextDocument] ++= this.documents) + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 10 => + __documents += LiteParser.readMessage(_input__, TextDocument.defaultInstance) + case tag => _input__.skipField(tag) + } + } + TextDocuments( + documents = __documents.result() + ) + } } diff --git a/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala b/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala new file mode 100644 index 000000000000..fce88c3b1b45 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala @@ -0,0 +1,35 @@ +package dotty.tools.dotc.semanticdb + +import scala.collection.JavaConverters._ +import org.junit.Assert._ + +object DiffAssertions { + def assertNoDiff(obtained: String, expected: String): Unit = + val diff = compareContents(obtained, expected) + if diff.nonEmpty then + fail(diff) + + private def stripTrailingWhitespace(str: String): String = str.replaceAll(" \n", "∙\n") + + private def splitIntoLines(string: String): Seq[String] = + string.trim.replace("\r\n", "\n").split("\n").toSeq + + private def compareContents(original: String, revised: String): String = + compareContents(splitIntoLines(original), splitIntoLines(revised)) + + private def compareContents(original: Seq[String], revised: Seq[String]): String = { + val diff = difflib.DiffUtils.diff(original.asJava, revised.asJava) + if (diff.getDeltas.isEmpty) "" + else + difflib.DiffUtils + .generateUnifiedDiff( + "obtained", + "expected", + original.asJava, + diff, + 1 + ) + .asScala + .mkString("\n") + } +} \ No newline at end of file diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala new file mode 100644 index 000000000000..9f90d972294e --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -0,0 +1,75 @@ +package dotty.tools.dotc.semanticdb + +import java.net.URLClassLoader +import java.util.regex.Pattern +import java.io.File +import java.nio.file._ +import java.nio.charset.StandardCharsets +import java.util.stream.Collectors +import scala.util.control.NonFatal +import org.junit.Assert._ +import org.junit.Test +import org.junit.experimental.categories.Category +import scala.collection.JavaConverters._ +import dotty.tools.dotc.Main +import dotty.tools.dotc.semanticdb.DiffAssertions._ + + +@main def updateExpect() = + new SemanticdbTests().runExpectTest(updateExpectFiles = true) + +class SemanticdbTests { + val scalaFile = FileSystems.getDefault.getPathMatcher("glob:**.scala") + val expectFile = FileSystems.getDefault.getPathMatcher("glob:**.expect.scala") + val semanticdbFile = FileSystems.getDefault.getPathMatcher("glob:**.scala.semanticdb") + val src = Paths.get(System.getProperty("user.dir")).resolve("tests").resolve("semanticdb") + + @Category(Array(classOf[dotty.SlowTests])) + @Test def expectTests: Unit = runExpectTest(updateExpectFiles = false) + + def runExpectTest(updateExpectFiles: Boolean): Unit = + val target = generateSemanticdb() + inputFiles().foreach { source => + val filename = source.getFileName.toString + val relpath = src.relativize(source) + val semanticdbPath = target + .resolve("META-INF") + .resolve("semanticdb") + .resolve(relpath) + .resolveSibling(filename + ".semanticdb") + val expectPath = source.resolveSibling(filename.replaceAllLiterally(".scala", ".expect.scala")) + val doc = Semanticdbs.loadTextDocument(source, relpath, semanticdbPath) + val obtained = trimTrailingWhitespace(Semanticdbs.printTextDocument(doc)) + if (updateExpectFiles) + Files.write(expectPath, obtained.getBytes(StandardCharsets.UTF_8)) + println("updated: " + expectPath) + else + val expected = new String(Files.readAllBytes(expectPath), StandardCharsets.UTF_8) + assertNoDiff(obtained, expected) + } + + def trimTrailingWhitespace(s: String): String = + Pattern.compile(" +$", Pattern.MULTILINE).matcher(s).replaceAll("") + + def inputFiles(): List[Path] = + val ls = Files.walk(src) + val files = + try ls.filter(p => scalaFile.matches(p) && !expectFile.matches(p)).collect(Collectors.toList).asScala + finally ls.close() + require(files.nonEmpty, s"No input files! $src") + files.toList + + def generateSemanticdb(): Path = + val target = Files.createTempDirectory("semanticdb") + val args = Array( + "-Ysemanticdb", + "-d", target.toString, + "-sourceroot", src.toString, + "-usejavacp", + ) ++ inputFiles().map(_.toString) + val exit = Main.process(args) + if (exit.hasErrors) + sys.error(s"dotc errors: ${exit.errorCount}") + target + +} \ No newline at end of file diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala new file mode 100644 index 000000000000..e01844bafe38 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -0,0 +1,105 @@ +package dotty.tools.dotc.semanticdb + +import java.nio.file._ +import java.nio.charset.StandardCharsets +import scala.collection.JavaConverters._ +import dotty.tools.dotc.util.SourceFile + +object Semanticdbs { + + /** Load SemanticDB TextDocument for a single Scala source file + * + * @param scalaAbsolutePath Absolute path to a Scala source file. + * @param scalaRelativePath scalaAbsolutePath relativized by the sourceroot. + * @param semanticdbAbsolutePath Absolute path to the SemanticDB file. + */ + def loadTextDocument( + scalaAbsolutePath: Path, + scalaRelativePath: Path, + semanticdbAbsolutePath: Path + ): TextDocument = { + val reluri = scalaRelativePath.iterator.asScala.mkString("/") + val sdocs = parseTextDocuments(semanticdbAbsolutePath) + sdocs.documents.find(_.uri == reluri) match { + case None => throw new NoSuchElementException(reluri) + case Some(document) => + val text = new String(Files.readAllBytes(scalaAbsolutePath), StandardCharsets.UTF_8) + // Assert the SemanticDB payload is in-sync with the contents of the Scala file on disk. + val md5FingerprintOnDisk = MD5.compute(text) + if (document.md5 != md5FingerprintOnDisk) { + throw new IllegalArgumentException("stale semanticdb: " + reluri) + } else { + // Update text document to include full text contents of the file. + document.copy(text = text) + } + } + } + + /** Parses SemanticDB text documents from an absolute path to a `*.semanticdb` file. */ + def parseTextDocuments(path: Path): TextDocuments = { + // NOTE: a *.semanticdb file is of type TextDocuments, not TextDocument + val bytes = Files.readAllBytes(path) + TextDocuments.parseFrom(bytes) + } + + + /** Prettyprint a text document with symbol occurrences next to each resolved identifier. + * + * Useful for testing purposes to ensure that SymbolOccurrence values make sense and are correct. + * Example output (NOTE, slightly modified to avoid "unclosed comment" errors): + * {{{ + * class Example *example/Example#* { + * val a *example/Example#a.* : String *scala/Predef.String#* = "1" + * } + * }}} + **/ + def printTextDocument(doc: TextDocument): String = { + val sb = new StringBuilder + val sourceFile = SourceFile.virtual(doc.uri, doc.text) + implicit val occurrenceOrdering: Ordering[SymbolOccurrence] = + buildOccurrenceOrdering(sourceFile) + val occurrences = doc.occurrences.sorted + var offset = 0 + occurrences.foreach { occ => + val range = occ.range.get + val end = math.max( + offset, + sourceFile.lineToOffset(range.endLine) + range.endCharacter + ) + sb.append(doc.text.substring(offset, end)) + .append(" /* ") + .append(if (occ.role.isDefinition) "<= " else "=> ") + .append(occ.symbol.replace('/', '.')) + .append(" */ ") + offset = end + } + sb.append(doc.text.substring(offset)) + sb.toString() + } + + /** Sort symbol occurrences by their start position. */ + def buildOccurrenceOrdering(sourceFile: SourceFile): Ordering[SymbolOccurrence] = { + new Ordering[SymbolOccurrence] { + def rangeToTuple(r : Range): (Int, Int) = { + val start = sourceFile.lineToOffset(r.startLine) + r.startCharacter + val end = sourceFile.lineToOffset(r.endLine) + r.endCharacter + (start, end) + } + + override def compare(x: SymbolOccurrence, y: SymbolOccurrence): Int = { + if (x.range.isEmpty) 0 + else if (y.range.isEmpty) 0 + else { + val (as, ae) = rangeToTuple(x.range.get) + val (bs, be) = rangeToTuple(y.range.get) + val byStart = Integer.compare(as, bs) + if (byStart != 0) { + byStart + } else { + Integer.compare(ae, be) + } + } + } + } + } +} diff --git a/project/Build.scala b/project/Build.scala index 383d8bb330dc..b6efdc575885 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -501,6 +501,7 @@ object Build { libraryDependencies ++= Seq( "org.scala-lang.modules" % "scala-asm" % "7.0.0-scala-1", // used by the backend Dependencies.`compiler-interface`, + "com.googlecode.java-diff-utils" % "diffutils" % "1.3.0", // for SemanticdbTests "org.jline" % "jline-reader" % "3.9.0", // used by the REPL "org.jline" % "jline-terminal" % "3.9.0", "org.jline" % "jline-terminal-jna" % "3.9.0" // needed for Windows diff --git a/tests/semanticdb/Definitions.expect.scala b/tests/semanticdb/Definitions.expect.scala new file mode 100644 index 000000000000..4465df8a6c11 --- /dev/null +++ b/tests/semanticdb/Definitions.expect.scala @@ -0,0 +1,8 @@ +package a /* => a. */ + /* => a.Definitions. */ /* => a.Definitions.``(). */ object /* => java.lang.Object#``(). */ Definitions /* <= a.Definitions. */ { + /* => scala.package.Serializable# */ /* => scala. */ /* => _root_ */ /* => a.Definitions. */ val a /* <= a.Definitions.a. */ = 1 + var b /* <= a.Definitions.b. */ = /* <= a.Definitions.`b_=`(). */ 2 + def c /* <= a.Definitions.c(). */ = 3 + class /* => java.lang.Object#``(). */ D /* <= a.Definitions.D# */ + trait E /* <= a.Definitions.E# */ +} diff --git a/tests/semanticdb/Definitions.scala b/tests/semanticdb/Definitions.scala new file mode 100644 index 000000000000..1d4a94811957 --- /dev/null +++ b/tests/semanticdb/Definitions.scala @@ -0,0 +1,8 @@ +package a +object Definitions { + val a = 1 + var b = 2 + def c = 3 + class D + trait E +} From e11844b540386ccfefce8383b1356b1268903485 Mon Sep 17 00:00:00 2001 From: Olafur Pall Geirsson Date: Wed, 9 Oct 2019 16:57:14 +0200 Subject: [PATCH 020/107] Move semanticdb-extract test file to new expect test suite --- .../semanticdb/semanticdb-extract.expect.scala | 18 ++++++++++++++++++ .../semanticdb-extract.scala | 0 2 files changed, 18 insertions(+) create mode 100644 tests/semanticdb/semanticdb-extract.expect.scala rename tests/{new => semanticdb}/semanticdb-extract.scala (100%) diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala new file mode 100644 index 000000000000..5d8ac1daad98 --- /dev/null +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -0,0 +1,18 @@ + /* => _empty_ */ /* => A. */ /* => A.``(). */ object /* => java.lang.Object#``(). */ A /* <= A. */ { + + /* => scala.package.Serializable# */ /* => scala. */ /* => _root_ */ /* => A. */ def foo /* <= A.foo(+1). */ (x /* <= A.foo(+1).(x) */ : Int /* => scala.Int# */ ) = () + def foo /* <= A.foo(+0). */ (): Unit /* => scala.Unit# */ = () + + foo /* => A.foo(+1). */ (1) + foo /* => A.foo(+0). */ () + + "".substring /* => java.lang.String#substring(+1). */ (1) + "".substring /* => java.lang.String#substring(+0). */ (1, 2) + + List /* => scala.package.List. */ /* => scala.collection.IterableFactory#apply(). */ (1, 2) + List /* => scala.package.List. */ .apply /* => scala.collection.IterableFactory#apply(). */ () + List /* => scala.package.List. */ .`apply` /* => scala.collection.IterableFactory#apply(). */ () + println /* => scala.Predef.println(+0). */ (1 + /* => scala.Int#`+`(+3). */ 2) + + /* => A.Foo#``(). */ /* => A.Foo#copy().(x) */ /* => A.Foo.``(). */ /* => A.Foo.apply().(x) */ case class /* => java.lang.Object#``(). */ Foo /* <= A.Foo# */ (x: In /* <= A.Foo#``(). */ /* <= A.Foo#``().(x) */ /* <= A.Foo#(x) */ /* <= A.Foo#copy().(x) */ /* <= A.Foo.apply().(x) */ t /* => scala.Int# */ /* => A.Foo#(x) */ /* => scala.package.Serializable# */ /* => scala. */ /* => _root_ */ ) /* => scala.Product# */ /* => scala. */ /* => _root_ */ /* => scala.package.Serializable# */ +} \ No newline at end of file diff --git a/tests/new/semanticdb-extract.scala b/tests/semanticdb/semanticdb-extract.scala similarity index 100% rename from tests/new/semanticdb-extract.scala rename to tests/semanticdb/semanticdb-extract.scala From 327f764dd04975dccf0b699d1072587e318e9b65 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 11 Oct 2019 17:29:17 +0200 Subject: [PATCH 021/107] update docs, pretty printer and remove Main test --- .../dotty/tools/dotc/semanticdb/Main.scala | 68 ------------------- .../tools/dotc/semanticdb/Semanticdbs.scala | 2 +- docs/docs/internals/overall-structure.md | 2 + tests/semanticdb/Definitions.expect.scala | 14 ++-- .../semanticdb-extract.expect.scala | 24 +++---- 5 files changed, 22 insertions(+), 88 deletions(-) delete mode 100644 compiler/src/dotty/tools/dotc/semanticdb/Main.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Main.scala b/compiler/src/dotty/tools/dotc/semanticdb/Main.scala deleted file mode 100644 index ab9057d87c7f..000000000000 --- a/compiler/src/dotty/tools/dotc/semanticdb/Main.scala +++ /dev/null @@ -1,68 +0,0 @@ -package dotty.tools.dotc.semanticdb - -import java.nio.file.Paths -import java.nio.file.Files -import java.nio.file.StandardOpenOption -import java.nio.file.Path -import java.security.MessageDigest -import java.nio.charset.StandardCharsets -import scala.collection.JavaConverters._ - -object Main { - def write( - source: Path, - contents: String, - sourceroot: Path, - targetroot: Path, - occurrences: Seq[SymbolOccurrence] - ): Unit = { - val relpath = sourceroot.relativize(source) - val reluri = relpath.iterator().asScala.mkString("/") - val outpath = targetroot - .resolve("META-INF") - .resolve("semanticdb") - .resolve(relpath) - .resolveSibling(source.getFileName().toString() + ".semanticdb") - Files.createDirectories(outpath.getParent()) - val doc: TextDocument = TextDocument( - schema = Schema.SEMANTICDB4, - language = Language.SCALA, - uri = reluri, - text = "", - md5 = MD5.compute(contents), - occurrences = occurrences - ) - val docs = TextDocuments(List(doc)) - val out = Files.newOutputStream(outpath) - try { - val stream = SemanticdbOutputStream.newInstance(out) - docs.writeTo(stream) - stream.flush() - } finally { - out.close() - } - } - - def main(args: Array[String]): Unit = { - if (args.isEmpty) { - println("missing ") - sys.exit(1) - } - val occurrences = List( - SymbolOccurrence( - "_empty_/Main.", - Some(Range(0, 8, 0, 12)), - SymbolOccurrence.Role.REFERENCE - ) - ) - val sourceroot = Paths.get(args(0)) - val targetroot = sourceroot.resolve("out") - write( - sourceroot.resolve("Main.scala"), - "object Main", - sourceroot, - targetroot, - occurrences - ) - } -} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index e01844bafe38..5f33c13e971c 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -68,7 +68,7 @@ object Semanticdbs { ) sb.append(doc.text.substring(offset, end)) .append(" /* ") - .append(if (occ.role.isDefinition) "<= " else "=> ") + .append(if (occ.role.isDefinition) "<== " else "==> ") .append(occ.symbol.replace('/', '.')) .append(" */ ") offset = end diff --git a/docs/docs/internals/overall-structure.md b/docs/docs/internals/overall-structure.md index 3356854eb102..0783b1b96a66 100644 --- a/docs/docs/internals/overall-structure.md +++ b/docs/docs/internals/overall-structure.md @@ -36,6 +36,7 @@ list of sub-packages and their focus. ├── repl // The interactive REPL ├── reporting // Reporting of error messages, warnings and other info. ├── rewrites // Helpers for rewriting Scala 2's constructs into dotty's. +├── semanticdb // Helpers for exporting semanticdb from trees. ├── transform // Miniphases and helpers for tree transformations. ├── typer // Type-checking and other frontend phases └── util // General purpose utility classes and modules. @@ -100,6 +101,7 @@ phases. The current list of phases is specified in class [Compiler] as follows: List(new YCheckPositions) :: // YCheck positions List(new Staging) :: // Check PCP, heal quoted types and expand macros List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks + List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files List(new PostTyper) :: // Additional checks and cleanups after type checking List(new sbt.ExtractAPI) :: // Sends a representation of the API of classes to sbt via callbacks List(new SetRootTree) :: // Set the `rootTreeOrProvider` on class symbols diff --git a/tests/semanticdb/Definitions.expect.scala b/tests/semanticdb/Definitions.expect.scala index 4465df8a6c11..691050c66957 100644 --- a/tests/semanticdb/Definitions.expect.scala +++ b/tests/semanticdb/Definitions.expect.scala @@ -1,8 +1,8 @@ -package a /* => a. */ - /* => a.Definitions. */ /* => a.Definitions.``(). */ object /* => java.lang.Object#``(). */ Definitions /* <= a.Definitions. */ { - /* => scala.package.Serializable# */ /* => scala. */ /* => _root_ */ /* => a.Definitions. */ val a /* <= a.Definitions.a. */ = 1 - var b /* <= a.Definitions.b. */ = /* <= a.Definitions.`b_=`(). */ 2 - def c /* <= a.Definitions.c(). */ = 3 - class /* => java.lang.Object#``(). */ D /* <= a.Definitions.D# */ - trait E /* <= a.Definitions.E# */ +package a /* ==> a. */ + /* ==> a.Definitions. */ /* ==> a.Definitions.``(). */ object /* ==> java.lang.Object#``(). */ Definitions /* <== a.Definitions. */ { + /* ==> scala.package.Serializable# */ /* ==> scala. */ /* ==> _root_ */ /* ==> a.Definitions. */ val a /* <== a.Definitions.a. */ = 1 + var b /* <== a.Definitions.b. */ = /* <== a.Definitions.`b_=`(). */ 2 + def c /* <== a.Definitions.c(). */ = 3 + class /* ==> java.lang.Object#``(). */ D /* <== a.Definitions.D# */ + trait E /* <== a.Definitions.E# */ } diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala index 5d8ac1daad98..64e09a72e6f6 100644 --- a/tests/semanticdb/semanticdb-extract.expect.scala +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -1,18 +1,18 @@ - /* => _empty_ */ /* => A. */ /* => A.``(). */ object /* => java.lang.Object#``(). */ A /* <= A. */ { + /* ==> _empty_ */ /* ==> A. */ /* ==> A.``(). */ object /* ==> java.lang.Object#``(). */ A /* <== A. */ { - /* => scala.package.Serializable# */ /* => scala. */ /* => _root_ */ /* => A. */ def foo /* <= A.foo(+1). */ (x /* <= A.foo(+1).(x) */ : Int /* => scala.Int# */ ) = () - def foo /* <= A.foo(+0). */ (): Unit /* => scala.Unit# */ = () + /* ==> scala.package.Serializable# */ /* ==> scala. */ /* ==> _root_ */ /* ==> A. */ def foo /* <== A.foo(+1). */ (x /* <== A.foo(+1).(x) */ : Int /* ==> scala.Int# */ ) = () + def foo /* <== A.foo(+0). */ (): Unit /* ==> scala.Unit# */ = () - foo /* => A.foo(+1). */ (1) - foo /* => A.foo(+0). */ () + foo /* ==> A.foo(+1). */ (1) + foo /* ==> A.foo(+0). */ () - "".substring /* => java.lang.String#substring(+1). */ (1) - "".substring /* => java.lang.String#substring(+0). */ (1, 2) + "".substring /* ==> java.lang.String#substring(+1). */ (1) + "".substring /* ==> java.lang.String#substring(+0). */ (1, 2) - List /* => scala.package.List. */ /* => scala.collection.IterableFactory#apply(). */ (1, 2) - List /* => scala.package.List. */ .apply /* => scala.collection.IterableFactory#apply(). */ () - List /* => scala.package.List. */ .`apply` /* => scala.collection.IterableFactory#apply(). */ () - println /* => scala.Predef.println(+0). */ (1 + /* => scala.Int#`+`(+3). */ 2) + List /* ==> scala.package.List. */ /* ==> scala.collection.IterableFactory#apply(). */ (1, 2) + List /* ==> scala.package.List. */ .apply /* ==> scala.collection.IterableFactory#apply(). */ () + List /* ==> scala.package.List. */ .`apply` /* ==> scala.collection.IterableFactory#apply(). */ () + println /* ==> scala.Predef.println(+0). */ (1 + /* ==> scala.Int#`+`(+3). */ 2) - /* => A.Foo#``(). */ /* => A.Foo#copy().(x) */ /* => A.Foo.``(). */ /* => A.Foo.apply().(x) */ case class /* => java.lang.Object#``(). */ Foo /* <= A.Foo# */ (x: In /* <= A.Foo#``(). */ /* <= A.Foo#``().(x) */ /* <= A.Foo#(x) */ /* <= A.Foo#copy().(x) */ /* <= A.Foo.apply().(x) */ t /* => scala.Int# */ /* => A.Foo#(x) */ /* => scala.package.Serializable# */ /* => scala. */ /* => _root_ */ ) /* => scala.Product# */ /* => scala. */ /* => _root_ */ /* => scala.package.Serializable# */ + /* ==> A.Foo#``(). */ /* ==> A.Foo#copy().(x) */ /* ==> A.Foo.``(). */ /* ==> A.Foo.apply().(x) */ case class /* ==> java.lang.Object#``(). */ Foo /* <== A.Foo# */ (x: In /* <== A.Foo#``(). */ /* <== A.Foo#``().(x) */ /* <== A.Foo#(x) */ /* <== A.Foo#copy().(x) */ /* <== A.Foo.apply().(x) */ t /* ==> scala.Int# */ /* ==> A.Foo#(x) */ /* ==> scala.package.Serializable# */ /* ==> scala. */ /* ==> _root_ */ ) /* ==> scala.Product# */ /* ==> scala. */ /* ==> _root_ */ /* ==> scala.package.Serializable# */ } \ No newline at end of file From 9875f1438d61c296f9733254880df7a14b356455 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 16 Oct 2019 19:07:00 +0200 Subject: [PATCH 022/107] add more tests, skip module var in semantic db generation --- .../dotc/semanticdb/ExtractSemanticDB.scala | 1 + .../dotc/semanticdb/SemanticdbTests.scala | 2 +- .../tools/dotc/semanticdb/Semanticdbs.scala | 2 +- tests/semanticdb/Definitions.expect.scala | 14 +++--- tests/semanticdb/Enums.expect.scala | 50 +++++++++++++++++++ tests/semanticdb/Enums.scala | 50 +++++++++++++++++++ tests/semanticdb/NewModifiers.expect.scala | 4 ++ tests/semanticdb/NewModifiers.scala | 4 ++ .../semanticdb-extract.expect.scala | 24 ++++----- tests/semanticdb/toplevel.expect.scala | 6 +++ tests/semanticdb/toplevel.scala | 6 +++ 11 files changed, 142 insertions(+), 21 deletions(-) create mode 100644 tests/semanticdb/Enums.expect.scala create mode 100644 tests/semanticdb/Enums.scala create mode 100644 tests/semanticdb/NewModifiers.expect.scala create mode 100644 tests/semanticdb/NewModifiers.scala create mode 100644 tests/semanticdb/toplevel.expect.scala create mode 100644 tests/semanticdb/toplevel.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 6277f871d238..db95c0bd033b 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -160,6 +160,7 @@ class ExtractSemanticDB extends Phase { override def traverse(tree: Tree)(given ctx: Context): Unit = tree match + case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => registerOccurrence(tree.symbol, tree.nameSpan, SymbolOccurrence.Role.DEFINITION) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 9f90d972294e..f20e9d8e22ef 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -72,4 +72,4 @@ class SemanticdbTests { sys.error(s"dotc errors: ${exit.errorCount}") target -} \ No newline at end of file +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index 5f33c13e971c..b51560feb335 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -68,7 +68,7 @@ object Semanticdbs { ) sb.append(doc.text.substring(offset, end)) .append(" /* ") - .append(if (occ.role.isDefinition) "<== " else "==> ") + .append(if (occ.role.isDefinition) "<<< " else "ref ") .append(occ.symbol.replace('/', '.')) .append(" */ ") offset = end diff --git a/tests/semanticdb/Definitions.expect.scala b/tests/semanticdb/Definitions.expect.scala index 691050c66957..64632cdc444e 100644 --- a/tests/semanticdb/Definitions.expect.scala +++ b/tests/semanticdb/Definitions.expect.scala @@ -1,8 +1,8 @@ -package a /* ==> a. */ - /* ==> a.Definitions. */ /* ==> a.Definitions.``(). */ object /* ==> java.lang.Object#``(). */ Definitions /* <== a.Definitions. */ { - /* ==> scala.package.Serializable# */ /* ==> scala. */ /* ==> _root_ */ /* ==> a.Definitions. */ val a /* <== a.Definitions.a. */ = 1 - var b /* <== a.Definitions.b. */ = /* <== a.Definitions.`b_=`(). */ 2 - def c /* <== a.Definitions.c(). */ = 3 - class /* ==> java.lang.Object#``(). */ D /* <== a.Definitions.D# */ - trait E /* <== a.Definitions.E# */ +package a /* ref a. */ +object /* ref java.lang.Object#``(). */ Definitions /* <<< a.Definitions. */ { + /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref a.Definitions. */ val a /* <<< a.Definitions.a. */ = 1 + var b /* <<< a.Definitions.b. */ = /* <<< a.Definitions.`b_=`(). */ 2 + def c /* <<< a.Definitions.c(). */ = 3 + class /* ref java.lang.Object#``(). */ D /* <<< a.Definitions.D# */ + trait E /* <<< a.Definitions.E# */ } diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala new file mode 100644 index 000000000000..e219017dd152 --- /dev/null +++ b/tests/semanticdb/Enums.expect.scala @@ -0,0 +1,50 @@ + /* ref _empty_ */ object /* ref java.lang.Object#``(). */ Enums /* <<< Enums. */ { + /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref Enums. */ enum /* ref java.lang.Object#``(). */ Colour /* <<< Enums.Colour# */ { + /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ case /* ref scala.collection.IterableOnceOps#toArray(). */ /* ref scala.runtime.EnumValues#values(). */ /* ref Enums.Colour.$values. */ /* ref scala.reflect.ClassTag.apply(). */ /* ref scala.reflect.ClassTag. */ /* ref scala.runtime.EnumValues#``(). */ /* ref scala.collection.MapOps#apply(). */ /* ref scala.runtime.EnumValues#fromName(). */ /* ref Enums.Colour.valueOf().($name) */ /* ref java.util.NoSuchElementException# */ /* ref ``.throw(). */ /* ref java.lang.IllegalArgumentException#``(+2). */ /* ref java.lang.String#concat(). */ /* ref Enums.Colour#``(). */ /* ref Enums.Colour.$new().(_$ordinal) */ /* ref Enums.Colour.$new().($name) */ /* ref scala.runtime.EnumValues#register(). */ /* ref local0 */ /* ref local1 */ Red /* ref Enums.Colour.Red. */ /* <<< Enums.Colour.Red. */ , Gr /* <<< Enums.Colour.$values. */ een /* ref Enums.Colour.Green. */ /* <<< Enums.Colour.Green. */ , Blue /* ref Enums.Colour.Blue. */ /* <<< Enums.Colour.Blue. */ + } + + enum /* ref java.lang.Object#``(). */ WeekDays /* <<< Enums.WeekDays# */ { + /* ref Enums.WeekDays.Monday. */ /* ref Enums.WeekDays.Tuesday. */ /* ref Enums.WeekDays.Wednesday. */ /* ref Enums.WeekDays.Thursday. */ /* ref Enums.WeekDays.Friday. */ /* ref Enums.WeekDays.Saturday. */ /* ref Enums.WeekDays.Sunday. */ /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref scala.collection.IterableOnceOps#toArray(). */ /* ref scala.runtime.EnumValues#values(). */ /* ref Enums.WeekDays.$values. */ /* ref scala.reflect.ClassTag.apply(). */ /* ref scala.reflect.ClassTag. */ /* ref scala.runtime.EnumValues#``(). */ /* ref scala.collection.MapOps#apply(). */ /* ref scala.runtime.EnumValues#fromName(). */ /* ref Enums.WeekDays.valueOf().($name) */ /* ref java.util.NoSuchElementException# */ /* ref ``.throw(). */ /* ref java.lang.IllegalArgumentException#``(+2). */ /* ref java.lang.String#concat(). */ /* ref Enums.WeekDays#``(). */ /* ref Enums.WeekDays.$new().(_$ordinal) */ /* ref Enums.WeekDays.$new().($name) */ /* ref scala.runtime.EnumValues#register(). */ /* ref local2 */ /* ref local3 */ case Monday /* <<< Enums.WeekDays.Monday. */ + /* <<< Enums.WeekDays.$values. */ case Tuesday /* <<< Enums.WeekDays.Tuesday. */ + case Wednesday /* <<< Enums.WeekDays.Wednesday. */ + case Thursday /* <<< Enums.WeekDays.Thursday. */ + case Friday /* <<< Enums.WeekDays.Friday. */ + case Saturday /* <<< Enums.WeekDays.Saturday. */ + case Sunday /* <<< Enums.WeekDays.Sunday. */ + } + + enum /* ref java.lang.Object#``(). */ Maybe /* <<< Enums.Maybe# */ [+A] { /* <<< Enums.Maybe#``(). */ /* <<< Enums.Maybe#``().(A) */ /* <<< Enums.Maybe#(A) */ /* ref Enums.Maybe.None. */ + /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref Enums.Maybe#``(). */ /* ref Enums.Maybe.Just#(A) */ /* ref Enums.Maybe.Just#``(). */ /* ref Enums.Maybe.Just#copy().(A) */ /* ref Enums.Maybe.Just#copy().(value) */ /* ref Enums.Maybe.Just.apply().(A) */ /* ref Enums.Maybe.Just.apply().(value) */ /* ref Enums.Maybe.Just.unapply().(A) */ case Just /* <<< Enums.Maybe.Just# */ (value /* <<< Enums.Maybe.Just#``(). */ /* <<< Enums.Maybe.Just#``().(value) */ /* <<< Enums.Maybe.Just#(value) */ /* <<< Enums.Maybe.Just#copy().(value) */ /* <<< Enums.Maybe.Just.apply().(value) */ : A /* ref Enums.Maybe.Just#``().(A) */ /* ref Enums.Maybe.Just#(value) */ ) /* ref scala.Product# */ /* ref scala. */ /* ref _root_ */ /* ref scala.package.Serializable# */ + /* ref Enums.Maybe#``(). */ case /* <<< local4 */ None /* <<< Enums.Maybe.None. */ /* ref local5 */ /* ref local4 */ + } + + enum /* ref java.lang.Object#``(). */ Tag /* <<< Enums.Tag# */ [A] { + /* <<< Enums.Tag#``(). */ /* <<< Enums.Tag#``().(A) */ /* <<< Enums.Tag#(A) */ /* ref Enums.Tag.IntTag. */ /* ref Enums.Tag.BooleanTag. */ /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ case IntTag /* <<< Enums.Tag.IntTag. */ extends Tag /* ref Enums.Tag# */ [I /* <<< local6 */ nt /* ref scala.Int# */ ] /* ref Enums.Tag#``(). */ /* ref local7 */ /* ref local6 */ + case BooleanTag /* <<< Enums.Tag.BooleanTag. */ extends Tag /* ref Enums.Tag# */ [B /* <<< local8 */ oolean /* ref scala.Boolean# */ ] /* ref Enums.Tag#``(). */ /* ref local9 */ /* ref local8 */ + } + + enum /* ref java.lang.Object#``(). */ =:= /* <<< Enums.`=:=`# */ [A, B] /* <<< Enums.`=:=`#``(). */ /* <<< Enums.`=:=`#``().(A) */ /* <<< Enums.`=:=`#(A) */ /* <<< Enums.`=:=`#``().(B) */ /* <<< Enums.`=:=`#(B) */ { + /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref Enums.`=:=`.Refl#``(). */ /* ref Enums.`=:=`.Refl#copy().(C) */ /* ref Enums.`=:=`.Refl.apply().(C) */ /* ref Enums.`=:=`.Refl.unapply().(C) */ case Refl /* <<< Enums.`=:=`.Refl# */ [C]() /* <<< Enums.`=:=`.Refl#``(). */ /* <<< Enums.`=:=`.Refl#``().(C) */ /* <<< Enums.`=:=`.Refl#(C) */ /* <<< Enums.`=:=`.Refl#copy().(C) */ /* <<< Enums.`=:=`.Refl.apply().(C) */ /* <<< Enums.`=:=`.Refl.unapply().(C) */ extends (C /* ref Enums.`=:=`.Refl#(C) */ /* ref Enums.`=:=`.Refl.apply().(C) */ =:= /* ref Enums.`=:=`# */ C /* ref Enums.`=:=`.Refl#(C) */ /* ref Enums.`=:=`.Refl.apply().(C) */ /* ref Enums.`=:=`#``(). */ ) /* ref scala.Product# */ /* ref scala. */ /* ref _root_ */ /* ref scala.package.Serializable# */ + } + + def unwrap /* <<< Enums.unwrap(). */ [A /* <<< Enums.unwrap().(A) */ ,B /* <<< Enums.unwrap().(B) */ ](opt /* <<< Enums.unwrap().(opt) */ : Option /* ref scala.Option# */ [A /* ref Enums.unwrap().(A) */ ])(given ev /* <<< Enums.unwrap().(ev) */ : A /* ref Enums.unwrap().(A) */ =:= /* ref Enums.`=:=`# */ Option /* ref scala.Option# */ [B /* ref Enums.unwrap().(B) */ ]): Option /* ref scala.Option# */ [B /* ref Enums.unwrap().(B) */ ] = { + ev /* ref Enums.unwrap().(ev) */ match { + case =:= /* ref Enums.`=:=`. */ .Refl /* ref Enums.`=:=`.Refl. */ () => opt /* ref Enums.unwrap().(opt) */ .flatMap /* ref scala.Option#flatMap(). */ (identity /* ref scala.Predef.identity(). */ [Option /* ref scala.Option# */ [B /* ref Enums.unwrap().(B) */ ]]) + } + } + + enum Planet /* <<< Enums.Planet# */ (mass: /* <<< Enums.Planet#``(). */ /* <<< Enums.Planet#``().(mass) */ /* <<< Enums.Planet#(mass) */ Double /* ref scala.Double# */ , radius /* <<< Enums.Planet#``().(radius) */ /* <<< Enums.Planet#(radius) */ : Double /* ref scala.Double# */ ) extends java /* ref java. */ .lang /* ref java.lang. */ .Enum /* ref java.lang.Enum# */ [Planet /* ref Enums.Planet# */ ] /* ref java.lang.Enum#``(). */ /* ref Enums.Planet.Mercury. */ /* ref Enums.Planet.Venus. */ /* ref Enums.Planet.Earth. */ /* ref Enums.Planet.Mars. */ /* ref Enums.Planet.Jupiter. */ /* ref Enums.Planet.Saturn. */ /* ref Enums.Planet.Uranus. */ /* ref Enums.Planet.Neptune. */ { + private final val G /* <<< Enums.Planet#G. */ = 6.67300E-11 + def surfaceGravity /* <<< Enums.Planet#surfaceGravity(). */ = G /* ref Enums.Planet#G. */ * /* ref scala.Double#`*`(+0). */ mass /* ref Enums.Planet#(mass) */ / /* ref scala.Double#`.`(+0). */ (radius /* ref Enums.Planet#(radius) */ * /* ref scala.Double#`*`(+0). */ radius /* ref Enums.Planet#(radius) */ ) + def surfaceWeight /* <<< Enums.Planet#surfaceWeight(). */ (otherMass /* <<< Enums.Planet#surfaceWeight().(otherMass) */ : Double /* ref scala.Double# */ ) = otherMass /* ref Enums.Planet#surfaceWeight().(otherMass) */ * /* ref scala.Double#`*`(+0). */ surfaceGravity /* ref Enums.Planet#surfaceGravity(). */ + + /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ case Mercury /* <<< Enums.Planet.$values. */ /* <<< Enums.Planet.Mercury. */ extends /* ref scala.collection.IterableOnceOps#toArray(). */ /* ref scala.runtime.EnumValues#values(). */ /* ref Enums.Planet.$values. */ /* ref scala.reflect.ClassTag.apply(). */ /* ref scala.reflect.ClassTag. */ /* ref scala.runtime.EnumValues#``(). */ /* ref scala.collection.MapOps#apply(). */ /* ref scala.runtime.EnumValues#fromName(). */ /* ref Enums.Planet.valueOf().($name) */ /* ref java.util.NoSuchElementException# */ /* ref ``.throw(). */ /* ref java.lang.IllegalArgumentException#``(+2). */ /* ref java.lang.String#concat(). */ Plane /* <<< local10 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (3.303e+23, 2.4397e6) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local11 */ /* ref local10 */ + case Venus /* <<< Enums.Planet.Venus. */ extends Plane /* <<< local12 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (4.869e+24, 6.0518e6) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local13 */ /* ref local12 */ + case Earth /* <<< Enums.Planet.Earth. */ extends Plane /* <<< local14 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (5.976e+24, 6.37814e6) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local15 */ /* ref local14 */ + case Mars /* <<< Enums.Planet.Mars. */ extends Plane /* <<< local16 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (6.421e+23, 3.3972e6) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local17 */ /* ref local16 */ + case Jupiter /* <<< Enums.Planet.Jupiter. */ extends Plane /* <<< local18 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (1.9e+27, 7.1492e7) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local19 */ /* ref local18 */ + case Saturn /* <<< Enums.Planet.Saturn. */ extends Plane /* <<< local20 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (5.688e+26, 6.0268e7) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local21 */ /* ref local20 */ + case Uranus /* <<< Enums.Planet.Uranus. */ extends Plane /* <<< local22 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (8.686e+25, 2.5559e7) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local23 */ /* ref local22 */ + case Neptune /* <<< Enums.Planet.Neptune. */ extends Plane /* <<< local24 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (1.024e+26, 2.4746e7) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local25 */ /* ref local24 */ + } +} diff --git a/tests/semanticdb/Enums.scala b/tests/semanticdb/Enums.scala new file mode 100644 index 000000000000..e3b6a857087c --- /dev/null +++ b/tests/semanticdb/Enums.scala @@ -0,0 +1,50 @@ +object Enums { + enum Colour { + case Red, Green, Blue + } + + enum WeekDays { + case Monday + case Tuesday + case Wednesday + case Thursday + case Friday + case Saturday + case Sunday + } + + enum Maybe[+A] { + case Just(value: A) + case None + } + + enum Tag[A] { + case IntTag extends Tag[Int] + case BooleanTag extends Tag[Boolean] + } + + enum =:=[A, B] { + case Refl[C]() extends (C =:= C) + } + + def unwrap[A,B](opt: Option[A])(given ev: A =:= Option[B]): Option[B] = { + ev match { + case =:=.Refl() => opt.flatMap(identity[Option[B]]) + } + } + + enum Planet(mass: Double, radius: Double) extends java.lang.Enum[Planet] { + private final val G = 6.67300E-11 + def surfaceGravity = G * mass / (radius * radius) + def surfaceWeight(otherMass: Double) = otherMass * surfaceGravity + + case Mercury extends Planet(3.303e+23, 2.4397e6) + case Venus extends Planet(4.869e+24, 6.0518e6) + case Earth extends Planet(5.976e+24, 6.37814e6) + case Mars extends Planet(6.421e+23, 3.3972e6) + case Jupiter extends Planet(1.9e+27, 7.1492e7) + case Saturn extends Planet(5.688e+26, 6.0268e7) + case Uranus extends Planet(8.686e+25, 2.5559e7) + case Neptune extends Planet(1.024e+26, 2.4746e7) + } +} diff --git a/tests/semanticdb/NewModifiers.expect.scala b/tests/semanticdb/NewModifiers.expect.scala new file mode 100644 index 000000000000..124ec2a0b9df --- /dev/null +++ b/tests/semanticdb/NewModifiers.expect.scala @@ -0,0 +1,4 @@ + /* ref _empty_ */ object /* ref java.lang.Object#``(). */ NewModifiers /* <<< NewModifiers. */ { + /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref NewModifiers. */ inline val foo /* <<< NewModifiers.foo. */ = "foo" + opaque type A /* <<< NewModifiers.A# */ = Int /* ref scala.Int# */ +} diff --git a/tests/semanticdb/NewModifiers.scala b/tests/semanticdb/NewModifiers.scala new file mode 100644 index 000000000000..2d5e82551b02 --- /dev/null +++ b/tests/semanticdb/NewModifiers.scala @@ -0,0 +1,4 @@ +object NewModifiers { + inline val foo = "foo" + opaque type A = Int +} diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala index 64e09a72e6f6..4c9daa14e947 100644 --- a/tests/semanticdb/semanticdb-extract.expect.scala +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -1,18 +1,18 @@ - /* ==> _empty_ */ /* ==> A. */ /* ==> A.``(). */ object /* ==> java.lang.Object#``(). */ A /* <== A. */ { + /* ref _empty_ */ object /* ref java.lang.Object#``(). */ A /* <<< A. */ { - /* ==> scala.package.Serializable# */ /* ==> scala. */ /* ==> _root_ */ /* ==> A. */ def foo /* <== A.foo(+1). */ (x /* <== A.foo(+1).(x) */ : Int /* ==> scala.Int# */ ) = () - def foo /* <== A.foo(+0). */ (): Unit /* ==> scala.Unit# */ = () + /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref A. */ def foo /* <<< A.foo(+1). */ (x /* <<< A.foo(+1).(x) */ : Int /* ref scala.Int# */ ) = () + def foo /* <<< A.foo(+0). */ (): Unit /* ref scala.Unit# */ = () - foo /* ==> A.foo(+1). */ (1) - foo /* ==> A.foo(+0). */ () + foo /* ref A.foo(+1). */ (1) + foo /* ref A.foo(+0). */ () - "".substring /* ==> java.lang.String#substring(+1). */ (1) - "".substring /* ==> java.lang.String#substring(+0). */ (1, 2) + "".substring /* ref java.lang.String#substring(+1). */ (1) + "".substring /* ref java.lang.String#substring(+0). */ (1, 2) - List /* ==> scala.package.List. */ /* ==> scala.collection.IterableFactory#apply(). */ (1, 2) - List /* ==> scala.package.List. */ .apply /* ==> scala.collection.IterableFactory#apply(). */ () - List /* ==> scala.package.List. */ .`apply` /* ==> scala.collection.IterableFactory#apply(). */ () - println /* ==> scala.Predef.println(+0). */ (1 + /* ==> scala.Int#`+`(+3). */ 2) + List /* ref scala.package.List. */ /* ref scala.collection.IterableFactory#apply(). */ (1, 2) + List /* ref scala.package.List. */ .apply /* ref scala.collection.IterableFactory#apply(). */ () + List /* ref scala.package.List. */ .`apply` /* ref scala.collection.IterableFactory#apply(). */ () + println /* ref scala.Predef.println(+0). */ (1 + /* ref scala.Int#`+`(+3). */ 2) - /* ==> A.Foo#``(). */ /* ==> A.Foo#copy().(x) */ /* ==> A.Foo.``(). */ /* ==> A.Foo.apply().(x) */ case class /* ==> java.lang.Object#``(). */ Foo /* <== A.Foo# */ (x: In /* <== A.Foo#``(). */ /* <== A.Foo#``().(x) */ /* <== A.Foo#(x) */ /* <== A.Foo#copy().(x) */ /* <== A.Foo.apply().(x) */ t /* ==> scala.Int# */ /* ==> A.Foo#(x) */ /* ==> scala.package.Serializable# */ /* ==> scala. */ /* ==> _root_ */ ) /* ==> scala.Product# */ /* ==> scala. */ /* ==> _root_ */ /* ==> scala.package.Serializable# */ + /* ref A.Foo#``(). */ /* ref A.Foo#copy().(x) */ /* ref A.Foo.apply().(x) */ case class /* ref java.lang.Object#``(). */ Foo /* <<< A.Foo# */ (x: In /* <<< A.Foo#``(). */ /* <<< A.Foo#``().(x) */ /* <<< A.Foo#(x) */ /* <<< A.Foo#copy().(x) */ /* <<< A.Foo.apply().(x) */ t /* ref scala.Int# */ /* ref A.Foo#(x) */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ ) /* ref scala.Product# */ /* ref scala. */ /* ref _root_ */ /* ref scala.package.Serializable# */ } \ No newline at end of file diff --git a/tests/semanticdb/toplevel.expect.scala b/tests/semanticdb/toplevel.expect.scala new file mode 100644 index 000000000000..17a2401a1801 --- /dev/null +++ b/tests/semanticdb/toplevel.expect.scala @@ -0,0 +1,6 @@ + /* ref _empty_ */ /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref toplevel$package. */ inline val a = " /* <<< toplevel$package. */ /* <<< toplevel$package.a. */ " +def (x: Int /* <<< toplevel$package.combine(). */ /* <<< toplevel$package.combine().(x) */ /* ref scala.Int# */ ) combine (y /* <<< toplevel$package.combine().(y) */ : Int /* ref scala.Int# */ ) = x /* ref toplevel$package.combine().(x) */ + /* ref scala.Int#`+`(+3). */ y /* ref toplevel$package.combine().(y) */ +given /* ref java.lang.Object#``(). */ [A](any: A) { + def /* <<< toplevel$package.given_sayHello_of_A. */ /* ref toplevel$package.given_sayHello_of_A. */ /* <<< toplevel$package.given_sayHello_of_A.sayHello().(A) */ /* <<< toplevel$package.given_sayHello_of_A.sayHello().(any) */ /* ref toplevel$package.given_sayHello_of_A.sayHello().(A) */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ sayHello /* <<< toplevel$package.given_sayHello_of_A.sayHello(). */ = s" /* ref scala.StringContext. */ /* ref scala. */ /* ref _root_ */ Hello, I am $any /* ref toplevel$package.given_sayHello_of_A.sayHello().(any) */ /* ref scala.StringContext#s(+1). */ " +} +val hello1 /* <<< toplevel$package.hello1. */ = /* ref toplevel$package.given_sayHello_of_A.sayHello(). */ /* ref toplevel$package.given_sayHello_of_A. */ 1.sayHello diff --git a/tests/semanticdb/toplevel.scala b/tests/semanticdb/toplevel.scala new file mode 100644 index 000000000000..e9f761a6ee13 --- /dev/null +++ b/tests/semanticdb/toplevel.scala @@ -0,0 +1,6 @@ +inline val a = "" +def (x: Int) combine (y: Int) = x + y +given [A](any: A) { + def sayHello = s"Hello, I am $any" +} +val hello1 = 1.sayHello From 42e4649c734d572c6474360c6a28cb87379991f2 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 17 Oct 2019 12:19:46 +0200 Subject: [PATCH 023/107] fix overload order and indexing, remove references at package defs --- .../dotc/semanticdb/ExtractSemanticDB.scala | 6 +- .../dotc/semanticdb/SemanticdbTests.scala | 3 +- .../tools/dotc/semanticdb/Semanticdbs.scala | 6 +- tests/semanticdb/Access.expect.scala | 11 +++ tests/semanticdb/Access.scala | 11 +++ tests/semanticdb/Definitions.expect.scala | 14 ++-- tests/semanticdb/Enums.expect.scala | 68 +++++++++---------- tests/semanticdb/Givens.expect.scala | 21 ++++++ tests/semanticdb/Givens.scala | 21 ++++++ tests/semanticdb/NewModifiers.expect.scala | 6 +- .../semanticdb-extract.expect.scala | 24 +++---- tests/semanticdb/toplevel.expect.scala | 10 ++- tests/semanticdb/toplevel.scala | 6 +- 13 files changed, 135 insertions(+), 72 deletions(-) create mode 100644 tests/semanticdb/Access.expect.scala create mode 100644 tests/semanticdb/Access.scala create mode 100644 tests/semanticdb/Givens.expect.scala create mode 100644 tests/semanticdb/Givens.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index db95c0bd033b..1a40c63fbb11 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -79,11 +79,12 @@ class ExtractSemanticDB extends Phase { if !owner.isRoot && !owner.isEmptyPackage then addSymName(b, owner) def addOverloadIdx(sym: Symbol): Unit = - val alts = sym.owner.info.decls.lookupAll(sym.name).toList + val alts = sym.owner.info.decls.lookupAll(sym.name).toList.reverse if alts.tail.nonEmpty then val idx = alts.indexOf(sym) assert(idx >= 0) - b.append('+').append(idx) + if idx > 0 then + b.append('+').append(idx) def addDescriptor(sym: Symbol): Unit = if sym.is(ModuleClass) then @@ -186,6 +187,7 @@ class ExtractSemanticDB extends Phase { registerUse(alt.symbol, sel.imported.span) case tree: Inlined => traverse(tree.call) + case tree: PackageDef => tree.stats.foreach(traverse) case _ => traverseChildren(tree) } diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index f20e9d8e22ef..f066d2d8fe26 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -21,7 +21,7 @@ import dotty.tools.dotc.semanticdb.DiffAssertions._ class SemanticdbTests { val scalaFile = FileSystems.getDefault.getPathMatcher("glob:**.scala") val expectFile = FileSystems.getDefault.getPathMatcher("glob:**.expect.scala") - val semanticdbFile = FileSystems.getDefault.getPathMatcher("glob:**.scala.semanticdb") + // val semanticdbFile = FileSystems.getDefault.getPathMatcher("glob:**.scala.semanticdb") val src = Paths.get(System.getProperty("user.dir")).resolve("tests").resolve("semanticdb") @Category(Array(classOf[dotty.SlowTests])) @@ -64,6 +64,7 @@ class SemanticdbTests { val args = Array( "-Ysemanticdb", "-d", target.toString, + // "-Xprint:extractSemanticDB", "-sourceroot", src.toString, "-usejavacp", ) ++ inputFiles().map(_.toString) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index b51560feb335..4f466fe44f11 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -67,10 +67,10 @@ object Semanticdbs { sourceFile.lineToOffset(range.endLine) + range.endCharacter ) sb.append(doc.text.substring(offset, end)) - .append(" /* ") - .append(if (occ.role.isDefinition) "<<< " else "ref ") + .append(" /*") + .append(if (occ.role.isDefinition) "<<=" else "=>>") .append(occ.symbol.replace('/', '.')) - .append(" */ ") + .append("*/ ") offset = end } sb.append(doc.text.substring(offset)) diff --git a/tests/semanticdb/Access.expect.scala b/tests/semanticdb/Access.expect.scala new file mode 100644 index 000000000000..1630c45f36ca --- /dev/null +++ b/tests/semanticdb/Access.expect.scala @@ -0,0 +1,11 @@ +package example + +class /*=>>java.lang.Object#``().*/ Access /*<<=example.Access#*/ { + private def m1 /*<<=example.Access#m1().*/ = ??? /*=>>scala.Predef.`???`().*/ + private[this] def m2 /*<<=example.Access#m2().*/ = ??? /*=>>scala.Predef.`???`().*/ + private[Access] def m3 /*<<=example.Access#m3().*/ = ??? /*=>>scala.Predef.`???`().*/ + protected def m4 /*<<=example.Access#m4().*/ = ??? /*=>>scala.Predef.`???`().*/ + protected[this] def m5 /*<<=example.Access#m5().*/ = ??? /*=>>scala.Predef.`???`().*/ + protected[example] def m6 /*<<=example.Access#m6().*/ = ??? /*=>>scala.Predef.`???`().*/ + def m7 /*<<=example.Access#m7().*/ = ??? /*=>>scala.Predef.`???`().*/ +} diff --git a/tests/semanticdb/Access.scala b/tests/semanticdb/Access.scala new file mode 100644 index 000000000000..aee3754da66b --- /dev/null +++ b/tests/semanticdb/Access.scala @@ -0,0 +1,11 @@ +package example + +class Access { + private def m1 = ??? + private[this] def m2 = ??? + private[Access] def m3 = ??? + protected def m4 = ??? + protected[this] def m5 = ??? + protected[example] def m6 = ??? + def m7 = ??? +} diff --git a/tests/semanticdb/Definitions.expect.scala b/tests/semanticdb/Definitions.expect.scala index 64632cdc444e..b8be2ec3d76f 100644 --- a/tests/semanticdb/Definitions.expect.scala +++ b/tests/semanticdb/Definitions.expect.scala @@ -1,8 +1,8 @@ -package a /* ref a. */ -object /* ref java.lang.Object#``(). */ Definitions /* <<< a.Definitions. */ { - /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref a.Definitions. */ val a /* <<< a.Definitions.a. */ = 1 - var b /* <<< a.Definitions.b. */ = /* <<< a.Definitions.`b_=`(). */ 2 - def c /* <<< a.Definitions.c(). */ = 3 - class /* ref java.lang.Object#``(). */ D /* <<< a.Definitions.D# */ - trait E /* <<< a.Definitions.E# */ +package a +object /*=>>java.lang.Object#``().*/ Definitions /*<<=a.Definitions.*/ { + /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>a.Definitions.*/ val a /*<<=a.Definitions.a.*/ = 1 + var b /*<<=a.Definitions.b.*/ = /*<<=a.Definitions.`b_=`().*/ 2 + def c /*<<=a.Definitions.c().*/ = 3 + class /*=>>java.lang.Object#``().*/ D /*<<=a.Definitions.D#*/ + trait E /*<<=a.Definitions.E#*/ } diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala index e219017dd152..ac8ca251da5c 100644 --- a/tests/semanticdb/Enums.expect.scala +++ b/tests/semanticdb/Enums.expect.scala @@ -1,50 +1,50 @@ - /* ref _empty_ */ object /* ref java.lang.Object#``(). */ Enums /* <<< Enums. */ { - /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref Enums. */ enum /* ref java.lang.Object#``(). */ Colour /* <<< Enums.Colour# */ { - /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ case /* ref scala.collection.IterableOnceOps#toArray(). */ /* ref scala.runtime.EnumValues#values(). */ /* ref Enums.Colour.$values. */ /* ref scala.reflect.ClassTag.apply(). */ /* ref scala.reflect.ClassTag. */ /* ref scala.runtime.EnumValues#``(). */ /* ref scala.collection.MapOps#apply(). */ /* ref scala.runtime.EnumValues#fromName(). */ /* ref Enums.Colour.valueOf().($name) */ /* ref java.util.NoSuchElementException# */ /* ref ``.throw(). */ /* ref java.lang.IllegalArgumentException#``(+2). */ /* ref java.lang.String#concat(). */ /* ref Enums.Colour#``(). */ /* ref Enums.Colour.$new().(_$ordinal) */ /* ref Enums.Colour.$new().($name) */ /* ref scala.runtime.EnumValues#register(). */ /* ref local0 */ /* ref local1 */ Red /* ref Enums.Colour.Red. */ /* <<< Enums.Colour.Red. */ , Gr /* <<< Enums.Colour.$values. */ een /* ref Enums.Colour.Green. */ /* <<< Enums.Colour.Green. */ , Blue /* ref Enums.Colour.Blue. */ /* <<< Enums.Colour.Blue. */ +object /*=>>java.lang.Object#``().*/ Enums /*<<=Enums.*/ { + /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>Enums.*/ enum /*=>>java.lang.Object#``().*/ Colour /*<<=Enums.Colour#*/ { + /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ case /*=>>scala.collection.IterableOnceOps#toArray().*/ /*=>>scala.runtime.EnumValues#values().*/ /*=>>Enums.Colour.$values.*/ /*=>>scala.reflect.ClassTag.apply().*/ /*=>>scala.reflect.ClassTag.*/ /*=>>scala.runtime.EnumValues#``().*/ /*=>>scala.collection.MapOps#apply().*/ /*=>>scala.runtime.EnumValues#fromName().*/ /*=>>Enums.Colour.valueOf().($name)*/ /*=>>java.util.NoSuchElementException#*/ /*=>>``.throw().*/ /*=>>java.lang.IllegalArgumentException#``(+1).*/ /*=>>java.lang.String#concat().*/ /*=>>Enums.Colour#``().*/ /*=>>Enums.Colour.$new().(_$ordinal)*/ /*=>>Enums.Colour.$new().($name)*/ /*=>>scala.runtime.EnumValues#register().*/ /*=>>local0*/ /*=>>local1*/ Red /*=>>Enums.Colour.Red.*/ /*<<=Enums.Colour.Red.*/ , Gr /*<<=Enums.Colour.$values.*/ een /*=>>Enums.Colour.Green.*/ /*<<=Enums.Colour.Green.*/ , Blue /*=>>Enums.Colour.Blue.*/ /*<<=Enums.Colour.Blue.*/ } - enum /* ref java.lang.Object#``(). */ WeekDays /* <<< Enums.WeekDays# */ { - /* ref Enums.WeekDays.Monday. */ /* ref Enums.WeekDays.Tuesday. */ /* ref Enums.WeekDays.Wednesday. */ /* ref Enums.WeekDays.Thursday. */ /* ref Enums.WeekDays.Friday. */ /* ref Enums.WeekDays.Saturday. */ /* ref Enums.WeekDays.Sunday. */ /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref scala.collection.IterableOnceOps#toArray(). */ /* ref scala.runtime.EnumValues#values(). */ /* ref Enums.WeekDays.$values. */ /* ref scala.reflect.ClassTag.apply(). */ /* ref scala.reflect.ClassTag. */ /* ref scala.runtime.EnumValues#``(). */ /* ref scala.collection.MapOps#apply(). */ /* ref scala.runtime.EnumValues#fromName(). */ /* ref Enums.WeekDays.valueOf().($name) */ /* ref java.util.NoSuchElementException# */ /* ref ``.throw(). */ /* ref java.lang.IllegalArgumentException#``(+2). */ /* ref java.lang.String#concat(). */ /* ref Enums.WeekDays#``(). */ /* ref Enums.WeekDays.$new().(_$ordinal) */ /* ref Enums.WeekDays.$new().($name) */ /* ref scala.runtime.EnumValues#register(). */ /* ref local2 */ /* ref local3 */ case Monday /* <<< Enums.WeekDays.Monday. */ - /* <<< Enums.WeekDays.$values. */ case Tuesday /* <<< Enums.WeekDays.Tuesday. */ - case Wednesday /* <<< Enums.WeekDays.Wednesday. */ - case Thursday /* <<< Enums.WeekDays.Thursday. */ - case Friday /* <<< Enums.WeekDays.Friday. */ - case Saturday /* <<< Enums.WeekDays.Saturday. */ - case Sunday /* <<< Enums.WeekDays.Sunday. */ + enum /*=>>java.lang.Object#``().*/ WeekDays /*<<=Enums.WeekDays#*/ { + /*=>>Enums.WeekDays.Monday.*/ /*=>>Enums.WeekDays.Tuesday.*/ /*=>>Enums.WeekDays.Wednesday.*/ /*=>>Enums.WeekDays.Thursday.*/ /*=>>Enums.WeekDays.Friday.*/ /*=>>Enums.WeekDays.Saturday.*/ /*=>>Enums.WeekDays.Sunday.*/ /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>scala.collection.IterableOnceOps#toArray().*/ /*=>>scala.runtime.EnumValues#values().*/ /*=>>Enums.WeekDays.$values.*/ /*=>>scala.reflect.ClassTag.apply().*/ /*=>>scala.reflect.ClassTag.*/ /*=>>scala.runtime.EnumValues#``().*/ /*=>>scala.collection.MapOps#apply().*/ /*=>>scala.runtime.EnumValues#fromName().*/ /*=>>Enums.WeekDays.valueOf().($name)*/ /*=>>java.util.NoSuchElementException#*/ /*=>>``.throw().*/ /*=>>java.lang.IllegalArgumentException#``(+1).*/ /*=>>java.lang.String#concat().*/ /*=>>Enums.WeekDays#``().*/ /*=>>Enums.WeekDays.$new().(_$ordinal)*/ /*=>>Enums.WeekDays.$new().($name)*/ /*=>>scala.runtime.EnumValues#register().*/ /*=>>local2*/ /*=>>local3*/ case Monday /*<<=Enums.WeekDays.Monday.*/ + /*<<=Enums.WeekDays.$values.*/ case Tuesday /*<<=Enums.WeekDays.Tuesday.*/ + case Wednesday /*<<=Enums.WeekDays.Wednesday.*/ + case Thursday /*<<=Enums.WeekDays.Thursday.*/ + case Friday /*<<=Enums.WeekDays.Friday.*/ + case Saturday /*<<=Enums.WeekDays.Saturday.*/ + case Sunday /*<<=Enums.WeekDays.Sunday.*/ } - enum /* ref java.lang.Object#``(). */ Maybe /* <<< Enums.Maybe# */ [+A] { /* <<< Enums.Maybe#``(). */ /* <<< Enums.Maybe#``().(A) */ /* <<< Enums.Maybe#(A) */ /* ref Enums.Maybe.None. */ - /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref Enums.Maybe#``(). */ /* ref Enums.Maybe.Just#(A) */ /* ref Enums.Maybe.Just#``(). */ /* ref Enums.Maybe.Just#copy().(A) */ /* ref Enums.Maybe.Just#copy().(value) */ /* ref Enums.Maybe.Just.apply().(A) */ /* ref Enums.Maybe.Just.apply().(value) */ /* ref Enums.Maybe.Just.unapply().(A) */ case Just /* <<< Enums.Maybe.Just# */ (value /* <<< Enums.Maybe.Just#``(). */ /* <<< Enums.Maybe.Just#``().(value) */ /* <<< Enums.Maybe.Just#(value) */ /* <<< Enums.Maybe.Just#copy().(value) */ /* <<< Enums.Maybe.Just.apply().(value) */ : A /* ref Enums.Maybe.Just#``().(A) */ /* ref Enums.Maybe.Just#(value) */ ) /* ref scala.Product# */ /* ref scala. */ /* ref _root_ */ /* ref scala.package.Serializable# */ - /* ref Enums.Maybe#``(). */ case /* <<< local4 */ None /* <<< Enums.Maybe.None. */ /* ref local5 */ /* ref local4 */ + enum /*=>>java.lang.Object#``().*/ Maybe /*<<=Enums.Maybe#*/ [+A] { /*<<=Enums.Maybe#``().*/ /*<<=Enums.Maybe#``().(A)*/ /*<<=Enums.Maybe#(A)*/ /*=>>Enums.Maybe.None.*/ + /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>Enums.Maybe#``().*/ /*=>>Enums.Maybe.Just#(A)*/ /*=>>Enums.Maybe.Just#``().*/ /*=>>Enums.Maybe.Just#copy().(A)*/ /*=>>Enums.Maybe.Just#copy().(value)*/ /*=>>Enums.Maybe.Just.apply().(A)*/ /*=>>Enums.Maybe.Just.apply().(value)*/ /*=>>Enums.Maybe.Just.unapply().(A)*/ case Just /*<<=Enums.Maybe.Just#*/ (value /*<<=Enums.Maybe.Just#``().*/ /*<<=Enums.Maybe.Just#``().(value)*/ /*<<=Enums.Maybe.Just#(value)*/ /*<<=Enums.Maybe.Just#copy().(value)*/ /*<<=Enums.Maybe.Just.apply().(value)*/ : A /*=>>Enums.Maybe.Just#``().(A)*/ /*=>>Enums.Maybe.Just#(value)*/ ) /*=>>scala.Product#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>scala.package.Serializable#*/ + /*=>>Enums.Maybe#``().*/ case /*<<=local4*/ None /*<<=Enums.Maybe.None.*/ /*=>>local5*/ /*=>>local4*/ } - enum /* ref java.lang.Object#``(). */ Tag /* <<< Enums.Tag# */ [A] { - /* <<< Enums.Tag#``(). */ /* <<< Enums.Tag#``().(A) */ /* <<< Enums.Tag#(A) */ /* ref Enums.Tag.IntTag. */ /* ref Enums.Tag.BooleanTag. */ /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ case IntTag /* <<< Enums.Tag.IntTag. */ extends Tag /* ref Enums.Tag# */ [I /* <<< local6 */ nt /* ref scala.Int# */ ] /* ref Enums.Tag#``(). */ /* ref local7 */ /* ref local6 */ - case BooleanTag /* <<< Enums.Tag.BooleanTag. */ extends Tag /* ref Enums.Tag# */ [B /* <<< local8 */ oolean /* ref scala.Boolean# */ ] /* ref Enums.Tag#``(). */ /* ref local9 */ /* ref local8 */ + enum /*=>>java.lang.Object#``().*/ Tag /*<<=Enums.Tag#*/ [A] { + /*<<=Enums.Tag#``().*/ /*<<=Enums.Tag#``().(A)*/ /*<<=Enums.Tag#(A)*/ /*=>>Enums.Tag.IntTag.*/ /*=>>Enums.Tag.BooleanTag.*/ /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ case IntTag /*<<=Enums.Tag.IntTag.*/ extends Tag /*=>>Enums.Tag#*/ [I /*<<=local6*/ nt /*=>>scala.Int#*/ ] /*=>>Enums.Tag#``().*/ /*=>>local7*/ /*=>>local6*/ + case BooleanTag /*<<=Enums.Tag.BooleanTag.*/ extends Tag /*=>>Enums.Tag#*/ [B /*<<=local8*/ oolean /*=>>scala.Boolean#*/ ] /*=>>Enums.Tag#``().*/ /*=>>local9*/ /*=>>local8*/ } - enum /* ref java.lang.Object#``(). */ =:= /* <<< Enums.`=:=`# */ [A, B] /* <<< Enums.`=:=`#``(). */ /* <<< Enums.`=:=`#``().(A) */ /* <<< Enums.`=:=`#(A) */ /* <<< Enums.`=:=`#``().(B) */ /* <<< Enums.`=:=`#(B) */ { - /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref Enums.`=:=`.Refl#``(). */ /* ref Enums.`=:=`.Refl#copy().(C) */ /* ref Enums.`=:=`.Refl.apply().(C) */ /* ref Enums.`=:=`.Refl.unapply().(C) */ case Refl /* <<< Enums.`=:=`.Refl# */ [C]() /* <<< Enums.`=:=`.Refl#``(). */ /* <<< Enums.`=:=`.Refl#``().(C) */ /* <<< Enums.`=:=`.Refl#(C) */ /* <<< Enums.`=:=`.Refl#copy().(C) */ /* <<< Enums.`=:=`.Refl.apply().(C) */ /* <<< Enums.`=:=`.Refl.unapply().(C) */ extends (C /* ref Enums.`=:=`.Refl#(C) */ /* ref Enums.`=:=`.Refl.apply().(C) */ =:= /* ref Enums.`=:=`# */ C /* ref Enums.`=:=`.Refl#(C) */ /* ref Enums.`=:=`.Refl.apply().(C) */ /* ref Enums.`=:=`#``(). */ ) /* ref scala.Product# */ /* ref scala. */ /* ref _root_ */ /* ref scala.package.Serializable# */ + enum /*=>>java.lang.Object#``().*/ =:= /*<<=Enums.`=:=`#*/ [A, B] /*<<=Enums.`=:=`#``().*/ /*<<=Enums.`=:=`#``().(A)*/ /*<<=Enums.`=:=`#(A)*/ /*<<=Enums.`=:=`#``().(B)*/ /*<<=Enums.`=:=`#(B)*/ { + /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>Enums.`=:=`.Refl#``().*/ /*=>>Enums.`=:=`.Refl#copy().(C)*/ /*=>>Enums.`=:=`.Refl.apply().(C)*/ /*=>>Enums.`=:=`.Refl.unapply().(C)*/ case Refl /*<<=Enums.`=:=`.Refl#*/ [C]() /*<<=Enums.`=:=`.Refl#``().*/ /*<<=Enums.`=:=`.Refl#``().(C)*/ /*<<=Enums.`=:=`.Refl#(C)*/ /*<<=Enums.`=:=`.Refl#copy().(C)*/ /*<<=Enums.`=:=`.Refl.apply().(C)*/ /*<<=Enums.`=:=`.Refl.unapply().(C)*/ extends (C /*=>>Enums.`=:=`.Refl#(C)*/ /*=>>Enums.`=:=`.Refl.apply().(C)*/ =:= /*=>>Enums.`=:=`#*/ C /*=>>Enums.`=:=`.Refl#(C)*/ /*=>>Enums.`=:=`.Refl.apply().(C)*/ /*=>>Enums.`=:=`#``().*/ ) /*=>>scala.Product#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>scala.package.Serializable#*/ } - def unwrap /* <<< Enums.unwrap(). */ [A /* <<< Enums.unwrap().(A) */ ,B /* <<< Enums.unwrap().(B) */ ](opt /* <<< Enums.unwrap().(opt) */ : Option /* ref scala.Option# */ [A /* ref Enums.unwrap().(A) */ ])(given ev /* <<< Enums.unwrap().(ev) */ : A /* ref Enums.unwrap().(A) */ =:= /* ref Enums.`=:=`# */ Option /* ref scala.Option# */ [B /* ref Enums.unwrap().(B) */ ]): Option /* ref scala.Option# */ [B /* ref Enums.unwrap().(B) */ ] = { - ev /* ref Enums.unwrap().(ev) */ match { - case =:= /* ref Enums.`=:=`. */ .Refl /* ref Enums.`=:=`.Refl. */ () => opt /* ref Enums.unwrap().(opt) */ .flatMap /* ref scala.Option#flatMap(). */ (identity /* ref scala.Predef.identity(). */ [Option /* ref scala.Option# */ [B /* ref Enums.unwrap().(B) */ ]]) + def unwrap /*<<=Enums.unwrap().*/ [A /*<<=Enums.unwrap().(A)*/ ,B /*<<=Enums.unwrap().(B)*/ ](opt /*<<=Enums.unwrap().(opt)*/ : Option /*=>>scala.Option#*/ [A /*=>>Enums.unwrap().(A)*/ ])(given ev /*<<=Enums.unwrap().(ev)*/ : A /*=>>Enums.unwrap().(A)*/ =:= /*=>>Enums.`=:=`#*/ Option /*=>>scala.Option#*/ [B /*=>>Enums.unwrap().(B)*/ ]): Option /*=>>scala.Option#*/ [B /*=>>Enums.unwrap().(B)*/ ] = { + ev /*=>>Enums.unwrap().(ev)*/ match { + case =:= /*=>>Enums.`=:=`.*/ .Refl /*=>>Enums.`=:=`.Refl.*/ () => opt /*=>>Enums.unwrap().(opt)*/ .flatMap /*=>>scala.Option#flatMap().*/ (identity /*=>>scala.Predef.identity().*/ [Option /*=>>scala.Option#*/ [B /*=>>Enums.unwrap().(B)*/ ]]) } } - enum Planet /* <<< Enums.Planet# */ (mass: /* <<< Enums.Planet#``(). */ /* <<< Enums.Planet#``().(mass) */ /* <<< Enums.Planet#(mass) */ Double /* ref scala.Double# */ , radius /* <<< Enums.Planet#``().(radius) */ /* <<< Enums.Planet#(radius) */ : Double /* ref scala.Double# */ ) extends java /* ref java. */ .lang /* ref java.lang. */ .Enum /* ref java.lang.Enum# */ [Planet /* ref Enums.Planet# */ ] /* ref java.lang.Enum#``(). */ /* ref Enums.Planet.Mercury. */ /* ref Enums.Planet.Venus. */ /* ref Enums.Planet.Earth. */ /* ref Enums.Planet.Mars. */ /* ref Enums.Planet.Jupiter. */ /* ref Enums.Planet.Saturn. */ /* ref Enums.Planet.Uranus. */ /* ref Enums.Planet.Neptune. */ { - private final val G /* <<< Enums.Planet#G. */ = 6.67300E-11 - def surfaceGravity /* <<< Enums.Planet#surfaceGravity(). */ = G /* ref Enums.Planet#G. */ * /* ref scala.Double#`*`(+0). */ mass /* ref Enums.Planet#(mass) */ / /* ref scala.Double#`.`(+0). */ (radius /* ref Enums.Planet#(radius) */ * /* ref scala.Double#`*`(+0). */ radius /* ref Enums.Planet#(radius) */ ) - def surfaceWeight /* <<< Enums.Planet#surfaceWeight(). */ (otherMass /* <<< Enums.Planet#surfaceWeight().(otherMass) */ : Double /* ref scala.Double# */ ) = otherMass /* ref Enums.Planet#surfaceWeight().(otherMass) */ * /* ref scala.Double#`*`(+0). */ surfaceGravity /* ref Enums.Planet#surfaceGravity(). */ + enum Planet /*<<=Enums.Planet#*/ (mass: /*<<=Enums.Planet#``().*/ /*<<=Enums.Planet#``().(mass)*/ /*<<=Enums.Planet#(mass)*/ Double /*=>>scala.Double#*/ , radius /*<<=Enums.Planet#``().(radius)*/ /*<<=Enums.Planet#(radius)*/ : Double /*=>>scala.Double#*/ ) extends java /*=>>java.*/ .lang /*=>>java.lang.*/ .Enum /*=>>java.lang.Enum#*/ [Planet /*=>>Enums.Planet#*/ ] /*=>>java.lang.Enum#``().*/ /*=>>Enums.Planet.Mercury.*/ /*=>>Enums.Planet.Venus.*/ /*=>>Enums.Planet.Earth.*/ /*=>>Enums.Planet.Mars.*/ /*=>>Enums.Planet.Jupiter.*/ /*=>>Enums.Planet.Saturn.*/ /*=>>Enums.Planet.Uranus.*/ /*=>>Enums.Planet.Neptune.*/ { + private final val G /*<<=Enums.Planet#G.*/ = 6.67300E-11 + def surfaceGravity /*<<=Enums.Planet#surfaceGravity().*/ = G /*=>>Enums.Planet#G.*/ * /*=>>scala.Double#`*`(+6).*/ mass /*=>>Enums.Planet#(mass)*/ / /*=>>scala.Double#`.`(+6).*/ (radius /*=>>Enums.Planet#(radius)*/ * /*=>>scala.Double#`*`(+6).*/ radius /*=>>Enums.Planet#(radius)*/ ) + def surfaceWeight /*<<=Enums.Planet#surfaceWeight().*/ (otherMass /*<<=Enums.Planet#surfaceWeight().(otherMass)*/ : Double /*=>>scala.Double#*/ ) = otherMass /*=>>Enums.Planet#surfaceWeight().(otherMass)*/ * /*=>>scala.Double#`*`(+6).*/ surfaceGravity /*=>>Enums.Planet#surfaceGravity().*/ - /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ case Mercury /* <<< Enums.Planet.$values. */ /* <<< Enums.Planet.Mercury. */ extends /* ref scala.collection.IterableOnceOps#toArray(). */ /* ref scala.runtime.EnumValues#values(). */ /* ref Enums.Planet.$values. */ /* ref scala.reflect.ClassTag.apply(). */ /* ref scala.reflect.ClassTag. */ /* ref scala.runtime.EnumValues#``(). */ /* ref scala.collection.MapOps#apply(). */ /* ref scala.runtime.EnumValues#fromName(). */ /* ref Enums.Planet.valueOf().($name) */ /* ref java.util.NoSuchElementException# */ /* ref ``.throw(). */ /* ref java.lang.IllegalArgumentException#``(+2). */ /* ref java.lang.String#concat(). */ Plane /* <<< local10 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (3.303e+23, 2.4397e6) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local11 */ /* ref local10 */ - case Venus /* <<< Enums.Planet.Venus. */ extends Plane /* <<< local12 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (4.869e+24, 6.0518e6) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local13 */ /* ref local12 */ - case Earth /* <<< Enums.Planet.Earth. */ extends Plane /* <<< local14 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (5.976e+24, 6.37814e6) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local15 */ /* ref local14 */ - case Mars /* <<< Enums.Planet.Mars. */ extends Plane /* <<< local16 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (6.421e+23, 3.3972e6) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local17 */ /* ref local16 */ - case Jupiter /* <<< Enums.Planet.Jupiter. */ extends Plane /* <<< local18 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (1.9e+27, 7.1492e7) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local19 */ /* ref local18 */ - case Saturn /* <<< Enums.Planet.Saturn. */ extends Plane /* <<< local20 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (5.688e+26, 6.0268e7) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local21 */ /* ref local20 */ - case Uranus /* <<< Enums.Planet.Uranus. */ extends Plane /* <<< local22 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (8.686e+25, 2.5559e7) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local23 */ /* ref local22 */ - case Neptune /* <<< Enums.Planet.Neptune. */ extends Plane /* <<< local24 */ t /* ref Enums.Planet# */ /* ref Enums.Planet#``(). */ (1.024e+26, 2.4746e7) /* ref scala.runtime.EnumValues#register(). */ /* ref Enums.Planet.$values. */ /* ref local25 */ /* ref local24 */ + /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ case Mercury /*<<=Enums.Planet.$values.*/ /*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.collection.IterableOnceOps#toArray().*/ /*=>>scala.runtime.EnumValues#values().*/ /*=>>Enums.Planet.$values.*/ /*=>>scala.reflect.ClassTag.apply().*/ /*=>>scala.reflect.ClassTag.*/ /*=>>scala.runtime.EnumValues#``().*/ /*=>>scala.collection.MapOps#apply().*/ /*=>>scala.runtime.EnumValues#fromName().*/ /*=>>Enums.Planet.valueOf().($name)*/ /*=>>java.util.NoSuchElementException#*/ /*=>>``.throw().*/ /*=>>java.lang.IllegalArgumentException#``(+1).*/ /*=>>java.lang.String#concat().*/ Plane /*<<=local10*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (3.303e+23, 2.4397e6) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local11*/ /*=>>local10*/ + case Venus /*<<=Enums.Planet.Venus.*/ extends Plane /*<<=local12*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (4.869e+24, 6.0518e6) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local13*/ /*=>>local12*/ + case Earth /*<<=Enums.Planet.Earth.*/ extends Plane /*<<=local14*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (5.976e+24, 6.37814e6) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local15*/ /*=>>local14*/ + case Mars /*<<=Enums.Planet.Mars.*/ extends Plane /*<<=local16*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (6.421e+23, 3.3972e6) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local17*/ /*=>>local16*/ + case Jupiter /*<<=Enums.Planet.Jupiter.*/ extends Plane /*<<=local18*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (1.9e+27, 7.1492e7) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local19*/ /*=>>local18*/ + case Saturn /*<<=Enums.Planet.Saturn.*/ extends Plane /*<<=local20*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (5.688e+26, 6.0268e7) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local21*/ /*=>>local20*/ + case Uranus /*<<=Enums.Planet.Uranus.*/ extends Plane /*<<=local22*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (8.686e+25, 2.5559e7) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local23*/ /*=>>local22*/ + case Neptune /*<<=Enums.Planet.Neptune.*/ extends Plane /*<<=local24*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (1.024e+26, 2.4746e7) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local25*/ /*=>>local24*/ } } diff --git a/tests/semanticdb/Givens.expect.scala b/tests/semanticdb/Givens.expect.scala new file mode 100644 index 000000000000..6e06a0a648e8 --- /dev/null +++ b/tests/semanticdb/Givens.expect.scala @@ -0,0 +1,21 @@ +package a +package b + +object /*=>>java.lang.Object#``().*/ Givens /*<<=a.b.Givens.*/ + + /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>a.b.Givens.*/ given /*=>>java.lang.Object#``().*/ :[A](any: A) + de /*<<=a.b.Givens.given_sayHello_of_A.*/ /*=>>a.b.Givens.given_sayHello_of_A.*/ /*<<=a.b.Givens.given_sayHello_of_A.sayHello().(A)*/ /*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*/ /*=>>a.b.Givens.given_sayHello_of_A.sayHello().(A)*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ f sayHello /*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s" /*=>>scala.StringContext.*/ /*=>>scala.*/ /*=>>_root_*/ Hello, I am $any /*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*/ /*=>>scala.StringContext#s().*/ " + + val hello1 /*<<=a.b.Givens.hello1.*/ = /*=>>a.b.Givens.given_sayHello_of_A.sayHello().*/ /*=>>a.b.Givens.given_sayHello_of_A.*/ 1.sayHello + + trait Monoid /*<<=a.b.Givens.Monoid#*/ [A] + /*<<=a.b.Givens.Monoid#``().*/ /*<<=a.b.Givens.Monoid#``().(A)*/ /*<<=a.b.Givens.Monoid#(A)*/ def empty /*<<=a.b.Givens.Monoid#empty().*/ : A /*=>>a.b.Givens.Monoid#(A)*/ + def (x: A) /*<<=a.b.Givens.Monoid#combine().*/ /*<<=a.b.Givens.Monoid#combine().(x)*/ /*=>>a.b.Givens.Monoid#(A)*/ combine (y /*<<=a.b.Givens.Monoid#combine().(y)*/ : A /*=>>a.b.Givens.Monoid#(A)*/ ): A /*=>>a.b.Givens.Monoid#(A)*/ + + given /*=>>java.lang.Object#``().*/ /*=>>a.b.Givens.given_Monoid_String.*/ Monoid /*=>>a.b.Givens.Monoid#*/ [String] + /*<<=a.b.Givens.given_Monoid_String.*/ /*=>>scala.Predef.String#*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ def empty /*<<=a.b.Givens.given_Monoid_String.empty().*/ = "" + def (x: Str /*<<=a.b.Givens.given_Monoid_String.combine().*/ /*<<=a.b.Givens.given_Monoid_String.combine().(x)*/ ing /*=>>scala.Predef.String#*/ ) combine (y /*<<=a.b.Givens.given_Monoid_String.combine().(y)*/ : String /*=>>scala.Predef.String#*/ ) = x /*=>>a.b.Givens.given_Monoid_String.combine().(x)*/ + /*=>>java.lang.String#`+`().*/ y /*=>>a.b.Givens.given_Monoid_String.combine().(y)*/ + + inline given int2String /*<<=a.b.Givens.int2String().*/ : Conversion /*=>>scala.Conversion#*/ [Int /*=>>scala.Int#*/ , String /*=>>scala.Predef.String#*/ ] = _ /*=>>local0*/ .toString /*=>>scala.Any#toString().*/ + + def foo /*<<=a.b.Givens.foo().*/ [A /*<<=a.b.Givens.foo().(A)*/ ](given A /*<<=a.b.Givens.foo().(A)*/ : Monoid /*=>>a.b.Givens.Monoid#*/ [A /*=>>a.b.Givens.foo().(A)*/ ]): A /*=>>a.b.Givens.foo().(A)*/ = A /*=>>a.b.Givens.foo().(A)*/ .combine /*=>>a.b.Givens.Monoid#combine().*/ (A /*=>>a.b.Givens.foo().(A)*/ .empty /*=>>a.b.Givens.Monoid#empty().*/ )(A /*=>>a.b.Givens.foo().(A)*/ .empty /*=>>a.b.Givens.Monoid#empty().*/ ) diff --git a/tests/semanticdb/Givens.scala b/tests/semanticdb/Givens.scala new file mode 100644 index 000000000000..b654447e7244 --- /dev/null +++ b/tests/semanticdb/Givens.scala @@ -0,0 +1,21 @@ +package a +package b + +object Givens + + given :[A](any: A) + def sayHello = s"Hello, I am $any" + + val hello1 = 1.sayHello + + trait Monoid[A] + def empty: A + def (x: A) combine (y: A): A + + given Monoid[String] + def empty = "" + def (x: String) combine (y: String) = x + y + + inline given int2String: Conversion[Int, String] = _.toString + + def foo[A](given A: Monoid[A]): A = A.combine(A.empty)(A.empty) diff --git a/tests/semanticdb/NewModifiers.expect.scala b/tests/semanticdb/NewModifiers.expect.scala index 124ec2a0b9df..fea243eecab6 100644 --- a/tests/semanticdb/NewModifiers.expect.scala +++ b/tests/semanticdb/NewModifiers.expect.scala @@ -1,4 +1,4 @@ - /* ref _empty_ */ object /* ref java.lang.Object#``(). */ NewModifiers /* <<< NewModifiers. */ { - /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref NewModifiers. */ inline val foo /* <<< NewModifiers.foo. */ = "foo" - opaque type A /* <<< NewModifiers.A# */ = Int /* ref scala.Int# */ +object /*=>>java.lang.Object#``().*/ NewModifiers /*<<=NewModifiers.*/ { + /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>NewModifiers.*/ inline val foo /*<<=NewModifiers.foo.*/ = "foo" + opaque type A /*<<=NewModifiers.A#*/ = Int /*=>>scala.Int#*/ } diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala index 4c9daa14e947..1940a6c92f95 100644 --- a/tests/semanticdb/semanticdb-extract.expect.scala +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -1,18 +1,18 @@ - /* ref _empty_ */ object /* ref java.lang.Object#``(). */ A /* <<< A. */ { +object /*=>>java.lang.Object#``().*/ A /*<<=A.*/ { - /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref A. */ def foo /* <<< A.foo(+1). */ (x /* <<< A.foo(+1).(x) */ : Int /* ref scala.Int# */ ) = () - def foo /* <<< A.foo(+0). */ (): Unit /* ref scala.Unit# */ = () + /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>A.*/ def foo /*<<=A.foo().*/ (x /*<<=A.foo().(x)*/ : Int /*=>>scala.Int#*/ ) = () + def foo /*<<=A.foo(+1).*/ (): Unit /*=>>scala.Unit#*/ = () - foo /* ref A.foo(+1). */ (1) - foo /* ref A.foo(+0). */ () + foo /*=>>A.foo().*/ (1) + foo /*=>>A.foo(+1).*/ () - "".substring /* ref java.lang.String#substring(+1). */ (1) - "".substring /* ref java.lang.String#substring(+0). */ (1, 2) + "".substring /*=>>java.lang.String#substring().*/ (1) + "".substring /*=>>java.lang.String#substring(+1).*/ (1, 2) - List /* ref scala.package.List. */ /* ref scala.collection.IterableFactory#apply(). */ (1, 2) - List /* ref scala.package.List. */ .apply /* ref scala.collection.IterableFactory#apply(). */ () - List /* ref scala.package.List. */ .`apply` /* ref scala.collection.IterableFactory#apply(). */ () - println /* ref scala.Predef.println(+0). */ (1 + /* ref scala.Int#`+`(+3). */ 2) + List /*=>>scala.package.List.*/ /*=>>scala.collection.IterableFactory#apply().*/ (1, 2) + List /*=>>scala.package.List.*/ .apply /*=>>scala.collection.IterableFactory#apply().*/ () + List /*=>>scala.package.List.*/ .`apply` /*=>>scala.collection.IterableFactory#apply().*/ () + println /*=>>scala.Predef.println(+1).*/ (1 + /*=>>scala.Int#`+`(+4).*/ 2) - /* ref A.Foo#``(). */ /* ref A.Foo#copy().(x) */ /* ref A.Foo.apply().(x) */ case class /* ref java.lang.Object#``(). */ Foo /* <<< A.Foo# */ (x: In /* <<< A.Foo#``(). */ /* <<< A.Foo#``().(x) */ /* <<< A.Foo#(x) */ /* <<< A.Foo#copy().(x) */ /* <<< A.Foo.apply().(x) */ t /* ref scala.Int# */ /* ref A.Foo#(x) */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ ) /* ref scala.Product# */ /* ref scala. */ /* ref _root_ */ /* ref scala.package.Serializable# */ + /*=>>A.Foo#``().*/ /*=>>A.Foo#copy().(x)*/ /*=>>A.Foo.apply().(x)*/ case class /*=>>java.lang.Object#``().*/ Foo /*<<=A.Foo#*/ (x: In /*<<=A.Foo#``().*/ /*<<=A.Foo#``().(x)*/ /*<<=A.Foo#(x)*/ /*<<=A.Foo#copy().(x)*/ /*<<=A.Foo.apply().(x)*/ t /*=>>scala.Int#*/ /*=>>A.Foo#(x)*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ ) /*=>>scala.Product#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>scala.package.Serializable#*/ } \ No newline at end of file diff --git a/tests/semanticdb/toplevel.expect.scala b/tests/semanticdb/toplevel.expect.scala index 17a2401a1801..6dbafecf4d21 100644 --- a/tests/semanticdb/toplevel.expect.scala +++ b/tests/semanticdb/toplevel.expect.scala @@ -1,6 +1,4 @@ - /* ref _empty_ */ /* ref java.lang.Object#``(). */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ /* ref toplevel$package. */ inline val a = " /* <<< toplevel$package. */ /* <<< toplevel$package.a. */ " -def (x: Int /* <<< toplevel$package.combine(). */ /* <<< toplevel$package.combine().(x) */ /* ref scala.Int# */ ) combine (y /* <<< toplevel$package.combine().(y) */ : Int /* ref scala.Int# */ ) = x /* ref toplevel$package.combine().(x) */ + /* ref scala.Int#`+`(+3). */ y /* ref toplevel$package.combine().(y) */ -given /* ref java.lang.Object#``(). */ [A](any: A) { - def /* <<< toplevel$package.given_sayHello_of_A. */ /* ref toplevel$package.given_sayHello_of_A. */ /* <<< toplevel$package.given_sayHello_of_A.sayHello().(A) */ /* <<< toplevel$package.given_sayHello_of_A.sayHello().(any) */ /* ref toplevel$package.given_sayHello_of_A.sayHello().(A) */ /* ref scala.package.Serializable# */ /* ref scala. */ /* ref _root_ */ sayHello /* <<< toplevel$package.given_sayHello_of_A.sayHello(). */ = s" /* ref scala.StringContext. */ /* ref scala. */ /* ref _root_ */ Hello, I am $any /* ref toplevel$package.given_sayHello_of_A.sayHello().(any) */ /* ref scala.StringContext#s(+1). */ " -} -val hello1 /* <<< toplevel$package.hello1. */ = /* ref toplevel$package.given_sayHello_of_A.sayHello(). */ /* ref toplevel$package.given_sayHello_of_A. */ 1.sayHello + /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>toplevel$package.*/ inline val a = " /*<<=toplevel$package.*/ /*<<=toplevel$package.a.*/ " +def (x: Int /*<<=toplevel$package.combine().*/ /*<<=toplevel$package.combine().(x)*/ /*=>>scala.Int#*/ ) combine (y /*<<=toplevel$package.combine().(y)*/ : Int /*=>>scala.Int#*/ ) = x /*=>>toplevel$package.combine().(x)*/ + /*=>>scala.Int#`+`(+4).*/ y /*=>>toplevel$package.combine().(y)*/ +def combine /*<<=toplevel$package.combine(+1).*/ (x /*<<=toplevel$package.combine(+1).(x)*/ : Int /*=>>scala.Int#*/ , y /*<<=toplevel$package.combine(+1).(y)*/ : Int /*=>>scala.Int#*/ , z /*<<=toplevel$package.combine(+1).(z)*/ : Int /*=>>scala.Int#*/ ) = x /*=>>toplevel$package.combine(+1).(x)*/ + /*=>>scala.Int#`+`(+4).*/ y /*=>>toplevel$package.combine(+1).(y)*/ + /*=>>scala.Int#`+`(+4).*/ z /*=>>toplevel$package.combine(+1).(z)*/ +def combine /*<<=toplevel$package.combine(+2).*/ = 0 diff --git a/tests/semanticdb/toplevel.scala b/tests/semanticdb/toplevel.scala index e9f761a6ee13..990d4102fcc5 100644 --- a/tests/semanticdb/toplevel.scala +++ b/tests/semanticdb/toplevel.scala @@ -1,6 +1,4 @@ inline val a = "" def (x: Int) combine (y: Int) = x + y -given [A](any: A) { - def sayHello = s"Hello, I am $any" -} -val hello1 = 1.sayHello +def combine(x: Int, y: Int, z: Int) = x + y + z +def combine = 0 From 05b41b4f70fb69d87d54e84d313ca5daef27fb9e Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 17 Oct 2019 15:40:29 +0200 Subject: [PATCH 024/107] register usage for path parts of an import statement --- .../dotc/semanticdb/ExtractSemanticDB.scala | 8 +++ .../tools/dotc/semanticdb/Semanticdbs.scala | 4 +- .../com/javacp/annot/ClassAnnotation.java | 10 +++ .../javacp/annot/ConstructorAnnotation.java | 10 +++ .../com/javacp/annot/FieldAnnotation.java | 10 +++ .../com/javacp/annot/InterfaceAnnotation.java | 10 +++ .../com/javacp/annot/LocalAnnotation.java | 10 +++ .../com/javacp/annot/MacroAnnotation.java | 10 +++ .../com/javacp/annot/MethodAnnotation.java | 10 +++ .../com/javacp/annot/ObjectAnnotation.java | 10 +++ .../com/javacp/annot/PackageAnnotation.java | 10 +++ .../javacp/annot/PackageObjectAnnotation.java | 10 +++ .../com/javacp/annot/ParameterAnnotation.java | 10 +++ .../javacp/annot/SelfParameterAnnotation.java | 10 +++ .../com/javacp/annot/TraitAnnotation.java | 10 +++ .../com/javacp/annot/TypeAnnotation.java | 10 +++ .../javacp/annot/TypeParameterAnnotation.java | 10 +++ .../annot/usage/AnnotatedInterface.java | 4 ++ .../javacp/annot/usage/AnnotatedPackage.java | 5 ++ tests/semanticdb/Access.expect.scala | 16 ++--- tests/semanticdb/Advanced.expect.scala | 42 ++++++++++++ tests/semanticdb/Advanced.scala | 42 ++++++++++++ tests/semanticdb/Annotations.expect.scala | 38 +++++++++++ tests/semanticdb/Annotations.scala | 38 +++++++++++ tests/semanticdb/Definitions.expect.scala | 12 ++-- tests/semanticdb/Enums.expect.scala | 68 +++++++++---------- tests/semanticdb/Givens.expect.scala | 24 +++---- tests/semanticdb/NewModifiers.expect.scala | 6 +- .../semanticdb-extract.expect.scala | 24 +++---- tests/semanticdb/toplevel.expect.scala | 9 +-- tests/semanticdb/toplevel.scala | 1 + 31 files changed, 410 insertions(+), 81 deletions(-) create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java create mode 100644 tests/semanticdb/Advanced.expect.scala create mode 100644 tests/semanticdb/Advanced.scala create mode 100644 tests/semanticdb/Annotations.expect.scala create mode 100644 tests/semanticdb/Annotations.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 1a40c63fbb11..c6fe42906a39 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -160,6 +160,13 @@ class ExtractSemanticDB extends Phase { registerOccurrence(sym, span, SymbolOccurrence.Role.REFERENCE) override def traverse(tree: Tree)(given ctx: Context): Unit = + def registerPath(expr: Tree): Unit = expr match + case t @ Select(expr, _) => + registerUse(t.symbol, t.span) + registerPath(expr) + + case _ => + tree match case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree @@ -185,6 +192,7 @@ class ExtractSemanticDB extends Phase { if imported != nme.WILDCARD then for alt <- tree.expr.tpe.member(imported).alternatives do registerUse(alt.symbol, sel.imported.span) + registerPath(tree.expr) case tree: Inlined => traverse(tree.call) case tree: PackageDef => tree.stats.foreach(traverse) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index 4f466fe44f11..be549291ea07 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -67,10 +67,10 @@ object Semanticdbs { sourceFile.lineToOffset(range.endLine) + range.endCharacter ) sb.append(doc.text.substring(offset, end)) - .append(" /*") + .append("/*") .append(if (occ.role.isDefinition) "<<=" else "=>>") .append(occ.symbol.replace('/', '.')) - .append("*/ ") + .append("*/") offset = end } sb.append(doc.text.substring(offset)) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java new file mode 100644 index 000000000000..4d676ab287f3 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface ClassAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java new file mode 100644 index 000000000000..454e66d4098c --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.CONSTRUCTOR) +public @interface ConstructorAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java new file mode 100644 index 000000000000..d86048627786 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.FIELD) +public @interface FieldAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java new file mode 100644 index 000000000000..a4b76a917588 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface InterfaceAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java new file mode 100644 index 000000000000..833661dc6e0b --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.LOCAL_VARIABLE) +public @interface LocalAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java new file mode 100644 index 000000000000..e82c63e3f49e --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.METHOD) +public @interface MacroAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java new file mode 100644 index 000000000000..37ab7a2655ea --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.METHOD) +public @interface MethodAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java new file mode 100644 index 000000000000..ae7cfe8f64ef --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface ObjectAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java new file mode 100644 index 000000000000..ec51d2e89e83 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.PACKAGE) +public @interface PackageAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java new file mode 100644 index 000000000000..50eedab9ed64 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.PACKAGE) +public @interface PackageObjectAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java new file mode 100644 index 000000000000..9ccbdf682fe5 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.PARAMETER) +public @interface ParameterAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java new file mode 100644 index 000000000000..e2446aebb22c --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.PARAMETER) +public @interface SelfParameterAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java new file mode 100644 index 000000000000..9cccb6293489 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface TraitAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java new file mode 100644 index 000000000000..d3770564771b --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE) +public @interface TypeAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java new file mode 100644 index 000000000000..05f7af7198fd --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java @@ -0,0 +1,10 @@ +package com.javacp.annot; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.annotation.ElementType; + +@Retention(RetentionPolicy.CLASS) +@Target(ElementType.TYPE_PARAMETER) +public @interface TypeParameterAnnotation{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java new file mode 100644 index 000000000000..0f161ae588e8 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java @@ -0,0 +1,4 @@ +package com.javacp.annot.usage; + +@com.javacp.annot.InterfaceAnnotation +public @interface AnnotatedInterface{} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java new file mode 100644 index 000000000000..c3473d17e878 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java @@ -0,0 +1,5 @@ +// compiler crash +// @annot.ParameterAnnotation +package com.javacp.annot.usage; + +public class AnnotatedPackage{} diff --git a/tests/semanticdb/Access.expect.scala b/tests/semanticdb/Access.expect.scala index 1630c45f36ca..354ac473ee85 100644 --- a/tests/semanticdb/Access.expect.scala +++ b/tests/semanticdb/Access.expect.scala @@ -1,11 +1,11 @@ package example -class /*=>>java.lang.Object#``().*/ Access /*<<=example.Access#*/ { - private def m1 /*<<=example.Access#m1().*/ = ??? /*=>>scala.Predef.`???`().*/ - private[this] def m2 /*<<=example.Access#m2().*/ = ??? /*=>>scala.Predef.`???`().*/ - private[Access] def m3 /*<<=example.Access#m3().*/ = ??? /*=>>scala.Predef.`???`().*/ - protected def m4 /*<<=example.Access#m4().*/ = ??? /*=>>scala.Predef.`???`().*/ - protected[this] def m5 /*<<=example.Access#m5().*/ = ??? /*=>>scala.Predef.`???`().*/ - protected[example] def m6 /*<<=example.Access#m6().*/ = ??? /*=>>scala.Predef.`???`().*/ - def m7 /*<<=example.Access#m7().*/ = ??? /*=>>scala.Predef.`???`().*/ +class /*=>>java.lang.Object#``().*/Access/*<<=example.Access#*/ { + private def m1/*<<=example.Access#m1().*/ = ???/*=>>scala.Predef.`???`().*/ + private[this] def m2/*<<=example.Access#m2().*/ = ???/*=>>scala.Predef.`???`().*/ + private[Access] def m3/*<<=example.Access#m3().*/ = ???/*=>>scala.Predef.`???`().*/ + protected def m4/*<<=example.Access#m4().*/ = ???/*=>>scala.Predef.`???`().*/ + protected[this] def m5/*<<=example.Access#m5().*/ = ???/*=>>scala.Predef.`???`().*/ + protected[example] def m6/*<<=example.Access#m6().*/ = ???/*=>>scala.Predef.`???`().*/ + def m7/*<<=example.Access#m7().*/ = ???/*=>>scala.Predef.`???`().*/ } diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/Advanced.expect.scala new file mode 100644 index 000000000000..afb1716bc016 --- /dev/null +++ b/tests/semanticdb/Advanced.expect.scala @@ -0,0 +1,42 @@ +package advanced + +import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ +import scala.language/*=>>scalaShadowing.language.*/.reflectiveCalls/*=>>scalaShadowing.language.reflectiveCalls.*/ + +import scala.reflect/*=>>scala.reflect.*/.Selectable/*=>>scala.reflect.Selectable.*/.reflectiveSelectable/*=>>scala.reflect.Selectable.reflectiveSelectable().*/ + +class /*=>>java.lang.Object#``().*/C/*<<=advanced.C#*/[T] { +/*<<=advanced.C#``().*//*<<=advanced.C#``().(T)*//*<<=advanced.C#(T)*/ def t/*<<=advanced.C#t().*/: T/*=>>advanced.C#(T)*/ = ???/*=>>scala.Predef.`???`().*/ +} + +class /*=>>java.lang.Object#``().*/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#*/ } = /*=>>java.lang.Object#``().*/new {/*<<=local2*/ val x/*<<=local3*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ }/*=>>local4*//*=>>local2*/ + def s3/*<<=advanced.Structural#s3().*/: { def m/*<<=local5*/(x/*<<=local6*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ } = /*=>>java.lang.Object#``().*/new {/*<<=local7*/ def m/*<<=local8*/(x/*<<=local9*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ }/*=>>local10*//*=>>local7*/ +} + +class /*=>>java.lang.Object#``().*/Wildcards/*<<=advanced.Wildcards#*/ { + def e1/*<<=advanced.Wildcards#e1().*/: List/*=>>scala.package.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ +} + +object /*=>>java.lang.Object#``().*/Test/*<<=advanced.Test.*/ { + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>advanced.Test.*/val s/*<<=advanced.Test.s.*/ = new Structural/*=>>advanced.Structural#*//*=>>advanced.Structural#``().*/ + val s1/*<<=advanced.Test.s1.*/ = s/*=>>advanced.Test.s.*/.s1/*=>>advanced.Structural#s1().*/ + val s1x/*<<=advanced.Test.s1x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s1/*=>>advanced.Structural#s1().*//*=>>scala.Selectable#selectDynamic().*/.x + val s2/*<<=advanced.Test.s2.*/ = s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*/ + val s2x/*<<=advanced.Test.s2x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*//*=>>scala.Selectable#selectDynamic().*/.x + val s3/*<<=advanced.Test.s3.*/ = s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*/ + val s3x/*<<=advanced.Test.s3x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*//*=>>scala.Selectable#applyDynamic().*/.m/*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>java.lang.Integer.TYPE.*//*=>>java.lang.Integer.*/(???/*=>>scala.Predef.`???`().*/) + + val e/*<<=advanced.Test.e.*/ = new Wildcards/*=>>advanced.Wildcards#*//*=>>advanced.Wildcards#``().*/ + val e1/*<<=advanced.Test.e1.*/ = e/*=>>advanced.Test.e.*/.e1/*=>>advanced.Wildcards#e1().*/ + val e1x/*<<=advanced.Test.e1x.*/ = e/*=>>advanced.Test.e.*/.e1/*=>>advanced.Wildcards#e1().*/.head/*=>>scala.collection.IterableOps#head().*/ + + { + (???/*=>>scala.Predef.`???`().*/ : Any/*=>>scala.Any#*/) match { + case e3/*<<=local11*/: List/*=>>scala.package.List#*/[_/*<<=local12*/] => + val e3x/*<<=local13*/ = e3/*=>>local11*/.head/*=>>scala.collection.IterableOps#head().*/ + () + } + } +} diff --git a/tests/semanticdb/Advanced.scala b/tests/semanticdb/Advanced.scala new file mode 100644 index 000000000000..3e14a46cb194 --- /dev/null +++ b/tests/semanticdb/Advanced.scala @@ -0,0 +1,42 @@ +package advanced + +import scala.language.higherKinds +import scala.language.reflectiveCalls + +import scala.reflect.Selectable.reflectiveSelectable + +class C[T] { + def t: T = ??? +} + +class Structural { + def s1: { val x: Int } = ??? + def s2: { val x: Int } = new { val x: Int = ??? } + def s3: { def m(x: Int): Int } = new { def m(x: Int): Int = ??? } +} + +class Wildcards { + def e1: List[_] = ??? +} + +object Test { + val s = new Structural + val s1 = s.s1 + val s1x = s.s1.x + val s2 = s.s2 + val s2x = s.s2.x + val s3 = s.s3 + val s3x = s.s3.m(???) + + val e = new Wildcards + val e1 = e.e1 + val e1x = e.e1.head + + { + (??? : Any) match { + case e3: List[_] => + val e3x = e3.head + () + } + } +} diff --git a/tests/semanticdb/Annotations.expect.scala b/tests/semanticdb/Annotations.expect.scala new file mode 100644 index 000000000000..57437c3fae74 --- /dev/null +++ b/tests/semanticdb/Annotations.expect.scala @@ -0,0 +1,38 @@ +package annot + +import com.javacp.annot._ +import scala.annotation.meta._ +import scala.language/*=>>scalaShadowing.language.*/.experimental/*=>>scalaShadowing.language.experimental.*/.macros/*=>>scalaShadowing.language.experimental.macros.*/ + +@ClassAnnotation +class /*=>>java.lang.Object#``().*/Annotations/*<<=annot.Annotations#*/[@Type/*<<=annot.Annotations#``().*/ParameterAnnotation T/*<<=annot.Annotations#``().(T)*//*<<=annot.Annotations#(T)*/](@ParameterAnnotation x/*<<=annot.Annotations#``().(x)*//*<<=annot.Annotations#(x)*/: T/*=>>annot.Annotations#``().(T)*/) { self/*<<=annot.Annotations#self.*/: AnyRef/*=>>scala.AnyRef#*/ => + @FieldAnnotation + val field/*<<=annot.Annotations#field.*/ = 42 + + @MethodAnnotation + def method/*<<=annot.Annotations#method().*/ = { + @LocalAnnotation + val local/*<<=local0*/ = 42 + local/*=>>local0*/ + } + @TypeAnnotation + type S/*<<=annot.Annotations#S#*/ +} + +class /*=>>java.lang.Object#``().*/B/*<<=annot.B#*/ @Cons/*<<=annot.B#``().*/tructorAnnotation()(x/*<<=annot.B#``().(x)*//*<<=annot.B#(x)*/: Int/*=>>scala.Int#*/) { + @ConstructorAnnotation + def this()/*<<=annot.B#``(+1).*/ = this(/*=>>annot.B#``().*/42) +} + +@ObjectAnnotation +object /*=>>java.lang.Object#``().*/M/*<<=annot.M.*/ { + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>annot.M.*/@MacroAnnotation + def m/*<<=annot.M.m().*/[TT/*<<=annot.M.m().(TT)*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*//*=>>scala.Predef.*//*=>>scala.*//*=>>_root_*/ = macro ??? +} + +@TraitAnnotation +trait T/*<<=annot.T#*/ + +object /*=>>java.lang.Object#``().*/Alias/*<<=annot.Alias.*/ { + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>annot.Alias.*/type A/*<<=annot.Alias.A#*/ = ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ @param/*=>>scala.annotation.meta.param#*//*=>>scala.annotation.meta.param#``().*/ +} diff --git a/tests/semanticdb/Annotations.scala b/tests/semanticdb/Annotations.scala new file mode 100644 index 000000000000..c897aa819a58 --- /dev/null +++ b/tests/semanticdb/Annotations.scala @@ -0,0 +1,38 @@ +package annot + +import com.javacp.annot._ +import scala.annotation.meta._ +import scala.language.experimental.macros + +@ClassAnnotation +class Annotations[@TypeParameterAnnotation T](@ParameterAnnotation x: T) { self: AnyRef => + @FieldAnnotation + val field = 42 + + @MethodAnnotation + def method = { + @LocalAnnotation + val local = 42 + local + } + @TypeAnnotation + type S +} + +class B @ConstructorAnnotation()(x: Int) { + @ConstructorAnnotation + def this() = this(42) +} + +@ObjectAnnotation +object M { + @MacroAnnotation + def m[TT]: Int = macro ??? +} + +@TraitAnnotation +trait T + +object Alias { + type A = ClassAnnotation @param +} diff --git a/tests/semanticdb/Definitions.expect.scala b/tests/semanticdb/Definitions.expect.scala index b8be2ec3d76f..74cf02666da2 100644 --- a/tests/semanticdb/Definitions.expect.scala +++ b/tests/semanticdb/Definitions.expect.scala @@ -1,8 +1,8 @@ package a -object /*=>>java.lang.Object#``().*/ Definitions /*<<=a.Definitions.*/ { - /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>a.Definitions.*/ val a /*<<=a.Definitions.a.*/ = 1 - var b /*<<=a.Definitions.b.*/ = /*<<=a.Definitions.`b_=`().*/ 2 - def c /*<<=a.Definitions.c().*/ = 3 - class /*=>>java.lang.Object#``().*/ D /*<<=a.Definitions.D#*/ - trait E /*<<=a.Definitions.E#*/ +object /*=>>java.lang.Object#``().*/Definitions/*<<=a.Definitions.*/ { + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>a.Definitions.*/val a/*<<=a.Definitions.a.*/ = 1 + var b/*<<=a.Definitions.b.*/ =/*<<=a.Definitions.`b_=`().*/ 2 + def c/*<<=a.Definitions.c().*/ = 3 + class /*=>>java.lang.Object#``().*/D/*<<=a.Definitions.D#*/ + trait E/*<<=a.Definitions.E#*/ } diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala index ac8ca251da5c..f61a2a31bf52 100644 --- a/tests/semanticdb/Enums.expect.scala +++ b/tests/semanticdb/Enums.expect.scala @@ -1,50 +1,50 @@ -object /*=>>java.lang.Object#``().*/ Enums /*<<=Enums.*/ { - /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>Enums.*/ enum /*=>>java.lang.Object#``().*/ Colour /*<<=Enums.Colour#*/ { - /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ case /*=>>scala.collection.IterableOnceOps#toArray().*/ /*=>>scala.runtime.EnumValues#values().*/ /*=>>Enums.Colour.$values.*/ /*=>>scala.reflect.ClassTag.apply().*/ /*=>>scala.reflect.ClassTag.*/ /*=>>scala.runtime.EnumValues#``().*/ /*=>>scala.collection.MapOps#apply().*/ /*=>>scala.runtime.EnumValues#fromName().*/ /*=>>Enums.Colour.valueOf().($name)*/ /*=>>java.util.NoSuchElementException#*/ /*=>>``.throw().*/ /*=>>java.lang.IllegalArgumentException#``(+1).*/ /*=>>java.lang.String#concat().*/ /*=>>Enums.Colour#``().*/ /*=>>Enums.Colour.$new().(_$ordinal)*/ /*=>>Enums.Colour.$new().($name)*/ /*=>>scala.runtime.EnumValues#register().*/ /*=>>local0*/ /*=>>local1*/ Red /*=>>Enums.Colour.Red.*/ /*<<=Enums.Colour.Red.*/ , Gr /*<<=Enums.Colour.$values.*/ een /*=>>Enums.Colour.Green.*/ /*<<=Enums.Colour.Green.*/ , Blue /*=>>Enums.Colour.Blue.*/ /*<<=Enums.Colour.Blue.*/ +object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.*/enum /*=>>java.lang.Object#``().*/Colour/*<<=Enums.Colour#*/ { + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Colour.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Colour.valueOf().($name)*//*=>>java.util.NoSuchElementException#*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.Colour#``().*//*=>>Enums.Colour.$new().(_$ordinal)*//*=>>Enums.Colour.$new().($name)*//*=>>scala.runtime.EnumValues#register().*//*=>>local0*//*=>>local1*/Red/*=>>Enums.Colour.Red.*//*<<=Enums.Colour.Red.*/, Gr/*<<=Enums.Colour.$values.*/een/*=>>Enums.Colour.Green.*//*<<=Enums.Colour.Green.*/, Blue/*=>>Enums.Colour.Blue.*//*<<=Enums.Colour.Blue.*/ } - enum /*=>>java.lang.Object#``().*/ WeekDays /*<<=Enums.WeekDays#*/ { - /*=>>Enums.WeekDays.Monday.*/ /*=>>Enums.WeekDays.Tuesday.*/ /*=>>Enums.WeekDays.Wednesday.*/ /*=>>Enums.WeekDays.Thursday.*/ /*=>>Enums.WeekDays.Friday.*/ /*=>>Enums.WeekDays.Saturday.*/ /*=>>Enums.WeekDays.Sunday.*/ /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>scala.collection.IterableOnceOps#toArray().*/ /*=>>scala.runtime.EnumValues#values().*/ /*=>>Enums.WeekDays.$values.*/ /*=>>scala.reflect.ClassTag.apply().*/ /*=>>scala.reflect.ClassTag.*/ /*=>>scala.runtime.EnumValues#``().*/ /*=>>scala.collection.MapOps#apply().*/ /*=>>scala.runtime.EnumValues#fromName().*/ /*=>>Enums.WeekDays.valueOf().($name)*/ /*=>>java.util.NoSuchElementException#*/ /*=>>``.throw().*/ /*=>>java.lang.IllegalArgumentException#``(+1).*/ /*=>>java.lang.String#concat().*/ /*=>>Enums.WeekDays#``().*/ /*=>>Enums.WeekDays.$new().(_$ordinal)*/ /*=>>Enums.WeekDays.$new().($name)*/ /*=>>scala.runtime.EnumValues#register().*/ /*=>>local2*/ /*=>>local3*/ case Monday /*<<=Enums.WeekDays.Monday.*/ - /*<<=Enums.WeekDays.$values.*/ case Tuesday /*<<=Enums.WeekDays.Tuesday.*/ - case Wednesday /*<<=Enums.WeekDays.Wednesday.*/ - case Thursday /*<<=Enums.WeekDays.Thursday.*/ - case Friday /*<<=Enums.WeekDays.Friday.*/ - case Saturday /*<<=Enums.WeekDays.Saturday.*/ - case Sunday /*<<=Enums.WeekDays.Sunday.*/ + enum /*=>>java.lang.Object#``().*/WeekDays/*<<=Enums.WeekDays#*/ { + /*=>>Enums.WeekDays.Monday.*//*=>>Enums.WeekDays.Tuesday.*//*=>>Enums.WeekDays.Wednesday.*//*=>>Enums.WeekDays.Thursday.*//*=>>Enums.WeekDays.Friday.*//*=>>Enums.WeekDays.Saturday.*//*=>>Enums.WeekDays.Sunday.*//*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.WeekDays.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.WeekDays.valueOf().($name)*//*=>>java.util.NoSuchElementException#*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.WeekDays#``().*//*=>>Enums.WeekDays.$new().(_$ordinal)*//*=>>Enums.WeekDays.$new().($name)*//*=>>scala.runtime.EnumValues#register().*//*=>>local2*//*=>>local3*/case Monday/*<<=Enums.WeekDays.Monday.*/ +/*<<=Enums.WeekDays.$values.*/ case Tuesday/*<<=Enums.WeekDays.Tuesday.*/ + case Wednesday/*<<=Enums.WeekDays.Wednesday.*/ + case Thursday/*<<=Enums.WeekDays.Thursday.*/ + case Friday/*<<=Enums.WeekDays.Friday.*/ + case Saturday/*<<=Enums.WeekDays.Saturday.*/ + case Sunday/*<<=Enums.WeekDays.Sunday.*/ } - enum /*=>>java.lang.Object#``().*/ Maybe /*<<=Enums.Maybe#*/ [+A] { /*<<=Enums.Maybe#``().*/ /*<<=Enums.Maybe#``().(A)*/ /*<<=Enums.Maybe#(A)*/ /*=>>Enums.Maybe.None.*/ - /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>Enums.Maybe#``().*/ /*=>>Enums.Maybe.Just#(A)*/ /*=>>Enums.Maybe.Just#``().*/ /*=>>Enums.Maybe.Just#copy().(A)*/ /*=>>Enums.Maybe.Just#copy().(value)*/ /*=>>Enums.Maybe.Just.apply().(A)*/ /*=>>Enums.Maybe.Just.apply().(value)*/ /*=>>Enums.Maybe.Just.unapply().(A)*/ case Just /*<<=Enums.Maybe.Just#*/ (value /*<<=Enums.Maybe.Just#``().*/ /*<<=Enums.Maybe.Just#``().(value)*/ /*<<=Enums.Maybe.Just#(value)*/ /*<<=Enums.Maybe.Just#copy().(value)*/ /*<<=Enums.Maybe.Just.apply().(value)*/ : A /*=>>Enums.Maybe.Just#``().(A)*/ /*=>>Enums.Maybe.Just#(value)*/ ) /*=>>scala.Product#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>scala.package.Serializable#*/ - /*=>>Enums.Maybe#``().*/ case /*<<=local4*/ None /*<<=Enums.Maybe.None.*/ /*=>>local5*/ /*=>>local4*/ + enum /*=>>java.lang.Object#``().*/Maybe/*<<=Enums.Maybe#*/[+A] {/*<<=Enums.Maybe#``().*//*<<=Enums.Maybe#``().(A)*//*<<=Enums.Maybe#(A)*//*=>>Enums.Maybe.None.*/ + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.Maybe#``().*//*=>>Enums.Maybe.Just#(A)*//*=>>Enums.Maybe.Just#``().*//*=>>Enums.Maybe.Just#copy().(A)*//*=>>Enums.Maybe.Just#copy().(value)*//*=>>Enums.Maybe.Just.apply().(A)*//*=>>Enums.Maybe.Just.apply().(value)*//*=>>Enums.Maybe.Just.unapply().(A)*/case Just/*<<=Enums.Maybe.Just#*/(value/*<<=Enums.Maybe.Just#``().*//*<<=Enums.Maybe.Just#``().(value)*//*<<=Enums.Maybe.Just#(value)*//*<<=Enums.Maybe.Just#copy().(value)*//*<<=Enums.Maybe.Just.apply().(value)*/: A/*=>>Enums.Maybe.Just#``().(A)*//*=>>Enums.Maybe.Just#(value)*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ + /*=>>Enums.Maybe#``().*/case /*<<=local4*/None/*<<=Enums.Maybe.None.*//*=>>local5*//*=>>local4*/ } - enum /*=>>java.lang.Object#``().*/ Tag /*<<=Enums.Tag#*/ [A] { - /*<<=Enums.Tag#``().*/ /*<<=Enums.Tag#``().(A)*/ /*<<=Enums.Tag#(A)*/ /*=>>Enums.Tag.IntTag.*/ /*=>>Enums.Tag.BooleanTag.*/ /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ case IntTag /*<<=Enums.Tag.IntTag.*/ extends Tag /*=>>Enums.Tag#*/ [I /*<<=local6*/ nt /*=>>scala.Int#*/ ] /*=>>Enums.Tag#``().*/ /*=>>local7*/ /*=>>local6*/ - case BooleanTag /*<<=Enums.Tag.BooleanTag.*/ extends Tag /*=>>Enums.Tag#*/ [B /*<<=local8*/ oolean /*=>>scala.Boolean#*/ ] /*=>>Enums.Tag#``().*/ /*=>>local9*/ /*=>>local8*/ + enum /*=>>java.lang.Object#``().*/Tag/*<<=Enums.Tag#*/[A] { +/*<<=Enums.Tag#``().*//*<<=Enums.Tag#``().(A)*//*<<=Enums.Tag#(A)*//*=>>Enums.Tag.IntTag.*//*=>>Enums.Tag.BooleanTag.*/ /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case IntTag/*<<=Enums.Tag.IntTag.*/ extends Tag/*=>>Enums.Tag#*/[I/*<<=local6*/nt/*=>>scala.Int#*/]/*=>>Enums.Tag#``().*//*=>>local7*//*=>>local6*/ + case BooleanTag/*<<=Enums.Tag.BooleanTag.*/ extends Tag/*=>>Enums.Tag#*/[B/*<<=local8*/oolean/*=>>scala.Boolean#*/]/*=>>Enums.Tag#``().*//*=>>local9*//*=>>local8*/ } - enum /*=>>java.lang.Object#``().*/ =:= /*<<=Enums.`=:=`#*/ [A, B] /*<<=Enums.`=:=`#``().*/ /*<<=Enums.`=:=`#``().(A)*/ /*<<=Enums.`=:=`#(A)*/ /*<<=Enums.`=:=`#``().(B)*/ /*<<=Enums.`=:=`#(B)*/ { - /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>Enums.`=:=`.Refl#``().*/ /*=>>Enums.`=:=`.Refl#copy().(C)*/ /*=>>Enums.`=:=`.Refl.apply().(C)*/ /*=>>Enums.`=:=`.Refl.unapply().(C)*/ case Refl /*<<=Enums.`=:=`.Refl#*/ [C]() /*<<=Enums.`=:=`.Refl#``().*/ /*<<=Enums.`=:=`.Refl#``().(C)*/ /*<<=Enums.`=:=`.Refl#(C)*/ /*<<=Enums.`=:=`.Refl#copy().(C)*/ /*<<=Enums.`=:=`.Refl.apply().(C)*/ /*<<=Enums.`=:=`.Refl.unapply().(C)*/ extends (C /*=>>Enums.`=:=`.Refl#(C)*/ /*=>>Enums.`=:=`.Refl.apply().(C)*/ =:= /*=>>Enums.`=:=`#*/ C /*=>>Enums.`=:=`.Refl#(C)*/ /*=>>Enums.`=:=`.Refl.apply().(C)*/ /*=>>Enums.`=:=`#``().*/ ) /*=>>scala.Product#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>scala.package.Serializable#*/ + enum /*=>>java.lang.Object#``().*/=:=/*<<=Enums.`=:=`#*/[A, B]/*<<=Enums.`=:=`#``().*//*<<=Enums.`=:=`#``().(A)*//*<<=Enums.`=:=`#(A)*//*<<=Enums.`=:=`#``().(B)*//*<<=Enums.`=:=`#(B)*/ { + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.`=:=`.Refl#``().*//*=>>Enums.`=:=`.Refl#copy().(C)*//*=>>Enums.`=:=`.Refl.apply().(C)*//*=>>Enums.`=:=`.Refl.unapply().(C)*/case Refl/*<<=Enums.`=:=`.Refl#*/[C]() /*<<=Enums.`=:=`.Refl#``().*//*<<=Enums.`=:=`.Refl#``().(C)*//*<<=Enums.`=:=`.Refl#(C)*//*<<=Enums.`=:=`.Refl#copy().(C)*//*<<=Enums.`=:=`.Refl.apply().(C)*//*<<=Enums.`=:=`.Refl.unapply().(C)*/extends (C/*=>>Enums.`=:=`.Refl#(C)*//*=>>Enums.`=:=`.Refl.apply().(C)*/ =:=/*=>>Enums.`=:=`#*/ C/*=>>Enums.`=:=`.Refl#(C)*//*=>>Enums.`=:=`.Refl.apply().(C)*//*=>>Enums.`=:=`#``().*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ } - def unwrap /*<<=Enums.unwrap().*/ [A /*<<=Enums.unwrap().(A)*/ ,B /*<<=Enums.unwrap().(B)*/ ](opt /*<<=Enums.unwrap().(opt)*/ : Option /*=>>scala.Option#*/ [A /*=>>Enums.unwrap().(A)*/ ])(given ev /*<<=Enums.unwrap().(ev)*/ : A /*=>>Enums.unwrap().(A)*/ =:= /*=>>Enums.`=:=`#*/ Option /*=>>scala.Option#*/ [B /*=>>Enums.unwrap().(B)*/ ]): Option /*=>>scala.Option#*/ [B /*=>>Enums.unwrap().(B)*/ ] = { - ev /*=>>Enums.unwrap().(ev)*/ match { - case =:= /*=>>Enums.`=:=`.*/ .Refl /*=>>Enums.`=:=`.Refl.*/ () => opt /*=>>Enums.unwrap().(opt)*/ .flatMap /*=>>scala.Option#flatMap().*/ (identity /*=>>scala.Predef.identity().*/ [Option /*=>>scala.Option#*/ [B /*=>>Enums.unwrap().(B)*/ ]]) + def unwrap/*<<=Enums.unwrap().*/[A/*<<=Enums.unwrap().(A)*/,B/*<<=Enums.unwrap().(B)*/](opt/*<<=Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>Enums.unwrap().(A)*/])(given ev/*<<=Enums.unwrap().(ev)*/: A/*=>>Enums.unwrap().(A)*/ =:=/*=>>Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().(B)*/]): Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().(B)*/] = { + ev/*=>>Enums.unwrap().(ev)*/ match { + case =:=/*=>>Enums.`=:=`.*/.Refl/*=>>Enums.`=:=`.Refl.*/() => opt/*=>>Enums.unwrap().(opt)*/.flatMap/*=>>scala.Option#flatMap().*/(identity/*=>>scala.Predef.identity().*/[Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().(B)*/]]) } } - enum Planet /*<<=Enums.Planet#*/ (mass: /*<<=Enums.Planet#``().*/ /*<<=Enums.Planet#``().(mass)*/ /*<<=Enums.Planet#(mass)*/ Double /*=>>scala.Double#*/ , radius /*<<=Enums.Planet#``().(radius)*/ /*<<=Enums.Planet#(radius)*/ : Double /*=>>scala.Double#*/ ) extends java /*=>>java.*/ .lang /*=>>java.lang.*/ .Enum /*=>>java.lang.Enum#*/ [Planet /*=>>Enums.Planet#*/ ] /*=>>java.lang.Enum#``().*/ /*=>>Enums.Planet.Mercury.*/ /*=>>Enums.Planet.Venus.*/ /*=>>Enums.Planet.Earth.*/ /*=>>Enums.Planet.Mars.*/ /*=>>Enums.Planet.Jupiter.*/ /*=>>Enums.Planet.Saturn.*/ /*=>>Enums.Planet.Uranus.*/ /*=>>Enums.Planet.Neptune.*/ { - private final val G /*<<=Enums.Planet#G.*/ = 6.67300E-11 - def surfaceGravity /*<<=Enums.Planet#surfaceGravity().*/ = G /*=>>Enums.Planet#G.*/ * /*=>>scala.Double#`*`(+6).*/ mass /*=>>Enums.Planet#(mass)*/ / /*=>>scala.Double#`.`(+6).*/ (radius /*=>>Enums.Planet#(radius)*/ * /*=>>scala.Double#`*`(+6).*/ radius /*=>>Enums.Planet#(radius)*/ ) - def surfaceWeight /*<<=Enums.Planet#surfaceWeight().*/ (otherMass /*<<=Enums.Planet#surfaceWeight().(otherMass)*/ : Double /*=>>scala.Double#*/ ) = otherMass /*=>>Enums.Planet#surfaceWeight().(otherMass)*/ * /*=>>scala.Double#`*`(+6).*/ surfaceGravity /*=>>Enums.Planet#surfaceGravity().*/ + enum Planet/*<<=Enums.Planet#*/(mass:/*<<=Enums.Planet#``().*//*<<=Enums.Planet#``().(mass)*//*<<=Enums.Planet#(mass)*/ Double/*=>>scala.Double#*/, radius/*<<=Enums.Planet#``().(radius)*//*<<=Enums.Planet#(radius)*/: Double/*=>>scala.Double#*/) extends java/*=>>java.*/.lang/*=>>java.lang.*/.Enum/*=>>java.lang.Enum#*/[Planet/*=>>Enums.Planet#*/]/*=>>java.lang.Enum#``().*//*=>>Enums.Planet.Mercury.*//*=>>Enums.Planet.Venus.*//*=>>Enums.Planet.Earth.*//*=>>Enums.Planet.Mars.*//*=>>Enums.Planet.Jupiter.*//*=>>Enums.Planet.Saturn.*//*=>>Enums.Planet.Uranus.*//*=>>Enums.Planet.Neptune.*/ { + private final val G/*<<=Enums.Planet#G.*/ = 6.67300E-11 + def surfaceGravity/*<<=Enums.Planet#surfaceGravity().*/ = G/*=>>Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>Enums.Planet#(mass)*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>Enums.Planet#(radius)*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>Enums.Planet#(radius)*/) + def surfaceWeight/*<<=Enums.Planet#surfaceWeight().*/(otherMass/*<<=Enums.Planet#surfaceWeight().(otherMass)*/: Double/*=>>scala.Double#*/) = otherMass/*=>>Enums.Planet#surfaceWeight().(otherMass)*/ */*=>>scala.Double#`*`(+6).*/ surfaceGravity/*=>>Enums.Planet#surfaceGravity().*/ - /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ case Mercury /*<<=Enums.Planet.$values.*/ /*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.collection.IterableOnceOps#toArray().*/ /*=>>scala.runtime.EnumValues#values().*/ /*=>>Enums.Planet.$values.*/ /*=>>scala.reflect.ClassTag.apply().*/ /*=>>scala.reflect.ClassTag.*/ /*=>>scala.runtime.EnumValues#``().*/ /*=>>scala.collection.MapOps#apply().*/ /*=>>scala.runtime.EnumValues#fromName().*/ /*=>>Enums.Planet.valueOf().($name)*/ /*=>>java.util.NoSuchElementException#*/ /*=>>``.throw().*/ /*=>>java.lang.IllegalArgumentException#``(+1).*/ /*=>>java.lang.String#concat().*/ Plane /*<<=local10*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (3.303e+23, 2.4397e6) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local11*/ /*=>>local10*/ - case Venus /*<<=Enums.Planet.Venus.*/ extends Plane /*<<=local12*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (4.869e+24, 6.0518e6) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local13*/ /*=>>local12*/ - case Earth /*<<=Enums.Planet.Earth.*/ extends Plane /*<<=local14*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (5.976e+24, 6.37814e6) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local15*/ /*=>>local14*/ - case Mars /*<<=Enums.Planet.Mars.*/ extends Plane /*<<=local16*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (6.421e+23, 3.3972e6) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local17*/ /*=>>local16*/ - case Jupiter /*<<=Enums.Planet.Jupiter.*/ extends Plane /*<<=local18*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (1.9e+27, 7.1492e7) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local19*/ /*=>>local18*/ - case Saturn /*<<=Enums.Planet.Saturn.*/ extends Plane /*<<=local20*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (5.688e+26, 6.0268e7) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local21*/ /*=>>local20*/ - case Uranus /*<<=Enums.Planet.Uranus.*/ extends Plane /*<<=local22*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (8.686e+25, 2.5559e7) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local23*/ /*=>>local22*/ - case Neptune /*<<=Enums.Planet.Neptune.*/ extends Plane /*<<=local24*/ t /*=>>Enums.Planet#*/ /*=>>Enums.Planet#``().*/ (1.024e+26, 2.4746e7) /*=>>scala.runtime.EnumValues#register().*/ /*=>>Enums.Planet.$values.*/ /*=>>local25*/ /*=>>local24*/ + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case Mercury/*<<=Enums.Planet.$values.*//*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Planet.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Planet.valueOf().($name)*//*=>>java.util.NoSuchElementException#*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*/Plane/*<<=local10*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local11*//*=>>local10*/ + case Venus/*<<=Enums.Planet.Venus.*/ extends Plane/*<<=local12*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local13*//*=>>local12*/ + case Earth/*<<=Enums.Planet.Earth.*/ extends Plane/*<<=local14*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local15*//*=>>local14*/ + case Mars/*<<=Enums.Planet.Mars.*/ extends Plane/*<<=local16*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local17*//*=>>local16*/ + case Jupiter/*<<=Enums.Planet.Jupiter.*/ extends Plane/*<<=local18*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local19*//*=>>local18*/ + case Saturn/*<<=Enums.Planet.Saturn.*/ extends Plane/*<<=local20*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local21*//*=>>local20*/ + case Uranus/*<<=Enums.Planet.Uranus.*/ extends Plane/*<<=local22*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local23*//*=>>local22*/ + case Neptune/*<<=Enums.Planet.Neptune.*/ extends Plane/*<<=local24*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local25*//*=>>local24*/ } } diff --git a/tests/semanticdb/Givens.expect.scala b/tests/semanticdb/Givens.expect.scala index 6e06a0a648e8..dc72324052f4 100644 --- a/tests/semanticdb/Givens.expect.scala +++ b/tests/semanticdb/Givens.expect.scala @@ -1,21 +1,21 @@ package a package b -object /*=>>java.lang.Object#``().*/ Givens /*<<=a.b.Givens.*/ +object /*=>>java.lang.Object#``().*/Givens/*<<=a.b.Givens.*/ - /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>a.b.Givens.*/ given /*=>>java.lang.Object#``().*/ :[A](any: A) - de /*<<=a.b.Givens.given_sayHello_of_A.*/ /*=>>a.b.Givens.given_sayHello_of_A.*/ /*<<=a.b.Givens.given_sayHello_of_A.sayHello().(A)*/ /*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*/ /*=>>a.b.Givens.given_sayHello_of_A.sayHello().(A)*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ f sayHello /*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s" /*=>>scala.StringContext.*/ /*=>>scala.*/ /*=>>_root_*/ Hello, I am $any /*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*/ /*=>>scala.StringContext#s().*/ " + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>a.b.Givens.*/given /*=>>java.lang.Object#``().*/:[A](any: A) + de/*<<=a.b.Givens.given_sayHello_of_A.*//*=>>a.b.Givens.given_sayHello_of_A.*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(A)*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>a.b.Givens.given_sayHello_of_A.sayHello().(A)*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/f sayHello/*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s"/*=>>scala.StringContext.*//*=>>scala.*//*=>>_root_*/Hello, I am $any/*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>scala.StringContext#s().*/" - val hello1 /*<<=a.b.Givens.hello1.*/ = /*=>>a.b.Givens.given_sayHello_of_A.sayHello().*/ /*=>>a.b.Givens.given_sayHello_of_A.*/ 1.sayHello + val hello1/*<<=a.b.Givens.hello1.*/ = /*=>>a.b.Givens.given_sayHello_of_A.sayHello().*//*=>>a.b.Givens.given_sayHello_of_A.*/1.sayHello - trait Monoid /*<<=a.b.Givens.Monoid#*/ [A] - /*<<=a.b.Givens.Monoid#``().*/ /*<<=a.b.Givens.Monoid#``().(A)*/ /*<<=a.b.Givens.Monoid#(A)*/ def empty /*<<=a.b.Givens.Monoid#empty().*/ : A /*=>>a.b.Givens.Monoid#(A)*/ - def (x: A) /*<<=a.b.Givens.Monoid#combine().*/ /*<<=a.b.Givens.Monoid#combine().(x)*/ /*=>>a.b.Givens.Monoid#(A)*/ combine (y /*<<=a.b.Givens.Monoid#combine().(y)*/ : A /*=>>a.b.Givens.Monoid#(A)*/ ): A /*=>>a.b.Givens.Monoid#(A)*/ + trait Monoid/*<<=a.b.Givens.Monoid#*/[A] + /*<<=a.b.Givens.Monoid#``().*//*<<=a.b.Givens.Monoid#``().(A)*//*<<=a.b.Givens.Monoid#(A)*/ def empty/*<<=a.b.Givens.Monoid#empty().*/: A/*=>>a.b.Givens.Monoid#(A)*/ + def (x: A) /*<<=a.b.Givens.Monoid#combine().*//*<<=a.b.Givens.Monoid#combine().(x)*//*=>>a.b.Givens.Monoid#(A)*/combine (y/*<<=a.b.Givens.Monoid#combine().(y)*/: A/*=>>a.b.Givens.Monoid#(A)*/): A/*=>>a.b.Givens.Monoid#(A)*/ - given /*=>>java.lang.Object#``().*/ /*=>>a.b.Givens.given_Monoid_String.*/ Monoid /*=>>a.b.Givens.Monoid#*/ [String] - /*<<=a.b.Givens.given_Monoid_String.*/ /*=>>scala.Predef.String#*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ def empty /*<<=a.b.Givens.given_Monoid_String.empty().*/ = "" - def (x: Str /*<<=a.b.Givens.given_Monoid_String.combine().*/ /*<<=a.b.Givens.given_Monoid_String.combine().(x)*/ ing /*=>>scala.Predef.String#*/ ) combine (y /*<<=a.b.Givens.given_Monoid_String.combine().(y)*/ : String /*=>>scala.Predef.String#*/ ) = x /*=>>a.b.Givens.given_Monoid_String.combine().(x)*/ + /*=>>java.lang.String#`+`().*/ y /*=>>a.b.Givens.given_Monoid_String.combine().(y)*/ + given /*=>>java.lang.Object#``().*//*=>>a.b.Givens.given_Monoid_String.*/Monoid/*=>>a.b.Givens.Monoid#*/[String] + /*<<=a.b.Givens.given_Monoid_String.*//*=>>scala.Predef.String#*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/def empty/*<<=a.b.Givens.given_Monoid_String.empty().*/ = "" + def (x: Str/*<<=a.b.Givens.given_Monoid_String.combine().*//*<<=a.b.Givens.given_Monoid_String.combine().(x)*/ing/*=>>scala.Predef.String#*/) combine (y/*<<=a.b.Givens.given_Monoid_String.combine().(y)*/: String/*=>>scala.Predef.String#*/) = x/*=>>a.b.Givens.given_Monoid_String.combine().(x)*/ +/*=>>java.lang.String#`+`().*/ y/*=>>a.b.Givens.given_Monoid_String.combine().(y)*/ - inline given int2String /*<<=a.b.Givens.int2String().*/ : Conversion /*=>>scala.Conversion#*/ [Int /*=>>scala.Int#*/ , String /*=>>scala.Predef.String#*/ ] = _ /*=>>local0*/ .toString /*=>>scala.Any#toString().*/ + inline given int2String/*<<=a.b.Givens.int2String().*/: Conversion/*=>>scala.Conversion#*/[Int/*=>>scala.Int#*/, String/*=>>scala.Predef.String#*/] = _/*=>>local0*/.toString/*=>>scala.Any#toString().*/ - def foo /*<<=a.b.Givens.foo().*/ [A /*<<=a.b.Givens.foo().(A)*/ ](given A /*<<=a.b.Givens.foo().(A)*/ : Monoid /*=>>a.b.Givens.Monoid#*/ [A /*=>>a.b.Givens.foo().(A)*/ ]): A /*=>>a.b.Givens.foo().(A)*/ = A /*=>>a.b.Givens.foo().(A)*/ .combine /*=>>a.b.Givens.Monoid#combine().*/ (A /*=>>a.b.Givens.foo().(A)*/ .empty /*=>>a.b.Givens.Monoid#empty().*/ )(A /*=>>a.b.Givens.foo().(A)*/ .empty /*=>>a.b.Givens.Monoid#empty().*/ ) + def foo/*<<=a.b.Givens.foo().*/[A/*<<=a.b.Givens.foo().(A)*/](given A/*<<=a.b.Givens.foo().(A)*/: Monoid/*=>>a.b.Givens.Monoid#*/[A/*=>>a.b.Givens.foo().(A)*/]): A/*=>>a.b.Givens.foo().(A)*/ = A/*=>>a.b.Givens.foo().(A)*/.combine/*=>>a.b.Givens.Monoid#combine().*/(A/*=>>a.b.Givens.foo().(A)*/.empty/*=>>a.b.Givens.Monoid#empty().*/)(A/*=>>a.b.Givens.foo().(A)*/.empty/*=>>a.b.Givens.Monoid#empty().*/) diff --git a/tests/semanticdb/NewModifiers.expect.scala b/tests/semanticdb/NewModifiers.expect.scala index fea243eecab6..fb77ee208362 100644 --- a/tests/semanticdb/NewModifiers.expect.scala +++ b/tests/semanticdb/NewModifiers.expect.scala @@ -1,4 +1,4 @@ -object /*=>>java.lang.Object#``().*/ NewModifiers /*<<=NewModifiers.*/ { - /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>NewModifiers.*/ inline val foo /*<<=NewModifiers.foo.*/ = "foo" - opaque type A /*<<=NewModifiers.A#*/ = Int /*=>>scala.Int#*/ +object /*=>>java.lang.Object#``().*/NewModifiers/*<<=NewModifiers.*/ { + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>NewModifiers.*/inline val foo/*<<=NewModifiers.foo.*/ = "foo" + opaque type A/*<<=NewModifiers.A#*/ = Int/*=>>scala.Int#*/ } diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala index 1940a6c92f95..df54fb012aef 100644 --- a/tests/semanticdb/semanticdb-extract.expect.scala +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -1,18 +1,18 @@ -object /*=>>java.lang.Object#``().*/ A /*<<=A.*/ { +object /*=>>java.lang.Object#``().*/A/*<<=A.*/ { - /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>A.*/ def foo /*<<=A.foo().*/ (x /*<<=A.foo().(x)*/ : Int /*=>>scala.Int#*/ ) = () - def foo /*<<=A.foo(+1).*/ (): Unit /*=>>scala.Unit#*/ = () + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>A.*/def foo/*<<=A.foo().*/(x/*<<=A.foo().(x)*/: Int/*=>>scala.Int#*/) = () + def foo/*<<=A.foo(+1).*/(): Unit/*=>>scala.Unit#*/ = () - foo /*=>>A.foo().*/ (1) - foo /*=>>A.foo(+1).*/ () + foo/*=>>A.foo().*/(1) + foo/*=>>A.foo(+1).*/() - "".substring /*=>>java.lang.String#substring().*/ (1) - "".substring /*=>>java.lang.String#substring(+1).*/ (1, 2) + "".substring/*=>>java.lang.String#substring().*/(1) + "".substring/*=>>java.lang.String#substring(+1).*/(1, 2) - List /*=>>scala.package.List.*/ /*=>>scala.collection.IterableFactory#apply().*/ (1, 2) - List /*=>>scala.package.List.*/ .apply /*=>>scala.collection.IterableFactory#apply().*/ () - List /*=>>scala.package.List.*/ .`apply` /*=>>scala.collection.IterableFactory#apply().*/ () - println /*=>>scala.Predef.println(+1).*/ (1 + /*=>>scala.Int#`+`(+4).*/ 2) + List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1, 2) + List/*=>>scala.package.List.*/.apply/*=>>scala.collection.IterableFactory#apply().*/() + List/*=>>scala.package.List.*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() + println/*=>>scala.Predef.println(+1).*/(1 +/*=>>scala.Int#`+`(+4).*/ 2) - /*=>>A.Foo#``().*/ /*=>>A.Foo#copy().(x)*/ /*=>>A.Foo.apply().(x)*/ case class /*=>>java.lang.Object#``().*/ Foo /*<<=A.Foo#*/ (x: In /*<<=A.Foo#``().*/ /*<<=A.Foo#``().(x)*/ /*<<=A.Foo#(x)*/ /*<<=A.Foo#copy().(x)*/ /*<<=A.Foo.apply().(x)*/ t /*=>>scala.Int#*/ /*=>>A.Foo#(x)*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ ) /*=>>scala.Product#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>scala.package.Serializable#*/ + /*=>>A.Foo#``().*//*=>>A.Foo#copy().(x)*//*=>>A.Foo.apply().(x)*/case class /*=>>java.lang.Object#``().*/Foo/*<<=A.Foo#*/(x: In/*<<=A.Foo#``().*//*<<=A.Foo#``().(x)*//*<<=A.Foo#(x)*//*<<=A.Foo#copy().(x)*//*<<=A.Foo.apply().(x)*/t/*=>>scala.Int#*//*=>>A.Foo#(x)*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ } \ No newline at end of file diff --git a/tests/semanticdb/toplevel.expect.scala b/tests/semanticdb/toplevel.expect.scala index 6dbafecf4d21..9c5c5d55129d 100644 --- a/tests/semanticdb/toplevel.expect.scala +++ b/tests/semanticdb/toplevel.expect.scala @@ -1,4 +1,5 @@ - /*=>>java.lang.Object#``().*/ /*=>>scala.package.Serializable#*/ /*=>>scala.*/ /*=>>_root_*/ /*=>>toplevel$package.*/ inline val a = " /*<<=toplevel$package.*/ /*<<=toplevel$package.a.*/ " -def (x: Int /*<<=toplevel$package.combine().*/ /*<<=toplevel$package.combine().(x)*/ /*=>>scala.Int#*/ ) combine (y /*<<=toplevel$package.combine().(y)*/ : Int /*=>>scala.Int#*/ ) = x /*=>>toplevel$package.combine().(x)*/ + /*=>>scala.Int#`+`(+4).*/ y /*=>>toplevel$package.combine().(y)*/ -def combine /*<<=toplevel$package.combine(+1).*/ (x /*<<=toplevel$package.combine(+1).(x)*/ : Int /*=>>scala.Int#*/ , y /*<<=toplevel$package.combine(+1).(y)*/ : Int /*=>>scala.Int#*/ , z /*<<=toplevel$package.combine(+1).(z)*/ : Int /*=>>scala.Int#*/ ) = x /*=>>toplevel$package.combine(+1).(x)*/ + /*=>>scala.Int#`+`(+4).*/ y /*=>>toplevel$package.combine(+1).(y)*/ + /*=>>scala.Int#`+`(+4).*/ z /*=>>toplevel$package.combine(+1).(z)*/ -def combine /*<<=toplevel$package.combine(+2).*/ = 0 +/*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>toplevel$package.*/inline val a = "/*<<=toplevel$package.*//*<<=toplevel$package.a.*/" +def (x: Int/*<<=toplevel$package.combine().*//*<<=toplevel$package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=toplevel$package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>toplevel$package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>toplevel$package.combine().(y)*/ +def combine/*<<=toplevel$package.combine(+1).*/(x/*<<=toplevel$package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=toplevel$package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=toplevel$package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>toplevel$package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>toplevel$package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>toplevel$package.combine(+1).(z)*/ +def combine/*<<=toplevel$package.combine(+2).*/ = 0 +def foo/*<<=toplevel$package.foo().*/ = "foo" diff --git a/tests/semanticdb/toplevel.scala b/tests/semanticdb/toplevel.scala index 990d4102fcc5..37ff0172e2aa 100644 --- a/tests/semanticdb/toplevel.scala +++ b/tests/semanticdb/toplevel.scala @@ -2,3 +2,4 @@ inline val a = "" def (x: Int) combine (y: Int) = x + y def combine(x: Int, y: Int, z: Int) = x + y + z def combine = 0 +def foo = "foo" From 17bdf103c03305e5d7f84104aa20d52e8da987f6 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 17 Oct 2019 15:50:34 +0200 Subject: [PATCH 025/107] self symbol is a local symbol --- .../src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala | 2 +- tests/semanticdb/Annotations.expect.scala | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index c6fe42906a39..ba5bce674e67 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -73,7 +73,7 @@ class ExtractSemanticDB extends Phase { /** Is symbol global? Non-global symbols get localX names */ def isGlobal(sym: Symbol): Boolean = sym.is(Package) - || (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) + || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) def addOwner(owner: Symbol): Unit = if !owner.isRoot && !owner.isEmptyPackage then addSymName(b, owner) diff --git a/tests/semanticdb/Annotations.expect.scala b/tests/semanticdb/Annotations.expect.scala index 57437c3fae74..783d4bdb3745 100644 --- a/tests/semanticdb/Annotations.expect.scala +++ b/tests/semanticdb/Annotations.expect.scala @@ -5,15 +5,15 @@ import scala.annotation.meta._ import scala.language/*=>>scalaShadowing.language.*/.experimental/*=>>scalaShadowing.language.experimental.*/.macros/*=>>scalaShadowing.language.experimental.macros.*/ @ClassAnnotation -class /*=>>java.lang.Object#``().*/Annotations/*<<=annot.Annotations#*/[@Type/*<<=annot.Annotations#``().*/ParameterAnnotation T/*<<=annot.Annotations#``().(T)*//*<<=annot.Annotations#(T)*/](@ParameterAnnotation x/*<<=annot.Annotations#``().(x)*//*<<=annot.Annotations#(x)*/: T/*=>>annot.Annotations#``().(T)*/) { self/*<<=annot.Annotations#self.*/: AnyRef/*=>>scala.AnyRef#*/ => +class /*=>>java.lang.Object#``().*/Annotations/*<<=annot.Annotations#*/[@Type/*<<=annot.Annotations#``().*/ParameterAnnotation T/*<<=annot.Annotations#``().(T)*//*<<=annot.Annotations#(T)*/](@ParameterAnnotation x/*<<=annot.Annotations#``().(x)*//*<<=annot.Annotations#(x)*/: T/*=>>annot.Annotations#``().(T)*/) { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => @FieldAnnotation val field/*<<=annot.Annotations#field.*/ = 42 @MethodAnnotation def method/*<<=annot.Annotations#method().*/ = { @LocalAnnotation - val local/*<<=local0*/ = 42 - local/*=>>local0*/ + val local/*<<=local1*/ = 42 + local/*=>>local1*/ } @TypeAnnotation type S/*<<=annot.Annotations#S#*/ From 69274af9b9c9a36d2429df975bdad8f25842a0fd Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 17 Oct 2019 16:37:04 +0200 Subject: [PATCH 026/107] visit symbol annotations if not from scala.annotation.internal package --- .../dotty/tools/dotc/core/Definitions.scala | 1 + .../dotc/semanticdb/ExtractSemanticDB.scala | 8 +++++++ tests/semanticdb/Annotations.expect.scala | 24 +++++++++---------- 3 files changed, 21 insertions(+), 12 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala index d057817c9b79..6a2bc8b401fb 100644 --- a/compiler/src/dotty/tools/dotc/core/Definitions.scala +++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala @@ -750,6 +750,7 @@ class Definitions { @tu lazy val RefiningAnnotationClass: ClassSymbol = ctx.requiredClass("scala.annotation.RefiningAnnotation") // Annotation classes + @tu lazy val ScalaAnnotationInternal: ClassSymbol = ctx.requiredClass("scala.annotation.internal") @tu lazy val AliasAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.Alias") @tu lazy val AnnotationDefaultAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.AnnotationDefault") @tu lazy val BodyAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.Body") diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index ba5bce674e67..bb9512035e02 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -167,6 +167,12 @@ class ExtractSemanticDB extends Phase { case _ => + for annot <- tree.symbol.annotations do + if annot.tree.span.exists + && annot.symbol.owner != defn.ScalaAnnotationInternal + then + traverse(annot.tree) + tree match case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree @@ -196,6 +202,8 @@ class ExtractSemanticDB extends Phase { case tree: Inlined => traverse(tree.call) case tree: PackageDef => tree.stats.foreach(traverse) + case tree: Annotated => // skip the annotation (see `@param` in https://github.com/scalameta/scalameta/blob/633824474e99bbfefe12ad0cc73da1fe064b3e9b/tests/jvm/src/test/resources/example/Annotations.scala#L37) + traverse(tree.arg) case _ => traverseChildren(tree) } diff --git a/tests/semanticdb/Annotations.expect.scala b/tests/semanticdb/Annotations.expect.scala index 783d4bdb3745..3bbfb966dbd0 100644 --- a/tests/semanticdb/Annotations.expect.scala +++ b/tests/semanticdb/Annotations.expect.scala @@ -4,35 +4,35 @@ import com.javacp.annot._ import scala.annotation.meta._ import scala.language/*=>>scalaShadowing.language.*/.experimental/*=>>scalaShadowing.language.experimental.*/.macros/*=>>scalaShadowing.language.experimental.macros.*/ -@ClassAnnotation -class /*=>>java.lang.Object#``().*/Annotations/*<<=annot.Annotations#*/[@Type/*<<=annot.Annotations#``().*/ParameterAnnotation T/*<<=annot.Annotations#``().(T)*//*<<=annot.Annotations#(T)*/](@ParameterAnnotation x/*<<=annot.Annotations#``().(x)*//*<<=annot.Annotations#(x)*/: T/*=>>annot.Annotations#``().(T)*/) { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => - @FieldAnnotation +@ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ +class /*=>>java.lang.Object#``().*/Annotations/*<<=annot.Annotations#*/[@Type/*<<=annot.Annotations#``().*/ParameterAnnotation/*=>>com.javacp.annot.TypeParameterAnnotation#*/ T/*<<=annot.Annotations#``().(T)*//*<<=annot.Annotations#(T)*/](@ParameterAnnotation/*=>>com.javacp.annot.ParameterAnnotation#*/ x/*<<=annot.Annotations#``().(x)*//*<<=annot.Annotations#(x)*/: T/*=>>annot.Annotations#``().(T)*/) { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => + @FieldAnnotation/*=>>com.javacp.annot.FieldAnnotation#*/ val field/*<<=annot.Annotations#field.*/ = 42 - @MethodAnnotation + @MethodAnnotation/*=>>com.javacp.annot.MethodAnnotation#*/ def method/*<<=annot.Annotations#method().*/ = { - @LocalAnnotation + @LocalAnnotation/*=>>com.javacp.annot.LocalAnnotation#*/ val local/*<<=local1*/ = 42 local/*=>>local1*/ } - @TypeAnnotation + @TypeAnnotation/*=>>com.javacp.annot.TypeAnnotation#*/ type S/*<<=annot.Annotations#S#*/ } -class /*=>>java.lang.Object#``().*/B/*<<=annot.B#*/ @Cons/*<<=annot.B#``().*/tructorAnnotation()(x/*<<=annot.B#``().(x)*//*<<=annot.B#(x)*/: Int/*=>>scala.Int#*/) { - @ConstructorAnnotation +class /*=>>java.lang.Object#``().*/B/*<<=annot.B#*/ @Cons/*<<=annot.B#``().*/tructorAnnotation/*=>>com.javacp.annot.ConstructorAnnotation#*/()(x/*<<=annot.B#``().(x)*//*<<=annot.B#(x)*/: Int/*=>>scala.Int#*/) { + @ConstructorAnnotation/*=>>com.javacp.annot.ConstructorAnnotation#*/ def this()/*<<=annot.B#``(+1).*/ = this(/*=>>annot.B#``().*/42) } -@ObjectAnnotation +@ObjectAnnotation/*=>>com.javacp.annot.ObjectAnnotation#*/ object /*=>>java.lang.Object#``().*/M/*<<=annot.M.*/ { - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>annot.M.*/@MacroAnnotation + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>annot.M.*/@MacroAnnotation/*=>>com.javacp.annot.MacroAnnotation#*/ def m/*<<=annot.M.m().*/[TT/*<<=annot.M.m().(TT)*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*//*=>>scala.Predef.*//*=>>scala.*//*=>>_root_*/ = macro ??? } -@TraitAnnotation +@TraitAnnotation/*=>>com.javacp.annot.TraitAnnotation#*/ trait T/*<<=annot.T#*/ object /*=>>java.lang.Object#``().*/Alias/*<<=annot.Alias.*/ { - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>annot.Alias.*/type A/*<<=annot.Alias.A#*/ = ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ @param/*=>>scala.annotation.meta.param#*//*=>>scala.annotation.meta.param#``().*/ + /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>annot.Alias.*/type A/*<<=annot.Alias.A#*/ = ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ @param } From 36e14b38a0c7a83bfab0c2baf53e2aa4a8fe1c9b Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 18 Oct 2019 15:04:30 +0200 Subject: [PATCH 027/107] do not semanticdb symbol occurences for wildcards --- .../dotty/tools/dotc/parsing/Parsers.scala | 8 +++---- .../dotc/semanticdb/ExtractSemanticDB.scala | 22 ++++++++++++++----- tests/semanticdb/Advanced.expect.scala | 6 ++--- tests/semanticdb/Annotations.expect.scala | 4 ++-- tests/semanticdb/Anonymous.expect.scala | 20 +++++++++++++++++ tests/semanticdb/Anonymous.scala | 20 +++++++++++++++++ tests/semanticdb/Enums.expect.scala | 20 ++++++++--------- tests/semanticdb/Givens.expect.scala | 10 ++++----- 8 files changed, 81 insertions(+), 29 deletions(-) create mode 100644 tests/semanticdb/Anonymous.expect.scala create mode 100644 tests/semanticdb/Anonymous.scala diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala index fa342d56e6af..3b0de7e93ea7 100644 --- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala +++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala @@ -2526,16 +2526,16 @@ object Parsers { case t => simplePatternRest(t) } case USCORE => - val wildIndent = wildcardIdent() + val wildIdent = wildcardIdent() // compatibility for Scala2 `x @ _*` and `_*` syntax // `x: _*' is parsed in `ascription' if (isIdent(nme.raw.STAR)) { in.nextToken() - if (in.token != RPAREN) syntaxError(SeqWildcardPatternPos(), wildIndent.span) - atSpan(wildIndent.span) { Ident(tpnme.WILDCARD_STAR) } + if (in.token != RPAREN) syntaxError(SeqWildcardPatternPos(), wildIdent.span) + atSpan(wildIdent.span) { Ident(tpnme.WILDCARD_STAR) } } - else wildIndent + else wildIdent case LPAREN => atSpan(in.offset) { makeTupleOrParens(inParens(patternsOpt())) } case QUOTE => diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index bb9512035e02..0bb218c8f398 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -89,10 +89,10 @@ class ExtractSemanticDB extends Phase { def addDescriptor(sym: Symbol): Unit = if sym.is(ModuleClass) then addDescriptor(sym.sourceModule) - else if sym.is(Param) || sym.is(ParamAccessor) then - b.append('('); addName(sym.name); b.append(')') else if sym.is(TypeParam) then b.append('['); addName(sym.name); b.append(']') + else if sym.is(Param) || sym.is(ParamAccessor) then + b.append('('); addName(sym.name); b.append(')') else addName(sym.name) if sym.is(Package) then b.append('/') @@ -141,6 +141,13 @@ class ExtractSemanticDB extends Phase { val (endLine, endCol) = lineCol(span.end) Some(Range(startLine, startCol, endLine, endCol)) + private val WILDCARDTypeName = nme.WILDCARD.toTypeName + + private def isWildcard(name: Name)(given ctx: Context) = name match + case nme.WILDCARD | WILDCARDTypeName => true + case _ if name.is(NameKinds.WildcardParamName) => true + case _ => false + /** Definitions of this symbol should be excluded from semanticdb */ private def excludeDef(sym: Symbol)(given Context): Boolean = !sym.exists || sym.isLocalDummy || sym.is(Synthetic) @@ -156,9 +163,13 @@ class ExtractSemanticDB extends Phase { generated += occ private def registerUse(sym: Symbol, span: Span)(given Context) = - if !excludeUse(sym, span) then + if !excludeUse(sym, span) && !isWildcard(sym.name) then registerOccurrence(sym, span, SymbolOccurrence.Role.REFERENCE) + private def registerDefinition(sym: Symbol, span: Span)(given Context) = + if !isWildcard(sym.name) then + registerOccurrence(sym, span, SymbolOccurrence.Role.DEFINITION) + override def traverse(tree: Tree)(given ctx: Context): Unit = def registerPath(expr: Tree): Unit = expr match case t @ Select(expr, _) => @@ -177,10 +188,11 @@ class ExtractSemanticDB extends Phase { case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => - registerOccurrence(tree.symbol, tree.nameSpan, SymbolOccurrence.Role.DEFINITION) + registerDefinition(tree.symbol, tree.nameSpan) traverseChildren(tree) case tree: Ident => - registerUse(tree.symbol, tree.span) + if tree.name != nme.WILDCARD && !excludeUse(tree.symbol, tree.span) then + registerUse(tree.symbol, tree.span) case tree: Select => if !excludeUse(tree.symbol, tree.span) then val end = tree.span.end diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/Advanced.expect.scala index afb1716bc016..1d5a22ac0eef 100644 --- a/tests/semanticdb/Advanced.expect.scala +++ b/tests/semanticdb/Advanced.expect.scala @@ -6,7 +6,7 @@ import scala.language/*=>>scalaShadowing.language.*/.reflectiveCalls/*=>>scalaSh import scala.reflect/*=>>scala.reflect.*/.Selectable/*=>>scala.reflect.Selectable.*/.reflectiveSelectable/*=>>scala.reflect.Selectable.reflectiveSelectable().*/ class /*=>>java.lang.Object#``().*/C/*<<=advanced.C#*/[T] { -/*<<=advanced.C#``().*//*<<=advanced.C#``().(T)*//*<<=advanced.C#(T)*/ def t/*<<=advanced.C#t().*/: T/*=>>advanced.C#(T)*/ = ???/*=>>scala.Predef.`???`().*/ +/*<<=advanced.C#``().*//*<<=advanced.C#``().[T]*//*<<=advanced.C#[T]*/ def t/*<<=advanced.C#t().*/: T/*=>>advanced.C#[T]*/ = ???/*=>>scala.Predef.`???`().*/ } class /*=>>java.lang.Object#``().*/Structural/*<<=advanced.Structural#*/ { @@ -34,8 +34,8 @@ object /*=>>java.lang.Object#``().*/Test/*<<=advanced.Test.*/ { { (???/*=>>scala.Predef.`???`().*/ : Any/*=>>scala.Any#*/) match { - case e3/*<<=local11*/: List/*=>>scala.package.List#*/[_/*<<=local12*/] => - val e3x/*<<=local13*/ = e3/*=>>local11*/.head/*=>>scala.collection.IterableOps#head().*/ + case e3/*<<=local11*/: List/*=>>scala.package.List#*/[_] => + val e3x/*<<=local12*/ = e3/*=>>local11*/.head/*=>>scala.collection.IterableOps#head().*/ () } } diff --git a/tests/semanticdb/Annotations.expect.scala b/tests/semanticdb/Annotations.expect.scala index 3bbfb966dbd0..87c6da3dc0d0 100644 --- a/tests/semanticdb/Annotations.expect.scala +++ b/tests/semanticdb/Annotations.expect.scala @@ -5,7 +5,7 @@ import scala.annotation.meta._ import scala.language/*=>>scalaShadowing.language.*/.experimental/*=>>scalaShadowing.language.experimental.*/.macros/*=>>scalaShadowing.language.experimental.macros.*/ @ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ -class /*=>>java.lang.Object#``().*/Annotations/*<<=annot.Annotations#*/[@Type/*<<=annot.Annotations#``().*/ParameterAnnotation/*=>>com.javacp.annot.TypeParameterAnnotation#*/ T/*<<=annot.Annotations#``().(T)*//*<<=annot.Annotations#(T)*/](@ParameterAnnotation/*=>>com.javacp.annot.ParameterAnnotation#*/ x/*<<=annot.Annotations#``().(x)*//*<<=annot.Annotations#(x)*/: T/*=>>annot.Annotations#``().(T)*/) { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => +class /*=>>java.lang.Object#``().*/Annotations/*<<=annot.Annotations#*/[@Type/*<<=annot.Annotations#``().*/ParameterAnnotation/*=>>com.javacp.annot.TypeParameterAnnotation#*/ T/*<<=annot.Annotations#``().[T]*//*<<=annot.Annotations#[T]*/](@ParameterAnnotation/*=>>com.javacp.annot.ParameterAnnotation#*/ x/*<<=annot.Annotations#``().(x)*//*<<=annot.Annotations#(x)*/: T/*=>>annot.Annotations#``().[T]*/) { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => @FieldAnnotation/*=>>com.javacp.annot.FieldAnnotation#*/ val field/*<<=annot.Annotations#field.*/ = 42 @@ -27,7 +27,7 @@ class /*=>>java.lang.Object#``().*/B/*<<=annot.B#*/ @Cons/*<<=annot.B#`>com.javacp.annot.ObjectAnnotation#*/ object /*=>>java.lang.Object#``().*/M/*<<=annot.M.*/ { /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>annot.M.*/@MacroAnnotation/*=>>com.javacp.annot.MacroAnnotation#*/ - def m/*<<=annot.M.m().*/[TT/*<<=annot.M.m().(TT)*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*//*=>>scala.Predef.*//*=>>scala.*//*=>>_root_*/ = macro ??? + def m/*<<=annot.M.m().*/[TT/*<<=annot.M.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*//*=>>scala.Predef.*//*=>>scala.*//*=>>_root_*/ = macro ??? } @TraitAnnotation/*=>>com.javacp.annot.TraitAnnotation#*/ diff --git a/tests/semanticdb/Anonymous.expect.scala b/tests/semanticdb/Anonymous.expect.scala new file mode 100644 index 000000000000..4a4e85ba3f45 --- /dev/null +++ b/tests/semanticdb/Anonymous.expect.scala @@ -0,0 +1,20 @@ +package example +import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ + +class /*=>>java.lang.Object#``().*/Anonymous/*<<=example.Anonymous#*/ { + this: Anonymous/*=>>example.Anonymous#*/ => + + def locally/*<<=example.Anonymous#locally().*/[A/*<<=example.Anonymous#locally().[A]*/](x/*<<=example.Anonymous#locally().(x)*/: A/*=>>example.Anonymous#locally().[A]*/): A/*=>>example.Anonymous#locally().[A]*/ = x/*=>>example.Anonymous#locally().(x)*/ + + def m1/*<<=example.Anonymous#m1().*/[T/*<<=example.Anonymous#m1().[T]*/[_]] = ???/*=>>scala.Predef.`???`().*/ + def m2/*<<=example.Anonymous#m2().*/: Map/*=>>scala.Predef.Map#*/[_, List/*=>>scala.package.List#*/[_]] = ???/*=>>scala.Predef.`???`().*/ + locally/*=>>example.Anonymous#locally().*/ { + ???/*=>>scala.Predef.`???`().*/ match { case _: List/*=>>scala.package.List#*/[_] => } + } + locally/*=>>example.Anonymous#locally().*/ { + val x/*<<=local0*/: Int/*=>>scala.Int#*/ => Int/*=>>scala.Int#*/ = _ => ???/*=>>scala.Predef.`???`().*/ + } + + trait Foo/*<<=example.Anonymous#Foo#*/ + /*=>>java.lang.Object#``().*/new F/*<<=local1*/oo/*=>>example.Anonymous#Foo#*/ {}/*=>>local2*//*=>>local1*/ +} diff --git a/tests/semanticdb/Anonymous.scala b/tests/semanticdb/Anonymous.scala new file mode 100644 index 000000000000..dbae5c8e38c0 --- /dev/null +++ b/tests/semanticdb/Anonymous.scala @@ -0,0 +1,20 @@ +package example +import scala.language.higherKinds + +class Anonymous { + this: Anonymous => + + def locally[A](x: A): A = x + + def m1[T[_]] = ??? + def m2: Map[_, List[_]] = ??? + locally { + ??? match { case _: List[_] => } + } + locally { + val x: Int => Int = _ => ??? + } + + trait Foo + new Foo {} +} diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala index f61a2a31bf52..f4d9e5e2f5c6 100644 --- a/tests/semanticdb/Enums.expect.scala +++ b/tests/semanticdb/Enums.expect.scala @@ -1,10 +1,10 @@ object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.*/enum /*=>>java.lang.Object#``().*/Colour/*<<=Enums.Colour#*/ { - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Colour.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Colour.valueOf().($name)*//*=>>java.util.NoSuchElementException#*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.Colour#``().*//*=>>Enums.Colour.$new().(_$ordinal)*//*=>>Enums.Colour.$new().($name)*//*=>>scala.runtime.EnumValues#register().*//*=>>local0*//*=>>local1*/Red/*=>>Enums.Colour.Red.*//*<<=Enums.Colour.Red.*/, Gr/*<<=Enums.Colour.$values.*/een/*=>>Enums.Colour.Green.*//*<<=Enums.Colour.Green.*/, Blue/*=>>Enums.Colour.Blue.*//*<<=Enums.Colour.Blue.*/ + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Colour.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Colour.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.Colour#``().*//*=>>Enums.Colour.$new().(_$ordinal)*//*=>>Enums.Colour.$new().($name)*//*=>>scala.runtime.EnumValues#register().*//*=>>local0*//*=>>local1*/Red/*=>>Enums.Colour.Red.*//*<<=Enums.Colour.Red.*/, Gr/*<<=Enums.Colour.$values.*/een/*=>>Enums.Colour.Green.*//*<<=Enums.Colour.Green.*/, Blue/*=>>Enums.Colour.Blue.*//*<<=Enums.Colour.Blue.*/ } enum /*=>>java.lang.Object#``().*/WeekDays/*<<=Enums.WeekDays#*/ { - /*=>>Enums.WeekDays.Monday.*//*=>>Enums.WeekDays.Tuesday.*//*=>>Enums.WeekDays.Wednesday.*//*=>>Enums.WeekDays.Thursday.*//*=>>Enums.WeekDays.Friday.*//*=>>Enums.WeekDays.Saturday.*//*=>>Enums.WeekDays.Sunday.*//*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.WeekDays.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.WeekDays.valueOf().($name)*//*=>>java.util.NoSuchElementException#*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.WeekDays#``().*//*=>>Enums.WeekDays.$new().(_$ordinal)*//*=>>Enums.WeekDays.$new().($name)*//*=>>scala.runtime.EnumValues#register().*//*=>>local2*//*=>>local3*/case Monday/*<<=Enums.WeekDays.Monday.*/ + /*=>>Enums.WeekDays.Monday.*//*=>>Enums.WeekDays.Tuesday.*//*=>>Enums.WeekDays.Wednesday.*//*=>>Enums.WeekDays.Thursday.*//*=>>Enums.WeekDays.Friday.*//*=>>Enums.WeekDays.Saturday.*//*=>>Enums.WeekDays.Sunday.*//*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.WeekDays.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.WeekDays.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.WeekDays#``().*//*=>>Enums.WeekDays.$new().(_$ordinal)*//*=>>Enums.WeekDays.$new().($name)*//*=>>scala.runtime.EnumValues#register().*//*=>>local2*//*=>>local3*/case Monday/*<<=Enums.WeekDays.Monday.*/ /*<<=Enums.WeekDays.$values.*/ case Tuesday/*<<=Enums.WeekDays.Tuesday.*/ case Wednesday/*<<=Enums.WeekDays.Wednesday.*/ case Thursday/*<<=Enums.WeekDays.Thursday.*/ @@ -13,23 +13,23 @@ object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { case Sunday/*<<=Enums.WeekDays.Sunday.*/ } - enum /*=>>java.lang.Object#``().*/Maybe/*<<=Enums.Maybe#*/[+A] {/*<<=Enums.Maybe#``().*//*<<=Enums.Maybe#``().(A)*//*<<=Enums.Maybe#(A)*//*=>>Enums.Maybe.None.*/ - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.Maybe#``().*//*=>>Enums.Maybe.Just#(A)*//*=>>Enums.Maybe.Just#``().*//*=>>Enums.Maybe.Just#copy().(A)*//*=>>Enums.Maybe.Just#copy().(value)*//*=>>Enums.Maybe.Just.apply().(A)*//*=>>Enums.Maybe.Just.apply().(value)*//*=>>Enums.Maybe.Just.unapply().(A)*/case Just/*<<=Enums.Maybe.Just#*/(value/*<<=Enums.Maybe.Just#``().*//*<<=Enums.Maybe.Just#``().(value)*//*<<=Enums.Maybe.Just#(value)*//*<<=Enums.Maybe.Just#copy().(value)*//*<<=Enums.Maybe.Just.apply().(value)*/: A/*=>>Enums.Maybe.Just#``().(A)*//*=>>Enums.Maybe.Just#(value)*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ + enum /*=>>java.lang.Object#``().*/Maybe/*<<=Enums.Maybe#*/[+A] {/*<<=Enums.Maybe#``().*//*<<=Enums.Maybe#``().[A]*//*<<=Enums.Maybe#[A]*//*=>>Enums.Maybe.None.*/ + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.Maybe#``().*//*=>>Enums.Maybe.Just#[A]*//*=>>Enums.Maybe.Just#``().*//*=>>Enums.Maybe.Just#copy().[A]*//*=>>Enums.Maybe.Just#copy().(value)*//*=>>Enums.Maybe.Just.apply().[A]*//*=>>Enums.Maybe.Just.apply().(value)*//*=>>Enums.Maybe.Just.unapply().[A]*/case Just/*<<=Enums.Maybe.Just#*/(value/*<<=Enums.Maybe.Just#``().*//*<<=Enums.Maybe.Just#``().(value)*//*<<=Enums.Maybe.Just#(value)*//*<<=Enums.Maybe.Just#copy().(value)*//*<<=Enums.Maybe.Just.apply().(value)*/: A/*=>>Enums.Maybe.Just#``().[A]*//*=>>Enums.Maybe.Just#(value)*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ /*=>>Enums.Maybe#``().*/case /*<<=local4*/None/*<<=Enums.Maybe.None.*//*=>>local5*//*=>>local4*/ } enum /*=>>java.lang.Object#``().*/Tag/*<<=Enums.Tag#*/[A] { -/*<<=Enums.Tag#``().*//*<<=Enums.Tag#``().(A)*//*<<=Enums.Tag#(A)*//*=>>Enums.Tag.IntTag.*//*=>>Enums.Tag.BooleanTag.*/ /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case IntTag/*<<=Enums.Tag.IntTag.*/ extends Tag/*=>>Enums.Tag#*/[I/*<<=local6*/nt/*=>>scala.Int#*/]/*=>>Enums.Tag#``().*//*=>>local7*//*=>>local6*/ +/*<<=Enums.Tag#``().*//*<<=Enums.Tag#``().[A]*//*<<=Enums.Tag#[A]*//*=>>Enums.Tag.IntTag.*//*=>>Enums.Tag.BooleanTag.*/ /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case IntTag/*<<=Enums.Tag.IntTag.*/ extends Tag/*=>>Enums.Tag#*/[I/*<<=local6*/nt/*=>>scala.Int#*/]/*=>>Enums.Tag#``().*//*=>>local7*//*=>>local6*/ case BooleanTag/*<<=Enums.Tag.BooleanTag.*/ extends Tag/*=>>Enums.Tag#*/[B/*<<=local8*/oolean/*=>>scala.Boolean#*/]/*=>>Enums.Tag#``().*//*=>>local9*//*=>>local8*/ } - enum /*=>>java.lang.Object#``().*/=:=/*<<=Enums.`=:=`#*/[A, B]/*<<=Enums.`=:=`#``().*//*<<=Enums.`=:=`#``().(A)*//*<<=Enums.`=:=`#(A)*//*<<=Enums.`=:=`#``().(B)*//*<<=Enums.`=:=`#(B)*/ { - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.`=:=`.Refl#``().*//*=>>Enums.`=:=`.Refl#copy().(C)*//*=>>Enums.`=:=`.Refl.apply().(C)*//*=>>Enums.`=:=`.Refl.unapply().(C)*/case Refl/*<<=Enums.`=:=`.Refl#*/[C]() /*<<=Enums.`=:=`.Refl#``().*//*<<=Enums.`=:=`.Refl#``().(C)*//*<<=Enums.`=:=`.Refl#(C)*//*<<=Enums.`=:=`.Refl#copy().(C)*//*<<=Enums.`=:=`.Refl.apply().(C)*//*<<=Enums.`=:=`.Refl.unapply().(C)*/extends (C/*=>>Enums.`=:=`.Refl#(C)*//*=>>Enums.`=:=`.Refl.apply().(C)*/ =:=/*=>>Enums.`=:=`#*/ C/*=>>Enums.`=:=`.Refl#(C)*//*=>>Enums.`=:=`.Refl.apply().(C)*//*=>>Enums.`=:=`#``().*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ + enum /*=>>java.lang.Object#``().*/=:=/*<<=Enums.`=:=`#*/[A, B]/*<<=Enums.`=:=`#``().*//*<<=Enums.`=:=`#``().[A]*//*<<=Enums.`=:=`#[A]*//*<<=Enums.`=:=`#``().[B]*//*<<=Enums.`=:=`#[B]*/ { + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.`=:=`.Refl#``().*//*=>>Enums.`=:=`.Refl#copy().[C]*//*=>>Enums.`=:=`.Refl.apply().[C]*//*=>>Enums.`=:=`.Refl.unapply().[C]*/case Refl/*<<=Enums.`=:=`.Refl#*/[C]() /*<<=Enums.`=:=`.Refl#``().*//*<<=Enums.`=:=`.Refl#``().[C]*//*<<=Enums.`=:=`.Refl#[C]*//*<<=Enums.`=:=`.Refl#copy().[C]*//*<<=Enums.`=:=`.Refl.apply().[C]*//*<<=Enums.`=:=`.Refl.unapply().[C]*/extends (C/*=>>Enums.`=:=`.Refl#[C]*//*=>>Enums.`=:=`.Refl.apply().[C]*/ =:=/*=>>Enums.`=:=`#*/ C/*=>>Enums.`=:=`.Refl#[C]*//*=>>Enums.`=:=`.Refl.apply().[C]*//*=>>Enums.`=:=`#``().*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ } - def unwrap/*<<=Enums.unwrap().*/[A/*<<=Enums.unwrap().(A)*/,B/*<<=Enums.unwrap().(B)*/](opt/*<<=Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>Enums.unwrap().(A)*/])(given ev/*<<=Enums.unwrap().(ev)*/: A/*=>>Enums.unwrap().(A)*/ =:=/*=>>Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().(B)*/]): Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().(B)*/] = { + def unwrap/*<<=Enums.unwrap().*/[A/*<<=Enums.unwrap().[A]*/,B/*<<=Enums.unwrap().[B]*/](opt/*<<=Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>Enums.unwrap().[A]*/])(given ev/*<<=Enums.unwrap().(ev)*/: A/*=>>Enums.unwrap().[A]*/ =:=/*=>>Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().[B]*/]): Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().[B]*/] = { ev/*=>>Enums.unwrap().(ev)*/ match { - case =:=/*=>>Enums.`=:=`.*/.Refl/*=>>Enums.`=:=`.Refl.*/() => opt/*=>>Enums.unwrap().(opt)*/.flatMap/*=>>scala.Option#flatMap().*/(identity/*=>>scala.Predef.identity().*/[Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().(B)*/]]) + case =:=/*=>>Enums.`=:=`.*/.Refl/*=>>Enums.`=:=`.Refl.*/() => opt/*=>>Enums.unwrap().(opt)*/.flatMap/*=>>scala.Option#flatMap().*/(identity/*=>>scala.Predef.identity().*/[Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().[B]*/]]) } } @@ -38,7 +38,7 @@ object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { def surfaceGravity/*<<=Enums.Planet#surfaceGravity().*/ = G/*=>>Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>Enums.Planet#(mass)*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>Enums.Planet#(radius)*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>Enums.Planet#(radius)*/) def surfaceWeight/*<<=Enums.Planet#surfaceWeight().*/(otherMass/*<<=Enums.Planet#surfaceWeight().(otherMass)*/: Double/*=>>scala.Double#*/) = otherMass/*=>>Enums.Planet#surfaceWeight().(otherMass)*/ */*=>>scala.Double#`*`(+6).*/ surfaceGravity/*=>>Enums.Planet#surfaceGravity().*/ - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case Mercury/*<<=Enums.Planet.$values.*//*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Planet.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Planet.valueOf().($name)*//*=>>java.util.NoSuchElementException#*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*/Plane/*<<=local10*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local11*//*=>>local10*/ + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case Mercury/*<<=Enums.Planet.$values.*//*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Planet.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Planet.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*/Plane/*<<=local10*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local11*//*=>>local10*/ case Venus/*<<=Enums.Planet.Venus.*/ extends Plane/*<<=local12*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local13*//*=>>local12*/ case Earth/*<<=Enums.Planet.Earth.*/ extends Plane/*<<=local14*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local15*//*=>>local14*/ case Mars/*<<=Enums.Planet.Mars.*/ extends Plane/*<<=local16*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local17*//*=>>local16*/ diff --git a/tests/semanticdb/Givens.expect.scala b/tests/semanticdb/Givens.expect.scala index dc72324052f4..d19fd7a5f3ae 100644 --- a/tests/semanticdb/Givens.expect.scala +++ b/tests/semanticdb/Givens.expect.scala @@ -4,18 +4,18 @@ package b object /*=>>java.lang.Object#``().*/Givens/*<<=a.b.Givens.*/ /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>a.b.Givens.*/given /*=>>java.lang.Object#``().*/:[A](any: A) - de/*<<=a.b.Givens.given_sayHello_of_A.*//*=>>a.b.Givens.given_sayHello_of_A.*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(A)*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>a.b.Givens.given_sayHello_of_A.sayHello().(A)*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/f sayHello/*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s"/*=>>scala.StringContext.*//*=>>scala.*//*=>>_root_*/Hello, I am $any/*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>scala.StringContext#s().*/" + de/*<<=a.b.Givens.given_sayHello_of_A.*//*=>>a.b.Givens.given_sayHello_of_A.*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().[A]*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>a.b.Givens.given_sayHello_of_A.sayHello().[A]*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/f sayHello/*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s"/*=>>scala.StringContext.*//*=>>scala.*//*=>>_root_*/Hello, I am $any/*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>scala.StringContext#s().*/" val hello1/*<<=a.b.Givens.hello1.*/ = /*=>>a.b.Givens.given_sayHello_of_A.sayHello().*//*=>>a.b.Givens.given_sayHello_of_A.*/1.sayHello trait Monoid/*<<=a.b.Givens.Monoid#*/[A] - /*<<=a.b.Givens.Monoid#``().*//*<<=a.b.Givens.Monoid#``().(A)*//*<<=a.b.Givens.Monoid#(A)*/ def empty/*<<=a.b.Givens.Monoid#empty().*/: A/*=>>a.b.Givens.Monoid#(A)*/ - def (x: A) /*<<=a.b.Givens.Monoid#combine().*//*<<=a.b.Givens.Monoid#combine().(x)*//*=>>a.b.Givens.Monoid#(A)*/combine (y/*<<=a.b.Givens.Monoid#combine().(y)*/: A/*=>>a.b.Givens.Monoid#(A)*/): A/*=>>a.b.Givens.Monoid#(A)*/ + /*<<=a.b.Givens.Monoid#``().*//*<<=a.b.Givens.Monoid#``().[A]*//*<<=a.b.Givens.Monoid#[A]*/ def empty/*<<=a.b.Givens.Monoid#empty().*/: A/*=>>a.b.Givens.Monoid#[A]*/ + def (x: A) /*<<=a.b.Givens.Monoid#combine().*//*<<=a.b.Givens.Monoid#combine().(x)*//*=>>a.b.Givens.Monoid#[A]*/combine (y/*<<=a.b.Givens.Monoid#combine().(y)*/: A/*=>>a.b.Givens.Monoid#[A]*/): A/*=>>a.b.Givens.Monoid#[A]*/ given /*=>>java.lang.Object#``().*//*=>>a.b.Givens.given_Monoid_String.*/Monoid/*=>>a.b.Givens.Monoid#*/[String] /*<<=a.b.Givens.given_Monoid_String.*//*=>>scala.Predef.String#*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/def empty/*<<=a.b.Givens.given_Monoid_String.empty().*/ = "" def (x: Str/*<<=a.b.Givens.given_Monoid_String.combine().*//*<<=a.b.Givens.given_Monoid_String.combine().(x)*/ing/*=>>scala.Predef.String#*/) combine (y/*<<=a.b.Givens.given_Monoid_String.combine().(y)*/: String/*=>>scala.Predef.String#*/) = x/*=>>a.b.Givens.given_Monoid_String.combine().(x)*/ +/*=>>java.lang.String#`+`().*/ y/*=>>a.b.Givens.given_Monoid_String.combine().(y)*/ - inline given int2String/*<<=a.b.Givens.int2String().*/: Conversion/*=>>scala.Conversion#*/[Int/*=>>scala.Int#*/, String/*=>>scala.Predef.String#*/] = _/*=>>local0*/.toString/*=>>scala.Any#toString().*/ + inline given int2String/*<<=a.b.Givens.int2String().*/: Conversion/*=>>scala.Conversion#*/[Int/*=>>scala.Int#*/, String/*=>>scala.Predef.String#*/] = _.toString/*=>>scala.Any#toString().*/ - def foo/*<<=a.b.Givens.foo().*/[A/*<<=a.b.Givens.foo().(A)*/](given A/*<<=a.b.Givens.foo().(A)*/: Monoid/*=>>a.b.Givens.Monoid#*/[A/*=>>a.b.Givens.foo().(A)*/]): A/*=>>a.b.Givens.foo().(A)*/ = A/*=>>a.b.Givens.foo().(A)*/.combine/*=>>a.b.Givens.Monoid#combine().*/(A/*=>>a.b.Givens.foo().(A)*/.empty/*=>>a.b.Givens.Monoid#empty().*/)(A/*=>>a.b.Givens.foo().(A)*/.empty/*=>>a.b.Givens.Monoid#empty().*/) + def foo/*<<=a.b.Givens.foo().*/[A/*<<=a.b.Givens.foo().[A]*/](given A/*<<=a.b.Givens.foo().(A)*/: Monoid/*=>>a.b.Givens.Monoid#*/[A/*=>>a.b.Givens.foo().[A]*/]): A/*=>>a.b.Givens.foo().[A]*/ = A/*=>>a.b.Givens.foo().(A)*/.combine/*=>>a.b.Givens.Monoid#combine().*/(A/*=>>a.b.Givens.foo().(A)*/.empty/*=>>a.b.Givens.Monoid#empty().*/)(A/*=>>a.b.Givens.foo().(A)*/.empty/*=>>a.b.Givens.Monoid#empty().*/) From df24fbc76f130df5ee5592367e88c039a9a02be2 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 18 Oct 2019 15:26:55 +0200 Subject: [PATCH 028/107] don't emit occurrences for anonymous symbols --- .../dotc/semanticdb/ExtractSemanticDB.scala | 8 +++++- tests/semanticdb/Advanced.expect.scala | 8 +++--- tests/semanticdb/Anonymous.expect.scala | 2 +- tests/semanticdb/Enums.expect.scala | 26 +++++++++---------- 4 files changed, 25 insertions(+), 19 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 0bb218c8f398..5c8cc83fe32d 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -150,7 +150,13 @@ class ExtractSemanticDB extends Phase { /** Definitions of this symbol should be excluded from semanticdb */ private def excludeDef(sym: Symbol)(given Context): Boolean = - !sym.exists || sym.isLocalDummy || sym.is(Synthetic) + !sym.exists + || sym.isLocalDummy + || sym.is(Synthetic) + || sym.isAnonymousClass + || sym.isAnonymousModuleVal + || sym.isAnonymousFunction + || sym.isPrimaryConstructor && excludeDef(sym.owner) /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ private def excludeUse(sym: Symbol, span: Span)(given Context): Boolean = diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/Advanced.expect.scala index 1d5a22ac0eef..02c7ecd244d2 100644 --- a/tests/semanticdb/Advanced.expect.scala +++ b/tests/semanticdb/Advanced.expect.scala @@ -11,8 +11,8 @@ class /*=>>java.lang.Object#``().*/C/*<<=advanced.C#*/[T] { class /*=>>java.lang.Object#``().*/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#*/ } = /*=>>java.lang.Object#``().*/new {/*<<=local2*/ val x/*<<=local3*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ }/*=>>local4*//*=>>local2*/ - def s3/*<<=advanced.Structural#s3().*/: { def m/*<<=local5*/(x/*<<=local6*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ } = /*=>>java.lang.Object#``().*/new {/*<<=local7*/ def m/*<<=local8*/(x/*<<=local9*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ }/*=>>local10*//*=>>local7*/ + def s2/*<<=advanced.Structural#s2().*/: { val x/*<<=local1*/: Int/*=>>scala.Int#*/ } = /*=>>java.lang.Object#``().*/new { val x/*<<=local2*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } + def s3/*<<=advanced.Structural#s3().*/: { def m/*<<=local3*/(x/*<<=local4*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ } = /*=>>java.lang.Object#``().*/new { def m/*<<=local5*/(x/*<<=local6*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } } class /*=>>java.lang.Object#``().*/Wildcards/*<<=advanced.Wildcards#*/ { @@ -34,8 +34,8 @@ object /*=>>java.lang.Object#``().*/Test/*<<=advanced.Test.*/ { { (???/*=>>scala.Predef.`???`().*/ : Any/*=>>scala.Any#*/) match { - case e3/*<<=local11*/: List/*=>>scala.package.List#*/[_] => - val e3x/*<<=local12*/ = e3/*=>>local11*/.head/*=>>scala.collection.IterableOps#head().*/ + case e3/*<<=local7*/: List/*=>>scala.package.List#*/[_] => + val e3x/*<<=local8*/ = e3/*=>>local7*/.head/*=>>scala.collection.IterableOps#head().*/ () } } diff --git a/tests/semanticdb/Anonymous.expect.scala b/tests/semanticdb/Anonymous.expect.scala index 4a4e85ba3f45..3c920933abd8 100644 --- a/tests/semanticdb/Anonymous.expect.scala +++ b/tests/semanticdb/Anonymous.expect.scala @@ -16,5 +16,5 @@ class /*=>>java.lang.Object#``().*/Anonymous/*<<=example.Anonymous#*/ { } trait Foo/*<<=example.Anonymous#Foo#*/ - /*=>>java.lang.Object#``().*/new F/*<<=local1*/oo/*=>>example.Anonymous#Foo#*/ {}/*=>>local2*//*=>>local1*/ + /*=>>java.lang.Object#``().*/new Foo/*=>>example.Anonymous#Foo#*/ {} } diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala index f4d9e5e2f5c6..70c3eddfb172 100644 --- a/tests/semanticdb/Enums.expect.scala +++ b/tests/semanticdb/Enums.expect.scala @@ -1,10 +1,10 @@ object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.*/enum /*=>>java.lang.Object#``().*/Colour/*<<=Enums.Colour#*/ { - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Colour.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Colour.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.Colour#``().*//*=>>Enums.Colour.$new().(_$ordinal)*//*=>>Enums.Colour.$new().($name)*//*=>>scala.runtime.EnumValues#register().*//*=>>local0*//*=>>local1*/Red/*=>>Enums.Colour.Red.*//*<<=Enums.Colour.Red.*/, Gr/*<<=Enums.Colour.$values.*/een/*=>>Enums.Colour.Green.*//*<<=Enums.Colour.Green.*/, Blue/*=>>Enums.Colour.Blue.*//*<<=Enums.Colour.Blue.*/ + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Colour.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Colour.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.Colour#``().*//*=>>Enums.Colour.$new().(_$ordinal)*//*=>>Enums.Colour.$new().($name)*//*=>>scala.runtime.EnumValues#register().*/Red/*=>>Enums.Colour.Red.*//*<<=Enums.Colour.Red.*/, Gr/*<<=Enums.Colour.$values.*/een/*=>>Enums.Colour.Green.*//*<<=Enums.Colour.Green.*/, Blue/*=>>Enums.Colour.Blue.*//*<<=Enums.Colour.Blue.*/ } enum /*=>>java.lang.Object#``().*/WeekDays/*<<=Enums.WeekDays#*/ { - /*=>>Enums.WeekDays.Monday.*//*=>>Enums.WeekDays.Tuesday.*//*=>>Enums.WeekDays.Wednesday.*//*=>>Enums.WeekDays.Thursday.*//*=>>Enums.WeekDays.Friday.*//*=>>Enums.WeekDays.Saturday.*//*=>>Enums.WeekDays.Sunday.*//*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.WeekDays.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.WeekDays.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.WeekDays#``().*//*=>>Enums.WeekDays.$new().(_$ordinal)*//*=>>Enums.WeekDays.$new().($name)*//*=>>scala.runtime.EnumValues#register().*//*=>>local2*//*=>>local3*/case Monday/*<<=Enums.WeekDays.Monday.*/ + /*=>>Enums.WeekDays.Monday.*//*=>>Enums.WeekDays.Tuesday.*//*=>>Enums.WeekDays.Wednesday.*//*=>>Enums.WeekDays.Thursday.*//*=>>Enums.WeekDays.Friday.*//*=>>Enums.WeekDays.Saturday.*//*=>>Enums.WeekDays.Sunday.*//*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.WeekDays.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.WeekDays.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.WeekDays#``().*//*=>>Enums.WeekDays.$new().(_$ordinal)*//*=>>Enums.WeekDays.$new().($name)*//*=>>scala.runtime.EnumValues#register().*/case Monday/*<<=Enums.WeekDays.Monday.*/ /*<<=Enums.WeekDays.$values.*/ case Tuesday/*<<=Enums.WeekDays.Tuesday.*/ case Wednesday/*<<=Enums.WeekDays.Wednesday.*/ case Thursday/*<<=Enums.WeekDays.Thursday.*/ @@ -15,12 +15,12 @@ object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { enum /*=>>java.lang.Object#``().*/Maybe/*<<=Enums.Maybe#*/[+A] {/*<<=Enums.Maybe#``().*//*<<=Enums.Maybe#``().[A]*//*<<=Enums.Maybe#[A]*//*=>>Enums.Maybe.None.*/ /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.Maybe#``().*//*=>>Enums.Maybe.Just#[A]*//*=>>Enums.Maybe.Just#``().*//*=>>Enums.Maybe.Just#copy().[A]*//*=>>Enums.Maybe.Just#copy().(value)*//*=>>Enums.Maybe.Just.apply().[A]*//*=>>Enums.Maybe.Just.apply().(value)*//*=>>Enums.Maybe.Just.unapply().[A]*/case Just/*<<=Enums.Maybe.Just#*/(value/*<<=Enums.Maybe.Just#``().*//*<<=Enums.Maybe.Just#``().(value)*//*<<=Enums.Maybe.Just#(value)*//*<<=Enums.Maybe.Just#copy().(value)*//*<<=Enums.Maybe.Just.apply().(value)*/: A/*=>>Enums.Maybe.Just#``().[A]*//*=>>Enums.Maybe.Just#(value)*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ - /*=>>Enums.Maybe#``().*/case /*<<=local4*/None/*<<=Enums.Maybe.None.*//*=>>local5*//*=>>local4*/ + /*=>>Enums.Maybe#``().*/case None/*<<=Enums.Maybe.None.*/ } enum /*=>>java.lang.Object#``().*/Tag/*<<=Enums.Tag#*/[A] { -/*<<=Enums.Tag#``().*//*<<=Enums.Tag#``().[A]*//*<<=Enums.Tag#[A]*//*=>>Enums.Tag.IntTag.*//*=>>Enums.Tag.BooleanTag.*/ /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case IntTag/*<<=Enums.Tag.IntTag.*/ extends Tag/*=>>Enums.Tag#*/[I/*<<=local6*/nt/*=>>scala.Int#*/]/*=>>Enums.Tag#``().*//*=>>local7*//*=>>local6*/ - case BooleanTag/*<<=Enums.Tag.BooleanTag.*/ extends Tag/*=>>Enums.Tag#*/[B/*<<=local8*/oolean/*=>>scala.Boolean#*/]/*=>>Enums.Tag#``().*//*=>>local9*//*=>>local8*/ +/*<<=Enums.Tag#``().*//*<<=Enums.Tag#``().[A]*//*<<=Enums.Tag#[A]*//*=>>Enums.Tag.IntTag.*//*=>>Enums.Tag.BooleanTag.*/ /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case IntTag/*<<=Enums.Tag.IntTag.*/ extends Tag/*=>>Enums.Tag#*/[Int/*=>>scala.Int#*/]/*=>>Enums.Tag#``().*/ + case BooleanTag/*<<=Enums.Tag.BooleanTag.*/ extends Tag/*=>>Enums.Tag#*/[Boolean/*=>>scala.Boolean#*/]/*=>>Enums.Tag#``().*/ } enum /*=>>java.lang.Object#``().*/=:=/*<<=Enums.`=:=`#*/[A, B]/*<<=Enums.`=:=`#``().*//*<<=Enums.`=:=`#``().[A]*//*<<=Enums.`=:=`#[A]*//*<<=Enums.`=:=`#``().[B]*//*<<=Enums.`=:=`#[B]*/ { @@ -38,13 +38,13 @@ object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { def surfaceGravity/*<<=Enums.Planet#surfaceGravity().*/ = G/*=>>Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>Enums.Planet#(mass)*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>Enums.Planet#(radius)*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>Enums.Planet#(radius)*/) def surfaceWeight/*<<=Enums.Planet#surfaceWeight().*/(otherMass/*<<=Enums.Planet#surfaceWeight().(otherMass)*/: Double/*=>>scala.Double#*/) = otherMass/*=>>Enums.Planet#surfaceWeight().(otherMass)*/ */*=>>scala.Double#`*`(+6).*/ surfaceGravity/*=>>Enums.Planet#surfaceGravity().*/ - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case Mercury/*<<=Enums.Planet.$values.*//*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Planet.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Planet.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*/Plane/*<<=local10*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local11*//*=>>local10*/ - case Venus/*<<=Enums.Planet.Venus.*/ extends Plane/*<<=local12*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local13*//*=>>local12*/ - case Earth/*<<=Enums.Planet.Earth.*/ extends Plane/*<<=local14*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local15*//*=>>local14*/ - case Mars/*<<=Enums.Planet.Mars.*/ extends Plane/*<<=local16*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local17*//*=>>local16*/ - case Jupiter/*<<=Enums.Planet.Jupiter.*/ extends Plane/*<<=local18*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local19*//*=>>local18*/ - case Saturn/*<<=Enums.Planet.Saturn.*/ extends Plane/*<<=local20*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local21*//*=>>local20*/ - case Uranus/*<<=Enums.Planet.Uranus.*/ extends Plane/*<<=local22*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local23*//*=>>local22*/ - case Neptune/*<<=Enums.Planet.Neptune.*/ extends Plane/*<<=local24*/t/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*//*=>>local25*//*=>>local24*/ + /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case Mercury/*<<=Enums.Planet.$values.*//*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Planet.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Planet.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*/Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ + case Venus/*<<=Enums.Planet.Venus.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ + case Earth/*<<=Enums.Planet.Earth.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ + case Mars/*<<=Enums.Planet.Mars.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ + case Jupiter/*<<=Enums.Planet.Jupiter.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ + case Saturn/*<<=Enums.Planet.Saturn.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ + case Uranus/*<<=Enums.Planet.Uranus.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ + case Neptune/*<<=Enums.Planet.Neptune.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ } } From 3c0a4a700cf001bba66dd3e319fff127893a546f Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Mon, 21 Oct 2019 16:18:24 +0200 Subject: [PATCH 029/107] Ignore noise in templates and children of synthetics --- .../dotc/semanticdb/ExtractSemanticDB.scala | 44 ++++++++++++++----- .../dotc/semanticdb/SemanticdbTests.scala | 1 + tests/semanticdb/Access.expect.scala | 2 +- tests/semanticdb/Advanced.expect.scala | 16 +++---- tests/semanticdb/Annotations.expect.scala | 12 ++--- tests/semanticdb/Anonymous.expect.scala | 4 +- tests/semanticdb/Classes.expect.scala | 33 ++++++++++++++ tests/semanticdb/Classes.scala | 33 ++++++++++++++ tests/semanticdb/Definitions.expect.scala | 6 +-- tests/semanticdb/Enums.expect.scala | 44 +++++++++---------- tests/semanticdb/Givens.expect.scala | 14 +++--- tests/semanticdb/NewModifiers.expect.scala | 4 +- .../semanticdb-extract.expect.scala | 12 ++--- tests/semanticdb/toplevel.expect.scala | 2 +- 14 files changed, 158 insertions(+), 69 deletions(-) create mode 100644 tests/semanticdb/Classes.expect.scala create mode 100644 tests/semanticdb/Classes.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 5c8cc83fe32d..e1da4cde315a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -91,13 +91,13 @@ class ExtractSemanticDB extends Phase { addDescriptor(sym.sourceModule) else if sym.is(TypeParam) then b.append('['); addName(sym.name); b.append(']') - else if sym.is(Param) || sym.is(ParamAccessor) then + else if sym.is(Param) then b.append('('); addName(sym.name); b.append(')') else addName(sym.name) if sym.is(Package) then b.append('/') else if sym.isType then b.append('#') - else if sym.is(Method) && (!sym.is(Accessor) || sym.is(Mutable)) then + else if sym.is(Method) || (sym.isOneOf(Accessor | Local) && sym.is(Mutable)) then b.append('('); addOverloadIdx(sym); b.append(").") else b.append('.') @@ -152,11 +152,14 @@ class ExtractSemanticDB extends Phase { private def excludeDef(sym: Symbol)(given Context): Boolean = !sym.exists || sym.isLocalDummy - || sym.is(Synthetic) - || sym.isAnonymousClass + || sym.is(Synthetic) || (sym.owner.is(Synthetic) && !sym.isAllOf(EnumCase)) + || sym.isAnonymous + || sym.isPrimaryConstructor && excludeDef(sym.owner) + + private def (sym: Symbol) isAnonymous(given Context): Boolean = + sym.isAnonymousClass || sym.isAnonymousModuleVal || sym.isAnonymousFunction - || sym.isPrimaryConstructor && excludeDef(sym.owner) /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ private def excludeUse(sym: Symbol, span: Span)(given Context): Boolean = @@ -196,6 +199,24 @@ class ExtractSemanticDB extends Phase { if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => registerDefinition(tree.symbol, tree.nameSpan) traverseChildren(tree) + case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip + case tree: Template => + for + vparams <- tree.constr.vparamss + vparam <- vparams + do + traverse(vparam.tpt) // the accessor symbol is traversed in the body + for parent <- tree.parentsOrDerived do + if + parent.symbol != defn.ObjectClass.primaryConstructor + && parent.tpe.dealias != defn.SerializableType + && parent.symbol != defn.ProductClass + then + traverse(parent) + val selfSpan = tree.self.span + if selfSpan.exists && selfSpan.start != selfSpan.end then + traverse(tree.self) + tree.body.foreach(traverse) case tree: Ident => if tree.name != nme.WILDCARD && !excludeUse(tree.symbol, tree.span) then registerUse(tree.symbol, tree.span) @@ -211,12 +232,13 @@ class ExtractSemanticDB extends Phase { registerUse(tree.symbol, Span(start max limit, end)) traverseChildren(tree) case tree: Import => - for sel <- tree.selectors do - val imported = sel.imported.name - if imported != nme.WILDCARD then - for alt <- tree.expr.tpe.member(imported).alternatives do - registerUse(alt.symbol, sel.imported.span) - registerPath(tree.expr) + if tree.span.exists && tree.span.start != tree.span.end then + for sel <- tree.selectors do + val imported = sel.imported.name + if imported != nme.WILDCARD then + for alt <- tree.expr.tpe.member(imported).alternatives do + registerUse(alt.symbol, sel.imported.span) + registerPath(tree.expr) case tree: Inlined => traverse(tree.call) case tree: PackageDef => tree.stats.foreach(traverse) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index f066d2d8fe26..10448fad61b2 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -64,6 +64,7 @@ class SemanticdbTests { val args = Array( "-Ysemanticdb", "-d", target.toString, + // "-Ydebug", // "-Xprint:extractSemanticDB", "-sourceroot", src.toString, "-usejavacp", diff --git a/tests/semanticdb/Access.expect.scala b/tests/semanticdb/Access.expect.scala index 354ac473ee85..fd693daf69c6 100644 --- a/tests/semanticdb/Access.expect.scala +++ b/tests/semanticdb/Access.expect.scala @@ -1,6 +1,6 @@ package example -class /*=>>java.lang.Object#``().*/Access/*<<=example.Access#*/ { +class Access/*<<=example.Access#*/ { private def m1/*<<=example.Access#m1().*/ = ???/*=>>scala.Predef.`???`().*/ private[this] def m2/*<<=example.Access#m2().*/ = ???/*=>>scala.Predef.`???`().*/ private[Access] def m3/*<<=example.Access#m3().*/ = ???/*=>>scala.Predef.`???`().*/ diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/Advanced.expect.scala index 02c7ecd244d2..042ac6e66f00 100644 --- a/tests/semanticdb/Advanced.expect.scala +++ b/tests/semanticdb/Advanced.expect.scala @@ -5,22 +5,22 @@ import scala.language/*=>>scalaShadowing.language.*/.reflectiveCalls/*=>>scalaSh import scala.reflect/*=>>scala.reflect.*/.Selectable/*=>>scala.reflect.Selectable.*/.reflectiveSelectable/*=>>scala.reflect.Selectable.reflectiveSelectable().*/ -class /*=>>java.lang.Object#``().*/C/*<<=advanced.C#*/[T] { -/*<<=advanced.C#``().*//*<<=advanced.C#``().[T]*//*<<=advanced.C#[T]*/ def t/*<<=advanced.C#t().*/: T/*=>>advanced.C#[T]*/ = ???/*=>>scala.Predef.`???`().*/ +class C/*<<=advanced.C#*/[T/*<<=advanced.C#[T]*/] { + def t/*<<=advanced.C#t().*/: T/*=>>advanced.C#[T]*/ = ???/*=>>scala.Predef.`???`().*/ } -class /*=>>java.lang.Object#``().*/Structural/*<<=advanced.Structural#*/ { +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#*/ } = /*=>>java.lang.Object#``().*/new { val x/*<<=local2*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } - def s3/*<<=advanced.Structural#s3().*/: { def m/*<<=local3*/(x/*<<=local4*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ } = /*=>>java.lang.Object#``().*/new { def m/*<<=local5*/(x/*<<=local6*/: 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/*<<=local3*/(x/*<<=local4*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ } = new { def m/*<<=local5*/(x/*<<=local6*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } } -class /*=>>java.lang.Object#``().*/Wildcards/*<<=advanced.Wildcards#*/ { +class Wildcards/*<<=advanced.Wildcards#*/ { def e1/*<<=advanced.Wildcards#e1().*/: List/*=>>scala.package.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ } -object /*=>>java.lang.Object#``().*/Test/*<<=advanced.Test.*/ { - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>advanced.Test.*/val s/*<<=advanced.Test.s.*/ = new Structural/*=>>advanced.Structural#*//*=>>advanced.Structural#``().*/ +object Test/*<<=advanced.Test.*/ { + val s/*<<=advanced.Test.s.*/ = new Structural/*=>>advanced.Structural#*//*=>>advanced.Structural#``().*/ val s1/*<<=advanced.Test.s1.*/ = s/*=>>advanced.Test.s.*/.s1/*=>>advanced.Structural#s1().*/ val s1x/*<<=advanced.Test.s1x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s1/*=>>advanced.Structural#s1().*//*=>>scala.Selectable#selectDynamic().*/.x val s2/*<<=advanced.Test.s2.*/ = s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*/ diff --git a/tests/semanticdb/Annotations.expect.scala b/tests/semanticdb/Annotations.expect.scala index 87c6da3dc0d0..903f1c18ec78 100644 --- a/tests/semanticdb/Annotations.expect.scala +++ b/tests/semanticdb/Annotations.expect.scala @@ -5,7 +5,7 @@ import scala.annotation.meta._ import scala.language/*=>>scalaShadowing.language.*/.experimental/*=>>scalaShadowing.language.experimental.*/.macros/*=>>scalaShadowing.language.experimental.macros.*/ @ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ -class /*=>>java.lang.Object#``().*/Annotations/*<<=annot.Annotations#*/[@Type/*<<=annot.Annotations#``().*/ParameterAnnotation/*=>>com.javacp.annot.TypeParameterAnnotation#*/ T/*<<=annot.Annotations#``().[T]*//*<<=annot.Annotations#[T]*/](@ParameterAnnotation/*=>>com.javacp.annot.ParameterAnnotation#*/ x/*<<=annot.Annotations#``().(x)*//*<<=annot.Annotations#(x)*/: T/*=>>annot.Annotations#``().[T]*/) { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => +class Annotations/*<<=annot.Annotations#*/[@TypeParameterAnnotation/*=>>com.javacp.annot.TypeParameterAnnotation#*/ T/*<<=annot.Annotations#[T]*/](@ParameterAnnotation/*=>>com.javacp.annot.ParameterAnnotation#*/ x/*<<=annot.Annotations#x.*/: T/*=>>annot.Annotations#``().[T]*/) { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => @FieldAnnotation/*=>>com.javacp.annot.FieldAnnotation#*/ val field/*<<=annot.Annotations#field.*/ = 42 @@ -19,20 +19,20 @@ class /*=>>java.lang.Object#``().*/Annotations/*<<=annot.Annotations#*/[@T type S/*<<=annot.Annotations#S#*/ } -class /*=>>java.lang.Object#``().*/B/*<<=annot.B#*/ @Cons/*<<=annot.B#``().*/tructorAnnotation/*=>>com.javacp.annot.ConstructorAnnotation#*/()(x/*<<=annot.B#``().(x)*//*<<=annot.B#(x)*/: Int/*=>>scala.Int#*/) { +class B/*<<=annot.B#*/ @ConstructorAnnotation/*=>>com.javacp.annot.ConstructorAnnotation#*/()(x/*<<=annot.B#x.*/: Int/*=>>scala.Int#*/) { @ConstructorAnnotation/*=>>com.javacp.annot.ConstructorAnnotation#*/ def this()/*<<=annot.B#``(+1).*/ = this(/*=>>annot.B#``().*/42) } @ObjectAnnotation/*=>>com.javacp.annot.ObjectAnnotation#*/ -object /*=>>java.lang.Object#``().*/M/*<<=annot.M.*/ { - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>annot.M.*/@MacroAnnotation/*=>>com.javacp.annot.MacroAnnotation#*/ +object M/*<<=annot.M.*/ { + @MacroAnnotation/*=>>com.javacp.annot.MacroAnnotation#*/ def m/*<<=annot.M.m().*/[TT/*<<=annot.M.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*//*=>>scala.Predef.*//*=>>scala.*//*=>>_root_*/ = macro ??? } @TraitAnnotation/*=>>com.javacp.annot.TraitAnnotation#*/ trait T/*<<=annot.T#*/ -object /*=>>java.lang.Object#``().*/Alias/*<<=annot.Alias.*/ { - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>annot.Alias.*/type A/*<<=annot.Alias.A#*/ = ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ @param +object Alias/*<<=annot.Alias.*/ { + type A/*<<=annot.Alias.A#*/ = ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ @param } diff --git a/tests/semanticdb/Anonymous.expect.scala b/tests/semanticdb/Anonymous.expect.scala index 3c920933abd8..bd1084ee6813 100644 --- a/tests/semanticdb/Anonymous.expect.scala +++ b/tests/semanticdb/Anonymous.expect.scala @@ -1,7 +1,7 @@ package example import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ -class /*=>>java.lang.Object#``().*/Anonymous/*<<=example.Anonymous#*/ { +class Anonymous/*<<=example.Anonymous#*/ { this: Anonymous/*=>>example.Anonymous#*/ => def locally/*<<=example.Anonymous#locally().*/[A/*<<=example.Anonymous#locally().[A]*/](x/*<<=example.Anonymous#locally().(x)*/: A/*=>>example.Anonymous#locally().[A]*/): A/*=>>example.Anonymous#locally().[A]*/ = x/*=>>example.Anonymous#locally().(x)*/ @@ -16,5 +16,5 @@ class /*=>>java.lang.Object#``().*/Anonymous/*<<=example.Anonymous#*/ { } trait Foo/*<<=example.Anonymous#Foo#*/ - /*=>>java.lang.Object#``().*/new Foo/*=>>example.Anonymous#Foo#*/ {} + new Foo/*=>>example.Anonymous#Foo#*/ {} } diff --git a/tests/semanticdb/Classes.expect.scala b/tests/semanticdb/Classes.expect.scala new file mode 100644 index 000000000000..18b30e58890d --- /dev/null +++ b/tests/semanticdb/Classes.expect.scala @@ -0,0 +1,33 @@ +package classes + +class C1/*<<=classes.C1#*/(val x1/*<<=classes.C1#x1.*/: Int/*=>>scala.Int#*/) extends AnyVal/*=>>scala.AnyVal#*//*=>>scala.AnyVal#``().*/ + +class C2/*<<=classes.C2#*/(val x2/*<<=classes.C2#x2.*/: Int/*=>>scala.Int#*/) extends AnyVal/*=>>scala.AnyVal#*//*=>>scala.AnyVal#``().*/ +object C2/*<<=classes.C2.*/ + +case class C3/*<<=classes.C3#*/(x/*<<=classes.C3#x.*/: Int/*=>>scala.Int#*/) + +case class C4/*<<=classes.C4#*/(x/*<<=classes.C4#x.*/: Int/*=>>scala.Int#*/) +object C4/*<<=classes.C4.*/ + +object M/*<<=classes.M.*/ { + implicit class C5/*<<=classes.M.C5#*/(x/*<<=classes.M.C5#x.*/: Int/*=>>scala.Int#*/) +} + +case class C6/*<<=classes.C6#*/(private val x/*<<=classes.C6#x.*/: Int/*=>>scala.Int#*/) + +class C7/*<<=classes.C7#*/(x/*<<=classes.C7#x.*/: Int/*=>>scala.Int#*/) + +class C8/*<<=classes.C8#*/(private[this] val x/*<<=classes.C8#x.*/: Int/*=>>scala.Int#*/) + +class C9/*<<=classes.C9#*/(private[this] var x/*<<=classes.C9#x().*/: Int/*=>>scala.Int#*/) + +object N/*<<=classes.N.*/ { + val anonClass/*<<=classes.N.anonClass.*/ = new C7/*=>>classes.C7#*//*=>>classes.C7#``().*/(42) { + 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 => + val local = 2 + local/*=>>local1*/ +/*=>>scala.Int#`+`(+4).*/ 2 + } +} diff --git a/tests/semanticdb/Classes.scala b/tests/semanticdb/Classes.scala new file mode 100644 index 000000000000..a1cfbbd9aee1 --- /dev/null +++ b/tests/semanticdb/Classes.scala @@ -0,0 +1,33 @@ +package classes + +class C1(val x1: Int) extends AnyVal + +class C2(val x2: Int) extends AnyVal +object C2 + +case class C3(x: Int) + +case class C4(x: Int) +object C4 + +object M { + implicit class C5(x: Int) +} + +case class C6(private val x: Int) + +class C7(x: Int) + +class C8(private[this] val x: Int) + +class C9(private[this] var x: Int) + +object N { + val anonClass = new C7(42) { + val local = ??? + } + val anonFun = List(1).map { i => + val local = 2 + local + 2 + } +} diff --git a/tests/semanticdb/Definitions.expect.scala b/tests/semanticdb/Definitions.expect.scala index 74cf02666da2..020a1f40426c 100644 --- a/tests/semanticdb/Definitions.expect.scala +++ b/tests/semanticdb/Definitions.expect.scala @@ -1,8 +1,8 @@ package a -object /*=>>java.lang.Object#``().*/Definitions/*<<=a.Definitions.*/ { - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>a.Definitions.*/val a/*<<=a.Definitions.a.*/ = 1 +object Definitions/*<<=a.Definitions.*/ { + val a/*<<=a.Definitions.a.*/ = 1 var b/*<<=a.Definitions.b.*/ =/*<<=a.Definitions.`b_=`().*/ 2 def c/*<<=a.Definitions.c().*/ = 3 - class /*=>>java.lang.Object#``().*/D/*<<=a.Definitions.D#*/ + class D/*<<=a.Definitions.D#*/ trait E/*<<=a.Definitions.E#*/ } diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala index 70c3eddfb172..358b54d326e5 100644 --- a/tests/semanticdb/Enums.expect.scala +++ b/tests/semanticdb/Enums.expect.scala @@ -1,11 +1,11 @@ -object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.*/enum /*=>>java.lang.Object#``().*/Colour/*<<=Enums.Colour#*/ { - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Colour.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Colour.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.Colour#``().*//*=>>Enums.Colour.$new().(_$ordinal)*//*=>>Enums.Colour.$new().($name)*//*=>>scala.runtime.EnumValues#register().*/Red/*=>>Enums.Colour.Red.*//*<<=Enums.Colour.Red.*/, Gr/*<<=Enums.Colour.$values.*/een/*=>>Enums.Colour.Green.*//*<<=Enums.Colour.Green.*/, Blue/*=>>Enums.Colour.Blue.*//*<<=Enums.Colour.Blue.*/ +object Enums/*<<=Enums.*/ { + enum Colour/*<<=Enums.Colour#*/ { + case /*=>>scala.runtime.EnumValues#``().*/Red/*=>>Enums.Colour.Red.*//*<<=Enums.Colour.Red.*/, Green/*=>>Enums.Colour.Green.*//*<<=Enums.Colour.Green.*/, Blue/*=>>Enums.Colour.Blue.*//*<<=Enums.Colour.Blue.*/ } - enum /*=>>java.lang.Object#``().*/WeekDays/*<<=Enums.WeekDays#*/ { - /*=>>Enums.WeekDays.Monday.*//*=>>Enums.WeekDays.Tuesday.*//*=>>Enums.WeekDays.Wednesday.*//*=>>Enums.WeekDays.Thursday.*//*=>>Enums.WeekDays.Friday.*//*=>>Enums.WeekDays.Saturday.*//*=>>Enums.WeekDays.Sunday.*//*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.WeekDays.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.WeekDays.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*//*=>>Enums.WeekDays#``().*//*=>>Enums.WeekDays.$new().(_$ordinal)*//*=>>Enums.WeekDays.$new().($name)*//*=>>scala.runtime.EnumValues#register().*/case Monday/*<<=Enums.WeekDays.Monday.*/ -/*<<=Enums.WeekDays.$values.*/ case Tuesday/*<<=Enums.WeekDays.Tuesday.*/ + enum WeekDays/*<<=Enums.WeekDays#*/ { + /*=>>scala.runtime.EnumValues#``().*/case Monday/*<<=Enums.WeekDays.Monday.*/ + case Tuesday/*<<=Enums.WeekDays.Tuesday.*/ case Wednesday/*<<=Enums.WeekDays.Wednesday.*/ case Thursday/*<<=Enums.WeekDays.Thursday.*/ case Friday/*<<=Enums.WeekDays.Friday.*/ @@ -13,18 +13,18 @@ object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { case Sunday/*<<=Enums.WeekDays.Sunday.*/ } - enum /*=>>java.lang.Object#``().*/Maybe/*<<=Enums.Maybe#*/[+A] {/*<<=Enums.Maybe#``().*//*<<=Enums.Maybe#``().[A]*//*<<=Enums.Maybe#[A]*//*=>>Enums.Maybe.None.*/ - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.Maybe#``().*//*=>>Enums.Maybe.Just#[A]*//*=>>Enums.Maybe.Just#``().*//*=>>Enums.Maybe.Just#copy().[A]*//*=>>Enums.Maybe.Just#copy().(value)*//*=>>Enums.Maybe.Just.apply().[A]*//*=>>Enums.Maybe.Just.apply().(value)*//*=>>Enums.Maybe.Just.unapply().[A]*/case Just/*<<=Enums.Maybe.Just#*/(value/*<<=Enums.Maybe.Just#``().*//*<<=Enums.Maybe.Just#``().(value)*//*<<=Enums.Maybe.Just#(value)*//*<<=Enums.Maybe.Just#copy().(value)*//*<<=Enums.Maybe.Just.apply().(value)*/: A/*=>>Enums.Maybe.Just#``().[A]*//*=>>Enums.Maybe.Just#(value)*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ + enum Maybe/*<<=Enums.Maybe#*/[+A/*<<=Enums.Maybe#[A]*/] { + /*=>>Enums.Maybe#``().*//*=>>Enums.Maybe.Just#[A]*/case Just/*<<=Enums.Maybe.Just#*/(value/*<<=Enums.Maybe.Just#value.*/: A/*=>>Enums.Maybe.Just#``().[A]*/) /*=>>Enums.Maybe#``().*/case None/*<<=Enums.Maybe.None.*/ } - enum /*=>>java.lang.Object#``().*/Tag/*<<=Enums.Tag#*/[A] { -/*<<=Enums.Tag#``().*//*<<=Enums.Tag#``().[A]*//*<<=Enums.Tag#[A]*//*=>>Enums.Tag.IntTag.*//*=>>Enums.Tag.BooleanTag.*/ /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case IntTag/*<<=Enums.Tag.IntTag.*/ extends Tag/*=>>Enums.Tag#*/[Int/*=>>scala.Int#*/]/*=>>Enums.Tag#``().*/ + enum Tag/*<<=Enums.Tag#*/[A/*<<=Enums.Tag#[A]*/] { + case IntTag/*<<=Enums.Tag.IntTag.*/ extends Tag/*=>>Enums.Tag#*/[Int/*=>>scala.Int#*/]/*=>>Enums.Tag#``().*/ case BooleanTag/*<<=Enums.Tag.BooleanTag.*/ extends Tag/*=>>Enums.Tag#*/[Boolean/*=>>scala.Boolean#*/]/*=>>Enums.Tag#``().*/ } - enum /*=>>java.lang.Object#``().*/=:=/*<<=Enums.`=:=`#*/[A, B]/*<<=Enums.`=:=`#``().*//*<<=Enums.`=:=`#``().[A]*//*<<=Enums.`=:=`#[A]*//*<<=Enums.`=:=`#``().[B]*//*<<=Enums.`=:=`#[B]*/ { - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>Enums.`=:=`.Refl#``().*//*=>>Enums.`=:=`.Refl#copy().[C]*//*=>>Enums.`=:=`.Refl.apply().[C]*//*=>>Enums.`=:=`.Refl.unapply().[C]*/case Refl/*<<=Enums.`=:=`.Refl#*/[C]() /*<<=Enums.`=:=`.Refl#``().*//*<<=Enums.`=:=`.Refl#``().[C]*//*<<=Enums.`=:=`.Refl#[C]*//*<<=Enums.`=:=`.Refl#copy().[C]*//*<<=Enums.`=:=`.Refl.apply().[C]*//*<<=Enums.`=:=`.Refl.unapply().[C]*/extends (C/*=>>Enums.`=:=`.Refl#[C]*//*=>>Enums.`=:=`.Refl.apply().[C]*/ =:=/*=>>Enums.`=:=`#*/ C/*=>>Enums.`=:=`.Refl#[C]*//*=>>Enums.`=:=`.Refl.apply().[C]*//*=>>Enums.`=:=`#``().*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ + enum =:=/*<<=Enums.`=:=`#*/[A/*<<=Enums.`=:=`#[A]*/, B/*<<=Enums.`=:=`#[B]*/] { + case Refl/*<<=Enums.`=:=`.Refl#*/[C/*<<=Enums.`=:=`.Refl#[C]*/]() extends (C/*=>>Enums.`=:=`.Refl#[C]*/ =:=/*=>>Enums.`=:=`#*/ C/*=>>Enums.`=:=`.Refl#[C]*//*=>>Enums.`=:=`#``().*/) } def unwrap/*<<=Enums.unwrap().*/[A/*<<=Enums.unwrap().[A]*/,B/*<<=Enums.unwrap().[B]*/](opt/*<<=Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>Enums.unwrap().[A]*/])(given ev/*<<=Enums.unwrap().(ev)*/: A/*=>>Enums.unwrap().[A]*/ =:=/*=>>Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().[B]*/]): Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().[B]*/] = { @@ -33,18 +33,18 @@ object /*=>>java.lang.Object#``().*/Enums/*<<=Enums.*/ { } } - enum Planet/*<<=Enums.Planet#*/(mass:/*<<=Enums.Planet#``().*//*<<=Enums.Planet#``().(mass)*//*<<=Enums.Planet#(mass)*/ Double/*=>>scala.Double#*/, radius/*<<=Enums.Planet#``().(radius)*//*<<=Enums.Planet#(radius)*/: Double/*=>>scala.Double#*/) extends java/*=>>java.*/.lang/*=>>java.lang.*/.Enum/*=>>java.lang.Enum#*/[Planet/*=>>Enums.Planet#*/]/*=>>java.lang.Enum#``().*//*=>>Enums.Planet.Mercury.*//*=>>Enums.Planet.Venus.*//*=>>Enums.Planet.Earth.*//*=>>Enums.Planet.Mars.*//*=>>Enums.Planet.Jupiter.*//*=>>Enums.Planet.Saturn.*//*=>>Enums.Planet.Uranus.*//*=>>Enums.Planet.Neptune.*/ { + enum Planet/*<<=Enums.Planet#*/(mass/*<<=Enums.Planet#mass.*/: Double/*=>>scala.Double#*/, radius/*<<=Enums.Planet#radius.*/: Double/*=>>scala.Double#*/) extends java/*=>>java.*/.lang/*=>>java.lang.*/.Enum/*=>>java.lang.Enum#*/[Planet/*=>>Enums.Planet#*/]/*=>>java.lang.Enum#``().*/ { private final val G/*<<=Enums.Planet#G.*/ = 6.67300E-11 - def surfaceGravity/*<<=Enums.Planet#surfaceGravity().*/ = G/*=>>Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>Enums.Planet#(mass)*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>Enums.Planet#(radius)*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>Enums.Planet#(radius)*/) + def surfaceGravity/*<<=Enums.Planet#surfaceGravity().*/ = G/*=>>Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>Enums.Planet#mass.*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>Enums.Planet#radius.*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>Enums.Planet#radius.*/) def surfaceWeight/*<<=Enums.Planet#surfaceWeight().*/(otherMass/*<<=Enums.Planet#surfaceWeight().(otherMass)*/: Double/*=>>scala.Double#*/) = otherMass/*=>>Enums.Planet#surfaceWeight().(otherMass)*/ */*=>>scala.Double#`*`(+6).*/ surfaceGravity/*=>>Enums.Planet#surfaceGravity().*/ - /*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/case Mercury/*<<=Enums.Planet.$values.*//*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.collection.IterableOnceOps#toArray().*//*=>>scala.runtime.EnumValues#values().*//*=>>Enums.Planet.$values.*//*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>scala.runtime.EnumValues#``().*//*=>>scala.collection.MapOps#apply().*//*=>>scala.runtime.EnumValues#fromName().*//*=>>Enums.Planet.valueOf().($name)*//*=>>``.throw().*//*=>>java.lang.IllegalArgumentException#``(+1).*//*=>>java.lang.String#concat().*/Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ - case Venus/*<<=Enums.Planet.Venus.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ - case Earth/*<<=Enums.Planet.Earth.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ - case Mars/*<<=Enums.Planet.Mars.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ - case Jupiter/*<<=Enums.Planet.Jupiter.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ - case Saturn/*<<=Enums.Planet.Saturn.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ - case Uranus/*<<=Enums.Planet.Uranus.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ - case Neptune/*<<=Enums.Planet.Neptune.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*//*=>>Enums.Planet.$values.*/ + case Mercury/*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.runtime.EnumValues#``().*/Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*/ + case Venus/*<<=Enums.Planet.Venus.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*/ + case Earth/*<<=Enums.Planet.Earth.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*/ + case Mars/*<<=Enums.Planet.Mars.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*/ + case Jupiter/*<<=Enums.Planet.Jupiter.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*/ + case Saturn/*<<=Enums.Planet.Saturn.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*/ + case Uranus/*<<=Enums.Planet.Uranus.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*/ + case Neptune/*<<=Enums.Planet.Neptune.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*/ } } diff --git a/tests/semanticdb/Givens.expect.scala b/tests/semanticdb/Givens.expect.scala index d19fd7a5f3ae..53f1c5f74c8e 100644 --- a/tests/semanticdb/Givens.expect.scala +++ b/tests/semanticdb/Givens.expect.scala @@ -1,19 +1,19 @@ package a package b -object /*=>>java.lang.Object#``().*/Givens/*<<=a.b.Givens.*/ +object Givens/*<<=a.b.Givens.*/ - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>a.b.Givens.*/given /*=>>java.lang.Object#``().*/:[A](any: A) - de/*<<=a.b.Givens.given_sayHello_of_A.*//*=>>a.b.Givens.given_sayHello_of_A.*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().[A]*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>a.b.Givens.given_sayHello_of_A.sayHello().[A]*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/f sayHello/*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s"/*=>>scala.StringContext.*//*=>>scala.*//*=>>_root_*/Hello, I am $any/*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>scala.StringContext#s().*/" + given :[A](any: A) + de/*<<=a.b.Givens.given_sayHello_of_A.*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().[A]*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>a.b.Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s"/*=>>scala.StringContext.*//*=>>scala.*//*=>>_root_*/Hello, I am $any/*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>scala.StringContext#s().*/" val hello1/*<<=a.b.Givens.hello1.*/ = /*=>>a.b.Givens.given_sayHello_of_A.sayHello().*//*=>>a.b.Givens.given_sayHello_of_A.*/1.sayHello - trait Monoid/*<<=a.b.Givens.Monoid#*/[A] - /*<<=a.b.Givens.Monoid#``().*//*<<=a.b.Givens.Monoid#``().[A]*//*<<=a.b.Givens.Monoid#[A]*/ def empty/*<<=a.b.Givens.Monoid#empty().*/: A/*=>>a.b.Givens.Monoid#[A]*/ + trait Monoid/*<<=a.b.Givens.Monoid#*/[A/*<<=a.b.Givens.Monoid#[A]*/] + def empty/*<<=a.b.Givens.Monoid#empty().*/: A/*=>>a.b.Givens.Monoid#[A]*/ def (x: A) /*<<=a.b.Givens.Monoid#combine().*//*<<=a.b.Givens.Monoid#combine().(x)*//*=>>a.b.Givens.Monoid#[A]*/combine (y/*<<=a.b.Givens.Monoid#combine().(y)*/: A/*=>>a.b.Givens.Monoid#[A]*/): A/*=>>a.b.Givens.Monoid#[A]*/ - given /*=>>java.lang.Object#``().*//*=>>a.b.Givens.given_Monoid_String.*/Monoid/*=>>a.b.Givens.Monoid#*/[String] - /*<<=a.b.Givens.given_Monoid_String.*//*=>>scala.Predef.String#*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/def empty/*<<=a.b.Givens.given_Monoid_String.empty().*/ = "" + given Monoid/*=>>a.b.Givens.Monoid#*/[String] + /*<<=a.b.Givens.given_Monoid_String.*//*=>>scala.Predef.String#*/def empty/*<<=a.b.Givens.given_Monoid_String.empty().*/ = "" def (x: Str/*<<=a.b.Givens.given_Monoid_String.combine().*//*<<=a.b.Givens.given_Monoid_String.combine().(x)*/ing/*=>>scala.Predef.String#*/) combine (y/*<<=a.b.Givens.given_Monoid_String.combine().(y)*/: String/*=>>scala.Predef.String#*/) = x/*=>>a.b.Givens.given_Monoid_String.combine().(x)*/ +/*=>>java.lang.String#`+`().*/ y/*=>>a.b.Givens.given_Monoid_String.combine().(y)*/ inline given int2String/*<<=a.b.Givens.int2String().*/: Conversion/*=>>scala.Conversion#*/[Int/*=>>scala.Int#*/, String/*=>>scala.Predef.String#*/] = _.toString/*=>>scala.Any#toString().*/ diff --git a/tests/semanticdb/NewModifiers.expect.scala b/tests/semanticdb/NewModifiers.expect.scala index fb77ee208362..adaab469bc29 100644 --- a/tests/semanticdb/NewModifiers.expect.scala +++ b/tests/semanticdb/NewModifiers.expect.scala @@ -1,4 +1,4 @@ -object /*=>>java.lang.Object#``().*/NewModifiers/*<<=NewModifiers.*/ { - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>NewModifiers.*/inline val foo/*<<=NewModifiers.foo.*/ = "foo" +object NewModifiers/*<<=NewModifiers.*/ { + inline val foo/*<<=NewModifiers.foo.*/ = "foo" opaque type A/*<<=NewModifiers.A#*/ = Int/*=>>scala.Int#*/ } diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala index df54fb012aef..285ae0ca86bb 100644 --- a/tests/semanticdb/semanticdb-extract.expect.scala +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -1,6 +1,6 @@ -object /*=>>java.lang.Object#``().*/A/*<<=A.*/ { +object A/*<<=A.*/ { - /*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>A.*/def foo/*<<=A.foo().*/(x/*<<=A.foo().(x)*/: Int/*=>>scala.Int#*/) = () + def foo/*<<=A.foo().*/(x/*<<=A.foo().(x)*/: Int/*=>>scala.Int#*/) = () def foo/*<<=A.foo(+1).*/(): Unit/*=>>scala.Unit#*/ = () foo/*=>>A.foo().*/(1) @@ -9,10 +9,10 @@ object /*=>>java.lang.Object#``().*/A/*<<=A.*/ { "".substring/*=>>java.lang.String#substring().*/(1) "".substring/*=>>java.lang.String#substring(+1).*/(1, 2) - List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1, 2) - List/*=>>scala.package.List.*/.apply/*=>>scala.collection.IterableFactory#apply().*/() - List/*=>>scala.package.List.*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() + List/*=>>scala.package.List().*//*=>>scala.collection.IterableFactory#apply().*/(1, 2) + List/*=>>scala.package.List().*/.apply/*=>>scala.collection.IterableFactory#apply().*/() + List/*=>>scala.package.List().*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() println/*=>>scala.Predef.println(+1).*/(1 +/*=>>scala.Int#`+`(+4).*/ 2) - /*=>>A.Foo#``().*//*=>>A.Foo#copy().(x)*//*=>>A.Foo.apply().(x)*/case class /*=>>java.lang.Object#``().*/Foo/*<<=A.Foo#*/(x: In/*<<=A.Foo#``().*//*<<=A.Foo#``().(x)*//*<<=A.Foo#(x)*//*<<=A.Foo#copy().(x)*//*<<=A.Foo.apply().(x)*/t/*=>>scala.Int#*//*=>>A.Foo#(x)*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*/)/*=>>scala.Product#*//*=>>scala.*//*=>>_root_*//*=>>scala.package.Serializable#*/ + case class Foo/*<<=A.Foo#*/(x/*<<=A.Foo#x.*/: Int/*=>>scala.Int#*/) } \ No newline at end of file diff --git a/tests/semanticdb/toplevel.expect.scala b/tests/semanticdb/toplevel.expect.scala index 9c5c5d55129d..b706505f13c6 100644 --- a/tests/semanticdb/toplevel.expect.scala +++ b/tests/semanticdb/toplevel.expect.scala @@ -1,4 +1,4 @@ -/*=>>java.lang.Object#``().*//*=>>scala.package.Serializable#*//*=>>scala.*//*=>>_root_*//*=>>toplevel$package.*/inline val a = "/*<<=toplevel$package.*//*<<=toplevel$package.a.*/" +inline val a = "/*<<=toplevel$package.*//*<<=toplevel$package.a.*/" def (x: Int/*<<=toplevel$package.combine().*//*<<=toplevel$package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=toplevel$package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>toplevel$package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>toplevel$package.combine().(y)*/ def combine/*<<=toplevel$package.combine(+1).*/(x/*<<=toplevel$package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=toplevel$package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=toplevel$package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>toplevel$package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>toplevel$package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>toplevel$package.combine(+1).(z)*/ def combine/*<<=toplevel$package.combine(+2).*/ = 0 From c20f2d1ba152b8d48e92b39cbf9e4dcd550262af Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Mon, 21 Oct 2019 16:23:07 +0200 Subject: [PATCH 030/107] append _empty_. if empty package is owner --- .../dotc/semanticdb/ExtractSemanticDB.scala | 8 +-- tests/semanticdb/Empty.expect.scala | 7 ++ tests/semanticdb/Empty.scala | 7 ++ tests/semanticdb/Enums.expect.scala | 68 +++++++++---------- tests/semanticdb/NewModifiers.expect.scala | 6 +- .../semanticdb-extract.expect.scala | 14 ++-- tests/semanticdb/semanticdb-extract.scala | 4 +- tests/semanticdb/toplevel.expect.scala | 10 +-- 8 files changed, 69 insertions(+), 55 deletions(-) create mode 100644 tests/semanticdb/Empty.expect.scala create mode 100644 tests/semanticdb/Empty.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index e1da4cde315a..0f25ffc98ba3 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -60,7 +60,7 @@ class ExtractSemanticDB extends Phase { private val generated = new mutable.HashSet[SymbolOccurrence] /** Add semanticdb name of the given symbol to string builder */ - private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = + private def addSymName(b: StringBuilder, sym: Symbol, inOwner: Boolean = false)(given ctx: Context): Unit = def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) @@ -76,7 +76,7 @@ class ExtractSemanticDB extends Phase { || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) def addOwner(owner: Symbol): Unit = - if !owner.isRoot && !owner.isEmptyPackage then addSymName(b, owner) + if !owner.isRoot then addSymName(b, owner, inOwner = true) def addOverloadIdx(sym: Symbol): Unit = val alts = sym.owner.info.decls.lookupAll(sym.name).toList.reverse @@ -118,9 +118,9 @@ class ExtractSemanticDB extends Phase { if sym.exists then if sym.isRoot then - b.append("_root_") + b.append(if !inOwner then "_root_" else "_root_.") else if sym.isEmptyPackage then - b.append("_empty_") + b.append(if !inOwner then "_empty_" else "_empty_.") else if isGlobal(sym) then addOwner(sym.owner); addDescriptor(sym) else diff --git a/tests/semanticdb/Empty.expect.scala b/tests/semanticdb/Empty.expect.scala new file mode 100644 index 000000000000..8b2a4692976a --- /dev/null +++ b/tests/semanticdb/Empty.expect.scala @@ -0,0 +1,7 @@ +class A/*<<=_empty_.A#*/ { + def b/*<<=_empty_.A#b().*/: B/*=>>_empty_.B#*/ = ???/*=>>scala.Predef.`???`().*/ +} + +class B/*<<=_empty_.B#*/ { + def a/*<<=_empty_.B#a().*/: A/*=>>_empty_.A#*/ = ???/*=>>scala.Predef.`???`().*/ +} diff --git a/tests/semanticdb/Empty.scala b/tests/semanticdb/Empty.scala new file mode 100644 index 000000000000..a1288dfd77b6 --- /dev/null +++ b/tests/semanticdb/Empty.scala @@ -0,0 +1,7 @@ +class A { + def b: B = ??? +} + +class B { + def a: A = ??? +} diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala index 358b54d326e5..e478cc89c9d7 100644 --- a/tests/semanticdb/Enums.expect.scala +++ b/tests/semanticdb/Enums.expect.scala @@ -1,50 +1,50 @@ -object Enums/*<<=Enums.*/ { - enum Colour/*<<=Enums.Colour#*/ { - case /*=>>scala.runtime.EnumValues#``().*/Red/*=>>Enums.Colour.Red.*//*<<=Enums.Colour.Red.*/, Green/*=>>Enums.Colour.Green.*//*<<=Enums.Colour.Green.*/, Blue/*=>>Enums.Colour.Blue.*//*<<=Enums.Colour.Blue.*/ +object Enums/*<<=_empty_.Enums.*/ { + enum Colour/*<<=_empty_.Enums.Colour#*/ { + case /*=>>scala.runtime.EnumValues#``().*/Red/*=>>_empty_.Enums.Colour.Red.*//*<<=_empty_.Enums.Colour.Red.*/, Green/*=>>_empty_.Enums.Colour.Green.*//*<<=_empty_.Enums.Colour.Green.*/, Blue/*=>>_empty_.Enums.Colour.Blue.*//*<<=_empty_.Enums.Colour.Blue.*/ } - enum WeekDays/*<<=Enums.WeekDays#*/ { - /*=>>scala.runtime.EnumValues#``().*/case Monday/*<<=Enums.WeekDays.Monday.*/ - case Tuesday/*<<=Enums.WeekDays.Tuesday.*/ - case Wednesday/*<<=Enums.WeekDays.Wednesday.*/ - case Thursday/*<<=Enums.WeekDays.Thursday.*/ - case Friday/*<<=Enums.WeekDays.Friday.*/ - case Saturday/*<<=Enums.WeekDays.Saturday.*/ - case Sunday/*<<=Enums.WeekDays.Sunday.*/ + enum WeekDays/*<<=_empty_.Enums.WeekDays#*/ { + /*=>>scala.runtime.EnumValues#``().*/case Monday/*<<=_empty_.Enums.WeekDays.Monday.*/ + case Tuesday/*<<=_empty_.Enums.WeekDays.Tuesday.*/ + case Wednesday/*<<=_empty_.Enums.WeekDays.Wednesday.*/ + case Thursday/*<<=_empty_.Enums.WeekDays.Thursday.*/ + case Friday/*<<=_empty_.Enums.WeekDays.Friday.*/ + case Saturday/*<<=_empty_.Enums.WeekDays.Saturday.*/ + case Sunday/*<<=_empty_.Enums.WeekDays.Sunday.*/ } - enum Maybe/*<<=Enums.Maybe#*/[+A/*<<=Enums.Maybe#[A]*/] { - /*=>>Enums.Maybe#``().*//*=>>Enums.Maybe.Just#[A]*/case Just/*<<=Enums.Maybe.Just#*/(value/*<<=Enums.Maybe.Just#value.*/: A/*=>>Enums.Maybe.Just#``().[A]*/) - /*=>>Enums.Maybe#``().*/case None/*<<=Enums.Maybe.None.*/ + enum Maybe/*<<=_empty_.Enums.Maybe#*/[+A/*<<=_empty_.Enums.Maybe#[A]*/] { + /*=>>_empty_.Enums.Maybe#``().*//*=>>_empty_.Enums.Maybe.Just#[A]*/case Just/*<<=_empty_.Enums.Maybe.Just#*/(value/*<<=_empty_.Enums.Maybe.Just#value.*/: A/*=>>_empty_.Enums.Maybe.Just#``().[A]*/) + /*=>>_empty_.Enums.Maybe#``().*/case None/*<<=_empty_.Enums.Maybe.None.*/ } - enum Tag/*<<=Enums.Tag#*/[A/*<<=Enums.Tag#[A]*/] { - case IntTag/*<<=Enums.Tag.IntTag.*/ extends Tag/*=>>Enums.Tag#*/[Int/*=>>scala.Int#*/]/*=>>Enums.Tag#``().*/ - case BooleanTag/*<<=Enums.Tag.BooleanTag.*/ extends Tag/*=>>Enums.Tag#*/[Boolean/*=>>scala.Boolean#*/]/*=>>Enums.Tag#``().*/ + enum Tag/*<<=_empty_.Enums.Tag#*/[A/*<<=_empty_.Enums.Tag#[A]*/] { + case IntTag/*<<=_empty_.Enums.Tag.IntTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Int/*=>>scala.Int#*/]/*=>>_empty_.Enums.Tag#``().*/ + case BooleanTag/*<<=_empty_.Enums.Tag.BooleanTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Boolean/*=>>scala.Boolean#*/]/*=>>_empty_.Enums.Tag#``().*/ } - enum =:=/*<<=Enums.`=:=`#*/[A/*<<=Enums.`=:=`#[A]*/, B/*<<=Enums.`=:=`#[B]*/] { - case Refl/*<<=Enums.`=:=`.Refl#*/[C/*<<=Enums.`=:=`.Refl#[C]*/]() extends (C/*=>>Enums.`=:=`.Refl#[C]*/ =:=/*=>>Enums.`=:=`#*/ C/*=>>Enums.`=:=`.Refl#[C]*//*=>>Enums.`=:=`#``().*/) + enum =:=/*<<=_empty_.Enums.`=:=`#*/[A/*<<=_empty_.Enums.`=:=`#[A]*/, B/*<<=_empty_.Enums.`=:=`#[B]*/] { + case Refl/*<<=_empty_.Enums.`=:=`.Refl#*/[C/*<<=_empty_.Enums.`=:=`.Refl#[C]*/]() extends (C/*=>>_empty_.Enums.`=:=`.Refl#[C]*/ =:=/*=>>_empty_.Enums.`=:=`#*/ C/*=>>_empty_.Enums.`=:=`.Refl#[C]*//*=>>_empty_.Enums.`=:=`#``().*/) } - def unwrap/*<<=Enums.unwrap().*/[A/*<<=Enums.unwrap().[A]*/,B/*<<=Enums.unwrap().[B]*/](opt/*<<=Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>Enums.unwrap().[A]*/])(given ev/*<<=Enums.unwrap().(ev)*/: A/*=>>Enums.unwrap().[A]*/ =:=/*=>>Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().[B]*/]): Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().[B]*/] = { - ev/*=>>Enums.unwrap().(ev)*/ match { - case =:=/*=>>Enums.`=:=`.*/.Refl/*=>>Enums.`=:=`.Refl.*/() => opt/*=>>Enums.unwrap().(opt)*/.flatMap/*=>>scala.Option#flatMap().*/(identity/*=>>scala.Predef.identity().*/[Option/*=>>scala.Option#*/[B/*=>>Enums.unwrap().[B]*/]]) + def unwrap/*<<=_empty_.Enums.unwrap().*/[A/*<<=_empty_.Enums.unwrap().[A]*/,B/*<<=_empty_.Enums.unwrap().[B]*/](opt/*<<=_empty_.Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>_empty_.Enums.unwrap().[A]*/])(given ev/*<<=_empty_.Enums.unwrap().(ev)*/: A/*=>>_empty_.Enums.unwrap().[A]*/ =:=/*=>>_empty_.Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/]): Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/] = { + ev/*=>>_empty_.Enums.unwrap().(ev)*/ match { + case =:=/*=>>_empty_.Enums.`=:=`.*/.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]*/]]) } } - enum Planet/*<<=Enums.Planet#*/(mass/*<<=Enums.Planet#mass.*/: Double/*=>>scala.Double#*/, radius/*<<=Enums.Planet#radius.*/: Double/*=>>scala.Double#*/) extends java/*=>>java.*/.lang/*=>>java.lang.*/.Enum/*=>>java.lang.Enum#*/[Planet/*=>>Enums.Planet#*/]/*=>>java.lang.Enum#``().*/ { - private final val G/*<<=Enums.Planet#G.*/ = 6.67300E-11 - def surfaceGravity/*<<=Enums.Planet#surfaceGravity().*/ = G/*=>>Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>Enums.Planet#mass.*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>Enums.Planet#radius.*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>Enums.Planet#radius.*/) - def surfaceWeight/*<<=Enums.Planet#surfaceWeight().*/(otherMass/*<<=Enums.Planet#surfaceWeight().(otherMass)*/: Double/*=>>scala.Double#*/) = otherMass/*=>>Enums.Planet#surfaceWeight().(otherMass)*/ */*=>>scala.Double#`*`(+6).*/ surfaceGravity/*=>>Enums.Planet#surfaceGravity().*/ + enum Planet/*<<=_empty_.Enums.Planet#*/(mass/*<<=_empty_.Enums.Planet#mass.*/: Double/*=>>scala.Double#*/, radius/*<<=_empty_.Enums.Planet#radius.*/: Double/*=>>scala.Double#*/) extends java/*=>>java.*/.lang/*=>>java.lang.*/.Enum/*=>>java.lang.Enum#*/[Planet/*=>>_empty_.Enums.Planet#*/]/*=>>java.lang.Enum#``().*/ { + private final val G/*<<=_empty_.Enums.Planet#G.*/ = 6.67300E-11 + def surfaceGravity/*<<=_empty_.Enums.Planet#surfaceGravity().*/ = G/*=>>_empty_.Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>_empty_.Enums.Planet#mass.*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>_empty_.Enums.Planet#radius.*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>_empty_.Enums.Planet#radius.*/) + def surfaceWeight/*<<=_empty_.Enums.Planet#surfaceWeight().*/(otherMass/*<<=_empty_.Enums.Planet#surfaceWeight().(otherMass)*/: Double/*=>>scala.Double#*/) = otherMass/*=>>_empty_.Enums.Planet#surfaceWeight().(otherMass)*/ */*=>>scala.Double#`*`(+6).*/ surfaceGravity/*=>>_empty_.Enums.Planet#surfaceGravity().*/ - case Mercury/*<<=Enums.Planet.Mercury.*/ extends /*=>>scala.runtime.EnumValues#``().*/Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*/ - case Venus/*<<=Enums.Planet.Venus.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*/ - case Earth/*<<=Enums.Planet.Earth.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*/ - case Mars/*<<=Enums.Planet.Mars.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*/ - case Jupiter/*<<=Enums.Planet.Jupiter.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*/ - case Saturn/*<<=Enums.Planet.Saturn.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*/ - case Uranus/*<<=Enums.Planet.Uranus.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*/ - case Neptune/*<<=Enums.Planet.Neptune.*/ extends Planet/*=>>Enums.Planet#*//*=>>Enums.Planet#``().*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*/ + case Mercury/*<<=_empty_.Enums.Planet.Mercury.*/ extends /*=>>scala.runtime.EnumValues#``().*/Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*/ + case Venus/*<<=_empty_.Enums.Planet.Venus.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*/ + case Earth/*<<=_empty_.Enums.Planet.Earth.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*/ + case Mars/*<<=_empty_.Enums.Planet.Mars.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*/ + case Jupiter/*<<=_empty_.Enums.Planet.Jupiter.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*/ + case Saturn/*<<=_empty_.Enums.Planet.Saturn.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*/ + case Uranus/*<<=_empty_.Enums.Planet.Uranus.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*/ + case Neptune/*<<=_empty_.Enums.Planet.Neptune.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*/ } } diff --git a/tests/semanticdb/NewModifiers.expect.scala b/tests/semanticdb/NewModifiers.expect.scala index adaab469bc29..ea3ef1abe154 100644 --- a/tests/semanticdb/NewModifiers.expect.scala +++ b/tests/semanticdb/NewModifiers.expect.scala @@ -1,4 +1,4 @@ -object NewModifiers/*<<=NewModifiers.*/ { - inline val foo/*<<=NewModifiers.foo.*/ = "foo" - opaque type A/*<<=NewModifiers.A#*/ = Int/*=>>scala.Int#*/ +object NewModifiers/*<<=_empty_.NewModifiers.*/ { + inline val foo/*<<=_empty_.NewModifiers.foo.*/ = "foo" + opaque type A/*<<=_empty_.NewModifiers.A#*/ = Int/*=>>scala.Int#*/ } diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala index 285ae0ca86bb..d85b91368c0f 100644 --- a/tests/semanticdb/semanticdb-extract.expect.scala +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -1,10 +1,10 @@ -object A/*<<=A.*/ { +object AnObject/*<<=_empty_.AnObject.*/ { - def foo/*<<=A.foo().*/(x/*<<=A.foo().(x)*/: Int/*=>>scala.Int#*/) = () - def foo/*<<=A.foo(+1).*/(): Unit/*=>>scala.Unit#*/ = () + def foo/*<<=_empty_.AnObject.foo().*/(x/*<<=_empty_.AnObject.foo().(x)*/: Int/*=>>scala.Int#*/) = () + def foo/*<<=_empty_.AnObject.foo(+1).*/(): Unit/*=>>scala.Unit#*/ = () - foo/*=>>A.foo().*/(1) - foo/*=>>A.foo(+1).*/() + foo/*=>>_empty_.AnObject.foo().*/(1) + foo/*=>>_empty_.AnObject.foo(+1).*/() "".substring/*=>>java.lang.String#substring().*/(1) "".substring/*=>>java.lang.String#substring(+1).*/(1, 2) @@ -14,5 +14,5 @@ object A/*<<=A.*/ { List/*=>>scala.package.List().*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() println/*=>>scala.Predef.println(+1).*/(1 +/*=>>scala.Int#`+`(+4).*/ 2) - case class Foo/*<<=A.Foo#*/(x/*<<=A.Foo#x.*/: Int/*=>>scala.Int#*/) -} \ No newline at end of file + case class Foo/*<<=_empty_.AnObject.Foo#*/(x/*<<=_empty_.AnObject.Foo#x.*/: Int/*=>>scala.Int#*/) +} diff --git a/tests/semanticdb/semanticdb-extract.scala b/tests/semanticdb/semanticdb-extract.scala index a7564db67b7d..6293c97845be 100644 --- a/tests/semanticdb/semanticdb-extract.scala +++ b/tests/semanticdb/semanticdb-extract.scala @@ -1,4 +1,4 @@ -object A { +object AnObject { def foo(x: Int) = () def foo(): Unit = () @@ -15,4 +15,4 @@ object A { println(1 + 2) case class Foo(x: Int) -} \ No newline at end of file +} diff --git a/tests/semanticdb/toplevel.expect.scala b/tests/semanticdb/toplevel.expect.scala index b706505f13c6..4847a33a41d1 100644 --- a/tests/semanticdb/toplevel.expect.scala +++ b/tests/semanticdb/toplevel.expect.scala @@ -1,5 +1,5 @@ -inline val a = "/*<<=toplevel$package.*//*<<=toplevel$package.a.*/" -def (x: Int/*<<=toplevel$package.combine().*//*<<=toplevel$package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=toplevel$package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>toplevel$package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>toplevel$package.combine().(y)*/ -def combine/*<<=toplevel$package.combine(+1).*/(x/*<<=toplevel$package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=toplevel$package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=toplevel$package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>toplevel$package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>toplevel$package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>toplevel$package.combine(+1).(z)*/ -def combine/*<<=toplevel$package.combine(+2).*/ = 0 -def foo/*<<=toplevel$package.foo().*/ = "foo" +inline val a = "/*<<=_empty_.toplevel$package.*//*<<=_empty_.toplevel$package.a.*/" +def (x: Int/*<<=_empty_.toplevel$package.combine().*//*<<=_empty_.toplevel$package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.toplevel$package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine().(y)*/ +def combine/*<<=_empty_.toplevel$package.combine(+1).*/(x/*<<=_empty_.toplevel$package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.toplevel$package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.toplevel$package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.toplevel$package.combine(+1).(z)*/ +def combine/*<<=_empty_.toplevel$package.combine(+2).*/ = 0 +def foo/*<<=_empty_.toplevel$package.foo().*/ = "foo" From 8775d514e4f102cad28f413ad06608ae377089af Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Mon, 21 Oct 2019 16:46:25 +0200 Subject: [PATCH 031/107] do not append package objects to symbols --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 4 +++- tests/semanticdb/Advanced.expect.scala | 4 ++-- tests/semanticdb/Anonymous.expect.scala | 4 ++-- tests/semanticdb/Classes.expect.scala | 2 +- tests/semanticdb/EmptyObject.expect.scala | 3 +++ tests/semanticdb/EmptyObject.scala | 3 +++ tests/semanticdb/EtaExpansion.expect.scala | 6 ++++++ tests/semanticdb/EtaExpansion.scala | 6 ++++++ tests/semanticdb/semanticdb-extract.expect.scala | 6 +++--- tests/semanticdb/toplevel.expect.scala | 10 +++++----- 10 files changed, 34 insertions(+), 14 deletions(-) create mode 100644 tests/semanticdb/EmptyObject.expect.scala create mode 100644 tests/semanticdb/EmptyObject.scala create mode 100644 tests/semanticdb/EtaExpansion.expect.scala create mode 100644 tests/semanticdb/EtaExpansion.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 0f25ffc98ba3..b04a93a3bebe 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -66,7 +66,7 @@ class ExtractSemanticDB extends Phase { isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) def addName(name: Name) = - val str = name.toString + val str = name.toString.replaceAllLiterally("package","") if isJavaIdent(str) then b.append(str) else b.append('`').append(str).append('`') @@ -93,6 +93,8 @@ class ExtractSemanticDB extends Phase { b.append('['); addName(sym.name); b.append(']') else if sym.is(Param) then b.append('('); addName(sym.name); b.append(')') + else if sym.isPackageObject then + () else addName(sym.name) if sym.is(Package) then b.append('/') diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/Advanced.expect.scala index 042ac6e66f00..84622afeed11 100644 --- a/tests/semanticdb/Advanced.expect.scala +++ b/tests/semanticdb/Advanced.expect.scala @@ -16,7 +16,7 @@ class Structural/*<<=advanced.Structural#*/ { } class Wildcards/*<<=advanced.Wildcards#*/ { - def e1/*<<=advanced.Wildcards#e1().*/: List/*=>>scala.package.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ + def e1/*<<=advanced.Wildcards#e1().*/: List/*=>>scala.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ } object Test/*<<=advanced.Test.*/ { @@ -34,7 +34,7 @@ object Test/*<<=advanced.Test.*/ { { (???/*=>>scala.Predef.`???`().*/ : Any/*=>>scala.Any#*/) match { - case e3/*<<=local7*/: List/*=>>scala.package.List#*/[_] => + case e3/*<<=local7*/: List/*=>>scala.List#*/[_] => val e3x/*<<=local8*/ = e3/*=>>local7*/.head/*=>>scala.collection.IterableOps#head().*/ () } diff --git a/tests/semanticdb/Anonymous.expect.scala b/tests/semanticdb/Anonymous.expect.scala index bd1084ee6813..ec44e2d8839e 100644 --- a/tests/semanticdb/Anonymous.expect.scala +++ b/tests/semanticdb/Anonymous.expect.scala @@ -7,9 +7,9 @@ class Anonymous/*<<=example.Anonymous#*/ { def locally/*<<=example.Anonymous#locally().*/[A/*<<=example.Anonymous#locally().[A]*/](x/*<<=example.Anonymous#locally().(x)*/: A/*=>>example.Anonymous#locally().[A]*/): A/*=>>example.Anonymous#locally().[A]*/ = x/*=>>example.Anonymous#locally().(x)*/ def m1/*<<=example.Anonymous#m1().*/[T/*<<=example.Anonymous#m1().[T]*/[_]] = ???/*=>>scala.Predef.`???`().*/ - def m2/*<<=example.Anonymous#m2().*/: Map/*=>>scala.Predef.Map#*/[_, List/*=>>scala.package.List#*/[_]] = ???/*=>>scala.Predef.`???`().*/ + def m2/*<<=example.Anonymous#m2().*/: Map/*=>>scala.Predef.Map#*/[_, List/*=>>scala.List#*/[_]] = ???/*=>>scala.Predef.`???`().*/ locally/*=>>example.Anonymous#locally().*/ { - ???/*=>>scala.Predef.`???`().*/ match { case _: List/*=>>scala.package.List#*/[_] => } + ???/*=>>scala.Predef.`???`().*/ match { case _: List/*=>>scala.List#*/[_] => } } locally/*=>>example.Anonymous#locally().*/ { val x/*<<=local0*/: Int/*=>>scala.Int#*/ => Int/*=>>scala.Int#*/ = _ => ???/*=>>scala.Predef.`???`().*/ diff --git a/tests/semanticdb/Classes.expect.scala b/tests/semanticdb/Classes.expect.scala index 18b30e58890d..fd9bafd116be 100644 --- a/tests/semanticdb/Classes.expect.scala +++ b/tests/semanticdb/Classes.expect.scala @@ -26,7 +26,7 @@ object N/*<<=classes.N.*/ { val anonClass/*<<=classes.N.anonClass.*/ = new C7/*=>>classes.C7#*//*=>>classes.C7#``().*/(42) { 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 => + val anonFun/*<<=classes.N.anonFun.*/ = List/*=>>scala.List().*//*=>>scala.collection.IterableFactory#apply().*/(1).map/*=>>scala.collection.immutable.List#map().*/ { i => val local = 2 local/*=>>local1*/ +/*=>>scala.Int#`+`(+4).*/ 2 } diff --git a/tests/semanticdb/EmptyObject.expect.scala b/tests/semanticdb/EmptyObject.expect.scala new file mode 100644 index 000000000000..1ce6ad8b983f --- /dev/null +++ b/tests/semanticdb/EmptyObject.expect.scala @@ -0,0 +1,3 @@ +package example + +object EmptyObject/*<<=example.EmptyObject.*/ {} diff --git a/tests/semanticdb/EmptyObject.scala b/tests/semanticdb/EmptyObject.scala new file mode 100644 index 000000000000..58773e9bd7eb --- /dev/null +++ b/tests/semanticdb/EmptyObject.scala @@ -0,0 +1,3 @@ +package example + +object EmptyObject {} diff --git a/tests/semanticdb/EtaExpansion.expect.scala b/tests/semanticdb/EtaExpansion.expect.scala new file mode 100644 index 000000000000..577af9d5d450 --- /dev/null +++ b/tests/semanticdb/EtaExpansion.expect.scala @@ -0,0 +1,6 @@ +package example + +class EtaExpansion/*<<=example.EtaExpansion#*/ { + Some/*=>>scala.Some.*/(1).map/*=>>scala.Option#map().*/(identity/*=>>scala.Predef.identity().*/) + List/*=>>scala.List().*//*=>>scala.collection.IterableFactory#apply().*/(1).foldLeft/*=>>scala.collection.LinearSeqOps#foldLeft().*/("")(_ +/*=>>java.lang.String#`+`().*/ _) +} diff --git a/tests/semanticdb/EtaExpansion.scala b/tests/semanticdb/EtaExpansion.scala new file mode 100644 index 000000000000..90400bfe1f80 --- /dev/null +++ b/tests/semanticdb/EtaExpansion.scala @@ -0,0 +1,6 @@ +package example + +class EtaExpansion { + Some(1).map(identity) + List(1).foldLeft("")(_ + _) +} diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala index d85b91368c0f..20fc93534519 100644 --- a/tests/semanticdb/semanticdb-extract.expect.scala +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -9,9 +9,9 @@ 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().*/.apply/*=>>scala.collection.IterableFactory#apply().*/() - List/*=>>scala.package.List().*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() + List/*=>>scala.List().*//*=>>scala.collection.IterableFactory#apply().*/(1, 2) + List/*=>>scala.List().*/.apply/*=>>scala.collection.IterableFactory#apply().*/() + List/*=>>scala.List().*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() println/*=>>scala.Predef.println(+1).*/(1 +/*=>>scala.Int#`+`(+4).*/ 2) case class Foo/*<<=_empty_.AnObject.Foo#*/(x/*<<=_empty_.AnObject.Foo#x.*/: Int/*=>>scala.Int#*/) diff --git a/tests/semanticdb/toplevel.expect.scala b/tests/semanticdb/toplevel.expect.scala index 4847a33a41d1..5f9c2207c27d 100644 --- a/tests/semanticdb/toplevel.expect.scala +++ b/tests/semanticdb/toplevel.expect.scala @@ -1,5 +1,5 @@ -inline val a = "/*<<=_empty_.toplevel$package.*//*<<=_empty_.toplevel$package.a.*/" -def (x: Int/*<<=_empty_.toplevel$package.combine().*//*<<=_empty_.toplevel$package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.toplevel$package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine().(y)*/ -def combine/*<<=_empty_.toplevel$package.combine(+1).*/(x/*<<=_empty_.toplevel$package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.toplevel$package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.toplevel$package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.toplevel$package.combine(+1).(z)*/ -def combine/*<<=_empty_.toplevel$package.combine(+2).*/ = 0 -def foo/*<<=_empty_.toplevel$package.foo().*/ = "foo" +inline val a = "/*<<=_empty_.*//*<<=_empty_.a.*/" +def (x: Int/*<<=_empty_.combine().*//*<<=_empty_.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.combine().(y)*/ +def combine/*<<=_empty_.combine(+1).*/(x/*<<=_empty_.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.combine(+1).(z)*/ +def combine/*<<=_empty_.combine(+2).*/ = 0 +def foo/*<<=_empty_.foo().*/ = "foo" From 2137141baa9b1fc986b98d3347ffc9e7cbbefb2c Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Mon, 21 Oct 2019 18:01:13 +0200 Subject: [PATCH 032/107] exclude default getters --- .../dotc/semanticdb/ExtractSemanticDB.scala | 18 ++++++++++++------ tests/semanticdb/Example.expect.scala | 11 +++++++++++ tests/semanticdb/Example.scala | 11 +++++++++++ 3 files changed, 34 insertions(+), 6 deletions(-) create mode 100644 tests/semanticdb/Example.expect.scala create mode 100644 tests/semanticdb/Example.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index b04a93a3bebe..80849afbb86e 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -66,7 +66,7 @@ class ExtractSemanticDB extends Phase { isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) def addName(name: Name) = - val str = name.toString.replaceAllLiterally("package","") + val str = name.toString if isJavaIdent(str) then b.append(str) else b.append('`').append(str).append('`') @@ -157,6 +157,10 @@ class ExtractSemanticDB extends Phase { || sym.is(Synthetic) || (sym.owner.is(Synthetic) && !sym.isAllOf(EnumCase)) || sym.isAnonymous || sym.isPrimaryConstructor && excludeDef(sym.owner) + || excludeDefStrict(sym) + + private def excludeDefStrict(sym: Symbol)(given Context): Boolean = + sym.name.is(NameKinds.DefaultGetterName) private def (sym: Symbol) isAnonymous(given Context): Boolean = sym.isAnonymousClass @@ -164,8 +168,8 @@ class ExtractSemanticDB extends Phase { || sym.isAnonymousFunction /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ - private def excludeUse(sym: Symbol, span: Span)(given Context): Boolean = - excludeDef(sym) && span.start == span.end + private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = + excludeDefStrict(sym) || (excludeDef(sym) && span.start == span.end) private def registerOccurrence(sym: Symbol, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = val occ = SymbolOccurrence(symbolName(sym), range(span), role) @@ -174,7 +178,7 @@ class ExtractSemanticDB extends Phase { generated += occ private def registerUse(sym: Symbol, span: Span)(given Context) = - if !excludeUse(sym, span) && !isWildcard(sym.name) then + if !excludeUseStrict(sym, span) && !isWildcard(sym.name) then registerOccurrence(sym, span, SymbolOccurrence.Role.REFERENCE) private def registerDefinition(sym: Symbol, span: Span)(given Context) = @@ -220,10 +224,10 @@ class ExtractSemanticDB extends Phase { traverse(tree.self) tree.body.foreach(traverse) case tree: Ident => - if tree.name != nme.WILDCARD && !excludeUse(tree.symbol, tree.span) then + if tree.name != nme.WILDCARD && !excludeUseStrict(tree.symbol, tree.span) then registerUse(tree.symbol, tree.span) case tree: Select => - if !excludeUse(tree.symbol, tree.span) then + if !excludeUseStrict(tree.symbol, tree.span) then val end = tree.span.end val limit = tree.qualifier.span.end val start = @@ -240,6 +244,8 @@ class ExtractSemanticDB extends Phase { if imported != nme.WILDCARD then for alt <- tree.expr.tpe.member(imported).alternatives do registerUse(alt.symbol, sel.imported.span) + if (alt.symbol.companionClass.exists) + registerUse(alt.symbol.companionClass, sel.imported.span) registerPath(tree.expr) case tree: Inlined => traverse(tree.call) diff --git a/tests/semanticdb/Example.expect.scala b/tests/semanticdb/Example.expect.scala new file mode 100644 index 000000000000..aa7cb6e784bb --- /dev/null +++ b/tests/semanticdb/Example.expect.scala @@ -0,0 +1,11 @@ +package example + +import scala.concurrent/*=>>scala.concurrent.*/.Future/*=>>scala.concurrent.Future.*//*=>>scala.concurrent.Future#*/ + +object Example/*<<=example.Example.*/ { /*=>>example.Example.*/self/*<<=local0*/ => + new /*=>>scala.collection.mutable.Stack.*/scala/*=>>scala.*/.collection/*=>>scala.collection.*/.mutable/*=>>scala.collection.mutable.*/.Stack/*=>>scala.collection.mutable.Stack#*/[Int/*=>>scala.Int#*/]/*=>>scala.collection.mutable.Stack#``(+1).*/() + def main/*<<=example.Example.main().*/(args/*<<=example.Example.main().(args)*/: Array/*=>>scala.Array#*/[String/*=>>scala.Predef.String#*/]): Unit/*=>>scala.Unit#*/ = { + println/*=>>scala.Predef.println(+1).*/(1) + } + val x/*<<=example.Example.x.*/ = scala/*=>>scala.*/.reflect/*=>>scala.reflect.*/.classTag/*=>>scala.reflect.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>java.lang.Integer.TYPE.*//*=>>java.lang.Integer.*/ +} diff --git a/tests/semanticdb/Example.scala b/tests/semanticdb/Example.scala new file mode 100644 index 000000000000..794ae807ffeb --- /dev/null +++ b/tests/semanticdb/Example.scala @@ -0,0 +1,11 @@ +package example + +import scala.concurrent.Future + +object Example { self => + new scala.collection.mutable.Stack[Int]() + def main(args: Array[String]): Unit = { + println(1) + } + val x = scala.reflect.classTag[Int] +} From c2054dd8ca44b90064ff3e604383609cf0305f10 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Mon, 21 Oct 2019 18:04:28 +0200 Subject: [PATCH 033/107] revert exclude package objects --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 2 -- tests/semanticdb/Advanced.expect.scala | 4 ++-- tests/semanticdb/Anonymous.expect.scala | 4 ++-- tests/semanticdb/Classes.expect.scala | 2 +- tests/semanticdb/EtaExpansion.expect.scala | 2 +- tests/semanticdb/Example.expect.scala | 2 +- tests/semanticdb/semanticdb-extract.expect.scala | 6 +++--- tests/semanticdb/toplevel.expect.scala | 10 +++++----- 8 files changed, 15 insertions(+), 17 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 80849afbb86e..d032348cd176 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -93,8 +93,6 @@ class ExtractSemanticDB extends Phase { b.append('['); addName(sym.name); b.append(']') else if sym.is(Param) then b.append('('); addName(sym.name); b.append(')') - else if sym.isPackageObject then - () else addName(sym.name) if sym.is(Package) then b.append('/') diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/Advanced.expect.scala index 84622afeed11..042ac6e66f00 100644 --- a/tests/semanticdb/Advanced.expect.scala +++ b/tests/semanticdb/Advanced.expect.scala @@ -16,7 +16,7 @@ class Structural/*<<=advanced.Structural#*/ { } class Wildcards/*<<=advanced.Wildcards#*/ { - def e1/*<<=advanced.Wildcards#e1().*/: List/*=>>scala.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ + def e1/*<<=advanced.Wildcards#e1().*/: List/*=>>scala.package.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ } object Test/*<<=advanced.Test.*/ { @@ -34,7 +34,7 @@ object Test/*<<=advanced.Test.*/ { { (???/*=>>scala.Predef.`???`().*/ : Any/*=>>scala.Any#*/) match { - case e3/*<<=local7*/: List/*=>>scala.List#*/[_] => + case e3/*<<=local7*/: List/*=>>scala.package.List#*/[_] => val e3x/*<<=local8*/ = e3/*=>>local7*/.head/*=>>scala.collection.IterableOps#head().*/ () } diff --git a/tests/semanticdb/Anonymous.expect.scala b/tests/semanticdb/Anonymous.expect.scala index ec44e2d8839e..bd1084ee6813 100644 --- a/tests/semanticdb/Anonymous.expect.scala +++ b/tests/semanticdb/Anonymous.expect.scala @@ -7,9 +7,9 @@ class Anonymous/*<<=example.Anonymous#*/ { def locally/*<<=example.Anonymous#locally().*/[A/*<<=example.Anonymous#locally().[A]*/](x/*<<=example.Anonymous#locally().(x)*/: A/*=>>example.Anonymous#locally().[A]*/): A/*=>>example.Anonymous#locally().[A]*/ = x/*=>>example.Anonymous#locally().(x)*/ def m1/*<<=example.Anonymous#m1().*/[T/*<<=example.Anonymous#m1().[T]*/[_]] = ???/*=>>scala.Predef.`???`().*/ - def m2/*<<=example.Anonymous#m2().*/: Map/*=>>scala.Predef.Map#*/[_, List/*=>>scala.List#*/[_]] = ???/*=>>scala.Predef.`???`().*/ + def m2/*<<=example.Anonymous#m2().*/: Map/*=>>scala.Predef.Map#*/[_, List/*=>>scala.package.List#*/[_]] = ???/*=>>scala.Predef.`???`().*/ locally/*=>>example.Anonymous#locally().*/ { - ???/*=>>scala.Predef.`???`().*/ match { case _: List/*=>>scala.List#*/[_] => } + ???/*=>>scala.Predef.`???`().*/ match { case _: List/*=>>scala.package.List#*/[_] => } } locally/*=>>example.Anonymous#locally().*/ { val x/*<<=local0*/: Int/*=>>scala.Int#*/ => Int/*=>>scala.Int#*/ = _ => ???/*=>>scala.Predef.`???`().*/ diff --git a/tests/semanticdb/Classes.expect.scala b/tests/semanticdb/Classes.expect.scala index fd9bafd116be..18b30e58890d 100644 --- a/tests/semanticdb/Classes.expect.scala +++ b/tests/semanticdb/Classes.expect.scala @@ -26,7 +26,7 @@ object N/*<<=classes.N.*/ { val anonClass/*<<=classes.N.anonClass.*/ = new C7/*=>>classes.C7#*//*=>>classes.C7#``().*/(42) { val local/*<<=local0*/ = ???/*=>>scala.Predef.`???`().*/ } - val anonFun/*<<=classes.N.anonFun.*/ = List/*=>>scala.List().*//*=>>scala.collection.IterableFactory#apply().*/(1).map/*=>>scala.collection.immutable.List#map().*/ { i => + val anonFun/*<<=classes.N.anonFun.*/ = List/*=>>scala.package.List().*//*=>>scala.collection.IterableFactory#apply().*/(1).map/*=>>scala.collection.immutable.List#map().*/ { i => val local = 2 local/*=>>local1*/ +/*=>>scala.Int#`+`(+4).*/ 2 } diff --git a/tests/semanticdb/EtaExpansion.expect.scala b/tests/semanticdb/EtaExpansion.expect.scala index 577af9d5d450..d57a4b31b6b4 100644 --- a/tests/semanticdb/EtaExpansion.expect.scala +++ b/tests/semanticdb/EtaExpansion.expect.scala @@ -2,5 +2,5 @@ package example class EtaExpansion/*<<=example.EtaExpansion#*/ { Some/*=>>scala.Some.*/(1).map/*=>>scala.Option#map().*/(identity/*=>>scala.Predef.identity().*/) - List/*=>>scala.List().*//*=>>scala.collection.IterableFactory#apply().*/(1).foldLeft/*=>>scala.collection.LinearSeqOps#foldLeft().*/("")(_ +/*=>>java.lang.String#`+`().*/ _) + List/*=>>scala.package.List().*//*=>>scala.collection.IterableFactory#apply().*/(1).foldLeft/*=>>scala.collection.LinearSeqOps#foldLeft().*/("")(_ +/*=>>java.lang.String#`+`().*/ _) } diff --git a/tests/semanticdb/Example.expect.scala b/tests/semanticdb/Example.expect.scala index aa7cb6e784bb..1010aad05782 100644 --- a/tests/semanticdb/Example.expect.scala +++ b/tests/semanticdb/Example.expect.scala @@ -7,5 +7,5 @@ object Example/*<<=example.Example.*/ { /*=>>example.Example.*/self/*<<=local0*/ 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/*=>>scala.*/.reflect/*=>>scala.reflect.*/.classTag/*=>>scala.reflect.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>java.lang.Integer.TYPE.*//*=>>java.lang.Integer.*/ + val x/*<<=example.Example.x.*/ = scala/*=>>scala.*/.reflect/*=>>scala.reflect.*/.classTag/*=>>scala.reflect.package.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>java.lang.Integer.TYPE.*//*=>>java.lang.Integer.*/ } diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala index 20fc93534519..d85b91368c0f 100644 --- a/tests/semanticdb/semanticdb-extract.expect.scala +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -9,9 +9,9 @@ object AnObject/*<<=_empty_.AnObject.*/ { "".substring/*=>>java.lang.String#substring().*/(1) "".substring/*=>>java.lang.String#substring(+1).*/(1, 2) - List/*=>>scala.List().*//*=>>scala.collection.IterableFactory#apply().*/(1, 2) - List/*=>>scala.List().*/.apply/*=>>scala.collection.IterableFactory#apply().*/() - List/*=>>scala.List().*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() + List/*=>>scala.package.List().*//*=>>scala.collection.IterableFactory#apply().*/(1, 2) + List/*=>>scala.package.List().*/.apply/*=>>scala.collection.IterableFactory#apply().*/() + List/*=>>scala.package.List().*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() println/*=>>scala.Predef.println(+1).*/(1 +/*=>>scala.Int#`+`(+4).*/ 2) case class Foo/*<<=_empty_.AnObject.Foo#*/(x/*<<=_empty_.AnObject.Foo#x.*/: Int/*=>>scala.Int#*/) diff --git a/tests/semanticdb/toplevel.expect.scala b/tests/semanticdb/toplevel.expect.scala index 5f9c2207c27d..4847a33a41d1 100644 --- a/tests/semanticdb/toplevel.expect.scala +++ b/tests/semanticdb/toplevel.expect.scala @@ -1,5 +1,5 @@ -inline val a = "/*<<=_empty_.*//*<<=_empty_.a.*/" -def (x: Int/*<<=_empty_.combine().*//*<<=_empty_.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.combine().(y)*/ -def combine/*<<=_empty_.combine(+1).*/(x/*<<=_empty_.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.combine(+1).(z)*/ -def combine/*<<=_empty_.combine(+2).*/ = 0 -def foo/*<<=_empty_.foo().*/ = "foo" +inline val a = "/*<<=_empty_.toplevel$package.*//*<<=_empty_.toplevel$package.a.*/" +def (x: Int/*<<=_empty_.toplevel$package.combine().*//*<<=_empty_.toplevel$package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.toplevel$package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine().(y)*/ +def combine/*<<=_empty_.toplevel$package.combine(+1).*/(x/*<<=_empty_.toplevel$package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.toplevel$package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.toplevel$package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.toplevel$package.combine(+1).(z)*/ +def combine/*<<=_empty_.toplevel$package.combine(+2).*/ = 0 +def foo/*<<=_empty_.toplevel$package.foo().*/ = "foo" From 457cf2cff4f73c56eb48a97be9a678099b6b7d68 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Mon, 21 Oct 2019 18:22:51 +0200 Subject: [PATCH 034/107] emit public vals without parens --- .../dotc/semanticdb/ExtractSemanticDB.scala | 3 ++- tests/semanticdb/Classes.expect.scala | 2 +- tests/semanticdb/Definitions.expect.scala | 2 +- tests/semanticdb/EtaExpansion.expect.scala | 2 +- tests/semanticdb/Flags.expect.scala | 26 +++++++++++++++++++ tests/semanticdb/Flags.scala | 26 +++++++++++++++++++ .../semanticdb-extract.expect.scala | 6 ++--- 7 files changed, 60 insertions(+), 7 deletions(-) create mode 100644 tests/semanticdb/Flags.expect.scala create mode 100644 tests/semanticdb/Flags.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index d032348cd176..df826167b71a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -97,7 +97,8 @@ class ExtractSemanticDB extends Phase { addName(sym.name) if sym.is(Package) then b.append('/') else if sym.isType then b.append('#') - else if sym.is(Method) || (sym.isOneOf(Accessor | Local) && sym.is(Mutable)) then + else if sym.isOneOf(Method | Mutable) + && (!sym.is(StableRealizable) || sym.name == nme.CONSTRUCTOR) then b.append('('); addOverloadIdx(sym); b.append(").") else b.append('.') diff --git a/tests/semanticdb/Classes.expect.scala b/tests/semanticdb/Classes.expect.scala index 18b30e58890d..37b1ac9b427c 100644 --- a/tests/semanticdb/Classes.expect.scala +++ b/tests/semanticdb/Classes.expect.scala @@ -26,7 +26,7 @@ object N/*<<=classes.N.*/ { val anonClass/*<<=classes.N.anonClass.*/ = new C7/*=>>classes.C7#*//*=>>classes.C7#``().*/(42) { 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 => + val anonFun/*<<=classes.N.anonFun.*/ = List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1).map/*=>>scala.collection.immutable.List#map().*/ { i => val local = 2 local/*=>>local1*/ +/*=>>scala.Int#`+`(+4).*/ 2 } diff --git a/tests/semanticdb/Definitions.expect.scala b/tests/semanticdb/Definitions.expect.scala index 020a1f40426c..76c9da838ef4 100644 --- a/tests/semanticdb/Definitions.expect.scala +++ b/tests/semanticdb/Definitions.expect.scala @@ -1,7 +1,7 @@ package a object Definitions/*<<=a.Definitions.*/ { val a/*<<=a.Definitions.a.*/ = 1 - var b/*<<=a.Definitions.b.*/ =/*<<=a.Definitions.`b_=`().*/ 2 + var b/*<<=a.Definitions.b().*/ =/*<<=a.Definitions.`b_=`().*/ 2 def c/*<<=a.Definitions.c().*/ = 3 class D/*<<=a.Definitions.D#*/ trait E/*<<=a.Definitions.E#*/ diff --git a/tests/semanticdb/EtaExpansion.expect.scala b/tests/semanticdb/EtaExpansion.expect.scala index d57a4b31b6b4..9bc1f39cf32b 100644 --- a/tests/semanticdb/EtaExpansion.expect.scala +++ b/tests/semanticdb/EtaExpansion.expect.scala @@ -2,5 +2,5 @@ package example class EtaExpansion/*<<=example.EtaExpansion#*/ { Some/*=>>scala.Some.*/(1).map/*=>>scala.Option#map().*/(identity/*=>>scala.Predef.identity().*/) - List/*=>>scala.package.List().*//*=>>scala.collection.IterableFactory#apply().*/(1).foldLeft/*=>>scala.collection.LinearSeqOps#foldLeft().*/("")(_ +/*=>>java.lang.String#`+`().*/ _) + List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1).foldLeft/*=>>scala.collection.LinearSeqOps#foldLeft().*/("")(_ +/*=>>java.lang.String#`+`().*/ _) } diff --git a/tests/semanticdb/Flags.expect.scala b/tests/semanticdb/Flags.expect.scala new file mode 100644 index 000000000000..1eb0595053b9 --- /dev/null +++ b/tests/semanticdb/Flags.expect.scala @@ -0,0 +1,26 @@ +package flags + +import scala.language/*=>>scalaShadowing.language.*/.experimental/*=>>scalaShadowing.language.experimental.*/.macros/*=>>scalaShadowing.language.experimental.macros.*/ + +package object p { + p/*<<=flags.p.package.*/rivate lazy val x/*<<=flags.p.package.x.*/ = 1 + protected implicit var y/*<<=flags.p.package.y().*/: /*<<=flags.p.package.`y_=`().*/Int/*=>>scala.Int#*/ = 2 + def z/*<<=flags.p.package.z().*/(pp/*<<=flags.p.package.z().(pp)*/: Int/*=>>scala.Int#*/) = 3 + def m/*<<=flags.p.package.m().*/[TT/*<<=flags.p.package.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*//*=>>scala.Predef.*//*=>>scala.*//*=>>_root_*/ = macro ??? + abstract class C/*<<=flags.p.package.C#*/[+T/*<<=flags.p.package.C#[T]*//*<<=flags.p.package.C#``(+1).[T]*/, -U/*<<=flags.p.package.C#[U]*//*<<=flags.p.package.C#``(+1).[U]*/, V/*<<=flags.p.package.C#[V]*//*<<=flags.p.package.C#``(+1).[V]*/](x/*<<=flags.p.package.C#x.*/: T/*=>>flags.p.package.C#``().[T]*/, y/*<<=flags.p.package.C#y.*/: U/*=>>flags.p.package.C#``().[U]*/, z/*<<=flags.p.package.C#z.*/: V/*=>>flags.p.package.C#``().[V]*/) { + def this()/*<<=flags.p.package.C#``(+1).*/ = this(/*=>>flags.p.package.C#``().*/???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/) + def w/*<<=flags.p.package.C#w().*/: Int/*=>>scala.Int#*/ + } + type T1/*<<=flags.p.package.T1#*/ = Int/*=>>scala.Int#*/ + type T2/*<<=flags.p.package.T2#*/[T/*<<=flags.p.package.T2#[T]*/] = S/*=>>flags.p.package.S#*/[T/*=>>flags.p.package.T2#[T]*/] + type U/*<<=flags.p.package.U#*/ <: Int/*=>>scala.Int#*/ + type V/*<<=flags.p.package.V#*/ >: Int/*=>>scala.Int#*/ + case object X/*<<=flags.p.package.X.*/ + final class Y/*<<=flags.p.package.Y#*/ + sealed trait Z/*<<=flags.p.package.Z#*/ + class AA/*<<=flags.p.package.AA#*/(x/*<<=flags.p.package.AA#x.*/: Int/*=>>scala.Int#*/, val y/*<<=flags.p.package.AA#y.*/: Int/*=>>scala.Int#*/, var z/*<<=flags.p.package.AA#z().*/: /*<<=flags.p.package.AA#`z_=`().*/Int/*=>>scala.Int#*/) + class S/*<<=flags.p.package.S#*/[@specialized/*=>>scala.specialized#*//*=>>scala.specialized#``(+2).*/ T/*<<=flags.p.package.S#[T]*/] + val List/*=>>scala.package.List.*//*=>>scala.collection.SeqFactory#unapplySeq().*/(xs1/*<<=flags.p.package.xs1.*//*<<=local0*/)/*=>>local0*/ = ???/*=>>scala.Predef.`???`().*/ + ???/*=>>scala.Predef.`???`().*/ match { case List/*=>>scala.package.List.*//*=>>scala.collection.SeqFactory#unapplySeq().*/(xs2/*<<=local1*/) => ???/*=>>scala.Predef.`???`().*/ } + ???/*=>>scala.Predef.`???`().*/ match { case _: List/*=>>scala.package.List#*/[t/*<<=local2*/] => ???/*=>>scala.Predef.`???`().*/ } +} diff --git a/tests/semanticdb/Flags.scala b/tests/semanticdb/Flags.scala new file mode 100644 index 000000000000..c7b0b058753c --- /dev/null +++ b/tests/semanticdb/Flags.scala @@ -0,0 +1,26 @@ +package flags + +import scala.language.experimental.macros + +package object p { + private lazy val x = 1 + protected implicit var y: Int = 2 + def z(pp: Int) = 3 + def m[TT]: Int = macro ??? + abstract class C[+T, -U, V](x: T, y: U, z: V) { + def this() = this(???, ???, ???) + def w: Int + } + type T1 = Int + type T2[T] = S[T] + type U <: Int + type V >: Int + case object X + final class Y + sealed trait Z + class AA(x: Int, val y: Int, var z: Int) + class S[@specialized T] + val List(xs1) = ??? + ??? match { case List(xs2) => ??? } + ??? match { case _: List[t] => ??? } +} diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/semanticdb-extract.expect.scala index d85b91368c0f..2cbd188ab708 100644 --- a/tests/semanticdb/semanticdb-extract.expect.scala +++ b/tests/semanticdb/semanticdb-extract.expect.scala @@ -9,9 +9,9 @@ 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().*/.apply/*=>>scala.collection.IterableFactory#apply().*/() - List/*=>>scala.package.List().*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() + List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1, 2) + List/*=>>scala.package.List.*/.apply/*=>>scala.collection.IterableFactory#apply().*/() + List/*=>>scala.package.List.*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() println/*=>>scala.Predef.println(+1).*/(1 +/*=>>scala.Int#`+`(+4).*/ 2) case class Foo/*<<=_empty_.AnObject.Foo#*/(x/*<<=_empty_.AnObject.Foo#x.*/: Int/*=>>scala.Int#*/) From c86266dd18fe7caf343091ed6b87b042f8841da1 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 5 Nov 2019 17:42:25 +0100 Subject: [PATCH 035/107] eliminate traversing select qualifier of _root_.scala.Predef --- compiler/src/dotty/tools/dotc/ast/Trees.scala | 6 +++--- .../dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala | 8 +++++++- tests/semanticdb/Annotations.expect.scala | 2 +- tests/semanticdb/Flags.expect.scala | 2 +- 4 files changed, 12 insertions(+), 6 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala index 0f68e1a64cbe..98bcb43dbdc7 100644 --- a/compiler/src/dotty/tools/dotc/ast/Trees.scala +++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala @@ -1448,13 +1448,13 @@ object Trees { this(x, trees) case UnApply(fun, implicits, patterns) => this(this(this(x, fun), implicits), patterns) - case tree @ ValDef(name, tpt, _) => + case tree @ ValDef(_, tpt, _) => implicit val ctx = localCtx this(this(x, tpt), tree.rhs) - case tree @ DefDef(name, tparams, vparamss, tpt, _) => + case tree @ DefDef(_, tparams, vparamss, tpt, _) => implicit val ctx = localCtx this(this(vparamss.foldLeft(this(x, tparams))(apply), tpt), tree.rhs) - case TypeDef(name, rhs) => + case TypeDef(_, rhs) => implicit val ctx = localCtx this(x, rhs) case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty => diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index df826167b71a..51e6a9f9bda9 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -198,6 +198,10 @@ class ExtractSemanticDB extends Phase { then traverse(annot.tree) + val Predef_name = defn.ScalaPredefModule.name + val RootName = nme.ROOTPKG.toSimpleName + val Scala = "scala".toTermName.toSimpleName + tree match case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree @@ -235,7 +239,9 @@ class ExtractSemanticDB extends Phase { if source.content()(end - 1) == '`' then end - len - 1 else end - len else limit registerUse(tree.symbol, Span(start max limit, end)) - traverseChildren(tree) + tree.qualifier match + case Select(Select(Ident(RootName), Scala), Predef_name) => // skip + case _ => traverseChildren(tree) case tree: Import => if tree.span.exists && tree.span.start != tree.span.end then for sel <- tree.selectors do diff --git a/tests/semanticdb/Annotations.expect.scala b/tests/semanticdb/Annotations.expect.scala index 903f1c18ec78..96133d1ae982 100644 --- a/tests/semanticdb/Annotations.expect.scala +++ b/tests/semanticdb/Annotations.expect.scala @@ -27,7 +27,7 @@ class B/*<<=annot.B#*/ @ConstructorAnnotation/*=>>com.javacp.annot.ConstructorAn @ObjectAnnotation/*=>>com.javacp.annot.ObjectAnnotation#*/ object M/*<<=annot.M.*/ { @MacroAnnotation/*=>>com.javacp.annot.MacroAnnotation#*/ - def m/*<<=annot.M.m().*/[TT/*<<=annot.M.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*//*=>>scala.Predef.*//*=>>scala.*//*=>>_root_*/ = macro ??? + def m/*<<=annot.M.m().*/[TT/*<<=annot.M.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*/ = macro ??? } @TraitAnnotation/*=>>com.javacp.annot.TraitAnnotation#*/ diff --git a/tests/semanticdb/Flags.expect.scala b/tests/semanticdb/Flags.expect.scala index 1eb0595053b9..b7f0947082d2 100644 --- a/tests/semanticdb/Flags.expect.scala +++ b/tests/semanticdb/Flags.expect.scala @@ -6,7 +6,7 @@ package object p { p/*<<=flags.p.package.*/rivate lazy val x/*<<=flags.p.package.x.*/ = 1 protected implicit var y/*<<=flags.p.package.y().*/: /*<<=flags.p.package.`y_=`().*/Int/*=>>scala.Int#*/ = 2 def z/*<<=flags.p.package.z().*/(pp/*<<=flags.p.package.z().(pp)*/: Int/*=>>scala.Int#*/) = 3 - def m/*<<=flags.p.package.m().*/[TT/*<<=flags.p.package.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*//*=>>scala.Predef.*//*=>>scala.*//*=>>_root_*/ = macro ??? + def m/*<<=flags.p.package.m().*/[TT/*<<=flags.p.package.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*/ = macro ??? abstract class C/*<<=flags.p.package.C#*/[+T/*<<=flags.p.package.C#[T]*//*<<=flags.p.package.C#``(+1).[T]*/, -U/*<<=flags.p.package.C#[U]*//*<<=flags.p.package.C#``(+1).[U]*/, V/*<<=flags.p.package.C#[V]*//*<<=flags.p.package.C#``(+1).[V]*/](x/*<<=flags.p.package.C#x.*/: T/*=>>flags.p.package.C#``().[T]*/, y/*<<=flags.p.package.C#y.*/: U/*=>>flags.p.package.C#``().[U]*/, z/*<<=flags.p.package.C#z.*/: V/*=>>flags.p.package.C#``().[V]*/) { def this()/*<<=flags.p.package.C#``(+1).*/ = this(/*=>>flags.p.package.C#``().*/???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/) def w/*<<=flags.p.package.C#w().*/: Int/*=>>scala.Int#*/ From 154089886a20283f29f3fdf0fe070e09bd88d6b4 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 5 Nov 2019 18:22:37 +0100 Subject: [PATCH 036/107] Add many tests --- .../dotc/semanticdb/ExtractSemanticDB.scala | 3 +- .../semanticdb/ForComprehension.expect.scala | 45 +++++++ tests/semanticdb/ForComprehension.scala | 45 +++++++ tests/semanticdb/Givens.expect.scala | 2 +- .../ImplicitConversion.expect.scala | 33 +++++ tests/semanticdb/ImplicitConversion.scala | 33 +++++ tests/semanticdb/Imports.expect.scala | 1 + tests/semanticdb/Imports.scala | 1 + tests/semanticdb/InstrumentTyper.expect.scala | 26 ++++ tests/semanticdb/InstrumentTyper.scala | 26 ++++ tests/semanticdb/Types.expect.scala | 115 ++++++++++++++++++ tests/semanticdb/Types.scala | 115 ++++++++++++++++++ 12 files changed, 442 insertions(+), 3 deletions(-) create mode 100644 tests/semanticdb/ForComprehension.expect.scala create mode 100644 tests/semanticdb/ForComprehension.scala create mode 100644 tests/semanticdb/ImplicitConversion.expect.scala create mode 100644 tests/semanticdb/ImplicitConversion.scala create mode 100644 tests/semanticdb/Imports.expect.scala create mode 100644 tests/semanticdb/Imports.scala create mode 100644 tests/semanticdb/InstrumentTyper.expect.scala create mode 100644 tests/semanticdb/InstrumentTyper.scala create mode 100644 tests/semanticdb/Types.expect.scala create mode 100644 tests/semanticdb/Types.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 51e6a9f9bda9..da9cf0b83e5a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -198,7 +198,6 @@ class ExtractSemanticDB extends Phase { then traverse(annot.tree) - val Predef_name = defn.ScalaPredefModule.name val RootName = nme.ROOTPKG.toSimpleName val Scala = "scala".toTermName.toSimpleName @@ -240,7 +239,7 @@ class ExtractSemanticDB extends Phase { else limit registerUse(tree.symbol, Span(start max limit, end)) tree.qualifier match - case Select(Select(Ident(RootName), Scala), Predef_name) => // skip + case Select(Select(Ident(RootName), Scala), _) => // skip case _ => traverseChildren(tree) case tree: Import => if tree.span.exists && tree.span.start != tree.span.end then diff --git a/tests/semanticdb/ForComprehension.expect.scala b/tests/semanticdb/ForComprehension.expect.scala new file mode 100644 index 000000000000..815ef923b78f --- /dev/null +++ b/tests/semanticdb/ForComprehension.expect.scala @@ -0,0 +1,45 @@ +package example + +class ForComprehension/*<<=example.ForComprehension#*/ { + for { + a <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1)/*=>>scala.collection.immutable.List#flatMap().*/ + b/*=>>local0*/ <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1)/*=>>scala.collection.IterableOps#withFilter().*/ + if b/*=>>local0*/ >/*=>>scala.Int#`>`(+3).*/ 1/*=>>scala.collection.WithFilter#map().*/ + c/*=>>local2*/ = a/*=>>local1*/ +/*=>>scala.Int#`+`(+4).*/ b/*=>>local0*//*=>>scala.collection.immutable.List#map().*/ + } yield (a/*=>>local1*/, b/*=>>local0*/, c/*=>>local2*/) + for { + a <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1)/*=>>scala.collection.immutable.List#flatMap().*/ + b <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(a/*=>>local3*/)/*=>>scala.collection.IterableOps#withFilter().*/ + if ( + a/*=>>local3*/, + b/*=>>local4*/ + ) ==/*=>>scala.Any#`==`().*/ (1, 2)/*=>>scala.collection.WithFilter#flatMap().*/ + ( + c, + d + ) <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/((a/*=>>local3*/, b/*=>>local4*/))/*=>>scala.collection.WithFilter#withFilter().*//*=>>scala.collection.IterableOps#withFilter().*/ + if ( + a/*=>>local3*/, + b/*=>>local4*/, + c/*=>>local5*/, + d/*=>>local6*/ + ) ==/*=>>scala.Any#`==`().*/ (1, 2, 3, 4)/*=>>scala.collection.WithFilter#map().*/ + e/*=>>local7*/ = ( + a/*=>>local3*/, + b/*=>>local4*/, + c/*=>>local5*/, + d/*=>>local6*/ + )/*=>>scala.collection.IterableOps#withFilter().*/ + if e/*=>>local7*/ ==/*=>>scala.Any#`==`().*/ (1, 2, 3, 4)/*=>>scala.collection.WithFilter#flatMap().*/ + f <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(e/*=>>local7*/)/*=>>scala.collection.immutable.List#map().*/ + } yield { + ( + a/*=>>local3*/, + b/*=>>local4*/, + c/*=>>local5*/, + d/*=>>local6*/, + e/*=>>local7*/, + f/*=>>local8*/ + ) + } +} diff --git a/tests/semanticdb/ForComprehension.scala b/tests/semanticdb/ForComprehension.scala new file mode 100644 index 000000000000..23cbc1ce9da8 --- /dev/null +++ b/tests/semanticdb/ForComprehension.scala @@ -0,0 +1,45 @@ +package example + +class ForComprehension { + for { + a <- List(1) + b <- List(1) + if b > 1 + c = a + b + } yield (a, b, c) + for { + a <- List(1) + b <- List(a) + if ( + a, + b + ) == (1, 2) + ( + c, + d + ) <- List((a, b)) + if ( + a, + b, + c, + d + ) == (1, 2, 3, 4) + e = ( + a, + b, + c, + d + ) + if e == (1, 2, 3, 4) + f <- List(e) + } yield { + ( + a, + b, + c, + d, + e, + f + ) + } +} diff --git a/tests/semanticdb/Givens.expect.scala b/tests/semanticdb/Givens.expect.scala index 53f1c5f74c8e..b50b4ce3e41e 100644 --- a/tests/semanticdb/Givens.expect.scala +++ b/tests/semanticdb/Givens.expect.scala @@ -4,7 +4,7 @@ package b object Givens/*<<=a.b.Givens.*/ given :[A](any: A) - de/*<<=a.b.Givens.given_sayHello_of_A.*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().[A]*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>a.b.Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s"/*=>>scala.StringContext.*//*=>>scala.*//*=>>_root_*/Hello, I am $any/*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>scala.StringContext#s().*/" + de/*<<=a.b.Givens.given_sayHello_of_A.*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().[A]*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>a.b.Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s"Hello, I am $any/*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>scala.StringContext#s().*/" val hello1/*<<=a.b.Givens.hello1.*/ = /*=>>a.b.Givens.given_sayHello_of_A.sayHello().*//*=>>a.b.Givens.given_sayHello_of_A.*/1.sayHello diff --git a/tests/semanticdb/ImplicitConversion.expect.scala b/tests/semanticdb/ImplicitConversion.expect.scala new file mode 100644 index 000000000000..fe81f6a6ed63 --- /dev/null +++ b/tests/semanticdb/ImplicitConversion.expect.scala @@ -0,0 +1,33 @@ +package example + +import scala.language/*=>>scalaShadowing.language.*/.implicitConversions/*=>>scalaShadowing.language.implicitConversions.*/ + +class ImplicitConversion/*<<=example.ImplicitConversion#*/ { + implicit def string2Number/*<<=example.ImplicitConversion#string2Number().*/( + string/*<<=example.ImplicitConversion#string2Number().(string)*/: String/*=>>scala.Predef.String#*/ + ): Int/*=>>scala.Int#*/ = 42 + implicit def newAny2StringAdd/*<<=example.ImplicitConversion#newAny2StringAdd().*/[T/*<<=example.ImplicitConversion#newAny2StringAdd().[T]*/]( + any/*<<=example.ImplicitConversion#newAny2StringAdd().(any)*/: T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/ + ): Predef/*=>>scala.Predef.*/.any2stringadd/*=>>scala.Predef.any2stringadd#*/[T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/] = new Predef/*=>>scala.Predef.*/.any2stringadd/*=>>*//*=>>scala.Predef.any2stringadd#``().*/(any/*=>>example.ImplicitConversion#newAny2StringAdd().(any)*/) + val message/*<<=example.ImplicitConversion#message.*/ = "" + val number/*<<=example.ImplicitConversion#number.*/ = 42 + 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.*/ + .stripSuffix/*=>>scala.collection.StringOps#stripSuffix().*/("h") + /*=>>example.ImplicitConversion#newAny2StringAdd().*/tuple/*=>>example.ImplicitConversion#tuple.*/ +/*=>>scala.Predef.any2stringadd#`+`().*/ "Hello" + + // implicit conversions + val x/*<<=example.ImplicitConversion#x.*/: Int/*=>>scala.Int#*/ = /*=>>example.ImplicitConversion#string2Number().*/message/*=>>example.ImplicitConversion#message.*/ + + // interpolators + s"Hello $message/*=>>example.ImplicitConversion#message.*/ $number/*=>>example.ImplicitConversion#number.*//*=>>scala.StringContext#s().*/" + /*=>>scala.Predef.augmentString().*/s"""Hello + |$message/*=>>example.ImplicitConversion#message.*/ + |$number/*=>>example.ImplicitConversion#number.*//*=>>scala.StringContext#s().*/""".stripMargin/*=>>scala.collection.StringOps#stripMargin(+1).*/ + + val a/*<<=example.ImplicitConversion#a.*/: Int/*=>>scala.Int#*/ = /*=>>scala.Char.char2int().*/char/*=>>example.ImplicitConversion#char.*/ + val b/*<<=example.ImplicitConversion#b.*/: Long/*=>>scala.Long#*/ = /*=>>scala.Char.char2long().*/char/*=>>example.ImplicitConversion#char.*/ +} diff --git a/tests/semanticdb/ImplicitConversion.scala b/tests/semanticdb/ImplicitConversion.scala new file mode 100644 index 000000000000..dba524ab6e3f --- /dev/null +++ b/tests/semanticdb/ImplicitConversion.scala @@ -0,0 +1,33 @@ +package example + +import scala.language.implicitConversions + +class ImplicitConversion { + implicit def string2Number( + string: String + ): Int = 42 + implicit def newAny2StringAdd[T]( + any: T + ): Predef.any2stringadd[T] = new Predef.any2stringadd(any) + val message = "" + val number = 42 + val tuple = (1, 2) + val char: Char = 'a' + + // extension methods + message + .stripSuffix("h") + tuple + "Hello" + + // implicit conversions + val x: Int = message + + // interpolators + s"Hello $message $number" + s"""Hello + |$message + |$number""".stripMargin + + val a: Int = char + val b: Long = char +} diff --git a/tests/semanticdb/Imports.expect.scala b/tests/semanticdb/Imports.expect.scala new file mode 100644 index 000000000000..c4f4f22fb56e --- /dev/null +++ b/tests/semanticdb/Imports.expect.scala @@ -0,0 +1 @@ +import scala.util/*=>>scala.util.*/.control/*=>>scala.util.control.*/.NonFatal/*=>>scala.util.control.NonFatal.*/ diff --git a/tests/semanticdb/Imports.scala b/tests/semanticdb/Imports.scala new file mode 100644 index 000000000000..e6a2bef1a5c4 --- /dev/null +++ b/tests/semanticdb/Imports.scala @@ -0,0 +1 @@ +import scala.util.control.NonFatal diff --git a/tests/semanticdb/InstrumentTyper.expect.scala b/tests/semanticdb/InstrumentTyper.expect.scala new file mode 100644 index 000000000000..e03e8eea0951 --- /dev/null +++ b/tests/semanticdb/InstrumentTyper.expect.scala @@ -0,0 +1,26 @@ +package example + +import scala.annotation/*=>>scala.annotation.*/.meta/*=>>scala.annotation.meta.*/.param/*=>>scala.annotation.meta.param.*/ +import scala.language/*=>>scalaShadowing.language.*/.existentials/*=>>scalaShadowing.language.existentials.*/ +import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ +import types.Test._ + +class InstrumentTyper/*<<=example.InstrumentTyper#*/ { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => + def all/*<<=example.InstrumentTyper#all().*/ = List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/( + Literal/*=>>types.Test.Literal.*/.int/*=>>types.Test.Literal.int.*/, + Literal/*=>>types.Test.Literal.*/.long/*=>>types.Test.Literal.long.*/, + Literal/*=>>types.Test.Literal.*/.float/*=>>types.Test.Literal.float.*/, + Literal/*=>>types.Test.Literal.*/.double/*=>>types.Test.Literal.double.*/, + Literal/*=>>types.Test.Literal.*/.nil/*=>>types.Test.Literal.nil.*/, + Literal/*=>>types.Test.Literal.*/.char/*=>>types.Test.Literal.char.*/, + Literal/*=>>types.Test.Literal.*/.string/*=>>types.Test.Literal.string.*/, + Literal/*=>>types.Test.Literal.*/.bool/*=>>types.Test.Literal.bool.*/, + Literal/*=>>types.Test.Literal.*/.unit/*=>>types.Test.Literal.unit.*/, + Literal/*=>>types.Test.Literal.*/.javaEnum/*=>>types.Test.Literal.javaEnum.*/, + Literal/*=>>types.Test.Literal.*/.clazzOf/*=>>types.Test.Literal.clazzOf.*/, + List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/() + ) + type AnnotatedType/*<<=example.InstrumentTyper#AnnotatedType#*/ = Int/*=>>scala.Int#*/ @param + def singletonType/*<<=example.InstrumentTyper#singletonType().*/(x/*<<=example.InstrumentTyper#singletonType().(x)*/: Predef/*=>>scala.Predef.*/.type) = ???/*=>>scala.Predef.`???`().*/ + final val clazzOf/*<<=example.InstrumentTyper#clazzOf.*/ = classOf/*=>>scala.Predef.classOf().*/[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] +} diff --git a/tests/semanticdb/InstrumentTyper.scala b/tests/semanticdb/InstrumentTyper.scala new file mode 100644 index 000000000000..2c2ede6f85da --- /dev/null +++ b/tests/semanticdb/InstrumentTyper.scala @@ -0,0 +1,26 @@ +package example + +import scala.annotation.meta.param +import scala.language.existentials +import scala.language.higherKinds +import types.Test._ + +class InstrumentTyper { self: AnyRef => + def all = List( + Literal.int, + Literal.long, + Literal.float, + Literal.double, + Literal.nil, + Literal.char, + Literal.string, + Literal.bool, + Literal.unit, + Literal.javaEnum, + Literal.clazzOf, + List() + ) + type AnnotatedType = Int @param + def singletonType(x: Predef.type) = ??? + final val clazzOf = classOf[Option[Int]] +} diff --git a/tests/semanticdb/Types.expect.scala b/tests/semanticdb/Types.expect.scala new file mode 100644 index 000000000000..e8b793c1778b --- /dev/null +++ b/tests/semanticdb/Types.expect.scala @@ -0,0 +1,115 @@ +package types + +import scala.language/*=>>scalaShadowing.language.*/.existentials/*=>>scalaShadowing.language.existentials.*/ +import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ + +class /*=>>scala.annotation.Annotation#``().*/ann/*<<=types.ann#*/[T/*<<=types.ann#[T]*/](x/*<<=types.ann#x.*/: T/*=>>types.ann#``().[T]*/) extends scala/*=>>scala.*/.annotation/*=>>scala.annotation.*/.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ +class /*=>>scala.annotation.Annotation#``().*/ann1/*<<=types.ann1#*/ extends scala/*=>>scala.*/.annotation/*=>>scala.annotation.*/.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ +class /*=>>scala.annotation.Annotation#``().*/ann2/*<<=types.ann2#*/ extends scala/*=>>scala.*/.annotation/*=>>scala.annotation.*/.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ + +class B/*<<=types.B#*/ + +class C/*<<=types.C#*/ + +class P/*<<=types.P#*/ { + class C/*<<=types.P#C#*/ + class X/*<<=types.P#X#*/ + val x/*<<=types.P#x.*/ = new X/*=>>types.P#X#*//*=>>types.P#X#``().*/ +} + +class T/*<<=types.T#*/ { + class C/*<<=types.T#C#*/ + class X/*<<=types.T#X#*/ + val x/*<<=types.T#x.*/ = new X/*=>>types.T#X#*//*=>>types.T#X#``().*/ +} + +object Test/*<<=types.Test.*/ { + class M/*<<=types.Test.M#*/ { + def m/*<<=types.Test.M#m().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + } + + trait N/*<<=types.Test.N#*/ { + def n/*<<=types.Test.N#n().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + } + + class C/*<<=types.Test.C#*/ extends M/*=>>types.Test.M#*//*=>>types.Test.M#``().*/ { + val p/*<<=types.Test.C#p.*/ = new P/*=>>types.P#*//*=>>types.P#``().*/ + val x/*<<=types.Test.C#x.*/ = p/*=>>types.Test.C#p.*/.x/*=>>types.P#x.*/ + + val typeRef1/*<<=types.Test.C#typeRef1.*/: C/*=>>types.Test.C#*/ = ???/*=>>scala.Predef.`???`().*/ + val typeRef2/*<<=types.Test.C#typeRef2.*/: p/*=>>types.Test.C#p.*/.C/*=>>types.P#C#*/ = ???/*=>>scala.Predef.`???`().*/ + val typeRef3/*<<=types.Test.C#typeRef3.*/: T/*=>>types.T#*/#C/*=>>types.T#C#*/ = ???/*=>>scala.Predef.`???`().*/ + val typeRef4/*<<=types.Test.C#typeRef4.*/: List/*=>>scala.package.List#*/[Int/*=>>scala.Int#*/] = ???/*=>>scala.Predef.`???`().*/ + + val singleType1/*<<=types.Test.C#singleType1.*/: x/*=>>types.Test.C#x.*/.type = ???/*=>>scala.Predef.`???`().*/ + val singleType2/*<<=types.Test.C#singleType2.*/: p/*=>>types.Test.C#p.*/.x/*=>>types.P#x.*/.type = ???/*=>>scala.Predef.`???`().*/ + val Either/*<<=types.Test.C#Either.*/ = scala/*=>>scala.*/.util/*=>>scala.util.*/.Either/*=>>scala.util.Either.*/ + + val thisType1/*<<=types.Test.C#thisType1.*/: this.type = ???/*=>>scala.Predef.`???`().*/ + val thisType2/*<<=types.Test.C#thisType2.*/: C.this.type = ???/*=>>scala.Predef.`???`().*/ + + val superType1/*<<=types.Test.C#superType1.*/ = super.m/*=>>types.Test.M#m().*/ + val superType2/*<<=types.Test.C#superType2.*/ = super[M].m/*=>>types.Test.M#m().*/ + val superType3/*<<=types.Test.C#superType3.*/ = C.super[M].m/*=>>types.Test.M#m().*/ + + val compoundType1/*<<=types.Test.C#compoundType1.*/: { def k/*<<=local0*/: Int/*=>>scala.Int#*/ } = ???/*=>>scala.Predef.`???`().*/ + val compoundType2/*<<=types.Test.C#compoundType2.*/: M/*=>>types.Test.M#*/ with N/*=>>types.Test.N#*/ = ???/*=>>scala.Predef.`???`().*/ + val compoundType3/*<<=types.Test.C#compoundType3.*/: M/*=>>types.Test.M#*/ with N/*=>>types.Test.N#*/ { def k/*<<=local1*/: Int/*=>>scala.Int#*/ } = ???/*=>>scala.Predef.`???`().*/ + val compoundType4/*<<=types.Test.C#compoundType4.*/ = new { def k/*<<=local2*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } + val compoundType5/*<<=types.Test.C#compoundType5.*/ = new M/*=>>types.Test.M#*//*=>>types.Test.M#``().*/ with N/*=>>types.Test.N#*/ + val compoundType6/*<<=types.Test.C#compoundType6.*/ = new M/*=>>types.Test.M#*//*=>>types.Test.M#``().*/ with N/*=>>types.Test.N#*/ { def k/*<<=local3*/: 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 @ann2 = ???/*=>>scala.Predef.`???`().*/ + + val existentialType2/*<<=types.Test.C#existentialType2.*/: List/*=>>scala.package.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ + val existentialType3/*<<=types.Test.C#existentialType3.*/ = Class/*=>>java.lang.Class.*/.forName/*=>>java.lang.Class.forName().*/("foo.Bar") + val existentialType4/*<<=types.Test.C#existentialType4.*/ = Class/*=>>java.lang.Class.*/.forName/*=>>java.lang.Class.forName().*/("foo.Bar") + + def typeLambda1/*<<=types.Test.C#typeLambda1().*/[M/*<<=types.Test.C#typeLambda1().[M]*/[_]] = ???/*=>>scala.Predef.`???`().*/ + typeLambda1/*=>>types.Test.C#typeLambda1().*/[({ type L/*<<=local4*/[T/*<<=local5*/] = List/*=>>scala.package.List#*/[T/*=>>local5*/] })#L/*=>>*/] + + object ClassInfoType1/*<<=types.Test.C#ClassInfoType1.*/ + class ClassInfoType2/*<<=types.Test.C#ClassInfoType2#*/ extends B/*=>>types.B#*//*=>>types.B#``().*/ { def x/*<<=types.Test.C#ClassInfoType2#x().*/ = 42 } + trait ClassInfoType3/*<<=types.Test.C#ClassInfoType3#*/[T/*<<=types.Test.C#ClassInfoType3#[T]*/] + + object MethodType/*<<=types.Test.C#MethodType.*/ { + def x1/*<<=types.Test.C#MethodType.x1().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + def x2/*<<=types.Test.C#MethodType.x2().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + def m3/*<<=types.Test.C#MethodType.m3().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + def m4/*<<=types.Test.C#MethodType.m4().*/(): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + def m5/*<<=types.Test.C#MethodType.m5().*/(x/*<<=types.Test.C#MethodType.m5().(x)*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + def m6/*<<=types.Test.C#MethodType.m6().*/[T/*<<=types.Test.C#MethodType.m6().[T]*/](x/*<<=types.Test.C#MethodType.m6().(x)*/: T/*=>>types.Test.C#MethodType.m6().[T]*/): T/*=>>types.Test.C#MethodType.m6().[T]*/ = ???/*=>>scala.Predef.`???`().*/ + } + + object ByNameType/*<<=types.Test.C#ByNameType.*/ { + def m1/*<<=types.Test.C#ByNameType.m1().*/(x/*<<=types.Test.C#ByNameType.m1().(x)*/: => Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + } + + case class RepeatedType/*<<=types.Test.C#RepeatedType#*/(s/*<<=types.Test.C#RepeatedType#s.*/: String/*=>>scala.Predef.String#*/*) { + def m1/*<<=types.Test.C#RepeatedType#m1().*/(x/*<<=types.Test.C#RepeatedType#m1().(x)*/: Int/*=>>scala.Int#*/*): Int/*=>>scala.Int#*/ = s/*=>>types.Test.C#RepeatedType#s.*/.length/*=>>scala.collection.SeqOps#length().*/ + } + + object TypeType/*<<=types.Test.C#TypeType.*/ { + type T1/*<<=types.Test.C#TypeType.T1#*/ + def m2/*<<=types.Test.C#TypeType.m2().*/[T2/*<<=types.Test.C#TypeType.m2().[T2]*/ >: C/*=>>types.Test.C#*/ <: C/*=>>types.Test.C#*/] = ???/*=>>scala.Predef.`???`().*/ + def m3/*<<=types.Test.C#TypeType.m3().*/[M3/*<<=types.Test.C#TypeType.m3().[M3]*/[_]] = ???/*=>>scala.Predef.`???`().*/ + type T4/*<<=types.Test.C#TypeType.T4#*/ = C/*=>>types.Test.C#*/ + type T5/*<<=types.Test.C#TypeType.T5#*/[U/*<<=types.Test.C#TypeType.T5#[U]*/] = U/*=>>types.Test.C#TypeType.T5#[U]*/ + } + } + + object Literal/*<<=types.Test.Literal.*/ { + final val int/*<<=types.Test.Literal.int.*/ = 1 + final val long/*<<=types.Test.Literal.long.*/ = 1L + final val float/*<<=types.Test.Literal.float.*/ = 1f + final val double/*<<=types.Test.Literal.double.*/ = 2d + final val nil/*<<=types.Test.Literal.nil.*/ = null + final val char/*<<=types.Test.Literal.char.*/ = 'a' + final val string/*<<=types.Test.Literal.string.*/ = "a" + final val bool/*<<=types.Test.Literal.bool.*/ = true + final val unit/*<<=types.Test.Literal.unit.*/ = () + final val javaEnum/*<<=types.Test.Literal.javaEnum.*/ = java/*=>>java.*/.nio/*=>>java.nio.*/.file/*=>>java.nio.file.*/.LinkOption/*=>>java.nio.file.LinkOption.*/.NOFOLLOW_LINKS/*=>>java.nio.file.LinkOption.NOFOLLOW_LINKS.*/ + final val clazzOf/*<<=types.Test.Literal.clazzOf.*/ = classOf/*=>>scala.Predef.classOf().*/[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] + } +} diff --git a/tests/semanticdb/Types.scala b/tests/semanticdb/Types.scala new file mode 100644 index 000000000000..b6f5495c9675 --- /dev/null +++ b/tests/semanticdb/Types.scala @@ -0,0 +1,115 @@ +package types + +import scala.language.existentials +import scala.language.higherKinds + +class ann[T](x: T) extends scala.annotation.StaticAnnotation +class ann1 extends scala.annotation.StaticAnnotation +class ann2 extends scala.annotation.StaticAnnotation + +class B + +class C + +class P { + class C + class X + val x = new X +} + +class T { + class C + class X + val x = new X +} + +object Test { + class M { + def m: Int = ??? + } + + trait N { + def n: Int = ??? + } + + class C extends M { + val p = new P + val x = p.x + + val typeRef1: C = ??? + val typeRef2: p.C = ??? + val typeRef3: T#C = ??? + val typeRef4: List[Int] = ??? + + val singleType1: x.type = ??? + val singleType2: p.x.type = ??? + val Either = scala.util.Either + + val thisType1: this.type = ??? + val thisType2: C.this.type = ??? + + val superType1 = super.m + val superType2 = super[M].m + val superType3 = C.super[M].m + + val compoundType1: { def k: Int } = ??? + val compoundType2: M with N = ??? + val compoundType3: M with N { def k: Int } = ??? + val compoundType4 = new { def k: Int = ??? } + val compoundType5 = new M with N + val compoundType6 = new M with N { def k: Int = ??? } + + val annType1: T @ann(42) = ??? + val annType2: T @ann1 @ann2 = ??? + + val existentialType2: List[_] = ??? + val existentialType3 = Class.forName("foo.Bar") + val existentialType4 = Class.forName("foo.Bar") + + def typeLambda1[M[_]] = ??? + typeLambda1[({ type L[T] = List[T] })#L] + + object ClassInfoType1 + class ClassInfoType2 extends B { def x = 42 } + trait ClassInfoType3[T] + + object MethodType { + def x1: Int = ??? + def x2: Int = ??? + def m3: Int = ??? + def m4(): Int = ??? + def m5(x: Int): Int = ??? + def m6[T](x: T): T = ??? + } + + object ByNameType { + def m1(x: => Int): Int = ??? + } + + case class RepeatedType(s: String*) { + def m1(x: Int*): Int = s.length + } + + object TypeType { + type T1 + def m2[T2 >: C <: C] = ??? + def m3[M3[_]] = ??? + type T4 = C + type T5[U] = U + } + } + + object Literal { + final val int = 1 + final val long = 1L + final val float = 1f + final val double = 2d + final val nil = null + final val char = 'a' + final val string = "a" + final val bool = true + final val unit = () + final val javaEnum = java.nio.file.LinkOption.NOFOLLOW_LINKS + final val clazzOf = classOf[Option[Int]] + } +} From 9caa5c4fd51e9e1ea5f7832ab8e6d72368494d72 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 6 Nov 2019 17:27:55 +0100 Subject: [PATCH 037/107] Add semanticdb todolist; only traverse paths if qualifier is not a package --- .../dotc/semanticdb/ExtractSemanticDB.scala | 19 ++++++++++--------- .../dotc/semanticdb/SemanticdbTests.scala | 2 +- tests/semanticdb/Advanced.expect.scala | 2 +- tests/semanticdb/Enums.expect.scala | 2 +- tests/semanticdb/Example.expect.scala | 6 +++--- .../ImplicitConversion.expect.scala | 2 +- tests/semanticdb/Imports.expect.scala | 2 +- tests/semanticdb/InstrumentTyper.expect.scala | 8 ++++---- tests/semanticdb/Issue1749.expect.scala | 16 ++++++++++++++++ tests/semanticdb/Issue1749.scala | 16 ++++++++++++++++ tests/semanticdb/Types.expect.scala | 14 +++++++------- tests/semanticdb/todo | 13 +++++++++++++ 12 files changed, 74 insertions(+), 28 deletions(-) create mode 100644 tests/semanticdb/Issue1749.expect.scala create mode 100644 tests/semanticdb/Issue1749.scala create mode 100644 tests/semanticdb/todo diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index da9cf0b83e5a..1b69bdd8ec55 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -160,6 +160,9 @@ class ExtractSemanticDB extends Phase { private def excludeDefStrict(sym: Symbol)(given Context): Boolean = sym.name.is(NameKinds.DefaultGetterName) + || sym == defn.Predef_classOf + || sym == defn.ScalaPredefModule + || sym == defn.StringContextModule private def (sym: Symbol) isAnonymous(given Context): Boolean = sym.isAnonymousClass @@ -172,7 +175,7 @@ class ExtractSemanticDB extends Phase { private def registerOccurrence(sym: Symbol, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = val occ = SymbolOccurrence(symbolName(sym), range(span), role) - if !generated.contains(occ) then + if !generated.contains(occ) && occ.symbol.nonEmpty then occurrences += occ generated += occ @@ -188,7 +191,8 @@ class ExtractSemanticDB extends Phase { def registerPath(expr: Tree): Unit = expr match case t @ Select(expr, _) => registerUse(t.symbol, t.span) - registerPath(expr) + if !expr.symbol.is(Package) then + registerPath(expr) case _ => @@ -198,9 +202,6 @@ class ExtractSemanticDB extends Phase { then traverse(annot.tree) - val RootName = nme.ROOTPKG.toSimpleName - val Scala = "scala".toTermName.toSimpleName - tree match case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree @@ -238,9 +239,8 @@ class ExtractSemanticDB extends Phase { if source.content()(end - 1) == '`' then end - len - 1 else end - len else limit registerUse(tree.symbol, Span(start max limit, end)) - tree.qualifier match - case Select(Select(Ident(RootName), Scala), _) => // skip - case _ => traverseChildren(tree) + if !tree.qualifier.symbol.is(Package) then + traverseChildren(tree) case tree: Import => if tree.span.exists && tree.span.start != tree.span.end then for sel <- tree.selectors do @@ -250,7 +250,8 @@ class ExtractSemanticDB extends Phase { registerUse(alt.symbol, sel.imported.span) if (alt.symbol.companionClass.exists) registerUse(alt.symbol.companionClass, sel.imported.span) - registerPath(tree.expr) + if !tree.expr.symbol.is(Package) then + registerPath(tree.expr) case tree: Inlined => traverse(tree.call) case tree: PackageDef => tree.stats.foreach(traverse) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 10448fad61b2..ffc46ad2864c 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -65,7 +65,7 @@ class SemanticdbTests { "-Ysemanticdb", "-d", target.toString, // "-Ydebug", - // "-Xprint:extractSemanticDB", + "-Xprint:extractSemanticDB", "-sourceroot", src.toString, "-usejavacp", ) ++ inputFiles().map(_.toString) diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/Advanced.expect.scala index 042ac6e66f00..46f598b4c54f 100644 --- a/tests/semanticdb/Advanced.expect.scala +++ b/tests/semanticdb/Advanced.expect.scala @@ -3,7 +3,7 @@ package advanced import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ import scala.language/*=>>scalaShadowing.language.*/.reflectiveCalls/*=>>scalaShadowing.language.reflectiveCalls.*/ -import scala.reflect/*=>>scala.reflect.*/.Selectable/*=>>scala.reflect.Selectable.*/.reflectiveSelectable/*=>>scala.reflect.Selectable.reflectiveSelectable().*/ +import scala.reflect.Selectable/*=>>scala.reflect.Selectable.*/.reflectiveSelectable/*=>>scala.reflect.Selectable.reflectiveSelectable().*/ class C/*<<=advanced.C#*/[T/*<<=advanced.C#[T]*/] { def t/*<<=advanced.C#t().*/: T/*=>>advanced.C#[T]*/ = ???/*=>>scala.Predef.`???`().*/ diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala index e478cc89c9d7..7a0379a4124a 100644 --- a/tests/semanticdb/Enums.expect.scala +++ b/tests/semanticdb/Enums.expect.scala @@ -33,7 +33,7 @@ object Enums/*<<=_empty_.Enums.*/ { } } - enum Planet/*<<=_empty_.Enums.Planet#*/(mass/*<<=_empty_.Enums.Planet#mass.*/: Double/*=>>scala.Double#*/, radius/*<<=_empty_.Enums.Planet#radius.*/: Double/*=>>scala.Double#*/) extends java/*=>>java.*/.lang/*=>>java.lang.*/.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 java.lang.Enum/*=>>java.lang.Enum#*/[Planet/*=>>_empty_.Enums.Planet#*/]/*=>>java.lang.Enum#``().*/ { 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/Example.expect.scala b/tests/semanticdb/Example.expect.scala index 1010aad05782..44be40aef5ec 100644 --- a/tests/semanticdb/Example.expect.scala +++ b/tests/semanticdb/Example.expect.scala @@ -1,11 +1,11 @@ package example -import scala.concurrent/*=>>scala.concurrent.*/.Future/*=>>scala.concurrent.Future.*//*=>>scala.concurrent.Future#*/ +import scala.concurrent.Future/*=>>scala.concurrent.Future.*//*=>>scala.concurrent.Future#*/ object Example/*<<=example.Example.*/ { /*=>>example.Example.*/self/*<<=local0*/ => - new /*=>>scala.collection.mutable.Stack.*/scala/*=>>scala.*/.collection/*=>>scala.collection.*/.mutable/*=>>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/*=>>scala.collection.mutable.Stack#*/[Int/*=>>scala.Int#*/]/*=>>scala.collection.mutable.Stack#``(+1).*/() def main/*<<=example.Example.main().*/(args/*<<=example.Example.main().(args)*/: Array/*=>>scala.Array#*/[String/*=>>scala.Predef.String#*/]): Unit/*=>>scala.Unit#*/ = { println/*=>>scala.Predef.println(+1).*/(1) } - val x/*<<=example.Example.x.*/ = scala/*=>>scala.*/.reflect/*=>>scala.reflect.*/.classTag/*=>>scala.reflect.package.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>java.lang.Integer.TYPE.*//*=>>java.lang.Integer.*/ + val x/*<<=example.Example.x.*/ = scala.reflect.classTag/*=>>scala.reflect.package.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>java.lang.Integer.TYPE.*//*=>>java.lang.Integer.*/ } diff --git a/tests/semanticdb/ImplicitConversion.expect.scala b/tests/semanticdb/ImplicitConversion.expect.scala index fe81f6a6ed63..bf797b030fa7 100644 --- a/tests/semanticdb/ImplicitConversion.expect.scala +++ b/tests/semanticdb/ImplicitConversion.expect.scala @@ -8,7 +8,7 @@ class ImplicitConversion/*<<=example.ImplicitConversion#*/ { ): Int/*=>>scala.Int#*/ = 42 implicit def newAny2StringAdd/*<<=example.ImplicitConversion#newAny2StringAdd().*/[T/*<<=example.ImplicitConversion#newAny2StringAdd().[T]*/]( any/*<<=example.ImplicitConversion#newAny2StringAdd().(any)*/: T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/ - ): Predef/*=>>scala.Predef.*/.any2stringadd/*=>>scala.Predef.any2stringadd#*/[T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/] = new Predef/*=>>scala.Predef.*/.any2stringadd/*=>>*//*=>>scala.Predef.any2stringadd#``().*/(any/*=>>example.ImplicitConversion#newAny2StringAdd().(any)*/) + ): Predef.any2stringadd/*=>>scala.Predef.any2stringadd#*/[T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/] = new Predef.any2stringadd/*=>>scala.Predef.any2stringadd#``().*/(any/*=>>example.ImplicitConversion#newAny2StringAdd().(any)*/) val message/*<<=example.ImplicitConversion#message.*/ = "" val number/*<<=example.ImplicitConversion#number.*/ = 42 val tuple/*<<=example.ImplicitConversion#tuple.*/ = (1, 2) diff --git a/tests/semanticdb/Imports.expect.scala b/tests/semanticdb/Imports.expect.scala index c4f4f22fb56e..d3c6dfe73ffd 100644 --- a/tests/semanticdb/Imports.expect.scala +++ b/tests/semanticdb/Imports.expect.scala @@ -1 +1 @@ -import scala.util/*=>>scala.util.*/.control/*=>>scala.util.control.*/.NonFatal/*=>>scala.util.control.NonFatal.*/ +import scala.util.control.NonFatal/*=>>scala.util.control.NonFatal.*/ diff --git a/tests/semanticdb/InstrumentTyper.expect.scala b/tests/semanticdb/InstrumentTyper.expect.scala index e03e8eea0951..4d8587b5b7f7 100644 --- a/tests/semanticdb/InstrumentTyper.expect.scala +++ b/tests/semanticdb/InstrumentTyper.expect.scala @@ -1,9 +1,9 @@ package example -import scala.annotation/*=>>scala.annotation.*/.meta/*=>>scala.annotation.meta.*/.param/*=>>scala.annotation.meta.param.*/ +import scala.annotation.meta.param/*=>>scala.annotation.meta.param.*/ import scala.language/*=>>scalaShadowing.language.*/.existentials/*=>>scalaShadowing.language.existentials.*/ import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ -import types.Test._ +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().*/( @@ -21,6 +21,6 @@ class InstrumentTyper/*<<=example.InstrumentTyper#*/ { self/*<<=local0*/: AnyRef List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/() ) type AnnotatedType/*<<=example.InstrumentTyper#AnnotatedType#*/ = Int/*=>>scala.Int#*/ @param - def singletonType/*<<=example.InstrumentTyper#singletonType().*/(x/*<<=example.InstrumentTyper#singletonType().(x)*/: Predef/*=>>scala.Predef.*/.type) = ???/*=>>scala.Predef.`???`().*/ - final val clazzOf/*<<=example.InstrumentTyper#clazzOf.*/ = classOf/*=>>scala.Predef.classOf().*/[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] + def singletonType/*<<=example.InstrumentTyper#singletonType().*/(x/*<<=example.InstrumentTyper#singletonType().(x)*/: Predef.type) = ???/*=>>scala.Predef.`???`().*/ + final val clazzOf/*<<=example.InstrumentTyper#clazzOf.*/ = classOf[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] } diff --git a/tests/semanticdb/Issue1749.expect.scala b/tests/semanticdb/Issue1749.expect.scala new file mode 100644 index 000000000000..4d037610ca25 --- /dev/null +++ b/tests/semanticdb/Issue1749.expect.scala @@ -0,0 +1,16 @@ +// See https://github.com/scalameta/scalameta/issues/1749 +package example + +import scala.math.Ordered/*=>>scala.math.Ordered.*/.orderingToOrdered/*=>>scala.math.Ordered.orderingToOrdered().*/ + +class Issue1749/*<<=example.Issue1749#*/ { + val x1/*<<=example.Issue1749#x1.*/ = 42 + val x2/*<<=example.Issue1749#x2.*/ = 42 + /*=>>scala.math.Ordered.orderingToOrdered().*/(x1/*=>>example.Issue1749#x1.*/, x1/*=>>example.Issue1749#x1.*/)/*=>>scala.math.Ordering.Tuple2().*//*=>>scala.math.Ordering.Int.*/ + .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" +} diff --git a/tests/semanticdb/Issue1749.scala b/tests/semanticdb/Issue1749.scala new file mode 100644 index 000000000000..053bd3d34562 --- /dev/null +++ b/tests/semanticdb/Issue1749.scala @@ -0,0 +1,16 @@ +// See https://github.com/scalameta/scalameta/issues/1749 +package example + +import scala.math.Ordered.orderingToOrdered + +class Issue1749 { + val x1 = 42 + val x2 = 42 + (x1, x1) + .compare((x2, x2)) +} + +class Issue1854 { + val map = collection.mutable.Map.empty[String, String] + map("a") = "b" +} diff --git a/tests/semanticdb/Types.expect.scala b/tests/semanticdb/Types.expect.scala index e8b793c1778b..9c09a29513b0 100644 --- a/tests/semanticdb/Types.expect.scala +++ b/tests/semanticdb/Types.expect.scala @@ -3,9 +3,9 @@ package types import scala.language/*=>>scalaShadowing.language.*/.existentials/*=>>scalaShadowing.language.existentials.*/ import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ -class /*=>>scala.annotation.Annotation#``().*/ann/*<<=types.ann#*/[T/*<<=types.ann#[T]*/](x/*<<=types.ann#x.*/: T/*=>>types.ann#``().[T]*/) extends scala/*=>>scala.*/.annotation/*=>>scala.annotation.*/.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ -class /*=>>scala.annotation.Annotation#``().*/ann1/*<<=types.ann1#*/ extends scala/*=>>scala.*/.annotation/*=>>scala.annotation.*/.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ -class /*=>>scala.annotation.Annotation#``().*/ann2/*<<=types.ann2#*/ extends scala/*=>>scala.*/.annotation/*=>>scala.annotation.*/.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ +class /*=>>scala.annotation.Annotation#``().*/ann/*<<=types.ann#*/[T/*<<=types.ann#[T]*/](x/*<<=types.ann#x.*/: T/*=>>types.ann#``().[T]*/) extends scala.annotation.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ +class /*=>>scala.annotation.Annotation#``().*/ann1/*<<=types.ann1#*/ extends scala.annotation.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ +class /*=>>scala.annotation.Annotation#``().*/ann2/*<<=types.ann2#*/ extends scala.annotation.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ class B/*<<=types.B#*/ @@ -43,7 +43,7 @@ object Test/*<<=types.Test.*/ { val singleType1/*<<=types.Test.C#singleType1.*/: x/*=>>types.Test.C#x.*/.type = ???/*=>>scala.Predef.`???`().*/ val singleType2/*<<=types.Test.C#singleType2.*/: p/*=>>types.Test.C#p.*/.x/*=>>types.P#x.*/.type = ???/*=>>scala.Predef.`???`().*/ - val Either/*<<=types.Test.C#Either.*/ = scala/*=>>scala.*/.util/*=>>scala.util.*/.Either/*=>>scala.util.Either.*/ + val Either/*<<=types.Test.C#Either.*/ = scala.util.Either/*=>>scala.util.Either.*/ val thisType1/*<<=types.Test.C#thisType1.*/: this.type = ???/*=>>scala.Predef.`???`().*/ val thisType2/*<<=types.Test.C#thisType2.*/: C.this.type = ???/*=>>scala.Predef.`???`().*/ @@ -67,7 +67,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/*<<=local4*/[T/*<<=local5*/] = List/*=>>scala.package.List#*/[T/*=>>local5*/] })#L/*=>>*/] + typeLambda1/*=>>types.Test.C#typeLambda1().*/[({ type L/*<<=local4*/[T/*<<=local5*/] = List/*=>>scala.package.List#*/[T/*=>>local5*/] })#L] object ClassInfoType1/*<<=types.Test.C#ClassInfoType1.*/ class ClassInfoType2/*<<=types.Test.C#ClassInfoType2#*/ extends B/*=>>types.B#*//*=>>types.B#``().*/ { def x/*<<=types.Test.C#ClassInfoType2#x().*/ = 42 } @@ -109,7 +109,7 @@ object Test/*<<=types.Test.*/ { final val string/*<<=types.Test.Literal.string.*/ = "a" final val bool/*<<=types.Test.Literal.bool.*/ = true final val unit/*<<=types.Test.Literal.unit.*/ = () - final val javaEnum/*<<=types.Test.Literal.javaEnum.*/ = java/*=>>java.*/.nio/*=>>java.nio.*/.file/*=>>java.nio.file.*/.LinkOption/*=>>java.nio.file.LinkOption.*/.NOFOLLOW_LINKS/*=>>java.nio.file.LinkOption.NOFOLLOW_LINKS.*/ - final val clazzOf/*<<=types.Test.Literal.clazzOf.*/ = classOf/*=>>scala.Predef.classOf().*/[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] + final val javaEnum/*<<=types.Test.Literal.javaEnum.*/ = java.nio.file.LinkOption/*=>>java.nio.file.LinkOption.*/.NOFOLLOW_LINKS/*=>>java.nio.file.LinkOption.NOFOLLOW_LINKS.*/ + final val clazzOf/*<<=types.Test.Literal.clazzOf.*/ = classOf[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] } } diff --git a/tests/semanticdb/todo b/tests/semanticdb/todo new file mode 100644 index 000000000000..9d584ad59f9d --- /dev/null +++ b/tests/semanticdb/todo @@ -0,0 +1,13 @@ +- [ ] Hide unapply, unapplySeq? +- [ ] Hide constructor of template +- [ ] Hide local vars in pattern def? +- [ ] Hide desugaring of for comprehension +- [ ] Hide calls to implicit conversions and their arguments +- [ ] Hide Tuple contructors +- [ ] Hide qualifier in Select inside a type? +- [x] Hide `Predef.classOf` +- [x] Hide `scala.Predef` +- [x] Hide `scala.StringContext` +- [x] Only traverse qualifier of a select if it is not a package +- [ ] Import wildcard needs to have reference to the qualifier +- [ ] We must look of the qualifier of a select on a term From 0b2e581c757cfef4375c06f8edb2e5e8b86d0da8 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 6 Nov 2019 18:17:20 +0100 Subject: [PATCH 038/107] unescape unicode in names, fix overload bug --- .../dotc/semanticdb/ExtractSemanticDB.scala | 23 +++++++++--- tests/semanticdb/InstrumentTyper.expect.scala | 2 +- tests/semanticdb/Local.expect.scala | 8 ++++ tests/semanticdb/Local.scala | 8 ++++ tests/semanticdb/Locals.expect.scala | 8 ++++ tests/semanticdb/Locals.scala | 8 ++++ tests/semanticdb/MethodUsages.expect.scala | 32 ++++++++++++++++ tests/semanticdb/MethodUsages.scala | 32 ++++++++++++++++ tests/semanticdb/Methods.expect.scala | 37 +++++++++++++++++++ tests/semanticdb/Methods.scala | 37 +++++++++++++++++++ tests/semanticdb/todo | 4 +- 11 files changed, 191 insertions(+), 8 deletions(-) create mode 100644 tests/semanticdb/Local.expect.scala create mode 100644 tests/semanticdb/Local.scala create mode 100644 tests/semanticdb/Locals.expect.scala create mode 100644 tests/semanticdb/Locals.scala create mode 100644 tests/semanticdb/MethodUsages.expect.scala create mode 100644 tests/semanticdb/MethodUsages.scala create mode 100644 tests/semanticdb/Methods.expect.scala create mode 100644 tests/semanticdb/Methods.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 1b69bdd8ec55..91d2ee1ffdec 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -59,14 +59,22 @@ class ExtractSemanticDB extends Phase { /** The symbol occurrences generated so far, as a set */ private val generated = new mutable.HashSet[SymbolOccurrence] + private val unicodeEscape = raw"\$$u(\p{XDigit}{4})".r + /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol, inOwner: Boolean = false)(given ctx: Context): Unit = def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) + def (name: Name) unescapeUnicode = { + unicodeEscape.replaceAllIn(name.toString, m => + String.valueOf(Integer.parseInt(m.group(1), 16).toChar) + ) + } + def addName(name: Name) = - val str = name.toString + val str = name.unescapeUnicode if isJavaIdent(str) then b.append(str) else b.append('`').append(str).append('`') @@ -79,8 +87,8 @@ class ExtractSemanticDB extends Phase { if !owner.isRoot then addSymName(b, owner, inOwner = true) def addOverloadIdx(sym: Symbol): Unit = - val alts = sym.owner.info.decls.lookupAll(sym.name).toList.reverse - if alts.tail.nonEmpty then + val alts = sym.owner.info.decls.lookupAll(sym.name).filter(_.is(Method)).toList.reverse + if alts.nonEmpty && alts.tail.nonEmpty then val idx = alts.indexOf(sym) assert(idx >= 0) if idx > 0 then @@ -161,6 +169,9 @@ class ExtractSemanticDB extends Phase { private def excludeDefStrict(sym: Symbol)(given Context): Boolean = sym.name.is(NameKinds.DefaultGetterName) || sym == defn.Predef_classOf + + private def blacklistPrefix(sym: Symbol)(given Context): Boolean = + sym.is(Package) || sym == defn.ScalaPredefModule || sym == defn.StringContextModule @@ -191,7 +202,7 @@ class ExtractSemanticDB extends Phase { def registerPath(expr: Tree): Unit = expr match case t @ Select(expr, _) => registerUse(t.symbol, t.span) - if !expr.symbol.is(Package) then + if !blacklistPrefix(expr.symbol) then registerPath(expr) case _ => @@ -239,7 +250,7 @@ class ExtractSemanticDB extends Phase { if source.content()(end - 1) == '`' then end - len - 1 else end - len else limit registerUse(tree.symbol, Span(start max limit, end)) - if !tree.qualifier.symbol.is(Package) then + if !blacklistPrefix(tree.qualifier.symbol) then traverseChildren(tree) case tree: Import => if tree.span.exists && tree.span.start != tree.span.end then @@ -250,7 +261,7 @@ class ExtractSemanticDB extends Phase { registerUse(alt.symbol, sel.imported.span) if (alt.symbol.companionClass.exists) registerUse(alt.symbol.companionClass, sel.imported.span) - if !tree.expr.symbol.is(Package) then + if !blacklistPrefix(tree.expr.symbol) then registerPath(tree.expr) case tree: Inlined => traverse(tree.call) diff --git a/tests/semanticdb/InstrumentTyper.expect.scala b/tests/semanticdb/InstrumentTyper.expect.scala index 4d8587b5b7f7..81a5032b9c25 100644 --- a/tests/semanticdb/InstrumentTyper.expect.scala +++ b/tests/semanticdb/InstrumentTyper.expect.scala @@ -21,6 +21,6 @@ class InstrumentTyper/*<<=example.InstrumentTyper#*/ { self/*<<=local0*/: AnyRef List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/() ) type AnnotatedType/*<<=example.InstrumentTyper#AnnotatedType#*/ = Int/*=>>scala.Int#*/ @param - def singletonType/*<<=example.InstrumentTyper#singletonType().*/(x/*<<=example.InstrumentTyper#singletonType().(x)*/: Predef.type) = ???/*=>>scala.Predef.`???`().*/ + def singletonType/*<<=example.InstrumentTyper#singletonType().*/(x/*<<=example.InstrumentTyper#singletonType().(x)*/: Predef/*=>>scala.Predef.*/.type) = ???/*=>>scala.Predef.`???`().*/ final val clazzOf/*<<=example.InstrumentTyper#clazzOf.*/ = classOf[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] } diff --git a/tests/semanticdb/Local.expect.scala b/tests/semanticdb/Local.expect.scala new file mode 100644 index 000000000000..f48a6dd28db5 --- /dev/null +++ b/tests/semanticdb/Local.expect.scala @@ -0,0 +1,8 @@ +package example + +class Local/*<<=example.Local#*/ { + def a/*<<=example.Local#a().*/() = { + def id/*<<=local0*/[A/*<<=local1*/](a/*<<=local2*/: A/*=>>local1*/): A/*=>>local1*/ = a/*=>>local2*/ + id/*=>>local0*/(1) + } +} diff --git a/tests/semanticdb/Local.scala b/tests/semanticdb/Local.scala new file mode 100644 index 000000000000..56caf92dd3b8 --- /dev/null +++ b/tests/semanticdb/Local.scala @@ -0,0 +1,8 @@ +package example + +class Local { + def a() = { + def id[A](a: A): A = a + id(1) + } +} diff --git a/tests/semanticdb/Locals.expect.scala b/tests/semanticdb/Locals.expect.scala new file mode 100644 index 000000000000..c6d4cf14fecf --- /dev/null +++ b/tests/semanticdb/Locals.expect.scala @@ -0,0 +1,8 @@ +package locals + +object Test/*<<=locals.Test.*/ { + val xs/*<<=locals.Test.xs.*/ = { + val x/*<<=local0*/ = 42 + List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(x/*=>>local0*/) + } +} diff --git a/tests/semanticdb/Locals.scala b/tests/semanticdb/Locals.scala new file mode 100644 index 000000000000..a040dddcd786 --- /dev/null +++ b/tests/semanticdb/Locals.scala @@ -0,0 +1,8 @@ +package locals + +object Test { + val xs = { + val x = 42 + List(x) + } +} diff --git a/tests/semanticdb/MethodUsages.expect.scala b/tests/semanticdb/MethodUsages.expect.scala new file mode 100644 index 000000000000..9dbe1876e33b --- /dev/null +++ b/tests/semanticdb/MethodUsages.expect.scala @@ -0,0 +1,32 @@ +package example + +class MethodUsages/*<<=example.MethodUsages#*/ { + val m/*<<=example.MethodUsages#m.*/ = new Methods/*=>>example.Methods#*/[Int/*=>>scala.Int#*/]/*=>>example.Methods#``().*/ + m/*=>>example.MethodUsages#m.*/.m1/*=>>example.Methods#m1().*/ + m/*=>>example.MethodUsages#m.*/.m2/*=>>example.Methods#m2().*/() + m/*=>>example.MethodUsages#m.*/.m3/*=>>example.Methods#m3().*/(0) + m/*=>>example.MethodUsages#m.*/.m4/*=>>example.Methods#m4().*/(0)(0) + m/*=>>example.MethodUsages#m.*/.m5/*=>>example.Methods#m5().*/("") + m/*=>>example.MethodUsages#m.*/.m5/*=>>example.Methods#m5(+1).*/(0) + m/*=>>example.MethodUsages#m.*/.m6/*=>>example.Methods#m6().*/(0) + m/*=>>example.MethodUsages#m.*/.m6/*=>>example.Methods#m6(+1).*/(new m/*=>>example.MethodUsages#m.*/.List/*=>>example.Methods#List#*/[Int/*=>>scala.Int#*/]/*=>>example.Methods#List#``().*/) + m/*=>>example.MethodUsages#m.*/.m6/*=>>example.Methods#m6(+2).*/(Nil/*=>>scala.package.Nil.*/) + m/*=>>example.MethodUsages#m.*/.m7/*=>>example.Methods#m7().*/(m/*=>>example.MethodUsages#m.*/, new m/*=>>example.MethodUsages#m.*/.List/*=>>example.Methods#List#*/[Int/*=>>scala.Int#*/]/*=>>example.Methods#List#``().*/)/*=>>scala.math.Ordering.Int.*/ + m/*=>>example.MethodUsages#m.*/.`m8().`/*=>>example.Methods#`m8().`().*/() + m/*=>>example.MethodUsages#m.*/.m9/*=>>example.Methods#m9().*/(null) + m/*=>>example.MethodUsages#m.*/.m10/*=>>example.Methods#m10().*/(null) + m/*=>>example.MethodUsages#m.*/.m11/*=>>example.Methods#m11().*/(Predef/*=>>scala.Predef.*/) + m/*=>>example.MethodUsages#m.*/.m11/*=>>example.Methods#m11(+1).*/(Example/*=>>example.Example.*/) + m/*=>>example.MethodUsages#m.*/.m12a/*=>>example.Methods#m12a().*/(null) + m/*=>>example.MethodUsages#m.*/.m12b/*=>>example.Methods#m12b().*/(null) + m/*=>>example.MethodUsages#m.*/.m13/*=>>example.Methods#m13().*/(0) + m/*=>>example.MethodUsages#m.*/.m15/*=>>example.Methods#m15().*/(0) + m/*=>>example.MethodUsages#m.*/.m16/*=>>example.Methods#m16().*/(0) + m/*=>>example.MethodUsages#m.*/.m16/*=>>example.Methods#m16().*/(0) + m/*=>>example.MethodUsages#m.*/.m17/*=>>example.Methods#m17.*/.m/*=>>example.Methods#m17.m().*/() + m/*=>>example.MethodUsages#m.*/.m17/*=>>example.Methods#m17().*/(1) + m/*=>>example.MethodUsages#m.*/.m17/*=>>example.Methods#m17(+1).*/("") + m/*=>>example.MethodUsages#m.*/.m18/*=>>example.Methods#m18.*/.m/*=>>example.Methods#m17.m().*/() + m/*=>>example.MethodUsages#m.*/.m18/*=>>example.Methods#m18().*/(1) + m/*=>>example.MethodUsages#m.*/.m18/*=>>example.Methods#m18(+1).*/("") +} diff --git a/tests/semanticdb/MethodUsages.scala b/tests/semanticdb/MethodUsages.scala new file mode 100644 index 000000000000..b5982e8563a5 --- /dev/null +++ b/tests/semanticdb/MethodUsages.scala @@ -0,0 +1,32 @@ +package example + +class MethodUsages { + val m = new Methods[Int] + m.m1 + m.m2() + m.m3(0) + m.m4(0)(0) + m.m5("") + m.m5(0) + m.m6(0) + m.m6(new m.List[Int]) + m.m6(Nil) + m.m7(m, new m.List[Int]) + m.`m8().`() + m.m9(null) + m.m10(null) + m.m11(Predef) + m.m11(Example) + m.m12a(null) + m.m12b(null) + m.m13(0) + m.m15(0) + m.m16(0) + m.m16(0) + m.m17.m() + m.m17(1) + m.m17("") + m.m18.m() + m.m18(1) + m.m18("") +} diff --git a/tests/semanticdb/Methods.expect.scala b/tests/semanticdb/Methods.expect.scala new file mode 100644 index 000000000000..877d125b25e7 --- /dev/null +++ b/tests/semanticdb/Methods.expect.scala @@ -0,0 +1,37 @@ +package example + +import scala.math.Ordering/*=>>scala.math.Ordering.*//*=>>scala.math.Ordering#*/ +import scala.language/*=>>scalaShadowing.language.*/.existentials/*=>>scalaShadowing.language.existentials.*/ + +class Methods/*<<=example.Methods#*/[T/*<<=example.Methods#[T]*/] { + class List/*<<=example.Methods#List#*/[T/*<<=example.Methods#List#[T]*/] + type AList/*<<=example.Methods#AList#*/[T/*<<=example.Methods#AList#[T]*/] = List/*=>>example.Methods#List#*/[T/*=>>example.Methods#AList#[T]*/] + def m1/*<<=example.Methods#m1().*/ = ???/*=>>scala.Predef.`???`().*/ + def m2/*<<=example.Methods#m2().*/() = ???/*=>>scala.Predef.`???`().*/ + def m3/*<<=example.Methods#m3().*/(x/*<<=example.Methods#m3().(x)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ + def m4/*<<=example.Methods#m4().*/(x/*<<=example.Methods#m4().(x)*/: Int/*=>>scala.Int#*/)(y/*<<=example.Methods#m4().(y)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ + def m5/*<<=example.Methods#m5().*/(x/*<<=example.Methods#m5().(x)*/: String/*=>>scala.Predef.String#*/) = ???/*=>>scala.Predef.`???`().*/ + def m5/*<<=example.Methods#m5(+1).*/(x/*<<=example.Methods#m5(+1).(x)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ + def m6/*<<=example.Methods#m6().*/(x/*<<=example.Methods#m6().(x)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ + def m6/*<<=example.Methods#m6(+1).*/(x/*<<=example.Methods#m6(+1).(x)*/: List/*=>>example.Methods#List#*/[T/*=>>example.Methods#[T]*/]) = ???/*=>>scala.Predef.`???`().*/ + def m6/*<<=example.Methods#m6(+2).*/(x/*<<=example.Methods#m6(+2).(x)*/: scala.List/*=>>scala.package.List#*/[T/*=>>example.Methods#[T]*/]) = ???/*=>>scala.Predef.`???`().*/ + def m7/*<<=example.Methods#m7().*/[U/*<<=example.Methods#m7().[U]*//*<<=example.Methods#m7().(evidence$1)*/: Ordering/*=>>scala.math.Ordering#*//*=>>example.Methods#m7().[U]*/](c/*<<=example.Methods#m7().(c)*/: Methods/*=>>example.Methods#*/[T/*=>>example.Methods#[T]*/], l/*<<=example.Methods#m7().(l)*/: List/*=>>example.Methods#List#*/[U/*=>>example.Methods#m7().[U]*/]) = ???/*=>>scala.Predef.`???`().*/ + def `m8().`() =/*<<=example.Methods#`m8().`().*/ ???/*=>>scala.Predef.`???`().*/ + class `m9().` + d/*<<=example.Methods#`m9().`#*/ef m9/*<<=example.Methods#m9().*/(x/*<<=example.Methods#m9().(x)*/: `m9().`/*=>>example.Methods#`m9().`#*/) = ???/*=>>scala.Predef.`???`().*/ + def m10/*<<=example.Methods#m10().*/(x/*<<=example.Methods#m10().(x)*/: AList/*=>>example.Methods#AList#*/[T/*=>>example.Methods#[T]*/]) = ???/*=>>scala.Predef.`???`().*/ + def m11/*<<=example.Methods#m11().*/(x/*<<=example.Methods#m11().(x)*/: Predef/*=>>scala.Predef.*/.type) = ???/*=>>scala.Predef.`???`().*/ + def m11/*<<=example.Methods#m11(+1).*/(x/*<<=example.Methods#m11(+1).(x)*/: Example/*=>>example.Example.*/.type) = ???/*=>>scala.Predef.`???`().*/ + def m12a/*<<=example.Methods#m12a().*/(x/*<<=example.Methods#m12a().(x)*/: {}) = ???/*=>>scala.Predef.`???`().*/ + def m12b/*<<=example.Methods#m12b().*/(x/*<<=example.Methods#m12b().(x)*/: { val x/*<<=local0*/: Int/*=>>scala.Int#*/ }) = ???/*=>>scala.Predef.`???`().*/ + def m13/*<<=example.Methods#m13().*/(x/*<<=example.Methods#m13().(x)*/: Int/*=>>scala.Int#*/ @unchecked) = ???/*=>>scala.Predef.`???`().*/ + def m15/*<<=example.Methods#m15().*/(x/*<<=example.Methods#m15().(x)*/: => Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ + def m16/*<<=example.Methods#m16().*/(x/*<<=example.Methods#m16().(x)*/: Int/*=>>scala.Int#*/*) = ???/*=>>scala.Predef.`???`().*/ + object m17/*<<=example.Methods#m17.*/ { def m/*<<=example.Methods#m17.m().*/() = ???/*=>>scala.Predef.`???`().*/ } + def m17/*<<=example.Methods#m17().*/(a/*<<=example.Methods#m17().(a)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ + def m17/*<<=example.Methods#m17(+1).*/(b/*<<=example.Methods#m17(+1).(b)*/: String/*=>>scala.Predef.String#*/) = ???/*=>>scala.Predef.`???`().*/ + val m18/*<<=example.Methods#m18.*/ = m17/*=>>example.Methods#m17.*/ + def m18/*<<=example.Methods#m18().*/(a/*<<=example.Methods#m18().(a)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ + def m18/*<<=example.Methods#m18(+1).*/(b/*<<=example.Methods#m18(+1).(b)*/: String/*=>>scala.Predef.String#*/) = ???/*=>>scala.Predef.`???`().*/ + def m19/*<<=example.Methods#m19().*/(x/*<<=example.Methods#m19().(x)*//*<<=example.Methods#m19$default$3().(x)*/: Int/*=>>scala.Int#*/, y/*<<=example.Methods#m19().(y)*//*<<=example.Methods#m19$default$3().(y)*/: Int/*=>>scala.Int#*/ = 2)(z/*<<=example.Methods#m19().(z)*/: Int/*=>>scala.Int#*/ = 3) = ???/*=>>scala.Predef.`???`().*/ +} diff --git a/tests/semanticdb/Methods.scala b/tests/semanticdb/Methods.scala new file mode 100644 index 000000000000..0327a3c32279 --- /dev/null +++ b/tests/semanticdb/Methods.scala @@ -0,0 +1,37 @@ +package example + +import scala.math.Ordering +import scala.language.existentials + +class Methods[T] { + class List[T] + type AList[T] = List[T] + def m1 = ??? + def m2() = ??? + def m3(x: Int) = ??? + def m4(x: Int)(y: Int) = ??? + def m5(x: String) = ??? + def m5(x: Int) = ??? + def m6(x: Int) = ??? + def m6(x: List[T]) = ??? + def m6(x: scala.List[T]) = ??? + def m7[U: Ordering](c: Methods[T], l: List[U]) = ??? + def `m8().`() = ??? + class `m9().` + def m9(x: `m9().`) = ??? + def m10(x: AList[T]) = ??? + def m11(x: Predef.type) = ??? + def m11(x: Example.type) = ??? + def m12a(x: {}) = ??? + def m12b(x: { val x: Int }) = ??? + def m13(x: Int @unchecked) = ??? + def m15(x: => Int) = ??? + def m16(x: Int*) = ??? + object m17 { def m() = ??? } + def m17(a: Int) = ??? + def m17(b: String) = ??? + val m18 = m17 + def m18(a: Int) = ??? + def m18(b: String) = ??? + def m19(x: Int, y: Int = 2)(z: Int = 3) = ??? +} diff --git a/tests/semanticdb/todo b/tests/semanticdb/todo index 9d584ad59f9d..b68cf1f2a6a6 100644 --- a/tests/semanticdb/todo +++ b/tests/semanticdb/todo @@ -5,9 +5,11 @@ - [ ] Hide calls to implicit conversions and their arguments - [ ] Hide Tuple contructors - [ ] Hide qualifier in Select inside a type? +- [x] unescape unicode in names. - [x] Hide `Predef.classOf` -- [x] Hide `scala.Predef` +- [x] Hide `scala.Predef` prefix - [x] Hide `scala.StringContext` - [x] Only traverse qualifier of a select if it is not a package +- [ ] Weird issue with method overload counter when mixed with objects - [ ] Import wildcard needs to have reference to the qualifier - [ ] We must look of the qualifier of a select on a term From 5bc5a7d805685d8eae585239a1a487271d64f40e Mon Sep 17 00:00:00 2001 From: bishabosha Date: Wed, 6 Nov 2019 22:38:34 +0100 Subject: [PATCH 039/107] all package objects are named 'package' --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 6 +++++- .../dotty/tools/dotc/semanticdb/SemanticdbTests.scala | 2 +- tests/semanticdb/toplevel.expect.scala | 10 +++++----- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 91d2ee1ffdec..89051ad9a1bb 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -102,7 +102,10 @@ class ExtractSemanticDB extends Phase { else if sym.is(Param) then b.append('('); addName(sym.name); b.append(')') else - addName(sym.name) + if (sym.isPackageObject) then + b.append("package") + else + addName(sym.name) if sym.is(Package) then b.append('/') else if sym.isType then b.append('#') else if sym.isOneOf(Method | Mutable) @@ -134,6 +137,7 @@ class ExtractSemanticDB extends Phase { addOwner(sym.owner); addDescriptor(sym) else b.append("local").append(localIdx(sym)) + end addSymName /** The semanticdb name of the given symbol */ diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index ffc46ad2864c..10448fad61b2 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -65,7 +65,7 @@ class SemanticdbTests { "-Ysemanticdb", "-d", target.toString, // "-Ydebug", - "-Xprint:extractSemanticDB", + // "-Xprint:extractSemanticDB", "-sourceroot", src.toString, "-usejavacp", ) ++ inputFiles().map(_.toString) diff --git a/tests/semanticdb/toplevel.expect.scala b/tests/semanticdb/toplevel.expect.scala index 4847a33a41d1..cea06b0313af 100644 --- a/tests/semanticdb/toplevel.expect.scala +++ b/tests/semanticdb/toplevel.expect.scala @@ -1,5 +1,5 @@ -inline val a = "/*<<=_empty_.toplevel$package.*//*<<=_empty_.toplevel$package.a.*/" -def (x: Int/*<<=_empty_.toplevel$package.combine().*//*<<=_empty_.toplevel$package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.toplevel$package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine().(y)*/ -def combine/*<<=_empty_.toplevel$package.combine(+1).*/(x/*<<=_empty_.toplevel$package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.toplevel$package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.toplevel$package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.toplevel$package.combine(+1).(z)*/ -def combine/*<<=_empty_.toplevel$package.combine(+2).*/ = 0 -def foo/*<<=_empty_.toplevel$package.foo().*/ = "foo" +inline val a = "/*<<=_empty_.package.*//*<<=_empty_.package.a.*/" +def (x: Int/*<<=_empty_.package.combine().*//*<<=_empty_.package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.package.combine().(y)*/ +def combine/*<<=_empty_.package.combine(+1).*/(x/*<<=_empty_.package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.package.combine(+1).(z)*/ +def combine/*<<=_empty_.package.combine(+2).*/ = 0 +def foo/*<<=_empty_.package.foo().*/ = "foo" From 61d08201cc85c04b46fcef2c24aaa482fd874e99 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Wed, 6 Nov 2019 22:52:59 +0100 Subject: [PATCH 040/107] restore scala.Predef.classOf(). --- .../src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala | 1 - tests/semanticdb/InstrumentTyper.expect.scala | 2 +- tests/semanticdb/Types.expect.scala | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 89051ad9a1bb..e3d2d44e597f 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -172,7 +172,6 @@ class ExtractSemanticDB extends Phase { private def excludeDefStrict(sym: Symbol)(given Context): Boolean = sym.name.is(NameKinds.DefaultGetterName) - || sym == defn.Predef_classOf private def blacklistPrefix(sym: Symbol)(given Context): Boolean = sym.is(Package) diff --git a/tests/semanticdb/InstrumentTyper.expect.scala b/tests/semanticdb/InstrumentTyper.expect.scala index 81a5032b9c25..7c9e2388c763 100644 --- a/tests/semanticdb/InstrumentTyper.expect.scala +++ b/tests/semanticdb/InstrumentTyper.expect.scala @@ -22,5 +22,5 @@ class InstrumentTyper/*<<=example.InstrumentTyper#*/ { self/*<<=local0*/: AnyRef ) type AnnotatedType/*<<=example.InstrumentTyper#AnnotatedType#*/ = Int/*=>>scala.Int#*/ @param def singletonType/*<<=example.InstrumentTyper#singletonType().*/(x/*<<=example.InstrumentTyper#singletonType().(x)*/: Predef/*=>>scala.Predef.*/.type) = ???/*=>>scala.Predef.`???`().*/ - final val clazzOf/*<<=example.InstrumentTyper#clazzOf.*/ = classOf[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] + final val clazzOf/*<<=example.InstrumentTyper#clazzOf.*/ = classOf/*=>>scala.Predef.classOf().*/[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] } diff --git a/tests/semanticdb/Types.expect.scala b/tests/semanticdb/Types.expect.scala index 9c09a29513b0..11aafa374b43 100644 --- a/tests/semanticdb/Types.expect.scala +++ b/tests/semanticdb/Types.expect.scala @@ -110,6 +110,6 @@ object Test/*<<=types.Test.*/ { final val bool/*<<=types.Test.Literal.bool.*/ = true final val unit/*<<=types.Test.Literal.unit.*/ = () final val javaEnum/*<<=types.Test.Literal.javaEnum.*/ = java.nio.file.LinkOption/*=>>java.nio.file.LinkOption.*/.NOFOLLOW_LINKS/*=>>java.nio.file.LinkOption.NOFOLLOW_LINKS.*/ - final val clazzOf/*<<=types.Test.Literal.clazzOf.*/ = classOf[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] + final val clazzOf/*<<=types.Test.Literal.clazzOf.*/ = classOf/*=>>scala.Predef.classOf().*/[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] } } From f753129d8f36bdc6685d00158228edac5fc32aeb Mon Sep 17 00:00:00 2001 From: bishabosha Date: Wed, 6 Nov 2019 23:02:09 +0100 Subject: [PATCH 041/107] update todo --- tests/semanticdb/todo | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/tests/semanticdb/todo b/tests/semanticdb/todo index b68cf1f2a6a6..605aa1946b05 100644 --- a/tests/semanticdb/todo +++ b/tests/semanticdb/todo @@ -1,15 +1,16 @@ +## BlackBox Todo list +This todolist is based upon blackbox observation of testcases at this repository: https://github.com/scalameta/scalameta/tree/master/tests/jvm/src/test/resources/example + - [ ] Hide unapply, unapplySeq? - [ ] Hide constructor of template - [ ] Hide local vars in pattern def? - [ ] Hide desugaring of for comprehension - [ ] Hide calls to implicit conversions and their arguments - [ ] Hide Tuple contructors -- [ ] Hide qualifier in Select inside a type? - [x] unescape unicode in names. -- [x] Hide `Predef.classOf` - [x] Hide `scala.Predef` prefix - [x] Hide `scala.StringContext` -- [x] Only traverse qualifier of a select if it is not a package -- [ ] Weird issue with method overload counter when mixed with objects -- [ ] Import wildcard needs to have reference to the qualifier -- [ ] We must look of the qualifier of a select on a term +- [x] Only traverse prefix of a Select if it is not a package +- [x] Ensure only methods are counted in overloads +- [x] Import wildcard needs to have reference to the qualifier +- [-] ~~Hide `Predef.classOf`~~ // won't fix - confirmed as a bug in scalameta From 6c91041bd32b61c6152eb7fcad569bf92bbd1d46 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Thu, 7 Nov 2019 00:14:34 +0100 Subject: [PATCH 042/107] avoid blacklisting scala.Predef and scala.StringContext Simply check if prefix of a select has a range that is visible --- .../dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala | 7 +++---- tests/semanticdb/Advanced.expect.scala | 2 +- tests/semanticdb/Enums.expect.scala | 2 +- tests/semanticdb/Example.expect.scala | 4 ++-- tests/semanticdb/Givens.expect.scala | 2 +- tests/semanticdb/ImplicitConversion.expect.scala | 2 +- tests/semanticdb/{todo => todo.md} | 4 ++-- 7 files changed, 11 insertions(+), 12 deletions(-) rename tests/semanticdb/{todo => todo.md} (79%) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index e3d2d44e597f..2da27d2ed3b5 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -175,8 +175,6 @@ class ExtractSemanticDB extends Phase { private def blacklistPrefix(sym: Symbol)(given Context): Boolean = sym.is(Package) - || sym == defn.ScalaPredefModule - || sym == defn.StringContextModule private def (sym: Symbol) isAnonymous(given Context): Boolean = sym.isAnonymousClass @@ -244,16 +242,17 @@ class ExtractSemanticDB extends Phase { if tree.name != nme.WILDCARD && !excludeUseStrict(tree.symbol, tree.span) then registerUse(tree.symbol, tree.span) case tree: Select => + val qualSpan = tree.qualifier.span if !excludeUseStrict(tree.symbol, tree.span) then val end = tree.span.end - val limit = tree.qualifier.span.end + val limit = qualSpan.end val start = if limit < end then val len = tree.name.toString.length if source.content()(end - 1) == '`' then end - len - 1 else end - len else limit registerUse(tree.symbol, Span(start max limit, end)) - if !blacklistPrefix(tree.qualifier.symbol) then + if !blacklistPrefix(tree.qualifier.symbol) && qualSpan.exists && qualSpan.start != qualSpan.end then traverseChildren(tree) case tree: Import => if tree.span.exists && tree.span.start != tree.span.end then diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/Advanced.expect.scala index 46f598b4c54f..0742b99d4e16 100644 --- a/tests/semanticdb/Advanced.expect.scala +++ b/tests/semanticdb/Advanced.expect.scala @@ -26,7 +26,7 @@ object Test/*<<=advanced.Test.*/ { val s2/*<<=advanced.Test.s2.*/ = s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*/ val s2x/*<<=advanced.Test.s2x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*//*=>>scala.Selectable#selectDynamic().*/.x val s3/*<<=advanced.Test.s3.*/ = s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*/ - val s3x/*<<=advanced.Test.s3x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*//*=>>scala.Selectable#applyDynamic().*/.m/*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>java.lang.Integer.TYPE.*//*=>>java.lang.Integer.*/(???/*=>>scala.Predef.`???`().*/) + val s3x/*<<=advanced.Test.s3x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*//*=>>scala.Selectable#applyDynamic().*/.m/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer.TYPE.*/(???/*=>>scala.Predef.`???`().*/) val e/*<<=advanced.Test.e.*/ = new Wildcards/*=>>advanced.Wildcards#*//*=>>advanced.Wildcards#``().*/ val e1/*<<=advanced.Test.e1.*/ = e/*=>>advanced.Test.e.*/.e1/*=>>advanced.Wildcards#e1().*/ diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala index 7a0379a4124a..21cd871c5b6b 100644 --- a/tests/semanticdb/Enums.expect.scala +++ b/tests/semanticdb/Enums.expect.scala @@ -14,7 +14,7 @@ object Enums/*<<=_empty_.Enums.*/ { } enum Maybe/*<<=_empty_.Enums.Maybe#*/[+A/*<<=_empty_.Enums.Maybe#[A]*/] { - /*=>>_empty_.Enums.Maybe#``().*//*=>>_empty_.Enums.Maybe.Just#[A]*/case Just/*<<=_empty_.Enums.Maybe.Just#*/(value/*<<=_empty_.Enums.Maybe.Just#value.*/: A/*=>>_empty_.Enums.Maybe.Just#``().[A]*/) + /*=>>_empty_.Enums.Maybe#``().*/case Just/*<<=_empty_.Enums.Maybe.Just#*/(value/*<<=_empty_.Enums.Maybe.Just#value.*/: A/*=>>_empty_.Enums.Maybe.Just#``().[A]*/) /*=>>_empty_.Enums.Maybe#``().*/case None/*<<=_empty_.Enums.Maybe.None.*/ } diff --git a/tests/semanticdb/Example.expect.scala b/tests/semanticdb/Example.expect.scala index 44be40aef5ec..7d83198205fd 100644 --- a/tests/semanticdb/Example.expect.scala +++ b/tests/semanticdb/Example.expect.scala @@ -3,9 +3,9 @@ package example import scala.concurrent.Future/*=>>scala.concurrent.Future.*//*=>>scala.concurrent.Future#*/ object Example/*<<=example.Example.*/ { /*=>>example.Example.*/self/*<<=local0*/ => - new /*=>>scala.collection.mutable.Stack.*/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#*/]/*=>>scala.collection.mutable.Stack#``(+1).*/() def main/*<<=example.Example.main().*/(args/*<<=example.Example.main().(args)*/: Array/*=>>scala.Array#*/[String/*=>>scala.Predef.String#*/]): Unit/*=>>scala.Unit#*/ = { println/*=>>scala.Predef.println(+1).*/(1) } - val x/*<<=example.Example.x.*/ = scala.reflect.classTag/*=>>scala.reflect.package.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>scala.reflect.ClassTag.*//*=>>java.lang.Integer.TYPE.*//*=>>java.lang.Integer.*/ + val x/*<<=example.Example.x.*/ = scala.reflect.classTag/*=>>scala.reflect.package.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer.TYPE.*/ } diff --git a/tests/semanticdb/Givens.expect.scala b/tests/semanticdb/Givens.expect.scala index b50b4ce3e41e..8200fe851eaf 100644 --- a/tests/semanticdb/Givens.expect.scala +++ b/tests/semanticdb/Givens.expect.scala @@ -6,7 +6,7 @@ object Givens/*<<=a.b.Givens.*/ given :[A](any: A) de/*<<=a.b.Givens.given_sayHello_of_A.*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().[A]*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>a.b.Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s"Hello, I am $any/*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>scala.StringContext#s().*/" - val hello1/*<<=a.b.Givens.hello1.*/ = /*=>>a.b.Givens.given_sayHello_of_A.sayHello().*//*=>>a.b.Givens.given_sayHello_of_A.*/1.sayHello + val hello1/*<<=a.b.Givens.hello1.*/ = /*=>>a.b.Givens.given_sayHello_of_A.sayHello().*/1.sayHello trait Monoid/*<<=a.b.Givens.Monoid#*/[A/*<<=a.b.Givens.Monoid#[A]*/] def empty/*<<=a.b.Givens.Monoid#empty().*/: A/*=>>a.b.Givens.Monoid#[A]*/ diff --git a/tests/semanticdb/ImplicitConversion.expect.scala b/tests/semanticdb/ImplicitConversion.expect.scala index bf797b030fa7..e67256448338 100644 --- a/tests/semanticdb/ImplicitConversion.expect.scala +++ b/tests/semanticdb/ImplicitConversion.expect.scala @@ -8,7 +8,7 @@ class ImplicitConversion/*<<=example.ImplicitConversion#*/ { ): Int/*=>>scala.Int#*/ = 42 implicit def newAny2StringAdd/*<<=example.ImplicitConversion#newAny2StringAdd().*/[T/*<<=example.ImplicitConversion#newAny2StringAdd().[T]*/]( any/*<<=example.ImplicitConversion#newAny2StringAdd().(any)*/: T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/ - ): Predef.any2stringadd/*=>>scala.Predef.any2stringadd#*/[T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/] = new Predef.any2stringadd/*=>>scala.Predef.any2stringadd#``().*/(any/*=>>example.ImplicitConversion#newAny2StringAdd().(any)*/) + ): Predef/*=>>scala.Predef.*/.any2stringadd/*=>>scala.Predef.any2stringadd#*/[T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/] = new Predef/*=>>scala.Predef.*/.any2stringadd/*=>>scala.Predef.any2stringadd#``().*/(any/*=>>example.ImplicitConversion#newAny2StringAdd().(any)*/) val message/*<<=example.ImplicitConversion#message.*/ = "" val number/*<<=example.ImplicitConversion#number.*/ = 42 val tuple/*<<=example.ImplicitConversion#tuple.*/ = (1, 2) diff --git a/tests/semanticdb/todo b/tests/semanticdb/todo.md similarity index 79% rename from tests/semanticdb/todo rename to tests/semanticdb/todo.md index 605aa1946b05..c5ecd706bbcc 100644 --- a/tests/semanticdb/todo +++ b/tests/semanticdb/todo.md @@ -8,9 +8,9 @@ This todolist is based upon blackbox observation of testcases at this repository - [ ] Hide calls to implicit conversions and their arguments - [ ] Hide Tuple contructors - [x] unescape unicode in names. -- [x] Hide `scala.Predef` prefix -- [x] Hide `scala.StringContext` - [x] Only traverse prefix of a Select if it is not a package - [x] Ensure only methods are counted in overloads - [x] Import wildcard needs to have reference to the qualifier +- [-] ~~Hide `scala.Predef` prefix~~ // same effect acheved by ensuring prefix has a range > 0 +- [-] ~~Hide `scala.StringContext`~~ // same effect acheved by ensuring prefix has a range > 0 - [-] ~~Hide `Predef.classOf`~~ // won't fix - confirmed as a bug in scalameta From 3744e196b183bee286f951cbe85e67455373aaa9 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 7 Nov 2019 14:00:14 +0100 Subject: [PATCH 043/107] Suspend test after rebase --- project/Build.scala | 3 +++ tests/semanticdb/MethodUsages.expect.scala | 2 +- tests/semanticdb/MethodUsages.scala | 2 +- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/project/Build.scala b/project/Build.scala index b6efdc575885..cccfab0f99df 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -740,6 +740,9 @@ object Build { if (mode == NonBootstrapped) nonBootstrapedDottyCompilerSettings else bootstrapedDottyCompilerSettings lazy val `dotty-compiler` = project.in(file("compiler")).asDottyCompiler(NonBootstrapped) + .settings( + Test / testOptions := Seq(Tests.Filter(s => s != "dotty.tools.dotc.semanticdb.SemanticdbTests")) + ) lazy val `dotty-compiler-bootstrapped` = project.in(file("compiler")).asDottyCompiler(Bootstrapped) def dottyCompiler(implicit mode: Mode): Project = mode match { diff --git a/tests/semanticdb/MethodUsages.expect.scala b/tests/semanticdb/MethodUsages.expect.scala index 9dbe1876e33b..8115e0631621 100644 --- a/tests/semanticdb/MethodUsages.expect.scala +++ b/tests/semanticdb/MethodUsages.expect.scala @@ -13,7 +13,7 @@ class MethodUsages/*<<=example.MethodUsages#*/ { m/*=>>example.MethodUsages#m.*/.m6/*=>>example.Methods#m6(+2).*/(Nil/*=>>scala.package.Nil.*/) m/*=>>example.MethodUsages#m.*/.m7/*=>>example.Methods#m7().*/(m/*=>>example.MethodUsages#m.*/, new m/*=>>example.MethodUsages#m.*/.List/*=>>example.Methods#List#*/[Int/*=>>scala.Int#*/]/*=>>example.Methods#List#``().*/)/*=>>scala.math.Ordering.Int.*/ m/*=>>example.MethodUsages#m.*/.`m8().`/*=>>example.Methods#`m8().`().*/() - m/*=>>example.MethodUsages#m.*/.m9/*=>>example.Methods#m9().*/(null) + // m.m9(null) suspended due to issue https://github.com/lampepfl/dotty/issues/7514 m/*=>>example.MethodUsages#m.*/.m10/*=>>example.Methods#m10().*/(null) m/*=>>example.MethodUsages#m.*/.m11/*=>>example.Methods#m11().*/(Predef/*=>>scala.Predef.*/) m/*=>>example.MethodUsages#m.*/.m11/*=>>example.Methods#m11(+1).*/(Example/*=>>example.Example.*/) diff --git a/tests/semanticdb/MethodUsages.scala b/tests/semanticdb/MethodUsages.scala index b5982e8563a5..8c9bb3a3fd25 100644 --- a/tests/semanticdb/MethodUsages.scala +++ b/tests/semanticdb/MethodUsages.scala @@ -13,7 +13,7 @@ class MethodUsages { m.m6(Nil) m.m7(m, new m.List[Int]) m.`m8().`() - m.m9(null) + // m.m9(null) suspended due to issue https://github.com/lampepfl/dotty/issues/7514 m.m10(null) m.m11(Predef) m.m11(Example) From b63908b641647a7307c47311bc463df347f71eec Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 7 Nov 2019 15:30:29 +0100 Subject: [PATCH 044/107] Better java symbols --- .../dotc/semanticdb/ExtractSemanticDB.scala | 23 +++-- .../semanticdb/com/javacp/ClassSuffix.java | 10 +++ .../dotc/semanticdb/com/javacp/Coin.java | 9 ++ .../dotc/semanticdb/com/javacp/Interface.java | 7 ++ .../dotc/semanticdb/com/javacp/Logger.java | 4 + .../dotc/semanticdb/com/javacp/MetacJava.java | 21 +++++ .../semanticdb/com/javacp/NonGeneric.java | 9 ++ .../dotc/semanticdb/com/javacp/Recursive.java | 26 ++++++ .../dotc/semanticdb/com/javacp/Test.java | 83 +++++++++++++++++++ tests/semanticdb/Advanced.expect.scala | 2 +- tests/semanticdb/Example.expect.scala | 2 +- tests/semanticdb/MetacJava.expect.scala | 20 +++++ tests/semanticdb/MetacJava.scala | 20 +++++ tests/semanticdb/Types.expect.scala | 6 +- 14 files changed, 229 insertions(+), 13 deletions(-) create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Coin.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Interface.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Logger.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java create mode 100644 compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Test.java create mode 100644 tests/semanticdb/MetacJava.expect.scala create mode 100644 tests/semanticdb/MetacJava.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 2da27d2ed3b5..7ced1f049519 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -87,12 +87,19 @@ class ExtractSemanticDB extends Phase { if !owner.isRoot then addSymName(b, owner, inOwner = true) def addOverloadIdx(sym: Symbol): Unit = - val alts = sym.owner.info.decls.lookupAll(sym.name).filter(_.is(Method)).toList.reverse - if alts.nonEmpty && alts.tail.nonEmpty then - val idx = alts.indexOf(sym) - assert(idx >= 0) - if idx > 0 then - b.append('+').append(idx) + val decls = { + val decls0 = sym.owner.info.decls.lookupAll(sym.name) + if sym.owner.isAllOf(JavaModule) + decls0 ++ sym.owner.companionClass.info.decls.lookupAll(sym.name) + else + decls0 + } + val alts = decls.filter(_.is(Method)).toList.reverse + alts match + case notSym :: rest if sym != notSym => + val idx = rest.indexOf(sym).ensuring(_ >= 0) + b.append('+').append(idx + 1) + case _ => def addDescriptor(sym: Symbol): Unit = if sym.is(ModuleClass) then @@ -107,7 +114,7 @@ class ExtractSemanticDB extends Phase { else addName(sym.name) if sym.is(Package) then b.append('/') - else if sym.isType then b.append('#') + else if sym.isType || sym.isAllOf(JavaModule) then b.append('#') else if sym.isOneOf(Method | Mutable) && (!sym.is(StableRealizable) || sym.name == nme.CONSTRUCTOR) then b.append('('); addOverloadIdx(sym); b.append(").") @@ -259,7 +266,7 @@ class ExtractSemanticDB extends Phase { for sel <- tree.selectors do val imported = sel.imported.name if imported != nme.WILDCARD then - for alt <- tree.expr.tpe.member(imported).alternatives do + for alt <- tree.expr.tpe.member(imported).alternatives if !alt.symbol.is(Package) do registerUse(alt.symbol, sel.imported.span) if (alt.symbol.companionClass.exists) registerUse(alt.symbol.companionClass, sel.imported.span) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java new file mode 100644 index 000000000000..7204ec09f77a --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java @@ -0,0 +1,10 @@ +package com.javacp; + +public class ClassSuffix { + class Inner { + class Bar { + class Fuz {} + } + } + public ClassSuffix.Inner.Bar.Fuz suffix; +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Coin.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Coin.java new file mode 100644 index 000000000000..b66009fd773a --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Coin.java @@ -0,0 +1,9 @@ +package com.javacp; + +public enum Coin { + PENNY(1), NICKEL(5), DIME(10), QUARTER(25); + Coin(int value) { this.value = value; } + + private final int value; + public int value() { return value; } +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Interface.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Interface.java new file mode 100644 index 000000000000..a85b4b795485 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Interface.java @@ -0,0 +1,7 @@ +package com.javacp; + +public interface Interface { + void a(); + default void d() {} + static void s() {} +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Logger.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Logger.java new file mode 100644 index 000000000000..6fc9c2525ec7 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Logger.java @@ -0,0 +1,4 @@ +package com.javacp; + +public class Logger { +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java new file mode 100644 index 000000000000..61d86af5117c --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java @@ -0,0 +1,21 @@ +package com.javacp; + +public class MetacJava { + public static class StaticInner { + public void isNotStatic() {} + public static void isStatic() {} + public class NonStatic { + public void method(NonStatic e) {} + } + } + public class Overload1 { public class A {} } + public static class Overload3 { + public static class A {} + } + public class Overload2 { public class A {} } + public void overload(Overload1.A a) {} + // NOTE: Overload3 is intentionally placed before Overload2 in order to test + // that methods are sorted by whether they're static or not. + public static void overload(Overload3.A a) {} + public void overload(Overload2.A a) {} +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java new file mode 100644 index 000000000000..78a1ac223e28 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java @@ -0,0 +1,9 @@ +package com.javacp; + +import java.io.IOException; +import java.io.Serializable; + +public class NonGeneric extends java.lang.Exception implements Serializable, java.io.Flushable { + @Override + public void flush() throws IOException { } +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java new file mode 100644 index 000000000000..62c749c63ded --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java @@ -0,0 +1,26 @@ +package com.javacp; + +import java.io.Serializable; +import java.util.ArrayList; + +public abstract class Recursive< + A extends Recursive & Serializable, + B extends Recursive.Inner> { + + public abstract static class Inner< + A extends Recursive & Serializable, + B extends Inner> { + } + + public abstract class Inner2> {} + + public ArrayList foo() { + return new ArrayList() { + @Override + public boolean remove(Object o) { + return true; + } + }; + } + +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Test.java b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Test.java new file mode 100644 index 000000000000..2ce00f3531e3 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Test.java @@ -0,0 +1,83 @@ +package com.javacp; + +import javax.naming.Context; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Hashtable; + +public final class Test extends ArrayList implements Comparable, Serializable { + + @Override + public final int compareTo(B b) { + return 0; + } + + public void wildcard(ArrayList wildcard) {} + public void wildcard(Collection a, Collection b) {} + + class InnerShadowTypeParam { + public void move(A a, B b) { } + } + + ArrayList genericField; + final int[] arrayField = null; + + ArrayList genericMethod() { + return null; + } + int[] arrayMethod() { + return new int[0]; + } + void genericParams(A a, B b) { } + void primitiveParams(int a, long b, float c, double d, short e, byte f, boolean g, char h) { } + void typeParams(ArrayList> a, Hashtable b) { } + void methodTypeParams(C c) { } + + public void overload(java.util.logging.Logger a) { } + public void overload(Logger a) { } + + // primitive fields + public int Int; + public long Long; + public float Float; + public short Short; + public byte Byte; + public boolean Boolean; + public char Char; + + + private int privateField; + protected int protectedField; + public int publicField; + int packagePrivateField; + + private void privateMethod() { } + protected void protectedMethod() { } + public void publicMethod() { } + void packagePrivateMethod() { } + + public Serializable anonymous = new Serializable() { }; + + static int staticField; + static void staticMethod() {} + static class StaticClass {} + + void vararg(int a, String... args) {} + + strictfp void strictfpMethod() {} + + void m1() {} + void m2() {} + void m3() {} +} + +interface X { +} + +interface Y { +} + +interface Z { +} diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/Advanced.expect.scala index 0742b99d4e16..5cf7de3a8523 100644 --- a/tests/semanticdb/Advanced.expect.scala +++ b/tests/semanticdb/Advanced.expect.scala @@ -26,7 +26,7 @@ object Test/*<<=advanced.Test.*/ { val s2/*<<=advanced.Test.s2.*/ = s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*/ val s2x/*<<=advanced.Test.s2x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*//*=>>scala.Selectable#selectDynamic().*/.x val s3/*<<=advanced.Test.s3.*/ = s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*/ - val s3x/*<<=advanced.Test.s3x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*//*=>>scala.Selectable#applyDynamic().*/.m/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer.TYPE.*/(???/*=>>scala.Predef.`???`().*/) + val s3x/*<<=advanced.Test.s3x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*//*=>>scala.Selectable#applyDynamic().*/.m/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer#TYPE.*/(???/*=>>scala.Predef.`???`().*/) val e/*<<=advanced.Test.e.*/ = new Wildcards/*=>>advanced.Wildcards#*//*=>>advanced.Wildcards#``().*/ val e1/*<<=advanced.Test.e1.*/ = e/*=>>advanced.Test.e.*/.e1/*=>>advanced.Wildcards#e1().*/ diff --git a/tests/semanticdb/Example.expect.scala b/tests/semanticdb/Example.expect.scala index 7d83198205fd..bb7a2f7fca2c 100644 --- a/tests/semanticdb/Example.expect.scala +++ b/tests/semanticdb/Example.expect.scala @@ -7,5 +7,5 @@ object Example/*<<=example.Example.*/ { /*=>>example.Example.*/self/*<<=local0*/ def main/*<<=example.Example.main().*/(args/*<<=example.Example.main().(args)*/: Array/*=>>scala.Array#*/[String/*=>>scala.Predef.String#*/]): Unit/*=>>scala.Unit#*/ = { println/*=>>scala.Predef.println(+1).*/(1) } - val x/*<<=example.Example.x.*/ = scala.reflect.classTag/*=>>scala.reflect.package.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer.TYPE.*/ + val x/*<<=example.Example.x.*/ = scala.reflect.classTag/*=>>scala.reflect.package.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer#TYPE.*/ } diff --git a/tests/semanticdb/MetacJava.expect.scala b/tests/semanticdb/MetacJava.expect.scala new file mode 100644 index 000000000000..0534f2d91c69 --- /dev/null +++ b/tests/semanticdb/MetacJava.expect.scala @@ -0,0 +1,20 @@ +package example + +import com.javacp + +class MetacJava/*<<=example.MetacJava#*/ { + javacp.MetacJava/*=>>com.javacp.MetacJava#*/.StaticInner/*=>>com.javacp.MetacJava#StaticInner#*/.isStatic/*=>>com.javacp.MetacJava#StaticInner#isStatic().*/() + new javacp.MetacJava/*=>>com.javacp.MetacJava#*/.StaticInner/*=>>com.javacp.MetacJava#StaticInner#*//*=>>com.javacp.MetacJava#StaticInner#``().*/().isNotStatic/*=>>com.javacp.MetacJava#StaticInner#isNotStatic().*/() + val inner/*<<=example.MetacJava#inner.*/ = new javacp.MetacJava/*=>>com.javacp.MetacJava#*//*=>>com.javacp.MetacJava#``().*/() + val overload1/*<<=example.MetacJava#overload1.*/ = new inner/*=>>example.MetacJava#inner.*/.Overload1/*=>>com.javacp.MetacJava#Overload1#*//*=>>com.javacp.MetacJava#Overload1#``().*/() + val overload2/*<<=example.MetacJava#overload2.*/ = new inner/*=>>example.MetacJava#inner.*/.Overload2/*=>>com.javacp.MetacJava#Overload2#*//*=>>com.javacp.MetacJava#Overload2#``().*/() + inner/*=>>example.MetacJava#inner.*/.overload/*=>>com.javacp.MetacJava#overload().*/(new overload1/*=>>example.MetacJava#overload1.*/.A/*=>>com.javacp.MetacJava#Overload1#A#*//*=>>com.javacp.MetacJava#Overload1#A#``().*/()) + inner/*=>>example.MetacJava#inner.*/.overload/*=>>com.javacp.MetacJava#overload(+1).*/(new overload2/*=>>example.MetacJava#overload2.*/.A/*=>>com.javacp.MetacJava#Overload2#A#*//*=>>com.javacp.MetacJava#Overload2#A#``().*/()) + val staticInner/*<<=example.MetacJava#staticInner.*/ = new javacp.MetacJava/*=>>com.javacp.MetacJava#*/.StaticInner/*=>>com.javacp.MetacJava#StaticInner#*//*=>>com.javacp.MetacJava#StaticInner#``().*/() + val nonStatic/*<<=example.MetacJava#nonStatic.*/ = new staticInner/*=>>example.MetacJava#staticInner.*/.NonStatic/*=>>com.javacp.MetacJava#StaticInner#NonStatic#*//*=>>com.javacp.MetacJava#StaticInner#NonStatic#``().*/() + nonStatic/*=>>example.MetacJava#nonStatic.*/.method/*=>>com.javacp.MetacJava#StaticInner#NonStatic#method().*/(nonStatic/*=>>example.MetacJava#nonStatic.*/) + javacp.MetacJava/*=>>com.javacp.MetacJava#*/.overload/*=>>com.javacp.MetacJava#overload(+2).*/(new javacp.MetacJava/*=>>com.javacp.MetacJava#*/.Overload3/*=>>com.javacp.MetacJava#Overload3#*/.A/*=>>com.javacp.MetacJava#Overload3#A#*//*=>>com.javacp.MetacJava#Overload3#A#``().*/()) + val interface/*<<=example.MetacJava#interface.*/: javacp.Interface/*=>>com.javacp.Interface#*/ = null + val coin/*<<=example.MetacJava#coin.*/: javacp.Coin/*=>>com.javacp.Coin#*/ = javacp.Coin/*=>>com.javacp.Coin#*/.PENNY/*=>>com.javacp.Coin#PENNY.*/ + val entry/*<<=example.MetacJava#entry.*/: java.util.Map/*=>>java.util.Map#*/.Entry/*=>>java.util.Map#Entry#*/[Int/*=>>scala.Int#*/, Int/*=>>scala.Int#*/] = null +} diff --git a/tests/semanticdb/MetacJava.scala b/tests/semanticdb/MetacJava.scala new file mode 100644 index 000000000000..8a8f20336a14 --- /dev/null +++ b/tests/semanticdb/MetacJava.scala @@ -0,0 +1,20 @@ +package example + +import com.javacp + +class MetacJava { + javacp.MetacJava.StaticInner.isStatic() + new javacp.MetacJava.StaticInner().isNotStatic() + val inner = new javacp.MetacJava() + val overload1 = new inner.Overload1() + val overload2 = new inner.Overload2() + inner.overload(new overload1.A()) + inner.overload(new overload2.A()) + val staticInner = new javacp.MetacJava.StaticInner() + val nonStatic = new staticInner.NonStatic() + nonStatic.method(nonStatic) + javacp.MetacJava.overload(new javacp.MetacJava.Overload3.A()) + val interface: javacp.Interface = null + val coin: javacp.Coin = javacp.Coin.PENNY + val entry: java.util.Map.Entry[Int, Int] = null +} diff --git a/tests/semanticdb/Types.expect.scala b/tests/semanticdb/Types.expect.scala index 11aafa374b43..fb2d2bddbc49 100644 --- a/tests/semanticdb/Types.expect.scala +++ b/tests/semanticdb/Types.expect.scala @@ -63,8 +63,8 @@ object Test/*<<=types.Test.*/ { val annType2/*<<=types.Test.C#annType2.*/: T/*=>>types.T#*/ @ann1 @ann2 = ???/*=>>scala.Predef.`???`().*/ val existentialType2/*<<=types.Test.C#existentialType2.*/: List/*=>>scala.package.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ - val existentialType3/*<<=types.Test.C#existentialType3.*/ = Class/*=>>java.lang.Class.*/.forName/*=>>java.lang.Class.forName().*/("foo.Bar") - val existentialType4/*<<=types.Test.C#existentialType4.*/ = Class/*=>>java.lang.Class.*/.forName/*=>>java.lang.Class.forName().*/("foo.Bar") + val existentialType3/*<<=types.Test.C#existentialType3.*/ = Class/*=>>java.lang.Class#*/.forName/*=>>java.lang.Class#forName().*/("foo.Bar") + val existentialType4/*<<=types.Test.C#existentialType4.*/ = Class/*=>>java.lang.Class#*/.forName/*=>>java.lang.Class#forName().*/("foo.Bar") def typeLambda1/*<<=types.Test.C#typeLambda1().*/[M/*<<=types.Test.C#typeLambda1().[M]*/[_]] = ???/*=>>scala.Predef.`???`().*/ typeLambda1/*=>>types.Test.C#typeLambda1().*/[({ type L/*<<=local4*/[T/*<<=local5*/] = List/*=>>scala.package.List#*/[T/*=>>local5*/] })#L] @@ -109,7 +109,7 @@ object Test/*<<=types.Test.*/ { final val string/*<<=types.Test.Literal.string.*/ = "a" final val bool/*<<=types.Test.Literal.bool.*/ = true final val unit/*<<=types.Test.Literal.unit.*/ = () - final val javaEnum/*<<=types.Test.Literal.javaEnum.*/ = java.nio.file.LinkOption/*=>>java.nio.file.LinkOption.*/.NOFOLLOW_LINKS/*=>>java.nio.file.LinkOption.NOFOLLOW_LINKS.*/ + final val javaEnum/*<<=types.Test.Literal.javaEnum.*/ = java.nio.file.LinkOption/*=>>java.nio.file.LinkOption#*/.NOFOLLOW_LINKS/*=>>java.nio.file.LinkOption#NOFOLLOW_LINKS.*/ final val clazzOf/*<<=types.Test.Literal.clazzOf.*/ = classOf/*=>>scala.Predef.classOf().*/[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] } } From 1f24961b9feff9ca481eb3bb09986713d9583807 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 7 Nov 2019 17:25:42 +0100 Subject: [PATCH 045/107] add named arguments tests --- tests/semanticdb/NamedApplyBlock.expect.scala | 14 ++++++++++++++ tests/semanticdb/NamedApplyBlock.scala | 14 ++++++++++++++ tests/semanticdb/NamedArguments.expect.scala | 7 +++++++ tests/semanticdb/NamedArguments.scala | 7 +++++++ tests/semanticdb/Objects.expect.scala | 5 +++++ tests/semanticdb/Objects.scala | 5 +++++ tests/semanticdb/Overrides.expect.scala | 4 ++++ tests/semanticdb/Overrides.scala | 4 ++++ 8 files changed, 60 insertions(+) create mode 100644 tests/semanticdb/NamedApplyBlock.expect.scala create mode 100644 tests/semanticdb/NamedApplyBlock.scala create mode 100644 tests/semanticdb/NamedArguments.expect.scala create mode 100644 tests/semanticdb/NamedArguments.scala create mode 100644 tests/semanticdb/Objects.expect.scala create mode 100644 tests/semanticdb/Objects.scala create mode 100644 tests/semanticdb/Overrides.expect.scala create mode 100644 tests/semanticdb/Overrides.scala diff --git a/tests/semanticdb/NamedApplyBlock.expect.scala b/tests/semanticdb/NamedApplyBlock.expect.scala new file mode 100644 index 000000000000..5a7b0786b119 --- /dev/null +++ b/tests/semanticdb/NamedApplyBlock.expect.scala @@ -0,0 +1,14 @@ +package example + +object NamedApplyBlockMethods/*<<=example.NamedApplyBlockMethods.*/ { + val local/*<<=example.NamedApplyBlockMethods.local.*/ = 1 + def foo/*<<=example.NamedApplyBlockMethods.foo().*/(a/*<<=example.NamedApplyBlockMethods.foo().(a)*/: Int/*=>>scala.Int#*/ = 1, b/*<<=example.NamedApplyBlockMethods.foo().(b)*/: Int/*=>>scala.Int#*/ = 2, c/*<<=example.NamedApplyBlockMethods.foo().(c)*/: Int/*=>>scala.Int#*/ = 3): Int/*=>>scala.Int#*/ = a/*=>>example.NamedApplyBlockMethods.foo().(a)*/ +/*=>>scala.Int#`+`(+4).*/ b/*=>>example.NamedApplyBlockMethods.foo().(b)*/ +/*=>>scala.Int#`+`(+4).*/ c/*=>>example.NamedApplyBlockMethods.foo().(c)*/ + def baseCase/*<<=example.NamedApplyBlockMethods.baseCase().*/ = foo/*=>>example.NamedApplyBlockMethods.foo().*/(local/*=>>example.NamedApplyBlockMethods.local.*/, c = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter + def recursive/*<<=example.NamedApplyBlockMethods.recursive().*/ = foo/*=>>example.NamedApplyBlockMethods.foo().*/(local/*=>>example.NamedApplyBlockMethods.local.*/, c = foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter +} + +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.*/(bodyText/*=>>example.NamedApplyBlockCaseClassConstruction.bodyText.*/, tail = "tail") +} diff --git a/tests/semanticdb/NamedApplyBlock.scala b/tests/semanticdb/NamedApplyBlock.scala new file mode 100644 index 000000000000..0a453b4dfe2b --- /dev/null +++ b/tests/semanticdb/NamedApplyBlock.scala @@ -0,0 +1,14 @@ +package example + +object NamedApplyBlockMethods { + val local = 1 + def foo(a: Int = 1, b: Int = 2, c: Int = 3): Int = a + b + c + def baseCase = foo(local, c = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter + def recursive = foo(local, c = foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter +} + +object NamedApplyBlockCaseClassConstruction { + case class Msg(body: String, head: String = "default", tail: String) + val bodyText = "body" + val msg = Msg(bodyText, tail = "tail") +} diff --git a/tests/semanticdb/NamedArguments.expect.scala b/tests/semanticdb/NamedArguments.expect.scala new file mode 100644 index 000000000000..bfae8a62783a --- /dev/null +++ b/tests/semanticdb/NamedArguments.expect.scala @@ -0,0 +1,7 @@ +package example + +class NamedArguments/*<<=example.NamedArguments#*/ { + case class User/*<<=example.NamedArguments#User#*/(name/*<<=example.NamedArguments#User#name.*/: String/*=>>scala.Predef.String#*/) + User/*=>>example.NamedArguments#User.*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg + User/*=>>example.NamedArguments#User.*/.apply/*=>>example.NamedArguments#User.apply().*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg +} diff --git a/tests/semanticdb/NamedArguments.scala b/tests/semanticdb/NamedArguments.scala new file mode 100644 index 000000000000..8a29aa46de42 --- /dev/null +++ b/tests/semanticdb/NamedArguments.scala @@ -0,0 +1,7 @@ +package example + +class NamedArguments { + case class User(name: String) + User(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg + User.apply(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg +} diff --git a/tests/semanticdb/Objects.expect.scala b/tests/semanticdb/Objects.expect.scala new file mode 100644 index 000000000000..dcb17d507bfd --- /dev/null +++ b/tests/semanticdb/Objects.expect.scala @@ -0,0 +1,5 @@ +package objects + +object X/*<<=objects.X.*/ { + object Y/*<<=objects.X.Y.*/ +} diff --git a/tests/semanticdb/Objects.scala b/tests/semanticdb/Objects.scala new file mode 100644 index 000000000000..b1be1db1da91 --- /dev/null +++ b/tests/semanticdb/Objects.scala @@ -0,0 +1,5 @@ +package objects + +object X { + object Y +} diff --git a/tests/semanticdb/Overrides.expect.scala b/tests/semanticdb/Overrides.expect.scala new file mode 100644 index 000000000000..dd0438238129 --- /dev/null +++ b/tests/semanticdb/Overrides.expect.scala @@ -0,0 +1,4 @@ +package example + +trait A/*<<=example.A#*/ { def foo/*<<=example.A#foo().*/: Int/*=>>scala.Int#*/ } +class B/*<<=example.B#*/() extends A/*=>>example.A#*/ { def foo/*<<=example.B#foo().*/: Int/*=>>scala.Int#*/ = 2 } diff --git a/tests/semanticdb/Overrides.scala b/tests/semanticdb/Overrides.scala new file mode 100644 index 000000000000..3dd04fd0ff1f --- /dev/null +++ b/tests/semanticdb/Overrides.scala @@ -0,0 +1,4 @@ +package example + +trait A { def foo: Int } +class B() extends A { def foo: Int = 2 } From b11402378378205b41e44a3488f89662dd6f88a6 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 7 Nov 2019 17:52:51 +0100 Subject: [PATCH 046/107] add remaining tests and update todo --- tests/semanticdb/Prefixes.expect.scala | 33 +++++++++++++ tests/semanticdb/Prefixes.scala | 33 +++++++++++++ tests/semanticdb/Selfs.expect.scala | 15 ++++++ tests/semanticdb/Selfs.scala | 15 ++++++ tests/semanticdb/Synthetic.expect.scala | 46 ++++++++++++++++++ tests/semanticdb/Synthetic.scala | 46 ++++++++++++++++++ tests/semanticdb/Traits.expect.scala | 14 ++++++ tests/semanticdb/Traits.scala | 14 ++++++ tests/semanticdb/ValPattern.expect.scala | 45 ++++++++++++++++++ tests/semanticdb/ValPattern.scala | 45 ++++++++++++++++++ tests/semanticdb/Vals.expect.scala | 47 +++++++++++++++++++ tests/semanticdb/Vals.scala | 47 +++++++++++++++++++ tests/semanticdb/Vararg.expect.scala | 6 +++ tests/semanticdb/Vararg.scala | 6 +++ .../filename with spaces.expect.scala | 3 ++ tests/semanticdb/filename with spaces.scala | 3 ++ tests/semanticdb/local-file.expect.scala | 8 ++++ tests/semanticdb/local-file.scala | 8 ++++ tests/semanticdb/todo.md | 2 + 19 files changed, 436 insertions(+) create mode 100644 tests/semanticdb/Prefixes.expect.scala create mode 100644 tests/semanticdb/Prefixes.scala create mode 100644 tests/semanticdb/Selfs.expect.scala create mode 100644 tests/semanticdb/Selfs.scala create mode 100644 tests/semanticdb/Synthetic.expect.scala create mode 100644 tests/semanticdb/Synthetic.scala create mode 100644 tests/semanticdb/Traits.expect.scala create mode 100644 tests/semanticdb/Traits.scala create mode 100644 tests/semanticdb/ValPattern.expect.scala create mode 100644 tests/semanticdb/ValPattern.scala create mode 100644 tests/semanticdb/Vals.expect.scala create mode 100644 tests/semanticdb/Vals.scala create mode 100644 tests/semanticdb/Vararg.expect.scala create mode 100644 tests/semanticdb/Vararg.scala create mode 100644 tests/semanticdb/filename with spaces.expect.scala create mode 100644 tests/semanticdb/filename with spaces.scala create mode 100644 tests/semanticdb/local-file.expect.scala create mode 100644 tests/semanticdb/local-file.scala diff --git a/tests/semanticdb/Prefixes.expect.scala b/tests/semanticdb/Prefixes.expect.scala new file mode 100644 index 000000000000..d6d9baceb274 --- /dev/null +++ b/tests/semanticdb/Prefixes.expect.scala @@ -0,0 +1,33 @@ +package prefixes + +class C/*<<=prefixes.C#*/ { + type T/*<<=prefixes.C#T#*/ + def m1/*<<=prefixes.C#m1().*/: T/*=>>prefixes.C#T#*/ = ???/*=>>scala.Predef.`???`().*/ + + object N/*<<=prefixes.C#N.*/ { + type U/*<<=prefixes.C#N.U#*/ + } + def k1/*<<=prefixes.C#k1().*/: N/*=>>prefixes.C#N.*/.U/*=>>prefixes.C#N.U#*/ = ???/*=>>scala.Predef.`???`().*/ +} + +object M/*<<=prefixes.M.*/ { + type T/*<<=prefixes.M.T#*/ + def n1/*<<=prefixes.M.n1().*/: T/*=>>prefixes.M.T#*/ = ???/*=>>scala.Predef.`???`().*/ +} + +object O/*<<=prefixes.O.*/ extends C/*=>>prefixes.C#*//*=>>prefixes.C#``().*/ { + def o1/*<<=prefixes.O.o1().*/: T/*=>>prefixes.C#T#*/ = ???/*=>>scala.Predef.`???`().*/ +} + +object Test/*<<=prefixes.Test.*/ { + val c/*<<=prefixes.Test.c.*/: C/*=>>prefixes.C#*/ = ???/*=>>scala.Predef.`???`().*/ + def m2/*<<=prefixes.Test.m2().*/: c/*=>>prefixes.Test.c.*/.T/*=>>prefixes.C#T#*/ = ???/*=>>scala.Predef.`???`().*/ + def k2/*<<=prefixes.Test.k2().*/: c/*=>>prefixes.Test.c.*/.N/*=>>prefixes.C#N.*/.U/*=>>prefixes.C#N.U#*/ = ???/*=>>scala.Predef.`???`().*/ + import c.N/*=>>prefixes.C#N.*/._ + def k3/*<<=prefixes.Test.k3().*/: U = ???/*=>>scala.Predef.`???`().*/ + + def n2/*<<=prefixes.Test.n2().*/: M/*=>>prefixes.M.*/.T/*=>>prefixes.M.T#*/ = ???/*=>>scala.Predef.`???`().*/ + + import M._ + def n3/*<<=prefixes.Test.n3().*/: T/*=>>prefixes.M.T#*/ = ???/*=>>scala.Predef.`???`().*/ +} diff --git a/tests/semanticdb/Prefixes.scala b/tests/semanticdb/Prefixes.scala new file mode 100644 index 000000000000..11891cb325ec --- /dev/null +++ b/tests/semanticdb/Prefixes.scala @@ -0,0 +1,33 @@ +package prefixes + +class C { + type T + def m1: T = ??? + + object N { + type U + } + def k1: N.U = ??? +} + +object M { + type T + def n1: T = ??? +} + +object O extends C { + def o1: T = ??? +} + +object Test { + val c: C = ??? + def m2: c.T = ??? + def k2: c.N.U = ??? + import c.N._ + def k3: U = ??? + + def n2: M.T = ??? + + import M._ + def n3: T = ??? +} diff --git a/tests/semanticdb/Selfs.expect.scala b/tests/semanticdb/Selfs.expect.scala new file mode 100644 index 000000000000..cd0c784fd4e8 --- /dev/null +++ b/tests/semanticdb/Selfs.expect.scala @@ -0,0 +1,15 @@ +package selfs + +class B/*<<=selfs.B#*/ + +class C1/*<<=selfs.C1#*/ extends B/*=>>selfs.B#*//*=>>selfs.B#``().*/ { self/*<<=local0*/ => +} + +class C2/*<<=selfs.C2#*/ extends B/*=>>selfs.B#*//*=>>selfs.B#``().*/ { self/*<<=local1*/: B/*=>>selfs.B#*/ => +} + +class C3/*<<=selfs.C3#*/ extends B/*=>>selfs.B#*//*=>>selfs.B#``().*/ { self/*<<=local2*/: B/*=>>selfs.B#*/ with C1/*=>>selfs.C1#*/ => +} + +class C6/*<<=selfs.C6#*/ extends B/*=>>selfs.B#*//*=>>selfs.B#``().*/ { this: B/*=>>selfs.B#*/ => +} diff --git a/tests/semanticdb/Selfs.scala b/tests/semanticdb/Selfs.scala new file mode 100644 index 000000000000..4e46793bd783 --- /dev/null +++ b/tests/semanticdb/Selfs.scala @@ -0,0 +1,15 @@ +package selfs + +class B + +class C1 extends B { self => +} + +class C2 extends B { self: B => +} + +class C3 extends B { self: B with C1 => +} + +class C6 extends B { this: B => +} diff --git a/tests/semanticdb/Synthetic.expect.scala b/tests/semanticdb/Synthetic.expect.scala new file mode 100644 index 000000000000..e9339903d7a1 --- /dev/null +++ b/tests/semanticdb/Synthetic.expect.scala @@ -0,0 +1,46 @@ +package example + +class Synthetic/*<<=example.Synthetic#*/ { + List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1).map/*=>>scala.collection.immutable.List#map().*/(_ +/*=>>scala.Int#`+`(+4).*/ 2) + /*=>>scala.Predef.intArrayOps().*/Array/*=>>scala.Array.*/.empty/*=>>scala.Array.empty().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer#TYPE.*/.headOption/*=>>scala.collection.ArrayOps#headOption().*/ + /*=>>scala.Predef.augmentString().*/"fooo".stripPrefix/*=>>scala.collection.StringOps#stripPrefix().*/("o") + + // See https://github.com/scalameta/scalameta/issues/977 + val Name/*<<=example.Synthetic#Name.*/ = /*=>>scala.Predef.augmentString().*/"name:(.*)".r/*=>>scala.collection.StringOps#r().*/ + /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/val x/*<<=example.Synthetic#x.*/ #:: xs/*<<=example.Synthetic#xs.*/ = Stream(1, 2) + val Name/*=>>example.Synthetic#Name.*//*=>>scala.util.matching.Regex#unapplySeq().*/(name/*<<=example.Synthetic#name.*//*<<=local0*/)/*=>>local0*/ = "name:foo" + 1 #:: /*=>>scala.collection.immutable.Stream.toDeferrer().*/2 #:: /*=>>scala.collection.immutable.Stream.toDeferrer().*/Stream/*=>>scala.package.Stream.*/.empty/*=>>scala.collection.immutable.Stream.empty().*//*=>>scala.collection.immutable.Stream.Deferrer#`#::`().*/ + + val lst/*<<=example.Synthetic#lst.*/ = 1 #:: /*=>>scala.collection.immutable.Stream.toDeferrer().*/2 #:: /*=>>scala.collection.immutable.Stream.toDeferrer().*/Stream/*=>>scala.package.Stream.*/.empty/*=>>scala.collection.immutable.Stream.empty().*//*=>>scala.collection.immutable.Stream.Deferrer#`#::`().*/ + + for (x <- /*=>>scala.LowPriorityImplicits#intWrapper().*/1 to/*=>>scala.runtime.RichInt#to().*/ 10/*=>>scala.collection.immutable.Range#foreach().*/; y <- /*=>>scala.LowPriorityImplicits#intWrapper().*/0 until/*=>>scala.runtime.RichInt#until().*/ 10/*=>>scala.collection.immutable.Range#foreach().*/) println/*=>>scala.Predef.println(+1).*/(x/*=>>local1*/ ->/*=>>scala.Predef.ArrowAssoc#`->`().*/ x/*=>>local1*/) + for (i <- /*=>>scala.LowPriorityImplicits#intWrapper().*/1 to/*=>>scala.runtime.RichInt#to().*/ 10/*=>>scala.collection.StrictOptimizedIterableOps#flatMap().*/; j <- /*=>>scala.LowPriorityImplicits#intWrapper().*/0 until/*=>>scala.runtime.RichInt#until().*/ 10/*=>>scala.collection.immutable.Range#map().*/) yield (i/*=>>local2*/, j/*=>>local3*/) + for (i <- /*=>>scala.LowPriorityImplicits#intWrapper().*/1 to/*=>>scala.runtime.RichInt#to().*/ 10/*=>>scala.collection.StrictOptimizedIterableOps#flatMap().*/; j <- /*=>>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 (i/*=>>local4*/, j/*=>>local5*/) + + object s/*<<=example.Synthetic#s.*/ { + def apply/*<<=example.Synthetic#s.apply().*/() = 2 + s/*=>>example.Synthetic#s.apply().*/() + s.apply/*=>>example.Synthetic#s.apply().*/() + case class Bar/*<<=example.Synthetic#s.Bar#*/() + Bar/*=>>example.Synthetic#s.Bar.*/() + null.asInstanceOf/*=>>scala.Any#asInstanceOf().*/[Int/*=>>scala.Int#*/ => Int/*=>>scala.Int#*/]/*=>>scala.Function1#apply().*/(2) + } + + class J/*<<=example.Synthetic#J#*/[T/*<<=example.Synthetic#J#[T]*//*<<=example.Synthetic#J#evidence$2.*/: 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]*/]/*=>>example.Synthetic#J#evidence$2.*/ } + + 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#F#``().*//*=>>example.Synthetic#ordering.*/ + + import scala.concurrent.ExecutionContext/*=>>scala.concurrent.ExecutionContext.*/.Implicits/*=>>scala.concurrent.ExecutionContext.Implicits.*/.global/*=>>scala.concurrent.ExecutionContext.Implicits.global().*/ + for { + a <- scala.concurrent.Future/*=>>scala.concurrent.Future.*/.successful/*=>>scala.concurrent.Future.successful().*/(1)/*=>>scala.concurrent.Future#foreach().*/ + b <- scala.concurrent.Future/*=>>scala.concurrent.Future.*/.successful/*=>>scala.concurrent.Future.successful().*/(2)/*=>>scala.concurrent.Future#foreach().*/ + } println/*=>>scala.Predef.println(+1).*/(a/*=>>local6*/)/*=>>scala.concurrent.ExecutionContext.Implicits.global().*/ + for { + a <- scala.concurrent.Future/*=>>scala.concurrent.Future.*/.successful/*=>>scala.concurrent.Future.successful().*/(1)/*=>>scala.concurrent.Future#flatMap().*/ + b <- scala.concurrent.Future/*=>>scala.concurrent.Future.*/.successful/*=>>scala.concurrent.Future.successful().*/(2)/*=>>scala.concurrent.Future#withFilter().*/ + if a/*=>>local7*/ >scala.Int#`<`(+3).*/ b/*=>>local8*//*=>>scala.concurrent.Future#map().*//*=>>scala.concurrent.ExecutionContext.Implicits.global().*/ + } yield a/*=>>local7*//*=>>scala.concurrent.ExecutionContext.Implicits.global().*/ + +} diff --git a/tests/semanticdb/Synthetic.scala b/tests/semanticdb/Synthetic.scala new file mode 100644 index 000000000000..5c7fb3519e51 --- /dev/null +++ b/tests/semanticdb/Synthetic.scala @@ -0,0 +1,46 @@ +package example + +class Synthetic { + List(1).map(_ + 2) + Array.empty[Int].headOption + "fooo".stripPrefix("o") + + // See https://github.com/scalameta/scalameta/issues/977 + val Name = "name:(.*)".r + val x #:: xs = Stream(1, 2) + val Name(name) = "name:foo" + 1 #:: 2 #:: Stream.empty + + val lst = 1 #:: 2 #:: Stream.empty + + for (x <- 1 to 10; y <- 0 until 10) println(x -> x) + for (i <- 1 to 10; j <- 0 until 10) yield (i, j) + for (i <- 1 to 10; j <- 0 until 10 if i % 2 == 0) yield (i, j) + + object s { + def apply() = 2 + s() + s.apply() + case class Bar() + Bar() + null.asInstanceOf[Int => Int](2) + } + + class J[T: Manifest] { val arr = Array.empty[T] } + + class F + implicit val ordering: Ordering[F] = ??? + val f: Ordered[F] = new F + + import scala.concurrent.ExecutionContext.Implicits.global + for { + a <- scala.concurrent.Future.successful(1) + b <- scala.concurrent.Future.successful(2) + } println(a) + for { + a <- scala.concurrent.Future.successful(1) + b <- scala.concurrent.Future.successful(2) + if a < b + } yield a + +} diff --git a/tests/semanticdb/Traits.expect.scala b/tests/semanticdb/Traits.expect.scala new file mode 100644 index 000000000000..929809d23ab5 --- /dev/null +++ b/tests/semanticdb/Traits.expect.scala @@ -0,0 +1,14 @@ +package traits + +trait T/*<<=traits.T#*/ { + def x/*<<=traits.T#x().*/ = 2 +} + +sealed trait U/*<<=traits.U#*/ +object U/*<<=traits.U.*/ { + def u/*<<=traits.U.u().*/: U/*=>>traits.U#*/ = new U/*=>>traits.U#*/ {} +} + +class C/*<<=traits.C#*/ +trait V/*<<=traits.V#*/ { self/*<<=local0*/: C/*=>>traits.C#*/ => +} diff --git a/tests/semanticdb/Traits.scala b/tests/semanticdb/Traits.scala new file mode 100644 index 000000000000..75efd131f04b --- /dev/null +++ b/tests/semanticdb/Traits.scala @@ -0,0 +1,14 @@ +package traits + +trait T { + def x = 2 +} + +sealed trait U +object U { + def u: U = new U {} +} + +class C +trait V { self: C => +} diff --git a/tests/semanticdb/ValPattern.expect.scala b/tests/semanticdb/ValPattern.expect.scala new file mode 100644 index 000000000000..987af9987291 --- /dev/null +++ b/tests/semanticdb/ValPattern.expect.scala @@ -0,0 +1,45 @@ +package example + +class ValPattern/*<<=example.ValPattern#*/ { + + /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/val (left/*<<=example.ValPattern#left.*/, right/*<<=example.ValPattern#right.*/) = (1, 2) + val Some/*=>>scala.Some.*/(number1/*<<=example.ValPattern#number1.*//*<<=local0*/)/*=>>local0*/ = + Some/*=>>scala.Some.*/(1) + + /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/var (leftVar/*<<=example.ValPattern#leftVar().*/, /*<<=example.ValPattern#`leftVar_=`().*/rightVar/*<<=example.ValPattern#rightVar().*/) /*<<=example.ValPattern#`rightVar_=`().*/= (1, 2) + var Some/*=>>scala.Some.*/(number1Var/*<<=example.ValPattern#number1Var().*//*<<=local1*/) /*<<=example.ValPattern#`number1Var_=`().*//*=>>local1*/= + Some/*=>>scala.Some.*/(1) + + def app/*<<=example.ValPattern#app().*/(): Unit/*=>>scala.Unit#*/ = { + println/*=>>scala.Predef.println(+1).*/( + ( + number1/*=>>example.ValPattern#number1.*/, + left/*=>>example.ValPattern#left.*/, + right/*=>>example.ValPattern#right.*/, + number1Var/*=>>example.ValPattern#number1Var().*/, + leftVar/*=>>example.ValPattern#leftVar().*/, + rightVar/*=>>example.ValPattern#rightVar().*/ + ) + ) + locally/*=>>dotty.DottyPredef.locally().*/ { + /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/val (left/*<<=local2*/, right/*<<=local3*/) = (1, 2) + val Some/*=>>scala.Some.*/(number1/*<<=local4*/)/*=>>local4*/ = + Some/*=>>scala.Some.*/(1) + + /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/var (leftVar/*<<=local5*/, rightVar/*<<=local6*/) = (1, 2) + var Some/*=>>scala.Some.*/(number1Var/*<<=local7*/)/*=>>local7*/ = + Some/*=>>scala.Some.*/(1) + println/*=>>scala.Predef.println(+1).*/( + ( + number1/*=>>local4*/, + left/*=>>local2*/, + right/*=>>local3*/, + number1Var/*=>>local7*/, + leftVar/*=>>local5*/, + rightVar/*=>>local6*/ + ) + ) + } + } + +} diff --git a/tests/semanticdb/ValPattern.scala b/tests/semanticdb/ValPattern.scala new file mode 100644 index 000000000000..2c802afdb374 --- /dev/null +++ b/tests/semanticdb/ValPattern.scala @@ -0,0 +1,45 @@ +package example + +class ValPattern { + + val (left, right) = (1, 2) + val Some(number1) = + Some(1) + + var (leftVar, rightVar) = (1, 2) + var Some(number1Var) = + Some(1) + + def app(): Unit = { + println( + ( + number1, + left, + right, + number1Var, + leftVar, + rightVar + ) + ) + locally { + val (left, right) = (1, 2) + val Some(number1) = + Some(1) + + var (leftVar, rightVar) = (1, 2) + var Some(number1Var) = + Some(1) + println( + ( + number1, + left, + right, + number1Var, + leftVar, + rightVar + ) + ) + } + } + +} diff --git a/tests/semanticdb/Vals.expect.scala b/tests/semanticdb/Vals.expect.scala new file mode 100644 index 000000000000..ca1308c0aa32 --- /dev/null +++ b/tests/semanticdb/Vals.expect.scala @@ -0,0 +1,47 @@ +package example + +abstract class Vals/*<<=example.Vals#*/(p/*<<=example.Vals#p.*/: Int/*=>>scala.Int#*/, val xp/*<<=example.Vals#xp.*/: Int/*=>>scala.Int#*/, var yp/*<<=example.Vals#yp().*/: /*<<=example.Vals#`yp_=`().*/Int/*=>>scala.Int#*/) { + val xm/*<<=example.Vals#xm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + val xam/*<<=example.Vals#xam.*/: Int/*=>>scala.Int#*/ + private[this] val xlm/*<<=example.Vals#xlm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + lazy val xzm/*<<=example.Vals#xzm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + private[this] lazy val xzlm/*<<=example.Vals#xzlm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + final val xfm/*<<=example.Vals#xfm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + implicit val xim/*<<=example.Vals#xim.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + var ym/*<<=example.Vals#ym().*/: /*<<=example.Vals#`ym_=`().*/Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + var yam/*<<=example.Vals#yam().*/: /*<<=example.Vals#`yam_=`().*/Int/*=>>scala.Int#*/ + private[this] var ylm/*<<=example.Vals#ylm().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + // NOTE: lazy not allowed here. Only vals can be lazy + // lazy var xzm: Int = ??? + // private[this] lazy var yzlm: Int = ??? + final var yfm/*<<=example.Vals#yfm().*/: /*<<=example.Vals#`yfm_=`().*/Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + implicit var yim/*<<=example.Vals#yim().*/: /*<<=example.Vals#`yim_=`().*/Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + def m/*<<=example.Vals#m().*/ = { + val xl/*<<=local0*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + lazy val xzl/*<<=local1*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + // NOTE: local values cannot be final + // final val xfl: Int = ??? + implicit val xil/*<<=local2*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + var yl/*<<=local3*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + // NOTE: lazy not allowed here. Only vals can be lazy + // lazy var yzl: Int = ??? + // NOTE: local variables cannot be final + // final var yfl: Int = ??? + implicit var yil/*<<=local4*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + yl/*=>>local3*/ = xl/*=>>local0*/ +/*=>>scala.Int#`+`(+4).*/ yl/*=>>local3*/ + println/*=>>scala.Predef.println(+1).*/(xzl/*=>>local1*/) + yil/*=>>local4*/ = xil/*=>>local2*/ +/*=>>scala.Int#`+`(+4).*/ yil/*=>>local4*/ + } + println/*=>>scala.Predef.println(+1).*/(xzlm/*=>>example.Vals#xzlm.*/) + ylm/*=>>example.Vals#ylm().*/ = xlm/*=>>example.Vals#xlm.*/ +/*=>>scala.Int#`+`(+4).*/ ylm/*=>>example.Vals#ylm().*/ +} + +object ValUsages/*<<=example.ValUsages.*/ { + val v/*<<=example.ValUsages.v.*/: Vals/*=>>example.Vals#*/ = ???/*=>>scala.Predef.`???`().*/ + v/*=>>example.ValUsages.v.*/.yp/*=>>example.Vals#yp().*/ = v/*=>>example.ValUsages.v.*/.xp/*=>>example.Vals#xp.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.yp/*=>>example.Vals#yp().*/ + v/*=>>example.ValUsages.v.*/.ym/*=>>example.Vals#ym().*/ = v/*=>>example.ValUsages.v.*/.xm/*=>>example.Vals#xm.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.ym/*=>>example.Vals#ym().*/ + v/*=>>example.ValUsages.v.*/.yam/*=>>example.Vals#yam().*/ = v/*=>>example.ValUsages.v.*/.xam/*=>>example.Vals#xam.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.yam/*=>>example.Vals#yam().*/ + println/*=>>scala.Predef.println(+1).*/(v/*=>>example.ValUsages.v.*/.xzm/*=>>example.Vals#xzm.*/) + v/*=>>example.ValUsages.v.*/.yfm/*=>>example.Vals#yfm().*/ = v/*=>>example.ValUsages.v.*/.xfm/*=>>example.Vals#xfm.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.yfm/*=>>example.Vals#yfm().*/ + v/*=>>example.ValUsages.v.*/.yim/*=>>example.Vals#yim().*/ = v/*=>>example.ValUsages.v.*/.xim/*=>>example.Vals#xim.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.yim/*=>>example.Vals#yim().*/ +} diff --git a/tests/semanticdb/Vals.scala b/tests/semanticdb/Vals.scala new file mode 100644 index 000000000000..64e8026448bc --- /dev/null +++ b/tests/semanticdb/Vals.scala @@ -0,0 +1,47 @@ +package example + +abstract class Vals(p: Int, val xp: Int, var yp: Int) { + val xm: Int = ??? + val xam: Int + private[this] val xlm: Int = ??? + lazy val xzm: Int = ??? + private[this] lazy val xzlm: Int = ??? + final val xfm: Int = ??? + implicit val xim: Int = ??? + var ym: Int = ??? + var yam: Int + private[this] var ylm: Int = ??? + // NOTE: lazy not allowed here. Only vals can be lazy + // lazy var xzm: Int = ??? + // private[this] lazy var yzlm: Int = ??? + final var yfm: Int = ??? + implicit var yim: Int = ??? + def m = { + val xl: Int = ??? + lazy val xzl: Int = ??? + // NOTE: local values cannot be final + // final val xfl: Int = ??? + implicit val xil: Int = ??? + var yl: Int = ??? + // NOTE: lazy not allowed here. Only vals can be lazy + // lazy var yzl: Int = ??? + // NOTE: local variables cannot be final + // final var yfl: Int = ??? + implicit var yil: Int = ??? + yl = xl + yl + println(xzl) + yil = xil + yil + } + println(xzlm) + ylm = xlm + ylm +} + +object ValUsages { + val v: Vals = ??? + v.yp = v.xp + v.yp + v.ym = v.xm + v.ym + v.yam = v.xam + v.yam + println(v.xzm) + v.yfm = v.xfm + v.yfm + v.yim = v.xim + v.yim +} diff --git a/tests/semanticdb/Vararg.expect.scala b/tests/semanticdb/Vararg.expect.scala new file mode 100644 index 000000000000..3ac0a16719ed --- /dev/null +++ b/tests/semanticdb/Vararg.expect.scala @@ -0,0 +1,6 @@ +package example + +class Vararg/*<<=example.Vararg#*/ { + def add1/*<<=example.Vararg#add1().*/(a/*<<=example.Vararg#add1().(a)*/: Int/*=>>scala.Int#*/*) = {} + def add2/*<<=example.Vararg#add2().*/(a/*<<=example.Vararg#add2().(a)*/: Seq/*=>>scala.package.Seq#*/[Int/*=>>scala.Int#*/]*): Unit/*=>>scala.Unit#*/ = {} +} diff --git a/tests/semanticdb/Vararg.scala b/tests/semanticdb/Vararg.scala new file mode 100644 index 000000000000..8500289f0d5a --- /dev/null +++ b/tests/semanticdb/Vararg.scala @@ -0,0 +1,6 @@ +package example + +class Vararg { + def add1(a: Int*) = {} + def add2(a: Seq[Int]*): Unit = {} +} diff --git a/tests/semanticdb/filename with spaces.expect.scala b/tests/semanticdb/filename with spaces.expect.scala new file mode 100644 index 000000000000..8e067c2662d9 --- /dev/null +++ b/tests/semanticdb/filename with spaces.expect.scala @@ -0,0 +1,3 @@ +package example + +class FilenameWithSpaces/*<<=example.FilenameWithSpaces#*//*<=example.FilenameWithSpaces#*/ diff --git a/tests/semanticdb/filename with spaces.scala b/tests/semanticdb/filename with spaces.scala new file mode 100644 index 000000000000..0a7c02c4d87b --- /dev/null +++ b/tests/semanticdb/filename with spaces.scala @@ -0,0 +1,3 @@ +package example + +class FilenameWithSpaces/*<=example.FilenameWithSpaces#*/ diff --git a/tests/semanticdb/local-file.expect.scala b/tests/semanticdb/local-file.expect.scala new file mode 100644 index 000000000000..322005341e99 --- /dev/null +++ b/tests/semanticdb/local-file.expect.scala @@ -0,0 +1,8 @@ +package example + +class `local-file/*<<=example.`local-file`#*/` { + locally/*=>>dotty.DottyPredef.locally().*/ { + val local/*<<=local0*/ = 42 + local/*=>>local0*/ +/*=>>scala.Int#`+`(+4).*/ 4 + } +} diff --git a/tests/semanticdb/local-file.scala b/tests/semanticdb/local-file.scala new file mode 100644 index 000000000000..ea699bdfff57 --- /dev/null +++ b/tests/semanticdb/local-file.scala @@ -0,0 +1,8 @@ +package example + +class `local-file` { + locally { + val local = 42 + local + 4 + } +} diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md index c5ecd706bbcc..27f2f5dc6a1e 100644 --- a/tests/semanticdb/todo.md +++ b/tests/semanticdb/todo.md @@ -7,6 +7,8 @@ This todolist is based upon blackbox observation of testcases at this repository - [ ] Hide desugaring of for comprehension - [ ] Hide calls to implicit conversions and their arguments - [ ] Hide Tuple contructors +- [ ] Hide implicitly applied arguments +- [ ] Assignments to vars should emit setter symbol - [x] unescape unicode in names. - [x] Only traverse prefix of a Select if it is not a package - [x] Ensure only methods are counted in overloads From 9e73299d31e34c7117f0b4174750b52cec18dd00 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 8 Nov 2019 16:49:18 +0100 Subject: [PATCH 047/107] fix special case of _root_ and _empty_ --- .../dotc/semanticdb/ExtractSemanticDB.scala | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 7ced1f049519..308fe13c60a0 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -62,7 +62,7 @@ class ExtractSemanticDB extends Phase { private val unicodeEscape = raw"\$$u(\p{XDigit}{4})".r /** Add semanticdb name of the given symbol to string builder */ - private def addSymName(b: StringBuilder, sym: Symbol, inOwner: Boolean = false)(given ctx: Context): Unit = + private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) @@ -84,7 +84,7 @@ class ExtractSemanticDB extends Phase { || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) def addOwner(owner: Symbol): Unit = - if !owner.isRoot then addSymName(b, owner, inOwner = true) + if !owner.isRoot then addSymName(b, owner) def addOverloadIdx(sym: Symbol): Unit = val decls = { @@ -109,7 +109,11 @@ class ExtractSemanticDB extends Phase { else if sym.is(Param) then b.append('('); addName(sym.name); b.append(')') else - if (sym.isPackageObject) then + if sym.isRoot then + b.append("_root_") + else if sym.isEmptyPackage then + b.append("_empty_") + else if (sym.isPackageObject) then b.append("package") else addName(sym.name) @@ -136,11 +140,7 @@ class ExtractSemanticDB extends Phase { locals.getOrElseUpdate(sym, computeLocalIdx()) if sym.exists then - if sym.isRoot then - b.append(if !inOwner then "_root_" else "_root_.") - else if sym.isEmptyPackage then - b.append(if !inOwner then "_empty_" else "_empty_.") - else if isGlobal(sym) then + if isGlobal(sym) then addOwner(sym.owner); addDescriptor(sym) else b.append("local").append(localIdx(sym)) From 1e3bc9177986c6a1597f7ce5f3339bbfa6cbb6a8 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 8 Nov 2019 17:16:53 +0100 Subject: [PATCH 048/107] remove testfilter, remove compilation warnings --- .../dotc/semanticdb/SemanticdbTests.scala | 9 ++++-- project/Build.scala | 3 -- tests/semanticdb/Anonymous.expect.scala | 2 +- tests/semanticdb/Anonymous.scala | 2 +- tests/semanticdb/Enums.expect.scala | 31 +++++++------------ tests/semanticdb/Enums.scala | 31 +++++++------------ .../ImplicitConversion.expect.scala | 12 ++++--- tests/semanticdb/ImplicitConversion.scala | 10 ++++-- tests/semanticdb/Synthetic.expect.scala | 8 +++-- tests/semanticdb/Synthetic.scala | 8 +++-- 10 files changed, 58 insertions(+), 58 deletions(-) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 10448fad61b2..e237092e00aa 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -7,17 +7,20 @@ import java.nio.file._ import java.nio.charset.StandardCharsets import java.util.stream.Collectors import scala.util.control.NonFatal +import scala.jdk.CollectionConverters._ + import org.junit.Assert._ import org.junit.Test import org.junit.experimental.categories.Category -import scala.collection.JavaConverters._ + +import dotty.BootstrappedOnlyTests import dotty.tools.dotc.Main import dotty.tools.dotc.semanticdb.DiffAssertions._ - @main def updateExpect() = new SemanticdbTests().runExpectTest(updateExpectFiles = true) +@Category(Array(classOf[BootstrappedOnlyTests])) class SemanticdbTests { val scalaFile = FileSystems.getDefault.getPathMatcher("glob:**.scala") val expectFile = FileSystems.getDefault.getPathMatcher("glob:**.expect.scala") @@ -64,6 +67,8 @@ class SemanticdbTests { val args = Array( "-Ysemanticdb", "-d", target.toString, + "-feature", + "-deprecation", // "-Ydebug", // "-Xprint:extractSemanticDB", "-sourceroot", src.toString, diff --git a/project/Build.scala b/project/Build.scala index cccfab0f99df..b6efdc575885 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -740,9 +740,6 @@ object Build { if (mode == NonBootstrapped) nonBootstrapedDottyCompilerSettings else bootstrapedDottyCompilerSettings lazy val `dotty-compiler` = project.in(file("compiler")).asDottyCompiler(NonBootstrapped) - .settings( - Test / testOptions := Seq(Tests.Filter(s => s != "dotty.tools.dotc.semanticdb.SemanticdbTests")) - ) lazy val `dotty-compiler-bootstrapped` = project.in(file("compiler")).asDottyCompiler(Bootstrapped) def dottyCompiler(implicit mode: Mode): Project = mode match { diff --git a/tests/semanticdb/Anonymous.expect.scala b/tests/semanticdb/Anonymous.expect.scala index bd1084ee6813..945414da8267 100644 --- a/tests/semanticdb/Anonymous.expect.scala +++ b/tests/semanticdb/Anonymous.expect.scala @@ -16,5 +16,5 @@ class Anonymous/*<<=example.Anonymous#*/ { } trait Foo/*<<=example.Anonymous#Foo#*/ - new Foo/*=>>example.Anonymous#Foo#*/ {} + val foo/*<<=example.Anonymous#foo.*/ = new Foo/*=>>example.Anonymous#Foo#*/ {} } diff --git a/tests/semanticdb/Anonymous.scala b/tests/semanticdb/Anonymous.scala index dbae5c8e38c0..8daeff92bf7f 100644 --- a/tests/semanticdb/Anonymous.scala +++ b/tests/semanticdb/Anonymous.scala @@ -16,5 +16,5 @@ class Anonymous { } trait Foo - new Foo {} + val foo = new Foo {} } diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/Enums.expect.scala index 21cd871c5b6b..5db51e90dbcd 100644 --- a/tests/semanticdb/Enums.expect.scala +++ b/tests/semanticdb/Enums.expect.scala @@ -1,9 +1,10 @@ -object Enums/*<<=_empty_.Enums.*/ { - enum Colour/*<<=_empty_.Enums.Colour#*/ { +object Enums/*<<=_empty_.Enums.*/ with + import =:=._ + + enum Colour/*<<=_empty_.Enums.Colour#*/ with case /*=>>scala.runtime.EnumValues#``().*/Red/*=>>_empty_.Enums.Colour.Red.*//*<<=_empty_.Enums.Colour.Red.*/, Green/*=>>_empty_.Enums.Colour.Green.*//*<<=_empty_.Enums.Colour.Green.*/, Blue/*=>>_empty_.Enums.Colour.Blue.*//*<<=_empty_.Enums.Colour.Blue.*/ - } - enum WeekDays/*<<=_empty_.Enums.WeekDays#*/ { + enum WeekDays/*<<=_empty_.Enums.WeekDays#*/ with /*=>>scala.runtime.EnumValues#``().*/case Monday/*<<=_empty_.Enums.WeekDays.Monday.*/ case Tuesday/*<<=_empty_.Enums.WeekDays.Tuesday.*/ case Wednesday/*<<=_empty_.Enums.WeekDays.Wednesday.*/ @@ -11,29 +12,23 @@ object Enums/*<<=_empty_.Enums.*/ { case Friday/*<<=_empty_.Enums.WeekDays.Friday.*/ case Saturday/*<<=_empty_.Enums.WeekDays.Saturday.*/ case Sunday/*<<=_empty_.Enums.WeekDays.Sunday.*/ - } - enum Maybe/*<<=_empty_.Enums.Maybe#*/[+A/*<<=_empty_.Enums.Maybe#[A]*/] { + enum Maybe/*<<=_empty_.Enums.Maybe#*/[+A/*<<=_empty_.Enums.Maybe#[A]*/] with /*=>>_empty_.Enums.Maybe#``().*/case Just/*<<=_empty_.Enums.Maybe.Just#*/(value/*<<=_empty_.Enums.Maybe.Just#value.*/: A/*=>>_empty_.Enums.Maybe.Just#``().[A]*/) /*=>>_empty_.Enums.Maybe#``().*/case None/*<<=_empty_.Enums.Maybe.None.*/ - } - enum Tag/*<<=_empty_.Enums.Tag#*/[A/*<<=_empty_.Enums.Tag#[A]*/] { + enum Tag/*<<=_empty_.Enums.Tag#*/[A/*<<=_empty_.Enums.Tag#[A]*/] with case IntTag/*<<=_empty_.Enums.Tag.IntTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Int/*=>>scala.Int#*/]/*=>>_empty_.Enums.Tag#``().*/ case BooleanTag/*<<=_empty_.Enums.Tag.BooleanTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Boolean/*=>>scala.Boolean#*/]/*=>>_empty_.Enums.Tag#``().*/ - } - enum =:=/*<<=_empty_.Enums.`=:=`#*/[A/*<<=_empty_.Enums.`=:=`#[A]*/, B/*<<=_empty_.Enums.`=:=`#[B]*/] { + enum =:=/*<<=_empty_.Enums.`=:=`#*/[A/*<<=_empty_.Enums.`=:=`#[A]*/, B/*<<=_empty_.Enums.`=:=`#[B]*/] with case Refl/*<<=_empty_.Enums.`=:=`.Refl#*/[C/*<<=_empty_.Enums.`=:=`.Refl#[C]*/]() extends (C/*=>>_empty_.Enums.`=:=`.Refl#[C]*/ =:=/*=>>_empty_.Enums.`=:=`#*/ C/*=>>_empty_.Enums.`=:=`.Refl#[C]*//*=>>_empty_.Enums.`=:=`#``().*/) - } - def unwrap/*<<=_empty_.Enums.unwrap().*/[A/*<<=_empty_.Enums.unwrap().[A]*/,B/*<<=_empty_.Enums.unwrap().[B]*/](opt/*<<=_empty_.Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>_empty_.Enums.unwrap().[A]*/])(given ev/*<<=_empty_.Enums.unwrap().(ev)*/: A/*=>>_empty_.Enums.unwrap().[A]*/ =:=/*=>>_empty_.Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/]): Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/] = { - ev/*=>>_empty_.Enums.unwrap().(ev)*/ match { - case =:=/*=>>_empty_.Enums.`=:=`.*/.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]*/]]) - } - } + def unwrap/*<<=_empty_.Enums.unwrap().*/[A/*<<=_empty_.Enums.unwrap().[A]*/,B/*<<=_empty_.Enums.unwrap().[B]*/](opt/*<<=_empty_.Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>_empty_.Enums.unwrap().[A]*/])(given ev/*<<=_empty_.Enums.unwrap().(ev)*/: A/*=>>_empty_.Enums.unwrap().[A]*/ =:=/*=>>_empty_.Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/]): Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/] = ev/*=>>_empty_.Enums.unwrap().(ev)*/ match + case Refl/*=>>_empty_.Enums.`=:=`.Refl.*/() => opt/*=>>_empty_.Enums.unwrap().(opt)*/.flatMap/*=>>scala.Option#flatMap().*/(identity/*=>>scala.Predef.identity().*/[Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/]]) + case _ => None/*=>>scala.None.*/ // TODO remove after https://github.com/lampepfl/dotty/issues/7524 is fixed - enum Planet/*<<=_empty_.Enums.Planet#*/(mass/*<<=_empty_.Enums.Planet#mass.*/: Double/*=>>scala.Double#*/, radius/*<<=_empty_.Enums.Planet#radius.*/: Double/*=>>scala.Double#*/) extends java.lang.Enum/*=>>java.lang.Enum#*/[Planet/*=>>_empty_.Enums.Planet#*/]/*=>>java.lang.Enum#``().*/ { + enum Planet/*<<=_empty_.Enums.Planet#*/(mass/*<<=_empty_.Enums.Planet#mass.*/: Double/*=>>scala.Double#*/, radius/*<<=_empty_.Enums.Planet#radius.*/: Double/*=>>scala.Double#*/) extends java.lang.Enum/*=>>java.lang.Enum#*/[Planet/*=>>_empty_.Enums.Planet#*/]/*=>>java.lang.Enum#``().*/ with private final val G/*<<=_empty_.Enums.Planet#G.*/ = 6.67300E-11 def surfaceGravity/*<<=_empty_.Enums.Planet#surfaceGravity().*/ = G/*=>>_empty_.Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>_empty_.Enums.Planet#mass.*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>_empty_.Enums.Planet#radius.*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>_empty_.Enums.Planet#radius.*/) def surfaceWeight/*<<=_empty_.Enums.Planet#surfaceWeight().*/(otherMass/*<<=_empty_.Enums.Planet#surfaceWeight().(otherMass)*/: Double/*=>>scala.Double#*/) = otherMass/*=>>_empty_.Enums.Planet#surfaceWeight().(otherMass)*/ */*=>>scala.Double#`*`(+6).*/ surfaceGravity/*=>>_empty_.Enums.Planet#surfaceGravity().*/ @@ -46,5 +41,3 @@ object Enums/*<<=_empty_.Enums.*/ { case Saturn/*<<=_empty_.Enums.Planet.Saturn.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*/ case Uranus/*<<=_empty_.Enums.Planet.Uranus.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*/ case Neptune/*<<=_empty_.Enums.Planet.Neptune.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*/ - } -} diff --git a/tests/semanticdb/Enums.scala b/tests/semanticdb/Enums.scala index e3b6a857087c..4856cb3a8c4c 100644 --- a/tests/semanticdb/Enums.scala +++ b/tests/semanticdb/Enums.scala @@ -1,9 +1,10 @@ -object Enums { - enum Colour { +object Enums with + import =:=._ + + enum Colour with case Red, Green, Blue - } - enum WeekDays { + enum WeekDays with case Monday case Tuesday case Wednesday @@ -11,29 +12,23 @@ object Enums { case Friday case Saturday case Sunday - } - enum Maybe[+A] { + enum Maybe[+A] with case Just(value: A) case None - } - enum Tag[A] { + enum Tag[A] with case IntTag extends Tag[Int] case BooleanTag extends Tag[Boolean] - } - enum =:=[A, B] { + enum =:=[A, B] with case Refl[C]() extends (C =:= C) - } - def unwrap[A,B](opt: Option[A])(given ev: A =:= Option[B]): Option[B] = { - ev match { - case =:=.Refl() => opt.flatMap(identity[Option[B]]) - } - } + def unwrap[A,B](opt: Option[A])(given ev: A =:= Option[B]): Option[B] = ev match + case Refl() => opt.flatMap(identity[Option[B]]) + case _ => None // TODO remove after https://github.com/lampepfl/dotty/issues/7524 is fixed - enum Planet(mass: Double, radius: Double) extends java.lang.Enum[Planet] { + enum Planet(mass: Double, radius: Double) extends java.lang.Enum[Planet] with private final val G = 6.67300E-11 def surfaceGravity = G * mass / (radius * radius) def surfaceWeight(otherMass: Double) = otherMass * surfaceGravity @@ -46,5 +41,3 @@ object Enums { case Saturn extends Planet(5.688e+26, 6.0268e7) case Uranus extends Planet(8.686e+25, 2.5559e7) case Neptune extends Planet(1.024e+26, 2.4746e7) - } -} diff --git a/tests/semanticdb/ImplicitConversion.expect.scala b/tests/semanticdb/ImplicitConversion.expect.scala index e67256448338..4aa1ac0661c7 100644 --- a/tests/semanticdb/ImplicitConversion.expect.scala +++ b/tests/semanticdb/ImplicitConversion.expect.scala @@ -3,12 +3,10 @@ package example import scala.language/*=>>scalaShadowing.language.*/.implicitConversions/*=>>scalaShadowing.language.implicitConversions.*/ class ImplicitConversion/*<<=example.ImplicitConversion#*/ { + import ImplicitConversion._ implicit def string2Number/*<<=example.ImplicitConversion#string2Number().*/( string/*<<=example.ImplicitConversion#string2Number().(string)*/: String/*=>>scala.Predef.String#*/ ): Int/*=>>scala.Int#*/ = 42 - implicit def newAny2StringAdd/*<<=example.ImplicitConversion#newAny2StringAdd().*/[T/*<<=example.ImplicitConversion#newAny2StringAdd().[T]*/]( - any/*<<=example.ImplicitConversion#newAny2StringAdd().(any)*/: T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/ - ): Predef/*=>>scala.Predef.*/.any2stringadd/*=>>scala.Predef.any2stringadd#*/[T/*=>>example.ImplicitConversion#newAny2StringAdd().[T]*/] = new Predef/*=>>scala.Predef.*/.any2stringadd/*=>>scala.Predef.any2stringadd#``().*/(any/*=>>example.ImplicitConversion#newAny2StringAdd().(any)*/) val message/*<<=example.ImplicitConversion#message.*/ = "" val number/*<<=example.ImplicitConversion#number.*/ = 42 val tuple/*<<=example.ImplicitConversion#tuple.*/ = (1, 2) @@ -17,7 +15,7 @@ class ImplicitConversion/*<<=example.ImplicitConversion#*/ { // extension methods /*=>>scala.Predef.augmentString().*/message/*=>>example.ImplicitConversion#message.*/ .stripSuffix/*=>>scala.collection.StringOps#stripSuffix().*/("h") - /*=>>example.ImplicitConversion#newAny2StringAdd().*/tuple/*=>>example.ImplicitConversion#tuple.*/ +/*=>>scala.Predef.any2stringadd#`+`().*/ "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.*/ @@ -31,3 +29,9 @@ class ImplicitConversion/*<<=example.ImplicitConversion#*/ { val a/*<<=example.ImplicitConversion#a.*/: Int/*=>>scala.Int#*/ = /*=>>scala.Char.char2int().*/char/*=>>example.ImplicitConversion#char.*/ val b/*<<=example.ImplicitConversion#b.*/: Long/*=>>scala.Long#*/ = /*=>>scala.Char.char2long().*/char/*=>>example.ImplicitConversion#char.*/ } + +object ImplicitConversion/*<<=example.ImplicitConversion.*/ { + implicit final class newAny2stringadd/*<<=example.ImplicitConversion.newAny2stringadd#*/[A/*<<=example.ImplicitConversion.newAny2stringadd#[A]*/](private val self/*<<=example.ImplicitConversion.newAny2stringadd#self.*/: A/*=>>example.ImplicitConversion.newAny2stringadd#``().[A]*/) extends AnyVal/*=>>scala.AnyVal#*//*=>>scala.AnyVal#``().*/ { + def +/*<<=example.ImplicitConversion.newAny2stringadd#`+`().*/(other/*<<=example.ImplicitConversion.newAny2stringadd#`+`().(other)*/: String/*=>>scala.Predef.String#*/): String/*=>>scala.Predef.String#*/ = String/*=>>java.lang.String#*/.valueOf/*=>>java.lang.String#valueOf().*/(self/*=>>example.ImplicitConversion.newAny2stringadd#self.*/) +/*=>>java.lang.String#`+`().*/ other/*=>>example.ImplicitConversion.newAny2stringadd#`+`().(other)*/ + } +} diff --git a/tests/semanticdb/ImplicitConversion.scala b/tests/semanticdb/ImplicitConversion.scala index dba524ab6e3f..fea8daa18bcd 100644 --- a/tests/semanticdb/ImplicitConversion.scala +++ b/tests/semanticdb/ImplicitConversion.scala @@ -3,12 +3,10 @@ package example import scala.language.implicitConversions class ImplicitConversion { + import ImplicitConversion._ implicit def string2Number( string: String ): Int = 42 - implicit def newAny2StringAdd[T]( - any: T - ): Predef.any2stringadd[T] = new Predef.any2stringadd(any) val message = "" val number = 42 val tuple = (1, 2) @@ -31,3 +29,9 @@ class ImplicitConversion { val a: Int = char val b: Long = char } + +object ImplicitConversion { + implicit final class newAny2stringadd[A](private val self: A) extends AnyVal { + def +(other: String): String = String.valueOf(self) + other + } +} diff --git a/tests/semanticdb/Synthetic.expect.scala b/tests/semanticdb/Synthetic.expect.scala index e9339903d7a1..cd7f65d7e81e 100644 --- a/tests/semanticdb/Synthetic.expect.scala +++ b/tests/semanticdb/Synthetic.expect.scala @@ -1,5 +1,7 @@ package example +import scala.language/*=>>scalaShadowing.language.*/.implicitConversions/*=>>scalaShadowing.language.implicitConversions.*/ + class Synthetic/*<<=example.Synthetic#*/ { List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1).map/*=>>scala.collection.immutable.List#map().*/(_ +/*=>>scala.Int#`+`(+4).*/ 2) /*=>>scala.Predef.intArrayOps().*/Array/*=>>scala.Array.*/.empty/*=>>scala.Array.empty().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer#TYPE.*/.headOption/*=>>scala.collection.ArrayOps#headOption().*/ @@ -7,11 +9,11 @@ class Synthetic/*<<=example.Synthetic#*/ { // See https://github.com/scalameta/scalameta/issues/977 val Name/*<<=example.Synthetic#Name.*/ = /*=>>scala.Predef.augmentString().*/"name:(.*)".r/*=>>scala.collection.StringOps#r().*/ - /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/val x/*<<=example.Synthetic#x.*/ #:: xs/*<<=example.Synthetic#xs.*/ = Stream(1, 2) + /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/val x/*<<=example.Synthetic#x.*/ #:: xs/*<<=example.Synthetic#xs.*/ = LazyList(1, 2) val Name/*=>>example.Synthetic#Name.*//*=>>scala.util.matching.Regex#unapplySeq().*/(name/*<<=example.Synthetic#name.*//*<<=local0*/)/*=>>local0*/ = "name:foo" - 1 #:: /*=>>scala.collection.immutable.Stream.toDeferrer().*/2 #:: /*=>>scala.collection.immutable.Stream.toDeferrer().*/Stream/*=>>scala.package.Stream.*/.empty/*=>>scala.collection.immutable.Stream.empty().*//*=>>scala.collection.immutable.Stream.Deferrer#`#::`().*/ + 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 #:: /*=>>scala.collection.immutable.Stream.toDeferrer().*/2 #:: /*=>>scala.collection.immutable.Stream.toDeferrer().*/Stream/*=>>scala.package.Stream.*/.empty/*=>>scala.collection.immutable.Stream.empty().*//*=>>scala.collection.immutable.Stream.Deferrer#`#::`().*/ + val lst/*<<=example.Synthetic#lst.*/ = 1 #:: /*=>>scala.collection.immutable.LazyList.toDeferrer().*/2 #:: /*=>>scala.collection.immutable.LazyList.toDeferrer().*/LazyList/*=>>scala.package.LazyList.*/.empty/*=>>scala.collection.immutable.LazyList.empty().*//*=>>scala.collection.immutable.LazyList.Deferrer#`#::`().*/ for (x <- /*=>>scala.LowPriorityImplicits#intWrapper().*/1 to/*=>>scala.runtime.RichInt#to().*/ 10/*=>>scala.collection.immutable.Range#foreach().*/; y <- /*=>>scala.LowPriorityImplicits#intWrapper().*/0 until/*=>>scala.runtime.RichInt#until().*/ 10/*=>>scala.collection.immutable.Range#foreach().*/) println/*=>>scala.Predef.println(+1).*/(x/*=>>local1*/ ->/*=>>scala.Predef.ArrowAssoc#`->`().*/ x/*=>>local1*/) for (i <- /*=>>scala.LowPriorityImplicits#intWrapper().*/1 to/*=>>scala.runtime.RichInt#to().*/ 10/*=>>scala.collection.StrictOptimizedIterableOps#flatMap().*/; j <- /*=>>scala.LowPriorityImplicits#intWrapper().*/0 until/*=>>scala.runtime.RichInt#until().*/ 10/*=>>scala.collection.immutable.Range#map().*/) yield (i/*=>>local2*/, j/*=>>local3*/) diff --git a/tests/semanticdb/Synthetic.scala b/tests/semanticdb/Synthetic.scala index 5c7fb3519e51..05fc74619078 100644 --- a/tests/semanticdb/Synthetic.scala +++ b/tests/semanticdb/Synthetic.scala @@ -1,5 +1,7 @@ package example +import scala.language.implicitConversions + class Synthetic { List(1).map(_ + 2) Array.empty[Int].headOption @@ -7,11 +9,11 @@ class Synthetic { // See https://github.com/scalameta/scalameta/issues/977 val Name = "name:(.*)".r - val x #:: xs = Stream(1, 2) + val x #:: xs = LazyList(1, 2) val Name(name) = "name:foo" - 1 #:: 2 #:: Stream.empty + 1 #:: 2 #:: LazyList.empty - val lst = 1 #:: 2 #:: Stream.empty + val lst = 1 #:: 2 #:: LazyList.empty for (x <- 1 to 10; y <- 0 until 10) println(x -> x) for (i <- 1 to 10; j <- 0 until 10) yield (i, j) From 78b48e4317446caea1ec5ad05ea8d7c8ebbfc2bd Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 12 Nov 2019 11:49:07 +0100 Subject: [PATCH 049/107] Introduce semanticdb Scala object for common definitions --- .../dotc/semanticdb/ExtractSemanticDB.scala | 22 +++++++++---------- .../dotty/tools/dotc/semanticdb/Scala.scala | 11 ++++++++++ .../dotc/semanticdb/SemanticdbTests.scala | 11 ++++------ 3 files changed, 26 insertions(+), 18 deletions(-) create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/Scala.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 308fe13c60a0..f7fff4005679 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -63,6 +63,7 @@ class ExtractSemanticDB extends Phase { /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = + import Scala._ def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) @@ -75,8 +76,8 @@ class ExtractSemanticDB extends Phase { def addName(name: Name) = val str = name.unescapeUnicode - if isJavaIdent(str) then b.append(str) - else b.append('`').append(str).append('`') + if isJavaIdent(str) then b `append` str + else b append '`' append str append '`' /** Is symbol global? Non-global symbols get localX names */ def isGlobal(sym: Symbol): Boolean = @@ -108,15 +109,14 @@ class ExtractSemanticDB extends Phase { 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.isPackageObject) then + b.append(Symbols.PackageObjectDescriptor) else - if sym.isRoot then - b.append("_root_") - else if sym.isEmptyPackage then - b.append("_empty_") - else if (sym.isPackageObject) then - b.append("package") - else - addName(sym.name) + 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) @@ -143,7 +143,7 @@ class ExtractSemanticDB extends Phase { if isGlobal(sym) then addOwner(sym.owner); addDescriptor(sym) else - b.append("local").append(localIdx(sym)) + b.append(Symbols.LocalPrefix).append(localIdx(sym)) end addSymName diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala new file mode 100644 index 000000000000..13699b2d3dcf --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala @@ -0,0 +1,11 @@ +package dotty.tools.dotc.semanticdb + +object Scala with + + object Symbols with + + val NoSymbol: String = "" + val RootPackage: String = "_root_/" + val EmptyPackage: String = "_empty_/" + val LocalPrefix: String = "local" + val PackageObjectDescriptor: String = "package." diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index e237092e00aa..2a5f123f9663 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -17,11 +17,11 @@ import dotty.BootstrappedOnlyTests import dotty.tools.dotc.Main import dotty.tools.dotc.semanticdb.DiffAssertions._ -@main def updateExpect() = - new SemanticdbTests().runExpectTest(updateExpectFiles = true) +@main def updateExpect = + SemanticdbTests().runExpectTest(updateExpectFiles = true) @Category(Array(classOf[BootstrappedOnlyTests])) -class SemanticdbTests { +class SemanticdbTests with val scalaFile = FileSystems.getDefault.getPathMatcher("glob:**.scala") val expectFile = FileSystems.getDefault.getPathMatcher("glob:**.expect.scala") // val semanticdbFile = FileSystems.getDefault.getPathMatcher("glob:**.scala.semanticdb") @@ -75,8 +75,5 @@ class SemanticdbTests { "-usejavacp", ) ++ inputFiles().map(_.toString) val exit = Main.process(args) - if (exit.hasErrors) - sys.error(s"dotc errors: ${exit.errorCount}") + assertFalse(s"dotc errors: ${exit.errorCount}", exit.hasErrors) target - -} From 3b78f2600666beddb8b3314bc10ddf60f95a6e3a Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 12 Nov 2019 11:58:24 +0100 Subject: [PATCH 050/107] move java sources to test-bootstrapped --- .../dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java | 0 .../dotty/tools/dotc/semanticdb/com/javacp/Coin.java | 0 .../dotty/tools/dotc/semanticdb/com/javacp/Interface.java | 0 .../dotty/tools/dotc/semanticdb/com/javacp/Logger.java | 0 .../dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java | 0 .../dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java | 0 .../dotty/tools/dotc/semanticdb/com/javacp/Recursive.java | 0 .../dotty/tools/dotc/semanticdb/com/javacp/Test.java | 0 .../tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java | 0 .../dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java | 0 .../tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java | 0 .../dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java | 0 .../tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java | 0 .../tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java | 0 .../tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java | 0 .../tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java | 0 .../dotc/semanticdb/com/javacp/annot/PackageAnnotation.java | 0 .../semanticdb/com/javacp/annot/PackageObjectAnnotation.java | 0 .../dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java | 0 .../semanticdb/com/javacp/annot/SelfParameterAnnotation.java | 0 .../tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java | 0 .../tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java | 0 .../semanticdb/com/javacp/annot/TypeParameterAnnotation.java | 0 .../semanticdb/com/javacp/annot/usage/AnnotatedInterface.java | 0 .../dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java | 0 project/Build.scala | 1 + 26 files changed, 1 insertion(+) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/Coin.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/Interface.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/Logger.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/Test.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java (100%) rename compiler/{test => test-bootstrapped}/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java (100%) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Coin.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Coin.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Coin.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Coin.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Interface.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Interface.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Interface.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Interface.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Logger.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Logger.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Logger.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Logger.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Test.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Test.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/Test.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Test.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java diff --git a/compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java b/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java similarity index 100% rename from compiler/test/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java rename to compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java diff --git a/project/Build.scala b/project/Build.scala index b6efdc575885..03d305cbccc8 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -271,6 +271,7 @@ object Build { // Settings used when compiling dotty with a non-bootstrapped dotty lazy val commonBootstrappedSettings = commonDottySettings ++ Seq( unmanagedSourceDirectories in Compile += baseDirectory.value / "src-bootstrapped", + unmanagedSourceDirectories in Test += baseDirectory.value / "test-bootstrapped", version := dottyVersion, scalaVersion := dottyNonBootstrappedVersion, From 4c8aed0510ef12145b148b3ac6e6c288697836e5 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 12 Nov 2019 15:33:39 +0100 Subject: [PATCH 051/107] only skip package symbols when printing expect output --- .../dotc/semanticdb/ExtractSemanticDB.scala | 14 +++------- .../dotty/tools/dotc/semanticdb/Scala.scala | 28 +++++++++++++++++++ .../dotc/semanticdb/DiffAssertions.scala | 19 ++++++------- .../dotc/semanticdb/SemanticdbTests.scala | 25 +++++++++++++---- .../tools/dotc/semanticdb/Semanticdbs.scala | 10 ++++--- project/Build.scala | 4 +++ .../{ => expect}/Access.expect.scala | 0 tests/semanticdb/{ => expect}/Access.scala | 0 .../{ => expect}/Advanced.expect.scala | 0 tests/semanticdb/{ => expect}/Advanced.scala | 0 .../{ => expect}/Annotations.expect.scala | 0 .../semanticdb/{ => expect}/Annotations.scala | 0 .../{ => expect}/Anonymous.expect.scala | 0 tests/semanticdb/{ => expect}/Anonymous.scala | 0 .../{ => expect}/Classes.expect.scala | 0 tests/semanticdb/{ => expect}/Classes.scala | 0 .../{ => expect}/Definitions.expect.scala | 0 .../semanticdb/{ => expect}/Definitions.scala | 0 .../{ => expect}/Empty.expect.scala | 0 tests/semanticdb/{ => expect}/Empty.scala | 0 .../{ => expect}/EmptyObject.expect.scala | 0 .../semanticdb/{ => expect}/EmptyObject.scala | 0 .../{ => expect}/Enums.expect.scala | 0 tests/semanticdb/{ => expect}/Enums.scala | 0 .../{ => expect}/EtaExpansion.expect.scala | 0 .../{ => expect}/EtaExpansion.scala | 0 .../{ => expect}/Example.expect.scala | 0 tests/semanticdb/{ => expect}/Example.scala | 0 .../{ => expect}/Flags.expect.scala | 0 tests/semanticdb/{ => expect}/Flags.scala | 0 .../ForComprehension.expect.scala | 0 .../{ => expect}/ForComprehension.scala | 0 .../{ => expect}/Givens.expect.scala | 0 tests/semanticdb/{ => expect}/Givens.scala | 0 .../ImplicitConversion.expect.scala | 0 .../{ => expect}/ImplicitConversion.scala | 0 .../{ => expect}/Imports.expect.scala | 0 tests/semanticdb/{ => expect}/Imports.scala | 0 .../{ => expect}/InstrumentTyper.expect.scala | 0 .../{ => expect}/InstrumentTyper.scala | 0 .../{ => expect}/Issue1749.expect.scala | 0 tests/semanticdb/{ => expect}/Issue1749.scala | 0 .../{ => expect}/Local.expect.scala | 0 tests/semanticdb/{ => expect}/Local.scala | 0 .../{ => expect}/Locals.expect.scala | 0 tests/semanticdb/{ => expect}/Locals.scala | 0 .../{ => expect}/MetacJava.expect.scala | 0 tests/semanticdb/{ => expect}/MetacJava.scala | 0 .../{ => expect}/MethodUsages.expect.scala | 0 .../{ => expect}/MethodUsages.scala | 0 .../{ => expect}/Methods.expect.scala | 0 tests/semanticdb/{ => expect}/Methods.scala | 0 .../{ => expect}/NamedApplyBlock.expect.scala | 0 .../{ => expect}/NamedApplyBlock.scala | 0 .../{ => expect}/NamedArguments.expect.scala | 0 .../{ => expect}/NamedArguments.scala | 0 .../{ => expect}/NewModifiers.expect.scala | 0 .../{ => expect}/NewModifiers.scala | 0 .../{ => expect}/Objects.expect.scala | 0 tests/semanticdb/{ => expect}/Objects.scala | 0 .../{ => expect}/Overrides.expect.scala | 0 tests/semanticdb/{ => expect}/Overrides.scala | 0 .../{ => expect}/Prefixes.expect.scala | 0 tests/semanticdb/{ => expect}/Prefixes.scala | 0 .../{ => expect}/Selfs.expect.scala | 0 tests/semanticdb/{ => expect}/Selfs.scala | 0 .../{ => expect}/Synthetic.expect.scala | 0 tests/semanticdb/{ => expect}/Synthetic.scala | 0 .../{ => expect}/Traits.expect.scala | 0 tests/semanticdb/{ => expect}/Traits.scala | 0 .../{ => expect}/Types.expect.scala | 0 tests/semanticdb/{ => expect}/Types.scala | 0 .../{ => expect}/ValPattern.expect.scala | 0 .../semanticdb/{ => expect}/ValPattern.scala | 0 .../semanticdb/{ => expect}/Vals.expect.scala | 0 tests/semanticdb/{ => expect}/Vals.scala | 0 .../{ => expect}/Vararg.expect.scala | 0 tests/semanticdb/{ => expect}/Vararg.scala | 0 .../filename with spaces.expect.scala | 0 .../{ => expect}/filename with spaces.scala | 0 .../{ => expect}/local-file.expect.scala | 0 .../semanticdb/{ => expect}/local-file.scala | 0 .../semanticdb-extract.expect.scala | 0 .../{ => expect}/semanticdb-extract.scala | 0 .../{ => expect}/toplevel.expect.scala | 0 tests/semanticdb/{ => expect}/toplevel.scala | 0 86 files changed, 70 insertions(+), 30 deletions(-) rename tests/semanticdb/{ => expect}/Access.expect.scala (100%) rename tests/semanticdb/{ => expect}/Access.scala (100%) rename tests/semanticdb/{ => expect}/Advanced.expect.scala (100%) rename tests/semanticdb/{ => expect}/Advanced.scala (100%) rename tests/semanticdb/{ => expect}/Annotations.expect.scala (100%) rename tests/semanticdb/{ => expect}/Annotations.scala (100%) rename tests/semanticdb/{ => expect}/Anonymous.expect.scala (100%) rename tests/semanticdb/{ => expect}/Anonymous.scala (100%) rename tests/semanticdb/{ => expect}/Classes.expect.scala (100%) rename tests/semanticdb/{ => expect}/Classes.scala (100%) rename tests/semanticdb/{ => expect}/Definitions.expect.scala (100%) rename tests/semanticdb/{ => expect}/Definitions.scala (100%) rename tests/semanticdb/{ => expect}/Empty.expect.scala (100%) rename tests/semanticdb/{ => expect}/Empty.scala (100%) rename tests/semanticdb/{ => expect}/EmptyObject.expect.scala (100%) rename tests/semanticdb/{ => expect}/EmptyObject.scala (100%) rename tests/semanticdb/{ => expect}/Enums.expect.scala (100%) rename tests/semanticdb/{ => expect}/Enums.scala (100%) rename tests/semanticdb/{ => expect}/EtaExpansion.expect.scala (100%) rename tests/semanticdb/{ => expect}/EtaExpansion.scala (100%) rename tests/semanticdb/{ => expect}/Example.expect.scala (100%) rename tests/semanticdb/{ => expect}/Example.scala (100%) rename tests/semanticdb/{ => expect}/Flags.expect.scala (100%) rename tests/semanticdb/{ => expect}/Flags.scala (100%) rename tests/semanticdb/{ => expect}/ForComprehension.expect.scala (100%) rename tests/semanticdb/{ => expect}/ForComprehension.scala (100%) rename tests/semanticdb/{ => expect}/Givens.expect.scala (100%) rename tests/semanticdb/{ => expect}/Givens.scala (100%) rename tests/semanticdb/{ => expect}/ImplicitConversion.expect.scala (100%) rename tests/semanticdb/{ => expect}/ImplicitConversion.scala (100%) rename tests/semanticdb/{ => expect}/Imports.expect.scala (100%) rename tests/semanticdb/{ => expect}/Imports.scala (100%) rename tests/semanticdb/{ => expect}/InstrumentTyper.expect.scala (100%) rename tests/semanticdb/{ => expect}/InstrumentTyper.scala (100%) rename tests/semanticdb/{ => expect}/Issue1749.expect.scala (100%) rename tests/semanticdb/{ => expect}/Issue1749.scala (100%) rename tests/semanticdb/{ => expect}/Local.expect.scala (100%) rename tests/semanticdb/{ => expect}/Local.scala (100%) rename tests/semanticdb/{ => expect}/Locals.expect.scala (100%) rename tests/semanticdb/{ => expect}/Locals.scala (100%) rename tests/semanticdb/{ => expect}/MetacJava.expect.scala (100%) rename tests/semanticdb/{ => expect}/MetacJava.scala (100%) rename tests/semanticdb/{ => expect}/MethodUsages.expect.scala (100%) rename tests/semanticdb/{ => expect}/MethodUsages.scala (100%) rename tests/semanticdb/{ => expect}/Methods.expect.scala (100%) rename tests/semanticdb/{ => expect}/Methods.scala (100%) rename tests/semanticdb/{ => expect}/NamedApplyBlock.expect.scala (100%) rename tests/semanticdb/{ => expect}/NamedApplyBlock.scala (100%) rename tests/semanticdb/{ => expect}/NamedArguments.expect.scala (100%) rename tests/semanticdb/{ => expect}/NamedArguments.scala (100%) rename tests/semanticdb/{ => expect}/NewModifiers.expect.scala (100%) rename tests/semanticdb/{ => expect}/NewModifiers.scala (100%) rename tests/semanticdb/{ => expect}/Objects.expect.scala (100%) rename tests/semanticdb/{ => expect}/Objects.scala (100%) rename tests/semanticdb/{ => expect}/Overrides.expect.scala (100%) rename tests/semanticdb/{ => expect}/Overrides.scala (100%) rename tests/semanticdb/{ => expect}/Prefixes.expect.scala (100%) rename tests/semanticdb/{ => expect}/Prefixes.scala (100%) rename tests/semanticdb/{ => expect}/Selfs.expect.scala (100%) rename tests/semanticdb/{ => expect}/Selfs.scala (100%) rename tests/semanticdb/{ => expect}/Synthetic.expect.scala (100%) rename tests/semanticdb/{ => expect}/Synthetic.scala (100%) rename tests/semanticdb/{ => expect}/Traits.expect.scala (100%) rename tests/semanticdb/{ => expect}/Traits.scala (100%) rename tests/semanticdb/{ => expect}/Types.expect.scala (100%) rename tests/semanticdb/{ => expect}/Types.scala (100%) rename tests/semanticdb/{ => expect}/ValPattern.expect.scala (100%) rename tests/semanticdb/{ => expect}/ValPattern.scala (100%) rename tests/semanticdb/{ => expect}/Vals.expect.scala (100%) rename tests/semanticdb/{ => expect}/Vals.scala (100%) rename tests/semanticdb/{ => expect}/Vararg.expect.scala (100%) rename tests/semanticdb/{ => expect}/Vararg.scala (100%) rename tests/semanticdb/{ => expect}/filename with spaces.expect.scala (100%) rename tests/semanticdb/{ => expect}/filename with spaces.scala (100%) rename tests/semanticdb/{ => expect}/local-file.expect.scala (100%) rename tests/semanticdb/{ => expect}/local-file.scala (100%) rename tests/semanticdb/{ => expect}/semanticdb-extract.expect.scala (100%) rename tests/semanticdb/{ => expect}/semanticdb-extract.scala (100%) rename tests/semanticdb/{ => expect}/toplevel.expect.scala (100%) rename tests/semanticdb/{ => expect}/toplevel.scala (100%) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index f7fff4005679..1927a65d3b1b 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -180,9 +180,6 @@ class ExtractSemanticDB extends Phase { private def excludeDefStrict(sym: Symbol)(given Context): Boolean = sym.name.is(NameKinds.DefaultGetterName) - private def blacklistPrefix(sym: Symbol)(given Context): Boolean = - sym.is(Package) - private def (sym: Symbol) isAnonymous(given Context): Boolean = sym.isAnonymousClass || sym.isAnonymousModuleVal @@ -210,8 +207,7 @@ class ExtractSemanticDB extends Phase { def registerPath(expr: Tree): Unit = expr match case t @ Select(expr, _) => registerUse(t.symbol, t.span) - if !blacklistPrefix(expr.symbol) then - registerPath(expr) + registerPath(expr) case _ => @@ -259,22 +255,20 @@ class ExtractSemanticDB extends Phase { if source.content()(end - 1) == '`' then end - len - 1 else end - len else limit registerUse(tree.symbol, Span(start max limit, end)) - if !blacklistPrefix(tree.qualifier.symbol) && qualSpan.exists && qualSpan.start != qualSpan.end then + if qualSpan.exists && qualSpan.start != qualSpan.end then traverseChildren(tree) case tree: Import => if tree.span.exists && tree.span.start != tree.span.end then for sel <- tree.selectors do val imported = sel.imported.name if imported != nme.WILDCARD then - for alt <- tree.expr.tpe.member(imported).alternatives if !alt.symbol.is(Package) do + for alt <- tree.expr.tpe.member(imported).alternatives do registerUse(alt.symbol, sel.imported.span) if (alt.symbol.companionClass.exists) registerUse(alt.symbol.companionClass, sel.imported.span) - if !blacklistPrefix(tree.expr.symbol) then - registerPath(tree.expr) + registerPath(tree.expr) case tree: Inlined => traverse(tree.call) - case tree: PackageDef => tree.stats.foreach(traverse) case tree: Annotated => // skip the annotation (see `@param` in https://github.com/scalameta/scalameta/blob/633824474e99bbfefe12ad0cc73da1fe064b3e9b/tests/jvm/src/test/resources/example/Annotations.scala#L37) traverse(tree.arg) case _ => diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala index 13699b2d3dcf..467c8a52dcc6 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala @@ -9,3 +9,31 @@ object Scala with val EmptyPackage: String = "_empty_/" val LocalPrefix: String = "local" val PackageObjectDescriptor: String = "package." + + given (symbol: String) with + + def isNoSymbol: Boolean = + symbol == Symbols.NoSymbol + def isRootPackage: Boolean = + symbol == Symbols.RootPackage + def isEmptyPackage: Boolean = + symbol == Symbols.EmptyPackage + def isGlobal: Boolean = + !symbol.isNoSymbol && !symbol.isMulti && (symbol.last match { + case '.' | '#' | '/' | ')' | ']' => true + case _ => false + }) + def isLocal: Boolean = + symbol.startsWith(Symbols.LocalPrefix) + def isMulti: Boolean = + symbol.startsWith(";") + def isTerm: Boolean = + !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '.' + def isType: Boolean = + !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '#' + def isPackage: Boolean = + !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '/' + def isParameter: Boolean = + !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ')' + def isTypeParameter: Boolean = + !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ']' diff --git a/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala b/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala index fce88c3b1b45..fbe9025ed4ac 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala @@ -1,30 +1,29 @@ package dotty.tools.dotc.semanticdb import scala.collection.JavaConverters._ -import org.junit.Assert._ object DiffAssertions { - def assertNoDiff(obtained: String, expected: String): Unit = - val diff = compareContents(obtained, expected) + def collectFailingDiff(obtained: String, expected: String, obtainedPath: String, expectedPath: String)(onFail: String => Unit): Unit = + val diff = compareContents(obtained, expected, obtainedPath, expectedPath) if diff.nonEmpty then - fail(diff) + onFail(diff) private def stripTrailingWhitespace(str: String): String = str.replaceAll(" \n", "∙\n") private def splitIntoLines(string: String): Seq[String] = string.trim.replace("\r\n", "\n").split("\n").toSeq - private def compareContents(original: String, revised: String): String = - compareContents(splitIntoLines(original), splitIntoLines(revised)) + private def compareContents(original: String, revised: String, obtainedPath: String, expectedPath: String): String = + compareContents(splitIntoLines(original), splitIntoLines(revised), obtainedPath, expectedPath) - private def compareContents(original: Seq[String], revised: Seq[String]): String = { + private def compareContents(original: Seq[String], revised: Seq[String], obtainedPath: String, expectedPath: String): String = { val diff = difflib.DiffUtils.diff(original.asJava, revised.asJava) if (diff.getDeltas.isEmpty) "" else difflib.DiffUtils .generateUnifiedDiff( - "obtained", - "expected", + obtainedPath, + expectedPath, original.asJava, diff, 1 @@ -32,4 +31,4 @@ object DiffAssertions { .asScala .mkString("\n") } -} \ No newline at end of file +} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 2a5f123f9663..c7987bb42e15 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -6,7 +6,9 @@ import java.io.File import java.nio.file._ import java.nio.charset.StandardCharsets import java.util.stream.Collectors +import java.util.Comparator import scala.util.control.NonFatal +import scala.collection.mutable import scala.jdk.CollectionConverters._ import org.junit.Assert._ @@ -25,16 +27,17 @@ class SemanticdbTests with val scalaFile = FileSystems.getDefault.getPathMatcher("glob:**.scala") val expectFile = FileSystems.getDefault.getPathMatcher("glob:**.expect.scala") // val semanticdbFile = FileSystems.getDefault.getPathMatcher("glob:**.scala.semanticdb") - val src = Paths.get(System.getProperty("user.dir")).resolve("tests").resolve("semanticdb") + val expectSrc = Paths.get(System.getProperty("dotty.tools.dotc.semanticdb.test.expect")) @Category(Array(classOf[dotty.SlowTests])) @Test def expectTests: Unit = runExpectTest(updateExpectFiles = false) def runExpectTest(updateExpectFiles: Boolean): Unit = val target = generateSemanticdb() + val errors = mutable.ArrayBuffer.empty[(Path, String)] inputFiles().foreach { source => val filename = source.getFileName.toString - val relpath = src.relativize(source) + val relpath = expectSrc.relativize(source) val semanticdbPath = target .resolve("META-INF") .resolve("semanticdb") @@ -48,18 +51,28 @@ class SemanticdbTests with println("updated: " + expectPath) else val expected = new String(Files.readAllBytes(expectPath), StandardCharsets.UTF_8) - assertNoDiff(obtained, expected) + val expectName = expectPath.getFileName + val relExpect = expectSrc.relativize(expectPath) + collectFailingDiff(obtained, expected, s"a/$relExpect", s"b/$relExpect")(errors += expectName -> _) } + errors.foreach { (source, diff) => + def red(msg: String) = Console.RED + msg + Console.RESET + def blue(msg: String) = Console.BLUE + msg + Console.RESET + println(s"[${red("error")}] check file ${blue(source.toString)} does not match generated:\n${red(diff)}") + } + Files.walk(target).sorted(Comparator.reverseOrder).forEach(Files.delete) + if errors.nonEmpty + fail(s"${errors.size} errors in expect test.") def trimTrailingWhitespace(s: String): String = Pattern.compile(" +$", Pattern.MULTILINE).matcher(s).replaceAll("") def inputFiles(): List[Path] = - val ls = Files.walk(src) + val ls = Files.walk(expectSrc) val files = try ls.filter(p => scalaFile.matches(p) && !expectFile.matches(p)).collect(Collectors.toList).asScala finally ls.close() - require(files.nonEmpty, s"No input files! $src") + require(files.nonEmpty, s"No input files! $expectSrc") files.toList def generateSemanticdb(): Path = @@ -71,7 +84,7 @@ class SemanticdbTests with "-deprecation", // "-Ydebug", // "-Xprint:extractSemanticDB", - "-sourceroot", src.toString, + "-sourceroot", expectSrc.toString, "-usejavacp", ) ++ inputFiles().map(_.toString) val exit = Main.process(args) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index be549291ea07..1260b659edac 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -4,6 +4,7 @@ import java.nio.file._ import java.nio.charset.StandardCharsets import scala.collection.JavaConverters._ import dotty.tools.dotc.util.SourceFile +import dotty.tools.dotc.semanticdb.Scala.{_, given} object Semanticdbs { @@ -67,10 +68,11 @@ object Semanticdbs { sourceFile.lineToOffset(range.endLine) + range.endCharacter ) sb.append(doc.text.substring(offset, end)) - .append("/*") - .append(if (occ.role.isDefinition) "<<=" else "=>>") - .append(occ.symbol.replace('/', '.')) - .append("*/") + if !occ.symbol.isPackage + sb.append("/*") + .append(if (occ.role.isDefinition) "<<=" else "=>>") + .append(occ.symbol.replace('/', '.')) + .append("*/") offset = end } sb.append(doc.text.substring(offset)) diff --git a/project/Build.scala b/project/Build.scala index 03d305cbccc8..c0f38317c80f 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -552,6 +552,10 @@ object Build { ) }, + javaOptions += ( + s"-Ddotty.tools.dotc.semanticdb.test.expect=${(ThisBuild / baseDirectory).value/"tests"/"semanticdb"/"expect"}" + ), + testCompilation := Def.inputTaskDyn { val args = spaceDelimited("").parsed if (args.contains("--help")) { diff --git a/tests/semanticdb/Access.expect.scala b/tests/semanticdb/expect/Access.expect.scala similarity index 100% rename from tests/semanticdb/Access.expect.scala rename to tests/semanticdb/expect/Access.expect.scala diff --git a/tests/semanticdb/Access.scala b/tests/semanticdb/expect/Access.scala similarity index 100% rename from tests/semanticdb/Access.scala rename to tests/semanticdb/expect/Access.scala diff --git a/tests/semanticdb/Advanced.expect.scala b/tests/semanticdb/expect/Advanced.expect.scala similarity index 100% rename from tests/semanticdb/Advanced.expect.scala rename to tests/semanticdb/expect/Advanced.expect.scala diff --git a/tests/semanticdb/Advanced.scala b/tests/semanticdb/expect/Advanced.scala similarity index 100% rename from tests/semanticdb/Advanced.scala rename to tests/semanticdb/expect/Advanced.scala diff --git a/tests/semanticdb/Annotations.expect.scala b/tests/semanticdb/expect/Annotations.expect.scala similarity index 100% rename from tests/semanticdb/Annotations.expect.scala rename to tests/semanticdb/expect/Annotations.expect.scala diff --git a/tests/semanticdb/Annotations.scala b/tests/semanticdb/expect/Annotations.scala similarity index 100% rename from tests/semanticdb/Annotations.scala rename to tests/semanticdb/expect/Annotations.scala diff --git a/tests/semanticdb/Anonymous.expect.scala b/tests/semanticdb/expect/Anonymous.expect.scala similarity index 100% rename from tests/semanticdb/Anonymous.expect.scala rename to tests/semanticdb/expect/Anonymous.expect.scala diff --git a/tests/semanticdb/Anonymous.scala b/tests/semanticdb/expect/Anonymous.scala similarity index 100% rename from tests/semanticdb/Anonymous.scala rename to tests/semanticdb/expect/Anonymous.scala diff --git a/tests/semanticdb/Classes.expect.scala b/tests/semanticdb/expect/Classes.expect.scala similarity index 100% rename from tests/semanticdb/Classes.expect.scala rename to tests/semanticdb/expect/Classes.expect.scala diff --git a/tests/semanticdb/Classes.scala b/tests/semanticdb/expect/Classes.scala similarity index 100% rename from tests/semanticdb/Classes.scala rename to tests/semanticdb/expect/Classes.scala diff --git a/tests/semanticdb/Definitions.expect.scala b/tests/semanticdb/expect/Definitions.expect.scala similarity index 100% rename from tests/semanticdb/Definitions.expect.scala rename to tests/semanticdb/expect/Definitions.expect.scala diff --git a/tests/semanticdb/Definitions.scala b/tests/semanticdb/expect/Definitions.scala similarity index 100% rename from tests/semanticdb/Definitions.scala rename to tests/semanticdb/expect/Definitions.scala diff --git a/tests/semanticdb/Empty.expect.scala b/tests/semanticdb/expect/Empty.expect.scala similarity index 100% rename from tests/semanticdb/Empty.expect.scala rename to tests/semanticdb/expect/Empty.expect.scala diff --git a/tests/semanticdb/Empty.scala b/tests/semanticdb/expect/Empty.scala similarity index 100% rename from tests/semanticdb/Empty.scala rename to tests/semanticdb/expect/Empty.scala diff --git a/tests/semanticdb/EmptyObject.expect.scala b/tests/semanticdb/expect/EmptyObject.expect.scala similarity index 100% rename from tests/semanticdb/EmptyObject.expect.scala rename to tests/semanticdb/expect/EmptyObject.expect.scala diff --git a/tests/semanticdb/EmptyObject.scala b/tests/semanticdb/expect/EmptyObject.scala similarity index 100% rename from tests/semanticdb/EmptyObject.scala rename to tests/semanticdb/expect/EmptyObject.scala diff --git a/tests/semanticdb/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala similarity index 100% rename from tests/semanticdb/Enums.expect.scala rename to tests/semanticdb/expect/Enums.expect.scala diff --git a/tests/semanticdb/Enums.scala b/tests/semanticdb/expect/Enums.scala similarity index 100% rename from tests/semanticdb/Enums.scala rename to tests/semanticdb/expect/Enums.scala diff --git a/tests/semanticdb/EtaExpansion.expect.scala b/tests/semanticdb/expect/EtaExpansion.expect.scala similarity index 100% rename from tests/semanticdb/EtaExpansion.expect.scala rename to tests/semanticdb/expect/EtaExpansion.expect.scala diff --git a/tests/semanticdb/EtaExpansion.scala b/tests/semanticdb/expect/EtaExpansion.scala similarity index 100% rename from tests/semanticdb/EtaExpansion.scala rename to tests/semanticdb/expect/EtaExpansion.scala diff --git a/tests/semanticdb/Example.expect.scala b/tests/semanticdb/expect/Example.expect.scala similarity index 100% rename from tests/semanticdb/Example.expect.scala rename to tests/semanticdb/expect/Example.expect.scala diff --git a/tests/semanticdb/Example.scala b/tests/semanticdb/expect/Example.scala similarity index 100% rename from tests/semanticdb/Example.scala rename to tests/semanticdb/expect/Example.scala diff --git a/tests/semanticdb/Flags.expect.scala b/tests/semanticdb/expect/Flags.expect.scala similarity index 100% rename from tests/semanticdb/Flags.expect.scala rename to tests/semanticdb/expect/Flags.expect.scala diff --git a/tests/semanticdb/Flags.scala b/tests/semanticdb/expect/Flags.scala similarity index 100% rename from tests/semanticdb/Flags.scala rename to tests/semanticdb/expect/Flags.scala diff --git a/tests/semanticdb/ForComprehension.expect.scala b/tests/semanticdb/expect/ForComprehension.expect.scala similarity index 100% rename from tests/semanticdb/ForComprehension.expect.scala rename to tests/semanticdb/expect/ForComprehension.expect.scala diff --git a/tests/semanticdb/ForComprehension.scala b/tests/semanticdb/expect/ForComprehension.scala similarity index 100% rename from tests/semanticdb/ForComprehension.scala rename to tests/semanticdb/expect/ForComprehension.scala diff --git a/tests/semanticdb/Givens.expect.scala b/tests/semanticdb/expect/Givens.expect.scala similarity index 100% rename from tests/semanticdb/Givens.expect.scala rename to tests/semanticdb/expect/Givens.expect.scala diff --git a/tests/semanticdb/Givens.scala b/tests/semanticdb/expect/Givens.scala similarity index 100% rename from tests/semanticdb/Givens.scala rename to tests/semanticdb/expect/Givens.scala diff --git a/tests/semanticdb/ImplicitConversion.expect.scala b/tests/semanticdb/expect/ImplicitConversion.expect.scala similarity index 100% rename from tests/semanticdb/ImplicitConversion.expect.scala rename to tests/semanticdb/expect/ImplicitConversion.expect.scala diff --git a/tests/semanticdb/ImplicitConversion.scala b/tests/semanticdb/expect/ImplicitConversion.scala similarity index 100% rename from tests/semanticdb/ImplicitConversion.scala rename to tests/semanticdb/expect/ImplicitConversion.scala diff --git a/tests/semanticdb/Imports.expect.scala b/tests/semanticdb/expect/Imports.expect.scala similarity index 100% rename from tests/semanticdb/Imports.expect.scala rename to tests/semanticdb/expect/Imports.expect.scala diff --git a/tests/semanticdb/Imports.scala b/tests/semanticdb/expect/Imports.scala similarity index 100% rename from tests/semanticdb/Imports.scala rename to tests/semanticdb/expect/Imports.scala diff --git a/tests/semanticdb/InstrumentTyper.expect.scala b/tests/semanticdb/expect/InstrumentTyper.expect.scala similarity index 100% rename from tests/semanticdb/InstrumentTyper.expect.scala rename to tests/semanticdb/expect/InstrumentTyper.expect.scala diff --git a/tests/semanticdb/InstrumentTyper.scala b/tests/semanticdb/expect/InstrumentTyper.scala similarity index 100% rename from tests/semanticdb/InstrumentTyper.scala rename to tests/semanticdb/expect/InstrumentTyper.scala diff --git a/tests/semanticdb/Issue1749.expect.scala b/tests/semanticdb/expect/Issue1749.expect.scala similarity index 100% rename from tests/semanticdb/Issue1749.expect.scala rename to tests/semanticdb/expect/Issue1749.expect.scala diff --git a/tests/semanticdb/Issue1749.scala b/tests/semanticdb/expect/Issue1749.scala similarity index 100% rename from tests/semanticdb/Issue1749.scala rename to tests/semanticdb/expect/Issue1749.scala diff --git a/tests/semanticdb/Local.expect.scala b/tests/semanticdb/expect/Local.expect.scala similarity index 100% rename from tests/semanticdb/Local.expect.scala rename to tests/semanticdb/expect/Local.expect.scala diff --git a/tests/semanticdb/Local.scala b/tests/semanticdb/expect/Local.scala similarity index 100% rename from tests/semanticdb/Local.scala rename to tests/semanticdb/expect/Local.scala diff --git a/tests/semanticdb/Locals.expect.scala b/tests/semanticdb/expect/Locals.expect.scala similarity index 100% rename from tests/semanticdb/Locals.expect.scala rename to tests/semanticdb/expect/Locals.expect.scala diff --git a/tests/semanticdb/Locals.scala b/tests/semanticdb/expect/Locals.scala similarity index 100% rename from tests/semanticdb/Locals.scala rename to tests/semanticdb/expect/Locals.scala diff --git a/tests/semanticdb/MetacJava.expect.scala b/tests/semanticdb/expect/MetacJava.expect.scala similarity index 100% rename from tests/semanticdb/MetacJava.expect.scala rename to tests/semanticdb/expect/MetacJava.expect.scala diff --git a/tests/semanticdb/MetacJava.scala b/tests/semanticdb/expect/MetacJava.scala similarity index 100% rename from tests/semanticdb/MetacJava.scala rename to tests/semanticdb/expect/MetacJava.scala diff --git a/tests/semanticdb/MethodUsages.expect.scala b/tests/semanticdb/expect/MethodUsages.expect.scala similarity index 100% rename from tests/semanticdb/MethodUsages.expect.scala rename to tests/semanticdb/expect/MethodUsages.expect.scala diff --git a/tests/semanticdb/MethodUsages.scala b/tests/semanticdb/expect/MethodUsages.scala similarity index 100% rename from tests/semanticdb/MethodUsages.scala rename to tests/semanticdb/expect/MethodUsages.scala diff --git a/tests/semanticdb/Methods.expect.scala b/tests/semanticdb/expect/Methods.expect.scala similarity index 100% rename from tests/semanticdb/Methods.expect.scala rename to tests/semanticdb/expect/Methods.expect.scala diff --git a/tests/semanticdb/Methods.scala b/tests/semanticdb/expect/Methods.scala similarity index 100% rename from tests/semanticdb/Methods.scala rename to tests/semanticdb/expect/Methods.scala diff --git a/tests/semanticdb/NamedApplyBlock.expect.scala b/tests/semanticdb/expect/NamedApplyBlock.expect.scala similarity index 100% rename from tests/semanticdb/NamedApplyBlock.expect.scala rename to tests/semanticdb/expect/NamedApplyBlock.expect.scala diff --git a/tests/semanticdb/NamedApplyBlock.scala b/tests/semanticdb/expect/NamedApplyBlock.scala similarity index 100% rename from tests/semanticdb/NamedApplyBlock.scala rename to tests/semanticdb/expect/NamedApplyBlock.scala diff --git a/tests/semanticdb/NamedArguments.expect.scala b/tests/semanticdb/expect/NamedArguments.expect.scala similarity index 100% rename from tests/semanticdb/NamedArguments.expect.scala rename to tests/semanticdb/expect/NamedArguments.expect.scala diff --git a/tests/semanticdb/NamedArguments.scala b/tests/semanticdb/expect/NamedArguments.scala similarity index 100% rename from tests/semanticdb/NamedArguments.scala rename to tests/semanticdb/expect/NamedArguments.scala diff --git a/tests/semanticdb/NewModifiers.expect.scala b/tests/semanticdb/expect/NewModifiers.expect.scala similarity index 100% rename from tests/semanticdb/NewModifiers.expect.scala rename to tests/semanticdb/expect/NewModifiers.expect.scala diff --git a/tests/semanticdb/NewModifiers.scala b/tests/semanticdb/expect/NewModifiers.scala similarity index 100% rename from tests/semanticdb/NewModifiers.scala rename to tests/semanticdb/expect/NewModifiers.scala diff --git a/tests/semanticdb/Objects.expect.scala b/tests/semanticdb/expect/Objects.expect.scala similarity index 100% rename from tests/semanticdb/Objects.expect.scala rename to tests/semanticdb/expect/Objects.expect.scala diff --git a/tests/semanticdb/Objects.scala b/tests/semanticdb/expect/Objects.scala similarity index 100% rename from tests/semanticdb/Objects.scala rename to tests/semanticdb/expect/Objects.scala diff --git a/tests/semanticdb/Overrides.expect.scala b/tests/semanticdb/expect/Overrides.expect.scala similarity index 100% rename from tests/semanticdb/Overrides.expect.scala rename to tests/semanticdb/expect/Overrides.expect.scala diff --git a/tests/semanticdb/Overrides.scala b/tests/semanticdb/expect/Overrides.scala similarity index 100% rename from tests/semanticdb/Overrides.scala rename to tests/semanticdb/expect/Overrides.scala diff --git a/tests/semanticdb/Prefixes.expect.scala b/tests/semanticdb/expect/Prefixes.expect.scala similarity index 100% rename from tests/semanticdb/Prefixes.expect.scala rename to tests/semanticdb/expect/Prefixes.expect.scala diff --git a/tests/semanticdb/Prefixes.scala b/tests/semanticdb/expect/Prefixes.scala similarity index 100% rename from tests/semanticdb/Prefixes.scala rename to tests/semanticdb/expect/Prefixes.scala diff --git a/tests/semanticdb/Selfs.expect.scala b/tests/semanticdb/expect/Selfs.expect.scala similarity index 100% rename from tests/semanticdb/Selfs.expect.scala rename to tests/semanticdb/expect/Selfs.expect.scala diff --git a/tests/semanticdb/Selfs.scala b/tests/semanticdb/expect/Selfs.scala similarity index 100% rename from tests/semanticdb/Selfs.scala rename to tests/semanticdb/expect/Selfs.scala diff --git a/tests/semanticdb/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala similarity index 100% rename from tests/semanticdb/Synthetic.expect.scala rename to tests/semanticdb/expect/Synthetic.expect.scala diff --git a/tests/semanticdb/Synthetic.scala b/tests/semanticdb/expect/Synthetic.scala similarity index 100% rename from tests/semanticdb/Synthetic.scala rename to tests/semanticdb/expect/Synthetic.scala diff --git a/tests/semanticdb/Traits.expect.scala b/tests/semanticdb/expect/Traits.expect.scala similarity index 100% rename from tests/semanticdb/Traits.expect.scala rename to tests/semanticdb/expect/Traits.expect.scala diff --git a/tests/semanticdb/Traits.scala b/tests/semanticdb/expect/Traits.scala similarity index 100% rename from tests/semanticdb/Traits.scala rename to tests/semanticdb/expect/Traits.scala diff --git a/tests/semanticdb/Types.expect.scala b/tests/semanticdb/expect/Types.expect.scala similarity index 100% rename from tests/semanticdb/Types.expect.scala rename to tests/semanticdb/expect/Types.expect.scala diff --git a/tests/semanticdb/Types.scala b/tests/semanticdb/expect/Types.scala similarity index 100% rename from tests/semanticdb/Types.scala rename to tests/semanticdb/expect/Types.scala diff --git a/tests/semanticdb/ValPattern.expect.scala b/tests/semanticdb/expect/ValPattern.expect.scala similarity index 100% rename from tests/semanticdb/ValPattern.expect.scala rename to tests/semanticdb/expect/ValPattern.expect.scala diff --git a/tests/semanticdb/ValPattern.scala b/tests/semanticdb/expect/ValPattern.scala similarity index 100% rename from tests/semanticdb/ValPattern.scala rename to tests/semanticdb/expect/ValPattern.scala diff --git a/tests/semanticdb/Vals.expect.scala b/tests/semanticdb/expect/Vals.expect.scala similarity index 100% rename from tests/semanticdb/Vals.expect.scala rename to tests/semanticdb/expect/Vals.expect.scala diff --git a/tests/semanticdb/Vals.scala b/tests/semanticdb/expect/Vals.scala similarity index 100% rename from tests/semanticdb/Vals.scala rename to tests/semanticdb/expect/Vals.scala diff --git a/tests/semanticdb/Vararg.expect.scala b/tests/semanticdb/expect/Vararg.expect.scala similarity index 100% rename from tests/semanticdb/Vararg.expect.scala rename to tests/semanticdb/expect/Vararg.expect.scala diff --git a/tests/semanticdb/Vararg.scala b/tests/semanticdb/expect/Vararg.scala similarity index 100% rename from tests/semanticdb/Vararg.scala rename to tests/semanticdb/expect/Vararg.scala diff --git a/tests/semanticdb/filename with spaces.expect.scala b/tests/semanticdb/expect/filename with spaces.expect.scala similarity index 100% rename from tests/semanticdb/filename with spaces.expect.scala rename to tests/semanticdb/expect/filename with spaces.expect.scala diff --git a/tests/semanticdb/filename with spaces.scala b/tests/semanticdb/expect/filename with spaces.scala similarity index 100% rename from tests/semanticdb/filename with spaces.scala rename to tests/semanticdb/expect/filename with spaces.scala diff --git a/tests/semanticdb/local-file.expect.scala b/tests/semanticdb/expect/local-file.expect.scala similarity index 100% rename from tests/semanticdb/local-file.expect.scala rename to tests/semanticdb/expect/local-file.expect.scala diff --git a/tests/semanticdb/local-file.scala b/tests/semanticdb/expect/local-file.scala similarity index 100% rename from tests/semanticdb/local-file.scala rename to tests/semanticdb/expect/local-file.scala diff --git a/tests/semanticdb/semanticdb-extract.expect.scala b/tests/semanticdb/expect/semanticdb-extract.expect.scala similarity index 100% rename from tests/semanticdb/semanticdb-extract.expect.scala rename to tests/semanticdb/expect/semanticdb-extract.expect.scala diff --git a/tests/semanticdb/semanticdb-extract.scala b/tests/semanticdb/expect/semanticdb-extract.scala similarity index 100% rename from tests/semanticdb/semanticdb-extract.scala rename to tests/semanticdb/expect/semanticdb-extract.scala diff --git a/tests/semanticdb/toplevel.expect.scala b/tests/semanticdb/expect/toplevel.expect.scala similarity index 100% rename from tests/semanticdb/toplevel.expect.scala rename to tests/semanticdb/expect/toplevel.expect.scala diff --git a/tests/semanticdb/toplevel.scala b/tests/semanticdb/expect/toplevel.scala similarity index 100% rename from tests/semanticdb/toplevel.scala rename to tests/semanticdb/expect/toplevel.scala From 20a4ccf41cf90fc47cd838fa20b6b406abbf3c92 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 12 Nov 2019 15:51:25 +0100 Subject: [PATCH 052/107] restructure semanticdb package --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 4 ++-- .../src/dotty/tools/dotc/semanticdb/Language.scala | 2 ++ .../src/dotty/tools/dotc/semanticdb/Range.scala | 10 ++++++---- .../src/dotty/tools/dotc/semanticdb/Schema.scala | 2 ++ .../tools/dotc/semanticdb/SemanticdbEnum.scala | 5 ----- .../tools/dotc/semanticdb/SymbolOccurrence.scala | 8 +++++--- .../dotty/tools/dotc/semanticdb/TextDocument.scala | 14 ++++++++------ .../tools/dotc/semanticdb/TextDocuments.scala | 4 +++- .../InvalidProtocolBufferException.scala | 2 +- .../semanticdb/{ => internal}/LiteParser.scala | 3 +-- .../tools/dotc/semanticdb/{ => internal}/MD5.scala | 2 +- .../dotc/semanticdb/internal/SemanticdbEnum.scala | 5 +++++ .../{ => internal}/SemanticdbInputStream.scala | 2 +- .../{ => internal}/SemanticdbMessage.scala | 2 +- .../{ => internal}/SemanticdbOutputStream.scala | 2 +- .../semanticdb/{ => internal}/WireFormat.scala | 2 +- .../dotty/tools/dotc/semanticdb/Semanticdbs.scala | 2 +- 17 files changed, 41 insertions(+), 30 deletions(-) delete mode 100644 compiler/src/dotty/tools/dotc/semanticdb/SemanticdbEnum.scala rename compiler/src/dotty/tools/dotc/semanticdb/{ => internal}/InvalidProtocolBufferException.scala (97%) rename compiler/src/dotty/tools/dotc/semanticdb/{ => internal}/LiteParser.scala (91%) rename compiler/src/dotty/tools/dotc/semanticdb/{ => internal}/MD5.scala (94%) create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbEnum.scala rename compiler/src/dotty/tools/dotc/semanticdb/{ => internal}/SemanticdbInputStream.scala (99%) rename compiler/src/dotty/tools/dotc/semanticdb/{ => internal}/SemanticdbMessage.scala (77%) rename compiler/src/dotty/tools/dotc/semanticdb/{ => internal}/SemanticdbOutputStream.scala (99%) rename compiler/src/dotty/tools/dotc/semanticdb/{ => internal}/WireFormat.scala (91%) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 1927a65d3b1b..1b6d7eaf42f4 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -306,13 +306,13 @@ object ExtractSemanticDB { language = Language.SCALA, uri = relURI, text = "", - md5 = MD5.compute(String(source.content)), + md5 = internal.MD5.compute(String(source.content)), occurrences = occurrences ) val docs = TextDocuments(List(doc)) val out = Files.newOutputStream(outpath) try - val stream = SemanticdbOutputStream.newInstance(out) + val stream = internal.SemanticdbOutputStream.newInstance(out) docs.writeTo(stream) stream.flush() finally diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala index a2e8404efd1e..587c86d911f9 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala @@ -1,5 +1,7 @@ package dotty.tools.dotc.semanticdb +import dotty.tools.dotc.semanticdb.internal._ + abstract class Language(val value: Int) extends SemanticdbEnum object Language { case object UNKNOWN_LANGUAGE extends Language(0) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala index 74f5dc2e5d94..69b6d9dd2ee5 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala @@ -1,5 +1,7 @@ package dotty.tools.dotc.semanticdb +import dotty.tools.dotc.semanticdb.internal._ + object Range { def defaultInstance: Range = Range(0, 0, 0, 0) } @@ -105,10 +107,10 @@ case class Range( } } Range( - startLine = __startLine, - startCharacter = __startCharacter, - endLine = __endLine, - endCharacter = __endCharacter + startLine = __startLine, + startCharacter = __startCharacter, + endLine = __endLine, + endCharacter = __endCharacter ) } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala index 4539fb67c8e4..7eba633d2bb1 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala @@ -1,5 +1,7 @@ package dotty.tools.dotc.semanticdb +import dotty.tools.dotc.semanticdb.internal._ + abstract class Schema(val value: Int) extends SemanticdbEnum object Schema { def fromValue(value: _root_.scala.Int): Schema = value match { diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbEnum.scala b/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbEnum.scala deleted file mode 100644 index eae4d818604e..000000000000 --- a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbEnum.scala +++ /dev/null @@ -1,5 +0,0 @@ -package dotty.tools.dotc.semanticdb - -trait SemanticdbEnum { - def value: Int -} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala index fa95bef76f21..7642b767e38a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala @@ -1,5 +1,7 @@ package dotty.tools.dotc.semanticdb +import dotty.tools.dotc.semanticdb.internal._ + object SymbolOccurrence { sealed abstract class Role(val value: Int) extends SemanticdbEnum { def isDefinition: Boolean = this == Role.DEFINITION @@ -104,9 +106,9 @@ case class SymbolOccurrence( } } SymbolOccurrence( - range = __range, - symbol = __symbol, - role = __role + range = __range, + symbol = __symbol, + role = __role ) } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala index 1f638332556e..e7d34f619976 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala @@ -1,5 +1,7 @@ package dotty.tools.dotc.semanticdb +import dotty.tools.dotc.semanticdb.internal._ + object TextDocument { def defaultInstance: TextDocument = TextDocument(Schema.LEGACY, Language.UNKNOWN_LANGUAGE, "", "", "", Nil) } @@ -116,12 +118,12 @@ case class TextDocument( } } TextDocument( - schema = __schema, - uri = __uri, - text = "", - md5 = __md5, - language = __language, - occurrences = __occurrences.result(), + schema = __schema, + uri = __uri, + text = "", + md5 = __md5, + language = __language, + occurrences = __occurrences.result(), ) } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala index f104480352c2..e66cb875f214 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala @@ -1,5 +1,7 @@ package dotty.tools.dotc.semanticdb +import dotty.tools.dotc.semanticdb.internal._ + object TextDocuments { def parseFrom(in: Array[Byte]): TextDocuments = { parseFrom(SemanticdbInputStream.newInstance(in)) @@ -50,7 +52,7 @@ case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage } } TextDocuments( - documents = __documents.result() + documents = __documents.result() ) } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/InvalidProtocolBufferException.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/InvalidProtocolBufferException.scala similarity index 97% rename from compiler/src/dotty/tools/dotc/semanticdb/InvalidProtocolBufferException.scala rename to compiler/src/dotty/tools/dotc/semanticdb/internal/InvalidProtocolBufferException.scala index 2d2363e53e2c..886067ed7a43 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/InvalidProtocolBufferException.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/InvalidProtocolBufferException.scala @@ -1,4 +1,4 @@ -package dotty.tools.dotc.semanticdb +package dotty.tools.dotc.semanticdb.internal import java.io.IOException diff --git a/compiler/src/dotty/tools/dotc/semanticdb/LiteParser.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/LiteParser.scala similarity index 91% rename from compiler/src/dotty/tools/dotc/semanticdb/LiteParser.scala rename to compiler/src/dotty/tools/dotc/semanticdb/internal/LiteParser.scala index 931c7bcc43fb..48412fd027b8 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/LiteParser.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/LiteParser.scala @@ -1,8 +1,7 @@ -package dotty.tools.dotc.semanticdb +package dotty.tools.dotc.semanticdb.internal import java.io.InputStream - object LiteParser { def readMessage[A](input: SemanticdbInputStream, message: SemanticdbMessage[A]): A = { diff --git a/compiler/src/dotty/tools/dotc/semanticdb/MD5.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala similarity index 94% rename from compiler/src/dotty/tools/dotc/semanticdb/MD5.scala rename to compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala index cbbb0f508c87..01bcc36467f4 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/MD5.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/MD5.scala @@ -1,4 +1,4 @@ -package dotty.tools.dotc.semanticdb +package dotty.tools.dotc.semanticdb.internal import java.nio.ByteBuffer import java.nio.charset.StandardCharsets diff --git a/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbEnum.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbEnum.scala new file mode 100644 index 000000000000..18b8edf8dab0 --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbEnum.scala @@ -0,0 +1,5 @@ +package dotty.tools.dotc.semanticdb.internal + +trait SemanticdbEnum { + def value: Int +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbInputStream.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala similarity index 99% rename from compiler/src/dotty/tools/dotc/semanticdb/SemanticdbInputStream.scala rename to compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala index 06db54eff96a..34210965607f 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbInputStream.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbInputStream.scala @@ -1,4 +1,4 @@ -package dotty.tools.dotc.semanticdb +package dotty.tools.dotc.semanticdb.internal import java.io.IOException import java.io.InputStream diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbMessage.scala similarity index 77% rename from compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala rename to compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbMessage.scala index 398230ed41ba..e20d1691a05d 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbMessage.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbMessage.scala @@ -1,4 +1,4 @@ -package dotty.tools.dotc.semanticdb +package dotty.tools.dotc.semanticdb.internal trait SemanticdbMessage[A] { def serializedSize: Int diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbOutputStream.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala similarity index 99% rename from compiler/src/dotty/tools/dotc/semanticdb/SemanticdbOutputStream.scala rename to compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala index 168c52a96194..2da5b70cbb91 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SemanticdbOutputStream.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/SemanticdbOutputStream.scala @@ -1,4 +1,4 @@ -package dotty.tools.dotc.semanticdb +package dotty.tools.dotc.semanticdb.internal import java.io.IOException import java.io.OutputStream diff --git a/compiler/src/dotty/tools/dotc/semanticdb/WireFormat.scala b/compiler/src/dotty/tools/dotc/semanticdb/internal/WireFormat.scala similarity index 91% rename from compiler/src/dotty/tools/dotc/semanticdb/WireFormat.scala rename to compiler/src/dotty/tools/dotc/semanticdb/internal/WireFormat.scala index 7419a8a17b6d..1a193fe99ca6 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/WireFormat.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/internal/WireFormat.scala @@ -1,4 +1,4 @@ -package dotty.tools.dotc.semanticdb +package dotty.tools.dotc.semanticdb.internal object WireFormat { val WIRETYPE_VARINT = 0 diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index 1260b659edac..b37aa6f772a0 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -26,7 +26,7 @@ object Semanticdbs { case Some(document) => val text = new String(Files.readAllBytes(scalaAbsolutePath), StandardCharsets.UTF_8) // Assert the SemanticDB payload is in-sync with the contents of the Scala file on disk. - val md5FingerprintOnDisk = MD5.compute(text) + val md5FingerprintOnDisk = internal.MD5.compute(text) if (document.md5 != md5FingerprintOnDisk) { throw new IllegalArgumentException("stale semanticdb: " + reluri) } else { From 945bdf71dfa616ba88c91d30100d1e26fac578f9 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 12 Nov 2019 17:27:33 +0100 Subject: [PATCH 053/107] serialise SymbolInformation, filter out primary ctor in expect test output --- .../dotc/semanticdb/ExtractSemanticDB.scala | 43 ++- .../dotty/tools/dotc/semanticdb/Scala.scala | 5 + .../dotc/semanticdb/SymbolInformation.scala | 244 ++++++++++++++++++ .../tools/dotc/semanticdb/TextDocument.scala | 17 +- .../tools/dotc/semanticdb/Semanticdbs.scala | 9 +- tests/semanticdb/expect/Advanced.expect.scala | 12 +- .../expect/Annotations.expect.scala | 2 +- tests/semanticdb/expect/Classes.expect.scala | 6 +- tests/semanticdb/expect/Enums.expect.scala | 26 +- tests/semanticdb/expect/Flags.expect.scala | 2 +- tests/semanticdb/expect/Prefixes.expect.scala | 2 +- tests/semanticdb/expect/Selfs.expect.scala | 8 +- .../semanticdb/expect/Synthetic.expect.scala | 2 +- tests/semanticdb/expect/Traits.expect.scala | 2 +- tests/semanticdb/expect/Types.expect.scala | 18 +- 15 files changed, 348 insertions(+), 50 deletions(-) create mode 100644 compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 1b6d7eaf42f4..823eb419698d 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -38,7 +38,7 @@ class ExtractSemanticDB extends Phase { val unit = ctx.compilationUnit val extract = Extractor() extract.traverse(unit.tpdTree) - ExtractSemanticDB.write(unit.source, extract.occurrences.toList) + ExtractSemanticDB.write(unit.source, extract.occurrences.toList, extract.symbols.toList) /** Extractor of symbol occurrences from trees */ class Extractor extends TreeTraverser { @@ -56,6 +56,9 @@ class ExtractSemanticDB extends Phase { /** The extracted symbol occurrences */ val occurrences = new mutable.ListBuffer[SymbolOccurrence]() + /** The extracted symbol infos */ + val symbols = new mutable.HashSet[SymbolInformation]() + /** The symbol occurrences generated so far, as a set */ private val generated = new mutable.HashSet[SymbolOccurrence] @@ -189,19 +192,45 @@ class ExtractSemanticDB extends Phase { private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = excludeDefStrict(sym) || (excludeDef(sym) && span.start == span.end) - private def registerOccurrence(sym: Symbol, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = - val occ = SymbolOccurrence(symbolName(sym), range(span), role) + private def symbolKind(sym: Symbol)(given Context): SymbolInformation.Kind = + if sym.name == nme.CONSTRUCTOR + SymbolInformation.Kind.CONSTRUCTOR + else + SymbolInformation.Kind.UNKNOWN_KIND + + private def symbolProps(sym: Symbol)(given Context): Set[SymbolInformation.Property] = + if sym.isPrimaryConstructor + Set(SymbolInformation.Property.PRIMARY) + else + Set.empty + + private def symbolInfo(sym: Symbol, symbolName: String)(given Context): SymbolInformation = SymbolInformation( + symbol = symbolName, + language = Language.SCALA, + kind = symbolKind(sym), + properties = symbolProps(sym).foldLeft(0)(_ | _.value), + displayName = sym.name.show + ) + + private def registerSymbol(sym: Symbol, symbolName: String)(given Context): Unit = + symbols += symbolInfo(sym, symbolName) + + private def registerOccurrence(symbol: String, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = + val occ = SymbolOccurrence(symbol, range(span), role) if !generated.contains(occ) && occ.symbol.nonEmpty then occurrences += occ generated += occ private def registerUse(sym: Symbol, span: Span)(given Context) = if !excludeUseStrict(sym, span) && !isWildcard(sym.name) then - registerOccurrence(sym, span, SymbolOccurrence.Role.REFERENCE) + registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE) private def registerDefinition(sym: Symbol, span: Span)(given Context) = if !isWildcard(sym.name) then - registerOccurrence(sym, span, SymbolOccurrence.Role.DEFINITION) + val symbol = symbolName(sym) + registerOccurrence(symbol, span, SymbolOccurrence.Role.DEFINITION) + if !sym.is(Package) + registerSymbol(sym, symbol) override def traverse(tree: Tree)(given ctx: Context): Unit = def registerPath(expr: Tree): Unit = expr match @@ -225,6 +254,7 @@ class ExtractSemanticDB extends Phase { traverseChildren(tree) case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => + registerDefinition(tree.constr.symbol, tree.constr.span) for vparams <- tree.constr.vparamss vparam <- vparams @@ -283,7 +313,7 @@ object ExtractSemanticDB { val name: String = "extractSemanticDB" - def write(source: SourceFile, occurrences: List[SymbolOccurrence])(given ctx: Context): Unit = + def write(source: SourceFile, occurrences: List[SymbolOccurrence], symbols: List[SymbolInformation])(given ctx: Context): Unit = def absolutePath(path: Path): Path = path.toAbsolutePath.normalize val sourcePath = absolutePath(source.file.jpath) val sourceRoot = absolutePath(Paths.get(ctx.settings.sourceroot.value)) @@ -307,6 +337,7 @@ object ExtractSemanticDB { uri = relURI, text = "", md5 = internal.MD5.compute(String(source.content)), + symbols = symbols, occurrences = occurrences ) val docs = TextDocuments(List(doc)) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala index 467c8a52dcc6..af0ee2c0720d 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala @@ -37,3 +37,8 @@ object Scala with !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ')' def isTypeParameter: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ']' + + given (info: SymbolInformation) with + + def isPrimary: Boolean = + (info.properties & SymbolInformation.Property.PRIMARY.value) != 0 diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala new file mode 100644 index 000000000000..d18a65dda66f --- /dev/null +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala @@ -0,0 +1,244 @@ +package dotty.tools.dotc.semanticdb + +import dotty.tools.dotc.semanticdb.internal._ + +object SymbolInformation { + + lazy val defaultInstance = SymbolInformation("", Language.UNKNOWN_LANGUAGE, SymbolInformation.Kind.UNKNOWN_KIND, 0, "") + + sealed trait Kind(val value: Int) extends SemanticdbEnum { + def isUnknownKind: _root_.scala.Boolean = false + def isLocal: _root_.scala.Boolean = false + def isField: _root_.scala.Boolean = false + def isMethod: _root_.scala.Boolean = false + def isConstructor: _root_.scala.Boolean = false + def isMacro: _root_.scala.Boolean = false + def isType: _root_.scala.Boolean = false + def isParameter: _root_.scala.Boolean = false + def isSelfParameter: _root_.scala.Boolean = false + def isTypeParameter: _root_.scala.Boolean = false + def isObject: _root_.scala.Boolean = false + def isPackage: _root_.scala.Boolean = false + def isPackageObject: _root_.scala.Boolean = false + def isClass: _root_.scala.Boolean = false + def isTrait: _root_.scala.Boolean = false + def isInterface: _root_.scala.Boolean = false + } + + object Kind { + + case object UNKNOWN_KIND extends Kind(0) + case object METHOD extends Kind(3) + case object MACRO extends Kind(6) + case object TYPE extends Kind(7) + case object PARAMETER extends Kind(8) + case object TYPE_PARAMETER extends Kind(9) + case object OBJECT extends Kind(10) + case object PACKAGE extends Kind(11) + case object PACKAGE_OBJECT extends Kind(12) + case object CLASS extends Kind(13) + case object TRAIT extends Kind(14) + case object SELF_PARAMETER extends Kind(17) + case object INTERFACE extends Kind(18) + case object LOCAL extends Kind(19) + case object FIELD extends Kind(20) + case object CONSTRUCTOR extends Kind(21) + final case class Unrecognized(id: _root_.scala.Int) extends Kind(id) + + def fromValue(value: _root_.scala.Int): Kind = value match { + case 0 => UNKNOWN_KIND + case 3 => METHOD + case 6 => MACRO + case 7 => TYPE + case 8 => PARAMETER + case 9 => TYPE_PARAMETER + case 10 => OBJECT + case 11 => PACKAGE + case 12 => PACKAGE_OBJECT + case 13 => CLASS + case 14 => TRAIT + case 17 => SELF_PARAMETER + case 18 => INTERFACE + case 19 => LOCAL + case 20 => FIELD + case 21 => CONSTRUCTOR + case __other => Unrecognized(__other) + } + } + sealed trait Property(val value: Int) extends SemanticdbEnum { + def isUnknownProperty: _root_.scala.Boolean = false + def isAbstract: _root_.scala.Boolean = false + def isFinal: _root_.scala.Boolean = false + def isSealed: _root_.scala.Boolean = false + def isImplicit: _root_.scala.Boolean = false + def isLazy: _root_.scala.Boolean = false + def isCase: _root_.scala.Boolean = false + def isCovariant: _root_.scala.Boolean = false + def isContravariant: _root_.scala.Boolean = false + def isVal: _root_.scala.Boolean = false + def isVar: _root_.scala.Boolean = false + def isStatic: _root_.scala.Boolean = false + def isPrimary: _root_.scala.Boolean = false + def isEnum: _root_.scala.Boolean = false + def isDefault: _root_.scala.Boolean = false + } + + object Property { + + case object UNKNOWN_PROPERTY extends Property(0) + case object ABSTRACT extends Property(4) + case object FINAL extends Property(8) + case object SEALED extends Property(16) + case object IMPLICIT extends Property(32) + case object LAZY extends Property(64) + case object CASE extends Property(128) + case object COVARIANT extends Property(256) + case object CONTRAVARIANT extends Property(512) + case object VAL extends Property(1024) + case object VAR extends Property(2048) + case object STATIC extends Property(4096) + case object PRIMARY extends Property(8192) + case object ENUM extends Property(16384) + case object DEFAULT extends Property(32768) + final case class Unrecognized(id: Int) extends Property(id) + + def fromValue(value: _root_.scala.Int): Property = value match { + case 0 => UNKNOWN_PROPERTY + case 4 => ABSTRACT + case 8 => FINAL + case 16 => SEALED + case 32 => IMPLICIT + case 64 => LAZY + case 128 => CASE + case 256 => COVARIANT + case 512 => CONTRAVARIANT + case 1024 => VAL + case 2048 => VAR + case 4096 => STATIC + case 8192 => PRIMARY + case 16384 => ENUM + case 32768 => DEFAULT + case __other => Unrecognized(__other) + } + } +} + +final case class SymbolInformation( + symbol: String, + language: Language, + kind: SymbolInformation.Kind, + properties: Int, + displayName: String +) extends SemanticdbMessage[SymbolInformation] { + @transient + private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 + private[this] def __computeSerializedValue(): _root_.scala.Int = { + var __size = 0 + + { + val __value = symbol + if (__value != "") { + __size += SemanticdbOutputStream.computeStringSize(1, __value) + } + }; + + { + val __value = language + if (__value != Language.UNKNOWN_LANGUAGE) { + __size += SemanticdbOutputStream.computeEnumSize(16, __value.value) + } + }; + + { + val __value = kind + if (__value != SymbolInformation.Kind.UNKNOWN_KIND) { + __size += SemanticdbOutputStream.computeEnumSize(3, __value.value) + } + }; + + { + val __value = properties + if (__value != 0) { + __size += SemanticdbOutputStream.computeInt32Size(4, __value) + } + }; + + { + val __value = displayName + if (__value != "") { + __size += SemanticdbOutputStream.computeStringSize(5, __value) + } + }; + __size + } + final override def serializedSize: _root_.scala.Int = { + var read = __serializedSizeCachedValue + if (read == 0) { + read = __computeSerializedValue() + __serializedSizeCachedValue = read + } + read + } + def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = { + { + val __v = symbol + if (__v != "") { + _output__.writeString(1, __v) + } + }; + { + val __v = kind + if (__v != SymbolInformation.Kind.UNKNOWN_KIND) { + _output__.writeEnum(3, __v.value) + } + }; + { + val __v = properties + if (__v != 0) { + _output__.writeInt32(4, __v) + } + }; + { + val __v = displayName + if (__v != "") { + _output__.writeString(5, __v) + } + }; + { + val __v = language + if (__v != Language.UNKNOWN_LANGUAGE) { + _output__.writeEnum(16, __v.value) + } + }; + } + def mergeFrom(`_input__`: SemanticdbInputStream): SymbolInformation = { + var __symbol = this.symbol + var __language = this.language + var __kind = this.kind + var __properties = this.properties + var __displayName = this.displayName + var _done__ = false + while (!_done__) { + val _tag__ = _input__.readTag() + _tag__ match { + case 0 => _done__ = true + case 10 => + __symbol = _input__.readString() + case 24 => + __kind = SymbolInformation.Kind.fromValue(_input__.readEnum()) + case 32 => + __properties = _input__.readInt32() + case 42 => + __displayName = _input__.readString() + case tag => _input__.skipField(tag) + } + } + SymbolInformation( + symbol = __symbol, + language = __language, + kind = __kind, + properties = __properties, + displayName = __displayName + ) + } +} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala index e7d34f619976..f47b483a7629 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala @@ -3,7 +3,7 @@ package dotty.tools.dotc.semanticdb import dotty.tools.dotc.semanticdb.internal._ object TextDocument { - def defaultInstance: TextDocument = TextDocument(Schema.LEGACY, Language.UNKNOWN_LANGUAGE, "", "", "", Nil) + def defaultInstance: TextDocument = TextDocument(Schema.LEGACY, Language.UNKNOWN_LANGUAGE, "", "", "", Nil, Nil) } case class TextDocument( schema: Schema, @@ -11,6 +11,7 @@ case class TextDocument( uri: String, text: String, md5: String, + symbols: Seq[SymbolInformation], occurrences: Seq[SymbolOccurrence] ) extends SemanticdbMessage[TextDocument] { private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 @@ -45,6 +46,10 @@ case class TextDocument( __size += SemanticdbOutputStream.computeEnumSize(10, __value.value) } }; + symbols.foreach { __item => + val __value = __item + __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize + } occurrences.foreach { __item => val __value = __item __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag( @@ -74,6 +79,12 @@ case class TextDocument( _output__.writeString(2, __v) } }; + symbols.foreach { __v => + val __m = __v + _output__.writeTag(5, 2) + _output__.writeUInt32NoTag(__m.serializedSize) + __m.writeTo(_output__) + }; occurrences.foreach { __v => val __m = __v _output__.writeTag(6, 2) @@ -98,6 +109,7 @@ case class TextDocument( var __uri = this.uri var __md5 = this.md5 var __language = this.language + val __symbols = (_root_.scala.collection.immutable.Vector.newBuilder[SymbolInformation] ++= this.symbols) val __occurrences = (_root_.scala.collection.immutable.Vector.newBuilder[SymbolOccurrence] ++= this.occurrences) var _done__ = false while (!_done__) { @@ -112,6 +124,8 @@ case class TextDocument( __md5 = _input__.readString() case 80 => __language = Language.fromValue(_input__.readEnum()) + case 42 => + __symbols += LiteParser.readMessage(_input__, SymbolInformation.defaultInstance) case 50 => __occurrences += LiteParser.readMessage(_input__, SymbolOccurrence.defaultInstance) case tag => _input__.skipField(tag) @@ -123,6 +137,7 @@ case class TextDocument( text = "", md5 = __md5, language = __language, + symbols = __symbols.result(), occurrences = __occurrences.result(), ) } diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index b37aa6f772a0..36bba56fe9fa 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -55,6 +55,7 @@ object Semanticdbs { * }}} **/ def printTextDocument(doc: TextDocument): String = { + val symtab = doc.symbols.iterator.map(info => info.symbol -> info).toMap val sb = new StringBuilder val sourceFile = SourceFile.virtual(doc.uri, doc.text) implicit val occurrenceOrdering: Ordering[SymbolOccurrence] = @@ -67,13 +68,15 @@ object Semanticdbs { offset, sourceFile.lineToOffset(range.endLine) + range.endCharacter ) - sb.append(doc.text.substring(offset, end)) - if !occ.symbol.isPackage + val isPrimaryConstructor = + symtab.get(occ.symbol).exists(_.isPrimary) + if !occ.symbol.isPackage && !isPrimaryConstructor + sb.append(doc.text.substring(offset, end)) sb.append("/*") .append(if (occ.role.isDefinition) "<<=" else "=>>") .append(occ.symbol.replace('/', '.')) .append("*/") - offset = end + offset = end } sb.append(doc.text.substring(offset)) sb.toString() diff --git a/tests/semanticdb/expect/Advanced.expect.scala b/tests/semanticdb/expect/Advanced.expect.scala index 5cf7de3a8523..6c0984a2ef8a 100644 --- a/tests/semanticdb/expect/Advanced.expect.scala +++ b/tests/semanticdb/expect/Advanced.expect.scala @@ -11,8 +11,8 @@ 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/*<<=local2*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } - def s3/*<<=advanced.Structural#s3().*/: { def m/*<<=local3*/(x/*<<=local4*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ } = new { def m/*<<=local5*/(x/*<<=local6*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } + def s2/*<<=advanced.Structural#s2().*/: { val x/*<<=local1*/: Int/*=>>scala.Int#*/ } = new { val x/*<<=local3*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } + def s3/*<<=advanced.Structural#s3().*/: { def m/*<<=local4*/(x/*<<=local5*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ } = new { def m/*<<=local7*/(x/*<<=local8*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } } class Wildcards/*<<=advanced.Wildcards#*/ { @@ -20,7 +20,7 @@ class Wildcards/*<<=advanced.Wildcards#*/ { } object Test/*<<=advanced.Test.*/ { - val s/*<<=advanced.Test.s.*/ = new Structural/*=>>advanced.Structural#*//*=>>advanced.Structural#``().*/ + val s/*<<=advanced.Test.s.*/ = new Structural/*=>>advanced.Structural#*/ val s1/*<<=advanced.Test.s1.*/ = s/*=>>advanced.Test.s.*/.s1/*=>>advanced.Structural#s1().*/ val s1x/*<<=advanced.Test.s1x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s1/*=>>advanced.Structural#s1().*//*=>>scala.Selectable#selectDynamic().*/.x val s2/*<<=advanced.Test.s2.*/ = s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*/ @@ -28,14 +28,14 @@ object Test/*<<=advanced.Test.*/ { val s3/*<<=advanced.Test.s3.*/ = s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*/ val s3x/*<<=advanced.Test.s3x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*//*=>>scala.Selectable#applyDynamic().*/.m/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer#TYPE.*/(???/*=>>scala.Predef.`???`().*/) - val e/*<<=advanced.Test.e.*/ = new Wildcards/*=>>advanced.Wildcards#*//*=>>advanced.Wildcards#``().*/ + val e/*<<=advanced.Test.e.*/ = new Wildcards/*=>>advanced.Wildcards#*/ val e1/*<<=advanced.Test.e1.*/ = e/*=>>advanced.Test.e.*/.e1/*=>>advanced.Wildcards#e1().*/ val e1x/*<<=advanced.Test.e1x.*/ = e/*=>>advanced.Test.e.*/.e1/*=>>advanced.Wildcards#e1().*/.head/*=>>scala.collection.IterableOps#head().*/ { (???/*=>>scala.Predef.`???`().*/ : Any/*=>>scala.Any#*/) match { - case e3/*<<=local7*/: List/*=>>scala.package.List#*/[_] => - val e3x/*<<=local8*/ = e3/*=>>local7*/.head/*=>>scala.collection.IterableOps#head().*/ + case e3/*<<=local9*/: List/*=>>scala.package.List#*/[_] => + val e3x/*<<=local10*/ = e3/*=>>local9*/.head/*=>>scala.collection.IterableOps#head().*/ () } } diff --git a/tests/semanticdb/expect/Annotations.expect.scala b/tests/semanticdb/expect/Annotations.expect.scala index 96133d1ae982..db114f3f5401 100644 --- a/tests/semanticdb/expect/Annotations.expect.scala +++ b/tests/semanticdb/expect/Annotations.expect.scala @@ -21,7 +21,7 @@ class Annotations/*<<=annot.Annotations#*/[@TypeParameterAnnotation/*=>>com.java class B/*<<=annot.B#*/ @ConstructorAnnotation/*=>>com.javacp.annot.ConstructorAnnotation#*/()(x/*<<=annot.B#x.*/: Int/*=>>scala.Int#*/) { @ConstructorAnnotation/*=>>com.javacp.annot.ConstructorAnnotation#*/ - def this()/*<<=annot.B#``(+1).*/ = this(/*=>>annot.B#``().*/42) + def this()/*<<=annot.B#``(+1).*/ = this(42) } @ObjectAnnotation/*=>>com.javacp.annot.ObjectAnnotation#*/ diff --git a/tests/semanticdb/expect/Classes.expect.scala b/tests/semanticdb/expect/Classes.expect.scala index 37b1ac9b427c..619671a7ca51 100644 --- a/tests/semanticdb/expect/Classes.expect.scala +++ b/tests/semanticdb/expect/Classes.expect.scala @@ -23,11 +23,11 @@ class C8/*<<=classes.C8#*/(private[this] val x/*<<=classes.C8#x.*/: Int/*=>>scal class C9/*<<=classes.C9#*/(private[this] var x/*<<=classes.C9#x().*/: Int/*=>>scala.Int#*/) object N/*<<=classes.N.*/ { - val anonClass/*<<=classes.N.anonClass.*/ = new C7/*=>>classes.C7#*//*=>>classes.C7#``().*/(42) { - val local/*<<=local0*/ = ???/*=>>scala.Predef.`???`().*/ + val anonClass/*<<=classes.N.anonClass.*/ = new C7/*=>>classes.C7#*/(42) { + val local/*<<=local1*/ = ???/*=>>scala.Predef.`???`().*/ } val anonFun/*<<=classes.N.anonFun.*/ = List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1).map/*=>>scala.collection.immutable.List#map().*/ { i => val local = 2 - local/*=>>local1*/ +/*=>>scala.Int#`+`(+4).*/ 2 + local/*=>>local2*/ +/*=>>scala.Int#`+`(+4).*/ 2 } } diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index 5db51e90dbcd..9507c4f488dd 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -14,15 +14,15 @@ object Enums/*<<=_empty_.Enums.*/ with case Sunday/*<<=_empty_.Enums.WeekDays.Sunday.*/ enum Maybe/*<<=_empty_.Enums.Maybe#*/[+A/*<<=_empty_.Enums.Maybe#[A]*/] with - /*=>>_empty_.Enums.Maybe#``().*/case Just/*<<=_empty_.Enums.Maybe.Just#*/(value/*<<=_empty_.Enums.Maybe.Just#value.*/: A/*=>>_empty_.Enums.Maybe.Just#``().[A]*/) - /*=>>_empty_.Enums.Maybe#``().*/case None/*<<=_empty_.Enums.Maybe.None.*/ + case Just/*<<=_empty_.Enums.Maybe.Just#*/(value/*<<=_empty_.Enums.Maybe.Just#value.*/: A/*=>>_empty_.Enums.Maybe.Just#``().[A]*/) + case None/*<<=_empty_.Enums.Maybe.None.*/ enum Tag/*<<=_empty_.Enums.Tag#*/[A/*<<=_empty_.Enums.Tag#[A]*/] with - case IntTag/*<<=_empty_.Enums.Tag.IntTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Int/*=>>scala.Int#*/]/*=>>_empty_.Enums.Tag#``().*/ - case BooleanTag/*<<=_empty_.Enums.Tag.BooleanTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Boolean/*=>>scala.Boolean#*/]/*=>>_empty_.Enums.Tag#``().*/ + case IntTag/*<<=_empty_.Enums.Tag.IntTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Int/*=>>scala.Int#*/] + case BooleanTag/*<<=_empty_.Enums.Tag.BooleanTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Boolean/*=>>scala.Boolean#*/] enum =:=/*<<=_empty_.Enums.`=:=`#*/[A/*<<=_empty_.Enums.`=:=`#[A]*/, B/*<<=_empty_.Enums.`=:=`#[B]*/] with - case Refl/*<<=_empty_.Enums.`=:=`.Refl#*/[C/*<<=_empty_.Enums.`=:=`.Refl#[C]*/]() extends (C/*=>>_empty_.Enums.`=:=`.Refl#[C]*/ =:=/*=>>_empty_.Enums.`=:=`#*/ C/*=>>_empty_.Enums.`=:=`.Refl#[C]*//*=>>_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]*/) def unwrap/*<<=_empty_.Enums.unwrap().*/[A/*<<=_empty_.Enums.unwrap().[A]*/,B/*<<=_empty_.Enums.unwrap().[B]*/](opt/*<<=_empty_.Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>_empty_.Enums.unwrap().[A]*/])(given ev/*<<=_empty_.Enums.unwrap().(ev)*/: A/*=>>_empty_.Enums.unwrap().[A]*/ =:=/*=>>_empty_.Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/]): Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/] = ev/*=>>_empty_.Enums.unwrap().(ev)*/ match case Refl/*=>>_empty_.Enums.`=:=`.Refl.*/() => opt/*=>>_empty_.Enums.unwrap().(opt)*/.flatMap/*=>>scala.Option#flatMap().*/(identity/*=>>scala.Predef.identity().*/[Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/]]) @@ -33,11 +33,11 @@ object Enums/*<<=_empty_.Enums.*/ with def surfaceGravity/*<<=_empty_.Enums.Planet#surfaceGravity().*/ = G/*=>>_empty_.Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>_empty_.Enums.Planet#mass.*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>_empty_.Enums.Planet#radius.*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>_empty_.Enums.Planet#radius.*/) def surfaceWeight/*<<=_empty_.Enums.Planet#surfaceWeight().*/(otherMass/*<<=_empty_.Enums.Planet#surfaceWeight().(otherMass)*/: Double/*=>>scala.Double#*/) = otherMass/*=>>_empty_.Enums.Planet#surfaceWeight().(otherMass)*/ */*=>>scala.Double#`*`(+6).*/ surfaceGravity/*=>>_empty_.Enums.Planet#surfaceGravity().*/ - case Mercury/*<<=_empty_.Enums.Planet.Mercury.*/ extends /*=>>scala.runtime.EnumValues#``().*/Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*/ - case Venus/*<<=_empty_.Enums.Planet.Venus.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*/ - case Earth/*<<=_empty_.Enums.Planet.Earth.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*/ - case Mars/*<<=_empty_.Enums.Planet.Mars.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*/ - case Jupiter/*<<=_empty_.Enums.Planet.Jupiter.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*/ - case Saturn/*<<=_empty_.Enums.Planet.Saturn.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*/ - case Uranus/*<<=_empty_.Enums.Planet.Uranus.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*/ - case Neptune/*<<=_empty_.Enums.Planet.Neptune.*/ extends Planet/*=>>_empty_.Enums.Planet#*//*=>>_empty_.Enums.Planet#``().*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*/ + case Mercury/*<<=_empty_.Enums.Planet.Mercury.*/ extends /*=>>scala.runtime.EnumValues#``().*/Planet/*=>>_empty_.Enums.Planet#*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*/ + case Venus/*<<=_empty_.Enums.Planet.Venus.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*/ + case Earth/*<<=_empty_.Enums.Planet.Earth.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*/ + case Mars/*<<=_empty_.Enums.Planet.Mars.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*/ + case Jupiter/*<<=_empty_.Enums.Planet.Jupiter.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*/ + case Saturn/*<<=_empty_.Enums.Planet.Saturn.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*/ + case Uranus/*<<=_empty_.Enums.Planet.Uranus.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*/ + case Neptune/*<<=_empty_.Enums.Planet.Neptune.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*/ diff --git a/tests/semanticdb/expect/Flags.expect.scala b/tests/semanticdb/expect/Flags.expect.scala index b7f0947082d2..cc0321c67bb2 100644 --- a/tests/semanticdb/expect/Flags.expect.scala +++ b/tests/semanticdb/expect/Flags.expect.scala @@ -8,7 +8,7 @@ package object p { def z/*<<=flags.p.package.z().*/(pp/*<<=flags.p.package.z().(pp)*/: Int/*=>>scala.Int#*/) = 3 def m/*<<=flags.p.package.m().*/[TT/*<<=flags.p.package.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*/ = macro ??? abstract class C/*<<=flags.p.package.C#*/[+T/*<<=flags.p.package.C#[T]*//*<<=flags.p.package.C#``(+1).[T]*/, -U/*<<=flags.p.package.C#[U]*//*<<=flags.p.package.C#``(+1).[U]*/, V/*<<=flags.p.package.C#[V]*//*<<=flags.p.package.C#``(+1).[V]*/](x/*<<=flags.p.package.C#x.*/: T/*=>>flags.p.package.C#``().[T]*/, y/*<<=flags.p.package.C#y.*/: U/*=>>flags.p.package.C#``().[U]*/, z/*<<=flags.p.package.C#z.*/: V/*=>>flags.p.package.C#``().[V]*/) { - def this()/*<<=flags.p.package.C#``(+1).*/ = this(/*=>>flags.p.package.C#``().*/???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/) + def this()/*<<=flags.p.package.C#``(+1).*/ = this(???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/) def w/*<<=flags.p.package.C#w().*/: Int/*=>>scala.Int#*/ } type T1/*<<=flags.p.package.T1#*/ = Int/*=>>scala.Int#*/ diff --git a/tests/semanticdb/expect/Prefixes.expect.scala b/tests/semanticdb/expect/Prefixes.expect.scala index d6d9baceb274..14a5ee8d2704 100644 --- a/tests/semanticdb/expect/Prefixes.expect.scala +++ b/tests/semanticdb/expect/Prefixes.expect.scala @@ -15,7 +15,7 @@ object M/*<<=prefixes.M.*/ { def n1/*<<=prefixes.M.n1().*/: T/*=>>prefixes.M.T#*/ = ???/*=>>scala.Predef.`???`().*/ } -object O/*<<=prefixes.O.*/ extends C/*=>>prefixes.C#*//*=>>prefixes.C#``().*/ { +object O/*<<=prefixes.O.*/ extends C/*=>>prefixes.C#*/ { def o1/*<<=prefixes.O.o1().*/: T/*=>>prefixes.C#T#*/ = ???/*=>>scala.Predef.`???`().*/ } diff --git a/tests/semanticdb/expect/Selfs.expect.scala b/tests/semanticdb/expect/Selfs.expect.scala index cd0c784fd4e8..ef46041e7a1a 100644 --- a/tests/semanticdb/expect/Selfs.expect.scala +++ b/tests/semanticdb/expect/Selfs.expect.scala @@ -2,14 +2,14 @@ package selfs class B/*<<=selfs.B#*/ -class C1/*<<=selfs.C1#*/ extends B/*=>>selfs.B#*//*=>>selfs.B#``().*/ { self/*<<=local0*/ => +class C1/*<<=selfs.C1#*/ extends B/*=>>selfs.B#*/ { self/*<<=local0*/ => } -class C2/*<<=selfs.C2#*/ extends B/*=>>selfs.B#*//*=>>selfs.B#``().*/ { self/*<<=local1*/: B/*=>>selfs.B#*/ => +class C2/*<<=selfs.C2#*/ extends B/*=>>selfs.B#*/ { self/*<<=local1*/: B/*=>>selfs.B#*/ => } -class C3/*<<=selfs.C3#*/ extends B/*=>>selfs.B#*//*=>>selfs.B#``().*/ { self/*<<=local2*/: B/*=>>selfs.B#*/ with C1/*=>>selfs.C1#*/ => +class C3/*<<=selfs.C3#*/ extends B/*=>>selfs.B#*/ { self/*<<=local2*/: B/*=>>selfs.B#*/ with C1/*=>>selfs.C1#*/ => } -class C6/*<<=selfs.C6#*/ extends B/*=>>selfs.B#*//*=>>selfs.B#``().*/ { this: B/*=>>selfs.B#*/ => +class C6/*<<=selfs.C6#*/ extends B/*=>>selfs.B#*/ { this: B/*=>>selfs.B#*/ => } diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala index cd7f65d7e81e..9b6b4ef2cfeb 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -32,7 +32,7 @@ class Synthetic/*<<=example.Synthetic#*/ { 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#F#``().*//*=>>example.Synthetic#ordering.*/ + val f/*<<=example.Synthetic#f.*/: Ordered/*=>>scala.package.Ordered#*/[F/*=>>example.Synthetic#F#*/] = /*=>>scala.math.Ordered.orderingToOrdered().*/new F/*=>>example.Synthetic#F#*//*=>>example.Synthetic#ordering.*/ import scala.concurrent.ExecutionContext/*=>>scala.concurrent.ExecutionContext.*/.Implicits/*=>>scala.concurrent.ExecutionContext.Implicits.*/.global/*=>>scala.concurrent.ExecutionContext.Implicits.global().*/ for { diff --git a/tests/semanticdb/expect/Traits.expect.scala b/tests/semanticdb/expect/Traits.expect.scala index 929809d23ab5..07acdabecfe7 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/*<<=local0*/: C/*=>>traits.C#*/ => +trait V/*<<=traits.V#*/ { self/*<<=local1*/: C/*=>>traits.C#*/ => } diff --git a/tests/semanticdb/expect/Types.expect.scala b/tests/semanticdb/expect/Types.expect.scala index fb2d2bddbc49..7515460861ad 100644 --- a/tests/semanticdb/expect/Types.expect.scala +++ b/tests/semanticdb/expect/Types.expect.scala @@ -14,13 +14,13 @@ class C/*<<=types.C#*/ class P/*<<=types.P#*/ { class C/*<<=types.P#C#*/ class X/*<<=types.P#X#*/ - val x/*<<=types.P#x.*/ = new X/*=>>types.P#X#*//*=>>types.P#X#``().*/ + val x/*<<=types.P#x.*/ = new X/*=>>types.P#X#*/ } class T/*<<=types.T#*/ { class C/*<<=types.T#C#*/ class X/*<<=types.T#X#*/ - val x/*<<=types.T#x.*/ = new X/*=>>types.T#X#*//*=>>types.T#X#``().*/ + val x/*<<=types.T#x.*/ = new X/*=>>types.T#X#*/ } object Test/*<<=types.Test.*/ { @@ -32,8 +32,8 @@ object Test/*<<=types.Test.*/ { def n/*<<=types.Test.N#n().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } - class C/*<<=types.Test.C#*/ extends M/*=>>types.Test.M#*//*=>>types.Test.M#``().*/ { - val p/*<<=types.Test.C#p.*/ = new P/*=>>types.P#*//*=>>types.P#``().*/ + class C/*<<=types.Test.C#*/ extends M/*=>>types.Test.M#*/ { + val p/*<<=types.Test.C#p.*/ = new P/*=>>types.P#*/ val x/*<<=types.Test.C#x.*/ = p/*=>>types.Test.C#p.*/.x/*=>>types.P#x.*/ val typeRef1/*<<=types.Test.C#typeRef1.*/: C/*=>>types.Test.C#*/ = ???/*=>>scala.Predef.`???`().*/ @@ -55,9 +55,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/*<<=local2*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } - val compoundType5/*<<=types.Test.C#compoundType5.*/ = new M/*=>>types.Test.M#*//*=>>types.Test.M#``().*/ with N/*=>>types.Test.N#*/ - val compoundType6/*<<=types.Test.C#compoundType6.*/ = new M/*=>>types.Test.M#*//*=>>types.Test.M#``().*/ with N/*=>>types.Test.N#*/ { def k/*<<=local3*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } + val compoundType4/*<<=types.Test.C#compoundType4.*/ = new { def k/*<<=local3*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } + val compoundType5/*<<=types.Test.C#compoundType5.*/ = new M/*=>>types.Test.M#*/ with N/*=>>types.Test.N#*/ + val compoundType6/*<<=types.Test.C#compoundType6.*/ = new M/*=>>types.Test.M#*/ with N/*=>>types.Test.N#*/ { def k/*<<=local6*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } val annType1/*<<=types.Test.C#annType1.*/: T/*=>>types.T#*/ @ann(42) = ???/*=>>scala.Predef.`???`().*/ val annType2/*<<=types.Test.C#annType2.*/: T/*=>>types.T#*/ @ann1 @ann2 = ???/*=>>scala.Predef.`???`().*/ @@ -67,10 +67,10 @@ 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/*<<=local4*/[T/*<<=local5*/] = List/*=>>scala.package.List#*/[T/*=>>local5*/] })#L] + typeLambda1/*=>>types.Test.C#typeLambda1().*/[({ type L/*<<=local7*/[T/*<<=local8*/] = List/*=>>scala.package.List#*/[T/*=>>local8*/] })#L] object ClassInfoType1/*<<=types.Test.C#ClassInfoType1.*/ - class ClassInfoType2/*<<=types.Test.C#ClassInfoType2#*/ extends B/*=>>types.B#*//*=>>types.B#``().*/ { def x/*<<=types.Test.C#ClassInfoType2#x().*/ = 42 } + class ClassInfoType2/*<<=types.Test.C#ClassInfoType2#*/ extends B/*=>>types.B#*/ { def x/*<<=types.Test.C#ClassInfoType2#x().*/ = 42 } trait ClassInfoType3/*<<=types.Test.C#ClassInfoType3#*/[T/*<<=types.Test.C#ClassInfoType3#[T]*/] object MethodType/*<<=types.Test.C#MethodType.*/ { From d89586adde8dfc55a695b856256fb6165980f38d Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 13 Nov 2019 15:35:40 +0100 Subject: [PATCH 054/107] improve safety of semanticdb serialisation classes --- .../tools/dotc/semanticdb/Language.scala | 10 +- .../dotty/tools/dotc/semanticdb/Range.scala | 26 ++--- .../dotty/tools/dotc/semanticdb/Schema.scala | 16 ++-- .../dotc/semanticdb/SymbolInformation.scala | 96 ++++++++++--------- .../dotc/semanticdb/SymbolOccurrence.scala | 31 +++--- .../tools/dotc/semanticdb/TextDocument.scala | 35 +++---- .../tools/dotc/semanticdb/TextDocuments.scala | 16 ++-- 7 files changed, 125 insertions(+), 105 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala index 587c86d911f9..482f11adc85a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala @@ -2,16 +2,20 @@ package dotty.tools.dotc.semanticdb import dotty.tools.dotc.semanticdb.internal._ -abstract class Language(val value: Int) extends SemanticdbEnum +sealed trait Language(val value: Int) extends SemanticdbEnum derives Eql + object Language { + case object UNKNOWN_LANGUAGE extends Language(0) case object SCALA extends Language(1) case object JAVA extends Language(2) - case class Unrecognized(id: Int) extends Language(id) - def fromValue(value: _root_.scala.Int): Language = value match { + final case class Unrecognized(id: Int) extends Language(id) + + def fromValue(value: Int): Language = value match { case 0 => UNKNOWN_LANGUAGE case 1 => SCALA case 2 => JAVA case __other => Unrecognized(__other) } + } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala index 69b6d9dd2ee5..87f6d8116a2c 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala @@ -1,19 +1,21 @@ package dotty.tools.dotc.semanticdb import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable object Range { - def defaultInstance: Range = Range(0, 0, 0, 0) + lazy val defaultInstance: Range = Range(0, 0, 0, 0) } -case class Range( - startLine: Int, - startCharacter: Int, - endLine: Int, - endCharacter: Int -) extends SemanticdbMessage[Range] { - @transient - private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 - private[this] def __computeSerializedValue(): _root_.scala.Int = { + +final case class Range( + startLine: Int, + startCharacter: Int, + endLine: Int, + endCharacter: Int +) extends SemanticdbMessage[Range] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { var __size = 0 { @@ -49,7 +51,7 @@ case class Range( }; __size } - final override def serializedSize: _root_.scala.Int = { + final override def serializedSize: Int = { var read = __serializedSizeCachedValue if (read == 0) { read = __computeSerializedValue() @@ -59,7 +61,7 @@ case class Range( } def writeTo( `_output__`: SemanticdbOutputStream - ): _root_.scala.Unit = { + ): Unit = { { val __v = startLine if (__v != 0) { diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala index 7eba633d2bb1..58571efadb10 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala @@ -2,16 +2,20 @@ package dotty.tools.dotc.semanticdb import dotty.tools.dotc.semanticdb.internal._ -abstract class Schema(val value: Int) extends SemanticdbEnum +sealed trait Schema(val value: Int) extends SemanticdbEnum derives Eql + object Schema { - def fromValue(value: _root_.scala.Int): Schema = value match { + + case object LEGACY extends Schema(0) + case object SEMANTICDB3 extends Schema(3) + case object SEMANTICDB4 extends Schema(4) + final case class Unrecognized(id: Int) extends Schema(id) + + def fromValue(value: Int): Schema = value match { case 0 => LEGACY case 3 => SEMANTICDB3 case 4 => SEMANTICDB4 case __other => Unrecognized(__other) } - case object LEGACY extends Schema(0) - case object SEMANTICDB3 extends Schema(3) - case object SEMANTICDB4 extends Schema(4) - case class Unrecognized(id: Int) extends Schema(id) + } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala index d18a65dda66f..d48f1dd46a0a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala @@ -1,28 +1,29 @@ package dotty.tools.dotc.semanticdb import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable object SymbolInformation { lazy val defaultInstance = SymbolInformation("", Language.UNKNOWN_LANGUAGE, SymbolInformation.Kind.UNKNOWN_KIND, 0, "") - sealed trait Kind(val value: Int) extends SemanticdbEnum { - def isUnknownKind: _root_.scala.Boolean = false - def isLocal: _root_.scala.Boolean = false - def isField: _root_.scala.Boolean = false - def isMethod: _root_.scala.Boolean = false - def isConstructor: _root_.scala.Boolean = false - def isMacro: _root_.scala.Boolean = false - def isType: _root_.scala.Boolean = false - def isParameter: _root_.scala.Boolean = false - def isSelfParameter: _root_.scala.Boolean = false - def isTypeParameter: _root_.scala.Boolean = false - def isObject: _root_.scala.Boolean = false - def isPackage: _root_.scala.Boolean = false - def isPackageObject: _root_.scala.Boolean = false - def isClass: _root_.scala.Boolean = false - def isTrait: _root_.scala.Boolean = false - def isInterface: _root_.scala.Boolean = false + sealed trait Kind(val value: Int) extends SemanticdbEnum derives Eql { + def isUnknownKind: Boolean = this == Kind.UNKNOWN_KIND + def isLocal: Boolean = this == Kind.LOCAL + def isField: Boolean = this == Kind.FIELD + def isMethod: Boolean = this == Kind.METHOD + def isConstructor: Boolean = this == Kind.CONSTRUCTOR + def isMacro: Boolean = this == Kind.MACRO + def isType: Boolean = this == Kind.TYPE + def isParameter: Boolean = this == Kind.PARAMETER + def isSelfParameter: Boolean = this == Kind.SELF_PARAMETER + def isTypeParameter: Boolean = this == Kind.TYPE_PARAMETER + def isObject: Boolean = this == Kind.OBJECT + def isPackage: Boolean = this == Kind.PACKAGE + def isPackageObject: Boolean = this == Kind.PACKAGE_OBJECT + def isClass: Boolean = this == Kind.CLASS + def isTrait: Boolean = this == Kind.TRAIT + def isInterface: Boolean = this == Kind.INTERFACE } object Kind { @@ -43,9 +44,9 @@ object SymbolInformation { case object LOCAL extends Kind(19) case object FIELD extends Kind(20) case object CONSTRUCTOR extends Kind(21) - final case class Unrecognized(id: _root_.scala.Int) extends Kind(id) + final case class Unrecognized(id: Int) extends Kind(id) - def fromValue(value: _root_.scala.Int): Kind = value match { + def fromValue(value: Int): Kind = value match { case 0 => UNKNOWN_KIND case 3 => METHOD case 6 => MACRO @@ -65,22 +66,23 @@ object SymbolInformation { case __other => Unrecognized(__other) } } - sealed trait Property(val value: Int) extends SemanticdbEnum { - def isUnknownProperty: _root_.scala.Boolean = false - def isAbstract: _root_.scala.Boolean = false - def isFinal: _root_.scala.Boolean = false - def isSealed: _root_.scala.Boolean = false - def isImplicit: _root_.scala.Boolean = false - def isLazy: _root_.scala.Boolean = false - def isCase: _root_.scala.Boolean = false - def isCovariant: _root_.scala.Boolean = false - def isContravariant: _root_.scala.Boolean = false - def isVal: _root_.scala.Boolean = false - def isVar: _root_.scala.Boolean = false - def isStatic: _root_.scala.Boolean = false - def isPrimary: _root_.scala.Boolean = false - def isEnum: _root_.scala.Boolean = false - def isDefault: _root_.scala.Boolean = false + + sealed trait Property(val value: Int) extends SemanticdbEnum derives Eql { + def isUnknownProperty: Boolean = this == Property.UNKNOWN_PROPERTY + def isAbstract: Boolean = this == Property.ABSTRACT + def isFinal: Boolean = this == Property.FINAL + def isSealed: Boolean = this == Property.SEALED + def isImplicit: Boolean = this == Property.IMPLICIT + def isLazy: Boolean = this == Property.LAZY + def isCase: Boolean = this == Property.CASE + def isCovariant: Boolean = this == Property.CONTRAVARIANT + def isContravariant: Boolean = this == Property.CONTRAVARIANT + def isVal: Boolean = this == Property.VAL + def isVar: Boolean = this == Property.VAR + def isStatic: Boolean = this == Property.STATIC + def isPrimary: Boolean = this == Property.PRIMARY + def isEnum: Boolean = this == Property.ENUM + def isDefault: Boolean = this == Property.DEFAULT } object Property { @@ -102,7 +104,7 @@ object SymbolInformation { case object DEFAULT extends Property(32768) final case class Unrecognized(id: Int) extends Property(id) - def fromValue(value: _root_.scala.Int): Property = value match { + def fromValue(value: Int): Property = value match { case 0 => UNKNOWN_PROPERTY case 4 => ABSTRACT case 8 => FINAL @@ -129,10 +131,10 @@ final case class SymbolInformation( kind: SymbolInformation.Kind, properties: Int, displayName: String -) extends SemanticdbMessage[SymbolInformation] { - @transient - private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 - private[this] def __computeSerializedValue(): _root_.scala.Int = { +) extends SemanticdbMessage[SymbolInformation] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { var __size = 0 { @@ -171,7 +173,7 @@ final case class SymbolInformation( }; __size } - final override def serializedSize: _root_.scala.Int = { + final override def serializedSize: Int = { var read = __serializedSizeCachedValue if (read == 0) { read = __computeSerializedValue() @@ -179,7 +181,7 @@ final case class SymbolInformation( } read } - def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = { + def writeTo(`_output__`: SemanticdbOutputStream): Unit = { { val __v = symbol if (__v != "") { @@ -234,11 +236,11 @@ final case class SymbolInformation( } } SymbolInformation( - symbol = __symbol, - language = __language, - kind = __kind, - properties = __properties, - displayName = __displayName + symbol = __symbol, + language = __language, + kind = __kind, + properties = __properties, + displayName = __displayName ) } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala index 7642b767e38a..5b3ce8e53d83 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala @@ -1,18 +1,21 @@ package dotty.tools.dotc.semanticdb import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable object SymbolOccurrence { - sealed abstract class Role(val value: Int) extends SemanticdbEnum { + + sealed trait Role(val value: Int) extends SemanticdbEnum derives Eql { def isDefinition: Boolean = this == Role.DEFINITION def isReference: Boolean = this == Role.REFERENCE } object Role { + case object UNKNOWN_ROLE extends Role(0) case object REFERENCE extends Role(1) case object DEFINITION extends Role(2) - case class Unrecognized(id: Int) extends Role(id) + final case class Unrecognized(id: Int) extends Role(id) def fromValue(value: Int): Role = value match { case 0 => UNKNOWN_ROLE @@ -20,18 +23,20 @@ object SymbolOccurrence { case 2 => DEFINITION case __other => Unrecognized(__other) } + } - def defaultInstance: SymbolOccurrence = SymbolOccurrence("", None, Role.UNKNOWN_ROLE) + lazy val defaultInstance: SymbolOccurrence = SymbolOccurrence("", None, Role.UNKNOWN_ROLE) } -case class SymbolOccurrence( - symbol: String, - range: Option[Range], - role: SymbolOccurrence.Role -) extends SemanticdbMessage[SymbolOccurrence] { - private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 - private[this] def __computeSerializedValue(): _root_.scala.Int = { +final case class SymbolOccurrence( + symbol: String, + range: Option[Range], + role: SymbolOccurrence.Role +) extends SemanticdbMessage[SymbolOccurrence] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { var __size = 0 if (range.isDefined) { val __value = range.get @@ -57,7 +62,7 @@ case class SymbolOccurrence( }; __size } - final override def serializedSize: _root_.scala.Int = { + final override def serializedSize: Int = { var read = __serializedSizeCachedValue if (read == 0) { read = __computeSerializedValue() @@ -65,9 +70,7 @@ case class SymbolOccurrence( } read } - def writeTo( - `_output__`: SemanticdbOutputStream - ): _root_.scala.Unit = { + def writeTo(`_output__`: SemanticdbOutputStream): Unit = { range.foreach { __v => val __m = __v _output__.writeTag(1, 2) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala index f47b483a7629..02e3e040ab46 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala @@ -1,21 +1,24 @@ package dotty.tools.dotc.semanticdb import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable object TextDocument { - def defaultInstance: TextDocument = TextDocument(Schema.LEGACY, Language.UNKNOWN_LANGUAGE, "", "", "", Nil, Nil) + lazy val defaultInstance: TextDocument = TextDocument(Schema.LEGACY, Language.UNKNOWN_LANGUAGE, "", "", "", Nil, Nil) } -case class TextDocument( - schema: Schema, - language: Language, - uri: String, - text: String, - md5: String, - symbols: Seq[SymbolInformation], - occurrences: Seq[SymbolOccurrence] -) extends SemanticdbMessage[TextDocument] { - private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 - private[this] def __computeSerializedValue(): _root_.scala.Int = { + +final case class TextDocument( + schema: Schema, + language: Language, + uri: String, + text: String, + md5: String, + symbols: Seq[SymbolInformation], + occurrences: Seq[SymbolOccurrence] +) extends SemanticdbMessage[TextDocument] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { var __size = 0 { @@ -58,7 +61,7 @@ case class TextDocument( } __size } - final override def serializedSize: _root_.scala.Int = { + final override def serializedSize: Int = { var read = __serializedSizeCachedValue if (read == 0) { read = __computeSerializedValue() @@ -66,7 +69,7 @@ case class TextDocument( } read } - def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = { + def writeTo(`_output__`: SemanticdbOutputStream): Unit = { { val __v = schema if (__v != Schema.LEGACY) { @@ -109,8 +112,8 @@ case class TextDocument( var __uri = this.uri var __md5 = this.md5 var __language = this.language - val __symbols = (_root_.scala.collection.immutable.Vector.newBuilder[SymbolInformation] ++= this.symbols) - val __occurrences = (_root_.scala.collection.immutable.Vector.newBuilder[SymbolOccurrence] ++= this.occurrences) + val __symbols = (Vector.newBuilder[SymbolInformation] ++= this.symbols) + val __occurrences = (Vector.newBuilder[SymbolOccurrence] ++= this.occurrences) var _done__ = false while (!_done__) { val _tag__ = _input__.readTag() diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala index e66cb875f214..1751dfaad186 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala @@ -1,6 +1,7 @@ package dotty.tools.dotc.semanticdb import dotty.tools.dotc.semanticdb.internal._ +import scala.annotation.internal.sharable object TextDocuments { def parseFrom(in: Array[Byte]): TextDocuments = { @@ -9,11 +10,12 @@ object TextDocuments { def parseFrom(in: SemanticdbInputStream): TextDocuments = { defaultInstance.mergeFrom(in) } - def defaultInstance: TextDocuments = TextDocuments(Nil) + lazy val defaultInstance: TextDocuments = TextDocuments(Nil) } -case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage[TextDocuments] { - private[this] var __serializedSizeCachedValue: _root_.scala.Int = 0 - private[this] def __computeSerializedValue(): _root_.scala.Int = { +final case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage[TextDocuments] derives Eql { + @sharable + private var __serializedSizeCachedValue: Int = 0 + private def __computeSerializedValue(): Int = { var __size = 0 documents.foreach { __item => val __value = __item @@ -23,7 +25,7 @@ case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage } __size } - final override def serializedSize: _root_.scala.Int = { + final override def serializedSize: Int = { var read = __serializedSizeCachedValue if (read == 0) { read = __computeSerializedValue() @@ -31,7 +33,7 @@ case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage } read } - def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = { + def writeTo(`_output__`: SemanticdbOutputStream): Unit = { documents.foreach { __v => val __m = __v _output__.writeTag(1, 2) @@ -40,7 +42,7 @@ case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage }; } def mergeFrom(`_input__`: SemanticdbInputStream): TextDocuments = { - val __documents = (_root_.scala.collection.immutable.Vector.newBuilder[TextDocument] ++= this.documents) + val __documents = (Vector.newBuilder[TextDocument] ++= this.documents) var _done__ = false while (!_done__) { val _tag__ = _input__.readTag() From 69e41219d29501f5a4d03feb97a407f104a2c134 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 13 Nov 2019 16:10:03 +0100 Subject: [PATCH 055/107] add occurences for private within --- compiler/src/dotty/tools/dotc/ast/Trees.scala | 2 +- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 10 ++++++++++ tests/semanticdb/expect/Access.expect.scala | 2 +- 3 files changed, 12 insertions(+), 2 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala index 98bcb43dbdc7..d22a1963aecd 100644 --- a/compiler/src/dotty/tools/dotc/ast/Trees.scala +++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala @@ -348,7 +348,7 @@ object Trees { if (rawMods.is(Synthetic) || name.toTermName == nme.ERROR) Span(point) else { val realName = name.stripModuleClassSuffix.lastPart.toString - val nameStart = + val nameStart = // TODO: This is not used if (point != span.start) point else { // Point might be too far away from start to be recorded. In this case we fall back to scanning diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 823eb419698d..da6e61d7a7e2 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -232,6 +232,13 @@ class ExtractSemanticDB extends Phase { if !sym.is(Package) registerSymbol(sym, symbol) + private def spanOfSymbol(sym: Symbol, span: Span)(given Context): Span = { + val contents = if source.exists then source.content() else Array.empty[Char] + val idx = contents.indexOfSlice(sym.name.show, span.start) + val start = if idx >= 0 then idx else span.start + Span(start, start + sym.name.show.length, start) + } + override def traverse(tree: Tree)(given ctx: Context): Unit = def registerPath(expr: Tree): Unit = expr match case t @ Select(expr, _) => @@ -251,6 +258,9 @@ class ExtractSemanticDB extends Phase { case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => registerDefinition(tree.symbol, tree.nameSpan) + val privateWithin = tree.symbol.privateWithin + if privateWithin `ne` NoSymbol + registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) traverseChildren(tree) case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => diff --git a/tests/semanticdb/expect/Access.expect.scala b/tests/semanticdb/expect/Access.expect.scala index fd693daf69c6..8d961c23ca83 100644 --- a/tests/semanticdb/expect/Access.expect.scala +++ b/tests/semanticdb/expect/Access.expect.scala @@ -3,7 +3,7 @@ package example class Access/*<<=example.Access#*/ { private def m1/*<<=example.Access#m1().*/ = ???/*=>>scala.Predef.`???`().*/ private[this] def m2/*<<=example.Access#m2().*/ = ???/*=>>scala.Predef.`???`().*/ - private[Access] def m3/*<<=example.Access#m3().*/ = ???/*=>>scala.Predef.`???`().*/ + private[Access/*=>>example.Access#*/] def m3/*<<=example.Access#m3().*/ = ???/*=>>scala.Predef.`???`().*/ protected def m4/*<<=example.Access#m4().*/ = ???/*=>>scala.Predef.`???`().*/ protected[this] def m5/*<<=example.Access#m5().*/ = ???/*=>>scala.Predef.`???`().*/ protected[example] def m6/*<<=example.Access#m6().*/ = ???/*=>>scala.Predef.`???`().*/ From 2af8a3aa5f0d4095e59e3243404e3b0450e10b71 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 13 Nov 2019 17:33:22 +0100 Subject: [PATCH 056/107] Traverse all paths --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 12 ++---------- tests/semanticdb/expect/Enums.expect.scala | 2 +- .../expect/ImplicitConversion.expect.scala | 2 +- tests/semanticdb/expect/Prefixes.expect.scala | 4 ++-- 4 files changed, 6 insertions(+), 14 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index da6e61d7a7e2..43b4707d75a5 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -177,7 +177,6 @@ class ExtractSemanticDB extends Phase { || sym.isLocalDummy || sym.is(Synthetic) || (sym.owner.is(Synthetic) && !sym.isAllOf(EnumCase)) || sym.isAnonymous - || sym.isPrimaryConstructor && excludeDef(sym.owner) || excludeDefStrict(sym) private def excludeDefStrict(sym: Symbol)(given Context): Boolean = @@ -209,7 +208,7 @@ class ExtractSemanticDB extends Phase { language = Language.SCALA, kind = symbolKind(sym), properties = symbolProps(sym).foldLeft(0)(_ | _.value), - displayName = sym.name.show + displayName = (if sym.is(ModuleClass) then sym.sourceModule else sym).name.show ) private def registerSymbol(sym: Symbol, symbolName: String)(given Context): Unit = @@ -240,13 +239,6 @@ class ExtractSemanticDB extends Phase { } override def traverse(tree: Tree)(given ctx: Context): Unit = - def registerPath(expr: Tree): Unit = expr match - case t @ Select(expr, _) => - registerUse(t.symbol, t.span) - registerPath(expr) - - case _ => - for annot <- tree.symbol.annotations do if annot.tree.span.exists && annot.symbol.owner != defn.ScalaAnnotationInternal @@ -306,7 +298,7 @@ class ExtractSemanticDB extends Phase { registerUse(alt.symbol, sel.imported.span) if (alt.symbol.companionClass.exists) registerUse(alt.symbol.companionClass, sel.imported.span) - registerPath(tree.expr) + traverseChildren(tree) case tree: Inlined => traverse(tree.call) case tree: Annotated => // skip the annotation (see `@param` in https://github.com/scalameta/scalameta/blob/633824474e99bbfefe12ad0cc73da1fe064b3e9b/tests/jvm/src/test/resources/example/Annotations.scala#L37) diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index 9507c4f488dd..c593e94e00fe 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -1,5 +1,5 @@ object Enums/*<<=_empty_.Enums.*/ with - import =:=._ + import =:=/*=>>_empty_.Enums.`=:=`.*/._ enum Colour/*<<=_empty_.Enums.Colour#*/ with case /*=>>scala.runtime.EnumValues#``().*/Red/*=>>_empty_.Enums.Colour.Red.*//*<<=_empty_.Enums.Colour.Red.*/, Green/*=>>_empty_.Enums.Colour.Green.*//*<<=_empty_.Enums.Colour.Green.*/, Blue/*=>>_empty_.Enums.Colour.Blue.*//*<<=_empty_.Enums.Colour.Blue.*/ diff --git a/tests/semanticdb/expect/ImplicitConversion.expect.scala b/tests/semanticdb/expect/ImplicitConversion.expect.scala index 4aa1ac0661c7..90659b033697 100644 --- a/tests/semanticdb/expect/ImplicitConversion.expect.scala +++ b/tests/semanticdb/expect/ImplicitConversion.expect.scala @@ -3,7 +3,7 @@ package example import scala.language/*=>>scalaShadowing.language.*/.implicitConversions/*=>>scalaShadowing.language.implicitConversions.*/ class ImplicitConversion/*<<=example.ImplicitConversion#*/ { - import ImplicitConversion._ + import ImplicitConversion/*=>>example.ImplicitConversion.*/._ implicit def string2Number/*<<=example.ImplicitConversion#string2Number().*/( string/*<<=example.ImplicitConversion#string2Number().(string)*/: String/*=>>scala.Predef.String#*/ ): Int/*=>>scala.Int#*/ = 42 diff --git a/tests/semanticdb/expect/Prefixes.expect.scala b/tests/semanticdb/expect/Prefixes.expect.scala index 14a5ee8d2704..cf863a438b35 100644 --- a/tests/semanticdb/expect/Prefixes.expect.scala +++ b/tests/semanticdb/expect/Prefixes.expect.scala @@ -23,11 +23,11 @@ object Test/*<<=prefixes.Test.*/ { val c/*<<=prefixes.Test.c.*/: C/*=>>prefixes.C#*/ = ???/*=>>scala.Predef.`???`().*/ def m2/*<<=prefixes.Test.m2().*/: c/*=>>prefixes.Test.c.*/.T/*=>>prefixes.C#T#*/ = ???/*=>>scala.Predef.`???`().*/ def k2/*<<=prefixes.Test.k2().*/: c/*=>>prefixes.Test.c.*/.N/*=>>prefixes.C#N.*/.U/*=>>prefixes.C#N.U#*/ = ???/*=>>scala.Predef.`???`().*/ - import c.N/*=>>prefixes.C#N.*/._ + import c/*=>>prefixes.Test.c.*/.N/*=>>prefixes.C#N.*/._ def k3/*<<=prefixes.Test.k3().*/: U = ???/*=>>scala.Predef.`???`().*/ def n2/*<<=prefixes.Test.n2().*/: M/*=>>prefixes.M.*/.T/*=>>prefixes.M.T#*/ = ???/*=>>scala.Predef.`???`().*/ - import M._ + import M/*=>>prefixes.M.*/._ def n3/*<<=prefixes.Test.n3().*/: T/*=>>prefixes.M.T#*/ = ???/*=>>scala.Predef.`???`().*/ } From f62ce3f9d636a6d2f6d6af3ebb81f67ef694dbc4 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 13 Nov 2019 17:36:24 +0100 Subject: [PATCH 057/107] unique package objects for top level definitions --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 5 ++++- tests/semanticdb/expect/toplevel.expect.scala | 10 +++++----- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 43b4707d75a5..d4bc3e408a12 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -105,6 +105,9 @@ class ExtractSemanticDB extends Phase { b.append('+').append(idx + 1) case _ => + def (sym: Symbol) isScala2PackageObject(given Context): Boolean = + sym.name == nme.PACKAGE && sym.owner.is(Package) && sym.is(Module) + def addDescriptor(sym: Symbol): Unit = if sym.is(ModuleClass) then addDescriptor(sym.sourceModule) @@ -116,7 +119,7 @@ class ExtractSemanticDB extends Phase { b.append(Symbols.RootPackage) else if sym.isEmptyPackage then b.append(Symbols.EmptyPackage) - else if (sym.isPackageObject) then + else if (sym.isScala2PackageObject) then b.append(Symbols.PackageObjectDescriptor) else addName(sym.name) diff --git a/tests/semanticdb/expect/toplevel.expect.scala b/tests/semanticdb/expect/toplevel.expect.scala index cea06b0313af..4847a33a41d1 100644 --- a/tests/semanticdb/expect/toplevel.expect.scala +++ b/tests/semanticdb/expect/toplevel.expect.scala @@ -1,5 +1,5 @@ -inline val a = "/*<<=_empty_.package.*//*<<=_empty_.package.a.*/" -def (x: Int/*<<=_empty_.package.combine().*//*<<=_empty_.package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.package.combine().(y)*/ -def combine/*<<=_empty_.package.combine(+1).*/(x/*<<=_empty_.package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.package.combine(+1).(z)*/ -def combine/*<<=_empty_.package.combine(+2).*/ = 0 -def foo/*<<=_empty_.package.foo().*/ = "foo" +inline val a = "/*<<=_empty_.toplevel$package.*//*<<=_empty_.toplevel$package.a.*/" +def (x: Int/*<<=_empty_.toplevel$package.combine().*//*<<=_empty_.toplevel$package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.toplevel$package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine().(y)*/ +def combine/*<<=_empty_.toplevel$package.combine(+1).*/(x/*<<=_empty_.toplevel$package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.toplevel$package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.toplevel$package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.toplevel$package.combine(+1).(z)*/ +def combine/*<<=_empty_.toplevel$package.combine(+2).*/ = 0 +def foo/*<<=_empty_.toplevel$package.foo().*/ = "foo" From 801fa972ad84f74340bdfd197ef70d7430c0d6bf Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 14 Nov 2019 10:29:11 +0100 Subject: [PATCH 058/107] add props and kind to all SymbolInformation --- .../dotc/semanticdb/ExtractSemanticDB.scala | 112 ++++++++++++++---- .../dotc/semanticdb/SymbolInformation.scala | 34 +++--- 2 files changed, 108 insertions(+), 38 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index d4bc3e408a12..2f5b0700fd66 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -25,6 +25,7 @@ import java.nio.file.Paths */ class ExtractSemanticDB extends Phase { import ast.tpd._ + import untpd.given override val phaseName: String = ExtractSemanticDB.name @@ -40,8 +41,12 @@ class ExtractSemanticDB extends Phase { extract.traverse(unit.tpdTree) ExtractSemanticDB.write(unit.source, extract.occurrences.toList, extract.symbols.toList) + def (sym: Symbol) isScala2PackageObject(given Context): Boolean = + sym.name == nme.PACKAGE && sym.owner.is(Package) && sym.is(Module) + /** Extractor of symbol occurrences from trees */ class Extractor extends TreeTraverser { + import Scala.{_, given} private var nextLocalIdx: Int = 0 @@ -64,9 +69,20 @@ class ExtractSemanticDB extends Phase { private val unicodeEscape = raw"\$$u(\p{XDigit}{4})".r + /**Necessary because if this phase is before `getters` then accessor info is not propagated from the tree to the + * symbol yet. + */ + private enum SymbolKind derives Eql with + kind => + + case Val, Var, Other + + def isValOrVar: Boolean = kind match + case Val | Var => true + case _ => false + /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = - import Scala._ def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) @@ -105,9 +121,6 @@ class ExtractSemanticDB extends Phase { b.append('+').append(idx + 1) case _ => - def (sym: Symbol) isScala2PackageObject(given Context): Boolean = - sym.name == nme.PACKAGE && sym.owner.is(Package) && sym.is(Module) - def addDescriptor(sym: Symbol): Unit = if sym.is(ModuleClass) then addDescriptor(sym.sourceModule) @@ -194,28 +207,82 @@ class ExtractSemanticDB extends Phase { private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = excludeDefStrict(sym) || (excludeDef(sym) && span.start == span.end) - private def symbolKind(sym: Symbol)(given Context): SymbolInformation.Kind = - if sym.name == nme.CONSTRUCTOR + private def symbolKind(sym: Symbol, symbol: String, symkind: SymbolKind)(given Context): SymbolInformation.Kind = + if sym.is(Local) || symbol.isLocal + SymbolInformation.Kind.LOCAL + else if sym.isInlineMethod || sym.is(Macro) + SymbolInformation.Kind.MACRO + else if sym.isOneOf(Method) || symkind.isValOrVar + SymbolInformation.Kind.METHOD + else if sym.isTypeParam + SymbolInformation.Kind.TYPE_PARAMETER + else if sym.isType + SymbolInformation.Kind.TYPE + else if sym.is(TermParam) + SymbolInformation.Kind.PARAMETER + else if sym.isScala2PackageObject + SymbolInformation.Kind.PACKAGE_OBJECT + else if sym.is(Module) + SymbolInformation.Kind.OBJECT + else if sym.is(Package) + SymbolInformation.Kind.PACKAGE + else if sym.isClass + SymbolInformation.Kind.CLASS + else if sym.isAllOf(JavaInterface) + SymbolInformation.Kind.INTERFACE + else if sym.is(Trait) + SymbolInformation.Kind.TRAIT + else if sym.isSelfSym + SymbolInformation.Kind.SELF_PARAMETER + else if sym.is(ParamAccessor) + SymbolInformation.Kind.FIELD + else if sym.name == nme.CONSTRUCTOR SymbolInformation.Kind.CONSTRUCTOR else SymbolInformation.Kind.UNKNOWN_KIND - private def symbolProps(sym: Symbol)(given Context): Set[SymbolInformation.Property] = + private def symbolProps(sym: Symbol, symkind: SymbolKind)(given Context): Set[SymbolInformation.Property] = + val props = mutable.HashSet.empty[SymbolInformation.Property] if sym.isPrimaryConstructor - Set(SymbolInformation.Property.PRIMARY) - else - Set.empty - - private def symbolInfo(sym: Symbol, symbolName: String)(given Context): SymbolInformation = SymbolInformation( + props += SymbolInformation.Property.PRIMARY + if sym.is(Abstract) + props += SymbolInformation.Property.ABSTRACT + if sym.is(Final) + props += SymbolInformation.Property.FINAL + if sym.is(Sealed) + props += SymbolInformation.Property.SEALED + if sym.isOneOf(GivenOrImplicit) + props += SymbolInformation.Property.IMPLICIT + if sym.is(Lazy) + props += SymbolInformation.Property.LAZY + if sym.isAllOf(CaseClass) || sym.isAllOf(EnumCase) + props += SymbolInformation.Property.CASE + if sym.is(Covariant) + props += SymbolInformation.Property.COVARIANT + if sym.is(Contravariant) + props += SymbolInformation.Property.CONTRAVARIANT + if sym.isAllOf(DefaultMethod | JavaDefined) || sym.is(Accessor) && sym.name.is(NameKinds.DefaultGetterName) + props += SymbolInformation.Property.DEFAULT + if symkind == SymbolKind.Val + props += SymbolInformation.Property.VAL + if symkind == SymbolKind.Var + props += SymbolInformation.Property.VAR + if sym.is(JavaStatic) + props += SymbolInformation.Property.STATIC + if sym.is(Enum) + props += SymbolInformation.Property.ENUM + props.toSet + + private def symbolInfo(sym: Symbol, symbolName: String, symkind: SymbolKind)(given Context): SymbolInformation = SymbolInformation( symbol = symbolName, language = Language.SCALA, - kind = symbolKind(sym), - properties = symbolProps(sym).foldLeft(0)(_ | _.value), + kind = symbolKind(sym, symbolName, symkind), + properties = symbolProps(sym, symkind).foldLeft(0)(_ | _.value), displayName = (if sym.is(ModuleClass) then sym.sourceModule else sym).name.show ) - private def registerSymbol(sym: Symbol, symbolName: String)(given Context): Unit = - symbols += symbolInfo(sym, symbolName) + private def registerSymbol(sym: Symbol, symbolName: String, symkind: SymbolKind)(given Context): Unit = + symbols += symbolInfo(sym, symbolName, symkind) private def registerOccurrence(symbol: String, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = val occ = SymbolOccurrence(symbol, range(span), role) @@ -227,12 +294,11 @@ class ExtractSemanticDB extends Phase { if !excludeUseStrict(sym, span) && !isWildcard(sym.name) then registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE) - private def registerDefinition(sym: Symbol, span: Span)(given Context) = + private def registerDefinition(sym: Symbol, span: Span, symkind: SymbolKind)(given Context) = if !isWildcard(sym.name) then val symbol = symbolName(sym) registerOccurrence(symbol, span, SymbolOccurrence.Role.DEFINITION) - if !sym.is(Package) - registerSymbol(sym, symbol) + registerSymbol(sym, symbol, symkind) private def spanOfSymbol(sym: Symbol, span: Span)(given Context): Span = { val contents = if source.exists then source.content() else Array.empty[Char] @@ -252,14 +318,18 @@ class ExtractSemanticDB extends Phase { case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => - registerDefinition(tree.symbol, tree.nameSpan) + val symkind = tree match + case _: ValDef => if tree.mods.is(Mutable) then SymbolKind.Var else SymbolKind.Val + case _: Bind => SymbolKind.Val + case _ => SymbolKind.Other + registerDefinition(tree.symbol, tree.nameSpan, symkind) val privateWithin = tree.symbol.privateWithin if privateWithin `ne` NoSymbol registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) traverseChildren(tree) case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => - registerDefinition(tree.constr.symbol, tree.constr.span) + registerDefinition(tree.constr.symbol, tree.constr.span, SymbolKind.Other) for vparams <- tree.constr.vparamss vparam <- vparams diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala index d48f1dd46a0a..fbc49d25939a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala @@ -63,7 +63,7 @@ object SymbolInformation { case 19 => LOCAL case 20 => FIELD case 21 => CONSTRUCTOR - case __other => Unrecognized(__other) + case id => Unrecognized(id) } } @@ -105,22 +105,22 @@ object SymbolInformation { final case class Unrecognized(id: Int) extends Property(id) def fromValue(value: Int): Property = value match { - case 0 => UNKNOWN_PROPERTY - case 4 => ABSTRACT - case 8 => FINAL - case 16 => SEALED - case 32 => IMPLICIT - case 64 => LAZY - case 128 => CASE - case 256 => COVARIANT - case 512 => CONTRAVARIANT - case 1024 => VAL - case 2048 => VAR - case 4096 => STATIC - case 8192 => PRIMARY - case 16384 => ENUM - case 32768 => DEFAULT - case __other => Unrecognized(__other) + case 0x0 => UNKNOWN_PROPERTY + case 0x4 => ABSTRACT + case 0x8 => FINAL + case 0x10 => SEALED + case 0x20 => IMPLICIT + case 0x40 => LAZY + case 0x80 => CASE + case 0x100 => COVARIANT + case 0x200 => CONTRAVARIANT + case 0x400 => VAL + case 0x800 => VAR + case 0x1000 => STATIC + case 0x2000 => PRIMARY + case 0x4000 => ENUM + case 0x8000 => DEFAULT + case id => Unrecognized(id) } } } From 637293ca0bd34967e5fa240c9d164b3071b7d70c Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 14 Nov 2019 11:01:45 +0100 Subject: [PATCH 059/107] change format of expect test output --- .../dotc/semanticdb/ExtractSemanticDB.scala | 6 +- .../tools/dotc/semanticdb/Semanticdbs.scala | 6 +- tests/semanticdb/expect/Access.expect.scala | 16 +- tests/semanticdb/expect/Advanced.expect.scala | 50 ++--- .../expect/Annotations.expect.scala | 46 ++--- .../semanticdb/expect/Anonymous.expect.scala | 24 +-- tests/semanticdb/expect/Classes.expect.scala | 34 ++-- .../expect/Definitions.expect.scala | 12 +- tests/semanticdb/expect/Empty.expect.scala | 8 +- .../expect/EmptyObject.expect.scala | 2 +- tests/semanticdb/expect/Enums.expect.scala | 86 ++++----- .../expect/EtaExpansion.expect.scala | 6 +- tests/semanticdb/expect/Example.expect.scala | 12 +- tests/semanticdb/expect/Flags.expect.scala | 40 ++-- .../expect/ForComprehension.expect.scala | 62 +++--- tests/semanticdb/expect/Givens.expect.scala | 22 +-- .../expect/ImplicitConversion.expect.scala | 46 ++--- tests/semanticdb/expect/Imports.expect.scala | 2 +- .../expect/InstrumentTyper.expect.scala | 42 ++-- .../semanticdb/expect/Issue1749.expect.scala | 18 +- tests/semanticdb/expect/Local.expect.scala | 8 +- tests/semanticdb/expect/Locals.expect.scala | 8 +- .../semanticdb/expect/MetacJava.expect.scala | 30 +-- .../expect/MethodUsages.expect.scala | 56 +++--- tests/semanticdb/expect/Methods.expect.scala | 64 +++---- .../expect/NamedApplyBlock.expect.scala | 18 +- .../expect/NamedArguments.expect.scala | 8 +- .../expect/NewModifiers.expect.scala | 6 +- tests/semanticdb/expect/Objects.expect.scala | 4 +- .../semanticdb/expect/Overrides.expect.scala | 4 +- tests/semanticdb/expect/Prefixes.expect.scala | 40 ++-- tests/semanticdb/expect/Selfs.expect.scala | 10 +- .../semanticdb/expect/Synthetic.expect.scala | 70 +++---- tests/semanticdb/expect/Traits.expect.scala | 14 +- tests/semanticdb/expect/Types.expect.scala | 180 +++++++++--------- .../semanticdb/expect/ValPattern.expect.scala | 58 +++--- tests/semanticdb/expect/Vals.expect.scala | 64 +++---- tests/semanticdb/expect/Vararg.expect.scala | 6 +- .../expect/filename with spaces.expect.scala | 2 +- .../semanticdb/expect/local-file.expect.scala | 8 +- .../expect/semanticdb-extract.expect.scala | 24 +-- tests/semanticdb/expect/toplevel.expect.scala | 10 +- 42 files changed, 614 insertions(+), 618 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 2f5b0700fd66..58841502b1bc 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -330,11 +330,7 @@ class ExtractSemanticDB extends Phase { case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => registerDefinition(tree.constr.symbol, tree.constr.span, SymbolKind.Other) - for - vparams <- tree.constr.vparamss - vparam <- vparams - do - traverse(vparam.tpt) // the accessor symbol is traversed in the body + tree.constr.vparamss.flatten.foreach(vparam => traverse(vparam.tpt)) // the accessor symbol is traversed in the body for parent <- tree.parentsOrDerived do if parent.symbol != defn.ObjectClass.primaryConstructor diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index 36bba56fe9fa..8557a407f6b4 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -50,7 +50,7 @@ object Semanticdbs { * Example output (NOTE, slightly modified to avoid "unclosed comment" errors): * {{{ * class Example *example/Example#* { - * val a *example/Example#a.* : String *scala/Predef.String#* = "1" + * val a *example/Example#a.* : String *scala/Predef.String#* = "1" * } * }}} **/ @@ -73,8 +73,8 @@ object Semanticdbs { if !occ.symbol.isPackage && !isPrimaryConstructor sb.append(doc.text.substring(offset, end)) sb.append("/*") - .append(if (occ.role.isDefinition) "<<=" else "=>>") - .append(occ.symbol.replace('/', '.')) + .append(if (occ.role.isDefinition) "<-" else "->") + .append(occ.symbol.replace("/", "::")) .append("*/") offset = end } diff --git a/tests/semanticdb/expect/Access.expect.scala b/tests/semanticdb/expect/Access.expect.scala index 8d961c23ca83..3186ce2a68c3 100644 --- a/tests/semanticdb/expect/Access.expect.scala +++ b/tests/semanticdb/expect/Access.expect.scala @@ -1,11 +1,11 @@ package example -class Access/*<<=example.Access#*/ { - private def m1/*<<=example.Access#m1().*/ = ???/*=>>scala.Predef.`???`().*/ - private[this] def m2/*<<=example.Access#m2().*/ = ???/*=>>scala.Predef.`???`().*/ - private[Access/*=>>example.Access#*/] def m3/*<<=example.Access#m3().*/ = ???/*=>>scala.Predef.`???`().*/ - protected def m4/*<<=example.Access#m4().*/ = ???/*=>>scala.Predef.`???`().*/ - protected[this] def m5/*<<=example.Access#m5().*/ = ???/*=>>scala.Predef.`???`().*/ - protected[example] def m6/*<<=example.Access#m6().*/ = ???/*=>>scala.Predef.`???`().*/ - def m7/*<<=example.Access#m7().*/ = ???/*=>>scala.Predef.`???`().*/ +class Access/*<-example::Access#*/ { + private def m1/*<-example::Access#m1().*/ = ???/*->scala::Predef.`???`().*/ + private[this] def m2/*<-example::Access#m2().*/ = ???/*->scala::Predef.`???`().*/ + private[Access/*->example::Access#*/] def m3/*<-example::Access#m3().*/ = ???/*->scala::Predef.`???`().*/ + protected def m4/*<-example::Access#m4().*/ = ???/*->scala::Predef.`???`().*/ + protected[this] def m5/*<-example::Access#m5().*/ = ???/*->scala::Predef.`???`().*/ + protected[example] def m6/*<-example::Access#m6().*/ = ???/*->scala::Predef.`???`().*/ + def m7/*<-example::Access#m7().*/ = ???/*->scala::Predef.`???`().*/ } diff --git a/tests/semanticdb/expect/Advanced.expect.scala b/tests/semanticdb/expect/Advanced.expect.scala index 6c0984a2ef8a..e4ae3370cba8 100644 --- a/tests/semanticdb/expect/Advanced.expect.scala +++ b/tests/semanticdb/expect/Advanced.expect.scala @@ -1,41 +1,41 @@ package advanced -import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ -import scala.language/*=>>scalaShadowing.language.*/.reflectiveCalls/*=>>scalaShadowing.language.reflectiveCalls.*/ +import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ +import scala.language/*->scalaShadowing::language.*/.reflectiveCalls/*->scalaShadowing::language.reflectiveCalls.*/ -import scala.reflect.Selectable/*=>>scala.reflect.Selectable.*/.reflectiveSelectable/*=>>scala.reflect.Selectable.reflectiveSelectable().*/ +import scala.reflect.Selectable/*->scala::reflect::Selectable.*/.reflectiveSelectable/*->scala::reflect::Selectable.reflectiveSelectable().*/ -class C/*<<=advanced.C#*/[T/*<<=advanced.C#[T]*/] { - def t/*<<=advanced.C#t().*/: T/*=>>advanced.C#[T]*/ = ???/*=>>scala.Predef.`???`().*/ +class C/*<-advanced::C#*/[T/*<-advanced::C#[T]*/] { + def t/*<-advanced::C#t().*/: T/*->advanced::C#[T]*/ = ???/*->scala::Predef.`???`().*/ } -class Structural/*<<=advanced.Structural#*/ { - def s1/*<<=advanced.Structural#s1().*/: { val x/*<<=local0*/: Int/*=>>scala.Int#*/ } = ???/*=>>scala.Predef.`???`().*/ - def s2/*<<=advanced.Structural#s2().*/: { val x/*<<=local1*/: Int/*=>>scala.Int#*/ } = new { val x/*<<=local3*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } - def s3/*<<=advanced.Structural#s3().*/: { def m/*<<=local4*/(x/*<<=local5*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ } = new { def m/*<<=local7*/(x/*<<=local8*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } +class Structural/*<-advanced::Structural#*/ { + def s1/*<-advanced::Structural#s1().*/: { val x/*<-local0*/: Int/*->scala::Int#*/ } = ???/*->scala::Predef.`???`().*/ + def s2/*<-advanced::Structural#s2().*/: { val x/*<-local1*/: Int/*->scala::Int#*/ } = new { val x/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + def s3/*<-advanced::Structural#s3().*/: { def m/*<-local4*/(x/*<-local5*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ } = new { def m/*<-local7*/(x/*<-local8*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } } -class Wildcards/*<<=advanced.Wildcards#*/ { - def e1/*<<=advanced.Wildcards#e1().*/: List/*=>>scala.package.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ +class Wildcards/*<-advanced::Wildcards#*/ { + def e1/*<-advanced::Wildcards#e1().*/: List/*->scala::package.List#*/[_] = ???/*->scala::Predef.`???`().*/ } -object Test/*<<=advanced.Test.*/ { - val s/*<<=advanced.Test.s.*/ = new Structural/*=>>advanced.Structural#*/ - val s1/*<<=advanced.Test.s1.*/ = s/*=>>advanced.Test.s.*/.s1/*=>>advanced.Structural#s1().*/ - val s1x/*<<=advanced.Test.s1x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s1/*=>>advanced.Structural#s1().*//*=>>scala.Selectable#selectDynamic().*/.x - val s2/*<<=advanced.Test.s2.*/ = s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*/ - val s2x/*<<=advanced.Test.s2x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s2/*=>>advanced.Structural#s2().*//*=>>scala.Selectable#selectDynamic().*/.x - val s3/*<<=advanced.Test.s3.*/ = s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*/ - val s3x/*<<=advanced.Test.s3x.*/ = /*=>>scala.reflect.Selectable.reflectiveSelectable().*/s/*=>>advanced.Test.s.*/.s3/*=>>advanced.Structural#s3().*//*=>>scala.Selectable#applyDynamic().*/.m/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer#TYPE.*/(???/*=>>scala.Predef.`???`().*/) +object Test/*<-advanced::Test.*/ { + val s/*<-advanced::Test.s.*/ = new Structural/*->advanced::Structural#*/ + val s1/*<-advanced::Test.s1.*/ = s/*->advanced::Test.s.*/.s1/*->advanced::Structural#s1().*/ + val s1x/*<-advanced::Test.s1x.*/ = /*->scala::reflect::Selectable.reflectiveSelectable().*/s/*->advanced::Test.s.*/.s1/*->advanced::Structural#s1().*//*->scala::Selectable#selectDynamic().*/.x + val s2/*<-advanced::Test.s2.*/ = s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*/ + val s2x/*<-advanced::Test.s2x.*/ = /*->scala::reflect::Selectable.reflectiveSelectable().*/s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*//*->scala::Selectable#selectDynamic().*/.x + val s3/*<-advanced::Test.s3.*/ = s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*/ + val s3x/*<-advanced::Test.s3x.*/ = /*->scala::reflect::Selectable.reflectiveSelectable().*/s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*//*->scala::Selectable#applyDynamic().*/.m/*->scala::reflect::ClassTag.apply().*//*->java::lang::Integer#TYPE.*/(???/*->scala::Predef.`???`().*/) - val e/*<<=advanced.Test.e.*/ = new Wildcards/*=>>advanced.Wildcards#*/ - val e1/*<<=advanced.Test.e1.*/ = e/*=>>advanced.Test.e.*/.e1/*=>>advanced.Wildcards#e1().*/ - val e1x/*<<=advanced.Test.e1x.*/ = e/*=>>advanced.Test.e.*/.e1/*=>>advanced.Wildcards#e1().*/.head/*=>>scala.collection.IterableOps#head().*/ + val e/*<-advanced::Test.e.*/ = new Wildcards/*->advanced::Wildcards#*/ + val e1/*<-advanced::Test.e1.*/ = e/*->advanced::Test.e.*/.e1/*->advanced::Wildcards#e1().*/ + val e1x/*<-advanced::Test.e1x.*/ = e/*->advanced::Test.e.*/.e1/*->advanced::Wildcards#e1().*/.head/*->scala::collection::IterableOps#head().*/ { - (???/*=>>scala.Predef.`???`().*/ : Any/*=>>scala.Any#*/) match { - case e3/*<<=local9*/: List/*=>>scala.package.List#*/[_] => - val e3x/*<<=local10*/ = e3/*=>>local9*/.head/*=>>scala.collection.IterableOps#head().*/ + (???/*->scala::Predef.`???`().*/ : Any/*->scala::Any#*/) match { + case e3/*<-local9*/: List/*->scala::package.List#*/[_] => + val e3x/*<-local10*/ = e3/*->local9*/.head/*->scala::collection::IterableOps#head().*/ () } } diff --git a/tests/semanticdb/expect/Annotations.expect.scala b/tests/semanticdb/expect/Annotations.expect.scala index db114f3f5401..368b52236107 100644 --- a/tests/semanticdb/expect/Annotations.expect.scala +++ b/tests/semanticdb/expect/Annotations.expect.scala @@ -2,37 +2,37 @@ package annot import com.javacp.annot._ import scala.annotation.meta._ -import scala.language/*=>>scalaShadowing.language.*/.experimental/*=>>scalaShadowing.language.experimental.*/.macros/*=>>scalaShadowing.language.experimental.macros.*/ +import scala.language/*->scalaShadowing::language.*/.experimental/*->scalaShadowing::language.experimental.*/.macros/*->scalaShadowing::language.experimental.macros.*/ -@ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ -class Annotations/*<<=annot.Annotations#*/[@TypeParameterAnnotation/*=>>com.javacp.annot.TypeParameterAnnotation#*/ T/*<<=annot.Annotations#[T]*/](@ParameterAnnotation/*=>>com.javacp.annot.ParameterAnnotation#*/ x/*<<=annot.Annotations#x.*/: T/*=>>annot.Annotations#``().[T]*/) { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => - @FieldAnnotation/*=>>com.javacp.annot.FieldAnnotation#*/ - val field/*<<=annot.Annotations#field.*/ = 42 +@ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/ +class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#``().[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => + @FieldAnnotation/*->com::javacp::annot::FieldAnnotation#*/ + val field/*<-annot::Annotations#field.*/ = 42 - @MethodAnnotation/*=>>com.javacp.annot.MethodAnnotation#*/ - def method/*<<=annot.Annotations#method().*/ = { - @LocalAnnotation/*=>>com.javacp.annot.LocalAnnotation#*/ - val local/*<<=local1*/ = 42 - local/*=>>local1*/ + @MethodAnnotation/*->com::javacp::annot::MethodAnnotation#*/ + def method/*<-annot::Annotations#method().*/ = { + @LocalAnnotation/*->com::javacp::annot::LocalAnnotation#*/ + val local/*<-local1*/ = 42 + local/*->local1*/ } - @TypeAnnotation/*=>>com.javacp.annot.TypeAnnotation#*/ - type S/*<<=annot.Annotations#S#*/ + @TypeAnnotation/*->com::javacp::annot::TypeAnnotation#*/ + type S/*<-annot::Annotations#S#*/ } -class B/*<<=annot.B#*/ @ConstructorAnnotation/*=>>com.javacp.annot.ConstructorAnnotation#*/()(x/*<<=annot.B#x.*/: Int/*=>>scala.Int#*/) { - @ConstructorAnnotation/*=>>com.javacp.annot.ConstructorAnnotation#*/ - def this()/*<<=annot.B#``(+1).*/ = this(42) +class B/*<-annot::B#*/ @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/()(x/*<-annot::B#x.*/: Int/*->scala::Int#*/) { + @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/ + def this()/*<-annot::B#``(+1).*/ = this(42) } -@ObjectAnnotation/*=>>com.javacp.annot.ObjectAnnotation#*/ -object M/*<<=annot.M.*/ { - @MacroAnnotation/*=>>com.javacp.annot.MacroAnnotation#*/ - def m/*<<=annot.M.m().*/[TT/*<<=annot.M.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*/ = macro ??? +@ObjectAnnotation/*->com::javacp::annot::ObjectAnnotation#*/ +object M/*<-annot::M.*/ { + @MacroAnnotation/*->com::javacp::annot::MacroAnnotation#*/ + def m/*<-annot::M.m().*/[TT/*<-annot::M.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ??? } -@TraitAnnotation/*=>>com.javacp.annot.TraitAnnotation#*/ -trait T/*<<=annot.T#*/ +@TraitAnnotation/*->com::javacp::annot::TraitAnnotation#*/ +trait T/*<-annot::T#*/ -object Alias/*<<=annot.Alias.*/ { - type A/*<<=annot.Alias.A#*/ = ClassAnnotation/*=>>com.javacp.annot.ClassAnnotation#*/ @param +object Alias/*<-annot::Alias.*/ { + type A/*<-annot::Alias.A#*/ = ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/ @param } diff --git a/tests/semanticdb/expect/Anonymous.expect.scala b/tests/semanticdb/expect/Anonymous.expect.scala index 945414da8267..ee2d433facb5 100644 --- a/tests/semanticdb/expect/Anonymous.expect.scala +++ b/tests/semanticdb/expect/Anonymous.expect.scala @@ -1,20 +1,20 @@ package example -import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ +import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ -class Anonymous/*<<=example.Anonymous#*/ { - this: Anonymous/*=>>example.Anonymous#*/ => +class Anonymous/*<-example::Anonymous#*/ { + this: Anonymous/*->example::Anonymous#*/ => - def locally/*<<=example.Anonymous#locally().*/[A/*<<=example.Anonymous#locally().[A]*/](x/*<<=example.Anonymous#locally().(x)*/: A/*=>>example.Anonymous#locally().[A]*/): A/*=>>example.Anonymous#locally().[A]*/ = x/*=>>example.Anonymous#locally().(x)*/ + def locally/*<-example::Anonymous#locally().*/[A/*<-example::Anonymous#locally().[A]*/](x/*<-example::Anonymous#locally().(x)*/: A/*->example::Anonymous#locally().[A]*/): A/*->example::Anonymous#locally().[A]*/ = x/*->example::Anonymous#locally().(x)*/ - def m1/*<<=example.Anonymous#m1().*/[T/*<<=example.Anonymous#m1().[T]*/[_]] = ???/*=>>scala.Predef.`???`().*/ - def m2/*<<=example.Anonymous#m2().*/: Map/*=>>scala.Predef.Map#*/[_, List/*=>>scala.package.List#*/[_]] = ???/*=>>scala.Predef.`???`().*/ - locally/*=>>example.Anonymous#locally().*/ { - ???/*=>>scala.Predef.`???`().*/ match { case _: List/*=>>scala.package.List#*/[_] => } + def m1/*<-example::Anonymous#m1().*/[T/*<-example::Anonymous#m1().[T]*/[_]] = ???/*->scala::Predef.`???`().*/ + def m2/*<-example::Anonymous#m2().*/: Map/*->scala::Predef.Map#*/[_, List/*->scala::package.List#*/[_]] = ???/*->scala::Predef.`???`().*/ + locally/*->example::Anonymous#locally().*/ { + ???/*->scala::Predef.`???`().*/ match { case _: List/*->scala::package.List#*/[_] => } } - locally/*=>>example.Anonymous#locally().*/ { - val x/*<<=local0*/: Int/*=>>scala.Int#*/ => Int/*=>>scala.Int#*/ = _ => ???/*=>>scala.Predef.`???`().*/ + locally/*->example::Anonymous#locally().*/ { + val x/*<-local0*/: Int/*->scala::Int#*/ => Int/*->scala::Int#*/ = _ => ???/*->scala::Predef.`???`().*/ } - trait Foo/*<<=example.Anonymous#Foo#*/ - val foo/*<<=example.Anonymous#foo.*/ = new Foo/*=>>example.Anonymous#Foo#*/ {} + trait Foo/*<-example::Anonymous#Foo#*/ + val foo/*<-example::Anonymous#foo.*/ = new Foo/*->example::Anonymous#Foo#*/ {} } diff --git a/tests/semanticdb/expect/Classes.expect.scala b/tests/semanticdb/expect/Classes.expect.scala index 619671a7ca51..a585fc53bb1b 100644 --- a/tests/semanticdb/expect/Classes.expect.scala +++ b/tests/semanticdb/expect/Classes.expect.scala @@ -1,33 +1,33 @@ package classes -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#*//*->scala::AnyVal#``().*/ -class C2/*<<=classes.C2#*/(val x2/*<<=classes.C2#x2.*/: Int/*=>>scala.Int#*/) extends AnyVal/*=>>scala.AnyVal#*//*=>>scala.AnyVal#``().*/ -object C2/*<<=classes.C2.*/ +class C2/*<-classes::C2#*/(val x2/*<-classes::C2#x2.*/: Int/*->scala::Int#*/) extends AnyVal/*->scala::AnyVal#*//*->scala::AnyVal#``().*/ +object C2/*<-classes::C2.*/ -case class C3/*<<=classes.C3#*/(x/*<<=classes.C3#x.*/: Int/*=>>scala.Int#*/) +case class C3/*<-classes::C3#*/(x/*<-classes::C3#x.*/: Int/*->scala::Int#*/) -case class C4/*<<=classes.C4#*/(x/*<<=classes.C4#x.*/: Int/*=>>scala.Int#*/) -object C4/*<<=classes.C4.*/ +case class C4/*<-classes::C4#*/(x/*<-classes::C4#x.*/: Int/*->scala::Int#*/) +object C4/*<-classes::C4.*/ -object M/*<<=classes.M.*/ { - implicit class C5/*<<=classes.M.C5#*/(x/*<<=classes.M.C5#x.*/: Int/*=>>scala.Int#*/) +object M/*<-classes::M.*/ { + implicit class C5/*<-classes::M.C5#*/(x/*<-classes::M.C5#x.*/: Int/*->scala::Int#*/) } -case class C6/*<<=classes.C6#*/(private val x/*<<=classes.C6#x.*/: Int/*=>>scala.Int#*/) +case class C6/*<-classes::C6#*/(private val x/*<-classes::C6#x.*/: Int/*->scala::Int#*/) -class C7/*<<=classes.C7#*/(x/*<<=classes.C7#x.*/: Int/*=>>scala.Int#*/) +class C7/*<-classes::C7#*/(x/*<-classes::C7#x.*/: Int/*->scala::Int#*/) -class C8/*<<=classes.C8#*/(private[this] val x/*<<=classes.C8#x.*/: Int/*=>>scala.Int#*/) +class C8/*<-classes::C8#*/(private[this] val x/*<-classes::C8#x.*/: Int/*->scala::Int#*/) -class C9/*<<=classes.C9#*/(private[this] var x/*<<=classes.C9#x().*/: Int/*=>>scala.Int#*/) +class C9/*<-classes::C9#*/(private[this] var x/*<-classes::C9#x().*/: Int/*->scala::Int#*/) -object N/*<<=classes.N.*/ { - val anonClass/*<<=classes.N.anonClass.*/ = new C7/*=>>classes.C7#*/(42) { - val local/*<<=local1*/ = ???/*=>>scala.Predef.`???`().*/ +object N/*<-classes::N.*/ { + val anonClass/*<-classes::N.anonClass.*/ = new C7/*->classes::C7#*/(42) { + val local/*<-local1*/ = ???/*->scala::Predef.`???`().*/ } - val anonFun/*<<=classes.N.anonFun.*/ = List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1).map/*=>>scala.collection.immutable.List#map().*/ { i => + val anonFun/*<-classes::N.anonFun.*/ = List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).map/*->scala::collection::immutable::List#map().*/ { i => val local = 2 - local/*=>>local2*/ +/*=>>scala.Int#`+`(+4).*/ 2 + local/*->local2*/ +/*->scala::Int#`+`(+4).*/ 2 } } diff --git a/tests/semanticdb/expect/Definitions.expect.scala b/tests/semanticdb/expect/Definitions.expect.scala index 76c9da838ef4..5e706341cf95 100644 --- a/tests/semanticdb/expect/Definitions.expect.scala +++ b/tests/semanticdb/expect/Definitions.expect.scala @@ -1,8 +1,8 @@ package a -object Definitions/*<<=a.Definitions.*/ { - val a/*<<=a.Definitions.a.*/ = 1 - var b/*<<=a.Definitions.b().*/ =/*<<=a.Definitions.`b_=`().*/ 2 - def c/*<<=a.Definitions.c().*/ = 3 - class D/*<<=a.Definitions.D#*/ - trait E/*<<=a.Definitions.E#*/ +object Definitions/*<-a::Definitions.*/ { + val a/*<-a::Definitions.a.*/ = 1 + var b/*<-a::Definitions.b().*/ =/*<-a::Definitions.`b_=`().*/ 2 + def c/*<-a::Definitions.c().*/ = 3 + class D/*<-a::Definitions.D#*/ + trait E/*<-a::Definitions.E#*/ } diff --git a/tests/semanticdb/expect/Empty.expect.scala b/tests/semanticdb/expect/Empty.expect.scala index 8b2a4692976a..808db6ad4ea5 100644 --- a/tests/semanticdb/expect/Empty.expect.scala +++ b/tests/semanticdb/expect/Empty.expect.scala @@ -1,7 +1,7 @@ -class A/*<<=_empty_.A#*/ { - def b/*<<=_empty_.A#b().*/: B/*=>>_empty_.B#*/ = ???/*=>>scala.Predef.`???`().*/ +class A/*<-_empty_::A#*/ { + def b/*<-_empty_::A#b().*/: B/*->_empty_::B#*/ = ???/*->scala::Predef.`???`().*/ } -class B/*<<=_empty_.B#*/ { - def a/*<<=_empty_.B#a().*/: A/*=>>_empty_.A#*/ = ???/*=>>scala.Predef.`???`().*/ +class B/*<-_empty_::B#*/ { + def a/*<-_empty_::B#a().*/: A/*->_empty_::A#*/ = ???/*->scala::Predef.`???`().*/ } diff --git a/tests/semanticdb/expect/EmptyObject.expect.scala b/tests/semanticdb/expect/EmptyObject.expect.scala index 1ce6ad8b983f..0e9fe500adee 100644 --- a/tests/semanticdb/expect/EmptyObject.expect.scala +++ b/tests/semanticdb/expect/EmptyObject.expect.scala @@ -1,3 +1,3 @@ package example -object EmptyObject/*<<=example.EmptyObject.*/ {} +object EmptyObject/*<-example::EmptyObject.*/ {} diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index c593e94e00fe..ef20f059da7e 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -1,43 +1,43 @@ -object Enums/*<<=_empty_.Enums.*/ with - import =:=/*=>>_empty_.Enums.`=:=`.*/._ - - enum Colour/*<<=_empty_.Enums.Colour#*/ with - case /*=>>scala.runtime.EnumValues#``().*/Red/*=>>_empty_.Enums.Colour.Red.*//*<<=_empty_.Enums.Colour.Red.*/, Green/*=>>_empty_.Enums.Colour.Green.*//*<<=_empty_.Enums.Colour.Green.*/, Blue/*=>>_empty_.Enums.Colour.Blue.*//*<<=_empty_.Enums.Colour.Blue.*/ - - enum WeekDays/*<<=_empty_.Enums.WeekDays#*/ with - /*=>>scala.runtime.EnumValues#``().*/case Monday/*<<=_empty_.Enums.WeekDays.Monday.*/ - case Tuesday/*<<=_empty_.Enums.WeekDays.Tuesday.*/ - case Wednesday/*<<=_empty_.Enums.WeekDays.Wednesday.*/ - case Thursday/*<<=_empty_.Enums.WeekDays.Thursday.*/ - case Friday/*<<=_empty_.Enums.WeekDays.Friday.*/ - case Saturday/*<<=_empty_.Enums.WeekDays.Saturday.*/ - case Sunday/*<<=_empty_.Enums.WeekDays.Sunday.*/ - - enum Maybe/*<<=_empty_.Enums.Maybe#*/[+A/*<<=_empty_.Enums.Maybe#[A]*/] with - case Just/*<<=_empty_.Enums.Maybe.Just#*/(value/*<<=_empty_.Enums.Maybe.Just#value.*/: A/*=>>_empty_.Enums.Maybe.Just#``().[A]*/) - case None/*<<=_empty_.Enums.Maybe.None.*/ - - enum Tag/*<<=_empty_.Enums.Tag#*/[A/*<<=_empty_.Enums.Tag#[A]*/] with - case IntTag/*<<=_empty_.Enums.Tag.IntTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Int/*=>>scala.Int#*/] - case BooleanTag/*<<=_empty_.Enums.Tag.BooleanTag.*/ extends Tag/*=>>_empty_.Enums.Tag#*/[Boolean/*=>>scala.Boolean#*/] - - enum =:=/*<<=_empty_.Enums.`=:=`#*/[A/*<<=_empty_.Enums.`=:=`#[A]*/, B/*<<=_empty_.Enums.`=:=`#[B]*/] with - case Refl/*<<=_empty_.Enums.`=:=`.Refl#*/[C/*<<=_empty_.Enums.`=:=`.Refl#[C]*/]() extends (C/*=>>_empty_.Enums.`=:=`.Refl#[C]*/ =:=/*=>>_empty_.Enums.`=:=`#*/ C/*=>>_empty_.Enums.`=:=`.Refl#[C]*/) - - def unwrap/*<<=_empty_.Enums.unwrap().*/[A/*<<=_empty_.Enums.unwrap().[A]*/,B/*<<=_empty_.Enums.unwrap().[B]*/](opt/*<<=_empty_.Enums.unwrap().(opt)*/: Option/*=>>scala.Option#*/[A/*=>>_empty_.Enums.unwrap().[A]*/])(given ev/*<<=_empty_.Enums.unwrap().(ev)*/: A/*=>>_empty_.Enums.unwrap().[A]*/ =:=/*=>>_empty_.Enums.`=:=`#*/ Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/]): Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/] = ev/*=>>_empty_.Enums.unwrap().(ev)*/ match - case Refl/*=>>_empty_.Enums.`=:=`.Refl.*/() => opt/*=>>_empty_.Enums.unwrap().(opt)*/.flatMap/*=>>scala.Option#flatMap().*/(identity/*=>>scala.Predef.identity().*/[Option/*=>>scala.Option#*/[B/*=>>_empty_.Enums.unwrap().[B]*/]]) - case _ => None/*=>>scala.None.*/ // TODO remove after https://github.com/lampepfl/dotty/issues/7524 is fixed - - enum Planet/*<<=_empty_.Enums.Planet#*/(mass/*<<=_empty_.Enums.Planet#mass.*/: Double/*=>>scala.Double#*/, radius/*<<=_empty_.Enums.Planet#radius.*/: Double/*=>>scala.Double#*/) extends java.lang.Enum/*=>>java.lang.Enum#*/[Planet/*=>>_empty_.Enums.Planet#*/]/*=>>java.lang.Enum#``().*/ with - private final val G/*<<=_empty_.Enums.Planet#G.*/ = 6.67300E-11 - def surfaceGravity/*<<=_empty_.Enums.Planet#surfaceGravity().*/ = G/*=>>_empty_.Enums.Planet#G.*/ */*=>>scala.Double#`*`(+6).*/ mass/*=>>_empty_.Enums.Planet#mass.*/ //*=>>scala.Double#`.`(+6).*/ (radius/*=>>_empty_.Enums.Planet#radius.*/ */*=>>scala.Double#`*`(+6).*/ radius/*=>>_empty_.Enums.Planet#radius.*/) - def surfaceWeight/*<<=_empty_.Enums.Planet#surfaceWeight().*/(otherMass/*<<=_empty_.Enums.Planet#surfaceWeight().(otherMass)*/: Double/*=>>scala.Double#*/) = otherMass/*=>>_empty_.Enums.Planet#surfaceWeight().(otherMass)*/ */*=>>scala.Double#`*`(+6).*/ surfaceGravity/*=>>_empty_.Enums.Planet#surfaceGravity().*/ - - case Mercury/*<<=_empty_.Enums.Planet.Mercury.*/ extends /*=>>scala.runtime.EnumValues#``().*/Planet/*=>>_empty_.Enums.Planet#*/(3.303e+23, 2.4397e6)/*=>>scala.runtime.EnumValues#register().*/ - case Venus/*<<=_empty_.Enums.Planet.Venus.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(4.869e+24, 6.0518e6)/*=>>scala.runtime.EnumValues#register().*/ - case Earth/*<<=_empty_.Enums.Planet.Earth.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(5.976e+24, 6.37814e6)/*=>>scala.runtime.EnumValues#register().*/ - case Mars/*<<=_empty_.Enums.Planet.Mars.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(6.421e+23, 3.3972e6)/*=>>scala.runtime.EnumValues#register().*/ - case Jupiter/*<<=_empty_.Enums.Planet.Jupiter.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(1.9e+27, 7.1492e7)/*=>>scala.runtime.EnumValues#register().*/ - case Saturn/*<<=_empty_.Enums.Planet.Saturn.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(5.688e+26, 6.0268e7)/*=>>scala.runtime.EnumValues#register().*/ - case Uranus/*<<=_empty_.Enums.Planet.Uranus.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(8.686e+25, 2.5559e7)/*=>>scala.runtime.EnumValues#register().*/ - case Neptune/*<<=_empty_.Enums.Planet.Neptune.*/ extends Planet/*=>>_empty_.Enums.Planet#*/(1.024e+26, 2.4746e7)/*=>>scala.runtime.EnumValues#register().*/ +object Enums/*<-_empty_::Enums.*/ with + import =:=/*->_empty_::Enums.`=:=`.*/._ + + enum Colour/*<-_empty_::Enums.Colour#*/ with + case /*->scala::runtime::EnumValues#``().*/Red/*->_empty_::Enums.Colour.Red.*//*<-_empty_::Enums.Colour.Red.*/, Green/*->_empty_::Enums.Colour.Green.*//*<-_empty_::Enums.Colour.Green.*/, Blue/*->_empty_::Enums.Colour.Blue.*//*<-_empty_::Enums.Colour.Blue.*/ + + enum WeekDays/*<-_empty_::Enums.WeekDays#*/ with + /*->scala::runtime::EnumValues#``().*/case Monday/*<-_empty_::Enums.WeekDays.Monday.*/ + case Tuesday/*<-_empty_::Enums.WeekDays.Tuesday.*/ + case Wednesday/*<-_empty_::Enums.WeekDays.Wednesday.*/ + case Thursday/*<-_empty_::Enums.WeekDays.Thursday.*/ + case Friday/*<-_empty_::Enums.WeekDays.Friday.*/ + case Saturday/*<-_empty_::Enums.WeekDays.Saturday.*/ + case Sunday/*<-_empty_::Enums.WeekDays.Sunday.*/ + + enum Maybe/*<-_empty_::Enums.Maybe#*/[+A/*<-_empty_::Enums.Maybe#[A]*/] with + case Just/*<-_empty_::Enums.Maybe.Just#*/(value/*<-_empty_::Enums.Maybe.Just#value.*/: A/*->_empty_::Enums.Maybe.Just#``().[A]*/) + case None/*<-_empty_::Enums.Maybe.None.*/ + + enum Tag/*<-_empty_::Enums.Tag#*/[A/*<-_empty_::Enums.Tag#[A]*/] with + case IntTag/*<-_empty_::Enums.Tag.IntTag.*/ extends Tag/*->_empty_::Enums.Tag#*/[Int/*->scala::Int#*/] + case BooleanTag/*<-_empty_::Enums.Tag.BooleanTag.*/ extends Tag/*->_empty_::Enums.Tag#*/[Boolean/*->scala::Boolean#*/] + + enum =:=/*<-_empty_::Enums.`=:=`#*/[A/*<-_empty_::Enums.`=:=`#[A]*/, B/*<-_empty_::Enums.`=:=`#[B]*/] with + case Refl/*<-_empty_::Enums.`=:=`.Refl#*/[C/*<-_empty_::Enums.`=:=`.Refl#[C]*/]() extends (C/*->_empty_::Enums.`=:=`.Refl#[C]*/ =:=/*->_empty_::Enums.`=:=`#*/ C/*->_empty_::Enums.`=:=`.Refl#[C]*/) + + def unwrap/*<-_empty_::Enums.unwrap().*/[A/*<-_empty_::Enums.unwrap().[A]*/,B/*<-_empty_::Enums.unwrap().[B]*/](opt/*<-_empty_::Enums.unwrap().(opt)*/: Option/*->scala::Option#*/[A/*->_empty_::Enums.unwrap().[A]*/])(given ev/*<-_empty_::Enums.unwrap().(ev)*/: A/*->_empty_::Enums.unwrap().[A]*/ =:=/*->_empty_::Enums.`=:=`#*/ Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]): Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/] = ev/*->_empty_::Enums.unwrap().(ev)*/ match + case Refl/*->_empty_::Enums.`=:=`.Refl.*/() => opt/*->_empty_::Enums.unwrap().(opt)*/.flatMap/*->scala::Option#flatMap().*/(identity/*->scala::Predef.identity().*/[Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]]) + case _ => None/*->scala::None.*/ // TODO remove after https://github.com/lampepfl/dotty/issues/7524 is fixed + + enum Planet/*<-_empty_::Enums.Planet#*/(mass/*<-_empty_::Enums.Planet#mass.*/: Double/*->scala::Double#*/, radius/*<-_empty_::Enums.Planet#radius.*/: Double/*->scala::Double#*/) extends java.lang.Enum/*->java::lang::Enum#*/[Planet/*->_empty_::Enums.Planet#*/]/*->java::lang::Enum#``().*/ with + private final val G/*<-_empty_::Enums.Planet#G.*/ = 6.67300E-11 + def surfaceGravity/*<-_empty_::Enums.Planet#surfaceGravity().*/ = G/*->_empty_::Enums.Planet#G.*/ */*->scala::Double#`*`(+6).*/ mass/*->_empty_::Enums.Planet#mass.*/ //*->scala::Double#`::`(+6).*/ (radius/*->_empty_::Enums.Planet#radius.*/ */*->scala::Double#`*`(+6).*/ radius/*->_empty_::Enums.Planet#radius.*/) + def surfaceWeight/*<-_empty_::Enums.Planet#surfaceWeight().*/(otherMass/*<-_empty_::Enums.Planet#surfaceWeight().(otherMass)*/: Double/*->scala::Double#*/) = otherMass/*->_empty_::Enums.Planet#surfaceWeight().(otherMass)*/ */*->scala::Double#`*`(+6).*/ surfaceGravity/*->_empty_::Enums.Planet#surfaceGravity().*/ + + case Mercury/*<-_empty_::Enums.Planet.Mercury.*/ extends /*->scala::runtime::EnumValues#``().*/Planet/*->_empty_::Enums.Planet#*/(3.303e+23, 2.4397e6)/*->scala::runtime::EnumValues#register().*/ + case Venus/*<-_empty_::Enums.Planet.Venus.*/ extends Planet/*->_empty_::Enums.Planet#*/(4.869e+24, 6.0518e6)/*->scala::runtime::EnumValues#register().*/ + case Earth/*<-_empty_::Enums.Planet.Earth.*/ extends Planet/*->_empty_::Enums.Planet#*/(5.976e+24, 6.37814e6)/*->scala::runtime::EnumValues#register().*/ + case Mars/*<-_empty_::Enums.Planet.Mars.*/ extends Planet/*->_empty_::Enums.Planet#*/(6.421e+23, 3.3972e6)/*->scala::runtime::EnumValues#register().*/ + case Jupiter/*<-_empty_::Enums.Planet.Jupiter.*/ extends Planet/*->_empty_::Enums.Planet#*/(1.9e+27, 7.1492e7)/*->scala::runtime::EnumValues#register().*/ + case Saturn/*<-_empty_::Enums.Planet.Saturn.*/ extends Planet/*->_empty_::Enums.Planet#*/(5.688e+26, 6.0268e7)/*->scala::runtime::EnumValues#register().*/ + case Uranus/*<-_empty_::Enums.Planet.Uranus.*/ extends Planet/*->_empty_::Enums.Planet#*/(8.686e+25, 2.5559e7)/*->scala::runtime::EnumValues#register().*/ + case Neptune/*<-_empty_::Enums.Planet.Neptune.*/ extends Planet/*->_empty_::Enums.Planet#*/(1.024e+26, 2.4746e7)/*->scala::runtime::EnumValues#register().*/ diff --git a/tests/semanticdb/expect/EtaExpansion.expect.scala b/tests/semanticdb/expect/EtaExpansion.expect.scala index 9bc1f39cf32b..41e623395955 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.*/(1).map/*=>>scala.Option#map().*/(identity/*=>>scala.Predef.identity().*/) - List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1).foldLeft/*=>>scala.collection.LinearSeqOps#foldLeft().*/("")(_ +/*=>>java.lang.String#`+`().*/ _) +class EtaExpansion/*<-example::EtaExpansion#*/ { + Some/*->scala::Some.*/(1).map/*->scala::Option#map().*/(identity/*->scala::Predef.identity().*/) + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(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 bb7a2f7fca2c..d8cf6786a485 100644 --- a/tests/semanticdb/expect/Example.expect.scala +++ b/tests/semanticdb/expect/Example.expect.scala @@ -1,11 +1,11 @@ package example -import scala.concurrent.Future/*=>>scala.concurrent.Future.*//*=>>scala.concurrent.Future#*/ +import scala.concurrent.Future/*->scala::concurrent::Future.*//*->scala::concurrent::Future#*/ -object Example/*<<=example.Example.*/ { /*=>>example.Example.*/self/*<<=local0*/ => - new scala.collection.mutable.Stack/*=>>scala.collection.mutable.Stack#*/[Int/*=>>scala.Int#*/]/*=>>scala.collection.mutable.Stack#``(+1).*/() - def main/*<<=example.Example.main().*/(args/*<<=example.Example.main().(args)*/: Array/*=>>scala.Array#*/[String/*=>>scala.Predef.String#*/]): Unit/*=>>scala.Unit#*/ = { - println/*=>>scala.Predef.println(+1).*/(1) +object Example/*<-example::Example.*/ { /*->example::Example.*/self/*<-local0*/ => + new scala.collection.mutable.Stack/*->scala::collection::mutable::Stack#*/[Int/*->scala::Int#*/]/*->scala::collection::mutable::Stack#``(+1).*/() + def main/*<-example::Example.main().*/(args/*<-example::Example.main().(args)*/: Array/*->scala::Array#*/[String/*->scala::Predef.String#*/]): Unit/*->scala::Unit#*/ = { + println/*->scala::Predef.println(+1).*/(1) } - val x/*<<=example.Example.x.*/ = scala.reflect.classTag/*=>>scala.reflect.package.classTag().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer#TYPE.*/ + val x/*<-example::Example.x.*/ = scala.reflect.classTag/*->scala::reflect::package.classTag().*/[Int/*->scala::Int#*/]/*->scala::reflect::ClassTag.apply().*//*->java::lang::Integer#TYPE.*/ } diff --git a/tests/semanticdb/expect/Flags.expect.scala b/tests/semanticdb/expect/Flags.expect.scala index cc0321c67bb2..b594656fa60a 100644 --- a/tests/semanticdb/expect/Flags.expect.scala +++ b/tests/semanticdb/expect/Flags.expect.scala @@ -1,26 +1,26 @@ package flags -import scala.language/*=>>scalaShadowing.language.*/.experimental/*=>>scalaShadowing.language.experimental.*/.macros/*=>>scalaShadowing.language.experimental.macros.*/ +import scala.language/*->scalaShadowing::language.*/.experimental/*->scalaShadowing::language.experimental.*/.macros/*->scalaShadowing::language.experimental.macros.*/ package object p { - p/*<<=flags.p.package.*/rivate lazy val x/*<<=flags.p.package.x.*/ = 1 - protected implicit var y/*<<=flags.p.package.y().*/: /*<<=flags.p.package.`y_=`().*/Int/*=>>scala.Int#*/ = 2 - def z/*<<=flags.p.package.z().*/(pp/*<<=flags.p.package.z().(pp)*/: Int/*=>>scala.Int#*/) = 3 - def m/*<<=flags.p.package.m().*/[TT/*<<=flags.p.package.m().[TT]*/]: Int/*=>>scala.Int#*//*=>>scala.Predef.`???`().*/ = macro ??? - abstract class C/*<<=flags.p.package.C#*/[+T/*<<=flags.p.package.C#[T]*//*<<=flags.p.package.C#``(+1).[T]*/, -U/*<<=flags.p.package.C#[U]*//*<<=flags.p.package.C#``(+1).[U]*/, V/*<<=flags.p.package.C#[V]*//*<<=flags.p.package.C#``(+1).[V]*/](x/*<<=flags.p.package.C#x.*/: T/*=>>flags.p.package.C#``().[T]*/, y/*<<=flags.p.package.C#y.*/: U/*=>>flags.p.package.C#``().[U]*/, z/*<<=flags.p.package.C#z.*/: V/*=>>flags.p.package.C#``().[V]*/) { - def this()/*<<=flags.p.package.C#``(+1).*/ = this(???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/, ???/*=>>scala.Predef.`???`().*/) - def w/*<<=flags.p.package.C#w().*/: Int/*=>>scala.Int#*/ + p/*<-flags::p::package.*/rivate lazy val x/*<-flags::p::package.x.*/ = 1 + protected implicit var y/*<-flags::p::package.y().*/: /*<-flags::p::package.`y_=`().*/Int/*->scala::Int#*/ = 2 + def z/*<-flags::p::package.z().*/(pp/*<-flags::p::package.z().(pp)*/: Int/*->scala::Int#*/) = 3 + def m/*<-flags::p::package.m().*/[TT/*<-flags::p::package.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ??? + abstract class C/*<-flags::p::package.C#*/[+T/*<-flags::p::package.C#[T]*//*<-flags::p::package.C#``(+1).[T]*/, -U/*<-flags::p::package.C#[U]*//*<-flags::p::package.C#``(+1).[U]*/, V/*<-flags::p::package.C#[V]*//*<-flags::p::package.C#``(+1).[V]*/](x/*<-flags::p::package.C#x.*/: T/*->flags::p::package.C#``().[T]*/, y/*<-flags::p::package.C#y.*/: U/*->flags::p::package.C#``().[U]*/, z/*<-flags::p::package.C#z.*/: V/*->flags::p::package.C#``().[V]*/) { + def this()/*<-flags::p::package.C#``(+1).*/ = this(???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/) + def w/*<-flags::p::package.C#w().*/: Int/*->scala::Int#*/ } - type T1/*<<=flags.p.package.T1#*/ = Int/*=>>scala.Int#*/ - type T2/*<<=flags.p.package.T2#*/[T/*<<=flags.p.package.T2#[T]*/] = S/*=>>flags.p.package.S#*/[T/*=>>flags.p.package.T2#[T]*/] - type U/*<<=flags.p.package.U#*/ <: Int/*=>>scala.Int#*/ - type V/*<<=flags.p.package.V#*/ >: Int/*=>>scala.Int#*/ - case object X/*<<=flags.p.package.X.*/ - final class Y/*<<=flags.p.package.Y#*/ - sealed trait Z/*<<=flags.p.package.Z#*/ - class AA/*<<=flags.p.package.AA#*/(x/*<<=flags.p.package.AA#x.*/: Int/*=>>scala.Int#*/, val y/*<<=flags.p.package.AA#y.*/: Int/*=>>scala.Int#*/, var z/*<<=flags.p.package.AA#z().*/: /*<<=flags.p.package.AA#`z_=`().*/Int/*=>>scala.Int#*/) - class S/*<<=flags.p.package.S#*/[@specialized/*=>>scala.specialized#*//*=>>scala.specialized#``(+2).*/ T/*<<=flags.p.package.S#[T]*/] - val List/*=>>scala.package.List.*//*=>>scala.collection.SeqFactory#unapplySeq().*/(xs1/*<<=flags.p.package.xs1.*//*<<=local0*/)/*=>>local0*/ = ???/*=>>scala.Predef.`???`().*/ - ???/*=>>scala.Predef.`???`().*/ match { case List/*=>>scala.package.List.*//*=>>scala.collection.SeqFactory#unapplySeq().*/(xs2/*<<=local1*/) => ???/*=>>scala.Predef.`???`().*/ } - ???/*=>>scala.Predef.`???`().*/ match { case _: List/*=>>scala.package.List#*/[t/*<<=local2*/] => ???/*=>>scala.Predef.`???`().*/ } + type T1/*<-flags::p::package.T1#*/ = Int/*->scala::Int#*/ + type T2/*<-flags::p::package.T2#*/[T/*<-flags::p::package.T2#[T]*/] = S/*->flags::p::package.S#*/[T/*->flags::p::package.T2#[T]*/] + type U/*<-flags::p::package.U#*/ <: Int/*->scala::Int#*/ + type V/*<-flags::p::package.V#*/ >: Int/*->scala::Int#*/ + case object X/*<-flags::p::package.X.*/ + final class Y/*<-flags::p::package.Y#*/ + sealed trait Z/*<-flags::p::package.Z#*/ + class AA/*<-flags::p::package.AA#*/(x/*<-flags::p::package.AA#x.*/: Int/*->scala::Int#*/, val y/*<-flags::p::package.AA#y.*/: Int/*->scala::Int#*/, var z/*<-flags::p::package.AA#z().*/: /*<-flags::p::package.AA#`z_=`().*/Int/*->scala::Int#*/) + class S/*<-flags::p::package.S#*/[@specialized/*->scala::specialized#*//*->scala::specialized#``(+2).*/ T/*<-flags::p::package.S#[T]*/] + val List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs1/*<-flags::p::package.xs1.*//*<-local0*/)/*->local0*/ = ???/*->scala::Predef.`???`().*/ + ???/*->scala::Predef.`???`().*/ match { case List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs2/*<-local1*/) => ???/*->scala::Predef.`???`().*/ } + ???/*->scala::Predef.`???`().*/ match { case _: List/*->scala::package.List#*/[t/*<-local2*/] => ???/*->scala::Predef.`???`().*/ } } diff --git a/tests/semanticdb/expect/ForComprehension.expect.scala b/tests/semanticdb/expect/ForComprehension.expect.scala index 815ef923b78f..e32db27c16bd 100644 --- a/tests/semanticdb/expect/ForComprehension.expect.scala +++ b/tests/semanticdb/expect/ForComprehension.expect.scala @@ -1,45 +1,45 @@ package example -class ForComprehension/*<<=example.ForComprehension#*/ { +class ForComprehension/*<-example::ForComprehension#*/ { for { - a <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1)/*=>>scala.collection.immutable.List#flatMap().*/ - b/*=>>local0*/ <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1)/*=>>scala.collection.IterableOps#withFilter().*/ - if b/*=>>local0*/ >/*=>>scala.Int#`>`(+3).*/ 1/*=>>scala.collection.WithFilter#map().*/ - c/*=>>local2*/ = a/*=>>local1*/ +/*=>>scala.Int#`+`(+4).*/ b/*=>>local0*//*=>>scala.collection.immutable.List#map().*/ - } yield (a/*=>>local1*/, b/*=>>local0*/, c/*=>>local2*/) + a <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ + b/*->local0*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::IterableOps#withFilter().*/ + if b/*->local0*/ >/*->scala::Int#`>`(+3).*/ 1/*->scala::collection::WithFilter#map().*/ + c/*->local2*/ = a/*->local1*/ +/*->scala::Int#`+`(+4).*/ b/*->local0*//*->scala::collection::immutable::List#map().*/ + } yield (a/*->local1*/, b/*->local0*/, c/*->local2*/) for { - a <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1)/*=>>scala.collection.immutable.List#flatMap().*/ - b <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(a/*=>>local3*/)/*=>>scala.collection.IterableOps#withFilter().*/ + a <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ + b <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(a/*->local3*/)/*->scala::collection::IterableOps#withFilter().*/ if ( - a/*=>>local3*/, - b/*=>>local4*/ - ) ==/*=>>scala.Any#`==`().*/ (1, 2)/*=>>scala.collection.WithFilter#flatMap().*/ + a/*->local3*/, + b/*->local4*/ + ) ==/*->scala::Any#`==`().*/ (1, 2)/*->scala::collection::WithFilter#flatMap().*/ ( c, d - ) <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/((a/*=>>local3*/, b/*=>>local4*/))/*=>>scala.collection.WithFilter#withFilter().*//*=>>scala.collection.IterableOps#withFilter().*/ + ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((a/*->local3*/, b/*->local4*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/ if ( - a/*=>>local3*/, - b/*=>>local4*/, - c/*=>>local5*/, - d/*=>>local6*/ - ) ==/*=>>scala.Any#`==`().*/ (1, 2, 3, 4)/*=>>scala.collection.WithFilter#map().*/ - e/*=>>local7*/ = ( - a/*=>>local3*/, - b/*=>>local4*/, - c/*=>>local5*/, - d/*=>>local6*/ - )/*=>>scala.collection.IterableOps#withFilter().*/ - if e/*=>>local7*/ ==/*=>>scala.Any#`==`().*/ (1, 2, 3, 4)/*=>>scala.collection.WithFilter#flatMap().*/ - f <- List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(e/*=>>local7*/)/*=>>scala.collection.immutable.List#map().*/ + a/*->local3*/, + b/*->local4*/, + c/*->local5*/, + d/*->local6*/ + ) ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#map().*/ + e/*->local7*/ = ( + a/*->local3*/, + b/*->local4*/, + c/*->local5*/, + d/*->local6*/ + )/*->scala::collection::IterableOps#withFilter().*/ + if e/*->local7*/ ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/ + f <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(e/*->local7*/)/*->scala::collection::immutable::List#map().*/ } yield { ( - a/*=>>local3*/, - b/*=>>local4*/, - c/*=>>local5*/, - d/*=>>local6*/, - e/*=>>local7*/, - f/*=>>local8*/ + a/*->local3*/, + b/*->local4*/, + c/*->local5*/, + d/*->local6*/, + e/*->local7*/, + f/*->local8*/ ) } } diff --git a/tests/semanticdb/expect/Givens.expect.scala b/tests/semanticdb/expect/Givens.expect.scala index 8200fe851eaf..d4b46b7dbc02 100644 --- a/tests/semanticdb/expect/Givens.expect.scala +++ b/tests/semanticdb/expect/Givens.expect.scala @@ -1,21 +1,21 @@ package a package b -object Givens/*<<=a.b.Givens.*/ +object Givens/*<-a::b::Givens.*/ given :[A](any: A) - de/*<<=a.b.Givens.given_sayHello_of_A.*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().[A]*//*<<=a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>a.b.Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<<=a.b.Givens.given_sayHello_of_A.sayHello().*/ = s"Hello, I am $any/*=>>a.b.Givens.given_sayHello_of_A.sayHello().(any)*//*=>>scala.StringContext#s().*/" + de/*<-a::b::Givens.given_sayHello_of_A.*//*<-a::b::Givens.given_sayHello_of_A.sayHello().[A]*//*<-a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->a::b::Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<-a::b::Givens.given_sayHello_of_A.sayHello().*/ = s"Hello, I am $any/*->a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->scala::StringContext#s().*/" - val hello1/*<<=a.b.Givens.hello1.*/ = /*=>>a.b.Givens.given_sayHello_of_A.sayHello().*/1.sayHello + val hello1/*<-a::b::Givens.hello1.*/ = /*->a::b::Givens.given_sayHello_of_A.sayHello().*/1.sayHello - trait Monoid/*<<=a.b.Givens.Monoid#*/[A/*<<=a.b.Givens.Monoid#[A]*/] - def empty/*<<=a.b.Givens.Monoid#empty().*/: A/*=>>a.b.Givens.Monoid#[A]*/ - def (x: A) /*<<=a.b.Givens.Monoid#combine().*//*<<=a.b.Givens.Monoid#combine().(x)*//*=>>a.b.Givens.Monoid#[A]*/combine (y/*<<=a.b.Givens.Monoid#combine().(y)*/: A/*=>>a.b.Givens.Monoid#[A]*/): A/*=>>a.b.Givens.Monoid#[A]*/ + trait Monoid/*<-a::b::Givens.Monoid#*/[A/*<-a::b::Givens.Monoid#[A]*/] + def empty/*<-a::b::Givens.Monoid#empty().*/: A/*->a::b::Givens.Monoid#[A]*/ + def (x: A) /*<-a::b::Givens.Monoid#combine().*//*<-a::b::Givens.Monoid#combine().(x)*//*->a::b::Givens.Monoid#[A]*/combine (y/*<-a::b::Givens.Monoid#combine().(y)*/: A/*->a::b::Givens.Monoid#[A]*/): A/*->a::b::Givens.Monoid#[A]*/ - given Monoid/*=>>a.b.Givens.Monoid#*/[String] - /*<<=a.b.Givens.given_Monoid_String.*//*=>>scala.Predef.String#*/def empty/*<<=a.b.Givens.given_Monoid_String.empty().*/ = "" - def (x: Str/*<<=a.b.Givens.given_Monoid_String.combine().*//*<<=a.b.Givens.given_Monoid_String.combine().(x)*/ing/*=>>scala.Predef.String#*/) combine (y/*<<=a.b.Givens.given_Monoid_String.combine().(y)*/: String/*=>>scala.Predef.String#*/) = x/*=>>a.b.Givens.given_Monoid_String.combine().(x)*/ +/*=>>java.lang.String#`+`().*/ y/*=>>a.b.Givens.given_Monoid_String.combine().(y)*/ + given Monoid/*->a::b::Givens.Monoid#*/[String] + /*<-a::b::Givens.given_Monoid_String.*//*->scala::Predef.String#*/def empty/*<-a::b::Givens.given_Monoid_String.empty().*/ = "" + def (x: Str/*<-a::b::Givens.given_Monoid_String.combine().*//*<-a::b::Givens.given_Monoid_String.combine().(x)*/ing/*->scala::Predef.String#*/) combine (y/*<-a::b::Givens.given_Monoid_String.combine().(y)*/: String/*->scala::Predef.String#*/) = x/*->a::b::Givens.given_Monoid_String.combine().(x)*/ +/*->java::lang::String#`+`().*/ y/*->a::b::Givens.given_Monoid_String.combine().(y)*/ - inline given int2String/*<<=a.b.Givens.int2String().*/: Conversion/*=>>scala.Conversion#*/[Int/*=>>scala.Int#*/, String/*=>>scala.Predef.String#*/] = _.toString/*=>>scala.Any#toString().*/ + inline given int2String/*<-a::b::Givens.int2String().*/: Conversion/*->scala::Conversion#*/[Int/*->scala::Int#*/, String/*->scala::Predef.String#*/] = _.toString/*->scala::Any#toString().*/ - def foo/*<<=a.b.Givens.foo().*/[A/*<<=a.b.Givens.foo().[A]*/](given A/*<<=a.b.Givens.foo().(A)*/: Monoid/*=>>a.b.Givens.Monoid#*/[A/*=>>a.b.Givens.foo().[A]*/]): A/*=>>a.b.Givens.foo().[A]*/ = A/*=>>a.b.Givens.foo().(A)*/.combine/*=>>a.b.Givens.Monoid#combine().*/(A/*=>>a.b.Givens.foo().(A)*/.empty/*=>>a.b.Givens.Monoid#empty().*/)(A/*=>>a.b.Givens.foo().(A)*/.empty/*=>>a.b.Givens.Monoid#empty().*/) + def foo/*<-a::b::Givens.foo().*/[A/*<-a::b::Givens.foo().[A]*/](given A/*<-a::b::Givens.foo().(A)*/: Monoid/*->a::b::Givens.Monoid#*/[A/*->a::b::Givens.foo().[A]*/]): A/*->a::b::Givens.foo().[A]*/ = A/*->a::b::Givens.foo().(A)*/.combine/*->a::b::Givens.Monoid#combine().*/(A/*->a::b::Givens.foo().(A)*/.empty/*->a::b::Givens.Monoid#empty().*/)(A/*->a::b::Givens.foo().(A)*/.empty/*->a::b::Givens.Monoid#empty().*/) diff --git a/tests/semanticdb/expect/ImplicitConversion.expect.scala b/tests/semanticdb/expect/ImplicitConversion.expect.scala index 90659b033697..5c050024066c 100644 --- a/tests/semanticdb/expect/ImplicitConversion.expect.scala +++ b/tests/semanticdb/expect/ImplicitConversion.expect.scala @@ -1,37 +1,37 @@ package example -import scala.language/*=>>scalaShadowing.language.*/.implicitConversions/*=>>scalaShadowing.language.implicitConversions.*/ +import scala.language/*->scalaShadowing::language.*/.implicitConversions/*->scalaShadowing::language.implicitConversions.*/ -class ImplicitConversion/*<<=example.ImplicitConversion#*/ { - import ImplicitConversion/*=>>example.ImplicitConversion.*/._ - implicit def string2Number/*<<=example.ImplicitConversion#string2Number().*/( - string/*<<=example.ImplicitConversion#string2Number().(string)*/: String/*=>>scala.Predef.String#*/ - ): Int/*=>>scala.Int#*/ = 42 - val message/*<<=example.ImplicitConversion#message.*/ = "" - val number/*<<=example.ImplicitConversion#number.*/ = 42 - val tuple/*<<=example.ImplicitConversion#tuple.*/ = (1, 2) - val char/*<<=example.ImplicitConversion#char.*/: Char/*=>>scala.Char#*/ = 'a' +class ImplicitConversion/*<-example::ImplicitConversion#*/ { + import ImplicitConversion/*->example::ImplicitConversion.*/._ + implicit def string2Number/*<-example::ImplicitConversion#string2Number().*/( + string/*<-example::ImplicitConversion#string2Number().(string)*/: String/*->scala::Predef.String#*/ + ): Int/*->scala::Int#*/ = 42 + val message/*<-example::ImplicitConversion#message.*/ = "" + val number/*<-example::ImplicitConversion#number.*/ = 42 + val tuple/*<-example::ImplicitConversion#tuple.*/ = (1, 2) + val char/*<-example::ImplicitConversion#char.*/: Char/*->scala::Char#*/ = 'a' // extension methods - /*=>>scala.Predef.augmentString().*/message/*=>>example.ImplicitConversion#message.*/ - .stripSuffix/*=>>scala.collection.StringOps#stripSuffix().*/("h") - tuple/*=>>example.ImplicitConversion#tuple.*/ +/*=>>example.ImplicitConversion.newAny2stringadd#`+`().*/ "Hello" + /*->scala::Predef.augmentString().*/message/*->example::ImplicitConversion#message.*/ + .stripSuffix/*->scala::collection::StringOps#stripSuffix().*/("h") + 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#*/ = /*->example::ImplicitConversion#string2Number().*/message/*->example::ImplicitConversion#message.*/ // interpolators - s"Hello $message/*=>>example.ImplicitConversion#message.*/ $number/*=>>example.ImplicitConversion#number.*//*=>>scala.StringContext#s().*/" - /*=>>scala.Predef.augmentString().*/s"""Hello - |$message/*=>>example.ImplicitConversion#message.*/ - |$number/*=>>example.ImplicitConversion#number.*//*=>>scala.StringContext#s().*/""".stripMargin/*=>>scala.collection.StringOps#stripMargin(+1).*/ + s"Hello $message/*->example::ImplicitConversion#message.*/ $number/*->example::ImplicitConversion#number.*//*->scala::StringContext#s().*/" + /*->scala::Predef.augmentString().*/s"""Hello + |$message/*->example::ImplicitConversion#message.*/ + |$number/*->example::ImplicitConversion#number.*//*->scala::StringContext#s().*/""".stripMargin/*->scala::collection::StringOps#stripMargin(+1).*/ - val a/*<<=example.ImplicitConversion#a.*/: Int/*=>>scala.Int#*/ = /*=>>scala.Char.char2int().*/char/*=>>example.ImplicitConversion#char.*/ - val b/*<<=example.ImplicitConversion#b.*/: Long/*=>>scala.Long#*/ = /*=>>scala.Char.char2long().*/char/*=>>example.ImplicitConversion#char.*/ + val a/*<-example::ImplicitConversion#a.*/: Int/*->scala::Int#*/ = /*->scala::Char.char2int().*/char/*->example::ImplicitConversion#char.*/ + val b/*<-example::ImplicitConversion#b.*/: Long/*->scala::Long#*/ = /*->scala::Char.char2long().*/char/*->example::ImplicitConversion#char.*/ } -object ImplicitConversion/*<<=example.ImplicitConversion.*/ { - implicit final class newAny2stringadd/*<<=example.ImplicitConversion.newAny2stringadd#*/[A/*<<=example.ImplicitConversion.newAny2stringadd#[A]*/](private val self/*<<=example.ImplicitConversion.newAny2stringadd#self.*/: A/*=>>example.ImplicitConversion.newAny2stringadd#``().[A]*/) extends AnyVal/*=>>scala.AnyVal#*//*=>>scala.AnyVal#``().*/ { - def +/*<<=example.ImplicitConversion.newAny2stringadd#`+`().*/(other/*<<=example.ImplicitConversion.newAny2stringadd#`+`().(other)*/: String/*=>>scala.Predef.String#*/): String/*=>>scala.Predef.String#*/ = String/*=>>java.lang.String#*/.valueOf/*=>>java.lang.String#valueOf().*/(self/*=>>example.ImplicitConversion.newAny2stringadd#self.*/) +/*=>>java.lang.String#`+`().*/ other/*=>>example.ImplicitConversion.newAny2stringadd#`+`().(other)*/ +object ImplicitConversion/*<-example::ImplicitConversion.*/ { + implicit final class newAny2stringadd/*<-example::ImplicitConversion.newAny2stringadd#*/[A/*<-example::ImplicitConversion.newAny2stringadd#[A]*/](private val self/*<-example::ImplicitConversion.newAny2stringadd#self.*/: A/*->example::ImplicitConversion.newAny2stringadd#``().[A]*/) extends AnyVal/*->scala::AnyVal#*//*->scala::AnyVal#``().*/ { + def +/*<-example::ImplicitConversion.newAny2stringadd#`+`().*/(other/*<-example::ImplicitConversion.newAny2stringadd#`+`().(other)*/: String/*->scala::Predef.String#*/): String/*->scala::Predef.String#*/ = String/*->java::lang::String#*/.valueOf/*->java::lang::String#valueOf().*/(self/*->example::ImplicitConversion.newAny2stringadd#self.*/) +/*->java::lang::String#`+`().*/ other/*->example::ImplicitConversion.newAny2stringadd#`+`().(other)*/ } } diff --git a/tests/semanticdb/expect/Imports.expect.scala b/tests/semanticdb/expect/Imports.expect.scala index d3c6dfe73ffd..87f7d4cb768f 100644 --- a/tests/semanticdb/expect/Imports.expect.scala +++ b/tests/semanticdb/expect/Imports.expect.scala @@ -1 +1 @@ -import scala.util.control.NonFatal/*=>>scala.util.control.NonFatal.*/ +import scala.util.control.NonFatal/*->scala::util::control::NonFatal.*/ diff --git a/tests/semanticdb/expect/InstrumentTyper.expect.scala b/tests/semanticdb/expect/InstrumentTyper.expect.scala index 7c9e2388c763..69cf23a1c0f8 100644 --- a/tests/semanticdb/expect/InstrumentTyper.expect.scala +++ b/tests/semanticdb/expect/InstrumentTyper.expect.scala @@ -1,26 +1,26 @@ package example -import scala.annotation.meta.param/*=>>scala.annotation.meta.param.*/ -import scala.language/*=>>scalaShadowing.language.*/.existentials/*=>>scalaShadowing.language.existentials.*/ -import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ -import types.Test/*=>>types.Test.*/._ +import scala.annotation.meta.param/*->scala::annotation::meta::param.*/ +import scala.language/*->scalaShadowing::language.*/.existentials/*->scalaShadowing::language.existentials.*/ +import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ +import types.Test/*->types::Test.*/._ -class InstrumentTyper/*<<=example.InstrumentTyper#*/ { self/*<<=local0*/: AnyRef/*=>>scala.AnyRef#*/ => - def all/*<<=example.InstrumentTyper#all().*/ = List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/( - Literal/*=>>types.Test.Literal.*/.int/*=>>types.Test.Literal.int.*/, - Literal/*=>>types.Test.Literal.*/.long/*=>>types.Test.Literal.long.*/, - Literal/*=>>types.Test.Literal.*/.float/*=>>types.Test.Literal.float.*/, - Literal/*=>>types.Test.Literal.*/.double/*=>>types.Test.Literal.double.*/, - Literal/*=>>types.Test.Literal.*/.nil/*=>>types.Test.Literal.nil.*/, - Literal/*=>>types.Test.Literal.*/.char/*=>>types.Test.Literal.char.*/, - Literal/*=>>types.Test.Literal.*/.string/*=>>types.Test.Literal.string.*/, - Literal/*=>>types.Test.Literal.*/.bool/*=>>types.Test.Literal.bool.*/, - Literal/*=>>types.Test.Literal.*/.unit/*=>>types.Test.Literal.unit.*/, - Literal/*=>>types.Test.Literal.*/.javaEnum/*=>>types.Test.Literal.javaEnum.*/, - Literal/*=>>types.Test.Literal.*/.clazzOf/*=>>types.Test.Literal.clazzOf.*/, - List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/() +class InstrumentTyper/*<-example::InstrumentTyper#*/ { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => + def all/*<-example::InstrumentTyper#all().*/ = List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/( + Literal/*->types::Test.Literal.*/.int/*->types::Test.Literal.int.*/, + Literal/*->types::Test.Literal.*/.long/*->types::Test.Literal.long.*/, + Literal/*->types::Test.Literal.*/.float/*->types::Test.Literal.float.*/, + Literal/*->types::Test.Literal.*/.double/*->types::Test.Literal.double.*/, + Literal/*->types::Test.Literal.*/.nil/*->types::Test.Literal.nil.*/, + Literal/*->types::Test.Literal.*/.char/*->types::Test.Literal.char.*/, + Literal/*->types::Test.Literal.*/.string/*->types::Test.Literal.string.*/, + Literal/*->types::Test.Literal.*/.bool/*->types::Test.Literal.bool.*/, + Literal/*->types::Test.Literal.*/.unit/*->types::Test.Literal.unit.*/, + Literal/*->types::Test.Literal.*/.javaEnum/*->types::Test.Literal.javaEnum.*/, + Literal/*->types::Test.Literal.*/.clazzOf/*->types::Test.Literal.clazzOf.*/, + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/() ) - type AnnotatedType/*<<=example.InstrumentTyper#AnnotatedType#*/ = Int/*=>>scala.Int#*/ @param - def singletonType/*<<=example.InstrumentTyper#singletonType().*/(x/*<<=example.InstrumentTyper#singletonType().(x)*/: Predef/*=>>scala.Predef.*/.type) = ???/*=>>scala.Predef.`???`().*/ - final val clazzOf/*<<=example.InstrumentTyper#clazzOf.*/ = classOf/*=>>scala.Predef.classOf().*/[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] + type AnnotatedType/*<-example::InstrumentTyper#AnnotatedType#*/ = Int/*->scala::Int#*/ @param + def singletonType/*<-example::InstrumentTyper#singletonType().*/(x/*<-example::InstrumentTyper#singletonType().(x)*/: Predef/*->scala::Predef.*/.type) = ???/*->scala::Predef.`???`().*/ + final val clazzOf/*<-example::InstrumentTyper#clazzOf.*/ = classOf/*->scala::Predef.classOf().*/[Option/*->scala::Option#*/[Int/*->scala::Int#*/]] } diff --git a/tests/semanticdb/expect/Issue1749.expect.scala b/tests/semanticdb/expect/Issue1749.expect.scala index 4d037610ca25..185b2cd86318 100644 --- a/tests/semanticdb/expect/Issue1749.expect.scala +++ b/tests/semanticdb/expect/Issue1749.expect.scala @@ -1,16 +1,16 @@ // See https://github.com/scalameta/scalameta/issues/1749 package example -import scala.math.Ordered/*=>>scala.math.Ordered.*/.orderingToOrdered/*=>>scala.math.Ordered.orderingToOrdered().*/ +import scala.math.Ordered/*->scala::math::Ordered.*/.orderingToOrdered/*->scala::math::Ordered.orderingToOrdered().*/ -class Issue1749/*<<=example.Issue1749#*/ { - val x1/*<<=example.Issue1749#x1.*/ = 42 - val x2/*<<=example.Issue1749#x2.*/ = 42 - /*=>>scala.math.Ordered.orderingToOrdered().*/(x1/*=>>example.Issue1749#x1.*/, x1/*=>>example.Issue1749#x1.*/)/*=>>scala.math.Ordering.Tuple2().*//*=>>scala.math.Ordering.Int.*/ - .compare/*=>>scala.math.Ordered#compare().*/((x2/*=>>example.Issue1749#x2.*/, x2/*=>>example.Issue1749#x2.*/)) +class Issue1749/*<-example::Issue1749#*/ { + val x1/*<-example::Issue1749#x1.*/ = 42 + val x2/*<-example::Issue1749#x2.*/ = 42 + /*->scala::math::Ordered.orderingToOrdered().*/(x1/*->example::Issue1749#x1.*/, x1/*->example::Issue1749#x1.*/)/*->scala::math::Ordering.Tuple2().*//*->scala::math::Ordering.Int.*/ + .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" +class Issue1854/*<-example::Issue1854#*/ { + val map/*<-example::Issue1854#map.*/ = collection.mutable.Map/*->scala::collection::mutable::Map.*/.empty/*->scala::collection::MapFactory.Delegate#empty().*/[String/*->scala::Predef.String#*/, String/*->scala::Predef.String#*/] + map/*->example::Issue1854#map.*//*->scala::collection::mutable::MapOps#update().*/("a") = "b" } diff --git a/tests/semanticdb/expect/Local.expect.scala b/tests/semanticdb/expect/Local.expect.scala index f48a6dd28db5..6c1aa8440b23 100644 --- a/tests/semanticdb/expect/Local.expect.scala +++ b/tests/semanticdb/expect/Local.expect.scala @@ -1,8 +1,8 @@ package example -class Local/*<<=example.Local#*/ { - def a/*<<=example.Local#a().*/() = { - def id/*<<=local0*/[A/*<<=local1*/](a/*<<=local2*/: A/*=>>local1*/): A/*=>>local1*/ = a/*=>>local2*/ - id/*=>>local0*/(1) +class Local/*<-example::Local#*/ { + def a/*<-example::Local#a().*/() = { + def id/*<-local0*/[A/*<-local1*/](a/*<-local2*/: A/*->local1*/): A/*->local1*/ = a/*->local2*/ + id/*->local0*/(1) } } diff --git a/tests/semanticdb/expect/Locals.expect.scala b/tests/semanticdb/expect/Locals.expect.scala index c6d4cf14fecf..7a8fdf0dd432 100644 --- a/tests/semanticdb/expect/Locals.expect.scala +++ b/tests/semanticdb/expect/Locals.expect.scala @@ -1,8 +1,8 @@ package locals -object Test/*<<=locals.Test.*/ { - val xs/*<<=locals.Test.xs.*/ = { - val x/*<<=local0*/ = 42 - List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(x/*=>>local0*/) +object Test/*<-locals::Test.*/ { + val xs/*<-locals::Test.xs.*/ = { + val x/*<-local0*/ = 42 + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(x/*->local0*/) } } diff --git a/tests/semanticdb/expect/MetacJava.expect.scala b/tests/semanticdb/expect/MetacJava.expect.scala index 0534f2d91c69..f95f82d787eb 100644 --- a/tests/semanticdb/expect/MetacJava.expect.scala +++ b/tests/semanticdb/expect/MetacJava.expect.scala @@ -2,19 +2,19 @@ package example import com.javacp -class MetacJava/*<<=example.MetacJava#*/ { - javacp.MetacJava/*=>>com.javacp.MetacJava#*/.StaticInner/*=>>com.javacp.MetacJava#StaticInner#*/.isStatic/*=>>com.javacp.MetacJava#StaticInner#isStatic().*/() - new javacp.MetacJava/*=>>com.javacp.MetacJava#*/.StaticInner/*=>>com.javacp.MetacJava#StaticInner#*//*=>>com.javacp.MetacJava#StaticInner#``().*/().isNotStatic/*=>>com.javacp.MetacJava#StaticInner#isNotStatic().*/() - val inner/*<<=example.MetacJava#inner.*/ = new javacp.MetacJava/*=>>com.javacp.MetacJava#*//*=>>com.javacp.MetacJava#``().*/() - val overload1/*<<=example.MetacJava#overload1.*/ = new inner/*=>>example.MetacJava#inner.*/.Overload1/*=>>com.javacp.MetacJava#Overload1#*//*=>>com.javacp.MetacJava#Overload1#``().*/() - val overload2/*<<=example.MetacJava#overload2.*/ = new inner/*=>>example.MetacJava#inner.*/.Overload2/*=>>com.javacp.MetacJava#Overload2#*//*=>>com.javacp.MetacJava#Overload2#``().*/() - inner/*=>>example.MetacJava#inner.*/.overload/*=>>com.javacp.MetacJava#overload().*/(new overload1/*=>>example.MetacJava#overload1.*/.A/*=>>com.javacp.MetacJava#Overload1#A#*//*=>>com.javacp.MetacJava#Overload1#A#``().*/()) - inner/*=>>example.MetacJava#inner.*/.overload/*=>>com.javacp.MetacJava#overload(+1).*/(new overload2/*=>>example.MetacJava#overload2.*/.A/*=>>com.javacp.MetacJava#Overload2#A#*//*=>>com.javacp.MetacJava#Overload2#A#``().*/()) - val staticInner/*<<=example.MetacJava#staticInner.*/ = new javacp.MetacJava/*=>>com.javacp.MetacJava#*/.StaticInner/*=>>com.javacp.MetacJava#StaticInner#*//*=>>com.javacp.MetacJava#StaticInner#``().*/() - val nonStatic/*<<=example.MetacJava#nonStatic.*/ = new staticInner/*=>>example.MetacJava#staticInner.*/.NonStatic/*=>>com.javacp.MetacJava#StaticInner#NonStatic#*//*=>>com.javacp.MetacJava#StaticInner#NonStatic#``().*/() - nonStatic/*=>>example.MetacJava#nonStatic.*/.method/*=>>com.javacp.MetacJava#StaticInner#NonStatic#method().*/(nonStatic/*=>>example.MetacJava#nonStatic.*/) - javacp.MetacJava/*=>>com.javacp.MetacJava#*/.overload/*=>>com.javacp.MetacJava#overload(+2).*/(new javacp.MetacJava/*=>>com.javacp.MetacJava#*/.Overload3/*=>>com.javacp.MetacJava#Overload3#*/.A/*=>>com.javacp.MetacJava#Overload3#A#*//*=>>com.javacp.MetacJava#Overload3#A#``().*/()) - val interface/*<<=example.MetacJava#interface.*/: javacp.Interface/*=>>com.javacp.Interface#*/ = null - val coin/*<<=example.MetacJava#coin.*/: javacp.Coin/*=>>com.javacp.Coin#*/ = javacp.Coin/*=>>com.javacp.Coin#*/.PENNY/*=>>com.javacp.Coin#PENNY.*/ - val entry/*<<=example.MetacJava#entry.*/: java.util.Map/*=>>java.util.Map#*/.Entry/*=>>java.util.Map#Entry#*/[Int/*=>>scala.Int#*/, Int/*=>>scala.Int#*/] = null +class MetacJava/*<-example::MetacJava#*/ { + javacp.MetacJava/*->com::javacp::MetacJava#*/.StaticInner/*->com::javacp::MetacJava#StaticInner#*/.isStatic/*->com::javacp::MetacJava#StaticInner#isStatic().*/() + new javacp.MetacJava/*->com::javacp::MetacJava#*/.StaticInner/*->com::javacp::MetacJava#StaticInner#*//*->com::javacp::MetacJava#StaticInner#``().*/().isNotStatic/*->com::javacp::MetacJava#StaticInner#isNotStatic().*/() + val inner/*<-example::MetacJava#inner.*/ = new javacp.MetacJava/*->com::javacp::MetacJava#*//*->com::javacp::MetacJava#``().*/() + val overload1/*<-example::MetacJava#overload1.*/ = new inner/*->example::MetacJava#inner.*/.Overload1/*->com::javacp::MetacJava#Overload1#*//*->com::javacp::MetacJava#Overload1#``().*/() + val overload2/*<-example::MetacJava#overload2.*/ = new inner/*->example::MetacJava#inner.*/.Overload2/*->com::javacp::MetacJava#Overload2#*//*->com::javacp::MetacJava#Overload2#``().*/() + inner/*->example::MetacJava#inner.*/.overload/*->com::javacp::MetacJava#overload().*/(new overload1/*->example::MetacJava#overload1.*/.A/*->com::javacp::MetacJava#Overload1#A#*//*->com::javacp::MetacJava#Overload1#A#``().*/()) + inner/*->example::MetacJava#inner.*/.overload/*->com::javacp::MetacJava#overload(+1).*/(new overload2/*->example::MetacJava#overload2.*/.A/*->com::javacp::MetacJava#Overload2#A#*//*->com::javacp::MetacJava#Overload2#A#``().*/()) + val staticInner/*<-example::MetacJava#staticInner.*/ = new javacp.MetacJava/*->com::javacp::MetacJava#*/.StaticInner/*->com::javacp::MetacJava#StaticInner#*//*->com::javacp::MetacJava#StaticInner#``().*/() + val nonStatic/*<-example::MetacJava#nonStatic.*/ = new staticInner/*->example::MetacJava#staticInner.*/.NonStatic/*->com::javacp::MetacJava#StaticInner#NonStatic#*//*->com::javacp::MetacJava#StaticInner#NonStatic#``().*/() + nonStatic/*->example::MetacJava#nonStatic.*/.method/*->com::javacp::MetacJava#StaticInner#NonStatic#method().*/(nonStatic/*->example::MetacJava#nonStatic.*/) + javacp.MetacJava/*->com::javacp::MetacJava#*/.overload/*->com::javacp::MetacJava#overload(+2).*/(new javacp.MetacJava/*->com::javacp::MetacJava#*/.Overload3/*->com::javacp::MetacJava#Overload3#*/.A/*->com::javacp::MetacJava#Overload3#A#*//*->com::javacp::MetacJava#Overload3#A#``().*/()) + val interface/*<-example::MetacJava#interface.*/: javacp.Interface/*->com::javacp::Interface#*/ = null + val coin/*<-example::MetacJava#coin.*/: javacp.Coin/*->com::javacp::Coin#*/ = javacp.Coin/*->com::javacp::Coin#*/.PENNY/*->com::javacp::Coin#PENNY.*/ + val entry/*<-example::MetacJava#entry.*/: java.util.Map/*->java::util::Map#*/.Entry/*->java::util::Map#Entry#*/[Int/*->scala::Int#*/, Int/*->scala::Int#*/] = null } diff --git a/tests/semanticdb/expect/MethodUsages.expect.scala b/tests/semanticdb/expect/MethodUsages.expect.scala index 8115e0631621..e98486a0a663 100644 --- a/tests/semanticdb/expect/MethodUsages.expect.scala +++ b/tests/semanticdb/expect/MethodUsages.expect.scala @@ -1,32 +1,32 @@ package example -class MethodUsages/*<<=example.MethodUsages#*/ { - val m/*<<=example.MethodUsages#m.*/ = new Methods/*=>>example.Methods#*/[Int/*=>>scala.Int#*/]/*=>>example.Methods#``().*/ - m/*=>>example.MethodUsages#m.*/.m1/*=>>example.Methods#m1().*/ - m/*=>>example.MethodUsages#m.*/.m2/*=>>example.Methods#m2().*/() - m/*=>>example.MethodUsages#m.*/.m3/*=>>example.Methods#m3().*/(0) - m/*=>>example.MethodUsages#m.*/.m4/*=>>example.Methods#m4().*/(0)(0) - m/*=>>example.MethodUsages#m.*/.m5/*=>>example.Methods#m5().*/("") - m/*=>>example.MethodUsages#m.*/.m5/*=>>example.Methods#m5(+1).*/(0) - m/*=>>example.MethodUsages#m.*/.m6/*=>>example.Methods#m6().*/(0) - m/*=>>example.MethodUsages#m.*/.m6/*=>>example.Methods#m6(+1).*/(new m/*=>>example.MethodUsages#m.*/.List/*=>>example.Methods#List#*/[Int/*=>>scala.Int#*/]/*=>>example.Methods#List#``().*/) - m/*=>>example.MethodUsages#m.*/.m6/*=>>example.Methods#m6(+2).*/(Nil/*=>>scala.package.Nil.*/) - m/*=>>example.MethodUsages#m.*/.m7/*=>>example.Methods#m7().*/(m/*=>>example.MethodUsages#m.*/, new m/*=>>example.MethodUsages#m.*/.List/*=>>example.Methods#List#*/[Int/*=>>scala.Int#*/]/*=>>example.Methods#List#``().*/)/*=>>scala.math.Ordering.Int.*/ - m/*=>>example.MethodUsages#m.*/.`m8().`/*=>>example.Methods#`m8().`().*/() +class MethodUsages/*<-example::MethodUsages#*/ { + val m/*<-example::MethodUsages#m.*/ = new Methods/*->example::Methods#*/[Int/*->scala::Int#*/]/*->example::Methods#``().*/ + m/*->example::MethodUsages#m.*/.m1/*->example::Methods#m1().*/ + m/*->example::MethodUsages#m.*/.m2/*->example::Methods#m2().*/() + m/*->example::MethodUsages#m.*/.m3/*->example::Methods#m3().*/(0) + m/*->example::MethodUsages#m.*/.m4/*->example::Methods#m4().*/(0)(0) + m/*->example::MethodUsages#m.*/.m5/*->example::Methods#m5().*/("") + m/*->example::MethodUsages#m.*/.m5/*->example::Methods#m5(+1).*/(0) + m/*->example::MethodUsages#m.*/.m6/*->example::Methods#m6().*/(0) + m/*->example::MethodUsages#m.*/.m6/*->example::Methods#m6(+1).*/(new m/*->example::MethodUsages#m.*/.List/*->example::Methods#List#*/[Int/*->scala::Int#*/]/*->example::Methods#List#``().*/) + m/*->example::MethodUsages#m.*/.m6/*->example::Methods#m6(+2).*/(Nil/*->scala::package.Nil.*/) + m/*->example::MethodUsages#m.*/.m7/*->example::Methods#m7().*/(m/*->example::MethodUsages#m.*/, new m/*->example::MethodUsages#m.*/.List/*->example::Methods#List#*/[Int/*->scala::Int#*/]/*->example::Methods#List#``().*/)/*->scala::math::Ordering.Int.*/ + m/*->example::MethodUsages#m.*/.`m8().`/*->example::Methods#`m8().`().*/() // m.m9(null) suspended due to issue https://github.com/lampepfl/dotty/issues/7514 - m/*=>>example.MethodUsages#m.*/.m10/*=>>example.Methods#m10().*/(null) - m/*=>>example.MethodUsages#m.*/.m11/*=>>example.Methods#m11().*/(Predef/*=>>scala.Predef.*/) - m/*=>>example.MethodUsages#m.*/.m11/*=>>example.Methods#m11(+1).*/(Example/*=>>example.Example.*/) - m/*=>>example.MethodUsages#m.*/.m12a/*=>>example.Methods#m12a().*/(null) - m/*=>>example.MethodUsages#m.*/.m12b/*=>>example.Methods#m12b().*/(null) - m/*=>>example.MethodUsages#m.*/.m13/*=>>example.Methods#m13().*/(0) - m/*=>>example.MethodUsages#m.*/.m15/*=>>example.Methods#m15().*/(0) - m/*=>>example.MethodUsages#m.*/.m16/*=>>example.Methods#m16().*/(0) - m/*=>>example.MethodUsages#m.*/.m16/*=>>example.Methods#m16().*/(0) - m/*=>>example.MethodUsages#m.*/.m17/*=>>example.Methods#m17.*/.m/*=>>example.Methods#m17.m().*/() - m/*=>>example.MethodUsages#m.*/.m17/*=>>example.Methods#m17().*/(1) - m/*=>>example.MethodUsages#m.*/.m17/*=>>example.Methods#m17(+1).*/("") - m/*=>>example.MethodUsages#m.*/.m18/*=>>example.Methods#m18.*/.m/*=>>example.Methods#m17.m().*/() - m/*=>>example.MethodUsages#m.*/.m18/*=>>example.Methods#m18().*/(1) - m/*=>>example.MethodUsages#m.*/.m18/*=>>example.Methods#m18(+1).*/("") + m/*->example::MethodUsages#m.*/.m10/*->example::Methods#m10().*/(null) + m/*->example::MethodUsages#m.*/.m11/*->example::Methods#m11().*/(Predef/*->scala::Predef.*/) + m/*->example::MethodUsages#m.*/.m11/*->example::Methods#m11(+1).*/(Example/*->example::Example.*/) + m/*->example::MethodUsages#m.*/.m12a/*->example::Methods#m12a().*/(null) + m/*->example::MethodUsages#m.*/.m12b/*->example::Methods#m12b().*/(null) + m/*->example::MethodUsages#m.*/.m13/*->example::Methods#m13().*/(0) + m/*->example::MethodUsages#m.*/.m15/*->example::Methods#m15().*/(0) + m/*->example::MethodUsages#m.*/.m16/*->example::Methods#m16().*/(0) + m/*->example::MethodUsages#m.*/.m16/*->example::Methods#m16().*/(0) + m/*->example::MethodUsages#m.*/.m17/*->example::Methods#m17.*/.m/*->example::Methods#m17.m().*/() + m/*->example::MethodUsages#m.*/.m17/*->example::Methods#m17().*/(1) + m/*->example::MethodUsages#m.*/.m17/*->example::Methods#m17(+1).*/("") + m/*->example::MethodUsages#m.*/.m18/*->example::Methods#m18.*/.m/*->example::Methods#m17.m().*/() + m/*->example::MethodUsages#m.*/.m18/*->example::Methods#m18().*/(1) + m/*->example::MethodUsages#m.*/.m18/*->example::Methods#m18(+1).*/("") } diff --git a/tests/semanticdb/expect/Methods.expect.scala b/tests/semanticdb/expect/Methods.expect.scala index 877d125b25e7..29c2a063c3aa 100644 --- a/tests/semanticdb/expect/Methods.expect.scala +++ b/tests/semanticdb/expect/Methods.expect.scala @@ -1,37 +1,37 @@ package example -import scala.math.Ordering/*=>>scala.math.Ordering.*//*=>>scala.math.Ordering#*/ -import scala.language/*=>>scalaShadowing.language.*/.existentials/*=>>scalaShadowing.language.existentials.*/ +import scala.math.Ordering/*->scala::math::Ordering.*//*->scala::math::Ordering#*/ +import scala.language/*->scalaShadowing::language.*/.existentials/*->scalaShadowing::language.existentials.*/ -class Methods/*<<=example.Methods#*/[T/*<<=example.Methods#[T]*/] { - class List/*<<=example.Methods#List#*/[T/*<<=example.Methods#List#[T]*/] - type AList/*<<=example.Methods#AList#*/[T/*<<=example.Methods#AList#[T]*/] = List/*=>>example.Methods#List#*/[T/*=>>example.Methods#AList#[T]*/] - def m1/*<<=example.Methods#m1().*/ = ???/*=>>scala.Predef.`???`().*/ - def m2/*<<=example.Methods#m2().*/() = ???/*=>>scala.Predef.`???`().*/ - def m3/*<<=example.Methods#m3().*/(x/*<<=example.Methods#m3().(x)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ - def m4/*<<=example.Methods#m4().*/(x/*<<=example.Methods#m4().(x)*/: Int/*=>>scala.Int#*/)(y/*<<=example.Methods#m4().(y)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ - def m5/*<<=example.Methods#m5().*/(x/*<<=example.Methods#m5().(x)*/: String/*=>>scala.Predef.String#*/) = ???/*=>>scala.Predef.`???`().*/ - def m5/*<<=example.Methods#m5(+1).*/(x/*<<=example.Methods#m5(+1).(x)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ - def m6/*<<=example.Methods#m6().*/(x/*<<=example.Methods#m6().(x)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ - def m6/*<<=example.Methods#m6(+1).*/(x/*<<=example.Methods#m6(+1).(x)*/: List/*=>>example.Methods#List#*/[T/*=>>example.Methods#[T]*/]) = ???/*=>>scala.Predef.`???`().*/ - def m6/*<<=example.Methods#m6(+2).*/(x/*<<=example.Methods#m6(+2).(x)*/: scala.List/*=>>scala.package.List#*/[T/*=>>example.Methods#[T]*/]) = ???/*=>>scala.Predef.`???`().*/ - def m7/*<<=example.Methods#m7().*/[U/*<<=example.Methods#m7().[U]*//*<<=example.Methods#m7().(evidence$1)*/: Ordering/*=>>scala.math.Ordering#*//*=>>example.Methods#m7().[U]*/](c/*<<=example.Methods#m7().(c)*/: Methods/*=>>example.Methods#*/[T/*=>>example.Methods#[T]*/], l/*<<=example.Methods#m7().(l)*/: List/*=>>example.Methods#List#*/[U/*=>>example.Methods#m7().[U]*/]) = ???/*=>>scala.Predef.`???`().*/ - def `m8().`() =/*<<=example.Methods#`m8().`().*/ ???/*=>>scala.Predef.`???`().*/ +class Methods/*<-example::Methods#*/[T/*<-example::Methods#[T]*/] { + class List/*<-example::Methods#List#*/[T/*<-example::Methods#List#[T]*/] + type AList/*<-example::Methods#AList#*/[T/*<-example::Methods#AList#[T]*/] = List/*->example::Methods#List#*/[T/*->example::Methods#AList#[T]*/] + def m1/*<-example::Methods#m1().*/ = ???/*->scala::Predef.`???`().*/ + def m2/*<-example::Methods#m2().*/() = ???/*->scala::Predef.`???`().*/ + def m3/*<-example::Methods#m3().*/(x/*<-example::Methods#m3().(x)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m4/*<-example::Methods#m4().*/(x/*<-example::Methods#m4().(x)*/: Int/*->scala::Int#*/)(y/*<-example::Methods#m4().(y)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m5/*<-example::Methods#m5().*/(x/*<-example::Methods#m5().(x)*/: String/*->scala::Predef.String#*/) = ???/*->scala::Predef.`???`().*/ + def m5/*<-example::Methods#m5(+1).*/(x/*<-example::Methods#m5(+1).(x)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m6/*<-example::Methods#m6().*/(x/*<-example::Methods#m6().(x)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m6/*<-example::Methods#m6(+1).*/(x/*<-example::Methods#m6(+1).(x)*/: List/*->example::Methods#List#*/[T/*->example::Methods#[T]*/]) = ???/*->scala::Predef.`???`().*/ + def m6/*<-example::Methods#m6(+2).*/(x/*<-example::Methods#m6(+2).(x)*/: scala.List/*->scala::package.List#*/[T/*->example::Methods#[T]*/]) = ???/*->scala::Predef.`???`().*/ + def m7/*<-example::Methods#m7().*/[U/*<-example::Methods#m7().[U]*//*<-example::Methods#m7().(evidence$1)*/: Ordering/*->scala::math::Ordering#*//*->example::Methods#m7().[U]*/](c/*<-example::Methods#m7().(c)*/: Methods/*->example::Methods#*/[T/*->example::Methods#[T]*/], l/*<-example::Methods#m7().(l)*/: List/*->example::Methods#List#*/[U/*->example::Methods#m7().[U]*/]) = ???/*->scala::Predef.`???`().*/ + def `m8().`() =/*<-example::Methods#`m8().`().*/ ???/*->scala::Predef.`???`().*/ class `m9().` - d/*<<=example.Methods#`m9().`#*/ef m9/*<<=example.Methods#m9().*/(x/*<<=example.Methods#m9().(x)*/: `m9().`/*=>>example.Methods#`m9().`#*/) = ???/*=>>scala.Predef.`???`().*/ - def m10/*<<=example.Methods#m10().*/(x/*<<=example.Methods#m10().(x)*/: AList/*=>>example.Methods#AList#*/[T/*=>>example.Methods#[T]*/]) = ???/*=>>scala.Predef.`???`().*/ - def m11/*<<=example.Methods#m11().*/(x/*<<=example.Methods#m11().(x)*/: Predef/*=>>scala.Predef.*/.type) = ???/*=>>scala.Predef.`???`().*/ - def m11/*<<=example.Methods#m11(+1).*/(x/*<<=example.Methods#m11(+1).(x)*/: Example/*=>>example.Example.*/.type) = ???/*=>>scala.Predef.`???`().*/ - def m12a/*<<=example.Methods#m12a().*/(x/*<<=example.Methods#m12a().(x)*/: {}) = ???/*=>>scala.Predef.`???`().*/ - def m12b/*<<=example.Methods#m12b().*/(x/*<<=example.Methods#m12b().(x)*/: { val x/*<<=local0*/: Int/*=>>scala.Int#*/ }) = ???/*=>>scala.Predef.`???`().*/ - def m13/*<<=example.Methods#m13().*/(x/*<<=example.Methods#m13().(x)*/: Int/*=>>scala.Int#*/ @unchecked) = ???/*=>>scala.Predef.`???`().*/ - def m15/*<<=example.Methods#m15().*/(x/*<<=example.Methods#m15().(x)*/: => Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ - def m16/*<<=example.Methods#m16().*/(x/*<<=example.Methods#m16().(x)*/: Int/*=>>scala.Int#*/*) = ???/*=>>scala.Predef.`???`().*/ - object m17/*<<=example.Methods#m17.*/ { def m/*<<=example.Methods#m17.m().*/() = ???/*=>>scala.Predef.`???`().*/ } - def m17/*<<=example.Methods#m17().*/(a/*<<=example.Methods#m17().(a)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ - def m17/*<<=example.Methods#m17(+1).*/(b/*<<=example.Methods#m17(+1).(b)*/: String/*=>>scala.Predef.String#*/) = ???/*=>>scala.Predef.`???`().*/ - val m18/*<<=example.Methods#m18.*/ = m17/*=>>example.Methods#m17.*/ - def m18/*<<=example.Methods#m18().*/(a/*<<=example.Methods#m18().(a)*/: Int/*=>>scala.Int#*/) = ???/*=>>scala.Predef.`???`().*/ - def m18/*<<=example.Methods#m18(+1).*/(b/*<<=example.Methods#m18(+1).(b)*/: String/*=>>scala.Predef.String#*/) = ???/*=>>scala.Predef.`???`().*/ - def m19/*<<=example.Methods#m19().*/(x/*<<=example.Methods#m19().(x)*//*<<=example.Methods#m19$default$3().(x)*/: Int/*=>>scala.Int#*/, y/*<<=example.Methods#m19().(y)*//*<<=example.Methods#m19$default$3().(y)*/: Int/*=>>scala.Int#*/ = 2)(z/*<<=example.Methods#m19().(z)*/: Int/*=>>scala.Int#*/ = 3) = ???/*=>>scala.Predef.`???`().*/ + d/*<-example::Methods#`m9().`#*/ef m9/*<-example::Methods#m9().*/(x/*<-example::Methods#m9().(x)*/: `m9().`/*->example::Methods#`m9().`#*/) = ???/*->scala::Predef.`???`().*/ + def m10/*<-example::Methods#m10().*/(x/*<-example::Methods#m10().(x)*/: AList/*->example::Methods#AList#*/[T/*->example::Methods#[T]*/]) = ???/*->scala::Predef.`???`().*/ + def m11/*<-example::Methods#m11().*/(x/*<-example::Methods#m11().(x)*/: Predef/*->scala::Predef.*/.type) = ???/*->scala::Predef.`???`().*/ + def m11/*<-example::Methods#m11(+1).*/(x/*<-example::Methods#m11(+1).(x)*/: Example/*->example::Example.*/.type) = ???/*->scala::Predef.`???`().*/ + def m12a/*<-example::Methods#m12a().*/(x/*<-example::Methods#m12a().(x)*/: {}) = ???/*->scala::Predef.`???`().*/ + def m12b/*<-example::Methods#m12b().*/(x/*<-example::Methods#m12b().(x)*/: { val x/*<-local0*/: Int/*->scala::Int#*/ }) = ???/*->scala::Predef.`???`().*/ + def m13/*<-example::Methods#m13().*/(x/*<-example::Methods#m13().(x)*/: Int/*->scala::Int#*/ @unchecked) = ???/*->scala::Predef.`???`().*/ + def m15/*<-example::Methods#m15().*/(x/*<-example::Methods#m15().(x)*/: => Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m16/*<-example::Methods#m16().*/(x/*<-example::Methods#m16().(x)*/: Int/*->scala::Int#*/*) = ???/*->scala::Predef.`???`().*/ + object m17/*<-example::Methods#m17.*/ { def m/*<-example::Methods#m17.m().*/() = ???/*->scala::Predef.`???`().*/ } + def m17/*<-example::Methods#m17().*/(a/*<-example::Methods#m17().(a)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m17/*<-example::Methods#m17(+1).*/(b/*<-example::Methods#m17(+1).(b)*/: String/*->scala::Predef.String#*/) = ???/*->scala::Predef.`???`().*/ + val m18/*<-example::Methods#m18.*/ = m17/*->example::Methods#m17.*/ + def m18/*<-example::Methods#m18().*/(a/*<-example::Methods#m18().(a)*/: Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ + def m18/*<-example::Methods#m18(+1).*/(b/*<-example::Methods#m18(+1).(b)*/: String/*->scala::Predef.String#*/) = ???/*->scala::Predef.`???`().*/ + def m19/*<-example::Methods#m19().*/(x/*<-example::Methods#m19().(x)*//*<-example::Methods#m19$default$3().(x)*/: Int/*->scala::Int#*/, y/*<-example::Methods#m19().(y)*//*<-example::Methods#m19$default$3().(y)*/: Int/*->scala::Int#*/ = 2)(z/*<-example::Methods#m19().(z)*/: Int/*->scala::Int#*/ = 3) = ???/*->scala::Predef.`???`().*/ } diff --git a/tests/semanticdb/expect/NamedApplyBlock.expect.scala b/tests/semanticdb/expect/NamedApplyBlock.expect.scala index 5a7b0786b119..a527c523bda5 100644 --- a/tests/semanticdb/expect/NamedApplyBlock.expect.scala +++ b/tests/semanticdb/expect/NamedApplyBlock.expect.scala @@ -1,14 +1,14 @@ package example -object NamedApplyBlockMethods/*<<=example.NamedApplyBlockMethods.*/ { - val local/*<<=example.NamedApplyBlockMethods.local.*/ = 1 - def foo/*<<=example.NamedApplyBlockMethods.foo().*/(a/*<<=example.NamedApplyBlockMethods.foo().(a)*/: Int/*=>>scala.Int#*/ = 1, b/*<<=example.NamedApplyBlockMethods.foo().(b)*/: Int/*=>>scala.Int#*/ = 2, c/*<<=example.NamedApplyBlockMethods.foo().(c)*/: Int/*=>>scala.Int#*/ = 3): Int/*=>>scala.Int#*/ = a/*=>>example.NamedApplyBlockMethods.foo().(a)*/ +/*=>>scala.Int#`+`(+4).*/ b/*=>>example.NamedApplyBlockMethods.foo().(b)*/ +/*=>>scala.Int#`+`(+4).*/ c/*=>>example.NamedApplyBlockMethods.foo().(c)*/ - def baseCase/*<<=example.NamedApplyBlockMethods.baseCase().*/ = foo/*=>>example.NamedApplyBlockMethods.foo().*/(local/*=>>example.NamedApplyBlockMethods.local.*/, c = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter - def recursive/*<<=example.NamedApplyBlockMethods.recursive().*/ = foo/*=>>example.NamedApplyBlockMethods.foo().*/(local/*=>>example.NamedApplyBlockMethods.local.*/, c = foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter +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 = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter + def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*/(local/*->example::NamedApplyBlockMethods.local.*/, c = foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter } -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.*/(bodyText/*=>>example.NamedApplyBlockCaseClassConstruction.bodyText.*/, tail = "tail") +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.*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail = "tail") } diff --git a/tests/semanticdb/expect/NamedArguments.expect.scala b/tests/semanticdb/expect/NamedArguments.expect.scala index bfae8a62783a..346525953482 100644 --- a/tests/semanticdb/expect/NamedArguments.expect.scala +++ b/tests/semanticdb/expect/NamedArguments.expect.scala @@ -1,7 +1,7 @@ package example -class NamedArguments/*<<=example.NamedArguments#*/ { - case class User/*<<=example.NamedArguments#User#*/(name/*<<=example.NamedArguments#User#name.*/: String/*=>>scala.Predef.String#*/) - User/*=>>example.NamedArguments#User.*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg - User/*=>>example.NamedArguments#User.*/.apply/*=>>example.NamedArguments#User.apply().*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg +class NamedArguments/*<-example::NamedArguments#*/ { + case class User/*<-example::NamedArguments#User#*/(name/*<-example::NamedArguments#User#name.*/: String/*->scala::Predef.String#*/) + User/*->example::NamedArguments#User.*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg + User/*->example::NamedArguments#User.*/.apply/*->example::NamedArguments#User.apply().*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg } diff --git a/tests/semanticdb/expect/NewModifiers.expect.scala b/tests/semanticdb/expect/NewModifiers.expect.scala index ea3ef1abe154..bc0d1dcf71e7 100644 --- a/tests/semanticdb/expect/NewModifiers.expect.scala +++ b/tests/semanticdb/expect/NewModifiers.expect.scala @@ -1,4 +1,4 @@ -object NewModifiers/*<<=_empty_.NewModifiers.*/ { - inline val foo/*<<=_empty_.NewModifiers.foo.*/ = "foo" - opaque type A/*<<=_empty_.NewModifiers.A#*/ = Int/*=>>scala.Int#*/ +object NewModifiers/*<-_empty_::NewModifiers.*/ { + inline val foo/*<-_empty_::NewModifiers.foo.*/ = "foo" + opaque type A/*<-_empty_::NewModifiers.A#*/ = Int/*->scala::Int#*/ } diff --git a/tests/semanticdb/expect/Objects.expect.scala b/tests/semanticdb/expect/Objects.expect.scala index dcb17d507bfd..d833d361b9e0 100644 --- a/tests/semanticdb/expect/Objects.expect.scala +++ b/tests/semanticdb/expect/Objects.expect.scala @@ -1,5 +1,5 @@ package objects -object X/*<<=objects.X.*/ { - object Y/*<<=objects.X.Y.*/ +object X/*<-objects::X.*/ { + object Y/*<-objects::X.Y.*/ } diff --git a/tests/semanticdb/expect/Overrides.expect.scala b/tests/semanticdb/expect/Overrides.expect.scala index dd0438238129..21e667b51cba 100644 --- a/tests/semanticdb/expect/Overrides.expect.scala +++ b/tests/semanticdb/expect/Overrides.expect.scala @@ -1,4 +1,4 @@ package example -trait A/*<<=example.A#*/ { def foo/*<<=example.A#foo().*/: Int/*=>>scala.Int#*/ } -class B/*<<=example.B#*/() extends A/*=>>example.A#*/ { def foo/*<<=example.B#foo().*/: Int/*=>>scala.Int#*/ = 2 } +trait A/*<-example::A#*/ { def foo/*<-example::A#foo().*/: Int/*->scala::Int#*/ } +class B/*<-example::B#*/() extends A/*->example::A#*/ { def foo/*<-example::B#foo().*/: Int/*->scala::Int#*/ = 2 } diff --git a/tests/semanticdb/expect/Prefixes.expect.scala b/tests/semanticdb/expect/Prefixes.expect.scala index cf863a438b35..0873e23555a7 100644 --- a/tests/semanticdb/expect/Prefixes.expect.scala +++ b/tests/semanticdb/expect/Prefixes.expect.scala @@ -1,33 +1,33 @@ package prefixes -class C/*<<=prefixes.C#*/ { - type T/*<<=prefixes.C#T#*/ - def m1/*<<=prefixes.C#m1().*/: T/*=>>prefixes.C#T#*/ = ???/*=>>scala.Predef.`???`().*/ +class C/*<-prefixes::C#*/ { + type T/*<-prefixes::C#T#*/ + def m1/*<-prefixes::C#m1().*/: T/*->prefixes::C#T#*/ = ???/*->scala::Predef.`???`().*/ - object N/*<<=prefixes.C#N.*/ { - type U/*<<=prefixes.C#N.U#*/ + object N/*<-prefixes::C#N.*/ { + type U/*<-prefixes::C#N.U#*/ } - def k1/*<<=prefixes.C#k1().*/: N/*=>>prefixes.C#N.*/.U/*=>>prefixes.C#N.U#*/ = ???/*=>>scala.Predef.`???`().*/ + def k1/*<-prefixes::C#k1().*/: N/*->prefixes::C#N.*/.U/*->prefixes::C#N.U#*/ = ???/*->scala::Predef.`???`().*/ } -object M/*<<=prefixes.M.*/ { - type T/*<<=prefixes.M.T#*/ - def n1/*<<=prefixes.M.n1().*/: T/*=>>prefixes.M.T#*/ = ???/*=>>scala.Predef.`???`().*/ +object M/*<-prefixes::M.*/ { + type T/*<-prefixes::M.T#*/ + def n1/*<-prefixes::M.n1().*/: T/*->prefixes::M.T#*/ = ???/*->scala::Predef.`???`().*/ } -object O/*<<=prefixes.O.*/ extends C/*=>>prefixes.C#*/ { - def o1/*<<=prefixes.O.o1().*/: T/*=>>prefixes.C#T#*/ = ???/*=>>scala.Predef.`???`().*/ +object O/*<-prefixes::O.*/ extends C/*->prefixes::C#*/ { + def o1/*<-prefixes::O.o1().*/: T/*->prefixes::C#T#*/ = ???/*->scala::Predef.`???`().*/ } -object Test/*<<=prefixes.Test.*/ { - val c/*<<=prefixes.Test.c.*/: C/*=>>prefixes.C#*/ = ???/*=>>scala.Predef.`???`().*/ - def m2/*<<=prefixes.Test.m2().*/: c/*=>>prefixes.Test.c.*/.T/*=>>prefixes.C#T#*/ = ???/*=>>scala.Predef.`???`().*/ - def k2/*<<=prefixes.Test.k2().*/: c/*=>>prefixes.Test.c.*/.N/*=>>prefixes.C#N.*/.U/*=>>prefixes.C#N.U#*/ = ???/*=>>scala.Predef.`???`().*/ - import c/*=>>prefixes.Test.c.*/.N/*=>>prefixes.C#N.*/._ - def k3/*<<=prefixes.Test.k3().*/: U = ???/*=>>scala.Predef.`???`().*/ +object Test/*<-prefixes::Test.*/ { + val c/*<-prefixes::Test.c.*/: C/*->prefixes::C#*/ = ???/*->scala::Predef.`???`().*/ + def m2/*<-prefixes::Test.m2().*/: c/*->prefixes::Test.c.*/.T/*->prefixes::C#T#*/ = ???/*->scala::Predef.`???`().*/ + def k2/*<-prefixes::Test.k2().*/: c/*->prefixes::Test.c.*/.N/*->prefixes::C#N.*/.U/*->prefixes::C#N.U#*/ = ???/*->scala::Predef.`???`().*/ + import c/*->prefixes::Test.c.*/.N/*->prefixes::C#N.*/._ + def k3/*<-prefixes::Test.k3().*/: U = ???/*->scala::Predef.`???`().*/ - def n2/*<<=prefixes.Test.n2().*/: M/*=>>prefixes.M.*/.T/*=>>prefixes.M.T#*/ = ???/*=>>scala.Predef.`???`().*/ + def n2/*<-prefixes::Test.n2().*/: M/*->prefixes::M.*/.T/*->prefixes::M.T#*/ = ???/*->scala::Predef.`???`().*/ - import M/*=>>prefixes.M.*/._ - def n3/*<<=prefixes.Test.n3().*/: T/*=>>prefixes.M.T#*/ = ???/*=>>scala.Predef.`???`().*/ + import M/*->prefixes::M.*/._ + def n3/*<-prefixes::Test.n3().*/: T/*->prefixes::M.T#*/ = ???/*->scala::Predef.`???`().*/ } diff --git a/tests/semanticdb/expect/Selfs.expect.scala b/tests/semanticdb/expect/Selfs.expect.scala index ef46041e7a1a..a8d5cf973d22 100644 --- a/tests/semanticdb/expect/Selfs.expect.scala +++ b/tests/semanticdb/expect/Selfs.expect.scala @@ -1,15 +1,15 @@ package selfs -class B/*<<=selfs.B#*/ +class B/*<-selfs::B#*/ -class C1/*<<=selfs.C1#*/ extends B/*=>>selfs.B#*/ { self/*<<=local0*/ => +class C1/*<-selfs::C1#*/ extends B/*->selfs::B#*/ { self/*<-local0*/ => } -class C2/*<<=selfs.C2#*/ extends B/*=>>selfs.B#*/ { self/*<<=local1*/: B/*=>>selfs.B#*/ => +class C2/*<-selfs::C2#*/ extends B/*->selfs::B#*/ { self/*<-local1*/: B/*->selfs::B#*/ => } -class C3/*<<=selfs.C3#*/ extends B/*=>>selfs.B#*/ { self/*<<=local2*/: B/*=>>selfs.B#*/ with C1/*=>>selfs.C1#*/ => +class C3/*<-selfs::C3#*/ extends B/*->selfs::B#*/ { self/*<-local2*/: B/*->selfs::B#*/ with C1/*->selfs::C1#*/ => } -class C6/*<<=selfs.C6#*/ extends B/*=>>selfs.B#*/ { this: B/*=>>selfs.B#*/ => +class C6/*<-selfs::C6#*/ extends B/*->selfs::B#*/ { this: B/*->selfs::B#*/ => } diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala index 9b6b4ef2cfeb..29151fc1309b 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -1,48 +1,48 @@ package example -import scala.language/*=>>scalaShadowing.language.*/.implicitConversions/*=>>scalaShadowing.language.implicitConversions.*/ +import scala.language/*->scalaShadowing::language.*/.implicitConversions/*->scalaShadowing::language.implicitConversions.*/ -class Synthetic/*<<=example.Synthetic#*/ { - List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1).map/*=>>scala.collection.immutable.List#map().*/(_ +/*=>>scala.Int#`+`(+4).*/ 2) - /*=>>scala.Predef.intArrayOps().*/Array/*=>>scala.Array.*/.empty/*=>>scala.Array.empty().*/[Int/*=>>scala.Int#*/]/*=>>scala.reflect.ClassTag.apply().*//*=>>java.lang.Integer#TYPE.*/.headOption/*=>>scala.collection.ArrayOps#headOption().*/ - /*=>>scala.Predef.augmentString().*/"fooo".stripPrefix/*=>>scala.collection.StringOps#stripPrefix().*/("o") +class Synthetic/*<-example::Synthetic#*/ { + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).map/*->scala::collection::immutable::List#map().*/(_ +/*->scala::Int#`+`(+4).*/ 2) + /*->scala::Predef.intArrayOps().*/Array/*->scala::Array.*/.empty/*->scala::Array.empty().*/[Int/*->scala::Int#*/]/*->scala::reflect::ClassTag.apply().*//*->java::lang::Integer#TYPE.*/.headOption/*->scala::collection::ArrayOps#headOption().*/ + /*->scala::Predef.augmentString().*/"fooo".stripPrefix/*->scala::collection::StringOps#stripPrefix().*/("o") // See https://github.com/scalameta/scalameta/issues/977 - val Name/*<<=example.Synthetic#Name.*/ = /*=>>scala.Predef.augmentString().*/"name:(.*)".r/*=>>scala.collection.StringOps#r().*/ - /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/val x/*<<=example.Synthetic#x.*/ #:: xs/*<<=example.Synthetic#xs.*/ = LazyList(1, 2) - val Name/*=>>example.Synthetic#Name.*//*=>>scala.util.matching.Regex#unapplySeq().*/(name/*<<=example.Synthetic#name.*//*<<=local0*/)/*=>>local0*/ = "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 lst/*<<=example.Synthetic#lst.*/ = 1 #:: /*=>>scala.collection.immutable.LazyList.toDeferrer().*/2 #:: /*=>>scala.collection.immutable.LazyList.toDeferrer().*/LazyList/*=>>scala.package.LazyList.*/.empty/*=>>scala.collection.immutable.LazyList.empty().*//*=>>scala.collection.immutable.LazyList.Deferrer#`#::`().*/ - - for (x <- /*=>>scala.LowPriorityImplicits#intWrapper().*/1 to/*=>>scala.runtime.RichInt#to().*/ 10/*=>>scala.collection.immutable.Range#foreach().*/; y <- /*=>>scala.LowPriorityImplicits#intWrapper().*/0 until/*=>>scala.runtime.RichInt#until().*/ 10/*=>>scala.collection.immutable.Range#foreach().*/) println/*=>>scala.Predef.println(+1).*/(x/*=>>local1*/ ->/*=>>scala.Predef.ArrowAssoc#`->`().*/ x/*=>>local1*/) - for (i <- /*=>>scala.LowPriorityImplicits#intWrapper().*/1 to/*=>>scala.runtime.RichInt#to().*/ 10/*=>>scala.collection.StrictOptimizedIterableOps#flatMap().*/; j <- /*=>>scala.LowPriorityImplicits#intWrapper().*/0 until/*=>>scala.runtime.RichInt#until().*/ 10/*=>>scala.collection.immutable.Range#map().*/) yield (i/*=>>local2*/, j/*=>>local3*/) - for (i <- /*=>>scala.LowPriorityImplicits#intWrapper().*/1 to/*=>>scala.runtime.RichInt#to().*/ 10/*=>>scala.collection.StrictOptimizedIterableOps#flatMap().*/; j <- /*=>>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 (i/*=>>local4*/, j/*=>>local5*/) - - object s/*<<=example.Synthetic#s.*/ { - def apply/*<<=example.Synthetic#s.apply().*/() = 2 - s/*=>>example.Synthetic#s.apply().*/() - s.apply/*=>>example.Synthetic#s.apply().*/() - case class Bar/*<<=example.Synthetic#s.Bar#*/() - Bar/*=>>example.Synthetic#s.Bar.*/() - null.asInstanceOf/*=>>scala.Any#asInstanceOf().*/[Int/*=>>scala.Int#*/ => Int/*=>>scala.Int#*/]/*=>>scala.Function1#apply().*/(2) + val Name/*<-example::Synthetic#Name.*/ = /*->scala::Predef.augmentString().*/"name:(.*)".r/*->scala::collection::StringOps#r().*/ + /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/val x/*<-example::Synthetic#x.*/ #:: xs/*<-example::Synthetic#xs.*/ = LazyList(1, 2) + val Name/*->example::Synthetic#Name.*//*->scala::util::matching::Regex#unapplySeq().*/(name/*<-example::Synthetic#name.*//*<-local0*/)/*->local0*/ = "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 lst/*<-example::Synthetic#lst.*/ = 1 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/2 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*//*->scala::collection::immutable::LazyList.Deferrer#`#::`().*/ + + for (x <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(x/*->local1*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local1*/) + for (i <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (i/*->local2*/, j/*->local3*/) + for (i <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j <- /*->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 (i/*->local4*/, j/*->local5*/) + + object s/*<-example::Synthetic#s.*/ { + def apply/*<-example::Synthetic#s.apply().*/() = 2 + s/*->example::Synthetic#s.apply().*/() + s.apply/*->example::Synthetic#s.apply().*/() + case class Bar/*<-example::Synthetic#s.Bar#*/() + Bar/*->example::Synthetic#s.Bar.*/() + null.asInstanceOf/*->scala::Any#asInstanceOf().*/[Int/*->scala::Int#*/ => Int/*->scala::Int#*/]/*->scala::Function1#apply().*/(2) } - class J/*<<=example.Synthetic#J#*/[T/*<<=example.Synthetic#J#[T]*//*<<=example.Synthetic#J#evidence$2.*/: 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]*/]/*=>>example.Synthetic#J#evidence$2.*/ } + class J/*<-example::Synthetic#J#*/[T/*<-example::Synthetic#J#[T]*//*<-example::Synthetic#J#evidence$2.*/: 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]*/]/*->example::Synthetic#J#evidence$2.*/ } - 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.*/ + class F/*<-example::Synthetic#F#*/ + implicit val ordering/*<-example::Synthetic#ordering.*/: Ordering/*->scala::package.Ordering#*/[F/*->example::Synthetic#F#*/] = ???/*->scala::Predef.`???`().*/ + val f/*<-example::Synthetic#f.*/: Ordered/*->scala::package.Ordered#*/[F/*->example::Synthetic#F#*/] = /*->scala::math::Ordered.orderingToOrdered().*/new F/*->example::Synthetic#F#*//*->example::Synthetic#ordering.*/ - import scala.concurrent.ExecutionContext/*=>>scala.concurrent.ExecutionContext.*/.Implicits/*=>>scala.concurrent.ExecutionContext.Implicits.*/.global/*=>>scala.concurrent.ExecutionContext.Implicits.global().*/ + import scala.concurrent.ExecutionContext/*->scala::concurrent::ExecutionContext.*/.Implicits/*->scala::concurrent::ExecutionContext.Implicits.*/.global/*->scala::concurrent::ExecutionContext.Implicits.global().*/ for { - a <- scala.concurrent.Future/*=>>scala.concurrent.Future.*/.successful/*=>>scala.concurrent.Future.successful().*/(1)/*=>>scala.concurrent.Future#foreach().*/ - b <- 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 <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#foreach().*/ + b <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#foreach().*/ + } println/*->scala::Predef.println(+1).*/(a/*->local6*/)/*->scala::concurrent::ExecutionContext.Implicits.global().*/ for { - a <- scala.concurrent.Future/*=>>scala.concurrent.Future.*/.successful/*=>>scala.concurrent.Future.successful().*/(1)/*=>>scala.concurrent.Future#flatMap().*/ - b <- scala.concurrent.Future/*=>>scala.concurrent.Future.*/.successful/*=>>scala.concurrent.Future.successful().*/(2)/*=>>scala.concurrent.Future#withFilter().*/ - if a/*=>>local7*/ >scala.Int#`<`(+3).*/ b/*=>>local8*//*=>>scala.concurrent.Future#map().*//*=>>scala.concurrent.ExecutionContext.Implicits.global().*/ - } yield a/*=>>local7*//*=>>scala.concurrent.ExecutionContext.Implicits.global().*/ + a <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#flatMap().*/ + b <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#withFilter().*/ + if a/*->local7*/ scala::Int#`<`(+3).*/ b/*->local8*//*->scala::concurrent::Future#map().*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ + } yield a/*->local7*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ } diff --git a/tests/semanticdb/expect/Traits.expect.scala b/tests/semanticdb/expect/Traits.expect.scala index 07acdabecfe7..193390b38826 100644 --- a/tests/semanticdb/expect/Traits.expect.scala +++ b/tests/semanticdb/expect/Traits.expect.scala @@ -1,14 +1,14 @@ package traits -trait T/*<<=traits.T#*/ { - def x/*<<=traits.T#x().*/ = 2 +trait T/*<-traits::T#*/ { + def x/*<-traits::T#x().*/ = 2 } -sealed trait U/*<<=traits.U#*/ -object U/*<<=traits.U.*/ { - def u/*<<=traits.U.u().*/: U/*=>>traits.U#*/ = new U/*=>>traits.U#*/ {} +sealed trait U/*<-traits::U#*/ +object U/*<-traits::U.*/ { + def u/*<-traits::U.u().*/: U/*->traits::U#*/ = new U/*->traits::U#*/ {} } -class C/*<<=traits.C#*/ -trait V/*<<=traits.V#*/ { self/*<<=local1*/: C/*=>>traits.C#*/ => +class C/*<-traits::C#*/ +trait V/*<-traits::V#*/ { self/*<-local1*/: C/*->traits::C#*/ => } diff --git a/tests/semanticdb/expect/Types.expect.scala b/tests/semanticdb/expect/Types.expect.scala index 7515460861ad..a6e8efd3ad6e 100644 --- a/tests/semanticdb/expect/Types.expect.scala +++ b/tests/semanticdb/expect/Types.expect.scala @@ -1,115 +1,115 @@ package types -import scala.language/*=>>scalaShadowing.language.*/.existentials/*=>>scalaShadowing.language.existentials.*/ -import scala.language/*=>>scalaShadowing.language.*/.higherKinds/*=>>scalaShadowing.language.higherKinds.*/ +import scala.language/*->scalaShadowing::language.*/.existentials/*->scalaShadowing::language.existentials.*/ +import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ -class /*=>>scala.annotation.Annotation#``().*/ann/*<<=types.ann#*/[T/*<<=types.ann#[T]*/](x/*<<=types.ann#x.*/: T/*=>>types.ann#``().[T]*/) extends scala.annotation.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ -class /*=>>scala.annotation.Annotation#``().*/ann1/*<<=types.ann1#*/ extends scala.annotation.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ -class /*=>>scala.annotation.Annotation#``().*/ann2/*<<=types.ann2#*/ extends scala.annotation.StaticAnnotation/*=>>scala.annotation.StaticAnnotation#*/ +class /*->scala::annotation::Annotation#``().*/ann/*<-types::ann#*/[T/*<-types::ann#[T]*/](x/*<-types::ann#x.*/: T/*->types::ann#``().[T]*/) extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class /*->scala::annotation::Annotation#``().*/ann1/*<-types::ann1#*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class /*->scala::annotation::Annotation#``().*/ann2/*<-types::ann2#*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ -class B/*<<=types.B#*/ +class B/*<-types::B#*/ -class C/*<<=types.C#*/ +class C/*<-types::C#*/ -class P/*<<=types.P#*/ { - class C/*<<=types.P#C#*/ - class X/*<<=types.P#X#*/ - val x/*<<=types.P#x.*/ = new X/*=>>types.P#X#*/ +class P/*<-types::P#*/ { + class C/*<-types::P#C#*/ + class X/*<-types::P#X#*/ + val x/*<-types::P#x.*/ = new X/*->types::P#X#*/ } -class T/*<<=types.T#*/ { - class C/*<<=types.T#C#*/ - class X/*<<=types.T#X#*/ - val x/*<<=types.T#x.*/ = new X/*=>>types.T#X#*/ +class T/*<-types::T#*/ { + class C/*<-types::T#C#*/ + class X/*<-types::T#X#*/ + val x/*<-types::T#x.*/ = new X/*->types::T#X#*/ } -object Test/*<<=types.Test.*/ { - class M/*<<=types.Test.M#*/ { - def m/*<<=types.Test.M#m().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ +object Test/*<-types::Test.*/ { + class M/*<-types::Test.M#*/ { + def m/*<-types::Test.M#m().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } - trait N/*<<=types.Test.N#*/ { - def n/*<<=types.Test.N#n().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + trait N/*<-types::Test.N#*/ { + def n/*<-types::Test.N#n().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } - class C/*<<=types.Test.C#*/ extends M/*=>>types.Test.M#*/ { - val p/*<<=types.Test.C#p.*/ = new P/*=>>types.P#*/ - val x/*<<=types.Test.C#x.*/ = p/*=>>types.Test.C#p.*/.x/*=>>types.P#x.*/ - - val typeRef1/*<<=types.Test.C#typeRef1.*/: C/*=>>types.Test.C#*/ = ???/*=>>scala.Predef.`???`().*/ - val typeRef2/*<<=types.Test.C#typeRef2.*/: p/*=>>types.Test.C#p.*/.C/*=>>types.P#C#*/ = ???/*=>>scala.Predef.`???`().*/ - val typeRef3/*<<=types.Test.C#typeRef3.*/: T/*=>>types.T#*/#C/*=>>types.T#C#*/ = ???/*=>>scala.Predef.`???`().*/ - val typeRef4/*<<=types.Test.C#typeRef4.*/: List/*=>>scala.package.List#*/[Int/*=>>scala.Int#*/] = ???/*=>>scala.Predef.`???`().*/ - - val singleType1/*<<=types.Test.C#singleType1.*/: x/*=>>types.Test.C#x.*/.type = ???/*=>>scala.Predef.`???`().*/ - val singleType2/*<<=types.Test.C#singleType2.*/: p/*=>>types.Test.C#p.*/.x/*=>>types.P#x.*/.type = ???/*=>>scala.Predef.`???`().*/ - val Either/*<<=types.Test.C#Either.*/ = scala.util.Either/*=>>scala.util.Either.*/ - - val thisType1/*<<=types.Test.C#thisType1.*/: this.type = ???/*=>>scala.Predef.`???`().*/ - val thisType2/*<<=types.Test.C#thisType2.*/: C.this.type = ???/*=>>scala.Predef.`???`().*/ - - val superType1/*<<=types.Test.C#superType1.*/ = super.m/*=>>types.Test.M#m().*/ - val superType2/*<<=types.Test.C#superType2.*/ = super[M].m/*=>>types.Test.M#m().*/ - val superType3/*<<=types.Test.C#superType3.*/ = C.super[M].m/*=>>types.Test.M#m().*/ - - val compoundType1/*<<=types.Test.C#compoundType1.*/: { def k/*<<=local0*/: Int/*=>>scala.Int#*/ } = ???/*=>>scala.Predef.`???`().*/ - val compoundType2/*<<=types.Test.C#compoundType2.*/: M/*=>>types.Test.M#*/ with N/*=>>types.Test.N#*/ = ???/*=>>scala.Predef.`???`().*/ - val compoundType3/*<<=types.Test.C#compoundType3.*/: M/*=>>types.Test.M#*/ with N/*=>>types.Test.N#*/ { def k/*<<=local1*/: Int/*=>>scala.Int#*/ } = ???/*=>>scala.Predef.`???`().*/ - val compoundType4/*<<=types.Test.C#compoundType4.*/ = new { def k/*<<=local3*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } - val compoundType5/*<<=types.Test.C#compoundType5.*/ = new M/*=>>types.Test.M#*/ with N/*=>>types.Test.N#*/ - val compoundType6/*<<=types.Test.C#compoundType6.*/ = new M/*=>>types.Test.M#*/ with N/*=>>types.Test.N#*/ { def k/*<<=local6*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ } - - val annType1/*<<=types.Test.C#annType1.*/: T/*=>>types.T#*/ @ann(42) = ???/*=>>scala.Predef.`???`().*/ - val annType2/*<<=types.Test.C#annType2.*/: T/*=>>types.T#*/ @ann1 @ann2 = ???/*=>>scala.Predef.`???`().*/ - - val existentialType2/*<<=types.Test.C#existentialType2.*/: List/*=>>scala.package.List#*/[_] = ???/*=>>scala.Predef.`???`().*/ - val existentialType3/*<<=types.Test.C#existentialType3.*/ = Class/*=>>java.lang.Class#*/.forName/*=>>java.lang.Class#forName().*/("foo.Bar") - val existentialType4/*<<=types.Test.C#existentialType4.*/ = Class/*=>>java.lang.Class#*/.forName/*=>>java.lang.Class#forName().*/("foo.Bar") - - def typeLambda1/*<<=types.Test.C#typeLambda1().*/[M/*<<=types.Test.C#typeLambda1().[M]*/[_]] = ???/*=>>scala.Predef.`???`().*/ - typeLambda1/*=>>types.Test.C#typeLambda1().*/[({ type L/*<<=local7*/[T/*<<=local8*/] = List/*=>>scala.package.List#*/[T/*=>>local8*/] })#L] - - object ClassInfoType1/*<<=types.Test.C#ClassInfoType1.*/ - class ClassInfoType2/*<<=types.Test.C#ClassInfoType2#*/ extends B/*=>>types.B#*/ { def x/*<<=types.Test.C#ClassInfoType2#x().*/ = 42 } - trait ClassInfoType3/*<<=types.Test.C#ClassInfoType3#*/[T/*<<=types.Test.C#ClassInfoType3#[T]*/] - - object MethodType/*<<=types.Test.C#MethodType.*/ { - def x1/*<<=types.Test.C#MethodType.x1().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - def x2/*<<=types.Test.C#MethodType.x2().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - def m3/*<<=types.Test.C#MethodType.m3().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - def m4/*<<=types.Test.C#MethodType.m4().*/(): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - def m5/*<<=types.Test.C#MethodType.m5().*/(x/*<<=types.Test.C#MethodType.m5().(x)*/: Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - def m6/*<<=types.Test.C#MethodType.m6().*/[T/*<<=types.Test.C#MethodType.m6().[T]*/](x/*<<=types.Test.C#MethodType.m6().(x)*/: T/*=>>types.Test.C#MethodType.m6().[T]*/): T/*=>>types.Test.C#MethodType.m6().[T]*/ = ???/*=>>scala.Predef.`???`().*/ + class C/*<-types::Test.C#*/ extends M/*->types::Test.M#*/ { + val p/*<-types::Test.C#p.*/ = new P/*->types::P#*/ + val x/*<-types::Test.C#x.*/ = p/*->types::Test.C#p.*/.x/*->types::P#x.*/ + + val typeRef1/*<-types::Test.C#typeRef1.*/: C/*->types::Test.C#*/ = ???/*->scala::Predef.`???`().*/ + val typeRef2/*<-types::Test.C#typeRef2.*/: p/*->types::Test.C#p.*/.C/*->types::P#C#*/ = ???/*->scala::Predef.`???`().*/ + val typeRef3/*<-types::Test.C#typeRef3.*/: T/*->types::T#*/#C/*->types::T#C#*/ = ???/*->scala::Predef.`???`().*/ + val typeRef4/*<-types::Test.C#typeRef4.*/: List/*->scala::package.List#*/[Int/*->scala::Int#*/] = ???/*->scala::Predef.`???`().*/ + + val singleType1/*<-types::Test.C#singleType1.*/: x/*->types::Test.C#x.*/.type = ???/*->scala::Predef.`???`().*/ + val singleType2/*<-types::Test.C#singleType2.*/: p/*->types::Test.C#p.*/.x/*->types::P#x.*/.type = ???/*->scala::Predef.`???`().*/ + val Either/*<-types::Test.C#Either.*/ = scala.util.Either/*->scala::util::Either.*/ + + val thisType1/*<-types::Test.C#thisType1.*/: this.type = ???/*->scala::Predef.`???`().*/ + val thisType2/*<-types::Test.C#thisType2.*/: C.this.type = ???/*->scala::Predef.`???`().*/ + + val superType1/*<-types::Test.C#superType1.*/ = super.m/*->types::Test.M#m().*/ + val superType2/*<-types::Test.C#superType2.*/ = super[M].m/*->types::Test.M#m().*/ + val superType3/*<-types::Test.C#superType3.*/ = C.super[M].m/*->types::Test.M#m().*/ + + val compoundType1/*<-types::Test.C#compoundType1.*/: { def k/*<-local0*/: Int/*->scala::Int#*/ } = ???/*->scala::Predef.`???`().*/ + val compoundType2/*<-types::Test.C#compoundType2.*/: M/*->types::Test.M#*/ with N/*->types::Test.N#*/ = ???/*->scala::Predef.`???`().*/ + val compoundType3/*<-types::Test.C#compoundType3.*/: M/*->types::Test.M#*/ with N/*->types::Test.N#*/ { def k/*<-local1*/: Int/*->scala::Int#*/ } = ???/*->scala::Predef.`???`().*/ + val compoundType4/*<-types::Test.C#compoundType4.*/ = new { def k/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + val compoundType5/*<-types::Test.C#compoundType5.*/ = new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ + val compoundType6/*<-types::Test.C#compoundType6.*/ = new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ { def k/*<-local6*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + + val annType1/*<-types::Test.C#annType1.*/: T/*->types::T#*/ @ann(42) = ???/*->scala::Predef.`???`().*/ + val annType2/*<-types::Test.C#annType2.*/: T/*->types::T#*/ @ann1 @ann2 = ???/*->scala::Predef.`???`().*/ + + val existentialType2/*<-types::Test.C#existentialType2.*/: List/*->scala::package.List#*/[_] = ???/*->scala::Predef.`???`().*/ + val existentialType3/*<-types::Test.C#existentialType3.*/ = Class/*->java::lang::Class#*/.forName/*->java::lang::Class#forName().*/("foo.Bar") + val existentialType4/*<-types::Test.C#existentialType4.*/ = Class/*->java::lang::Class#*/.forName/*->java::lang::Class#forName().*/("foo.Bar") + + def typeLambda1/*<-types::Test.C#typeLambda1().*/[M/*<-types::Test.C#typeLambda1().[M]*/[_]] = ???/*->scala::Predef.`???`().*/ + typeLambda1/*->types::Test.C#typeLambda1().*/[({ type L/*<-local7*/[T/*<-local8*/] = List/*->scala::package.List#*/[T/*->local8*/] })#L] + + object ClassInfoType1/*<-types::Test.C#ClassInfoType1.*/ + class ClassInfoType2/*<-types::Test.C#ClassInfoType2#*/ extends B/*->types::B#*/ { def x/*<-types::Test.C#ClassInfoType2#x().*/ = 42 } + trait ClassInfoType3/*<-types::Test.C#ClassInfoType3#*/[T/*<-types::Test.C#ClassInfoType3#[T]*/] + + object MethodType/*<-types::Test.C#MethodType.*/ { + def x1/*<-types::Test.C#MethodType.x1().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def x2/*<-types::Test.C#MethodType.x2().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m3/*<-types::Test.C#MethodType.m3().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m4/*<-types::Test.C#MethodType.m4().*/(): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m5/*<-types::Test.C#MethodType.m5().*/(x/*<-types::Test.C#MethodType.m5().(x)*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m6/*<-types::Test.C#MethodType.m6().*/[T/*<-types::Test.C#MethodType.m6().[T]*/](x/*<-types::Test.C#MethodType.m6().(x)*/: T/*->types::Test.C#MethodType.m6().[T]*/): T/*->types::Test.C#MethodType.m6().[T]*/ = ???/*->scala::Predef.`???`().*/ } - object ByNameType/*<<=types.Test.C#ByNameType.*/ { - def m1/*<<=types.Test.C#ByNameType.m1().*/(x/*<<=types.Test.C#ByNameType.m1().(x)*/: => Int/*=>>scala.Int#*/): Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + object ByNameType/*<-types::Test.C#ByNameType.*/ { + def m1/*<-types::Test.C#ByNameType.m1().*/(x/*<-types::Test.C#ByNameType.m1().(x)*/: => Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } - case class RepeatedType/*<<=types.Test.C#RepeatedType#*/(s/*<<=types.Test.C#RepeatedType#s.*/: String/*=>>scala.Predef.String#*/*) { - def m1/*<<=types.Test.C#RepeatedType#m1().*/(x/*<<=types.Test.C#RepeatedType#m1().(x)*/: Int/*=>>scala.Int#*/*): Int/*=>>scala.Int#*/ = s/*=>>types.Test.C#RepeatedType#s.*/.length/*=>>scala.collection.SeqOps#length().*/ + case class RepeatedType/*<-types::Test.C#RepeatedType#*/(s/*<-types::Test.C#RepeatedType#s.*/: String/*->scala::Predef.String#*/*) { + def m1/*<-types::Test.C#RepeatedType#m1().*/(x/*<-types::Test.C#RepeatedType#m1().(x)*/: Int/*->scala::Int#*/*): Int/*->scala::Int#*/ = s/*->types::Test.C#RepeatedType#s.*/.length/*->scala::collection::SeqOps#length().*/ } - object TypeType/*<<=types.Test.C#TypeType.*/ { - type T1/*<<=types.Test.C#TypeType.T1#*/ - def m2/*<<=types.Test.C#TypeType.m2().*/[T2/*<<=types.Test.C#TypeType.m2().[T2]*/ >: C/*=>>types.Test.C#*/ <: C/*=>>types.Test.C#*/] = ???/*=>>scala.Predef.`???`().*/ - def m3/*<<=types.Test.C#TypeType.m3().*/[M3/*<<=types.Test.C#TypeType.m3().[M3]*/[_]] = ???/*=>>scala.Predef.`???`().*/ - type T4/*<<=types.Test.C#TypeType.T4#*/ = C/*=>>types.Test.C#*/ - type T5/*<<=types.Test.C#TypeType.T5#*/[U/*<<=types.Test.C#TypeType.T5#[U]*/] = U/*=>>types.Test.C#TypeType.T5#[U]*/ + object TypeType/*<-types::Test.C#TypeType.*/ { + type T1/*<-types::Test.C#TypeType.T1#*/ + def m2/*<-types::Test.C#TypeType.m2().*/[T2/*<-types::Test.C#TypeType.m2().[T2]*/ >: C/*->types::Test.C#*/ <: C/*->types::Test.C#*/] = ???/*->scala::Predef.`???`().*/ + def m3/*<-types::Test.C#TypeType.m3().*/[M3/*<-types::Test.C#TypeType.m3().[M3]*/[_]] = ???/*->scala::Predef.`???`().*/ + type T4/*<-types::Test.C#TypeType.T4#*/ = C/*->types::Test.C#*/ + type T5/*<-types::Test.C#TypeType.T5#*/[U/*<-types::Test.C#TypeType.T5#[U]*/] = U/*->types::Test.C#TypeType.T5#[U]*/ } } - object Literal/*<<=types.Test.Literal.*/ { - final val int/*<<=types.Test.Literal.int.*/ = 1 - final val long/*<<=types.Test.Literal.long.*/ = 1L - final val float/*<<=types.Test.Literal.float.*/ = 1f - final val double/*<<=types.Test.Literal.double.*/ = 2d - final val nil/*<<=types.Test.Literal.nil.*/ = null - final val char/*<<=types.Test.Literal.char.*/ = 'a' - final val string/*<<=types.Test.Literal.string.*/ = "a" - final val bool/*<<=types.Test.Literal.bool.*/ = true - final val unit/*<<=types.Test.Literal.unit.*/ = () - final val javaEnum/*<<=types.Test.Literal.javaEnum.*/ = java.nio.file.LinkOption/*=>>java.nio.file.LinkOption#*/.NOFOLLOW_LINKS/*=>>java.nio.file.LinkOption#NOFOLLOW_LINKS.*/ - final val clazzOf/*<<=types.Test.Literal.clazzOf.*/ = classOf/*=>>scala.Predef.classOf().*/[Option/*=>>scala.Option#*/[Int/*=>>scala.Int#*/]] + object Literal/*<-types::Test.Literal.*/ { + final val int/*<-types::Test.Literal.int.*/ = 1 + final val long/*<-types::Test.Literal.long.*/ = 1L + final val float/*<-types::Test.Literal.float.*/ = 1f + final val double/*<-types::Test.Literal.double.*/ = 2d + final val nil/*<-types::Test.Literal.nil.*/ = null + final val char/*<-types::Test.Literal.char.*/ = 'a' + final val string/*<-types::Test.Literal.string.*/ = "a" + final val bool/*<-types::Test.Literal.bool.*/ = true + final val unit/*<-types::Test.Literal.unit.*/ = () + final val javaEnum/*<-types::Test.Literal.javaEnum.*/ = java.nio.file.LinkOption/*->java::nio::file::LinkOption#*/.NOFOLLOW_LINKS/*->java::nio::file::LinkOption#NOFOLLOW_LINKS.*/ + final val clazzOf/*<-types::Test.Literal.clazzOf.*/ = classOf/*->scala::Predef.classOf().*/[Option/*->scala::Option#*/[Int/*->scala::Int#*/]] } } diff --git a/tests/semanticdb/expect/ValPattern.expect.scala b/tests/semanticdb/expect/ValPattern.expect.scala index 987af9987291..7d1a589039d3 100644 --- a/tests/semanticdb/expect/ValPattern.expect.scala +++ b/tests/semanticdb/expect/ValPattern.expect.scala @@ -1,42 +1,42 @@ package example -class ValPattern/*<<=example.ValPattern#*/ { +class ValPattern/*<-example::ValPattern#*/ { - /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/val (left/*<<=example.ValPattern#left.*/, right/*<<=example.ValPattern#right.*/) = (1, 2) - val Some/*=>>scala.Some.*/(number1/*<<=example.ValPattern#number1.*//*<<=local0*/)/*=>>local0*/ = - Some/*=>>scala.Some.*/(1) + /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/val (left/*<-example::ValPattern#left.*/, right/*<-example::ValPattern#right.*/) = (1, 2) + val Some/*->scala::Some.*/(number1/*<-example::ValPattern#number1.*//*<-local0*/)/*->local0*/ = + Some/*->scala::Some.*/(1) - /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/var (leftVar/*<<=example.ValPattern#leftVar().*/, /*<<=example.ValPattern#`leftVar_=`().*/rightVar/*<<=example.ValPattern#rightVar().*/) /*<<=example.ValPattern#`rightVar_=`().*/= (1, 2) - var Some/*=>>scala.Some.*/(number1Var/*<<=example.ValPattern#number1Var().*//*<<=local1*/) /*<<=example.ValPattern#`number1Var_=`().*//*=>>local1*/= - Some/*=>>scala.Some.*/(1) + /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/var (leftVar/*<-example::ValPattern#leftVar().*/, /*<-example::ValPattern#`leftVar_=`().*/rightVar/*<-example::ValPattern#rightVar().*/) /*<-example::ValPattern#`rightVar_=`().*/= (1, 2) + var Some/*->scala::Some.*/(number1Var/*<-example::ValPattern#number1Var().*//*<-local1*/) /*<-example::ValPattern#`number1Var_=`().*//*->local1*/= + Some/*->scala::Some.*/(1) - def app/*<<=example.ValPattern#app().*/(): Unit/*=>>scala.Unit#*/ = { - println/*=>>scala.Predef.println(+1).*/( + def app/*<-example::ValPattern#app().*/(): Unit/*->scala::Unit#*/ = { + println/*->scala::Predef.println(+1).*/( ( - number1/*=>>example.ValPattern#number1.*/, - left/*=>>example.ValPattern#left.*/, - right/*=>>example.ValPattern#right.*/, - number1Var/*=>>example.ValPattern#number1Var().*/, - leftVar/*=>>example.ValPattern#leftVar().*/, - rightVar/*=>>example.ValPattern#rightVar().*/ + number1/*->example::ValPattern#number1.*/, + left/*->example::ValPattern#left.*/, + right/*->example::ValPattern#right.*/, + number1Var/*->example::ValPattern#number1Var().*/, + leftVar/*->example::ValPattern#leftVar().*/, + rightVar/*->example::ValPattern#rightVar().*/ ) ) - locally/*=>>dotty.DottyPredef.locally().*/ { - /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/val (left/*<<=local2*/, right/*<<=local3*/) = (1, 2) - val Some/*=>>scala.Some.*/(number1/*<<=local4*/)/*=>>local4*/ = - Some/*=>>scala.Some.*/(1) + locally/*->dotty::DottyPredef.locally().*/ { + /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/val (left/*<-local2*/, right/*<-local3*/) = (1, 2) + val Some/*->scala::Some.*/(number1/*<-local4*/)/*->local4*/ = + Some/*->scala::Some.*/(1) - /*=>>scala.Tuple2#_1.*//*=>>scala.Tuple2#_2.*/var (leftVar/*<<=local5*/, rightVar/*<<=local6*/) = (1, 2) - var Some/*=>>scala.Some.*/(number1Var/*<<=local7*/)/*=>>local7*/ = - Some/*=>>scala.Some.*/(1) - println/*=>>scala.Predef.println(+1).*/( + /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/var (leftVar/*<-local5*/, rightVar/*<-local6*/) = (1, 2) + var Some/*->scala::Some.*/(number1Var/*<-local7*/)/*->local7*/ = + Some/*->scala::Some.*/(1) + println/*->scala::Predef.println(+1).*/( ( - number1/*=>>local4*/, - left/*=>>local2*/, - right/*=>>local3*/, - number1Var/*=>>local7*/, - leftVar/*=>>local5*/, - rightVar/*=>>local6*/ + number1/*->local4*/, + left/*->local2*/, + right/*->local3*/, + number1Var/*->local7*/, + leftVar/*->local5*/, + rightVar/*->local6*/ ) ) } diff --git a/tests/semanticdb/expect/Vals.expect.scala b/tests/semanticdb/expect/Vals.expect.scala index ca1308c0aa32..0cd42f1c8705 100644 --- a/tests/semanticdb/expect/Vals.expect.scala +++ b/tests/semanticdb/expect/Vals.expect.scala @@ -1,47 +1,47 @@ package example -abstract class Vals/*<<=example.Vals#*/(p/*<<=example.Vals#p.*/: Int/*=>>scala.Int#*/, val xp/*<<=example.Vals#xp.*/: Int/*=>>scala.Int#*/, var yp/*<<=example.Vals#yp().*/: /*<<=example.Vals#`yp_=`().*/Int/*=>>scala.Int#*/) { - val xm/*<<=example.Vals#xm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - val xam/*<<=example.Vals#xam.*/: Int/*=>>scala.Int#*/ - private[this] val xlm/*<<=example.Vals#xlm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - lazy val xzm/*<<=example.Vals#xzm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - private[this] lazy val xzlm/*<<=example.Vals#xzlm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - final val xfm/*<<=example.Vals#xfm.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - implicit val xim/*<<=example.Vals#xim.*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - var ym/*<<=example.Vals#ym().*/: /*<<=example.Vals#`ym_=`().*/Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - var yam/*<<=example.Vals#yam().*/: /*<<=example.Vals#`yam_=`().*/Int/*=>>scala.Int#*/ - private[this] var ylm/*<<=example.Vals#ylm().*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ +abstract class Vals/*<-example::Vals#*/(p/*<-example::Vals#p.*/: Int/*->scala::Int#*/, val xp/*<-example::Vals#xp.*/: Int/*->scala::Int#*/, var yp/*<-example::Vals#yp().*/: /*<-example::Vals#`yp_=`().*/Int/*->scala::Int#*/) { + val xm/*<-example::Vals#xm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + val xam/*<-example::Vals#xam.*/: Int/*->scala::Int#*/ + private[this] val xlm/*<-example::Vals#xlm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + lazy val xzm/*<-example::Vals#xzm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + private[this] lazy val xzlm/*<-example::Vals#xzlm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + final val xfm/*<-example::Vals#xfm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + implicit val xim/*<-example::Vals#xim.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + var ym/*<-example::Vals#ym().*/: /*<-example::Vals#`ym_=`().*/Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + var yam/*<-example::Vals#yam().*/: /*<-example::Vals#`yam_=`().*/Int/*->scala::Int#*/ + private[this] var ylm/*<-example::Vals#ylm().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ // NOTE: lazy not allowed here. Only vals can be lazy // lazy var xzm: Int = ??? // private[this] lazy var yzlm: Int = ??? - final var yfm/*<<=example.Vals#yfm().*/: /*<<=example.Vals#`yfm_=`().*/Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - implicit var yim/*<<=example.Vals#yim().*/: /*<<=example.Vals#`yim_=`().*/Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - def m/*<<=example.Vals#m().*/ = { - val xl/*<<=local0*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - lazy val xzl/*<<=local1*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + final var yfm/*<-example::Vals#yfm().*/: /*<-example::Vals#`yfm_=`().*/Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + implicit var yim/*<-example::Vals#yim().*/: /*<-example::Vals#`yim_=`().*/Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + def m/*<-example::Vals#m().*/ = { + val xl/*<-local0*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + lazy val xzl/*<-local1*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ // NOTE: local values cannot be final // final val xfl: Int = ??? - implicit val xil/*<<=local2*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - var yl/*<<=local3*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ + implicit val xil/*<-local2*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + var yl/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ // NOTE: lazy not allowed here. Only vals can be lazy // lazy var yzl: Int = ??? // NOTE: local variables cannot be final // final var yfl: Int = ??? - implicit var yil/*<<=local4*/: Int/*=>>scala.Int#*/ = ???/*=>>scala.Predef.`???`().*/ - yl/*=>>local3*/ = xl/*=>>local0*/ +/*=>>scala.Int#`+`(+4).*/ yl/*=>>local3*/ - println/*=>>scala.Predef.println(+1).*/(xzl/*=>>local1*/) - yil/*=>>local4*/ = xil/*=>>local2*/ +/*=>>scala.Int#`+`(+4).*/ yil/*=>>local4*/ + implicit var yil/*<-local4*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + yl/*->local3*/ = xl/*->local0*/ +/*->scala::Int#`+`(+4).*/ yl/*->local3*/ + println/*->scala::Predef.println(+1).*/(xzl/*->local1*/) + yil/*->local4*/ = xil/*->local2*/ +/*->scala::Int#`+`(+4).*/ yil/*->local4*/ } - println/*=>>scala.Predef.println(+1).*/(xzlm/*=>>example.Vals#xzlm.*/) - ylm/*=>>example.Vals#ylm().*/ = xlm/*=>>example.Vals#xlm.*/ +/*=>>scala.Int#`+`(+4).*/ ylm/*=>>example.Vals#ylm().*/ + println/*->scala::Predef.println(+1).*/(xzlm/*->example::Vals#xzlm.*/) + ylm/*->example::Vals#ylm().*/ = xlm/*->example::Vals#xlm.*/ +/*->scala::Int#`+`(+4).*/ ylm/*->example::Vals#ylm().*/ } -object ValUsages/*<<=example.ValUsages.*/ { - val v/*<<=example.ValUsages.v.*/: Vals/*=>>example.Vals#*/ = ???/*=>>scala.Predef.`???`().*/ - v/*=>>example.ValUsages.v.*/.yp/*=>>example.Vals#yp().*/ = v/*=>>example.ValUsages.v.*/.xp/*=>>example.Vals#xp.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.yp/*=>>example.Vals#yp().*/ - v/*=>>example.ValUsages.v.*/.ym/*=>>example.Vals#ym().*/ = v/*=>>example.ValUsages.v.*/.xm/*=>>example.Vals#xm.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.ym/*=>>example.Vals#ym().*/ - v/*=>>example.ValUsages.v.*/.yam/*=>>example.Vals#yam().*/ = v/*=>>example.ValUsages.v.*/.xam/*=>>example.Vals#xam.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.yam/*=>>example.Vals#yam().*/ - println/*=>>scala.Predef.println(+1).*/(v/*=>>example.ValUsages.v.*/.xzm/*=>>example.Vals#xzm.*/) - v/*=>>example.ValUsages.v.*/.yfm/*=>>example.Vals#yfm().*/ = v/*=>>example.ValUsages.v.*/.xfm/*=>>example.Vals#xfm.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.yfm/*=>>example.Vals#yfm().*/ - v/*=>>example.ValUsages.v.*/.yim/*=>>example.Vals#yim().*/ = v/*=>>example.ValUsages.v.*/.xim/*=>>example.Vals#xim.*/ +/*=>>scala.Int#`+`(+4).*/ v/*=>>example.ValUsages.v.*/.yim/*=>>example.Vals#yim().*/ +object ValUsages/*<-example::ValUsages.*/ { + val v/*<-example::ValUsages.v.*/: Vals/*->example::Vals#*/ = ???/*->scala::Predef.`???`().*/ + v/*->example::ValUsages.v.*/.yp/*->example::Vals#yp().*/ = v/*->example::ValUsages.v.*/.xp/*->example::Vals#xp.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yp/*->example::Vals#yp().*/ + v/*->example::ValUsages.v.*/.ym/*->example::Vals#ym().*/ = v/*->example::ValUsages.v.*/.xm/*->example::Vals#xm.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.ym/*->example::Vals#ym().*/ + v/*->example::ValUsages.v.*/.yam/*->example::Vals#yam().*/ = v/*->example::ValUsages.v.*/.xam/*->example::Vals#xam.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yam/*->example::Vals#yam().*/ + println/*->scala::Predef.println(+1).*/(v/*->example::ValUsages.v.*/.xzm/*->example::Vals#xzm.*/) + v/*->example::ValUsages.v.*/.yfm/*->example::Vals#yfm().*/ = v/*->example::ValUsages.v.*/.xfm/*->example::Vals#xfm.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yfm/*->example::Vals#yfm().*/ + v/*->example::ValUsages.v.*/.yim/*->example::Vals#yim().*/ = v/*->example::ValUsages.v.*/.xim/*->example::Vals#xim.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yim/*->example::Vals#yim().*/ } diff --git a/tests/semanticdb/expect/Vararg.expect.scala b/tests/semanticdb/expect/Vararg.expect.scala index 3ac0a16719ed..5b82e2f16f25 100644 --- a/tests/semanticdb/expect/Vararg.expect.scala +++ b/tests/semanticdb/expect/Vararg.expect.scala @@ -1,6 +1,6 @@ package example -class Vararg/*<<=example.Vararg#*/ { - def add1/*<<=example.Vararg#add1().*/(a/*<<=example.Vararg#add1().(a)*/: Int/*=>>scala.Int#*/*) = {} - def add2/*<<=example.Vararg#add2().*/(a/*<<=example.Vararg#add2().(a)*/: Seq/*=>>scala.package.Seq#*/[Int/*=>>scala.Int#*/]*): Unit/*=>>scala.Unit#*/ = {} +class Vararg/*<-example::Vararg#*/ { + def add1/*<-example::Vararg#add1().*/(a/*<-example::Vararg#add1().(a)*/: Int/*->scala::Int#*/*) = {} + def add2/*<-example::Vararg#add2().*/(a/*<-example::Vararg#add2().(a)*/: Seq/*->scala::package.Seq#*/[Int/*->scala::Int#*/]*): Unit/*->scala::Unit#*/ = {} } diff --git a/tests/semanticdb/expect/filename with spaces.expect.scala b/tests/semanticdb/expect/filename with spaces.expect.scala index 8e067c2662d9..90ffb6265a64 100644 --- a/tests/semanticdb/expect/filename with spaces.expect.scala +++ b/tests/semanticdb/expect/filename with spaces.expect.scala @@ -1,3 +1,3 @@ package example -class FilenameWithSpaces/*<<=example.FilenameWithSpaces#*//*<=example.FilenameWithSpaces#*/ +class FilenameWithSpaces/*<-example::FilenameWithSpaces#*//*<=example.FilenameWithSpaces#*/ diff --git a/tests/semanticdb/expect/local-file.expect.scala b/tests/semanticdb/expect/local-file.expect.scala index 322005341e99..aa2842dcee28 100644 --- a/tests/semanticdb/expect/local-file.expect.scala +++ b/tests/semanticdb/expect/local-file.expect.scala @@ -1,8 +1,8 @@ package example -class `local-file/*<<=example.`local-file`#*/` { - locally/*=>>dotty.DottyPredef.locally().*/ { - val local/*<<=local0*/ = 42 - local/*=>>local0*/ +/*=>>scala.Int#`+`(+4).*/ 4 +class `local-file/*<-example::`local-file`#*/` { + locally/*->dotty::DottyPredef.locally().*/ { + val local/*<-local0*/ = 42 + local/*->local0*/ +/*->scala::Int#`+`(+4).*/ 4 } } diff --git a/tests/semanticdb/expect/semanticdb-extract.expect.scala b/tests/semanticdb/expect/semanticdb-extract.expect.scala index 2cbd188ab708..02bd562a718b 100644 --- a/tests/semanticdb/expect/semanticdb-extract.expect.scala +++ b/tests/semanticdb/expect/semanticdb-extract.expect.scala @@ -1,18 +1,18 @@ -object AnObject/*<<=_empty_.AnObject.*/ { +object AnObject/*<-_empty_::AnObject.*/ { - def foo/*<<=_empty_.AnObject.foo().*/(x/*<<=_empty_.AnObject.foo().(x)*/: Int/*=>>scala.Int#*/) = () - def foo/*<<=_empty_.AnObject.foo(+1).*/(): Unit/*=>>scala.Unit#*/ = () + def foo/*<-_empty_::AnObject.foo().*/(x/*<-_empty_::AnObject.foo().(x)*/: Int/*->scala::Int#*/) = () + def foo/*<-_empty_::AnObject.foo(+1).*/(): Unit/*->scala::Unit#*/ = () - foo/*=>>_empty_.AnObject.foo().*/(1) - foo/*=>>_empty_.AnObject.foo(+1).*/() + foo/*->_empty_::AnObject.foo().*/(1) + foo/*->_empty_::AnObject.foo(+1).*/() - "".substring/*=>>java.lang.String#substring().*/(1) - "".substring/*=>>java.lang.String#substring(+1).*/(1, 2) + "".substring/*->java::lang::String#substring().*/(1) + "".substring/*->java::lang::String#substring(+1).*/(1, 2) - List/*=>>scala.package.List.*//*=>>scala.collection.IterableFactory#apply().*/(1, 2) - List/*=>>scala.package.List.*/.apply/*=>>scala.collection.IterableFactory#apply().*/() - List/*=>>scala.package.List.*/.`apply`/*=>>scala.collection.IterableFactory#apply().*/() - println/*=>>scala.Predef.println(+1).*/(1 +/*=>>scala.Int#`+`(+4).*/ 2) + List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1, 2) + List/*->scala::package.List.*/.apply/*->scala::collection::IterableFactory#apply().*/() + List/*->scala::package.List.*/.`apply`/*->scala::collection::IterableFactory#apply().*/() + println/*->scala::Predef.println(+1).*/(1 +/*->scala::Int#`+`(+4).*/ 2) - case class Foo/*<<=_empty_.AnObject.Foo#*/(x/*<<=_empty_.AnObject.Foo#x.*/: Int/*=>>scala.Int#*/) + case class Foo/*<-_empty_::AnObject.Foo#*/(x/*<-_empty_::AnObject.Foo#x.*/: Int/*->scala::Int#*/) } diff --git a/tests/semanticdb/expect/toplevel.expect.scala b/tests/semanticdb/expect/toplevel.expect.scala index 4847a33a41d1..b61e882fef36 100644 --- a/tests/semanticdb/expect/toplevel.expect.scala +++ b/tests/semanticdb/expect/toplevel.expect.scala @@ -1,5 +1,5 @@ -inline val a = "/*<<=_empty_.toplevel$package.*//*<<=_empty_.toplevel$package.a.*/" -def (x: Int/*<<=_empty_.toplevel$package.combine().*//*<<=_empty_.toplevel$package.combine().(x)*//*=>>scala.Int#*/) combine (y/*<<=_empty_.toplevel$package.combine().(y)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine().(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine().(y)*/ -def combine/*<<=_empty_.toplevel$package.combine(+1).*/(x/*<<=_empty_.toplevel$package.combine(+1).(x)*/: Int/*=>>scala.Int#*/, y/*<<=_empty_.toplevel$package.combine(+1).(y)*/: Int/*=>>scala.Int#*/, z/*<<=_empty_.toplevel$package.combine(+1).(z)*/: Int/*=>>scala.Int#*/) = x/*=>>_empty_.toplevel$package.combine(+1).(x)*/ +/*=>>scala.Int#`+`(+4).*/ y/*=>>_empty_.toplevel$package.combine(+1).(y)*/ +/*=>>scala.Int#`+`(+4).*/ z/*=>>_empty_.toplevel$package.combine(+1).(z)*/ -def combine/*<<=_empty_.toplevel$package.combine(+2).*/ = 0 -def foo/*<<=_empty_.toplevel$package.foo().*/ = "foo" +inline val a = "/*<-_empty_::toplevel$package.*//*<-_empty_::toplevel$package.a.*/" +def (x: Int/*<-_empty_::toplevel$package.combine().*//*<-_empty_::toplevel$package.combine().(x)*//*->scala::Int#*/) combine (y/*<-_empty_::toplevel$package.combine().(y)*/: Int/*->scala::Int#*/) = x/*->_empty_::toplevel$package.combine().(x)*/ +/*->scala::Int#`+`(+4).*/ y/*->_empty_::toplevel$package.combine().(y)*/ +def combine/*<-_empty_::toplevel$package.combine(+1).*/(x/*<-_empty_::toplevel$package.combine(+1).(x)*/: Int/*->scala::Int#*/, y/*<-_empty_::toplevel$package.combine(+1).(y)*/: Int/*->scala::Int#*/, z/*<-_empty_::toplevel$package.combine(+1).(z)*/: Int/*->scala::Int#*/) = x/*->_empty_::toplevel$package.combine(+1).(x)*/ +/*->scala::Int#`+`(+4).*/ y/*->_empty_::toplevel$package.combine(+1).(y)*/ +/*->scala::Int#`+`(+4).*/ z/*->_empty_::toplevel$package.combine(+1).(z)*/ +def combine/*<-_empty_::toplevel$package.combine(+2).*/ = 0 +def foo/*<-_empty_::toplevel$package.foo().*/ = "foo" From 3bb757d9535cad26a98dbf1b9aa60388278c445a Mon Sep 17 00:00:00 2001 From: bishabosha Date: Thu, 14 Nov 2019 19:58:13 +0100 Subject: [PATCH 060/107] add metac.expect test --- .../dotc/semanticdb/ExtractSemanticDB.scala | 55 +- .../dotty/tools/dotc/semanticdb/Scala.scala | 57 +- .../dotc/semanticdb/SemanticdbTests.scala | 22 +- .../tools/dotc/semanticdb/Semanticdbs.scala | 234 +- project/Build.scala | 2 +- tests/semanticdb/expect/Enums.expect.scala | 2 +- tests/semanticdb/expect/Example.expect.scala | 2 +- tests/semanticdb/expect/Givens.expect.scala | 4 +- tests/semanticdb/expect/Types.expect.scala | 6 +- tests/semanticdb/metac.expect | 3314 +++++++++++++++++ 10 files changed, 3603 insertions(+), 95 deletions(-) create mode 100644 tests/semanticdb/metac.expect diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 58841502b1bc..6a48b36340a7 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -41,8 +41,17 @@ class ExtractSemanticDB extends Phase { extract.traverse(unit.tpdTree) ExtractSemanticDB.write(unit.source, extract.occurrences.toList, extract.symbols.toList) + def (name: Name) isScala2PackageObjectName: Boolean = name match { + case name: Names.TermName => name == nme.PACKAGE + case name: Names.TypeName => + name.toTermName match { + case NameKinds.ModuleClassName(original) => original.isScala2PackageObjectName + case _ => false + } + } + def (sym: Symbol) isScala2PackageObject(given Context): Boolean = - sym.name == nme.PACKAGE && sym.owner.is(Package) && sym.is(Module) + sym.name.isScala2PackageObjectName && sym.owner.is(Package) && sym.is(Module) /** Extractor of symbol occurrences from trees */ class Extractor extends TreeTraverser { @@ -207,20 +216,22 @@ class ExtractSemanticDB extends Phase { private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = excludeDefStrict(sym) || (excludeDef(sym) && span.start == span.end) - private def symbolKind(sym: Symbol, symbol: String, symkind: SymbolKind)(given Context): SymbolInformation.Kind = - if sym.is(Local) || symbol.isLocal + private def symbolKind(sym: Symbol, symkind: SymbolKind)(given Context): SymbolInformation.Kind = + if sym.isTypeParam + SymbolInformation.Kind.TYPE_PARAMETER + else if sym.is(TermParam) + SymbolInformation.Kind.PARAMETER + else if sym.isTerm && sym.owner.isTerm SymbolInformation.Kind.LOCAL else if sym.isInlineMethod || sym.is(Macro) SymbolInformation.Kind.MACRO + else if sym.name == nme.CONSTRUCTOR + SymbolInformation.Kind.CONSTRUCTOR + else if sym.isSelfSym + SymbolInformation.Kind.SELF_PARAMETER else if sym.isOneOf(Method) || symkind.isValOrVar SymbolInformation.Kind.METHOD - else if sym.isTypeParam - SymbolInformation.Kind.TYPE_PARAMETER - else if sym.isType - SymbolInformation.Kind.TYPE - else if sym.is(TermParam) - SymbolInformation.Kind.PARAMETER - else if sym.isScala2PackageObject + else if sym.isPackageObject SymbolInformation.Kind.PACKAGE_OBJECT else if sym.is(Module) SymbolInformation.Kind.OBJECT @@ -232,12 +243,10 @@ class ExtractSemanticDB extends Phase { SymbolInformation.Kind.INTERFACE else if sym.is(Trait) SymbolInformation.Kind.TRAIT - else if sym.isSelfSym - SymbolInformation.Kind.SELF_PARAMETER + else if sym.isType + SymbolInformation.Kind.TYPE else if sym.is(ParamAccessor) SymbolInformation.Kind.FIELD - else if sym.name == nme.CONSTRUCTOR - SymbolInformation.Kind.CONSTRUCTOR else SymbolInformation.Kind.UNKNOWN_KIND @@ -276,9 +285,9 @@ class ExtractSemanticDB extends Phase { private def symbolInfo(sym: Symbol, symbolName: String, symkind: SymbolKind)(given Context): SymbolInformation = SymbolInformation( symbol = symbolName, language = Language.SCALA, - kind = symbolKind(sym, symbolName, symkind), + kind = symbolKind(sym, symkind), properties = symbolProps(sym, symkind).foldLeft(0)(_ | _.value), - displayName = (if sym.is(ModuleClass) then sym.sourceModule else sym).name.show + displayName = Symbols.displaySymbol(sym) ) private def registerSymbol(sym: Symbol, symbolName: String, symkind: SymbolKind)(given Context): Unit = @@ -318,10 +327,13 @@ class ExtractSemanticDB extends Phase { case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => - val symkind = tree match - case _: ValDef => if tree.mods.is(Mutable) then SymbolKind.Var else SymbolKind.Val - case _: Bind => SymbolKind.Val - case _ => SymbolKind.Other + val symkind = + if tree.symbol.isSelfSym + SymbolKind.Other + else tree match + case _: ValDef => if tree.mods.is(Mutable) then SymbolKind.Var else SymbolKind.Val + case _: Bind => SymbolKind.Val + case _ => SymbolKind.Other registerDefinition(tree.symbol, tree.nameSpan, symkind) val privateWithin = tree.symbol.privateWithin if privateWithin `ne` NoSymbol @@ -395,7 +407,6 @@ object ExtractSemanticDB { else Paths.get(targetRootSetting) ) val relPath = sourceRoot.relativize(sourcePath) - val relURI = relPath.iterator().asScala.mkString("/") val outpath = targetRoot .resolve("META-INF") .resolve("semanticdb") @@ -405,7 +416,7 @@ object ExtractSemanticDB { val doc: TextDocument = TextDocument( schema = Schema.SEMANTICDB4, language = Language.SCALA, - uri = relURI, + uri = relPath.toString, text = "", md5 = internal.MD5.compute(String(source.content)), symbols = symbols, diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala index af0ee2c0720d..81c48923f4ec 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala @@ -1,5 +1,9 @@ package dotty.tools.dotc.semanticdb +import dotty.tools.dotc.core.Symbols.{ Symbol => DottySymbol, defn } +import dotty.tools.dotc.core.Contexts.Context +import dotty.tools.dotc.core.Flags._ + object Scala with object Symbols with @@ -9,6 +13,31 @@ object Scala with val EmptyPackage: String = "_empty_/" val LocalPrefix: String = "local" val PackageObjectDescriptor: String = "package." + val s"${RootPackageName @ _}/" = RootPackage + val s"${EmptyPackageName @ _}/" = EmptyPackage + + def displaySymbol(symbol: DottySymbol)(given Context): String = + if symbol.isPackageObject then + displaySymbol(symbol.owner) + else if symbol.is(ModuleClass) then + displaySymbol(symbol.sourceModule) + else if symbol == defn.RootPackage + RootPackageName + else if symbol.isEmptyPackage + EmptyPackageName + else + symbol.name.show + + + private val locals = raw"local(\d+)" + + object LocalSymbol with + def unapply(symbolInfo: SymbolInformation): Option[Int] = + symbolInfo.symbol match + case locals.r(ints) => + val bi = BigInt(ints) + if bi.isValidInt then Some(bi.toInt) else None + case _ => None given (symbol: String) with @@ -24,7 +53,7 @@ object Scala with case _ => false }) def isLocal: Boolean = - symbol.startsWith(Symbols.LocalPrefix) + symbol.matches(locals) def isMulti: Boolean = symbol.startsWith(";") def isTerm: Boolean = @@ -42,3 +71,29 @@ object Scala with def isPrimary: Boolean = (info.properties & SymbolInformation.Property.PRIMARY.value) != 0 + def isAbstract: Boolean = + (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0 + def isFinal: Boolean = + (info.properties & SymbolInformation.Property.FINAL.value) != 0 + def isSealed: Boolean = + (info.properties & SymbolInformation.Property.SEALED.value) != 0 + def isImplicit: Boolean = + (info.properties & SymbolInformation.Property.IMPLICIT.value) != 0 + def isLazy: Boolean = + (info.properties & SymbolInformation.Property.LAZY.value) != 0 + def isCase: Boolean = + (info.properties & SymbolInformation.Property.CASE.value) != 0 + def isCovariant: Boolean = + (info.properties & SymbolInformation.Property.COVARIANT.value) != 0 + def isContravariant: Boolean = + (info.properties & SymbolInformation.Property.CONTRAVARIANT.value) != 0 + def isVal: Boolean = + (info.properties & SymbolInformation.Property.VAL.value) != 0 + def isVar: Boolean = + (info.properties & SymbolInformation.Property.VAR.value) != 0 + def isStatic: Boolean = + (info.properties & SymbolInformation.Property.STATIC.value) != 0 + def isEnum: Boolean = + (info.properties & SymbolInformation.Property.ENUM.value) != 0 + def isDefault: Boolean = + (info.properties & SymbolInformation.Property.DEFAULT.value) != 0 diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index c7987bb42e15..06c09856e158 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -27,7 +27,9 @@ class SemanticdbTests with val scalaFile = FileSystems.getDefault.getPathMatcher("glob:**.scala") val expectFile = FileSystems.getDefault.getPathMatcher("glob:**.expect.scala") // val semanticdbFile = FileSystems.getDefault.getPathMatcher("glob:**.scala.semanticdb") - val expectSrc = Paths.get(System.getProperty("dotty.tools.dotc.semanticdb.test.expect")) + val rootSrc = Paths.get(System.getProperty("dotty.tools.dotc.semanticdb.test")) + val expectSrc = rootSrc.resolve("expect") + val metacExpectFile = rootSrc.resolve("metac.expect") @Category(Array(classOf[dotty.SlowTests])) @Test def expectTests: Unit = runExpectTest(updateExpectFiles = false) @@ -35,7 +37,8 @@ class SemanticdbTests with def runExpectTest(updateExpectFiles: Boolean): Unit = val target = generateSemanticdb() val errors = mutable.ArrayBuffer.empty[(Path, String)] - inputFiles().foreach { source => + given metacSb: StringBuilder = StringBuilder(5000) + inputFiles().sorted.foreach { source => val filename = source.getFileName.toString val relpath = expectSrc.relativize(source) val semanticdbPath = target @@ -45,16 +48,25 @@ class SemanticdbTests with .resolveSibling(filename + ".semanticdb") val expectPath = source.resolveSibling(filename.replaceAllLiterally(".scala", ".expect.scala")) val doc = Semanticdbs.loadTextDocument(source, relpath, semanticdbPath) + Semanticdbs.metac(doc, rootSrc.relativize(source))(given metacSb) val obtained = trimTrailingWhitespace(Semanticdbs.printTextDocument(doc)) - if (updateExpectFiles) + if updateExpectFiles Files.write(expectPath, obtained.getBytes(StandardCharsets.UTF_8)) println("updated: " + expectPath) else val expected = new String(Files.readAllBytes(expectPath), StandardCharsets.UTF_8) val expectName = expectPath.getFileName - val relExpect = expectSrc.relativize(expectPath) - collectFailingDiff(obtained, expected, s"a/$relExpect", s"b/$relExpect")(errors += expectName -> _) + val relExpect = rootSrc.relativize(expectPath) + collectFailingDiff(expected, obtained, s"a/$relExpect", s"b/$relExpect")(errors += expectName -> _) } + if updateExpectFiles + Files.write(metacExpectFile, metacSb.toString.getBytes) + println("updated: " + metacExpectFile) + else + val expected = new String(Files.readAllBytes(metacExpectFile), StandardCharsets.UTF_8) + val expectName = metacExpectFile.getFileName + val relExpect = rootSrc.relativize(metacExpectFile) + collectFailingDiff(expected, metacSb.toString, s"a/$relExpect", s"b/$relExpect")(errors += expectName -> _) errors.foreach { (source, diff) => def red(msg: String) = Console.RED + msg + Console.RESET def blue(msg: String) = Console.BLUE + msg + Console.RESET diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index 8557a407f6b4..bad61e034c73 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -6,7 +6,7 @@ import scala.collection.JavaConverters._ import dotty.tools.dotc.util.SourceFile import dotty.tools.dotc.semanticdb.Scala.{_, given} -object Semanticdbs { +object Semanticdbs with /** Load SemanticDB TextDocument for a single Scala source file * @@ -15,34 +15,29 @@ object Semanticdbs { * @param semanticdbAbsolutePath Absolute path to the SemanticDB file. */ def loadTextDocument( - scalaAbsolutePath: Path, - scalaRelativePath: Path, - semanticdbAbsolutePath: Path - ): TextDocument = { - val reluri = scalaRelativePath.iterator.asScala.mkString("/") + scalaAbsolutePath: Path, + scalaRelativePath: Path, + semanticdbAbsolutePath: Path + ): TextDocument = + val reluri = scalaRelativePath.toString val sdocs = parseTextDocuments(semanticdbAbsolutePath) - sdocs.documents.find(_.uri == reluri) match { - case None => throw new NoSuchElementException(reluri) - case Some(document) => - val text = new String(Files.readAllBytes(scalaAbsolutePath), StandardCharsets.UTF_8) - // Assert the SemanticDB payload is in-sync with the contents of the Scala file on disk. - val md5FingerprintOnDisk = internal.MD5.compute(text) - if (document.md5 != md5FingerprintOnDisk) { - throw new IllegalArgumentException("stale semanticdb: " + reluri) - } else { - // Update text document to include full text contents of the file. - document.copy(text = text) - } - } - } + sdocs.documents.find(_.uri == reluri) match + case None => throw new NoSuchElementException(reluri) + case Some(document) => + val text = new String(Files.readAllBytes(scalaAbsolutePath), StandardCharsets.UTF_8) + // Assert the SemanticDB payload is in-sync with the contents of the Scala file on disk. + val md5FingerprintOnDisk = internal.MD5.compute(text) + if document.md5 != md5FingerprintOnDisk + throw new IllegalArgumentException("stale semanticdb: " + reluri) + else + // Update text document to include full text contents of the file. + document.copy(text = text) + end loadTextDocument /** Parses SemanticDB text documents from an absolute path to a `*.semanticdb` file. */ - def parseTextDocuments(path: Path): TextDocuments = { - // NOTE: a *.semanticdb file is of type TextDocuments, not TextDocument - val bytes = Files.readAllBytes(path) + def parseTextDocuments(path: Path): TextDocuments = + val bytes = Files.readAllBytes(path) // NOTE: a semanticdb file is a TextDocuments message, not TextDocument TextDocuments.parseFrom(bytes) - } - /** Prettyprint a text document with symbol occurrences next to each resolved identifier. * @@ -54,15 +49,12 @@ object Semanticdbs { * } * }}} **/ - def printTextDocument(doc: TextDocument): String = { + def printTextDocument(doc: TextDocument): String = val symtab = doc.symbols.iterator.map(info => info.symbol -> info).toMap - val sb = new StringBuilder + val sb = StringBuilder(1000) val sourceFile = SourceFile.virtual(doc.uri, doc.text) - implicit val occurrenceOrdering: Ordering[SymbolOccurrence] = - buildOccurrenceOrdering(sourceFile) - val occurrences = doc.occurrences.sorted var offset = 0 - occurrences.foreach { occ => + for occ <- doc.occurrences.sorted do val range = occ.range.get val end = math.max( offset, @@ -77,34 +69,158 @@ object Semanticdbs { .append(occ.symbol.replace("/", "::")) .append("*/") offset = end - } sb.append(doc.text.substring(offset)) - sb.toString() - } + sb.toString + end printTextDocument + + def schemaString(schema: Schema) = + import Schema._ + schema match + case SEMANTICDB3 => "SemanticDB v3" + case SEMANTICDB4 => "SemanticDB v4" + case LEGACY => "SemanticDB legacy" + case Unrecognized(_) => "unknown" + end schemaString + + def languageString(language: Language) = + import Language._ + language match + case SCALA => "Scala" + case JAVA => "Java" + case UNKNOWN_LANGUAGE | Unrecognized(_) => "unknown" + end languageString + + def processSymbol(info: SymbolInformation)(given sb: StringBuilder): Unit = + import SymbolInformation.Kind._ + sb.append(info.symbol).append(" => ") + if info.isAbstract then sb.append("abstract ") + if info.isFinal then sb.append("final ") + if info.isSealed then sb.append("sealed ") + if info.isImplicit then sb.append("implicit ") + if info.isLazy then sb.append("lazy ") + if info.isCase then sb.append("case ") + if info.isCovariant then sb.append("covariant ") + if info.isContravariant then sb.append("contravariant ") + if info.isVal then sb.append("val ") + if info.isVar then sb.append("var ") + if info.isStatic then sb.append("static ") + if info.isPrimary then sb.append("primary ") + if info.isEnum then sb.append("enum ") + if info.isDefault then sb.append("default ") + info.kind match + case LOCAL => sb.append("local ") + case FIELD => sb.append("field ") + case METHOD => sb.append("method ") + case CONSTRUCTOR => sb.append("ctor ") + case MACRO => sb.append("macro ") + case TYPE => sb.append("type ") + case PARAMETER => sb.append("param ") + case SELF_PARAMETER => sb.append("selfparam ") + case TYPE_PARAMETER => sb.append("typeparam ") + case OBJECT => sb.append("object ") + case PACKAGE => sb.append("package ") + case PACKAGE_OBJECT => sb.append("package object ") + case CLASS => sb.append("class ") + case TRAIT => sb.append("trait ") + case INTERFACE => sb.append("interface ") + case UNKNOWN_KIND | Unrecognized(_) => sb.append("unknown ") + sb.append(info.displayName).nl + end processSymbol + + def processOccurrence(occ: SymbolOccurrence)(given sb: StringBuilder): 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(')') + case _ => + sb.append("[)") + end match + sb.append(" => ").append(occ.symbol).nl + end processOccurrence + + def metac(doc: TextDocument, realPath: Path)(given sb: StringBuilder): StringBuilder = + val realURI = realPath.toString + sb.append(realURI).nl + sb.append("_" * realURI.length).nl + sb.nl + sb.append("Summary:").nl + sb.append("Schema => ").append(schemaString(doc.schema)).nl + sb.append("Uri => ").append(doc.uri).nl + sb.append("Text => empty").nl + sb.append("Language => ").append(languageString(doc.language)).nl + sb.append("Symbols => ").append(doc.symbols.length).append(" entries").nl + sb.append("Occurrences => ").append(doc.occurrences.length).append(" entries").nl + sb.nl + sb.append("Symbols:").nl + doc.symbols.sorted.foreach(processSymbol) + sb.nl + sb.append("Occurrences:").nl + doc.occurrences.sorted.foreach(processOccurrence) + sb.nl + end metac /** Sort symbol occurrences by their start position. */ - def buildOccurrenceOrdering(sourceFile: SourceFile): Ordering[SymbolOccurrence] = { - new Ordering[SymbolOccurrence] { - def rangeToTuple(r : Range): (Int, Int) = { - val start = sourceFile.lineToOffset(r.startLine) + r.startCharacter - val end = sourceFile.lineToOffset(r.endLine) + r.endCharacter - (start, end) - } - - override def compare(x: SymbolOccurrence, y: SymbolOccurrence): Int = { - if (x.range.isEmpty) 0 - else if (y.range.isEmpty) 0 - else { - val (as, ae) = rangeToTuple(x.range.get) - val (bs, be) = rangeToTuple(y.range.get) - val byStart = Integer.compare(as, bs) - if (byStart != 0) { - byStart - } else { - Integer.compare(ae, be) - } - } - } - } - } -} + given buildOccurrenceOrdering: Ordering[SymbolOccurrence] = (x, y) => + x.range -> y.range match + case None -> _ | _ -> None => 0 + case Some(a) -> Some(b) => + val byLine = Integer.compare(a.startLine, b.startLine) + if (byLine != 0) + byLine + else // byCharacter + Integer.compare(a.startCharacter, b.startCharacter) + end buildOccurrenceOrdering + + given Ordering[SymbolInformation] = Ordering.by[SymbolInformation, String](_.symbol)(IdentifierOrdering()) + + /** + * A comparator for identifier like "Predef" or "Function10". + * + * Differences from the default string comparator: + * - works with CharSequences like compiler `Name` + * - orders numbers by their numerical value instead of lexicographical + * - Good: `Function1`, `Function2`, `Function10` + * - Bad: `Function1`, `Function10`, `Function2` + * + * taken from https://github.com/scalameta/scalameta/blob/master/semanticdb/metap/src/main/scala/scala/meta/internal/metap/IdentifierOrdering.scala + */ + class IdentifierOrdering[T <: CharSequence] extends Ordering[T] with + + override def compare(o1: T, o2: T): Int = + val len = math.min(o1.length(), o2.length()) + var i = 0 + while i < len do + val a = o1.charAt(i) + val b = o2.charAt(i) + if a.isDigit && b.isDigit + val byDigit = Integer.compare(toDigit(o1, i), toDigit(o2, i)) + if (byDigit != 0) return byDigit + else + i = seekNonDigit(o1, i) + else + val result = Character.compare(a, b) + if result != 0 + return result + i += 1 + end while + Integer.compare(o1.length(), o2.length()) + end compare + + private def seekNonDigit(cs: T, i: Int): Int = + var curr = i + while curr < cs.length && cs.charAt(curr).isDigit do + curr += 1 + curr + end seekNonDigit + + private def toDigit(cs: T, i: Int): Int = + val digit = cs.subSequence(i, seekNonDigit(cs, i)) + Integer.parseUnsignedInt(digit.toString) + end toDigit + + end IdentifierOrdering + + inline def (sb: StringBuilder) nl = sb.append(System.lineSeparator) diff --git a/project/Build.scala b/project/Build.scala index c0f38317c80f..dd879e320197 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -553,7 +553,7 @@ object Build { }, javaOptions += ( - s"-Ddotty.tools.dotc.semanticdb.test.expect=${(ThisBuild / baseDirectory).value/"tests"/"semanticdb"/"expect"}" + s"-Ddotty.tools.dotc.semanticdb.test=${(ThisBuild / baseDirectory).value/"tests"/"semanticdb"}" ), testCompilation := Def.inputTaskDyn { diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index ef20f059da7e..0fc6390e2b2d 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -2,7 +2,7 @@ object Enums/*<-_empty_::Enums.*/ with import =:=/*->_empty_::Enums.`=:=`.*/._ enum Colour/*<-_empty_::Enums.Colour#*/ with - case /*->scala::runtime::EnumValues#``().*/Red/*->_empty_::Enums.Colour.Red.*//*<-_empty_::Enums.Colour.Red.*/, Green/*->_empty_::Enums.Colour.Green.*//*<-_empty_::Enums.Colour.Green.*/, Blue/*->_empty_::Enums.Colour.Blue.*//*<-_empty_::Enums.Colour.Blue.*/ + case Red/*->_empty_::Enums.Colour.Red.*//*->scala::runtime::EnumValues#``().*//*<-_empty_::Enums.Colour.Red.*/, Green/*->_empty_::Enums.Colour.Green.*//*<-_empty_::Enums.Colour.Green.*/, Blue/*->_empty_::Enums.Colour.Blue.*//*<-_empty_::Enums.Colour.Blue.*/ enum WeekDays/*<-_empty_::Enums.WeekDays#*/ with /*->scala::runtime::EnumValues#``().*/case Monday/*<-_empty_::Enums.WeekDays.Monday.*/ diff --git a/tests/semanticdb/expect/Example.expect.scala b/tests/semanticdb/expect/Example.expect.scala index d8cf6786a485..6be705f334a7 100644 --- a/tests/semanticdb/expect/Example.expect.scala +++ b/tests/semanticdb/expect/Example.expect.scala @@ -2,7 +2,7 @@ package example import scala.concurrent.Future/*->scala::concurrent::Future.*//*->scala::concurrent::Future#*/ -object Example/*<-example::Example.*/ { /*->example::Example.*/self/*<-local0*/ => +object Example/*<-example::Example.*/ { self/*<-local0*//*->example::Example.*/ => new scala.collection.mutable.Stack/*->scala::collection::mutable::Stack#*/[Int/*->scala::Int#*/]/*->scala::collection::mutable::Stack#``(+1).*/() def main/*<-example::Example.main().*/(args/*<-example::Example.main().(args)*/: Array/*->scala::Array#*/[String/*->scala::Predef.String#*/]): Unit/*->scala::Unit#*/ = { println/*->scala::Predef.println(+1).*/(1) diff --git a/tests/semanticdb/expect/Givens.expect.scala b/tests/semanticdb/expect/Givens.expect.scala index d4b46b7dbc02..a969158a55a1 100644 --- a/tests/semanticdb/expect/Givens.expect.scala +++ b/tests/semanticdb/expect/Givens.expect.scala @@ -12,8 +12,8 @@ object Givens/*<-a::b::Givens.*/ def empty/*<-a::b::Givens.Monoid#empty().*/: A/*->a::b::Givens.Monoid#[A]*/ def (x: A) /*<-a::b::Givens.Monoid#combine().*//*<-a::b::Givens.Monoid#combine().(x)*//*->a::b::Givens.Monoid#[A]*/combine (y/*<-a::b::Givens.Monoid#combine().(y)*/: A/*->a::b::Givens.Monoid#[A]*/): A/*->a::b::Givens.Monoid#[A]*/ - given Monoid/*->a::b::Givens.Monoid#*/[String] - /*<-a::b::Givens.given_Monoid_String.*//*->scala::Predef.String#*/def empty/*<-a::b::Givens.given_Monoid_String.empty().*/ = "" + given Monoid[String] + /*<-a::b::Givens.given_Monoid_String.*//*->a::b::Givens.Monoid#*//*->scala::Predef.String#*/def empty/*<-a::b::Givens.given_Monoid_String.empty().*/ = "" def (x: Str/*<-a::b::Givens.given_Monoid_String.combine().*//*<-a::b::Givens.given_Monoid_String.combine().(x)*/ing/*->scala::Predef.String#*/) combine (y/*<-a::b::Givens.given_Monoid_String.combine().(y)*/: String/*->scala::Predef.String#*/) = x/*->a::b::Givens.given_Monoid_String.combine().(x)*/ +/*->java::lang::String#`+`().*/ y/*->a::b::Givens.given_Monoid_String.combine().(y)*/ inline given int2String/*<-a::b::Givens.int2String().*/: Conversion/*->scala::Conversion#*/[Int/*->scala::Int#*/, String/*->scala::Predef.String#*/] = _.toString/*->scala::Any#toString().*/ diff --git a/tests/semanticdb/expect/Types.expect.scala b/tests/semanticdb/expect/Types.expect.scala index a6e8efd3ad6e..2d65b6f009c8 100644 --- a/tests/semanticdb/expect/Types.expect.scala +++ b/tests/semanticdb/expect/Types.expect.scala @@ -3,9 +3,9 @@ package types import scala.language/*->scalaShadowing::language.*/.existentials/*->scalaShadowing::language.existentials.*/ import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ -class /*->scala::annotation::Annotation#``().*/ann/*<-types::ann#*/[T/*<-types::ann#[T]*/](x/*<-types::ann#x.*/: T/*->types::ann#``().[T]*/) extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ -class /*->scala::annotation::Annotation#``().*/ann1/*<-types::ann1#*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ -class /*->scala::annotation::Annotation#``().*/ann2/*<-types::ann2#*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class ann/*<-types::ann#*//*->scala::annotation::Annotation#``().*/[T/*<-types::ann#[T]*/](x/*<-types::ann#x.*/: T/*->types::ann#``().[T]*/) extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class ann1/*<-types::ann1#*//*->scala::annotation::Annotation#``().*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class ann2/*<-types::ann2#*//*->scala::annotation::Annotation#``().*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ class B/*<-types::B#*/ diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect new file mode 100644 index 000000000000..556071160925 --- /dev/null +++ b/tests/semanticdb/metac.expect @@ -0,0 +1,3314 @@ +expect/Access.scala +___________________ + +Summary: +Schema => SemanticDB v4 +Uri => Access.scala +Text => empty +Language => Scala +Symbols => 9 entries +Occurrences => 19 entries + +Symbols: +example/Access# => class Access +example/Access#``(). => primary ctor +example/Access#m1(). => method m1 +example/Access#m2(). => method m2 +example/Access#m3(). => method m3 +example/Access#m4(). => method m4 +example/Access#m5(). => method m5 +example/Access#m6(). => method m6 +example/Access#m7(). => method m7 + +Occurrences: +[0:8..0:15) => example/ +[2:6..2:12) => example/Access# +[3:2..3:2) => example/Access#``(). +[3:14..3:16) => example/Access#m1(). +[3:19..3:22) => scala/Predef.`???`(). +[4:20..4:22) => example/Access#m2(). +[4:25..4:28) => scala/Predef.`???`(). +[5:10..5:16) => example/Access# +[5:22..5:24) => example/Access#m3(). +[5:27..5:30) => scala/Predef.`???`(). +[6:16..6:18) => example/Access#m4(). +[6:21..6:24) => scala/Predef.`???`(). +[7:22..7:24) => example/Access#m5(). +[7:27..7:30) => scala/Predef.`???`(). +[8:12..8:19) => example/ +[8:25..8:27) => example/Access#m6(). +[8:30..8:33) => scala/Predef.`???`(). +[9:6..9:8) => example/Access#m7(). +[9:11..9:14) => scala/Predef.`???`(). + +expect/Advanced.scala +_____________________ + +Summary: +Schema => SemanticDB v4 +Uri => Advanced.scala +Text => empty +Language => Scala +Symbols => 35 entries +Occurrences => 97 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.``(). => primary ctor +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 => val method x +local1 => val method x +local2 => primary ctor +local3 => val method x +local4 => method m +local5 => val param x +local6 => primary ctor +local7 => method m +local8 => val param x +local9 => val local e3 +local10 => val local e3x + +Occurrences: +[0:8..0:16) => advanced/ +[2:7..2:12) => scala/ +[2:13..2:21) => scalaShadowing/language. +[2:22..2:33) => scalaShadowing/language.higherKinds. +[3:7..3:12) => scala/ +[3:13..3:21) => scalaShadowing/language. +[3:22..3:37) => scalaShadowing/language.reflectiveCalls. +[5:7..5:12) => scala/ +[5:13..5:20) => scala/reflect/ +[5:21..5:31) => scala/reflect/Selectable. +[5:32..5:52) => scala/reflect/Selectable.reflectiveSelectable(). +[7:6..7:7) => advanced/C# +[7:7..7:10) => advanced/C#``(). +[7:8..7:9) => advanced/C#[T] +[8:6..8:7) => advanced/C#t(). +[8:9..8:10) => advanced/C#[T] +[8:13..8:16) => scala/Predef.`???`(). +[11:6..11:16) => advanced/Structural# +[12:2..12:2) => advanced/Structural#``(). +[12:6..12:8) => advanced/Structural#s1(). +[12:16..12:17) => local0 +[12:19..12:22) => scala/Int# +[12:27..12:30) => scala/Predef.`???`(). +[13:6..13:8) => advanced/Structural#s2(). +[13:16..13:17) => local1 +[13:19..13:22) => scala/Int# +[13:33..13:33) => local2 +[13:37..13:38) => local3 +[13:40..13:43) => scala/Int# +[13:46..13:49) => scala/Predef.`???`(). +[13:51..13:51) => local2 +[14:6..14:8) => advanced/Structural#s3(). +[14:16..14:17) => local4 +[14:18..14:19) => local5 +[14:21..14:24) => scala/Int# +[14:27..14:30) => scala/Int# +[14:41..14:41) => local6 +[14:45..14:46) => local7 +[14:47..14:48) => local8 +[14:50..14:53) => scala/Int# +[14:56..14:59) => scala/Int# +[14:62..14:65) => scala/Predef.`???`(). +[14:67..14:67) => local6 +[17:6..17:15) => advanced/Wildcards# +[18:2..18:2) => advanced/Wildcards#``(). +[18:6..18:8) => advanced/Wildcards#e1(). +[18:10..18:14) => scala/package.List# +[18:20..18:23) => scala/Predef.`???`(). +[21:7..21:11) => advanced/Test. +[22:2..22:2) => advanced/Test.``(). +[22:6..22:7) => advanced/Test.s. +[22:14..22:24) => advanced/Structural# +[22:24..22:24) => advanced/Structural#``(). +[23:6..23:8) => advanced/Test.s1. +[23:11..23:12) => advanced/Test.s. +[23:13..23:15) => advanced/Structural#s1(). +[24:6..24:9) => advanced/Test.s1x. +[24:12..24:12) => scala/reflect/Selectable.reflectiveSelectable(). +[24:12..24:13) => advanced/Test.s. +[24:14..24:16) => advanced/Structural#s1(). +[24:16..24:16) => scala/Selectable#selectDynamic(). +[25:6..25:8) => advanced/Test.s2. +[25:11..25:12) => advanced/Test.s. +[25:13..25:15) => advanced/Structural#s2(). +[26:6..26:9) => advanced/Test.s2x. +[26:12..26:12) => scala/reflect/Selectable.reflectiveSelectable(). +[26:12..26:13) => advanced/Test.s. +[26:14..26:16) => advanced/Structural#s2(). +[26:16..26:16) => scala/Selectable#selectDynamic(). +[27:6..27:8) => advanced/Test.s3. +[27:11..27:12) => advanced/Test.s. +[27:13..27:15) => advanced/Structural#s3(). +[28:6..28:9) => advanced/Test.s3x. +[28:12..28:12) => scala/reflect/Selectable.reflectiveSelectable(). +[28:12..28:13) => advanced/Test.s. +[28:14..28:16) => advanced/Structural#s3(). +[28:16..28:16) => scala/Selectable#applyDynamic(). +[28:18..28:18) => scala/reflect/ClassTag.apply(). +[28:18..28:18) => java/lang/Integer#TYPE. +[28:19..28:22) => scala/Predef.`???`(). +[30:6..30:7) => advanced/Test.e. +[30:14..30:23) => advanced/Wildcards# +[30:23..30:23) => advanced/Wildcards#``(). +[31:6..31:8) => advanced/Test.e1. +[31:11..31:12) => advanced/Test.e. +[31:13..31:15) => advanced/Wildcards#e1(). +[32:6..32:9) => advanced/Test.e1x. +[32:12..32:13) => advanced/Test.e. +[32:14..32:16) => advanced/Wildcards#e1(). +[32:17..32:21) => scala/collection/IterableOps#head(). +[35:5..35:8) => scala/Predef.`???`(). +[35:11..35:14) => scala/Any# +[36:11..36:13) => local9 +[36:15..36:19) => scala/package.List# +[37:12..37:15) => local10 +[37:18..37:20) => local9 +[37:21..37:25) => scala/collection/IterableOps#head(). + +expect/Annotations.scala +________________________ + +Summary: +Schema => SemanticDB v4 +Uri => Annotations.scala +Text => empty +Language => Scala +Symbols => 22 entries +Occurrences => 53 entries + +Symbols: +annot/Alias. => final object Alias +annot/Alias.A# => type A +annot/Alias.``(). => primary ctor +annot/Annotations# => class Annotations +annot/Annotations#S# => type S +annot/Annotations#[T] => typeparam T +annot/Annotations#``(). => primary ctor +annot/Annotations#field. => val method field +annot/Annotations#method(). => method method +annot/Annotations#x. => val method x +annot/B# => class B +annot/B#``(). => primary ctor +annot/B#``(+1). => ctor +annot/B#x. => val method x +annot/M. => final object M +annot/M.``(). => primary ctor +annot/M.m(). => method m +annot/M.m().[TT] => typeparam TT +annot/T# => class T +annot/T#``(). => primary ctor +local0 => selfparam self +local1 => val local local + +Occurrences: +[0:8..0:13) => annot/ +[2:7..2:10) => com/ +[2:11..2:17) => com/javacp/ +[2:18..2:23) => com/javacp/annot/ +[3:7..3:12) => scala/ +[3:13..3:23) => scala/annotation/ +[3:24..3:28) => scala/annotation/meta/ +[4:7..4:12) => scala/ +[4:13..4:21) => scalaShadowing/language. +[4:22..4:34) => scalaShadowing/language.experimental. +[4:35..4:41) => scalaShadowing/language.experimental.macros. +[6:1..6:16) => com/javacp/annot/ClassAnnotation# +[7:6..7:17) => annot/Annotations# +[7:17..7:72) => annot/Annotations#``(). +[7:19..7:42) => com/javacp/annot/TypeParameterAnnotation# +[7:43..7:44) => annot/Annotations#[T] +[7:47..7:66) => com/javacp/annot/ParameterAnnotation# +[7:67..7:68) => annot/Annotations#x. +[7:70..7:71) => annot/Annotations#``().[T] +[7:75..7:79) => local0 +[7:81..7:87) => scala/AnyRef# +[8:3..8:18) => com/javacp/annot/FieldAnnotation# +[9:6..9:11) => annot/Annotations#field. +[11:3..11:19) => com/javacp/annot/MethodAnnotation# +[12:6..12:12) => annot/Annotations#method(). +[13:5..13:20) => com/javacp/annot/LocalAnnotation# +[14:8..14:13) => local1 +[15:4..15:9) => local1 +[17:3..17:17) => com/javacp/annot/TypeAnnotation# +[18:7..18:8) => annot/Annotations#S# +[21:6..21:7) => annot/B# +[21:7..21:40) => annot/B#``(). +[21:9..21:30) => com/javacp/annot/ConstructorAnnotation# +[21:33..21:34) => annot/B#x. +[21:36..21:39) => scala/Int# +[22:3..22:24) => com/javacp/annot/ConstructorAnnotation# +[23:6..23:12) => annot/B#``(+1). +[23:20..23:20) => annot/B#``(). +[26:1..26:17) => com/javacp/annot/ObjectAnnotation# +[27:7..27:8) => annot/M. +[28:2..28:2) => annot/M.``(). +[28:3..28:18) => com/javacp/annot/MacroAnnotation# +[29:6..29:7) => annot/M.m(). +[29:8..29:10) => annot/M.m().[TT] +[29:13..29:16) => scala/Int# +[29:16..29:16) => scala/Predef.`???`(). +[32:0..32:0) => annot/T#``(). +[32:1..32:16) => com/javacp/annot/TraitAnnotation# +[33:6..33:7) => annot/T# +[35:7..35:12) => annot/Alias. +[36:2..36:2) => annot/Alias.``(). +[36:7..36:8) => annot/Alias.A# +[36:11..36:26) => com/javacp/annot/ClassAnnotation# + +expect/Anonymous.scala +______________________ + +Summary: +Schema => SemanticDB v4 +Uri => Anonymous.scala +Text => empty +Language => Scala +Symbols => 13 entries +Occurrences => 34 entries + +Symbols: +example/Anonymous# => class Anonymous +example/Anonymous#Foo# => class 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) => val 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 => primary ctor + +Occurrences: +[0:8..0:15) => example/ +[1:7..1:12) => scala/ +[1:13..1:21) => scalaShadowing/language. +[1:22..1:33) => scalaShadowing/language.higherKinds. +[3:6..3:15) => example/Anonymous# +[4:2..4:2) => example/Anonymous#``(). +[4:8..4:17) => example/Anonymous# +[6:6..6:13) => example/Anonymous#locally(). +[6:14..6:15) => example/Anonymous#locally().[A] +[6:17..6:18) => example/Anonymous#locally().(x) +[6:20..6:21) => example/Anonymous#locally().[A] +[6:24..6:25) => example/Anonymous#locally().[A] +[6:28..6:29) => example/Anonymous#locally().(x) +[8:6..8:8) => example/Anonymous#m1(). +[8:9..8:10) => example/Anonymous#m1().[T] +[8:17..8:20) => scala/Predef.`???`(). +[9:6..9:8) => example/Anonymous#m2(). +[9:10..9:13) => scala/Predef.Map# +[9:17..9:21) => scala/package.List# +[9:28..9:31) => scala/Predef.`???`(). +[10:2..10:9) => example/Anonymous#locally(). +[11:4..11:7) => scala/Predef.`???`(). +[11:24..11:28) => scala/package.List# +[13:2..13:9) => example/Anonymous#locally(). +[14:8..14:9) => local0 +[14:11..14:14) => scala/Int# +[14:18..14:21) => scala/Int# +[14:29..14:32) => scala/Predef.`???`(). +[17:2..17:2) => example/Anonymous#Foo#``(). +[17:8..17:11) => example/Anonymous#Foo# +[18:6..18:9) => example/Anonymous#foo. +[18:16..18:16) => local1 +[18:16..18:19) => example/Anonymous#Foo# +[18:22..18:22) => local1 + +expect/Classes.scala +____________________ + +Summary: +Schema => SemanticDB v4 +Uri => Classes.scala +Text => empty +Language => Scala +Symbols => 42 entries +Occurrences => 65 entries + +Symbols: +classes/C1# => final class C1 +classes/C1#``(). => primary ctor +classes/C1#x1. => val method x1 +classes/C1.``(). => primary ctor +classes/C2# => final class C2 +classes/C2#``(). => primary ctor +classes/C2#x2. => val method x2 +classes/C2. => final object C2 +classes/C2.``(). => primary ctor +classes/C3# => case class C3 +classes/C3#``(). => primary ctor +classes/C3#x. => val method x +classes/C3.``(). => primary ctor +classes/C4# => case class C4 +classes/C4#``(). => primary ctor +classes/C4#x. => val method x +classes/C4. => final object C4 +classes/C4.``(). => primary ctor +classes/C6# => case class C6 +classes/C6#``(). => primary ctor +classes/C6#x. => val method x +classes/C6.``(). => primary ctor +classes/C7# => class C7 +classes/C7#``(). => primary ctor +classes/C7#x. => val method x +classes/C8# => class C8 +classes/C8#``(). => primary ctor +classes/C8#x. => val method x +classes/C9# => class C9 +classes/C9#``(). => primary ctor +classes/C9#x(). => var method x +classes/M. => final object M +classes/M.C5# => class C5 +classes/M.C5#``(). => primary ctor +classes/M.C5#x. => val method x +classes/M.``(). => primary ctor +classes/N. => final object N +classes/N.``(). => primary ctor +classes/N.anonClass. => val method anonClass +classes/N.anonFun. => val method anonFun +local0 => primary ctor +local1 => val method local + +Occurrences: +[0:8..0:15) => classes/ +[2:0..2:0) => classes/C1.``(). +[2:6..2:8) => classes/C1# +[2:8..2:21) => classes/C1#``(). +[2:13..2:15) => classes/C1#x1. +[2:17..2:20) => scala/Int# +[2:30..2:36) => scala/AnyVal# +[2:36..2:36) => scala/AnyVal#``(). +[4:6..4:8) => classes/C2# +[4:8..4:21) => classes/C2#``(). +[4:13..4:15) => classes/C2#x2. +[4:17..4:20) => scala/Int# +[4:30..4:36) => scala/AnyVal# +[4:36..4:36) => scala/AnyVal#``(). +[5:0..5:0) => classes/C2.``(). +[5:7..5:9) => classes/C2. +[7:0..7:0) => classes/C3.``(). +[7:11..7:13) => classes/C3# +[7:13..7:21) => classes/C3#``(). +[7:14..7:15) => classes/C3#x. +[7:17..7:20) => scala/Int# +[9:11..9:13) => classes/C4# +[9:13..9:21) => classes/C4#``(). +[9:14..9:15) => classes/C4#x. +[9:17..9:20) => scala/Int# +[10:0..10:0) => classes/C4.``(). +[10:7..10:9) => classes/C4. +[12:7..12:8) => classes/M. +[13:2..13:2) => classes/M.``(). +[13:17..13:19) => classes/M.C5# +[13:19..13:27) => classes/M.C5#``(). +[13:20..13:21) => classes/M.C5#x. +[13:23..13:26) => scala/Int# +[16:0..16:0) => classes/C6.``(). +[16:11..16:13) => classes/C6# +[16:13..16:33) => classes/C6#``(). +[16:26..16:27) => classes/C6#x. +[16:29..16:32) => scala/Int# +[18:6..18:8) => classes/C7# +[18:8..18:16) => classes/C7#``(). +[18:9..18:10) => classes/C7#x. +[18:12..18:15) => scala/Int# +[20:6..20:8) => classes/C8# +[20:8..20:34) => classes/C8#``(). +[20:27..20:28) => classes/C8#x. +[20:30..20:33) => scala/Int# +[22:6..22:8) => classes/C9# +[22:8..22:34) => classes/C9#``(). +[22:27..22:28) => classes/C9#x(). +[22:30..22:33) => scala/Int# +[24:7..24:8) => classes/N. +[25:2..25:2) => classes/N.``(). +[25:6..25:15) => classes/N.anonClass. +[25:22..25:22) => local0 +[25:22..25:24) => classes/C7# +[25:24..25:24) => classes/C7#``(). +[26:8..26:13) => local1 +[26:16..26:19) => scala/Predef.`???`(). +[27:3..27:3) => local0 +[28:6..28:13) => classes/N.anonFun. +[28:16..28:20) => scala/package.List. +[28:20..28:20) => scala/collection/IterableFactory#apply(). +[28:24..28:27) => scala/collection/immutable/List#map(). +[30:4..30:9) => local2 +[30:10..30:11) => scala/Int#`+`(+4). + +expect/Definitions.scala +________________________ + +Summary: +Schema => SemanticDB v4 +Uri => Definitions.scala +Text => empty +Language => Scala +Symbols => 10 entries +Occurrences => 11 entries + +Symbols: +a/Definitions. => final object Definitions +a/Definitions.D# => class D +a/Definitions.D#``(). => primary ctor +a/Definitions.E# => class E +a/Definitions.E#``(). => primary ctor +a/Definitions.``(). => primary ctor +a/Definitions.`b_=`(). => method b_= +a/Definitions.a. => val method a +a/Definitions.b(). => var method b +a/Definitions.c(). => method c + +Occurrences: +[0:8..0:9) => a/ +[1:7..1:18) => a/Definitions. +[2:2..2:2) => a/Definitions.``(). +[2:6..2:7) => a/Definitions.a. +[3:6..3:7) => a/Definitions.b(). +[3:6..3:9) => a/Definitions.`b_=`(). +[4:6..4:7) => a/Definitions.c(). +[5:2..5:2) => a/Definitions.D#``(). +[5:8..5:9) => a/Definitions.D# +[6:2..6:2) => a/Definitions.E#``(). +[6:8..6:9) => a/Definitions.E# + +expect/Empty.scala +__________________ + +Summary: +Schema => SemanticDB v4 +Uri => Empty.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 11 entries + +Symbols: +_empty_/A# => class A +_empty_/A#``(). => primary ctor +_empty_/A#b(). => method b +_empty_/B# => class B +_empty_/B#``(). => primary ctor +_empty_/B#a(). => method a + +Occurrences: +[0:0..0:0) => _empty_/ +[0:6..0:7) => _empty_/A# +[1:2..1:2) => _empty_/A#``(). +[1:6..1:7) => _empty_/A#b(). +[1:9..1:10) => _empty_/B# +[1:13..1:16) => scala/Predef.`???`(). +[4:6..4:7) => _empty_/B# +[5:2..5:2) => _empty_/B#``(). +[5:6..5:7) => _empty_/B#a(). +[5:9..5:10) => _empty_/A# +[5:13..5:16) => scala/Predef.`???`(). + +expect/EmptyObject.scala +________________________ + +Summary: +Schema => SemanticDB v4 +Uri => EmptyObject.scala +Text => empty +Language => Scala +Symbols => 2 entries +Occurrences => 3 entries + +Symbols: +example/EmptyObject. => final object EmptyObject +example/EmptyObject.``(). => primary ctor + +Occurrences: +[0:8..0:15) => example/ +[2:0..2:0) => example/EmptyObject.``(). +[2:7..2:18) => example/EmptyObject. + +expect/Enums.scala +__________________ + +Summary: +Schema => SemanticDB v4 +Uri => Enums.scala +Text => empty +Language => Scala +Symbols => 75 entries +Occurrences => 165 entries + +Symbols: +_empty_/Enums. => final object Enums +_empty_/Enums.Colour# => abstract sealed enum class Colour +_empty_/Enums.Colour#``(). => primary ctor +_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.``(). => primary ctor +_empty_/Enums.Maybe# => abstract sealed enum class Maybe +_empty_/Enums.Maybe#[A] => covariant typeparam A +_empty_/Enums.Maybe#``(). => primary ctor +_empty_/Enums.Maybe.Just# => final case enum class Just +_empty_/Enums.Maybe.Just#``(). => primary ctor +_empty_/Enums.Maybe.Just#value. => val method value +_empty_/Enums.Maybe.Just.``(). => primary ctor +_empty_/Enums.Maybe.None. => case val static enum method None +_empty_/Enums.Maybe.``(). => primary ctor +_empty_/Enums.Planet# => abstract sealed enum class Planet +_empty_/Enums.Planet#G. => final val method G +_empty_/Enums.Planet#``(). => primary ctor +_empty_/Enums.Planet#mass. => val method mass +_empty_/Enums.Planet#radius. => val method radius +_empty_/Enums.Planet#surfaceGravity(). => method surfaceGravity +_empty_/Enums.Planet#surfaceWeight(). => method surfaceWeight +_empty_/Enums.Planet#surfaceWeight().(otherMass) => val param otherMass +_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.``(). => primary ctor +_empty_/Enums.Tag# => abstract sealed enum class Tag +_empty_/Enums.Tag#[A] => typeparam A +_empty_/Enums.Tag#``(). => primary ctor +_empty_/Enums.Tag.BooleanTag. => case val static enum method BooleanTag +_empty_/Enums.Tag.IntTag. => case val static enum method IntTag +_empty_/Enums.Tag.``(). => primary ctor +_empty_/Enums.WeekDays# => abstract sealed enum class WeekDays +_empty_/Enums.WeekDays#``(). => primary ctor +_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.``(). => primary ctor +_empty_/Enums.``(). => primary ctor +_empty_/Enums.`=:=`# => abstract sealed enum class =:= +_empty_/Enums.`=:=`#[A] => typeparam A +_empty_/Enums.`=:=`#[B] => typeparam B +_empty_/Enums.`=:=`#``(). => primary ctor +_empty_/Enums.`=:=`.Refl# => final case enum class Refl +_empty_/Enums.`=:=`.Refl#[C] => typeparam C +_empty_/Enums.`=:=`.Refl#``(). => primary ctor +_empty_/Enums.`=:=`.Refl.``(). => primary ctor +_empty_/Enums.`=:=`.``(). => primary ctor +_empty_/Enums.unwrap(). => method unwrap +_empty_/Enums.unwrap().(ev) => implicit val param ev +_empty_/Enums.unwrap().(opt) => val param opt +_empty_/Enums.unwrap().[A] => typeparam A +_empty_/Enums.unwrap().[B] => typeparam B +local0 => primary ctor +local1 => primary ctor +local2 => primary ctor +local3 => primary ctor +local4 => primary ctor +local5 => primary ctor +local6 => primary ctor +local7 => primary ctor +local8 => primary ctor +local9 => primary ctor +local10 => primary ctor + +Occurrences: +[0:0..0:0) => _empty_/ +[0:7..0:12) => _empty_/Enums. +[1:2..1:2) => _empty_/Enums.``(). +[1:9..1:12) => _empty_/Enums.`=:=`. +[3:7..3:13) => _empty_/Enums.Colour# +[4:4..4:4) => _empty_/Enums.Colour#``(). +[4:4..4:4) => _empty_/Enums.Colour.``(). +[4:9..4:12) => _empty_/Enums.Colour.Red. +[4:9..4:9) => scala/runtime/EnumValues#``(). +[4:9..4:12) => _empty_/Enums.Colour.Red. +[4:14..4:19) => _empty_/Enums.Colour.Green. +[4:14..4:19) => _empty_/Enums.Colour.Green. +[4:21..4:25) => _empty_/Enums.Colour.Blue. +[4:21..4:25) => _empty_/Enums.Colour.Blue. +[6:7..6:15) => _empty_/Enums.WeekDays# +[7:4..7:4) => _empty_/Enums.WeekDays#``(). +[7:4..7:4) => _empty_/Enums.WeekDays.``(). +[7:4..7:4) => scala/runtime/EnumValues#``(). +[7:9..7:15) => _empty_/Enums.WeekDays.Monday. +[8:9..8:16) => _empty_/Enums.WeekDays.Tuesday. +[9:9..9:18) => _empty_/Enums.WeekDays.Wednesday. +[10:9..10:17) => _empty_/Enums.WeekDays.Thursday. +[11:9..11:15) => _empty_/Enums.WeekDays.Friday. +[12:9..12:17) => _empty_/Enums.WeekDays.Saturday. +[13:9..13:15) => _empty_/Enums.WeekDays.Sunday. +[15:7..15:12) => _empty_/Enums.Maybe# +[15:12..15:16) => _empty_/Enums.Maybe#``(). +[15:14..15:15) => _empty_/Enums.Maybe#[A] +[16:4..16:4) => _empty_/Enums.Maybe.``(). +[16:4..16:4) => _empty_/Enums.Maybe#``(). +[16:4..16:4) => _empty_/Enums.Maybe.Just.``(). +[16:9..16:13) => _empty_/Enums.Maybe.Just# +[16:13..16:23) => _empty_/Enums.Maybe.Just#``(). +[16:14..16:19) => _empty_/Enums.Maybe.Just#value. +[16:21..16:22) => _empty_/Enums.Maybe.Just#``().[A] +[17:4..17:4) => local0 +[17:4..17:4) => _empty_/Enums.Maybe#``(). +[17:9..17:13) => _empty_/Enums.Maybe.None. +[17:13..17:13) => local0 +[19:7..19:10) => _empty_/Enums.Tag# +[19:10..19:13) => _empty_/Enums.Tag#``(). +[19:11..19:12) => _empty_/Enums.Tag#[A] +[20:4..20:4) => _empty_/Enums.Tag.``(). +[20:9..20:15) => _empty_/Enums.Tag.IntTag. +[20:24..20:24) => local1 +[20:24..20:27) => _empty_/Enums.Tag# +[20:28..20:31) => scala/Int# +[20:32..20:32) => _empty_/Enums.Tag#``(). +[20:32..20:32) => local1 +[21:9..21:19) => _empty_/Enums.Tag.BooleanTag. +[21:28..21:28) => local2 +[21:28..21:31) => _empty_/Enums.Tag# +[21:32..21:39) => scala/Boolean# +[21:40..21:40) => _empty_/Enums.Tag#``(). +[21:40..21:40) => local2 +[23:7..23:10) => _empty_/Enums.`=:=`# +[23:10..23:16) => _empty_/Enums.`=:=`#``(). +[23:11..23:12) => _empty_/Enums.`=:=`#[A] +[23:14..23:15) => _empty_/Enums.`=:=`#[B] +[24:4..24:4) => _empty_/Enums.`=:=`.``(). +[24:4..24:4) => _empty_/Enums.`=:=`.Refl.``(). +[24:9..24:13) => _empty_/Enums.`=:=`.Refl# +[24:13..24:18) => _empty_/Enums.`=:=`.Refl#``(). +[24:14..24:15) => _empty_/Enums.`=:=`.Refl#[C] +[24:28..24:29) => _empty_/Enums.`=:=`.Refl#[C] +[24:30..24:33) => _empty_/Enums.`=:=`# +[24:34..24:35) => _empty_/Enums.`=:=`.Refl#[C] +[24:35..24:35) => _empty_/Enums.`=:=`#``(). +[26:6..26:12) => _empty_/Enums.unwrap(). +[26:13..26:14) => _empty_/Enums.unwrap().[A] +[26:15..26:16) => _empty_/Enums.unwrap().[B] +[26:18..26:21) => _empty_/Enums.unwrap().(opt) +[26:23..26:29) => scala/Option# +[26:30..26:31) => _empty_/Enums.unwrap().[A] +[26:40..26:42) => _empty_/Enums.unwrap().(ev) +[26:44..26:45) => _empty_/Enums.unwrap().[A] +[26:46..26:49) => _empty_/Enums.`=:=`# +[26:50..26:56) => scala/Option# +[26:57..26:58) => _empty_/Enums.unwrap().[B] +[26:62..26:68) => scala/Option# +[26:69..26:70) => _empty_/Enums.unwrap().[B] +[26:74..26:76) => _empty_/Enums.unwrap().(ev) +[27:9..27:13) => _empty_/Enums.`=:=`.Refl. +[27:19..27:22) => _empty_/Enums.unwrap().(opt) +[27:23..27:30) => scala/Option#flatMap(). +[27:31..27:39) => scala/Predef.identity(). +[27:40..27:46) => scala/Option# +[27:47..27:48) => _empty_/Enums.unwrap().[B] +[28:19..28:23) => scala/None. +[30:7..30:13) => _empty_/Enums.Planet# +[30:13..30:43) => _empty_/Enums.Planet#``(). +[30:14..30:18) => _empty_/Enums.Planet#mass. +[30:20..30:26) => scala/Double# +[30:28..30:34) => _empty_/Enums.Planet#radius. +[30:36..30:42) => scala/Double# +[30:52..30:56) => java/ +[30:57..30:61) => java/lang/ +[30:62..30:66) => java/lang/Enum# +[30:67..30:73) => _empty_/Enums.Planet# +[30:74..30:74) => java/lang/Enum#``(). +[31:22..31:23) => _empty_/Enums.Planet#G. +[32:8..32:22) => _empty_/Enums.Planet#surfaceGravity(). +[32:25..32:26) => _empty_/Enums.Planet#G. +[32:27..32:28) => scala/Double#`*`(+6). +[32:29..32:33) => _empty_/Enums.Planet#mass. +[32:34..32:35) => scala/Double#`/`(+6). +[32:37..32:43) => _empty_/Enums.Planet#radius. +[32:44..32:45) => scala/Double#`*`(+6). +[32:46..32:52) => _empty_/Enums.Planet#radius. +[33:8..33:21) => _empty_/Enums.Planet#surfaceWeight(). +[33:22..33:31) => _empty_/Enums.Planet#surfaceWeight().(otherMass) +[33:33..33:39) => scala/Double# +[33:43..33:52) => _empty_/Enums.Planet#surfaceWeight().(otherMass) +[33:53..33:54) => scala/Double#`*`(+6). +[33:55..33:69) => _empty_/Enums.Planet#surfaceGravity(). +[35:4..35:4) => _empty_/Enums.Planet.``(). +[35:9..35:16) => _empty_/Enums.Planet.Mercury. +[35:25..35:25) => scala/runtime/EnumValues#``(). +[35:25..35:25) => local3 +[35:25..35:31) => _empty_/Enums.Planet# +[35:31..35:31) => _empty_/Enums.Planet#``(). +[35:52..35:52) => scala/runtime/EnumValues#register(). +[35:52..35:52) => local3 +[36:9..36:14) => _empty_/Enums.Planet.Venus. +[36:25..36:25) => local4 +[36:25..36:31) => _empty_/Enums.Planet# +[36:31..36:31) => _empty_/Enums.Planet#``(). +[36:52..36:52) => scala/runtime/EnumValues#register(). +[36:52..36:52) => local4 +[37:9..37:14) => _empty_/Enums.Planet.Earth. +[37:25..37:25) => local5 +[37:25..37:31) => _empty_/Enums.Planet# +[37:31..37:31) => _empty_/Enums.Planet#``(). +[37:53..37:53) => scala/runtime/EnumValues#register(). +[37:53..37:53) => local5 +[38:9..38:13) => _empty_/Enums.Planet.Mars. +[38:25..38:25) => local6 +[38:25..38:31) => _empty_/Enums.Planet# +[38:31..38:31) => _empty_/Enums.Planet#``(). +[38:52..38:52) => scala/runtime/EnumValues#register(). +[38:52..38:52) => local6 +[39:9..39:16) => _empty_/Enums.Planet.Jupiter. +[39:25..39:25) => local7 +[39:25..39:31) => _empty_/Enums.Planet# +[39:31..39:31) => _empty_/Enums.Planet#``(). +[39:52..39:52) => scala/runtime/EnumValues#register(). +[39:52..39:52) => local7 +[40:9..40:15) => _empty_/Enums.Planet.Saturn. +[40:25..40:25) => local8 +[40:25..40:31) => _empty_/Enums.Planet# +[40:31..40:31) => _empty_/Enums.Planet#``(). +[40:52..40:52) => scala/runtime/EnumValues#register(). +[40:52..40:52) => local8 +[41:9..41:15) => _empty_/Enums.Planet.Uranus. +[41:25..41:25) => local9 +[41:25..41:31) => _empty_/Enums.Planet# +[41:31..41:31) => _empty_/Enums.Planet#``(). +[41:52..41:52) => scala/runtime/EnumValues#register(). +[41:52..41:52) => local9 +[42:9..42:16) => _empty_/Enums.Planet.Neptune. +[42:25..42:25) => local10 +[42:25..42:31) => _empty_/Enums.Planet# +[42:31..42:31) => _empty_/Enums.Planet#``(). +[42:52..42:52) => scala/runtime/EnumValues#register(). +[42:52..42:52) => local10 + +expect/EtaExpansion.scala +_________________________ + +Summary: +Schema => SemanticDB v4 +Uri => EtaExpansion.scala +Text => empty +Language => Scala +Symbols => 2 entries +Occurrences => 10 entries + +Symbols: +example/EtaExpansion# => class EtaExpansion +example/EtaExpansion#``(). => primary ctor + +Occurrences: +[0:8..0:15) => example/ +[2:6..2:18) => example/EtaExpansion# +[3:2..3:2) => example/EtaExpansion#``(). +[3:2..3:6) => scala/Some. +[3:10..3:13) => scala/Option#map(). +[3:14..3:22) => scala/Predef.identity(). +[4:2..4:6) => scala/package.List. +[4:6..4:6) => scala/collection/IterableFactory#apply(). +[4:10..4:18) => scala/collection/LinearSeqOps#foldLeft(). +[4:25..4:26) => java/lang/String#`+`(). + +expect/Example.scala +____________________ + +Summary: +Schema => SemanticDB v4 +Uri => Example.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 28 entries + +Symbols: +example/Example. => final object Example +example/Example.``(). => primary ctor +example/Example.main(). => method main +example/Example.main().(args) => val param args +example/Example.x. => val method x +local0 => selfparam self + +Occurrences: +[0:8..0:15) => example/ +[2:7..2:12) => scala/ +[2:13..2:23) => scala/concurrent/ +[2:24..2:30) => scala/concurrent/Future. +[2:24..2:30) => scala/concurrent/Future# +[4:7..4:14) => example/Example. +[4:17..4:17) => example/Example.``(). +[4:17..4:21) => local0 +[4:17..4:17) => example/Example. +[5:6..5:11) => scala/ +[5:12..5:22) => scala/collection/ +[5:23..5:30) => scala/collection/mutable/ +[5:31..5:36) => scala/collection/mutable/Stack# +[5:37..5:40) => scala/Int# +[5:41..5:41) => scala/collection/mutable/Stack#``(+1). +[6:6..6:10) => example/Example.main(). +[6:11..6:15) => example/Example.main().(args) +[6:17..6:22) => scala/Array# +[6:23..6:29) => scala/Predef.String# +[6:33..6:37) => scala/Unit# +[7:4..7:11) => scala/Predef.println(+1). +[9:6..9:7) => example/Example.x. +[9:10..9:15) => scala/ +[9:16..9:23) => scala/reflect/ +[9:24..9:32) => scala/reflect/package.classTag(). +[9:33..9:36) => scala/Int# +[9:37..9:37) => scala/reflect/ClassTag.apply(). +[9:37..9:37) => java/lang/Integer#TYPE. + +expect/Flags.scala +__________________ + +Summary: +Schema => SemanticDB v4 +Uri => Flags.scala +Text => empty +Language => Scala +Symbols => 46 entries +Occurrences => 86 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#`z_=`(). => method z_= +flags/p/package.AA#x. => val method x +flags/p/package.AA#y. => val method y +flags/p/package.AA#z(). => var method z +flags/p/package.C# => abstract class C +flags/p/package.C#[T] => covariant typeparam T +flags/p/package.C#[U] => contravariant typeparam U +flags/p/package.C#[V] => typeparam V +flags/p/package.C#``(). => primary ctor +flags/p/package.C#``(+1). => ctor +flags/p/package.C#``(+1).[T] => typeparam T +flags/p/package.C#``(+1).[U] => typeparam U +flags/p/package.C#``(+1).[V] => typeparam V +flags/p/package.C#w(). => method w +flags/p/package.C#x. => val method x +flags/p/package.C#y. => val method y +flags/p/package.C#z. => val method z +flags/p/package.S# => class S +flags/p/package.S#[T] => typeparam T +flags/p/package.S#``(). => primary ctor +flags/p/package.T1# => type T1 +flags/p/package.T2# => type T2 +flags/p/package.T2#[T] => typeparam T +flags/p/package.U# => type U +flags/p/package.V# => type V +flags/p/package.X. => final case object X +flags/p/package.X.``(). => primary ctor +flags/p/package.Y# => final class Y +flags/p/package.Y#``(). => primary ctor +flags/p/package.Z# => sealed class Z +flags/p/package.Z#``(). => primary ctor +flags/p/package.``(). => primary ctor +flags/p/package.`y_=`(). => method y_= +flags/p/package.m(). => method m +flags/p/package.m().[TT] => typeparam TT +flags/p/package.x. => lazy val method x +flags/p/package.xs1. => val method xs1 +flags/p/package.y(). => implicit var method y +flags/p/package.z(). => method z +flags/p/package.z().(pp) => val param pp +local0 => val local xs1 +local1 => val local xs2 +local2 => case val method t + +Occurrences: +[0:8..0:13) => flags/ +[2:7..2:12) => scala/ +[2:13..2:21) => scalaShadowing/language. +[2:22..2:34) => scalaShadowing/language.experimental. +[2:35..2:41) => scalaShadowing/language.experimental.macros. +[4:0..4:0) => flags/p/ +[4:15..5:3) => flags/p/package. +[5:2..5:2) => flags/p/package.``(). +[5:2..5:3) => flags/p/ +[5:19..5:20) => flags/p/package.x. +[6:25..6:26) => flags/p/package.y(). +[6:25..6:28) => flags/p/package.`y_=`(). +[6:28..6:31) => scala/Int# +[7:6..7:7) => flags/p/package.z(). +[7:8..7:10) => flags/p/package.z().(pp) +[7:12..7:15) => scala/Int# +[8:6..8:7) => flags/p/package.m(). +[8:8..8:10) => flags/p/package.m().[TT] +[8:13..8:16) => scala/Int# +[8:16..8:16) => scala/Predef.`???`(). +[9:17..9:18) => flags/p/package.C# +[9:18..9:47) => flags/p/package.C#``(). +[9:20..9:21) => flags/p/package.C#[T] +[9:20..9:21) => flags/p/package.C#``(+1).[T] +[9:24..9:25) => flags/p/package.C#[U] +[9:24..9:25) => flags/p/package.C#``(+1).[U] +[9:27..9:28) => flags/p/package.C#[V] +[9:27..9:28) => flags/p/package.C#``(+1).[V] +[9:30..9:31) => flags/p/package.C#x. +[9:33..9:34) => flags/p/package.C#``().[T] +[9:36..9:37) => flags/p/package.C#y. +[9:39..9:40) => flags/p/package.C#``().[U] +[9:42..9:43) => flags/p/package.C#z. +[9:45..9:46) => flags/p/package.C#``().[V] +[10:8..10:14) => flags/p/package.C#``(+1). +[10:22..10:22) => flags/p/package.C#``(). +[10:22..10:25) => scala/Predef.`???`(). +[10:27..10:30) => scala/Predef.`???`(). +[10:32..10:35) => scala/Predef.`???`(). +[11:8..11:9) => flags/p/package.C#w(). +[11:11..11:14) => scala/Int# +[13:7..13:9) => flags/p/package.T1# +[13:12..13:15) => scala/Int# +[14:7..14:9) => flags/p/package.T2# +[14:10..14:11) => flags/p/package.T2#[T] +[14:15..14:16) => flags/p/package.S# +[14:17..14:18) => flags/p/package.T2#[T] +[15:7..15:8) => flags/p/package.U# +[15:12..15:15) => scala/Int# +[16:7..16:8) => flags/p/package.V# +[16:12..16:15) => scala/Int# +[17:2..17:2) => flags/p/package.X.``(). +[17:14..17:15) => flags/p/package.X. +[18:2..18:2) => flags/p/package.Y#``(). +[18:14..18:15) => flags/p/package.Y# +[19:2..19:2) => flags/p/package.Z#``(). +[19:15..19:16) => flags/p/package.Z# +[20:8..20:10) => flags/p/package.AA# +[20:10..20:42) => flags/p/package.AA#``(). +[20:11..20:12) => flags/p/package.AA#x. +[20:14..20:17) => scala/Int# +[20:23..20:24) => flags/p/package.AA#y. +[20:26..20:29) => scala/Int# +[20:35..20:36) => flags/p/package.AA#z(). +[20:35..20:38) => flags/p/package.AA#`z_=`(). +[20:38..20:41) => scala/Int# +[21:8..21:9) => flags/p/package.S# +[21:9..21:25) => flags/p/package.S#``(). +[21:11..21:22) => scala/specialized# +[21:22..21:22) => scala/specialized#``(+2). +[21:23..21:24) => flags/p/package.S#[T] +[22:6..22:10) => scala/package.List. +[22:10..22:10) => scala/collection/SeqFactory#unapplySeq(). +[22:11..22:14) => flags/p/package.xs1. +[22:11..22:14) => local0 +[22:15..22:15) => local0 +[22:18..22:21) => scala/Predef.`???`(). +[23:2..23:5) => scala/Predef.`???`(). +[23:19..23:23) => scala/package.List. +[23:23..23:23) => scala/collection/SeqFactory#unapplySeq(). +[23:24..23:27) => local1 +[23:32..23:35) => scala/Predef.`???`(). +[24:2..24:5) => scala/Predef.`???`(). +[24:22..24:26) => scala/package.List# +[24:27..24:28) => local2 +[24:33..24:36) => scala/Predef.`???`(). + +expect/ForComprehension.scala +_____________________________ + +Summary: +Schema => SemanticDB v4 +Uri => ForComprehension.scala +Text => empty +Language => Scala +Symbols => 2 entries +Occurrences => 63 entries + +Symbols: +example/ForComprehension# => class ForComprehension +example/ForComprehension#``(). => primary ctor + +Occurrences: +[0:8..0:15) => example/ +[2:6..2:22) => example/ForComprehension# +[3:2..3:2) => example/ForComprehension#``(). +[4:9..4:13) => scala/package.List. +[4:13..4:13) => scala/collection/IterableFactory#apply(). +[4:16..4:16) => scala/collection/immutable/List#flatMap(). +[5:4..5:5) => local0 +[5:9..5:13) => scala/package.List. +[5:13..5:13) => scala/collection/IterableFactory#apply(). +[5:16..5:16) => scala/collection/IterableOps#withFilter(). +[6:7..6:8) => local0 +[6:9..6:10) => scala/Int#`>`(+3). +[6:12..6:12) => scala/collection/WithFilter#map(). +[7:4..7:5) => local2 +[7:8..7:9) => local1 +[7:10..7:11) => scala/Int#`+`(+4). +[7:12..7:13) => local0 +[7:13..7:13) => scala/collection/immutable/List#map(). +[8:11..8:12) => local1 +[8:14..8:15) => local0 +[8:17..8:18) => local2 +[10:9..10:13) => scala/package.List. +[10:13..10:13) => scala/collection/IterableFactory#apply(). +[10:16..10:16) => scala/collection/immutable/List#flatMap(). +[11:9..11:13) => scala/package.List. +[11:13..11:13) => scala/collection/IterableFactory#apply(). +[11:14..11:15) => local3 +[11:16..11:16) => scala/collection/IterableOps#withFilter(). +[13:6..13:7) => local3 +[14:6..14:7) => local4 +[15:6..15:8) => scala/Any#`==`(). +[15:15..15:15) => scala/collection/WithFilter#flatMap(). +[19:9..19:13) => scala/package.List. +[19:13..19:13) => scala/collection/IterableFactory#apply(). +[19:15..19:16) => local3 +[19:18..19:19) => local4 +[19:21..19:21) => scala/collection/WithFilter#withFilter(). +[19:21..19:21) => scala/collection/IterableOps#withFilter(). +[21:6..21:7) => local3 +[22:6..22:7) => local4 +[23:6..23:7) => local5 +[24:6..24:7) => local6 +[25:6..25:8) => scala/Any#`==`(). +[25:21..25:21) => scala/collection/WithFilter#map(). +[26:4..26:5) => local7 +[27:6..27:7) => local3 +[28:6..28:7) => local4 +[29:6..29:7) => local5 +[30:6..30:7) => local6 +[31:5..31:5) => scala/collection/IterableOps#withFilter(). +[32:7..32:8) => local7 +[32:9..32:11) => scala/Any#`==`(). +[32:24..32:24) => scala/collection/WithFilter#flatMap(). +[33:9..33:13) => scala/package.List. +[33:13..33:13) => scala/collection/IterableFactory#apply(). +[33:14..33:15) => local7 +[33:16..33:16) => scala/collection/immutable/List#map(). +[36:6..36:7) => local3 +[37:6..37:7) => local4 +[38:6..38:7) => local5 +[39:6..39:7) => local6 +[40:6..40:7) => local7 +[41:6..41:7) => local8 + +expect/Givens.scala +___________________ + +Summary: +Schema => SemanticDB v4 +Uri => Givens.scala +Text => empty +Language => Scala +Symbols => 25 entries +Occurrences => 55 entries + +Symbols: +a/b/Givens. => final object Givens +a/b/Givens.Monoid# => class Monoid +a/b/Givens.Monoid#[A] => typeparam A +a/b/Givens.Monoid#``(). => primary ctor +a/b/Givens.Monoid#combine(). => method combine +a/b/Givens.Monoid#combine().(x) => val param x +a/b/Givens.Monoid#combine().(y) => val param y +a/b/Givens.Monoid#empty(). => method empty +a/b/Givens.``(). => primary ctor +a/b/Givens.foo(). => method foo +a/b/Givens.foo().(A) => implicit val param A +a/b/Givens.foo().[A] => typeparam A +a/b/Givens.given_Monoid_String. => final object given_Monoid_String +a/b/Givens.given_Monoid_String.``(). => primary ctor +a/b/Givens.given_Monoid_String.combine(). => method combine +a/b/Givens.given_Monoid_String.combine().(x) => val param x +a/b/Givens.given_Monoid_String.combine().(y) => val param y +a/b/Givens.given_Monoid_String.empty(). => method empty +a/b/Givens.given_sayHello_of_A. => final object given_sayHello_of_A +a/b/Givens.given_sayHello_of_A.``(). => primary ctor +a/b/Givens.given_sayHello_of_A.sayHello(). => method sayHello +a/b/Givens.given_sayHello_of_A.sayHello().(any) => val param any +a/b/Givens.given_sayHello_of_A.sayHello().[A] => typeparam A +a/b/Givens.hello1. => val method hello1 +a/b/Givens.int2String(). => final implicit macro int2String + +Occurrences: +[0:8..0:9) => a/ +[1:8..1:9) => a/b/ +[3:7..3:13) => a/b/Givens. +[5:2..5:2) => a/b/Givens.``(). +[5:8..6:6) => a/b/Givens.given_sayHello_of_A. +[5:10..5:11) => a/b/Givens.given_sayHello_of_A.sayHello().[A] +[5:13..5:16) => a/b/Givens.given_sayHello_of_A.sayHello().(any) +[5:18..5:19) => a/b/Givens.given_sayHello_of_A.sayHello().[A] +[6:4..6:4) => a/b/Givens.given_sayHello_of_A.``(). +[6:8..6:16) => a/b/Givens.given_sayHello_of_A.sayHello(). +[6:34..6:37) => a/b/Givens.given_sayHello_of_A.sayHello().(any) +[6:37..6:37) => scala/StringContext#s(). +[8:6..8:12) => a/b/Givens.hello1. +[8:15..8:15) => a/b/Givens.given_sayHello_of_A.sayHello(). +[10:8..10:14) => a/b/Givens.Monoid# +[10:14..10:17) => a/b/Givens.Monoid#``(). +[10:15..10:16) => a/b/Givens.Monoid#[A] +[11:8..11:13) => a/b/Givens.Monoid#empty(). +[11:15..11:16) => a/b/Givens.Monoid#[A] +[12:8..12:15) => a/b/Givens.Monoid#combine(). +[12:9..12:10) => a/b/Givens.Monoid#combine().(x) +[12:12..12:13) => a/b/Givens.Monoid#[A] +[12:24..12:25) => a/b/Givens.Monoid#combine().(y) +[12:27..12:28) => a/b/Givens.Monoid#[A] +[12:31..12:32) => a/b/Givens.Monoid#[A] +[14:8..15:4) => a/b/Givens.given_Monoid_String. +[14:8..14:8) => a/b/Givens.given_Monoid_String.``(). +[14:8..14:14) => a/b/Givens.Monoid# +[14:15..14:21) => scala/Predef.String# +[15:8..15:13) => a/b/Givens.given_Monoid_String.empty(). +[16:8..16:15) => a/b/Givens.given_Monoid_String.combine(). +[16:9..16:10) => a/b/Givens.given_Monoid_String.combine().(x) +[16:12..16:18) => scala/Predef.String# +[16:29..16:30) => a/b/Givens.given_Monoid_String.combine().(y) +[16:32..16:38) => scala/Predef.String# +[16:42..16:43) => a/b/Givens.given_Monoid_String.combine().(x) +[16:44..16:45) => java/lang/String#`+`(). +[16:46..16:47) => a/b/Givens.given_Monoid_String.combine().(y) +[18:15..18:25) => a/b/Givens.int2String(). +[18:27..18:37) => scala/Conversion# +[18:38..18:41) => scala/Int# +[18:43..18:49) => scala/Predef.String# +[18:55..18:63) => scala/Any#toString(). +[20:6..20:9) => a/b/Givens.foo(). +[20:10..20:11) => a/b/Givens.foo().[A] +[20:19..20:20) => a/b/Givens.foo().(A) +[20:22..20:28) => a/b/Givens.Monoid# +[20:29..20:30) => a/b/Givens.foo().[A] +[20:34..20:35) => a/b/Givens.foo().[A] +[20:38..20:39) => a/b/Givens.foo().(A) +[20:40..20:47) => a/b/Givens.Monoid#combine(). +[20:48..20:49) => a/b/Givens.foo().(A) +[20:50..20:55) => a/b/Givens.Monoid#empty(). +[20:57..20:58) => a/b/Givens.foo().(A) +[20:59..20:64) => a/b/Givens.Monoid#empty(). + +expect/ImplicitConversion.scala +_______________________________ + +Summary: +Schema => SemanticDB v4 +Uri => ImplicitConversion.scala +Text => empty +Language => Scala +Symbols => 20 entries +Occurrences => 60 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) => val param string +example/ImplicitConversion#tuple. => val method tuple +example/ImplicitConversion#x. => val method x +example/ImplicitConversion. => final object ImplicitConversion +example/ImplicitConversion.``(). => primary ctor +example/ImplicitConversion.newAny2stringadd# => final class newAny2stringadd +example/ImplicitConversion.newAny2stringadd#[A] => typeparam A +example/ImplicitConversion.newAny2stringadd#`+`(). => method + +example/ImplicitConversion.newAny2stringadd#`+`().(other) => val param other +example/ImplicitConversion.newAny2stringadd#``(). => primary ctor +example/ImplicitConversion.newAny2stringadd#self. => val method self +example/ImplicitConversion.newAny2stringadd.``(). => primary ctor + +Occurrences: +[0:8..0:15) => example/ +[2:7..2:12) => scala/ +[2:13..2:21) => scalaShadowing/language. +[2:22..2:41) => scalaShadowing/language.implicitConversions. +[4:6..4:24) => example/ImplicitConversion# +[5:2..5:2) => example/ImplicitConversion#``(). +[5:9..5:27) => example/ImplicitConversion. +[6:15..6:28) => example/ImplicitConversion#string2Number(). +[7:6..7:12) => example/ImplicitConversion#string2Number().(string) +[7:14..7:20) => scala/Predef.String# +[8:5..8:8) => scala/Int# +[9:6..9:13) => example/ImplicitConversion#message. +[10:6..10:12) => example/ImplicitConversion#number. +[11:6..11:11) => example/ImplicitConversion#tuple. +[12:6..12:10) => example/ImplicitConversion#char. +[12:12..12:16) => scala/Char# +[15:2..15:2) => scala/Predef.augmentString(). +[15:2..15:9) => example/ImplicitConversion#message. +[16:5..16:16) => scala/collection/StringOps#stripSuffix(). +[17:2..17:7) => example/ImplicitConversion#tuple. +[17:8..17:9) => example/ImplicitConversion.newAny2stringadd#`+`(). +[20:6..20:7) => example/ImplicitConversion#x. +[20:9..20:12) => scala/Int# +[20:15..20:15) => example/ImplicitConversion#string2Number(). +[20:15..20:22) => example/ImplicitConversion#message. +[23:11..23:18) => example/ImplicitConversion#message. +[23:20..23:26) => example/ImplicitConversion#number. +[23:26..23:26) => scala/StringContext#s(). +[24:2..24:2) => scala/Predef.augmentString(). +[25:7..25:14) => example/ImplicitConversion#message. +[26:7..26:13) => example/ImplicitConversion#number. +[26:13..26:13) => scala/StringContext#s(). +[26:17..26:28) => scala/collection/StringOps#stripMargin(+1). +[28:6..28:7) => example/ImplicitConversion#a. +[28:9..28:12) => scala/Int# +[28:15..28:15) => scala/Char.char2int(). +[28:15..28:19) => example/ImplicitConversion#char. +[29:6..29:7) => example/ImplicitConversion#b. +[29:9..29:13) => scala/Long# +[29:16..29:16) => scala/Char.char2long(). +[29:16..29:20) => example/ImplicitConversion#char. +[32:7..32:25) => example/ImplicitConversion. +[33:2..33:2) => example/ImplicitConversion.``(). +[33:2..33:2) => example/ImplicitConversion.newAny2stringadd.``(). +[33:23..33:39) => example/ImplicitConversion.newAny2stringadd# +[33:39..33:63) => example/ImplicitConversion.newAny2stringadd#``(). +[33:40..33:41) => example/ImplicitConversion.newAny2stringadd#[A] +[33:55..33:59) => example/ImplicitConversion.newAny2stringadd#self. +[33:61..33:62) => example/ImplicitConversion.newAny2stringadd#``().[A] +[33:72..33:78) => scala/AnyVal# +[33:78..33:78) => scala/AnyVal#``(). +[34:8..34:9) => example/ImplicitConversion.newAny2stringadd#`+`(). +[34:10..34:15) => example/ImplicitConversion.newAny2stringadd#`+`().(other) +[34:17..34:23) => scala/Predef.String# +[34:26..34:32) => scala/Predef.String# +[34:35..34:41) => java/lang/String# +[34:42..34:49) => java/lang/String#valueOf(). +[34:50..34:54) => example/ImplicitConversion.newAny2stringadd#self. +[34:56..34:57) => java/lang/String#`+`(). +[34:58..34:63) => example/ImplicitConversion.newAny2stringadd#`+`().(other) + +expect/Imports.scala +____________________ + +Summary: +Schema => SemanticDB v4 +Uri => Imports.scala +Text => empty +Language => Scala +Symbols => 0 entries +Occurrences => 5 entries + +Symbols: + +Occurrences: +[0:0..0:0) => _empty_/ +[0:7..0:12) => scala/ +[0:13..0:17) => scala/util/ +[0:18..0:25) => scala/util/control/ +[0:26..0:34) => scala/util/control/NonFatal. + +expect/InstrumentTyper.scala +____________________________ + +Summary: +Schema => SemanticDB v4 +Uri => InstrumentTyper.scala +Text => empty +Language => Scala +Symbols => 8 entries +Occurrences => 54 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) => val param x +local0 => selfparam self + +Occurrences: +[0:8..0:15) => example/ +[2:7..2:12) => scala/ +[2:13..2:23) => scala/annotation/ +[2:24..2:28) => scala/annotation/meta/ +[2:29..2:34) => scala/annotation/meta/param. +[3:7..3:12) => scala/ +[3:13..3:21) => scalaShadowing/language. +[3:22..3:34) => scalaShadowing/language.existentials. +[4:7..4:12) => scala/ +[4:13..4:21) => scalaShadowing/language. +[4:22..4:33) => scalaShadowing/language.higherKinds. +[5:7..5:12) => types/ +[5:13..5:17) => types/Test. +[7:6..7:21) => example/InstrumentTyper# +[7:24..7:24) => example/InstrumentTyper#``(). +[7:24..7:28) => local0 +[7:30..7:36) => scala/AnyRef# +[8:6..8:9) => example/InstrumentTyper#all(). +[8:12..8:16) => scala/package.List. +[8:16..8:16) => scala/collection/IterableFactory#apply(). +[9:4..9:11) => types/Test.Literal. +[9:12..9:15) => types/Test.Literal.int. +[10:4..10:11) => types/Test.Literal. +[10:12..10:16) => types/Test.Literal.long. +[11:4..11:11) => types/Test.Literal. +[11:12..11:17) => types/Test.Literal.float. +[12:4..12:11) => types/Test.Literal. +[12:12..12:18) => types/Test.Literal.double. +[13:4..13:11) => types/Test.Literal. +[13:12..13:15) => types/Test.Literal.nil. +[14:4..14:11) => types/Test.Literal. +[14:12..14:16) => types/Test.Literal.char. +[15:4..15:11) => types/Test.Literal. +[15:12..15:18) => types/Test.Literal.string. +[16:4..16:11) => types/Test.Literal. +[16:12..16:16) => types/Test.Literal.bool. +[17:4..17:11) => types/Test.Literal. +[17:12..17:16) => types/Test.Literal.unit. +[18:4..18:11) => types/Test.Literal. +[18:12..18:20) => types/Test.Literal.javaEnum. +[19:4..19:11) => types/Test.Literal. +[19:12..19:19) => types/Test.Literal.clazzOf. +[20:4..20:8) => scala/package.List. +[20:8..20:8) => scala/collection/IterableFactory#apply(). +[22:7..22:20) => example/InstrumentTyper#AnnotatedType# +[22:23..22:26) => scala/Int# +[23:6..23:19) => example/InstrumentTyper#singletonType(). +[23:20..23:21) => example/InstrumentTyper#singletonType().(x) +[23:23..23:29) => scala/Predef. +[23:38..23:41) => scala/Predef.`???`(). +[24:12..24:19) => example/InstrumentTyper#clazzOf. +[24:22..24:29) => scala/Predef.classOf(). +[24:30..24:36) => scala/Option# +[24:37..24:40) => scala/Int# + +expect/Issue1749.scala +______________________ + +Summary: +Schema => SemanticDB v4 +Uri => Issue1749.scala +Text => empty +Language => Scala +Symbols => 7 entries +Occurrences => 28 entries + +Symbols: +example/Issue1749# => class Issue1749 +example/Issue1749#``(). => primary ctor +example/Issue1749#x1. => val method x1 +example/Issue1749#x2. => val method x2 +example/Issue1854# => class Issue1854 +example/Issue1854#``(). => primary ctor +example/Issue1854#map. => val method map + +Occurrences: +[1:8..1:15) => example/ +[3:7..3:12) => scala/ +[3:13..3:17) => scala/math/ +[3:18..3:25) => scala/math/Ordered. +[3:26..3:43) => scala/math/Ordered.orderingToOrdered(). +[5:6..5:15) => example/Issue1749# +[6:2..6:2) => example/Issue1749#``(). +[6:6..6:8) => example/Issue1749#x1. +[7:6..7:8) => example/Issue1749#x2. +[8:2..8:2) => scala/math/Ordered.orderingToOrdered(). +[8:3..8:5) => example/Issue1749#x1. +[8:7..8:9) => example/Issue1749#x1. +[8:10..8:10) => scala/math/Ordering.Tuple2(). +[8:10..8:10) => scala/math/Ordering.Int. +[9:5..9:12) => scala/math/Ordered#compare(). +[9:14..9:16) => example/Issue1749#x2. +[9:18..9:20) => example/Issue1749#x2. +[12:6..12:15) => example/Issue1854# +[13:2..13:2) => example/Issue1854#``(). +[13:6..13:9) => example/Issue1854#map. +[13:12..13:22) => scala/collection/ +[13:23..13:30) => scala/collection/mutable/ +[13:31..13:34) => scala/collection/mutable/Map. +[13:35..13:40) => scala/collection/MapFactory.Delegate#empty(). +[13:41..13:47) => scala/Predef.String# +[13:49..13:55) => scala/Predef.String# +[14:2..14:5) => example/Issue1854#map. +[14:5..14:5) => scala/collection/mutable/MapOps#update(). + +expect/Local.scala +__________________ + +Summary: +Schema => SemanticDB v4 +Uri => Local.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 11 entries + +Symbols: +example/Local# => class Local +example/Local#``(). => primary ctor +example/Local#a(). => method a +local0 => local id +local1 => typeparam A +local2 => val param a + +Occurrences: +[0:8..0:15) => example/ +[2:6..2:11) => example/Local# +[3:2..3:2) => example/Local#``(). +[3:6..3:7) => example/Local#a(). +[4:8..4:10) => local0 +[4:11..4:12) => local1 +[4:14..4:15) => local2 +[4:17..4:18) => local1 +[4:21..4:22) => local1 +[4:25..4:26) => local2 +[5:4..5:6) => local0 + +expect/Locals.scala +___________________ + +Summary: +Schema => SemanticDB v4 +Uri => Locals.scala +Text => empty +Language => Scala +Symbols => 4 entries +Occurrences => 8 entries + +Symbols: +local0 => val local x +locals/Test. => final object Test +locals/Test.``(). => primary ctor +locals/Test.xs. => val method xs + +Occurrences: +[0:8..0:14) => locals/ +[2:7..2:11) => locals/Test. +[3:2..3:2) => locals/Test.``(). +[3:6..3:8) => locals/Test.xs. +[4:8..4:9) => local0 +[5:4..5:8) => scala/package.List. +[5:8..5:8) => scala/collection/IterableFactory#apply(). +[5:9..5:10) => local0 + +expect/MetacJava.scala +______________________ + +Summary: +Schema => SemanticDB v4 +Uri => MetacJava.scala +Text => empty +Language => Scala +Symbols => 10 entries +Occurrences => 72 entries + +Symbols: +example/MetacJava# => class MetacJava +example/MetacJava#``(). => primary ctor +example/MetacJava#coin. => val method coin +example/MetacJava#entry. => val method entry +example/MetacJava#inner. => val method inner +example/MetacJava#interface. => val method interface +example/MetacJava#nonStatic. => val method nonStatic +example/MetacJava#overload1. => val method overload1 +example/MetacJava#overload2. => val method overload2 +example/MetacJava#staticInner. => val method staticInner + +Occurrences: +[0:8..0:15) => example/ +[2:7..2:10) => com/ +[2:11..2:17) => com/javacp/ +[4:6..4:15) => example/MetacJava# +[5:2..5:2) => example/MetacJava#``(). +[5:2..5:8) => com/javacp/ +[5:9..5:18) => com/javacp/MetacJava# +[5:19..5:30) => com/javacp/MetacJava#StaticInner# +[5:31..5:39) => com/javacp/MetacJava#StaticInner#isStatic(). +[6:6..6:12) => com/javacp/ +[6:13..6:22) => com/javacp/MetacJava# +[6:23..6:34) => com/javacp/MetacJava#StaticInner# +[6:34..6:34) => com/javacp/MetacJava#StaticInner#``(). +[6:37..6:48) => com/javacp/MetacJava#StaticInner#isNotStatic(). +[7:6..7:11) => example/MetacJava#inner. +[7:18..7:24) => com/javacp/ +[7:25..7:34) => com/javacp/MetacJava# +[7:34..7:34) => com/javacp/MetacJava#``(). +[8:6..8:15) => example/MetacJava#overload1. +[8:22..8:27) => example/MetacJava#inner. +[8:28..8:37) => com/javacp/MetacJava#Overload1# +[8:37..8:37) => com/javacp/MetacJava#Overload1#``(). +[9:6..9:15) => example/MetacJava#overload2. +[9:22..9:27) => example/MetacJava#inner. +[9:28..9:37) => com/javacp/MetacJava#Overload2# +[9:37..9:37) => com/javacp/MetacJava#Overload2#``(). +[10:2..10:7) => example/MetacJava#inner. +[10:8..10:16) => com/javacp/MetacJava#overload(). +[10:21..10:30) => example/MetacJava#overload1. +[10:31..10:32) => com/javacp/MetacJava#Overload1#A# +[10:32..10:32) => com/javacp/MetacJava#Overload1#A#``(). +[11:2..11:7) => example/MetacJava#inner. +[11:8..11:16) => com/javacp/MetacJava#overload(+1). +[11:21..11:30) => example/MetacJava#overload2. +[11:31..11:32) => com/javacp/MetacJava#Overload2#A# +[11:32..11:32) => com/javacp/MetacJava#Overload2#A#``(). +[12:6..12:17) => example/MetacJava#staticInner. +[12:24..12:30) => com/javacp/ +[12:31..12:40) => com/javacp/MetacJava# +[12:41..12:52) => com/javacp/MetacJava#StaticInner# +[12:52..12:52) => com/javacp/MetacJava#StaticInner#``(). +[13:6..13:15) => example/MetacJava#nonStatic. +[13:22..13:33) => example/MetacJava#staticInner. +[13:34..13:43) => com/javacp/MetacJava#StaticInner#NonStatic# +[13:43..13:43) => com/javacp/MetacJava#StaticInner#NonStatic#``(). +[14:2..14:11) => example/MetacJava#nonStatic. +[14:12..14:18) => com/javacp/MetacJava#StaticInner#NonStatic#method(). +[14:19..14:28) => example/MetacJava#nonStatic. +[15:2..15:8) => com/javacp/ +[15:9..15:18) => com/javacp/MetacJava# +[15:19..15:27) => com/javacp/MetacJava#overload(+2). +[15:32..15:38) => com/javacp/ +[15:39..15:48) => com/javacp/MetacJava# +[15:49..15:58) => com/javacp/MetacJava#Overload3# +[15:59..15:60) => com/javacp/MetacJava#Overload3#A# +[15:60..15:60) => com/javacp/MetacJava#Overload3#A#``(). +[16:6..16:15) => example/MetacJava#interface. +[16:17..16:23) => com/javacp/ +[16:24..16:33) => com/javacp/Interface# +[17:6..17:10) => example/MetacJava#coin. +[17:12..17:18) => com/javacp/ +[17:19..17:23) => com/javacp/Coin# +[17:26..17:32) => com/javacp/ +[17:33..17:37) => com/javacp/Coin# +[17:38..17:43) => com/javacp/Coin#PENNY. +[18:6..18:11) => example/MetacJava#entry. +[18:13..18:17) => java/ +[18:18..18:22) => java/util/ +[18:23..18:26) => java/util/Map# +[18:27..18:32) => java/util/Map#Entry# +[18:33..18:36) => scala/Int# +[18:38..18:41) => scala/Int# + +expect/MethodUsages.scala +_________________________ + +Summary: +Schema => SemanticDB v4 +Uri => MethodUsages.scala +Text => empty +Language => Scala +Symbols => 3 entries +Occurrences => 74 entries + +Symbols: +example/MethodUsages# => class MethodUsages +example/MethodUsages#``(). => primary ctor +example/MethodUsages#m. => val method m + +Occurrences: +[0:8..0:15) => example/ +[2:6..2:18) => example/MethodUsages# +[3:2..3:2) => example/MethodUsages#``(). +[3:6..3:7) => example/MethodUsages#m. +[3:14..3:21) => example/Methods# +[3:22..3:25) => scala/Int# +[3:26..3:26) => example/Methods#``(). +[4:2..4:3) => example/MethodUsages#m. +[4:4..4:6) => example/Methods#m1(). +[5:2..5:3) => example/MethodUsages#m. +[5:4..5:6) => example/Methods#m2(). +[6:2..6:3) => example/MethodUsages#m. +[6:4..6:6) => example/Methods#m3(). +[7:2..7:3) => example/MethodUsages#m. +[7:4..7:6) => example/Methods#m4(). +[8:2..8:3) => example/MethodUsages#m. +[8:4..8:6) => example/Methods#m5(). +[9:2..9:3) => example/MethodUsages#m. +[9:4..9:6) => example/Methods#m5(+1). +[10:2..10:3) => example/MethodUsages#m. +[10:4..10:6) => example/Methods#m6(). +[11:2..11:3) => example/MethodUsages#m. +[11:4..11:6) => example/Methods#m6(+1). +[11:11..11:12) => example/MethodUsages#m. +[11:13..11:17) => example/Methods#List# +[11:18..11:21) => scala/Int# +[11:22..11:22) => example/Methods#List#``(). +[12:2..12:3) => example/MethodUsages#m. +[12:4..12:6) => example/Methods#m6(+2). +[12:7..12:10) => scala/package.Nil. +[13:2..13:3) => example/MethodUsages#m. +[13:4..13:6) => example/Methods#m7(). +[13:7..13:8) => example/MethodUsages#m. +[13:14..13:15) => example/MethodUsages#m. +[13:16..13:20) => example/Methods#List# +[13:21..13:24) => scala/Int# +[13:25..13:25) => example/Methods#List#``(). +[13:26..13:26) => scala/math/Ordering.Int. +[14:2..14:3) => example/MethodUsages#m. +[14:3..14:11) => example/Methods#`m8().`(). +[16:2..16:3) => example/MethodUsages#m. +[16:4..16:7) => example/Methods#m10(). +[17:2..17:3) => example/MethodUsages#m. +[17:4..17:7) => example/Methods#m11(). +[17:8..17:14) => scala/Predef. +[18:2..18:3) => example/MethodUsages#m. +[18:4..18:7) => example/Methods#m11(+1). +[18:8..18:15) => example/Example. +[19:2..19:3) => example/MethodUsages#m. +[19:4..19:8) => example/Methods#m12a(). +[20:2..20:3) => example/MethodUsages#m. +[20:4..20:8) => example/Methods#m12b(). +[21:2..21:3) => example/MethodUsages#m. +[21:4..21:7) => example/Methods#m13(). +[22:2..22:3) => example/MethodUsages#m. +[22:4..22:7) => example/Methods#m15(). +[23:2..23:3) => example/MethodUsages#m. +[23:4..23:7) => example/Methods#m16(). +[24:2..24:3) => example/MethodUsages#m. +[24:4..24:7) => example/Methods#m16(). +[25:2..25:3) => example/MethodUsages#m. +[25:4..25:7) => example/Methods#m17. +[25:8..25:9) => example/Methods#m17.m(). +[26:2..26:3) => example/MethodUsages#m. +[26:4..26:7) => example/Methods#m17(). +[27:2..27:3) => example/MethodUsages#m. +[27:4..27:7) => example/Methods#m17(+1). +[28:2..28:3) => example/MethodUsages#m. +[28:4..28:7) => example/Methods#m18. +[28:8..28:9) => example/Methods#m17.m(). +[29:2..29:3) => example/MethodUsages#m. +[29:4..29:7) => example/Methods#m18(). +[30:2..30:3) => example/MethodUsages#m. +[30:4..30:7) => example/Methods#m18(+1). + +expect/Methods.scala +____________________ + +Summary: +Schema => SemanticDB v4 +Uri => Methods.scala +Text => empty +Language => Scala +Symbols => 70 entries +Occurrences => 140 entries + +Symbols: +example/Methods# => class Methods +example/Methods#AList# => type AList +example/Methods#AList#[T] => typeparam T +example/Methods#List# => class List +example/Methods#List#[T] => typeparam T +example/Methods#List#``(). => primary ctor +example/Methods#[T] => typeparam T +example/Methods#``(). => primary ctor +example/Methods#`m8().`(). => method m8(). +example/Methods#`m9().`# => class m9(). +example/Methods#`m9().`#``(). => primary ctor +example/Methods#m1(). => method m1 +example/Methods#m2(). => method m2 +example/Methods#m3(). => method m3 +example/Methods#m3().(x) => val param x +example/Methods#m4(). => method m4 +example/Methods#m4().(x) => val param x +example/Methods#m4().(y) => val param y +example/Methods#m5(). => method m5 +example/Methods#m5().(x) => val param x +example/Methods#m5(+1). => method m5 +example/Methods#m5(+1).(x) => val param x +example/Methods#m6(). => method m6 +example/Methods#m6().(x) => val param x +example/Methods#m6(+1). => method m6 +example/Methods#m6(+1).(x) => val param x +example/Methods#m6(+2). => method m6 +example/Methods#m6(+2).(x) => val param x +example/Methods#m7(). => method m7 +example/Methods#m7().(c) => val param c +example/Methods#m7().(evidence$1) => implicit val param evidence$1 +example/Methods#m7().(l) => val param l +example/Methods#m7().[U] => typeparam U +example/Methods#m9(). => method m9 +example/Methods#m9().(x) => val param x +example/Methods#m10(). => method m10 +example/Methods#m10().(x) => val param x +example/Methods#m11(). => method m11 +example/Methods#m11().(x) => val param x +example/Methods#m11(+1). => method m11 +example/Methods#m11(+1).(x) => val param x +example/Methods#m12a(). => method m12a +example/Methods#m12a().(x) => val param x +example/Methods#m12b(). => method m12b +example/Methods#m12b().(x) => val param x +example/Methods#m13(). => method m13 +example/Methods#m13().(x) => val param x +example/Methods#m15(). => method m15 +example/Methods#m15().(x) => val param x +example/Methods#m16(). => method m16 +example/Methods#m16().(x) => val param x +example/Methods#m17(). => method m17 +example/Methods#m17().(a) => val param a +example/Methods#m17(+1). => method m17 +example/Methods#m17(+1).(b) => val param b +example/Methods#m17. => final object m17 +example/Methods#m17.``(). => primary ctor +example/Methods#m17.m(). => method m +example/Methods#m18(). => method m18 +example/Methods#m18().(a) => val param a +example/Methods#m18(+1). => method m18 +example/Methods#m18(+1).(b) => val param b +example/Methods#m18. => val method m18 +example/Methods#m19$default$3().(x) => val param x +example/Methods#m19$default$3().(y) => val param y +example/Methods#m19(). => method m19 +example/Methods#m19().(x) => val param x +example/Methods#m19().(y) => val param y +example/Methods#m19().(z) => val param z +local0 => val method x + +Occurrences: +[0:8..0:15) => example/ +[2:7..2:12) => scala/ +[2:13..2:17) => scala/math/ +[2:18..2:26) => scala/math/Ordering. +[2:18..2:26) => scala/math/Ordering# +[3:7..3:12) => scala/ +[3:13..3:21) => scalaShadowing/language. +[3:22..3:34) => scalaShadowing/language.existentials. +[5:6..5:13) => example/Methods# +[5:13..5:16) => example/Methods#``(). +[5:14..5:15) => example/Methods#[T] +[6:8..6:12) => example/Methods#List# +[6:12..6:15) => example/Methods#List#``(). +[6:13..6:14) => example/Methods#List#[T] +[7:7..7:12) => example/Methods#AList# +[7:13..7:14) => example/Methods#AList#[T] +[7:18..7:22) => example/Methods#List# +[7:23..7:24) => example/Methods#AList#[T] +[8:6..8:8) => example/Methods#m1(). +[8:11..8:14) => scala/Predef.`???`(). +[9:6..9:8) => example/Methods#m2(). +[9:13..9:16) => scala/Predef.`???`(). +[10:6..10:8) => example/Methods#m3(). +[10:9..10:10) => example/Methods#m3().(x) +[10:12..10:15) => scala/Int# +[10:19..10:22) => scala/Predef.`???`(). +[11:6..11:8) => example/Methods#m4(). +[11:9..11:10) => example/Methods#m4().(x) +[11:12..11:15) => scala/Int# +[11:17..11:18) => example/Methods#m4().(y) +[11:20..11:23) => scala/Int# +[11:27..11:30) => scala/Predef.`???`(). +[12:6..12:8) => example/Methods#m5(). +[12:9..12:10) => example/Methods#m5().(x) +[12:12..12:18) => scala/Predef.String# +[12:22..12:25) => scala/Predef.`???`(). +[13:6..13:8) => example/Methods#m5(+1). +[13:9..13:10) => example/Methods#m5(+1).(x) +[13:12..13:15) => scala/Int# +[13:19..13:22) => scala/Predef.`???`(). +[14:6..14:8) => example/Methods#m6(). +[14:9..14:10) => example/Methods#m6().(x) +[14:12..14:15) => scala/Int# +[14:19..14:22) => scala/Predef.`???`(). +[15:6..15:8) => example/Methods#m6(+1). +[15:9..15:10) => example/Methods#m6(+1).(x) +[15:12..15:16) => example/Methods#List# +[15:17..15:18) => example/Methods#[T] +[15:23..15:26) => scala/Predef.`???`(). +[16:6..16:8) => example/Methods#m6(+2). +[16:9..16:10) => example/Methods#m6(+2).(x) +[16:12..16:17) => scala/ +[16:18..16:22) => scala/package.List# +[16:23..16:24) => example/Methods#[T] +[16:29..16:32) => scala/Predef.`???`(). +[17:6..17:8) => example/Methods#m7(). +[17:9..17:10) => example/Methods#m7().[U] +[17:10..17:10) => example/Methods#m7().(evidence$1) +[17:12..17:20) => scala/math/Ordering# +[17:20..17:20) => example/Methods#m7().[U] +[17:22..17:23) => example/Methods#m7().(c) +[17:25..17:32) => example/Methods# +[17:33..17:34) => example/Methods#[T] +[17:37..17:38) => example/Methods#m7().(l) +[17:40..17:44) => example/Methods#List# +[17:45..17:46) => example/Methods#m7().[U] +[17:51..17:54) => scala/Predef.`???`(). +[18:7..18:17) => example/Methods#`m8().`(). +[18:18..18:21) => scala/Predef.`???`(). +[19:2..19:2) => example/Methods#`m9().`#``(). +[19:9..20:3) => example/Methods#`m9().`# +[20:6..20:8) => example/Methods#m9(). +[20:9..20:10) => example/Methods#m9().(x) +[20:12..20:19) => example/Methods#`m9().`# +[20:23..20:26) => scala/Predef.`???`(). +[21:6..21:9) => example/Methods#m10(). +[21:10..21:11) => example/Methods#m10().(x) +[21:13..21:18) => example/Methods#AList# +[21:19..21:20) => example/Methods#[T] +[21:25..21:28) => scala/Predef.`???`(). +[22:6..22:9) => example/Methods#m11(). +[22:10..22:11) => example/Methods#m11().(x) +[22:13..22:19) => scala/Predef. +[22:28..22:31) => scala/Predef.`???`(). +[23:6..23:9) => example/Methods#m11(+1). +[23:10..23:11) => example/Methods#m11(+1).(x) +[23:13..23:20) => example/Example. +[23:29..23:32) => scala/Predef.`???`(). +[24:6..24:10) => example/Methods#m12a(). +[24:11..24:12) => example/Methods#m12a().(x) +[24:20..24:23) => scala/Predef.`???`(). +[25:6..25:10) => example/Methods#m12b(). +[25:11..25:12) => example/Methods#m12b().(x) +[25:20..25:21) => local0 +[25:23..25:26) => scala/Int# +[25:32..25:35) => scala/Predef.`???`(). +[26:6..26:9) => example/Methods#m13(). +[26:10..26:11) => example/Methods#m13().(x) +[26:13..26:16) => scala/Int# +[26:31..26:34) => scala/Predef.`???`(). +[27:6..27:9) => example/Methods#m15(). +[27:10..27:11) => example/Methods#m15().(x) +[27:16..27:19) => scala/Int# +[27:23..27:26) => scala/Predef.`???`(). +[28:6..28:9) => example/Methods#m16(). +[28:10..28:11) => example/Methods#m16().(x) +[28:13..28:16) => scala/Int# +[28:21..28:24) => scala/Predef.`???`(). +[29:9..29:12) => example/Methods#m17. +[29:15..29:15) => example/Methods#m17.``(). +[29:19..29:20) => example/Methods#m17.m(). +[29:25..29:28) => scala/Predef.`???`(). +[30:6..30:9) => example/Methods#m17(). +[30:10..30:11) => example/Methods#m17().(a) +[30:13..30:16) => scala/Int# +[30:20..30:23) => scala/Predef.`???`(). +[31:6..31:9) => example/Methods#m17(+1). +[31:10..31:11) => example/Methods#m17(+1).(b) +[31:13..31:19) => scala/Predef.String# +[31:23..31:26) => scala/Predef.`???`(). +[32:6..32:9) => example/Methods#m18. +[32:12..32:15) => example/Methods#m17. +[33:6..33:9) => example/Methods#m18(). +[33:10..33:11) => example/Methods#m18().(a) +[33:13..33:16) => scala/Int# +[33:20..33:23) => scala/Predef.`???`(). +[34:6..34:9) => example/Methods#m18(+1). +[34:10..34:11) => example/Methods#m18(+1).(b) +[34:13..34:19) => scala/Predef.String# +[34:23..34:26) => scala/Predef.`???`(). +[35:6..35:9) => example/Methods#m19(). +[35:10..35:11) => example/Methods#m19().(x) +[35:10..35:11) => example/Methods#m19$default$3().(x) +[35:13..35:16) => scala/Int# +[35:18..35:19) => example/Methods#m19().(y) +[35:18..35:19) => example/Methods#m19$default$3().(y) +[35:21..35:24) => scala/Int# +[35:30..35:31) => example/Methods#m19().(z) +[35:33..35:36) => scala/Int# +[35:44..35:47) => scala/Predef.`???`(). + +expect/NamedApplyBlock.scala +____________________________ + +Summary: +Schema => SemanticDB v4 +Uri => NamedApplyBlock.scala +Text => empty +Language => Scala +Symbols => 19 entries +Occurrences => 38 entries + +Symbols: +example/NamedApplyBlockCaseClassConstruction. => final object NamedApplyBlockCaseClassConstruction +example/NamedApplyBlockCaseClassConstruction.Msg# => case class Msg +example/NamedApplyBlockCaseClassConstruction.Msg#``(). => primary ctor +example/NamedApplyBlockCaseClassConstruction.Msg#body. => val method body +example/NamedApplyBlockCaseClassConstruction.Msg#head. => val method head +example/NamedApplyBlockCaseClassConstruction.Msg#tail. => val method tail +example/NamedApplyBlockCaseClassConstruction.Msg.``(). => primary ctor +example/NamedApplyBlockCaseClassConstruction.``(). => primary ctor +example/NamedApplyBlockCaseClassConstruction.bodyText. => val method bodyText +example/NamedApplyBlockCaseClassConstruction.msg. => val method msg +example/NamedApplyBlockMethods. => final object NamedApplyBlockMethods +example/NamedApplyBlockMethods.``(). => primary ctor +example/NamedApplyBlockMethods.baseCase(). => method baseCase +example/NamedApplyBlockMethods.foo(). => method foo +example/NamedApplyBlockMethods.foo().(a) => val param a +example/NamedApplyBlockMethods.foo().(b) => val param b +example/NamedApplyBlockMethods.foo().(c) => val param c +example/NamedApplyBlockMethods.local. => val method local +example/NamedApplyBlockMethods.recursive(). => method recursive + +Occurrences: +[0:8..0:15) => example/ +[2:7..2:29) => example/NamedApplyBlockMethods. +[3:2..3:2) => example/NamedApplyBlockMethods.``(). +[3:6..3:11) => example/NamedApplyBlockMethods.local. +[4:6..4:9) => example/NamedApplyBlockMethods.foo(). +[4:10..4:11) => example/NamedApplyBlockMethods.foo().(a) +[4:13..4:16) => scala/Int# +[4:22..4:23) => example/NamedApplyBlockMethods.foo().(b) +[4:25..4:28) => scala/Int# +[4:34..4:35) => example/NamedApplyBlockMethods.foo().(c) +[4:37..4:40) => scala/Int# +[4:47..4:50) => scala/Int# +[4:53..4:54) => example/NamedApplyBlockMethods.foo().(a) +[4:55..4:56) => scala/Int#`+`(+4). +[4:57..4:58) => example/NamedApplyBlockMethods.foo().(b) +[4:59..4:60) => scala/Int#`+`(+4). +[4:61..4:62) => example/NamedApplyBlockMethods.foo().(c) +[5:6..5:14) => example/NamedApplyBlockMethods.baseCase(). +[5:17..5:20) => example/NamedApplyBlockMethods.foo(). +[5:21..5:26) => example/NamedApplyBlockMethods.local. +[6:6..6:15) => example/NamedApplyBlockMethods.recursive(). +[6:18..6:21) => example/NamedApplyBlockMethods.foo(). +[6:22..6:27) => example/NamedApplyBlockMethods.local. +[9:7..9:43) => example/NamedApplyBlockCaseClassConstruction. +[10:2..10:2) => example/NamedApplyBlockCaseClassConstruction.``(). +[10:2..10:2) => example/NamedApplyBlockCaseClassConstruction.Msg.``(). +[10:13..10:16) => example/NamedApplyBlockCaseClassConstruction.Msg# +[10:16..10:70) => example/NamedApplyBlockCaseClassConstruction.Msg#``(). +[10:17..10:21) => example/NamedApplyBlockCaseClassConstruction.Msg#body. +[10:23..10:29) => scala/Predef.String# +[10:31..10:35) => example/NamedApplyBlockCaseClassConstruction.Msg#head. +[10:37..10:43) => scala/Predef.String# +[10:57..10:61) => example/NamedApplyBlockCaseClassConstruction.Msg#tail. +[10:63..10:69) => scala/Predef.String# +[11:6..11:14) => example/NamedApplyBlockCaseClassConstruction.bodyText. +[12:6..12:9) => example/NamedApplyBlockCaseClassConstruction.msg. +[12:12..12:15) => example/NamedApplyBlockCaseClassConstruction.Msg. +[12:16..12:24) => example/NamedApplyBlockCaseClassConstruction.bodyText. + +expect/NamedArguments.scala +___________________________ + +Summary: +Schema => SemanticDB v4 +Uri => NamedArguments.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 11 entries + +Symbols: +example/NamedArguments# => class NamedArguments +example/NamedArguments#User# => case class User +example/NamedArguments#User#``(). => primary ctor +example/NamedArguments#User#name. => val method name +example/NamedArguments#User.``(). => primary ctor +example/NamedArguments#``(). => primary ctor + +Occurrences: +[0:8..0:15) => example/ +[2:6..2:20) => example/NamedArguments# +[3:2..3:2) => example/NamedArguments#``(). +[3:2..3:2) => example/NamedArguments#User.``(). +[3:13..3:17) => example/NamedArguments#User# +[3:17..3:31) => example/NamedArguments#User#``(). +[3:18..3:22) => example/NamedArguments#User#name. +[3:24..3:30) => scala/Predef.String# +[4:2..4:6) => example/NamedArguments#User. +[5:2..5:6) => example/NamedArguments#User. +[5:7..5:12) => example/NamedArguments#User.apply(). + +expect/NewModifiers.scala +_________________________ + +Summary: +Schema => SemanticDB v4 +Uri => NewModifiers.scala +Text => empty +Language => Scala +Symbols => 4 entries +Occurrences => 6 entries + +Symbols: +_empty_/NewModifiers. => final object NewModifiers +_empty_/NewModifiers.A# => type A +_empty_/NewModifiers.``(). => primary ctor +_empty_/NewModifiers.foo. => val method foo + +Occurrences: +[0:0..0:0) => _empty_/ +[0:7..0:19) => _empty_/NewModifiers. +[1:2..1:2) => _empty_/NewModifiers.``(). +[1:13..1:16) => _empty_/NewModifiers.foo. +[2:14..2:15) => _empty_/NewModifiers.A# +[2:18..2:21) => scala/Int# + +expect/Objects.scala +____________________ + +Summary: +Schema => SemanticDB v4 +Uri => Objects.scala +Text => empty +Language => Scala +Symbols => 4 entries +Occurrences => 5 entries + +Symbols: +objects/X. => final object X +objects/X.Y. => final object Y +objects/X.Y.``(). => primary ctor +objects/X.``(). => primary ctor + +Occurrences: +[0:8..0:15) => objects/ +[2:7..2:8) => objects/X. +[3:2..3:2) => objects/X.``(). +[3:2..3:2) => objects/X.Y.``(). +[3:9..3:10) => objects/X.Y. + +expect/Overrides.scala +______________________ + +Summary: +Schema => SemanticDB v4 +Uri => Overrides.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 10 entries + +Symbols: +example/A# => class A +example/A#``(). => primary ctor +example/A#foo(). => method foo +example/B# => class B +example/B#``(). => primary ctor +example/B#foo(). => method foo + +Occurrences: +[0:8..0:15) => example/ +[2:6..2:7) => example/A# +[2:10..2:10) => example/A#``(). +[2:14..2:17) => example/A#foo(). +[2:19..2:22) => scala/Int# +[3:6..3:7) => example/B# +[3:7..3:9) => example/B#``(). +[3:18..3:19) => example/A# +[3:26..3:29) => example/B#foo(). +[3:31..3:34) => scala/Int# + +expect/Prefixes.scala +_____________________ + +Summary: +Schema => SemanticDB v4 +Uri => Prefixes.scala +Text => empty +Language => Scala +Symbols => 23 entries +Occurrences => 53 entries + +Symbols: +prefixes/C# => class C +prefixes/C#N. => final object N +prefixes/C#N.U# => type U +prefixes/C#N.``(). => primary ctor +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.``(). => primary ctor +prefixes/M.n1(). => method n1 +prefixes/O. => final object O +prefixes/O.``(). => primary ctor +prefixes/O.o1(). => method o1 +prefixes/Test. => final object Test +prefixes/Test.``(). => primary ctor +prefixes/Test.c. => val method c +prefixes/Test.k2(). => method k2 +prefixes/Test.k3(). => method k3 +prefixes/Test.m2(). => method m2 +prefixes/Test.n2(). => method n2 +prefixes/Test.n3(). => method n3 + +Occurrences: +[0:8..0:16) => prefixes/ +[2:6..2:7) => prefixes/C# +[3:2..3:2) => prefixes/C#``(). +[3:7..3:8) => prefixes/C#T# +[4:6..4:8) => prefixes/C#m1(). +[4:10..4:11) => prefixes/C#T# +[4:14..4:17) => scala/Predef.`???`(). +[6:9..6:10) => prefixes/C#N. +[7:4..7:4) => prefixes/C#N.``(). +[7:9..7:10) => prefixes/C#N.U# +[9:6..9:8) => prefixes/C#k1(). +[9:10..9:11) => prefixes/C#N. +[9:12..9:13) => prefixes/C#N.U# +[9:16..9:19) => scala/Predef.`???`(). +[12:7..12:8) => prefixes/M. +[13:2..13:2) => prefixes/M.``(). +[13:7..13:8) => prefixes/M.T# +[14:6..14:8) => prefixes/M.n1(). +[14:10..14:11) => prefixes/M.T# +[14:14..14:17) => scala/Predef.`???`(). +[17:7..17:8) => prefixes/O. +[17:17..17:17) => prefixes/O.``(). +[17:17..17:18) => prefixes/C# +[17:18..17:18) => prefixes/C#``(). +[18:6..18:8) => prefixes/O.o1(). +[18:10..18:11) => prefixes/C#T# +[18:14..18:17) => scala/Predef.`???`(). +[21:7..21:11) => prefixes/Test. +[22:2..22:2) => prefixes/Test.``(). +[22:6..22:7) => prefixes/Test.c. +[22:9..22:10) => prefixes/C# +[22:13..22:16) => scala/Predef.`???`(). +[23:6..23:8) => prefixes/Test.m2(). +[23:10..23:11) => prefixes/Test.c. +[23:12..23:13) => prefixes/C#T# +[23:16..23:19) => scala/Predef.`???`(). +[24:6..24:8) => prefixes/Test.k2(). +[24:10..24:11) => prefixes/Test.c. +[24:12..24:13) => prefixes/C#N. +[24:14..24:15) => prefixes/C#N.U# +[24:18..24:21) => scala/Predef.`???`(). +[25:9..25:10) => prefixes/Test.c. +[25:11..25:12) => prefixes/C#N. +[26:6..26:8) => prefixes/Test.k3(). +[26:14..26:17) => scala/Predef.`???`(). +[28:6..28:8) => prefixes/Test.n2(). +[28:10..28:11) => prefixes/M. +[28:12..28:13) => prefixes/M.T# +[28:16..28:19) => scala/Predef.`???`(). +[30:9..30:10) => prefixes/M. +[31:6..31:8) => prefixes/Test.n3(). +[31:10..31:11) => prefixes/M.T# +[31:14..31:17) => scala/Predef.`???`(). + +expect/Selfs.scala +__________________ + +Summary: +Schema => SemanticDB v4 +Uri => Selfs.scala +Text => empty +Language => Scala +Symbols => 13 entries +Occurrences => 26 entries + +Symbols: +local0 => selfparam self +local1 => selfparam self +local2 => selfparam self +selfs/B# => class B +selfs/B#``(). => primary ctor +selfs/C1# => class C1 +selfs/C1#``(). => primary ctor +selfs/C2# => class C2 +selfs/C2#``(). => primary ctor +selfs/C3# => class C3 +selfs/C3#``(). => primary ctor +selfs/C6# => class C6 +selfs/C6#``(). => primary ctor + +Occurrences: +[0:8..0:13) => selfs/ +[2:0..2:0) => selfs/B#``(). +[2:6..2:7) => selfs/B# +[4:6..4:8) => selfs/C1# +[4:17..4:17) => selfs/C1#``(). +[4:17..4:18) => selfs/B# +[4:18..4:18) => selfs/B#``(). +[4:21..4:25) => local0 +[7:6..7:8) => selfs/C2# +[7:17..7:17) => selfs/C2#``(). +[7:17..7:18) => selfs/B# +[7:18..7:18) => selfs/B#``(). +[7:21..7:25) => local1 +[7:27..7:28) => selfs/B# +[10:6..10:8) => selfs/C3# +[10:17..10:17) => selfs/C3#``(). +[10:17..10:18) => selfs/B# +[10:18..10:18) => selfs/B#``(). +[10:21..10:25) => local2 +[10:27..10:28) => selfs/B# +[10:34..10:36) => selfs/C1# +[13:6..13:8) => selfs/C6# +[13:17..13:17) => selfs/C6#``(). +[13:17..13:18) => selfs/B# +[13:18..13:18) => selfs/B#``(). +[13:27..13:28) => selfs/B# + +expect/Synthetic.scala +______________________ + +Summary: +Schema => SemanticDB v4 +Uri => Synthetic.scala +Text => empty +Language => Scala +Symbols => 23 entries +Occurrences => 144 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#J#evidence$2. => implicit val method evidence$2 +example/Synthetic#Name. => val method Name +example/Synthetic#``(). => primary ctor +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.``(). => primary ctor +example/Synthetic#s.``(). => primary ctor +example/Synthetic#s.apply(). => method apply +example/Synthetic#x. => val method x +example/Synthetic#xs. => val method xs +local0 => val local name + +Occurrences: +[0:8..0:15) => example/ +[2:7..2:12) => scala/ +[2:13..2:21) => scalaShadowing/language. +[2:22..2:41) => scalaShadowing/language.implicitConversions. +[4:6..4:15) => example/Synthetic# +[5:2..5:2) => example/Synthetic#``(). +[5:2..5:6) => scala/package.List. +[5:6..5:6) => scala/collection/IterableFactory#apply(). +[5:10..5:13) => scala/collection/immutable/List#map(). +[5:16..5:17) => scala/Int#`+`(+4). +[6:2..6:2) => scala/Predef.intArrayOps(). +[6:2..6:7) => scala/Array. +[6:8..6:13) => scala/Array.empty(). +[6:14..6:17) => scala/Int# +[6:18..6:18) => scala/reflect/ClassTag.apply(). +[6:18..6:18) => java/lang/Integer#TYPE. +[6:19..6:29) => scala/collection/ArrayOps#headOption(). +[7:2..7:2) => scala/Predef.augmentString(). +[7:9..7:20) => scala/collection/StringOps#stripPrefix(). +[10:6..10:10) => example/Synthetic#Name. +[10:13..10:13) => scala/Predef.augmentString(). +[10:25..10:26) => scala/collection/StringOps#r(). +[11:2..11:2) => scala/Tuple2#_1. +[11:2..11:2) => scala/Tuple2#_2. +[11:6..11:7) => example/Synthetic#x. +[11:12..11:14) => example/Synthetic#xs. +[12:6..12:10) => example/Synthetic#Name. +[12:10..12:10) => scala/util/matching/Regex#unapplySeq(). +[12:11..12:15) => example/Synthetic#name. +[12:11..12:15) => local0 +[12:16..12:16) => local0 +[13:8..13:8) => scala/collection/immutable/LazyList.toDeferrer(). +[13:14..13:14) => scala/collection/immutable/LazyList.toDeferrer(). +[13:14..13:22) => scala/package.LazyList. +[13:23..13:28) => scala/collection/immutable/LazyList.empty(). +[13:28..13:28) => scala/collection/immutable/LazyList.Deferrer#`#::`(). +[15:6..15:9) => example/Synthetic#lst. +[15:18..15:18) => scala/collection/immutable/LazyList.toDeferrer(). +[15:24..15:24) => scala/collection/immutable/LazyList.toDeferrer(). +[15:24..15:32) => scala/package.LazyList. +[15:33..15:38) => scala/collection/immutable/LazyList.empty(). +[15:38..15:38) => scala/collection/immutable/LazyList.Deferrer#`#::`(). +[17:12..17:12) => scala/LowPriorityImplicits#intWrapper(). +[17:14..17:16) => scala/runtime/RichInt#to(). +[17:19..17:19) => scala/collection/immutable/Range#foreach(). +[17:26..17:26) => scala/LowPriorityImplicits#intWrapper(). +[17:28..17:33) => scala/runtime/RichInt#until(). +[17:36..17:36) => scala/collection/immutable/Range#foreach(). +[17:38..17:45) => scala/Predef.println(+1). +[17:46..17:47) => local1 +[17:48..17:50) => scala/Predef.ArrowAssoc#`->`(). +[17:51..17:52) => local1 +[18:12..18:12) => scala/LowPriorityImplicits#intWrapper(). +[18:14..18:16) => scala/runtime/RichInt#to(). +[18:19..18:19) => scala/collection/StrictOptimizedIterableOps#flatMap(). +[18:26..18:26) => scala/LowPriorityImplicits#intWrapper(). +[18:28..18:33) => scala/runtime/RichInt#until(). +[18:36..18:36) => scala/collection/immutable/Range#map(). +[18:45..18:46) => local2 +[18:48..18:49) => local3 +[19:12..19:12) => scala/LowPriorityImplicits#intWrapper(). +[19:14..19:16) => scala/runtime/RichInt#to(). +[19:19..19:19) => scala/collection/StrictOptimizedIterableOps#flatMap(). +[19:26..19:26) => scala/LowPriorityImplicits#intWrapper(). +[19:28..19:33) => scala/runtime/RichInt#until(). +[19:36..19:36) => scala/collection/IterableOps#withFilter(). +[19:40..19:41) => local4 +[19:42..19:43) => scala/Int#`%`(+3). +[19:46..19:48) => scala/Int#`==`(+3). +[19:50..19:50) => scala/collection/WithFilter#map(). +[19:59..19:60) => local4 +[19:62..19:63) => local5 +[21:9..21:10) => example/Synthetic#s. +[22:4..22:4) => example/Synthetic#s.``(). +[22:8..22:13) => example/Synthetic#s.apply(). +[23:5..23:5) => example/Synthetic#s.apply(). +[24:6..24:11) => example/Synthetic#s.apply(). +[25:4..25:4) => example/Synthetic#s.Bar.``(). +[25:15..25:18) => example/Synthetic#s.Bar# +[25:18..25:20) => example/Synthetic#s.Bar#``(). +[26:4..26:7) => example/Synthetic#s.Bar. +[27:9..27:21) => scala/Any#asInstanceOf(). +[27:22..27:25) => scala/Int# +[27:29..27:32) => scala/Int# +[27:33..27:33) => scala/Function1#apply(). +[30:8..30:9) => example/Synthetic#J# +[30:9..30:22) => example/Synthetic#J#``(). +[30:10..30:11) => example/Synthetic#J#[T] +[30:11..30:11) => example/Synthetic#J#evidence$2. +[30:13..30:21) => scala/Predef.Manifest# +[30:21..30:21) => example/Synthetic#J#``().[T] +[30:29..30:32) => example/Synthetic#J#arr. +[30:35..30:40) => scala/Array. +[30:41..30:46) => scala/Array.empty(). +[30:47..30:48) => example/Synthetic#J#[T] +[30:49..30:49) => example/Synthetic#J#evidence$2. +[32:2..32:2) => example/Synthetic#F#``(). +[32:8..32:9) => example/Synthetic#F# +[33:15..33:23) => example/Synthetic#ordering. +[33:25..33:33) => scala/package.Ordering# +[33:34..33:35) => example/Synthetic#F# +[33:39..33:42) => scala/Predef.`???`(). +[34:6..34:7) => example/Synthetic#f. +[34:9..34:16) => scala/package.Ordered# +[34:17..34:18) => example/Synthetic#F# +[34:22..34:22) => scala/math/Ordered.orderingToOrdered(). +[34:26..34:27) => example/Synthetic#F# +[34:27..34:27) => example/Synthetic#F#``(). +[34:27..34:27) => example/Synthetic#ordering. +[36:9..36:14) => scala/ +[36:15..36:25) => scala/concurrent/ +[36:26..36:42) => scala/concurrent/ExecutionContext. +[36:43..36:52) => scala/concurrent/ExecutionContext.Implicits. +[36:53..36:59) => scala/concurrent/ExecutionContext.Implicits.global(). +[38:9..38:14) => scala/ +[38:15..38:25) => scala/concurrent/ +[38:26..38:32) => scala/concurrent/Future. +[38:33..38:43) => scala/concurrent/Future.successful(). +[38:46..38:46) => scala/concurrent/Future#foreach(). +[39:9..39:14) => scala/ +[39:15..39:25) => scala/concurrent/ +[39:26..39:32) => scala/concurrent/Future. +[39:33..39:43) => scala/concurrent/Future.successful(). +[39:46..39:46) => scala/concurrent/Future#foreach(). +[40:4..40:11) => scala/Predef.println(+1). +[40:12..40:13) => local6 +[40:14..40:14) => scala/concurrent/ExecutionContext.Implicits.global(). +[42:9..42:14) => scala/ +[42:15..42:25) => scala/concurrent/ +[42:26..42:32) => scala/concurrent/Future. +[42:33..42:43) => scala/concurrent/Future.successful(). +[42:46..42:46) => scala/concurrent/Future#flatMap(). +[43:9..43:14) => scala/ +[43:15..43:25) => scala/concurrent/ +[43:26..43:32) => scala/concurrent/Future. +[43:33..43:43) => scala/concurrent/Future.successful(). +[43:46..43:46) => scala/concurrent/Future#withFilter(). +[44:7..44:8) => local7 +[44:9..44:10) => scala/Int#`<`(+3). +[44:11..44:12) => local8 +[44:12..44:12) => scala/concurrent/Future#map(). +[44:12..44:12) => scala/concurrent/ExecutionContext.Implicits.global(). +[45:10..45:11) => local7 +[45:11..45:11) => scala/concurrent/ExecutionContext.Implicits.global(). + +expect/Traits.scala +___________________ + +Summary: +Schema => SemanticDB v4 +Uri => Traits.scala +Text => empty +Language => Scala +Symbols => 14 entries +Occurrences => 19 entries + +Symbols: +local0 => primary ctor +local1 => selfparam self +traits/C# => class C +traits/C#``(). => primary ctor +traits/T# => class T +traits/T#``(). => primary ctor +traits/T#x(). => method x +traits/U# => sealed class U +traits/U#``(). => primary ctor +traits/U. => final object U +traits/U.``(). => primary ctor +traits/U.u(). => method u +traits/V# => class V +traits/V#``(). => primary ctor + +Occurrences: +[0:8..0:14) => traits/ +[2:6..2:7) => traits/T# +[3:2..3:2) => traits/T#``(). +[3:6..3:7) => traits/T#x(). +[6:0..6:0) => traits/U#``(). +[6:13..6:14) => traits/U# +[7:7..7:8) => traits/U. +[8:2..8:2) => traits/U.``(). +[8:6..8:7) => traits/U.u(). +[8:9..8:10) => traits/U# +[8:17..8:17) => local0 +[8:17..8:18) => traits/U# +[8:21..8:21) => local0 +[11:0..11:0) => traits/C#``(). +[11:6..11:7) => traits/C# +[12:6..12:7) => traits/V# +[12:10..12:10) => traits/V#``(). +[12:10..12:14) => local1 +[12:16..12:17) => traits/C# + +expect/Types.scala +__________________ + +Summary: +Schema => SemanticDB v4 +Uri => Types.scala +Text => empty +Language => Scala +Symbols => 124 entries +Occurrences => 256 entries + +Symbols: +local0 => method k +local1 => method k +local2 => primary ctor +local3 => method k +local4 => primary ctor +local5 => primary ctor +local6 => method k +local7 => type L +local8 => typeparam T +types/B# => class B +types/B#``(). => primary ctor +types/C# => class C +types/C#``(). => primary ctor +types/P# => class P +types/P#C# => class C +types/P#C#``(). => primary ctor +types/P#X# => class X +types/P#X#``(). => primary ctor +types/P#``(). => primary ctor +types/P#x. => val method x +types/T# => class T +types/T#C# => class C +types/T#C#``(). => primary ctor +types/T#X# => class X +types/T#X#``(). => primary ctor +types/T#``(). => primary ctor +types/T#x. => val method x +types/Test. => final object Test +types/Test.C# => class C +types/Test.C#ByNameType. => final object ByNameType +types/Test.C#ByNameType.``(). => primary ctor +types/Test.C#ByNameType.m1(). => method m1 +types/Test.C#ByNameType.m1().(x) => val param x +types/Test.C#ClassInfoType1. => final object ClassInfoType1 +types/Test.C#ClassInfoType1.``(). => primary ctor +types/Test.C#ClassInfoType2# => class ClassInfoType2 +types/Test.C#ClassInfoType2#``(). => primary ctor +types/Test.C#ClassInfoType2#x(). => method x +types/Test.C#ClassInfoType3# => class 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.``(). => primary ctor +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) => val param x +types/Test.C#MethodType.m6(). => method m6 +types/Test.C#MethodType.m6().(x) => val 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#``(). => primary ctor +types/Test.C#RepeatedType#m1(). => method m1 +types/Test.C#RepeatedType#m1().(x) => val param x +types/Test.C#RepeatedType#s. => val method s +types/Test.C#RepeatedType.``(). => primary ctor +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.``(). => primary ctor +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.``(). => primary ctor +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# => class N +types/Test.N#``(). => primary ctor +types/Test.N#n(). => method n +types/Test.``(). => primary ctor +types/ann# => class ann +types/ann#[T] => typeparam T +types/ann#``(). => primary ctor +types/ann#x. => val method x +types/ann1# => class ann1 +types/ann1#``(). => primary ctor +types/ann2# => class ann2 +types/ann2#``(). => primary ctor + +Occurrences: +[0:8..0:13) => types/ +[2:7..2:12) => scala/ +[2:13..2:21) => scalaShadowing/language. +[2:22..2:34) => scalaShadowing/language.existentials. +[3:7..3:12) => scala/ +[3:13..3:21) => scalaShadowing/language. +[3:22..3:33) => scalaShadowing/language.higherKinds. +[5:6..5:9) => types/ann# +[5:6..5:6) => scala/annotation/Annotation#``(). +[5:9..5:18) => types/ann#``(). +[5:10..5:11) => types/ann#[T] +[5:13..5:14) => types/ann#x. +[5:16..5:17) => types/ann#``().[T] +[5:27..5:32) => scala/ +[5:33..5:43) => scala/annotation/ +[5:44..5:60) => scala/annotation/StaticAnnotation# +[6:6..6:10) => types/ann1# +[6:6..6:6) => scala/annotation/Annotation#``(). +[6:19..6:19) => types/ann1#``(). +[6:19..6:24) => scala/ +[6:25..6:35) => scala/annotation/ +[6:36..6:52) => scala/annotation/StaticAnnotation# +[7:6..7:10) => types/ann2# +[7:6..7:6) => scala/annotation/Annotation#``(). +[7:19..7:19) => types/ann2#``(). +[7:19..7:24) => scala/ +[7:25..7:35) => scala/annotation/ +[7:36..7:52) => scala/annotation/StaticAnnotation# +[9:0..9:0) => types/B#``(). +[9:6..9:7) => types/B# +[11:0..11:0) => types/C#``(). +[11:6..11:7) => types/C# +[13:6..13:7) => types/P# +[14:2..14:2) => types/P#``(). +[14:2..14:2) => types/P#C#``(). +[14:8..14:9) => types/P#C# +[15:2..15:2) => types/P#X#``(). +[15:8..15:9) => types/P#X# +[16:6..16:7) => types/P#x. +[16:14..16:15) => types/P#X# +[16:15..16:15) => types/P#X#``(). +[19:6..19:7) => types/T# +[20:2..20:2) => types/T#``(). +[20:2..20:2) => types/T#C#``(). +[20:8..20:9) => types/T#C# +[21:2..21:2) => types/T#X#``(). +[21:8..21:9) => types/T#X# +[22:6..22:7) => types/T#x. +[22:14..22:15) => types/T#X# +[22:15..22:15) => types/T#X#``(). +[25:7..25:11) => types/Test. +[26:2..26:2) => types/Test.``(). +[26:8..26:9) => types/Test.M# +[27:4..27:4) => types/Test.M#``(). +[27:8..27:9) => types/Test.M#m(). +[27:11..27:14) => scala/Int# +[27:17..27:20) => scala/Predef.`???`(). +[30:8..30:9) => types/Test.N# +[31:4..31:4) => types/Test.N#``(). +[31:8..31:9) => types/Test.N#n(). +[31:11..31:14) => scala/Int# +[31:17..31:20) => scala/Predef.`???`(). +[34:8..34:9) => types/Test.C# +[34:18..34:18) => types/Test.C#``(). +[34:18..34:19) => types/Test.M# +[34:19..34:19) => types/Test.M#``(). +[35:8..35:9) => types/Test.C#p. +[35:16..35:17) => types/P# +[35:17..35:17) => types/P#``(). +[36:8..36:9) => types/Test.C#x. +[36:12..36:13) => types/Test.C#p. +[36:14..36:15) => types/P#x. +[38:8..38:16) => types/Test.C#typeRef1. +[38:18..38:19) => types/Test.C# +[38:22..38:25) => scala/Predef.`???`(). +[39:8..39:16) => types/Test.C#typeRef2. +[39:18..39:19) => types/Test.C#p. +[39:20..39:21) => types/P#C# +[39:24..39:27) => scala/Predef.`???`(). +[40:8..40:16) => types/Test.C#typeRef3. +[40:18..40:19) => types/T# +[40:20..40:21) => types/T#C# +[40:24..40:27) => scala/Predef.`???`(). +[41:8..41:16) => types/Test.C#typeRef4. +[41:18..41:22) => scala/package.List# +[41:23..41:26) => scala/Int# +[41:30..41:33) => scala/Predef.`???`(). +[43:8..43:19) => types/Test.C#singleType1. +[43:21..43:22) => types/Test.C#x. +[43:30..43:33) => scala/Predef.`???`(). +[44:8..44:19) => types/Test.C#singleType2. +[44:21..44:22) => types/Test.C#p. +[44:23..44:24) => types/P#x. +[44:32..44:35) => scala/Predef.`???`(). +[45:8..45:14) => types/Test.C#Either. +[45:17..45:22) => scala/ +[45:23..45:27) => scala/util/ +[45:28..45:34) => scala/util/Either. +[47:8..47:17) => types/Test.C#thisType1. +[47:31..47:34) => scala/Predef.`???`(). +[48:8..48:17) => types/Test.C#thisType2. +[48:33..48:36) => scala/Predef.`???`(). +[50:8..50:18) => types/Test.C#superType1. +[50:27..50:28) => types/Test.M#m(). +[51:8..51:18) => types/Test.C#superType2. +[51:30..51:31) => types/Test.M#m(). +[52:8..52:18) => types/Test.C#superType3. +[52:32..52:33) => types/Test.M#m(). +[54:8..54:21) => types/Test.C#compoundType1. +[54:29..54:30) => local0 +[54:32..54:35) => scala/Int# +[54:40..54:43) => scala/Predef.`???`(). +[55:8..55:21) => types/Test.C#compoundType2. +[55:23..55:24) => types/Test.M# +[55:30..55:31) => types/Test.N# +[55:34..55:37) => scala/Predef.`???`(). +[56:8..56:21) => types/Test.C#compoundType3. +[56:23..56:24) => types/Test.M# +[56:30..56:31) => types/Test.N# +[56:38..56:39) => local1 +[56:41..56:44) => scala/Int# +[56:49..56:52) => scala/Predef.`???`(). +[57:8..57:21) => types/Test.C#compoundType4. +[57:30..57:30) => local2 +[57:34..57:35) => local3 +[57:37..57:40) => scala/Int# +[57:43..57:46) => scala/Predef.`???`(). +[57:48..57:48) => local2 +[58:8..58:21) => types/Test.C#compoundType5. +[58:28..58:28) => local4 +[58:28..58:29) => types/Test.M# +[58:29..58:29) => types/Test.M#``(). +[58:35..58:36) => types/Test.N# +[58:36..58:36) => local4 +[59:8..59:21) => types/Test.C#compoundType6. +[59:28..59:28) => local5 +[59:28..59:29) => types/Test.M# +[59:29..59:29) => types/Test.M#``(). +[59:35..59:36) => types/Test.N# +[59:43..59:44) => local6 +[59:46..59:49) => scala/Int# +[59:52..59:55) => scala/Predef.`???`(). +[59:57..59:57) => local5 +[61:8..61:16) => types/Test.C#annType1. +[61:18..61:19) => types/T# +[61:31..61:34) => scala/Predef.`???`(). +[62:8..62:16) => types/Test.C#annType2. +[62:18..62:19) => types/T# +[62:34..62:37) => scala/Predef.`???`(). +[64:8..64:24) => types/Test.C#existentialType2. +[64:26..64:30) => scala/package.List# +[64:36..64:39) => scala/Predef.`???`(). +[65:8..65:24) => types/Test.C#existentialType3. +[65:27..65:32) => java/lang/Class# +[65:33..65:40) => java/lang/Class#forName(). +[66:8..66:24) => types/Test.C#existentialType4. +[66:27..66:32) => java/lang/Class# +[66:33..66:40) => java/lang/Class#forName(). +[68:8..68:19) => types/Test.C#typeLambda1(). +[68:20..68:21) => types/Test.C#typeLambda1().[M] +[68:28..68:31) => scala/Predef.`???`(). +[69:4..69:15) => types/Test.C#typeLambda1(). +[69:24..69:25) => local7 +[69:26..69:27) => local8 +[69:31..69:35) => scala/package.List# +[69:36..69:37) => local8 +[71:4..71:4) => types/Test.C#ClassInfoType1.``(). +[71:11..71:25) => types/Test.C#ClassInfoType1. +[72:10..72:24) => types/Test.C#ClassInfoType2# +[72:33..72:33) => types/Test.C#ClassInfoType2#``(). +[72:33..72:34) => types/B# +[72:34..72:34) => types/B#``(). +[72:41..72:42) => types/Test.C#ClassInfoType2#x(). +[73:10..73:24) => types/Test.C#ClassInfoType3# +[73:24..73:27) => types/Test.C#ClassInfoType3#``(). +[73:25..73:26) => types/Test.C#ClassInfoType3#[T] +[75:11..75:21) => types/Test.C#MethodType. +[76:6..76:6) => types/Test.C#MethodType.``(). +[76:10..76:12) => types/Test.C#MethodType.x1(). +[76:14..76:17) => scala/Int# +[76:20..76:23) => scala/Predef.`???`(). +[77:10..77:12) => types/Test.C#MethodType.x2(). +[77:14..77:17) => scala/Int# +[77:20..77:23) => scala/Predef.`???`(). +[78:10..78:12) => types/Test.C#MethodType.m3(). +[78:14..78:17) => scala/Int# +[78:20..78:23) => scala/Predef.`???`(). +[79:10..79:12) => types/Test.C#MethodType.m4(). +[79:16..79:19) => scala/Int# +[79:22..79:25) => scala/Predef.`???`(). +[80:10..80:12) => types/Test.C#MethodType.m5(). +[80:13..80:14) => types/Test.C#MethodType.m5().(x) +[80:16..80:19) => scala/Int# +[80:22..80:25) => scala/Int# +[80:28..80:31) => scala/Predef.`???`(). +[81:10..81:12) => types/Test.C#MethodType.m6(). +[81:13..81:14) => types/Test.C#MethodType.m6().[T] +[81:16..81:17) => types/Test.C#MethodType.m6().(x) +[81:19..81:20) => types/Test.C#MethodType.m6().[T] +[81:23..81:24) => types/Test.C#MethodType.m6().[T] +[81:27..81:30) => scala/Predef.`???`(). +[84:11..84:21) => types/Test.C#ByNameType. +[85:6..85:6) => types/Test.C#ByNameType.``(). +[85:10..85:12) => types/Test.C#ByNameType.m1(). +[85:13..85:14) => types/Test.C#ByNameType.m1().(x) +[85:19..85:22) => scala/Int# +[85:25..85:28) => scala/Int# +[85:31..85:34) => scala/Predef.`???`(). +[88:4..88:4) => types/Test.C#RepeatedType.``(). +[88:15..88:27) => types/Test.C#RepeatedType# +[88:27..88:39) => types/Test.C#RepeatedType#``(). +[88:28..88:29) => types/Test.C#RepeatedType#s. +[88:31..88:37) => scala/Predef.String# +[89:10..89:12) => types/Test.C#RepeatedType#m1(). +[89:13..89:14) => types/Test.C#RepeatedType#m1().(x) +[89:16..89:19) => scala/Int# +[89:23..89:26) => scala/Int# +[89:29..89:30) => types/Test.C#RepeatedType#s. +[89:31..89:37) => scala/collection/SeqOps#length(). +[92:11..92:19) => types/Test.C#TypeType. +[93:6..93:6) => types/Test.C#TypeType.``(). +[93:11..93:13) => types/Test.C#TypeType.T1# +[94:10..94:12) => types/Test.C#TypeType.m2(). +[94:13..94:15) => types/Test.C#TypeType.m2().[T2] +[94:19..94:20) => types/Test.C# +[94:24..94:25) => types/Test.C# +[94:29..94:32) => scala/Predef.`???`(). +[95:10..95:12) => types/Test.C#TypeType.m3(). +[95:13..95:15) => types/Test.C#TypeType.m3().[M3] +[95:22..95:25) => scala/Predef.`???`(). +[96:11..96:13) => types/Test.C#TypeType.T4# +[96:16..96:17) => types/Test.C# +[97:11..97:13) => types/Test.C#TypeType.T5# +[97:14..97:15) => types/Test.C#TypeType.T5#[U] +[97:19..97:20) => types/Test.C#TypeType.T5#[U] +[101:9..101:16) => types/Test.Literal. +[102:4..102:4) => types/Test.Literal.``(). +[102:14..102:17) => types/Test.Literal.int. +[103:14..103:18) => types/Test.Literal.long. +[104:14..104:19) => types/Test.Literal.float. +[105:14..105:20) => types/Test.Literal.double. +[106:14..106:17) => types/Test.Literal.nil. +[107:14..107:18) => types/Test.Literal.char. +[108:14..108:20) => types/Test.Literal.string. +[109:14..109:18) => types/Test.Literal.bool. +[110:14..110:18) => types/Test.Literal.unit. +[111:14..111:22) => types/Test.Literal.javaEnum. +[111:25..111:29) => java/ +[111:30..111:33) => java/nio/ +[111:34..111:38) => java/nio/file/ +[111:39..111:49) => java/nio/file/LinkOption# +[111:50..111:64) => java/nio/file/LinkOption#NOFOLLOW_LINKS. +[112:14..112:21) => types/Test.Literal.clazzOf. +[112:24..112:31) => scala/Predef.classOf(). +[112:32..112:38) => scala/Option# +[112:39..112:42) => scala/Int# + +expect/ValPattern.scala +_______________________ + +Summary: +Schema => SemanticDB v4 +Uri => ValPattern.scala +Text => empty +Language => Scala +Symbols => 21 entries +Occurrences => 57 entries + +Symbols: +example/ValPattern# => class ValPattern +example/ValPattern#``(). => primary ctor +example/ValPattern#`leftVar_=`(). => method leftVar_= +example/ValPattern#`number1Var_=`(). => method number1Var_= +example/ValPattern#`rightVar_=`(). => method rightVar_= +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#right. => val method right +example/ValPattern#rightVar(). => var method rightVar +local0 => val local number1 +local1 => val local number1Var +local2 => val local left +local3 => val local right +local4 => val local number1 +local5 => var local leftVar +local6 => var local rightVar +local7 => val local number1Var +local7 => var local number1Var + +Occurrences: +[0:8..0:15) => example/ +[2:6..2:16) => example/ValPattern# +[4:2..4:2) => example/ValPattern#``(). +[4:2..4:2) => scala/Tuple2#_1. +[4:2..4:2) => scala/Tuple2#_2. +[4:7..4:11) => example/ValPattern#left. +[4:13..4:18) => example/ValPattern#right. +[5:6..5:10) => scala/Some. +[5:11..5:18) => example/ValPattern#number1. +[5:11..5:18) => local0 +[5:19..5:19) => local0 +[6:4..6:8) => scala/Some. +[8:2..8:2) => scala/Tuple2#_1. +[8:2..8:2) => scala/Tuple2#_2. +[8:7..8:14) => example/ValPattern#leftVar(). +[8:7..8:16) => example/ValPattern#`leftVar_=`(). +[8:16..8:24) => example/ValPattern#rightVar(). +[8:16..8:26) => example/ValPattern#`rightVar_=`(). +[9:6..9:10) => scala/Some. +[9:11..9:21) => example/ValPattern#number1Var(). +[9:11..9:21) => local1 +[9:11..9:23) => example/ValPattern#`number1Var_=`(). +[9:22..9:22) => local1 +[10:4..10:8) => scala/Some. +[12:6..12:9) => example/ValPattern#app(). +[12:13..12:17) => scala/Unit# +[13:4..13:11) => scala/Predef.println(+1). +[15:8..15:15) => example/ValPattern#number1. +[16:8..16:12) => example/ValPattern#left. +[17:8..17:13) => example/ValPattern#right. +[18:8..18:18) => example/ValPattern#number1Var(). +[19:8..19:15) => example/ValPattern#leftVar(). +[20:8..20:16) => example/ValPattern#rightVar(). +[23:4..23:11) => dotty/DottyPredef.locally(). +[24:6..24:6) => scala/Tuple2#_1. +[24:6..24:6) => scala/Tuple2#_2. +[24:11..24:15) => local2 +[24:17..24:22) => local3 +[25:10..25:14) => scala/Some. +[25:15..25:22) => local4 +[25:23..25:23) => local4 +[26:8..26:12) => scala/Some. +[28:6..28:6) => scala/Tuple2#_1. +[28:6..28:6) => scala/Tuple2#_2. +[28:11..28:18) => local5 +[28:20..28:28) => local6 +[29:10..29:14) => scala/Some. +[29:15..29:25) => local7 +[29:26..29:26) => local7 +[30:8..30:12) => scala/Some. +[31:6..31:13) => scala/Predef.println(+1). +[33:10..33:17) => local4 +[34:10..34:14) => local2 +[35:10..35:15) => local3 +[36:10..36:20) => local7 +[37:10..37:17) => local5 +[38:10..38:18) => local6 + +expect/Vals.scala +_________________ + +Summary: +Schema => SemanticDB v4 +Uri => Vals.scala +Text => empty +Language => Scala +Symbols => 31 entries +Occurrences => 123 entries + +Symbols: +example/ValUsages. => final object ValUsages +example/ValUsages.``(). => primary ctor +example/ValUsages.v. => val method v +example/Vals# => abstract class Vals +example/Vals#``(). => primary ctor +example/Vals#`yam_=`(). => method yam_= +example/Vals#`yfm_=`(). => final method yfm_= +example/Vals#`yim_=`(). => method yim_= +example/Vals#`ym_=`(). => method ym_= +example/Vals#`yp_=`(). => method yp_= +example/Vals#m(). => method m +example/Vals#p. => val method p +example/Vals#xam. => val method xam +example/Vals#xfm. => final val method xfm +example/Vals#xim. => implicit val method xim +example/Vals#xlm. => val method xlm +example/Vals#xm. => val method xm +example/Vals#xp. => val method xp +example/Vals#xzlm. => lazy val method xzlm +example/Vals#xzm. => lazy val method xzm +example/Vals#yam(). => var method yam +example/Vals#yfm(). => final var method yfm +example/Vals#yim(). => implicit var method yim +example/Vals#ylm(). => var method ylm +example/Vals#ym(). => var method ym +example/Vals#yp(). => var method yp +local0 => val local xl +local1 => lazy val local xzl +local2 => implicit val local xil +local3 => var local yl +local4 => implicit var local yil + +Occurrences: +[0:8..0:15) => example/ +[2:15..2:19) => example/Vals# +[2:19..2:53) => example/Vals#``(). +[2:20..2:21) => example/Vals#p. +[2:23..2:26) => scala/Int# +[2:32..2:34) => example/Vals#xp. +[2:36..2:39) => scala/Int# +[2:45..2:47) => example/Vals#yp(). +[2:45..2:49) => example/Vals#`yp_=`(). +[2:49..2:52) => scala/Int# +[3:6..3:8) => example/Vals#xm. +[3:10..3:13) => scala/Int# +[3:16..3:19) => scala/Predef.`???`(). +[4:6..4:9) => example/Vals#xam. +[4:11..4:14) => scala/Int# +[5:20..5:23) => example/Vals#xlm. +[5:25..5:28) => scala/Int# +[5:31..5:34) => scala/Predef.`???`(). +[6:11..6:14) => example/Vals#xzm. +[6:16..6:19) => scala/Int# +[6:22..6:25) => scala/Predef.`???`(). +[7:25..7:29) => example/Vals#xzlm. +[7:31..7:34) => scala/Int# +[7:37..7:40) => scala/Predef.`???`(). +[8:12..8:15) => example/Vals#xfm. +[8:17..8:20) => scala/Int# +[8:23..8:26) => scala/Predef.`???`(). +[9:15..9:18) => example/Vals#xim. +[9:20..9:23) => scala/Int# +[9:26..9:29) => scala/Predef.`???`(). +[10:6..10:8) => example/Vals#ym(). +[10:6..10:10) => example/Vals#`ym_=`(). +[10:10..10:13) => scala/Int# +[10:16..10:19) => scala/Predef.`???`(). +[11:6..11:9) => example/Vals#yam(). +[11:6..11:11) => example/Vals#`yam_=`(). +[11:11..11:14) => scala/Int# +[12:20..12:23) => example/Vals#ylm(). +[12:25..12:28) => scala/Int# +[12:31..12:34) => scala/Predef.`???`(). +[16:12..16:15) => example/Vals#yfm(). +[16:12..16:17) => example/Vals#`yfm_=`(). +[16:17..16:20) => scala/Int# +[16:23..16:26) => scala/Predef.`???`(). +[17:15..17:18) => example/Vals#yim(). +[17:15..17:20) => example/Vals#`yim_=`(). +[17:20..17:23) => scala/Int# +[17:26..17:29) => scala/Predef.`???`(). +[18:6..18:7) => example/Vals#m(). +[19:8..19:10) => local0 +[19:12..19:15) => scala/Int# +[19:18..19:21) => scala/Predef.`???`(). +[20:13..20:16) => local1 +[20:18..20:21) => scala/Int# +[20:24..20:27) => scala/Predef.`???`(). +[23:17..23:20) => local2 +[23:22..23:25) => scala/Int# +[23:28..23:31) => scala/Predef.`???`(). +[24:8..24:10) => local3 +[24:12..24:15) => scala/Int# +[24:18..24:21) => scala/Predef.`???`(). +[29:17..29:20) => local4 +[29:22..29:25) => scala/Int# +[29:28..29:31) => scala/Predef.`???`(). +[30:4..30:6) => local3 +[30:9..30:11) => local0 +[30:12..30:13) => scala/Int#`+`(+4). +[30:14..30:16) => local3 +[31:4..31:11) => scala/Predef.println(+1). +[31:12..31:15) => local1 +[32:4..32:7) => local4 +[32:10..32:13) => local2 +[32:14..32:15) => scala/Int#`+`(+4). +[32:16..32:19) => local4 +[34:2..34:9) => scala/Predef.println(+1). +[34:10..34:14) => example/Vals#xzlm. +[35:2..35:5) => example/Vals#ylm(). +[35:8..35:11) => example/Vals#xlm. +[35:12..35:13) => scala/Int#`+`(+4). +[35:14..35:17) => example/Vals#ylm(). +[38:7..38:16) => example/ValUsages. +[39:2..39:2) => example/ValUsages.``(). +[39:6..39:7) => example/ValUsages.v. +[39:9..39:13) => example/Vals# +[39:16..39:19) => scala/Predef.`???`(). +[40:2..40:3) => example/ValUsages.v. +[40:4..40:6) => example/Vals#yp(). +[40:9..40:10) => example/ValUsages.v. +[40:11..40:13) => example/Vals#xp. +[40:14..40:15) => scala/Int#`+`(+4). +[40:16..40:17) => example/ValUsages.v. +[40:18..40:20) => example/Vals#yp(). +[41:2..41:3) => example/ValUsages.v. +[41:4..41:6) => example/Vals#ym(). +[41:9..41:10) => example/ValUsages.v. +[41:11..41:13) => example/Vals#xm. +[41:14..41:15) => scala/Int#`+`(+4). +[41:16..41:17) => example/ValUsages.v. +[41:18..41:20) => example/Vals#ym(). +[42:2..42:3) => example/ValUsages.v. +[42:4..42:7) => example/Vals#yam(). +[42:10..42:11) => example/ValUsages.v. +[42:12..42:15) => example/Vals#xam. +[42:16..42:17) => scala/Int#`+`(+4). +[42:18..42:19) => example/ValUsages.v. +[42:20..42:23) => example/Vals#yam(). +[43:2..43:9) => scala/Predef.println(+1). +[43:10..43:11) => example/ValUsages.v. +[43:12..43:15) => example/Vals#xzm. +[44:2..44:3) => example/ValUsages.v. +[44:4..44:7) => example/Vals#yfm(). +[44:10..44:11) => example/ValUsages.v. +[44:12..44:15) => example/Vals#xfm. +[44:16..44:17) => scala/Int#`+`(+4). +[44:18..44:19) => example/ValUsages.v. +[44:20..44:23) => example/Vals#yfm(). +[45:2..45:3) => example/ValUsages.v. +[45:4..45:7) => example/Vals#yim(). +[45:10..45:11) => example/ValUsages.v. +[45:12..45:15) => example/Vals#xim. +[45:16..45:17) => scala/Int#`+`(+4). +[45:18..45:19) => example/ValUsages.v. +[45:20..45:23) => example/Vals#yim(). + +expect/Vararg.scala +___________________ + +Summary: +Schema => SemanticDB v4 +Uri => Vararg.scala +Text => empty +Language => Scala +Symbols => 6 entries +Occurrences => 11 entries + +Symbols: +example/Vararg# => class Vararg +example/Vararg#``(). => primary ctor +example/Vararg#add1(). => method add1 +example/Vararg#add1().(a) => val param a +example/Vararg#add2(). => method add2 +example/Vararg#add2().(a) => val param a + +Occurrences: +[0:8..0:15) => example/ +[2:6..2:12) => example/Vararg# +[3:2..3:2) => example/Vararg#``(). +[3:6..3:10) => example/Vararg#add1(). +[3:11..3:12) => example/Vararg#add1().(a) +[3:14..3:17) => scala/Int# +[4:6..4:10) => example/Vararg#add2(). +[4:11..4:12) => example/Vararg#add2().(a) +[4:14..4:17) => scala/package.Seq# +[4:18..4:21) => scala/Int# +[4:26..4:30) => scala/Unit# + +expect/filename with spaces.scala +_________________________________ + +Summary: +Schema => SemanticDB v4 +Uri => filename with spaces.scala +Text => empty +Language => Scala +Symbols => 2 entries +Occurrences => 3 entries + +Symbols: +example/FilenameWithSpaces# => class FilenameWithSpaces +example/FilenameWithSpaces#``(). => primary ctor + +Occurrences: +[0:8..0:15) => example/ +[2:0..2:0) => example/FilenameWithSpaces#``(). +[2:6..2:24) => example/FilenameWithSpaces# + +expect/local-file.scala +_______________________ + +Summary: +Schema => SemanticDB v4 +Uri => local-file.scala +Text => empty +Language => Scala +Symbols => 3 entries +Occurrences => 7 entries + +Symbols: +example/`local-file`# => class local-file +example/`local-file`#``(). => primary ctor +local0 => val local local + +Occurrences: +[0:8..0:15) => example/ +[2:7..2:17) => example/`local-file`# +[3:2..3:2) => example/`local-file`#``(). +[3:2..3:9) => dotty/DottyPredef.locally(). +[4:8..4:13) => local0 +[5:4..5:9) => local0 +[5:10..5:11) => scala/Int#`+`(+4). + +expect/semanticdb-extract.scala +_______________________________ + +Summary: +Schema => SemanticDB v4 +Uri => semanticdb-extract.scala +Text => empty +Language => Scala +Symbols => 9 entries +Occurrences => 25 entries + +Symbols: +_empty_/AnObject. => final object AnObject +_empty_/AnObject.Foo# => case class Foo +_empty_/AnObject.Foo#``(). => primary ctor +_empty_/AnObject.Foo#x. => val method x +_empty_/AnObject.Foo.``(). => primary ctor +_empty_/AnObject.``(). => primary ctor +_empty_/AnObject.foo(). => method foo +_empty_/AnObject.foo().(x) => val param x +_empty_/AnObject.foo(+1). => method foo + +Occurrences: +[0:0..0:0) => _empty_/ +[0:7..0:15) => _empty_/AnObject. +[2:2..2:2) => _empty_/AnObject.``(). +[2:6..2:9) => _empty_/AnObject.foo(). +[2:10..2:11) => _empty_/AnObject.foo().(x) +[2:13..2:16) => scala/Int# +[3:6..3:9) => _empty_/AnObject.foo(+1). +[3:13..3:17) => scala/Unit# +[5:2..5:5) => _empty_/AnObject.foo(). +[6:2..6:5) => _empty_/AnObject.foo(+1). +[8:5..8:14) => java/lang/String#substring(). +[9:5..9:14) => java/lang/String#substring(+1). +[11:2..11:6) => scala/package.List. +[11:6..11:6) => scala/collection/IterableFactory#apply(). +[12:2..12:6) => scala/package.List. +[12:7..12:12) => scala/collection/IterableFactory#apply(). +[13:2..13:6) => scala/package.List. +[13:8..13:14) => scala/collection/IterableFactory#apply(). +[14:2..14:9) => scala/Predef.println(+1). +[14:12..14:13) => scala/Int#`+`(+4). +[16:2..16:2) => _empty_/AnObject.Foo.``(). +[16:13..16:16) => _empty_/AnObject.Foo# +[16:16..16:24) => _empty_/AnObject.Foo#``(). +[16:17..16:18) => _empty_/AnObject.Foo#x. +[16:20..16:23) => scala/Int# + +expect/toplevel.scala +_____________________ + +Summary: +Schema => SemanticDB v4 +Uri => toplevel.scala +Text => empty +Language => Scala +Symbols => 12 entries +Occurrences => 26 entries + +Symbols: +_empty_/toplevel$package. => final package object _empty_ +_empty_/toplevel$package.``(). => primary ctor +_empty_/toplevel$package.a. => val method a +_empty_/toplevel$package.combine(). => method combine +_empty_/toplevel$package.combine().(x) => val param x +_empty_/toplevel$package.combine().(y) => val param y +_empty_/toplevel$package.combine(+1). => method combine +_empty_/toplevel$package.combine(+1).(x) => val param x +_empty_/toplevel$package.combine(+1).(y) => val param y +_empty_/toplevel$package.combine(+1).(z) => val param z +_empty_/toplevel$package.combine(+2). => method combine +_empty_/toplevel$package.foo(). => method foo + +Occurrences: +[0:0..0:0) => _empty_/ +[0:0..0:16) => _empty_/toplevel$package. +[0:0..0:0) => _empty_/toplevel$package.``(). +[0:11..0:12) => _empty_/toplevel$package.a. +[1:4..1:11) => _empty_/toplevel$package.combine(). +[1:5..1:6) => _empty_/toplevel$package.combine().(x) +[1:8..1:11) => scala/Int# +[1:22..1:23) => _empty_/toplevel$package.combine().(y) +[1:25..1:28) => scala/Int# +[1:32..1:33) => _empty_/toplevel$package.combine().(x) +[1:34..1:35) => scala/Int#`+`(+4). +[1:36..1:37) => _empty_/toplevel$package.combine().(y) +[2:4..2:11) => _empty_/toplevel$package.combine(+1). +[2:12..2:13) => _empty_/toplevel$package.combine(+1).(x) +[2:15..2:18) => scala/Int# +[2:20..2:21) => _empty_/toplevel$package.combine(+1).(y) +[2:23..2:26) => scala/Int# +[2:28..2:29) => _empty_/toplevel$package.combine(+1).(z) +[2:31..2:34) => scala/Int# +[2:38..2:39) => _empty_/toplevel$package.combine(+1).(x) +[2:40..2:41) => scala/Int#`+`(+4). +[2:42..2:43) => _empty_/toplevel$package.combine(+1).(y) +[2:44..2:45) => scala/Int#`+`(+4). +[2:46..2:47) => _empty_/toplevel$package.combine(+1).(z) +[3:4..3:11) => _empty_/toplevel$package.combine(+2). +[4:4..4:7) => _empty_/toplevel$package.foo(). From f54a997414c2d6ed081735202d7a0bec29c56346 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 15 Nov 2019 13:34:01 +0100 Subject: [PATCH 061/107] optimise some definitions --- .../tools/dotc/semanticdb/Language.scala | 2 +- .../dotty/tools/dotc/semanticdb/Range.scala | 2 +- .../dotty/tools/dotc/semanticdb/Scala.scala | 19 ++++++++++++------- .../dotty/tools/dotc/semanticdb/Schema.scala | 2 +- .../dotc/semanticdb/SymbolInformation.scala | 2 +- .../dotc/semanticdb/SymbolOccurrence.scala | 4 ++-- .../tools/dotc/semanticdb/TextDocument.scala | 2 +- .../tools/dotc/semanticdb/TextDocuments.scala | 6 ++---- 8 files changed, 21 insertions(+), 18 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala index 482f11adc85a..eeaac6d4e643 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Language.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Language.scala @@ -15,7 +15,7 @@ object Language { case 0 => UNKNOWN_LANGUAGE case 1 => SCALA case 2 => JAVA - case __other => Unrecognized(__other) + case id => Unrecognized(id) } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala index 87f6d8116a2c..ad4249d0b53c 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Range.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Range.scala @@ -4,7 +4,7 @@ import dotty.tools.dotc.semanticdb.internal._ import scala.annotation.internal.sharable object Range { - lazy val defaultInstance: Range = Range(0, 0, 0, 0) + val defaultInstance: Range = Range(0, 0, 0, 0) } final case class Range( diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala index 81c48923f4ec..a8ee1ee96473 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala @@ -4,6 +4,9 @@ import dotty.tools.dotc.core.Symbols.{ Symbol => DottySymbol, defn } import dotty.tools.dotc.core.Contexts.Context import dotty.tools.dotc.core.Flags._ +import scala.annotation.internal.sharable +import scala.annotation.switch + object Scala with object Symbols with @@ -28,13 +31,13 @@ object Scala with else symbol.name.show - - private val locals = raw"local(\d+)" + @sharable + private val locals = raw"local(\d+)".r object LocalSymbol with def unapply(symbolInfo: SymbolInformation): Option[Int] = symbolInfo.symbol match - case locals.r(ints) => + case locals(ints) => val bi = BigInt(ints) if bi.isValidInt then Some(bi.toInt) else None case _ => None @@ -48,14 +51,16 @@ object Scala with def isEmptyPackage: Boolean = symbol == Symbols.EmptyPackage def isGlobal: Boolean = - !symbol.isNoSymbol && !symbol.isMulti && (symbol.last match { + !symbol.isNoSymbol + && !symbol.isMulti + && { (symbol.last: @switch) match case '.' | '#' | '/' | ')' | ']' => true case _ => false - }) + } def isLocal: Boolean = - symbol.matches(locals) + locals matches symbol def isMulti: Boolean = - symbol.startsWith(";") + symbol startsWith ";" def isTerm: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '.' def isType: Boolean = diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala index 58571efadb10..e23f2cccca6d 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Schema.scala @@ -15,7 +15,7 @@ object Schema { case 0 => LEGACY case 3 => SEMANTICDB3 case 4 => SEMANTICDB4 - case __other => Unrecognized(__other) + case id => Unrecognized(id) } } diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala index fbc49d25939a..5a5f2c0b4e1e 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolInformation.scala @@ -5,7 +5,7 @@ import scala.annotation.internal.sharable object SymbolInformation { - lazy val defaultInstance = SymbolInformation("", Language.UNKNOWN_LANGUAGE, SymbolInformation.Kind.UNKNOWN_KIND, 0, "") + val defaultInstance = SymbolInformation("", Language.UNKNOWN_LANGUAGE, SymbolInformation.Kind.UNKNOWN_KIND, 0, "") sealed trait Kind(val value: Int) extends SemanticdbEnum derives Eql { def isUnknownKind: Boolean = this == Kind.UNKNOWN_KIND diff --git a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala index 5b3ce8e53d83..594e265fda4d 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/SymbolOccurrence.scala @@ -21,12 +21,12 @@ object SymbolOccurrence { case 0 => UNKNOWN_ROLE case 1 => REFERENCE case 2 => DEFINITION - case __other => Unrecognized(__other) + case id => Unrecognized(id) } } - lazy val defaultInstance: SymbolOccurrence = SymbolOccurrence("", None, Role.UNKNOWN_ROLE) + val defaultInstance: SymbolOccurrence = SymbolOccurrence("", None, Role.UNKNOWN_ROLE) } final case class SymbolOccurrence( diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala index 02e3e040ab46..b81632bdd12f 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocument.scala @@ -4,7 +4,7 @@ import dotty.tools.dotc.semanticdb.internal._ import scala.annotation.internal.sharable object TextDocument { - lazy val defaultInstance: TextDocument = TextDocument(Schema.LEGACY, Language.UNKNOWN_LANGUAGE, "", "", "", Nil, Nil) + val defaultInstance: TextDocument = TextDocument(Schema.LEGACY, Language.UNKNOWN_LANGUAGE, "", "", "", Nil, Nil) } final case class TextDocument( diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala index 1751dfaad186..4e56641fe3c3 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/TextDocuments.scala @@ -10,7 +10,7 @@ object TextDocuments { def parseFrom(in: SemanticdbInputStream): TextDocuments = { defaultInstance.mergeFrom(in) } - lazy val defaultInstance: TextDocuments = TextDocuments(Nil) + val defaultInstance: TextDocuments = TextDocuments(Nil) } final case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbMessage[TextDocuments] derives Eql { @sharable @@ -53,8 +53,6 @@ final case class TextDocuments(documents: Seq[TextDocument]) extends SemanticdbM case tag => _input__.skipField(tag) } } - TextDocuments( - documents = __documents.result() - ) + TextDocuments(documents = __documents.result()) } } From cbaf51e6e5fd9200a3fb7ee118cd7c56b32d5b57 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 15 Nov 2019 13:57:31 +0100 Subject: [PATCH 062/107] don't make symbols or occurrences for constructors of objects --- .../dotc/semanticdb/ExtractSemanticDB.scala | 6 +- tests/semanticdb/metac.expect | 205 ++++-------------- 2 files changed, 51 insertions(+), 160 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 6a48b36340a7..8614022fb630 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -201,6 +201,7 @@ class ExtractSemanticDB extends Phase { !sym.exists || sym.isLocalDummy || sym.is(Synthetic) || (sym.owner.is(Synthetic) && !sym.isAllOf(EnumCase)) + || sym.name == nme.CONSTRUCTOR && sym.owner.is(ModuleClass) || sym.isAnonymous || excludeDefStrict(sym) @@ -341,8 +342,9 @@ class ExtractSemanticDB extends Phase { traverseChildren(tree) case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => - registerDefinition(tree.constr.symbol, tree.constr.span, SymbolKind.Other) - tree.constr.vparamss.flatten.foreach(vparam => traverse(vparam.tpt)) // the accessor symbol is traversed in the body + if !excludeDef(tree.constr.symbol) + registerDefinition(tree.constr.symbol, tree.constr.span, SymbolKind.Other) + tree.constr.vparamss.flatten.foreach(vparam => traverse(vparam.tpt)) // the accessor symbol is traversed in the body for parent <- tree.parentsOrDerived do if parent.symbol != defn.ObjectClass.primaryConstructor diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 556071160925..8ea05b853583 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -49,8 +49,8 @@ Schema => SemanticDB v4 Uri => Advanced.scala Text => empty Language => Scala -Symbols => 35 entries -Occurrences => 97 entries +Symbols => 34 entries +Occurrences => 96 entries Symbols: advanced/C# => class C @@ -63,7 +63,6 @@ advanced/Structural#s1(). => method s1 advanced/Structural#s2(). => method s2 advanced/Structural#s3(). => method s3 advanced/Test. => final object Test -advanced/Test.``(). => primary ctor advanced/Test.e. => val method e advanced/Test.e1. => val method e1 advanced/Test.e1x. => val method e1x @@ -139,7 +138,6 @@ Occurrences: [18:10..18:14) => scala/package.List# [18:20..18:23) => scala/Predef.`???`(). [21:7..21:11) => advanced/Test. -[22:2..22:2) => advanced/Test.``(). [22:6..22:7) => advanced/Test.s. [22:14..22:24) => advanced/Structural# [22:24..22:24) => advanced/Structural#``(). @@ -196,13 +194,12 @@ Schema => SemanticDB v4 Uri => Annotations.scala Text => empty Language => Scala -Symbols => 22 entries -Occurrences => 53 entries +Symbols => 20 entries +Occurrences => 51 entries Symbols: annot/Alias. => final object Alias annot/Alias.A# => type A -annot/Alias.``(). => primary ctor annot/Annotations# => class Annotations annot/Annotations#S# => type S annot/Annotations#[T] => typeparam T @@ -215,7 +212,6 @@ annot/B#``(). => primary ctor annot/B#``(+1). => ctor annot/B#x. => val method x annot/M. => final object M -annot/M.``(). => primary ctor annot/M.m(). => method m annot/M.m().[TT] => typeparam TT annot/T# => class T @@ -264,7 +260,6 @@ Occurrences: [23:20..23:20) => annot/B#``(). [26:1..26:17) => com/javacp/annot/ObjectAnnotation# [27:7..27:8) => annot/M. -[28:2..28:2) => annot/M.``(). [28:3..28:18) => com/javacp/annot/MacroAnnotation# [29:6..29:7) => annot/M.m(). [29:8..29:10) => annot/M.m().[TT] @@ -274,7 +269,6 @@ Occurrences: [32:1..32:16) => com/javacp/annot/TraitAnnotation# [33:6..33:7) => annot/T# [35:7..35:12) => annot/Alias. -[36:2..36:2) => annot/Alias.``(). [36:7..36:8) => annot/Alias.A# [36:11..36:26) => com/javacp/annot/ClassAnnotation# @@ -348,32 +342,27 @@ Schema => SemanticDB v4 Uri => Classes.scala Text => empty Language => Scala -Symbols => 42 entries -Occurrences => 65 entries +Symbols => 35 entries +Occurrences => 58 entries Symbols: classes/C1# => final class C1 classes/C1#``(). => primary ctor classes/C1#x1. => val method x1 -classes/C1.``(). => primary ctor classes/C2# => final class C2 classes/C2#``(). => primary ctor classes/C2#x2. => val method x2 classes/C2. => final object C2 -classes/C2.``(). => primary ctor classes/C3# => case class C3 classes/C3#``(). => primary ctor classes/C3#x. => val method x -classes/C3.``(). => primary ctor classes/C4# => case class C4 classes/C4#``(). => primary ctor classes/C4#x. => val method x classes/C4. => final object C4 -classes/C4.``(). => primary ctor classes/C6# => case class C6 classes/C6#``(). => primary ctor classes/C6#x. => val method x -classes/C6.``(). => primary ctor classes/C7# => class C7 classes/C7#``(). => primary ctor classes/C7#x. => val method x @@ -387,9 +376,7 @@ classes/M. => final object M classes/M.C5# => class C5 classes/M.C5#``(). => primary ctor classes/M.C5#x. => val method x -classes/M.``(). => primary ctor classes/N. => final object N -classes/N.``(). => primary ctor classes/N.anonClass. => val method anonClass classes/N.anonFun. => val method anonFun local0 => primary ctor @@ -397,7 +384,6 @@ local1 => val method local Occurrences: [0:8..0:15) => classes/ -[2:0..2:0) => classes/C1.``(). [2:6..2:8) => classes/C1# [2:8..2:21) => classes/C1#``(). [2:13..2:15) => classes/C1#x1. @@ -410,9 +396,7 @@ Occurrences: [4:17..4:20) => scala/Int# [4:30..4:36) => scala/AnyVal# [4:36..4:36) => scala/AnyVal#``(). -[5:0..5:0) => classes/C2.``(). [5:7..5:9) => classes/C2. -[7:0..7:0) => classes/C3.``(). [7:11..7:13) => classes/C3# [7:13..7:21) => classes/C3#``(). [7:14..7:15) => classes/C3#x. @@ -421,15 +405,12 @@ Occurrences: [9:13..9:21) => classes/C4#``(). [9:14..9:15) => classes/C4#x. [9:17..9:20) => scala/Int# -[10:0..10:0) => classes/C4.``(). [10:7..10:9) => classes/C4. [12:7..12:8) => classes/M. -[13:2..13:2) => classes/M.``(). [13:17..13:19) => classes/M.C5# [13:19..13:27) => classes/M.C5#``(). [13:20..13:21) => classes/M.C5#x. [13:23..13:26) => scala/Int# -[16:0..16:0) => classes/C6.``(). [16:11..16:13) => classes/C6# [16:13..16:33) => classes/C6#``(). [16:26..16:27) => classes/C6#x. @@ -447,7 +428,6 @@ Occurrences: [22:27..22:28) => classes/C9#x(). [22:30..22:33) => scala/Int# [24:7..24:8) => classes/N. -[25:2..25:2) => classes/N.``(). [25:6..25:15) => classes/N.anonClass. [25:22..25:22) => local0 [25:22..25:24) => classes/C7# @@ -470,8 +450,8 @@ Schema => SemanticDB v4 Uri => Definitions.scala Text => empty Language => Scala -Symbols => 10 entries -Occurrences => 11 entries +Symbols => 9 entries +Occurrences => 10 entries Symbols: a/Definitions. => final object Definitions @@ -479,7 +459,6 @@ a/Definitions.D# => class D a/Definitions.D#``(). => primary ctor a/Definitions.E# => class E a/Definitions.E#``(). => primary ctor -a/Definitions.``(). => primary ctor a/Definitions.`b_=`(). => method b_= a/Definitions.a. => val method a a/Definitions.b(). => var method b @@ -488,7 +467,6 @@ a/Definitions.c(). => method c Occurrences: [0:8..0:9) => a/ [1:7..1:18) => a/Definitions. -[2:2..2:2) => a/Definitions.``(). [2:6..2:7) => a/Definitions.a. [3:6..3:7) => a/Definitions.b(). [3:6..3:9) => a/Definitions.`b_=`(). @@ -538,16 +516,14 @@ Schema => SemanticDB v4 Uri => EmptyObject.scala Text => empty Language => Scala -Symbols => 2 entries -Occurrences => 3 entries +Symbols => 1 entries +Occurrences => 2 entries Symbols: example/EmptyObject. => final object EmptyObject -example/EmptyObject.``(). => primary ctor Occurrences: [0:8..0:15) => example/ -[2:0..2:0) => example/EmptyObject.``(). [2:7..2:18) => example/EmptyObject. expect/Enums.scala @@ -558,8 +534,8 @@ Schema => SemanticDB v4 Uri => Enums.scala Text => empty Language => Scala -Symbols => 75 entries -Occurrences => 165 entries +Symbols => 66 entries +Occurrences => 156 entries Symbols: _empty_/Enums. => final object Enums @@ -568,16 +544,13 @@ _empty_/Enums.Colour#``(). => primary ctor _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.``(). => primary ctor _empty_/Enums.Maybe# => abstract sealed enum class Maybe _empty_/Enums.Maybe#[A] => covariant typeparam A _empty_/Enums.Maybe#``(). => primary ctor _empty_/Enums.Maybe.Just# => final case enum class Just _empty_/Enums.Maybe.Just#``(). => primary ctor _empty_/Enums.Maybe.Just#value. => val method value -_empty_/Enums.Maybe.Just.``(). => primary ctor _empty_/Enums.Maybe.None. => case val static enum method None -_empty_/Enums.Maybe.``(). => primary ctor _empty_/Enums.Planet# => abstract sealed enum class Planet _empty_/Enums.Planet#G. => final val method G _empty_/Enums.Planet#``(). => primary ctor @@ -594,13 +567,11 @@ _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.``(). => primary ctor _empty_/Enums.Tag# => abstract sealed enum class Tag _empty_/Enums.Tag#[A] => typeparam A _empty_/Enums.Tag#``(). => primary ctor _empty_/Enums.Tag.BooleanTag. => case val static enum method BooleanTag _empty_/Enums.Tag.IntTag. => case val static enum method IntTag -_empty_/Enums.Tag.``(). => primary ctor _empty_/Enums.WeekDays# => abstract sealed enum class WeekDays _empty_/Enums.WeekDays#``(). => primary ctor _empty_/Enums.WeekDays.Friday. => case val static enum method Friday @@ -610,8 +581,6 @@ _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.``(). => primary ctor -_empty_/Enums.``(). => primary ctor _empty_/Enums.`=:=`# => abstract sealed enum class =:= _empty_/Enums.`=:=`#[A] => typeparam A _empty_/Enums.`=:=`#[B] => typeparam B @@ -619,8 +588,6 @@ _empty_/Enums.`=:=`#``(). => primary ctor _empty_/Enums.`=:=`.Refl# => final case enum class Refl _empty_/Enums.`=:=`.Refl#[C] => typeparam C _empty_/Enums.`=:=`.Refl#``(). => primary ctor -_empty_/Enums.`=:=`.Refl.``(). => primary ctor -_empty_/Enums.`=:=`.``(). => primary ctor _empty_/Enums.unwrap(). => method unwrap _empty_/Enums.unwrap().(ev) => implicit val param ev _empty_/Enums.unwrap().(opt) => val param opt @@ -641,11 +608,9 @@ local10 => primary ctor Occurrences: [0:0..0:0) => _empty_/ [0:7..0:12) => _empty_/Enums. -[1:2..1:2) => _empty_/Enums.``(). [1:9..1:12) => _empty_/Enums.`=:=`. [3:7..3:13) => _empty_/Enums.Colour# [4:4..4:4) => _empty_/Enums.Colour#``(). -[4:4..4:4) => _empty_/Enums.Colour.``(). [4:9..4:12) => _empty_/Enums.Colour.Red. [4:9..4:9) => scala/runtime/EnumValues#``(). [4:9..4:12) => _empty_/Enums.Colour.Red. @@ -655,7 +620,6 @@ Occurrences: [4:21..4:25) => _empty_/Enums.Colour.Blue. [6:7..6:15) => _empty_/Enums.WeekDays# [7:4..7:4) => _empty_/Enums.WeekDays#``(). -[7:4..7:4) => _empty_/Enums.WeekDays.``(). [7:4..7:4) => scala/runtime/EnumValues#``(). [7:9..7:15) => _empty_/Enums.WeekDays.Monday. [8:9..8:16) => _empty_/Enums.WeekDays.Tuesday. @@ -667,9 +631,7 @@ Occurrences: [15:7..15:12) => _empty_/Enums.Maybe# [15:12..15:16) => _empty_/Enums.Maybe#``(). [15:14..15:15) => _empty_/Enums.Maybe#[A] -[16:4..16:4) => _empty_/Enums.Maybe.``(). [16:4..16:4) => _empty_/Enums.Maybe#``(). -[16:4..16:4) => _empty_/Enums.Maybe.Just.``(). [16:9..16:13) => _empty_/Enums.Maybe.Just# [16:13..16:23) => _empty_/Enums.Maybe.Just#``(). [16:14..16:19) => _empty_/Enums.Maybe.Just#value. @@ -681,7 +643,6 @@ Occurrences: [19:7..19:10) => _empty_/Enums.Tag# [19:10..19:13) => _empty_/Enums.Tag#``(). [19:11..19:12) => _empty_/Enums.Tag#[A] -[20:4..20:4) => _empty_/Enums.Tag.``(). [20:9..20:15) => _empty_/Enums.Tag.IntTag. [20:24..20:24) => local1 [20:24..20:27) => _empty_/Enums.Tag# @@ -698,8 +659,6 @@ Occurrences: [23:10..23:16) => _empty_/Enums.`=:=`#``(). [23:11..23:12) => _empty_/Enums.`=:=`#[A] [23:14..23:15) => _empty_/Enums.`=:=`#[B] -[24:4..24:4) => _empty_/Enums.`=:=`.``(). -[24:4..24:4) => _empty_/Enums.`=:=`.Refl.``(). [24:9..24:13) => _empty_/Enums.`=:=`.Refl# [24:13..24:18) => _empty_/Enums.`=:=`.Refl#``(). [24:14..24:15) => _empty_/Enums.`=:=`.Refl#[C] @@ -754,7 +713,6 @@ Occurrences: [33:43..33:52) => _empty_/Enums.Planet#surfaceWeight().(otherMass) [33:53..33:54) => scala/Double#`*`(+6). [33:55..33:69) => _empty_/Enums.Planet#surfaceGravity(). -[35:4..35:4) => _empty_/Enums.Planet.``(). [35:9..35:16) => _empty_/Enums.Planet.Mercury. [35:25..35:25) => scala/runtime/EnumValues#``(). [35:25..35:25) => local3 @@ -840,12 +798,11 @@ Schema => SemanticDB v4 Uri => Example.scala Text => empty Language => Scala -Symbols => 6 entries -Occurrences => 28 entries +Symbols => 5 entries +Occurrences => 27 entries Symbols: example/Example. => final object Example -example/Example.``(). => primary ctor example/Example.main(). => method main example/Example.main().(args) => val param args example/Example.x. => val method x @@ -858,7 +815,6 @@ Occurrences: [2:24..2:30) => scala/concurrent/Future. [2:24..2:30) => scala/concurrent/Future# [4:7..4:14) => example/Example. -[4:17..4:17) => example/Example.``(). [4:17..4:21) => local0 [4:17..4:17) => example/Example. [5:6..5:11) => scala/ @@ -889,8 +845,8 @@ Schema => SemanticDB v4 Uri => Flags.scala Text => empty Language => Scala -Symbols => 46 entries -Occurrences => 86 entries +Symbols => 44 entries +Occurrences => 84 entries Symbols: flags/p/package. => final package object p @@ -922,12 +878,10 @@ 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.X.``(). => primary ctor flags/p/package.Y# => final class Y flags/p/package.Y#``(). => primary ctor flags/p/package.Z# => sealed class Z flags/p/package.Z#``(). => primary ctor -flags/p/package.``(). => primary ctor flags/p/package.`y_=`(). => method y_= flags/p/package.m(). => method m flags/p/package.m().[TT] => typeparam TT @@ -948,7 +902,6 @@ Occurrences: [2:35..2:41) => scalaShadowing/language.experimental.macros. [4:0..4:0) => flags/p/ [4:15..5:3) => flags/p/package. -[5:2..5:2) => flags/p/package.``(). [5:2..5:3) => flags/p/ [5:19..5:20) => flags/p/package.x. [6:25..6:26) => flags/p/package.y(). @@ -992,7 +945,6 @@ Occurrences: [15:12..15:15) => scala/Int# [16:7..16:8) => flags/p/package.V# [16:12..16:15) => scala/Int# -[17:2..17:2) => flags/p/package.X.``(). [17:14..17:15) => flags/p/package.X. [18:2..18:2) => flags/p/package.Y#``(). [18:14..18:15) => flags/p/package.Y# @@ -1116,8 +1068,8 @@ Schema => SemanticDB v4 Uri => Givens.scala Text => empty Language => Scala -Symbols => 25 entries -Occurrences => 55 entries +Symbols => 22 entries +Occurrences => 52 entries Symbols: a/b/Givens. => final object Givens @@ -1128,18 +1080,15 @@ a/b/Givens.Monoid#combine(). => method combine a/b/Givens.Monoid#combine().(x) => val param x a/b/Givens.Monoid#combine().(y) => val param y a/b/Givens.Monoid#empty(). => method empty -a/b/Givens.``(). => primary ctor a/b/Givens.foo(). => method foo a/b/Givens.foo().(A) => implicit val param A a/b/Givens.foo().[A] => typeparam A a/b/Givens.given_Monoid_String. => final object given_Monoid_String -a/b/Givens.given_Monoid_String.``(). => primary ctor a/b/Givens.given_Monoid_String.combine(). => method combine a/b/Givens.given_Monoid_String.combine().(x) => val param x a/b/Givens.given_Monoid_String.combine().(y) => val param y a/b/Givens.given_Monoid_String.empty(). => method empty a/b/Givens.given_sayHello_of_A. => final object given_sayHello_of_A -a/b/Givens.given_sayHello_of_A.``(). => primary ctor a/b/Givens.given_sayHello_of_A.sayHello(). => method sayHello a/b/Givens.given_sayHello_of_A.sayHello().(any) => val param any a/b/Givens.given_sayHello_of_A.sayHello().[A] => typeparam A @@ -1150,12 +1099,10 @@ Occurrences: [0:8..0:9) => a/ [1:8..1:9) => a/b/ [3:7..3:13) => a/b/Givens. -[5:2..5:2) => a/b/Givens.``(). [5:8..6:6) => a/b/Givens.given_sayHello_of_A. [5:10..5:11) => a/b/Givens.given_sayHello_of_A.sayHello().[A] [5:13..5:16) => a/b/Givens.given_sayHello_of_A.sayHello().(any) [5:18..5:19) => a/b/Givens.given_sayHello_of_A.sayHello().[A] -[6:4..6:4) => a/b/Givens.given_sayHello_of_A.``(). [6:8..6:16) => a/b/Givens.given_sayHello_of_A.sayHello(). [6:34..6:37) => a/b/Givens.given_sayHello_of_A.sayHello().(any) [6:37..6:37) => scala/StringContext#s(). @@ -1173,7 +1120,6 @@ Occurrences: [12:27..12:28) => a/b/Givens.Monoid#[A] [12:31..12:32) => a/b/Givens.Monoid#[A] [14:8..15:4) => a/b/Givens.given_Monoid_String. -[14:8..14:8) => a/b/Givens.given_Monoid_String.``(). [14:8..14:14) => a/b/Givens.Monoid# [14:15..14:21) => scala/Predef.String# [15:8..15:13) => a/b/Givens.given_Monoid_String.empty(). @@ -1211,8 +1157,8 @@ Schema => SemanticDB v4 Uri => ImplicitConversion.scala Text => empty Language => Scala -Symbols => 20 entries -Occurrences => 60 entries +Symbols => 18 entries +Occurrences => 58 entries Symbols: example/ImplicitConversion# => class ImplicitConversion @@ -1227,14 +1173,12 @@ example/ImplicitConversion#string2Number().(string) => val param string example/ImplicitConversion#tuple. => val method tuple example/ImplicitConversion#x. => val method x example/ImplicitConversion. => final object ImplicitConversion -example/ImplicitConversion.``(). => primary ctor example/ImplicitConversion.newAny2stringadd# => final class newAny2stringadd example/ImplicitConversion.newAny2stringadd#[A] => typeparam A example/ImplicitConversion.newAny2stringadd#`+`(). => method + example/ImplicitConversion.newAny2stringadd#`+`().(other) => val param other example/ImplicitConversion.newAny2stringadd#``(). => primary ctor example/ImplicitConversion.newAny2stringadd#self. => val method self -example/ImplicitConversion.newAny2stringadd.``(). => primary ctor Occurrences: [0:8..0:15) => example/ @@ -1279,8 +1223,6 @@ Occurrences: [29:16..29:16) => scala/Char.char2long(). [29:16..29:20) => example/ImplicitConversion#char. [32:7..32:25) => example/ImplicitConversion. -[33:2..33:2) => example/ImplicitConversion.``(). -[33:2..33:2) => example/ImplicitConversion.newAny2stringadd.``(). [33:23..33:39) => example/ImplicitConversion.newAny2stringadd# [33:39..33:63) => example/ImplicitConversion.newAny2stringadd#``(). [33:40..33:41) => example/ImplicitConversion.newAny2stringadd#[A] @@ -1485,19 +1427,17 @@ Schema => SemanticDB v4 Uri => Locals.scala Text => empty Language => Scala -Symbols => 4 entries -Occurrences => 8 entries +Symbols => 3 entries +Occurrences => 7 entries Symbols: local0 => val local x locals/Test. => final object Test -locals/Test.``(). => primary ctor locals/Test.xs. => val method xs Occurrences: [0:8..0:14) => locals/ [2:7..2:11) => locals/Test. -[3:2..3:2) => locals/Test.``(). [3:6..3:8) => locals/Test.xs. [4:8..4:9) => local0 [5:4..5:8) => scala/package.List. @@ -1701,8 +1641,8 @@ Schema => SemanticDB v4 Uri => Methods.scala Text => empty Language => Scala -Symbols => 70 entries -Occurrences => 140 entries +Symbols => 69 entries +Occurrences => 139 entries Symbols: example/Methods# => class Methods @@ -1761,7 +1701,6 @@ example/Methods#m17().(a) => val param a example/Methods#m17(+1). => method m17 example/Methods#m17(+1).(b) => val param b example/Methods#m17. => final object m17 -example/Methods#m17.``(). => primary ctor example/Methods#m17.m(). => method m example/Methods#m18(). => method m18 example/Methods#m18().(a) => val param a @@ -1886,7 +1825,6 @@ Occurrences: [28:13..28:16) => scala/Int# [28:21..28:24) => scala/Predef.`???`(). [29:9..29:12) => example/Methods#m17. -[29:15..29:15) => example/Methods#m17.``(). [29:19..29:20) => example/Methods#m17.m(). [29:25..29:28) => scala/Predef.`???`(). [30:6..30:9) => example/Methods#m17(). @@ -1926,8 +1864,8 @@ Schema => SemanticDB v4 Uri => NamedApplyBlock.scala Text => empty Language => Scala -Symbols => 19 entries -Occurrences => 38 entries +Symbols => 16 entries +Occurrences => 35 entries Symbols: example/NamedApplyBlockCaseClassConstruction. => final object NamedApplyBlockCaseClassConstruction @@ -1936,12 +1874,9 @@ example/NamedApplyBlockCaseClassConstruction.Msg#``(). => primary ctor val method body example/NamedApplyBlockCaseClassConstruction.Msg#head. => val method head example/NamedApplyBlockCaseClassConstruction.Msg#tail. => val method tail -example/NamedApplyBlockCaseClassConstruction.Msg.``(). => primary ctor -example/NamedApplyBlockCaseClassConstruction.``(). => primary ctor example/NamedApplyBlockCaseClassConstruction.bodyText. => val method bodyText example/NamedApplyBlockCaseClassConstruction.msg. => val method msg example/NamedApplyBlockMethods. => final object NamedApplyBlockMethods -example/NamedApplyBlockMethods.``(). => primary ctor example/NamedApplyBlockMethods.baseCase(). => method baseCase example/NamedApplyBlockMethods.foo(). => method foo example/NamedApplyBlockMethods.foo().(a) => val param a @@ -1953,7 +1888,6 @@ example/NamedApplyBlockMethods.recursive(). => method recursive Occurrences: [0:8..0:15) => example/ [2:7..2:29) => example/NamedApplyBlockMethods. -[3:2..3:2) => example/NamedApplyBlockMethods.``(). [3:6..3:11) => example/NamedApplyBlockMethods.local. [4:6..4:9) => example/NamedApplyBlockMethods.foo(). [4:10..4:11) => example/NamedApplyBlockMethods.foo().(a) @@ -1975,8 +1909,6 @@ Occurrences: [6:18..6:21) => example/NamedApplyBlockMethods.foo(). [6:22..6:27) => example/NamedApplyBlockMethods.local. [9:7..9:43) => example/NamedApplyBlockCaseClassConstruction. -[10:2..10:2) => example/NamedApplyBlockCaseClassConstruction.``(). -[10:2..10:2) => example/NamedApplyBlockCaseClassConstruction.Msg.``(). [10:13..10:16) => example/NamedApplyBlockCaseClassConstruction.Msg# [10:16..10:70) => example/NamedApplyBlockCaseClassConstruction.Msg#``(). [10:17..10:21) => example/NamedApplyBlockCaseClassConstruction.Msg#body. @@ -1998,22 +1930,20 @@ Schema => SemanticDB v4 Uri => NamedArguments.scala Text => empty Language => Scala -Symbols => 6 entries -Occurrences => 11 entries +Symbols => 5 entries +Occurrences => 10 entries Symbols: example/NamedArguments# => class NamedArguments example/NamedArguments#User# => case class User example/NamedArguments#User#``(). => primary ctor example/NamedArguments#User#name. => val method name -example/NamedArguments#User.``(). => primary ctor example/NamedArguments#``(). => primary ctor Occurrences: [0:8..0:15) => example/ [2:6..2:20) => example/NamedArguments# [3:2..3:2) => example/NamedArguments#``(). -[3:2..3:2) => example/NamedArguments#User.``(). [3:13..3:17) => example/NamedArguments#User# [3:17..3:31) => example/NamedArguments#User#``(). [3:18..3:22) => example/NamedArguments#User#name. @@ -2030,19 +1960,17 @@ Schema => SemanticDB v4 Uri => NewModifiers.scala Text => empty Language => Scala -Symbols => 4 entries -Occurrences => 6 entries +Symbols => 3 entries +Occurrences => 5 entries Symbols: _empty_/NewModifiers. => final object NewModifiers _empty_/NewModifiers.A# => type A -_empty_/NewModifiers.``(). => primary ctor _empty_/NewModifiers.foo. => val method foo Occurrences: [0:0..0:0) => _empty_/ [0:7..0:19) => _empty_/NewModifiers. -[1:2..1:2) => _empty_/NewModifiers.``(). [1:13..1:16) => _empty_/NewModifiers.foo. [2:14..2:15) => _empty_/NewModifiers.A# [2:18..2:21) => scala/Int# @@ -2055,20 +1983,16 @@ Schema => SemanticDB v4 Uri => Objects.scala Text => empty Language => Scala -Symbols => 4 entries -Occurrences => 5 entries +Symbols => 2 entries +Occurrences => 3 entries Symbols: objects/X. => final object X objects/X.Y. => final object Y -objects/X.Y.``(). => primary ctor -objects/X.``(). => primary ctor Occurrences: [0:8..0:15) => objects/ [2:7..2:8) => objects/X. -[3:2..3:2) => objects/X.``(). -[3:2..3:2) => objects/X.Y.``(). [3:9..3:10) => objects/X.Y. expect/Overrides.scala @@ -2110,27 +2034,23 @@ Schema => SemanticDB v4 Uri => Prefixes.scala Text => empty Language => Scala -Symbols => 23 entries -Occurrences => 53 entries +Symbols => 19 entries +Occurrences => 49 entries Symbols: prefixes/C# => class C prefixes/C#N. => final object N prefixes/C#N.U# => type U -prefixes/C#N.``(). => primary ctor 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.``(). => primary ctor prefixes/M.n1(). => method n1 prefixes/O. => final object O -prefixes/O.``(). => primary ctor prefixes/O.o1(). => method o1 prefixes/Test. => final object Test -prefixes/Test.``(). => primary ctor prefixes/Test.c. => val method c prefixes/Test.k2(). => method k2 prefixes/Test.k3(). => method k3 @@ -2147,27 +2067,23 @@ Occurrences: [4:10..4:11) => prefixes/C#T# [4:14..4:17) => scala/Predef.`???`(). [6:9..6:10) => prefixes/C#N. -[7:4..7:4) => prefixes/C#N.``(). [7:9..7:10) => prefixes/C#N.U# [9:6..9:8) => prefixes/C#k1(). [9:10..9:11) => prefixes/C#N. [9:12..9:13) => prefixes/C#N.U# [9:16..9:19) => scala/Predef.`???`(). [12:7..12:8) => prefixes/M. -[13:2..13:2) => prefixes/M.``(). [13:7..13:8) => prefixes/M.T# [14:6..14:8) => prefixes/M.n1(). [14:10..14:11) => prefixes/M.T# [14:14..14:17) => scala/Predef.`???`(). [17:7..17:8) => prefixes/O. -[17:17..17:17) => prefixes/O.``(). [17:17..17:18) => prefixes/C# [17:18..17:18) => prefixes/C#``(). [18:6..18:8) => prefixes/O.o1(). [18:10..18:11) => prefixes/C#T# [18:14..18:17) => scala/Predef.`???`(). [21:7..21:11) => prefixes/Test. -[22:2..22:2) => prefixes/Test.``(). [22:6..22:7) => prefixes/Test.c. [22:9..22:10) => prefixes/C# [22:13..22:16) => scala/Predef.`???`(). @@ -2255,8 +2171,8 @@ Schema => SemanticDB v4 Uri => Synthetic.scala Text => empty Language => Scala -Symbols => 23 entries -Occurrences => 144 entries +Symbols => 21 entries +Occurrences => 142 entries Symbols: example/Synthetic# => class Synthetic @@ -2276,8 +2192,6 @@ 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.``(). => primary ctor -example/Synthetic#s.``(). => primary ctor example/Synthetic#s.apply(). => method apply example/Synthetic#x. => val method x example/Synthetic#xs. => val method xs @@ -2357,11 +2271,9 @@ Occurrences: [19:59..19:60) => local4 [19:62..19:63) => local5 [21:9..21:10) => example/Synthetic#s. -[22:4..22:4) => example/Synthetic#s.``(). [22:8..22:13) => example/Synthetic#s.apply(). [23:5..23:5) => example/Synthetic#s.apply(). [24:6..24:11) => example/Synthetic#s.apply(). -[25:4..25:4) => example/Synthetic#s.Bar.``(). [25:15..25:18) => example/Synthetic#s.Bar# [25:18..25:20) => example/Synthetic#s.Bar#``(). [26:4..26:7) => example/Synthetic#s.Bar. @@ -2437,8 +2349,8 @@ Schema => SemanticDB v4 Uri => Traits.scala Text => empty Language => Scala -Symbols => 14 entries -Occurrences => 19 entries +Symbols => 13 entries +Occurrences => 18 entries Symbols: local0 => primary ctor @@ -2451,7 +2363,6 @@ traits/T#x(). => method x traits/U# => sealed class U traits/U#``(). => primary ctor traits/U. => final object U -traits/U.``(). => primary ctor traits/U.u(). => method u traits/V# => class V traits/V#``(). => primary ctor @@ -2464,7 +2375,6 @@ Occurrences: [6:0..6:0) => traits/U#``(). [6:13..6:14) => traits/U# [7:7..7:8) => traits/U. -[8:2..8:2) => traits/U.``(). [8:6..8:7) => traits/U.u(). [8:9..8:10) => traits/U# [8:17..8:17) => local0 @@ -2485,8 +2395,8 @@ Schema => SemanticDB v4 Uri => Types.scala Text => empty Language => Scala -Symbols => 124 entries -Occurrences => 256 entries +Symbols => 117 entries +Occurrences => 249 entries Symbols: local0 => method k @@ -2519,11 +2429,9 @@ 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.``(). => primary ctor types/Test.C#ByNameType.m1(). => method m1 types/Test.C#ByNameType.m1().(x) => val param x types/Test.C#ClassInfoType1. => final object ClassInfoType1 -types/Test.C#ClassInfoType1.``(). => primary ctor types/Test.C#ClassInfoType2# => class ClassInfoType2 types/Test.C#ClassInfoType2#``(). => primary ctor types/Test.C#ClassInfoType2#x(). => method x @@ -2532,7 +2440,6 @@ 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.``(). => primary ctor types/Test.C#MethodType.m3(). => method m3 types/Test.C#MethodType.m4(). => method m4 types/Test.C#MethodType.m5(). => method m5 @@ -2547,13 +2454,11 @@ types/Test.C#RepeatedType#``(). => primary ctor types/Test.C#RepeatedType#m1(). => method m1 types/Test.C#RepeatedType#m1().(x) => val param x types/Test.C#RepeatedType#s. => val method s -types/Test.C#RepeatedType.``(). => primary ctor 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.``(). => primary ctor types/Test.C#TypeType.m2(). => method m2 types/Test.C#TypeType.m2().[T2] => typeparam T2 types/Test.C#TypeType.m3(). => method m3 @@ -2586,7 +2491,6 @@ 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.``(). => primary ctor types/Test.Literal.bool. => final val method bool types/Test.Literal.char. => final val method char types/Test.Literal.clazzOf. => final val method clazzOf @@ -2604,7 +2508,6 @@ types/Test.M#m(). => method m types/Test.N# => class N types/Test.N#``(). => primary ctor types/Test.N#n(). => method n -types/Test.``(). => primary ctor types/ann# => class ann types/ann#[T] => typeparam T types/ann#``(). => primary ctor @@ -2666,7 +2569,6 @@ Occurrences: [22:14..22:15) => types/T#X# [22:15..22:15) => types/T#X#``(). [25:7..25:11) => types/Test. -[26:2..26:2) => types/Test.``(). [26:8..26:9) => types/Test.M# [27:4..27:4) => types/Test.M#``(). [27:8..27:9) => types/Test.M#m(). @@ -2781,7 +2683,6 @@ Occurrences: [69:26..69:27) => local8 [69:31..69:35) => scala/package.List# [69:36..69:37) => local8 -[71:4..71:4) => types/Test.C#ClassInfoType1.``(). [71:11..71:25) => types/Test.C#ClassInfoType1. [72:10..72:24) => types/Test.C#ClassInfoType2# [72:33..72:33) => types/Test.C#ClassInfoType2#``(). @@ -2792,7 +2693,6 @@ Occurrences: [73:24..73:27) => types/Test.C#ClassInfoType3#``(). [73:25..73:26) => types/Test.C#ClassInfoType3#[T] [75:11..75:21) => types/Test.C#MethodType. -[76:6..76:6) => types/Test.C#MethodType.``(). [76:10..76:12) => types/Test.C#MethodType.x1(). [76:14..76:17) => scala/Int# [76:20..76:23) => scala/Predef.`???`(). @@ -2817,13 +2717,11 @@ Occurrences: [81:23..81:24) => types/Test.C#MethodType.m6().[T] [81:27..81:30) => scala/Predef.`???`(). [84:11..84:21) => types/Test.C#ByNameType. -[85:6..85:6) => types/Test.C#ByNameType.``(). [85:10..85:12) => types/Test.C#ByNameType.m1(). [85:13..85:14) => types/Test.C#ByNameType.m1().(x) [85:19..85:22) => scala/Int# [85:25..85:28) => scala/Int# [85:31..85:34) => scala/Predef.`???`(). -[88:4..88:4) => types/Test.C#RepeatedType.``(). [88:15..88:27) => types/Test.C#RepeatedType# [88:27..88:39) => types/Test.C#RepeatedType#``(). [88:28..88:29) => types/Test.C#RepeatedType#s. @@ -2835,7 +2733,6 @@ Occurrences: [89:29..89:30) => types/Test.C#RepeatedType#s. [89:31..89:37) => scala/collection/SeqOps#length(). [92:11..92:19) => types/Test.C#TypeType. -[93:6..93:6) => types/Test.C#TypeType.``(). [93:11..93:13) => types/Test.C#TypeType.T1# [94:10..94:12) => types/Test.C#TypeType.m2(). [94:13..94:15) => types/Test.C#TypeType.m2().[T2] @@ -2851,7 +2748,6 @@ Occurrences: [97:14..97:15) => types/Test.C#TypeType.T5#[U] [97:19..97:20) => types/Test.C#TypeType.T5#[U] [101:9..101:16) => types/Test.Literal. -[102:4..102:4) => types/Test.Literal.``(). [102:14..102:17) => types/Test.Literal.int. [103:14..103:18) => types/Test.Literal.long. [104:14..104:19) => types/Test.Literal.float. @@ -2973,12 +2869,11 @@ Schema => SemanticDB v4 Uri => Vals.scala Text => empty Language => Scala -Symbols => 31 entries -Occurrences => 123 entries +Symbols => 30 entries +Occurrences => 122 entries Symbols: example/ValUsages. => final object ValUsages -example/ValUsages.``(). => primary ctor example/ValUsages.v. => val method v example/Vals# => abstract class Vals example/Vals#``(). => primary ctor @@ -3091,7 +2986,6 @@ Occurrences: [35:12..35:13) => scala/Int#`+`(+4). [35:14..35:17) => example/Vals#ylm(). [38:7..38:16) => example/ValUsages. -[39:2..39:2) => example/ValUsages.``(). [39:6..39:7) => example/ValUsages.v. [39:9..39:13) => example/Vals# [39:16..39:19) => scala/Predef.`???`(). @@ -3219,16 +3113,14 @@ Schema => SemanticDB v4 Uri => semanticdb-extract.scala Text => empty Language => Scala -Symbols => 9 entries -Occurrences => 25 entries +Symbols => 7 entries +Occurrences => 23 entries Symbols: _empty_/AnObject. => final object AnObject _empty_/AnObject.Foo# => case class Foo _empty_/AnObject.Foo#``(). => primary ctor _empty_/AnObject.Foo#x. => val method x -_empty_/AnObject.Foo.``(). => primary ctor -_empty_/AnObject.``(). => primary ctor _empty_/AnObject.foo(). => method foo _empty_/AnObject.foo().(x) => val param x _empty_/AnObject.foo(+1). => method foo @@ -3236,7 +3128,6 @@ _empty_/AnObject.foo(+1). => method foo Occurrences: [0:0..0:0) => _empty_/ [0:7..0:15) => _empty_/AnObject. -[2:2..2:2) => _empty_/AnObject.``(). [2:6..2:9) => _empty_/AnObject.foo(). [2:10..2:11) => _empty_/AnObject.foo().(x) [2:13..2:16) => scala/Int# @@ -3254,7 +3145,6 @@ Occurrences: [13:8..13:14) => scala/collection/IterableFactory#apply(). [14:2..14:9) => scala/Predef.println(+1). [14:12..14:13) => scala/Int#`+`(+4). -[16:2..16:2) => _empty_/AnObject.Foo.``(). [16:13..16:16) => _empty_/AnObject.Foo# [16:16..16:24) => _empty_/AnObject.Foo#``(). [16:17..16:18) => _empty_/AnObject.Foo#x. @@ -3268,12 +3158,11 @@ Schema => SemanticDB v4 Uri => toplevel.scala Text => empty Language => Scala -Symbols => 12 entries -Occurrences => 26 entries +Symbols => 11 entries +Occurrences => 25 entries Symbols: _empty_/toplevel$package. => final package object _empty_ -_empty_/toplevel$package.``(). => primary ctor _empty_/toplevel$package.a. => val method a _empty_/toplevel$package.combine(). => method combine _empty_/toplevel$package.combine().(x) => val param x @@ -3288,7 +3177,6 @@ _empty_/toplevel$package.foo(). => method foo Occurrences: [0:0..0:0) => _empty_/ [0:0..0:16) => _empty_/toplevel$package. -[0:0..0:0) => _empty_/toplevel$package.``(). [0:11..0:12) => _empty_/toplevel$package.a. [1:4..1:11) => _empty_/toplevel$package.combine(). [1:5..1:6) => _empty_/toplevel$package.combine().(x) @@ -3312,3 +3200,4 @@ Occurrences: [2:46..2:47) => _empty_/toplevel$package.combine(+1).(z) [3:4..3:11) => _empty_/toplevel$package.combine(+2). [4:4..4:7) => _empty_/toplevel$package.foo(). + From 17a4e47210a6f790881607dec1a6e3d28fcaf3a9 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 15 Nov 2019 15:00:46 +0100 Subject: [PATCH 063/107] abstract, and var method for SymbolInformation --- .../dotc/semanticdb/ExtractSemanticDB.scala | 78 ++++++++++++------- tests/semanticdb/metac.expect | 46 +++++------ 2 files changed, 75 insertions(+), 49 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 8614022fb630..886b28c4929f 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -26,6 +26,7 @@ import java.nio.file.Paths class ExtractSemanticDB extends Phase { import ast.tpd._ import untpd.given + import NameOps.given override val phaseName: String = ExtractSemanticDB.name @@ -84,11 +85,18 @@ class ExtractSemanticDB extends Phase { private enum SymbolKind derives Eql with kind => - case Val, Var, Other + case Val, Var, Setter, Abstract - def isValOrVar: Boolean = kind match - case Val | Var => true - case _ => false + def isVar: Boolean = + kind == Var + || kind == Setter + + def isVal: Boolean = + kind == Val + + def isValOrVar: Boolean = + kind.isVar + || kind.isVal /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = @@ -217,7 +225,7 @@ class ExtractSemanticDB extends Phase { private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = excludeDefStrict(sym) || (excludeDef(sym) && span.start == span.end) - private def symbolKind(sym: Symbol, symkind: SymbolKind)(given Context): SymbolInformation.Kind = + private def symbolKind(sym: Symbol, symkinds: Set[SymbolKind])(given Context): SymbolInformation.Kind = if sym.isTypeParam SymbolInformation.Kind.TYPE_PARAMETER else if sym.is(TermParam) @@ -230,7 +238,7 @@ class ExtractSemanticDB extends Phase { SymbolInformation.Kind.CONSTRUCTOR else if sym.isSelfSym SymbolInformation.Kind.SELF_PARAMETER - else if sym.isOneOf(Method) || symkind.isValOrVar + else if sym.isOneOf(Method) || symkinds.exists(_.isValOrVar) SymbolInformation.Kind.METHOD else if sym.isPackageObject SymbolInformation.Kind.PACKAGE_OBJECT @@ -251,11 +259,11 @@ class ExtractSemanticDB extends Phase { else SymbolInformation.Kind.UNKNOWN_KIND - private def symbolProps(sym: Symbol, symkind: SymbolKind)(given Context): Set[SymbolInformation.Property] = + private def symbolProps(sym: Symbol, symkinds: Set[SymbolKind])(given Context): Set[SymbolInformation.Property] = val props = mutable.HashSet.empty[SymbolInformation.Property] if sym.isPrimaryConstructor props += SymbolInformation.Property.PRIMARY - if sym.is(Abstract) + if sym.is(Abstract) || symkinds.contains(SymbolKind.Abstract) props += SymbolInformation.Property.ABSTRACT if sym.is(Final) props += SymbolInformation.Property.FINAL @@ -273,9 +281,9 @@ class ExtractSemanticDB extends Phase { props += SymbolInformation.Property.CONTRAVARIANT if sym.isAllOf(DefaultMethod | JavaDefined) || sym.is(Accessor) && sym.name.is(NameKinds.DefaultGetterName) props += SymbolInformation.Property.DEFAULT - if symkind == SymbolKind.Val + if symkinds.exists(_.isVal) props += SymbolInformation.Property.VAL - if symkind == SymbolKind.Var + if symkinds.exists(_.isVar) props += SymbolInformation.Property.VAR if sym.is(JavaStatic) props += SymbolInformation.Property.STATIC @@ -283,16 +291,16 @@ class ExtractSemanticDB extends Phase { props += SymbolInformation.Property.ENUM props.toSet - private def symbolInfo(sym: Symbol, symbolName: String, symkind: SymbolKind)(given Context): SymbolInformation = SymbolInformation( + private def symbolInfo(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(given Context): SymbolInformation = SymbolInformation( symbol = symbolName, language = Language.SCALA, - kind = symbolKind(sym, symkind), - properties = symbolProps(sym, symkind).foldLeft(0)(_ | _.value), + kind = symbolKind(sym, symkinds), + properties = symbolProps(sym, symkinds).foldLeft(0)(_ | _.value), displayName = Symbols.displaySymbol(sym) ) - private def registerSymbol(sym: Symbol, symbolName: String, symkind: SymbolKind)(given Context): Unit = - symbols += symbolInfo(sym, symbolName, symkind) + private def registerSymbol(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(given Context): Unit = + symbols += symbolInfo(sym, symbolName, symkinds) private def registerOccurrence(symbol: String, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = val occ = SymbolOccurrence(symbol, range(span), role) @@ -304,11 +312,11 @@ class ExtractSemanticDB extends Phase { if !excludeUseStrict(sym, span) && !isWildcard(sym.name) then registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE) - private def registerDefinition(sym: Symbol, span: Span, symkind: SymbolKind)(given Context) = + private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind])(given Context) = if !isWildcard(sym.name) then val symbol = symbolName(sym) registerOccurrence(symbol, span, SymbolOccurrence.Role.DEFINITION) - registerSymbol(sym, symbol, symkind) + registerSymbol(sym, symbol, symkinds) private def spanOfSymbol(sym: Symbol, span: Span)(given Context): Span = { val contents = if source.exists then source.content() else Array.empty[Char] @@ -317,7 +325,10 @@ class ExtractSemanticDB extends Phase { Span(start, start + sym.name.show.length, start) } - override def traverse(tree: Tree)(given ctx: Context): Unit = + def (tree: DefDef) isSetterDef(given Context): Boolean = + tree.name.isSetterName && tree.mods.is(Accessor) && tree.vparamss.flatten.length == 1 + + override def traverse(tree: Tree)(given Context): Unit = for annot <- tree.symbol.annotations do if annot.tree.span.exists && annot.symbol.owner != defn.ScalaAnnotationInternal @@ -328,14 +339,29 @@ class ExtractSemanticDB extends Phase { case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => - val symkind = + val symkinds = if tree.symbol.isSelfSym - SymbolKind.Other - else tree match - case _: ValDef => if tree.mods.is(Mutable) then SymbolKind.Var else SymbolKind.Val - case _: Bind => SymbolKind.Val - case _ => SymbolKind.Other - registerDefinition(tree.symbol, tree.nameSpan, symkind) + Set.empty + else + val symkinds = mutable.HashSet.empty[SymbolKind] + tree match + case tree: ValDef => + if tree.mods.is(Mutable) + symkinds += SymbolKind.Var + else + symkinds += SymbolKind.Val + if tree.rhs.isEmpty && !tree.symbol.is(TermParam) && !tree.symbol.is(CaseAccessor) && !tree.mods.is(ParamAccessor) + symkinds += SymbolKind.Abstract + case tree: DefDef => + if tree.isSetterDef then + symkinds += SymbolKind.Setter + else + if tree.rhs.isEmpty + symkinds += SymbolKind.Abstract + case tree: Bind => symkinds += SymbolKind.Val + case _ => + symkinds.toSet + registerDefinition(tree.symbol, tree.nameSpan, symkinds) val privateWithin = tree.symbol.privateWithin if privateWithin `ne` NoSymbol registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) @@ -343,7 +369,7 @@ class ExtractSemanticDB extends Phase { case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => if !excludeDef(tree.constr.symbol) - registerDefinition(tree.constr.symbol, tree.constr.span, SymbolKind.Other) + registerDefinition(tree.constr.symbol, tree.constr.span, Set.empty) tree.constr.vparamss.flatten.foreach(vparam => traverse(vparam.tpt)) // the accessor symbol is traversed in the body for parent <- tree.parentsOrDerived do if diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 8ea05b853583..9caf754475c1 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -76,11 +76,11 @@ advanced/Test.s3x. => val method s3x advanced/Wildcards# => class Wildcards advanced/Wildcards#``(). => primary ctor advanced/Wildcards#e1(). => method e1 -local0 => val method x -local1 => val method x +local0 => abstract val method x +local1 => abstract val method x local2 => primary ctor local3 => val method x -local4 => method m +local4 => abstract method m local5 => val param x local6 => primary ctor local7 => method m @@ -459,7 +459,7 @@ a/Definitions.D# => class D a/Definitions.D#``(). => primary ctor a/Definitions.E# => class E a/Definitions.E#``(). => primary ctor -a/Definitions.`b_=`(). => method b_= +a/Definitions.`b_=`(). => var method b_= a/Definitions.a. => val method a a/Definitions.b(). => var method b a/Definitions.c(). => method c @@ -852,7 +852,7 @@ Symbols: flags/p/package. => final package object p flags/p/package.AA# => class AA flags/p/package.AA#``(). => primary ctor -flags/p/package.AA#`z_=`(). => method z_= +flags/p/package.AA#`z_=`(). => var method z_= flags/p/package.AA#x. => val method x flags/p/package.AA#y. => val method y flags/p/package.AA#z(). => var method z @@ -865,7 +865,7 @@ flags/p/package.C#``(+1). => ctor flags/p/package.C#``(+1).[T] => typeparam T flags/p/package.C#``(+1).[U] => typeparam U flags/p/package.C#``(+1).[V] => typeparam V -flags/p/package.C#w(). => method w +flags/p/package.C#w(). => abstract method w flags/p/package.C#x. => val method x flags/p/package.C#y. => val method y flags/p/package.C#z. => val method z @@ -882,7 +882,7 @@ flags/p/package.Y# => final class Y flags/p/package.Y#``(). => primary ctor flags/p/package.Z# => sealed class Z flags/p/package.Z#``(). => primary ctor -flags/p/package.`y_=`(). => method y_= +flags/p/package.`y_=`(). => var method y_= flags/p/package.m(). => method m flags/p/package.m().[TT] => typeparam TT flags/p/package.x. => lazy val method x @@ -1076,10 +1076,10 @@ a/b/Givens. => final object Givens a/b/Givens.Monoid# => class Monoid a/b/Givens.Monoid#[A] => typeparam A a/b/Givens.Monoid#``(). => primary ctor -a/b/Givens.Monoid#combine(). => method combine +a/b/Givens.Monoid#combine(). => abstract method combine a/b/Givens.Monoid#combine().(x) => val param x a/b/Givens.Monoid#combine().(y) => val param y -a/b/Givens.Monoid#empty(). => method empty +a/b/Givens.Monoid#empty(). => abstract method empty a/b/Givens.foo(). => method foo a/b/Givens.foo().(A) => implicit val param A a/b/Givens.foo().[A] => typeparam A @@ -1713,7 +1713,7 @@ example/Methods#m19(). => method m19 example/Methods#m19().(x) => val param x example/Methods#m19().(y) => val param y example/Methods#m19().(z) => val param z -local0 => val method x +local0 => abstract val method x Occurrences: [0:8..0:15) => example/ @@ -2009,7 +2009,7 @@ Occurrences => 10 entries Symbols: example/A# => class A example/A#``(). => primary ctor -example/A#foo(). => method foo +example/A#foo(). => abstract method foo example/B# => class B example/B#``(). => primary ctor example/B#foo(). => method foo @@ -2399,8 +2399,8 @@ Symbols => 117 entries Occurrences => 249 entries Symbols: -local0 => method k -local1 => method k +local0 => abstract method k +local1 => abstract method k local2 => primary ctor local3 => method k local4 => primary ctor @@ -2782,9 +2782,9 @@ Occurrences => 57 entries Symbols: example/ValPattern# => class ValPattern example/ValPattern#``(). => primary ctor -example/ValPattern#`leftVar_=`(). => method leftVar_= -example/ValPattern#`number1Var_=`(). => method number1Var_= -example/ValPattern#`rightVar_=`(). => method rightVar_= +example/ValPattern#`leftVar_=`(). => var method leftVar_= +example/ValPattern#`number1Var_=`(). => var method number1Var_= +example/ValPattern#`rightVar_=`(). => var method rightVar_= example/ValPattern#app(). => method app example/ValPattern#left. => val method left example/ValPattern#leftVar(). => var method leftVar @@ -2877,14 +2877,14 @@ example/ValUsages. => final object ValUsages example/ValUsages.v. => val method v example/Vals# => abstract class Vals example/Vals#``(). => primary ctor -example/Vals#`yam_=`(). => method yam_= -example/Vals#`yfm_=`(). => final method yfm_= -example/Vals#`yim_=`(). => method yim_= -example/Vals#`ym_=`(). => method ym_= -example/Vals#`yp_=`(). => method yp_= +example/Vals#`yam_=`(). => var method yam_= +example/Vals#`yfm_=`(). => final var method yfm_= +example/Vals#`yim_=`(). => var method yim_= +example/Vals#`ym_=`(). => var method ym_= +example/Vals#`yp_=`(). => var method yp_= example/Vals#m(). => method m example/Vals#p. => val method p -example/Vals#xam. => val method xam +example/Vals#xam. => abstract val method xam example/Vals#xfm. => final val method xfm example/Vals#xim. => implicit val method xim example/Vals#xlm. => val method xlm @@ -2892,7 +2892,7 @@ example/Vals#xm. => val method xm example/Vals#xp. => val method xp example/Vals#xzlm. => lazy val method xzlm example/Vals#xzm. => lazy val method xzm -example/Vals#yam(). => var method yam +example/Vals#yam(). => abstract var method yam example/Vals#yfm(). => final var method yfm example/Vals#yim(). => implicit var method yim example/Vals#ylm(). => var method ylm From 66edfef7f926b0877482761ba395361e609dee2a Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 15 Nov 2019 15:34:41 +0100 Subject: [PATCH 064/107] emit uses of setters instead of the getter --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 7 +++++++ tests/semanticdb/expect/Vals.expect.scala | 10 +++++----- tests/semanticdb/metac.expect | 10 +++++----- tests/semanticdb/todo.md | 4 ++-- 4 files changed, 19 insertions(+), 12 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 886b28c4929f..fc755d598746 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -382,6 +382,13 @@ class ExtractSemanticDB extends Phase { if selfSpan.exists && selfSpan.start != selfSpan.end then traverse(tree.self) tree.body.foreach(traverse) + case tree: Assign => + traverseChildren(tree.lhs) + if !excludeUseStrict(tree.lhs.symbol, tree.lhs.span) + val name = tree.lhs.symbol.name + val setter = tree.lhs.symbol.owner.info.decls.find(s => s.name.startsWith(name.show) && s.name.isSetterName) + registerUse(setter.orElse(tree.lhs.symbol), tree.lhs.span) + traverse(tree.rhs) case tree: Ident => if tree.name != nme.WILDCARD && !excludeUseStrict(tree.symbol, tree.span) then registerUse(tree.symbol, tree.span) diff --git a/tests/semanticdb/expect/Vals.expect.scala b/tests/semanticdb/expect/Vals.expect.scala index 0cd42f1c8705..3f2c681ddab2 100644 --- a/tests/semanticdb/expect/Vals.expect.scala +++ b/tests/semanticdb/expect/Vals.expect.scala @@ -38,10 +38,10 @@ abstract class Vals/*<-example::Vals#*/(p/*<-example::Vals#p.*/: Int/*->scala::I object ValUsages/*<-example::ValUsages.*/ { val v/*<-example::ValUsages.v.*/: Vals/*->example::Vals#*/ = ???/*->scala::Predef.`???`().*/ - v/*->example::ValUsages.v.*/.yp/*->example::Vals#yp().*/ = v/*->example::ValUsages.v.*/.xp/*->example::Vals#xp.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yp/*->example::Vals#yp().*/ - v/*->example::ValUsages.v.*/.ym/*->example::Vals#ym().*/ = v/*->example::ValUsages.v.*/.xm/*->example::Vals#xm.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.ym/*->example::Vals#ym().*/ - v/*->example::ValUsages.v.*/.yam/*->example::Vals#yam().*/ = v/*->example::ValUsages.v.*/.xam/*->example::Vals#xam.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yam/*->example::Vals#yam().*/ + v/*->example::ValUsages.v.*/.yp/*->example::Vals#`yp_=`().*/ = v/*->example::ValUsages.v.*/.xp/*->example::Vals#xp.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yp/*->example::Vals#yp().*/ + v/*->example::ValUsages.v.*/.ym/*->example::Vals#`ym_=`().*/ = v/*->example::ValUsages.v.*/.xm/*->example::Vals#xm.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.ym/*->example::Vals#ym().*/ + v/*->example::ValUsages.v.*/.yam/*->example::Vals#`yam_=`().*/ = v/*->example::ValUsages.v.*/.xam/*->example::Vals#xam.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yam/*->example::Vals#yam().*/ println/*->scala::Predef.println(+1).*/(v/*->example::ValUsages.v.*/.xzm/*->example::Vals#xzm.*/) - v/*->example::ValUsages.v.*/.yfm/*->example::Vals#yfm().*/ = v/*->example::ValUsages.v.*/.xfm/*->example::Vals#xfm.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yfm/*->example::Vals#yfm().*/ - v/*->example::ValUsages.v.*/.yim/*->example::Vals#yim().*/ = v/*->example::ValUsages.v.*/.xim/*->example::Vals#xim.*/ +/*->scala::Int#`+`(+4).*/ v/*->example::ValUsages.v.*/.yim/*->example::Vals#yim().*/ + v/*->example::ValUsages.v.*/.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().*/ } diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 9caf754475c1..e69ebaa8ea5e 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -2990,21 +2990,21 @@ Occurrences: [39:9..39:13) => example/Vals# [39:16..39:19) => scala/Predef.`???`(). [40:2..40:3) => example/ValUsages.v. -[40:4..40:6) => example/Vals#yp(). +[40:2..40:6) => example/Vals#`yp_=`(). [40:9..40:10) => example/ValUsages.v. [40:11..40:13) => example/Vals#xp. [40:14..40:15) => scala/Int#`+`(+4). [40:16..40:17) => example/ValUsages.v. [40:18..40:20) => example/Vals#yp(). [41:2..41:3) => example/ValUsages.v. -[41:4..41:6) => example/Vals#ym(). +[41:2..41:6) => example/Vals#`ym_=`(). [41:9..41:10) => example/ValUsages.v. [41:11..41:13) => example/Vals#xm. [41:14..41:15) => scala/Int#`+`(+4). [41:16..41:17) => example/ValUsages.v. [41:18..41:20) => example/Vals#ym(). [42:2..42:3) => example/ValUsages.v. -[42:4..42:7) => example/Vals#yam(). +[42:2..42:7) => example/Vals#`yam_=`(). [42:10..42:11) => example/ValUsages.v. [42:12..42:15) => example/Vals#xam. [42:16..42:17) => scala/Int#`+`(+4). @@ -3014,14 +3014,14 @@ Occurrences: [43:10..43:11) => example/ValUsages.v. [43:12..43:15) => example/Vals#xzm. [44:2..44:3) => example/ValUsages.v. -[44:4..44:7) => example/Vals#yfm(). +[44:2..44:7) => example/Vals#`yfm_=`(). [44:10..44:11) => example/ValUsages.v. [44:12..44:15) => example/Vals#xfm. [44:16..44:17) => scala/Int#`+`(+4). [44:18..44:19) => example/ValUsages.v. [44:20..44:23) => example/Vals#yfm(). [45:2..45:3) => example/ValUsages.v. -[45:4..45:7) => example/Vals#yim(). +[45:2..45:7) => example/Vals#`yim_=`(). [45:10..45:11) => example/ValUsages.v. [45:12..45:15) => example/Vals#xim. [45:16..45:17) => scala/Int#`+`(+4). diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md index 27f2f5dc6a1e..47cb52f80402 100644 --- a/tests/semanticdb/todo.md +++ b/tests/semanticdb/todo.md @@ -2,13 +2,13 @@ This todolist is based upon blackbox observation of testcases at this repository: https://github.com/scalameta/scalameta/tree/master/tests/jvm/src/test/resources/example - [ ] Hide unapply, unapplySeq? -- [ ] Hide constructor of template - [ ] Hide local vars in pattern def? - [ ] Hide desugaring of for comprehension - [ ] Hide calls to implicit conversions and their arguments - [ ] Hide Tuple contructors - [ ] Hide implicitly applied arguments -- [ ] Assignments to vars should emit setter symbol +- [x] Assignments to vars should emit uses of the setter method and not the getter +- [x] Hide constructor of module template // expect tests hide primary ctors - [x] unescape unicode in names. - [x] Only traverse prefix of a Select if it is not a package - [x] Ensure only methods are counted in overloads From b0a73eee0bcef0b59dc3182a93a543e33782c4eb Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 15 Nov 2019 16:54:31 +0100 Subject: [PATCH 065/107] emit SymbolInfo for ctor params --- .../dotc/semanticdb/ExtractSemanticDB.scala | 40 +++++++++++--- tests/semanticdb/metac.expect | 54 +++++++++++++++---- 2 files changed, 77 insertions(+), 17 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index fc755d598746..0a8dd713ee4b 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -18,6 +18,8 @@ import collection.mutable import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} import java.nio.file.Paths +import scala.annotation.{ threadUnsafe => tu } + /** Extract symbol references and uses to semanticdb files. * See https://scalameta.org/docs/semanticdb/specification.html#symbol-1 * for a description of the format. @@ -98,6 +100,15 @@ class ExtractSemanticDB extends Phase { kind.isVar || kind.isVal + private object SymbolKind with + val SingletonVal = Set(Val) + val SingletonVar = Set(Var) + + private def isWildcard(name: Name)(given ctx: Context) = name match + case nme.WILDCARD | WILDCARDTypeName => true + case _ if name.is(NameKinds.WildcardParamName) => true + case _ => false + /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = @@ -199,11 +210,6 @@ class ExtractSemanticDB extends Phase { private val WILDCARDTypeName = nme.WILDCARD.toTypeName - private def isWildcard(name: Name)(given ctx: Context) = name match - case nme.WILDCARD | WILDCARDTypeName => true - case _ if name.is(NameKinds.WildcardParamName) => true - case _ => false - /** Definitions of this symbol should be excluded from semanticdb */ private def excludeDef(sym: Symbol)(given Context): Boolean = !sym.exists @@ -328,6 +334,19 @@ class ExtractSemanticDB extends Phase { def (tree: DefDef) isSetterDef(given Context): Boolean = tree.name.isSetterName && tree.mods.is(Accessor) && tree.vparamss.flatten.length == 1 + def findGetters(ctorParams: List[ValDef], body: List[ast.tpd.Tree])(given Context): Map[Names.TermName, ValDef] = + if ctorParams.isEmpty then + Map.empty + else + val ctorParamNames = ctorParams.map(_.name).toSet + body.collect({ + case tree: ValDef + if ctorParamNames.contains(tree.name) + && !tree.symbol.isPrivate => + tree.name -> tree + }).toMap + end findGetters + override def traverse(tree: Tree)(given Context): Unit = for annot <- tree.symbol.annotations do if annot.tree.span.exists @@ -370,7 +389,16 @@ class ExtractSemanticDB extends Phase { case tree: Template => if !excludeDef(tree.constr.symbol) registerDefinition(tree.constr.symbol, tree.constr.span, Set.empty) - tree.constr.vparamss.flatten.foreach(vparam => traverse(vparam.tpt)) // the accessor symbol is traversed in the body + val ctorParams = tree.constr.vparamss.flatten + @tu lazy val getters = findGetters(ctorParams, tree.body) + for vparam <- ctorParams do + if !isWildcard(vparam.name) + val symkinds = + getters.get(vparam.name).fold( + Set.empty[SymbolKind])( + getter => if getter.mods.is(Mutable) then SymbolKind.SingletonVar else SymbolKind.SingletonVal) + registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds) + traverse(vparam.tpt) for parent <- tree.parentsOrDerived do if parent.symbol != defn.ObjectClass.primaryConstructor diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index e69ebaa8ea5e..3ba275e9a089 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -194,7 +194,7 @@ Schema => SemanticDB v4 Uri => Annotations.scala Text => empty Language => Scala -Symbols => 20 entries +Symbols => 22 entries Occurrences => 51 entries Symbols: @@ -204,11 +204,13 @@ annot/Annotations# => class Annotations annot/Annotations#S# => type S annot/Annotations#[T] => typeparam T annot/Annotations#``(). => primary ctor +annot/Annotations#``().(x) => param x annot/Annotations#field. => val method field annot/Annotations#method(). => method method annot/Annotations#x. => val method x annot/B# => class B annot/B#``(). => primary ctor +annot/B#``().(x) => param x annot/B#``(+1). => ctor annot/B#x. => val method x annot/M. => final object M @@ -342,39 +344,48 @@ Schema => SemanticDB v4 Uri => Classes.scala Text => empty Language => Scala -Symbols => 35 entries +Symbols => 44 entries Occurrences => 58 entries Symbols: classes/C1# => final class C1 classes/C1#``(). => primary ctor +classes/C1#``().(x1) => val param x1 classes/C1#x1. => val method x1 classes/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#``(). => primary ctor +classes/C3#``().(x) => val param x classes/C3#x. => val method x classes/C4# => case class C4 classes/C4#``(). => primary ctor +classes/C4#``().(x) => val param x classes/C4#x. => val method x classes/C4. => final object C4 classes/C6# => case class C6 classes/C6#``(). => primary ctor +classes/C6#``().(x) => param x classes/C6#x. => val method x classes/C7# => class C7 classes/C7#``(). => primary ctor +classes/C7#``().(x) => param x classes/C7#x. => val method x classes/C8# => class C8 classes/C8#``(). => primary ctor +classes/C8#``().(x) => param x classes/C8#x. => val method x classes/C9# => class C9 classes/C9#``(). => primary ctor +classes/C9#``().(x) => param x classes/C9#x(). => var method x classes/M. => final object M classes/M.C5# => class C5 classes/M.C5#``(). => primary ctor +classes/M.C5#``().(x) => param x classes/M.C5#x. => val method x classes/N. => final object N classes/N.anonClass. => val method anonClass @@ -534,7 +545,7 @@ Schema => SemanticDB v4 Uri => Enums.scala Text => empty Language => Scala -Symbols => 66 entries +Symbols => 69 entries Occurrences => 156 entries Symbols: @@ -549,11 +560,14 @@ _empty_/Enums.Maybe#[A] => covariant typeparam A _empty_/Enums.Maybe#``(). => primary ctor _empty_/Enums.Maybe.Just# => final case enum class Just _empty_/Enums.Maybe.Just#``(). => primary ctor +_empty_/Enums.Maybe.Just#``().(value) => val param value _empty_/Enums.Maybe.Just#value. => val method value _empty_/Enums.Maybe.None. => case val static enum method None _empty_/Enums.Planet# => abstract sealed enum class Planet _empty_/Enums.Planet#G. => final val method G _empty_/Enums.Planet#``(). => primary ctor +_empty_/Enums.Planet#``().(mass) => param mass +_empty_/Enums.Planet#``().(radius) => param radius _empty_/Enums.Planet#mass. => val method mass _empty_/Enums.Planet#radius. => val method radius _empty_/Enums.Planet#surfaceGravity(). => method surfaceGravity @@ -845,13 +859,16 @@ Schema => SemanticDB v4 Uri => Flags.scala Text => empty Language => Scala -Symbols => 44 entries +Symbols => 50 entries Occurrences => 84 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#x. => val method x flags/p/package.AA#y. => val method y @@ -861,6 +878,9 @@ 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#``(+1).[T] => typeparam T flags/p/package.C#``(+1).[U] => typeparam U @@ -1157,7 +1177,7 @@ Schema => SemanticDB v4 Uri => ImplicitConversion.scala Text => empty Language => Scala -Symbols => 18 entries +Symbols => 19 entries Occurrences => 58 entries Symbols: @@ -1178,6 +1198,7 @@ example/ImplicitConversion.newAny2stringadd#[A] => typeparam A example/ImplicitConversion.newAny2stringadd#`+`(). => method + example/ImplicitConversion.newAny2stringadd#`+`().(other) => val param other example/ImplicitConversion.newAny2stringadd#``(). => primary ctor +example/ImplicitConversion.newAny2stringadd#``().(self) => param self example/ImplicitConversion.newAny2stringadd#self. => val method self Occurrences: @@ -1864,13 +1885,16 @@ Schema => SemanticDB v4 Uri => NamedApplyBlock.scala Text => empty Language => Scala -Symbols => 16 entries +Symbols => 19 entries Occurrences => 35 entries Symbols: example/NamedApplyBlockCaseClassConstruction. => final object NamedApplyBlockCaseClassConstruction example/NamedApplyBlockCaseClassConstruction.Msg# => case class Msg 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#head. => val method head example/NamedApplyBlockCaseClassConstruction.Msg#tail. => val method tail @@ -1930,13 +1954,14 @@ Schema => SemanticDB v4 Uri => NamedArguments.scala Text => empty Language => Scala -Symbols => 5 entries +Symbols => 6 entries Occurrences => 10 entries Symbols: example/NamedArguments# => class NamedArguments example/NamedArguments#User# => case class User example/NamedArguments#User#``(). => primary ctor +example/NamedArguments#User#``().(name) => val param name example/NamedArguments#User#name. => val method name example/NamedArguments#``(). => primary ctor @@ -2171,7 +2196,7 @@ Schema => SemanticDB v4 Uri => Synthetic.scala Text => empty Language => Scala -Symbols => 21 entries +Symbols => 22 entries Occurrences => 142 entries Symbols: @@ -2181,6 +2206,7 @@ example/Synthetic#F#``(). => primary ctor example/Synthetic#J# => class J example/Synthetic#J#[T] => typeparam T example/Synthetic#J#``(). => primary ctor +example/Synthetic#J#``().(evidence$2) => implicit param evidence$2 example/Synthetic#J#arr. => val method arr example/Synthetic#J#evidence$2. => implicit val method evidence$2 example/Synthetic#Name. => val method Name @@ -2395,7 +2421,7 @@ Schema => SemanticDB v4 Uri => Types.scala Text => empty Language => Scala -Symbols => 117 entries +Symbols => 119 entries Occurrences => 249 entries Symbols: @@ -2451,6 +2477,7 @@ 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#``(). => primary ctor +types/Test.C#RepeatedType#``().(s) => val param s types/Test.C#RepeatedType#m1(). => method m1 types/Test.C#RepeatedType#m1().(x) => val param x types/Test.C#RepeatedType#s. => val method s @@ -2511,6 +2538,7 @@ types/Test.N#n(). => method n types/ann# => class ann types/ann#[T] => typeparam T types/ann#``(). => primary ctor +types/ann#``().(x) => param x types/ann#x. => val method x types/ann1# => class ann1 types/ann1#``(). => primary ctor @@ -2869,7 +2897,7 @@ Schema => SemanticDB v4 Uri => Vals.scala Text => empty Language => Scala -Symbols => 30 entries +Symbols => 33 entries Occurrences => 122 entries Symbols: @@ -2877,6 +2905,9 @@ example/ValUsages. => final object ValUsages example/ValUsages.v. => val method v example/Vals# => abstract class Vals example/Vals#``(). => primary ctor +example/Vals#``().(p) => param p +example/Vals#``().(xp) => val param xp +example/Vals#``().(yp) => var param yp example/Vals#`yam_=`(). => var method yam_= example/Vals#`yfm_=`(). => final var method yfm_= example/Vals#`yim_=`(). => var method yim_= @@ -3113,13 +3144,14 @@ Schema => SemanticDB v4 Uri => semanticdb-extract.scala Text => empty Language => Scala -Symbols => 7 entries +Symbols => 8 entries Occurrences => 23 entries Symbols: _empty_/AnObject. => final object AnObject _empty_/AnObject.Foo# => case class Foo _empty_/AnObject.Foo#``(). => primary ctor +_empty_/AnObject.Foo#``().(x) => val param x _empty_/AnObject.Foo#x. => val method x _empty_/AnObject.foo(). => method foo _empty_/AnObject.foo().(x) => val param x From 65d8eb98f0b2f0054d10c534cd0c9a5d8849494c Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 15 Nov 2019 17:03:54 +0100 Subject: [PATCH 066/107] support trait kind in SymbolInformation --- .../dotc/semanticdb/ExtractSemanticDB.scala | 4 ++-- tests/semanticdb/metac.expect | 22 +++++++++---------- tests/semanticdb/todo.md | 1 + 3 files changed, 14 insertions(+), 13 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 0a8dd713ee4b..60f9143d5a3c 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -252,12 +252,12 @@ class ExtractSemanticDB extends Phase { SymbolInformation.Kind.OBJECT else if sym.is(Package) SymbolInformation.Kind.PACKAGE - else if sym.isClass - SymbolInformation.Kind.CLASS else if sym.isAllOf(JavaInterface) SymbolInformation.Kind.INTERFACE else if sym.is(Trait) SymbolInformation.Kind.TRAIT + else if sym.isClass + SymbolInformation.Kind.CLASS else if sym.isType SymbolInformation.Kind.TYPE else if sym.is(ParamAccessor) diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 3ba275e9a089..9fa82b1e1cbf 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -216,7 +216,7 @@ annot/B#x. => val method x annot/M. => final object M annot/M.m(). => method m annot/M.m().[TT] => typeparam TT -annot/T# => class T +annot/T# => trait T annot/T#``(). => primary ctor local0 => selfparam self local1 => val local local @@ -287,7 +287,7 @@ Occurrences => 34 entries Symbols: example/Anonymous# => class Anonymous -example/Anonymous#Foo# => class Foo +example/Anonymous#Foo# => trait Foo example/Anonymous#Foo#``(). => primary ctor example/Anonymous#``(). => primary ctor example/Anonymous#foo. => val method foo @@ -468,7 +468,7 @@ Symbols: a/Definitions. => final object Definitions a/Definitions.D# => class D a/Definitions.D#``(). => primary ctor -a/Definitions.E# => class E +a/Definitions.E# => trait E a/Definitions.E#``(). => primary ctor a/Definitions.`b_=`(). => var method b_= a/Definitions.a. => val method a @@ -900,7 +900,7 @@ 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 class Z +flags/p/package.Z# => sealed trait Z flags/p/package.Z#``(). => primary ctor flags/p/package.`y_=`(). => var method y_= flags/p/package.m(). => method m @@ -1093,7 +1093,7 @@ Occurrences => 52 entries Symbols: a/b/Givens. => final object Givens -a/b/Givens.Monoid# => class Monoid +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 @@ -2032,7 +2032,7 @@ Symbols => 6 entries Occurrences => 10 entries Symbols: -example/A# => class A +example/A# => trait A example/A#``(). => primary ctor example/A#foo(). => abstract method foo example/B# => class B @@ -2383,14 +2383,14 @@ local0 => primary ctor local1 => selfparam self traits/C# => class C traits/C#``(). => primary ctor -traits/T# => class T +traits/T# => trait T traits/T#``(). => primary ctor traits/T#x(). => method x -traits/U# => sealed class U +traits/U# => sealed trait U traits/U#``(). => primary ctor traits/U. => final object U traits/U.u(). => method u -traits/V# => class V +traits/V# => trait V traits/V#``(). => primary ctor Occurrences: @@ -2461,7 +2461,7 @@ 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# => class ClassInfoType3 +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 @@ -2532,7 +2532,7 @@ 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# => class N +types/Test.N# => trait N types/Test.N#``(). => primary ctor types/Test.N#n(). => method n types/ann# => class ann diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md index 47cb52f80402..06a93e70c738 100644 --- a/tests/semanticdb/todo.md +++ b/tests/semanticdb/todo.md @@ -7,6 +7,7 @@ This todolist is based upon blackbox observation of testcases at this repository - [ ] Hide calls to implicit conversions and their arguments - [ ] Hide Tuple contructors - [ ] Hide implicitly applied arguments +- [ ] `macro ???` is already rewritten to `???` so can't add macro kind. - [x] Assignments to vars should emit uses of the setter method and not the getter - [x] Hide constructor of module template // expect tests hide primary ctors - [x] unescape unicode in names. From 1b6d7a9b9a4ecc536f0ec9f0cca15001c0c63ab4 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 15 Nov 2019 19:08:59 +0100 Subject: [PATCH 067/107] correct arrow direction in metac occurrences, include source snippet, correct package def role --- .../dotc/semanticdb/ExtractSemanticDB.scala | 45 +- .../tools/dotc/semanticdb/Semanticdbs.scala | 10 +- tests/semanticdb/metac.expect | 3839 ++++++++--------- 3 files changed, 1957 insertions(+), 1937 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 60f9143d5a3c..f6ed53f5b734 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -322,7 +322,8 @@ class ExtractSemanticDB extends Phase { if !isWildcard(sym.name) then val symbol = symbolName(sym) registerOccurrence(symbol, span, SymbolOccurrence.Role.DEFINITION) - registerSymbol(sym, symbol, symkinds) + if !sym.is(Package) + registerSymbol(sym, symbol, symkinds) private def spanOfSymbol(sym: Symbol, span: Span)(given Context): Span = { val contents = if source.exists then source.content() else Array.empty[Char] @@ -347,6 +348,16 @@ class ExtractSemanticDB extends Phase { }).toMap end findGetters + def adjustSpanToName(span: Span, qualSpan: Span, name: Name)(given Context) = + val end = span.end + val limit = qualSpan.end + val start = + if limit < end then + val len = name.toString.length + if source.content()(end - 1) == '`' then end - len - 2 else end - len + else limit + Span(start max limit, end) + override def traverse(tree: Tree)(given Context): Unit = for annot <- tree.symbol.annotations do if annot.tree.span.exists @@ -355,6 +366,15 @@ class ExtractSemanticDB extends Phase { traverse(annot.tree) tree match + case tree: PackageDef => + if !excludeDef(tree.pid.symbol) && tree.pid.span.start != tree.pid.span.end + tree.pid match + case tree @ Select(qual, _) => + traverse(qual) + registerDefinition(tree.symbol, adjustSpanToName(tree.span, qual.span, tree.symbol.name), Set.empty) + case tree @ Ident(name) => + registerDefinition(tree.symbol, tree.span, Set.empty) + tree.stats.foreach(traverse) case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => @@ -413,9 +433,17 @@ class ExtractSemanticDB extends Phase { case tree: Assign => traverseChildren(tree.lhs) if !excludeUseStrict(tree.lhs.symbol, tree.lhs.span) - val name = tree.lhs.symbol.name - val setter = tree.lhs.symbol.owner.info.decls.find(s => s.name.startsWith(name.show) && s.name.isSetterName) - registerUse(setter.orElse(tree.lhs.symbol), tree.lhs.span) + val lhs = tree.lhs.symbol + val name = lhs.name + val setter = + lhs.owner + .info + .decls + .find(s => s.name.startsWith(name.show) && s.name.isSetterName) + .orElse(lhs) + tree.lhs match + case tree @ Select(qual, _) => registerUse(setter, adjustSpanToName(tree.span, qual.span, name)) + case tree: Ident => registerUse(setter, tree.span) traverse(tree.rhs) case tree: Ident => if tree.name != nme.WILDCARD && !excludeUseStrict(tree.symbol, tree.span) then @@ -423,14 +451,7 @@ class ExtractSemanticDB extends Phase { case tree: Select => val qualSpan = tree.qualifier.span if !excludeUseStrict(tree.symbol, tree.span) then - val end = tree.span.end - val limit = qualSpan.end - val start = - if limit < end then - val len = tree.name.toString.length - if source.content()(end - 1) == '`' then end - len - 1 else end - len - else limit - registerUse(tree.symbol, Span(start max limit, end)) + registerUse(tree.symbol, adjustSpanToName(tree.span, qualSpan, tree.name)) if qualSpan.exists && qualSpan.start != qualSpan.end then traverseChildren(tree) case tree: Import => diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index bad61e034c73..205f237d5f8e 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -127,7 +127,7 @@ object Semanticdbs with sb.append(info.displayName).nl end processSymbol - def processOccurrence(occ: SymbolOccurrence)(given sb: StringBuilder): Unit = + def processOccurrence(occ: SymbolOccurrence)(given sb: StringBuilder, sourceFile: SourceFile): Unit = occ.range match case Some(range) => sb.append('[') @@ -135,14 +135,20 @@ object Semanticdbs with .append("..") .append(range.endLine).append(':').append(range.endCharacter) .append(')') + if range.endLine == range.startLine + && range.startCharacter != range.endCharacter + && !(occ.role.isDefinition && occ.symbol.matches(raw".+``\((?:\+\d+)?\)\.")) + val line = sourceFile.lineContent(sourceFile.lineToOffset(range.startLine)) + sb.append(" ").append(line.substring(range.startCharacter, range.endCharacter)) case _ => sb.append("[)") end match - sb.append(" => ").append(occ.symbol).nl + sb.append(if occ.role.isReference then " -> " else " <- ").append(occ.symbol).nl end processOccurrence def metac(doc: TextDocument, realPath: Path)(given sb: StringBuilder): StringBuilder = val realURI = realPath.toString + given SourceFile = SourceFile.virtual(doc.uri, doc.text) sb.append(realURI).nl sb.append("_" * realURI.length).nl sb.nl diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 9fa82b1e1cbf..a265c9a7b06b 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -21,25 +21,25 @@ example/Access#m6(). => method m6 example/Access#m7(). => method m7 Occurrences: -[0:8..0:15) => example/ -[2:6..2:12) => example/Access# -[3:2..3:2) => example/Access#``(). -[3:14..3:16) => example/Access#m1(). -[3:19..3:22) => scala/Predef.`???`(). -[4:20..4:22) => example/Access#m2(). -[4:25..4:28) => scala/Predef.`???`(). -[5:10..5:16) => example/Access# -[5:22..5:24) => example/Access#m3(). -[5:27..5:30) => scala/Predef.`???`(). -[6:16..6:18) => example/Access#m4(). -[6:21..6:24) => scala/Predef.`???`(). -[7:22..7:24) => example/Access#m5(). -[7:27..7:30) => scala/Predef.`???`(). -[8:12..8:19) => example/ -[8:25..8:27) => example/Access#m6(). -[8:30..8:33) => scala/Predef.`???`(). -[9:6..9:8) => example/Access#m7(). -[9:11..9:14) => scala/Predef.`???`(). +[0:8..0:15) example <- example/ +[2:6..2:12) Access <- example/Access# +[3:2..3:2) <- example/Access#``(). +[3:14..3:16) m1 <- example/Access#m1(). +[3:19..3:22) ??? -> scala/Predef.`???`(). +[4:20..4:22) m2 <- example/Access#m2(). +[4:25..4:28) ??? -> scala/Predef.`???`(). +[5:10..5:16) Access -> example/Access# +[5:22..5:24) m3 <- example/Access#m3(). +[5:27..5:30) ??? -> scala/Predef.`???`(). +[6:16..6:18) m4 <- example/Access#m4(). +[6:21..6:24) ??? -> scala/Predef.`???`(). +[7:22..7:24) m5 <- example/Access#m5(). +[7:27..7:30) ??? -> scala/Predef.`???`(). +[8:12..8:19) example -> example/ +[8:25..8:27) m6 <- example/Access#m6(). +[8:30..8:33) ??? -> scala/Predef.`???`(). +[9:6..9:8) m7 <- example/Access#m7(). +[9:11..9:14) ??? -> scala/Predef.`???`(). expect/Advanced.scala _____________________ @@ -89,102 +89,102 @@ local9 => val local e3 local10 => val local e3x Occurrences: -[0:8..0:16) => advanced/ -[2:7..2:12) => scala/ -[2:13..2:21) => scalaShadowing/language. -[2:22..2:33) => scalaShadowing/language.higherKinds. -[3:7..3:12) => scala/ -[3:13..3:21) => scalaShadowing/language. -[3:22..3:37) => scalaShadowing/language.reflectiveCalls. -[5:7..5:12) => scala/ -[5:13..5:20) => scala/reflect/ -[5:21..5:31) => scala/reflect/Selectable. -[5:32..5:52) => scala/reflect/Selectable.reflectiveSelectable(). -[7:6..7:7) => advanced/C# -[7:7..7:10) => advanced/C#``(). -[7:8..7:9) => advanced/C#[T] -[8:6..8:7) => advanced/C#t(). -[8:9..8:10) => advanced/C#[T] -[8:13..8:16) => scala/Predef.`???`(). -[11:6..11:16) => advanced/Structural# -[12:2..12:2) => advanced/Structural#``(). -[12:6..12:8) => advanced/Structural#s1(). -[12:16..12:17) => local0 -[12:19..12:22) => scala/Int# -[12:27..12:30) => scala/Predef.`???`(). -[13:6..13:8) => advanced/Structural#s2(). -[13:16..13:17) => local1 -[13:19..13:22) => scala/Int# -[13:33..13:33) => local2 -[13:37..13:38) => local3 -[13:40..13:43) => scala/Int# -[13:46..13:49) => scala/Predef.`???`(). -[13:51..13:51) => local2 -[14:6..14:8) => advanced/Structural#s3(). -[14:16..14:17) => local4 -[14:18..14:19) => local5 -[14:21..14:24) => scala/Int# -[14:27..14:30) => scala/Int# -[14:41..14:41) => local6 -[14:45..14:46) => local7 -[14:47..14:48) => local8 -[14:50..14:53) => scala/Int# -[14:56..14:59) => scala/Int# -[14:62..14:65) => scala/Predef.`???`(). -[14:67..14:67) => local6 -[17:6..17:15) => advanced/Wildcards# -[18:2..18:2) => advanced/Wildcards#``(). -[18:6..18:8) => advanced/Wildcards#e1(). -[18:10..18:14) => scala/package.List# -[18:20..18:23) => scala/Predef.`???`(). -[21:7..21:11) => advanced/Test. -[22:6..22:7) => advanced/Test.s. -[22:14..22:24) => advanced/Structural# -[22:24..22:24) => advanced/Structural#``(). -[23:6..23:8) => advanced/Test.s1. -[23:11..23:12) => advanced/Test.s. -[23:13..23:15) => advanced/Structural#s1(). -[24:6..24:9) => advanced/Test.s1x. -[24:12..24:12) => scala/reflect/Selectable.reflectiveSelectable(). -[24:12..24:13) => advanced/Test.s. -[24:14..24:16) => advanced/Structural#s1(). -[24:16..24:16) => scala/Selectable#selectDynamic(). -[25:6..25:8) => advanced/Test.s2. -[25:11..25:12) => advanced/Test.s. -[25:13..25:15) => advanced/Structural#s2(). -[26:6..26:9) => advanced/Test.s2x. -[26:12..26:12) => scala/reflect/Selectable.reflectiveSelectable(). -[26:12..26:13) => advanced/Test.s. -[26:14..26:16) => advanced/Structural#s2(). -[26:16..26:16) => scala/Selectable#selectDynamic(). -[27:6..27:8) => advanced/Test.s3. -[27:11..27:12) => advanced/Test.s. -[27:13..27:15) => advanced/Structural#s3(). -[28:6..28:9) => advanced/Test.s3x. -[28:12..28:12) => scala/reflect/Selectable.reflectiveSelectable(). -[28:12..28:13) => advanced/Test.s. -[28:14..28:16) => advanced/Structural#s3(). -[28:16..28:16) => scala/Selectable#applyDynamic(). -[28:18..28:18) => scala/reflect/ClassTag.apply(). -[28:18..28:18) => java/lang/Integer#TYPE. -[28:19..28:22) => scala/Predef.`???`(). -[30:6..30:7) => advanced/Test.e. -[30:14..30:23) => advanced/Wildcards# -[30:23..30:23) => advanced/Wildcards#``(). -[31:6..31:8) => advanced/Test.e1. -[31:11..31:12) => advanced/Test.e. -[31:13..31:15) => advanced/Wildcards#e1(). -[32:6..32:9) => advanced/Test.e1x. -[32:12..32:13) => advanced/Test.e. -[32:14..32:16) => advanced/Wildcards#e1(). -[32:17..32:21) => scala/collection/IterableOps#head(). -[35:5..35:8) => scala/Predef.`???`(). -[35:11..35:14) => scala/Any# -[36:11..36:13) => local9 -[36:15..36:19) => scala/package.List# -[37:12..37:15) => local10 -[37:18..37:20) => local9 -[37:21..37:25) => scala/collection/IterableOps#head(). +[0:8..0:16) advanced <- advanced/ +[2:7..2:12) scala -> scala/ +[2:13..2:21) language -> scalaShadowing/language. +[2:22..2:33) higherKinds -> scalaShadowing/language.higherKinds. +[3:7..3:12) scala -> scala/ +[3:13..3:21) language -> scalaShadowing/language. +[3:22..3:37) reflectiveCalls -> scalaShadowing/language.reflectiveCalls. +[5:7..5:12) scala -> scala/ +[5:13..5:20) reflect -> scala/reflect/ +[5:21..5:31) Selectable -> scala/reflect/Selectable. +[5:32..5:52) reflectiveSelectable -> scala/reflect/Selectable.reflectiveSelectable(). +[7:6..7:7) C <- advanced/C# +[7:7..7:10) <- advanced/C#``(). +[7:8..7:9) T <- advanced/C#[T] +[8:6..8:7) t <- advanced/C#t(). +[8:9..8:10) T -> advanced/C#[T] +[8:13..8:16) ??? -> scala/Predef.`???`(). +[11:6..11:16) Structural <- advanced/Structural# +[12:2..12:2) <- advanced/Structural#``(). +[12:6..12:8) s1 <- advanced/Structural#s1(). +[12:16..12:17) x <- local0 +[12:19..12:22) Int -> scala/Int# +[12:27..12:30) ??? -> scala/Predef.`???`(). +[13:6..13:8) s2 <- advanced/Structural#s2(). +[13:16..13:17) x <- local1 +[13:19..13:22) Int -> scala/Int# +[13:33..13:33) <- local2 +[13:37..13:38) x <- local3 +[13:40..13:43) Int -> scala/Int# +[13:46..13:49) ??? -> scala/Predef.`???`(). +[13:51..13:51) -> local2 +[14:6..14:8) s3 <- advanced/Structural#s3(). +[14:16..14:17) m <- local4 +[14:18..14:19) x <- local5 +[14:21..14:24) Int -> scala/Int# +[14:27..14:30) Int -> scala/Int# +[14:41..14:41) <- local6 +[14:45..14:46) m <- local7 +[14:47..14:48) x <- local8 +[14:50..14:53) Int -> scala/Int# +[14:56..14:59) Int -> scala/Int# +[14:62..14:65) ??? -> scala/Predef.`???`(). +[14:67..14:67) -> local6 +[17:6..17:15) Wildcards <- advanced/Wildcards# +[18:2..18:2) <- advanced/Wildcards#``(). +[18:6..18:8) e1 <- advanced/Wildcards#e1(). +[18:10..18:14) List -> scala/package.List# +[18:20..18:23) ??? -> scala/Predef.`???`(). +[21:7..21:11) Test <- advanced/Test. +[22:6..22:7) s <- advanced/Test.s. +[22:14..22:24) Structural -> advanced/Structural# +[22:24..22:24) -> advanced/Structural#``(). +[23:6..23:8) s1 <- advanced/Test.s1. +[23:11..23:12) s -> advanced/Test.s. +[23:13..23:15) s1 -> advanced/Structural#s1(). +[24:6..24:9) s1x <- advanced/Test.s1x. +[24:12..24:12) -> scala/reflect/Selectable.reflectiveSelectable(). +[24:12..24:13) s -> advanced/Test.s. +[24:14..24:16) s1 -> advanced/Structural#s1(). +[24:16..24:16) -> scala/Selectable#selectDynamic(). +[25:6..25:8) s2 <- advanced/Test.s2. +[25:11..25:12) s -> advanced/Test.s. +[25:13..25:15) s2 -> advanced/Structural#s2(). +[26:6..26:9) s2x <- advanced/Test.s2x. +[26:12..26:12) -> scala/reflect/Selectable.reflectiveSelectable(). +[26:12..26:13) s -> advanced/Test.s. +[26:14..26:16) s2 -> advanced/Structural#s2(). +[26:16..26:16) -> scala/Selectable#selectDynamic(). +[27:6..27:8) s3 <- advanced/Test.s3. +[27:11..27:12) s -> advanced/Test.s. +[27:13..27:15) s3 -> advanced/Structural#s3(). +[28:6..28:9) s3x <- advanced/Test.s3x. +[28:12..28:12) -> scala/reflect/Selectable.reflectiveSelectable(). +[28:12..28:13) s -> advanced/Test.s. +[28:14..28:16) s3 -> advanced/Structural#s3(). +[28:16..28:16) -> scala/Selectable#applyDynamic(). +[28:18..28:18) -> scala/reflect/ClassTag.apply(). +[28:18..28:18) -> java/lang/Integer#TYPE. +[28:19..28:22) ??? -> scala/Predef.`???`(). +[30:6..30:7) e <- advanced/Test.e. +[30:14..30:23) Wildcards -> advanced/Wildcards# +[30:23..30:23) -> advanced/Wildcards#``(). +[31:6..31:8) e1 <- advanced/Test.e1. +[31:11..31:12) e -> advanced/Test.e. +[31:13..31:15) e1 -> advanced/Wildcards#e1(). +[32:6..32:9) e1x <- advanced/Test.e1x. +[32:12..32:13) e -> advanced/Test.e. +[32:14..32:16) e1 -> advanced/Wildcards#e1(). +[32:17..32:21) head -> scala/collection/IterableOps#head(). +[35:5..35:8) ??? -> scala/Predef.`???`(). +[35:11..35:14) Any -> scala/Any# +[36:11..36:13) e3 <- local9 +[36:15..36:19) List -> scala/package.List# +[37:12..37:15) e3x <- local10 +[37:18..37:20) e3 -> local9 +[37:21..37:25) head -> scala/collection/IterableOps#head(). expect/Annotations.scala ________________________ @@ -222,57 +222,57 @@ local0 => selfparam self local1 => val local local Occurrences: -[0:8..0:13) => annot/ -[2:7..2:10) => com/ -[2:11..2:17) => com/javacp/ -[2:18..2:23) => com/javacp/annot/ -[3:7..3:12) => scala/ -[3:13..3:23) => scala/annotation/ -[3:24..3:28) => scala/annotation/meta/ -[4:7..4:12) => scala/ -[4:13..4:21) => scalaShadowing/language. -[4:22..4:34) => scalaShadowing/language.experimental. -[4:35..4:41) => scalaShadowing/language.experimental.macros. -[6:1..6:16) => com/javacp/annot/ClassAnnotation# -[7:6..7:17) => annot/Annotations# -[7:17..7:72) => annot/Annotations#``(). -[7:19..7:42) => com/javacp/annot/TypeParameterAnnotation# -[7:43..7:44) => annot/Annotations#[T] -[7:47..7:66) => com/javacp/annot/ParameterAnnotation# -[7:67..7:68) => annot/Annotations#x. -[7:70..7:71) => annot/Annotations#``().[T] -[7:75..7:79) => local0 -[7:81..7:87) => scala/AnyRef# -[8:3..8:18) => com/javacp/annot/FieldAnnotation# -[9:6..9:11) => annot/Annotations#field. -[11:3..11:19) => com/javacp/annot/MethodAnnotation# -[12:6..12:12) => annot/Annotations#method(). -[13:5..13:20) => com/javacp/annot/LocalAnnotation# -[14:8..14:13) => local1 -[15:4..15:9) => local1 -[17:3..17:17) => com/javacp/annot/TypeAnnotation# -[18:7..18:8) => annot/Annotations#S# -[21:6..21:7) => annot/B# -[21:7..21:40) => annot/B#``(). -[21:9..21:30) => com/javacp/annot/ConstructorAnnotation# -[21:33..21:34) => annot/B#x. -[21:36..21:39) => scala/Int# -[22:3..22:24) => com/javacp/annot/ConstructorAnnotation# -[23:6..23:12) => annot/B#``(+1). -[23:20..23:20) => annot/B#``(). -[26:1..26:17) => com/javacp/annot/ObjectAnnotation# -[27:7..27:8) => annot/M. -[28:3..28:18) => com/javacp/annot/MacroAnnotation# -[29:6..29:7) => annot/M.m(). -[29:8..29:10) => annot/M.m().[TT] -[29:13..29:16) => scala/Int# -[29:16..29:16) => scala/Predef.`???`(). -[32:0..32:0) => annot/T#``(). -[32:1..32:16) => com/javacp/annot/TraitAnnotation# -[33:6..33:7) => annot/T# -[35:7..35:12) => annot/Alias. -[36:7..36:8) => annot/Alias.A# -[36:11..36:26) => com/javacp/annot/ClassAnnotation# +[0:8..0:13) annot <- annot/ +[2:7..2:10) com -> com/ +[2:11..2:17) javacp -> com/javacp/ +[2:18..2:23) annot -> com/javacp/annot/ +[3:7..3:12) scala -> scala/ +[3:13..3:23) annotation -> scala/annotation/ +[3:24..3:28) meta -> scala/annotation/meta/ +[4:7..4:12) scala -> scala/ +[4:13..4:21) language -> scalaShadowing/language. +[4:22..4:34) experimental -> scalaShadowing/language.experimental. +[4:35..4:41) macros -> scalaShadowing/language.experimental.macros. +[6:1..6:16) ClassAnnotation -> com/javacp/annot/ClassAnnotation# +[7:6..7:17) Annotations <- annot/Annotations# +[7:17..7:72) <- annot/Annotations#``(). +[7:19..7:42) TypeParameterAnnotation -> com/javacp/annot/TypeParameterAnnotation# +[7:43..7:44) T <- annot/Annotations#[T] +[7:47..7:66) ParameterAnnotation -> com/javacp/annot/ParameterAnnotation# +[7:67..7:68) x <- annot/Annotations#x. +[7:70..7:71) T -> annot/Annotations#``().[T] +[7:75..7:79) self <- local0 +[7:81..7:87) AnyRef -> scala/AnyRef# +[8:3..8:18) FieldAnnotation -> com/javacp/annot/FieldAnnotation# +[9:6..9:11) field <- annot/Annotations#field. +[11:3..11:19) MethodAnnotation -> com/javacp/annot/MethodAnnotation# +[12:6..12:12) method <- annot/Annotations#method(). +[13:5..13:20) LocalAnnotation -> com/javacp/annot/LocalAnnotation# +[14:8..14:13) local <- local1 +[15:4..15:9) local -> local1 +[17:3..17:17) TypeAnnotation -> com/javacp/annot/TypeAnnotation# +[18:7..18:8) S <- annot/Annotations#S# +[21:6..21:7) B <- annot/B# +[21:7..21:40) <- annot/B#``(). +[21:9..21:30) ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# +[21:33..21:34) x <- annot/B#x. +[21:36..21:39) Int -> scala/Int# +[22:3..22:24) ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# +[23:6..23:12) <- annot/B#``(+1). +[23:20..23:20) -> annot/B#``(). +[26:1..26:17) ObjectAnnotation -> com/javacp/annot/ObjectAnnotation# +[27:7..27:8) M <- annot/M. +[28:3..28:18) MacroAnnotation -> com/javacp/annot/MacroAnnotation# +[29:6..29:7) m <- annot/M.m(). +[29:8..29:10) TT <- annot/M.m().[TT] +[29:13..29:16) Int -> scala/Int# +[29:16..29:16) -> scala/Predef.`???`(). +[32:0..32:0) <- annot/T#``(). +[32:1..32:16) TraitAnnotation -> com/javacp/annot/TraitAnnotation# +[33:6..33:7) T <- annot/T# +[35:7..35:12) Alias <- annot/Alias. +[36:7..36:8) A <- annot/Alias.A# +[36:11..36:26) ClassAnnotation -> com/javacp/annot/ClassAnnotation# expect/Anonymous.scala ______________________ @@ -301,40 +301,40 @@ local0 => val local x local1 => primary ctor Occurrences: -[0:8..0:15) => example/ -[1:7..1:12) => scala/ -[1:13..1:21) => scalaShadowing/language. -[1:22..1:33) => scalaShadowing/language.higherKinds. -[3:6..3:15) => example/Anonymous# -[4:2..4:2) => example/Anonymous#``(). -[4:8..4:17) => example/Anonymous# -[6:6..6:13) => example/Anonymous#locally(). -[6:14..6:15) => example/Anonymous#locally().[A] -[6:17..6:18) => example/Anonymous#locally().(x) -[6:20..6:21) => example/Anonymous#locally().[A] -[6:24..6:25) => example/Anonymous#locally().[A] -[6:28..6:29) => example/Anonymous#locally().(x) -[8:6..8:8) => example/Anonymous#m1(). -[8:9..8:10) => example/Anonymous#m1().[T] -[8:17..8:20) => scala/Predef.`???`(). -[9:6..9:8) => example/Anonymous#m2(). -[9:10..9:13) => scala/Predef.Map# -[9:17..9:21) => scala/package.List# -[9:28..9:31) => scala/Predef.`???`(). -[10:2..10:9) => example/Anonymous#locally(). -[11:4..11:7) => scala/Predef.`???`(). -[11:24..11:28) => scala/package.List# -[13:2..13:9) => example/Anonymous#locally(). -[14:8..14:9) => local0 -[14:11..14:14) => scala/Int# -[14:18..14:21) => scala/Int# -[14:29..14:32) => scala/Predef.`???`(). -[17:2..17:2) => example/Anonymous#Foo#``(). -[17:8..17:11) => example/Anonymous#Foo# -[18:6..18:9) => example/Anonymous#foo. -[18:16..18:16) => local1 -[18:16..18:19) => example/Anonymous#Foo# -[18:22..18:22) => local1 +[0:8..0:15) example <- example/ +[1:7..1:12) scala -> scala/ +[1:13..1:21) language -> scalaShadowing/language. +[1:22..1:33) higherKinds -> scalaShadowing/language.higherKinds. +[3:6..3:15) Anonymous <- example/Anonymous# +[4:2..4:2) <- example/Anonymous#``(). +[4:8..4:17) Anonymous -> example/Anonymous# +[6:6..6:13) locally <- example/Anonymous#locally(). +[6:14..6:15) A <- example/Anonymous#locally().[A] +[6:17..6:18) x <- example/Anonymous#locally().(x) +[6:20..6:21) A -> example/Anonymous#locally().[A] +[6:24..6:25) A -> example/Anonymous#locally().[A] +[6:28..6:29) x -> example/Anonymous#locally().(x) +[8:6..8:8) m1 <- example/Anonymous#m1(). +[8:9..8:10) T <- example/Anonymous#m1().[T] +[8:17..8:20) ??? -> scala/Predef.`???`(). +[9:6..9:8) m2 <- example/Anonymous#m2(). +[9:10..9:13) Map -> scala/Predef.Map# +[9:17..9:21) List -> scala/package.List# +[9:28..9:31) ??? -> scala/Predef.`???`(). +[10:2..10:9) locally -> example/Anonymous#locally(). +[11:4..11:7) ??? -> scala/Predef.`???`(). +[11:24..11:28) List -> scala/package.List# +[13:2..13:9) locally -> example/Anonymous#locally(). +[14:8..14:9) x <- local0 +[14:11..14:14) Int -> scala/Int# +[14:18..14:21) Int -> scala/Int# +[14:29..14:32) ??? -> scala/Predef.`???`(). +[17:2..17:2) <- example/Anonymous#Foo#``(). +[17:8..17:11) Foo <- example/Anonymous#Foo# +[18:6..18:9) foo <- example/Anonymous#foo. +[18:16..18:16) <- local1 +[18:16..18:19) Foo -> example/Anonymous#Foo# +[18:22..18:22) -> local1 expect/Classes.scala ____________________ @@ -394,64 +394,64 @@ local0 => primary ctor local1 => val method local Occurrences: -[0:8..0:15) => classes/ -[2:6..2:8) => classes/C1# -[2:8..2:21) => classes/C1#``(). -[2:13..2:15) => classes/C1#x1. -[2:17..2:20) => scala/Int# -[2:30..2:36) => scala/AnyVal# -[2:36..2:36) => scala/AnyVal#``(). -[4:6..4:8) => classes/C2# -[4:8..4:21) => classes/C2#``(). -[4:13..4:15) => classes/C2#x2. -[4:17..4:20) => scala/Int# -[4:30..4:36) => scala/AnyVal# -[4:36..4:36) => scala/AnyVal#``(). -[5:7..5:9) => classes/C2. -[7:11..7:13) => classes/C3# -[7:13..7:21) => classes/C3#``(). -[7:14..7:15) => classes/C3#x. -[7:17..7:20) => scala/Int# -[9:11..9:13) => classes/C4# -[9:13..9:21) => classes/C4#``(). -[9:14..9:15) => classes/C4#x. -[9:17..9:20) => scala/Int# -[10:7..10:9) => classes/C4. -[12:7..12:8) => classes/M. -[13:17..13:19) => classes/M.C5# -[13:19..13:27) => classes/M.C5#``(). -[13:20..13:21) => classes/M.C5#x. -[13:23..13:26) => scala/Int# -[16:11..16:13) => classes/C6# -[16:13..16:33) => classes/C6#``(). -[16:26..16:27) => classes/C6#x. -[16:29..16:32) => scala/Int# -[18:6..18:8) => classes/C7# -[18:8..18:16) => classes/C7#``(). -[18:9..18:10) => classes/C7#x. -[18:12..18:15) => scala/Int# -[20:6..20:8) => classes/C8# -[20:8..20:34) => classes/C8#``(). -[20:27..20:28) => classes/C8#x. -[20:30..20:33) => scala/Int# -[22:6..22:8) => classes/C9# -[22:8..22:34) => classes/C9#``(). -[22:27..22:28) => classes/C9#x(). -[22:30..22:33) => scala/Int# -[24:7..24:8) => classes/N. -[25:6..25:15) => classes/N.anonClass. -[25:22..25:22) => local0 -[25:22..25:24) => classes/C7# -[25:24..25:24) => classes/C7#``(). -[26:8..26:13) => local1 -[26:16..26:19) => scala/Predef.`???`(). -[27:3..27:3) => local0 -[28:6..28:13) => classes/N.anonFun. -[28:16..28:20) => scala/package.List. -[28:20..28:20) => scala/collection/IterableFactory#apply(). -[28:24..28:27) => scala/collection/immutable/List#map(). -[30:4..30:9) => local2 -[30:10..30:11) => scala/Int#`+`(+4). +[0:8..0:15) classes <- classes/ +[2:6..2:8) C1 <- classes/C1# +[2:8..2:21) <- classes/C1#``(). +[2:13..2:15) x1 <- classes/C1#x1. +[2:17..2:20) Int -> scala/Int# +[2:30..2:36) AnyVal -> scala/AnyVal# +[2:36..2:36) -> scala/AnyVal#``(). +[4:6..4:8) C2 <- classes/C2# +[4:8..4:21) <- classes/C2#``(). +[4:13..4:15) x2 <- classes/C2#x2. +[4:17..4:20) Int -> scala/Int# +[4:30..4:36) AnyVal -> scala/AnyVal# +[4:36..4:36) -> scala/AnyVal#``(). +[5:7..5:9) C2 <- classes/C2. +[7:11..7:13) C3 <- classes/C3# +[7:13..7:21) <- classes/C3#``(). +[7:14..7:15) x <- classes/C3#x. +[7:17..7:20) Int -> scala/Int# +[9:11..9:13) C4 <- classes/C4# +[9:13..9:21) <- classes/C4#``(). +[9:14..9:15) x <- classes/C4#x. +[9:17..9:20) Int -> scala/Int# +[10:7..10:9) C4 <- classes/C4. +[12:7..12:8) M <- classes/M. +[13:17..13:19) C5 <- classes/M.C5# +[13:19..13:27) <- classes/M.C5#``(). +[13:20..13:21) x <- classes/M.C5#x. +[13:23..13:26) Int -> scala/Int# +[16:11..16:13) C6 <- classes/C6# +[16:13..16:33) <- classes/C6#``(). +[16:26..16:27) x <- classes/C6#x. +[16:29..16:32) Int -> scala/Int# +[18:6..18:8) C7 <- classes/C7# +[18:8..18:16) <- classes/C7#``(). +[18:9..18:10) x <- classes/C7#x. +[18:12..18:15) Int -> scala/Int# +[20:6..20:8) C8 <- classes/C8# +[20:8..20:34) <- classes/C8#``(). +[20:27..20:28) x <- classes/C8#x. +[20:30..20:33) Int -> scala/Int# +[22:6..22:8) C9 <- classes/C9# +[22:8..22:34) <- classes/C9#``(). +[22:27..22:28) x <- classes/C9#x(). +[22:30..22:33) Int -> scala/Int# +[24:7..24:8) N <- classes/N. +[25:6..25:15) anonClass <- classes/N.anonClass. +[25:22..25:22) <- local0 +[25:22..25:24) C7 -> classes/C7# +[25:24..25:24) -> classes/C7#``(). +[26:8..26:13) local <- local1 +[26:16..26:19) ??? -> scala/Predef.`???`(). +[27:3..27:3) -> local0 +[28:6..28:13) anonFun <- classes/N.anonFun. +[28:16..28:20) List -> scala/package.List. +[28:20..28:20) -> scala/collection/IterableFactory#apply(). +[28:24..28:27) map -> scala/collection/immutable/List#map(). +[30:4..30:9) local -> local2 +[30:10..30:11) + -> scala/Int#`+`(+4). expect/Definitions.scala ________________________ @@ -476,16 +476,16 @@ a/Definitions.b(). => var method b a/Definitions.c(). => method c Occurrences: -[0:8..0:9) => a/ -[1:7..1:18) => a/Definitions. -[2:6..2:7) => a/Definitions.a. -[3:6..3:7) => a/Definitions.b(). -[3:6..3:9) => a/Definitions.`b_=`(). -[4:6..4:7) => a/Definitions.c(). -[5:2..5:2) => a/Definitions.D#``(). -[5:8..5:9) => a/Definitions.D# -[6:2..6:2) => a/Definitions.E#``(). -[6:8..6:9) => a/Definitions.E# +[0:8..0:9) a <- a/ +[1:7..1:18) Definitions <- a/Definitions. +[2:6..2:7) a <- a/Definitions.a. +[3:6..3:7) b <- a/Definitions.b(). +[3:6..3:9) b = <- a/Definitions.`b_=`(). +[4:6..4:7) c <- a/Definitions.c(). +[5:2..5:2) <- a/Definitions.D#``(). +[5:8..5:9) D <- a/Definitions.D# +[6:2..6:2) <- a/Definitions.E#``(). +[6:8..6:9) E <- a/Definitions.E# expect/Empty.scala __________________ @@ -496,7 +496,7 @@ Uri => Empty.scala Text => empty Language => Scala Symbols => 6 entries -Occurrences => 11 entries +Occurrences => 10 entries Symbols: _empty_/A# => class A @@ -507,17 +507,16 @@ _empty_/B#``(). => primary ctor _empty_/B#a(). => method a Occurrences: -[0:0..0:0) => _empty_/ -[0:6..0:7) => _empty_/A# -[1:2..1:2) => _empty_/A#``(). -[1:6..1:7) => _empty_/A#b(). -[1:9..1:10) => _empty_/B# -[1:13..1:16) => scala/Predef.`???`(). -[4:6..4:7) => _empty_/B# -[5:2..5:2) => _empty_/B#``(). -[5:6..5:7) => _empty_/B#a(). -[5:9..5:10) => _empty_/A# -[5:13..5:16) => scala/Predef.`???`(). +[0:6..0:7) A <- _empty_/A# +[1:2..1:2) <- _empty_/A#``(). +[1:6..1:7) b <- _empty_/A#b(). +[1:9..1:10) B -> _empty_/B# +[1:13..1:16) ??? -> scala/Predef.`???`(). +[4:6..4:7) B <- _empty_/B# +[5:2..5:2) <- _empty_/B#``(). +[5:6..5:7) a <- _empty_/B#a(). +[5:9..5:10) A -> _empty_/A# +[5:13..5:16) ??? -> scala/Predef.`???`(). expect/EmptyObject.scala ________________________ @@ -534,8 +533,8 @@ Symbols: example/EmptyObject. => final object EmptyObject Occurrences: -[0:8..0:15) => example/ -[2:7..2:18) => example/EmptyObject. +[0:8..0:15) example <- example/ +[2:7..2:18) EmptyObject <- example/EmptyObject. expect/Enums.scala __________________ @@ -546,7 +545,7 @@ Uri => Enums.scala Text => empty Language => Scala Symbols => 69 entries -Occurrences => 156 entries +Occurrences => 155 entries Symbols: _empty_/Enums. => final object Enums @@ -620,162 +619,161 @@ local9 => primary ctor local10 => primary ctor Occurrences: -[0:0..0:0) => _empty_/ -[0:7..0:12) => _empty_/Enums. -[1:9..1:12) => _empty_/Enums.`=:=`. -[3:7..3:13) => _empty_/Enums.Colour# -[4:4..4:4) => _empty_/Enums.Colour#``(). -[4:9..4:12) => _empty_/Enums.Colour.Red. -[4:9..4:9) => scala/runtime/EnumValues#``(). -[4:9..4:12) => _empty_/Enums.Colour.Red. -[4:14..4:19) => _empty_/Enums.Colour.Green. -[4:14..4:19) => _empty_/Enums.Colour.Green. -[4:21..4:25) => _empty_/Enums.Colour.Blue. -[4:21..4:25) => _empty_/Enums.Colour.Blue. -[6:7..6:15) => _empty_/Enums.WeekDays# -[7:4..7:4) => _empty_/Enums.WeekDays#``(). -[7:4..7:4) => scala/runtime/EnumValues#``(). -[7:9..7:15) => _empty_/Enums.WeekDays.Monday. -[8:9..8:16) => _empty_/Enums.WeekDays.Tuesday. -[9:9..9:18) => _empty_/Enums.WeekDays.Wednesday. -[10:9..10:17) => _empty_/Enums.WeekDays.Thursday. -[11:9..11:15) => _empty_/Enums.WeekDays.Friday. -[12:9..12:17) => _empty_/Enums.WeekDays.Saturday. -[13:9..13:15) => _empty_/Enums.WeekDays.Sunday. -[15:7..15:12) => _empty_/Enums.Maybe# -[15:12..15:16) => _empty_/Enums.Maybe#``(). -[15:14..15:15) => _empty_/Enums.Maybe#[A] -[16:4..16:4) => _empty_/Enums.Maybe#``(). -[16:9..16:13) => _empty_/Enums.Maybe.Just# -[16:13..16:23) => _empty_/Enums.Maybe.Just#``(). -[16:14..16:19) => _empty_/Enums.Maybe.Just#value. -[16:21..16:22) => _empty_/Enums.Maybe.Just#``().[A] -[17:4..17:4) => local0 -[17:4..17:4) => _empty_/Enums.Maybe#``(). -[17:9..17:13) => _empty_/Enums.Maybe.None. -[17:13..17:13) => local0 -[19:7..19:10) => _empty_/Enums.Tag# -[19:10..19:13) => _empty_/Enums.Tag#``(). -[19:11..19:12) => _empty_/Enums.Tag#[A] -[20:9..20:15) => _empty_/Enums.Tag.IntTag. -[20:24..20:24) => local1 -[20:24..20:27) => _empty_/Enums.Tag# -[20:28..20:31) => scala/Int# -[20:32..20:32) => _empty_/Enums.Tag#``(). -[20:32..20:32) => local1 -[21:9..21:19) => _empty_/Enums.Tag.BooleanTag. -[21:28..21:28) => local2 -[21:28..21:31) => _empty_/Enums.Tag# -[21:32..21:39) => scala/Boolean# -[21:40..21:40) => _empty_/Enums.Tag#``(). -[21:40..21:40) => local2 -[23:7..23:10) => _empty_/Enums.`=:=`# -[23:10..23:16) => _empty_/Enums.`=:=`#``(). -[23:11..23:12) => _empty_/Enums.`=:=`#[A] -[23:14..23:15) => _empty_/Enums.`=:=`#[B] -[24:9..24:13) => _empty_/Enums.`=:=`.Refl# -[24:13..24:18) => _empty_/Enums.`=:=`.Refl#``(). -[24:14..24:15) => _empty_/Enums.`=:=`.Refl#[C] -[24:28..24:29) => _empty_/Enums.`=:=`.Refl#[C] -[24:30..24:33) => _empty_/Enums.`=:=`# -[24:34..24:35) => _empty_/Enums.`=:=`.Refl#[C] -[24:35..24:35) => _empty_/Enums.`=:=`#``(). -[26:6..26:12) => _empty_/Enums.unwrap(). -[26:13..26:14) => _empty_/Enums.unwrap().[A] -[26:15..26:16) => _empty_/Enums.unwrap().[B] -[26:18..26:21) => _empty_/Enums.unwrap().(opt) -[26:23..26:29) => scala/Option# -[26:30..26:31) => _empty_/Enums.unwrap().[A] -[26:40..26:42) => _empty_/Enums.unwrap().(ev) -[26:44..26:45) => _empty_/Enums.unwrap().[A] -[26:46..26:49) => _empty_/Enums.`=:=`# -[26:50..26:56) => scala/Option# -[26:57..26:58) => _empty_/Enums.unwrap().[B] -[26:62..26:68) => scala/Option# -[26:69..26:70) => _empty_/Enums.unwrap().[B] -[26:74..26:76) => _empty_/Enums.unwrap().(ev) -[27:9..27:13) => _empty_/Enums.`=:=`.Refl. -[27:19..27:22) => _empty_/Enums.unwrap().(opt) -[27:23..27:30) => scala/Option#flatMap(). -[27:31..27:39) => scala/Predef.identity(). -[27:40..27:46) => scala/Option# -[27:47..27:48) => _empty_/Enums.unwrap().[B] -[28:19..28:23) => scala/None. -[30:7..30:13) => _empty_/Enums.Planet# -[30:13..30:43) => _empty_/Enums.Planet#``(). -[30:14..30:18) => _empty_/Enums.Planet#mass. -[30:20..30:26) => scala/Double# -[30:28..30:34) => _empty_/Enums.Planet#radius. -[30:36..30:42) => scala/Double# -[30:52..30:56) => java/ -[30:57..30:61) => java/lang/ -[30:62..30:66) => java/lang/Enum# -[30:67..30:73) => _empty_/Enums.Planet# -[30:74..30:74) => java/lang/Enum#``(). -[31:22..31:23) => _empty_/Enums.Planet#G. -[32:8..32:22) => _empty_/Enums.Planet#surfaceGravity(). -[32:25..32:26) => _empty_/Enums.Planet#G. -[32:27..32:28) => scala/Double#`*`(+6). -[32:29..32:33) => _empty_/Enums.Planet#mass. -[32:34..32:35) => scala/Double#`/`(+6). -[32:37..32:43) => _empty_/Enums.Planet#radius. -[32:44..32:45) => scala/Double#`*`(+6). -[32:46..32:52) => _empty_/Enums.Planet#radius. -[33:8..33:21) => _empty_/Enums.Planet#surfaceWeight(). -[33:22..33:31) => _empty_/Enums.Planet#surfaceWeight().(otherMass) -[33:33..33:39) => scala/Double# -[33:43..33:52) => _empty_/Enums.Planet#surfaceWeight().(otherMass) -[33:53..33:54) => scala/Double#`*`(+6). -[33:55..33:69) => _empty_/Enums.Planet#surfaceGravity(). -[35:9..35:16) => _empty_/Enums.Planet.Mercury. -[35:25..35:25) => scala/runtime/EnumValues#``(). -[35:25..35:25) => local3 -[35:25..35:31) => _empty_/Enums.Planet# -[35:31..35:31) => _empty_/Enums.Planet#``(). -[35:52..35:52) => scala/runtime/EnumValues#register(). -[35:52..35:52) => local3 -[36:9..36:14) => _empty_/Enums.Planet.Venus. -[36:25..36:25) => local4 -[36:25..36:31) => _empty_/Enums.Planet# -[36:31..36:31) => _empty_/Enums.Planet#``(). -[36:52..36:52) => scala/runtime/EnumValues#register(). -[36:52..36:52) => local4 -[37:9..37:14) => _empty_/Enums.Planet.Earth. -[37:25..37:25) => local5 -[37:25..37:31) => _empty_/Enums.Planet# -[37:31..37:31) => _empty_/Enums.Planet#``(). -[37:53..37:53) => scala/runtime/EnumValues#register(). -[37:53..37:53) => local5 -[38:9..38:13) => _empty_/Enums.Planet.Mars. -[38:25..38:25) => local6 -[38:25..38:31) => _empty_/Enums.Planet# -[38:31..38:31) => _empty_/Enums.Planet#``(). -[38:52..38:52) => scala/runtime/EnumValues#register(). -[38:52..38:52) => local6 -[39:9..39:16) => _empty_/Enums.Planet.Jupiter. -[39:25..39:25) => local7 -[39:25..39:31) => _empty_/Enums.Planet# -[39:31..39:31) => _empty_/Enums.Planet#``(). -[39:52..39:52) => scala/runtime/EnumValues#register(). -[39:52..39:52) => local7 -[40:9..40:15) => _empty_/Enums.Planet.Saturn. -[40:25..40:25) => local8 -[40:25..40:31) => _empty_/Enums.Planet# -[40:31..40:31) => _empty_/Enums.Planet#``(). -[40:52..40:52) => scala/runtime/EnumValues#register(). -[40:52..40:52) => local8 -[41:9..41:15) => _empty_/Enums.Planet.Uranus. -[41:25..41:25) => local9 -[41:25..41:31) => _empty_/Enums.Planet# -[41:31..41:31) => _empty_/Enums.Planet#``(). -[41:52..41:52) => scala/runtime/EnumValues#register(). -[41:52..41:52) => local9 -[42:9..42:16) => _empty_/Enums.Planet.Neptune. -[42:25..42:25) => local10 -[42:25..42:31) => _empty_/Enums.Planet# -[42:31..42:31) => _empty_/Enums.Planet#``(). -[42:52..42:52) => scala/runtime/EnumValues#register(). -[42:52..42:52) => local10 +[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:9..4:12) Red -> _empty_/Enums.Colour.Red. +[4:9..4:9) -> scala/runtime/EnumValues#``(). +[4:9..4:12) Red <- _empty_/Enums.Colour.Red. +[4:14..4:19) Green -> _empty_/Enums.Colour.Green. +[4:14..4:19) Green <- _empty_/Enums.Colour.Green. +[4:21..4:25) Blue -> _empty_/Enums.Colour.Blue. +[4:21..4:25) Blue <- _empty_/Enums.Colour.Blue. +[6:7..6:15) WeekDays <- _empty_/Enums.WeekDays# +[7:4..7:4) <- _empty_/Enums.WeekDays#``(). +[7:4..7:4) -> scala/runtime/EnumValues#``(). +[7:9..7:15) Monday <- _empty_/Enums.WeekDays.Monday. +[8:9..8:16) Tuesday <- _empty_/Enums.WeekDays.Tuesday. +[9:9..9:18) Wednesday <- _empty_/Enums.WeekDays.Wednesday. +[10:9..10:17) Thursday <- _empty_/Enums.WeekDays.Thursday. +[11:9..11:15) Friday <- _empty_/Enums.WeekDays.Friday. +[12:9..12:17) Saturday <- _empty_/Enums.WeekDays.Saturday. +[13:9..13:15) Sunday <- _empty_/Enums.WeekDays.Sunday. +[15:7..15:12) Maybe <- _empty_/Enums.Maybe# +[15:12..15:16) <- _empty_/Enums.Maybe#``(). +[15:14..15:15) A <- _empty_/Enums.Maybe#[A] +[16:4..16:4) -> _empty_/Enums.Maybe#``(). +[16:9..16:13) Just <- _empty_/Enums.Maybe.Just# +[16:13..16:23) <- _empty_/Enums.Maybe.Just#``(). +[16:14..16:19) value <- _empty_/Enums.Maybe.Just#value. +[16:21..16:22) A -> _empty_/Enums.Maybe.Just#``().[A] +[17:4..17:4) <- local0 +[17:4..17:4) -> _empty_/Enums.Maybe#``(). +[17:9..17:13) None <- _empty_/Enums.Maybe.None. +[17:13..17:13) -> local0 +[19:7..19:10) Tag <- _empty_/Enums.Tag# +[19:10..19:13) <- _empty_/Enums.Tag#``(). +[19:11..19:12) A <- _empty_/Enums.Tag#[A] +[20:9..20:15) IntTag <- _empty_/Enums.Tag.IntTag. +[20:24..20:24) <- local1 +[20:24..20:27) Tag -> _empty_/Enums.Tag# +[20:28..20:31) Int -> scala/Int# +[20:32..20:32) -> _empty_/Enums.Tag#``(). +[20:32..20:32) -> local1 +[21:9..21:19) BooleanTag <- _empty_/Enums.Tag.BooleanTag. +[21:28..21:28) <- local2 +[21:28..21:31) Tag -> _empty_/Enums.Tag# +[21:32..21:39) Boolean -> scala/Boolean# +[21:40..21:40) -> _empty_/Enums.Tag#``(). +[21:40..21:40) -> local2 +[23:7..23:10) =:= <- _empty_/Enums.`=:=`# +[23:10..23:16) <- _empty_/Enums.`=:=`#``(). +[23:11..23:12) A <- _empty_/Enums.`=:=`#[A] +[23:14..23:15) B <- _empty_/Enums.`=:=`#[B] +[24:9..24:13) Refl <- _empty_/Enums.`=:=`.Refl# +[24:13..24:18) <- _empty_/Enums.`=:=`.Refl#``(). +[24:14..24:15) C <- _empty_/Enums.`=:=`.Refl#[C] +[24:28..24:29) C -> _empty_/Enums.`=:=`.Refl#[C] +[24:30..24:33) =:= -> _empty_/Enums.`=:=`# +[24:34..24:35) C -> _empty_/Enums.`=:=`.Refl#[C] +[24:35..24:35) -> _empty_/Enums.`=:=`#``(). +[26:6..26:12) unwrap <- _empty_/Enums.unwrap(). +[26:13..26:14) A <- _empty_/Enums.unwrap().[A] +[26:15..26:16) B <- _empty_/Enums.unwrap().[B] +[26:18..26:21) opt <- _empty_/Enums.unwrap().(opt) +[26:23..26:29) Option -> scala/Option# +[26:30..26:31) A -> _empty_/Enums.unwrap().[A] +[26:40..26:42) ev <- _empty_/Enums.unwrap().(ev) +[26:44..26:45) A -> _empty_/Enums.unwrap().[A] +[26:46..26:49) =:= -> _empty_/Enums.`=:=`# +[26:50..26:56) Option -> scala/Option# +[26:57..26:58) B -> _empty_/Enums.unwrap().[B] +[26:62..26:68) Option -> scala/Option# +[26:69..26:70) B -> _empty_/Enums.unwrap().[B] +[26:74..26:76) ev -> _empty_/Enums.unwrap().(ev) +[27:9..27:13) Refl -> _empty_/Enums.`=:=`.Refl. +[27:19..27:22) opt -> _empty_/Enums.unwrap().(opt) +[27:23..27:30) flatMap -> scala/Option#flatMap(). +[27:31..27:39) identity -> scala/Predef.identity(). +[27:40..27:46) Option -> scala/Option# +[27:47..27:48) B -> _empty_/Enums.unwrap().[B] +[28:19..28:23) None -> scala/None. +[30:7..30:13) Planet <- _empty_/Enums.Planet# +[30:13..30:43) <- _empty_/Enums.Planet#``(). +[30:14..30:18) mass <- _empty_/Enums.Planet#mass. +[30:20..30:26) Double -> scala/Double# +[30:28..30:34) radius <- _empty_/Enums.Planet#radius. +[30:36..30:42) Double -> scala/Double# +[30:52..30:56) java -> java/ +[30:57..30:61) lang -> java/lang/ +[30:62..30:66) Enum -> java/lang/Enum# +[30:67..30:73) Planet -> _empty_/Enums.Planet# +[30:74..30:74) -> java/lang/Enum#``(). +[31:22..31:23) G <- _empty_/Enums.Planet#G. +[32:8..32:22) surfaceGravity <- _empty_/Enums.Planet#surfaceGravity(). +[32:25..32:26) G -> _empty_/Enums.Planet#G. +[32:27..32:28) * -> scala/Double#`*`(+6). +[32:29..32:33) mass -> _empty_/Enums.Planet#mass. +[32:34..32:35) / -> scala/Double#`/`(+6). +[32:37..32:43) radius -> _empty_/Enums.Planet#radius. +[32:44..32:45) * -> scala/Double#`*`(+6). +[32:46..32:52) radius -> _empty_/Enums.Planet#radius. +[33:8..33:21) surfaceWeight <- _empty_/Enums.Planet#surfaceWeight(). +[33:22..33:31) otherMass <- _empty_/Enums.Planet#surfaceWeight().(otherMass) +[33:33..33:39) Double -> scala/Double# +[33:43..33:52) otherMass -> _empty_/Enums.Planet#surfaceWeight().(otherMass) +[33:53..33:54) * -> scala/Double#`*`(+6). +[33:55..33:69) surfaceGravity -> _empty_/Enums.Planet#surfaceGravity(). +[35:9..35:16) Mercury <- _empty_/Enums.Planet.Mercury. +[35:25..35:25) -> scala/runtime/EnumValues#``(). +[35:25..35:25) <- local3 +[35:25..35:31) Planet -> _empty_/Enums.Planet# +[35:31..35:31) -> _empty_/Enums.Planet#``(). +[35:52..35:52) -> scala/runtime/EnumValues#register(). +[35:52..35:52) -> local3 +[36:9..36:14) Venus <- _empty_/Enums.Planet.Venus. +[36:25..36:25) <- local4 +[36:25..36:31) Planet -> _empty_/Enums.Planet# +[36:31..36:31) -> _empty_/Enums.Planet#``(). +[36:52..36:52) -> scala/runtime/EnumValues#register(). +[36:52..36:52) -> local4 +[37:9..37:14) Earth <- _empty_/Enums.Planet.Earth. +[37:25..37:25) <- local5 +[37:25..37:31) Planet -> _empty_/Enums.Planet# +[37:31..37:31) -> _empty_/Enums.Planet#``(). +[37:53..37:53) -> scala/runtime/EnumValues#register(). +[37:53..37:53) -> local5 +[38:9..38:13) Mars <- _empty_/Enums.Planet.Mars. +[38:25..38:25) <- local6 +[38:25..38:31) Planet -> _empty_/Enums.Planet# +[38:31..38:31) -> _empty_/Enums.Planet#``(). +[38:52..38:52) -> scala/runtime/EnumValues#register(). +[38:52..38:52) -> local6 +[39:9..39:16) Jupiter <- _empty_/Enums.Planet.Jupiter. +[39:25..39:25) <- local7 +[39:25..39:31) Planet -> _empty_/Enums.Planet# +[39:31..39:31) -> _empty_/Enums.Planet#``(). +[39:52..39:52) -> scala/runtime/EnumValues#register(). +[39:52..39:52) -> local7 +[40:9..40:15) Saturn <- _empty_/Enums.Planet.Saturn. +[40:25..40:25) <- local8 +[40:25..40:31) Planet -> _empty_/Enums.Planet# +[40:31..40:31) -> _empty_/Enums.Planet#``(). +[40:52..40:52) -> scala/runtime/EnumValues#register(). +[40:52..40:52) -> local8 +[41:9..41:15) Uranus <- _empty_/Enums.Planet.Uranus. +[41:25..41:25) <- local9 +[41:25..41:31) Planet -> _empty_/Enums.Planet# +[41:31..41:31) -> _empty_/Enums.Planet#``(). +[41:52..41:52) -> scala/runtime/EnumValues#register(). +[41:52..41:52) -> local9 +[42:9..42:16) Neptune <- _empty_/Enums.Planet.Neptune. +[42:25..42:25) <- local10 +[42:25..42:31) Planet -> _empty_/Enums.Planet# +[42:31..42:31) -> _empty_/Enums.Planet#``(). +[42:52..42:52) -> scala/runtime/EnumValues#register(). +[42:52..42:52) -> local10 expect/EtaExpansion.scala _________________________ @@ -793,16 +791,16 @@ example/EtaExpansion# => class EtaExpansion example/EtaExpansion#``(). => primary ctor Occurrences: -[0:8..0:15) => example/ -[2:6..2:18) => example/EtaExpansion# -[3:2..3:2) => example/EtaExpansion#``(). -[3:2..3:6) => scala/Some. -[3:10..3:13) => scala/Option#map(). -[3:14..3:22) => scala/Predef.identity(). -[4:2..4:6) => scala/package.List. -[4:6..4:6) => scala/collection/IterableFactory#apply(). -[4:10..4:18) => scala/collection/LinearSeqOps#foldLeft(). -[4:25..4:26) => java/lang/String#`+`(). +[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:10..3:13) map -> scala/Option#map(). +[3:14..3:22) identity -> scala/Predef.identity(). +[4:2..4:6) List -> scala/package.List. +[4:6..4:6) -> scala/collection/IterableFactory#apply(). +[4:10..4:18) foldLeft -> scala/collection/LinearSeqOps#foldLeft(). +[4:25..4:26) + -> java/lang/String#`+`(). expect/Example.scala ____________________ @@ -823,33 +821,33 @@ example/Example.x. => val method x local0 => selfparam self Occurrences: -[0:8..0:15) => example/ -[2:7..2:12) => scala/ -[2:13..2:23) => scala/concurrent/ -[2:24..2:30) => scala/concurrent/Future. -[2:24..2:30) => scala/concurrent/Future# -[4:7..4:14) => example/Example. -[4:17..4:21) => local0 -[4:17..4:17) => example/Example. -[5:6..5:11) => scala/ -[5:12..5:22) => scala/collection/ -[5:23..5:30) => scala/collection/mutable/ -[5:31..5:36) => scala/collection/mutable/Stack# -[5:37..5:40) => scala/Int# -[5:41..5:41) => scala/collection/mutable/Stack#``(+1). -[6:6..6:10) => example/Example.main(). -[6:11..6:15) => example/Example.main().(args) -[6:17..6:22) => scala/Array# -[6:23..6:29) => scala/Predef.String# -[6:33..6:37) => scala/Unit# -[7:4..7:11) => scala/Predef.println(+1). -[9:6..9:7) => example/Example.x. -[9:10..9:15) => scala/ -[9:16..9:23) => scala/reflect/ -[9:24..9:32) => scala/reflect/package.classTag(). -[9:33..9:36) => scala/Int# -[9:37..9:37) => scala/reflect/ClassTag.apply(). -[9:37..9:37) => java/lang/Integer#TYPE. +[0:8..0:15) example <- example/ +[2:7..2:12) scala -> scala/ +[2:13..2:23) concurrent -> scala/concurrent/ +[2:24..2:30) Future -> scala/concurrent/Future. +[2:24..2:30) Future -> scala/concurrent/Future# +[4:7..4:14) Example <- example/Example. +[4:17..4:21) self <- local0 +[4:17..4:17) -> example/Example. +[5:6..5:11) scala -> scala/ +[5:12..5:22) collection -> scala/collection/ +[5:23..5:30) mutable -> scala/collection/mutable/ +[5:31..5:36) Stack -> scala/collection/mutable/Stack# +[5:37..5:40) Int -> scala/Int# +[5:41..5:41) -> scala/collection/mutable/Stack#``(+1). +[6:6..6:10) main <- example/Example.main(). +[6:11..6:15) args <- example/Example.main().(args) +[6:17..6:22) Array -> scala/Array# +[6:23..6:29) String -> scala/Predef.String# +[6:33..6:37) Unit -> scala/Unit# +[7:4..7:11) println -> scala/Predef.println(+1). +[9:6..9:7) x <- example/Example.x. +[9:10..9:15) scala -> scala/ +[9:16..9:23) reflect -> scala/reflect/ +[9:24..9:32) classTag -> scala/reflect/package.classTag(). +[9:33..9:36) Int -> scala/Int# +[9:37..9:37) -> scala/reflect/ClassTag.apply(). +[9:37..9:37) -> java/lang/Integer#TYPE. expect/Flags.scala __________________ @@ -860,7 +858,7 @@ Uri => Flags.scala Text => empty Language => Scala Symbols => 50 entries -Occurrences => 84 entries +Occurrences => 83 entries Symbols: flags/p/package. => final package object p @@ -915,90 +913,89 @@ local1 => val local xs2 local2 => case val method t Occurrences: -[0:8..0:13) => flags/ -[2:7..2:12) => scala/ -[2:13..2:21) => scalaShadowing/language. -[2:22..2:34) => scalaShadowing/language.experimental. -[2:35..2:41) => scalaShadowing/language.experimental.macros. -[4:0..4:0) => flags/p/ -[4:15..5:3) => flags/p/package. -[5:2..5:3) => flags/p/ -[5:19..5:20) => flags/p/package.x. -[6:25..6:26) => flags/p/package.y(). -[6:25..6:28) => flags/p/package.`y_=`(). -[6:28..6:31) => scala/Int# -[7:6..7:7) => flags/p/package.z(). -[7:8..7:10) => flags/p/package.z().(pp) -[7:12..7:15) => scala/Int# -[8:6..8:7) => flags/p/package.m(). -[8:8..8:10) => flags/p/package.m().[TT] -[8:13..8:16) => scala/Int# -[8:16..8:16) => scala/Predef.`???`(). -[9:17..9:18) => flags/p/package.C# -[9:18..9:47) => flags/p/package.C#``(). -[9:20..9:21) => flags/p/package.C#[T] -[9:20..9:21) => flags/p/package.C#``(+1).[T] -[9:24..9:25) => flags/p/package.C#[U] -[9:24..9:25) => flags/p/package.C#``(+1).[U] -[9:27..9:28) => flags/p/package.C#[V] -[9:27..9:28) => flags/p/package.C#``(+1).[V] -[9:30..9:31) => flags/p/package.C#x. -[9:33..9:34) => flags/p/package.C#``().[T] -[9:36..9:37) => flags/p/package.C#y. -[9:39..9:40) => flags/p/package.C#``().[U] -[9:42..9:43) => flags/p/package.C#z. -[9:45..9:46) => flags/p/package.C#``().[V] -[10:8..10:14) => flags/p/package.C#``(+1). -[10:22..10:22) => flags/p/package.C#``(). -[10:22..10:25) => scala/Predef.`???`(). -[10:27..10:30) => scala/Predef.`???`(). -[10:32..10:35) => scala/Predef.`???`(). -[11:8..11:9) => flags/p/package.C#w(). -[11:11..11:14) => scala/Int# -[13:7..13:9) => flags/p/package.T1# -[13:12..13:15) => scala/Int# -[14:7..14:9) => flags/p/package.T2# -[14:10..14:11) => flags/p/package.T2#[T] -[14:15..14:16) => flags/p/package.S# -[14:17..14:18) => flags/p/package.T2#[T] -[15:7..15:8) => flags/p/package.U# -[15:12..15:15) => scala/Int# -[16:7..16:8) => flags/p/package.V# -[16:12..16:15) => scala/Int# -[17:14..17:15) => flags/p/package.X. -[18:2..18:2) => flags/p/package.Y#``(). -[18:14..18:15) => flags/p/package.Y# -[19:2..19:2) => flags/p/package.Z#``(). -[19:15..19:16) => flags/p/package.Z# -[20:8..20:10) => flags/p/package.AA# -[20:10..20:42) => flags/p/package.AA#``(). -[20:11..20:12) => flags/p/package.AA#x. -[20:14..20:17) => scala/Int# -[20:23..20:24) => flags/p/package.AA#y. -[20:26..20:29) => scala/Int# -[20:35..20:36) => flags/p/package.AA#z(). -[20:35..20:38) => flags/p/package.AA#`z_=`(). -[20:38..20:41) => scala/Int# -[21:8..21:9) => flags/p/package.S# -[21:9..21:25) => flags/p/package.S#``(). -[21:11..21:22) => scala/specialized# -[21:22..21:22) => scala/specialized#``(+2). -[21:23..21:24) => flags/p/package.S#[T] -[22:6..22:10) => scala/package.List. -[22:10..22:10) => scala/collection/SeqFactory#unapplySeq(). -[22:11..22:14) => flags/p/package.xs1. -[22:11..22:14) => local0 -[22:15..22:15) => local0 -[22:18..22:21) => scala/Predef.`???`(). -[23:2..23:5) => scala/Predef.`???`(). -[23:19..23:23) => scala/package.List. -[23:23..23:23) => scala/collection/SeqFactory#unapplySeq(). -[23:24..23:27) => local1 -[23:32..23:35) => scala/Predef.`???`(). -[24:2..24:5) => scala/Predef.`???`(). -[24:22..24:26) => scala/package.List# -[24:27..24:28) => local2 -[24:33..24:36) => scala/Predef.`???`(). +[0:8..0:13) flags <- flags/ +[2:7..2:12) scala -> scala/ +[2:13..2:21) language -> scalaShadowing/language. +[2:22..2:34) experimental -> scalaShadowing/language.experimental. +[2:35..2:41) macros -> scalaShadowing/language.experimental.macros. +[4:15..5:3) <- flags/p/package. +[5:2..5:3) p -> flags/p/ +[5:19..5:20) x <- flags/p/package.x. +[6:25..6:26) y <- flags/p/package.y(). +[6:25..6:28) y: <- flags/p/package.`y_=`(). +[6:28..6:31) Int -> scala/Int# +[7:6..7:7) z <- flags/p/package.z(). +[7:8..7:10) pp <- flags/p/package.z().(pp) +[7:12..7:15) Int -> scala/Int# +[8:6..8:7) m <- flags/p/package.m(). +[8:8..8:10) TT <- flags/p/package.m().[TT] +[8:13..8:16) Int -> scala/Int# +[8:16..8:16) -> scala/Predef.`???`(). +[9:17..9:18) C <- flags/p/package.C# +[9:18..9:47) <- flags/p/package.C#``(). +[9:20..9:21) T <- flags/p/package.C#[T] +[9:20..9:21) T <- flags/p/package.C#``(+1).[T] +[9:24..9:25) U <- flags/p/package.C#[U] +[9:24..9:25) U <- flags/p/package.C#``(+1).[U] +[9:27..9:28) V <- flags/p/package.C#[V] +[9:27..9:28) V <- flags/p/package.C#``(+1).[V] +[9:30..9:31) x <- flags/p/package.C#x. +[9:33..9:34) T -> flags/p/package.C#``().[T] +[9:36..9:37) y <- flags/p/package.C#y. +[9:39..9:40) U -> flags/p/package.C#``().[U] +[9:42..9:43) z <- flags/p/package.C#z. +[9:45..9:46) V -> flags/p/package.C#``().[V] +[10:8..10:14) <- flags/p/package.C#``(+1). +[10:22..10:22) -> flags/p/package.C#``(). +[10:22..10:25) ??? -> scala/Predef.`???`(). +[10:27..10:30) ??? -> scala/Predef.`???`(). +[10:32..10:35) ??? -> scala/Predef.`???`(). +[11:8..11:9) w <- flags/p/package.C#w(). +[11:11..11:14) Int -> scala/Int# +[13:7..13:9) T1 <- flags/p/package.T1# +[13:12..13:15) Int -> scala/Int# +[14:7..14:9) T2 <- flags/p/package.T2# +[14:10..14:11) T <- flags/p/package.T2#[T] +[14:15..14:16) S -> flags/p/package.S# +[14:17..14:18) T -> flags/p/package.T2#[T] +[15:7..15:8) U <- flags/p/package.U# +[15:12..15:15) Int -> scala/Int# +[16:7..16:8) V <- flags/p/package.V# +[16:12..16:15) Int -> scala/Int# +[17:14..17:15) X <- flags/p/package.X. +[18:2..18:2) <- flags/p/package.Y#``(). +[18:14..18:15) Y <- flags/p/package.Y# +[19:2..19:2) <- flags/p/package.Z#``(). +[19:15..19:16) Z <- flags/p/package.Z# +[20:8..20:10) AA <- flags/p/package.AA# +[20:10..20:42) <- flags/p/package.AA#``(). +[20:11..20:12) x <- flags/p/package.AA#x. +[20:14..20:17) Int -> scala/Int# +[20:23..20:24) y <- flags/p/package.AA#y. +[20:26..20:29) Int -> scala/Int# +[20:35..20:36) z <- flags/p/package.AA#z(). +[20:35..20:38) z: <- flags/p/package.AA#`z_=`(). +[20:38..20:41) Int -> scala/Int# +[21:8..21:9) S <- flags/p/package.S# +[21:9..21:25) <- flags/p/package.S#``(). +[21:11..21:22) specialized -> scala/specialized# +[21:22..21:22) -> scala/specialized#``(+2). +[21:23..21:24) T <- flags/p/package.S#[T] +[22:6..22:10) List -> scala/package.List. +[22:10..22:10) -> scala/collection/SeqFactory#unapplySeq(). +[22:11..22:14) xs1 <- flags/p/package.xs1. +[22:11..22:14) xs1 <- local0 +[22:15..22:15) -> local0 +[22:18..22:21) ??? -> scala/Predef.`???`(). +[23:2..23:5) ??? -> scala/Predef.`???`(). +[23:19..23:23) List -> scala/package.List. +[23:23..23:23) -> scala/collection/SeqFactory#unapplySeq(). +[23:24..23:27) xs2 <- local1 +[23:32..23:35) ??? -> scala/Predef.`???`(). +[24:2..24:5) ??? -> scala/Predef.`???`(). +[24:22..24:26) List -> scala/package.List# +[24:27..24:28) t <- local2 +[24:33..24:36) ??? -> scala/Predef.`???`(). expect/ForComprehension.scala _____________________________ @@ -1016,69 +1013,69 @@ example/ForComprehension# => class ForComprehension example/ForComprehension#``(). => primary ctor Occurrences: -[0:8..0:15) => example/ -[2:6..2:22) => example/ForComprehension# -[3:2..3:2) => example/ForComprehension#``(). -[4:9..4:13) => scala/package.List. -[4:13..4:13) => scala/collection/IterableFactory#apply(). -[4:16..4:16) => scala/collection/immutable/List#flatMap(). -[5:4..5:5) => local0 -[5:9..5:13) => scala/package.List. -[5:13..5:13) => scala/collection/IterableFactory#apply(). -[5:16..5:16) => scala/collection/IterableOps#withFilter(). -[6:7..6:8) => local0 -[6:9..6:10) => scala/Int#`>`(+3). -[6:12..6:12) => scala/collection/WithFilter#map(). -[7:4..7:5) => local2 -[7:8..7:9) => local1 -[7:10..7:11) => scala/Int#`+`(+4). -[7:12..7:13) => local0 -[7:13..7:13) => scala/collection/immutable/List#map(). -[8:11..8:12) => local1 -[8:14..8:15) => local0 -[8:17..8:18) => local2 -[10:9..10:13) => scala/package.List. -[10:13..10:13) => scala/collection/IterableFactory#apply(). -[10:16..10:16) => scala/collection/immutable/List#flatMap(). -[11:9..11:13) => scala/package.List. -[11:13..11:13) => scala/collection/IterableFactory#apply(). -[11:14..11:15) => local3 -[11:16..11:16) => scala/collection/IterableOps#withFilter(). -[13:6..13:7) => local3 -[14:6..14:7) => local4 -[15:6..15:8) => scala/Any#`==`(). -[15:15..15:15) => scala/collection/WithFilter#flatMap(). -[19:9..19:13) => scala/package.List. -[19:13..19:13) => scala/collection/IterableFactory#apply(). -[19:15..19:16) => local3 -[19:18..19:19) => local4 -[19:21..19:21) => scala/collection/WithFilter#withFilter(). -[19:21..19:21) => scala/collection/IterableOps#withFilter(). -[21:6..21:7) => local3 -[22:6..22:7) => local4 -[23:6..23:7) => local5 -[24:6..24:7) => local6 -[25:6..25:8) => scala/Any#`==`(). -[25:21..25:21) => scala/collection/WithFilter#map(). -[26:4..26:5) => local7 -[27:6..27:7) => local3 -[28:6..28:7) => local4 -[29:6..29:7) => local5 -[30:6..30:7) => local6 -[31:5..31:5) => scala/collection/IterableOps#withFilter(). -[32:7..32:8) => local7 -[32:9..32:11) => scala/Any#`==`(). -[32:24..32:24) => scala/collection/WithFilter#flatMap(). -[33:9..33:13) => scala/package.List. -[33:13..33:13) => scala/collection/IterableFactory#apply(). -[33:14..33:15) => local7 -[33:16..33:16) => scala/collection/immutable/List#map(). -[36:6..36:7) => local3 -[37:6..37:7) => local4 -[38:6..38:7) => local5 -[39:6..39:7) => local6 -[40:6..40:7) => local7 -[41:6..41:7) => local8 +[0:8..0:15) example <- example/ +[2:6..2:22) ForComprehension <- example/ForComprehension# +[3:2..3:2) <- example/ForComprehension#``(). +[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 -> local0 +[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 -> local0 +[6:9..6:10) > -> scala/Int#`>`(+3). +[6:12..6:12) -> scala/collection/WithFilter#map(). +[7:4..7:5) c -> local2 +[7:8..7:9) a -> local1 +[7:10..7:11) + -> scala/Int#`+`(+4). +[7:12..7:13) b -> local0 +[7:13..7:13) -> scala/collection/immutable/List#map(). +[8:11..8:12) a -> local1 +[8:14..8:15) b -> local0 +[8:17..8:18) c -> local2 +[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:9..11:13) List -> scala/package.List. +[11:13..11:13) -> scala/collection/IterableFactory#apply(). +[11:14..11:15) a -> local3 +[11:16..11:16) -> scala/collection/IterableOps#withFilter(). +[13:6..13:7) a -> local3 +[14:6..14:7) b -> local4 +[15:6..15:8) == -> scala/Any#`==`(). +[15:15..15:15) -> scala/collection/WithFilter#flatMap(). +[19:9..19:13) List -> scala/package.List. +[19:13..19:13) -> scala/collection/IterableFactory#apply(). +[19:15..19:16) a -> local3 +[19:18..19:19) b -> local4 +[19:21..19:21) -> scala/collection/WithFilter#withFilter(). +[19:21..19:21) -> scala/collection/IterableOps#withFilter(). +[21:6..21:7) a -> local3 +[22:6..22:7) b -> local4 +[23:6..23:7) c -> local5 +[24:6..24:7) d -> local6 +[25:6..25:8) == -> scala/Any#`==`(). +[25:21..25:21) -> scala/collection/WithFilter#map(). +[26:4..26:5) e -> local7 +[27:6..27:7) a -> local3 +[28:6..28:7) b -> local4 +[29:6..29:7) c -> local5 +[30:6..30:7) d -> local6 +[31:5..31:5) -> scala/collection/IterableOps#withFilter(). +[32:7..32:8) e -> local7 +[32:9..32:11) == -> scala/Any#`==`(). +[32:24..32:24) -> scala/collection/WithFilter#flatMap(). +[33:9..33:13) List -> scala/package.List. +[33:13..33:13) -> scala/collection/IterableFactory#apply(). +[33:14..33:15) e -> local7 +[33:16..33:16) -> scala/collection/immutable/List#map(). +[36:6..36:7) a -> local3 +[37:6..37:7) b -> local4 +[38:6..38:7) c -> local5 +[39:6..39:7) d -> local6 +[40:6..40:7) e -> local7 +[41:6..41:7) f -> local8 expect/Givens.scala ___________________ @@ -1116,58 +1113,58 @@ a/b/Givens.hello1. => val method hello1 a/b/Givens.int2String(). => final implicit macro int2String Occurrences: -[0:8..0:9) => a/ -[1:8..1:9) => a/b/ -[3:7..3:13) => a/b/Givens. -[5:8..6:6) => a/b/Givens.given_sayHello_of_A. -[5:10..5:11) => a/b/Givens.given_sayHello_of_A.sayHello().[A] -[5:13..5:16) => a/b/Givens.given_sayHello_of_A.sayHello().(any) -[5:18..5:19) => a/b/Givens.given_sayHello_of_A.sayHello().[A] -[6:8..6:16) => a/b/Givens.given_sayHello_of_A.sayHello(). -[6:34..6:37) => a/b/Givens.given_sayHello_of_A.sayHello().(any) -[6:37..6:37) => scala/StringContext#s(). -[8:6..8:12) => a/b/Givens.hello1. -[8:15..8:15) => a/b/Givens.given_sayHello_of_A.sayHello(). -[10:8..10:14) => a/b/Givens.Monoid# -[10:14..10:17) => a/b/Givens.Monoid#``(). -[10:15..10:16) => a/b/Givens.Monoid#[A] -[11:8..11:13) => a/b/Givens.Monoid#empty(). -[11:15..11:16) => a/b/Givens.Monoid#[A] -[12:8..12:15) => a/b/Givens.Monoid#combine(). -[12:9..12:10) => a/b/Givens.Monoid#combine().(x) -[12:12..12:13) => a/b/Givens.Monoid#[A] -[12:24..12:25) => a/b/Givens.Monoid#combine().(y) -[12:27..12:28) => a/b/Givens.Monoid#[A] -[12:31..12:32) => a/b/Givens.Monoid#[A] -[14:8..15:4) => a/b/Givens.given_Monoid_String. -[14:8..14:14) => a/b/Givens.Monoid# -[14:15..14:21) => scala/Predef.String# -[15:8..15:13) => a/b/Givens.given_Monoid_String.empty(). -[16:8..16:15) => a/b/Givens.given_Monoid_String.combine(). -[16:9..16:10) => a/b/Givens.given_Monoid_String.combine().(x) -[16:12..16:18) => scala/Predef.String# -[16:29..16:30) => a/b/Givens.given_Monoid_String.combine().(y) -[16:32..16:38) => scala/Predef.String# -[16:42..16:43) => a/b/Givens.given_Monoid_String.combine().(x) -[16:44..16:45) => java/lang/String#`+`(). -[16:46..16:47) => a/b/Givens.given_Monoid_String.combine().(y) -[18:15..18:25) => a/b/Givens.int2String(). -[18:27..18:37) => scala/Conversion# -[18:38..18:41) => scala/Int# -[18:43..18:49) => scala/Predef.String# -[18:55..18:63) => scala/Any#toString(). -[20:6..20:9) => a/b/Givens.foo(). -[20:10..20:11) => a/b/Givens.foo().[A] -[20:19..20:20) => a/b/Givens.foo().(A) -[20:22..20:28) => a/b/Givens.Monoid# -[20:29..20:30) => a/b/Givens.foo().[A] -[20:34..20:35) => a/b/Givens.foo().[A] -[20:38..20:39) => a/b/Givens.foo().(A) -[20:40..20:47) => a/b/Givens.Monoid#combine(). -[20:48..20:49) => a/b/Givens.foo().(A) -[20:50..20:55) => a/b/Givens.Monoid#empty(). -[20:57..20:58) => a/b/Givens.foo().(A) -[20:59..20:64) => a/b/Givens.Monoid#empty(). +[0:8..0:9) a <- a/ +[1:8..1:9) b <- a/b/ +[3:7..3:13) Givens <- a/b/Givens. +[5:8..6:6) <- a/b/Givens.given_sayHello_of_A. +[5:10..5:11) A <- a/b/Givens.given_sayHello_of_A.sayHello().[A] +[5:13..5:16) any <- a/b/Givens.given_sayHello_of_A.sayHello().(any) +[5:18..5:19) A -> a/b/Givens.given_sayHello_of_A.sayHello().[A] +[6:8..6:16) sayHello <- a/b/Givens.given_sayHello_of_A.sayHello(). +[6:34..6:37) any -> a/b/Givens.given_sayHello_of_A.sayHello().(any) +[6:37..6:37) -> scala/StringContext#s(). +[8:6..8:12) hello1 <- a/b/Givens.hello1. +[8:15..8:15) -> a/b/Givens.given_sayHello_of_A.sayHello(). +[10:8..10:14) Monoid <- a/b/Givens.Monoid# +[10:14..10:17) <- a/b/Givens.Monoid#``(). +[10:15..10:16) A <- a/b/Givens.Monoid#[A] +[11:8..11:13) empty <- a/b/Givens.Monoid#empty(). +[11:15..11:16) A -> a/b/Givens.Monoid#[A] +[12:8..12:15) (x: A) <- a/b/Givens.Monoid#combine(). +[12:9..12:10) x <- a/b/Givens.Monoid#combine().(x) +[12:12..12:13) A -> a/b/Givens.Monoid#[A] +[12:24..12:25) y <- a/b/Givens.Monoid#combine().(y) +[12:27..12:28) A -> a/b/Givens.Monoid#[A] +[12:31..12:32) A -> a/b/Givens.Monoid#[A] +[14:8..15:4) <- a/b/Givens.given_Monoid_String. +[14:8..14:14) Monoid -> a/b/Givens.Monoid# +[14:15..14:21) String -> scala/Predef.String# +[15:8..15:13) empty <- a/b/Givens.given_Monoid_String.empty(). +[16:8..16:15) (x: Str <- a/b/Givens.given_Monoid_String.combine(). +[16:9..16:10) x <- a/b/Givens.given_Monoid_String.combine().(x) +[16:12..16:18) String -> scala/Predef.String# +[16:29..16:30) y <- a/b/Givens.given_Monoid_String.combine().(y) +[16:32..16:38) String -> scala/Predef.String# +[16:42..16:43) x -> a/b/Givens.given_Monoid_String.combine().(x) +[16:44..16:45) + -> java/lang/String#`+`(). +[16:46..16:47) y -> a/b/Givens.given_Monoid_String.combine().(y) +[18:15..18:25) int2String <- a/b/Givens.int2String(). +[18:27..18:37) Conversion -> scala/Conversion# +[18:38..18:41) Int -> scala/Int# +[18:43..18:49) String -> scala/Predef.String# +[18:55..18:63) toString -> scala/Any#toString(). +[20:6..20:9) foo <- a/b/Givens.foo(). +[20:10..20:11) A <- a/b/Givens.foo().[A] +[20:19..20:20) A <- a/b/Givens.foo().(A) +[20:22..20:28) Monoid -> a/b/Givens.Monoid# +[20:29..20:30) A -> a/b/Givens.foo().[A] +[20:34..20:35) A -> a/b/Givens.foo().[A] +[20:38..20:39) A -> a/b/Givens.foo().(A) +[20:40..20:47) combine -> a/b/Givens.Monoid#combine(). +[20:48..20:49) A -> a/b/Givens.foo().(A) +[20:50..20:55) empty -> a/b/Givens.Monoid#empty(). +[20:57..20:58) A -> a/b/Givens.foo().(A) +[20:59..20:64) empty -> a/b/Givens.Monoid#empty(). expect/ImplicitConversion.scala _______________________________ @@ -1202,64 +1199,64 @@ example/ImplicitConversion.newAny2stringadd#``().(self) => param self example/ImplicitConversion.newAny2stringadd#self. => val method self Occurrences: -[0:8..0:15) => example/ -[2:7..2:12) => scala/ -[2:13..2:21) => scalaShadowing/language. -[2:22..2:41) => scalaShadowing/language.implicitConversions. -[4:6..4:24) => example/ImplicitConversion# -[5:2..5:2) => example/ImplicitConversion#``(). -[5:9..5:27) => example/ImplicitConversion. -[6:15..6:28) => example/ImplicitConversion#string2Number(). -[7:6..7:12) => example/ImplicitConversion#string2Number().(string) -[7:14..7:20) => scala/Predef.String# -[8:5..8:8) => scala/Int# -[9:6..9:13) => example/ImplicitConversion#message. -[10:6..10:12) => example/ImplicitConversion#number. -[11:6..11:11) => example/ImplicitConversion#tuple. -[12:6..12:10) => example/ImplicitConversion#char. -[12:12..12:16) => scala/Char# -[15:2..15:2) => scala/Predef.augmentString(). -[15:2..15:9) => example/ImplicitConversion#message. -[16:5..16:16) => scala/collection/StringOps#stripSuffix(). -[17:2..17:7) => example/ImplicitConversion#tuple. -[17:8..17:9) => example/ImplicitConversion.newAny2stringadd#`+`(). -[20:6..20:7) => example/ImplicitConversion#x. -[20:9..20:12) => scala/Int# -[20:15..20:15) => example/ImplicitConversion#string2Number(). -[20:15..20:22) => example/ImplicitConversion#message. -[23:11..23:18) => example/ImplicitConversion#message. -[23:20..23:26) => example/ImplicitConversion#number. -[23:26..23:26) => scala/StringContext#s(). -[24:2..24:2) => scala/Predef.augmentString(). -[25:7..25:14) => example/ImplicitConversion#message. -[26:7..26:13) => example/ImplicitConversion#number. -[26:13..26:13) => scala/StringContext#s(). -[26:17..26:28) => scala/collection/StringOps#stripMargin(+1). -[28:6..28:7) => example/ImplicitConversion#a. -[28:9..28:12) => scala/Int# -[28:15..28:15) => scala/Char.char2int(). -[28:15..28:19) => example/ImplicitConversion#char. -[29:6..29:7) => example/ImplicitConversion#b. -[29:9..29:13) => scala/Long# -[29:16..29:16) => scala/Char.char2long(). -[29:16..29:20) => example/ImplicitConversion#char. -[32:7..32:25) => example/ImplicitConversion. -[33:23..33:39) => example/ImplicitConversion.newAny2stringadd# -[33:39..33:63) => example/ImplicitConversion.newAny2stringadd#``(). -[33:40..33:41) => example/ImplicitConversion.newAny2stringadd#[A] -[33:55..33:59) => example/ImplicitConversion.newAny2stringadd#self. -[33:61..33:62) => example/ImplicitConversion.newAny2stringadd#``().[A] -[33:72..33:78) => scala/AnyVal# -[33:78..33:78) => scala/AnyVal#``(). -[34:8..34:9) => example/ImplicitConversion.newAny2stringadd#`+`(). -[34:10..34:15) => example/ImplicitConversion.newAny2stringadd#`+`().(other) -[34:17..34:23) => scala/Predef.String# -[34:26..34:32) => scala/Predef.String# -[34:35..34:41) => java/lang/String# -[34:42..34:49) => java/lang/String#valueOf(). -[34:50..34:54) => example/ImplicitConversion.newAny2stringadd#self. -[34:56..34:57) => java/lang/String#`+`(). -[34:58..34:63) => example/ImplicitConversion.newAny2stringadd#`+`().(other) +[0:8..0:15) example <- example/ +[2:7..2:12) scala -> scala/ +[2:13..2:21) language -> scalaShadowing/language. +[2:22..2:41) implicitConversions -> scalaShadowing/language.implicitConversions. +[4:6..4:24) ImplicitConversion <- example/ImplicitConversion# +[5:2..5:2) <- example/ImplicitConversion#``(). +[5:9..5:27) ImplicitConversion -> example/ImplicitConversion. +[6:15..6:28) string2Number <- example/ImplicitConversion#string2Number(). +[7:6..7:12) string <- example/ImplicitConversion#string2Number().(string) +[7:14..7:20) String -> scala/Predef.String# +[8:5..8:8) Int -> scala/Int# +[9:6..9:13) message <- example/ImplicitConversion#message. +[10:6..10:12) number <- example/ImplicitConversion#number. +[11:6..11:11) tuple <- example/ImplicitConversion#tuple. +[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: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:11..23:18) message -> example/ImplicitConversion#message. +[23:20..23:26) number -> example/ImplicitConversion#number. +[23:26..23:26) -> scala/StringContext#s(). +[24:2..24:2) -> scala/Predef.augmentString(). +[25:7..25:14) message -> example/ImplicitConversion#message. +[26:7..26:13) number -> example/ImplicitConversion#number. +[26:13..26:13) -> scala/StringContext#s(). +[26:17..26:28) stripMargin -> scala/collection/StringOps#stripMargin(+1). +[28:6..28:7) a <- example/ImplicitConversion#a. +[28:9..28:12) Int -> scala/Int# +[28:15..28:15) -> scala/Char.char2int(). +[28:15..28:19) char -> example/ImplicitConversion#char. +[29:6..29:7) b <- example/ImplicitConversion#b. +[29:9..29:13) Long -> scala/Long# +[29:16..29:16) -> scala/Char.char2long(). +[29:16..29:20) char -> example/ImplicitConversion#char. +[32:7..32:25) ImplicitConversion <- example/ImplicitConversion. +[33:23..33:39) newAny2stringadd <- example/ImplicitConversion.newAny2stringadd# +[33:39..33:63) <- example/ImplicitConversion.newAny2stringadd#``(). +[33:40..33:41) A <- example/ImplicitConversion.newAny2stringadd#[A] +[33:55..33:59) self <- example/ImplicitConversion.newAny2stringadd#self. +[33:61..33:62) A -> example/ImplicitConversion.newAny2stringadd#``().[A] +[33:72..33:78) AnyVal -> scala/AnyVal# +[33:78..33:78) -> scala/AnyVal#``(). +[34:8..34:9) + <- example/ImplicitConversion.newAny2stringadd#`+`(). +[34:10..34:15) other <- example/ImplicitConversion.newAny2stringadd#`+`().(other) +[34:17..34:23) String -> scala/Predef.String# +[34:26..34:32) String -> scala/Predef.String# +[34:35..34:41) String -> java/lang/String# +[34:42..34:49) valueOf -> java/lang/String#valueOf(). +[34:50..34:54) self -> example/ImplicitConversion.newAny2stringadd#self. +[34:56..34:57) + -> java/lang/String#`+`(). +[34:58..34:63) other -> example/ImplicitConversion.newAny2stringadd#`+`().(other) expect/Imports.scala ____________________ @@ -1270,16 +1267,15 @@ Uri => Imports.scala Text => empty Language => Scala Symbols => 0 entries -Occurrences => 5 entries +Occurrences => 4 entries Symbols: Occurrences: -[0:0..0:0) => _empty_/ -[0:7..0:12) => scala/ -[0:13..0:17) => scala/util/ -[0:18..0:25) => scala/util/control/ -[0:26..0:34) => scala/util/control/NonFatal. +[0:7..0:12) scala -> scala/ +[0:13..0:17) util -> scala/util/ +[0:18..0:25) control -> scala/util/control/ +[0:26..0:34) NonFatal -> scala/util/control/NonFatal. expect/InstrumentTyper.scala ____________________________ @@ -1303,60 +1299,60 @@ example/InstrumentTyper#singletonType().(x) => val param x local0 => selfparam self Occurrences: -[0:8..0:15) => example/ -[2:7..2:12) => scala/ -[2:13..2:23) => scala/annotation/ -[2:24..2:28) => scala/annotation/meta/ -[2:29..2:34) => scala/annotation/meta/param. -[3:7..3:12) => scala/ -[3:13..3:21) => scalaShadowing/language. -[3:22..3:34) => scalaShadowing/language.existentials. -[4:7..4:12) => scala/ -[4:13..4:21) => scalaShadowing/language. -[4:22..4:33) => scalaShadowing/language.higherKinds. -[5:7..5:12) => types/ -[5:13..5:17) => types/Test. -[7:6..7:21) => example/InstrumentTyper# -[7:24..7:24) => example/InstrumentTyper#``(). -[7:24..7:28) => local0 -[7:30..7:36) => scala/AnyRef# -[8:6..8:9) => example/InstrumentTyper#all(). -[8:12..8:16) => scala/package.List. -[8:16..8:16) => scala/collection/IterableFactory#apply(). -[9:4..9:11) => types/Test.Literal. -[9:12..9:15) => types/Test.Literal.int. -[10:4..10:11) => types/Test.Literal. -[10:12..10:16) => types/Test.Literal.long. -[11:4..11:11) => types/Test.Literal. -[11:12..11:17) => types/Test.Literal.float. -[12:4..12:11) => types/Test.Literal. -[12:12..12:18) => types/Test.Literal.double. -[13:4..13:11) => types/Test.Literal. -[13:12..13:15) => types/Test.Literal.nil. -[14:4..14:11) => types/Test.Literal. -[14:12..14:16) => types/Test.Literal.char. -[15:4..15:11) => types/Test.Literal. -[15:12..15:18) => types/Test.Literal.string. -[16:4..16:11) => types/Test.Literal. -[16:12..16:16) => types/Test.Literal.bool. -[17:4..17:11) => types/Test.Literal. -[17:12..17:16) => types/Test.Literal.unit. -[18:4..18:11) => types/Test.Literal. -[18:12..18:20) => types/Test.Literal.javaEnum. -[19:4..19:11) => types/Test.Literal. -[19:12..19:19) => types/Test.Literal.clazzOf. -[20:4..20:8) => scala/package.List. -[20:8..20:8) => scala/collection/IterableFactory#apply(). -[22:7..22:20) => example/InstrumentTyper#AnnotatedType# -[22:23..22:26) => scala/Int# -[23:6..23:19) => example/InstrumentTyper#singletonType(). -[23:20..23:21) => example/InstrumentTyper#singletonType().(x) -[23:23..23:29) => scala/Predef. -[23:38..23:41) => scala/Predef.`???`(). -[24:12..24:19) => example/InstrumentTyper#clazzOf. -[24:22..24:29) => scala/Predef.classOf(). -[24:30..24:36) => scala/Option# -[24:37..24:40) => scala/Int# +[0:8..0:15) example <- example/ +[2:7..2:12) scala -> scala/ +[2:13..2:23) annotation -> scala/annotation/ +[2:24..2:28) meta -> scala/annotation/meta/ +[2:29..2:34) param -> scala/annotation/meta/param. +[3:7..3:12) scala -> scala/ +[3:13..3:21) language -> scalaShadowing/language. +[3:22..3:34) existentials -> scalaShadowing/language.existentials. +[4:7..4:12) scala -> scala/ +[4:13..4:21) language -> scalaShadowing/language. +[4:22..4:33) higherKinds -> scalaShadowing/language.higherKinds. +[5:7..5:12) types -> types/ +[5:13..5:17) Test -> types/Test. +[7:6..7:21) InstrumentTyper <- example/InstrumentTyper# +[7:24..7:24) <- example/InstrumentTyper#``(). +[7:24..7:28) self <- local0 +[7:30..7:36) AnyRef -> scala/AnyRef# +[8:6..8:9) all <- example/InstrumentTyper#all(). +[8:12..8:16) List -> scala/package.List. +[8:16..8:16) -> scala/collection/IterableFactory#apply(). +[9:4..9:11) Literal -> types/Test.Literal. +[9:12..9:15) int -> types/Test.Literal.int. +[10:4..10:11) Literal -> types/Test.Literal. +[10:12..10:16) long -> types/Test.Literal.long. +[11:4..11:11) Literal -> types/Test.Literal. +[11:12..11:17) float -> types/Test.Literal.float. +[12:4..12:11) Literal -> types/Test.Literal. +[12:12..12:18) double -> types/Test.Literal.double. +[13:4..13:11) Literal -> types/Test.Literal. +[13:12..13:15) nil -> types/Test.Literal.nil. +[14:4..14:11) Literal -> types/Test.Literal. +[14:12..14:16) char -> types/Test.Literal.char. +[15:4..15:11) Literal -> types/Test.Literal. +[15:12..15:18) string -> types/Test.Literal.string. +[16:4..16:11) Literal -> types/Test.Literal. +[16:12..16:16) bool -> types/Test.Literal.bool. +[17:4..17:11) Literal -> types/Test.Literal. +[17:12..17:16) unit -> types/Test.Literal.unit. +[18:4..18:11) Literal -> types/Test.Literal. +[18:12..18:20) javaEnum -> types/Test.Literal.javaEnum. +[19:4..19:11) Literal -> types/Test.Literal. +[19:12..19:19) clazzOf -> types/Test.Literal.clazzOf. +[20:4..20:8) List -> scala/package.List. +[20:8..20:8) -> scala/collection/IterableFactory#apply(). +[22:7..22:20) AnnotatedType <- example/InstrumentTyper#AnnotatedType# +[22:23..22:26) Int -> scala/Int# +[23:6..23:19) singletonType <- example/InstrumentTyper#singletonType(). +[23:20..23:21) x <- example/InstrumentTyper#singletonType().(x) +[23:23..23:29) Predef -> scala/Predef. +[23:38..23:41) ??? -> scala/Predef.`???`(). +[24:12..24:19) clazzOf <- example/InstrumentTyper#clazzOf. +[24:22..24:29) classOf -> scala/Predef.classOf(). +[24:30..24:36) Option -> scala/Option# +[24:37..24:40) Int -> scala/Int# expect/Issue1749.scala ______________________ @@ -1379,34 +1375,34 @@ example/Issue1854#``(). => primary ctor example/Issue1854#map. => val method map Occurrences: -[1:8..1:15) => example/ -[3:7..3:12) => scala/ -[3:13..3:17) => scala/math/ -[3:18..3:25) => scala/math/Ordered. -[3:26..3:43) => scala/math/Ordered.orderingToOrdered(). -[5:6..5:15) => example/Issue1749# -[6:2..6:2) => example/Issue1749#``(). -[6:6..6:8) => example/Issue1749#x1. -[7:6..7:8) => example/Issue1749#x2. -[8:2..8:2) => scala/math/Ordered.orderingToOrdered(). -[8:3..8:5) => example/Issue1749#x1. -[8:7..8:9) => example/Issue1749#x1. -[8:10..8:10) => scala/math/Ordering.Tuple2(). -[8:10..8:10) => scala/math/Ordering.Int. -[9:5..9:12) => scala/math/Ordered#compare(). -[9:14..9:16) => example/Issue1749#x2. -[9:18..9:20) => example/Issue1749#x2. -[12:6..12:15) => example/Issue1854# -[13:2..13:2) => example/Issue1854#``(). -[13:6..13:9) => example/Issue1854#map. -[13:12..13:22) => scala/collection/ -[13:23..13:30) => scala/collection/mutable/ -[13:31..13:34) => scala/collection/mutable/Map. -[13:35..13:40) => scala/collection/MapFactory.Delegate#empty(). -[13:41..13:47) => scala/Predef.String# -[13:49..13:55) => scala/Predef.String# -[14:2..14:5) => example/Issue1854#map. -[14:5..14:5) => scala/collection/mutable/MapOps#update(). +[1:8..1:15) example <- example/ +[3:7..3:12) scala -> scala/ +[3:13..3:17) math -> scala/math/ +[3:18..3:25) Ordered -> scala/math/Ordered. +[3:26..3:43) orderingToOrdered -> scala/math/Ordered.orderingToOrdered(). +[5:6..5:15) Issue1749 <- example/Issue1749# +[6:2..6:2) <- example/Issue1749#``(). +[6:6..6:8) x1 <- example/Issue1749#x1. +[7:6..7:8) x2 <- example/Issue1749#x2. +[8:2..8:2) -> scala/math/Ordered.orderingToOrdered(). +[8:3..8: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:16) x2 -> example/Issue1749#x2. +[9:18..9:20) x2 -> example/Issue1749#x2. +[12:6..12:15) Issue1854 <- example/Issue1854# +[13:2..13:2) <- example/Issue1854#``(). +[13:6..13:9) map <- example/Issue1854#map. +[13:12..13:22) collection -> scala/collection/ +[13:23..13:30) mutable -> scala/collection/mutable/ +[13:31..13:34) Map -> scala/collection/mutable/Map. +[13:35..13:40) empty -> scala/collection/MapFactory.Delegate#empty(). +[13:41..13:47) String -> scala/Predef.String# +[13:49..13:55) String -> scala/Predef.String# +[14:2..14:5) map -> example/Issue1854#map. +[14:5..14:5) -> scala/collection/mutable/MapOps#update(). expect/Local.scala __________________ @@ -1428,17 +1424,17 @@ local1 => typeparam A local2 => val param a Occurrences: -[0:8..0:15) => example/ -[2:6..2:11) => example/Local# -[3:2..3:2) => example/Local#``(). -[3:6..3:7) => example/Local#a(). -[4:8..4:10) => local0 -[4:11..4:12) => local1 -[4:14..4:15) => local2 -[4:17..4:18) => local1 -[4:21..4:22) => local1 -[4:25..4:26) => local2 -[5:4..5:6) => local0 +[0:8..0:15) example <- example/ +[2:6..2:11) Local <- example/Local# +[3:2..3:2) <- example/Local#``(). +[3:6..3:7) a <- example/Local#a(). +[4:8..4:10) id <- local0 +[4:11..4:12) A <- local1 +[4:14..4:15) a <- local2 +[4:17..4:18) A -> local1 +[4:21..4:22) A -> local1 +[4:25..4:26) a -> local2 +[5:4..5:6) id -> local0 expect/Locals.scala ___________________ @@ -1457,13 +1453,13 @@ locals/Test. => final object Test locals/Test.xs. => val method xs Occurrences: -[0:8..0:14) => locals/ -[2:7..2:11) => locals/Test. -[3:6..3:8) => locals/Test.xs. -[4:8..4:9) => local0 -[5:4..5:8) => scala/package.List. -[5:8..5:8) => scala/collection/IterableFactory#apply(). -[5:9..5:10) => local0 +[0:8..0:14) locals <- locals/ +[2:7..2:11) Test <- locals/Test. +[3:6..3:8) xs <- locals/Test.xs. +[4:8..4:9) x <- local0 +[5:4..5:8) List -> scala/package.List. +[5:8..5:8) -> scala/collection/IterableFactory#apply(). +[5:9..5:10) x -> local0 expect/MetacJava.scala ______________________ @@ -1489,78 +1485,78 @@ example/MetacJava#overload2. => val method overload2 example/MetacJava#staticInner. => val method staticInner Occurrences: -[0:8..0:15) => example/ -[2:7..2:10) => com/ -[2:11..2:17) => com/javacp/ -[4:6..4:15) => example/MetacJava# -[5:2..5:2) => example/MetacJava#``(). -[5:2..5:8) => com/javacp/ -[5:9..5:18) => com/javacp/MetacJava# -[5:19..5:30) => com/javacp/MetacJava#StaticInner# -[5:31..5:39) => com/javacp/MetacJava#StaticInner#isStatic(). -[6:6..6:12) => com/javacp/ -[6:13..6:22) => com/javacp/MetacJava# -[6:23..6:34) => com/javacp/MetacJava#StaticInner# -[6:34..6:34) => com/javacp/MetacJava#StaticInner#``(). -[6:37..6:48) => com/javacp/MetacJava#StaticInner#isNotStatic(). -[7:6..7:11) => example/MetacJava#inner. -[7:18..7:24) => com/javacp/ -[7:25..7:34) => com/javacp/MetacJava# -[7:34..7:34) => com/javacp/MetacJava#``(). -[8:6..8:15) => example/MetacJava#overload1. -[8:22..8:27) => example/MetacJava#inner. -[8:28..8:37) => com/javacp/MetacJava#Overload1# -[8:37..8:37) => com/javacp/MetacJava#Overload1#``(). -[9:6..9:15) => example/MetacJava#overload2. -[9:22..9:27) => example/MetacJava#inner. -[9:28..9:37) => com/javacp/MetacJava#Overload2# -[9:37..9:37) => com/javacp/MetacJava#Overload2#``(). -[10:2..10:7) => example/MetacJava#inner. -[10:8..10:16) => com/javacp/MetacJava#overload(). -[10:21..10:30) => example/MetacJava#overload1. -[10:31..10:32) => com/javacp/MetacJava#Overload1#A# -[10:32..10:32) => com/javacp/MetacJava#Overload1#A#``(). -[11:2..11:7) => example/MetacJava#inner. -[11:8..11:16) => com/javacp/MetacJava#overload(+1). -[11:21..11:30) => example/MetacJava#overload2. -[11:31..11:32) => com/javacp/MetacJava#Overload2#A# -[11:32..11:32) => com/javacp/MetacJava#Overload2#A#``(). -[12:6..12:17) => example/MetacJava#staticInner. -[12:24..12:30) => com/javacp/ -[12:31..12:40) => com/javacp/MetacJava# -[12:41..12:52) => com/javacp/MetacJava#StaticInner# -[12:52..12:52) => com/javacp/MetacJava#StaticInner#``(). -[13:6..13:15) => example/MetacJava#nonStatic. -[13:22..13:33) => example/MetacJava#staticInner. -[13:34..13:43) => com/javacp/MetacJava#StaticInner#NonStatic# -[13:43..13:43) => com/javacp/MetacJava#StaticInner#NonStatic#``(). -[14:2..14:11) => example/MetacJava#nonStatic. -[14:12..14:18) => com/javacp/MetacJava#StaticInner#NonStatic#method(). -[14:19..14:28) => example/MetacJava#nonStatic. -[15:2..15:8) => com/javacp/ -[15:9..15:18) => com/javacp/MetacJava# -[15:19..15:27) => com/javacp/MetacJava#overload(+2). -[15:32..15:38) => com/javacp/ -[15:39..15:48) => com/javacp/MetacJava# -[15:49..15:58) => com/javacp/MetacJava#Overload3# -[15:59..15:60) => com/javacp/MetacJava#Overload3#A# -[15:60..15:60) => com/javacp/MetacJava#Overload3#A#``(). -[16:6..16:15) => example/MetacJava#interface. -[16:17..16:23) => com/javacp/ -[16:24..16:33) => com/javacp/Interface# -[17:6..17:10) => example/MetacJava#coin. -[17:12..17:18) => com/javacp/ -[17:19..17:23) => com/javacp/Coin# -[17:26..17:32) => com/javacp/ -[17:33..17:37) => com/javacp/Coin# -[17:38..17:43) => com/javacp/Coin#PENNY. -[18:6..18:11) => example/MetacJava#entry. -[18:13..18:17) => java/ -[18:18..18:22) => java/util/ -[18:23..18:26) => java/util/Map# -[18:27..18:32) => java/util/Map#Entry# -[18:33..18:36) => scala/Int# -[18:38..18:41) => scala/Int# +[0:8..0:15) example <- example/ +[2:7..2:10) com -> com/ +[2:11..2:17) javacp -> com/javacp/ +[4:6..4:15) MetacJava <- example/MetacJava# +[5:2..5:2) <- example/MetacJava#``(). +[5:2..5:8) javacp -> com/javacp/ +[5:9..5:18) MetacJava -> com/javacp/MetacJava# +[5:19..5:30) StaticInner -> com/javacp/MetacJava#StaticInner# +[5:31..5:39) isStatic -> com/javacp/MetacJava#StaticInner#isStatic(). +[6:6..6:12) javacp -> com/javacp/ +[6:13..6:22) MetacJava -> com/javacp/MetacJava# +[6:23..6:34) StaticInner -> com/javacp/MetacJava#StaticInner# +[6:34..6:34) -> com/javacp/MetacJava#StaticInner#``(). +[6:37..6:48) isNotStatic -> com/javacp/MetacJava#StaticInner#isNotStatic(). +[7:6..7:11) inner <- example/MetacJava#inner. +[7:18..7:24) javacp -> com/javacp/ +[7:25..7:34) MetacJava -> com/javacp/MetacJava# +[7:34..7:34) -> com/javacp/MetacJava#``(). +[8:6..8:15) overload1 <- example/MetacJava#overload1. +[8:22..8:27) inner -> example/MetacJava#inner. +[8:28..8:37) Overload1 -> com/javacp/MetacJava#Overload1# +[8:37..8:37) -> com/javacp/MetacJava#Overload1#``(). +[9:6..9:15) overload2 <- example/MetacJava#overload2. +[9:22..9:27) inner -> example/MetacJava#inner. +[9:28..9:37) Overload2 -> com/javacp/MetacJava#Overload2# +[9:37..9:37) -> com/javacp/MetacJava#Overload2#``(). +[10:2..10:7) inner -> example/MetacJava#inner. +[10:8..10:16) overload -> com/javacp/MetacJava#overload(). +[10:21..10:30) overload1 -> example/MetacJava#overload1. +[10:31..10:32) A -> com/javacp/MetacJava#Overload1#A# +[10:32..10:32) -> com/javacp/MetacJava#Overload1#A#``(). +[11:2..11:7) inner -> example/MetacJava#inner. +[11:8..11:16) overload -> com/javacp/MetacJava#overload(+1). +[11:21..11:30) overload2 -> example/MetacJava#overload2. +[11:31..11:32) A -> com/javacp/MetacJava#Overload2#A# +[11:32..11:32) -> com/javacp/MetacJava#Overload2#A#``(). +[12:6..12:17) staticInner <- example/MetacJava#staticInner. +[12:24..12:30) javacp -> com/javacp/ +[12:31..12:40) MetacJava -> com/javacp/MetacJava# +[12:41..12:52) StaticInner -> com/javacp/MetacJava#StaticInner# +[12:52..12:52) -> com/javacp/MetacJava#StaticInner#``(). +[13:6..13:15) nonStatic <- example/MetacJava#nonStatic. +[13:22..13:33) staticInner -> example/MetacJava#staticInner. +[13:34..13:43) NonStatic -> com/javacp/MetacJava#StaticInner#NonStatic# +[13:43..13:43) -> com/javacp/MetacJava#StaticInner#NonStatic#``(). +[14:2..14:11) nonStatic -> example/MetacJava#nonStatic. +[14:12..14:18) method -> com/javacp/MetacJava#StaticInner#NonStatic#method(). +[14:19..14:28) nonStatic -> example/MetacJava#nonStatic. +[15:2..15:8) javacp -> com/javacp/ +[15:9..15:18) MetacJava -> com/javacp/MetacJava# +[15:19..15:27) overload -> com/javacp/MetacJava#overload(+2). +[15:32..15:38) javacp -> com/javacp/ +[15:39..15:48) MetacJava -> com/javacp/MetacJava# +[15:49..15:58) Overload3 -> com/javacp/MetacJava#Overload3# +[15:59..15:60) A -> com/javacp/MetacJava#Overload3#A# +[15:60..15:60) -> com/javacp/MetacJava#Overload3#A#``(). +[16:6..16:15) interface <- example/MetacJava#interface. +[16:17..16:23) javacp -> com/javacp/ +[16:24..16:33) Interface -> com/javacp/Interface# +[17:6..17:10) coin <- example/MetacJava#coin. +[17:12..17:18) javacp -> com/javacp/ +[17:19..17:23) Coin -> com/javacp/Coin# +[17:26..17:32) javacp -> com/javacp/ +[17:33..17:37) Coin -> com/javacp/Coin# +[17:38..17:43) PENNY -> com/javacp/Coin#PENNY. +[18:6..18:11) entry <- example/MetacJava#entry. +[18:13..18:17) java -> java/ +[18:18..18:22) util -> java/util/ +[18:23..18:26) Map -> java/util/Map# +[18:27..18:32) Entry -> java/util/Map#Entry# +[18:33..18:36) Int -> scala/Int# +[18:38..18:41) Int -> scala/Int# expect/MethodUsages.scala _________________________ @@ -1579,80 +1575,80 @@ example/MethodUsages#``(). => primary ctor example/MethodUsages#m. => val method m Occurrences: -[0:8..0:15) => example/ -[2:6..2:18) => example/MethodUsages# -[3:2..3:2) => example/MethodUsages#``(). -[3:6..3:7) => example/MethodUsages#m. -[3:14..3:21) => example/Methods# -[3:22..3:25) => scala/Int# -[3:26..3:26) => example/Methods#``(). -[4:2..4:3) => example/MethodUsages#m. -[4:4..4:6) => example/Methods#m1(). -[5:2..5:3) => example/MethodUsages#m. -[5:4..5:6) => example/Methods#m2(). -[6:2..6:3) => example/MethodUsages#m. -[6:4..6:6) => example/Methods#m3(). -[7:2..7:3) => example/MethodUsages#m. -[7:4..7:6) => example/Methods#m4(). -[8:2..8:3) => example/MethodUsages#m. -[8:4..8:6) => example/Methods#m5(). -[9:2..9:3) => example/MethodUsages#m. -[9:4..9:6) => example/Methods#m5(+1). -[10:2..10:3) => example/MethodUsages#m. -[10:4..10:6) => example/Methods#m6(). -[11:2..11:3) => example/MethodUsages#m. -[11:4..11:6) => example/Methods#m6(+1). -[11:11..11:12) => example/MethodUsages#m. -[11:13..11:17) => example/Methods#List# -[11:18..11:21) => scala/Int# -[11:22..11:22) => example/Methods#List#``(). -[12:2..12:3) => example/MethodUsages#m. -[12:4..12:6) => example/Methods#m6(+2). -[12:7..12:10) => scala/package.Nil. -[13:2..13:3) => example/MethodUsages#m. -[13:4..13:6) => example/Methods#m7(). -[13:7..13:8) => example/MethodUsages#m. -[13:14..13:15) => example/MethodUsages#m. -[13:16..13:20) => example/Methods#List# -[13:21..13:24) => scala/Int# -[13:25..13:25) => example/Methods#List#``(). -[13:26..13:26) => scala/math/Ordering.Int. -[14:2..14:3) => example/MethodUsages#m. -[14:3..14:11) => example/Methods#`m8().`(). -[16:2..16:3) => example/MethodUsages#m. -[16:4..16:7) => example/Methods#m10(). -[17:2..17:3) => example/MethodUsages#m. -[17:4..17:7) => example/Methods#m11(). -[17:8..17:14) => scala/Predef. -[18:2..18:3) => example/MethodUsages#m. -[18:4..18:7) => example/Methods#m11(+1). -[18:8..18:15) => example/Example. -[19:2..19:3) => example/MethodUsages#m. -[19:4..19:8) => example/Methods#m12a(). -[20:2..20:3) => example/MethodUsages#m. -[20:4..20:8) => example/Methods#m12b(). -[21:2..21:3) => example/MethodUsages#m. -[21:4..21:7) => example/Methods#m13(). -[22:2..22:3) => example/MethodUsages#m. -[22:4..22:7) => example/Methods#m15(). -[23:2..23:3) => example/MethodUsages#m. -[23:4..23:7) => example/Methods#m16(). -[24:2..24:3) => example/MethodUsages#m. -[24:4..24:7) => example/Methods#m16(). -[25:2..25:3) => example/MethodUsages#m. -[25:4..25:7) => example/Methods#m17. -[25:8..25:9) => example/Methods#m17.m(). -[26:2..26:3) => example/MethodUsages#m. -[26:4..26:7) => example/Methods#m17(). -[27:2..27:3) => example/MethodUsages#m. -[27:4..27:7) => example/Methods#m17(+1). -[28:2..28:3) => example/MethodUsages#m. -[28:4..28:7) => example/Methods#m18. -[28:8..28:9) => example/Methods#m17.m(). -[29:2..29:3) => example/MethodUsages#m. -[29:4..29:7) => example/Methods#m18(). -[30:2..30:3) => example/MethodUsages#m. -[30:4..30:7) => example/Methods#m18(+1). +[0:8..0:15) example <- example/ +[2:6..2:18) MethodUsages <- example/MethodUsages# +[3:2..3:2) <- example/MethodUsages#``(). +[3:6..3:7) m <- example/MethodUsages#m. +[3:14..3:21) Methods -> example/Methods# +[3:22..3:25) Int -> scala/Int# +[3:26..3:26) -> example/Methods#``(). +[4:2..4:3) m -> example/MethodUsages#m. +[4:4..4:6) m1 -> example/Methods#m1(). +[5:2..5:3) m -> example/MethodUsages#m. +[5:4..5:6) m2 -> example/Methods#m2(). +[6:2..6:3) m -> example/MethodUsages#m. +[6:4..6:6) m3 -> example/Methods#m3(). +[7:2..7:3) m -> example/MethodUsages#m. +[7:4..7:6) m4 -> example/Methods#m4(). +[8:2..8:3) m -> example/MethodUsages#m. +[8:4..8:6) m5 -> example/Methods#m5(). +[9:2..9:3) m -> example/MethodUsages#m. +[9:4..9:6) m5 -> example/Methods#m5(+1). +[10:2..10:3) m -> example/MethodUsages#m. +[10:4..10:6) m6 -> example/Methods#m6(). +[11:2..11:3) m -> example/MethodUsages#m. +[11:4..11:6) m6 -> example/Methods#m6(+1). +[11:11..11:12) m -> example/MethodUsages#m. +[11:13..11:17) List -> example/Methods#List# +[11:18..11:21) Int -> scala/Int# +[11:22..11:22) -> example/Methods#List#``(). +[12:2..12:3) m -> example/MethodUsages#m. +[12:4..12:6) m6 -> example/Methods#m6(+2). +[12:7..12:10) Nil -> scala/package.Nil. +[13:2..13:3) m -> example/MethodUsages#m. +[13:4..13:6) m7 -> example/Methods#m7(). +[13:7..13:8) m -> example/MethodUsages#m. +[13:14..13:15) m -> example/MethodUsages#m. +[13:16..13:20) List -> example/Methods#List# +[13:21..13:24) Int -> scala/Int# +[13:25..13:25) -> example/Methods#List#``(). +[13:26..13:26) -> scala/math/Ordering.Int. +[14:2..14:3) m -> example/MethodUsages#m. +[14:3..14:11) .`m8().` -> example/Methods#`m8().`(). +[16:2..16:3) m -> example/MethodUsages#m. +[16:4..16:7) m10 -> example/Methods#m10(). +[17:2..17:3) m -> example/MethodUsages#m. +[17:4..17:7) m11 -> example/Methods#m11(). +[17:8..17:14) Predef -> scala/Predef. +[18:2..18:3) m -> example/MethodUsages#m. +[18:4..18:7) m11 -> example/Methods#m11(+1). +[18:8..18:15) Example -> example/Example. +[19:2..19:3) m -> example/MethodUsages#m. +[19:4..19:8) m12a -> example/Methods#m12a(). +[20:2..20:3) m -> example/MethodUsages#m. +[20:4..20:8) m12b -> example/Methods#m12b(). +[21:2..21:3) m -> example/MethodUsages#m. +[21:4..21:7) m13 -> example/Methods#m13(). +[22:2..22:3) m -> example/MethodUsages#m. +[22:4..22:7) m15 -> example/Methods#m15(). +[23:2..23:3) m -> example/MethodUsages#m. +[23:4..23:7) m16 -> example/Methods#m16(). +[24:2..24:3) m -> example/MethodUsages#m. +[24:4..24:7) m16 -> example/Methods#m16(). +[25:2..25:3) m -> example/MethodUsages#m. +[25:4..25:7) m17 -> example/Methods#m17. +[25:8..25:9) m -> example/Methods#m17.m(). +[26:2..26:3) m -> example/MethodUsages#m. +[26:4..26:7) m17 -> example/Methods#m17(). +[27:2..27:3) m -> example/MethodUsages#m. +[27:4..27:7) m17 -> example/Methods#m17(+1). +[28:2..28:3) m -> example/MethodUsages#m. +[28:4..28:7) m18 -> example/Methods#m18. +[28:8..28:9) m -> example/Methods#m17.m(). +[29:2..29:3) m -> example/MethodUsages#m. +[29:4..29:7) m18 -> example/Methods#m18(). +[30:2..30:3) m -> example/MethodUsages#m. +[30:4..30:7) m18 -> example/Methods#m18(+1). expect/Methods.scala ____________________ @@ -1737,145 +1733,145 @@ example/Methods#m19().(z) => val param z local0 => abstract val method x Occurrences: -[0:8..0:15) => example/ -[2:7..2:12) => scala/ -[2:13..2:17) => scala/math/ -[2:18..2:26) => scala/math/Ordering. -[2:18..2:26) => scala/math/Ordering# -[3:7..3:12) => scala/ -[3:13..3:21) => scalaShadowing/language. -[3:22..3:34) => scalaShadowing/language.existentials. -[5:6..5:13) => example/Methods# -[5:13..5:16) => example/Methods#``(). -[5:14..5:15) => example/Methods#[T] -[6:8..6:12) => example/Methods#List# -[6:12..6:15) => example/Methods#List#``(). -[6:13..6:14) => example/Methods#List#[T] -[7:7..7:12) => example/Methods#AList# -[7:13..7:14) => example/Methods#AList#[T] -[7:18..7:22) => example/Methods#List# -[7:23..7:24) => example/Methods#AList#[T] -[8:6..8:8) => example/Methods#m1(). -[8:11..8:14) => scala/Predef.`???`(). -[9:6..9:8) => example/Methods#m2(). -[9:13..9:16) => scala/Predef.`???`(). -[10:6..10:8) => example/Methods#m3(). -[10:9..10:10) => example/Methods#m3().(x) -[10:12..10:15) => scala/Int# -[10:19..10:22) => scala/Predef.`???`(). -[11:6..11:8) => example/Methods#m4(). -[11:9..11:10) => example/Methods#m4().(x) -[11:12..11:15) => scala/Int# -[11:17..11:18) => example/Methods#m4().(y) -[11:20..11:23) => scala/Int# -[11:27..11:30) => scala/Predef.`???`(). -[12:6..12:8) => example/Methods#m5(). -[12:9..12:10) => example/Methods#m5().(x) -[12:12..12:18) => scala/Predef.String# -[12:22..12:25) => scala/Predef.`???`(). -[13:6..13:8) => example/Methods#m5(+1). -[13:9..13:10) => example/Methods#m5(+1).(x) -[13:12..13:15) => scala/Int# -[13:19..13:22) => scala/Predef.`???`(). -[14:6..14:8) => example/Methods#m6(). -[14:9..14:10) => example/Methods#m6().(x) -[14:12..14:15) => scala/Int# -[14:19..14:22) => scala/Predef.`???`(). -[15:6..15:8) => example/Methods#m6(+1). -[15:9..15:10) => example/Methods#m6(+1).(x) -[15:12..15:16) => example/Methods#List# -[15:17..15:18) => example/Methods#[T] -[15:23..15:26) => scala/Predef.`???`(). -[16:6..16:8) => example/Methods#m6(+2). -[16:9..16:10) => example/Methods#m6(+2).(x) -[16:12..16:17) => scala/ -[16:18..16:22) => scala/package.List# -[16:23..16:24) => example/Methods#[T] -[16:29..16:32) => scala/Predef.`???`(). -[17:6..17:8) => example/Methods#m7(). -[17:9..17:10) => example/Methods#m7().[U] -[17:10..17:10) => example/Methods#m7().(evidence$1) -[17:12..17:20) => scala/math/Ordering# -[17:20..17:20) => example/Methods#m7().[U] -[17:22..17:23) => example/Methods#m7().(c) -[17:25..17:32) => example/Methods# -[17:33..17:34) => example/Methods#[T] -[17:37..17:38) => example/Methods#m7().(l) -[17:40..17:44) => example/Methods#List# -[17:45..17:46) => example/Methods#m7().[U] -[17:51..17:54) => scala/Predef.`???`(). -[18:7..18:17) => example/Methods#`m8().`(). -[18:18..18:21) => scala/Predef.`???`(). -[19:2..19:2) => example/Methods#`m9().`#``(). -[19:9..20:3) => example/Methods#`m9().`# -[20:6..20:8) => example/Methods#m9(). -[20:9..20:10) => example/Methods#m9().(x) -[20:12..20:19) => example/Methods#`m9().`# -[20:23..20:26) => scala/Predef.`???`(). -[21:6..21:9) => example/Methods#m10(). -[21:10..21:11) => example/Methods#m10().(x) -[21:13..21:18) => example/Methods#AList# -[21:19..21:20) => example/Methods#[T] -[21:25..21:28) => scala/Predef.`???`(). -[22:6..22:9) => example/Methods#m11(). -[22:10..22:11) => example/Methods#m11().(x) -[22:13..22:19) => scala/Predef. -[22:28..22:31) => scala/Predef.`???`(). -[23:6..23:9) => example/Methods#m11(+1). -[23:10..23:11) => example/Methods#m11(+1).(x) -[23:13..23:20) => example/Example. -[23:29..23:32) => scala/Predef.`???`(). -[24:6..24:10) => example/Methods#m12a(). -[24:11..24:12) => example/Methods#m12a().(x) -[24:20..24:23) => scala/Predef.`???`(). -[25:6..25:10) => example/Methods#m12b(). -[25:11..25:12) => example/Methods#m12b().(x) -[25:20..25:21) => local0 -[25:23..25:26) => scala/Int# -[25:32..25:35) => scala/Predef.`???`(). -[26:6..26:9) => example/Methods#m13(). -[26:10..26:11) => example/Methods#m13().(x) -[26:13..26:16) => scala/Int# -[26:31..26:34) => scala/Predef.`???`(). -[27:6..27:9) => example/Methods#m15(). -[27:10..27:11) => example/Methods#m15().(x) -[27:16..27:19) => scala/Int# -[27:23..27:26) => scala/Predef.`???`(). -[28:6..28:9) => example/Methods#m16(). -[28:10..28:11) => example/Methods#m16().(x) -[28:13..28:16) => scala/Int# -[28:21..28:24) => scala/Predef.`???`(). -[29:9..29:12) => example/Methods#m17. -[29:19..29:20) => example/Methods#m17.m(). -[29:25..29:28) => scala/Predef.`???`(). -[30:6..30:9) => example/Methods#m17(). -[30:10..30:11) => example/Methods#m17().(a) -[30:13..30:16) => scala/Int# -[30:20..30:23) => scala/Predef.`???`(). -[31:6..31:9) => example/Methods#m17(+1). -[31:10..31:11) => example/Methods#m17(+1).(b) -[31:13..31:19) => scala/Predef.String# -[31:23..31:26) => scala/Predef.`???`(). -[32:6..32:9) => example/Methods#m18. -[32:12..32:15) => example/Methods#m17. -[33:6..33:9) => example/Methods#m18(). -[33:10..33:11) => example/Methods#m18().(a) -[33:13..33:16) => scala/Int# -[33:20..33:23) => scala/Predef.`???`(). -[34:6..34:9) => example/Methods#m18(+1). -[34:10..34:11) => example/Methods#m18(+1).(b) -[34:13..34:19) => scala/Predef.String# -[34:23..34:26) => scala/Predef.`???`(). -[35:6..35:9) => example/Methods#m19(). -[35:10..35:11) => example/Methods#m19().(x) -[35:10..35:11) => example/Methods#m19$default$3().(x) -[35:13..35:16) => scala/Int# -[35:18..35:19) => example/Methods#m19().(y) -[35:18..35:19) => example/Methods#m19$default$3().(y) -[35:21..35:24) => scala/Int# -[35:30..35:31) => example/Methods#m19().(z) -[35:33..35:36) => scala/Int# -[35:44..35:47) => scala/Predef.`???`(). +[0:8..0:15) example <- example/ +[2:7..2:12) scala -> scala/ +[2:13..2:17) math -> scala/math/ +[2:18..2:26) Ordering -> scala/math/Ordering. +[2:18..2:26) Ordering -> scala/math/Ordering# +[3:7..3:12) scala -> scala/ +[3:13..3:21) language -> scalaShadowing/language. +[3:22..3:34) existentials -> scalaShadowing/language.existentials. +[5:6..5:13) Methods <- example/Methods# +[5:13..5:16) <- example/Methods#``(). +[5:14..5:15) T <- example/Methods#[T] +[6:8..6:12) List <- example/Methods#List# +[6:12..6:15) <- example/Methods#List#``(). +[6:13..6:14) T <- example/Methods#List#[T] +[7:7..7:12) AList <- example/Methods#AList# +[7:13..7:14) T <- example/Methods#AList#[T] +[7:18..7:22) List -> example/Methods#List# +[7:23..7:24) T -> example/Methods#AList#[T] +[8:6..8:8) m1 <- example/Methods#m1(). +[8:11..8:14) ??? -> scala/Predef.`???`(). +[9:6..9:8) m2 <- example/Methods#m2(). +[9:13..9:16) ??? -> scala/Predef.`???`(). +[10:6..10:8) m3 <- example/Methods#m3(). +[10:9..10:10) x <- example/Methods#m3().(x) +[10:12..10:15) Int -> scala/Int# +[10:19..10:22) ??? -> scala/Predef.`???`(). +[11:6..11:8) m4 <- example/Methods#m4(). +[11:9..11:10) x <- example/Methods#m4().(x) +[11:12..11:15) Int -> scala/Int# +[11:17..11:18) y <- example/Methods#m4().(y) +[11:20..11:23) Int -> scala/Int# +[11:27..11:30) ??? -> scala/Predef.`???`(). +[12:6..12:8) m5 <- example/Methods#m5(). +[12:9..12:10) x <- example/Methods#m5().(x) +[12:12..12:18) String -> scala/Predef.String# +[12:22..12:25) ??? -> scala/Predef.`???`(). +[13:6..13:8) m5 <- example/Methods#m5(+1). +[13:9..13:10) x <- example/Methods#m5(+1).(x) +[13:12..13:15) Int -> scala/Int# +[13:19..13:22) ??? -> scala/Predef.`???`(). +[14:6..14:8) m6 <- example/Methods#m6(). +[14:9..14:10) x <- example/Methods#m6().(x) +[14:12..14:15) Int -> scala/Int# +[14:19..14:22) ??? -> scala/Predef.`???`(). +[15:6..15:8) m6 <- example/Methods#m6(+1). +[15:9..15:10) x <- example/Methods#m6(+1).(x) +[15:12..15:16) List -> example/Methods#List# +[15:17..15:18) T -> example/Methods#[T] +[15:23..15:26) ??? -> scala/Predef.`???`(). +[16:6..16:8) m6 <- example/Methods#m6(+2). +[16:9..16:10) x <- example/Methods#m6(+2).(x) +[16:12..16:17) scala -> scala/ +[16:18..16:22) List -> scala/package.List# +[16:23..16:24) T -> example/Methods#[T] +[16:29..16:32) ??? -> scala/Predef.`???`(). +[17:6..17:8) m7 <- example/Methods#m7(). +[17:9..17:10) U <- example/Methods#m7().[U] +[17: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] +[17:37..17:38) l <- example/Methods#m7().(l) +[17:40..17:44) List -> example/Methods#List# +[17:45..17:46) U -> example/Methods#m7().[U] +[17:51..17:54) ??? -> scala/Predef.`???`(). +[18:7..18:17) m8().`() = <- example/Methods#`m8().`(). +[18:18..18:21) ??? -> scala/Predef.`???`(). +[19:2..19:2) <- example/Methods#`m9().`#``(). +[19:9..20:3) <- example/Methods#`m9().`# +[20:6..20:8) m9 <- example/Methods#m9(). +[20:9..20:10) x <- example/Methods#m9().(x) +[20:12..20:19) `m9().` -> example/Methods#`m9().`# +[20:23..20:26) ??? -> scala/Predef.`???`(). +[21:6..21:9) m10 <- example/Methods#m10(). +[21:10..21:11) x <- example/Methods#m10().(x) +[21:13..21:18) AList -> example/Methods#AList# +[21:19..21:20) T -> example/Methods#[T] +[21:25..21:28) ??? -> scala/Predef.`???`(). +[22:6..22:9) m11 <- example/Methods#m11(). +[22:10..22:11) x <- example/Methods#m11().(x) +[22:13..22:19) Predef -> scala/Predef. +[22:28..22:31) ??? -> scala/Predef.`???`(). +[23:6..23:9) m11 <- example/Methods#m11(+1). +[23:10..23:11) x <- example/Methods#m11(+1).(x) +[23:13..23:20) Example -> example/Example. +[23:29..23:32) ??? -> scala/Predef.`???`(). +[24:6..24:10) m12a <- example/Methods#m12a(). +[24:11..24:12) x <- example/Methods#m12a().(x) +[24:20..24:23) ??? -> scala/Predef.`???`(). +[25:6..25:10) m12b <- example/Methods#m12b(). +[25:11..25:12) x <- example/Methods#m12b().(x) +[25:20..25:21) x <- local0 +[25:23..25:26) Int -> scala/Int# +[25:32..25:35) ??? -> scala/Predef.`???`(). +[26:6..26:9) m13 <- example/Methods#m13(). +[26:10..26:11) x <- example/Methods#m13().(x) +[26:13..26:16) Int -> scala/Int# +[26:31..26:34) ??? -> scala/Predef.`???`(). +[27:6..27:9) m15 <- example/Methods#m15(). +[27:10..27:11) x <- example/Methods#m15().(x) +[27:16..27:19) Int -> scala/Int# +[27:23..27:26) ??? -> scala/Predef.`???`(). +[28:6..28:9) m16 <- example/Methods#m16(). +[28:10..28:11) x <- example/Methods#m16().(x) +[28:13..28:16) Int -> scala/Int# +[28:21..28:24) ??? -> scala/Predef.`???`(). +[29:9..29:12) m17 <- example/Methods#m17. +[29:19..29:20) m <- example/Methods#m17.m(). +[29:25..29:28) ??? -> scala/Predef.`???`(). +[30:6..30:9) m17 <- example/Methods#m17(). +[30:10..30:11) a <- example/Methods#m17().(a) +[30:13..30:16) Int -> scala/Int# +[30:20..30:23) ??? -> scala/Predef.`???`(). +[31:6..31:9) m17 <- example/Methods#m17(+1). +[31:10..31:11) b <- example/Methods#m17(+1).(b) +[31:13..31:19) String -> scala/Predef.String# +[31:23..31:26) ??? -> scala/Predef.`???`(). +[32:6..32:9) m18 <- example/Methods#m18. +[32:12..32:15) m17 -> example/Methods#m17. +[33:6..33:9) m18 <- example/Methods#m18(). +[33:10..33:11) a <- example/Methods#m18().(a) +[33:13..33:16) Int -> scala/Int# +[33:20..33:23) ??? -> scala/Predef.`???`(). +[34:6..34:9) m18 <- example/Methods#m18(+1). +[34:10..34:11) b <- example/Methods#m18(+1).(b) +[34:13..34:19) String -> scala/Predef.String# +[34:23..34:26) ??? -> scala/Predef.`???`(). +[35:6..35:9) m19 <- example/Methods#m19(). +[35:10..35:11) x <- example/Methods#m19().(x) +[35:10..35:11) x <- example/Methods#m19$default$3().(x) +[35:13..35:16) Int -> scala/Int# +[35:18..35:19) y <- example/Methods#m19().(y) +[35:18..35:19) y <- example/Methods#m19$default$3().(y) +[35:21..35:24) Int -> scala/Int# +[35:30..35:31) z <- example/Methods#m19().(z) +[35:33..35:36) Int -> scala/Int# +[35:44..35:47) ??? -> scala/Predef.`???`(). expect/NamedApplyBlock.scala ____________________________ @@ -1910,41 +1906,41 @@ example/NamedApplyBlockMethods.local. => val method local example/NamedApplyBlockMethods.recursive(). => method recursive Occurrences: -[0:8..0:15) => example/ -[2:7..2:29) => example/NamedApplyBlockMethods. -[3:6..3:11) => example/NamedApplyBlockMethods.local. -[4:6..4:9) => example/NamedApplyBlockMethods.foo(). -[4:10..4:11) => example/NamedApplyBlockMethods.foo().(a) -[4:13..4:16) => scala/Int# -[4:22..4:23) => example/NamedApplyBlockMethods.foo().(b) -[4:25..4:28) => scala/Int# -[4:34..4:35) => example/NamedApplyBlockMethods.foo().(c) -[4:37..4:40) => scala/Int# -[4:47..4:50) => scala/Int# -[4:53..4:54) => example/NamedApplyBlockMethods.foo().(a) -[4:55..4:56) => scala/Int#`+`(+4). -[4:57..4:58) => example/NamedApplyBlockMethods.foo().(b) -[4:59..4:60) => scala/Int#`+`(+4). -[4:61..4:62) => example/NamedApplyBlockMethods.foo().(c) -[5:6..5:14) => example/NamedApplyBlockMethods.baseCase(). -[5:17..5:20) => example/NamedApplyBlockMethods.foo(). -[5:21..5:26) => example/NamedApplyBlockMethods.local. -[6:6..6:15) => example/NamedApplyBlockMethods.recursive(). -[6:18..6:21) => example/NamedApplyBlockMethods.foo(). -[6:22..6:27) => example/NamedApplyBlockMethods.local. -[9:7..9:43) => example/NamedApplyBlockCaseClassConstruction. -[10:13..10:16) => example/NamedApplyBlockCaseClassConstruction.Msg# -[10:16..10:70) => example/NamedApplyBlockCaseClassConstruction.Msg#``(). -[10:17..10:21) => example/NamedApplyBlockCaseClassConstruction.Msg#body. -[10:23..10:29) => scala/Predef.String# -[10:31..10:35) => example/NamedApplyBlockCaseClassConstruction.Msg#head. -[10:37..10:43) => scala/Predef.String# -[10:57..10:61) => example/NamedApplyBlockCaseClassConstruction.Msg#tail. -[10:63..10:69) => scala/Predef.String# -[11:6..11:14) => example/NamedApplyBlockCaseClassConstruction.bodyText. -[12:6..12:9) => example/NamedApplyBlockCaseClassConstruction.msg. -[12:12..12:15) => example/NamedApplyBlockCaseClassConstruction.Msg. -[12:16..12:24) => example/NamedApplyBlockCaseClassConstruction.bodyText. +[0:8..0:15) example <- example/ +[2:7..2:29) NamedApplyBlockMethods <- example/NamedApplyBlockMethods. +[3:6..3:11) local <- example/NamedApplyBlockMethods.local. +[4:6..4:9) foo <- example/NamedApplyBlockMethods.foo(). +[4:10..4:11) a <- example/NamedApplyBlockMethods.foo().(a) +[4:13..4:16) Int -> scala/Int# +[4:22..4:23) b <- example/NamedApplyBlockMethods.foo().(b) +[4:25..4:28) Int -> scala/Int# +[4:34..4:35) c <- example/NamedApplyBlockMethods.foo().(c) +[4:37..4:40) Int -> scala/Int# +[4:47..4:50) Int -> scala/Int# +[4:53..4:54) a -> example/NamedApplyBlockMethods.foo().(a) +[4:55..4:56) + -> scala/Int#`+`(+4). +[4:57..4:58) b -> example/NamedApplyBlockMethods.foo().(b) +[4:59..4:60) + -> scala/Int#`+`(+4). +[4:61..4:62) c -> example/NamedApplyBlockMethods.foo().(c) +[5:6..5:14) baseCase <- example/NamedApplyBlockMethods.baseCase(). +[5:17..5:20) foo -> example/NamedApplyBlockMethods.foo(). +[5:21..5:26) local -> example/NamedApplyBlockMethods.local. +[6:6..6:15) recursive <- example/NamedApplyBlockMethods.recursive(). +[6:18..6:21) foo -> example/NamedApplyBlockMethods.foo(). +[6:22..6:27) local -> example/NamedApplyBlockMethods.local. +[9:7..9:43) NamedApplyBlockCaseClassConstruction <- example/NamedApplyBlockCaseClassConstruction. +[10:13..10:16) Msg <- example/NamedApplyBlockCaseClassConstruction.Msg# +[10:16..10:70) <- example/NamedApplyBlockCaseClassConstruction.Msg#``(). +[10:17..10:21) body <- example/NamedApplyBlockCaseClassConstruction.Msg#body. +[10:23..10:29) String -> scala/Predef.String# +[10:31..10:35) head <- example/NamedApplyBlockCaseClassConstruction.Msg#head. +[10:37..10:43) String -> scala/Predef.String# +[10:57..10:61) tail <- example/NamedApplyBlockCaseClassConstruction.Msg#tail. +[10:63..10:69) String -> scala/Predef.String# +[11:6..11:14) bodyText <- example/NamedApplyBlockCaseClassConstruction.bodyText. +[12:6..12:9) msg <- example/NamedApplyBlockCaseClassConstruction.msg. +[12:12..12:15) Msg -> example/NamedApplyBlockCaseClassConstruction.Msg. +[12:16..12:24) bodyText -> example/NamedApplyBlockCaseClassConstruction.bodyText. expect/NamedArguments.scala ___________________________ @@ -1966,16 +1962,16 @@ example/NamedArguments#User#name. => val method name example/NamedArguments#``(). => primary ctor Occurrences: -[0:8..0:15) => example/ -[2:6..2:20) => example/NamedArguments# -[3:2..3:2) => example/NamedArguments#``(). -[3:13..3:17) => example/NamedArguments#User# -[3:17..3:31) => example/NamedArguments#User#``(). -[3:18..3:22) => example/NamedArguments#User#name. -[3:24..3:30) => scala/Predef.String# -[4:2..4:6) => example/NamedArguments#User. -[5:2..5:6) => example/NamedArguments#User. -[5:7..5:12) => example/NamedArguments#User.apply(). +[0:8..0:15) example <- example/ +[2:6..2:20) NamedArguments <- example/NamedArguments# +[3:2..3:2) <- example/NamedArguments#``(). +[3:13..3:17) User <- example/NamedArguments#User# +[3:17..3:31) <- example/NamedArguments#User#``(). +[3:18..3:22) name <- example/NamedArguments#User#name. +[3:24..3:30) String -> scala/Predef.String# +[4:2..4:6) User -> example/NamedArguments#User. +[5:2..5:6) User -> example/NamedArguments#User. +[5:7..5:12) apply -> example/NamedArguments#User.apply(). expect/NewModifiers.scala _________________________ @@ -1986,7 +1982,7 @@ Uri => NewModifiers.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 5 entries +Occurrences => 4 entries Symbols: _empty_/NewModifiers. => final object NewModifiers @@ -1994,11 +1990,10 @@ _empty_/NewModifiers.A# => type A _empty_/NewModifiers.foo. => val method foo Occurrences: -[0:0..0:0) => _empty_/ -[0:7..0:19) => _empty_/NewModifiers. -[1:13..1:16) => _empty_/NewModifiers.foo. -[2:14..2:15) => _empty_/NewModifiers.A# -[2:18..2:21) => scala/Int# +[0:7..0:19) NewModifiers <- _empty_/NewModifiers. +[1:13..1:16) foo <- _empty_/NewModifiers.foo. +[2:14..2:15) A <- _empty_/NewModifiers.A# +[2:18..2:21) Int -> scala/Int# expect/Objects.scala ____________________ @@ -2016,9 +2011,9 @@ objects/X. => final object X objects/X.Y. => final object Y Occurrences: -[0:8..0:15) => objects/ -[2:7..2:8) => objects/X. -[3:9..3:10) => objects/X.Y. +[0:8..0:15) objects <- objects/ +[2:7..2:8) X <- objects/X. +[3:9..3:10) Y <- objects/X.Y. expect/Overrides.scala ______________________ @@ -2040,16 +2035,16 @@ example/B#``(). => primary ctor example/B#foo(). => method foo Occurrences: -[0:8..0:15) => example/ -[2:6..2:7) => example/A# -[2:10..2:10) => example/A#``(). -[2:14..2:17) => example/A#foo(). -[2:19..2:22) => scala/Int# -[3:6..3:7) => example/B# -[3:7..3:9) => example/B#``(). -[3:18..3:19) => example/A# -[3:26..3:29) => example/B#foo(). -[3:31..3:34) => scala/Int# +[0:8..0:15) example <- example/ +[2:6..2:7) A <- example/A# +[2:10..2:10) <- example/A#``(). +[2:14..2:17) foo <- example/A#foo(). +[2:19..2:22) Int -> scala/Int# +[3:6..3:7) B <- example/B# +[3:7..3:9) <- example/B#``(). +[3:18..3:19) A -> example/A# +[3:26..3:29) foo <- example/B#foo(). +[3:31..3:34) Int -> scala/Int# expect/Prefixes.scala _____________________ @@ -2084,55 +2079,55 @@ prefixes/Test.n2(). => method n2 prefixes/Test.n3(). => method n3 Occurrences: -[0:8..0:16) => prefixes/ -[2:6..2:7) => prefixes/C# -[3:2..3:2) => prefixes/C#``(). -[3:7..3:8) => prefixes/C#T# -[4:6..4:8) => prefixes/C#m1(). -[4:10..4:11) => prefixes/C#T# -[4:14..4:17) => scala/Predef.`???`(). -[6:9..6:10) => prefixes/C#N. -[7:9..7:10) => prefixes/C#N.U# -[9:6..9:8) => prefixes/C#k1(). -[9:10..9:11) => prefixes/C#N. -[9:12..9:13) => prefixes/C#N.U# -[9:16..9:19) => scala/Predef.`???`(). -[12:7..12:8) => prefixes/M. -[13:7..13:8) => prefixes/M.T# -[14:6..14:8) => prefixes/M.n1(). -[14:10..14:11) => prefixes/M.T# -[14:14..14:17) => scala/Predef.`???`(). -[17:7..17:8) => prefixes/O. -[17:17..17:18) => prefixes/C# -[17:18..17:18) => prefixes/C#``(). -[18:6..18:8) => prefixes/O.o1(). -[18:10..18:11) => prefixes/C#T# -[18:14..18:17) => scala/Predef.`???`(). -[21:7..21:11) => prefixes/Test. -[22:6..22:7) => prefixes/Test.c. -[22:9..22:10) => prefixes/C# -[22:13..22:16) => scala/Predef.`???`(). -[23:6..23:8) => prefixes/Test.m2(). -[23:10..23:11) => prefixes/Test.c. -[23:12..23:13) => prefixes/C#T# -[23:16..23:19) => scala/Predef.`???`(). -[24:6..24:8) => prefixes/Test.k2(). -[24:10..24:11) => prefixes/Test.c. -[24:12..24:13) => prefixes/C#N. -[24:14..24:15) => prefixes/C#N.U# -[24:18..24:21) => scala/Predef.`???`(). -[25:9..25:10) => prefixes/Test.c. -[25:11..25:12) => prefixes/C#N. -[26:6..26:8) => prefixes/Test.k3(). -[26:14..26:17) => scala/Predef.`???`(). -[28:6..28:8) => prefixes/Test.n2(). -[28:10..28:11) => prefixes/M. -[28:12..28:13) => prefixes/M.T# -[28:16..28:19) => scala/Predef.`???`(). -[30:9..30:10) => prefixes/M. -[31:6..31:8) => prefixes/Test.n3(). -[31:10..31:11) => prefixes/M.T# -[31:14..31:17) => scala/Predef.`???`(). +[0:8..0:16) prefixes <- prefixes/ +[2:6..2:7) C <- prefixes/C# +[3:2..3:2) <- prefixes/C#``(). +[3:7..3:8) T <- prefixes/C#T# +[4:6..4:8) m1 <- prefixes/C#m1(). +[4:10..4:11) T -> prefixes/C#T# +[4:14..4:17) ??? -> scala/Predef.`???`(). +[6:9..6:10) N <- prefixes/C#N. +[7:9..7:10) U <- prefixes/C#N.U# +[9:6..9:8) k1 <- prefixes/C#k1(). +[9:10..9:11) N -> prefixes/C#N. +[9:12..9:13) U -> prefixes/C#N.U# +[9:16..9:19) ??? -> scala/Predef.`???`(). +[12:7..12:8) M <- prefixes/M. +[13:7..13:8) T <- prefixes/M.T# +[14:6..14:8) n1 <- prefixes/M.n1(). +[14:10..14:11) T -> prefixes/M.T# +[14:14..14:17) ??? -> scala/Predef.`???`(). +[17:7..17:8) O <- prefixes/O. +[17:17..17:18) C -> prefixes/C# +[17:18..17:18) -> prefixes/C#``(). +[18:6..18:8) o1 <- prefixes/O.o1(). +[18:10..18:11) T -> prefixes/C#T# +[18:14..18:17) ??? -> scala/Predef.`???`(). +[21:7..21:11) Test <- prefixes/Test. +[22:6..22:7) c <- prefixes/Test.c. +[22:9..22:10) C -> prefixes/C# +[22:13..22:16) ??? -> scala/Predef.`???`(). +[23:6..23:8) m2 <- prefixes/Test.m2(). +[23:10..23:11) c -> prefixes/Test.c. +[23:12..23:13) T -> prefixes/C#T# +[23:16..23:19) ??? -> scala/Predef.`???`(). +[24:6..24:8) k2 <- prefixes/Test.k2(). +[24:10..24:11) c -> prefixes/Test.c. +[24:12..24:13) N -> prefixes/C#N. +[24:14..24:15) U -> prefixes/C#N.U# +[24:18..24:21) ??? -> scala/Predef.`???`(). +[25:9..25:10) c -> prefixes/Test.c. +[25:11..25:12) N -> prefixes/C#N. +[26:6..26:8) k3 <- prefixes/Test.k3(). +[26:14..26:17) ??? -> scala/Predef.`???`(). +[28:6..28:8) n2 <- prefixes/Test.n2(). +[28:10..28:11) M -> prefixes/M. +[28:12..28:13) T -> prefixes/M.T# +[28:16..28:19) ??? -> scala/Predef.`???`(). +[30:9..30:10) M -> prefixes/M. +[31:6..31:8) n3 <- prefixes/Test.n3(). +[31:10..31:11) T -> prefixes/M.T# +[31:14..31:17) ??? -> scala/Predef.`???`(). expect/Selfs.scala __________________ @@ -2161,32 +2156,32 @@ selfs/C6# => class C6 selfs/C6#``(). => primary ctor Occurrences: -[0:8..0:13) => selfs/ -[2:0..2:0) => selfs/B#``(). -[2:6..2:7) => selfs/B# -[4:6..4:8) => selfs/C1# -[4:17..4:17) => selfs/C1#``(). -[4:17..4:18) => selfs/B# -[4:18..4:18) => selfs/B#``(). -[4:21..4:25) => local0 -[7:6..7:8) => selfs/C2# -[7:17..7:17) => selfs/C2#``(). -[7:17..7:18) => selfs/B# -[7:18..7:18) => selfs/B#``(). -[7:21..7:25) => local1 -[7:27..7:28) => selfs/B# -[10:6..10:8) => selfs/C3# -[10:17..10:17) => selfs/C3#``(). -[10:17..10:18) => selfs/B# -[10:18..10:18) => selfs/B#``(). -[10:21..10:25) => local2 -[10:27..10:28) => selfs/B# -[10:34..10:36) => selfs/C1# -[13:6..13:8) => selfs/C6# -[13:17..13:17) => selfs/C6#``(). -[13:17..13:18) => selfs/B# -[13:18..13:18) => selfs/B#``(). -[13:27..13:28) => selfs/B# +[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 ______________________ @@ -2224,148 +2219,148 @@ example/Synthetic#xs. => val method xs local0 => val local name Occurrences: -[0:8..0:15) => example/ -[2:7..2:12) => scala/ -[2:13..2:21) => scalaShadowing/language. -[2:22..2:41) => scalaShadowing/language.implicitConversions. -[4:6..4:15) => example/Synthetic# -[5:2..5:2) => example/Synthetic#``(). -[5:2..5:6) => scala/package.List. -[5:6..5:6) => scala/collection/IterableFactory#apply(). -[5:10..5:13) => scala/collection/immutable/List#map(). -[5:16..5:17) => scala/Int#`+`(+4). -[6:2..6:2) => scala/Predef.intArrayOps(). -[6:2..6:7) => scala/Array. -[6:8..6:13) => scala/Array.empty(). -[6:14..6:17) => scala/Int# -[6:18..6:18) => scala/reflect/ClassTag.apply(). -[6:18..6:18) => java/lang/Integer#TYPE. -[6:19..6:29) => scala/collection/ArrayOps#headOption(). -[7:2..7:2) => scala/Predef.augmentString(). -[7:9..7:20) => scala/collection/StringOps#stripPrefix(). -[10:6..10:10) => example/Synthetic#Name. -[10:13..10:13) => scala/Predef.augmentString(). -[10:25..10:26) => scala/collection/StringOps#r(). -[11:2..11:2) => scala/Tuple2#_1. -[11:2..11:2) => scala/Tuple2#_2. -[11:6..11:7) => example/Synthetic#x. -[11:12..11:14) => example/Synthetic#xs. -[12:6..12:10) => example/Synthetic#Name. -[12:10..12:10) => scala/util/matching/Regex#unapplySeq(). -[12:11..12:15) => example/Synthetic#name. -[12:11..12:15) => local0 -[12:16..12:16) => local0 -[13:8..13:8) => scala/collection/immutable/LazyList.toDeferrer(). -[13:14..13:14) => scala/collection/immutable/LazyList.toDeferrer(). -[13:14..13:22) => scala/package.LazyList. -[13:23..13:28) => scala/collection/immutable/LazyList.empty(). -[13:28..13:28) => scala/collection/immutable/LazyList.Deferrer#`#::`(). -[15:6..15:9) => example/Synthetic#lst. -[15:18..15:18) => scala/collection/immutable/LazyList.toDeferrer(). -[15:24..15:24) => scala/collection/immutable/LazyList.toDeferrer(). -[15:24..15:32) => scala/package.LazyList. -[15:33..15:38) => scala/collection/immutable/LazyList.empty(). -[15:38..15:38) => scala/collection/immutable/LazyList.Deferrer#`#::`(). -[17:12..17:12) => scala/LowPriorityImplicits#intWrapper(). -[17:14..17:16) => scala/runtime/RichInt#to(). -[17:19..17:19) => scala/collection/immutable/Range#foreach(). -[17:26..17:26) => scala/LowPriorityImplicits#intWrapper(). -[17:28..17:33) => scala/runtime/RichInt#until(). -[17:36..17:36) => scala/collection/immutable/Range#foreach(). -[17:38..17:45) => scala/Predef.println(+1). -[17:46..17:47) => local1 -[17:48..17:50) => scala/Predef.ArrowAssoc#`->`(). -[17:51..17:52) => local1 -[18:12..18:12) => scala/LowPriorityImplicits#intWrapper(). -[18:14..18:16) => scala/runtime/RichInt#to(). -[18:19..18:19) => scala/collection/StrictOptimizedIterableOps#flatMap(). -[18:26..18:26) => scala/LowPriorityImplicits#intWrapper(). -[18:28..18:33) => scala/runtime/RichInt#until(). -[18:36..18:36) => scala/collection/immutable/Range#map(). -[18:45..18:46) => local2 -[18:48..18:49) => local3 -[19:12..19:12) => scala/LowPriorityImplicits#intWrapper(). -[19:14..19:16) => scala/runtime/RichInt#to(). -[19:19..19:19) => scala/collection/StrictOptimizedIterableOps#flatMap(). -[19:26..19:26) => scala/LowPriorityImplicits#intWrapper(). -[19:28..19:33) => scala/runtime/RichInt#until(). -[19:36..19:36) => scala/collection/IterableOps#withFilter(). -[19:40..19:41) => local4 -[19:42..19:43) => scala/Int#`%`(+3). -[19:46..19:48) => scala/Int#`==`(+3). -[19:50..19:50) => scala/collection/WithFilter#map(). -[19:59..19:60) => local4 -[19:62..19:63) => local5 -[21:9..21:10) => example/Synthetic#s. -[22:8..22:13) => example/Synthetic#s.apply(). -[23:5..23:5) => example/Synthetic#s.apply(). -[24:6..24:11) => example/Synthetic#s.apply(). -[25:15..25:18) => example/Synthetic#s.Bar# -[25:18..25:20) => example/Synthetic#s.Bar#``(). -[26:4..26:7) => example/Synthetic#s.Bar. -[27:9..27:21) => scala/Any#asInstanceOf(). -[27:22..27:25) => scala/Int# -[27:29..27:32) => scala/Int# -[27:33..27:33) => scala/Function1#apply(). -[30:8..30:9) => example/Synthetic#J# -[30:9..30:22) => example/Synthetic#J#``(). -[30:10..30:11) => example/Synthetic#J#[T] -[30:11..30:11) => example/Synthetic#J#evidence$2. -[30:13..30:21) => scala/Predef.Manifest# -[30:21..30:21) => example/Synthetic#J#``().[T] -[30:29..30:32) => example/Synthetic#J#arr. -[30:35..30:40) => scala/Array. -[30:41..30:46) => scala/Array.empty(). -[30:47..30:48) => example/Synthetic#J#[T] -[30:49..30:49) => example/Synthetic#J#evidence$2. -[32:2..32:2) => example/Synthetic#F#``(). -[32:8..32:9) => example/Synthetic#F# -[33:15..33:23) => example/Synthetic#ordering. -[33:25..33:33) => scala/package.Ordering# -[33:34..33:35) => example/Synthetic#F# -[33:39..33:42) => scala/Predef.`???`(). -[34:6..34:7) => example/Synthetic#f. -[34:9..34:16) => scala/package.Ordered# -[34:17..34:18) => example/Synthetic#F# -[34:22..34:22) => scala/math/Ordered.orderingToOrdered(). -[34:26..34:27) => example/Synthetic#F# -[34:27..34:27) => example/Synthetic#F#``(). -[34:27..34:27) => example/Synthetic#ordering. -[36:9..36:14) => scala/ -[36:15..36:25) => scala/concurrent/ -[36:26..36:42) => scala/concurrent/ExecutionContext. -[36:43..36:52) => scala/concurrent/ExecutionContext.Implicits. -[36:53..36:59) => scala/concurrent/ExecutionContext.Implicits.global(). -[38:9..38:14) => scala/ -[38:15..38:25) => scala/concurrent/ -[38:26..38:32) => scala/concurrent/Future. -[38:33..38:43) => scala/concurrent/Future.successful(). -[38:46..38:46) => scala/concurrent/Future#foreach(). -[39:9..39:14) => scala/ -[39:15..39:25) => scala/concurrent/ -[39:26..39:32) => scala/concurrent/Future. -[39:33..39:43) => scala/concurrent/Future.successful(). -[39:46..39:46) => scala/concurrent/Future#foreach(). -[40:4..40:11) => scala/Predef.println(+1). -[40:12..40:13) => local6 -[40:14..40:14) => scala/concurrent/ExecutionContext.Implicits.global(). -[42:9..42:14) => scala/ -[42:15..42:25) => scala/concurrent/ -[42:26..42:32) => scala/concurrent/Future. -[42:33..42:43) => scala/concurrent/Future.successful(). -[42:46..42:46) => scala/concurrent/Future#flatMap(). -[43:9..43:14) => scala/ -[43:15..43:25) => scala/concurrent/ -[43:26..43:32) => scala/concurrent/Future. -[43:33..43:43) => scala/concurrent/Future.successful(). -[43:46..43:46) => scala/concurrent/Future#withFilter(). -[44:7..44:8) => local7 -[44:9..44:10) => scala/Int#`<`(+3). -[44:11..44:12) => local8 -[44:12..44:12) => scala/concurrent/Future#map(). -[44:12..44:12) => scala/concurrent/ExecutionContext.Implicits.global(). -[45:10..45:11) => local7 -[45:11..45:11) => scala/concurrent/ExecutionContext.Implicits.global(). +[0:8..0:15) example <- example/ +[2:7..2:12) scala -> scala/ +[2:13..2:21) language -> scalaShadowing/language. +[2:22..2:41) implicitConversions -> scalaShadowing/language.implicitConversions. +[4:6..4:15) Synthetic <- example/Synthetic# +[5:2..5:2) <- example/Synthetic#``(). +[5:2..5:6) List -> scala/package.List. +[5:6..5:6) -> scala/collection/IterableFactory#apply(). +[5:10..5:13) map -> scala/collection/immutable/List#map(). +[5:16..5:17) + -> scala/Int#`+`(+4). +[6:2..6:2) -> scala/Predef.intArrayOps(). +[6:2..6:7) Array -> scala/Array. +[6:8..6:13) empty -> scala/Array.empty(). +[6:14..6:17) Int -> scala/Int# +[6:18..6:18) -> scala/reflect/ClassTag.apply(). +[6:18..6:18) -> java/lang/Integer#TYPE. +[6:19..6:29) headOption -> scala/collection/ArrayOps#headOption(). +[7:2..7:2) -> scala/Predef.augmentString(). +[7:9..7:20) stripPrefix -> scala/collection/StringOps#stripPrefix(). +[10:6..10:10) Name <- example/Synthetic#Name. +[10:13..10:13) -> scala/Predef.augmentString(). +[10:25..10:26) r -> scala/collection/StringOps#r(). +[11:2..11:2) -> scala/Tuple2#_1. +[11:2..11:2) -> scala/Tuple2#_2. +[11:6..11:7) x <- example/Synthetic#x. +[11:12..11:14) xs <- example/Synthetic#xs. +[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. +[12:11..12:15) name <- local0 +[12:16..12:16) -> local0 +[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:9) lst <- example/Synthetic#lst. +[15:18..15:18) -> scala/collection/immutable/LazyList.toDeferrer(). +[15:24..15:24) -> scala/collection/immutable/LazyList.toDeferrer(). +[15:24..15:32) LazyList -> scala/package.LazyList. +[15:33..15:38) empty -> scala/collection/immutable/LazyList.empty(). +[15:38..15:38) -> scala/collection/immutable/LazyList.Deferrer#`#::`(). +[17:12..17:12) -> scala/LowPriorityImplicits#intWrapper(). +[17:14..17:16) to -> scala/runtime/RichInt#to(). +[17:19..17:19) -> scala/collection/immutable/Range#foreach(). +[17:26..17:26) -> scala/LowPriorityImplicits#intWrapper(). +[17:28..17:33) until -> scala/runtime/RichInt#until(). +[17:36..17:36) -> scala/collection/immutable/Range#foreach(). +[17:38..17:45) println -> scala/Predef.println(+1). +[17:46..17:47) x -> local1 +[17:48..17:50) -> -> scala/Predef.ArrowAssoc#`->`(). +[17:51..17:52) x -> local1 +[18:12..18:12) -> scala/LowPriorityImplicits#intWrapper(). +[18:14..18:16) to -> scala/runtime/RichInt#to(). +[18:19..18:19) -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[18:26..18:26) -> scala/LowPriorityImplicits#intWrapper(). +[18:28..18:33) until -> scala/runtime/RichInt#until(). +[18:36..18:36) -> scala/collection/immutable/Range#map(). +[18:45..18:46) i -> local2 +[18:48..18:49) j -> local3 +[19:12..19:12) -> scala/LowPriorityImplicits#intWrapper(). +[19:14..19:16) to -> scala/runtime/RichInt#to(). +[19:19..19:19) -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[19:26..19:26) -> scala/LowPriorityImplicits#intWrapper(). +[19:28..19:33) until -> scala/runtime/RichInt#until(). +[19:36..19:36) -> scala/collection/IterableOps#withFilter(). +[19:40..19:41) i -> local4 +[19:42..19:43) % -> scala/Int#`%`(+3). +[19:46..19:48) == -> scala/Int#`==`(+3). +[19:50..19:50) -> scala/collection/WithFilter#map(). +[19:59..19:60) i -> local4 +[19:62..19:63) j -> local5 +[21:9..21:10) s <- example/Synthetic#s. +[22:8..22:13) apply <- example/Synthetic#s.apply(). +[23:5..23:5) -> example/Synthetic#s.apply(). +[24:6..24:11) apply -> example/Synthetic#s.apply(). +[25:15..25:18) Bar <- example/Synthetic#s.Bar# +[25:18..25:20) <- example/Synthetic#s.Bar#``(). +[26:4..26:7) Bar -> example/Synthetic#s.Bar. +[27:9..27:21) asInstanceOf -> scala/Any#asInstanceOf(). +[27:22..27:25) Int -> scala/Int# +[27:29..27:32) Int -> scala/Int# +[27:33..27:33) -> scala/Function1#apply(). +[30:8..30:9) J <- example/Synthetic#J# +[30:9..30:22) <- example/Synthetic#J#``(). +[30:10..30:11) T <- example/Synthetic#J#[T] +[30:11..30:11) <- example/Synthetic#J#evidence$2. +[30:13..30:21) Manifest -> scala/Predef.Manifest# +[30:21..30:21) -> example/Synthetic#J#``().[T] +[30:29..30:32) arr <- example/Synthetic#J#arr. +[30:35..30:40) Array -> scala/Array. +[30:41..30:46) empty -> scala/Array.empty(). +[30:47..30:48) T -> example/Synthetic#J#[T] +[30:49..30:49) -> example/Synthetic#J#evidence$2. +[32:2..32:2) <- example/Synthetic#F#``(). +[32:8..32:9) F <- example/Synthetic#F# +[33:15..33:23) ordering <- example/Synthetic#ordering. +[33:25..33:33) Ordering -> scala/package.Ordering# +[33:34..33:35) F -> example/Synthetic#F# +[33:39..33:42) ??? -> scala/Predef.`???`(). +[34:6..34:7) f <- example/Synthetic#f. +[34:9..34:16) Ordered -> scala/package.Ordered# +[34:17..34:18) F -> example/Synthetic#F# +[34:22..34:22) -> scala/math/Ordered.orderingToOrdered(). +[34:26..34:27) F -> example/Synthetic#F# +[34:27..34:27) -> example/Synthetic#F#``(). +[34:27..34:27) -> example/Synthetic#ordering. +[36:9..36:14) scala -> scala/ +[36:15..36:25) concurrent -> scala/concurrent/ +[36:26..36:42) ExecutionContext -> scala/concurrent/ExecutionContext. +[36:43..36:52) Implicits -> scala/concurrent/ExecutionContext.Implicits. +[36:53..36:59) global -> scala/concurrent/ExecutionContext.Implicits.global(). +[38:9..38:14) scala -> scala/ +[38:15..38:25) concurrent -> scala/concurrent/ +[38:26..38:32) Future -> scala/concurrent/Future. +[38:33..38:43) successful -> scala/concurrent/Future.successful(). +[38:46..38:46) -> scala/concurrent/Future#foreach(). +[39:9..39:14) scala -> scala/ +[39:15..39:25) concurrent -> scala/concurrent/ +[39:26..39:32) Future -> scala/concurrent/Future. +[39:33..39:43) successful -> scala/concurrent/Future.successful(). +[39:46..39:46) -> scala/concurrent/Future#foreach(). +[40:4..40:11) println -> scala/Predef.println(+1). +[40:12..40:13) a -> local6 +[40:14..40:14) -> scala/concurrent/ExecutionContext.Implicits.global(). +[42:9..42:14) scala -> scala/ +[42:15..42:25) concurrent -> scala/concurrent/ +[42:26..42:32) Future -> scala/concurrent/Future. +[42:33..42:43) successful -> scala/concurrent/Future.successful(). +[42:46..42:46) -> scala/concurrent/Future#flatMap(). +[43:9..43:14) scala -> scala/ +[43:15..43:25) concurrent -> scala/concurrent/ +[43:26..43:32) Future -> scala/concurrent/Future. +[43:33..43:43) successful -> scala/concurrent/Future.successful(). +[43:46..43:46) -> scala/concurrent/Future#withFilter(). +[44:7..44:8) a -> local7 +[44:9..44:10) < -> scala/Int#`<`(+3). +[44:11..44:12) b -> local8 +[44:12..44:12) -> scala/concurrent/Future#map(). +[44:12..44:12) -> scala/concurrent/ExecutionContext.Implicits.global(). +[45:10..45:11) a -> local7 +[45:11..45:11) -> scala/concurrent/ExecutionContext.Implicits.global(). expect/Traits.scala ___________________ @@ -2394,24 +2389,24 @@ traits/V# => trait V traits/V#``(). => primary ctor Occurrences: -[0:8..0:14) => traits/ -[2:6..2:7) => traits/T# -[3:2..3:2) => traits/T#``(). -[3:6..3:7) => traits/T#x(). -[6:0..6:0) => traits/U#``(). -[6:13..6:14) => traits/U# -[7:7..7:8) => traits/U. -[8:6..8:7) => traits/U.u(). -[8:9..8:10) => traits/U# -[8:17..8:17) => local0 -[8:17..8:18) => traits/U# -[8:21..8:21) => local0 -[11:0..11:0) => traits/C#``(). -[11:6..11:7) => traits/C# -[12:6..12:7) => traits/V# -[12:10..12:10) => traits/V#``(). -[12:10..12:14) => local1 -[12:16..12:17) => traits/C# +[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:17) <- local0 +[8:17..8:18) U -> traits/U# +[8:21..8:21) -> local0 +[11:0..11:0) <- traits/C#``(). +[11:6..11:7) C <- traits/C# +[12:6..12:7) V <- traits/V# +[12:10..12:10) <- traits/V#``(). +[12:10..12:14) self <- local1 +[12:16..12:17) C -> traits/C# expect/Types.scala __________________ @@ -2546,255 +2541,255 @@ types/ann2# => class ann2 types/ann2#``(). => primary ctor Occurrences: -[0:8..0:13) => types/ -[2:7..2:12) => scala/ -[2:13..2:21) => scalaShadowing/language. -[2:22..2:34) => scalaShadowing/language.existentials. -[3:7..3:12) => scala/ -[3:13..3:21) => scalaShadowing/language. -[3:22..3:33) => scalaShadowing/language.higherKinds. -[5:6..5:9) => types/ann# -[5:6..5:6) => scala/annotation/Annotation#``(). -[5:9..5:18) => types/ann#``(). -[5:10..5:11) => types/ann#[T] -[5:13..5:14) => types/ann#x. -[5:16..5:17) => types/ann#``().[T] -[5:27..5:32) => scala/ -[5:33..5:43) => scala/annotation/ -[5:44..5:60) => scala/annotation/StaticAnnotation# -[6:6..6:10) => types/ann1# -[6:6..6:6) => scala/annotation/Annotation#``(). -[6:19..6:19) => types/ann1#``(). -[6:19..6:24) => scala/ -[6:25..6:35) => scala/annotation/ -[6:36..6:52) => scala/annotation/StaticAnnotation# -[7:6..7:10) => types/ann2# -[7:6..7:6) => scala/annotation/Annotation#``(). -[7:19..7:19) => types/ann2#``(). -[7:19..7:24) => scala/ -[7:25..7:35) => scala/annotation/ -[7:36..7:52) => scala/annotation/StaticAnnotation# -[9:0..9:0) => types/B#``(). -[9:6..9:7) => types/B# -[11:0..11:0) => types/C#``(). -[11:6..11:7) => types/C# -[13:6..13:7) => types/P# -[14:2..14:2) => types/P#``(). -[14:2..14:2) => types/P#C#``(). -[14:8..14:9) => types/P#C# -[15:2..15:2) => types/P#X#``(). -[15:8..15:9) => types/P#X# -[16:6..16:7) => types/P#x. -[16:14..16:15) => types/P#X# -[16:15..16:15) => types/P#X#``(). -[19:6..19:7) => types/T# -[20:2..20:2) => types/T#``(). -[20:2..20:2) => types/T#C#``(). -[20:8..20:9) => types/T#C# -[21:2..21:2) => types/T#X#``(). -[21:8..21:9) => types/T#X# -[22:6..22:7) => types/T#x. -[22:14..22:15) => types/T#X# -[22:15..22:15) => types/T#X#``(). -[25:7..25:11) => types/Test. -[26:8..26:9) => types/Test.M# -[27:4..27:4) => types/Test.M#``(). -[27:8..27:9) => types/Test.M#m(). -[27:11..27:14) => scala/Int# -[27:17..27:20) => scala/Predef.`???`(). -[30:8..30:9) => types/Test.N# -[31:4..31:4) => types/Test.N#``(). -[31:8..31:9) => types/Test.N#n(). -[31:11..31:14) => scala/Int# -[31:17..31:20) => scala/Predef.`???`(). -[34:8..34:9) => types/Test.C# -[34:18..34:18) => types/Test.C#``(). -[34:18..34:19) => types/Test.M# -[34:19..34:19) => types/Test.M#``(). -[35:8..35:9) => types/Test.C#p. -[35:16..35:17) => types/P# -[35:17..35:17) => types/P#``(). -[36:8..36:9) => types/Test.C#x. -[36:12..36:13) => types/Test.C#p. -[36:14..36:15) => types/P#x. -[38:8..38:16) => types/Test.C#typeRef1. -[38:18..38:19) => types/Test.C# -[38:22..38:25) => scala/Predef.`???`(). -[39:8..39:16) => types/Test.C#typeRef2. -[39:18..39:19) => types/Test.C#p. -[39:20..39:21) => types/P#C# -[39:24..39:27) => scala/Predef.`???`(). -[40:8..40:16) => types/Test.C#typeRef3. -[40:18..40:19) => types/T# -[40:20..40:21) => types/T#C# -[40:24..40:27) => scala/Predef.`???`(). -[41:8..41:16) => types/Test.C#typeRef4. -[41:18..41:22) => scala/package.List# -[41:23..41:26) => scala/Int# -[41:30..41:33) => scala/Predef.`???`(). -[43:8..43:19) => types/Test.C#singleType1. -[43:21..43:22) => types/Test.C#x. -[43:30..43:33) => scala/Predef.`???`(). -[44:8..44:19) => types/Test.C#singleType2. -[44:21..44:22) => types/Test.C#p. -[44:23..44:24) => types/P#x. -[44:32..44:35) => scala/Predef.`???`(). -[45:8..45:14) => types/Test.C#Either. -[45:17..45:22) => scala/ -[45:23..45:27) => scala/util/ -[45:28..45:34) => scala/util/Either. -[47:8..47:17) => types/Test.C#thisType1. -[47:31..47:34) => scala/Predef.`???`(). -[48:8..48:17) => types/Test.C#thisType2. -[48:33..48:36) => scala/Predef.`???`(). -[50:8..50:18) => types/Test.C#superType1. -[50:27..50:28) => types/Test.M#m(). -[51:8..51:18) => types/Test.C#superType2. -[51:30..51:31) => types/Test.M#m(). -[52:8..52:18) => types/Test.C#superType3. -[52:32..52:33) => types/Test.M#m(). -[54:8..54:21) => types/Test.C#compoundType1. -[54:29..54:30) => local0 -[54:32..54:35) => scala/Int# -[54:40..54:43) => scala/Predef.`???`(). -[55:8..55:21) => types/Test.C#compoundType2. -[55:23..55:24) => types/Test.M# -[55:30..55:31) => types/Test.N# -[55:34..55:37) => scala/Predef.`???`(). -[56:8..56:21) => types/Test.C#compoundType3. -[56:23..56:24) => types/Test.M# -[56:30..56:31) => types/Test.N# -[56:38..56:39) => local1 -[56:41..56:44) => scala/Int# -[56:49..56:52) => scala/Predef.`???`(). -[57:8..57:21) => types/Test.C#compoundType4. -[57:30..57:30) => local2 -[57:34..57:35) => local3 -[57:37..57:40) => scala/Int# -[57:43..57:46) => scala/Predef.`???`(). -[57:48..57:48) => local2 -[58:8..58:21) => types/Test.C#compoundType5. -[58:28..58:28) => local4 -[58:28..58:29) => types/Test.M# -[58:29..58:29) => types/Test.M#``(). -[58:35..58:36) => types/Test.N# -[58:36..58:36) => local4 -[59:8..59:21) => types/Test.C#compoundType6. -[59:28..59:28) => local5 -[59:28..59:29) => types/Test.M# -[59:29..59:29) => types/Test.M#``(). -[59:35..59:36) => types/Test.N# -[59:43..59:44) => local6 -[59:46..59:49) => scala/Int# -[59:52..59:55) => scala/Predef.`???`(). -[59:57..59:57) => local5 -[61:8..61:16) => types/Test.C#annType1. -[61:18..61:19) => types/T# -[61:31..61:34) => scala/Predef.`???`(). -[62:8..62:16) => types/Test.C#annType2. -[62:18..62:19) => types/T# -[62:34..62:37) => scala/Predef.`???`(). -[64:8..64:24) => types/Test.C#existentialType2. -[64:26..64:30) => scala/package.List# -[64:36..64:39) => scala/Predef.`???`(). -[65:8..65:24) => types/Test.C#existentialType3. -[65:27..65:32) => java/lang/Class# -[65:33..65:40) => java/lang/Class#forName(). -[66:8..66:24) => types/Test.C#existentialType4. -[66:27..66:32) => java/lang/Class# -[66:33..66:40) => java/lang/Class#forName(). -[68:8..68:19) => types/Test.C#typeLambda1(). -[68:20..68:21) => types/Test.C#typeLambda1().[M] -[68:28..68:31) => scala/Predef.`???`(). -[69:4..69:15) => types/Test.C#typeLambda1(). -[69:24..69:25) => local7 -[69:26..69:27) => local8 -[69:31..69:35) => scala/package.List# -[69:36..69:37) => local8 -[71:11..71:25) => types/Test.C#ClassInfoType1. -[72:10..72:24) => types/Test.C#ClassInfoType2# -[72:33..72:33) => types/Test.C#ClassInfoType2#``(). -[72:33..72:34) => types/B# -[72:34..72:34) => types/B#``(). -[72:41..72:42) => types/Test.C#ClassInfoType2#x(). -[73:10..73:24) => types/Test.C#ClassInfoType3# -[73:24..73:27) => types/Test.C#ClassInfoType3#``(). -[73:25..73:26) => types/Test.C#ClassInfoType3#[T] -[75:11..75:21) => types/Test.C#MethodType. -[76:10..76:12) => types/Test.C#MethodType.x1(). -[76:14..76:17) => scala/Int# -[76:20..76:23) => scala/Predef.`???`(). -[77:10..77:12) => types/Test.C#MethodType.x2(). -[77:14..77:17) => scala/Int# -[77:20..77:23) => scala/Predef.`???`(). -[78:10..78:12) => types/Test.C#MethodType.m3(). -[78:14..78:17) => scala/Int# -[78:20..78:23) => scala/Predef.`???`(). -[79:10..79:12) => types/Test.C#MethodType.m4(). -[79:16..79:19) => scala/Int# -[79:22..79:25) => scala/Predef.`???`(). -[80:10..80:12) => types/Test.C#MethodType.m5(). -[80:13..80:14) => types/Test.C#MethodType.m5().(x) -[80:16..80:19) => scala/Int# -[80:22..80:25) => scala/Int# -[80:28..80:31) => scala/Predef.`???`(). -[81:10..81:12) => types/Test.C#MethodType.m6(). -[81:13..81:14) => types/Test.C#MethodType.m6().[T] -[81:16..81:17) => types/Test.C#MethodType.m6().(x) -[81:19..81:20) => types/Test.C#MethodType.m6().[T] -[81:23..81:24) => types/Test.C#MethodType.m6().[T] -[81:27..81:30) => scala/Predef.`???`(). -[84:11..84:21) => types/Test.C#ByNameType. -[85:10..85:12) => types/Test.C#ByNameType.m1(). -[85:13..85:14) => types/Test.C#ByNameType.m1().(x) -[85:19..85:22) => scala/Int# -[85:25..85:28) => scala/Int# -[85:31..85:34) => scala/Predef.`???`(). -[88:15..88:27) => types/Test.C#RepeatedType# -[88:27..88:39) => types/Test.C#RepeatedType#``(). -[88:28..88:29) => types/Test.C#RepeatedType#s. -[88:31..88:37) => scala/Predef.String# -[89:10..89:12) => types/Test.C#RepeatedType#m1(). -[89:13..89:14) => types/Test.C#RepeatedType#m1().(x) -[89:16..89:19) => scala/Int# -[89:23..89:26) => scala/Int# -[89:29..89:30) => types/Test.C#RepeatedType#s. -[89:31..89:37) => scala/collection/SeqOps#length(). -[92:11..92:19) => types/Test.C#TypeType. -[93:11..93:13) => types/Test.C#TypeType.T1# -[94:10..94:12) => types/Test.C#TypeType.m2(). -[94:13..94:15) => types/Test.C#TypeType.m2().[T2] -[94:19..94:20) => types/Test.C# -[94:24..94:25) => types/Test.C# -[94:29..94:32) => scala/Predef.`???`(). -[95:10..95:12) => types/Test.C#TypeType.m3(). -[95:13..95:15) => types/Test.C#TypeType.m3().[M3] -[95:22..95:25) => scala/Predef.`???`(). -[96:11..96:13) => types/Test.C#TypeType.T4# -[96:16..96:17) => types/Test.C# -[97:11..97:13) => types/Test.C#TypeType.T5# -[97:14..97:15) => types/Test.C#TypeType.T5#[U] -[97:19..97:20) => types/Test.C#TypeType.T5#[U] -[101:9..101:16) => types/Test.Literal. -[102:14..102:17) => types/Test.Literal.int. -[103:14..103:18) => types/Test.Literal.long. -[104:14..104:19) => types/Test.Literal.float. -[105:14..105:20) => types/Test.Literal.double. -[106:14..106:17) => types/Test.Literal.nil. -[107:14..107:18) => types/Test.Literal.char. -[108:14..108:20) => types/Test.Literal.string. -[109:14..109:18) => types/Test.Literal.bool. -[110:14..110:18) => types/Test.Literal.unit. -[111:14..111:22) => types/Test.Literal.javaEnum. -[111:25..111:29) => java/ -[111:30..111:33) => java/nio/ -[111:34..111:38) => java/nio/file/ -[111:39..111:49) => java/nio/file/LinkOption# -[111:50..111:64) => java/nio/file/LinkOption#NOFOLLOW_LINKS. -[112:14..112:21) => types/Test.Literal.clazzOf. -[112:24..112:31) => scala/Predef.classOf(). -[112:32..112:38) => scala/Option# -[112:39..112:42) => scala/Int# +[0:8..0:13) types <- types/ +[2:7..2:12) scala -> scala/ +[2:13..2:21) language -> scalaShadowing/language. +[2:22..2:34) existentials -> scalaShadowing/language.existentials. +[3:7..3:12) scala -> scala/ +[3:13..3:21) language -> scalaShadowing/language. +[3:22..3:33) higherKinds -> scalaShadowing/language.higherKinds. +[5:6..5:9) ann <- types/ann# +[5:6..5:6) -> scala/annotation/Annotation#``(). +[5:9..5:18) <- types/ann#``(). +[5:10..5:11) T <- types/ann#[T] +[5:13..5:14) x <- types/ann#x. +[5:16..5:17) T -> types/ann#``().[T] +[5:27..5:32) scala -> scala/ +[5:33..5:43) annotation -> scala/annotation/ +[5:44..5:60) StaticAnnotation -> scala/annotation/StaticAnnotation# +[6:6..6:10) ann1 <- types/ann1# +[6:6..6:6) -> scala/annotation/Annotation#``(). +[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:6..7:6) -> scala/annotation/Annotation#``(). +[7:19..7:19) <- types/ann2#``(). +[7:19..7:24) scala -> scala/ +[7:25..7:35) annotation -> scala/annotation/ +[7:36..7:52) StaticAnnotation -> scala/annotation/StaticAnnotation# +[9:0..9:0) <- types/B#``(). +[9:6..9:7) B <- types/B# +[11:0..11:0) <- types/C#``(). +[11:6..11:7) C <- types/C# +[13:6..13:7) P <- types/P# +[14:2..14:2) <- types/P#``(). +[14:2..14:2) <- types/P#C#``(). +[14:8..14:9) C <- types/P#C# +[15:2..15:2) <- types/P#X#``(). +[15:8..15:9) X <- types/P#X# +[16:6..16:7) x <- types/P#x. +[16:14..16:15) X -> types/P#X# +[16:15..16:15) -> types/P#X#``(). +[19:6..19:7) T <- types/T# +[20:2..20:2) <- types/T#``(). +[20:2..20:2) <- types/T#C#``(). +[20:8..20:9) C <- types/T#C# +[21:2..21:2) <- types/T#X#``(). +[21:8..21:9) X <- types/T#X# +[22:6..22:7) x <- types/T#x. +[22:14..22:15) X -> types/T#X# +[22:15..22:15) -> types/T#X#``(). +[25:7..25:11) Test <- types/Test. +[26:8..26:9) M <- types/Test.M# +[27:4..27:4) <- types/Test.M#``(). +[27:8..27:9) m <- types/Test.M#m(). +[27:11..27:14) Int -> scala/Int# +[27:17..27:20) ??? -> scala/Predef.`???`(). +[30:8..30:9) N <- types/Test.N# +[31:4..31:4) <- types/Test.N#``(). +[31:8..31:9) n <- types/Test.N#n(). +[31:11..31:14) Int -> scala/Int# +[31:17..31:20) ??? -> scala/Predef.`???`(). +[34:8..34:9) C <- types/Test.C# +[34:18..34:18) <- types/Test.C#``(). +[34:18..34:19) M -> types/Test.M# +[34:19..34:19) -> types/Test.M#``(). +[35:8..35:9) p <- types/Test.C#p. +[35:16..35:17) P -> types/P# +[35:17..35:17) -> types/P#``(). +[36:8..36:9) x <- types/Test.C#x. +[36:12..36:13) p -> types/Test.C#p. +[36:14..36:15) x -> types/P#x. +[38:8..38:16) typeRef1 <- types/Test.C#typeRef1. +[38:18..38:19) C -> types/Test.C# +[38:22..38:25) ??? -> scala/Predef.`???`(). +[39:8..39:16) typeRef2 <- types/Test.C#typeRef2. +[39:18..39:19) p -> types/Test.C#p. +[39:20..39:21) C -> types/P#C# +[39:24..39:27) ??? -> scala/Predef.`???`(). +[40:8..40:16) typeRef3 <- types/Test.C#typeRef3. +[40:18..40:19) T -> types/T# +[40:20..40:21) C -> types/T#C# +[40:24..40:27) ??? -> scala/Predef.`???`(). +[41:8..41:16) typeRef4 <- types/Test.C#typeRef4. +[41:18..41:22) List -> scala/package.List# +[41:23..41:26) Int -> scala/Int# +[41:30..41:33) ??? -> scala/Predef.`???`(). +[43:8..43:19) singleType1 <- types/Test.C#singleType1. +[43:21..43:22) x -> types/Test.C#x. +[43:30..43:33) ??? -> scala/Predef.`???`(). +[44:8..44:19) singleType2 <- types/Test.C#singleType2. +[44:21..44:22) p -> types/Test.C#p. +[44:23..44:24) x -> types/P#x. +[44:32..44:35) ??? -> scala/Predef.`???`(). +[45:8..45:14) Either <- types/Test.C#Either. +[45:17..45:22) scala -> scala/ +[45:23..45:27) util -> scala/util/ +[45:28..45:34) Either -> scala/util/Either. +[47:8..47:17) thisType1 <- types/Test.C#thisType1. +[47:31..47:34) ??? -> scala/Predef.`???`(). +[48:8..48:17) thisType2 <- types/Test.C#thisType2. +[48:33..48:36) ??? -> scala/Predef.`???`(). +[50:8..50:18) superType1 <- types/Test.C#superType1. +[50:27..50:28) m -> types/Test.M#m(). +[51:8..51:18) superType2 <- types/Test.C#superType2. +[51:30..51:31) m -> types/Test.M#m(). +[52:8..52:18) superType3 <- types/Test.C#superType3. +[52:32..52:33) m -> types/Test.M#m(). +[54:8..54:21) compoundType1 <- types/Test.C#compoundType1. +[54:29..54:30) k <- local0 +[54:32..54:35) Int -> scala/Int# +[54:40..54:43) ??? -> scala/Predef.`???`(). +[55:8..55:21) compoundType2 <- types/Test.C#compoundType2. +[55:23..55:24) M -> types/Test.M# +[55:30..55:31) N -> types/Test.N# +[55:34..55:37) ??? -> scala/Predef.`???`(). +[56:8..56:21) compoundType3 <- types/Test.C#compoundType3. +[56:23..56:24) M -> types/Test.M# +[56:30..56:31) N -> types/Test.N# +[56:38..56:39) k <- local1 +[56:41..56:44) Int -> scala/Int# +[56:49..56:52) ??? -> scala/Predef.`???`(). +[57:8..57:21) compoundType4 <- types/Test.C#compoundType4. +[57:30..57:30) <- local2 +[57:34..57:35) k <- local3 +[57:37..57:40) Int -> scala/Int# +[57:43..57:46) ??? -> scala/Predef.`???`(). +[57:48..57:48) -> local2 +[58:8..58:21) compoundType5 <- types/Test.C#compoundType5. +[58:28..58:28) <- local4 +[58:28..58:29) M -> types/Test.M# +[58:29..58:29) -> types/Test.M#``(). +[58:35..58:36) N -> types/Test.N# +[58:36..58:36) -> local4 +[59:8..59:21) compoundType6 <- types/Test.C#compoundType6. +[59:28..59:28) <- local5 +[59:28..59:29) M -> types/Test.M# +[59:29..59:29) -> types/Test.M#``(). +[59:35..59:36) N -> types/Test.N# +[59:43..59:44) k <- local6 +[59:46..59:49) Int -> scala/Int# +[59:52..59:55) ??? -> scala/Predef.`???`(). +[59:57..59:57) -> local5 +[61:8..61:16) annType1 <- types/Test.C#annType1. +[61:18..61:19) T -> types/T# +[61:31..61:34) ??? -> scala/Predef.`???`(). +[62:8..62:16) annType2 <- types/Test.C#annType2. +[62:18..62:19) T -> types/T# +[62:34..62:37) ??? -> scala/Predef.`???`(). +[64:8..64:24) existentialType2 <- types/Test.C#existentialType2. +[64:26..64:30) List -> scala/package.List# +[64:36..64:39) ??? -> scala/Predef.`???`(). +[65:8..65:24) existentialType3 <- types/Test.C#existentialType3. +[65:27..65:32) Class -> java/lang/Class# +[65:33..65:40) forName -> java/lang/Class#forName(). +[66:8..66:24) existentialType4 <- types/Test.C#existentialType4. +[66:27..66:32) Class -> java/lang/Class# +[66:33..66:40) forName -> java/lang/Class#forName(). +[68:8..68:19) typeLambda1 <- types/Test.C#typeLambda1(). +[68:20..68:21) M <- types/Test.C#typeLambda1().[M] +[68:28..68:31) ??? -> scala/Predef.`???`(). +[69:4..69:15) typeLambda1 -> types/Test.C#typeLambda1(). +[69:24..69:25) L <- local7 +[69:26..69:27) T <- local8 +[69:31..69:35) List -> scala/package.List# +[69:36..69:37) T -> local8 +[71:11..71:25) ClassInfoType1 <- types/Test.C#ClassInfoType1. +[72:10..72:24) ClassInfoType2 <- types/Test.C#ClassInfoType2# +[72:33..72:33) <- types/Test.C#ClassInfoType2#``(). +[72:33..72:34) B -> types/B# +[72:34..72:34) -> types/B#``(). +[72:41..72:42) x <- types/Test.C#ClassInfoType2#x(). +[73:10..73:24) ClassInfoType3 <- types/Test.C#ClassInfoType3# +[73:24..73:27) <- types/Test.C#ClassInfoType3#``(). +[73:25..73:26) T <- types/Test.C#ClassInfoType3#[T] +[75:11..75:21) MethodType <- types/Test.C#MethodType. +[76:10..76:12) x1 <- types/Test.C#MethodType.x1(). +[76:14..76:17) Int -> scala/Int# +[76:20..76:23) ??? -> scala/Predef.`???`(). +[77:10..77:12) x2 <- types/Test.C#MethodType.x2(). +[77:14..77:17) Int -> scala/Int# +[77:20..77:23) ??? -> scala/Predef.`???`(). +[78:10..78:12) m3 <- types/Test.C#MethodType.m3(). +[78:14..78:17) Int -> scala/Int# +[78:20..78:23) ??? -> scala/Predef.`???`(). +[79:10..79:12) m4 <- types/Test.C#MethodType.m4(). +[79:16..79:19) Int -> scala/Int# +[79:22..79:25) ??? -> scala/Predef.`???`(). +[80:10..80:12) m5 <- types/Test.C#MethodType.m5(). +[80:13..80:14) x <- types/Test.C#MethodType.m5().(x) +[80:16..80:19) Int -> scala/Int# +[80:22..80:25) Int -> scala/Int# +[80:28..80:31) ??? -> scala/Predef.`???`(). +[81:10..81:12) m6 <- types/Test.C#MethodType.m6(). +[81:13..81:14) T <- types/Test.C#MethodType.m6().[T] +[81:16..81:17) x <- types/Test.C#MethodType.m6().(x) +[81:19..81:20) T -> types/Test.C#MethodType.m6().[T] +[81:23..81:24) T -> types/Test.C#MethodType.m6().[T] +[81:27..81:30) ??? -> scala/Predef.`???`(). +[84:11..84:21) ByNameType <- types/Test.C#ByNameType. +[85:10..85:12) m1 <- types/Test.C#ByNameType.m1(). +[85:13..85:14) x <- types/Test.C#ByNameType.m1().(x) +[85:19..85:22) Int -> scala/Int# +[85:25..85:28) Int -> scala/Int# +[85:31..85:34) ??? -> scala/Predef.`???`(). +[88:15..88:27) RepeatedType <- types/Test.C#RepeatedType# +[88:27..88:39) <- types/Test.C#RepeatedType#``(). +[88:28..88:29) s <- types/Test.C#RepeatedType#s. +[88:31..88:37) String -> scala/Predef.String# +[89:10..89:12) m1 <- types/Test.C#RepeatedType#m1(). +[89:13..89:14) x <- types/Test.C#RepeatedType#m1().(x) +[89:16..89:19) Int -> scala/Int# +[89:23..89:26) Int -> scala/Int# +[89:29..89:30) s -> types/Test.C#RepeatedType#s. +[89:31..89:37) length -> scala/collection/SeqOps#length(). +[92:11..92:19) TypeType <- types/Test.C#TypeType. +[93:11..93:13) T1 <- types/Test.C#TypeType.T1# +[94:10..94:12) m2 <- types/Test.C#TypeType.m2(). +[94:13..94:15) T2 <- types/Test.C#TypeType.m2().[T2] +[94:19..94:20) C -> types/Test.C# +[94:24..94:25) C -> types/Test.C# +[94:29..94:32) ??? -> scala/Predef.`???`(). +[95:10..95:12) m3 <- types/Test.C#TypeType.m3(). +[95:13..95:15) M3 <- types/Test.C#TypeType.m3().[M3] +[95:22..95:25) ??? -> scala/Predef.`???`(). +[96:11..96:13) T4 <- types/Test.C#TypeType.T4# +[96:16..96:17) C -> types/Test.C# +[97:11..97:13) T5 <- types/Test.C#TypeType.T5# +[97:14..97:15) U <- types/Test.C#TypeType.T5#[U] +[97:19..97:20) U -> types/Test.C#TypeType.T5#[U] +[101:9..101:16) Literal <- types/Test.Literal. +[102:14..102:17) int <- types/Test.Literal.int. +[103:14..103:18) long <- types/Test.Literal.long. +[104:14..104:19) float <- types/Test.Literal.float. +[105:14..105:20) double <- types/Test.Literal.double. +[106:14..106:17) nil <- types/Test.Literal.nil. +[107:14..107:18) char <- types/Test.Literal.char. +[108:14..108:20) string <- types/Test.Literal.string. +[109:14..109:18) bool <- types/Test.Literal.bool. +[110:14..110:18) unit <- types/Test.Literal.unit. +[111:14..111:22) javaEnum <- types/Test.Literal.javaEnum. +[111:25..111:29) java -> java/ +[111:30..111:33) nio -> java/nio/ +[111:34..111:38) file -> java/nio/file/ +[111:39..111:49) LinkOption -> java/nio/file/LinkOption# +[111:50..111:64) NOFOLLOW_LINKS -> java/nio/file/LinkOption#NOFOLLOW_LINKS. +[112:14..112:21) clazzOf <- types/Test.Literal.clazzOf. +[112:24..112:31) classOf -> scala/Predef.classOf(). +[112:32..112:38) Option -> scala/Option# +[112:39..112:42) Int -> scala/Int# expect/ValPattern.scala _______________________ @@ -2831,63 +2826,63 @@ local7 => val local number1Var local7 => var local number1Var Occurrences: -[0:8..0:15) => example/ -[2:6..2:16) => example/ValPattern# -[4:2..4:2) => example/ValPattern#``(). -[4:2..4:2) => scala/Tuple2#_1. -[4:2..4:2) => scala/Tuple2#_2. -[4:7..4:11) => example/ValPattern#left. -[4:13..4:18) => example/ValPattern#right. -[5:6..5:10) => scala/Some. -[5:11..5:18) => example/ValPattern#number1. -[5:11..5:18) => local0 -[5:19..5:19) => local0 -[6:4..6:8) => scala/Some. -[8:2..8:2) => scala/Tuple2#_1. -[8:2..8:2) => scala/Tuple2#_2. -[8:7..8:14) => example/ValPattern#leftVar(). -[8:7..8:16) => example/ValPattern#`leftVar_=`(). -[8:16..8:24) => example/ValPattern#rightVar(). -[8:16..8:26) => example/ValPattern#`rightVar_=`(). -[9:6..9:10) => scala/Some. -[9:11..9:21) => example/ValPattern#number1Var(). -[9:11..9:21) => local1 -[9:11..9:23) => example/ValPattern#`number1Var_=`(). -[9:22..9:22) => local1 -[10:4..10:8) => scala/Some. -[12:6..12:9) => example/ValPattern#app(). -[12:13..12:17) => scala/Unit# -[13:4..13:11) => scala/Predef.println(+1). -[15:8..15:15) => example/ValPattern#number1. -[16:8..16:12) => example/ValPattern#left. -[17:8..17:13) => example/ValPattern#right. -[18:8..18:18) => example/ValPattern#number1Var(). -[19:8..19:15) => example/ValPattern#leftVar(). -[20:8..20:16) => example/ValPattern#rightVar(). -[23:4..23:11) => dotty/DottyPredef.locally(). -[24:6..24:6) => scala/Tuple2#_1. -[24:6..24:6) => scala/Tuple2#_2. -[24:11..24:15) => local2 -[24:17..24:22) => local3 -[25:10..25:14) => scala/Some. -[25:15..25:22) => local4 -[25:23..25:23) => local4 -[26:8..26:12) => scala/Some. -[28:6..28:6) => scala/Tuple2#_1. -[28:6..28:6) => scala/Tuple2#_2. -[28:11..28:18) => local5 -[28:20..28:28) => local6 -[29:10..29:14) => scala/Some. -[29:15..29:25) => local7 -[29:26..29:26) => local7 -[30:8..30:12) => scala/Some. -[31:6..31:13) => scala/Predef.println(+1). -[33:10..33:17) => local4 -[34:10..34:14) => local2 -[35:10..35:15) => local3 -[36:10..36:20) => local7 -[37:10..37:17) => local5 -[38:10..38:18) => local6 +[0:8..0:15) example <- example/ +[2:6..2:16) ValPattern <- example/ValPattern# +[4:2..4:2) <- example/ValPattern#``(). +[4:2..4:2) -> scala/Tuple2#_1. +[4:2..4:2) -> scala/Tuple2#_2. +[4:7..4:11) left <- example/ValPattern#left. +[4:13..4:18) right <- example/ValPattern#right. +[5:6..5:10) Some -> scala/Some. +[5:11..5:18) number1 <- example/ValPattern#number1. +[5:11..5:18) number1 <- local0 +[5:19..5:19) -> local0 +[6:4..6:8) Some -> scala/Some. +[8:2..8:2) -> scala/Tuple2#_1. +[8:2..8:2) -> scala/Tuple2#_2. +[8:7..8:14) leftVar <- example/ValPattern#leftVar(). +[8:7..8:16) leftVar, <- example/ValPattern#`leftVar_=`(). +[8:16..8:24) rightVar <- example/ValPattern#rightVar(). +[8:16..8:26) rightVar) <- example/ValPattern#`rightVar_=`(). +[9:6..9:10) Some -> scala/Some. +[9:11..9:21) number1Var <- example/ValPattern#number1Var(). +[9:11..9:21) number1Var <- local1 +[9:11..9:23) number1Var) <- example/ValPattern#`number1Var_=`(). +[9:22..9:22) -> local1 +[10:4..10:8) Some -> scala/Some. +[12:6..12:9) app <- example/ValPattern#app(). +[12:13..12:17) Unit -> scala/Unit# +[13:4..13:11) println -> scala/Predef.println(+1). +[15:8..15:15) number1 -> example/ValPattern#number1. +[16:8..16:12) left -> example/ValPattern#left. +[17:8..17:13) right -> example/ValPattern#right. +[18:8..18:18) number1Var -> example/ValPattern#number1Var(). +[19:8..19:15) leftVar -> example/ValPattern#leftVar(). +[20:8..20:16) rightVar -> example/ValPattern#rightVar(). +[23:4..23:11) locally -> dotty/DottyPredef.locally(). +[24:6..24:6) -> scala/Tuple2#_1. +[24:6..24:6) -> scala/Tuple2#_2. +[24:11..24:15) left <- local2 +[24:17..24:22) right <- local3 +[25:10..25:14) Some -> scala/Some. +[25:15..25:22) number1 <- local4 +[25:23..25:23) -> local4 +[26:8..26:12) Some -> scala/Some. +[28:6..28:6) -> scala/Tuple2#_1. +[28:6..28:6) -> scala/Tuple2#_2. +[28:11..28:18) leftVar <- local5 +[28:20..28:28) rightVar <- local6 +[29:10..29:14) Some -> scala/Some. +[29:15..29:25) number1Var <- local7 +[29:26..29:26) -> local7 +[30:8..30:12) Some -> scala/Some. +[31:6..31:13) println -> scala/Predef.println(+1). +[33:10..33:17) number1 -> local4 +[34:10..34:14) left -> local2 +[35:10..35:15) right -> local3 +[36:10..36:20) number1Var -> local7 +[37:10..37:17) leftVar -> local5 +[38:10..38:18) rightVar -> local6 expect/Vals.scala _________________ @@ -2936,128 +2931,128 @@ local3 => var local yl local4 => implicit var local yil Occurrences: -[0:8..0:15) => example/ -[2:15..2:19) => example/Vals# -[2:19..2:53) => example/Vals#``(). -[2:20..2:21) => example/Vals#p. -[2:23..2:26) => scala/Int# -[2:32..2:34) => example/Vals#xp. -[2:36..2:39) => scala/Int# -[2:45..2:47) => example/Vals#yp(). -[2:45..2:49) => example/Vals#`yp_=`(). -[2:49..2:52) => scala/Int# -[3:6..3:8) => example/Vals#xm. -[3:10..3:13) => scala/Int# -[3:16..3:19) => scala/Predef.`???`(). -[4:6..4:9) => example/Vals#xam. -[4:11..4:14) => scala/Int# -[5:20..5:23) => example/Vals#xlm. -[5:25..5:28) => scala/Int# -[5:31..5:34) => scala/Predef.`???`(). -[6:11..6:14) => example/Vals#xzm. -[6:16..6:19) => scala/Int# -[6:22..6:25) => scala/Predef.`???`(). -[7:25..7:29) => example/Vals#xzlm. -[7:31..7:34) => scala/Int# -[7:37..7:40) => scala/Predef.`???`(). -[8:12..8:15) => example/Vals#xfm. -[8:17..8:20) => scala/Int# -[8:23..8:26) => scala/Predef.`???`(). -[9:15..9:18) => example/Vals#xim. -[9:20..9:23) => scala/Int# -[9:26..9:29) => scala/Predef.`???`(). -[10:6..10:8) => example/Vals#ym(). -[10:6..10:10) => example/Vals#`ym_=`(). -[10:10..10:13) => scala/Int# -[10:16..10:19) => scala/Predef.`???`(). -[11:6..11:9) => example/Vals#yam(). -[11:6..11:11) => example/Vals#`yam_=`(). -[11:11..11:14) => scala/Int# -[12:20..12:23) => example/Vals#ylm(). -[12:25..12:28) => scala/Int# -[12:31..12:34) => scala/Predef.`???`(). -[16:12..16:15) => example/Vals#yfm(). -[16:12..16:17) => example/Vals#`yfm_=`(). -[16:17..16:20) => scala/Int# -[16:23..16:26) => scala/Predef.`???`(). -[17:15..17:18) => example/Vals#yim(). -[17:15..17:20) => example/Vals#`yim_=`(). -[17:20..17:23) => scala/Int# -[17:26..17:29) => scala/Predef.`???`(). -[18:6..18:7) => example/Vals#m(). -[19:8..19:10) => local0 -[19:12..19:15) => scala/Int# -[19:18..19:21) => scala/Predef.`???`(). -[20:13..20:16) => local1 -[20:18..20:21) => scala/Int# -[20:24..20:27) => scala/Predef.`???`(). -[23:17..23:20) => local2 -[23:22..23:25) => scala/Int# -[23:28..23:31) => scala/Predef.`???`(). -[24:8..24:10) => local3 -[24:12..24:15) => scala/Int# -[24:18..24:21) => scala/Predef.`???`(). -[29:17..29:20) => local4 -[29:22..29:25) => scala/Int# -[29:28..29:31) => scala/Predef.`???`(). -[30:4..30:6) => local3 -[30:9..30:11) => local0 -[30:12..30:13) => scala/Int#`+`(+4). -[30:14..30:16) => local3 -[31:4..31:11) => scala/Predef.println(+1). -[31:12..31:15) => local1 -[32:4..32:7) => local4 -[32:10..32:13) => local2 -[32:14..32:15) => scala/Int#`+`(+4). -[32:16..32:19) => local4 -[34:2..34:9) => scala/Predef.println(+1). -[34:10..34:14) => example/Vals#xzlm. -[35:2..35:5) => example/Vals#ylm(). -[35:8..35:11) => example/Vals#xlm. -[35:12..35:13) => scala/Int#`+`(+4). -[35:14..35:17) => example/Vals#ylm(). -[38:7..38:16) => example/ValUsages. -[39:6..39:7) => example/ValUsages.v. -[39:9..39:13) => example/Vals# -[39:16..39:19) => scala/Predef.`???`(). -[40:2..40:3) => example/ValUsages.v. -[40:2..40:6) => example/Vals#`yp_=`(). -[40:9..40:10) => example/ValUsages.v. -[40:11..40:13) => example/Vals#xp. -[40:14..40:15) => scala/Int#`+`(+4). -[40:16..40:17) => example/ValUsages.v. -[40:18..40:20) => example/Vals#yp(). -[41:2..41:3) => example/ValUsages.v. -[41:2..41:6) => example/Vals#`ym_=`(). -[41:9..41:10) => example/ValUsages.v. -[41:11..41:13) => example/Vals#xm. -[41:14..41:15) => scala/Int#`+`(+4). -[41:16..41:17) => example/ValUsages.v. -[41:18..41:20) => example/Vals#ym(). -[42:2..42:3) => example/ValUsages.v. -[42:2..42:7) => example/Vals#`yam_=`(). -[42:10..42:11) => example/ValUsages.v. -[42:12..42:15) => example/Vals#xam. -[42:16..42:17) => scala/Int#`+`(+4). -[42:18..42:19) => example/ValUsages.v. -[42:20..42:23) => example/Vals#yam(). -[43:2..43:9) => scala/Predef.println(+1). -[43:10..43:11) => example/ValUsages.v. -[43:12..43:15) => example/Vals#xzm. -[44:2..44:3) => example/ValUsages.v. -[44:2..44:7) => example/Vals#`yfm_=`(). -[44:10..44:11) => example/ValUsages.v. -[44:12..44:15) => example/Vals#xfm. -[44:16..44:17) => scala/Int#`+`(+4). -[44:18..44:19) => example/ValUsages.v. -[44:20..44:23) => example/Vals#yfm(). -[45:2..45:3) => example/ValUsages.v. -[45:2..45:7) => example/Vals#`yim_=`(). -[45:10..45:11) => example/ValUsages.v. -[45:12..45:15) => example/Vals#xim. -[45:16..45:17) => scala/Int#`+`(+4). -[45:18..45:19) => example/ValUsages.v. -[45:20..45:23) => example/Vals#yim(). +[0:8..0:15) example <- example/ +[2:15..2:19) Vals <- example/Vals# +[2:19..2:53) <- example/Vals#``(). +[2:20..2:21) p <- example/Vals#p. +[2:23..2:26) Int -> scala/Int# +[2:32..2:34) xp <- example/Vals#xp. +[2:36..2:39) Int -> scala/Int# +[2:45..2:47) yp <- example/Vals#yp(). +[2:45..2:49) yp: <- example/Vals#`yp_=`(). +[2:49..2:52) Int -> scala/Int# +[3:6..3:8) xm <- example/Vals#xm. +[3:10..3:13) Int -> scala/Int# +[3:16..3:19) ??? -> scala/Predef.`???`(). +[4:6..4:9) xam <- example/Vals#xam. +[4:11..4:14) Int -> scala/Int# +[5:20..5:23) xlm <- example/Vals#xlm. +[5:25..5:28) Int -> scala/Int# +[5:31..5:34) ??? -> scala/Predef.`???`(). +[6:11..6:14) xzm <- example/Vals#xzm. +[6:16..6:19) Int -> scala/Int# +[6:22..6:25) ??? -> scala/Predef.`???`(). +[7:25..7:29) xzlm <- example/Vals#xzlm. +[7:31..7:34) Int -> scala/Int# +[7:37..7:40) ??? -> scala/Predef.`???`(). +[8:12..8:15) xfm <- example/Vals#xfm. +[8:17..8:20) Int -> scala/Int# +[8:23..8:26) ??? -> scala/Predef.`???`(). +[9:15..9:18) xim <- example/Vals#xim. +[9:20..9:23) Int -> scala/Int# +[9:26..9:29) ??? -> scala/Predef.`???`(). +[10:6..10:8) ym <- example/Vals#ym(). +[10:6..10:10) ym: <- example/Vals#`ym_=`(). +[10:10..10:13) Int -> scala/Int# +[10:16..10:19) ??? -> scala/Predef.`???`(). +[11:6..11:9) yam <- example/Vals#yam(). +[11:6..11:11) yam: <- example/Vals#`yam_=`(). +[11:11..11:14) Int -> scala/Int# +[12:20..12:23) ylm <- example/Vals#ylm(). +[12:25..12:28) Int -> scala/Int# +[12:31..12:34) ??? -> scala/Predef.`???`(). +[16:12..16:15) yfm <- example/Vals#yfm(). +[16:12..16:17) yfm: <- example/Vals#`yfm_=`(). +[16:17..16:20) Int -> scala/Int# +[16:23..16:26) ??? -> scala/Predef.`???`(). +[17:15..17:18) yim <- example/Vals#yim(). +[17:15..17:20) yim: <- example/Vals#`yim_=`(). +[17:20..17:23) Int -> scala/Int# +[17:26..17:29) ??? -> scala/Predef.`???`(). +[18:6..18:7) m <- example/Vals#m(). +[19:8..19:10) xl <- local0 +[19:12..19:15) Int -> scala/Int# +[19:18..19:21) ??? -> scala/Predef.`???`(). +[20:13..20:16) xzl <- local1 +[20:18..20:21) Int -> scala/Int# +[20:24..20:27) ??? -> scala/Predef.`???`(). +[23:17..23:20) xil <- local2 +[23:22..23:25) Int -> scala/Int# +[23:28..23:31) ??? -> scala/Predef.`???`(). +[24:8..24:10) yl <- local3 +[24:12..24:15) Int -> scala/Int# +[24:18..24:21) ??? -> scala/Predef.`???`(). +[29:17..29:20) yil <- local4 +[29:22..29:25) Int -> scala/Int# +[29:28..29:31) ??? -> scala/Predef.`???`(). +[30:4..30:6) yl -> local3 +[30:9..30:11) xl -> local0 +[30:12..30:13) + -> scala/Int#`+`(+4). +[30:14..30:16) yl -> local3 +[31:4..31:11) println -> scala/Predef.println(+1). +[31:12..31:15) xzl -> local1 +[32:4..32:7) yil -> local4 +[32:10..32:13) xil -> local2 +[32:14..32:15) + -> scala/Int#`+`(+4). +[32:16..32:19) yil -> local4 +[34:2..34:9) println -> scala/Predef.println(+1). +[34:10..34:14) xzlm -> example/Vals#xzlm. +[35:2..35:5) ylm -> example/Vals#ylm(). +[35:8..35:11) xlm -> example/Vals#xlm. +[35:12..35:13) + -> scala/Int#`+`(+4). +[35:14..35:17) ylm -> example/Vals#ylm(). +[38:7..38:16) ValUsages <- example/ValUsages. +[39:6..39:7) v <- example/ValUsages.v. +[39:9..39:13) Vals -> example/Vals# +[39:16..39:19) ??? -> scala/Predef.`???`(). +[40:2..40:3) v -> example/ValUsages.v. +[40:4..40:6) yp -> example/Vals#`yp_=`(). +[40:9..40:10) v -> example/ValUsages.v. +[40:11..40:13) xp -> example/Vals#xp. +[40:14..40:15) + -> scala/Int#`+`(+4). +[40:16..40:17) v -> example/ValUsages.v. +[40:18..40:20) yp -> example/Vals#yp(). +[41:2..41:3) v -> example/ValUsages.v. +[41:4..41:6) ym -> example/Vals#`ym_=`(). +[41:9..41:10) v -> example/ValUsages.v. +[41:11..41:13) xm -> example/Vals#xm. +[41:14..41:15) + -> scala/Int#`+`(+4). +[41:16..41:17) v -> example/ValUsages.v. +[41:18..41:20) ym -> example/Vals#ym(). +[42:2..42:3) v -> example/ValUsages.v. +[42:4..42:7) yam -> example/Vals#`yam_=`(). +[42:10..42:11) v -> example/ValUsages.v. +[42:12..42:15) xam -> example/Vals#xam. +[42:16..42:17) + -> scala/Int#`+`(+4). +[42:18..42:19) v -> example/ValUsages.v. +[42:20..42:23) yam -> example/Vals#yam(). +[43:2..43:9) println -> scala/Predef.println(+1). +[43:10..43:11) v -> example/ValUsages.v. +[43:12..43:15) xzm -> example/Vals#xzm. +[44:2..44:3) v -> example/ValUsages.v. +[44:4..44:7) yfm -> example/Vals#`yfm_=`(). +[44:10..44:11) v -> example/ValUsages.v. +[44:12..44:15) xfm -> example/Vals#xfm. +[44:16..44:17) + -> scala/Int#`+`(+4). +[44:18..44:19) v -> example/ValUsages.v. +[44:20..44:23) yfm -> example/Vals#yfm(). +[45:2..45:3) v -> example/ValUsages.v. +[45:4..45:7) yim -> example/Vals#`yim_=`(). +[45:10..45:11) v -> example/ValUsages.v. +[45:12..45:15) xim -> example/Vals#xim. +[45:16..45:17) + -> scala/Int#`+`(+4). +[45:18..45:19) v -> example/ValUsages.v. +[45:20..45:23) yim -> example/Vals#yim(). expect/Vararg.scala ___________________ @@ -3079,17 +3074,17 @@ example/Vararg#add2(). => method add2 example/Vararg#add2().(a) => val param a Occurrences: -[0:8..0:15) => example/ -[2:6..2:12) => example/Vararg# -[3:2..3:2) => example/Vararg#``(). -[3:6..3:10) => example/Vararg#add1(). -[3:11..3:12) => example/Vararg#add1().(a) -[3:14..3:17) => scala/Int# -[4:6..4:10) => example/Vararg#add2(). -[4:11..4:12) => example/Vararg#add2().(a) -[4:14..4:17) => scala/package.Seq# -[4:18..4:21) => scala/Int# -[4:26..4:30) => scala/Unit# +[0:8..0:15) example <- example/ +[2:6..2:12) Vararg <- example/Vararg# +[3:2..3:2) <- example/Vararg#``(). +[3:6..3:10) add1 <- example/Vararg#add1(). +[3:11..3:12) a <- example/Vararg#add1().(a) +[3:14..3:17) Int -> scala/Int# +[4:6..4:10) add2 <- example/Vararg#add2(). +[4:11..4:12) a <- example/Vararg#add2().(a) +[4:14..4:17) Seq -> scala/package.Seq# +[4:18..4:21) Int -> scala/Int# +[4:26..4:30) Unit -> scala/Unit# expect/filename with spaces.scala _________________________________ @@ -3107,9 +3102,9 @@ example/FilenameWithSpaces# => class FilenameWithSpaces example/FilenameWithSpaces#``(). => primary ctor Occurrences: -[0:8..0:15) => example/ -[2:0..2:0) => example/FilenameWithSpaces#``(). -[2:6..2:24) => example/FilenameWithSpaces# +[0:8..0:15) example <- example/ +[2:0..2:0) <- example/FilenameWithSpaces#``(). +[2:6..2:24) FilenameWithSpaces <- example/FilenameWithSpaces# expect/local-file.scala _______________________ @@ -3128,13 +3123,13 @@ example/`local-file`#``(). => primary ctor local0 => val local local Occurrences: -[0:8..0:15) => example/ -[2:7..2:17) => example/`local-file`# -[3:2..3:2) => example/`local-file`#``(). -[3:2..3:9) => dotty/DottyPredef.locally(). -[4:8..4:13) => local0 -[5:4..5:9) => local0 -[5:10..5:11) => scala/Int#`+`(+4). +[0:8..0:15) example <- example/ +[2:7..2:17) local-file <- example/`local-file`# +[3:2..3:2) <- example/`local-file`#``(). +[3:2..3:9) locally -> dotty/DottyPredef.locally(). +[4:8..4:13) local <- local0 +[5:4..5:9) local -> local0 +[5:10..5:11) + -> scala/Int#`+`(+4). expect/semanticdb-extract.scala _______________________________ @@ -3145,7 +3140,7 @@ Uri => semanticdb-extract.scala Text => empty Language => Scala Symbols => 8 entries -Occurrences => 23 entries +Occurrences => 22 entries Symbols: _empty_/AnObject. => final object AnObject @@ -3158,29 +3153,28 @@ _empty_/AnObject.foo().(x) => val param x _empty_/AnObject.foo(+1). => method foo Occurrences: -[0:0..0:0) => _empty_/ -[0:7..0:15) => _empty_/AnObject. -[2:6..2:9) => _empty_/AnObject.foo(). -[2:10..2:11) => _empty_/AnObject.foo().(x) -[2:13..2:16) => scala/Int# -[3:6..3:9) => _empty_/AnObject.foo(+1). -[3:13..3:17) => scala/Unit# -[5:2..5:5) => _empty_/AnObject.foo(). -[6:2..6:5) => _empty_/AnObject.foo(+1). -[8:5..8:14) => java/lang/String#substring(). -[9:5..9:14) => java/lang/String#substring(+1). -[11:2..11:6) => scala/package.List. -[11:6..11:6) => scala/collection/IterableFactory#apply(). -[12:2..12:6) => scala/package.List. -[12:7..12:12) => scala/collection/IterableFactory#apply(). -[13:2..13:6) => scala/package.List. -[13:8..13:14) => scala/collection/IterableFactory#apply(). -[14:2..14:9) => scala/Predef.println(+1). -[14:12..14:13) => scala/Int#`+`(+4). -[16:13..16:16) => _empty_/AnObject.Foo# -[16:16..16:24) => _empty_/AnObject.Foo#``(). -[16:17..16:18) => _empty_/AnObject.Foo#x. -[16:20..16:23) => scala/Int# +[0:7..0:15) AnObject <- _empty_/AnObject. +[2:6..2:9) foo <- _empty_/AnObject.foo(). +[2:10..2:11) x <- _empty_/AnObject.foo().(x) +[2:13..2:16) Int -> scala/Int# +[3:6..3:9) foo <- _empty_/AnObject.foo(+1). +[3:13..3:17) Unit -> scala/Unit# +[5:2..5:5) foo -> _empty_/AnObject.foo(). +[6:2..6:5) foo -> _empty_/AnObject.foo(+1). +[8:5..8:14) substring -> java/lang/String#substring(). +[9:5..9:14) substring -> java/lang/String#substring(+1). +[11:2..11:6) List -> scala/package.List. +[11:6..11:6) -> scala/collection/IterableFactory#apply(). +[12:2..12:6) List -> scala/package.List. +[12:7..12:12) apply -> scala/collection/IterableFactory#apply(). +[13:2..13:6) List -> scala/package.List. +[13:7..13:14) `apply` -> scala/collection/IterableFactory#apply(). +[14:2..14:9) println -> scala/Predef.println(+1). +[14:12..14:13) + -> scala/Int#`+`(+4). +[16:13..16:16) Foo <- _empty_/AnObject.Foo# +[16:16..16:24) <- _empty_/AnObject.Foo#``(). +[16:17..16:18) x <- _empty_/AnObject.Foo#x. +[16:20..16:23) Int -> scala/Int# expect/toplevel.scala _____________________ @@ -3191,7 +3185,7 @@ Uri => toplevel.scala Text => empty Language => Scala Symbols => 11 entries -Occurrences => 25 entries +Occurrences => 24 entries Symbols: _empty_/toplevel$package. => final package object _empty_ @@ -3207,29 +3201,28 @@ _empty_/toplevel$package.combine(+2). => method combine _empty_/toplevel$package.foo(). => method foo Occurrences: -[0:0..0:0) => _empty_/ -[0:0..0:16) => _empty_/toplevel$package. -[0:11..0:12) => _empty_/toplevel$package.a. -[1:4..1:11) => _empty_/toplevel$package.combine(). -[1:5..1:6) => _empty_/toplevel$package.combine().(x) -[1:8..1:11) => scala/Int# -[1:22..1:23) => _empty_/toplevel$package.combine().(y) -[1:25..1:28) => scala/Int# -[1:32..1:33) => _empty_/toplevel$package.combine().(x) -[1:34..1:35) => scala/Int#`+`(+4). -[1:36..1:37) => _empty_/toplevel$package.combine().(y) -[2:4..2:11) => _empty_/toplevel$package.combine(+1). -[2:12..2:13) => _empty_/toplevel$package.combine(+1).(x) -[2:15..2:18) => scala/Int# -[2:20..2:21) => _empty_/toplevel$package.combine(+1).(y) -[2:23..2:26) => scala/Int# -[2:28..2:29) => _empty_/toplevel$package.combine(+1).(z) -[2:31..2:34) => scala/Int# -[2:38..2:39) => _empty_/toplevel$package.combine(+1).(x) -[2:40..2:41) => scala/Int#`+`(+4). -[2:42..2:43) => _empty_/toplevel$package.combine(+1).(y) -[2:44..2:45) => scala/Int#`+`(+4). -[2:46..2:47) => _empty_/toplevel$package.combine(+1).(z) -[3:4..3:11) => _empty_/toplevel$package.combine(+2). -[4:4..4:7) => _empty_/toplevel$package.foo(). +[0:0..0:16) inline val a = " <- _empty_/toplevel$package. +[0:11..0:12) a <- _empty_/toplevel$package.a. +[1:4..1:11) (x: Int <- _empty_/toplevel$package.combine(). +[1:5..1:6) x <- _empty_/toplevel$package.combine().(x) +[1:8..1:11) Int -> scala/Int# +[1:22..1:23) y <- _empty_/toplevel$package.combine().(y) +[1:25..1:28) Int -> scala/Int# +[1:32..1:33) x -> _empty_/toplevel$package.combine().(x) +[1:34..1:35) + -> scala/Int#`+`(+4). +[1:36..1:37) y -> _empty_/toplevel$package.combine().(y) +[2:4..2:11) combine <- _empty_/toplevel$package.combine(+1). +[2:12..2:13) x <- _empty_/toplevel$package.combine(+1).(x) +[2:15..2:18) Int -> scala/Int# +[2:20..2:21) y <- _empty_/toplevel$package.combine(+1).(y) +[2:23..2:26) Int -> scala/Int# +[2:28..2:29) z <- _empty_/toplevel$package.combine(+1).(z) +[2:31..2:34) Int -> scala/Int# +[2:38..2:39) x -> _empty_/toplevel$package.combine(+1).(x) +[2:40..2:41) + -> scala/Int#`+`(+4). +[2:42..2:43) y -> _empty_/toplevel$package.combine(+1).(y) +[2:44..2:45) + -> scala/Int#`+`(+4). +[2:46..2:47) z -> _empty_/toplevel$package.combine(+1).(z) +[3:4..3:11) combine <- _empty_/toplevel$package.combine(+2). +[4:4..4:7) foo <- _empty_/toplevel$package.foo(). From 02747cd59ee218190e2996e3ab439de493808b6a Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sat, 16 Nov 2019 17:35:32 +0100 Subject: [PATCH 068/107] test collective extension methods with more than one method --- tests/semanticdb/expect/Givens.expect.scala | 6 + tests/semanticdb/expect/Givens.scala | 6 + tests/semanticdb/metac.expect | 115 ++++++++++++-------- 3 files changed, 82 insertions(+), 45 deletions(-) diff --git a/tests/semanticdb/expect/Givens.expect.scala b/tests/semanticdb/expect/Givens.expect.scala index a969158a55a1..80d89954e06b 100644 --- a/tests/semanticdb/expect/Givens.expect.scala +++ b/tests/semanticdb/expect/Givens.expect.scala @@ -6,7 +6,13 @@ object Givens/*<-a::b::Givens.*/ given :[A](any: A) de/*<-a::b::Givens.given_sayHello_of_A.*//*<-a::b::Givens.given_sayHello_of_A.sayHello().[A]*//*<-a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->a::b::Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<-a::b::Givens.given_sayHello_of_A.sayHello().*/ = s"Hello, I am $any/*->a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->scala::StringContext#s().*/" + given :[B](any: B) + def /*<-a::b::Givens.given_sayGoodbye_of_B.*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*/sayGoodbye/*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/ = s"Goodbye, from $any/*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*->scala::StringContext#s().*/" + def saySoLong/*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().*/ = s"So Long, from $any/*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->scala::StringContext#s().*/" + val hello1/*<-a::b::Givens.hello1.*/ = /*->a::b::Givens.given_sayHello_of_A.sayHello().*/1.sayHello + val goodbye1/*<-a::b::Givens.goodbye1.*/ = /*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/1.sayGoodbye + val soLong1/*<-a::b::Givens.soLong1.*/ = /*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().*/1.saySoLong trait Monoid/*<-a::b::Givens.Monoid#*/[A/*<-a::b::Givens.Monoid#[A]*/] def empty/*<-a::b::Givens.Monoid#empty().*/: A/*->a::b::Givens.Monoid#[A]*/ diff --git a/tests/semanticdb/expect/Givens.scala b/tests/semanticdb/expect/Givens.scala index b654447e7244..b12d514fddb2 100644 --- a/tests/semanticdb/expect/Givens.scala +++ b/tests/semanticdb/expect/Givens.scala @@ -6,7 +6,13 @@ object Givens given :[A](any: A) def sayHello = s"Hello, I am $any" + given :[B](any: B) + def sayGoodbye = s"Goodbye, from $any" + def saySoLong = s"So Long, from $any" + val hello1 = 1.sayHello + val goodbye1 = 1.sayGoodbye + val soLong1 = 1.saySoLong trait Monoid[A] def empty: A diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index a265c9a7b06b..0bd6f3845ec5 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -1085,8 +1085,8 @@ Schema => SemanticDB v4 Uri => Givens.scala Text => empty Language => Scala -Symbols => 22 entries -Occurrences => 52 entries +Symbols => 31 entries +Occurrences => 69 entries Symbols: a/b/Givens. => final object Givens @@ -1105,12 +1105,21 @@ a/b/Givens.given_Monoid_String.combine(). => method combine a/b/Givens.given_Monoid_String.combine().(x) => val param x a/b/Givens.given_Monoid_String.combine().(y) => val param y a/b/Givens.given_Monoid_String.empty(). => method empty +a/b/Givens.given_sayGoodbye_of_B. => final object given_sayGoodbye_of_B +a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). => method sayGoodbye +a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) => val param any +a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] => typeparam B +a/b/Givens.given_sayGoodbye_of_B.saySoLong(). => method saySoLong +a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) => val param any +a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] => typeparam B a/b/Givens.given_sayHello_of_A. => final object given_sayHello_of_A a/b/Givens.given_sayHello_of_A.sayHello(). => method sayHello a/b/Givens.given_sayHello_of_A.sayHello().(any) => val param any a/b/Givens.given_sayHello_of_A.sayHello().[A] => typeparam A +a/b/Givens.goodbye1. => val method goodbye1 a/b/Givens.hello1. => val method hello1 a/b/Givens.int2String(). => final implicit macro int2String +a/b/Givens.soLong1. => val method soLong1 Occurrences: [0:8..0:9) a <- a/ @@ -1123,48 +1132,65 @@ Occurrences: [6:8..6:16) sayHello <- a/b/Givens.given_sayHello_of_A.sayHello(). [6:34..6:37) any -> a/b/Givens.given_sayHello_of_A.sayHello().(any) [6:37..6:37) -> scala/StringContext#s(). -[8:6..8:12) hello1 <- a/b/Givens.hello1. -[8:15..8:15) -> a/b/Givens.given_sayHello_of_A.sayHello(). -[10:8..10:14) Monoid <- a/b/Givens.Monoid# -[10:14..10:17) <- a/b/Givens.Monoid#``(). -[10:15..10:16) A <- a/b/Givens.Monoid#[A] -[11:8..11:13) empty <- a/b/Givens.Monoid#empty(). -[11:15..11:16) A -> a/b/Givens.Monoid#[A] -[12:8..12:15) (x: A) <- a/b/Givens.Monoid#combine(). -[12:9..12:10) x <- a/b/Givens.Monoid#combine().(x) -[12:12..12:13) A -> a/b/Givens.Monoid#[A] -[12:24..12:25) y <- a/b/Givens.Monoid#combine().(y) -[12:27..12:28) A -> a/b/Givens.Monoid#[A] -[12:31..12:32) A -> a/b/Givens.Monoid#[A] -[14:8..15:4) <- a/b/Givens.given_Monoid_String. -[14:8..14:14) Monoid -> a/b/Givens.Monoid# -[14:15..14:21) String -> scala/Predef.String# -[15:8..15:13) empty <- a/b/Givens.given_Monoid_String.empty(). -[16:8..16:15) (x: Str <- a/b/Givens.given_Monoid_String.combine(). -[16:9..16:10) x <- a/b/Givens.given_Monoid_String.combine().(x) -[16:12..16:18) String -> scala/Predef.String# -[16:29..16:30) y <- a/b/Givens.given_Monoid_String.combine().(y) -[16:32..16:38) String -> scala/Predef.String# -[16:42..16:43) x -> a/b/Givens.given_Monoid_String.combine().(x) -[16:44..16:45) + -> java/lang/String#`+`(). -[16:46..16:47) y -> a/b/Givens.given_Monoid_String.combine().(y) -[18:15..18:25) int2String <- a/b/Givens.int2String(). -[18:27..18:37) Conversion -> scala/Conversion# -[18:38..18:41) Int -> scala/Int# -[18:43..18:49) String -> scala/Predef.String# -[18:55..18:63) toString -> scala/Any#toString(). -[20:6..20:9) foo <- a/b/Givens.foo(). -[20:10..20:11) A <- a/b/Givens.foo().[A] -[20:19..20:20) A <- a/b/Givens.foo().(A) -[20:22..20:28) Monoid -> a/b/Givens.Monoid# -[20:29..20:30) A -> a/b/Givens.foo().[A] -[20:34..20:35) A -> a/b/Givens.foo().[A] -[20:38..20:39) A -> a/b/Givens.foo().(A) -[20:40..20:47) combine -> a/b/Givens.Monoid#combine(). -[20:48..20:49) A -> a/b/Givens.foo().(A) -[20:50..20:55) empty -> a/b/Givens.Monoid#empty(). -[20:57..20:58) A -> a/b/Givens.foo().(A) -[20:59..20:64) empty -> a/b/Givens.Monoid#empty(). +[8:8..9:8) <- a/b/Givens.given_sayGoodbye_of_B. +[8:10..8:11) B <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] +[8:10..8:11) B <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] +[8:13..8:16) any <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) +[8:13..8:16) any <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) +[8:18..8:19) B -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] +[8:18..8:19) B -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] +[9:8..9:18) sayGoodbye <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). +[9:38..9:41) any -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) +[9:41..9:41) -> scala/StringContext#s(). +[10:8..10:17) saySoLong <- a/b/Givens.given_sayGoodbye_of_B.saySoLong(). +[10:37..10:40) any -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) +[10:40..10:40) -> scala/StringContext#s(). +[12:6..12:12) hello1 <- a/b/Givens.hello1. +[12:15..12:15) -> a/b/Givens.given_sayHello_of_A.sayHello(). +[13:6..13:14) goodbye1 <- a/b/Givens.goodbye1. +[13:17..13:17) -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). +[14:6..14:13) soLong1 <- a/b/Givens.soLong1. +[14:16..14:16) -> a/b/Givens.given_sayGoodbye_of_B.saySoLong(). +[16:8..16:14) Monoid <- a/b/Givens.Monoid# +[16:14..16:17) <- a/b/Givens.Monoid#``(). +[16:15..16:16) A <- a/b/Givens.Monoid#[A] +[17:8..17:13) empty <- a/b/Givens.Monoid#empty(). +[17:15..17:16) A -> a/b/Givens.Monoid#[A] +[18:8..18:15) (x: A) <- a/b/Givens.Monoid#combine(). +[18:9..18:10) x <- a/b/Givens.Monoid#combine().(x) +[18:12..18:13) A -> a/b/Givens.Monoid#[A] +[18:24..18:25) y <- a/b/Givens.Monoid#combine().(y) +[18:27..18:28) A -> a/b/Givens.Monoid#[A] +[18:31..18:32) A -> a/b/Givens.Monoid#[A] +[20:8..21:4) <- a/b/Givens.given_Monoid_String. +[20:8..20:14) Monoid -> a/b/Givens.Monoid# +[20:15..20:21) String -> scala/Predef.String# +[21:8..21:13) empty <- a/b/Givens.given_Monoid_String.empty(). +[22:8..22:15) (x: Str <- a/b/Givens.given_Monoid_String.combine(). +[22:9..22:10) x <- a/b/Givens.given_Monoid_String.combine().(x) +[22:12..22:18) String -> scala/Predef.String# +[22:29..22:30) y <- a/b/Givens.given_Monoid_String.combine().(y) +[22:32..22:38) String -> scala/Predef.String# +[22:42..22:43) x -> a/b/Givens.given_Monoid_String.combine().(x) +[22:44..22:45) + -> java/lang/String#`+`(). +[22:46..22:47) y -> a/b/Givens.given_Monoid_String.combine().(y) +[24:15..24:25) int2String <- a/b/Givens.int2String(). +[24:27..24:37) Conversion -> scala/Conversion# +[24:38..24:41) Int -> scala/Int# +[24:43..24:49) String -> scala/Predef.String# +[24:55..24:63) toString -> scala/Any#toString(). +[26:6..26:9) foo <- a/b/Givens.foo(). +[26:10..26:11) A <- a/b/Givens.foo().[A] +[26:19..26:20) A <- a/b/Givens.foo().(A) +[26:22..26:28) Monoid -> a/b/Givens.Monoid# +[26:29..26:30) A -> a/b/Givens.foo().[A] +[26:34..26:35) A -> a/b/Givens.foo().[A] +[26:38..26:39) A -> a/b/Givens.foo().(A) +[26:40..26:47) combine -> a/b/Givens.Monoid#combine(). +[26:48..26:49) A -> a/b/Givens.foo().(A) +[26:50..26:55) empty -> a/b/Givens.Monoid#empty(). +[26:57..26:58) A -> a/b/Givens.foo().(A) +[26:59..26:64) empty -> a/b/Givens.Monoid#empty(). expect/ImplicitConversion.scala _______________________________ @@ -3225,4 +3251,3 @@ 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(). - From 7145d0adc5e27a8a5488dfed760cfb3ffcc5c768 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sat, 16 Nov 2019 18:06:10 +0100 Subject: [PATCH 069/107] typeref to tparam in ctor refers to class tparam instead --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 13 ++++++++++--- tests/semanticdb/expect/Annotations.expect.scala | 2 +- tests/semanticdb/expect/Enums.expect.scala | 2 +- tests/semanticdb/expect/Flags.expect.scala | 2 +- .../expect/ImplicitConversion.expect.scala | 2 +- tests/semanticdb/expect/Types.expect.scala | 2 +- tests/semanticdb/metac.expect | 15 ++++++++------- 7 files changed, 23 insertions(+), 15 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index f6ed53f5b734..193985911b25 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -407,8 +407,9 @@ class ExtractSemanticDB extends Phase { traverseChildren(tree) case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => - if !excludeDef(tree.constr.symbol) - registerDefinition(tree.constr.symbol, tree.constr.span, Set.empty) + val ctorSym = tree.constr.symbol + if !excludeDef(ctorSym) + registerDefinition(ctorSym, tree.constr.span, Set.empty) val ctorParams = tree.constr.vparamss.flatten @tu lazy val getters = findGetters(ctorParams, tree.body) for vparam <- ctorParams do @@ -418,7 +419,13 @@ class ExtractSemanticDB extends Phase { Set.empty[SymbolKind])( getter => if getter.mods.is(Mutable) then SymbolKind.SingletonVar else SymbolKind.SingletonVal) registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds) - traverse(vparam.tpt) + val tptSym = vparam.tpt.symbol + if tptSym.owner == ctorSym + val found = ctorSym.owner.info.member(tptSym.name.toTypeName).symbol + if !excludeUseStrict(found, vparam.tpt.span) && vparam.tpt.span.start != vparam.tpt.span.end + registerUse(found, vparam.tpt.span) + else + traverse(vparam.tpt) for parent <- tree.parentsOrDerived do if parent.symbol != defn.ObjectClass.primaryConstructor diff --git a/tests/semanticdb/expect/Annotations.expect.scala b/tests/semanticdb/expect/Annotations.expect.scala index 368b52236107..70685535ddc8 100644 --- a/tests/semanticdb/expect/Annotations.expect.scala +++ b/tests/semanticdb/expect/Annotations.expect.scala @@ -5,7 +5,7 @@ import scala.annotation.meta._ import scala.language/*->scalaShadowing::language.*/.experimental/*->scalaShadowing::language.experimental.*/.macros/*->scalaShadowing::language.experimental.macros.*/ @ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/ -class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#``().[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => +class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => @FieldAnnotation/*->com::javacp::annot::FieldAnnotation#*/ val field/*<-annot::Annotations#field.*/ = 42 diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index 0fc6390e2b2d..1c1e330ccb2e 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -14,7 +14,7 @@ object Enums/*<-_empty_::Enums.*/ with case Sunday/*<-_empty_::Enums.WeekDays.Sunday.*/ enum Maybe/*<-_empty_::Enums.Maybe#*/[+A/*<-_empty_::Enums.Maybe#[A]*/] with - case Just/*<-_empty_::Enums.Maybe.Just#*/(value/*<-_empty_::Enums.Maybe.Just#value.*/: A/*->_empty_::Enums.Maybe.Just#``().[A]*/) + case Just/*<-_empty_::Enums.Maybe.Just#*/(value/*<-_empty_::Enums.Maybe.Just#value.*/: A/*->_empty_::Enums.Maybe.Just#[A]*/) case None/*<-_empty_::Enums.Maybe.None.*/ enum Tag/*<-_empty_::Enums.Tag#*/[A/*<-_empty_::Enums.Tag#[A]*/] with diff --git a/tests/semanticdb/expect/Flags.expect.scala b/tests/semanticdb/expect/Flags.expect.scala index b594656fa60a..bb123fe03672 100644 --- a/tests/semanticdb/expect/Flags.expect.scala +++ b/tests/semanticdb/expect/Flags.expect.scala @@ -7,7 +7,7 @@ package object p { protected implicit var y/*<-flags::p::package.y().*/: /*<-flags::p::package.`y_=`().*/Int/*->scala::Int#*/ = 2 def z/*<-flags::p::package.z().*/(pp/*<-flags::p::package.z().(pp)*/: Int/*->scala::Int#*/) = 3 def m/*<-flags::p::package.m().*/[TT/*<-flags::p::package.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ??? - abstract class C/*<-flags::p::package.C#*/[+T/*<-flags::p::package.C#[T]*//*<-flags::p::package.C#``(+1).[T]*/, -U/*<-flags::p::package.C#[U]*//*<-flags::p::package.C#``(+1).[U]*/, V/*<-flags::p::package.C#[V]*//*<-flags::p::package.C#``(+1).[V]*/](x/*<-flags::p::package.C#x.*/: T/*->flags::p::package.C#``().[T]*/, y/*<-flags::p::package.C#y.*/: U/*->flags::p::package.C#``().[U]*/, z/*<-flags::p::package.C#z.*/: V/*->flags::p::package.C#``().[V]*/) { + abstract class C/*<-flags::p::package.C#*/[+T/*<-flags::p::package.C#[T]*//*<-flags::p::package.C#``(+1).[T]*/, -U/*<-flags::p::package.C#[U]*//*<-flags::p::package.C#``(+1).[U]*/, V/*<-flags::p::package.C#[V]*//*<-flags::p::package.C#``(+1).[V]*/](x/*<-flags::p::package.C#x.*/: T/*->flags::p::package.C#[T]*/, y/*<-flags::p::package.C#y.*/: U/*->flags::p::package.C#[U]*/, z/*<-flags::p::package.C#z.*/: V/*->flags::p::package.C#[V]*/) { def this()/*<-flags::p::package.C#``(+1).*/ = this(???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/) def w/*<-flags::p::package.C#w().*/: Int/*->scala::Int#*/ } diff --git a/tests/semanticdb/expect/ImplicitConversion.expect.scala b/tests/semanticdb/expect/ImplicitConversion.expect.scala index 5c050024066c..d46d03f4a573 100644 --- a/tests/semanticdb/expect/ImplicitConversion.expect.scala +++ b/tests/semanticdb/expect/ImplicitConversion.expect.scala @@ -31,7 +31,7 @@ class ImplicitConversion/*<-example::ImplicitConversion#*/ { } 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#*//*->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/Types.expect.scala b/tests/semanticdb/expect/Types.expect.scala index 2d65b6f009c8..5f5267258824 100644 --- a/tests/semanticdb/expect/Types.expect.scala +++ b/tests/semanticdb/expect/Types.expect.scala @@ -3,7 +3,7 @@ package types import scala.language/*->scalaShadowing::language.*/.existentials/*->scalaShadowing::language.existentials.*/ import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ -class ann/*<-types::ann#*//*->scala::annotation::Annotation#``().*/[T/*<-types::ann#[T]*/](x/*<-types::ann#x.*/: T/*->types::ann#``().[T]*/) extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class ann/*<-types::ann#*//*->scala::annotation::Annotation#``().*/[T/*<-types::ann#[T]*/](x/*<-types::ann#x.*/: T/*->types::ann#[T]*/) extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ class ann1/*<-types::ann1#*//*->scala::annotation::Annotation#``().*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ class ann2/*<-types::ann2#*//*->scala::annotation::Annotation#``().*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 0bd6f3845ec5..dea7cc15820d 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -240,7 +240,7 @@ Occurrences: [7:43..7:44) T <- annot/Annotations#[T] [7:47..7:66) ParameterAnnotation -> com/javacp/annot/ParameterAnnotation# [7:67..7:68) x <- annot/Annotations#x. -[7:70..7:71) T -> annot/Annotations#``().[T] +[7:70..7:71) T -> annot/Annotations#[T] [7:75..7:79) self <- local0 [7:81..7:87) AnyRef -> scala/AnyRef# [8:3..8:18) FieldAnnotation -> com/javacp/annot/FieldAnnotation# @@ -647,7 +647,7 @@ Occurrences: [16:9..16:13) Just <- _empty_/Enums.Maybe.Just# [16:13..16:23) <- _empty_/Enums.Maybe.Just#``(). [16:14..16:19) value <- _empty_/Enums.Maybe.Just#value. -[16:21..16:22) A -> _empty_/Enums.Maybe.Just#``().[A] +[16:21..16:22) A -> _empty_/Enums.Maybe.Just#[A] [17:4..17:4) <- local0 [17:4..17:4) -> _empty_/Enums.Maybe#``(). [17:9..17:13) None <- _empty_/Enums.Maybe.None. @@ -940,11 +940,11 @@ Occurrences: [9:27..9:28) V <- flags/p/package.C#[V] [9:27..9:28) V <- flags/p/package.C#``(+1).[V] [9:30..9:31) x <- flags/p/package.C#x. -[9:33..9:34) T -> flags/p/package.C#``().[T] +[9:33..9:34) T -> flags/p/package.C#[T] [9:36..9:37) y <- flags/p/package.C#y. -[9:39..9:40) U -> flags/p/package.C#``().[U] +[9:39..9:40) U -> flags/p/package.C#[U] [9:42..9:43) z <- flags/p/package.C#z. -[9:45..9:46) V -> flags/p/package.C#``().[V] +[9:45..9:46) V -> flags/p/package.C#[V] [10:8..10:14) <- flags/p/package.C#``(+1). [10:22..10:22) -> flags/p/package.C#``(). [10:22..10:25) ??? -> scala/Predef.`???`(). @@ -1271,7 +1271,7 @@ Occurrences: [33:39..33:63) <- example/ImplicitConversion.newAny2stringadd#``(). [33:40..33:41) A <- example/ImplicitConversion.newAny2stringadd#[A] [33:55..33:59) self <- example/ImplicitConversion.newAny2stringadd#self. -[33:61..33:62) A -> example/ImplicitConversion.newAny2stringadd#``().[A] +[33: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#`+`(). @@ -2579,7 +2579,7 @@ Occurrences: [5:9..5:18) <- types/ann#``(). [5:10..5:11) T <- types/ann#[T] [5:13..5:14) x <- types/ann#x. -[5:16..5:17) T -> types/ann#``().[T] +[5:16..5:17) T -> types/ann#[T] [5:27..5:32) scala -> scala/ [5:33..5:43) annotation -> scala/annotation/ [5:44..5:60) StaticAnnotation -> scala/annotation/StaticAnnotation# @@ -3251,3 +3251,4 @@ 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(). + From 6f7fbe64fd4646a6226a1e28449d04f7736f21f7 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sat, 16 Nov 2019 19:25:04 +0100 Subject: [PATCH 070/107] do not taverse synthetic import in enum --- .../dotc/semanticdb/ExtractSemanticDB.scala | 32 +- .../dotc/semanticdb/SemanticdbTests.scala | 2 +- tests/semanticdb/expect/Enums.expect.scala | 13 +- tests/semanticdb/expect/Enums.scala | 11 + tests/semanticdb/metac.expect | 367 ++++++++++-------- 5 files changed, 262 insertions(+), 163 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 193985911b25..e57531c1b6d9 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -18,7 +18,7 @@ import collection.mutable import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} import java.nio.file.Paths -import scala.annotation.{ threadUnsafe => tu } +import scala.annotation.{ threadUnsafe => tu, tailrec } /** Extract symbol references and uses to semanticdb files. * See https://scalameta.org/docs/semanticdb/specification.html#symbol-1 @@ -358,6 +358,19 @@ class ExtractSemanticDB extends Phase { else limit Span(start max limit, end) + def (span: Span) hasLength: Boolean = span.start != span.end + + /**Consume head while not an import statement. + * Returns the rest of the list after the first import, or else the empty list + */ + @tailrec + private def (body: List[Tree]) foreachUntilImport(op: Tree => Unit): List[Tree] = body match + case ((_: Import) :: rest) => rest + case stat :: rest => + op(stat) + rest.foreachUntilImport(op) + case Nil => Nil + override def traverse(tree: Tree)(given Context): Unit = for annot <- tree.symbol.annotations do if annot.tree.span.exists @@ -367,7 +380,7 @@ class ExtractSemanticDB extends Phase { tree match case tree: PackageDef => - if !excludeDef(tree.pid.symbol) && tree.pid.span.start != tree.pid.span.end + if !excludeDef(tree.pid.symbol) && tree.pid.span.hasLength tree.pid match case tree @ Select(qual, _) => traverse(qual) @@ -377,7 +390,7 @@ class ExtractSemanticDB extends Phase { tree.stats.foreach(traverse) case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree - if !excludeDef(tree.symbol) && tree.span.start != tree.span.end => + if !excludeDef(tree.symbol) && tree.span.hasLength => val symkinds = if tree.symbol.isSelfSym Set.empty @@ -422,7 +435,7 @@ class ExtractSemanticDB extends Phase { val tptSym = vparam.tpt.symbol if tptSym.owner == ctorSym val found = ctorSym.owner.info.member(tptSym.name.toTypeName).symbol - if !excludeUseStrict(found, vparam.tpt.span) && vparam.tpt.span.start != vparam.tpt.span.end + if !excludeUseStrict(found, vparam.tpt.span) && vparam.tpt.span.hasLength registerUse(found, vparam.tpt.span) else traverse(vparam.tpt) @@ -434,9 +447,12 @@ class ExtractSemanticDB extends Phase { then traverse(parent) val selfSpan = tree.self.span - if selfSpan.exists && selfSpan.start != selfSpan.end then + if selfSpan.exists && selfSpan.hasLength then traverse(tree.self) - tree.body.foreach(traverse) + if ctorSym.owner.is(Enum, butNot=Case) + tree.body.foreachUntilImport(traverse).foreach(traverse) + else + tree.body.foreach(traverse) case tree: Assign => traverseChildren(tree.lhs) if !excludeUseStrict(tree.lhs.symbol, tree.lhs.span) @@ -459,10 +475,10 @@ class ExtractSemanticDB extends Phase { val qualSpan = tree.qualifier.span if !excludeUseStrict(tree.symbol, tree.span) then registerUse(tree.symbol, adjustSpanToName(tree.span, qualSpan, tree.name)) - if qualSpan.exists && qualSpan.start != qualSpan.end then + if qualSpan.exists && qualSpan.hasLength then traverseChildren(tree) case tree: Import => - if tree.span.exists && tree.span.start != tree.span.end then + if tree.span.exists && tree.span.hasLength then for sel <- tree.selectors do val imported = sel.imported.name if imported != nme.WILDCARD then diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 06c09856e158..1f6e1545eadb 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -94,7 +94,7 @@ class SemanticdbTests with "-d", target.toString, "-feature", "-deprecation", - // "-Ydebug", + // "-Ydebug-flags", // "-Xprint:extractSemanticDB", "-sourceroot", expectSrc.toString, "-usejavacp", diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index 1c1e330ccb2e..0af592796964 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -2,7 +2,11 @@ object Enums/*<-_empty_::Enums.*/ with import =:=/*->_empty_::Enums.`=:=`.*/._ enum Colour/*<-_empty_::Enums.Colour#*/ with - case Red/*->_empty_::Enums.Colour.Red.*//*->scala::runtime::EnumValues#``().*//*<-_empty_::Enums.Colour.Red.*/, Green/*->_empty_::Enums.Colour.Green.*//*<-_empty_::Enums.Colour.Green.*/, Blue/*->_empty_::Enums.Colour.Blue.*//*<-_empty_::Enums.Colour.Blue.*/ + import Colour/*->_empty_::Enums.Colour.*/.Red/*->_empty_::Enums.Colour.Red.*/ + case /*->scala::runtime::EnumValues#``().*/Red/*<-_empty_::Enums.Colour.Red.*/, Green/*<-_empty_::Enums.Colour.Green.*/, Blue/*<-_empty_::Enums.Colour.Blue.*/ + + enum Directions/*<-_empty_::Enums.Directions#*/ with + case /*->scala::runtime::EnumValues#``().*/North/*<-_empty_::Enums.Directions.North.*/, East/*<-_empty_::Enums.Directions.East.*/, South/*<-_empty_::Enums.Directions.South.*/, West/*<-_empty_::Enums.Directions.West.*/ enum WeekDays/*<-_empty_::Enums.WeekDays#*/ with /*->scala::runtime::EnumValues#``().*/case Monday/*<-_empty_::Enums.WeekDays.Monday.*/ @@ -13,6 +17,13 @@ object Enums/*<-_empty_::Enums.*/ with case Saturday/*<-_empty_::Enums.WeekDays.Saturday.*/ case Sunday/*<-_empty_::Enums.WeekDays.Sunday.*/ + enum Coin/*<-_empty_::Enums.Coin#*/(value/*<-_empty_::Enums.Coin#value.*/: Int/*->scala::Int#*/) with + case Penny/*<-_empty_::Enums.Coin.Penny.*/ extends /*->scala::runtime::EnumValues#``().*/Coin/*->_empty_::Enums.Coin#*/(1)/*->scala::runtime::EnumValues#register().*/ + case Nickel/*<-_empty_::Enums.Coin.Nickel.*/ extends Coin/*->_empty_::Enums.Coin#*/(5)/*->scala::runtime::EnumValues#register().*/ + case Dime/*<-_empty_::Enums.Coin.Dime.*/ extends Coin/*->_empty_::Enums.Coin#*/(10)/*->scala::runtime::EnumValues#register().*/ + case Quarter/*<-_empty_::Enums.Coin.Quarter.*/ extends Coin/*->_empty_::Enums.Coin#*/(25)/*->scala::runtime::EnumValues#register().*/ + case Dollar/*<-_empty_::Enums.Coin.Dollar.*/ extends Coin/*->_empty_::Enums.Coin#*/(100)/*->scala::runtime::EnumValues#register().*/ + enum Maybe/*<-_empty_::Enums.Maybe#*/[+A/*<-_empty_::Enums.Maybe#[A]*/] with case Just/*<-_empty_::Enums.Maybe.Just#*/(value/*<-_empty_::Enums.Maybe.Just#value.*/: A/*->_empty_::Enums.Maybe.Just#[A]*/) case None/*<-_empty_::Enums.Maybe.None.*/ diff --git a/tests/semanticdb/expect/Enums.scala b/tests/semanticdb/expect/Enums.scala index 4856cb3a8c4c..dd4b5689e74f 100644 --- a/tests/semanticdb/expect/Enums.scala +++ b/tests/semanticdb/expect/Enums.scala @@ -2,8 +2,12 @@ object Enums with import =:=._ enum Colour with + import Colour.Red case Red, Green, Blue + enum Directions with + case North, East, South, West + enum WeekDays with case Monday case Tuesday @@ -13,6 +17,13 @@ object Enums with case Saturday case Sunday + enum Coin(value: Int) with + case Penny extends Coin(1) + case Nickel extends Coin(5) + case Dime extends Coin(10) + case Quarter extends Coin(25) + case Dollar extends Coin(100) + enum Maybe[+A] with case Just(value: A) case None diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index dea7cc15820d..c549db5a454c 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -544,16 +544,31 @@ Schema => SemanticDB v4 Uri => Enums.scala Text => empty Language => Scala -Symbols => 69 entries -Occurrences => 155 entries +Symbols => 89 entries +Occurrences => 196 entries Symbols: _empty_/Enums. => final object Enums +_empty_/Enums.Coin# => abstract sealed enum class Coin +_empty_/Enums.Coin#``(). => primary ctor +_empty_/Enums.Coin#``().(value) => param value +_empty_/Enums.Coin#value. => val method value +_empty_/Enums.Coin.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.Colour# => abstract sealed enum class Colour _empty_/Enums.Colour#``(). => primary ctor _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.Directions# => abstract sealed enum class Directions +_empty_/Enums.Directions#``(). => primary ctor +_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.Maybe# => abstract sealed enum class Maybe _empty_/Enums.Maybe#[A] => covariant typeparam A _empty_/Enums.Maybe#``(). => primary ctor @@ -617,163 +632,209 @@ local7 => primary ctor local8 => primary ctor local9 => primary ctor local10 => primary ctor +local11 => primary ctor +local12 => primary ctor +local13 => primary ctor +local14 => primary ctor +local15 => primary ctor 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:9..4:12) Red -> _empty_/Enums.Colour.Red. -[4:9..4:9) -> scala/runtime/EnumValues#``(). -[4:9..4:12) Red <- _empty_/Enums.Colour.Red. -[4:14..4:19) Green -> _empty_/Enums.Colour.Green. -[4:14..4:19) Green <- _empty_/Enums.Colour.Green. -[4:21..4:25) Blue -> _empty_/Enums.Colour.Blue. -[4:21..4:25) Blue <- _empty_/Enums.Colour.Blue. -[6:7..6:15) WeekDays <- _empty_/Enums.WeekDays# -[7:4..7:4) <- _empty_/Enums.WeekDays#``(). -[7:4..7:4) -> scala/runtime/EnumValues#``(). -[7:9..7:15) Monday <- _empty_/Enums.WeekDays.Monday. -[8:9..8:16) Tuesday <- _empty_/Enums.WeekDays.Tuesday. -[9:9..9:18) Wednesday <- _empty_/Enums.WeekDays.Wednesday. -[10:9..10:17) Thursday <- _empty_/Enums.WeekDays.Thursday. -[11:9..11:15) Friday <- _empty_/Enums.WeekDays.Friday. -[12:9..12:17) Saturday <- _empty_/Enums.WeekDays.Saturday. -[13:9..13:15) Sunday <- _empty_/Enums.WeekDays.Sunday. -[15:7..15:12) Maybe <- _empty_/Enums.Maybe# -[15:12..15:16) <- _empty_/Enums.Maybe#``(). -[15:14..15:15) A <- _empty_/Enums.Maybe#[A] -[16:4..16:4) -> _empty_/Enums.Maybe#``(). -[16:9..16:13) Just <- _empty_/Enums.Maybe.Just# -[16:13..16:23) <- _empty_/Enums.Maybe.Just#``(). -[16:14..16:19) value <- _empty_/Enums.Maybe.Just#value. -[16:21..16:22) A -> _empty_/Enums.Maybe.Just#[A] -[17:4..17:4) <- local0 -[17:4..17:4) -> _empty_/Enums.Maybe#``(). -[17:9..17:13) None <- _empty_/Enums.Maybe.None. -[17:13..17:13) -> local0 -[19:7..19:10) Tag <- _empty_/Enums.Tag# -[19:10..19:13) <- _empty_/Enums.Tag#``(). -[19:11..19:12) A <- _empty_/Enums.Tag#[A] -[20:9..20:15) IntTag <- _empty_/Enums.Tag.IntTag. -[20:24..20:24) <- local1 -[20:24..20:27) Tag -> _empty_/Enums.Tag# -[20:28..20:31) Int -> scala/Int# -[20:32..20:32) -> _empty_/Enums.Tag#``(). -[20:32..20:32) -> local1 -[21:9..21:19) BooleanTag <- _empty_/Enums.Tag.BooleanTag. -[21:28..21:28) <- local2 -[21:28..21:31) Tag -> _empty_/Enums.Tag# -[21:32..21:39) Boolean -> scala/Boolean# -[21:40..21:40) -> _empty_/Enums.Tag#``(). -[21:40..21:40) -> local2 -[23:7..23:10) =:= <- _empty_/Enums.`=:=`# -[23:10..23:16) <- _empty_/Enums.`=:=`#``(). -[23:11..23:12) A <- _empty_/Enums.`=:=`#[A] -[23:14..23:15) B <- _empty_/Enums.`=:=`#[B] -[24:9..24:13) Refl <- _empty_/Enums.`=:=`.Refl# -[24:13..24:18) <- _empty_/Enums.`=:=`.Refl#``(). -[24:14..24:15) C <- _empty_/Enums.`=:=`.Refl#[C] -[24:28..24:29) C -> _empty_/Enums.`=:=`.Refl#[C] -[24:30..24:33) =:= -> _empty_/Enums.`=:=`# -[24:34..24:35) C -> _empty_/Enums.`=:=`.Refl#[C] -[24:35..24:35) -> _empty_/Enums.`=:=`#``(). -[26:6..26:12) unwrap <- _empty_/Enums.unwrap(). -[26:13..26:14) A <- _empty_/Enums.unwrap().[A] -[26:15..26:16) B <- _empty_/Enums.unwrap().[B] -[26:18..26:21) opt <- _empty_/Enums.unwrap().(opt) -[26:23..26:29) Option -> scala/Option# -[26:30..26:31) A -> _empty_/Enums.unwrap().[A] -[26:40..26:42) ev <- _empty_/Enums.unwrap().(ev) -[26:44..26:45) A -> _empty_/Enums.unwrap().[A] -[26:46..26:49) =:= -> _empty_/Enums.`=:=`# -[26:50..26:56) Option -> scala/Option# -[26:57..26:58) B -> _empty_/Enums.unwrap().[B] -[26:62..26:68) Option -> scala/Option# -[26:69..26:70) B -> _empty_/Enums.unwrap().[B] -[26:74..26:76) ev -> _empty_/Enums.unwrap().(ev) -[27:9..27:13) Refl -> _empty_/Enums.`=:=`.Refl. -[27:19..27:22) opt -> _empty_/Enums.unwrap().(opt) -[27:23..27:30) flatMap -> scala/Option#flatMap(). -[27:31..27:39) identity -> scala/Predef.identity(). -[27:40..27:46) Option -> scala/Option# -[27:47..27:48) B -> _empty_/Enums.unwrap().[B] -[28:19..28:23) None -> scala/None. -[30:7..30:13) Planet <- _empty_/Enums.Planet# -[30:13..30:43) <- _empty_/Enums.Planet#``(). -[30:14..30:18) mass <- _empty_/Enums.Planet#mass. -[30:20..30:26) Double -> scala/Double# -[30:28..30:34) radius <- _empty_/Enums.Planet#radius. -[30:36..30:42) Double -> scala/Double# -[30:52..30:56) java -> java/ -[30:57..30:61) lang -> java/lang/ -[30:62..30:66) Enum -> java/lang/Enum# -[30:67..30:73) Planet -> _empty_/Enums.Planet# -[30:74..30:74) -> java/lang/Enum#``(). -[31:22..31:23) G <- _empty_/Enums.Planet#G. -[32:8..32:22) surfaceGravity <- _empty_/Enums.Planet#surfaceGravity(). -[32:25..32:26) G -> _empty_/Enums.Planet#G. -[32:27..32:28) * -> scala/Double#`*`(+6). -[32:29..32:33) mass -> _empty_/Enums.Planet#mass. -[32:34..32:35) / -> scala/Double#`/`(+6). -[32:37..32:43) radius -> _empty_/Enums.Planet#radius. -[32:44..32:45) * -> scala/Double#`*`(+6). -[32:46..32:52) radius -> _empty_/Enums.Planet#radius. -[33:8..33:21) surfaceWeight <- _empty_/Enums.Planet#surfaceWeight(). -[33:22..33:31) otherMass <- _empty_/Enums.Planet#surfaceWeight().(otherMass) -[33:33..33:39) Double -> scala/Double# -[33:43..33:52) otherMass -> _empty_/Enums.Planet#surfaceWeight().(otherMass) -[33:53..33:54) * -> scala/Double#`*`(+6). -[33:55..33:69) surfaceGravity -> _empty_/Enums.Planet#surfaceGravity(). -[35:9..35:16) Mercury <- _empty_/Enums.Planet.Mercury. -[35:25..35:25) -> scala/runtime/EnumValues#``(). -[35:25..35:25) <- local3 -[35:25..35:31) Planet -> _empty_/Enums.Planet# -[35:31..35:31) -> _empty_/Enums.Planet#``(). -[35:52..35:52) -> scala/runtime/EnumValues#register(). -[35:52..35:52) -> local3 -[36:9..36:14) Venus <- _empty_/Enums.Planet.Venus. -[36:25..36:25) <- local4 -[36:25..36:31) Planet -> _empty_/Enums.Planet# -[36:31..36:31) -> _empty_/Enums.Planet#``(). -[36:52..36:52) -> scala/runtime/EnumValues#register(). -[36:52..36:52) -> local4 -[37:9..37:14) Earth <- _empty_/Enums.Planet.Earth. -[37:25..37:25) <- local5 -[37:25..37:31) Planet -> _empty_/Enums.Planet# -[37:31..37:31) -> _empty_/Enums.Planet#``(). -[37:53..37:53) -> scala/runtime/EnumValues#register(). -[37:53..37:53) -> local5 -[38:9..38:13) Mars <- _empty_/Enums.Planet.Mars. -[38:25..38:25) <- local6 -[38:25..38:31) Planet -> _empty_/Enums.Planet# -[38:31..38:31) -> _empty_/Enums.Planet#``(). -[38:52..38:52) -> scala/runtime/EnumValues#register(). -[38:52..38:52) -> local6 -[39:9..39:16) Jupiter <- _empty_/Enums.Planet.Jupiter. -[39:25..39:25) <- local7 -[39:25..39:31) Planet -> _empty_/Enums.Planet# -[39:31..39:31) -> _empty_/Enums.Planet#``(). -[39:52..39:52) -> scala/runtime/EnumValues#register(). -[39:52..39:52) -> local7 -[40:9..40:15) Saturn <- _empty_/Enums.Planet.Saturn. -[40:25..40:25) <- local8 -[40:25..40:31) Planet -> _empty_/Enums.Planet# -[40:31..40:31) -> _empty_/Enums.Planet#``(). -[40:52..40:52) -> scala/runtime/EnumValues#register(). -[40:52..40:52) -> local8 -[41:9..41:15) Uranus <- _empty_/Enums.Planet.Uranus. -[41:25..41:25) <- local9 -[41:25..41:31) Planet -> _empty_/Enums.Planet# -[41:31..41:31) -> _empty_/Enums.Planet#``(). -[41:52..41:52) -> scala/runtime/EnumValues#register(). -[41:52..41:52) -> local9 -[42:9..42:16) Neptune <- _empty_/Enums.Planet.Neptune. -[42:25..42:25) <- local10 -[42:25..42:31) Planet -> _empty_/Enums.Planet# -[42:31..42:31) -> _empty_/Enums.Planet#``(). -[42:52..42:52) -> scala/runtime/EnumValues#register(). -[42:52..42:52) -> local10 +[4:11..4:17) Colour -> _empty_/Enums.Colour. +[4:18..4:21) Red -> _empty_/Enums.Colour.Red. +[5:9..5:9) -> scala/runtime/EnumValues#``(). +[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:9) -> scala/runtime/EnumValues#``(). +[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:15) WeekDays <- _empty_/Enums.WeekDays# +[11:4..11:4) <- _empty_/Enums.WeekDays#``(). +[11:4..11:4) -> scala/runtime/EnumValues#``(). +[11:9..11:15) Monday <- _empty_/Enums.WeekDays.Monday. +[12:9..12:16) Tuesday <- _empty_/Enums.WeekDays.Tuesday. +[13:9..13:18) Wednesday <- _empty_/Enums.WeekDays.Wednesday. +[14:9..14:17) Thursday <- _empty_/Enums.WeekDays.Thursday. +[15:9..15:15) Friday <- _empty_/Enums.WeekDays.Friday. +[16:9..16:17) Saturday <- _empty_/Enums.WeekDays.Saturday. +[17:9..17:15) Sunday <- _empty_/Enums.WeekDays.Sunday. +[19:7..19:11) Coin <- _empty_/Enums.Coin# +[19:11..19:23) <- _empty_/Enums.Coin#``(). +[19:12..19:17) value <- _empty_/Enums.Coin#value. +[19:19..19:22) Int -> scala/Int# +[20:9..20:14) Penny <- _empty_/Enums.Coin.Penny. +[20:26..20:26) -> scala/runtime/EnumValues#``(). +[20:26..20:26) <- local0 +[20:26..20:30) Coin -> _empty_/Enums.Coin# +[20:30..20:30) -> _empty_/Enums.Coin#``(). +[20:33..20:33) -> scala/runtime/EnumValues#register(). +[20:33..20:33) -> local0 +[21:9..21:15) Nickel <- _empty_/Enums.Coin.Nickel. +[21:26..21:26) <- local1 +[21:26..21:30) Coin -> _empty_/Enums.Coin# +[21:30..21:30) -> _empty_/Enums.Coin#``(). +[21:33..21:33) -> scala/runtime/EnumValues#register(). +[21:33..21:33) -> local1 +[22:9..22:13) Dime <- _empty_/Enums.Coin.Dime. +[22:26..22:26) <- local2 +[22:26..22:30) Coin -> _empty_/Enums.Coin# +[22:30..22:30) -> _empty_/Enums.Coin#``(). +[22:34..22:34) -> scala/runtime/EnumValues#register(). +[22:34..22:34) -> local2 +[23:9..23:16) Quarter <- _empty_/Enums.Coin.Quarter. +[23:26..23:26) <- local3 +[23:26..23:30) Coin -> _empty_/Enums.Coin# +[23:30..23:30) -> _empty_/Enums.Coin#``(). +[23:34..23:34) -> scala/runtime/EnumValues#register(). +[23:34..23:34) -> local3 +[24:9..24:15) Dollar <- _empty_/Enums.Coin.Dollar. +[24:26..24:26) <- local4 +[24:26..24:30) Coin -> _empty_/Enums.Coin# +[24:30..24:30) -> _empty_/Enums.Coin#``(). +[24:35..24:35) -> scala/runtime/EnumValues#register(). +[24:35..24:35) -> local4 +[26:7..26:12) Maybe <- _empty_/Enums.Maybe# +[26:12..26:16) <- _empty_/Enums.Maybe#``(). +[26:14..26:15) A <- _empty_/Enums.Maybe#[A] +[27:4..27:4) -> _empty_/Enums.Maybe#``(). +[27:9..27:13) Just <- _empty_/Enums.Maybe.Just# +[27:13..27:23) <- _empty_/Enums.Maybe.Just#``(). +[27:14..27:19) value <- _empty_/Enums.Maybe.Just#value. +[27:21..27:22) A -> _empty_/Enums.Maybe.Just#[A] +[28:4..28:4) <- local5 +[28:4..28:4) -> _empty_/Enums.Maybe#``(). +[28:9..28:13) None <- _empty_/Enums.Maybe.None. +[28:13..28:13) -> local5 +[30:7..30:10) Tag <- _empty_/Enums.Tag# +[30:10..30:13) <- _empty_/Enums.Tag#``(). +[30:11..30:12) A <- _empty_/Enums.Tag#[A] +[31:9..31:15) IntTag <- _empty_/Enums.Tag.IntTag. +[31:24..31:24) <- local6 +[31:24..31:27) Tag -> _empty_/Enums.Tag# +[31:28..31:31) Int -> scala/Int# +[31:32..31:32) -> _empty_/Enums.Tag#``(). +[31:32..31:32) -> local6 +[32:9..32:19) BooleanTag <- _empty_/Enums.Tag.BooleanTag. +[32:28..32:28) <- local7 +[32:28..32:31) Tag -> _empty_/Enums.Tag# +[32:32..32:39) Boolean -> scala/Boolean# +[32:40..32:40) -> _empty_/Enums.Tag#``(). +[32:40..32:40) -> local7 +[34:7..34:10) =:= <- _empty_/Enums.`=:=`# +[34:10..34:16) <- _empty_/Enums.`=:=`#``(). +[34:11..34:12) A <- _empty_/Enums.`=:=`#[A] +[34:14..34:15) B <- _empty_/Enums.`=:=`#[B] +[35:9..35:13) Refl <- _empty_/Enums.`=:=`.Refl# +[35:13..35:18) <- _empty_/Enums.`=:=`.Refl#``(). +[35:14..35:15) C <- _empty_/Enums.`=:=`.Refl#[C] +[35:28..35:29) C -> _empty_/Enums.`=:=`.Refl#[C] +[35:30..35:33) =:= -> _empty_/Enums.`=:=`# +[35:34..35:35) C -> _empty_/Enums.`=:=`.Refl#[C] +[35:35..35:35) -> _empty_/Enums.`=:=`#``(). +[37:6..37:12) unwrap <- _empty_/Enums.unwrap(). +[37:13..37:14) A <- _empty_/Enums.unwrap().[A] +[37:15..37:16) B <- _empty_/Enums.unwrap().[B] +[37:18..37:21) opt <- _empty_/Enums.unwrap().(opt) +[37:23..37:29) Option -> scala/Option# +[37:30..37:31) A -> _empty_/Enums.unwrap().[A] +[37:40..37:42) ev <- _empty_/Enums.unwrap().(ev) +[37:44..37:45) A -> _empty_/Enums.unwrap().[A] +[37:46..37:49) =:= -> _empty_/Enums.`=:=`# +[37:50..37:56) Option -> scala/Option# +[37:57..37:58) B -> _empty_/Enums.unwrap().[B] +[37:62..37:68) Option -> scala/Option# +[37:69..37:70) B -> _empty_/Enums.unwrap().[B] +[37:74..37:76) ev -> _empty_/Enums.unwrap().(ev) +[38:9..38:13) Refl -> _empty_/Enums.`=:=`.Refl. +[38:19..38:22) opt -> _empty_/Enums.unwrap().(opt) +[38:23..38:30) flatMap -> scala/Option#flatMap(). +[38:31..38:39) identity -> scala/Predef.identity(). +[38:40..38:46) Option -> scala/Option# +[38:47..38:48) B -> _empty_/Enums.unwrap().[B] +[39:19..39:23) None -> scala/None. +[41:7..41:13) Planet <- _empty_/Enums.Planet# +[41:13..41:43) <- _empty_/Enums.Planet#``(). +[41:14..41:18) mass <- _empty_/Enums.Planet#mass. +[41:20..41:26) Double -> scala/Double# +[41:28..41:34) radius <- _empty_/Enums.Planet#radius. +[41:36..41:42) Double -> scala/Double# +[41:52..41:56) java -> java/ +[41:57..41:61) lang -> java/lang/ +[41:62..41:66) Enum -> java/lang/Enum# +[41:67..41:73) Planet -> _empty_/Enums.Planet# +[41:74..41:74) -> java/lang/Enum#``(). +[42:22..42:23) G <- _empty_/Enums.Planet#G. +[43:8..43:22) surfaceGravity <- _empty_/Enums.Planet#surfaceGravity(). +[43:25..43:26) G -> _empty_/Enums.Planet#G. +[43:27..43:28) * -> scala/Double#`*`(+6). +[43:29..43:33) mass -> _empty_/Enums.Planet#mass. +[43:34..43:35) / -> scala/Double#`/`(+6). +[43:37..43:43) radius -> _empty_/Enums.Planet#radius. +[43:44..43:45) * -> scala/Double#`*`(+6). +[43:46..43:52) radius -> _empty_/Enums.Planet#radius. +[44:8..44:21) surfaceWeight <- _empty_/Enums.Planet#surfaceWeight(). +[44:22..44:31) otherMass <- _empty_/Enums.Planet#surfaceWeight().(otherMass) +[44:33..44:39) Double -> scala/Double# +[44:43..44:52) otherMass -> _empty_/Enums.Planet#surfaceWeight().(otherMass) +[44:53..44:54) * -> scala/Double#`*`(+6). +[44:55..44:69) surfaceGravity -> _empty_/Enums.Planet#surfaceGravity(). +[46:9..46:16) Mercury <- _empty_/Enums.Planet.Mercury. +[46:25..46:25) -> scala/runtime/EnumValues#``(). +[46:25..46:25) <- local8 +[46:25..46:31) Planet -> _empty_/Enums.Planet# +[46:31..46:31) -> _empty_/Enums.Planet#``(). +[46:52..46:52) -> scala/runtime/EnumValues#register(). +[46:52..46:52) -> local8 +[47:9..47:14) Venus <- _empty_/Enums.Planet.Venus. +[47:25..47:25) <- local9 +[47:25..47:31) Planet -> _empty_/Enums.Planet# +[47:31..47:31) -> _empty_/Enums.Planet#``(). +[47:52..47:52) -> scala/runtime/EnumValues#register(). +[47:52..47:52) -> local9 +[48:9..48:14) Earth <- _empty_/Enums.Planet.Earth. +[48:25..48:25) <- local10 +[48:25..48:31) Planet -> _empty_/Enums.Planet# +[48:31..48:31) -> _empty_/Enums.Planet#``(). +[48:53..48:53) -> scala/runtime/EnumValues#register(). +[48:53..48:53) -> local10 +[49:9..49:13) Mars <- _empty_/Enums.Planet.Mars. +[49:25..49:25) <- local11 +[49:25..49:31) Planet -> _empty_/Enums.Planet# +[49:31..49:31) -> _empty_/Enums.Planet#``(). +[49:52..49:52) -> scala/runtime/EnumValues#register(). +[49:52..49:52) -> local11 +[50:9..50:16) Jupiter <- _empty_/Enums.Planet.Jupiter. +[50:25..50:25) <- local12 +[50:25..50:31) Planet -> _empty_/Enums.Planet# +[50:31..50:31) -> _empty_/Enums.Planet#``(). +[50:52..50:52) -> scala/runtime/EnumValues#register(). +[50:52..50:52) -> local12 +[51:9..51:15) Saturn <- _empty_/Enums.Planet.Saturn. +[51:25..51:25) <- local13 +[51:25..51:31) Planet -> _empty_/Enums.Planet# +[51:31..51:31) -> _empty_/Enums.Planet#``(). +[51:52..51:52) -> scala/runtime/EnumValues#register(). +[51:52..51:52) -> local13 +[52:9..52:15) Uranus <- _empty_/Enums.Planet.Uranus. +[52:25..52:25) <- local14 +[52:25..52:31) Planet -> _empty_/Enums.Planet# +[52:31..52:31) -> _empty_/Enums.Planet#``(). +[52:52..52:52) -> scala/runtime/EnumValues#register(). +[52:52..52:52) -> local14 +[53:9..53:16) Neptune <- _empty_/Enums.Planet.Neptune. +[53:25..53:25) <- local15 +[53:25..53:31) Planet -> _empty_/Enums.Planet# +[53:31..53:31) -> _empty_/Enums.Planet#``(). +[53:52..53:52) -> scala/runtime/EnumValues#register(). +[53:52..53:52) -> local15 expect/EtaExpansion.scala _________________________ From e8e30a6e35cc7eb74021b1f12f7c3cfe0ee30bf4 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sat, 16 Nov 2019 20:27:09 +0100 Subject: [PATCH 071/107] Filter in enums and enumValues.register --- .../dotc/semanticdb/ExtractSemanticDB.scala | 16 ++++- tests/semanticdb/expect/Enums.expect.scala | 32 ++++----- tests/semanticdb/metac.expect | 70 +------------------ 3 files changed, 33 insertions(+), 85 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index e57531c1b6d9..2a4f9ad0c263 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -417,7 +417,13 @@ class ExtractSemanticDB extends Phase { val privateWithin = tree.symbol.privateWithin if privateWithin `ne` NoSymbol registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) - traverseChildren(tree) + tree match + case tree: ValDef if tree.symbol.isAllOf(EnumValue) => + tree.rhs match + case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause + template.parents.foreach(traverse) + case _ => // calls $new + case _ => traverseChildren(tree) case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => val ctorSym = tree.constr.symbol @@ -451,6 +457,14 @@ class ExtractSemanticDB extends Phase { traverse(tree.self) if ctorSym.owner.is(Enum, butNot=Case) tree.body.foreachUntilImport(traverse).foreach(traverse) + else if ctorSym.owner.is(ModuleClass) && ctorSym.owner.companionClass.is(Enum, butNot=Case) + // TODO: Remove this branch if $values is removed or made synthetic + tree.body.filter({ + case tree @ ValDef(nme.DOLLAR_VALUES,_,_) + if tree.mods.flags.is(Private) + && tree.symbol.info.typeSymbol == defn.EnumValuesClass => false + case _ => true + }).foreach(traverse) else tree.body.foreach(traverse) case tree: Assign => diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index 0af592796964..084dae22d6a4 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -3,13 +3,13 @@ object Enums/*<-_empty_::Enums.*/ with enum Colour/*<-_empty_::Enums.Colour#*/ with import Colour/*->_empty_::Enums.Colour.*/.Red/*->_empty_::Enums.Colour.Red.*/ - case /*->scala::runtime::EnumValues#``().*/Red/*<-_empty_::Enums.Colour.Red.*/, Green/*<-_empty_::Enums.Colour.Green.*/, Blue/*<-_empty_::Enums.Colour.Blue.*/ + case Red/*<-_empty_::Enums.Colour.Red.*/, Green/*<-_empty_::Enums.Colour.Green.*/, Blue/*<-_empty_::Enums.Colour.Blue.*/ enum Directions/*<-_empty_::Enums.Directions#*/ with - case /*->scala::runtime::EnumValues#``().*/North/*<-_empty_::Enums.Directions.North.*/, East/*<-_empty_::Enums.Directions.East.*/, South/*<-_empty_::Enums.Directions.South.*/, West/*<-_empty_::Enums.Directions.West.*/ + case North/*<-_empty_::Enums.Directions.North.*/, East/*<-_empty_::Enums.Directions.East.*/, South/*<-_empty_::Enums.Directions.South.*/, West/*<-_empty_::Enums.Directions.West.*/ enum WeekDays/*<-_empty_::Enums.WeekDays#*/ with - /*->scala::runtime::EnumValues#``().*/case Monday/*<-_empty_::Enums.WeekDays.Monday.*/ + case Monday/*<-_empty_::Enums.WeekDays.Monday.*/ case Tuesday/*<-_empty_::Enums.WeekDays.Tuesday.*/ case Wednesday/*<-_empty_::Enums.WeekDays.Wednesday.*/ case Thursday/*<-_empty_::Enums.WeekDays.Thursday.*/ @@ -18,11 +18,11 @@ object Enums/*<-_empty_::Enums.*/ with case Sunday/*<-_empty_::Enums.WeekDays.Sunday.*/ enum Coin/*<-_empty_::Enums.Coin#*/(value/*<-_empty_::Enums.Coin#value.*/: Int/*->scala::Int#*/) with - case Penny/*<-_empty_::Enums.Coin.Penny.*/ extends /*->scala::runtime::EnumValues#``().*/Coin/*->_empty_::Enums.Coin#*/(1)/*->scala::runtime::EnumValues#register().*/ - case Nickel/*<-_empty_::Enums.Coin.Nickel.*/ extends Coin/*->_empty_::Enums.Coin#*/(5)/*->scala::runtime::EnumValues#register().*/ - case Dime/*<-_empty_::Enums.Coin.Dime.*/ extends Coin/*->_empty_::Enums.Coin#*/(10)/*->scala::runtime::EnumValues#register().*/ - case Quarter/*<-_empty_::Enums.Coin.Quarter.*/ extends Coin/*->_empty_::Enums.Coin#*/(25)/*->scala::runtime::EnumValues#register().*/ - case Dollar/*<-_empty_::Enums.Coin.Dollar.*/ extends Coin/*->_empty_::Enums.Coin#*/(100)/*->scala::runtime::EnumValues#register().*/ + case Penny/*<-_empty_::Enums.Coin.Penny.*/ extends Coin/*->_empty_::Enums.Coin#*/(1) + case Nickel/*<-_empty_::Enums.Coin.Nickel.*/ extends Coin/*->_empty_::Enums.Coin#*/(5) + case Dime/*<-_empty_::Enums.Coin.Dime.*/ extends Coin/*->_empty_::Enums.Coin#*/(10) + case Quarter/*<-_empty_::Enums.Coin.Quarter.*/ extends Coin/*->_empty_::Enums.Coin#*/(25) + case Dollar/*<-_empty_::Enums.Coin.Dollar.*/ extends Coin/*->_empty_::Enums.Coin#*/(100) enum Maybe/*<-_empty_::Enums.Maybe#*/[+A/*<-_empty_::Enums.Maybe#[A]*/] with case Just/*<-_empty_::Enums.Maybe.Just#*/(value/*<-_empty_::Enums.Maybe.Just#value.*/: A/*->_empty_::Enums.Maybe.Just#[A]*/) @@ -44,11 +44,11 @@ object Enums/*<-_empty_::Enums.*/ with def surfaceGravity/*<-_empty_::Enums.Planet#surfaceGravity().*/ = G/*->_empty_::Enums.Planet#G.*/ */*->scala::Double#`*`(+6).*/ mass/*->_empty_::Enums.Planet#mass.*/ //*->scala::Double#`::`(+6).*/ (radius/*->_empty_::Enums.Planet#radius.*/ */*->scala::Double#`*`(+6).*/ radius/*->_empty_::Enums.Planet#radius.*/) def surfaceWeight/*<-_empty_::Enums.Planet#surfaceWeight().*/(otherMass/*<-_empty_::Enums.Planet#surfaceWeight().(otherMass)*/: Double/*->scala::Double#*/) = otherMass/*->_empty_::Enums.Planet#surfaceWeight().(otherMass)*/ */*->scala::Double#`*`(+6).*/ surfaceGravity/*->_empty_::Enums.Planet#surfaceGravity().*/ - case Mercury/*<-_empty_::Enums.Planet.Mercury.*/ extends /*->scala::runtime::EnumValues#``().*/Planet/*->_empty_::Enums.Planet#*/(3.303e+23, 2.4397e6)/*->scala::runtime::EnumValues#register().*/ - case Venus/*<-_empty_::Enums.Planet.Venus.*/ extends Planet/*->_empty_::Enums.Planet#*/(4.869e+24, 6.0518e6)/*->scala::runtime::EnumValues#register().*/ - case Earth/*<-_empty_::Enums.Planet.Earth.*/ extends Planet/*->_empty_::Enums.Planet#*/(5.976e+24, 6.37814e6)/*->scala::runtime::EnumValues#register().*/ - case Mars/*<-_empty_::Enums.Planet.Mars.*/ extends Planet/*->_empty_::Enums.Planet#*/(6.421e+23, 3.3972e6)/*->scala::runtime::EnumValues#register().*/ - case Jupiter/*<-_empty_::Enums.Planet.Jupiter.*/ extends Planet/*->_empty_::Enums.Planet#*/(1.9e+27, 7.1492e7)/*->scala::runtime::EnumValues#register().*/ - case Saturn/*<-_empty_::Enums.Planet.Saturn.*/ extends Planet/*->_empty_::Enums.Planet#*/(5.688e+26, 6.0268e7)/*->scala::runtime::EnumValues#register().*/ - case Uranus/*<-_empty_::Enums.Planet.Uranus.*/ extends Planet/*->_empty_::Enums.Planet#*/(8.686e+25, 2.5559e7)/*->scala::runtime::EnumValues#register().*/ - case Neptune/*<-_empty_::Enums.Planet.Neptune.*/ extends Planet/*->_empty_::Enums.Planet#*/(1.024e+26, 2.4746e7)/*->scala::runtime::EnumValues#register().*/ + case Mercury/*<-_empty_::Enums.Planet.Mercury.*/ extends Planet/*->_empty_::Enums.Planet#*/(3.303e+23, 2.4397e6) + case Venus/*<-_empty_::Enums.Planet.Venus.*/ extends Planet/*->_empty_::Enums.Planet#*/(4.869e+24, 6.0518e6) + case Earth/*<-_empty_::Enums.Planet.Earth.*/ extends Planet/*->_empty_::Enums.Planet#*/(5.976e+24, 6.37814e6) + case Mars/*<-_empty_::Enums.Planet.Mars.*/ extends Planet/*->_empty_::Enums.Planet#*/(6.421e+23, 3.3972e6) + case Jupiter/*<-_empty_::Enums.Planet.Jupiter.*/ extends Planet/*->_empty_::Enums.Planet#*/(1.9e+27, 7.1492e7) + case Saturn/*<-_empty_::Enums.Planet.Saturn.*/ extends Planet/*->_empty_::Enums.Planet#*/(5.688e+26, 6.0268e7) + case Uranus/*<-_empty_::Enums.Planet.Uranus.*/ extends Planet/*->_empty_::Enums.Planet#*/(8.686e+25, 2.5559e7) + case Neptune/*<-_empty_::Enums.Planet.Neptune.*/ extends Planet/*->_empty_::Enums.Planet#*/(1.024e+26, 2.4746e7) diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index c549db5a454c..36b076959d64 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -544,8 +544,8 @@ Schema => SemanticDB v4 Uri => Enums.scala Text => empty Language => Scala -Symbols => 89 entries -Occurrences => 196 entries +Symbols => 73 entries +Occurrences => 146 entries Symbols: _empty_/Enums. => final object Enums @@ -621,22 +621,6 @@ _empty_/Enums.unwrap().(ev) => implicit val param ev _empty_/Enums.unwrap().(opt) => val param opt _empty_/Enums.unwrap().[A] => typeparam A _empty_/Enums.unwrap().[B] => typeparam B -local0 => primary ctor -local1 => primary ctor -local2 => primary ctor -local3 => primary ctor -local4 => primary ctor -local5 => primary ctor -local6 => primary ctor -local7 => primary ctor -local8 => primary ctor -local9 => primary ctor -local10 => primary ctor -local11 => primary ctor -local12 => primary ctor -local13 => primary ctor -local14 => primary ctor -local15 => primary ctor Occurrences: [0:7..0:12) Enums <- _empty_/Enums. @@ -645,20 +629,17 @@ Occurrences: [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:9) -> scala/runtime/EnumValues#``(). [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:9) -> scala/runtime/EnumValues#``(). [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:15) WeekDays <- _empty_/Enums.WeekDays# [11:4..11:4) <- _empty_/Enums.WeekDays#``(). -[11:4..11:4) -> scala/runtime/EnumValues#``(). [11:9..11:15) Monday <- _empty_/Enums.WeekDays.Monday. [12:9..12:16) Tuesday <- _empty_/Enums.WeekDays.Tuesday. [13:9..13:18) Wednesday <- _empty_/Enums.WeekDays.Wednesday. @@ -671,36 +652,20 @@ Occurrences: [19:12..19:17) value <- _empty_/Enums.Coin#value. [19:19..19:22) Int -> scala/Int# [20:9..20:14) Penny <- _empty_/Enums.Coin.Penny. -[20:26..20:26) -> scala/runtime/EnumValues#``(). -[20:26..20:26) <- local0 [20:26..20:30) Coin -> _empty_/Enums.Coin# [20:30..20:30) -> _empty_/Enums.Coin#``(). -[20:33..20:33) -> scala/runtime/EnumValues#register(). -[20:33..20:33) -> local0 [21:9..21:15) Nickel <- _empty_/Enums.Coin.Nickel. -[21:26..21:26) <- local1 [21:26..21:30) Coin -> _empty_/Enums.Coin# [21:30..21:30) -> _empty_/Enums.Coin#``(). -[21:33..21:33) -> scala/runtime/EnumValues#register(). -[21:33..21:33) -> local1 [22:9..22:13) Dime <- _empty_/Enums.Coin.Dime. -[22:26..22:26) <- local2 [22:26..22:30) Coin -> _empty_/Enums.Coin# [22:30..22:30) -> _empty_/Enums.Coin#``(). -[22:34..22:34) -> scala/runtime/EnumValues#register(). -[22:34..22:34) -> local2 [23:9..23:16) Quarter <- _empty_/Enums.Coin.Quarter. -[23:26..23:26) <- local3 [23:26..23:30) Coin -> _empty_/Enums.Coin# [23:30..23:30) -> _empty_/Enums.Coin#``(). -[23:34..23:34) -> scala/runtime/EnumValues#register(). -[23:34..23:34) -> local3 [24:9..24:15) Dollar <- _empty_/Enums.Coin.Dollar. -[24:26..24:26) <- local4 [24:26..24:30) Coin -> _empty_/Enums.Coin# [24:30..24:30) -> _empty_/Enums.Coin#``(). -[24:35..24:35) -> scala/runtime/EnumValues#register(). -[24:35..24:35) -> local4 [26:7..26:12) Maybe <- _empty_/Enums.Maybe# [26:12..26:16) <- _empty_/Enums.Maybe#``(). [26:14..26:15) A <- _empty_/Enums.Maybe#[A] @@ -709,25 +674,19 @@ Occurrences: [27:13..27:23) <- _empty_/Enums.Maybe.Just#``(). [27:14..27:19) value <- _empty_/Enums.Maybe.Just#value. [27:21..27:22) A -> _empty_/Enums.Maybe.Just#[A] -[28:4..28:4) <- local5 [28:4..28:4) -> _empty_/Enums.Maybe#``(). [28:9..28:13) None <- _empty_/Enums.Maybe.None. -[28:13..28:13) -> local5 [30:7..30:10) Tag <- _empty_/Enums.Tag# [30:10..30:13) <- _empty_/Enums.Tag#``(). [30:11..30:12) A <- _empty_/Enums.Tag#[A] [31:9..31:15) IntTag <- _empty_/Enums.Tag.IntTag. -[31:24..31:24) <- local6 [31:24..31:27) Tag -> _empty_/Enums.Tag# [31:28..31:31) Int -> scala/Int# [31:32..31:32) -> _empty_/Enums.Tag#``(). -[31:32..31:32) -> local6 [32:9..32:19) BooleanTag <- _empty_/Enums.Tag.BooleanTag. -[32:28..32:28) <- local7 [32:28..32:31) Tag -> _empty_/Enums.Tag# [32:32..32:39) Boolean -> scala/Boolean# [32:40..32:40) -> _empty_/Enums.Tag#``(). -[32:40..32:40) -> local7 [34:7..34:10) =:= <- _empty_/Enums.`=:=`# [34:10..34:16) <- _empty_/Enums.`=:=`#``(). [34:11..34:12) A <- _empty_/Enums.`=:=`#[A] @@ -787,54 +746,29 @@ Occurrences: [44:53..44:54) * -> scala/Double#`*`(+6). [44:55..44:69) surfaceGravity -> _empty_/Enums.Planet#surfaceGravity(). [46:9..46:16) Mercury <- _empty_/Enums.Planet.Mercury. -[46:25..46:25) -> scala/runtime/EnumValues#``(). -[46:25..46:25) <- local8 [46:25..46:31) Planet -> _empty_/Enums.Planet# [46:31..46:31) -> _empty_/Enums.Planet#``(). -[46:52..46:52) -> scala/runtime/EnumValues#register(). -[46:52..46:52) -> local8 [47:9..47:14) Venus <- _empty_/Enums.Planet.Venus. -[47:25..47:25) <- local9 [47:25..47:31) Planet -> _empty_/Enums.Planet# [47:31..47:31) -> _empty_/Enums.Planet#``(). -[47:52..47:52) -> scala/runtime/EnumValues#register(). -[47:52..47:52) -> local9 [48:9..48:14) Earth <- _empty_/Enums.Planet.Earth. -[48:25..48:25) <- local10 [48:25..48:31) Planet -> _empty_/Enums.Planet# [48:31..48:31) -> _empty_/Enums.Planet#``(). -[48:53..48:53) -> scala/runtime/EnumValues#register(). -[48:53..48:53) -> local10 [49:9..49:13) Mars <- _empty_/Enums.Planet.Mars. -[49:25..49:25) <- local11 [49:25..49:31) Planet -> _empty_/Enums.Planet# [49:31..49:31) -> _empty_/Enums.Planet#``(). -[49:52..49:52) -> scala/runtime/EnumValues#register(). -[49:52..49:52) -> local11 [50:9..50:16) Jupiter <- _empty_/Enums.Planet.Jupiter. -[50:25..50:25) <- local12 [50:25..50:31) Planet -> _empty_/Enums.Planet# [50:31..50:31) -> _empty_/Enums.Planet#``(). -[50:52..50:52) -> scala/runtime/EnumValues#register(). -[50:52..50:52) -> local12 [51:9..51:15) Saturn <- _empty_/Enums.Planet.Saturn. -[51:25..51:25) <- local13 [51:25..51:31) Planet -> _empty_/Enums.Planet# [51:31..51:31) -> _empty_/Enums.Planet#``(). -[51:52..51:52) -> scala/runtime/EnumValues#register(). -[51:52..51:52) -> local13 [52:9..52:15) Uranus <- _empty_/Enums.Planet.Uranus. -[52:25..52:25) <- local14 [52:25..52:31) Planet -> _empty_/Enums.Planet# [52:31..52:31) -> _empty_/Enums.Planet#``(). -[52:52..52:52) -> scala/runtime/EnumValues#register(). -[52:52..52:52) -> local14 [53:9..53:16) Neptune <- _empty_/Enums.Planet.Neptune. -[53:25..53:25) <- local15 [53:25..53:31) Planet -> _empty_/Enums.Planet# [53:31..53:31) -> _empty_/Enums.Planet#``(). -[53:52..53:52) -> scala/runtime/EnumValues#register(). -[53:52..53:52) -> local15 expect/EtaExpansion.scala _________________________ From 303dcb659bf67761881bfbd4bb415b8f85ab1ee7 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sat, 16 Nov 2019 22:11:16 +0100 Subject: [PATCH 072/107] optimise some methods --- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 12 +++++++----- compiler/src/dotty/tools/dotc/semanticdb/Scala.scala | 5 +++++ .../dotty/tools/dotc/semanticdb/Semanticdbs.scala | 2 +- 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 2a4f9ad0c263..342774331cb5 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -167,7 +167,7 @@ class ExtractSemanticDB extends Phase { 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.name == nme.CONSTRUCTOR) then + && (!sym.is(StableRealizable) || sym.isConstructor) then b.append('('); addOverloadIdx(sym); b.append(").") else b.append('.') @@ -215,7 +215,7 @@ class ExtractSemanticDB extends Phase { !sym.exists || sym.isLocalDummy || sym.is(Synthetic) || (sym.owner.is(Synthetic) && !sym.isAllOf(EnumCase)) - || sym.name == nme.CONSTRUCTOR && sym.owner.is(ModuleClass) + || sym.isConstructor && sym.owner.is(ModuleClass) || sym.isAnonymous || excludeDefStrict(sym) @@ -240,7 +240,7 @@ class ExtractSemanticDB extends Phase { SymbolInformation.Kind.LOCAL else if sym.isInlineMethod || sym.is(Macro) SymbolInformation.Kind.MACRO - else if sym.name == nme.CONSTRUCTOR + else if sym.isConstructor SymbolInformation.Kind.CONSTRUCTOR else if sym.isSelfSym SymbolInformation.Kind.SELF_PARAMETER @@ -483,8 +483,10 @@ class ExtractSemanticDB extends Phase { case tree: Ident => registerUse(setter, tree.span) traverse(tree.rhs) case tree: Ident => - if tree.name != nme.WILDCARD && !excludeUseStrict(tree.symbol, tree.span) then - registerUse(tree.symbol, tree.span) + if tree.name != nme.WILDCARD then + // if tree.symbol.isTypeParam && tree.symbol.owner.isConstructor + if !excludeUseStrict(tree.symbol, tree.span) then + registerUse(tree.symbol, tree.span) case tree: Select => val qualSpan = tree.qualifier.span if !excludeUseStrict(tree.symbol, tree.span) then diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala index a8ee1ee96473..325edd7b20b7 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala @@ -34,6 +34,9 @@ object Scala with @sharable private val locals = raw"local(\d+)".r + @sharable + private val ctor = raw"[^;].*``\((?:\+\d+)?\)\.".r + object LocalSymbol with def unapply(symbolInfo: SymbolInformation): Option[Int] = symbolInfo.symbol match @@ -61,6 +64,8 @@ object Scala with locals matches symbol def isMulti: Boolean = symbol startsWith ";" + def isConstructor: Boolean = + ctor matches symbol def isTerm: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '.' def isType: Boolean = diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index 205f237d5f8e..c47ac7a70996 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -137,7 +137,7 @@ object Semanticdbs with .append(')') if range.endLine == range.startLine && range.startCharacter != range.endCharacter - && !(occ.role.isDefinition && occ.symbol.matches(raw".+``\((?:\+\d+)?\)\.")) + && !(occ.symbol.isConstructor && occ.role.isDefinition) val line = sourceFile.lineContent(sourceFile.lineToOffset(range.startLine)) sb.append(" ").append(line.substring(range.startCharacter, range.endCharacter)) case _ => From 711ac1839b056e16d70efe80998f7a0cc10d92ea Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sat, 16 Nov 2019 23:32:06 +0100 Subject: [PATCH 073/107] dont define typarams for non primary ctors; remove refs to ctor tparams --- .../dotc/semanticdb/ExtractSemanticDB.scala | 66 +++++++---- tests/semanticdb/expect/Flags.expect.scala | 3 +- tests/semanticdb/expect/Flags.scala | 1 + .../semanticdb/expect/Synthetic.expect.scala | 2 +- tests/semanticdb/metac.expect | 109 +++++++++--------- 5 files changed, 101 insertions(+), 80 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 342774331cb5..8a081f790fc7 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -332,10 +332,10 @@ class ExtractSemanticDB extends Phase { Span(start, start + sym.name.show.length, start) } - def (tree: DefDef) isSetterDef(given Context): Boolean = + private def (tree: DefDef) isSetterDef(given Context): Boolean = tree.name.isSetterName && tree.mods.is(Accessor) && tree.vparamss.flatten.length == 1 - def findGetters(ctorParams: List[ValDef], body: List[ast.tpd.Tree])(given Context): Map[Names.TermName, ValDef] = + private def findGetters(ctorParams: List[ValDef], body: List[ast.tpd.Tree])(given Context): Map[Names.TermName, ValDef] = if ctorParams.isEmpty then Map.empty else @@ -348,7 +348,7 @@ class ExtractSemanticDB extends Phase { }).toMap end findGetters - def adjustSpanToName(span: Span, qualSpan: Span, name: Name)(given Context) = + private def adjustSpanToName(span: Span, qualSpan: Span, name: Name)(given Context) = val end = span.end val limit = qualSpan.end val start = @@ -358,7 +358,7 @@ class ExtractSemanticDB extends Phase { else limit Span(start max limit, end) - def (span: Span) hasLength: Boolean = span.start != span.end + private def (span: Span) hasLength: Boolean = span.start != span.end /**Consume head while not an import statement. * Returns the rest of the list after the first import, or else the empty list @@ -371,6 +371,15 @@ class ExtractSemanticDB extends Phase { rest.foreachUntilImport(op) case Nil => Nil + private def (sym: Symbol) adjustIfCtorTyparam(given Context) = + if sym.isType && sym.owner.isConstructor + matchingMemberType(sym, sym.owner.owner) + else + sym + + private inline def matchingMemberType(ctorTypeParam: Symbol, classSym: Symbol)(given Context) = + classSym.info.member(ctorTypeParam.name).symbol + override def traverse(tree: Tree)(given Context): Unit = for annot <- tree.symbol.annotations do if annot.tree.span.exists @@ -378,6 +387,24 @@ class ExtractSemanticDB extends Phase { then traverse(annot.tree) + def ctorParams(ctorSym: Symbol, vparamss: List[List[ValDef]], body: List[Tree]): Unit = + val ctorParams = vparamss.flatten + @tu lazy val getters = findGetters(ctorParams, body) + for vparam <- ctorParams do + if !isWildcard(vparam.name) + val symkinds = + getters.get(vparam.name).fold( + Set.empty[SymbolKind])( + getter => if getter.mods.is(Mutable) then SymbolKind.SingletonVar else SymbolKind.SingletonVal) + registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds) + val tptSym = vparam.tpt.symbol + if tptSym.owner == ctorSym + val found = matchingMemberType(tptSym, ctorSym.owner) + if !excludeUseStrict(found, vparam.tpt.span) && vparam.tpt.span.hasLength + registerUse(found, vparam.tpt.span) + else + traverse(vparam.tpt) + tree match case tree: PackageDef => if !excludeDef(tree.pid.symbol) && tree.pid.span.hasLength @@ -423,28 +450,16 @@ class ExtractSemanticDB extends Phase { case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause template.parents.foreach(traverse) case _ => // calls $new + case tree: DefDef if tree.symbol.isConstructor => + tree.vparamss.flatten.foreach(traverse) + traverse(tree.rhs) case _ => traverseChildren(tree) case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => val ctorSym = tree.constr.symbol if !excludeDef(ctorSym) registerDefinition(ctorSym, tree.constr.span, Set.empty) - val ctorParams = tree.constr.vparamss.flatten - @tu lazy val getters = findGetters(ctorParams, tree.body) - for vparam <- ctorParams do - if !isWildcard(vparam.name) - val symkinds = - getters.get(vparam.name).fold( - Set.empty[SymbolKind])( - getter => if getter.mods.is(Mutable) then SymbolKind.SingletonVar else SymbolKind.SingletonVal) - registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds) - val tptSym = vparam.tpt.symbol - if tptSym.owner == ctorSym - val found = ctorSym.owner.info.member(tptSym.name.toTypeName).symbol - if !excludeUseStrict(found, vparam.tpt.span) && vparam.tpt.span.hasLength - registerUse(found, vparam.tpt.span) - else - traverse(vparam.tpt) + ctorParams(ctorSym, tree.constr.vparamss, tree.body) for parent <- tree.parentsOrDerived do if parent.symbol != defn.ObjectClass.primaryConstructor @@ -484,13 +499,14 @@ class ExtractSemanticDB extends Phase { traverse(tree.rhs) case tree: Ident => if tree.name != nme.WILDCARD then - // if tree.symbol.isTypeParam && tree.symbol.owner.isConstructor - if !excludeUseStrict(tree.symbol, tree.span) then - registerUse(tree.symbol, tree.span) + val sym = tree.symbol.adjustIfCtorTyparam + if !excludeUseStrict(sym, tree.span) then + registerUse(sym, tree.span) case tree: Select => val qualSpan = tree.qualifier.span - if !excludeUseStrict(tree.symbol, tree.span) then - registerUse(tree.symbol, adjustSpanToName(tree.span, qualSpan, tree.name)) + val sym = tree.symbol.adjustIfCtorTyparam + if !excludeUseStrict(sym, tree.span) then + registerUse(sym, adjustSpanToName(tree.span, qualSpan, tree.name)) if qualSpan.exists && qualSpan.hasLength then traverseChildren(tree) case tree: Import => diff --git a/tests/semanticdb/expect/Flags.expect.scala b/tests/semanticdb/expect/Flags.expect.scala index bb123fe03672..25188c017220 100644 --- a/tests/semanticdb/expect/Flags.expect.scala +++ b/tests/semanticdb/expect/Flags.expect.scala @@ -7,8 +7,9 @@ package object p { protected implicit var y/*<-flags::p::package.y().*/: /*<-flags::p::package.`y_=`().*/Int/*->scala::Int#*/ = 2 def z/*<-flags::p::package.z().*/(pp/*<-flags::p::package.z().(pp)*/: Int/*->scala::Int#*/) = 3 def m/*<-flags::p::package.m().*/[TT/*<-flags::p::package.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ??? - abstract class C/*<-flags::p::package.C#*/[+T/*<-flags::p::package.C#[T]*//*<-flags::p::package.C#``(+1).[T]*/, -U/*<-flags::p::package.C#[U]*//*<-flags::p::package.C#``(+1).[U]*/, V/*<-flags::p::package.C#[V]*//*<-flags::p::package.C#``(+1).[V]*/](x/*<-flags::p::package.C#x.*/: T/*->flags::p::package.C#[T]*/, y/*<-flags::p::package.C#y.*/: U/*->flags::p::package.C#[U]*/, z/*<-flags::p::package.C#z.*/: V/*->flags::p::package.C#[V]*/) { + abstract class C/*<-flags::p::package.C#*/[+T/*<-flags::p::package.C#[T]*/, -U/*<-flags::p::package.C#[U]*/, V/*<-flags::p::package.C#[V]*/](x/*<-flags::p::package.C#x.*/: T/*->flags::p::package.C#[T]*/, y/*<-flags::p::package.C#y.*/: U/*->flags::p::package.C#[U]*/, z/*<-flags::p::package.C#z.*/: V/*->flags::p::package.C#[V]*/) { def this()/*<-flags::p::package.C#``(+1).*/ = this(???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/) + def this(t/*<-flags::p::package.C#``(+2).*//*<-flags::p::package.C#``(+2).(t)*/: T/*->flags::p::package.C#[T]*/) = this(t/*->flags::p::package.C#``(+2).(t)*/, ???/*->scala::Predef.`???`().*/, ???/*->scala::Predef.`???`().*/) def w/*<-flags::p::package.C#w().*/: Int/*->scala::Int#*/ } type T1/*<-flags::p::package.T1#*/ = Int/*->scala::Int#*/ diff --git a/tests/semanticdb/expect/Flags.scala b/tests/semanticdb/expect/Flags.scala index c7b0b058753c..d2e76e0fb956 100644 --- a/tests/semanticdb/expect/Flags.scala +++ b/tests/semanticdb/expect/Flags.scala @@ -9,6 +9,7 @@ package object p { def m[TT]: Int = macro ??? abstract class C[+T, -U, V](x: T, y: U, z: V) { def this() = this(???, ???, ???) + def this(t: T) = this(t, ???, ???) def w: Int } type T1 = Int diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala index 29151fc1309b..c03c5d29a8fe 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -28,7 +28,7 @@ class Synthetic/*<-example::Synthetic#*/ { null.asInstanceOf/*->scala::Any#asInstanceOf().*/[Int/*->scala::Int#*/ => Int/*->scala::Int#*/]/*->scala::Function1#apply().*/(2) } - class J/*<-example::Synthetic#J#*/[T/*<-example::Synthetic#J#[T]*//*<-example::Synthetic#J#evidence$2.*/: 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]*/]/*->example::Synthetic#J#evidence$2.*/ } + class J/*<-example::Synthetic#J#*/[T/*<-example::Synthetic#J#[T]*//*<-example::Synthetic#J#evidence$2.*/: 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]*/]/*->example::Synthetic#J#evidence$2.*/ } class F/*<-example::Synthetic#F#*/ implicit val ordering/*<-example::Synthetic#ordering.*/: Ordering/*->scala::package.Ordering#*/[F/*->example::Synthetic#F#*/] = ???/*->scala::Predef.`???`().*/ diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 36b076959d64..9d4f6506e64e 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -852,8 +852,8 @@ Schema => SemanticDB v4 Uri => Flags.scala Text => empty Language => Scala -Symbols => 50 entries -Occurrences => 83 entries +Symbols => 49 entries +Occurrences => 87 entries Symbols: flags/p/package. => final package object p @@ -875,9 +875,8 @@ 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#``(+1).[T] => typeparam T -flags/p/package.C#``(+1).[U] => typeparam U -flags/p/package.C#``(+1).[V] => typeparam V +flags/p/package.C#``(+2). => ctor +flags/p/package.C#``(+2).(t) => val param t flags/p/package.C#w(). => abstract method w flags/p/package.C#x. => val method x flags/p/package.C#y. => val method y @@ -929,11 +928,8 @@ Occurrences: [9:17..9:18) C <- flags/p/package.C# [9:18..9:47) <- flags/p/package.C#``(). [9:20..9:21) T <- flags/p/package.C#[T] -[9:20..9:21) T <- flags/p/package.C#``(+1).[T] [9:24..9:25) U <- flags/p/package.C#[U] -[9:24..9:25) U <- flags/p/package.C#``(+1).[U] [9:27..9:28) V <- flags/p/package.C#[V] -[9:27..9:28) V <- flags/p/package.C#``(+1).[V] [9:30..9:31) x <- flags/p/package.C#x. [9:33..9:34) T -> flags/p/package.C#[T] [9:36..9:37) y <- flags/p/package.C#y. @@ -945,52 +941,59 @@ Occurrences: [10:22..10:25) ??? -> scala/Predef.`???`(). [10:27..10:30) ??? -> scala/Predef.`???`(). [10:32..10:35) ??? -> scala/Predef.`???`(). -[11:8..11:9) w <- flags/p/package.C#w(). -[11:11..11:14) Int -> scala/Int# -[13:7..13:9) T1 <- flags/p/package.T1# -[13:12..13:15) Int -> scala/Int# -[14:7..14:9) T2 <- flags/p/package.T2# -[14:10..14:11) T <- flags/p/package.T2#[T] -[14:15..14:16) S -> flags/p/package.S# -[14:17..14:18) T -> flags/p/package.T2#[T] -[15:7..15:8) U <- flags/p/package.U# -[15:12..15:15) Int -> scala/Int# -[16:7..16:8) V <- flags/p/package.V# +[11:8..11:14) <- flags/p/package.C#``(+2). +[11:13..11:14) t <- flags/p/package.C#``(+2).(t) +[11:16..11:17) T -> flags/p/package.C#[T] +[11:26..11:26) -> flags/p/package.C#``(). +[11:26..11:27) t -> flags/p/package.C#``(+2).(t) +[11:29..11:32) ??? -> scala/Predef.`???`(). +[11:34..11:37) ??? -> scala/Predef.`???`(). +[12:8..12:9) w <- flags/p/package.C#w(). +[12:11..12:14) Int -> scala/Int# +[14:7..14:9) T1 <- flags/p/package.T1# +[14:12..14:15) Int -> scala/Int# +[15:7..15:9) T2 <- flags/p/package.T2# +[15:10..15:11) T <- flags/p/package.T2#[T] +[15:15..15:16) S -> flags/p/package.S# +[15:17..15:18) T -> flags/p/package.T2#[T] +[16:7..16:8) U <- flags/p/package.U# [16:12..16:15) Int -> scala/Int# -[17:14..17:15) X <- flags/p/package.X. -[18:2..18:2) <- flags/p/package.Y#``(). -[18:14..18:15) Y <- flags/p/package.Y# -[19:2..19:2) <- flags/p/package.Z#``(). -[19:15..19:16) Z <- flags/p/package.Z# -[20:8..20:10) AA <- flags/p/package.AA# -[20:10..20:42) <- flags/p/package.AA#``(). -[20:11..20:12) x <- flags/p/package.AA#x. -[20:14..20:17) Int -> scala/Int# -[20:23..20:24) y <- flags/p/package.AA#y. -[20:26..20:29) Int -> scala/Int# -[20:35..20:36) z <- flags/p/package.AA#z(). -[20:35..20:38) z: <- flags/p/package.AA#`z_=`(). -[20:38..20:41) Int -> scala/Int# -[21:8..21:9) S <- flags/p/package.S# -[21:9..21:25) <- flags/p/package.S#``(). -[21:11..21:22) specialized -> scala/specialized# -[21:22..21:22) -> scala/specialized#``(+2). -[21:23..21:24) T <- flags/p/package.S#[T] -[22:6..22:10) List -> scala/package.List. -[22:10..22:10) -> scala/collection/SeqFactory#unapplySeq(). -[22:11..22:14) xs1 <- flags/p/package.xs1. -[22:11..22:14) xs1 <- local0 -[22:15..22:15) -> local0 -[22:18..22:21) ??? -> scala/Predef.`???`(). -[23:2..23:5) ??? -> scala/Predef.`???`(). -[23:19..23:23) List -> scala/package.List. -[23:23..23:23) -> scala/collection/SeqFactory#unapplySeq(). -[23:24..23:27) xs2 <- local1 -[23:32..23:35) ??? -> scala/Predef.`???`(). +[17:7..17:8) V <- flags/p/package.V# +[17:12..17:15) Int -> scala/Int# +[18:14..18:15) X <- flags/p/package.X. +[19:2..19:2) <- flags/p/package.Y#``(). +[19:14..19:15) Y <- flags/p/package.Y# +[20:2..20:2) <- flags/p/package.Z#``(). +[20:15..20:16) Z <- flags/p/package.Z# +[21:8..21:10) AA <- flags/p/package.AA# +[21:10..21:42) <- flags/p/package.AA#``(). +[21:11..21:12) x <- flags/p/package.AA#x. +[21:14..21:17) Int -> scala/Int# +[21:23..21:24) y <- flags/p/package.AA#y. +[21:26..21:29) Int -> scala/Int# +[21:35..21:36) z <- flags/p/package.AA#z(). +[21:35..21:38) z: <- flags/p/package.AA#`z_=`(). +[21:38..21:41) Int -> scala/Int# +[22:8..22:9) S <- flags/p/package.S# +[22:9..22:25) <- flags/p/package.S#``(). +[22:11..22:22) specialized -> scala/specialized# +[22:22..22:22) -> scala/specialized#``(+2). +[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:11..23:14) xs1 <- local0 +[23:15..23:15) -> local0 +[23:18..23:21) ??? -> scala/Predef.`???`(). [24:2..24:5) ??? -> scala/Predef.`???`(). -[24:22..24:26) List -> scala/package.List# -[24:27..24:28) t <- local2 -[24:33..24:36) ??? -> scala/Predef.`???`(). +[24:19..24:23) List -> scala/package.List. +[24:23..24:23) -> scala/collection/SeqFactory#unapplySeq(). +[24:24..24:27) xs2 <- local1 +[24:32..24:35) ??? -> scala/Predef.`???`(). +[25:2..25:5) ??? -> scala/Predef.`???`(). +[25:22..25:26) List -> scala/package.List# +[25:27..25:28) t <- local2 +[25:33..25:36) ??? -> scala/Predef.`???`(). expect/ForComprehension.scala _____________________________ @@ -2328,7 +2331,7 @@ Occurrences: [30:10..30:11) T <- example/Synthetic#J#[T] [30:11..30:11) <- example/Synthetic#J#evidence$2. [30:13..30:21) Manifest -> scala/Predef.Manifest# -[30:21..30:21) -> example/Synthetic#J#``().[T] +[30:21..30:21) -> example/Synthetic#J#[T] [30:29..30:32) arr <- example/Synthetic#J#arr. [30:35..30:40) Array -> scala/Array. [30:41..30:46) empty -> scala/Array.empty(). From f337a6e6240754d05f7cc940c0f0d5c28b9fab5c Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sat, 16 Nov 2019 23:33:44 +0100 Subject: [PATCH 074/107] method params are never val/var --- .../dotc/semanticdb/ExtractSemanticDB.scala | 9 +- tests/semanticdb/metac.expect | 155 +++++++++--------- 2 files changed, 83 insertions(+), 81 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 8a081f790fc7..8b39c4c29de3 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -425,10 +425,11 @@ class ExtractSemanticDB extends Phase { val symkinds = mutable.HashSet.empty[SymbolKind] tree match case tree: ValDef => - if tree.mods.is(Mutable) - symkinds += SymbolKind.Var - else - symkinds += SymbolKind.Val + if !tree.symbol.owner.is(Method) + if tree.mods.is(Mutable) + symkinds += SymbolKind.Var + else + symkinds += SymbolKind.Val if tree.rhs.isEmpty && !tree.symbol.is(TermParam) && !tree.symbol.is(CaseAccessor) && !tree.mods.is(ParamAccessor) symkinds += SymbolKind.Abstract case tree: DefDef => diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 9d4f6506e64e..708148862430 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -81,10 +81,10 @@ local1 => abstract val method x local2 => primary ctor local3 => val method x local4 => abstract method m -local5 => val param x +local5 => param x local6 => primary ctor local7 => method m -local8 => val param x +local8 => param x local9 => val local e3 local10 => val local e3x @@ -219,7 +219,7 @@ annot/M.m().[TT] => typeparam TT annot/T# => trait T annot/T#``(). => primary ctor local0 => selfparam self -local1 => val local local +local1 => local local Occurrences: [0:8..0:13) annot <- annot/ @@ -292,7 +292,7 @@ example/Anonymous#Foo#``(). => primary ctor example/Anonymous#``(). => primary ctor example/Anonymous#foo. => val method foo example/Anonymous#locally(). => method locally -example/Anonymous#locally().(x) => val param x +example/Anonymous#locally().(x) => param x example/Anonymous#locally().[A] => typeparam A example/Anonymous#m1(). => method m1 example/Anonymous#m1().[T] => typeparam T @@ -586,7 +586,7 @@ _empty_/Enums.Planet#mass. => val method mass _empty_/Enums.Planet#radius. => val method radius _empty_/Enums.Planet#surfaceGravity(). => method surfaceGravity _empty_/Enums.Planet#surfaceWeight(). => method surfaceWeight -_empty_/Enums.Planet#surfaceWeight().(otherMass) => val param otherMass +_empty_/Enums.Planet#surfaceWeight().(otherMass) => param otherMass _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 @@ -617,8 +617,8 @@ _empty_/Enums.`=:=`.Refl# => final case enum class Refl _empty_/Enums.`=:=`.Refl#[C] => typeparam C _empty_/Enums.`=:=`.Refl#``(). => primary ctor _empty_/Enums.unwrap(). => method unwrap -_empty_/Enums.unwrap().(ev) => implicit val param ev -_empty_/Enums.unwrap().(opt) => val param opt +_empty_/Enums.unwrap().(ev) => implicit param ev +_empty_/Enums.unwrap().(opt) => param opt _empty_/Enums.unwrap().[A] => typeparam A _empty_/Enums.unwrap().[B] => typeparam B @@ -811,7 +811,7 @@ Occurrences => 27 entries Symbols: example/Example. => final object Example example/Example.main(). => method main -example/Example.main().(args) => val param args +example/Example.main().(args) => param args example/Example.x. => val method x local0 => selfparam self @@ -876,7 +876,7 @@ 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) => val param t +flags/p/package.C#``(+2).(t) => param t flags/p/package.C#w(). => abstract method w flags/p/package.C#x. => val method x flags/p/package.C#y. => val method y @@ -901,7 +901,7 @@ flags/p/package.x. => lazy val method x flags/p/package.xs1. => val method xs1 flags/p/package.y(). => implicit var method y flags/p/package.z(). => method z -flags/p/package.z().(pp) => val param pp +flags/p/package.z().(pp) => param pp local0 => val local xs1 local1 => val local xs2 local2 => case val method t @@ -1092,27 +1092,27 @@ 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) => val param x -a/b/Givens.Monoid#combine().(y) => val param y +a/b/Givens.Monoid#combine().(x) => param x +a/b/Givens.Monoid#combine().(y) => param y a/b/Givens.Monoid#empty(). => abstract method empty a/b/Givens.foo(). => method foo -a/b/Givens.foo().(A) => implicit val param A +a/b/Givens.foo().(A) => implicit param A a/b/Givens.foo().[A] => typeparam A a/b/Givens.given_Monoid_String. => final object given_Monoid_String a/b/Givens.given_Monoid_String.combine(). => method combine -a/b/Givens.given_Monoid_String.combine().(x) => val param x -a/b/Givens.given_Monoid_String.combine().(y) => val param y +a/b/Givens.given_Monoid_String.combine().(x) => param x +a/b/Givens.given_Monoid_String.combine().(y) => param y a/b/Givens.given_Monoid_String.empty(). => method empty a/b/Givens.given_sayGoodbye_of_B. => final object given_sayGoodbye_of_B a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). => method sayGoodbye -a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) => val param any +a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) => param any a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] => typeparam B a/b/Givens.given_sayGoodbye_of_B.saySoLong(). => method saySoLong -a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) => val param any +a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) => param any a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] => typeparam B a/b/Givens.given_sayHello_of_A. => final object given_sayHello_of_A a/b/Givens.given_sayHello_of_A.sayHello(). => method sayHello -a/b/Givens.given_sayHello_of_A.sayHello().(any) => val param any +a/b/Givens.given_sayHello_of_A.sayHello().(any) => param any a/b/Givens.given_sayHello_of_A.sayHello().[A] => typeparam A a/b/Givens.goodbye1. => val method goodbye1 a/b/Givens.hello1. => val method hello1 @@ -1210,14 +1210,14 @@ 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) => val param string +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) => val param other +example/ImplicitConversion.newAny2stringadd#`+`().(other) => param other example/ImplicitConversion.newAny2stringadd#``(). => primary ctor example/ImplicitConversion.newAny2stringadd#``().(self) => param self example/ImplicitConversion.newAny2stringadd#self. => val method self @@ -1319,7 +1319,7 @@ 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) => val param x +example/InstrumentTyper#singletonType().(x) => param x local0 => selfparam self Occurrences: @@ -1445,7 +1445,7 @@ example/Local#``(). => primary ctor example/Local#a(). => method a local0 => local id local1 => typeparam A -local2 => val param a +local2 => param a Occurrences: [0:8..0:15) example <- example/ @@ -1700,60 +1700,60 @@ example/Methods#`m9().`#``(). => primary ctor example/Methods#m1(). => method m1 example/Methods#m2(). => method m2 example/Methods#m3(). => method m3 -example/Methods#m3().(x) => val param x +example/Methods#m3().(x) => param x example/Methods#m4(). => method m4 -example/Methods#m4().(x) => val param x -example/Methods#m4().(y) => val param y +example/Methods#m4().(x) => param x +example/Methods#m4().(y) => param y example/Methods#m5(). => method m5 -example/Methods#m5().(x) => val param x +example/Methods#m5().(x) => param x example/Methods#m5(+1). => method m5 -example/Methods#m5(+1).(x) => val param x +example/Methods#m5(+1).(x) => param x example/Methods#m6(). => method m6 -example/Methods#m6().(x) => val param x +example/Methods#m6().(x) => param x example/Methods#m6(+1). => method m6 -example/Methods#m6(+1).(x) => val param x +example/Methods#m6(+1).(x) => param x example/Methods#m6(+2). => method m6 -example/Methods#m6(+2).(x) => val param x +example/Methods#m6(+2).(x) => param x example/Methods#m7(). => method m7 -example/Methods#m7().(c) => val param c -example/Methods#m7().(evidence$1) => implicit val param evidence$1 -example/Methods#m7().(l) => val param l +example/Methods#m7().(c) => param c +example/Methods#m7().(evidence$1) => implicit param evidence$1 +example/Methods#m7().(l) => param l example/Methods#m7().[U] => typeparam U example/Methods#m9(). => method m9 -example/Methods#m9().(x) => val param x +example/Methods#m9().(x) => param x example/Methods#m10(). => method m10 -example/Methods#m10().(x) => val param x +example/Methods#m10().(x) => param x example/Methods#m11(). => method m11 -example/Methods#m11().(x) => val param x +example/Methods#m11().(x) => param x example/Methods#m11(+1). => method m11 -example/Methods#m11(+1).(x) => val param x +example/Methods#m11(+1).(x) => param x example/Methods#m12a(). => method m12a -example/Methods#m12a().(x) => val param x +example/Methods#m12a().(x) => param x example/Methods#m12b(). => method m12b -example/Methods#m12b().(x) => val param x +example/Methods#m12b().(x) => param x example/Methods#m13(). => method m13 -example/Methods#m13().(x) => val param x +example/Methods#m13().(x) => param x example/Methods#m15(). => method m15 -example/Methods#m15().(x) => val param x +example/Methods#m15().(x) => param x example/Methods#m16(). => method m16 -example/Methods#m16().(x) => val param x +example/Methods#m16().(x) => param x example/Methods#m17(). => method m17 -example/Methods#m17().(a) => val param a +example/Methods#m17().(a) => param a example/Methods#m17(+1). => method m17 -example/Methods#m17(+1).(b) => val param b +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) => val param a +example/Methods#m18().(a) => param a example/Methods#m18(+1). => method m18 -example/Methods#m18(+1).(b) => val param b +example/Methods#m18(+1).(b) => param b example/Methods#m18. => val method m18 -example/Methods#m19$default$3().(x) => val param x -example/Methods#m19$default$3().(y) => val param y +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) => val param x -example/Methods#m19().(y) => val param y -example/Methods#m19().(z) => val param z +example/Methods#m19().(x) => param x +example/Methods#m19().(y) => param y +example/Methods#m19().(z) => param z local0 => abstract val method x Occurrences: @@ -1923,9 +1923,9 @@ example/NamedApplyBlockCaseClassConstruction.msg. => val method msg example/NamedApplyBlockMethods. => final object NamedApplyBlockMethods example/NamedApplyBlockMethods.baseCase(). => method baseCase example/NamedApplyBlockMethods.foo(). => method foo -example/NamedApplyBlockMethods.foo().(a) => val param a -example/NamedApplyBlockMethods.foo().(b) => val param b -example/NamedApplyBlockMethods.foo().(c) => val param c +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 @@ -2475,7 +2475,7 @@ 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) => val param x +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 @@ -2488,9 +2488,9 @@ 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) => val param x +types/Test.C#MethodType.m5().(x) => param x types/Test.C#MethodType.m6(). => method m6 -types/Test.C#MethodType.m6().(x) => val param x +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 @@ -2498,7 +2498,7 @@ types/Test.C#RepeatedType# => case class RepeatedType 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) => val param x +types/Test.C#RepeatedType#m1().(x) => param x types/Test.C#RepeatedType#s. => val method s types/Test.C#TypeType. => final object TypeType types/Test.C#TypeType.T1# => type T1 @@ -2823,7 +2823,7 @@ Schema => SemanticDB v4 Uri => ValPattern.scala Text => empty Language => Scala -Symbols => 21 entries +Symbols => 22 entries Occurrences => 57 entries Symbols: @@ -2841,13 +2841,14 @@ example/ValPattern#right. => val method right example/ValPattern#rightVar(). => var method rightVar local0 => val local number1 local1 => val local number1Var -local2 => val local left -local3 => val local right +local2 => local left +local3 => local right +local4 => local number1 local4 => val local number1 -local5 => var local leftVar -local6 => var local rightVar +local5 => local leftVar +local6 => local rightVar local7 => val local number1Var -local7 => var local number1Var +local7 => local number1Var Occurrences: [0:8..0:15) example <- example/ @@ -2948,11 +2949,11 @@ example/Vals#yim(). => implicit var method yim example/Vals#ylm(). => var method ylm example/Vals#ym(). => var method ym example/Vals#yp(). => var method yp -local0 => val local xl -local1 => lazy val local xzl -local2 => implicit val local xil -local3 => var local yl -local4 => implicit var local yil +local0 => local xl +local1 => lazy local xzl +local2 => implicit local xil +local3 => local yl +local4 => implicit local yil Occurrences: [0:8..0:15) example <- example/ @@ -3093,9 +3094,9 @@ Symbols: example/Vararg# => class Vararg example/Vararg#``(). => primary ctor example/Vararg#add1(). => method add1 -example/Vararg#add1().(a) => val param a +example/Vararg#add1().(a) => param a example/Vararg#add2(). => method add2 -example/Vararg#add2().(a) => val param a +example/Vararg#add2().(a) => param a Occurrences: [0:8..0:15) example <- example/ @@ -3173,7 +3174,7 @@ _empty_/AnObject.Foo#``(). => primary ctor _empty_/AnObject.Foo#``().(x) => val param x _empty_/AnObject.Foo#x. => val method x _empty_/AnObject.foo(). => method foo -_empty_/AnObject.foo().(x) => val param x +_empty_/AnObject.foo().(x) => param x _empty_/AnObject.foo(+1). => method foo Occurrences: @@ -3215,12 +3216,12 @@ Symbols: _empty_/toplevel$package. => final package object _empty_ _empty_/toplevel$package.a. => val method a _empty_/toplevel$package.combine(). => method combine -_empty_/toplevel$package.combine().(x) => val param x -_empty_/toplevel$package.combine().(y) => val param y +_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) => val param x -_empty_/toplevel$package.combine(+1).(y) => val param y -_empty_/toplevel$package.combine(+1).(z) => val param z +_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 From 48be9dd11c0c36face51488f9c0d1b3b7805adb4 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sun, 17 Nov 2019 00:03:10 +0100 Subject: [PATCH 075/107] add more enum tests --- tests/semanticdb/expect/Enums.expect.scala | 27 +- tests/semanticdb/expect/Enums.scala | 25 +- tests/semanticdb/metac.expect | 334 ++++++++++++--------- 3 files changed, 234 insertions(+), 152 deletions(-) diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index 084dae22d6a4..c7dc21c3ed65 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -1,5 +1,5 @@ object Enums/*<-_empty_::Enums.*/ with - import =:=/*->_empty_::Enums.`=:=`.*/._ + import <:_empty_::Enums.`<:<`.*/._ enum Colour/*<-_empty_::Enums.Colour#*/ with import Colour/*->_empty_::Enums.Colour.*/.Red/*->_empty_::Enums.Colour.Red.*/ @@ -8,6 +8,17 @@ object Enums/*<-_empty_::Enums.*/ with enum Directions/*<-_empty_::Enums.Directions#*/ with case North/*<-_empty_::Enums.Directions.North.*/, East/*<-_empty_::Enums.Directions.East.*/, South/*<-_empty_::Enums.Directions.South.*/, West/*<-_empty_::Enums.Directions.West.*/ + enum Suits/*<-_empty_::Enums.Suits#*/ derives /*->scala::Eql.derived.*/Eql with + case Hearts/*<-_empty_::Enums.Suits.Hearts.*/, Spades/*<-_empty_::Enums.Suits.Spades.*/, Clubs/*<-_empty_::Enums.Suits.Clubs.*/, Diamonds/*<-_empty_::Enums.Suits.Diamonds.*/ + + object Suits/*<-_empty_::Enums.Suits.*/ with + def (suit/*<-_empty_::Enums.Suits.isRed().*//*<-_empty_::Enums.Suits.isRed().(suit)*/: Suits/*->_empty_::Enums.Suits#*/) isRed: Boolean/*->scala::Boolean#*/ = + suit/*->_empty_::Enums.Suits.isRed().(suit)*/ ==/*->scala::Any#`==`().*/ Hearts/*->_empty_::Enums.Suits.Hearts.*/ ||/*->scala::Boolean#`||`().*/ suit/*->_empty_::Enums.Suits.isRed().(suit)*/ ==/*->scala::Any#`==`().*/ Diamonds/*->_empty_::Enums.Suits.Diamonds.*/ + + def (suit: /*<-_empty_::Enums.Suits.isBlack().*//*<-_empty_::Enums.Suits.isBlack().(suit)*/Suits/*->_empty_::Enums.Suits#*/) isBlack: Boolean/*->scala::Boolean#*/ = suit/*->_empty_::Enums.Suits.isBlack().(suit)*/ match + case Spades/*->_empty_::Enums.Suits.Spades.*/ | Diamonds/*->_empty_::Enums.Suits.Diamonds.*/ => true + case _ => false + enum WeekDays/*<-_empty_::Enums.WeekDays#*/ with case Monday/*<-_empty_::Enums.WeekDays.Monday.*/ case Tuesday/*<-_empty_::Enums.WeekDays.Tuesday.*/ @@ -32,12 +43,16 @@ object Enums/*<-_empty_::Enums.*/ with case IntTag/*<-_empty_::Enums.Tag.IntTag.*/ extends Tag/*->_empty_::Enums.Tag#*/[Int/*->scala::Int#*/] case BooleanTag/*<-_empty_::Enums.Tag.BooleanTag.*/ extends Tag/*->_empty_::Enums.Tag#*/[Boolean/*->scala::Boolean#*/] - enum =:=/*<-_empty_::Enums.`=:=`#*/[A/*<-_empty_::Enums.`=:=`#[A]*/, B/*<-_empty_::Enums.`=:=`#[B]*/] with - case Refl/*<-_empty_::Enums.`=:=`.Refl#*/[C/*<-_empty_::Enums.`=:=`.Refl#[C]*/]() extends (C/*->_empty_::Enums.`=:=`.Refl#[C]*/ =:=/*->_empty_::Enums.`=:=`#*/ C/*->_empty_::Enums.`=:=`.Refl#[C]*/) + enum <:_empty_::Enums.`<:<`.Refl#[C]*/ <:_empty_::Enums.`<:<`#*/ C/*->_empty_::Enums.`<:<`.Refl#[C]*/) + + object <:_empty_::Enums.`<:<`.given_T().[T]*/ <:_empty_::Enums.`<:<`#*/ T/*->_empty_::Enums.`<:<`.given_T().[T]*/) = Refl/*->_empty_::Enums.`<:<`.Refl.*/() + + def [A, B]/*<-_empty_::Enums.unwrap().*//*<-_empty_::Enums.unwrap().[A]*//*<-_empty_::Enums.unwrap().[B]*/(opt/*<-_empty_::Enums.unwrap().(opt)*/: Option/*->scala::Option#*/[A/*->_empty_::Enums.unwrap().[A]*/]) unwrap(given ev/*<-_empty_::Enums.unwrap().(ev)*/: A/*->_empty_::Enums.unwrap().[A]*/ <:_empty_::Enums.`<:<`#*/ Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]): Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/] = ev/*->_empty_::Enums.unwrap().(ev)*/ match + case Refl/*->_empty_::Enums.`<:<`.Refl.*/() => opt/*->_empty_::Enums.unwrap().(opt)*/.flatMap/*->scala::Option#flatMap().*/(identity/*->scala::Predef.identity().*/[Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]]) - def unwrap/*<-_empty_::Enums.unwrap().*/[A/*<-_empty_::Enums.unwrap().[A]*/,B/*<-_empty_::Enums.unwrap().[B]*/](opt/*<-_empty_::Enums.unwrap().(opt)*/: Option/*->scala::Option#*/[A/*->_empty_::Enums.unwrap().[A]*/])(given ev/*<-_empty_::Enums.unwrap().(ev)*/: A/*->_empty_::Enums.unwrap().[A]*/ =:=/*->_empty_::Enums.`=:=`#*/ Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]): Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/] = ev/*->_empty_::Enums.unwrap().(ev)*/ match - case Refl/*->_empty_::Enums.`=:=`.Refl.*/() => opt/*->_empty_::Enums.unwrap().(opt)*/.flatMap/*->scala::Option#flatMap().*/(identity/*->scala::Predef.identity().*/[Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]]) - case _ => None/*->scala::None.*/ // TODO remove after https://github.com/lampepfl/dotty/issues/7524 is fixed + val some1/*<-_empty_::Enums.some1.*/ = /*->_empty_::Enums.unwrap().*/Some/*->scala::Some.*/(Some/*->scala::Some.*/(1))/*->_empty_::Enums.`<:<`.given_T().*/.unwrap enum Planet/*<-_empty_::Enums.Planet#*/(mass/*<-_empty_::Enums.Planet#mass.*/: Double/*->scala::Double#*/, radius/*<-_empty_::Enums.Planet#radius.*/: Double/*->scala::Double#*/) extends java.lang.Enum/*->java::lang::Enum#*/[Planet/*->_empty_::Enums.Planet#*/]/*->java::lang::Enum#``().*/ with private final val G/*<-_empty_::Enums.Planet#G.*/ = 6.67300E-11 diff --git a/tests/semanticdb/expect/Enums.scala b/tests/semanticdb/expect/Enums.scala index dd4b5689e74f..28f2a8a4372e 100644 --- a/tests/semanticdb/expect/Enums.scala +++ b/tests/semanticdb/expect/Enums.scala @@ -1,5 +1,5 @@ object Enums with - import =:=._ + import <:<._ enum Colour with import Colour.Red @@ -8,6 +8,17 @@ object Enums with enum Directions with case North, East, South, West + enum Suits derives Eql with + case Hearts, Spades, Clubs, Diamonds + + object Suits with + def (suit: Suits) isRed: Boolean = + suit == Hearts || suit == Diamonds + + def (suit: Suits) isBlack: Boolean = suit match + case Spades | Diamonds => true + case _ => false + enum WeekDays with case Monday case Tuesday @@ -32,12 +43,16 @@ object Enums with case IntTag extends Tag[Int] case BooleanTag extends Tag[Boolean] - enum =:=[A, B] with - case Refl[C]() extends (C =:= C) + enum <:<[-A, B] with + case Refl[C]() extends (C <:< C) - def unwrap[A,B](opt: Option[A])(given ev: A =:= Option[B]): Option[B] = ev match + object <:< with + given [T]: (T <:< T) = Refl() + + def [A, B](opt: Option[A]) unwrap(given ev: A <:< Option[B]): Option[B] = ev match case Refl() => opt.flatMap(identity[Option[B]]) - case _ => None // TODO remove after https://github.com/lampepfl/dotty/issues/7524 is fixed + + val some1 = Some(Some(1)).unwrap enum Planet(mass: Double, radius: Double) extends java.lang.Enum[Planet] with private final val G = 6.67300E-11 diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 708148862430..3e77275c8c5b 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -544,8 +544,8 @@ Schema => SemanticDB v4 Uri => Enums.scala Text => empty Language => Scala -Symbols => 73 entries -Occurrences => 146 entries +Symbols => 88 entries +Occurrences => 183 entries Symbols: _empty_/Enums. => final object Enums @@ -595,6 +595,17 @@ _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.Suits# => abstract sealed enum class Suits +_empty_/Enums.Suits#``(). => primary ctor +_empty_/Enums.Suits. => final object Suits +_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.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.Tag# => abstract sealed enum class Tag _empty_/Enums.Tag#[A] => typeparam A _empty_/Enums.Tag#``(). => primary ctor @@ -609,13 +620,17 @@ _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.`=:=`# => abstract sealed enum class =:= -_empty_/Enums.`=:=`#[A] => typeparam A -_empty_/Enums.`=:=`#[B] => typeparam B -_empty_/Enums.`=:=`#``(). => primary ctor -_empty_/Enums.`=:=`.Refl# => final case enum class Refl -_empty_/Enums.`=:=`.Refl#[C] => typeparam C -_empty_/Enums.`=:=`.Refl#``(). => primary ctor +_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.`<:<`.given_T(). => final implicit method given_T +_empty_/Enums.`<:<`.given_T().[T] => typeparam T +_empty_/Enums.some1. => val method some1 _empty_/Enums.unwrap(). => method unwrap _empty_/Enums.unwrap().(ev) => implicit param ev _empty_/Enums.unwrap().(opt) => param opt @@ -624,7 +639,7 @@ _empty_/Enums.unwrap().[B] => typeparam B Occurrences: [0:7..0:12) Enums <- _empty_/Enums. -[1:9..1:12) =:= -> _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. @@ -638,137 +653,174 @@ Occurrences: [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:15) WeekDays <- _empty_/Enums.WeekDays# -[11:4..11:4) <- _empty_/Enums.WeekDays#``(). -[11:9..11:15) Monday <- _empty_/Enums.WeekDays.Monday. -[12:9..12:16) Tuesday <- _empty_/Enums.WeekDays.Tuesday. -[13:9..13:18) Wednesday <- _empty_/Enums.WeekDays.Wednesday. -[14:9..14:17) Thursday <- _empty_/Enums.WeekDays.Thursday. -[15:9..15:15) Friday <- _empty_/Enums.WeekDays.Friday. -[16:9..16:17) Saturday <- _empty_/Enums.WeekDays.Saturday. -[17:9..17:15) Sunday <- _empty_/Enums.WeekDays.Sunday. -[19:7..19:11) Coin <- _empty_/Enums.Coin# -[19:11..19:23) <- _empty_/Enums.Coin#``(). -[19:12..19:17) value <- _empty_/Enums.Coin#value. -[19:19..19:22) Int -> scala/Int# -[20:9..20:14) Penny <- _empty_/Enums.Coin.Penny. -[20:26..20:30) Coin -> _empty_/Enums.Coin# -[20:30..20:30) -> _empty_/Enums.Coin#``(). -[21:9..21:15) Nickel <- _empty_/Enums.Coin.Nickel. -[21:26..21:30) Coin -> _empty_/Enums.Coin# -[21:30..21:30) -> _empty_/Enums.Coin#``(). -[22:9..22:13) Dime <- _empty_/Enums.Coin.Dime. -[22:26..22:30) Coin -> _empty_/Enums.Coin# -[22:30..22:30) -> _empty_/Enums.Coin#``(). -[23:9..23:16) Quarter <- _empty_/Enums.Coin.Quarter. -[23:26..23:30) Coin -> _empty_/Enums.Coin# -[23:30..23:30) -> _empty_/Enums.Coin#``(). -[24:9..24:15) Dollar <- _empty_/Enums.Coin.Dollar. -[24:26..24:30) Coin -> _empty_/Enums.Coin# -[24:30..24:30) -> _empty_/Enums.Coin#``(). -[26:7..26:12) Maybe <- _empty_/Enums.Maybe# -[26:12..26:16) <- _empty_/Enums.Maybe#``(). -[26:14..26:15) A <- _empty_/Enums.Maybe#[A] -[27:4..27:4) -> _empty_/Enums.Maybe#``(). -[27:9..27:13) Just <- _empty_/Enums.Maybe.Just# -[27:13..27:23) <- _empty_/Enums.Maybe.Just#``(). -[27:14..27:19) value <- _empty_/Enums.Maybe.Just#value. -[27:21..27:22) A -> _empty_/Enums.Maybe.Just#[A] -[28:4..28:4) -> _empty_/Enums.Maybe#``(). -[28:9..28:13) None <- _empty_/Enums.Maybe.None. -[30:7..30:10) Tag <- _empty_/Enums.Tag# -[30:10..30:13) <- _empty_/Enums.Tag#``(). -[30:11..30:12) A <- _empty_/Enums.Tag#[A] -[31:9..31:15) IntTag <- _empty_/Enums.Tag.IntTag. -[31:24..31:27) Tag -> _empty_/Enums.Tag# -[31:28..31:31) Int -> scala/Int# -[31:32..31:32) -> _empty_/Enums.Tag#``(). -[32:9..32:19) BooleanTag <- _empty_/Enums.Tag.BooleanTag. -[32:28..32:31) Tag -> _empty_/Enums.Tag# -[32:32..32:39) Boolean -> scala/Boolean# -[32:40..32:40) -> _empty_/Enums.Tag#``(). -[34:7..34:10) =:= <- _empty_/Enums.`=:=`# -[34:10..34:16) <- _empty_/Enums.`=:=`#``(). -[34:11..34:12) A <- _empty_/Enums.`=:=`#[A] -[34:14..34:15) B <- _empty_/Enums.`=:=`#[B] -[35:9..35:13) Refl <- _empty_/Enums.`=:=`.Refl# -[35:13..35:18) <- _empty_/Enums.`=:=`.Refl#``(). -[35:14..35:15) C <- _empty_/Enums.`=:=`.Refl#[C] -[35:28..35:29) C -> _empty_/Enums.`=:=`.Refl#[C] -[35:30..35:33) =:= -> _empty_/Enums.`=:=`# -[35:34..35:35) C -> _empty_/Enums.`=:=`.Refl#[C] -[35:35..35:35) -> _empty_/Enums.`=:=`#``(). -[37:6..37:12) unwrap <- _empty_/Enums.unwrap(). -[37:13..37:14) A <- _empty_/Enums.unwrap().[A] -[37:15..37:16) B <- _empty_/Enums.unwrap().[B] -[37:18..37:21) opt <- _empty_/Enums.unwrap().(opt) -[37:23..37:29) Option -> scala/Option# -[37:30..37:31) A -> _empty_/Enums.unwrap().[A] -[37:40..37:42) ev <- _empty_/Enums.unwrap().(ev) -[37:44..37:45) A -> _empty_/Enums.unwrap().[A] -[37:46..37:49) =:= -> _empty_/Enums.`=:=`# -[37:50..37:56) Option -> scala/Option# -[37:57..37:58) B -> _empty_/Enums.unwrap().[B] -[37:62..37:68) Option -> scala/Option# -[37:69..37:70) B -> _empty_/Enums.unwrap().[B] -[37:74..37:76) ev -> _empty_/Enums.unwrap().(ev) -[38:9..38:13) Refl -> _empty_/Enums.`=:=`.Refl. -[38:19..38:22) opt -> _empty_/Enums.unwrap().(opt) -[38:23..38:30) flatMap -> scala/Option#flatMap(). -[38:31..38:39) identity -> scala/Predef.identity(). -[38:40..38:46) Option -> scala/Option# -[38:47..38:48) B -> _empty_/Enums.unwrap().[B] -[39:19..39:23) None -> scala/None. -[41:7..41:13) Planet <- _empty_/Enums.Planet# -[41:13..41:43) <- _empty_/Enums.Planet#``(). -[41:14..41:18) mass <- _empty_/Enums.Planet#mass. -[41:20..41:26) Double -> scala/Double# -[41:28..41:34) radius <- _empty_/Enums.Planet#radius. -[41:36..41:42) Double -> scala/Double# -[41:52..41:56) java -> java/ -[41:57..41:61) lang -> java/lang/ -[41:62..41:66) Enum -> java/lang/Enum# -[41:67..41:73) Planet -> _empty_/Enums.Planet# -[41:74..41:74) -> java/lang/Enum#``(). -[42:22..42:23) G <- _empty_/Enums.Planet#G. -[43:8..43:22) surfaceGravity <- _empty_/Enums.Planet#surfaceGravity(). -[43:25..43:26) G -> _empty_/Enums.Planet#G. -[43:27..43:28) * -> scala/Double#`*`(+6). -[43:29..43:33) mass -> _empty_/Enums.Planet#mass. -[43:34..43:35) / -> scala/Double#`/`(+6). -[43:37..43:43) radius -> _empty_/Enums.Planet#radius. -[43:44..43:45) * -> scala/Double#`*`(+6). -[43:46..43:52) radius -> _empty_/Enums.Planet#radius. -[44:8..44:21) surfaceWeight <- _empty_/Enums.Planet#surfaceWeight(). -[44:22..44:31) otherMass <- _empty_/Enums.Planet#surfaceWeight().(otherMass) -[44:33..44:39) Double -> scala/Double# -[44:43..44:52) otherMass -> _empty_/Enums.Planet#surfaceWeight().(otherMass) -[44:53..44:54) * -> scala/Double#`*`(+6). -[44:55..44:69) surfaceGravity -> _empty_/Enums.Planet#surfaceGravity(). -[46:9..46:16) Mercury <- _empty_/Enums.Planet.Mercury. -[46:25..46:31) Planet -> _empty_/Enums.Planet# -[46:31..46:31) -> _empty_/Enums.Planet#``(). -[47:9..47:14) Venus <- _empty_/Enums.Planet.Venus. -[47:25..47:31) Planet -> _empty_/Enums.Planet# -[47:31..47:31) -> _empty_/Enums.Planet#``(). -[48:9..48:14) Earth <- _empty_/Enums.Planet.Earth. -[48:25..48:31) Planet -> _empty_/Enums.Planet# -[48:31..48:31) -> _empty_/Enums.Planet#``(). -[49:9..49:13) Mars <- _empty_/Enums.Planet.Mars. -[49:25..49:31) Planet -> _empty_/Enums.Planet# -[49:31..49:31) -> _empty_/Enums.Planet#``(). -[50:9..50:16) Jupiter <- _empty_/Enums.Planet.Jupiter. -[50:25..50:31) Planet -> _empty_/Enums.Planet# -[50:31..50:31) -> _empty_/Enums.Planet#``(). -[51:9..51:15) Saturn <- _empty_/Enums.Planet.Saturn. -[51:25..51:31) Planet -> _empty_/Enums.Planet# -[51:31..51:31) -> _empty_/Enums.Planet#``(). -[52:9..52:15) Uranus <- _empty_/Enums.Planet.Uranus. -[52:25..52:31) Planet -> _empty_/Enums.Planet# -[52:31..52:31) -> _empty_/Enums.Planet#``(). -[53:9..53:16) Neptune <- _empty_/Enums.Planet.Neptune. -[53:25..53:31) Planet -> _empty_/Enums.Planet# -[53:31..53:31) -> _empty_/Enums.Planet#``(). +[10:7..10:12) Suits <- _empty_/Enums.Suits# +[10:21..10:21) <- _empty_/Enums.Suits#``(). +[10:21..10:21) -> scala/Eql.derived. +[11:9..11:15) Hearts <- _empty_/Enums.Suits.Hearts. +[11:17..11:23) Spades <- _empty_/Enums.Suits.Spades. +[11:25..11:30) Clubs <- _empty_/Enums.Suits.Clubs. +[11:32..11:40) Diamonds <- _empty_/Enums.Suits.Diamonds. +[13:9..13:14) Suits <- _empty_/Enums.Suits. +[14:8..14:13) (suit <- _empty_/Enums.Suits.isRed(). +[14:9..14:13) suit <- _empty_/Enums.Suits.isRed().(suit) +[14:15..14:20) Suits -> _empty_/Enums.Suits# +[14:29..14:36) Boolean -> scala/Boolean# +[15:6..15:10) suit -> _empty_/Enums.Suits.isRed().(suit) +[15:11..15:13) == -> scala/Any#`==`(). +[15:14..15:20) Hearts -> _empty_/Enums.Suits.Hearts. +[15:21..15:23) || -> scala/Boolean#`||`(). +[15:24..15:28) suit -> _empty_/Enums.Suits.isRed().(suit) +[15:29..15:31) == -> scala/Any#`==`(). +[15:32..15:40) Diamonds -> _empty_/Enums.Suits.Diamonds. +[17:8..17:15) (suit: <- _empty_/Enums.Suits.isBlack(). +[17:9..17:13) suit <- _empty_/Enums.Suits.isBlack().(suit) +[17:15..17:20) Suits -> _empty_/Enums.Suits# +[17:31..17:38) Boolean -> scala/Boolean# +[17:41..17:45) suit -> _empty_/Enums.Suits.isBlack().(suit) +[18:11..18:17) Spades -> _empty_/Enums.Suits.Spades. +[18:20..18:28) Diamonds -> _empty_/Enums.Suits.Diamonds. +[21:7..21:15) WeekDays <- _empty_/Enums.WeekDays# +[22:4..22:4) <- _empty_/Enums.WeekDays#``(). +[22:9..22:15) Monday <- _empty_/Enums.WeekDays.Monday. +[23:9..23:16) Tuesday <- _empty_/Enums.WeekDays.Tuesday. +[24:9..24:18) Wednesday <- _empty_/Enums.WeekDays.Wednesday. +[25:9..25:17) Thursday <- _empty_/Enums.WeekDays.Thursday. +[26:9..26:15) Friday <- _empty_/Enums.WeekDays.Friday. +[27:9..27:17) Saturday <- _empty_/Enums.WeekDays.Saturday. +[28:9..28:15) Sunday <- _empty_/Enums.WeekDays.Sunday. +[30:7..30:11) Coin <- _empty_/Enums.Coin# +[30:11..30:23) <- _empty_/Enums.Coin#``(). +[30:12..30:17) value <- _empty_/Enums.Coin#value. +[30:19..30:22) Int -> scala/Int# +[31:9..31:14) Penny <- _empty_/Enums.Coin.Penny. +[31:26..31:30) Coin -> _empty_/Enums.Coin# +[31:30..31:30) -> _empty_/Enums.Coin#``(). +[32:9..32:15) Nickel <- _empty_/Enums.Coin.Nickel. +[32:26..32:30) Coin -> _empty_/Enums.Coin# +[32:30..32:30) -> _empty_/Enums.Coin#``(). +[33:9..33:13) Dime <- _empty_/Enums.Coin.Dime. +[33:26..33:30) Coin -> _empty_/Enums.Coin# +[33:30..33:30) -> _empty_/Enums.Coin#``(). +[34:9..34:16) Quarter <- _empty_/Enums.Coin.Quarter. +[34:26..34:30) Coin -> _empty_/Enums.Coin# +[34:30..34:30) -> _empty_/Enums.Coin#``(). +[35:9..35:15) Dollar <- _empty_/Enums.Coin.Dollar. +[35:26..35:30) Coin -> _empty_/Enums.Coin# +[35:30..35:30) -> _empty_/Enums.Coin#``(). +[37:7..37:12) Maybe <- _empty_/Enums.Maybe# +[37:12..37:16) <- _empty_/Enums.Maybe#``(). +[37:14..37:15) A <- _empty_/Enums.Maybe#[A] +[38:4..38:4) -> _empty_/Enums.Maybe#``(). +[38:9..38:13) Just <- _empty_/Enums.Maybe.Just# +[38:13..38:23) <- _empty_/Enums.Maybe.Just#``(). +[38:14..38:19) value <- _empty_/Enums.Maybe.Just#value. +[38:21..38:22) A -> _empty_/Enums.Maybe.Just#[A] +[39:4..39:4) -> _empty_/Enums.Maybe#``(). +[39:9..39:13) None <- _empty_/Enums.Maybe.None. +[41:7..41:10) Tag <- _empty_/Enums.Tag# +[41:10..41:13) <- _empty_/Enums.Tag#``(). +[41:11..41:12) A <- _empty_/Enums.Tag#[A] +[42:9..42:15) IntTag <- _empty_/Enums.Tag.IntTag. +[42:24..42:27) Tag -> _empty_/Enums.Tag# +[42:28..42:31) Int -> scala/Int# +[42:32..42:32) -> _empty_/Enums.Tag#``(). +[43:9..43:19) BooleanTag <- _empty_/Enums.Tag.BooleanTag. +[43:28..43:31) Tag -> _empty_/Enums.Tag# +[43:32..43:39) Boolean -> scala/Boolean# +[43:40..43:40) -> _empty_/Enums.Tag#``(). +[45:7..45:10) <:< <- _empty_/Enums.`<:<`# +[45:10..45:17) <- _empty_/Enums.`<:<`#``(). +[45:12..45:13) A <- _empty_/Enums.`<:<`#[A] +[45:15..45:16) B <- _empty_/Enums.`<:<`#[B] +[46:9..46:13) Refl <- _empty_/Enums.`<:<`.Refl# +[46:13..46:18) <- _empty_/Enums.`<:<`.Refl#``(). +[46:14..46:15) C <- _empty_/Enums.`<:<`.Refl#[C] +[46:28..46:29) C -> _empty_/Enums.`<:<`.Refl#[C] +[46:30..46:33) <:< -> _empty_/Enums.`<:<`# +[46:34..46:35) C -> _empty_/Enums.`<:<`.Refl#[C] +[46:35..46:35) -> _empty_/Enums.`<:<`#``(). +[48:9..48:12) <:< <- _empty_/Enums.`<:<`. +[49:10..49:17) [T]: (T <- _empty_/Enums.`<:<`.given_T(). +[49:11..49:12) T <- _empty_/Enums.`<:<`.given_T().[T] +[49:16..49:17) T -> _empty_/Enums.`<:<`.given_T().[T] +[49:18..49:21) <:< -> _empty_/Enums.`<:<`# +[49:22..49:23) T -> _empty_/Enums.`<:<`.given_T().[T] +[49:27..49:31) Refl -> _empty_/Enums.`<:<`.Refl. +[51:6..51:12) [A, B] <- _empty_/Enums.unwrap(). +[51:7..51:8) A <- _empty_/Enums.unwrap().[A] +[51:10..51:11) B <- _empty_/Enums.unwrap().[B] +[51:13..51:16) opt <- _empty_/Enums.unwrap().(opt) +[51:18..51:24) Option -> scala/Option# +[51:25..51:26) A -> _empty_/Enums.unwrap().[A] +[51:42..51:44) ev <- _empty_/Enums.unwrap().(ev) +[51:46..51:47) A -> _empty_/Enums.unwrap().[A] +[51:48..51:51) <:< -> _empty_/Enums.`<:<`# +[51:52..51:58) Option -> scala/Option# +[51:59..51:60) B -> _empty_/Enums.unwrap().[B] +[51:64..51:70) Option -> scala/Option# +[51:71..51:72) B -> _empty_/Enums.unwrap().[B] +[51:76..51:78) ev -> _empty_/Enums.unwrap().(ev) +[52:9..52:13) Refl -> _empty_/Enums.`<:<`.Refl. +[52: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:40..52:46) Option -> scala/Option# +[52:47..52:48) B -> _empty_/Enums.unwrap().[B] +[54:6..54:11) some1 <- _empty_/Enums.some1. +[54:14..54:14) -> _empty_/Enums.unwrap(). +[54:14..54:18) Some -> scala/Some. +[54:19..54:23) Some -> scala/Some. +[54:27..54:27) -> _empty_/Enums.`<:<`.given_T(). +[56:7..56:13) Planet <- _empty_/Enums.Planet# +[56:13..56:43) <- _empty_/Enums.Planet#``(). +[56:14..56:18) mass <- _empty_/Enums.Planet#mass. +[56:20..56:26) Double -> scala/Double# +[56:28..56:34) radius <- _empty_/Enums.Planet#radius. +[56:36..56:42) Double -> scala/Double# +[56:52..56:56) java -> java/ +[56:57..56:61) lang -> java/lang/ +[56:62..56:66) Enum -> java/lang/Enum# +[56:67..56:73) Planet -> _empty_/Enums.Planet# +[56:74..56:74) -> java/lang/Enum#``(). +[57:22..57:23) G <- _empty_/Enums.Planet#G. +[58:8..58:22) surfaceGravity <- _empty_/Enums.Planet#surfaceGravity(). +[58:25..58:26) G -> _empty_/Enums.Planet#G. +[58:27..58:28) * -> scala/Double#`*`(+6). +[58:29..58:33) mass -> _empty_/Enums.Planet#mass. +[58:34..58:35) / -> scala/Double#`/`(+6). +[58:37..58:43) radius -> _empty_/Enums.Planet#radius. +[58:44..58:45) * -> scala/Double#`*`(+6). +[58:46..58:52) radius -> _empty_/Enums.Planet#radius. +[59:8..59:21) surfaceWeight <- _empty_/Enums.Planet#surfaceWeight(). +[59:22..59:31) otherMass <- _empty_/Enums.Planet#surfaceWeight().(otherMass) +[59:33..59:39) Double -> scala/Double# +[59:43..59:52) otherMass -> _empty_/Enums.Planet#surfaceWeight().(otherMass) +[59:53..59:54) * -> scala/Double#`*`(+6). +[59:55..59:69) surfaceGravity -> _empty_/Enums.Planet#surfaceGravity(). +[61:9..61:16) Mercury <- _empty_/Enums.Planet.Mercury. +[61:25..61:31) Planet -> _empty_/Enums.Planet# +[61:31..61:31) -> _empty_/Enums.Planet#``(). +[62:9..62:14) Venus <- _empty_/Enums.Planet.Venus. +[62:25..62:31) Planet -> _empty_/Enums.Planet# +[62:31..62:31) -> _empty_/Enums.Planet#``(). +[63:9..63:14) Earth <- _empty_/Enums.Planet.Earth. +[63:25..63:31) Planet -> _empty_/Enums.Planet# +[63:31..63:31) -> _empty_/Enums.Planet#``(). +[64:9..64:13) Mars <- _empty_/Enums.Planet.Mars. +[64:25..64:31) Planet -> _empty_/Enums.Planet# +[64:31..64:31) -> _empty_/Enums.Planet#``(). +[65:9..65:16) Jupiter <- _empty_/Enums.Planet.Jupiter. +[65:25..65:31) Planet -> _empty_/Enums.Planet# +[65:31..65:31) -> _empty_/Enums.Planet#``(). +[66:9..66:15) Saturn <- _empty_/Enums.Planet.Saturn. +[66:25..66:31) Planet -> _empty_/Enums.Planet# +[66:31..66:31) -> _empty_/Enums.Planet#``(). +[67:9..67:15) Uranus <- _empty_/Enums.Planet.Uranus. +[67:25..67:31) Planet -> _empty_/Enums.Planet# +[67:31..67:31) -> _empty_/Enums.Planet#``(). +[68:9..68:16) Neptune <- _empty_/Enums.Planet.Neptune. +[68:25..68:31) Planet -> _empty_/Enums.Planet# +[68:31..68:31) -> _empty_/Enums.Planet#``(). expect/EtaExpansion.scala _________________________ From 1924ea5308c4a9eaff5a177366a96dfb8e092345 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sun, 17 Nov 2019 14:48:17 +0100 Subject: [PATCH 076/107] remove special case for dollarvalues in enum companion --- .../dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala | 8 -------- 1 file changed, 8 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 8b39c4c29de3..b0850a45ddfc 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -473,14 +473,6 @@ class ExtractSemanticDB extends Phase { traverse(tree.self) if ctorSym.owner.is(Enum, butNot=Case) tree.body.foreachUntilImport(traverse).foreach(traverse) - else if ctorSym.owner.is(ModuleClass) && ctorSym.owner.companionClass.is(Enum, butNot=Case) - // TODO: Remove this branch if $values is removed or made synthetic - tree.body.filter({ - case tree @ ValDef(nme.DOLLAR_VALUES,_,_) - if tree.mods.flags.is(Private) - && tree.symbol.info.typeSymbol == defn.EnumValuesClass => false - case _ => true - }).foreach(traverse) else tree.body.foreach(traverse) case tree: Assign => From ddae2a7f7a81507d0b00d8c195b7376df574d354 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Sun, 17 Nov 2019 23:59:03 +0100 Subject: [PATCH 077/107] refactor definitions --- .../dotc/semanticdb/ExtractSemanticDB.scala | 327 ++++++++---------- .../dotty/tools/dotc/semanticdb/Scala.scala | 75 +++- 2 files changed, 205 insertions(+), 197 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index b0850a45ddfc..a0335fe87d65 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -4,12 +4,10 @@ package semanticdb import core._ import Phases._ -import ast.Trees._ -import ast.untpd +import ast.tpd._ import Contexts._ import Symbols._ import Flags._ -import Decorators._ import Names.Name import StdNames.nme import util.Spans.Span @@ -18,6 +16,9 @@ import collection.mutable import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} import java.nio.file.Paths +import ast.untpd.given +import NameOps.given + import scala.annotation.{ threadUnsafe => tu, tailrec } /** Extract symbol references and uses to semanticdb files. @@ -25,10 +26,9 @@ import scala.annotation.{ threadUnsafe => tu, tailrec } * for a description of the format. * TODO: Also extract type information */ -class ExtractSemanticDB extends Phase { - import ast.tpd._ - import untpd.given - import NameOps.given +class ExtractSemanticDB extends Phase with + import Scala.{_, given} + import Symbols.given override val phaseName: String = ExtractSemanticDB.name @@ -44,21 +44,8 @@ class ExtractSemanticDB extends Phase { extract.traverse(unit.tpdTree) ExtractSemanticDB.write(unit.source, extract.occurrences.toList, extract.symbols.toList) - def (name: Name) isScala2PackageObjectName: Boolean = name match { - case name: Names.TermName => name == nme.PACKAGE - case name: Names.TypeName => - name.toTermName match { - case NameKinds.ModuleClassName(original) => original.isScala2PackageObjectName - case _ => false - } - } - - def (sym: Symbol) isScala2PackageObject(given Context): Boolean = - sym.name.isScala2PackageObjectName && sym.owner.is(Package) && sym.is(Module) - /** Extractor of symbol occurrences from trees */ - class Extractor extends TreeTraverser { - import Scala.{_, given} + class Extractor extends TreeTraverser with private var nextLocalIdx: Int = 0 @@ -66,9 +53,8 @@ class ExtractSemanticDB extends Phase { private val locals = mutable.HashMap[Symbol, Int]() /** The local symbol(s) starting at given offset */ - private val symsAtOffset = new mutable.HashMap[Int, Set[Symbol]]() { + private val symsAtOffset = new mutable.HashMap[Int, Set[Symbol]]() with override def default(key: Int) = Set[Symbol]() - } /** The extracted symbol occurrences */ val occurrences = new mutable.ListBuffer[SymbolOccurrence]() @@ -79,51 +65,15 @@ class ExtractSemanticDB extends Phase { /** The symbol occurrences generated so far, as a set */ private val generated = new mutable.HashSet[SymbolOccurrence] - private val unicodeEscape = raw"\$$u(\p{XDigit}{4})".r - - /**Necessary because if this phase is before `getters` then accessor info is not propagated from the tree to the - * symbol yet. - */ - private enum SymbolKind derives Eql with - kind => - - case Val, Var, Setter, Abstract - - def isVar: Boolean = - kind == Var - || kind == Setter - - def isVal: Boolean = - kind == Val - - def isValOrVar: Boolean = - kind.isVar - || kind.isVal - - private object SymbolKind with - val SingletonVal = Set(Val) - val SingletonVar = Set(Var) - - private def isWildcard(name: Name)(given ctx: Context) = name match - case nme.WILDCARD | WILDCARDTypeName => true - case _ if name.is(NameKinds.WildcardParamName) => true - case _ => false - /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = def isJavaIdent(str: String) = isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) - def (name: Name) unescapeUnicode = { - unicodeEscape.replaceAllIn(name.toString, m => - String.valueOf(Integer.parseInt(m.group(1), 16).toChar) - ) - } - def addName(name: Name) = - val str = name.unescapeUnicode - if isJavaIdent(str) then b `append` str + val str = name.toString.unescapeUnicode + if isJavaIdent(str) then b append str else b append '`' append str append '`' /** Is symbol global? Non-global symbols get localX names */ @@ -135,13 +85,13 @@ class ExtractSemanticDB extends Phase { if !owner.isRoot then addSymName(b, owner) def addOverloadIdx(sym: Symbol): Unit = - val decls = { + val decls = val decls0 = sym.owner.info.decls.lookupAll(sym.name) if sym.owner.isAllOf(JavaModule) decls0 ++ sym.owner.companionClass.info.decls.lookupAll(sym.name) else decls0 - } + end decls val alts = decls.filter(_.is(Method)).toList.reverse alts match case notSym :: rest if sym != notSym => @@ -196,11 +146,11 @@ class ExtractSemanticDB extends Phase { /** The semanticdb name of the given symbol */ private def symbolName(sym: Symbol)(given ctx: Context): String = - val b = StringBuilder() + val b = StringBuilder(20) addSymName(b, sym) b.toString - private def source(given ctx: Context) = ctx.compilationUnit.source + inline private def source(given ctx: Context) = ctx.compilationUnit.source private def range(span: Span)(given ctx: Context): Option[Range] = def lineCol(offset: Int) = (source.offsetToLine(offset), source.column(offset)) @@ -208,28 +158,24 @@ class ExtractSemanticDB extends Phase { val (endLine, endCol) = lineCol(span.end) Some(Range(startLine, startCol, endLine, endCol)) - private val WILDCARDTypeName = nme.WILDCARD.toTypeName - /** Definitions of this symbol should be excluded from semanticdb */ private def excludeDef(sym: Symbol)(given Context): Boolean = !sym.exists || sym.isLocalDummy - || sym.is(Synthetic) || (sym.owner.is(Synthetic) && !sym.isAllOf(EnumCase)) + || sym.is(Synthetic) + || sym.owner.is(Synthetic) && !sym.isAllOf(EnumCase) || sym.isConstructor && sym.owner.is(ModuleClass) || sym.isAnonymous || excludeDefStrict(sym) private def excludeDefStrict(sym: Symbol)(given Context): Boolean = sym.name.is(NameKinds.DefaultGetterName) - - private def (sym: Symbol) isAnonymous(given Context): Boolean = - sym.isAnonymousClass - || sym.isAnonymousModuleVal - || sym.isAnonymousFunction + || sym.name.isWildcard /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = - excludeDefStrict(sym) || (excludeDef(sym) && span.start == span.end) + excludeDefStrict(sym) + || excludeDef(sym) && span.zeroLength private def symbolKind(sym: Symbol, symkinds: Set[SymbolKind])(given Context): SymbolInformation.Kind = if sym.isTypeParam @@ -244,7 +190,7 @@ class ExtractSemanticDB extends Phase { SymbolInformation.Kind.CONSTRUCTOR else if sym.isSelfSym SymbolInformation.Kind.SELF_PARAMETER - else if sym.isOneOf(Method) || symkinds.exists(_.isValOrVar) + else if sym.isOneOf(Method) || symkinds.exists(_.isVarOrVal) SymbolInformation.Kind.METHOD else if sym.isPackageObject SymbolInformation.Kind.PACKAGE_OBJECT @@ -265,45 +211,46 @@ class ExtractSemanticDB extends Phase { else SymbolInformation.Kind.UNKNOWN_KIND - private def symbolProps(sym: Symbol, symkinds: Set[SymbolKind])(given Context): Set[SymbolInformation.Property] = - val props = mutable.HashSet.empty[SymbolInformation.Property] + private def symbolProps(sym: Symbol, symkinds: Set[SymbolKind])(given Context): Int = + var props = 0 if sym.isPrimaryConstructor - props += SymbolInformation.Property.PRIMARY + props |= SymbolInformation.Property.PRIMARY.value if sym.is(Abstract) || symkinds.contains(SymbolKind.Abstract) - props += SymbolInformation.Property.ABSTRACT + props |= SymbolInformation.Property.ABSTRACT.value if sym.is(Final) - props += SymbolInformation.Property.FINAL + props |= SymbolInformation.Property.FINAL.value if sym.is(Sealed) - props += SymbolInformation.Property.SEALED + props |= SymbolInformation.Property.SEALED.value if sym.isOneOf(GivenOrImplicit) - props += SymbolInformation.Property.IMPLICIT + props |= SymbolInformation.Property.IMPLICIT.value if sym.is(Lazy) - props += SymbolInformation.Property.LAZY + props |= SymbolInformation.Property.LAZY.value if sym.isAllOf(CaseClass) || sym.isAllOf(EnumCase) - props += SymbolInformation.Property.CASE + props |= SymbolInformation.Property.CASE.value if sym.is(Covariant) - props += SymbolInformation.Property.COVARIANT + props |= SymbolInformation.Property.COVARIANT.value if sym.is(Contravariant) - props += SymbolInformation.Property.CONTRAVARIANT + props |= SymbolInformation.Property.CONTRAVARIANT.value if sym.isAllOf(DefaultMethod | JavaDefined) || sym.is(Accessor) && sym.name.is(NameKinds.DefaultGetterName) - props += SymbolInformation.Property.DEFAULT + props |= SymbolInformation.Property.DEFAULT.value if symkinds.exists(_.isVal) - props += SymbolInformation.Property.VAL + props |= SymbolInformation.Property.VAL.value if symkinds.exists(_.isVar) - props += SymbolInformation.Property.VAR + props |= SymbolInformation.Property.VAR.value if sym.is(JavaStatic) - props += SymbolInformation.Property.STATIC + props |= SymbolInformation.Property.STATIC.value if sym.is(Enum) - props += SymbolInformation.Property.ENUM - props.toSet - - private def symbolInfo(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(given Context): SymbolInformation = SymbolInformation( - symbol = symbolName, - language = Language.SCALA, - kind = symbolKind(sym, symkinds), - properties = symbolProps(sym, symkinds).foldLeft(0)(_ | _.value), - displayName = Symbols.displaySymbol(sym) - ) + props |= SymbolInformation.Property.ENUM.value + props + + private def symbolInfo(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(given Context): SymbolInformation = + SymbolInformation( + symbol = symbolName, + language = Language.SCALA, + kind = symbolKind(sym, symkinds), + properties = symbolProps(sym, symkinds), + displayName = Symbols.displaySymbol(sym) + ) private def registerSymbol(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(given Context): Unit = symbols += symbolInfo(sym, symbolName, symkinds) @@ -315,36 +262,37 @@ class ExtractSemanticDB extends Phase { generated += occ private def registerUse(sym: Symbol, span: Span)(given Context) = - if !excludeUseStrict(sym, span) && !isWildcard(sym.name) then + if !excludeUseStrict(sym, span) then registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE) private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind])(given Context) = - if !isWildcard(sym.name) then - val symbol = symbolName(sym) - registerOccurrence(symbol, span, SymbolOccurrence.Role.DEFINITION) - if !sym.is(Package) - registerSymbol(sym, symbol, symkinds) + val symbol = symbolName(sym) + registerOccurrence(symbol, span, SymbolOccurrence.Role.DEFINITION) + if !sym.is(Package) + registerSymbol(sym, symbol, symkinds) - private def spanOfSymbol(sym: Symbol, span: Span)(given Context): Span = { + private def spanOfSymbol(sym: Symbol, span: Span)(given Context): Span = val contents = if source.exists then source.content() else Array.empty[Char] val idx = contents.indexOfSlice(sym.name.show, span.start) val start = if idx >= 0 then idx else span.start Span(start, start + sym.name.show.length, start) - } + + private inline def (list: List[List[ValDef]]) isSingleArg = list match + case (_::Nil)::Nil => true + case _ => false private def (tree: DefDef) isSetterDef(given Context): Boolean = - tree.name.isSetterName && tree.mods.is(Accessor) && tree.vparamss.flatten.length == 1 + tree.name.isSetterName && tree.mods.is(Accessor) && tree.vparamss.isSingleArg - private def findGetters(ctorParams: List[ValDef], body: List[ast.tpd.Tree])(given Context): Map[Names.TermName, ValDef] = - if ctorParams.isEmpty then + private def findGetters(ctorParams: Set[Names.TermName], body: List[Tree])(given Context): Map[Names.TermName, ValDef] = + if ctorParams.isEmpty || body.isEmpty then Map.empty else - val ctorParamNames = ctorParams.map(_.name).toSet body.collect({ case tree: ValDef - if ctorParamNames.contains(tree.name) - && !tree.symbol.isPrivate => - tree.name -> tree + if ctorParams.contains(tree.name) + && !tree.symbol.isPrivate => + tree.name -> tree }).toMap end findGetters @@ -358,7 +306,9 @@ class ExtractSemanticDB extends Phase { else limit Span(start max limit, end) - private def (span: Span) hasLength: Boolean = span.start != span.end + private given spanOps: (span: Span) with + def hasLength: Boolean = span.start != span.end + def zeroLength: Boolean = span.start == span.end /**Consume head while not an import statement. * Returns the rest of the list after the first import, or else the empty list @@ -380,87 +330,91 @@ class ExtractSemanticDB extends Phase { private inline def matchingMemberType(ctorTypeParam: Symbol, classSym: Symbol)(given Context) = classSym.info.member(ctorTypeParam.name).symbol + /**Necessary because not all of the eventual flags are propagated from the Tree to the symbol yet. + */ + private def symbolKinds(tree: NamedDefTree)(given Context): Set[SymbolKind] = + if tree.symbol.isSelfSym + Set.empty + else + val symkinds = mutable.HashSet.empty[SymbolKind] + tree match + case tree: ValDef => + if !tree.symbol.owner.is(Method) + symkinds += (if tree.mods is Mutable then SymbolKind.Var else SymbolKind.Val) + if tree.rhs.isEmpty && !tree.symbol.isOneOf(TermParam | CaseAccessor | ParamAccessor) + symkinds += SymbolKind.Abstract + case tree: DefDef => + if tree.isSetterDef + symkinds += SymbolKind.Setter + else if tree.rhs.isEmpty + symkinds += SymbolKind.Abstract + case tree: Bind => symkinds += SymbolKind.Val + case _ => + symkinds.toSet + + private inline def ctorParams( + vparamss: List[List[ValDef]], body: List[Tree])(traverseTpt: => Tree => Unit)(given Context): Unit = + @tu lazy val getters = findGetters(vparamss.flatMap(_.map(_.name)).toSet, body) + for + vparams <- vparamss + vparam <- vparams + do + if !vparam.name.isWildcard + val symkinds = + getters.get(vparam.name).fold(SymbolKind.emptySet)(getter => + if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet) + registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds) + traverseTpt(vparam.tpt) + override def traverse(tree: Tree)(given Context): Unit = + + inline def traverseCtorParamTpt(ctorSym: Symbol, tpt: Tree): Unit = + val tptSym = tpt.symbol + if tptSym.owner == ctorSym + val found = matchingMemberType(tptSym, ctorSym.owner) + if !excludeUseStrict(found, tpt.span) && tpt.span.hasLength + registerUse(found, tpt.span) + else + traverse(tpt) + for annot <- tree.symbol.annotations do if annot.tree.span.exists && annot.symbol.owner != defn.ScalaAnnotationInternal then traverse(annot.tree) - def ctorParams(ctorSym: Symbol, vparamss: List[List[ValDef]], body: List[Tree]): Unit = - val ctorParams = vparamss.flatten - @tu lazy val getters = findGetters(ctorParams, body) - for vparam <- ctorParams do - if !isWildcard(vparam.name) - val symkinds = - getters.get(vparam.name).fold( - Set.empty[SymbolKind])( - getter => if getter.mods.is(Mutable) then SymbolKind.SingletonVar else SymbolKind.SingletonVal) - registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds) - val tptSym = vparam.tpt.symbol - if tptSym.owner == ctorSym - val found = matchingMemberType(tptSym, ctorSym.owner) - if !excludeUseStrict(found, vparam.tpt.span) && vparam.tpt.span.hasLength - registerUse(found, vparam.tpt.span) - else - traverse(vparam.tpt) - tree match case tree: PackageDef => if !excludeDef(tree.pid.symbol) && tree.pid.span.hasLength tree.pid match - case tree @ Select(qual, _) => - traverse(qual) - registerDefinition(tree.symbol, adjustSpanToName(tree.span, qual.span, tree.symbol.name), Set.empty) - case tree @ Ident(name) => - registerDefinition(tree.symbol, tree.span, Set.empty) + case tree @ Select(qual, name) => + registerDefinition(tree.symbol, adjustSpanToName(tree.span, qual.span, name), Set.empty) + traverse(qual) + case tree => registerDefinition(tree.symbol, tree.span, Set.empty) tree.stats.foreach(traverse) case tree: ValDef if tree.symbol.is(Module) => // skip module val case tree: NamedDefTree if !excludeDef(tree.symbol) && tree.span.hasLength => - val symkinds = - if tree.symbol.isSelfSym - Set.empty - else - val symkinds = mutable.HashSet.empty[SymbolKind] - tree match - case tree: ValDef => - if !tree.symbol.owner.is(Method) - if tree.mods.is(Mutable) - symkinds += SymbolKind.Var - else - symkinds += SymbolKind.Val - if tree.rhs.isEmpty && !tree.symbol.is(TermParam) && !tree.symbol.is(CaseAccessor) && !tree.mods.is(ParamAccessor) - symkinds += SymbolKind.Abstract - case tree: DefDef => - if tree.isSetterDef then - symkinds += SymbolKind.Setter - else - if tree.rhs.isEmpty - symkinds += SymbolKind.Abstract - case tree: Bind => symkinds += SymbolKind.Val - case _ => - symkinds.toSet - registerDefinition(tree.symbol, tree.nameSpan, symkinds) + registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree)) val privateWithin = tree.symbol.privateWithin - if privateWithin `ne` NoSymbol + if privateWithin.exists registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) tree match - case tree: ValDef if tree.symbol.isAllOf(EnumValue) => - tree.rhs match - case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause - template.parents.foreach(traverse) - case _ => // calls $new - case tree: DefDef if tree.symbol.isConstructor => - tree.vparamss.flatten.foreach(traverse) - traverse(tree.rhs) - case _ => traverseChildren(tree) - case tree: (ValDef | DefDef | TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip + case tree: ValDef if tree.symbol.isAllOf(EnumValue) => + tree.rhs match + case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause + template.parents.foreach(traverse) + case _ => // calls $new + case tree: DefDef if tree.symbol.isConstructor => // ignore typeparams for secondary ctors + tree.vparamss.foreach(_.foreach(traverse)) + traverse(tree.rhs) + case _ => traverseChildren(tree) + case tree: (ValDef|DefDef|TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip case tree: Template => val ctorSym = tree.constr.symbol if !excludeDef(ctorSym) registerDefinition(ctorSym, tree.constr.span, Set.empty) - ctorParams(ctorSym, tree.constr.vparamss, tree.body) + ctorParams(tree.constr.vparamss, tree.body)(traverseCtorParamTpt(ctorSym, _)) for parent <- tree.parentsOrDerived do if parent.symbol != defn.ObjectClass.primaryConstructor @@ -471,24 +425,18 @@ class ExtractSemanticDB extends Phase { val selfSpan = tree.self.span if selfSpan.exists && selfSpan.hasLength then traverse(tree.self) - if ctorSym.owner.is(Enum, butNot=Case) - tree.body.foreachUntilImport(traverse).foreach(traverse) + if tree.symbol.owner.is(Enum, butNot=Case) + tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement else tree.body.foreach(traverse) case tree: Assign => - traverseChildren(tree.lhs) if !excludeUseStrict(tree.lhs.symbol, tree.lhs.span) val lhs = tree.lhs.symbol - val name = lhs.name - val setter = - lhs.owner - .info - .decls - .find(s => s.name.startsWith(name.show) && s.name.isSetterName) - .orElse(lhs) + val setter = lhs.matchingSetter.orElse(lhs) tree.lhs match - case tree @ Select(qual, _) => registerUse(setter, adjustSpanToName(tree.span, qual.span, name)) - case tree: Ident => registerUse(setter, tree.span) + case tree @ Select(qual, name) => registerUse(setter, adjustSpanToName(tree.span, qual.span, name)) + case tree => registerUse(setter, tree.span) + traverseChildren(tree.lhs) traverse(tree.rhs) case tree: Ident => if tree.name != nme.WILDCARD then @@ -518,10 +466,8 @@ class ExtractSemanticDB extends Phase { traverse(tree.arg) case _ => traverseChildren(tree) - } -} -object ExtractSemanticDB { +object ExtractSemanticDB with import java.nio.file.Path import scala.collection.JavaConverters._ import java.nio.file.Files @@ -562,4 +508,3 @@ object ExtractSemanticDB { stream.flush() finally out.close() -} diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala index 325edd7b20b7..cbde9dddbf68 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala @@ -1,13 +1,44 @@ package dotty.tools.dotc.semanticdb -import dotty.tools.dotc.core.Symbols.{ Symbol => DottySymbol, defn } +import dotty.tools.dotc.core.Symbols.{ Symbol, defn } import dotty.tools.dotc.core.Contexts.Context +import dotty.tools.dotc.core.Names +import dotty.tools.dotc.core.Names.Name +import dotty.tools.dotc.core.Types.Type import dotty.tools.dotc.core.Flags._ +import dotty.tools.dotc.core.NameKinds +import dotty.tools.dotc.core.NameOps +import dotty.tools.dotc.core.StdNames.nme import scala.annotation.internal.sharable import scala.annotation.switch object Scala with + import NameOps.given + + @sharable private val unicodeEscape = raw"\$$u(\p{XDigit}{4})".r + @sharable private val locals = raw"local(\d+)".r + @sharable private val ctor = raw"[^;].*``\((?:\+\d+)?\)\.".r + + private val WILDCARDTypeName = nme.WILDCARD.toTypeName + + enum SymbolKind derives Eql with + kind => + + case Val, Var, Setter, Abstract + + def isVar: Boolean = kind match + case Var | Setter => true + case _ => false + + def isVal: Boolean = kind == Val + + def isVarOrVal: Boolean = kind.isVar || kind.isVal + + object SymbolKind with + val ValSet = Set(Val) + val VarSet = Set(Var) + val emptySet = Set.empty[SymbolKind] object Symbols with @@ -19,7 +50,7 @@ object Scala with val s"${RootPackageName @ _}/" = RootPackage val s"${EmptyPackageName @ _}/" = EmptyPackage - def displaySymbol(symbol: DottySymbol)(given Context): String = + def displaySymbol(symbol: Symbol)(given Context): String = if symbol.isPackageObject then displaySymbol(symbol.owner) else if symbol.is(ModuleClass) then @@ -31,11 +62,43 @@ object Scala with else symbol.name.show - @sharable - private val locals = raw"local(\d+)".r + given symbolOps: (symbol: String) with + def unescapeUnicode = + unicodeEscape.replaceAllIn(symbol, m => String.valueOf(Integer.parseInt(m.group(1), 16).toChar)) + + given nameOps: (name: Name) with + + def isWildcard = name match + case nme.WILDCARD | WILDCARDTypeName => true + case _ => name.is(NameKinds.WildcardParamName) + + def isScala2PackageObjectName: Boolean = name match + case name: Names.TermName => name == nme.PACKAGE + case name: Names.TypeName => + name.toTermName match + case NameKinds.ModuleClassName(original) => original.isScala2PackageObjectName + case _ => false + + + given symbolOps: (sym: Symbol) with + + def isScala2PackageObject(given Context): Boolean = + sym.name.isScala2PackageObjectName && sym.owner.is(Package) && sym.is(Module) + + def isAnonymous(given Context): Boolean = + sym.isAnonymousClass + || sym.isAnonymousModuleVal + || sym.isAnonymousFunction + + def matchingSetter(given Context): Symbol = + + val setterName = sym.name.toTermName.setterName + + inline def (t: Type) matchingType = t.paramInfoss match + case (arg::Nil)::Nil => t.resultType == defn.UnitType && arg == sym.info + case _ => false - @sharable - private val ctor = raw"[^;].*``\((?:\+\d+)?\)\.".r + sym.owner.info.decls.find(s => s.name == setterName && s.info.matchingType) object LocalSymbol with def unapply(symbolInfo: SymbolInformation): Option[Int] = From ba0f8cb5d8192696c9210289ca0e1693d462c389 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Mon, 18 Nov 2019 00:40:26 +0100 Subject: [PATCH 078/107] reformat metac.expect --- .../tools/dotc/semanticdb/Semanticdbs.scala | 4 +- tests/semanticdb/metac.expect | 3917 ++++++++--------- 2 files changed, 1960 insertions(+), 1961 deletions(-) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index c47ac7a70996..669b959a825b 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -134,14 +134,14 @@ object Semanticdbs with .append(range.startLine).append(':').append(range.startCharacter) .append("..") .append(range.endLine).append(':').append(range.endCharacter) - .append(')') + .append("):") if range.endLine == range.startLine && range.startCharacter != range.endCharacter && !(occ.symbol.isConstructor && occ.role.isDefinition) val line = sourceFile.lineContent(sourceFile.lineToOffset(range.startLine)) sb.append(" ").append(line.substring(range.startCharacter, range.endCharacter)) case _ => - sb.append("[)") + sb.append("[):") end match sb.append(if occ.role.isReference then " -> " else " <- ").append(occ.symbol).nl end processOccurrence diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 3e77275c8c5b..fc5e31cafd77 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -21,25 +21,25 @@ example/Access#m6(). => method m6 example/Access#m7(). => method m7 Occurrences: -[0:8..0:15) example <- example/ -[2:6..2:12) Access <- example/Access# -[3:2..3:2) <- example/Access#``(). -[3:14..3:16) m1 <- example/Access#m1(). -[3:19..3:22) ??? -> scala/Predef.`???`(). -[4:20..4:22) m2 <- example/Access#m2(). -[4:25..4:28) ??? -> scala/Predef.`???`(). -[5:10..5:16) Access -> example/Access# -[5:22..5:24) m3 <- example/Access#m3(). -[5:27..5:30) ??? -> scala/Predef.`???`(). -[6:16..6:18) m4 <- example/Access#m4(). -[6:21..6:24) ??? -> scala/Predef.`???`(). -[7:22..7:24) m5 <- example/Access#m5(). -[7:27..7:30) ??? -> scala/Predef.`???`(). -[8:12..8:19) example -> example/ -[8:25..8:27) m6 <- example/Access#m6(). -[8:30..8:33) ??? -> scala/Predef.`???`(). -[9:6..9:8) m7 <- example/Access#m7(). -[9:11..9:14) ??? -> scala/Predef.`???`(). +[0:8..0:15): example <- example/ +[2:6..2:12): Access <- example/Access# +[3:2..3:2): <- example/Access#``(). +[3:14..3:16): m1 <- example/Access#m1(). +[3:19..3:22): ??? -> scala/Predef.`???`(). +[4:20..4:22): m2 <- example/Access#m2(). +[4:25..4:28): ??? -> scala/Predef.`???`(). +[5:10..5:16): Access -> example/Access# +[5:22..5:24): m3 <- example/Access#m3(). +[5:27..5:30): ??? -> scala/Predef.`???`(). +[6:16..6:18): m4 <- example/Access#m4(). +[6:21..6:24): ??? -> scala/Predef.`???`(). +[7:22..7:24): m5 <- example/Access#m5(). +[7:27..7:30): ??? -> scala/Predef.`???`(). +[8:12..8:19): example -> example/ +[8:25..8:27): m6 <- example/Access#m6(). +[8:30..8:33): ??? -> scala/Predef.`???`(). +[9:6..9:8): m7 <- example/Access#m7(). +[9:11..9:14): ??? -> scala/Predef.`???`(). expect/Advanced.scala _____________________ @@ -89,102 +89,102 @@ local9 => val local e3 local10 => val local e3x Occurrences: -[0:8..0:16) advanced <- advanced/ -[2:7..2:12) scala -> scala/ -[2:13..2:21) language -> scalaShadowing/language. -[2:22..2:33) higherKinds -> scalaShadowing/language.higherKinds. -[3:7..3:12) scala -> scala/ -[3:13..3:21) language -> scalaShadowing/language. -[3:22..3:37) reflectiveCalls -> scalaShadowing/language.reflectiveCalls. -[5:7..5:12) scala -> scala/ -[5:13..5:20) reflect -> scala/reflect/ -[5:21..5:31) Selectable -> scala/reflect/Selectable. -[5:32..5:52) reflectiveSelectable -> scala/reflect/Selectable.reflectiveSelectable(). -[7:6..7:7) C <- advanced/C# -[7:7..7:10) <- advanced/C#``(). -[7:8..7:9) T <- advanced/C#[T] -[8:6..8:7) t <- advanced/C#t(). -[8:9..8:10) T -> advanced/C#[T] -[8:13..8:16) ??? -> scala/Predef.`???`(). -[11:6..11:16) Structural <- advanced/Structural# -[12:2..12:2) <- advanced/Structural#``(). -[12:6..12:8) s1 <- advanced/Structural#s1(). -[12:16..12:17) x <- local0 -[12:19..12:22) Int -> scala/Int# -[12:27..12:30) ??? -> scala/Predef.`???`(). -[13:6..13:8) s2 <- advanced/Structural#s2(). -[13:16..13:17) x <- local1 -[13:19..13:22) Int -> scala/Int# -[13:33..13:33) <- local2 -[13:37..13:38) x <- local3 -[13:40..13:43) Int -> scala/Int# -[13:46..13:49) ??? -> scala/Predef.`???`(). -[13:51..13:51) -> local2 -[14:6..14:8) s3 <- advanced/Structural#s3(). -[14:16..14:17) m <- local4 -[14:18..14:19) x <- local5 -[14:21..14:24) Int -> scala/Int# -[14:27..14:30) Int -> scala/Int# -[14:41..14:41) <- local6 -[14:45..14:46) m <- local7 -[14:47..14:48) x <- local8 -[14:50..14:53) Int -> scala/Int# -[14:56..14:59) Int -> scala/Int# -[14:62..14:65) ??? -> scala/Predef.`???`(). -[14:67..14:67) -> local6 -[17:6..17:15) Wildcards <- advanced/Wildcards# -[18:2..18:2) <- advanced/Wildcards#``(). -[18:6..18:8) e1 <- advanced/Wildcards#e1(). -[18:10..18:14) List -> scala/package.List# -[18:20..18:23) ??? -> scala/Predef.`???`(). -[21:7..21:11) Test <- advanced/Test. -[22:6..22:7) s <- advanced/Test.s. -[22:14..22:24) Structural -> advanced/Structural# -[22:24..22:24) -> advanced/Structural#``(). -[23:6..23:8) s1 <- advanced/Test.s1. -[23:11..23:12) s -> advanced/Test.s. -[23:13..23:15) s1 -> advanced/Structural#s1(). -[24:6..24:9) s1x <- advanced/Test.s1x. -[24:12..24:12) -> scala/reflect/Selectable.reflectiveSelectable(). -[24:12..24:13) s -> advanced/Test.s. -[24:14..24:16) s1 -> advanced/Structural#s1(). -[24:16..24:16) -> scala/Selectable#selectDynamic(). -[25:6..25:8) s2 <- advanced/Test.s2. -[25:11..25:12) s -> advanced/Test.s. -[25:13..25:15) s2 -> advanced/Structural#s2(). -[26:6..26:9) s2x <- advanced/Test.s2x. -[26:12..26:12) -> scala/reflect/Selectable.reflectiveSelectable(). -[26:12..26:13) s -> advanced/Test.s. -[26:14..26:16) s2 -> advanced/Structural#s2(). -[26:16..26:16) -> scala/Selectable#selectDynamic(). -[27:6..27:8) s3 <- advanced/Test.s3. -[27:11..27:12) s -> advanced/Test.s. -[27:13..27:15) s3 -> advanced/Structural#s3(). -[28:6..28:9) s3x <- advanced/Test.s3x. -[28:12..28:12) -> scala/reflect/Selectable.reflectiveSelectable(). -[28:12..28:13) s -> advanced/Test.s. -[28:14..28:16) s3 -> advanced/Structural#s3(). -[28:16..28:16) -> scala/Selectable#applyDynamic(). -[28:18..28:18) -> scala/reflect/ClassTag.apply(). -[28:18..28:18) -> java/lang/Integer#TYPE. -[28:19..28:22) ??? -> scala/Predef.`???`(). -[30:6..30:7) e <- advanced/Test.e. -[30:14..30:23) Wildcards -> advanced/Wildcards# -[30:23..30:23) -> advanced/Wildcards#``(). -[31:6..31:8) e1 <- advanced/Test.e1. -[31:11..31:12) e -> advanced/Test.e. -[31:13..31:15) e1 -> advanced/Wildcards#e1(). -[32:6..32:9) e1x <- advanced/Test.e1x. -[32:12..32:13) e -> advanced/Test.e. -[32:14..32:16) e1 -> advanced/Wildcards#e1(). -[32:17..32:21) head -> scala/collection/IterableOps#head(). -[35:5..35:8) ??? -> scala/Predef.`???`(). -[35:11..35:14) Any -> scala/Any# -[36:11..36:13) e3 <- local9 -[36:15..36:19) List -> scala/package.List# -[37:12..37:15) e3x <- local10 -[37:18..37:20) e3 -> local9 -[37:21..37:25) head -> scala/collection/IterableOps#head(). +[0:8..0:16): advanced <- advanced/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:33): higherKinds -> scalaShadowing/language.higherKinds. +[3:7..3:12): scala -> scala/ +[3:13..3:21): language -> scalaShadowing/language. +[3:22..3:37): reflectiveCalls -> scalaShadowing/language.reflectiveCalls. +[5:7..5:12): scala -> scala/ +[5:13..5:20): reflect -> scala/reflect/ +[5:21..5:31): Selectable -> scala/reflect/Selectable. +[5:32..5:52): reflectiveSelectable -> scala/reflect/Selectable.reflectiveSelectable(). +[7:6..7:7): C <- advanced/C# +[7:7..7:10): <- advanced/C#``(). +[7:8..7:9): T <- advanced/C#[T] +[8:6..8:7): t <- advanced/C#t(). +[8:9..8:10): T -> advanced/C#[T] +[8:13..8:16): ??? -> scala/Predef.`???`(). +[11:6..11:16): Structural <- advanced/Structural# +[12:2..12:2): <- advanced/Structural#``(). +[12:6..12:8): s1 <- advanced/Structural#s1(). +[12:16..12:17): x <- local0 +[12:19..12:22): Int -> scala/Int# +[12:27..12:30): ??? -> scala/Predef.`???`(). +[13:6..13:8): s2 <- advanced/Structural#s2(). +[13:16..13:17): x <- local1 +[13:19..13:22): Int -> scala/Int# +[13:33..13:33): <- local2 +[13:37..13:38): x <- local3 +[13:40..13:43): Int -> scala/Int# +[13:46..13:49): ??? -> scala/Predef.`???`(). +[13:51..13:51): -> local2 +[14:6..14:8): s3 <- advanced/Structural#s3(). +[14:16..14:17): m <- local4 +[14:18..14:19): x <- local5 +[14:21..14:24): Int -> scala/Int# +[14:27..14:30): Int -> scala/Int# +[14:41..14:41): <- local6 +[14:45..14:46): m <- local7 +[14:47..14:48): x <- local8 +[14:50..14:53): Int -> scala/Int# +[14:56..14:59): Int -> scala/Int# +[14:62..14:65): ??? -> scala/Predef.`???`(). +[14:67..14:67): -> local6 +[17:6..17:15): Wildcards <- advanced/Wildcards# +[18:2..18:2): <- advanced/Wildcards#``(). +[18:6..18:8): e1 <- advanced/Wildcards#e1(). +[18:10..18:14): List -> scala/package.List# +[18:20..18:23): ??? -> scala/Predef.`???`(). +[21:7..21:11): Test <- advanced/Test. +[22:6..22:7): s <- advanced/Test.s. +[22:14..22:24): Structural -> advanced/Structural# +[22:24..22:24): -> advanced/Structural#``(). +[23:6..23:8): s1 <- advanced/Test.s1. +[23:11..23:12): s -> advanced/Test.s. +[23:13..23:15): s1 -> advanced/Structural#s1(). +[24:6..24:9): s1x <- advanced/Test.s1x. +[24:12..24:12): -> scala/reflect/Selectable.reflectiveSelectable(). +[24:12..24:13): s -> advanced/Test.s. +[24:14..24:16): s1 -> advanced/Structural#s1(). +[24:16..24:16): -> scala/Selectable#selectDynamic(). +[25:6..25:8): s2 <- advanced/Test.s2. +[25:11..25:12): s -> advanced/Test.s. +[25:13..25:15): s2 -> advanced/Structural#s2(). +[26:6..26:9): s2x <- advanced/Test.s2x. +[26:12..26:12): -> scala/reflect/Selectable.reflectiveSelectable(). +[26:12..26:13): s -> advanced/Test.s. +[26:14..26:16): s2 -> advanced/Structural#s2(). +[26:16..26:16): -> scala/Selectable#selectDynamic(). +[27:6..27:8): s3 <- advanced/Test.s3. +[27:11..27:12): s -> advanced/Test.s. +[27:13..27:15): s3 -> advanced/Structural#s3(). +[28:6..28:9): s3x <- advanced/Test.s3x. +[28:12..28:12): -> scala/reflect/Selectable.reflectiveSelectable(). +[28:12..28:13): s -> advanced/Test.s. +[28:14..28:16): s3 -> advanced/Structural#s3(). +[28:16..28:16): -> scala/Selectable#applyDynamic(). +[28:18..28:18): -> scala/reflect/ClassTag.apply(). +[28:18..28:18): -> java/lang/Integer#TYPE. +[28:19..28:22): ??? -> scala/Predef.`???`(). +[30:6..30:7): e <- advanced/Test.e. +[30:14..30:23): Wildcards -> advanced/Wildcards# +[30:23..30:23): -> advanced/Wildcards#``(). +[31:6..31:8): e1 <- advanced/Test.e1. +[31:11..31:12): e -> advanced/Test.e. +[31:13..31:15): e1 -> advanced/Wildcards#e1(). +[32:6..32:9): e1x <- advanced/Test.e1x. +[32:12..32:13): e -> advanced/Test.e. +[32:14..32:16): e1 -> advanced/Wildcards#e1(). +[32:17..32:21): head -> scala/collection/IterableOps#head(). +[35:5..35:8): ??? -> scala/Predef.`???`(). +[35:11..35:14): Any -> scala/Any# +[36:11..36:13): e3 <- local9 +[36:15..36:19): List -> scala/package.List# +[37:12..37:15): e3x <- local10 +[37:18..37:20): e3 -> local9 +[37:21..37:25): head -> scala/collection/IterableOps#head(). expect/Annotations.scala ________________________ @@ -222,57 +222,57 @@ local0 => selfparam self local1 => local local Occurrences: -[0:8..0:13) annot <- annot/ -[2:7..2:10) com -> com/ -[2:11..2:17) javacp -> com/javacp/ -[2:18..2:23) annot -> com/javacp/annot/ -[3:7..3:12) scala -> scala/ -[3:13..3:23) annotation -> scala/annotation/ -[3:24..3:28) meta -> scala/annotation/meta/ -[4:7..4:12) scala -> scala/ -[4:13..4:21) language -> scalaShadowing/language. -[4:22..4:34) experimental -> scalaShadowing/language.experimental. -[4:35..4:41) macros -> scalaShadowing/language.experimental.macros. -[6:1..6:16) ClassAnnotation -> com/javacp/annot/ClassAnnotation# -[7:6..7:17) Annotations <- annot/Annotations# -[7:17..7:72) <- annot/Annotations#``(). -[7:19..7:42) TypeParameterAnnotation -> com/javacp/annot/TypeParameterAnnotation# -[7:43..7:44) T <- annot/Annotations#[T] -[7:47..7:66) ParameterAnnotation -> com/javacp/annot/ParameterAnnotation# -[7:67..7:68) x <- annot/Annotations#x. -[7:70..7:71) T -> annot/Annotations#[T] -[7:75..7:79) self <- local0 -[7:81..7:87) AnyRef -> scala/AnyRef# -[8:3..8:18) FieldAnnotation -> com/javacp/annot/FieldAnnotation# -[9:6..9:11) field <- annot/Annotations#field. -[11:3..11:19) MethodAnnotation -> com/javacp/annot/MethodAnnotation# -[12:6..12:12) method <- annot/Annotations#method(). -[13:5..13:20) LocalAnnotation -> com/javacp/annot/LocalAnnotation# -[14:8..14:13) local <- local1 -[15:4..15:9) local -> local1 -[17:3..17:17) TypeAnnotation -> com/javacp/annot/TypeAnnotation# -[18:7..18:8) S <- annot/Annotations#S# -[21:6..21:7) B <- annot/B# -[21:7..21:40) <- annot/B#``(). -[21:9..21:30) ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# -[21:33..21:34) x <- annot/B#x. -[21:36..21:39) Int -> scala/Int# -[22:3..22:24) ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# -[23:6..23:12) <- annot/B#``(+1). -[23:20..23:20) -> annot/B#``(). -[26:1..26:17) ObjectAnnotation -> com/javacp/annot/ObjectAnnotation# -[27:7..27:8) M <- annot/M. -[28:3..28:18) MacroAnnotation -> com/javacp/annot/MacroAnnotation# -[29:6..29:7) m <- annot/M.m(). -[29:8..29:10) TT <- annot/M.m().[TT] -[29:13..29:16) Int -> scala/Int# -[29:16..29:16) -> scala/Predef.`???`(). -[32:0..32:0) <- annot/T#``(). -[32:1..32:16) TraitAnnotation -> com/javacp/annot/TraitAnnotation# -[33:6..33:7) T <- annot/T# -[35:7..35:12) Alias <- annot/Alias. -[36:7..36:8) A <- annot/Alias.A# -[36:11..36:26) ClassAnnotation -> com/javacp/annot/ClassAnnotation# +[0:8..0:13): annot <- annot/ +[2:7..2:10): com -> com/ +[2:11..2:17): javacp -> com/javacp/ +[2:18..2:23): annot -> com/javacp/annot/ +[3:7..3:12): scala -> scala/ +[3:13..3:23): annotation -> scala/annotation/ +[3:24..3:28): meta -> scala/annotation/meta/ +[4:7..4:12): scala -> scala/ +[4:13..4:21): language -> scalaShadowing/language. +[4:22..4:34): experimental -> scalaShadowing/language.experimental. +[4:35..4:41): macros -> scalaShadowing/language.experimental.macros. +[6:1..6:16): ClassAnnotation -> com/javacp/annot/ClassAnnotation# +[7:6..7:17): Annotations <- annot/Annotations# +[7:17..7:72): <- annot/Annotations#``(). +[7:19..7:42): TypeParameterAnnotation -> com/javacp/annot/TypeParameterAnnotation# +[7:43..7:44): T <- annot/Annotations#[T] +[7:47..7:66): ParameterAnnotation -> com/javacp/annot/ParameterAnnotation# +[7:67..7:68): x <- annot/Annotations#x. +[7:70..7:71): T -> annot/Annotations#[T] +[7:75..7:79): self <- local0 +[7:81..7:87): AnyRef -> scala/AnyRef# +[8:3..8:18): FieldAnnotation -> com/javacp/annot/FieldAnnotation# +[9:6..9:11): field <- annot/Annotations#field. +[11:3..11:19): MethodAnnotation -> com/javacp/annot/MethodAnnotation# +[12:6..12:12): method <- annot/Annotations#method(). +[13:5..13:20): LocalAnnotation -> com/javacp/annot/LocalAnnotation# +[14:8..14:13): local <- local1 +[15:4..15:9): local -> local1 +[17:3..17:17): TypeAnnotation -> com/javacp/annot/TypeAnnotation# +[18:7..18:8): S <- annot/Annotations#S# +[21:6..21:7): B <- annot/B# +[21:7..21:40): <- annot/B#``(). +[21:9..21:30): ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# +[21:33..21:34): x <- annot/B#x. +[21:36..21:39): Int -> scala/Int# +[22:3..22:24): ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# +[23:6..23:12): <- annot/B#``(+1). +[23:20..23:20): -> annot/B#``(). +[26:1..26:17): ObjectAnnotation -> com/javacp/annot/ObjectAnnotation# +[27:7..27:8): M <- annot/M. +[28:3..28:18): MacroAnnotation -> com/javacp/annot/MacroAnnotation# +[29:6..29:7): m <- annot/M.m(). +[29:8..29:10): TT <- annot/M.m().[TT] +[29:13..29:16): Int -> scala/Int# +[29:16..29:16): -> scala/Predef.`???`(). +[32:0..32:0): <- annot/T#``(). +[32:1..32:16): TraitAnnotation -> com/javacp/annot/TraitAnnotation# +[33:6..33:7): T <- annot/T# +[35:7..35:12): Alias <- annot/Alias. +[36:7..36:8): A <- annot/Alias.A# +[36:11..36:26): ClassAnnotation -> com/javacp/annot/ClassAnnotation# expect/Anonymous.scala ______________________ @@ -301,40 +301,40 @@ local0 => val local x local1 => primary ctor Occurrences: -[0:8..0:15) example <- example/ -[1:7..1:12) scala -> scala/ -[1:13..1:21) language -> scalaShadowing/language. -[1:22..1:33) higherKinds -> scalaShadowing/language.higherKinds. -[3:6..3:15) Anonymous <- example/Anonymous# -[4:2..4:2) <- example/Anonymous#``(). -[4:8..4:17) Anonymous -> example/Anonymous# -[6:6..6:13) locally <- example/Anonymous#locally(). -[6:14..6:15) A <- example/Anonymous#locally().[A] -[6:17..6:18) x <- example/Anonymous#locally().(x) -[6:20..6:21) A -> example/Anonymous#locally().[A] -[6:24..6:25) A -> example/Anonymous#locally().[A] -[6:28..6:29) x -> example/Anonymous#locally().(x) -[8:6..8:8) m1 <- example/Anonymous#m1(). -[8:9..8:10) T <- example/Anonymous#m1().[T] -[8:17..8:20) ??? -> scala/Predef.`???`(). -[9:6..9:8) m2 <- example/Anonymous#m2(). -[9:10..9:13) Map -> scala/Predef.Map# -[9:17..9:21) List -> scala/package.List# -[9:28..9:31) ??? -> scala/Predef.`???`(). -[10:2..10:9) locally -> example/Anonymous#locally(). -[11:4..11:7) ??? -> scala/Predef.`???`(). -[11:24..11:28) List -> scala/package.List# -[13:2..13:9) locally -> example/Anonymous#locally(). -[14:8..14:9) x <- local0 -[14:11..14:14) Int -> scala/Int# -[14:18..14:21) Int -> scala/Int# -[14:29..14:32) ??? -> scala/Predef.`???`(). -[17:2..17:2) <- example/Anonymous#Foo#``(). -[17:8..17:11) Foo <- example/Anonymous#Foo# -[18:6..18:9) foo <- example/Anonymous#foo. -[18:16..18:16) <- local1 -[18:16..18:19) Foo -> example/Anonymous#Foo# -[18:22..18:22) -> local1 +[0:8..0:15): example <- example/ +[1:7..1:12): scala -> scala/ +[1:13..1:21): language -> scalaShadowing/language. +[1:22..1:33): higherKinds -> scalaShadowing/language.higherKinds. +[3:6..3:15): Anonymous <- example/Anonymous# +[4:2..4:2): <- example/Anonymous#``(). +[4:8..4:17): Anonymous -> example/Anonymous# +[6:6..6:13): locally <- example/Anonymous#locally(). +[6:14..6:15): A <- example/Anonymous#locally().[A] +[6:17..6:18): x <- example/Anonymous#locally().(x) +[6:20..6:21): A -> example/Anonymous#locally().[A] +[6:24..6:25): A -> example/Anonymous#locally().[A] +[6:28..6:29): x -> example/Anonymous#locally().(x) +[8:6..8:8): m1 <- example/Anonymous#m1(). +[8:9..8:10): T <- example/Anonymous#m1().[T] +[8:17..8:20): ??? -> scala/Predef.`???`(). +[9:6..9:8): m2 <- example/Anonymous#m2(). +[9:10..9:13): Map -> scala/Predef.Map# +[9:17..9:21): List -> scala/package.List# +[9:28..9:31): ??? -> scala/Predef.`???`(). +[10:2..10:9): locally -> example/Anonymous#locally(). +[11:4..11:7): ??? -> scala/Predef.`???`(). +[11:24..11:28): List -> scala/package.List# +[13:2..13:9): locally -> example/Anonymous#locally(). +[14:8..14:9): x <- local0 +[14:11..14:14): Int -> scala/Int# +[14:18..14:21): Int -> scala/Int# +[14:29..14:32): ??? -> scala/Predef.`???`(). +[17:2..17:2): <- example/Anonymous#Foo#``(). +[17:8..17:11): Foo <- example/Anonymous#Foo# +[18:6..18:9): foo <- example/Anonymous#foo. +[18:16..18:16): <- local1 +[18:16..18:19): Foo -> example/Anonymous#Foo# +[18:22..18:22): -> local1 expect/Classes.scala ____________________ @@ -394,64 +394,64 @@ local0 => primary ctor local1 => val method local Occurrences: -[0:8..0:15) classes <- classes/ -[2:6..2:8) C1 <- classes/C1# -[2:8..2:21) <- classes/C1#``(). -[2:13..2:15) x1 <- classes/C1#x1. -[2:17..2:20) Int -> scala/Int# -[2:30..2:36) AnyVal -> scala/AnyVal# -[2:36..2:36) -> scala/AnyVal#``(). -[4:6..4:8) C2 <- classes/C2# -[4:8..4:21) <- classes/C2#``(). -[4:13..4:15) x2 <- classes/C2#x2. -[4:17..4:20) Int -> scala/Int# -[4:30..4:36) AnyVal -> scala/AnyVal# -[4:36..4:36) -> scala/AnyVal#``(). -[5:7..5:9) C2 <- classes/C2. -[7:11..7:13) C3 <- classes/C3# -[7:13..7:21) <- classes/C3#``(). -[7:14..7:15) x <- classes/C3#x. -[7:17..7:20) Int -> scala/Int# -[9:11..9:13) C4 <- classes/C4# -[9:13..9:21) <- classes/C4#``(). -[9:14..9:15) x <- classes/C4#x. -[9:17..9:20) Int -> scala/Int# -[10:7..10:9) C4 <- classes/C4. -[12:7..12:8) M <- classes/M. -[13:17..13:19) C5 <- classes/M.C5# -[13:19..13:27) <- classes/M.C5#``(). -[13:20..13:21) x <- classes/M.C5#x. -[13:23..13:26) Int -> scala/Int# -[16:11..16:13) C6 <- classes/C6# -[16:13..16:33) <- classes/C6#``(). -[16:26..16:27) x <- classes/C6#x. -[16:29..16:32) Int -> scala/Int# -[18:6..18:8) C7 <- classes/C7# -[18:8..18:16) <- classes/C7#``(). -[18:9..18:10) x <- classes/C7#x. -[18:12..18:15) Int -> scala/Int# -[20:6..20:8) C8 <- classes/C8# -[20:8..20:34) <- classes/C8#``(). -[20:27..20:28) x <- classes/C8#x. -[20:30..20:33) Int -> scala/Int# -[22:6..22:8) C9 <- classes/C9# -[22:8..22:34) <- classes/C9#``(). -[22:27..22:28) x <- classes/C9#x(). -[22:30..22:33) Int -> scala/Int# -[24:7..24:8) N <- classes/N. -[25:6..25:15) anonClass <- classes/N.anonClass. -[25:22..25:22) <- local0 -[25:22..25:24) C7 -> classes/C7# -[25:24..25:24) -> classes/C7#``(). -[26:8..26:13) local <- local1 -[26:16..26:19) ??? -> scala/Predef.`???`(). -[27:3..27:3) -> local0 -[28:6..28:13) anonFun <- classes/N.anonFun. -[28:16..28:20) List -> scala/package.List. -[28:20..28:20) -> scala/collection/IterableFactory#apply(). -[28:24..28:27) map -> scala/collection/immutable/List#map(). -[30:4..30:9) local -> local2 -[30:10..30:11) + -> scala/Int#`+`(+4). +[0:8..0:15): classes <- classes/ +[2:6..2:8): C1 <- classes/C1# +[2:8..2:21): <- classes/C1#``(). +[2:13..2:15): x1 <- classes/C1#x1. +[2:17..2:20): Int -> scala/Int# +[2:30..2:36): AnyVal -> scala/AnyVal# +[2:36..2:36): -> scala/AnyVal#``(). +[4:6..4:8): C2 <- classes/C2# +[4:8..4:21): <- classes/C2#``(). +[4:13..4:15): x2 <- classes/C2#x2. +[4:17..4:20): Int -> scala/Int# +[4:30..4:36): AnyVal -> scala/AnyVal# +[4:36..4:36): -> scala/AnyVal#``(). +[5:7..5:9): C2 <- classes/C2. +[7:11..7:13): C3 <- classes/C3# +[7:13..7:21): <- classes/C3#``(). +[7:14..7:15): x <- classes/C3#x. +[7:17..7:20): Int -> scala/Int# +[9:11..9:13): C4 <- classes/C4# +[9:13..9:21): <- classes/C4#``(). +[9:14..9:15): x <- classes/C4#x. +[9:17..9:20): Int -> scala/Int# +[10:7..10:9): C4 <- classes/C4. +[12:7..12:8): M <- classes/M. +[13:17..13:19): C5 <- classes/M.C5# +[13:19..13:27): <- classes/M.C5#``(). +[13:20..13:21): x <- classes/M.C5#x. +[13:23..13:26): Int -> scala/Int# +[16:11..16:13): C6 <- classes/C6# +[16:13..16:33): <- classes/C6#``(). +[16:26..16:27): x <- classes/C6#x. +[16:29..16:32): Int -> scala/Int# +[18:6..18:8): C7 <- classes/C7# +[18:8..18:16): <- classes/C7#``(). +[18:9..18:10): x <- classes/C7#x. +[18:12..18:15): Int -> scala/Int# +[20:6..20:8): C8 <- classes/C8# +[20:8..20:34): <- classes/C8#``(). +[20:27..20:28): x <- classes/C8#x. +[20:30..20:33): Int -> scala/Int# +[22:6..22:8): C9 <- classes/C9# +[22:8..22:34): <- classes/C9#``(). +[22:27..22:28): x <- classes/C9#x(). +[22:30..22:33): Int -> scala/Int# +[24:7..24:8): N <- classes/N. +[25:6..25:15): anonClass <- classes/N.anonClass. +[25:22..25:22): <- local0 +[25:22..25:24): C7 -> classes/C7# +[25:24..25:24): -> classes/C7#``(). +[26:8..26:13): local <- local1 +[26:16..26:19): ??? -> scala/Predef.`???`(). +[27:3..27:3): -> local0 +[28:6..28:13): anonFun <- classes/N.anonFun. +[28:16..28:20): List -> scala/package.List. +[28:20..28:20): -> scala/collection/IterableFactory#apply(). +[28:24..28:27): map -> scala/collection/immutable/List#map(). +[30:4..30:9): local -> local2 +[30:10..30:11): + -> scala/Int#`+`(+4). expect/Definitions.scala ________________________ @@ -476,16 +476,16 @@ a/Definitions.b(). => var method b a/Definitions.c(). => method c Occurrences: -[0:8..0:9) a <- a/ -[1:7..1:18) Definitions <- a/Definitions. -[2:6..2:7) a <- a/Definitions.a. -[3:6..3:7) b <- a/Definitions.b(). -[3:6..3:9) 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# +[0:8..0:9): a <- a/ +[1:7..1:18): Definitions <- a/Definitions. +[2:6..2:7): a <- a/Definitions.a. +[3:6..3:7): b <- a/Definitions.b(). +[3:6..3:9): b = <- a/Definitions.`b_=`(). +[4:6..4:7): c <- a/Definitions.c(). +[5:2..5:2): <- a/Definitions.D#``(). +[5:8..5:9): D <- a/Definitions.D# +[6:2..6:2): <- a/Definitions.E#``(). +[6:8..6:9): E <- a/Definitions.E# expect/Empty.scala __________________ @@ -507,16 +507,16 @@ _empty_/B#``(). => primary ctor _empty_/B#a(). => method a Occurrences: -[0:6..0:7) A <- _empty_/A# -[1:2..1:2) <- _empty_/A#``(). -[1:6..1:7) b <- _empty_/A#b(). -[1:9..1:10) B -> _empty_/B# -[1:13..1:16) ??? -> scala/Predef.`???`(). -[4:6..4:7) B <- _empty_/B# -[5:2..5:2) <- _empty_/B#``(). -[5:6..5:7) a <- _empty_/B#a(). -[5:9..5:10) A -> _empty_/A# -[5:13..5:16) ??? -> scala/Predef.`???`(). +[0:6..0:7): A <- _empty_/A# +[1:2..1:2): <- _empty_/A#``(). +[1:6..1:7): b <- _empty_/A#b(). +[1:9..1:10): B -> _empty_/B# +[1:13..1:16): ??? -> scala/Predef.`???`(). +[4:6..4:7): B <- _empty_/B# +[5:2..5:2): <- _empty_/B#``(). +[5:6..5:7): a <- _empty_/B#a(). +[5:9..5:10): A -> _empty_/A# +[5:13..5:16): ??? -> scala/Predef.`???`(). expect/EmptyObject.scala ________________________ @@ -533,8 +533,8 @@ Symbols: example/EmptyObject. => final object EmptyObject Occurrences: -[0:8..0:15) example <- example/ -[2:7..2:18) EmptyObject <- example/EmptyObject. +[0:8..0:15): example <- example/ +[2:7..2:18): EmptyObject <- example/EmptyObject. expect/Enums.scala __________________ @@ -638,189 +638,189 @@ _empty_/Enums.unwrap().[A] => typeparam A _empty_/Enums.unwrap().[B] => typeparam 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/Eql.derived. -[11:9..11:15) Hearts <- _empty_/Enums.Suits.Hearts. -[11:17..11:23) Spades <- _empty_/Enums.Suits.Spades. -[11:25..11:30) Clubs <- _empty_/Enums.Suits.Clubs. -[11:32..11:40) Diamonds <- _empty_/Enums.Suits.Diamonds. -[13:9..13:14) Suits <- _empty_/Enums.Suits. -[14:8..14:13) (suit <- _empty_/Enums.Suits.isRed(). -[14:9..14:13) suit <- _empty_/Enums.Suits.isRed().(suit) -[14:15..14:20) Suits -> _empty_/Enums.Suits# -[14:29..14:36) Boolean -> scala/Boolean# -[15:6..15:10) suit -> _empty_/Enums.Suits.isRed().(suit) -[15:11..15:13) == -> scala/Any#`==`(). -[15:14..15:20) Hearts -> _empty_/Enums.Suits.Hearts. -[15:21..15:23) || -> scala/Boolean#`||`(). -[15:24..15:28) suit -> _empty_/Enums.Suits.isRed().(suit) -[15:29..15:31) == -> scala/Any#`==`(). -[15:32..15:40) Diamonds -> _empty_/Enums.Suits.Diamonds. -[17:8..17:15) (suit: <- _empty_/Enums.Suits.isBlack(). -[17:9..17:13) suit <- _empty_/Enums.Suits.isBlack().(suit) -[17:15..17:20) Suits -> _empty_/Enums.Suits# -[17:31..17:38) Boolean -> scala/Boolean# -[17:41..17:45) suit -> _empty_/Enums.Suits.isBlack().(suit) -[18:11..18:17) Spades -> _empty_/Enums.Suits.Spades. -[18:20..18:28) Diamonds -> _empty_/Enums.Suits.Diamonds. -[21:7..21:15) WeekDays <- _empty_/Enums.WeekDays# -[22:4..22:4) <- _empty_/Enums.WeekDays#``(). -[22:9..22:15) Monday <- _empty_/Enums.WeekDays.Monday. -[23:9..23:16) Tuesday <- _empty_/Enums.WeekDays.Tuesday. -[24:9..24:18) Wednesday <- _empty_/Enums.WeekDays.Wednesday. -[25:9..25:17) Thursday <- _empty_/Enums.WeekDays.Thursday. -[26:9..26:15) Friday <- _empty_/Enums.WeekDays.Friday. -[27:9..27:17) Saturday <- _empty_/Enums.WeekDays.Saturday. -[28:9..28:15) Sunday <- _empty_/Enums.WeekDays.Sunday. -[30:7..30:11) Coin <- _empty_/Enums.Coin# -[30:11..30:23) <- _empty_/Enums.Coin#``(). -[30:12..30:17) value <- _empty_/Enums.Coin#value. -[30:19..30:22) Int -> scala/Int# -[31:9..31:14) Penny <- _empty_/Enums.Coin.Penny. -[31:26..31:30) Coin -> _empty_/Enums.Coin# -[31:30..31:30) -> _empty_/Enums.Coin#``(). -[32:9..32:15) Nickel <- _empty_/Enums.Coin.Nickel. -[32:26..32:30) Coin -> _empty_/Enums.Coin# -[32:30..32:30) -> _empty_/Enums.Coin#``(). -[33:9..33:13) Dime <- _empty_/Enums.Coin.Dime. -[33:26..33:30) Coin -> _empty_/Enums.Coin# -[33:30..33:30) -> _empty_/Enums.Coin#``(). -[34:9..34:16) Quarter <- _empty_/Enums.Coin.Quarter. -[34:26..34:30) Coin -> _empty_/Enums.Coin# -[34:30..34:30) -> _empty_/Enums.Coin#``(). -[35:9..35:15) Dollar <- _empty_/Enums.Coin.Dollar. -[35:26..35:30) Coin -> _empty_/Enums.Coin# -[35:30..35:30) -> _empty_/Enums.Coin#``(). -[37:7..37:12) Maybe <- _empty_/Enums.Maybe# -[37:12..37:16) <- _empty_/Enums.Maybe#``(). -[37:14..37:15) A <- _empty_/Enums.Maybe#[A] -[38:4..38:4) -> _empty_/Enums.Maybe#``(). -[38:9..38:13) Just <- _empty_/Enums.Maybe.Just# -[38:13..38:23) <- _empty_/Enums.Maybe.Just#``(). -[38:14..38:19) value <- _empty_/Enums.Maybe.Just#value. -[38:21..38:22) A -> _empty_/Enums.Maybe.Just#[A] -[39:4..39:4) -> _empty_/Enums.Maybe#``(). -[39:9..39:13) None <- _empty_/Enums.Maybe.None. -[41:7..41:10) Tag <- _empty_/Enums.Tag# -[41:10..41:13) <- _empty_/Enums.Tag#``(). -[41:11..41:12) A <- _empty_/Enums.Tag#[A] -[42:9..42:15) IntTag <- _empty_/Enums.Tag.IntTag. -[42:24..42:27) Tag -> _empty_/Enums.Tag# -[42:28..42:31) Int -> scala/Int# -[42:32..42:32) -> _empty_/Enums.Tag#``(). -[43:9..43:19) BooleanTag <- _empty_/Enums.Tag.BooleanTag. -[43:28..43:31) Tag -> _empty_/Enums.Tag# -[43:32..43:39) Boolean -> scala/Boolean# -[43:40..43:40) -> _empty_/Enums.Tag#``(). -[45:7..45:10) <:< <- _empty_/Enums.`<:<`# -[45:10..45:17) <- _empty_/Enums.`<:<`#``(). -[45:12..45:13) A <- _empty_/Enums.`<:<`#[A] -[45:15..45:16) B <- _empty_/Enums.`<:<`#[B] -[46:9..46:13) Refl <- _empty_/Enums.`<:<`.Refl# -[46:13..46:18) <- _empty_/Enums.`<:<`.Refl#``(). -[46:14..46:15) C <- _empty_/Enums.`<:<`.Refl#[C] -[46:28..46:29) C -> _empty_/Enums.`<:<`.Refl#[C] -[46:30..46:33) <:< -> _empty_/Enums.`<:<`# -[46:34..46:35) C -> _empty_/Enums.`<:<`.Refl#[C] -[46:35..46:35) -> _empty_/Enums.`<:<`#``(). -[48:9..48:12) <:< <- _empty_/Enums.`<:<`. -[49:10..49:17) [T]: (T <- _empty_/Enums.`<:<`.given_T(). -[49:11..49:12) T <- _empty_/Enums.`<:<`.given_T().[T] -[49:16..49:17) T -> _empty_/Enums.`<:<`.given_T().[T] -[49:18..49:21) <:< -> _empty_/Enums.`<:<`# -[49:22..49:23) T -> _empty_/Enums.`<:<`.given_T().[T] -[49:27..49:31) Refl -> _empty_/Enums.`<:<`.Refl. -[51:6..51:12) [A, B] <- _empty_/Enums.unwrap(). -[51:7..51:8) A <- _empty_/Enums.unwrap().[A] -[51:10..51:11) B <- _empty_/Enums.unwrap().[B] -[51:13..51:16) opt <- _empty_/Enums.unwrap().(opt) -[51:18..51:24) Option -> scala/Option# -[51:25..51:26) A -> _empty_/Enums.unwrap().[A] -[51:42..51:44) ev <- _empty_/Enums.unwrap().(ev) -[51:46..51:47) A -> _empty_/Enums.unwrap().[A] -[51:48..51:51) <:< -> _empty_/Enums.`<:<`# -[51:52..51:58) Option -> scala/Option# -[51:59..51:60) B -> _empty_/Enums.unwrap().[B] -[51:64..51:70) Option -> scala/Option# -[51:71..51:72) B -> _empty_/Enums.unwrap().[B] -[51:76..51:78) ev -> _empty_/Enums.unwrap().(ev) -[52:9..52:13) Refl -> _empty_/Enums.`<:<`.Refl. -[52: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:40..52:46) Option -> scala/Option# -[52:47..52:48) B -> _empty_/Enums.unwrap().[B] -[54:6..54:11) some1 <- _empty_/Enums.some1. -[54:14..54:14) -> _empty_/Enums.unwrap(). -[54:14..54:18) Some -> scala/Some. -[54:19..54:23) Some -> scala/Some. -[54:27..54:27) -> _empty_/Enums.`<:<`.given_T(). -[56:7..56:13) Planet <- _empty_/Enums.Planet# -[56:13..56:43) <- _empty_/Enums.Planet#``(). -[56:14..56:18) mass <- _empty_/Enums.Planet#mass. -[56:20..56:26) Double -> scala/Double# -[56:28..56:34) radius <- _empty_/Enums.Planet#radius. -[56:36..56:42) Double -> scala/Double# -[56:52..56:56) java -> java/ -[56:57..56:61) lang -> java/lang/ -[56:62..56:66) Enum -> java/lang/Enum# -[56:67..56:73) Planet -> _empty_/Enums.Planet# -[56:74..56:74) -> java/lang/Enum#``(). -[57:22..57:23) G <- _empty_/Enums.Planet#G. -[58:8..58:22) surfaceGravity <- _empty_/Enums.Planet#surfaceGravity(). -[58:25..58:26) G -> _empty_/Enums.Planet#G. -[58:27..58:28) * -> scala/Double#`*`(+6). -[58:29..58:33) mass -> _empty_/Enums.Planet#mass. -[58:34..58:35) / -> scala/Double#`/`(+6). -[58:37..58:43) radius -> _empty_/Enums.Planet#radius. -[58:44..58:45) * -> scala/Double#`*`(+6). -[58:46..58:52) radius -> _empty_/Enums.Planet#radius. -[59:8..59:21) surfaceWeight <- _empty_/Enums.Planet#surfaceWeight(). -[59:22..59:31) otherMass <- _empty_/Enums.Planet#surfaceWeight().(otherMass) -[59:33..59:39) Double -> scala/Double# -[59:43..59:52) otherMass -> _empty_/Enums.Planet#surfaceWeight().(otherMass) -[59:53..59:54) * -> scala/Double#`*`(+6). -[59:55..59:69) surfaceGravity -> _empty_/Enums.Planet#surfaceGravity(). -[61:9..61:16) Mercury <- _empty_/Enums.Planet.Mercury. -[61:25..61:31) Planet -> _empty_/Enums.Planet# -[61:31..61:31) -> _empty_/Enums.Planet#``(). -[62:9..62:14) Venus <- _empty_/Enums.Planet.Venus. -[62:25..62:31) Planet -> _empty_/Enums.Planet# -[62:31..62:31) -> _empty_/Enums.Planet#``(). -[63:9..63:14) Earth <- _empty_/Enums.Planet.Earth. -[63:25..63:31) Planet -> _empty_/Enums.Planet# -[63:31..63:31) -> _empty_/Enums.Planet#``(). -[64:9..64:13) Mars <- _empty_/Enums.Planet.Mars. -[64:25..64:31) Planet -> _empty_/Enums.Planet# -[64:31..64:31) -> _empty_/Enums.Planet#``(). -[65:9..65:16) Jupiter <- _empty_/Enums.Planet.Jupiter. -[65:25..65:31) Planet -> _empty_/Enums.Planet# -[65:31..65:31) -> _empty_/Enums.Planet#``(). -[66:9..66:15) Saturn <- _empty_/Enums.Planet.Saturn. -[66:25..66:31) Planet -> _empty_/Enums.Planet# -[66:31..66:31) -> _empty_/Enums.Planet#``(). -[67:9..67:15) Uranus <- _empty_/Enums.Planet.Uranus. -[67:25..67:31) Planet -> _empty_/Enums.Planet# -[67:31..67:31) -> _empty_/Enums.Planet#``(). -[68:9..68:16) Neptune <- _empty_/Enums.Planet.Neptune. -[68:25..68:31) Planet -> _empty_/Enums.Planet# -[68:31..68:31) -> _empty_/Enums.Planet#``(). +[0:7..0:12): Enums <- _empty_/Enums. +[1:9..1:12): <:< -> _empty_/Enums.`<:<`. +[3:7..3:13): Colour <- _empty_/Enums.Colour# +[4:4..4:4): <- _empty_/Enums.Colour#``(). +[4:11..4:17): Colour -> _empty_/Enums.Colour. +[4:18..4:21): Red -> _empty_/Enums.Colour.Red. +[5:9..5:12): Red <- _empty_/Enums.Colour.Red. +[5:14..5:19): Green <- _empty_/Enums.Colour.Green. +[5:21..5:25): Blue <- _empty_/Enums.Colour.Blue. +[7:7..7:17): Directions <- _empty_/Enums.Directions# +[8:4..8:4): <- _empty_/Enums.Directions#``(). +[8:9..8:14): North <- _empty_/Enums.Directions.North. +[8:16..8:20): East <- _empty_/Enums.Directions.East. +[8:22..8:27): South <- _empty_/Enums.Directions.South. +[8:29..8:33): West <- _empty_/Enums.Directions.West. +[10:7..10:12): Suits <- _empty_/Enums.Suits# +[10:21..10:21): <- _empty_/Enums.Suits#``(). +[10:21..10:21): -> scala/Eql.derived. +[11:9..11:15): Hearts <- _empty_/Enums.Suits.Hearts. +[11:17..11:23): Spades <- _empty_/Enums.Suits.Spades. +[11:25..11:30): Clubs <- _empty_/Enums.Suits.Clubs. +[11:32..11:40): Diamonds <- _empty_/Enums.Suits.Diamonds. +[13:9..13:14): Suits <- _empty_/Enums.Suits. +[14:8..14:13): (suit <- _empty_/Enums.Suits.isRed(). +[14:9..14:13): suit <- _empty_/Enums.Suits.isRed().(suit) +[14:15..14:20): Suits -> _empty_/Enums.Suits# +[14:29..14:36): Boolean -> scala/Boolean# +[15:6..15:10): suit -> _empty_/Enums.Suits.isRed().(suit) +[15:11..15:13): == -> scala/Any#`==`(). +[15:14..15:20): Hearts -> _empty_/Enums.Suits.Hearts. +[15:21..15:23): || -> scala/Boolean#`||`(). +[15:24..15:28): suit -> _empty_/Enums.Suits.isRed().(suit) +[15:29..15:31): == -> scala/Any#`==`(). +[15:32..15:40): Diamonds -> _empty_/Enums.Suits.Diamonds. +[17:8..17:15): (suit: <- _empty_/Enums.Suits.isBlack(). +[17:9..17:13): suit <- _empty_/Enums.Suits.isBlack().(suit) +[17:15..17:20): Suits -> _empty_/Enums.Suits# +[17:31..17:38): Boolean -> scala/Boolean# +[17:41..17:45): suit -> _empty_/Enums.Suits.isBlack().(suit) +[18:11..18:17): Spades -> _empty_/Enums.Suits.Spades. +[18:20..18:28): Diamonds -> _empty_/Enums.Suits.Diamonds. +[21:7..21:15): WeekDays <- _empty_/Enums.WeekDays# +[22:4..22:4): <- _empty_/Enums.WeekDays#``(). +[22:9..22:15): Monday <- _empty_/Enums.WeekDays.Monday. +[23:9..23:16): Tuesday <- _empty_/Enums.WeekDays.Tuesday. +[24:9..24:18): Wednesday <- _empty_/Enums.WeekDays.Wednesday. +[25:9..25:17): Thursday <- _empty_/Enums.WeekDays.Thursday. +[26:9..26:15): Friday <- _empty_/Enums.WeekDays.Friday. +[27:9..27:17): Saturday <- _empty_/Enums.WeekDays.Saturday. +[28:9..28:15): Sunday <- _empty_/Enums.WeekDays.Sunday. +[30:7..30:11): Coin <- _empty_/Enums.Coin# +[30:11..30:23): <- _empty_/Enums.Coin#``(). +[30:12..30:17): value <- _empty_/Enums.Coin#value. +[30:19..30:22): Int -> scala/Int# +[31:9..31:14): Penny <- _empty_/Enums.Coin.Penny. +[31:26..31:30): Coin -> _empty_/Enums.Coin# +[31:30..31:30): -> _empty_/Enums.Coin#``(). +[32:9..32:15): Nickel <- _empty_/Enums.Coin.Nickel. +[32:26..32:30): Coin -> _empty_/Enums.Coin# +[32:30..32:30): -> _empty_/Enums.Coin#``(). +[33:9..33:13): Dime <- _empty_/Enums.Coin.Dime. +[33:26..33:30): Coin -> _empty_/Enums.Coin# +[33:30..33:30): -> _empty_/Enums.Coin#``(). +[34:9..34:16): Quarter <- _empty_/Enums.Coin.Quarter. +[34:26..34:30): Coin -> _empty_/Enums.Coin# +[34:30..34:30): -> _empty_/Enums.Coin#``(). +[35:9..35:15): Dollar <- _empty_/Enums.Coin.Dollar. +[35:26..35:30): Coin -> _empty_/Enums.Coin# +[35:30..35:30): -> _empty_/Enums.Coin#``(). +[37:7..37:12): Maybe <- _empty_/Enums.Maybe# +[37:12..37:16): <- _empty_/Enums.Maybe#``(). +[37:14..37:15): A <- _empty_/Enums.Maybe#[A] +[38:4..38:4): -> _empty_/Enums.Maybe#``(). +[38:9..38:13): Just <- _empty_/Enums.Maybe.Just# +[38:13..38:23): <- _empty_/Enums.Maybe.Just#``(). +[38:14..38:19): value <- _empty_/Enums.Maybe.Just#value. +[38:21..38:22): A -> _empty_/Enums.Maybe.Just#[A] +[39:4..39:4): -> _empty_/Enums.Maybe#``(). +[39:9..39:13): None <- _empty_/Enums.Maybe.None. +[41:7..41:10): Tag <- _empty_/Enums.Tag# +[41:10..41:13): <- _empty_/Enums.Tag#``(). +[41:11..41:12): A <- _empty_/Enums.Tag#[A] +[42:9..42:15): IntTag <- _empty_/Enums.Tag.IntTag. +[42:24..42:27): Tag -> _empty_/Enums.Tag# +[42:28..42:31): Int -> scala/Int# +[42:32..42:32): -> _empty_/Enums.Tag#``(). +[43:9..43:19): BooleanTag <- _empty_/Enums.Tag.BooleanTag. +[43:28..43:31): Tag -> _empty_/Enums.Tag# +[43:32..43:39): Boolean -> scala/Boolean# +[43:40..43:40): -> _empty_/Enums.Tag#``(). +[45:7..45:10): <:< <- _empty_/Enums.`<:<`# +[45:10..45:17): <- _empty_/Enums.`<:<`#``(). +[45:12..45:13): A <- _empty_/Enums.`<:<`#[A] +[45:15..45:16): B <- _empty_/Enums.`<:<`#[B] +[46:9..46:13): Refl <- _empty_/Enums.`<:<`.Refl# +[46:13..46:18): <- _empty_/Enums.`<:<`.Refl#``(). +[46:14..46:15): C <- _empty_/Enums.`<:<`.Refl#[C] +[46:28..46:29): C -> _empty_/Enums.`<:<`.Refl#[C] +[46:30..46:33): <:< -> _empty_/Enums.`<:<`# +[46:34..46:35): C -> _empty_/Enums.`<:<`.Refl#[C] +[46:35..46:35): -> _empty_/Enums.`<:<`#``(). +[48:9..48:12): <:< <- _empty_/Enums.`<:<`. +[49:10..49:17): [T]: (T <- _empty_/Enums.`<:<`.given_T(). +[49:11..49:12): T <- _empty_/Enums.`<:<`.given_T().[T] +[49:16..49:17): T -> _empty_/Enums.`<:<`.given_T().[T] +[49:18..49:21): <:< -> _empty_/Enums.`<:<`# +[49:22..49:23): T -> _empty_/Enums.`<:<`.given_T().[T] +[49:27..49:31): Refl -> _empty_/Enums.`<:<`.Refl. +[51:6..51:12): [A, B] <- _empty_/Enums.unwrap(). +[51:7..51:8): A <- _empty_/Enums.unwrap().[A] +[51:10..51:11): B <- _empty_/Enums.unwrap().[B] +[51:13..51:16): opt <- _empty_/Enums.unwrap().(opt) +[51:18..51:24): Option -> scala/Option# +[51:25..51:26): A -> _empty_/Enums.unwrap().[A] +[51:42..51:44): ev <- _empty_/Enums.unwrap().(ev) +[51:46..51:47): A -> _empty_/Enums.unwrap().[A] +[51:48..51:51): <:< -> _empty_/Enums.`<:<`# +[51:52..51:58): Option -> scala/Option# +[51:59..51:60): B -> _empty_/Enums.unwrap().[B] +[51:64..51:70): Option -> scala/Option# +[51:71..51:72): B -> _empty_/Enums.unwrap().[B] +[51:76..51:78): ev -> _empty_/Enums.unwrap().(ev) +[52:9..52:13): Refl -> _empty_/Enums.`<:<`.Refl. +[52: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:40..52:46): Option -> scala/Option# +[52:47..52:48): B -> _empty_/Enums.unwrap().[B] +[54:6..54:11): some1 <- _empty_/Enums.some1. +[54:14..54:14): -> _empty_/Enums.unwrap(). +[54:14..54:18): Some -> scala/Some. +[54:19..54:23): Some -> scala/Some. +[54:27..54:27): -> _empty_/Enums.`<:<`.given_T(). +[56:7..56:13): Planet <- _empty_/Enums.Planet# +[56:13..56:43): <- _empty_/Enums.Planet#``(). +[56:14..56:18): mass <- _empty_/Enums.Planet#mass. +[56:20..56:26): Double -> scala/Double# +[56:28..56:34): radius <- _empty_/Enums.Planet#radius. +[56:36..56:42): Double -> scala/Double# +[56:52..56:56): java -> java/ +[56:57..56:61): lang -> java/lang/ +[56:62..56:66): Enum -> java/lang/Enum# +[56:67..56:73): Planet -> _empty_/Enums.Planet# +[56:74..56:74): -> java/lang/Enum#``(). +[57:22..57:23): G <- _empty_/Enums.Planet#G. +[58:8..58:22): surfaceGravity <- _empty_/Enums.Planet#surfaceGravity(). +[58:25..58:26): G -> _empty_/Enums.Planet#G. +[58:27..58:28): * -> scala/Double#`*`(+6). +[58:29..58:33): mass -> _empty_/Enums.Planet#mass. +[58:34..58:35): / -> scala/Double#`/`(+6). +[58:37..58:43): radius -> _empty_/Enums.Planet#radius. +[58:44..58:45): * -> scala/Double#`*`(+6). +[58:46..58:52): radius -> _empty_/Enums.Planet#radius. +[59:8..59:21): surfaceWeight <- _empty_/Enums.Planet#surfaceWeight(). +[59:22..59:31): otherMass <- _empty_/Enums.Planet#surfaceWeight().(otherMass) +[59:33..59:39): Double -> scala/Double# +[59:43..59:52): otherMass -> _empty_/Enums.Planet#surfaceWeight().(otherMass) +[59:53..59:54): * -> scala/Double#`*`(+6). +[59:55..59:69): surfaceGravity -> _empty_/Enums.Planet#surfaceGravity(). +[61:9..61:16): Mercury <- _empty_/Enums.Planet.Mercury. +[61:25..61:31): Planet -> _empty_/Enums.Planet# +[61:31..61:31): -> _empty_/Enums.Planet#``(). +[62:9..62:14): Venus <- _empty_/Enums.Planet.Venus. +[62:25..62:31): Planet -> _empty_/Enums.Planet# +[62:31..62:31): -> _empty_/Enums.Planet#``(). +[63:9..63:14): Earth <- _empty_/Enums.Planet.Earth. +[63:25..63:31): Planet -> _empty_/Enums.Planet# +[63:31..63:31): -> _empty_/Enums.Planet#``(). +[64:9..64:13): Mars <- _empty_/Enums.Planet.Mars. +[64:25..64:31): Planet -> _empty_/Enums.Planet# +[64:31..64:31): -> _empty_/Enums.Planet#``(). +[65:9..65:16): Jupiter <- _empty_/Enums.Planet.Jupiter. +[65:25..65:31): Planet -> _empty_/Enums.Planet# +[65:31..65:31): -> _empty_/Enums.Planet#``(). +[66:9..66:15): Saturn <- _empty_/Enums.Planet.Saturn. +[66:25..66:31): Planet -> _empty_/Enums.Planet# +[66:31..66:31): -> _empty_/Enums.Planet#``(). +[67:9..67:15): Uranus <- _empty_/Enums.Planet.Uranus. +[67:25..67:31): Planet -> _empty_/Enums.Planet# +[67:31..67:31): -> _empty_/Enums.Planet#``(). +[68:9..68:16): Neptune <- _empty_/Enums.Planet.Neptune. +[68:25..68:31): Planet -> _empty_/Enums.Planet# +[68:31..68:31): -> _empty_/Enums.Planet#``(). expect/EtaExpansion.scala _________________________ @@ -838,16 +838,16 @@ example/EtaExpansion# => class EtaExpansion example/EtaExpansion#``(). => primary ctor 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:10..3:13) map -> scala/Option#map(). -[3:14..3:22) identity -> scala/Predef.identity(). -[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#`+`(). +[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:10..3:13): map -> scala/Option#map(). +[3:14..3:22): identity -> scala/Predef.identity(). +[4:2..4:6): List -> scala/package.List. +[4:6..4:6): -> scala/collection/IterableFactory#apply(). +[4:10..4:18): foldLeft -> scala/collection/LinearSeqOps#foldLeft(). +[4:25..4:26): + -> java/lang/String#`+`(). expect/Example.scala ____________________ @@ -868,33 +868,33 @@ example/Example.x. => val method x local0 => selfparam self Occurrences: -[0:8..0:15) example <- example/ -[2:7..2:12) scala -> scala/ -[2:13..2:23) concurrent -> scala/concurrent/ -[2:24..2:30) Future -> scala/concurrent/Future. -[2:24..2:30) Future -> scala/concurrent/Future# -[4:7..4:14) Example <- example/Example. -[4:17..4:21) self <- local0 -[4:17..4:17) -> example/Example. -[5:6..5:11) scala -> scala/ -[5:12..5:22) collection -> scala/collection/ -[5:23..5:30) mutable -> scala/collection/mutable/ -[5:31..5:36) Stack -> scala/collection/mutable/Stack# -[5:37..5:40) Int -> scala/Int# -[5:41..5:41) -> scala/collection/mutable/Stack#``(+1). -[6:6..6:10) main <- example/Example.main(). -[6:11..6:15) args <- example/Example.main().(args) -[6:17..6:22) Array -> scala/Array# -[6:23..6:29) String -> scala/Predef.String# -[6:33..6:37) Unit -> scala/Unit# -[7:4..7:11) println -> scala/Predef.println(+1). -[9:6..9:7) x <- example/Example.x. -[9:10..9:15) scala -> scala/ -[9:16..9:23) reflect -> scala/reflect/ -[9:24..9:32) classTag -> scala/reflect/package.classTag(). -[9:33..9:36) Int -> scala/Int# -[9:37..9:37) -> scala/reflect/ClassTag.apply(). -[9:37..9:37) -> java/lang/Integer#TYPE. +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:23): concurrent -> scala/concurrent/ +[2:24..2:30): Future -> scala/concurrent/Future. +[2:24..2:30): Future -> scala/concurrent/Future# +[4:7..4:14): Example <- example/Example. +[4:17..4:21): self <- local0 +[4:17..4:17): -> example/Example. +[5:6..5:11): scala -> scala/ +[5:12..5:22): collection -> scala/collection/ +[5:23..5:30): mutable -> scala/collection/mutable/ +[5:31..5:36): Stack -> scala/collection/mutable/Stack# +[5:37..5:40): Int -> scala/Int# +[5:41..5:41): -> scala/collection/mutable/Stack#``(+1). +[6:6..6:10): main <- example/Example.main(). +[6:11..6:15): args <- example/Example.main().(args) +[6:17..6:22): Array -> scala/Array# +[6:23..6:29): String -> scala/Predef.String# +[6:33..6:37): Unit -> scala/Unit# +[7:4..7:11): println -> scala/Predef.println(+1). +[9:6..9:7): x <- example/Example.x. +[9:10..9:15): scala -> scala/ +[9:16..9:23): reflect -> scala/reflect/ +[9:24..9:32): classTag -> scala/reflect/package.classTag(). +[9:33..9:36): Int -> scala/Int# +[9:37..9:37): -> scala/reflect/ClassTag.apply(). +[9:37..9:37): -> java/lang/Integer#TYPE. expect/Flags.scala __________________ @@ -959,93 +959,93 @@ local1 => val local xs2 local2 => case val method t Occurrences: -[0:8..0:13) flags <- flags/ -[2:7..2:12) scala -> scala/ -[2:13..2:21) language -> scalaShadowing/language. -[2:22..2:34) experimental -> scalaShadowing/language.experimental. -[2:35..2:41) macros -> scalaShadowing/language.experimental.macros. -[4:15..5:3) <- flags/p/package. -[5:2..5:3) p -> flags/p/ -[5:19..5:20) x <- flags/p/package.x. -[6:25..6:26) y <- flags/p/package.y(). -[6:25..6:28) y: <- flags/p/package.`y_=`(). -[6:28..6:31) Int -> scala/Int# -[7:6..7:7) z <- flags/p/package.z(). -[7:8..7:10) pp <- flags/p/package.z().(pp) -[7:12..7:15) Int -> scala/Int# -[8:6..8:7) m <- flags/p/package.m(). -[8:8..8:10) TT <- flags/p/package.m().[TT] -[8:13..8:16) Int -> scala/Int# -[8:16..8:16) -> scala/Predef.`???`(). -[9:17..9:18) C <- flags/p/package.C# -[9:18..9:47) <- flags/p/package.C#``(). -[9:20..9:21) T <- flags/p/package.C#[T] -[9:24..9:25) U <- flags/p/package.C#[U] -[9:27..9:28) V <- flags/p/package.C#[V] -[9:30..9:31) x <- flags/p/package.C#x. -[9:33..9:34) T -> flags/p/package.C#[T] -[9:36..9:37) y <- flags/p/package.C#y. -[9:39..9:40) U -> flags/p/package.C#[U] -[9:42..9:43) z <- flags/p/package.C#z. -[9:45..9:46) V -> flags/p/package.C#[V] -[10:8..10:14) <- flags/p/package.C#``(+1). -[10:22..10:22) -> flags/p/package.C#``(). -[10:22..10:25) ??? -> scala/Predef.`???`(). -[10:27..10:30) ??? -> scala/Predef.`???`(). -[10:32..10:35) ??? -> scala/Predef.`???`(). -[11:8..11:14) <- flags/p/package.C#``(+2). -[11:13..11:14) t <- flags/p/package.C#``(+2).(t) -[11:16..11:17) T -> flags/p/package.C#[T] -[11:26..11:26) -> flags/p/package.C#``(). -[11:26..11:27) t -> flags/p/package.C#``(+2).(t) -[11:29..11:32) ??? -> scala/Predef.`???`(). -[11:34..11:37) ??? -> scala/Predef.`???`(). -[12:8..12:9) w <- flags/p/package.C#w(). -[12:11..12:14) Int -> scala/Int# -[14:7..14:9) T1 <- flags/p/package.T1# -[14:12..14:15) Int -> scala/Int# -[15:7..15:9) T2 <- flags/p/package.T2# -[15:10..15:11) T <- flags/p/package.T2#[T] -[15:15..15:16) S -> flags/p/package.S# -[15:17..15:18) T -> flags/p/package.T2#[T] -[16:7..16:8) U <- flags/p/package.U# -[16:12..16:15) Int -> scala/Int# -[17:7..17:8) V <- flags/p/package.V# -[17:12..17:15) Int -> scala/Int# -[18:14..18:15) X <- flags/p/package.X. -[19:2..19:2) <- flags/p/package.Y#``(). -[19:14..19:15) Y <- flags/p/package.Y# -[20:2..20:2) <- flags/p/package.Z#``(). -[20:15..20:16) Z <- flags/p/package.Z# -[21:8..21:10) AA <- flags/p/package.AA# -[21:10..21:42) <- flags/p/package.AA#``(). -[21:11..21:12) x <- flags/p/package.AA#x. -[21:14..21:17) Int -> scala/Int# -[21:23..21:24) y <- flags/p/package.AA#y. -[21:26..21:29) Int -> scala/Int# -[21:35..21:36) z <- flags/p/package.AA#z(). -[21:35..21:38) z: <- flags/p/package.AA#`z_=`(). -[21:38..21:41) Int -> scala/Int# -[22:8..22:9) S <- flags/p/package.S# -[22:9..22:25) <- flags/p/package.S#``(). -[22:11..22:22) specialized -> scala/specialized# -[22:22..22:22) -> scala/specialized#``(+2). -[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:11..23:14) xs1 <- local0 -[23:15..23:15) -> local0 -[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 <- local1 -[24:32..24:35) ??? -> scala/Predef.`???`(). -[25:2..25:5) ??? -> scala/Predef.`???`(). -[25:22..25:26) List -> scala/package.List# -[25:27..25:28) t <- local2 -[25:33..25:36) ??? -> scala/Predef.`???`(). +[0:8..0:13): flags <- flags/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:34): experimental -> scalaShadowing/language.experimental. +[2:35..2:41): macros -> scalaShadowing/language.experimental.macros. +[4:15..5:3): <- flags/p/package. +[5:2..5:3): p -> flags/p/ +[5:19..5:20): x <- flags/p/package.x. +[6:25..6:26): y <- flags/p/package.y(). +[6:25..6:28): y: <- flags/p/package.`y_=`(). +[6:28..6:31): Int -> scala/Int# +[7:6..7:7): z <- flags/p/package.z(). +[7:8..7:10): pp <- flags/p/package.z().(pp) +[7:12..7:15): Int -> scala/Int# +[8:6..8:7): m <- flags/p/package.m(). +[8:8..8:10): TT <- flags/p/package.m().[TT] +[8:13..8:16): Int -> scala/Int# +[8:16..8:16): -> scala/Predef.`???`(). +[9:17..9:18): C <- flags/p/package.C# +[9:18..9:47): <- flags/p/package.C#``(). +[9:20..9:21): T <- flags/p/package.C#[T] +[9:24..9:25): U <- flags/p/package.C#[U] +[9:27..9:28): V <- flags/p/package.C#[V] +[9:30..9:31): x <- flags/p/package.C#x. +[9:33..9:34): T -> flags/p/package.C#[T] +[9:36..9:37): y <- flags/p/package.C#y. +[9:39..9:40): U -> flags/p/package.C#[U] +[9:42..9:43): z <- flags/p/package.C#z. +[9:45..9:46): V -> flags/p/package.C#[V] +[10:8..10:14): <- flags/p/package.C#``(+1). +[10:22..10:22): -> flags/p/package.C#``(). +[10:22..10:25): ??? -> scala/Predef.`???`(). +[10:27..10:30): ??? -> scala/Predef.`???`(). +[10:32..10:35): ??? -> scala/Predef.`???`(). +[11:8..11:14): <- flags/p/package.C#``(+2). +[11:13..11:14): t <- flags/p/package.C#``(+2).(t) +[11:16..11:17): T -> flags/p/package.C#[T] +[11:26..11:26): -> flags/p/package.C#``(). +[11:26..11:27): t -> flags/p/package.C#``(+2).(t) +[11:29..11:32): ??? -> scala/Predef.`???`(). +[11:34..11:37): ??? -> scala/Predef.`???`(). +[12:8..12:9): w <- flags/p/package.C#w(). +[12:11..12:14): Int -> scala/Int# +[14:7..14:9): T1 <- flags/p/package.T1# +[14:12..14:15): Int -> scala/Int# +[15:7..15:9): T2 <- flags/p/package.T2# +[15:10..15:11): T <- flags/p/package.T2#[T] +[15:15..15:16): S -> flags/p/package.S# +[15:17..15:18): T -> flags/p/package.T2#[T] +[16:7..16:8): U <- flags/p/package.U# +[16:12..16:15): Int -> scala/Int# +[17:7..17:8): V <- flags/p/package.V# +[17:12..17:15): Int -> scala/Int# +[18:14..18:15): X <- flags/p/package.X. +[19:2..19:2): <- flags/p/package.Y#``(). +[19:14..19:15): Y <- flags/p/package.Y# +[20:2..20:2): <- flags/p/package.Z#``(). +[20:15..20:16): Z <- flags/p/package.Z# +[21:8..21:10): AA <- flags/p/package.AA# +[21:10..21:42): <- flags/p/package.AA#``(). +[21:11..21:12): x <- flags/p/package.AA#x. +[21:14..21:17): Int -> scala/Int# +[21:23..21:24): y <- flags/p/package.AA#y. +[21:26..21:29): Int -> scala/Int# +[21:35..21:36): z <- flags/p/package.AA#z(). +[21:35..21:38): z: <- flags/p/package.AA#`z_=`(). +[21:38..21:41): Int -> scala/Int# +[22:8..22:9): S <- flags/p/package.S# +[22:9..22:25): <- flags/p/package.S#``(). +[22:11..22:22): specialized -> scala/specialized# +[22:22..22:22): -> scala/specialized#``(+2). +[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:11..23:14): xs1 <- local0 +[23:15..23:15): -> local0 +[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 <- local1 +[24:32..24:35): ??? -> scala/Predef.`???`(). +[25:2..25:5): ??? -> scala/Predef.`???`(). +[25:22..25:26): List -> scala/package.List# +[25:27..25:28): t <- local2 +[25:33..25:36): ??? -> scala/Predef.`???`(). expect/ForComprehension.scala _____________________________ @@ -1063,69 +1063,69 @@ example/ForComprehension# => class ForComprehension example/ForComprehension#``(). => primary ctor Occurrences: -[0:8..0:15) example <- example/ -[2:6..2:22) ForComprehension <- example/ForComprehension# -[3:2..3:2) <- example/ForComprehension#``(). -[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 -> local0 -[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 -> local0 -[6:9..6:10) > -> scala/Int#`>`(+3). -[6:12..6:12) -> scala/collection/WithFilter#map(). -[7:4..7:5) c -> local2 -[7:8..7:9) a -> local1 -[7:10..7:11) + -> scala/Int#`+`(+4). -[7:12..7:13) b -> local0 -[7:13..7:13) -> scala/collection/immutable/List#map(). -[8:11..8:12) a -> local1 -[8:14..8:15) b -> local0 -[8:17..8:18) c -> local2 -[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:9..11:13) List -> scala/package.List. -[11:13..11:13) -> scala/collection/IterableFactory#apply(). -[11:14..11:15) a -> local3 -[11:16..11:16) -> scala/collection/IterableOps#withFilter(). -[13:6..13:7) a -> local3 -[14:6..14:7) b -> local4 -[15:6..15:8) == -> scala/Any#`==`(). -[15:15..15:15) -> scala/collection/WithFilter#flatMap(). -[19:9..19:13) List -> scala/package.List. -[19:13..19:13) -> scala/collection/IterableFactory#apply(). -[19:15..19:16) a -> local3 -[19:18..19:19) b -> local4 -[19:21..19:21) -> scala/collection/WithFilter#withFilter(). -[19:21..19:21) -> scala/collection/IterableOps#withFilter(). -[21:6..21:7) a -> local3 -[22:6..22:7) b -> local4 -[23:6..23:7) c -> local5 -[24:6..24:7) d -> local6 -[25:6..25:8) == -> scala/Any#`==`(). -[25:21..25:21) -> scala/collection/WithFilter#map(). -[26:4..26:5) e -> local7 -[27:6..27:7) a -> local3 -[28:6..28:7) b -> local4 -[29:6..29:7) c -> local5 -[30:6..30:7) d -> local6 -[31:5..31:5) -> scala/collection/IterableOps#withFilter(). -[32:7..32:8) e -> local7 -[32:9..32:11) == -> scala/Any#`==`(). -[32:24..32:24) -> scala/collection/WithFilter#flatMap(). -[33:9..33:13) List -> scala/package.List. -[33:13..33:13) -> scala/collection/IterableFactory#apply(). -[33:14..33:15) e -> local7 -[33:16..33:16) -> scala/collection/immutable/List#map(). -[36:6..36:7) a -> local3 -[37:6..37:7) b -> local4 -[38:6..38:7) c -> local5 -[39:6..39:7) d -> local6 -[40:6..40:7) e -> local7 -[41:6..41:7) f -> local8 +[0:8..0:15): example <- example/ +[2:6..2:22): ForComprehension <- example/ForComprehension# +[3:2..3:2): <- example/ForComprehension#``(). +[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 -> local0 +[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 -> local0 +[6:9..6:10): > -> scala/Int#`>`(+3). +[6:12..6:12): -> scala/collection/WithFilter#map(). +[7:4..7:5): c -> local2 +[7:8..7:9): a -> local1 +[7:10..7:11): + -> scala/Int#`+`(+4). +[7:12..7:13): b -> local0 +[7:13..7:13): -> scala/collection/immutable/List#map(). +[8:11..8:12): a -> local1 +[8:14..8:15): b -> local0 +[8:17..8:18): c -> local2 +[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:9..11:13): List -> scala/package.List. +[11:13..11:13): -> scala/collection/IterableFactory#apply(). +[11:14..11:15): a -> local3 +[11:16..11:16): -> scala/collection/IterableOps#withFilter(). +[13:6..13:7): a -> local3 +[14:6..14:7): b -> local4 +[15:6..15:8): == -> scala/Any#`==`(). +[15:15..15:15): -> scala/collection/WithFilter#flatMap(). +[19:9..19:13): List -> scala/package.List. +[19:13..19:13): -> scala/collection/IterableFactory#apply(). +[19:15..19:16): a -> local3 +[19:18..19:19): b -> local4 +[19:21..19:21): -> scala/collection/WithFilter#withFilter(). +[19:21..19:21): -> scala/collection/IterableOps#withFilter(). +[21:6..21:7): a -> local3 +[22:6..22:7): b -> local4 +[23:6..23:7): c -> local5 +[24:6..24:7): d -> local6 +[25:6..25:8): == -> scala/Any#`==`(). +[25:21..25:21): -> scala/collection/WithFilter#map(). +[26:4..26:5): e -> local7 +[27:6..27:7): a -> local3 +[28:6..28:7): b -> local4 +[29:6..29:7): c -> local5 +[30:6..30:7): d -> local6 +[31:5..31:5): -> scala/collection/IterableOps#withFilter(). +[32:7..32:8): e -> local7 +[32:9..32:11): == -> scala/Any#`==`(). +[32:24..32:24): -> scala/collection/WithFilter#flatMap(). +[33:9..33:13): List -> scala/package.List. +[33:13..33:13): -> scala/collection/IterableFactory#apply(). +[33:14..33:15): e -> local7 +[33:16..33:16): -> scala/collection/immutable/List#map(). +[36:6..36:7): a -> local3 +[37:6..37:7): b -> local4 +[38:6..38:7): c -> local5 +[39:6..39:7): d -> local6 +[40:6..40:7): e -> local7 +[41:6..41:7): f -> local8 expect/Givens.scala ___________________ @@ -1172,75 +1172,75 @@ a/b/Givens.int2String(). => final implicit macro int2String a/b/Givens.soLong1. => val method soLong1 Occurrences: -[0:8..0:9) a <- a/ -[1:8..1:9) b <- a/b/ -[3:7..3:13) Givens <- a/b/Givens. -[5:8..6:6) <- a/b/Givens.given_sayHello_of_A. -[5:10..5:11) A <- a/b/Givens.given_sayHello_of_A.sayHello().[A] -[5:13..5:16) any <- a/b/Givens.given_sayHello_of_A.sayHello().(any) -[5:18..5:19) A -> a/b/Givens.given_sayHello_of_A.sayHello().[A] -[6:8..6:16) sayHello <- a/b/Givens.given_sayHello_of_A.sayHello(). -[6:34..6:37) any -> a/b/Givens.given_sayHello_of_A.sayHello().(any) -[6:37..6:37) -> scala/StringContext#s(). -[8:8..9:8) <- a/b/Givens.given_sayGoodbye_of_B. -[8:10..8:11) B <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] -[8:10..8:11) B <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] -[8:13..8:16) any <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) -[8:13..8:16) any <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) -[8:18..8:19) B -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] -[8:18..8:19) B -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] -[9:8..9:18) sayGoodbye <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). -[9:38..9:41) any -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) -[9:41..9:41) -> scala/StringContext#s(). -[10:8..10:17) saySoLong <- a/b/Givens.given_sayGoodbye_of_B.saySoLong(). -[10:37..10:40) any -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) -[10:40..10:40) -> scala/StringContext#s(). -[12:6..12:12) hello1 <- a/b/Givens.hello1. -[12:15..12:15) -> a/b/Givens.given_sayHello_of_A.sayHello(). -[13:6..13:14) goodbye1 <- a/b/Givens.goodbye1. -[13:17..13:17) -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). -[14:6..14:13) soLong1 <- a/b/Givens.soLong1. -[14:16..14:16) -> a/b/Givens.given_sayGoodbye_of_B.saySoLong(). -[16:8..16:14) Monoid <- a/b/Givens.Monoid# -[16:14..16:17) <- a/b/Givens.Monoid#``(). -[16:15..16:16) A <- a/b/Givens.Monoid#[A] -[17:8..17:13) empty <- a/b/Givens.Monoid#empty(). -[17:15..17:16) A -> a/b/Givens.Monoid#[A] -[18:8..18:15) (x: A) <- a/b/Givens.Monoid#combine(). -[18:9..18:10) x <- a/b/Givens.Monoid#combine().(x) -[18:12..18:13) A -> a/b/Givens.Monoid#[A] -[18:24..18:25) y <- a/b/Givens.Monoid#combine().(y) -[18:27..18:28) A -> a/b/Givens.Monoid#[A] -[18:31..18:32) A -> a/b/Givens.Monoid#[A] -[20:8..21:4) <- a/b/Givens.given_Monoid_String. -[20:8..20:14) Monoid -> a/b/Givens.Monoid# -[20:15..20:21) String -> scala/Predef.String# -[21:8..21:13) empty <- a/b/Givens.given_Monoid_String.empty(). -[22:8..22:15) (x: Str <- a/b/Givens.given_Monoid_String.combine(). -[22:9..22:10) x <- a/b/Givens.given_Monoid_String.combine().(x) -[22:12..22:18) String -> scala/Predef.String# -[22:29..22:30) y <- a/b/Givens.given_Monoid_String.combine().(y) -[22:32..22:38) String -> scala/Predef.String# -[22:42..22:43) x -> a/b/Givens.given_Monoid_String.combine().(x) -[22:44..22:45) + -> java/lang/String#`+`(). -[22:46..22:47) y -> a/b/Givens.given_Monoid_String.combine().(y) -[24:15..24:25) int2String <- a/b/Givens.int2String(). -[24:27..24:37) Conversion -> scala/Conversion# -[24:38..24:41) Int -> scala/Int# -[24:43..24:49) String -> scala/Predef.String# -[24:55..24:63) toString -> scala/Any#toString(). -[26:6..26:9) foo <- a/b/Givens.foo(). -[26:10..26:11) A <- a/b/Givens.foo().[A] -[26:19..26:20) A <- a/b/Givens.foo().(A) -[26:22..26:28) Monoid -> a/b/Givens.Monoid# -[26:29..26:30) A -> a/b/Givens.foo().[A] -[26:34..26:35) A -> a/b/Givens.foo().[A] -[26:38..26:39) A -> a/b/Givens.foo().(A) -[26:40..26:47) combine -> a/b/Givens.Monoid#combine(). -[26:48..26:49) A -> a/b/Givens.foo().(A) -[26:50..26:55) empty -> a/b/Givens.Monoid#empty(). -[26:57..26:58) A -> a/b/Givens.foo().(A) -[26:59..26:64) empty -> a/b/Givens.Monoid#empty(). +[0:8..0:9): a <- a/ +[1:8..1:9): b <- a/b/ +[3:7..3:13): Givens <- a/b/Givens. +[5:8..6:6): <- a/b/Givens.given_sayHello_of_A. +[5:10..5:11): A <- a/b/Givens.given_sayHello_of_A.sayHello().[A] +[5:13..5:16): any <- a/b/Givens.given_sayHello_of_A.sayHello().(any) +[5:18..5:19): A -> a/b/Givens.given_sayHello_of_A.sayHello().[A] +[6:8..6:16): sayHello <- a/b/Givens.given_sayHello_of_A.sayHello(). +[6:34..6:37): any -> a/b/Givens.given_sayHello_of_A.sayHello().(any) +[6:37..6:37): -> scala/StringContext#s(). +[8:8..9:8): <- a/b/Givens.given_sayGoodbye_of_B. +[8:10..8:11): B <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] +[8:10..8:11): B <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] +[8:13..8:16): any <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) +[8:13..8:16): any <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) +[8:18..8:19): B -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] +[8:18..8:19): B -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] +[9:8..9:18): sayGoodbye <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). +[9:38..9:41): any -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) +[9:41..9:41): -> scala/StringContext#s(). +[10:8..10:17): saySoLong <- a/b/Givens.given_sayGoodbye_of_B.saySoLong(). +[10:37..10:40): any -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) +[10:40..10:40): -> scala/StringContext#s(). +[12:6..12:12): hello1 <- a/b/Givens.hello1. +[12:15..12:15): -> a/b/Givens.given_sayHello_of_A.sayHello(). +[13:6..13:14): goodbye1 <- a/b/Givens.goodbye1. +[13:17..13:17): -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). +[14:6..14:13): soLong1 <- a/b/Givens.soLong1. +[14:16..14:16): -> a/b/Givens.given_sayGoodbye_of_B.saySoLong(). +[16:8..16:14): Monoid <- a/b/Givens.Monoid# +[16:14..16:17): <- a/b/Givens.Monoid#``(). +[16:15..16:16): A <- a/b/Givens.Monoid#[A] +[17:8..17:13): empty <- a/b/Givens.Monoid#empty(). +[17:15..17:16): A -> a/b/Givens.Monoid#[A] +[18:8..18:15): (x: A) <- a/b/Givens.Monoid#combine(). +[18:9..18:10): x <- a/b/Givens.Monoid#combine().(x) +[18:12..18:13): A -> a/b/Givens.Monoid#[A] +[18:24..18:25): y <- a/b/Givens.Monoid#combine().(y) +[18:27..18:28): A -> a/b/Givens.Monoid#[A] +[18:31..18:32): A -> a/b/Givens.Monoid#[A] +[20:8..21:4): <- a/b/Givens.given_Monoid_String. +[20:8..20:14): Monoid -> a/b/Givens.Monoid# +[20:15..20:21): String -> scala/Predef.String# +[21:8..21:13): empty <- a/b/Givens.given_Monoid_String.empty(). +[22:8..22:15): (x: Str <- a/b/Givens.given_Monoid_String.combine(). +[22:9..22:10): x <- a/b/Givens.given_Monoid_String.combine().(x) +[22:12..22:18): String -> scala/Predef.String# +[22:29..22:30): y <- a/b/Givens.given_Monoid_String.combine().(y) +[22:32..22:38): String -> scala/Predef.String# +[22:42..22:43): x -> a/b/Givens.given_Monoid_String.combine().(x) +[22:44..22:45): + -> java/lang/String#`+`(). +[22:46..22:47): y -> a/b/Givens.given_Monoid_String.combine().(y) +[24:15..24:25): int2String <- a/b/Givens.int2String(). +[24:27..24:37): Conversion -> scala/Conversion# +[24:38..24:41): Int -> scala/Int# +[24:43..24:49): String -> scala/Predef.String# +[24:55..24:63): toString -> scala/Any#toString(). +[26:6..26:9): foo <- a/b/Givens.foo(). +[26:10..26:11): A <- a/b/Givens.foo().[A] +[26:19..26:20): A <- a/b/Givens.foo().(A) +[26:22..26:28): Monoid -> a/b/Givens.Monoid# +[26:29..26:30): A -> a/b/Givens.foo().[A] +[26:34..26:35): A -> a/b/Givens.foo().[A] +[26:38..26:39): A -> a/b/Givens.foo().(A) +[26:40..26:47): combine -> a/b/Givens.Monoid#combine(). +[26:48..26:49): A -> a/b/Givens.foo().(A) +[26:50..26:55): empty -> a/b/Givens.Monoid#empty(). +[26:57..26:58): A -> a/b/Givens.foo().(A) +[26:59..26:64): empty -> a/b/Givens.Monoid#empty(). expect/ImplicitConversion.scala _______________________________ @@ -1275,64 +1275,64 @@ example/ImplicitConversion.newAny2stringadd#``().(self) => param self example/ImplicitConversion.newAny2stringadd#self. => val method self Occurrences: -[0:8..0:15) example <- example/ -[2:7..2:12) scala -> scala/ -[2:13..2:21) language -> scalaShadowing/language. -[2:22..2:41) implicitConversions -> scalaShadowing/language.implicitConversions. -[4:6..4:24) ImplicitConversion <- example/ImplicitConversion# -[5:2..5:2) <- example/ImplicitConversion#``(). -[5:9..5:27) ImplicitConversion -> example/ImplicitConversion. -[6:15..6:28) string2Number <- example/ImplicitConversion#string2Number(). -[7:6..7:12) string <- example/ImplicitConversion#string2Number().(string) -[7:14..7:20) String -> scala/Predef.String# -[8:5..8:8) Int -> scala/Int# -[9:6..9:13) message <- example/ImplicitConversion#message. -[10:6..10:12) number <- example/ImplicitConversion#number. -[11:6..11:11) tuple <- example/ImplicitConversion#tuple. -[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: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:11..23:18) message -> example/ImplicitConversion#message. -[23:20..23:26) number -> example/ImplicitConversion#number. -[23:26..23:26) -> scala/StringContext#s(). -[24:2..24:2) -> scala/Predef.augmentString(). -[25:7..25:14) message -> example/ImplicitConversion#message. -[26:7..26:13) number -> example/ImplicitConversion#number. -[26:13..26:13) -> scala/StringContext#s(). -[26:17..26:28) stripMargin -> scala/collection/StringOps#stripMargin(+1). -[28:6..28:7) a <- example/ImplicitConversion#a. -[28:9..28:12) Int -> scala/Int# -[28:15..28:15) -> scala/Char.char2int(). -[28:15..28:19) char -> example/ImplicitConversion#char. -[29:6..29:7) b <- example/ImplicitConversion#b. -[29:9..29:13) Long -> scala/Long# -[29:16..29:16) -> scala/Char.char2long(). -[29:16..29:20) char -> example/ImplicitConversion#char. -[32:7..32:25) ImplicitConversion <- example/ImplicitConversion. -[33:23..33:39) newAny2stringadd <- example/ImplicitConversion.newAny2stringadd# -[33:39..33:63) <- example/ImplicitConversion.newAny2stringadd#``(). -[33:40..33:41) A <- example/ImplicitConversion.newAny2stringadd#[A] -[33:55..33:59) self <- example/ImplicitConversion.newAny2stringadd#self. -[33:61..33:62) A -> example/ImplicitConversion.newAny2stringadd#[A] -[33:72..33:78) AnyVal -> scala/AnyVal# -[33:78..33:78) -> scala/AnyVal#``(). -[34:8..34:9) + <- example/ImplicitConversion.newAny2stringadd#`+`(). -[34:10..34:15) other <- example/ImplicitConversion.newAny2stringadd#`+`().(other) -[34:17..34:23) String -> scala/Predef.String# -[34:26..34:32) String -> scala/Predef.String# -[34:35..34:41) String -> java/lang/String# -[34:42..34:49) valueOf -> java/lang/String#valueOf(). -[34:50..34:54) self -> example/ImplicitConversion.newAny2stringadd#self. -[34:56..34:57) + -> java/lang/String#`+`(). -[34:58..34:63) other -> example/ImplicitConversion.newAny2stringadd#`+`().(other) +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:41): implicitConversions -> scalaShadowing/language.implicitConversions. +[4:6..4:24): ImplicitConversion <- example/ImplicitConversion# +[5:2..5:2): <- example/ImplicitConversion#``(). +[5:9..5:27): ImplicitConversion -> example/ImplicitConversion. +[6:15..6:28): string2Number <- example/ImplicitConversion#string2Number(). +[7:6..7:12): string <- example/ImplicitConversion#string2Number().(string) +[7:14..7:20): String -> scala/Predef.String# +[8:5..8:8): Int -> scala/Int# +[9:6..9:13): message <- example/ImplicitConversion#message. +[10:6..10:12): number <- example/ImplicitConversion#number. +[11:6..11:11): tuple <- example/ImplicitConversion#tuple. +[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: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:11..23:18): message -> example/ImplicitConversion#message. +[23:20..23:26): number -> example/ImplicitConversion#number. +[23:26..23:26): -> scala/StringContext#s(). +[24:2..24:2): -> scala/Predef.augmentString(). +[25:7..25:14): message -> example/ImplicitConversion#message. +[26:7..26:13): number -> example/ImplicitConversion#number. +[26:13..26:13): -> scala/StringContext#s(). +[26:17..26:28): stripMargin -> scala/collection/StringOps#stripMargin(+1). +[28:6..28:7): a <- example/ImplicitConversion#a. +[28:9..28:12): Int -> scala/Int# +[28:15..28:15): -> scala/Char.char2int(). +[28:15..28:19): char -> example/ImplicitConversion#char. +[29:6..29:7): b <- example/ImplicitConversion#b. +[29:9..29:13): Long -> scala/Long# +[29:16..29:16): -> scala/Char.char2long(). +[29:16..29:20): char -> example/ImplicitConversion#char. +[32:7..32:25): ImplicitConversion <- example/ImplicitConversion. +[33:23..33:39): newAny2stringadd <- example/ImplicitConversion.newAny2stringadd# +[33:39..33:63): <- example/ImplicitConversion.newAny2stringadd#``(). +[33:40..33:41): A <- example/ImplicitConversion.newAny2stringadd#[A] +[33:55..33:59): self <- example/ImplicitConversion.newAny2stringadd#self. +[33:61..33:62): A -> example/ImplicitConversion.newAny2stringadd#[A] +[33:72..33:78): AnyVal -> scala/AnyVal# +[33:78..33:78): -> scala/AnyVal#``(). +[34:8..34:9): + <- example/ImplicitConversion.newAny2stringadd#`+`(). +[34:10..34:15): other <- example/ImplicitConversion.newAny2stringadd#`+`().(other) +[34:17..34:23): String -> scala/Predef.String# +[34:26..34:32): String -> scala/Predef.String# +[34:35..34:41): String -> java/lang/String# +[34:42..34:49): valueOf -> java/lang/String#valueOf(). +[34:50..34:54): self -> example/ImplicitConversion.newAny2stringadd#self. +[34:56..34:57): + -> java/lang/String#`+`(). +[34:58..34:63): other -> example/ImplicitConversion.newAny2stringadd#`+`().(other) expect/Imports.scala ____________________ @@ -1348,10 +1348,10 @@ Occurrences => 4 entries Symbols: Occurrences: -[0:7..0:12) scala -> scala/ -[0:13..0:17) util -> scala/util/ -[0:18..0:25) control -> scala/util/control/ -[0:26..0:34) NonFatal -> scala/util/control/NonFatal. +[0:7..0:12): scala -> scala/ +[0:13..0:17): util -> scala/util/ +[0:18..0:25): control -> scala/util/control/ +[0:26..0:34): NonFatal -> scala/util/control/NonFatal. expect/InstrumentTyper.scala ____________________________ @@ -1375,60 +1375,60 @@ example/InstrumentTyper#singletonType().(x) => param x local0 => selfparam self Occurrences: -[0:8..0:15) example <- example/ -[2:7..2:12) scala -> scala/ -[2:13..2:23) annotation -> scala/annotation/ -[2:24..2:28) meta -> scala/annotation/meta/ -[2:29..2:34) param -> scala/annotation/meta/param. -[3:7..3:12) scala -> scala/ -[3:13..3:21) language -> scalaShadowing/language. -[3:22..3:34) existentials -> scalaShadowing/language.existentials. -[4:7..4:12) scala -> scala/ -[4:13..4:21) language -> scalaShadowing/language. -[4:22..4:33) higherKinds -> scalaShadowing/language.higherKinds. -[5:7..5:12) types -> types/ -[5:13..5:17) Test -> types/Test. -[7:6..7:21) InstrumentTyper <- example/InstrumentTyper# -[7:24..7:24) <- example/InstrumentTyper#``(). -[7:24..7:28) self <- local0 -[7:30..7:36) AnyRef -> scala/AnyRef# -[8:6..8:9) all <- example/InstrumentTyper#all(). -[8:12..8:16) List -> scala/package.List. -[8:16..8:16) -> scala/collection/IterableFactory#apply(). -[9:4..9:11) Literal -> types/Test.Literal. -[9:12..9:15) int -> types/Test.Literal.int. -[10:4..10:11) Literal -> types/Test.Literal. -[10:12..10:16) long -> types/Test.Literal.long. -[11:4..11:11) Literal -> types/Test.Literal. -[11:12..11:17) float -> types/Test.Literal.float. -[12:4..12:11) Literal -> types/Test.Literal. -[12:12..12:18) double -> types/Test.Literal.double. -[13:4..13:11) Literal -> types/Test.Literal. -[13:12..13:15) nil -> types/Test.Literal.nil. -[14:4..14:11) Literal -> types/Test.Literal. -[14:12..14:16) char -> types/Test.Literal.char. -[15:4..15:11) Literal -> types/Test.Literal. -[15:12..15:18) string -> types/Test.Literal.string. -[16:4..16:11) Literal -> types/Test.Literal. -[16:12..16:16) bool -> types/Test.Literal.bool. -[17:4..17:11) Literal -> types/Test.Literal. -[17:12..17:16) unit -> types/Test.Literal.unit. -[18:4..18:11) Literal -> types/Test.Literal. -[18:12..18:20) javaEnum -> types/Test.Literal.javaEnum. -[19:4..19:11) Literal -> types/Test.Literal. -[19:12..19:19) clazzOf -> types/Test.Literal.clazzOf. -[20:4..20:8) List -> scala/package.List. -[20:8..20:8) -> scala/collection/IterableFactory#apply(). -[22:7..22:20) AnnotatedType <- example/InstrumentTyper#AnnotatedType# -[22:23..22:26) Int -> scala/Int# -[23:6..23:19) singletonType <- example/InstrumentTyper#singletonType(). -[23:20..23:21) x <- example/InstrumentTyper#singletonType().(x) -[23:23..23:29) Predef -> scala/Predef. -[23:38..23:41) ??? -> scala/Predef.`???`(). -[24:12..24:19) clazzOf <- example/InstrumentTyper#clazzOf. -[24:22..24:29) classOf -> scala/Predef.classOf(). -[24:30..24:36) Option -> scala/Option# -[24:37..24:40) Int -> scala/Int# +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:23): annotation -> scala/annotation/ +[2:24..2:28): meta -> scala/annotation/meta/ +[2:29..2:34): param -> scala/annotation/meta/param. +[3:7..3:12): scala -> scala/ +[3:13..3:21): language -> scalaShadowing/language. +[3:22..3:34): existentials -> scalaShadowing/language.existentials. +[4:7..4:12): scala -> scala/ +[4:13..4:21): language -> scalaShadowing/language. +[4:22..4:33): higherKinds -> scalaShadowing/language.higherKinds. +[5:7..5:12): types -> types/ +[5:13..5:17): Test -> types/Test. +[7:6..7:21): InstrumentTyper <- example/InstrumentTyper# +[7:24..7:24): <- example/InstrumentTyper#``(). +[7:24..7:28): self <- local0 +[7:30..7:36): AnyRef -> scala/AnyRef# +[8:6..8:9): all <- example/InstrumentTyper#all(). +[8:12..8:16): List -> scala/package.List. +[8:16..8:16): -> scala/collection/IterableFactory#apply(). +[9:4..9:11): Literal -> types/Test.Literal. +[9:12..9:15): int -> types/Test.Literal.int. +[10:4..10:11): Literal -> types/Test.Literal. +[10:12..10:16): long -> types/Test.Literal.long. +[11:4..11:11): Literal -> types/Test.Literal. +[11:12..11:17): float -> types/Test.Literal.float. +[12:4..12:11): Literal -> types/Test.Literal. +[12:12..12:18): double -> types/Test.Literal.double. +[13:4..13:11): Literal -> types/Test.Literal. +[13:12..13:15): nil -> types/Test.Literal.nil. +[14:4..14:11): Literal -> types/Test.Literal. +[14:12..14:16): char -> types/Test.Literal.char. +[15:4..15:11): Literal -> types/Test.Literal. +[15:12..15:18): string -> types/Test.Literal.string. +[16:4..16:11): Literal -> types/Test.Literal. +[16:12..16:16): bool -> types/Test.Literal.bool. +[17:4..17:11): Literal -> types/Test.Literal. +[17:12..17:16): unit -> types/Test.Literal.unit. +[18:4..18:11): Literal -> types/Test.Literal. +[18:12..18:20): javaEnum -> types/Test.Literal.javaEnum. +[19:4..19:11): Literal -> types/Test.Literal. +[19:12..19:19): clazzOf -> types/Test.Literal.clazzOf. +[20:4..20:8): List -> scala/package.List. +[20:8..20:8): -> scala/collection/IterableFactory#apply(). +[22:7..22:20): AnnotatedType <- example/InstrumentTyper#AnnotatedType# +[22:23..22:26): Int -> scala/Int# +[23:6..23:19): singletonType <- example/InstrumentTyper#singletonType(). +[23:20..23:21): x <- example/InstrumentTyper#singletonType().(x) +[23:23..23:29): Predef -> scala/Predef. +[23:38..23:41): ??? -> scala/Predef.`???`(). +[24:12..24:19): clazzOf <- example/InstrumentTyper#clazzOf. +[24:22..24:29): classOf -> scala/Predef.classOf(). +[24:30..24:36): Option -> scala/Option# +[24:37..24:40): Int -> scala/Int# expect/Issue1749.scala ______________________ @@ -1451,34 +1451,34 @@ example/Issue1854#``(). => primary ctor example/Issue1854#map. => val method map Occurrences: -[1:8..1:15) example <- example/ -[3:7..3:12) scala -> scala/ -[3:13..3:17) math -> scala/math/ -[3:18..3:25) Ordered -> scala/math/Ordered. -[3:26..3:43) orderingToOrdered -> scala/math/Ordered.orderingToOrdered(). -[5:6..5:15) Issue1749 <- example/Issue1749# -[6:2..6:2) <- example/Issue1749#``(). -[6:6..6:8) x1 <- example/Issue1749#x1. -[7:6..7:8) x2 <- example/Issue1749#x2. -[8:2..8:2) -> scala/math/Ordered.orderingToOrdered(). -[8:3..8: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:16) x2 -> example/Issue1749#x2. -[9:18..9:20) x2 -> example/Issue1749#x2. -[12:6..12:15) Issue1854 <- example/Issue1854# -[13:2..13:2) <- example/Issue1854#``(). -[13:6..13:9) map <- example/Issue1854#map. -[13:12..13:22) collection -> scala/collection/ -[13:23..13:30) mutable -> scala/collection/mutable/ -[13:31..13:34) Map -> scala/collection/mutable/Map. -[13:35..13:40) empty -> scala/collection/MapFactory.Delegate#empty(). -[13:41..13:47) String -> scala/Predef.String# -[13:49..13:55) String -> scala/Predef.String# -[14:2..14:5) map -> example/Issue1854#map. -[14:5..14:5) -> scala/collection/mutable/MapOps#update(). +[1:8..1:15): example <- example/ +[3:7..3:12): scala -> scala/ +[3:13..3:17): math -> scala/math/ +[3:18..3:25): Ordered -> scala/math/Ordered. +[3:26..3:43): orderingToOrdered -> scala/math/Ordered.orderingToOrdered(). +[5:6..5:15): Issue1749 <- example/Issue1749# +[6:2..6:2): <- example/Issue1749#``(). +[6:6..6:8): x1 <- example/Issue1749#x1. +[7:6..7:8): x2 <- example/Issue1749#x2. +[8:2..8:2): -> scala/math/Ordered.orderingToOrdered(). +[8:3..8: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:16): x2 -> example/Issue1749#x2. +[9:18..9:20): x2 -> example/Issue1749#x2. +[12:6..12:15): Issue1854 <- example/Issue1854# +[13:2..13:2): <- example/Issue1854#``(). +[13:6..13:9): map <- example/Issue1854#map. +[13:12..13:22): collection -> scala/collection/ +[13:23..13:30): mutable -> scala/collection/mutable/ +[13:31..13:34): Map -> scala/collection/mutable/Map. +[13:35..13:40): empty -> scala/collection/MapFactory.Delegate#empty(). +[13:41..13:47): String -> scala/Predef.String# +[13:49..13:55): String -> scala/Predef.String# +[14:2..14:5): map -> example/Issue1854#map. +[14:5..14:5): -> scala/collection/mutable/MapOps#update(). expect/Local.scala __________________ @@ -1500,17 +1500,17 @@ local1 => typeparam A local2 => param a Occurrences: -[0:8..0:15) example <- example/ -[2:6..2:11) Local <- example/Local# -[3:2..3:2) <- example/Local#``(). -[3:6..3:7) a <- example/Local#a(). -[4:8..4:10) id <- local0 -[4:11..4:12) A <- local1 -[4:14..4:15) a <- local2 -[4:17..4:18) A -> local1 -[4:21..4:22) A -> local1 -[4:25..4:26) a -> local2 -[5:4..5:6) id -> local0 +[0:8..0:15): example <- example/ +[2:6..2:11): Local <- example/Local# +[3:2..3:2): <- example/Local#``(). +[3:6..3:7): a <- example/Local#a(). +[4:8..4:10): id <- local0 +[4:11..4:12): A <- local1 +[4:14..4:15): a <- local2 +[4:17..4:18): A -> local1 +[4:21..4:22): A -> local1 +[4:25..4:26): a -> local2 +[5:4..5:6): id -> local0 expect/Locals.scala ___________________ @@ -1529,13 +1529,13 @@ locals/Test. => final object Test locals/Test.xs. => val method xs Occurrences: -[0:8..0:14) locals <- locals/ -[2:7..2:11) Test <- locals/Test. -[3:6..3:8) xs <- locals/Test.xs. -[4:8..4:9) x <- local0 -[5:4..5:8) List -> scala/package.List. -[5:8..5:8) -> scala/collection/IterableFactory#apply(). -[5:9..5:10) x -> local0 +[0:8..0:14): locals <- locals/ +[2:7..2:11): Test <- locals/Test. +[3:6..3:8): xs <- locals/Test.xs. +[4:8..4:9): x <- local0 +[5:4..5:8): List -> scala/package.List. +[5:8..5:8): -> scala/collection/IterableFactory#apply(). +[5:9..5:10): x -> local0 expect/MetacJava.scala ______________________ @@ -1561,78 +1561,78 @@ example/MetacJava#overload2. => val method overload2 example/MetacJava#staticInner. => val method staticInner Occurrences: -[0:8..0:15) example <- example/ -[2:7..2:10) com -> com/ -[2:11..2:17) javacp -> com/javacp/ -[4:6..4:15) MetacJava <- example/MetacJava# -[5:2..5:2) <- example/MetacJava#``(). -[5:2..5:8) javacp -> com/javacp/ -[5:9..5:18) MetacJava -> com/javacp/MetacJava# -[5:19..5:30) StaticInner -> com/javacp/MetacJava#StaticInner# -[5:31..5:39) isStatic -> com/javacp/MetacJava#StaticInner#isStatic(). -[6:6..6:12) javacp -> com/javacp/ -[6:13..6:22) MetacJava -> com/javacp/MetacJava# -[6:23..6:34) StaticInner -> com/javacp/MetacJava#StaticInner# -[6:34..6:34) -> com/javacp/MetacJava#StaticInner#``(). -[6:37..6:48) isNotStatic -> com/javacp/MetacJava#StaticInner#isNotStatic(). -[7:6..7:11) inner <- example/MetacJava#inner. -[7:18..7:24) javacp -> com/javacp/ -[7:25..7:34) MetacJava -> com/javacp/MetacJava# -[7:34..7:34) -> com/javacp/MetacJava#``(). -[8:6..8:15) overload1 <- example/MetacJava#overload1. -[8:22..8:27) inner -> example/MetacJava#inner. -[8:28..8:37) Overload1 -> com/javacp/MetacJava#Overload1# -[8:37..8:37) -> com/javacp/MetacJava#Overload1#``(). -[9:6..9:15) overload2 <- example/MetacJava#overload2. -[9:22..9:27) inner -> example/MetacJava#inner. -[9:28..9:37) Overload2 -> com/javacp/MetacJava#Overload2# -[9:37..9:37) -> com/javacp/MetacJava#Overload2#``(). -[10:2..10:7) inner -> example/MetacJava#inner. -[10:8..10:16) overload -> com/javacp/MetacJava#overload(). -[10:21..10:30) overload1 -> example/MetacJava#overload1. -[10:31..10:32) A -> com/javacp/MetacJava#Overload1#A# -[10:32..10:32) -> com/javacp/MetacJava#Overload1#A#``(). -[11:2..11:7) inner -> example/MetacJava#inner. -[11:8..11:16) overload -> com/javacp/MetacJava#overload(+1). -[11:21..11:30) overload2 -> example/MetacJava#overload2. -[11:31..11:32) A -> com/javacp/MetacJava#Overload2#A# -[11:32..11:32) -> com/javacp/MetacJava#Overload2#A#``(). -[12:6..12:17) staticInner <- example/MetacJava#staticInner. -[12:24..12:30) javacp -> com/javacp/ -[12:31..12:40) MetacJava -> com/javacp/MetacJava# -[12:41..12:52) StaticInner -> com/javacp/MetacJava#StaticInner# -[12:52..12:52) -> com/javacp/MetacJava#StaticInner#``(). -[13:6..13:15) nonStatic <- example/MetacJava#nonStatic. -[13:22..13:33) staticInner -> example/MetacJava#staticInner. -[13:34..13:43) NonStatic -> com/javacp/MetacJava#StaticInner#NonStatic# -[13:43..13:43) -> com/javacp/MetacJava#StaticInner#NonStatic#``(). -[14:2..14:11) nonStatic -> example/MetacJava#nonStatic. -[14:12..14:18) method -> com/javacp/MetacJava#StaticInner#NonStatic#method(). -[14:19..14:28) nonStatic -> example/MetacJava#nonStatic. -[15:2..15:8) javacp -> com/javacp/ -[15:9..15:18) MetacJava -> com/javacp/MetacJava# -[15:19..15:27) overload -> com/javacp/MetacJava#overload(+2). -[15:32..15:38) javacp -> com/javacp/ -[15:39..15:48) MetacJava -> com/javacp/MetacJava# -[15:49..15:58) Overload3 -> com/javacp/MetacJava#Overload3# -[15:59..15:60) A -> com/javacp/MetacJava#Overload3#A# -[15:60..15:60) -> com/javacp/MetacJava#Overload3#A#``(). -[16:6..16:15) interface <- example/MetacJava#interface. -[16:17..16:23) javacp -> com/javacp/ -[16:24..16:33) Interface -> com/javacp/Interface# -[17:6..17:10) coin <- example/MetacJava#coin. -[17:12..17:18) javacp -> com/javacp/ -[17:19..17:23) Coin -> com/javacp/Coin# -[17:26..17:32) javacp -> com/javacp/ -[17:33..17:37) Coin -> com/javacp/Coin# -[17:38..17:43) PENNY -> com/javacp/Coin#PENNY. -[18:6..18:11) entry <- example/MetacJava#entry. -[18:13..18:17) java -> java/ -[18:18..18:22) util -> java/util/ -[18:23..18:26) Map -> java/util/Map# -[18:27..18:32) Entry -> java/util/Map#Entry# -[18:33..18:36) Int -> scala/Int# -[18:38..18:41) Int -> scala/Int# +[0:8..0:15): example <- example/ +[2:7..2:10): com -> com/ +[2:11..2:17): javacp -> com/javacp/ +[4:6..4:15): MetacJava <- example/MetacJava# +[5:2..5:2): <- example/MetacJava#``(). +[5:2..5:8): javacp -> com/javacp/ +[5:9..5:18): MetacJava -> com/javacp/MetacJava# +[5:19..5:30): StaticInner -> com/javacp/MetacJava#StaticInner# +[5:31..5:39): isStatic -> com/javacp/MetacJava#StaticInner#isStatic(). +[6:6..6:12): javacp -> com/javacp/ +[6:13..6:22): MetacJava -> com/javacp/MetacJava# +[6:23..6:34): StaticInner -> com/javacp/MetacJava#StaticInner# +[6:34..6:34): -> com/javacp/MetacJava#StaticInner#``(). +[6:37..6:48): isNotStatic -> com/javacp/MetacJava#StaticInner#isNotStatic(). +[7:6..7:11): inner <- example/MetacJava#inner. +[7:18..7:24): javacp -> com/javacp/ +[7:25..7:34): MetacJava -> com/javacp/MetacJava# +[7:34..7:34): -> com/javacp/MetacJava#``(). +[8:6..8:15): overload1 <- example/MetacJava#overload1. +[8:22..8:27): inner -> example/MetacJava#inner. +[8:28..8:37): Overload1 -> com/javacp/MetacJava#Overload1# +[8:37..8:37): -> com/javacp/MetacJava#Overload1#``(). +[9:6..9:15): overload2 <- example/MetacJava#overload2. +[9:22..9:27): inner -> example/MetacJava#inner. +[9:28..9:37): Overload2 -> com/javacp/MetacJava#Overload2# +[9:37..9:37): -> com/javacp/MetacJava#Overload2#``(). +[10:2..10:7): inner -> example/MetacJava#inner. +[10:8..10:16): overload -> com/javacp/MetacJava#overload(). +[10:21..10:30): overload1 -> example/MetacJava#overload1. +[10:31..10:32): A -> com/javacp/MetacJava#Overload1#A# +[10:32..10:32): -> com/javacp/MetacJava#Overload1#A#``(). +[11:2..11:7): inner -> example/MetacJava#inner. +[11:8..11:16): overload -> com/javacp/MetacJava#overload(+1). +[11:21..11:30): overload2 -> example/MetacJava#overload2. +[11:31..11:32): A -> com/javacp/MetacJava#Overload2#A# +[11:32..11:32): -> com/javacp/MetacJava#Overload2#A#``(). +[12:6..12:17): staticInner <- example/MetacJava#staticInner. +[12:24..12:30): javacp -> com/javacp/ +[12:31..12:40): MetacJava -> com/javacp/MetacJava# +[12:41..12:52): StaticInner -> com/javacp/MetacJava#StaticInner# +[12:52..12:52): -> com/javacp/MetacJava#StaticInner#``(). +[13:6..13:15): nonStatic <- example/MetacJava#nonStatic. +[13:22..13:33): staticInner -> example/MetacJava#staticInner. +[13:34..13:43): NonStatic -> com/javacp/MetacJava#StaticInner#NonStatic# +[13:43..13:43): -> com/javacp/MetacJava#StaticInner#NonStatic#``(). +[14:2..14:11): nonStatic -> example/MetacJava#nonStatic. +[14:12..14:18): method -> com/javacp/MetacJava#StaticInner#NonStatic#method(). +[14:19..14:28): nonStatic -> example/MetacJava#nonStatic. +[15:2..15:8): javacp -> com/javacp/ +[15:9..15:18): MetacJava -> com/javacp/MetacJava# +[15:19..15:27): overload -> com/javacp/MetacJava#overload(+2). +[15:32..15:38): javacp -> com/javacp/ +[15:39..15:48): MetacJava -> com/javacp/MetacJava# +[15:49..15:58): Overload3 -> com/javacp/MetacJava#Overload3# +[15:59..15:60): A -> com/javacp/MetacJava#Overload3#A# +[15:60..15:60): -> com/javacp/MetacJava#Overload3#A#``(). +[16:6..16:15): interface <- example/MetacJava#interface. +[16:17..16:23): javacp -> com/javacp/ +[16:24..16:33): Interface -> com/javacp/Interface# +[17:6..17:10): coin <- example/MetacJava#coin. +[17:12..17:18): javacp -> com/javacp/ +[17:19..17:23): Coin -> com/javacp/Coin# +[17:26..17:32): javacp -> com/javacp/ +[17:33..17:37): Coin -> com/javacp/Coin# +[17:38..17:43): PENNY -> com/javacp/Coin#PENNY. +[18:6..18:11): entry <- example/MetacJava#entry. +[18:13..18:17): java -> java/ +[18:18..18:22): util -> java/util/ +[18:23..18:26): Map -> java/util/Map# +[18:27..18:32): Entry -> java/util/Map#Entry# +[18:33..18:36): Int -> scala/Int# +[18:38..18:41): Int -> scala/Int# expect/MethodUsages.scala _________________________ @@ -1651,80 +1651,80 @@ example/MethodUsages#``(). => primary ctor example/MethodUsages#m. => val method m Occurrences: -[0:8..0:15) example <- example/ -[2:6..2:18) MethodUsages <- example/MethodUsages# -[3:2..3:2) <- example/MethodUsages#``(). -[3:6..3:7) m <- example/MethodUsages#m. -[3:14..3:21) Methods -> example/Methods# -[3:22..3:25) Int -> scala/Int# -[3:26..3:26) -> example/Methods#``(). -[4:2..4:3) m -> example/MethodUsages#m. -[4:4..4:6) m1 -> example/Methods#m1(). -[5:2..5:3) m -> example/MethodUsages#m. -[5:4..5:6) m2 -> example/Methods#m2(). -[6:2..6:3) m -> example/MethodUsages#m. -[6:4..6:6) m3 -> example/Methods#m3(). -[7:2..7:3) m -> example/MethodUsages#m. -[7:4..7:6) m4 -> example/Methods#m4(). -[8:2..8:3) m -> example/MethodUsages#m. -[8:4..8:6) m5 -> example/Methods#m5(). -[9:2..9:3) m -> example/MethodUsages#m. -[9:4..9:6) m5 -> example/Methods#m5(+1). -[10:2..10:3) m -> example/MethodUsages#m. -[10:4..10:6) m6 -> example/Methods#m6(). -[11:2..11:3) m -> example/MethodUsages#m. -[11:4..11:6) m6 -> example/Methods#m6(+1). -[11:11..11:12) m -> example/MethodUsages#m. -[11:13..11:17) List -> example/Methods#List# -[11:18..11:21) Int -> scala/Int# -[11:22..11:22) -> example/Methods#List#``(). -[12:2..12:3) m -> example/MethodUsages#m. -[12:4..12:6) m6 -> example/Methods#m6(+2). -[12:7..12:10) Nil -> scala/package.Nil. -[13:2..13:3) m -> example/MethodUsages#m. -[13:4..13:6) m7 -> example/Methods#m7(). -[13:7..13:8) m -> example/MethodUsages#m. -[13:14..13:15) m -> example/MethodUsages#m. -[13:16..13:20) List -> example/Methods#List# -[13:21..13:24) Int -> scala/Int# -[13:25..13:25) -> example/Methods#List#``(). -[13:26..13:26) -> scala/math/Ordering.Int. -[14:2..14:3) m -> example/MethodUsages#m. -[14:3..14:11) .`m8().` -> example/Methods#`m8().`(). -[16:2..16:3) m -> example/MethodUsages#m. -[16:4..16:7) m10 -> example/Methods#m10(). -[17:2..17:3) m -> example/MethodUsages#m. -[17:4..17:7) m11 -> example/Methods#m11(). -[17:8..17:14) Predef -> scala/Predef. -[18:2..18:3) m -> example/MethodUsages#m. -[18:4..18:7) m11 -> example/Methods#m11(+1). -[18:8..18:15) Example -> example/Example. -[19:2..19:3) m -> example/MethodUsages#m. -[19:4..19:8) m12a -> example/Methods#m12a(). -[20:2..20:3) m -> example/MethodUsages#m. -[20:4..20:8) m12b -> example/Methods#m12b(). -[21:2..21:3) m -> example/MethodUsages#m. -[21:4..21:7) m13 -> example/Methods#m13(). -[22:2..22:3) m -> example/MethodUsages#m. -[22:4..22:7) m15 -> example/Methods#m15(). -[23:2..23:3) m -> example/MethodUsages#m. -[23:4..23:7) m16 -> example/Methods#m16(). -[24:2..24:3) m -> example/MethodUsages#m. -[24:4..24:7) m16 -> example/Methods#m16(). -[25:2..25:3) m -> example/MethodUsages#m. -[25:4..25:7) m17 -> example/Methods#m17. -[25:8..25:9) m -> example/Methods#m17.m(). -[26:2..26:3) m -> example/MethodUsages#m. -[26:4..26:7) m17 -> example/Methods#m17(). -[27:2..27:3) m -> example/MethodUsages#m. -[27:4..27:7) m17 -> example/Methods#m17(+1). -[28:2..28:3) m -> example/MethodUsages#m. -[28:4..28:7) m18 -> example/Methods#m18. -[28:8..28:9) m -> example/Methods#m17.m(). -[29:2..29:3) m -> example/MethodUsages#m. -[29:4..29:7) m18 -> example/Methods#m18(). -[30:2..30:3) m -> example/MethodUsages#m. -[30:4..30:7) m18 -> example/Methods#m18(+1). +[0:8..0:15): example <- example/ +[2:6..2:18): MethodUsages <- example/MethodUsages# +[3:2..3:2): <- example/MethodUsages#``(). +[3:6..3:7): m <- example/MethodUsages#m. +[3:14..3:21): Methods -> example/Methods# +[3:22..3:25): Int -> scala/Int# +[3:26..3:26): -> example/Methods#``(). +[4:2..4:3): m -> example/MethodUsages#m. +[4:4..4:6): m1 -> example/Methods#m1(). +[5:2..5:3): m -> example/MethodUsages#m. +[5:4..5:6): m2 -> example/Methods#m2(). +[6:2..6:3): m -> example/MethodUsages#m. +[6:4..6:6): m3 -> example/Methods#m3(). +[7:2..7:3): m -> example/MethodUsages#m. +[7:4..7:6): m4 -> example/Methods#m4(). +[8:2..8:3): m -> example/MethodUsages#m. +[8:4..8:6): m5 -> example/Methods#m5(). +[9:2..9:3): m -> example/MethodUsages#m. +[9:4..9:6): m5 -> example/Methods#m5(+1). +[10:2..10:3): m -> example/MethodUsages#m. +[10:4..10:6): m6 -> example/Methods#m6(). +[11:2..11:3): m -> example/MethodUsages#m. +[11:4..11:6): m6 -> example/Methods#m6(+1). +[11:11..11:12): m -> example/MethodUsages#m. +[11:13..11:17): List -> example/Methods#List# +[11:18..11:21): Int -> scala/Int# +[11:22..11:22): -> example/Methods#List#``(). +[12:2..12:3): m -> example/MethodUsages#m. +[12:4..12:6): m6 -> example/Methods#m6(+2). +[12:7..12:10): Nil -> scala/package.Nil. +[13:2..13:3): m -> example/MethodUsages#m. +[13:4..13:6): m7 -> example/Methods#m7(). +[13:7..13:8): m -> example/MethodUsages#m. +[13:14..13:15): m -> example/MethodUsages#m. +[13:16..13:20): List -> example/Methods#List# +[13:21..13:24): Int -> scala/Int# +[13:25..13:25): -> example/Methods#List#``(). +[13:26..13:26): -> scala/math/Ordering.Int. +[14:2..14:3): m -> example/MethodUsages#m. +[14:3..14:11): .`m8().` -> example/Methods#`m8().`(). +[16:2..16:3): m -> example/MethodUsages#m. +[16:4..16:7): m10 -> example/Methods#m10(). +[17:2..17:3): m -> example/MethodUsages#m. +[17:4..17:7): m11 -> example/Methods#m11(). +[17:8..17:14): Predef -> scala/Predef. +[18:2..18:3): m -> example/MethodUsages#m. +[18:4..18:7): m11 -> example/Methods#m11(+1). +[18:8..18:15): Example -> example/Example. +[19:2..19:3): m -> example/MethodUsages#m. +[19:4..19:8): m12a -> example/Methods#m12a(). +[20:2..20:3): m -> example/MethodUsages#m. +[20:4..20:8): m12b -> example/Methods#m12b(). +[21:2..21:3): m -> example/MethodUsages#m. +[21:4..21:7): m13 -> example/Methods#m13(). +[22:2..22:3): m -> example/MethodUsages#m. +[22:4..22:7): m15 -> example/Methods#m15(). +[23:2..23:3): m -> example/MethodUsages#m. +[23:4..23:7): m16 -> example/Methods#m16(). +[24:2..24:3): m -> example/MethodUsages#m. +[24:4..24:7): m16 -> example/Methods#m16(). +[25:2..25:3): m -> example/MethodUsages#m. +[25:4..25:7): m17 -> example/Methods#m17. +[25:8..25:9): m -> example/Methods#m17.m(). +[26:2..26:3): m -> example/MethodUsages#m. +[26:4..26:7): m17 -> example/Methods#m17(). +[27:2..27:3): m -> example/MethodUsages#m. +[27:4..27:7): m17 -> example/Methods#m17(+1). +[28:2..28:3): m -> example/MethodUsages#m. +[28:4..28:7): m18 -> example/Methods#m18. +[28:8..28:9): m -> example/Methods#m17.m(). +[29:2..29:3): m -> example/MethodUsages#m. +[29:4..29:7): m18 -> example/Methods#m18(). +[30:2..30:3): m -> example/MethodUsages#m. +[30:4..30:7): m18 -> example/Methods#m18(+1). expect/Methods.scala ____________________ @@ -1809,145 +1809,145 @@ example/Methods#m19().(z) => param z local0 => abstract val method x Occurrences: -[0:8..0:15) example <- example/ -[2:7..2:12) scala -> scala/ -[2:13..2:17) math -> scala/math/ -[2:18..2:26) Ordering -> scala/math/Ordering. -[2:18..2:26) Ordering -> scala/math/Ordering# -[3:7..3:12) scala -> scala/ -[3:13..3:21) language -> scalaShadowing/language. -[3:22..3:34) existentials -> scalaShadowing/language.existentials. -[5:6..5:13) Methods <- example/Methods# -[5:13..5:16) <- example/Methods#``(). -[5:14..5:15) T <- example/Methods#[T] -[6:8..6:12) List <- example/Methods#List# -[6:12..6:15) <- example/Methods#List#``(). -[6:13..6:14) T <- example/Methods#List#[T] -[7:7..7:12) AList <- example/Methods#AList# -[7:13..7:14) T <- example/Methods#AList#[T] -[7:18..7:22) List -> example/Methods#List# -[7:23..7:24) T -> example/Methods#AList#[T] -[8:6..8:8) m1 <- example/Methods#m1(). -[8:11..8:14) ??? -> scala/Predef.`???`(). -[9:6..9:8) m2 <- example/Methods#m2(). -[9:13..9:16) ??? -> scala/Predef.`???`(). -[10:6..10:8) m3 <- example/Methods#m3(). -[10:9..10:10) x <- example/Methods#m3().(x) -[10:12..10:15) Int -> scala/Int# -[10:19..10:22) ??? -> scala/Predef.`???`(). -[11:6..11:8) m4 <- example/Methods#m4(). -[11:9..11:10) x <- example/Methods#m4().(x) -[11:12..11:15) Int -> scala/Int# -[11:17..11:18) y <- example/Methods#m4().(y) -[11:20..11:23) Int -> scala/Int# -[11:27..11:30) ??? -> scala/Predef.`???`(). -[12:6..12:8) m5 <- example/Methods#m5(). -[12:9..12:10) x <- example/Methods#m5().(x) -[12:12..12:18) String -> scala/Predef.String# -[12:22..12:25) ??? -> scala/Predef.`???`(). -[13:6..13:8) m5 <- example/Methods#m5(+1). -[13:9..13:10) x <- example/Methods#m5(+1).(x) -[13:12..13:15) Int -> scala/Int# -[13:19..13:22) ??? -> scala/Predef.`???`(). -[14:6..14:8) m6 <- example/Methods#m6(). -[14:9..14:10) x <- example/Methods#m6().(x) -[14:12..14:15) Int -> scala/Int# -[14:19..14:22) ??? -> scala/Predef.`???`(). -[15:6..15:8) m6 <- example/Methods#m6(+1). -[15:9..15:10) x <- example/Methods#m6(+1).(x) -[15:12..15:16) List -> example/Methods#List# -[15:17..15:18) T -> example/Methods#[T] -[15:23..15:26) ??? -> scala/Predef.`???`(). -[16:6..16:8) m6 <- example/Methods#m6(+2). -[16:9..16:10) x <- example/Methods#m6(+2).(x) -[16:12..16:17) scala -> scala/ -[16:18..16:22) List -> scala/package.List# -[16:23..16:24) T -> example/Methods#[T] -[16:29..16:32) ??? -> scala/Predef.`???`(). -[17:6..17:8) m7 <- example/Methods#m7(). -[17:9..17:10) U <- example/Methods#m7().[U] -[17: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] -[17:37..17:38) l <- example/Methods#m7().(l) -[17:40..17:44) List -> example/Methods#List# -[17:45..17:46) U -> example/Methods#m7().[U] -[17:51..17:54) ??? -> scala/Predef.`???`(). -[18:7..18:17) m8().`() = <- example/Methods#`m8().`(). -[18:18..18:21) ??? -> scala/Predef.`???`(). -[19:2..19:2) <- example/Methods#`m9().`#``(). -[19:9..20:3) <- example/Methods#`m9().`# -[20:6..20:8) m9 <- example/Methods#m9(). -[20:9..20:10) x <- example/Methods#m9().(x) -[20:12..20:19) `m9().` -> example/Methods#`m9().`# -[20:23..20:26) ??? -> scala/Predef.`???`(). -[21:6..21:9) m10 <- example/Methods#m10(). -[21:10..21:11) x <- example/Methods#m10().(x) -[21:13..21:18) AList -> example/Methods#AList# -[21:19..21:20) T -> example/Methods#[T] -[21:25..21:28) ??? -> scala/Predef.`???`(). -[22:6..22:9) m11 <- example/Methods#m11(). -[22:10..22:11) x <- example/Methods#m11().(x) -[22:13..22:19) Predef -> scala/Predef. -[22:28..22:31) ??? -> scala/Predef.`???`(). -[23:6..23:9) m11 <- example/Methods#m11(+1). -[23:10..23:11) x <- example/Methods#m11(+1).(x) -[23:13..23:20) Example -> example/Example. -[23:29..23:32) ??? -> scala/Predef.`???`(). -[24:6..24:10) m12a <- example/Methods#m12a(). -[24:11..24:12) x <- example/Methods#m12a().(x) -[24:20..24:23) ??? -> scala/Predef.`???`(). -[25:6..25:10) m12b <- example/Methods#m12b(). -[25:11..25:12) x <- example/Methods#m12b().(x) -[25:20..25:21) x <- local0 -[25:23..25:26) Int -> scala/Int# -[25:32..25:35) ??? -> scala/Predef.`???`(). -[26:6..26:9) m13 <- example/Methods#m13(). -[26:10..26:11) x <- example/Methods#m13().(x) -[26:13..26:16) Int -> scala/Int# -[26: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.`???`(). +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:17): math -> scala/math/ +[2:18..2:26): Ordering -> scala/math/Ordering. +[2:18..2:26): Ordering -> scala/math/Ordering# +[3:7..3:12): scala -> scala/ +[3:13..3:21): language -> scalaShadowing/language. +[3:22..3:34): existentials -> scalaShadowing/language.existentials. +[5:6..5:13): Methods <- example/Methods# +[5:13..5:16): <- example/Methods#``(). +[5:14..5:15): T <- example/Methods#[T] +[6:8..6:12): List <- example/Methods#List# +[6:12..6:15): <- example/Methods#List#``(). +[6:13..6:14): T <- example/Methods#List#[T] +[7:7..7:12): AList <- example/Methods#AList# +[7:13..7:14): T <- example/Methods#AList#[T] +[7:18..7:22): List -> example/Methods#List# +[7:23..7:24): T -> example/Methods#AList#[T] +[8:6..8:8): m1 <- example/Methods#m1(). +[8:11..8:14): ??? -> scala/Predef.`???`(). +[9:6..9:8): m2 <- example/Methods#m2(). +[9:13..9:16): ??? -> scala/Predef.`???`(). +[10:6..10:8): m3 <- example/Methods#m3(). +[10:9..10:10): x <- example/Methods#m3().(x) +[10:12..10:15): Int -> scala/Int# +[10:19..10:22): ??? -> scala/Predef.`???`(). +[11:6..11:8): m4 <- example/Methods#m4(). +[11:9..11:10): x <- example/Methods#m4().(x) +[11:12..11:15): Int -> scala/Int# +[11:17..11:18): y <- example/Methods#m4().(y) +[11:20..11:23): Int -> scala/Int# +[11:27..11:30): ??? -> scala/Predef.`???`(). +[12:6..12:8): m5 <- example/Methods#m5(). +[12:9..12:10): x <- example/Methods#m5().(x) +[12:12..12:18): String -> scala/Predef.String# +[12:22..12:25): ??? -> scala/Predef.`???`(). +[13:6..13:8): m5 <- example/Methods#m5(+1). +[13:9..13:10): x <- example/Methods#m5(+1).(x) +[13:12..13:15): Int -> scala/Int# +[13:19..13:22): ??? -> scala/Predef.`???`(). +[14:6..14:8): m6 <- example/Methods#m6(). +[14:9..14:10): x <- example/Methods#m6().(x) +[14:12..14:15): Int -> scala/Int# +[14:19..14:22): ??? -> scala/Predef.`???`(). +[15:6..15:8): m6 <- example/Methods#m6(+1). +[15:9..15:10): x <- example/Methods#m6(+1).(x) +[15:12..15:16): List -> example/Methods#List# +[15:17..15:18): T -> example/Methods#[T] +[15:23..15:26): ??? -> scala/Predef.`???`(). +[16:6..16:8): m6 <- example/Methods#m6(+2). +[16:9..16:10): x <- example/Methods#m6(+2).(x) +[16:12..16:17): scala -> scala/ +[16:18..16:22): List -> scala/package.List# +[16:23..16:24): T -> example/Methods#[T] +[16:29..16:32): ??? -> scala/Predef.`???`(). +[17:6..17:8): m7 <- example/Methods#m7(). +[17:9..17:10): U <- example/Methods#m7().[U] +[17: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] +[17:37..17:38): l <- example/Methods#m7().(l) +[17:40..17:44): List -> example/Methods#List# +[17:45..17:46): U -> example/Methods#m7().[U] +[17:51..17:54): ??? -> scala/Predef.`???`(). +[18:7..18:17): m8().`() = <- example/Methods#`m8().`(). +[18:18..18:21): ??? -> scala/Predef.`???`(). +[19:2..19:2): <- example/Methods#`m9().`#``(). +[19:9..20:3): <- example/Methods#`m9().`# +[20:6..20:8): m9 <- example/Methods#m9(). +[20:9..20:10): x <- example/Methods#m9().(x) +[20:12..20:19): `m9().` -> example/Methods#`m9().`# +[20:23..20:26): ??? -> scala/Predef.`???`(). +[21:6..21:9): m10 <- example/Methods#m10(). +[21:10..21:11): x <- example/Methods#m10().(x) +[21:13..21:18): AList -> example/Methods#AList# +[21:19..21:20): T -> example/Methods#[T] +[21:25..21:28): ??? -> scala/Predef.`???`(). +[22:6..22:9): m11 <- example/Methods#m11(). +[22:10..22:11): x <- example/Methods#m11().(x) +[22:13..22:19): Predef -> scala/Predef. +[22:28..22:31): ??? -> scala/Predef.`???`(). +[23:6..23:9): m11 <- example/Methods#m11(+1). +[23:10..23:11): x <- example/Methods#m11(+1).(x) +[23:13..23:20): Example -> example/Example. +[23:29..23:32): ??? -> scala/Predef.`???`(). +[24:6..24:10): m12a <- example/Methods#m12a(). +[24:11..24:12): x <- example/Methods#m12a().(x) +[24:20..24:23): ??? -> scala/Predef.`???`(). +[25:6..25:10): m12b <- example/Methods#m12b(). +[25:11..25:12): x <- example/Methods#m12b().(x) +[25:20..25:21): x <- local0 +[25:23..25:26): Int -> scala/Int# +[25:32..25:35): ??? -> scala/Predef.`???`(). +[26:6..26:9): m13 <- example/Methods#m13(). +[26:10..26:11): x <- example/Methods#m13().(x) +[26:13..26:16): Int -> scala/Int# +[26:31..26:34): ??? -> scala/Predef.`???`(). +[27:6..27:9): m15 <- example/Methods#m15(). +[27:10..27:11): x <- example/Methods#m15().(x) +[27:16..27:19): Int -> scala/Int# +[27:23..27:26): ??? -> scala/Predef.`???`(). +[28:6..28:9): m16 <- example/Methods#m16(). +[28:10..28:11): x <- example/Methods#m16().(x) +[28:13..28:16): Int -> scala/Int# +[28:21..28:24): ??? -> scala/Predef.`???`(). +[29:9..29:12): m17 <- example/Methods#m17. +[29:19..29:20): m <- example/Methods#m17.m(). +[29:25..29:28): ??? -> scala/Predef.`???`(). +[30:6..30:9): m17 <- example/Methods#m17(). +[30:10..30:11): a <- example/Methods#m17().(a) +[30:13..30:16): Int -> scala/Int# +[30:20..30:23): ??? -> scala/Predef.`???`(). +[31:6..31:9): m17 <- example/Methods#m17(+1). +[31:10..31:11): b <- example/Methods#m17(+1).(b) +[31:13..31:19): String -> scala/Predef.String# +[31:23..31:26): ??? -> scala/Predef.`???`(). +[32:6..32:9): m18 <- example/Methods#m18. +[32:12..32:15): m17 -> example/Methods#m17. +[33:6..33:9): m18 <- example/Methods#m18(). +[33:10..33:11): a <- example/Methods#m18().(a) +[33:13..33:16): Int -> scala/Int# +[33:20..33:23): ??? -> scala/Predef.`???`(). +[34:6..34:9): m18 <- example/Methods#m18(+1). +[34:10..34:11): b <- example/Methods#m18(+1).(b) +[34:13..34:19): String -> scala/Predef.String# +[34:23..34:26): ??? -> scala/Predef.`???`(). +[35:6..35:9): m19 <- example/Methods#m19(). +[35:10..35:11): x <- example/Methods#m19().(x) +[35:10..35:11): x <- example/Methods#m19$default$3().(x) +[35:13..35:16): Int -> scala/Int# +[35:18..35:19): y <- example/Methods#m19().(y) +[35:18..35:19): y <- example/Methods#m19$default$3().(y) +[35:21..35:24): Int -> scala/Int# +[35:30..35:31): z <- example/Methods#m19().(z) +[35:33..35:36): Int -> scala/Int# +[35:44..35:47): ??? -> scala/Predef.`???`(). expect/NamedApplyBlock.scala ____________________________ @@ -1982,41 +1982,41 @@ example/NamedApplyBlockMethods.local. => val method local example/NamedApplyBlockMethods.recursive(). => method recursive Occurrences: -[0:8..0:15) example <- example/ -[2:7..2:29) NamedApplyBlockMethods <- example/NamedApplyBlockMethods. -[3:6..3:11) local <- example/NamedApplyBlockMethods.local. -[4:6..4:9) foo <- example/NamedApplyBlockMethods.foo(). -[4:10..4:11) a <- example/NamedApplyBlockMethods.foo().(a) -[4:13..4:16) Int -> scala/Int# -[4:22..4:23) b <- example/NamedApplyBlockMethods.foo().(b) -[4:25..4:28) Int -> scala/Int# -[4:34..4:35) c <- example/NamedApplyBlockMethods.foo().(c) -[4:37..4:40) Int -> scala/Int# -[4:47..4:50) Int -> scala/Int# -[4:53..4:54) a -> example/NamedApplyBlockMethods.foo().(a) -[4:55..4:56) + -> scala/Int#`+`(+4). -[4:57..4:58) b -> example/NamedApplyBlockMethods.foo().(b) -[4:59..4:60) + -> scala/Int#`+`(+4). -[4:61..4:62) c -> example/NamedApplyBlockMethods.foo().(c) -[5:6..5:14) baseCase <- example/NamedApplyBlockMethods.baseCase(). -[5:17..5:20) foo -> example/NamedApplyBlockMethods.foo(). -[5:21..5:26) local -> example/NamedApplyBlockMethods.local. -[6:6..6:15) recursive <- example/NamedApplyBlockMethods.recursive(). -[6:18..6:21) foo -> example/NamedApplyBlockMethods.foo(). -[6:22..6:27) local -> example/NamedApplyBlockMethods.local. -[9:7..9:43) NamedApplyBlockCaseClassConstruction <- example/NamedApplyBlockCaseClassConstruction. -[10:13..10:16) Msg <- example/NamedApplyBlockCaseClassConstruction.Msg# -[10:16..10:70) <- example/NamedApplyBlockCaseClassConstruction.Msg#``(). -[10:17..10:21) body <- example/NamedApplyBlockCaseClassConstruction.Msg#body. -[10:23..10:29) String -> scala/Predef.String# -[10:31..10:35) head <- example/NamedApplyBlockCaseClassConstruction.Msg#head. -[10:37..10:43) String -> scala/Predef.String# -[10:57..10:61) tail <- example/NamedApplyBlockCaseClassConstruction.Msg#tail. -[10:63..10:69) String -> scala/Predef.String# -[11:6..11:14) bodyText <- example/NamedApplyBlockCaseClassConstruction.bodyText. -[12:6..12:9) msg <- example/NamedApplyBlockCaseClassConstruction.msg. -[12:12..12:15) Msg -> example/NamedApplyBlockCaseClassConstruction.Msg. -[12:16..12:24) bodyText -> example/NamedApplyBlockCaseClassConstruction.bodyText. +[0:8..0:15): example <- example/ +[2:7..2:29): NamedApplyBlockMethods <- example/NamedApplyBlockMethods. +[3:6..3:11): local <- example/NamedApplyBlockMethods.local. +[4:6..4:9): foo <- example/NamedApplyBlockMethods.foo(). +[4:10..4:11): a <- example/NamedApplyBlockMethods.foo().(a) +[4:13..4:16): Int -> scala/Int# +[4:22..4:23): b <- example/NamedApplyBlockMethods.foo().(b) +[4:25..4:28): Int -> scala/Int# +[4:34..4:35): c <- example/NamedApplyBlockMethods.foo().(c) +[4:37..4:40): Int -> scala/Int# +[4:47..4:50): Int -> scala/Int# +[4:53..4:54): a -> example/NamedApplyBlockMethods.foo().(a) +[4:55..4:56): + -> scala/Int#`+`(+4). +[4:57..4:58): b -> example/NamedApplyBlockMethods.foo().(b) +[4:59..4:60): + -> scala/Int#`+`(+4). +[4:61..4:62): c -> example/NamedApplyBlockMethods.foo().(c) +[5:6..5:14): baseCase <- example/NamedApplyBlockMethods.baseCase(). +[5:17..5:20): foo -> example/NamedApplyBlockMethods.foo(). +[5:21..5:26): local -> example/NamedApplyBlockMethods.local. +[6:6..6:15): recursive <- example/NamedApplyBlockMethods.recursive(). +[6:18..6:21): foo -> example/NamedApplyBlockMethods.foo(). +[6:22..6:27): local -> example/NamedApplyBlockMethods.local. +[9:7..9:43): NamedApplyBlockCaseClassConstruction <- example/NamedApplyBlockCaseClassConstruction. +[10:13..10:16): Msg <- example/NamedApplyBlockCaseClassConstruction.Msg# +[10:16..10:70): <- example/NamedApplyBlockCaseClassConstruction.Msg#``(). +[10:17..10:21): body <- example/NamedApplyBlockCaseClassConstruction.Msg#body. +[10:23..10:29): String -> scala/Predef.String# +[10:31..10:35): head <- example/NamedApplyBlockCaseClassConstruction.Msg#head. +[10:37..10:43): String -> scala/Predef.String# +[10:57..10:61): tail <- example/NamedApplyBlockCaseClassConstruction.Msg#tail. +[10:63..10:69): String -> scala/Predef.String# +[11:6..11:14): bodyText <- example/NamedApplyBlockCaseClassConstruction.bodyText. +[12:6..12:9): msg <- example/NamedApplyBlockCaseClassConstruction.msg. +[12:12..12:15): Msg -> example/NamedApplyBlockCaseClassConstruction.Msg. +[12:16..12:24): bodyText -> example/NamedApplyBlockCaseClassConstruction.bodyText. expect/NamedArguments.scala ___________________________ @@ -2038,16 +2038,16 @@ example/NamedArguments#User#name. => val method name example/NamedArguments#``(). => primary ctor Occurrences: -[0:8..0:15) example <- example/ -[2:6..2:20) NamedArguments <- example/NamedArguments# -[3:2..3:2) <- example/NamedArguments#``(). -[3:13..3:17) User <- example/NamedArguments#User# -[3:17..3:31) <- example/NamedArguments#User#``(). -[3:18..3:22) name <- example/NamedArguments#User#name. -[3:24..3:30) String -> scala/Predef.String# -[4:2..4:6) User -> example/NamedArguments#User. -[5:2..5:6) User -> example/NamedArguments#User. -[5:7..5:12) apply -> example/NamedArguments#User.apply(). +[0:8..0:15): example <- example/ +[2:6..2:20): NamedArguments <- example/NamedArguments# +[3:2..3:2): <- example/NamedArguments#``(). +[3:13..3:17): User <- example/NamedArguments#User# +[3:17..3:31): <- example/NamedArguments#User#``(). +[3:18..3:22): name <- example/NamedArguments#User#name. +[3:24..3:30): String -> scala/Predef.String# +[4:2..4:6): User -> example/NamedArguments#User. +[5:2..5:6): User -> example/NamedArguments#User. +[5:7..5:12): apply -> example/NamedArguments#User.apply(). expect/NewModifiers.scala _________________________ @@ -2066,10 +2066,10 @@ _empty_/NewModifiers.A# => type A _empty_/NewModifiers.foo. => val method foo Occurrences: -[0:7..0:19) NewModifiers <- _empty_/NewModifiers. -[1:13..1:16) foo <- _empty_/NewModifiers.foo. -[2:14..2:15) A <- _empty_/NewModifiers.A# -[2:18..2:21) Int -> scala/Int# +[0:7..0:19): NewModifiers <- _empty_/NewModifiers. +[1:13..1:16): foo <- _empty_/NewModifiers.foo. +[2:14..2:15): A <- _empty_/NewModifiers.A# +[2:18..2:21): Int -> scala/Int# expect/Objects.scala ____________________ @@ -2087,9 +2087,9 @@ objects/X. => final object X objects/X.Y. => final object Y Occurrences: -[0:8..0:15) objects <- objects/ -[2:7..2:8) X <- objects/X. -[3:9..3:10) Y <- objects/X.Y. +[0:8..0:15): objects <- objects/ +[2:7..2:8): X <- objects/X. +[3:9..3:10): Y <- objects/X.Y. expect/Overrides.scala ______________________ @@ -2111,16 +2111,16 @@ example/B#``(). => primary ctor example/B#foo(). => method foo Occurrences: -[0:8..0:15) example <- example/ -[2:6..2:7) A <- example/A# -[2:10..2:10) <- example/A#``(). -[2:14..2:17) foo <- example/A#foo(). -[2:19..2:22) Int -> scala/Int# -[3:6..3:7) B <- example/B# -[3:7..3:9) <- example/B#``(). -[3:18..3:19) A -> example/A# -[3:26..3:29) foo <- example/B#foo(). -[3:31..3:34) Int -> scala/Int# +[0:8..0:15): example <- example/ +[2:6..2:7): A <- example/A# +[2:10..2:10): <- example/A#``(). +[2:14..2:17): foo <- example/A#foo(). +[2:19..2:22): Int -> scala/Int# +[3:6..3:7): B <- example/B# +[3:7..3:9): <- example/B#``(). +[3:18..3:19): A -> example/A# +[3:26..3:29): foo <- example/B#foo(). +[3:31..3:34): Int -> scala/Int# expect/Prefixes.scala _____________________ @@ -2155,55 +2155,55 @@ prefixes/Test.n2(). => method n2 prefixes/Test.n3(). => method n3 Occurrences: -[0:8..0:16) prefixes <- prefixes/ -[2:6..2:7) C <- prefixes/C# -[3:2..3:2) <- prefixes/C#``(). -[3:7..3:8) T <- prefixes/C#T# -[4:6..4:8) m1 <- prefixes/C#m1(). -[4:10..4:11) T -> prefixes/C#T# -[4:14..4:17) ??? -> scala/Predef.`???`(). -[6:9..6:10) N <- prefixes/C#N. -[7:9..7:10) U <- prefixes/C#N.U# -[9:6..9:8) k1 <- prefixes/C#k1(). -[9:10..9:11) N -> prefixes/C#N. -[9:12..9:13) U -> prefixes/C#N.U# -[9:16..9:19) ??? -> scala/Predef.`???`(). -[12:7..12:8) M <- prefixes/M. -[13:7..13:8) T <- prefixes/M.T# -[14:6..14:8) n1 <- prefixes/M.n1(). -[14:10..14:11) T -> prefixes/M.T# -[14:14..14:17) ??? -> scala/Predef.`???`(). -[17:7..17:8) O <- prefixes/O. -[17:17..17:18) C -> prefixes/C# -[17:18..17:18) -> prefixes/C#``(). -[18:6..18:8) o1 <- prefixes/O.o1(). -[18:10..18:11) T -> prefixes/C#T# -[18:14..18:17) ??? -> scala/Predef.`???`(). -[21:7..21:11) Test <- prefixes/Test. -[22:6..22:7) c <- prefixes/Test.c. -[22:9..22:10) C -> prefixes/C# -[22:13..22:16) ??? -> scala/Predef.`???`(). -[23:6..23:8) m2 <- prefixes/Test.m2(). -[23:10..23:11) c -> prefixes/Test.c. -[23:12..23:13) T -> prefixes/C#T# -[23:16..23:19) ??? -> scala/Predef.`???`(). -[24:6..24:8) k2 <- prefixes/Test.k2(). -[24:10..24:11) c -> prefixes/Test.c. -[24:12..24:13) N -> prefixes/C#N. -[24:14..24:15) U -> prefixes/C#N.U# -[24:18..24:21) ??? -> scala/Predef.`???`(). -[25:9..25:10) c -> prefixes/Test.c. -[25:11..25:12) N -> prefixes/C#N. -[26:6..26:8) k3 <- prefixes/Test.k3(). -[26:14..26:17) ??? -> scala/Predef.`???`(). -[28:6..28:8) n2 <- prefixes/Test.n2(). -[28:10..28:11) M -> prefixes/M. -[28:12..28:13) T -> prefixes/M.T# -[28:16..28:19) ??? -> scala/Predef.`???`(). -[30:9..30:10) M -> prefixes/M. -[31:6..31:8) n3 <- prefixes/Test.n3(). -[31:10..31:11) T -> prefixes/M.T# -[31:14..31:17) ??? -> scala/Predef.`???`(). +[0:8..0:16): prefixes <- prefixes/ +[2:6..2:7): C <- prefixes/C# +[3:2..3:2): <- prefixes/C#``(). +[3:7..3:8): T <- prefixes/C#T# +[4:6..4:8): m1 <- prefixes/C#m1(). +[4:10..4:11): T -> prefixes/C#T# +[4:14..4:17): ??? -> scala/Predef.`???`(). +[6:9..6:10): N <- prefixes/C#N. +[7:9..7:10): U <- prefixes/C#N.U# +[9:6..9:8): k1 <- prefixes/C#k1(). +[9:10..9:11): N -> prefixes/C#N. +[9:12..9:13): U -> prefixes/C#N.U# +[9:16..9:19): ??? -> scala/Predef.`???`(). +[12:7..12:8): M <- prefixes/M. +[13:7..13:8): T <- prefixes/M.T# +[14:6..14:8): n1 <- prefixes/M.n1(). +[14:10..14:11): T -> prefixes/M.T# +[14:14..14:17): ??? -> scala/Predef.`???`(). +[17:7..17:8): O <- prefixes/O. +[17:17..17:18): C -> prefixes/C# +[17:18..17:18): -> prefixes/C#``(). +[18:6..18:8): o1 <- prefixes/O.o1(). +[18:10..18:11): T -> prefixes/C#T# +[18:14..18:17): ??? -> scala/Predef.`???`(). +[21:7..21:11): Test <- prefixes/Test. +[22:6..22:7): c <- prefixes/Test.c. +[22:9..22:10): C -> prefixes/C# +[22:13..22:16): ??? -> scala/Predef.`???`(). +[23:6..23:8): m2 <- prefixes/Test.m2(). +[23:10..23:11): c -> prefixes/Test.c. +[23:12..23:13): T -> prefixes/C#T# +[23:16..23:19): ??? -> scala/Predef.`???`(). +[24:6..24:8): k2 <- prefixes/Test.k2(). +[24:10..24:11): c -> prefixes/Test.c. +[24:12..24:13): N -> prefixes/C#N. +[24:14..24:15): U -> prefixes/C#N.U# +[24:18..24:21): ??? -> scala/Predef.`???`(). +[25:9..25:10): c -> prefixes/Test.c. +[25:11..25:12): N -> prefixes/C#N. +[26:6..26:8): k3 <- prefixes/Test.k3(). +[26:14..26:17): ??? -> scala/Predef.`???`(). +[28:6..28:8): n2 <- prefixes/Test.n2(). +[28:10..28:11): M -> prefixes/M. +[28:12..28:13): T -> prefixes/M.T# +[28:16..28:19): ??? -> scala/Predef.`???`(). +[30:9..30:10): M -> prefixes/M. +[31:6..31:8): n3 <- prefixes/Test.n3(). +[31:10..31:11): T -> prefixes/M.T# +[31:14..31:17): ??? -> scala/Predef.`???`(). expect/Selfs.scala __________________ @@ -2232,32 +2232,32 @@ selfs/C6# => class C6 selfs/C6#``(). => primary ctor Occurrences: -[0:8..0:13) selfs <- selfs/ -[2:0..2:0) <- selfs/B#``(). -[2:6..2:7) B <- selfs/B# -[4:6..4:8) C1 <- selfs/C1# -[4:17..4:17) <- selfs/C1#``(). -[4:17..4:18) B -> selfs/B# -[4:18..4:18) -> selfs/B#``(). -[4:21..4:25) self <- local0 -[7:6..7:8) C2 <- selfs/C2# -[7:17..7:17) <- selfs/C2#``(). -[7:17..7:18) B -> selfs/B# -[7:18..7:18) -> selfs/B#``(). -[7:21..7:25) self <- local1 -[7:27..7:28) B -> selfs/B# -[10:6..10:8) C3 <- selfs/C3# -[10:17..10:17) <- selfs/C3#``(). -[10:17..10:18) B -> selfs/B# -[10:18..10:18) -> selfs/B#``(). -[10:21..10:25) self <- local2 -[10:27..10:28) B -> selfs/B# -[10:34..10:36) C1 -> selfs/C1# -[13:6..13:8) C6 <- selfs/C6# -[13:17..13:17) <- selfs/C6#``(). -[13:17..13:18) B -> selfs/B# -[13:18..13:18) -> selfs/B#``(). -[13:27..13:28) B -> selfs/B# +[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 ______________________ @@ -2295,148 +2295,148 @@ example/Synthetic#xs. => val method xs local0 => val local name Occurrences: -[0:8..0:15) example <- example/ -[2:7..2:12) scala -> scala/ -[2:13..2:21) language -> scalaShadowing/language. -[2:22..2:41) implicitConversions -> scalaShadowing/language.implicitConversions. -[4:6..4:15) Synthetic <- example/Synthetic# -[5:2..5:2) <- example/Synthetic#``(). -[5:2..5:6) List -> scala/package.List. -[5:6..5:6) -> scala/collection/IterableFactory#apply(). -[5:10..5:13) map -> scala/collection/immutable/List#map(). -[5:16..5:17) + -> scala/Int#`+`(+4). -[6:2..6:2) -> scala/Predef.intArrayOps(). -[6:2..6:7) Array -> scala/Array. -[6:8..6:13) empty -> scala/Array.empty(). -[6:14..6:17) Int -> scala/Int# -[6:18..6:18) -> scala/reflect/ClassTag.apply(). -[6:18..6:18) -> java/lang/Integer#TYPE. -[6:19..6:29) headOption -> scala/collection/ArrayOps#headOption(). -[7:2..7:2) -> scala/Predef.augmentString(). -[7:9..7:20) stripPrefix -> scala/collection/StringOps#stripPrefix(). -[10:6..10:10) Name <- example/Synthetic#Name. -[10:13..10:13) -> scala/Predef.augmentString(). -[10:25..10:26) r -> scala/collection/StringOps#r(). -[11:2..11:2) -> scala/Tuple2#_1. -[11:2..11:2) -> scala/Tuple2#_2. -[11:6..11:7) x <- example/Synthetic#x. -[11:12..11:14) xs <- example/Synthetic#xs. -[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. -[12:11..12:15) name <- local0 -[12:16..12:16) -> local0 -[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:9) lst <- example/Synthetic#lst. -[15:18..15:18) -> scala/collection/immutable/LazyList.toDeferrer(). -[15:24..15:24) -> scala/collection/immutable/LazyList.toDeferrer(). -[15:24..15:32) LazyList -> scala/package.LazyList. -[15:33..15:38) empty -> scala/collection/immutable/LazyList.empty(). -[15:38..15:38) -> scala/collection/immutable/LazyList.Deferrer#`#::`(). -[17:12..17:12) -> scala/LowPriorityImplicits#intWrapper(). -[17:14..17:16) to -> scala/runtime/RichInt#to(). -[17:19..17:19) -> scala/collection/immutable/Range#foreach(). -[17:26..17:26) -> scala/LowPriorityImplicits#intWrapper(). -[17:28..17:33) until -> scala/runtime/RichInt#until(). -[17:36..17:36) -> scala/collection/immutable/Range#foreach(). -[17:38..17:45) println -> scala/Predef.println(+1). -[17:46..17:47) x -> local1 -[17:48..17:50) -> -> scala/Predef.ArrowAssoc#`->`(). -[17:51..17:52) x -> local1 -[18:12..18:12) -> scala/LowPriorityImplicits#intWrapper(). -[18:14..18:16) to -> scala/runtime/RichInt#to(). -[18:19..18:19) -> scala/collection/StrictOptimizedIterableOps#flatMap(). -[18:26..18:26) -> scala/LowPriorityImplicits#intWrapper(). -[18:28..18:33) until -> scala/runtime/RichInt#until(). -[18:36..18:36) -> scala/collection/immutable/Range#map(). -[18:45..18:46) i -> local2 -[18:48..18:49) j -> local3 -[19:12..19:12) -> scala/LowPriorityImplicits#intWrapper(). -[19:14..19:16) to -> scala/runtime/RichInt#to(). -[19:19..19:19) -> scala/collection/StrictOptimizedIterableOps#flatMap(). -[19:26..19:26) -> scala/LowPriorityImplicits#intWrapper(). -[19:28..19:33) until -> scala/runtime/RichInt#until(). -[19:36..19:36) -> scala/collection/IterableOps#withFilter(). -[19:40..19:41) i -> local4 -[19:42..19:43) % -> scala/Int#`%`(+3). -[19:46..19:48) == -> scala/Int#`==`(+3). -[19:50..19:50) -> scala/collection/WithFilter#map(). -[19:59..19:60) i -> local4 -[19:62..19:63) j -> local5 -[21:9..21:10) s <- example/Synthetic#s. -[22:8..22:13) apply <- example/Synthetic#s.apply(). -[23:5..23:5) -> example/Synthetic#s.apply(). -[24:6..24:11) apply -> example/Synthetic#s.apply(). -[25:15..25:18) Bar <- example/Synthetic#s.Bar# -[25:18..25:20) <- example/Synthetic#s.Bar#``(). -[26:4..26:7) Bar -> example/Synthetic#s.Bar. -[27:9..27:21) asInstanceOf -> scala/Any#asInstanceOf(). -[27:22..27:25) Int -> scala/Int# -[27:29..27:32) Int -> scala/Int# -[27:33..27:33) -> scala/Function1#apply(). -[30:8..30:9) J <- example/Synthetic#J# -[30:9..30:22) <- example/Synthetic#J#``(). -[30:10..30:11) T <- example/Synthetic#J#[T] -[30:11..30:11) <- example/Synthetic#J#evidence$2. -[30:13..30:21) Manifest -> scala/Predef.Manifest# -[30:21..30:21) -> example/Synthetic#J#[T] -[30:29..30:32) arr <- example/Synthetic#J#arr. -[30:35..30:40) Array -> scala/Array. -[30:41..30:46) empty -> scala/Array.empty(). -[30:47..30:48) T -> example/Synthetic#J#[T] -[30:49..30:49) -> example/Synthetic#J#evidence$2. -[32:2..32:2) <- example/Synthetic#F#``(). -[32:8..32:9) F <- example/Synthetic#F# -[33:15..33:23) ordering <- example/Synthetic#ordering. -[33:25..33:33) Ordering -> scala/package.Ordering# -[33:34..33:35) F -> example/Synthetic#F# -[33:39..33:42) ??? -> scala/Predef.`???`(). -[34:6..34:7) f <- example/Synthetic#f. -[34:9..34:16) Ordered -> scala/package.Ordered# -[34:17..34:18) F -> example/Synthetic#F# -[34:22..34:22) -> scala/math/Ordered.orderingToOrdered(). -[34:26..34:27) F -> example/Synthetic#F# -[34:27..34:27) -> example/Synthetic#F#``(). -[34:27..34:27) -> example/Synthetic#ordering. -[36:9..36:14) scala -> scala/ -[36:15..36:25) concurrent -> scala/concurrent/ -[36:26..36:42) ExecutionContext -> scala/concurrent/ExecutionContext. -[36:43..36:52) Implicits -> scala/concurrent/ExecutionContext.Implicits. -[36:53..36:59) global -> scala/concurrent/ExecutionContext.Implicits.global(). -[38:9..38:14) scala -> scala/ -[38:15..38:25) concurrent -> scala/concurrent/ -[38:26..38:32) Future -> scala/concurrent/Future. -[38:33..38:43) successful -> scala/concurrent/Future.successful(). -[38:46..38:46) -> scala/concurrent/Future#foreach(). -[39:9..39:14) scala -> scala/ -[39:15..39:25) concurrent -> scala/concurrent/ -[39:26..39:32) Future -> scala/concurrent/Future. -[39:33..39:43) successful -> scala/concurrent/Future.successful(). -[39:46..39:46) -> scala/concurrent/Future#foreach(). -[40:4..40:11) println -> scala/Predef.println(+1). -[40:12..40:13) a -> local6 -[40:14..40:14) -> scala/concurrent/ExecutionContext.Implicits.global(). -[42:9..42:14) scala -> scala/ -[42:15..42:25) concurrent -> scala/concurrent/ -[42:26..42:32) Future -> scala/concurrent/Future. -[42:33..42:43) successful -> scala/concurrent/Future.successful(). -[42:46..42:46) -> scala/concurrent/Future#flatMap(). -[43:9..43:14) scala -> scala/ -[43:15..43:25) concurrent -> scala/concurrent/ -[43:26..43:32) Future -> scala/concurrent/Future. -[43:33..43:43) successful -> scala/concurrent/Future.successful(). -[43:46..43:46) -> scala/concurrent/Future#withFilter(). -[44:7..44:8) a -> local7 -[44:9..44:10) < -> scala/Int#`<`(+3). -[44:11..44:12) b -> local8 -[44:12..44:12) -> scala/concurrent/Future#map(). -[44:12..44:12) -> scala/concurrent/ExecutionContext.Implicits.global(). -[45:10..45:11) a -> local7 -[45:11..45:11) -> scala/concurrent/ExecutionContext.Implicits.global(). +[0:8..0:15): example <- example/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:41): implicitConversions -> scalaShadowing/language.implicitConversions. +[4:6..4:15): Synthetic <- example/Synthetic# +[5:2..5:2): <- example/Synthetic#``(). +[5:2..5:6): List -> scala/package.List. +[5:6..5:6): -> scala/collection/IterableFactory#apply(). +[5:10..5:13): map -> scala/collection/immutable/List#map(). +[5:16..5:17): + -> scala/Int#`+`(+4). +[6:2..6:2): -> scala/Predef.intArrayOps(). +[6:2..6:7): Array -> scala/Array. +[6:8..6:13): empty -> scala/Array.empty(). +[6:14..6:17): Int -> scala/Int# +[6:18..6:18): -> scala/reflect/ClassTag.apply(). +[6:18..6:18): -> java/lang/Integer#TYPE. +[6:19..6:29): headOption -> scala/collection/ArrayOps#headOption(). +[7:2..7:2): -> scala/Predef.augmentString(). +[7:9..7:20): stripPrefix -> scala/collection/StringOps#stripPrefix(). +[10:6..10:10): Name <- example/Synthetic#Name. +[10:13..10:13): -> scala/Predef.augmentString(). +[10:25..10:26): r -> scala/collection/StringOps#r(). +[11:2..11:2): -> scala/Tuple2#_1. +[11:2..11:2): -> scala/Tuple2#_2. +[11:6..11:7): x <- example/Synthetic#x. +[11:12..11:14): xs <- example/Synthetic#xs. +[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. +[12:11..12:15): name <- local0 +[12:16..12:16): -> local0 +[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:9): lst <- example/Synthetic#lst. +[15:18..15:18): -> scala/collection/immutable/LazyList.toDeferrer(). +[15:24..15:24): -> scala/collection/immutable/LazyList.toDeferrer(). +[15:24..15:32): LazyList -> scala/package.LazyList. +[15:33..15:38): empty -> scala/collection/immutable/LazyList.empty(). +[15:38..15:38): -> scala/collection/immutable/LazyList.Deferrer#`#::`(). +[17:12..17:12): -> scala/LowPriorityImplicits#intWrapper(). +[17:14..17:16): to -> scala/runtime/RichInt#to(). +[17:19..17:19): -> scala/collection/immutable/Range#foreach(). +[17:26..17:26): -> scala/LowPriorityImplicits#intWrapper(). +[17:28..17:33): until -> scala/runtime/RichInt#until(). +[17:36..17:36): -> scala/collection/immutable/Range#foreach(). +[17:38..17:45): println -> scala/Predef.println(+1). +[17:46..17:47): x -> local1 +[17:48..17:50): -> -> scala/Predef.ArrowAssoc#`->`(). +[17:51..17:52): x -> local1 +[18:12..18:12): -> scala/LowPriorityImplicits#intWrapper(). +[18:14..18:16): to -> scala/runtime/RichInt#to(). +[18:19..18:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[18:26..18:26): -> scala/LowPriorityImplicits#intWrapper(). +[18:28..18:33): until -> scala/runtime/RichInt#until(). +[18:36..18:36): -> scala/collection/immutable/Range#map(). +[18:45..18:46): i -> local2 +[18:48..18:49): j -> local3 +[19:12..19:12): -> scala/LowPriorityImplicits#intWrapper(). +[19:14..19:16): to -> scala/runtime/RichInt#to(). +[19:19..19:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[19:26..19:26): -> scala/LowPriorityImplicits#intWrapper(). +[19:28..19:33): until -> scala/runtime/RichInt#until(). +[19:36..19:36): -> scala/collection/IterableOps#withFilter(). +[19:40..19:41): i -> local4 +[19:42..19:43): % -> scala/Int#`%`(+3). +[19:46..19:48): == -> scala/Int#`==`(+3). +[19:50..19:50): -> scala/collection/WithFilter#map(). +[19:59..19:60): i -> local4 +[19:62..19:63): j -> local5 +[21:9..21:10): s <- example/Synthetic#s. +[22:8..22:13): apply <- example/Synthetic#s.apply(). +[23:5..23:5): -> example/Synthetic#s.apply(). +[24:6..24:11): apply -> example/Synthetic#s.apply(). +[25:15..25:18): Bar <- example/Synthetic#s.Bar# +[25:18..25:20): <- example/Synthetic#s.Bar#``(). +[26:4..26:7): Bar -> example/Synthetic#s.Bar. +[27:9..27:21): asInstanceOf -> scala/Any#asInstanceOf(). +[27:22..27:25): Int -> scala/Int# +[27:29..27:32): Int -> scala/Int# +[27:33..27:33): -> scala/Function1#apply(). +[30:8..30:9): J <- example/Synthetic#J# +[30:9..30:22): <- example/Synthetic#J#``(). +[30:10..30:11): T <- example/Synthetic#J#[T] +[30:11..30:11): <- example/Synthetic#J#evidence$2. +[30:13..30:21): Manifest -> scala/Predef.Manifest# +[30:21..30:21): -> example/Synthetic#J#[T] +[30:29..30:32): arr <- example/Synthetic#J#arr. +[30:35..30:40): Array -> scala/Array. +[30:41..30:46): empty -> scala/Array.empty(). +[30:47..30:48): T -> example/Synthetic#J#[T] +[30:49..30:49): -> example/Synthetic#J#evidence$2. +[32:2..32:2): <- example/Synthetic#F#``(). +[32:8..32:9): F <- example/Synthetic#F# +[33:15..33:23): ordering <- example/Synthetic#ordering. +[33:25..33:33): Ordering -> scala/package.Ordering# +[33:34..33:35): F -> example/Synthetic#F# +[33:39..33:42): ??? -> scala/Predef.`???`(). +[34:6..34:7): f <- example/Synthetic#f. +[34:9..34:16): Ordered -> scala/package.Ordered# +[34:17..34:18): F -> example/Synthetic#F# +[34:22..34:22): -> scala/math/Ordered.orderingToOrdered(). +[34:26..34:27): F -> example/Synthetic#F# +[34:27..34:27): -> example/Synthetic#F#``(). +[34:27..34:27): -> example/Synthetic#ordering. +[36:9..36:14): scala -> scala/ +[36:15..36:25): concurrent -> scala/concurrent/ +[36:26..36:42): ExecutionContext -> scala/concurrent/ExecutionContext. +[36:43..36:52): Implicits -> scala/concurrent/ExecutionContext.Implicits. +[36:53..36:59): global -> scala/concurrent/ExecutionContext.Implicits.global(). +[38:9..38:14): scala -> scala/ +[38:15..38:25): concurrent -> scala/concurrent/ +[38:26..38:32): Future -> scala/concurrent/Future. +[38:33..38:43): successful -> scala/concurrent/Future.successful(). +[38:46..38:46): -> scala/concurrent/Future#foreach(). +[39:9..39:14): scala -> scala/ +[39:15..39:25): concurrent -> scala/concurrent/ +[39:26..39:32): Future -> scala/concurrent/Future. +[39:33..39:43): successful -> scala/concurrent/Future.successful(). +[39:46..39:46): -> scala/concurrent/Future#foreach(). +[40:4..40:11): println -> scala/Predef.println(+1). +[40:12..40:13): a -> local6 +[40:14..40:14): -> scala/concurrent/ExecutionContext.Implicits.global(). +[42:9..42:14): scala -> scala/ +[42:15..42:25): concurrent -> scala/concurrent/ +[42:26..42:32): Future -> scala/concurrent/Future. +[42:33..42:43): successful -> scala/concurrent/Future.successful(). +[42:46..42:46): -> scala/concurrent/Future#flatMap(). +[43:9..43:14): scala -> scala/ +[43:15..43:25): concurrent -> scala/concurrent/ +[43:26..43:32): Future -> scala/concurrent/Future. +[43:33..43:43): successful -> scala/concurrent/Future.successful(). +[43:46..43:46): -> scala/concurrent/Future#withFilter(). +[44:7..44:8): a -> local7 +[44:9..44:10): < -> scala/Int#`<`(+3). +[44:11..44:12): b -> local8 +[44:12..44:12): -> scala/concurrent/Future#map(). +[44:12..44:12): -> scala/concurrent/ExecutionContext.Implicits.global(). +[45:10..45:11): a -> local7 +[45:11..45:11): -> scala/concurrent/ExecutionContext.Implicits.global(). expect/Traits.scala ___________________ @@ -2465,24 +2465,24 @@ traits/V# => trait V traits/V#``(). => primary ctor Occurrences: -[0:8..0:14) traits <- traits/ -[2:6..2:7) T <- traits/T# -[3:2..3:2) <- traits/T#``(). -[3:6..3:7) x <- traits/T#x(). -[6:0..6:0) <- traits/U#``(). -[6:13..6:14) U <- traits/U# -[7:7..7:8) U <- traits/U. -[8:6..8:7) u <- traits/U.u(). -[8:9..8:10) U -> traits/U# -[8:17..8:17) <- local0 -[8:17..8:18) U -> traits/U# -[8:21..8:21) -> local0 -[11:0..11:0) <- traits/C#``(). -[11:6..11:7) C <- traits/C# -[12:6..12:7) V <- traits/V# -[12:10..12:10) <- traits/V#``(). -[12:10..12:14) self <- local1 -[12:16..12:17) C -> traits/C# +[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:17): <- local0 +[8:17..8:18): U -> traits/U# +[8:21..8:21): -> local0 +[11:0..11:0): <- traits/C#``(). +[11:6..11:7): C <- traits/C# +[12:6..12:7): V <- traits/V# +[12:10..12:10): <- traits/V#``(). +[12:10..12:14): self <- local1 +[12:16..12:17): C -> traits/C# expect/Types.scala __________________ @@ -2617,255 +2617,255 @@ types/ann2# => class ann2 types/ann2#``(). => primary ctor Occurrences: -[0:8..0:13) types <- types/ -[2:7..2:12) scala -> scala/ -[2:13..2:21) language -> scalaShadowing/language. -[2:22..2:34) existentials -> scalaShadowing/language.existentials. -[3:7..3:12) scala -> scala/ -[3:13..3:21) language -> scalaShadowing/language. -[3:22..3:33) higherKinds -> scalaShadowing/language.higherKinds. -[5:6..5:9) ann <- types/ann# -[5:6..5:6) -> scala/annotation/Annotation#``(). -[5:9..5:18) <- types/ann#``(). -[5:10..5:11) T <- types/ann#[T] -[5:13..5:14) x <- types/ann#x. -[5:16..5:17) T -> types/ann#[T] -[5:27..5:32) scala -> scala/ -[5:33..5:43) annotation -> scala/annotation/ -[5:44..5:60) StaticAnnotation -> scala/annotation/StaticAnnotation# -[6:6..6:10) ann1 <- types/ann1# -[6:6..6:6) -> scala/annotation/Annotation#``(). -[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:6..7:6) -> scala/annotation/Annotation#``(). -[7:19..7:19) <- types/ann2#``(). -[7:19..7:24) scala -> scala/ -[7:25..7:35) annotation -> scala/annotation/ -[7:36..7:52) StaticAnnotation -> scala/annotation/StaticAnnotation# -[9:0..9:0) <- types/B#``(). -[9:6..9:7) B <- types/B# -[11:0..11:0) <- types/C#``(). -[11:6..11:7) C <- types/C# -[13:6..13:7) P <- types/P# -[14:2..14:2) <- types/P#``(). -[14:2..14:2) <- types/P#C#``(). -[14:8..14:9) C <- types/P#C# -[15:2..15:2) <- types/P#X#``(). -[15:8..15:9) X <- types/P#X# -[16:6..16:7) x <- types/P#x. -[16:14..16:15) X -> types/P#X# -[16:15..16:15) -> types/P#X#``(). -[19:6..19:7) T <- types/T# -[20:2..20:2) <- types/T#``(). -[20:2..20:2) <- types/T#C#``(). -[20:8..20:9) C <- types/T#C# -[21:2..21:2) <- types/T#X#``(). -[21:8..21:9) X <- types/T#X# -[22:6..22:7) x <- types/T#x. -[22:14..22:15) X -> types/T#X# -[22:15..22:15) -> types/T#X#``(). -[25:7..25:11) Test <- types/Test. -[26:8..26:9) M <- types/Test.M# -[27:4..27:4) <- types/Test.M#``(). -[27:8..27:9) m <- types/Test.M#m(). -[27:11..27:14) Int -> scala/Int# -[27:17..27:20) ??? -> scala/Predef.`???`(). -[30:8..30:9) N <- types/Test.N# -[31:4..31:4) <- types/Test.N#``(). -[31:8..31:9) n <- types/Test.N#n(). -[31:11..31:14) Int -> scala/Int# -[31:17..31:20) ??? -> scala/Predef.`???`(). -[34:8..34:9) C <- types/Test.C# -[34:18..34:18) <- types/Test.C#``(). -[34:18..34:19) M -> types/Test.M# -[34:19..34:19) -> types/Test.M#``(). -[35:8..35:9) p <- types/Test.C#p. -[35:16..35:17) P -> types/P# -[35:17..35:17) -> types/P#``(). -[36:8..36:9) x <- types/Test.C#x. -[36:12..36:13) p -> types/Test.C#p. -[36:14..36:15) x -> types/P#x. -[38:8..38:16) typeRef1 <- types/Test.C#typeRef1. -[38:18..38:19) C -> types/Test.C# -[38:22..38:25) ??? -> scala/Predef.`???`(). -[39:8..39:16) typeRef2 <- types/Test.C#typeRef2. -[39:18..39:19) p -> types/Test.C#p. -[39:20..39:21) C -> types/P#C# -[39:24..39:27) ??? -> scala/Predef.`???`(). -[40:8..40:16) typeRef3 <- types/Test.C#typeRef3. -[40:18..40:19) T -> types/T# -[40:20..40:21) C -> types/T#C# -[40:24..40:27) ??? -> scala/Predef.`???`(). -[41:8..41:16) typeRef4 <- types/Test.C#typeRef4. -[41:18..41:22) List -> scala/package.List# -[41:23..41:26) Int -> scala/Int# -[41:30..41:33) ??? -> scala/Predef.`???`(). -[43:8..43:19) singleType1 <- types/Test.C#singleType1. -[43:21..43:22) x -> types/Test.C#x. -[43:30..43:33) ??? -> scala/Predef.`???`(). -[44:8..44:19) singleType2 <- types/Test.C#singleType2. -[44:21..44:22) p -> types/Test.C#p. -[44:23..44:24) x -> types/P#x. -[44:32..44:35) ??? -> scala/Predef.`???`(). -[45:8..45:14) Either <- types/Test.C#Either. -[45:17..45:22) scala -> scala/ -[45:23..45:27) util -> scala/util/ -[45:28..45:34) Either -> scala/util/Either. -[47:8..47:17) thisType1 <- types/Test.C#thisType1. -[47:31..47:34) ??? -> scala/Predef.`???`(). -[48:8..48:17) thisType2 <- types/Test.C#thisType2. -[48:33..48:36) ??? -> scala/Predef.`???`(). -[50:8..50:18) superType1 <- types/Test.C#superType1. -[50:27..50:28) m -> types/Test.M#m(). -[51:8..51:18) superType2 <- types/Test.C#superType2. -[51:30..51:31) m -> types/Test.M#m(). -[52:8..52:18) superType3 <- types/Test.C#superType3. -[52:32..52:33) m -> types/Test.M#m(). -[54:8..54:21) compoundType1 <- types/Test.C#compoundType1. -[54:29..54:30) k <- local0 -[54:32..54:35) Int -> scala/Int# -[54:40..54:43) ??? -> scala/Predef.`???`(). -[55:8..55:21) compoundType2 <- types/Test.C#compoundType2. -[55:23..55:24) M -> types/Test.M# -[55:30..55:31) N -> types/Test.N# -[55:34..55:37) ??? -> scala/Predef.`???`(). -[56:8..56:21) compoundType3 <- types/Test.C#compoundType3. -[56:23..56:24) M -> types/Test.M# -[56:30..56:31) N -> types/Test.N# -[56:38..56:39) k <- local1 -[56:41..56:44) Int -> scala/Int# -[56:49..56:52) ??? -> scala/Predef.`???`(). -[57:8..57:21) compoundType4 <- types/Test.C#compoundType4. -[57:30..57:30) <- local2 -[57:34..57:35) k <- local3 -[57:37..57:40) Int -> scala/Int# -[57:43..57:46) ??? -> scala/Predef.`???`(). -[57:48..57:48) -> local2 -[58:8..58:21) compoundType5 <- types/Test.C#compoundType5. -[58:28..58:28) <- local4 -[58:28..58:29) M -> types/Test.M# -[58:29..58:29) -> types/Test.M#``(). -[58:35..58:36) N -> types/Test.N# -[58:36..58:36) -> local4 -[59:8..59:21) compoundType6 <- types/Test.C#compoundType6. -[59:28..59:28) <- local5 -[59:28..59:29) M -> types/Test.M# -[59:29..59:29) -> types/Test.M#``(). -[59:35..59:36) N -> types/Test.N# -[59:43..59:44) k <- local6 -[59:46..59:49) Int -> scala/Int# -[59:52..59:55) ??? -> scala/Predef.`???`(). -[59:57..59:57) -> local5 -[61:8..61:16) annType1 <- types/Test.C#annType1. -[61:18..61:19) T -> types/T# -[61:31..61:34) ??? -> scala/Predef.`???`(). -[62:8..62:16) annType2 <- types/Test.C#annType2. -[62:18..62:19) T -> types/T# -[62:34..62:37) ??? -> scala/Predef.`???`(). -[64:8..64:24) existentialType2 <- types/Test.C#existentialType2. -[64:26..64:30) List -> scala/package.List# -[64:36..64:39) ??? -> scala/Predef.`???`(). -[65:8..65:24) existentialType3 <- types/Test.C#existentialType3. -[65:27..65:32) Class -> java/lang/Class# -[65:33..65:40) forName -> java/lang/Class#forName(). -[66:8..66:24) existentialType4 <- types/Test.C#existentialType4. -[66:27..66:32) Class -> java/lang/Class# -[66:33..66:40) forName -> java/lang/Class#forName(). -[68:8..68:19) typeLambda1 <- types/Test.C#typeLambda1(). -[68:20..68:21) M <- types/Test.C#typeLambda1().[M] -[68:28..68:31) ??? -> scala/Predef.`???`(). -[69:4..69:15) typeLambda1 -> types/Test.C#typeLambda1(). -[69:24..69:25) L <- local7 -[69:26..69:27) T <- local8 -[69:31..69:35) List -> scala/package.List# -[69:36..69:37) T -> local8 -[71:11..71:25) ClassInfoType1 <- types/Test.C#ClassInfoType1. -[72:10..72:24) ClassInfoType2 <- types/Test.C#ClassInfoType2# -[72:33..72:33) <- types/Test.C#ClassInfoType2#``(). -[72:33..72:34) B -> types/B# -[72:34..72:34) -> types/B#``(). -[72:41..72:42) x <- types/Test.C#ClassInfoType2#x(). -[73:10..73:24) ClassInfoType3 <- types/Test.C#ClassInfoType3# -[73:24..73:27) <- types/Test.C#ClassInfoType3#``(). -[73:25..73:26) T <- types/Test.C#ClassInfoType3#[T] -[75:11..75:21) MethodType <- types/Test.C#MethodType. -[76:10..76:12) x1 <- types/Test.C#MethodType.x1(). -[76:14..76:17) Int -> scala/Int# -[76:20..76:23) ??? -> scala/Predef.`???`(). -[77:10..77:12) x2 <- types/Test.C#MethodType.x2(). -[77:14..77:17) Int -> scala/Int# -[77:20..77:23) ??? -> scala/Predef.`???`(). -[78:10..78:12) m3 <- types/Test.C#MethodType.m3(). -[78:14..78:17) Int -> scala/Int# -[78:20..78:23) ??? -> scala/Predef.`???`(). -[79:10..79:12) m4 <- types/Test.C#MethodType.m4(). -[79:16..79:19) Int -> scala/Int# -[79:22..79:25) ??? -> scala/Predef.`???`(). -[80:10..80:12) m5 <- types/Test.C#MethodType.m5(). -[80:13..80:14) x <- types/Test.C#MethodType.m5().(x) -[80:16..80:19) Int -> scala/Int# -[80:22..80:25) Int -> scala/Int# -[80:28..80:31) ??? -> scala/Predef.`???`(). -[81:10..81:12) m6 <- types/Test.C#MethodType.m6(). -[81:13..81:14) T <- types/Test.C#MethodType.m6().[T] -[81:16..81:17) x <- types/Test.C#MethodType.m6().(x) -[81:19..81:20) T -> types/Test.C#MethodType.m6().[T] -[81:23..81:24) T -> types/Test.C#MethodType.m6().[T] -[81:27..81:30) ??? -> scala/Predef.`???`(). -[84:11..84:21) ByNameType <- types/Test.C#ByNameType. -[85:10..85:12) m1 <- types/Test.C#ByNameType.m1(). -[85:13..85:14) x <- types/Test.C#ByNameType.m1().(x) -[85:19..85:22) Int -> scala/Int# -[85:25..85:28) Int -> scala/Int# -[85:31..85:34) ??? -> scala/Predef.`???`(). -[88:15..88:27) RepeatedType <- types/Test.C#RepeatedType# -[88:27..88:39) <- types/Test.C#RepeatedType#``(). -[88:28..88:29) s <- types/Test.C#RepeatedType#s. -[88:31..88:37) String -> scala/Predef.String# -[89:10..89:12) m1 <- types/Test.C#RepeatedType#m1(). -[89:13..89:14) x <- types/Test.C#RepeatedType#m1().(x) -[89:16..89:19) Int -> scala/Int# -[89:23..89:26) Int -> scala/Int# -[89:29..89:30) s -> types/Test.C#RepeatedType#s. -[89:31..89:37) length -> scala/collection/SeqOps#length(). -[92:11..92:19) TypeType <- types/Test.C#TypeType. -[93:11..93:13) T1 <- types/Test.C#TypeType.T1# -[94:10..94:12) m2 <- types/Test.C#TypeType.m2(). -[94:13..94:15) T2 <- types/Test.C#TypeType.m2().[T2] -[94:19..94:20) C -> types/Test.C# -[94:24..94:25) C -> types/Test.C# -[94:29..94:32) ??? -> scala/Predef.`???`(). -[95:10..95:12) m3 <- types/Test.C#TypeType.m3(). -[95:13..95:15) M3 <- types/Test.C#TypeType.m3().[M3] -[95:22..95:25) ??? -> scala/Predef.`???`(). -[96:11..96:13) T4 <- types/Test.C#TypeType.T4# -[96:16..96:17) C -> types/Test.C# -[97:11..97:13) T5 <- types/Test.C#TypeType.T5# -[97:14..97:15) U <- types/Test.C#TypeType.T5#[U] -[97:19..97:20) U -> types/Test.C#TypeType.T5#[U] -[101:9..101:16) Literal <- types/Test.Literal. -[102:14..102:17) int <- types/Test.Literal.int. -[103:14..103:18) long <- types/Test.Literal.long. -[104:14..104:19) float <- types/Test.Literal.float. -[105:14..105:20) double <- types/Test.Literal.double. -[106:14..106:17) nil <- types/Test.Literal.nil. -[107:14..107:18) char <- types/Test.Literal.char. -[108:14..108:20) string <- types/Test.Literal.string. -[109:14..109:18) bool <- types/Test.Literal.bool. -[110:14..110:18) unit <- types/Test.Literal.unit. -[111:14..111:22) javaEnum <- types/Test.Literal.javaEnum. -[111:25..111:29) java -> java/ -[111:30..111:33) nio -> java/nio/ -[111:34..111:38) file -> java/nio/file/ -[111:39..111:49) LinkOption -> java/nio/file/LinkOption# -[111:50..111:64) NOFOLLOW_LINKS -> java/nio/file/LinkOption#NOFOLLOW_LINKS. -[112:14..112:21) clazzOf <- types/Test.Literal.clazzOf. -[112:24..112:31) classOf -> scala/Predef.classOf(). -[112:32..112:38) Option -> scala/Option# -[112:39..112:42) Int -> scala/Int# +[0:8..0:13): types <- types/ +[2:7..2:12): scala -> scala/ +[2:13..2:21): language -> scalaShadowing/language. +[2:22..2:34): existentials -> scalaShadowing/language.existentials. +[3:7..3:12): scala -> scala/ +[3:13..3:21): language -> scalaShadowing/language. +[3:22..3:33): higherKinds -> scalaShadowing/language.higherKinds. +[5:6..5:9): ann <- types/ann# +[5:6..5:6): -> scala/annotation/Annotation#``(). +[5:9..5:18): <- types/ann#``(). +[5:10..5:11): T <- types/ann#[T] +[5:13..5:14): x <- types/ann#x. +[5:16..5:17): T -> types/ann#[T] +[5:27..5:32): scala -> scala/ +[5:33..5:43): annotation -> scala/annotation/ +[5:44..5:60): StaticAnnotation -> scala/annotation/StaticAnnotation# +[6:6..6:10): ann1 <- types/ann1# +[6:6..6:6): -> scala/annotation/Annotation#``(). +[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:6..7:6): -> scala/annotation/Annotation#``(). +[7:19..7:19): <- types/ann2#``(). +[7:19..7:24): scala -> scala/ +[7:25..7:35): annotation -> scala/annotation/ +[7:36..7:52): StaticAnnotation -> scala/annotation/StaticAnnotation# +[9:0..9:0): <- types/B#``(). +[9:6..9:7): B <- types/B# +[11:0..11:0): <- types/C#``(). +[11:6..11:7): C <- types/C# +[13:6..13:7): P <- types/P# +[14:2..14:2): <- types/P#``(). +[14:2..14:2): <- types/P#C#``(). +[14:8..14:9): C <- types/P#C# +[15:2..15:2): <- types/P#X#``(). +[15:8..15:9): X <- types/P#X# +[16:6..16:7): x <- types/P#x. +[16:14..16:15): X -> types/P#X# +[16:15..16:15): -> types/P#X#``(). +[19:6..19:7): T <- types/T# +[20:2..20:2): <- types/T#``(). +[20:2..20:2): <- types/T#C#``(). +[20:8..20:9): C <- types/T#C# +[21:2..21:2): <- types/T#X#``(). +[21:8..21:9): X <- types/T#X# +[22:6..22:7): x <- types/T#x. +[22:14..22:15): X -> types/T#X# +[22:15..22:15): -> types/T#X#``(). +[25:7..25:11): Test <- types/Test. +[26:8..26:9): M <- types/Test.M# +[27:4..27:4): <- types/Test.M#``(). +[27:8..27:9): m <- types/Test.M#m(). +[27:11..27:14): Int -> scala/Int# +[27:17..27:20): ??? -> scala/Predef.`???`(). +[30:8..30:9): N <- types/Test.N# +[31:4..31:4): <- types/Test.N#``(). +[31:8..31:9): n <- types/Test.N#n(). +[31:11..31:14): Int -> scala/Int# +[31:17..31:20): ??? -> scala/Predef.`???`(). +[34:8..34:9): C <- types/Test.C# +[34:18..34:18): <- types/Test.C#``(). +[34:18..34:19): M -> types/Test.M# +[34:19..34:19): -> types/Test.M#``(). +[35:8..35:9): p <- types/Test.C#p. +[35:16..35:17): P -> types/P# +[35:17..35:17): -> types/P#``(). +[36:8..36:9): x <- types/Test.C#x. +[36:12..36:13): p -> types/Test.C#p. +[36:14..36:15): x -> types/P#x. +[38:8..38:16): typeRef1 <- types/Test.C#typeRef1. +[38:18..38:19): C -> types/Test.C# +[38:22..38:25): ??? -> scala/Predef.`???`(). +[39:8..39:16): typeRef2 <- types/Test.C#typeRef2. +[39:18..39:19): p -> types/Test.C#p. +[39:20..39:21): C -> types/P#C# +[39:24..39:27): ??? -> scala/Predef.`???`(). +[40:8..40:16): typeRef3 <- types/Test.C#typeRef3. +[40:18..40:19): T -> types/T# +[40:20..40:21): C -> types/T#C# +[40:24..40:27): ??? -> scala/Predef.`???`(). +[41:8..41:16): typeRef4 <- types/Test.C#typeRef4. +[41:18..41:22): List -> scala/package.List# +[41:23..41:26): Int -> scala/Int# +[41:30..41:33): ??? -> scala/Predef.`???`(). +[43:8..43:19): singleType1 <- types/Test.C#singleType1. +[43:21..43:22): x -> types/Test.C#x. +[43:30..43:33): ??? -> scala/Predef.`???`(). +[44:8..44:19): singleType2 <- types/Test.C#singleType2. +[44:21..44:22): p -> types/Test.C#p. +[44:23..44:24): x -> types/P#x. +[44:32..44:35): ??? -> scala/Predef.`???`(). +[45:8..45:14): Either <- types/Test.C#Either. +[45:17..45:22): scala -> scala/ +[45:23..45:27): util -> scala/util/ +[45:28..45:34): Either -> scala/util/Either. +[47:8..47:17): thisType1 <- types/Test.C#thisType1. +[47:31..47:34): ??? -> scala/Predef.`???`(). +[48:8..48:17): thisType2 <- types/Test.C#thisType2. +[48:33..48:36): ??? -> scala/Predef.`???`(). +[50:8..50:18): superType1 <- types/Test.C#superType1. +[50:27..50:28): m -> types/Test.M#m(). +[51:8..51:18): superType2 <- types/Test.C#superType2. +[51:30..51:31): m -> types/Test.M#m(). +[52:8..52:18): superType3 <- types/Test.C#superType3. +[52:32..52:33): m -> types/Test.M#m(). +[54:8..54:21): compoundType1 <- types/Test.C#compoundType1. +[54:29..54:30): k <- local0 +[54:32..54:35): Int -> scala/Int# +[54:40..54:43): ??? -> scala/Predef.`???`(). +[55:8..55:21): compoundType2 <- types/Test.C#compoundType2. +[55:23..55:24): M -> types/Test.M# +[55:30..55:31): N -> types/Test.N# +[55:34..55:37): ??? -> scala/Predef.`???`(). +[56:8..56:21): compoundType3 <- types/Test.C#compoundType3. +[56:23..56:24): M -> types/Test.M# +[56:30..56:31): N -> types/Test.N# +[56:38..56:39): k <- local1 +[56:41..56:44): Int -> scala/Int# +[56:49..56:52): ??? -> scala/Predef.`???`(). +[57:8..57:21): compoundType4 <- types/Test.C#compoundType4. +[57:30..57:30): <- local2 +[57:34..57:35): k <- local3 +[57:37..57:40): Int -> scala/Int# +[57:43..57:46): ??? -> scala/Predef.`???`(). +[57:48..57:48): -> local2 +[58:8..58:21): compoundType5 <- types/Test.C#compoundType5. +[58:28..58:28): <- local4 +[58:28..58:29): M -> types/Test.M# +[58:29..58:29): -> types/Test.M#``(). +[58:35..58:36): N -> types/Test.N# +[58:36..58:36): -> local4 +[59:8..59:21): compoundType6 <- types/Test.C#compoundType6. +[59:28..59:28): <- local5 +[59:28..59:29): M -> types/Test.M# +[59:29..59:29): -> types/Test.M#``(). +[59:35..59:36): N -> types/Test.N# +[59:43..59:44): k <- local6 +[59:46..59:49): Int -> scala/Int# +[59:52..59:55): ??? -> scala/Predef.`???`(). +[59:57..59:57): -> local5 +[61:8..61:16): annType1 <- types/Test.C#annType1. +[61:18..61:19): T -> types/T# +[61:31..61:34): ??? -> scala/Predef.`???`(). +[62:8..62:16): annType2 <- types/Test.C#annType2. +[62:18..62:19): T -> types/T# +[62:34..62:37): ??? -> scala/Predef.`???`(). +[64:8..64:24): existentialType2 <- types/Test.C#existentialType2. +[64:26..64:30): List -> scala/package.List# +[64:36..64:39): ??? -> scala/Predef.`???`(). +[65:8..65:24): existentialType3 <- types/Test.C#existentialType3. +[65:27..65:32): Class -> java/lang/Class# +[65:33..65:40): forName -> java/lang/Class#forName(). +[66:8..66:24): existentialType4 <- types/Test.C#existentialType4. +[66:27..66:32): Class -> java/lang/Class# +[66:33..66:40): forName -> java/lang/Class#forName(). +[68:8..68:19): typeLambda1 <- types/Test.C#typeLambda1(). +[68:20..68:21): M <- types/Test.C#typeLambda1().[M] +[68:28..68:31): ??? -> scala/Predef.`???`(). +[69:4..69:15): typeLambda1 -> types/Test.C#typeLambda1(). +[69:24..69:25): L <- local7 +[69:26..69:27): T <- local8 +[69:31..69:35): List -> scala/package.List# +[69:36..69:37): T -> local8 +[71:11..71:25): ClassInfoType1 <- types/Test.C#ClassInfoType1. +[72:10..72:24): ClassInfoType2 <- types/Test.C#ClassInfoType2# +[72:33..72:33): <- types/Test.C#ClassInfoType2#``(). +[72:33..72:34): B -> types/B# +[72:34..72:34): -> types/B#``(). +[72:41..72:42): x <- types/Test.C#ClassInfoType2#x(). +[73:10..73:24): ClassInfoType3 <- types/Test.C#ClassInfoType3# +[73:24..73:27): <- types/Test.C#ClassInfoType3#``(). +[73:25..73:26): T <- types/Test.C#ClassInfoType3#[T] +[75:11..75:21): MethodType <- types/Test.C#MethodType. +[76:10..76:12): x1 <- types/Test.C#MethodType.x1(). +[76:14..76:17): Int -> scala/Int# +[76:20..76:23): ??? -> scala/Predef.`???`(). +[77:10..77:12): x2 <- types/Test.C#MethodType.x2(). +[77:14..77:17): Int -> scala/Int# +[77:20..77:23): ??? -> scala/Predef.`???`(). +[78:10..78:12): m3 <- types/Test.C#MethodType.m3(). +[78:14..78:17): Int -> scala/Int# +[78:20..78:23): ??? -> scala/Predef.`???`(). +[79:10..79:12): m4 <- types/Test.C#MethodType.m4(). +[79:16..79:19): Int -> scala/Int# +[79:22..79:25): ??? -> scala/Predef.`???`(). +[80:10..80:12): m5 <- types/Test.C#MethodType.m5(). +[80:13..80:14): x <- types/Test.C#MethodType.m5().(x) +[80:16..80:19): Int -> scala/Int# +[80:22..80:25): Int -> scala/Int# +[80:28..80:31): ??? -> scala/Predef.`???`(). +[81:10..81:12): m6 <- types/Test.C#MethodType.m6(). +[81:13..81:14): T <- types/Test.C#MethodType.m6().[T] +[81:16..81:17): x <- types/Test.C#MethodType.m6().(x) +[81:19..81:20): T -> types/Test.C#MethodType.m6().[T] +[81:23..81:24): T -> types/Test.C#MethodType.m6().[T] +[81:27..81:30): ??? -> scala/Predef.`???`(). +[84:11..84:21): ByNameType <- types/Test.C#ByNameType. +[85:10..85:12): m1 <- types/Test.C#ByNameType.m1(). +[85:13..85:14): x <- types/Test.C#ByNameType.m1().(x) +[85:19..85:22): Int -> scala/Int# +[85:25..85:28): Int -> scala/Int# +[85:31..85:34): ??? -> scala/Predef.`???`(). +[88:15..88:27): RepeatedType <- types/Test.C#RepeatedType# +[88:27..88:39): <- types/Test.C#RepeatedType#``(). +[88:28..88:29): s <- types/Test.C#RepeatedType#s. +[88:31..88:37): String -> scala/Predef.String# +[89:10..89:12): m1 <- types/Test.C#RepeatedType#m1(). +[89:13..89:14): x <- types/Test.C#RepeatedType#m1().(x) +[89:16..89:19): Int -> scala/Int# +[89:23..89:26): Int -> scala/Int# +[89:29..89:30): s -> types/Test.C#RepeatedType#s. +[89:31..89:37): length -> scala/collection/SeqOps#length(). +[92:11..92:19): TypeType <- types/Test.C#TypeType. +[93:11..93:13): T1 <- types/Test.C#TypeType.T1# +[94:10..94:12): m2 <- types/Test.C#TypeType.m2(). +[94:13..94:15): T2 <- types/Test.C#TypeType.m2().[T2] +[94:19..94:20): C -> types/Test.C# +[94:24..94:25): C -> types/Test.C# +[94:29..94:32): ??? -> scala/Predef.`???`(). +[95:10..95:12): m3 <- types/Test.C#TypeType.m3(). +[95:13..95:15): M3 <- types/Test.C#TypeType.m3().[M3] +[95:22..95:25): ??? -> scala/Predef.`???`(). +[96:11..96:13): T4 <- types/Test.C#TypeType.T4# +[96:16..96:17): C -> types/Test.C# +[97:11..97:13): T5 <- types/Test.C#TypeType.T5# +[97:14..97:15): U <- types/Test.C#TypeType.T5#[U] +[97:19..97:20): U -> types/Test.C#TypeType.T5#[U] +[101:9..101:16): Literal <- types/Test.Literal. +[102:14..102:17): int <- types/Test.Literal.int. +[103:14..103:18): long <- types/Test.Literal.long. +[104:14..104:19): float <- types/Test.Literal.float. +[105:14..105:20): double <- types/Test.Literal.double. +[106:14..106:17): nil <- types/Test.Literal.nil. +[107:14..107:18): char <- types/Test.Literal.char. +[108:14..108:20): string <- types/Test.Literal.string. +[109:14..109:18): bool <- types/Test.Literal.bool. +[110:14..110:18): unit <- types/Test.Literal.unit. +[111:14..111:22): javaEnum <- types/Test.Literal.javaEnum. +[111:25..111:29): java -> java/ +[111:30..111:33): nio -> java/nio/ +[111:34..111:38): file -> java/nio/file/ +[111:39..111:49): LinkOption -> java/nio/file/LinkOption# +[111:50..111:64): NOFOLLOW_LINKS -> java/nio/file/LinkOption#NOFOLLOW_LINKS. +[112:14..112:21): clazzOf <- types/Test.Literal.clazzOf. +[112:24..112:31): classOf -> scala/Predef.classOf(). +[112:32..112:38): Option -> scala/Option# +[112:39..112:42): Int -> scala/Int# expect/ValPattern.scala _______________________ @@ -2903,63 +2903,63 @@ local7 => val local number1Var local7 => local number1Var Occurrences: -[0:8..0:15) example <- example/ -[2:6..2:16) ValPattern <- example/ValPattern# -[4:2..4:2) <- example/ValPattern#``(). -[4:2..4:2) -> scala/Tuple2#_1. -[4:2..4:2) -> scala/Tuple2#_2. -[4:7..4:11) left <- example/ValPattern#left. -[4:13..4:18) right <- example/ValPattern#right. -[5:6..5:10) Some -> scala/Some. -[5:11..5:18) number1 <- example/ValPattern#number1. -[5:11..5:18) number1 <- local0 -[5:19..5:19) -> local0 -[6:4..6:8) Some -> scala/Some. -[8:2..8:2) -> scala/Tuple2#_1. -[8:2..8:2) -> scala/Tuple2#_2. -[8:7..8:14) leftVar <- example/ValPattern#leftVar(). -[8:7..8:16) leftVar, <- example/ValPattern#`leftVar_=`(). -[8:16..8:24) rightVar <- example/ValPattern#rightVar(). -[8:16..8:26) rightVar) <- example/ValPattern#`rightVar_=`(). -[9:6..9:10) Some -> scala/Some. -[9:11..9:21) number1Var <- example/ValPattern#number1Var(). -[9:11..9:21) number1Var <- local1 -[9:11..9:23) number1Var) <- example/ValPattern#`number1Var_=`(). -[9:22..9:22) -> local1 -[10:4..10:8) Some -> scala/Some. -[12:6..12:9) app <- example/ValPattern#app(). -[12:13..12:17) Unit -> scala/Unit# -[13:4..13:11) println -> scala/Predef.println(+1). -[15:8..15:15) number1 -> example/ValPattern#number1. -[16:8..16:12) left -> example/ValPattern#left. -[17:8..17:13) right -> example/ValPattern#right. -[18:8..18:18) number1Var -> example/ValPattern#number1Var(). -[19:8..19:15) leftVar -> example/ValPattern#leftVar(). -[20:8..20:16) rightVar -> example/ValPattern#rightVar(). -[23:4..23:11) locally -> dotty/DottyPredef.locally(). -[24:6..24:6) -> scala/Tuple2#_1. -[24:6..24:6) -> scala/Tuple2#_2. -[24:11..24:15) left <- local2 -[24:17..24:22) right <- local3 -[25:10..25:14) Some -> scala/Some. -[25:15..25:22) number1 <- local4 -[25:23..25:23) -> local4 -[26:8..26:12) Some -> scala/Some. -[28:6..28:6) -> scala/Tuple2#_1. -[28:6..28:6) -> scala/Tuple2#_2. -[28:11..28:18) leftVar <- local5 -[28:20..28:28) rightVar <- local6 -[29:10..29:14) Some -> scala/Some. -[29:15..29:25) number1Var <- local7 -[29:26..29:26) -> local7 -[30:8..30:12) Some -> scala/Some. -[31:6..31:13) println -> scala/Predef.println(+1). -[33:10..33:17) number1 -> local4 -[34:10..34:14) left -> local2 -[35:10..35:15) right -> local3 -[36:10..36:20) number1Var -> local7 -[37:10..37:17) leftVar -> local5 -[38:10..38:18) rightVar -> local6 +[0:8..0:15): example <- example/ +[2:6..2:16): ValPattern <- example/ValPattern# +[4:2..4:2): <- example/ValPattern#``(). +[4:2..4:2): -> scala/Tuple2#_1. +[4:2..4:2): -> scala/Tuple2#_2. +[4:7..4:11): left <- example/ValPattern#left. +[4:13..4:18): right <- example/ValPattern#right. +[5:6..5:10): Some -> scala/Some. +[5:11..5:18): number1 <- example/ValPattern#number1. +[5:11..5:18): number1 <- local0 +[5:19..5:19): -> local0 +[6:4..6:8): Some -> scala/Some. +[8:2..8:2): -> scala/Tuple2#_1. +[8:2..8:2): -> scala/Tuple2#_2. +[8:7..8:14): leftVar <- example/ValPattern#leftVar(). +[8:7..8:16): leftVar, <- example/ValPattern#`leftVar_=`(). +[8:16..8:24): rightVar <- example/ValPattern#rightVar(). +[8:16..8:26): rightVar) <- example/ValPattern#`rightVar_=`(). +[9:6..9:10): Some -> scala/Some. +[9:11..9:21): number1Var <- example/ValPattern#number1Var(). +[9:11..9:21): number1Var <- local1 +[9:11..9:23): number1Var) <- example/ValPattern#`number1Var_=`(). +[9:22..9:22): -> local1 +[10:4..10:8): Some -> scala/Some. +[12:6..12:9): app <- example/ValPattern#app(). +[12:13..12:17): Unit -> scala/Unit# +[13:4..13:11): println -> scala/Predef.println(+1). +[15:8..15:15): number1 -> example/ValPattern#number1. +[16:8..16:12): left -> example/ValPattern#left. +[17:8..17:13): right -> example/ValPattern#right. +[18:8..18:18): number1Var -> example/ValPattern#number1Var(). +[19:8..19:15): leftVar -> example/ValPattern#leftVar(). +[20:8..20:16): rightVar -> example/ValPattern#rightVar(). +[23:4..23:11): locally -> dotty/DottyPredef.locally(). +[24:6..24:6): -> scala/Tuple2#_1. +[24:6..24:6): -> scala/Tuple2#_2. +[24:11..24:15): left <- local2 +[24:17..24:22): right <- local3 +[25:10..25:14): Some -> scala/Some. +[25:15..25:22): number1 <- local4 +[25:23..25:23): -> local4 +[26:8..26:12): Some -> scala/Some. +[28:6..28:6): -> scala/Tuple2#_1. +[28:6..28:6): -> scala/Tuple2#_2. +[28:11..28:18): leftVar <- local5 +[28:20..28:28): rightVar <- local6 +[29:10..29:14): Some -> scala/Some. +[29:15..29:25): number1Var <- local7 +[29:26..29:26): -> local7 +[30:8..30:12): Some -> scala/Some. +[31:6..31:13): println -> scala/Predef.println(+1). +[33:10..33:17): number1 -> local4 +[34:10..34:14): left -> local2 +[35:10..35:15): right -> local3 +[36:10..36:20): number1Var -> local7 +[37:10..37:17): leftVar -> local5 +[38:10..38:18): rightVar -> local6 expect/Vals.scala _________________ @@ -3008,128 +3008,128 @@ local3 => local yl local4 => implicit local yil Occurrences: -[0:8..0:15) example <- example/ -[2:15..2:19) Vals <- example/Vals# -[2:19..2:53) <- example/Vals#``(). -[2:20..2:21) p <- example/Vals#p. -[2:23..2:26) Int -> scala/Int# -[2:32..2:34) xp <- example/Vals#xp. -[2:36..2:39) Int -> scala/Int# -[2:45..2:47) yp <- example/Vals#yp(). -[2:45..2:49) yp: <- example/Vals#`yp_=`(). -[2:49..2:52) Int -> scala/Int# -[3:6..3:8) xm <- example/Vals#xm. -[3:10..3:13) Int -> scala/Int# -[3:16..3:19) ??? -> scala/Predef.`???`(). -[4:6..4:9) xam <- example/Vals#xam. -[4:11..4:14) Int -> scala/Int# -[5:20..5:23) xlm <- example/Vals#xlm. -[5:25..5:28) Int -> scala/Int# -[5:31..5:34) ??? -> scala/Predef.`???`(). -[6:11..6:14) xzm <- example/Vals#xzm. -[6:16..6:19) Int -> scala/Int# -[6:22..6:25) ??? -> scala/Predef.`???`(). -[7:25..7:29) xzlm <- example/Vals#xzlm. -[7:31..7:34) Int -> scala/Int# -[7:37..7:40) ??? -> scala/Predef.`???`(). -[8:12..8:15) xfm <- example/Vals#xfm. -[8:17..8:20) Int -> scala/Int# -[8:23..8:26) ??? -> scala/Predef.`???`(). -[9:15..9:18) xim <- example/Vals#xim. -[9:20..9:23) Int -> scala/Int# -[9:26..9:29) ??? -> scala/Predef.`???`(). -[10:6..10:8) ym <- example/Vals#ym(). -[10:6..10:10) ym: <- example/Vals#`ym_=`(). -[10:10..10:13) Int -> scala/Int# -[10:16..10:19) ??? -> scala/Predef.`???`(). -[11:6..11:9) yam <- example/Vals#yam(). -[11:6..11:11) yam: <- example/Vals#`yam_=`(). -[11:11..11:14) Int -> scala/Int# -[12:20..12:23) ylm <- example/Vals#ylm(). -[12:25..12:28) Int -> scala/Int# -[12:31..12:34) ??? -> scala/Predef.`???`(). -[16:12..16:15) yfm <- example/Vals#yfm(). -[16:12..16:17) yfm: <- example/Vals#`yfm_=`(). -[16:17..16:20) Int -> scala/Int# -[16:23..16:26) ??? -> scala/Predef.`???`(). -[17:15..17:18) yim <- example/Vals#yim(). -[17:15..17:20) yim: <- example/Vals#`yim_=`(). -[17:20..17:23) Int -> scala/Int# -[17:26..17:29) ??? -> scala/Predef.`???`(). -[18:6..18:7) m <- example/Vals#m(). -[19:8..19:10) xl <- local0 -[19:12..19:15) Int -> scala/Int# -[19:18..19:21) ??? -> scala/Predef.`???`(). -[20:13..20:16) xzl <- local1 -[20:18..20:21) Int -> scala/Int# -[20:24..20:27) ??? -> scala/Predef.`???`(). -[23:17..23:20) xil <- local2 -[23:22..23:25) Int -> scala/Int# -[23:28..23:31) ??? -> scala/Predef.`???`(). -[24:8..24:10) yl <- local3 -[24:12..24:15) Int -> scala/Int# -[24:18..24:21) ??? -> scala/Predef.`???`(). -[29:17..29:20) yil <- local4 -[29:22..29:25) Int -> scala/Int# -[29:28..29:31) ??? -> scala/Predef.`???`(). -[30:4..30:6) yl -> local3 -[30:9..30:11) xl -> local0 -[30:12..30:13) + -> scala/Int#`+`(+4). -[30:14..30:16) yl -> local3 -[31:4..31:11) println -> scala/Predef.println(+1). -[31:12..31:15) xzl -> local1 -[32:4..32:7) yil -> local4 -[32:10..32:13) xil -> local2 -[32:14..32:15) + -> scala/Int#`+`(+4). -[32:16..32:19) yil -> local4 -[34:2..34:9) println -> scala/Predef.println(+1). -[34:10..34:14) xzlm -> example/Vals#xzlm. -[35:2..35:5) ylm -> example/Vals#ylm(). -[35:8..35:11) xlm -> example/Vals#xlm. -[35:12..35:13) + -> scala/Int#`+`(+4). -[35:14..35:17) ylm -> example/Vals#ylm(). -[38:7..38:16) ValUsages <- example/ValUsages. -[39:6..39:7) v <- example/ValUsages.v. -[39:9..39:13) Vals -> example/Vals# -[39:16..39:19) ??? -> scala/Predef.`???`(). -[40:2..40:3) v -> example/ValUsages.v. -[40:4..40:6) yp -> example/Vals#`yp_=`(). -[40:9..40:10) v -> example/ValUsages.v. -[40:11..40:13) xp -> example/Vals#xp. -[40:14..40:15) + -> scala/Int#`+`(+4). -[40:16..40:17) v -> example/ValUsages.v. -[40:18..40:20) yp -> example/Vals#yp(). -[41:2..41:3) v -> example/ValUsages.v. -[41:4..41:6) ym -> example/Vals#`ym_=`(). -[41:9..41:10) v -> example/ValUsages.v. -[41:11..41:13) xm -> example/Vals#xm. -[41:14..41:15) + -> scala/Int#`+`(+4). -[41:16..41:17) v -> example/ValUsages.v. -[41:18..41:20) ym -> example/Vals#ym(). -[42:2..42:3) v -> example/ValUsages.v. -[42:4..42:7) yam -> example/Vals#`yam_=`(). -[42:10..42:11) v -> example/ValUsages.v. -[42:12..42:15) xam -> example/Vals#xam. -[42:16..42:17) + -> scala/Int#`+`(+4). -[42:18..42:19) v -> example/ValUsages.v. -[42:20..42:23) yam -> example/Vals#yam(). -[43:2..43:9) println -> scala/Predef.println(+1). -[43:10..43:11) v -> example/ValUsages.v. -[43:12..43:15) xzm -> example/Vals#xzm. -[44:2..44:3) v -> example/ValUsages.v. -[44:4..44:7) yfm -> example/Vals#`yfm_=`(). -[44:10..44:11) v -> example/ValUsages.v. -[44:12..44:15) xfm -> example/Vals#xfm. -[44:16..44:17) + -> scala/Int#`+`(+4). -[44:18..44:19) v -> example/ValUsages.v. -[44:20..44:23) yfm -> example/Vals#yfm(). -[45:2..45:3) v -> example/ValUsages.v. -[45:4..45:7) yim -> example/Vals#`yim_=`(). -[45:10..45:11) v -> example/ValUsages.v. -[45:12..45:15) xim -> example/Vals#xim. -[45:16..45:17) + -> scala/Int#`+`(+4). -[45:18..45:19) v -> example/ValUsages.v. -[45:20..45:23) yim -> example/Vals#yim(). +[0:8..0:15): example <- example/ +[2:15..2:19): Vals <- example/Vals# +[2:19..2:53): <- example/Vals#``(). +[2:20..2:21): p <- example/Vals#p. +[2:23..2:26): Int -> scala/Int# +[2:32..2:34): xp <- example/Vals#xp. +[2:36..2:39): Int -> scala/Int# +[2:45..2:47): yp <- example/Vals#yp(). +[2:45..2:49): yp: <- example/Vals#`yp_=`(). +[2:49..2:52): Int -> scala/Int# +[3:6..3:8): xm <- example/Vals#xm. +[3:10..3:13): Int -> scala/Int# +[3:16..3:19): ??? -> scala/Predef.`???`(). +[4:6..4:9): xam <- example/Vals#xam. +[4:11..4:14): Int -> scala/Int# +[5:20..5:23): xlm <- example/Vals#xlm. +[5:25..5:28): Int -> scala/Int# +[5:31..5:34): ??? -> scala/Predef.`???`(). +[6:11..6:14): xzm <- example/Vals#xzm. +[6:16..6:19): Int -> scala/Int# +[6:22..6:25): ??? -> scala/Predef.`???`(). +[7:25..7:29): xzlm <- example/Vals#xzlm. +[7:31..7:34): Int -> scala/Int# +[7:37..7:40): ??? -> scala/Predef.`???`(). +[8:12..8:15): xfm <- example/Vals#xfm. +[8:17..8:20): Int -> scala/Int# +[8:23..8:26): ??? -> scala/Predef.`???`(). +[9:15..9:18): xim <- example/Vals#xim. +[9:20..9:23): Int -> scala/Int# +[9:26..9:29): ??? -> scala/Predef.`???`(). +[10:6..10:8): ym <- example/Vals#ym(). +[10:6..10:10): ym: <- example/Vals#`ym_=`(). +[10:10..10:13): Int -> scala/Int# +[10:16..10:19): ??? -> scala/Predef.`???`(). +[11:6..11:9): yam <- example/Vals#yam(). +[11:6..11:11): yam: <- example/Vals#`yam_=`(). +[11:11..11:14): Int -> scala/Int# +[12:20..12:23): ylm <- example/Vals#ylm(). +[12:25..12:28): Int -> scala/Int# +[12:31..12:34): ??? -> scala/Predef.`???`(). +[16:12..16:15): yfm <- example/Vals#yfm(). +[16:12..16:17): yfm: <- example/Vals#`yfm_=`(). +[16:17..16:20): Int -> scala/Int# +[16:23..16:26): ??? -> scala/Predef.`???`(). +[17:15..17:18): yim <- example/Vals#yim(). +[17:15..17:20): yim: <- example/Vals#`yim_=`(). +[17:20..17:23): Int -> scala/Int# +[17:26..17:29): ??? -> scala/Predef.`???`(). +[18:6..18:7): m <- example/Vals#m(). +[19:8..19:10): xl <- local0 +[19:12..19:15): Int -> scala/Int# +[19:18..19:21): ??? -> scala/Predef.`???`(). +[20:13..20:16): xzl <- local1 +[20:18..20:21): Int -> scala/Int# +[20:24..20:27): ??? -> scala/Predef.`???`(). +[23:17..23:20): xil <- local2 +[23:22..23:25): Int -> scala/Int# +[23:28..23:31): ??? -> scala/Predef.`???`(). +[24:8..24:10): yl <- local3 +[24:12..24:15): Int -> scala/Int# +[24:18..24:21): ??? -> scala/Predef.`???`(). +[29:17..29:20): yil <- local4 +[29:22..29:25): Int -> scala/Int# +[29:28..29:31): ??? -> scala/Predef.`???`(). +[30:4..30:6): yl -> local3 +[30:9..30:11): xl -> local0 +[30:12..30:13): + -> scala/Int#`+`(+4). +[30:14..30:16): yl -> local3 +[31:4..31:11): println -> scala/Predef.println(+1). +[31:12..31:15): xzl -> local1 +[32:4..32:7): yil -> local4 +[32:10..32:13): xil -> local2 +[32:14..32:15): + -> scala/Int#`+`(+4). +[32:16..32:19): yil -> local4 +[34:2..34:9): println -> scala/Predef.println(+1). +[34:10..34:14): xzlm -> example/Vals#xzlm. +[35:2..35:5): ylm -> example/Vals#ylm(). +[35:8..35:11): xlm -> example/Vals#xlm. +[35:12..35:13): + -> scala/Int#`+`(+4). +[35:14..35:17): ylm -> example/Vals#ylm(). +[38:7..38:16): ValUsages <- example/ValUsages. +[39:6..39:7): v <- example/ValUsages.v. +[39:9..39:13): Vals -> example/Vals# +[39:16..39:19): ??? -> scala/Predef.`???`(). +[40:2..40:3): v -> example/ValUsages.v. +[40:4..40:6): yp -> example/Vals#`yp_=`(). +[40:9..40:10): v -> example/ValUsages.v. +[40:11..40:13): xp -> example/Vals#xp. +[40:14..40:15): + -> scala/Int#`+`(+4). +[40:16..40:17): v -> example/ValUsages.v. +[40:18..40:20): yp -> example/Vals#yp(). +[41:2..41:3): v -> example/ValUsages.v. +[41:4..41:6): ym -> example/Vals#`ym_=`(). +[41:9..41:10): v -> example/ValUsages.v. +[41:11..41:13): xm -> example/Vals#xm. +[41:14..41:15): + -> scala/Int#`+`(+4). +[41:16..41:17): v -> example/ValUsages.v. +[41:18..41:20): ym -> example/Vals#ym(). +[42:2..42:3): v -> example/ValUsages.v. +[42:4..42:7): yam -> example/Vals#`yam_=`(). +[42:10..42:11): v -> example/ValUsages.v. +[42:12..42:15): xam -> example/Vals#xam. +[42:16..42:17): + -> scala/Int#`+`(+4). +[42:18..42:19): v -> example/ValUsages.v. +[42:20..42:23): yam -> example/Vals#yam(). +[43:2..43:9): println -> scala/Predef.println(+1). +[43:10..43:11): v -> example/ValUsages.v. +[43:12..43:15): xzm -> example/Vals#xzm. +[44:2..44:3): v -> example/ValUsages.v. +[44:4..44:7): yfm -> example/Vals#`yfm_=`(). +[44:10..44:11): v -> example/ValUsages.v. +[44:12..44:15): xfm -> example/Vals#xfm. +[44:16..44:17): + -> scala/Int#`+`(+4). +[44:18..44:19): v -> example/ValUsages.v. +[44:20..44:23): yfm -> example/Vals#yfm(). +[45:2..45:3): v -> example/ValUsages.v. +[45:4..45:7): yim -> example/Vals#`yim_=`(). +[45:10..45:11): v -> example/ValUsages.v. +[45:12..45:15): xim -> example/Vals#xim. +[45:16..45:17): + -> scala/Int#`+`(+4). +[45:18..45:19): v -> example/ValUsages.v. +[45:20..45:23): yim -> example/Vals#yim(). expect/Vararg.scala ___________________ @@ -3151,17 +3151,17 @@ example/Vararg#add2(). => method add2 example/Vararg#add2().(a) => param a Occurrences: -[0:8..0:15) example <- example/ -[2:6..2:12) Vararg <- example/Vararg# -[3:2..3:2) <- example/Vararg#``(). -[3:6..3:10) add1 <- example/Vararg#add1(). -[3:11..3:12) a <- example/Vararg#add1().(a) -[3:14..3:17) Int -> scala/Int# -[4:6..4:10) add2 <- example/Vararg#add2(). -[4:11..4:12) a <- example/Vararg#add2().(a) -[4:14..4:17) Seq -> scala/package.Seq# -[4:18..4:21) Int -> scala/Int# -[4:26..4:30) Unit -> scala/Unit# +[0:8..0:15): example <- example/ +[2:6..2:12): Vararg <- example/Vararg# +[3:2..3:2): <- example/Vararg#``(). +[3:6..3:10): add1 <- example/Vararg#add1(). +[3:11..3:12): a <- example/Vararg#add1().(a) +[3:14..3:17): Int -> scala/Int# +[4:6..4:10): add2 <- example/Vararg#add2(). +[4:11..4:12): a <- example/Vararg#add2().(a) +[4:14..4:17): Seq -> scala/package.Seq# +[4:18..4:21): Int -> scala/Int# +[4:26..4:30): Unit -> scala/Unit# expect/filename with spaces.scala _________________________________ @@ -3179,9 +3179,9 @@ example/FilenameWithSpaces# => class FilenameWithSpaces example/FilenameWithSpaces#``(). => primary ctor Occurrences: -[0:8..0:15) example <- example/ -[2:0..2:0) <- example/FilenameWithSpaces#``(). -[2:6..2:24) FilenameWithSpaces <- example/FilenameWithSpaces# +[0:8..0:15): example <- example/ +[2:0..2:0): <- example/FilenameWithSpaces#``(). +[2:6..2:24): FilenameWithSpaces <- example/FilenameWithSpaces# expect/local-file.scala _______________________ @@ -3200,13 +3200,13 @@ example/`local-file`#``(). => primary ctor local0 => val local local Occurrences: -[0:8..0:15) example <- example/ -[2:7..2:17) local-file <- example/`local-file`# -[3:2..3:2) <- example/`local-file`#``(). -[3:2..3:9) locally -> dotty/DottyPredef.locally(). -[4:8..4:13) local <- local0 -[5:4..5:9) local -> local0 -[5:10..5:11) + -> scala/Int#`+`(+4). +[0:8..0:15): example <- example/ +[2:7..2:17): local-file <- example/`local-file`# +[3:2..3:2): <- example/`local-file`#``(). +[3:2..3:9): locally -> dotty/DottyPredef.locally(). +[4:8..4:13): local <- local0 +[5:4..5:9): local -> local0 +[5:10..5:11): + -> scala/Int#`+`(+4). expect/semanticdb-extract.scala _______________________________ @@ -3230,28 +3230,28 @@ _empty_/AnObject.foo().(x) => param x _empty_/AnObject.foo(+1). => method foo Occurrences: -[0:7..0:15) AnObject <- _empty_/AnObject. -[2:6..2:9) foo <- _empty_/AnObject.foo(). -[2:10..2:11) x <- _empty_/AnObject.foo().(x) -[2:13..2:16) Int -> scala/Int# -[3:6..3:9) foo <- _empty_/AnObject.foo(+1). -[3:13..3:17) Unit -> scala/Unit# -[5:2..5:5) foo -> _empty_/AnObject.foo(). -[6:2..6:5) foo -> _empty_/AnObject.foo(+1). -[8:5..8:14) substring -> java/lang/String#substring(). -[9:5..9:14) substring -> java/lang/String#substring(+1). -[11:2..11:6) List -> scala/package.List. -[11:6..11:6) -> scala/collection/IterableFactory#apply(). -[12:2..12:6) List -> scala/package.List. -[12:7..12:12) apply -> scala/collection/IterableFactory#apply(). -[13:2..13:6) List -> scala/package.List. -[13:7..13:14) `apply` -> scala/collection/IterableFactory#apply(). -[14:2..14:9) println -> scala/Predef.println(+1). -[14:12..14:13) + -> scala/Int#`+`(+4). -[16:13..16:16) Foo <- _empty_/AnObject.Foo# -[16:16..16:24) <- _empty_/AnObject.Foo#``(). -[16:17..16:18) x <- _empty_/AnObject.Foo#x. -[16:20..16:23) Int -> scala/Int# +[0:7..0:15): AnObject <- _empty_/AnObject. +[2:6..2:9): foo <- _empty_/AnObject.foo(). +[2:10..2:11): x <- _empty_/AnObject.foo().(x) +[2:13..2:16): Int -> scala/Int# +[3:6..3:9): foo <- _empty_/AnObject.foo(+1). +[3:13..3:17): Unit -> scala/Unit# +[5:2..5:5): foo -> _empty_/AnObject.foo(). +[6:2..6:5): foo -> _empty_/AnObject.foo(+1). +[8:5..8:14): substring -> java/lang/String#substring(). +[9:5..9:14): substring -> java/lang/String#substring(+1). +[11:2..11:6): List -> scala/package.List. +[11:6..11:6): -> scala/collection/IterableFactory#apply(). +[12:2..12:6): List -> scala/package.List. +[12:7..12:12): apply -> scala/collection/IterableFactory#apply(). +[13:2..13:6): List -> scala/package.List. +[13:7..13:14): `apply` -> scala/collection/IterableFactory#apply(). +[14:2..14:9): println -> scala/Predef.println(+1). +[14:12..14:13): + -> scala/Int#`+`(+4). +[16:13..16:16): Foo <- _empty_/AnObject.Foo# +[16:16..16:24): <- _empty_/AnObject.Foo#``(). +[16:17..16:18): x <- _empty_/AnObject.Foo#x. +[16:20..16:23): Int -> scala/Int# expect/toplevel.scala _____________________ @@ -3278,28 +3278,27 @@ _empty_/toplevel$package.combine(+2). => method combine _empty_/toplevel$package.foo(). => method foo Occurrences: -[0:0..0:16) inline val a = " <- _empty_/toplevel$package. -[0:11..0:12) a <- _empty_/toplevel$package.a. -[1:4..1:11) (x: Int <- _empty_/toplevel$package.combine(). -[1:5..1:6) x <- _empty_/toplevel$package.combine().(x) -[1:8..1:11) Int -> scala/Int# -[1:22..1:23) y <- _empty_/toplevel$package.combine().(y) -[1:25..1:28) Int -> scala/Int# -[1:32..1:33) x -> _empty_/toplevel$package.combine().(x) -[1:34..1:35) + -> scala/Int#`+`(+4). -[1:36..1:37) y -> _empty_/toplevel$package.combine().(y) -[2:4..2:11) combine <- _empty_/toplevel$package.combine(+1). -[2:12..2:13) x <- _empty_/toplevel$package.combine(+1).(x) -[2:15..2:18) Int -> scala/Int# -[2:20..2:21) y <- _empty_/toplevel$package.combine(+1).(y) -[2:23..2:26) Int -> scala/Int# -[2:28..2:29) z <- _empty_/toplevel$package.combine(+1).(z) -[2:31..2:34) Int -> scala/Int# -[2:38..2:39) x -> _empty_/toplevel$package.combine(+1).(x) -[2:40..2:41) + -> scala/Int#`+`(+4). -[2:42..2:43) y -> _empty_/toplevel$package.combine(+1).(y) -[2:44..2:45) + -> scala/Int#`+`(+4). -[2:46..2:47) z -> _empty_/toplevel$package.combine(+1).(z) -[3:4..3:11) combine <- _empty_/toplevel$package.combine(+2). -[4:4..4:7) foo <- _empty_/toplevel$package.foo(). - +[0:0..0:16): inline val a = " <- _empty_/toplevel$package. +[0:11..0:12): a <- _empty_/toplevel$package.a. +[1:4..1:11): (x: Int <- _empty_/toplevel$package.combine(). +[1:5..1:6): x <- _empty_/toplevel$package.combine().(x) +[1:8..1:11): Int -> scala/Int# +[1:22..1:23): y <- _empty_/toplevel$package.combine().(y) +[1:25..1:28): Int -> scala/Int# +[1:32..1:33): x -> _empty_/toplevel$package.combine().(x) +[1:34..1:35): + -> scala/Int#`+`(+4). +[1:36..1:37): y -> _empty_/toplevel$package.combine().(y) +[2:4..2:11): combine <- _empty_/toplevel$package.combine(+1). +[2:12..2:13): x <- _empty_/toplevel$package.combine(+1).(x) +[2:15..2:18): Int -> scala/Int# +[2:20..2:21): y <- _empty_/toplevel$package.combine(+1).(y) +[2:23..2:26): Int -> scala/Int# +[2:28..2:29): z <- _empty_/toplevel$package.combine(+1).(z) +[2:31..2:34): Int -> scala/Int# +[2:38..2:39): x -> _empty_/toplevel$package.combine(+1).(x) +[2:40..2:41): + -> scala/Int#`+`(+4). +[2:42..2:43): y -> _empty_/toplevel$package.combine(+1).(y) +[2:44..2:45): + -> scala/Int#`+`(+4). +[2:46..2:47): z -> _empty_/toplevel$package.combine(+1).(z) +[3:4..3:11): combine <- _empty_/toplevel$package.combine(+2). +[4:4..4:7): foo <- _empty_/toplevel$package.foo(). From 22707e327b4216507a7ffd076fe156df946834d8 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Mon, 18 Nov 2019 01:28:09 +0100 Subject: [PATCH 079/107] only traverse self tpt if it has span --- .../dotc/semanticdb/ExtractSemanticDB.scala | 3 +++ tests/semanticdb/expect/Example.expect.scala | 2 +- tests/semanticdb/metac.expect | 4 ++-- tests/semanticdb/todo.md | 24 +++++-------------- 4 files changed, 12 insertions(+), 21 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index a0335fe87d65..f5a872bd965a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -405,6 +405,9 @@ class ExtractSemanticDB extends Phase with case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause template.parents.foreach(traverse) case _ => // calls $new + case tree: ValDef if tree.symbol.isSelfSym => + if tree.tpt.span.hasLength + traverse(tree.tpt) case tree: DefDef if tree.symbol.isConstructor => // ignore typeparams for secondary ctors tree.vparamss.foreach(_.foreach(traverse)) traverse(tree.rhs) diff --git a/tests/semanticdb/expect/Example.expect.scala b/tests/semanticdb/expect/Example.expect.scala index 6be705f334a7..aaf344f54a15 100644 --- a/tests/semanticdb/expect/Example.expect.scala +++ b/tests/semanticdb/expect/Example.expect.scala @@ -2,7 +2,7 @@ package example import scala.concurrent.Future/*->scala::concurrent::Future.*//*->scala::concurrent::Future#*/ -object Example/*<-example::Example.*/ { self/*<-local0*//*->example::Example.*/ => +object Example/*<-example::Example.*/ { self/*<-local0*/ => new scala.collection.mutable.Stack/*->scala::collection::mutable::Stack#*/[Int/*->scala::Int#*/]/*->scala::collection::mutable::Stack#``(+1).*/() def main/*<-example::Example.main().*/(args/*<-example::Example.main().(args)*/: Array/*->scala::Array#*/[String/*->scala::Predef.String#*/]): Unit/*->scala::Unit#*/ = { println/*->scala::Predef.println(+1).*/(1) diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index fc5e31cafd77..5f7c53dd1dc3 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -858,7 +858,7 @@ Uri => Example.scala Text => empty Language => Scala Symbols => 5 entries -Occurrences => 27 entries +Occurrences => 26 entries Symbols: example/Example. => final object Example @@ -875,7 +875,6 @@ Occurrences: [2:24..2:30): Future -> scala/concurrent/Future# [4:7..4:14): Example <- example/Example. [4:17..4:21): self <- local0 -[4:17..4:17): -> example/Example. [5:6..5:11): scala -> scala/ [5:12..5:22): collection -> scala/collection/ [5:23..5:30): mutable -> scala/collection/mutable/ @@ -3302,3 +3301,4 @@ 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(). + diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md index 06a93e70c738..480e14b50bef 100644 --- a/tests/semanticdb/todo.md +++ b/tests/semanticdb/todo.md @@ -1,19 +1,7 @@ -## BlackBox Todo list -This todolist is based upon blackbox observation of testcases at this repository: https://github.com/scalameta/scalameta/tree/master/tests/jvm/src/test/resources/example +## Todo List +Differences between scalameta implementation and dotc. -- [ ] Hide unapply, unapplySeq? -- [ ] Hide local vars in pattern def? -- [ ] Hide desugaring of for comprehension -- [ ] Hide calls to implicit conversions and their arguments -- [ ] Hide Tuple contructors -- [ ] Hide implicitly applied arguments -- [ ] `macro ???` is already rewritten to `???` so can't add macro kind. -- [x] Assignments to vars should emit uses of the setter method and not the getter -- [x] Hide constructor of module template // expect tests hide primary ctors -- [x] unescape unicode in names. -- [x] Only traverse prefix of a Select if it is not a package -- [x] Ensure only methods are counted in overloads -- [x] Import wildcard needs to have reference to the qualifier -- [-] ~~Hide `scala.Predef` prefix~~ // same effect acheved by ensuring prefix has a range > 0 -- [-] ~~Hide `scala.StringContext`~~ // same effect acheved by ensuring prefix has a range > 0 -- [-] ~~Hide `Predef.classOf`~~ // won't fix - confirmed as a bug in scalameta +- [ ] For comprehension in Synthetic section. +- [ ] Implicit conversions in Synthetic section. +- [ ] Record all definitions in Symbols section. +- [ ] give definitions in Anonymous functions occurrences From 18d003b115825f2b06f83798b5816d552d9a2c0b Mon Sep 17 00:00:00 2001 From: bishabosha Date: Mon, 18 Nov 2019 02:11:36 +0100 Subject: [PATCH 080/107] params of anonymous funs are emitted --- .../dotc/semanticdb/ExtractSemanticDB.scala | 2 +- tests/semanticdb/expect/Classes.expect.scala | 6 +- .../expect/ForComprehension.expect.scala | 28 ++--- .../semanticdb/expect/Synthetic.expect.scala | 20 ++-- tests/semanticdb/metac.expect | 102 +++++++++++++----- tests/semanticdb/todo.md | 1 - 6 files changed, 103 insertions(+), 56 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index f5a872bd965a..fc33a9d3a209 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -163,7 +163,7 @@ class ExtractSemanticDB extends Phase with !sym.exists || sym.isLocalDummy || sym.is(Synthetic) - || sym.owner.is(Synthetic) && !sym.isAllOf(EnumCase) + || sym.owner.is(Synthetic) && !sym.owner.isAnonymous && !sym.isAllOf(EnumCase) || sym.isConstructor && sym.owner.is(ModuleClass) || sym.isAnonymous || excludeDefStrict(sym) diff --git a/tests/semanticdb/expect/Classes.expect.scala b/tests/semanticdb/expect/Classes.expect.scala index a585fc53bb1b..c7418107c372 100644 --- a/tests/semanticdb/expect/Classes.expect.scala +++ b/tests/semanticdb/expect/Classes.expect.scala @@ -26,8 +26,8 @@ object N/*<-classes::N.*/ { val anonClass/*<-classes::N.anonClass.*/ = new C7/*->classes::C7#*/(42) { val local/*<-local1*/ = ???/*->scala::Predef.`???`().*/ } - val anonFun/*<-classes::N.anonFun.*/ = List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).map/*->scala::collection::immutable::List#map().*/ { i => - val local = 2 - local/*->local2*/ +/*->scala::Int#`+`(+4).*/ 2 + val anonFun/*<-classes::N.anonFun.*/ = List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).map/*->scala::collection::immutable::List#map().*/ { i/*<-local2*/ => + val local/*<-local3*/ = 2 + local/*->local3*/ +/*->scala::Int#`+`(+4).*/ 2 } } diff --git a/tests/semanticdb/expect/ForComprehension.expect.scala b/tests/semanticdb/expect/ForComprehension.expect.scala index e32db27c16bd..64a64f12f045 100644 --- a/tests/semanticdb/expect/ForComprehension.expect.scala +++ b/tests/semanticdb/expect/ForComprehension.expect.scala @@ -2,21 +2,21 @@ package example class ForComprehension/*<-example::ForComprehension#*/ { for { - a <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ - b/*->local0*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::IterableOps#withFilter().*/ - if b/*->local0*/ >/*->scala::Int#`>`(+3).*/ 1/*->scala::collection::WithFilter#map().*/ - c/*->local2*/ = a/*->local1*/ +/*->scala::Int#`+`(+4).*/ b/*->local0*//*->scala::collection::immutable::List#map().*/ - } yield (a/*->local1*/, b/*->local0*/, c/*->local2*/) + a/*<-local0*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ + b/*<-local1*//*->local1*/ <- 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 (a/*->local0*/, b/*->local1*/, c/*->local2*/) for { - a <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ - b <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(a/*->local3*/)/*->scala::collection::IterableOps#withFilter().*/ + a/*<-local3*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ + b/*<-local4*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(a/*->local3*/)/*->scala::collection::IterableOps#withFilter().*/ if ( a/*->local3*/, b/*->local4*/ ) ==/*->scala::Any#`==`().*/ (1, 2)/*->scala::collection::WithFilter#flatMap().*/ ( - c, - d + /*<-local7*/ c/*<-local5*/, + d/*<-local6*/ ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((a/*->local3*/, b/*->local4*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/ if ( a/*->local3*/, @@ -24,22 +24,22 @@ class ForComprehension/*<-example::ForComprehension#*/ { c/*->local5*/, d/*->local6*/ ) ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#map().*/ - e/*->local7*/ = ( + e/*<-local8*//*->local7*//*->local8*/ = ( a/*->local3*/, b/*->local4*/, c/*->local5*/, d/*->local6*/ )/*->scala::collection::IterableOps#withFilter().*/ - if e/*->local7*/ ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/ - f <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(e/*->local7*/)/*->scala::collection::immutable::List#map().*/ + if e/*->local8*/ ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/ + f/*<-local9*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(e/*->local8*/)/*->scala::collection::immutable::List#map().*/ } yield { ( a/*->local3*/, b/*->local4*/, c/*->local5*/, d/*->local6*/, - e/*->local7*/, - f/*->local8*/ + e/*->local8*/, + f/*->local9*/ ) } } diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala index c03c5d29a8fe..4f404e8e7567 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -15,9 +15,9 @@ class Synthetic/*<-example::Synthetic#*/ { val lst/*<-example::Synthetic#lst.*/ = 1 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/2 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*//*->scala::collection::immutable::LazyList.Deferrer#`#::`().*/ - for (x <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(x/*->local1*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local1*/) - for (i <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (i/*->local2*/, j/*->local3*/) - for (i <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j <- /*->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 (i/*->local4*/, j/*->local5*/) + for (x/*<-local1*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y/*<-local2*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(x/*->local1*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local1*/) + for (i/*<-local3*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local4*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (i/*->local3*/, j/*->local4*/) + for (i/*<-local5*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local6*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::IterableOps#withFilter().*/ if i/*->local5*/ %/*->scala::Int#`%`(+3).*/ 2 ==/*->scala::Int#`==`(+3).*/ 0/*->scala::collection::WithFilter#map().*/) yield (i/*->local5*/, j/*->local6*/) object s/*<-example::Synthetic#s.*/ { def apply/*<-example::Synthetic#s.apply().*/() = 2 @@ -36,13 +36,13 @@ class Synthetic/*<-example::Synthetic#*/ { import scala.concurrent.ExecutionContext/*->scala::concurrent::ExecutionContext.*/.Implicits/*->scala::concurrent::ExecutionContext.Implicits.*/.global/*->scala::concurrent::ExecutionContext.Implicits.global().*/ for { - a <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#foreach().*/ - b <- 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/*<-local7*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#foreach().*/ + b/*<-local8*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#foreach().*/ + } println/*->scala::Predef.println(+1).*/(a/*->local7*/)/*->scala::concurrent::ExecutionContext.Implicits.global().*/ for { - a <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#flatMap().*/ - b <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#withFilter().*/ - if a/*->local7*/ scala::Int#`<`(+3).*/ b/*->local8*//*->scala::concurrent::Future#map().*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ - } yield a/*->local7*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ + a/*<-local9*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#flatMap().*/ + b/*<-local10*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#withFilter().*/ + if a/*->local9*/ scala::Int#`<`(+3).*/ b/*->local10*//*->scala::concurrent::Future#map().*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ + } yield a/*->local9*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ } diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 5f7c53dd1dc3..cf107d217426 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -344,8 +344,8 @@ Schema => SemanticDB v4 Uri => Classes.scala Text => empty Language => Scala -Symbols => 44 entries -Occurrences => 58 entries +Symbols => 46 entries +Occurrences => 60 entries Symbols: classes/C1# => final class C1 @@ -392,6 +392,8 @@ classes/N.anonClass. => val method anonClass classes/N.anonFun. => val method anonFun local0 => primary ctor local1 => val method local +local2 => param i +local3 => local local Occurrences: [0:8..0:15): classes <- classes/ @@ -450,7 +452,9 @@ Occurrences: [28:16..28:20): List -> scala/package.List. [28:20..28:20): -> scala/collection/IterableFactory#apply(). [28:24..28:27): map -> scala/collection/immutable/List#map(). -[30:4..30:9): local -> local2 +[28:30..28:31): i <- local2 +[29:8..29:13): local <- local3 +[30:4..30:9): local -> local3 [30:10..30:11): + -> scala/Int#`+`(+4). expect/Definitions.scala @@ -1054,38 +1058,56 @@ Schema => SemanticDB v4 Uri => ForComprehension.scala Text => empty Language => Scala -Symbols => 2 entries -Occurrences => 63 entries +Symbols => 15 entries +Occurrences => 74 entries Symbols: example/ForComprehension# => class ForComprehension example/ForComprehension#``(). => primary ctor +local0 => param a +local1 => val local b +local1 => param b +local2 => local c +local2 => val local c +local3 => param a +local4 => param b +local5 => val local c +local6 => val local d +local7 => val local $1$ +local8 => val local e +local8 => local e +local9 => param f Occurrences: [0:8..0:15): example <- example/ [2:6..2:22): ForComprehension <- example/ForComprehension# [3:2..3:2): <- example/ForComprehension#``(). +[4:4..4:5): a <- local0 [4:9..4:13): List -> scala/package.List. [4:13..4:13): -> scala/collection/IterableFactory#apply(). [4:16..4:16): -> scala/collection/immutable/List#flatMap(). -[5:4..5:5): b -> local0 +[5:4..5:5): b <- local1 +[5:4..5:5): b -> local1 [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 -> local0 +[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 -> local1 +[7:8..7:9): a -> local0 [7:10..7:11): + -> scala/Int#`+`(+4). -[7:12..7:13): b -> local0 +[7:12..7:13): b -> local1 [7:13..7:13): -> scala/collection/immutable/List#map(). -[8:11..8:12): a -> local1 -[8:14..8:15): b -> local0 +[8:11..8:12): a -> local0 +[8:14..8:15): b -> local1 [8:17..8:18): c -> local2 +[10:4..10:5): a <- local3 [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 <- local4 [11:9..11:13): List -> scala/package.List. [11:13..11:13): -> scala/collection/IterableFactory#apply(). [11:14..11:15): a -> local3 @@ -1094,6 +1116,9 @@ Occurrences: [14:6..14:7): b -> local4 [15:6..15:8): == -> scala/Any#`==`(). [15:15..15:15): -> scala/collection/WithFilter#flatMap(). +[16:4..17:1): <- local7 +[17:6..17:7): c <- local5 +[18:6..18:7): d <- local6 [19:9..19:13): List -> scala/package.List. [19:13..19:13): -> scala/collection/IterableFactory#apply(). [19:15..19:16): a -> local3 @@ -1106,25 +1131,28 @@ Occurrences: [24:6..24:7): d -> local6 [25:6..25:8): == -> scala/Any#`==`(). [25:21..25:21): -> scala/collection/WithFilter#map(). -[26:4..26:5): e -> local7 +[26:4..26:5): e <- local8 +[26:4..26:4): -> local7 +[26:4..26:5): e -> local8 [27:6..27:7): a -> local3 [28:6..28:7): b -> local4 [29:6..29:7): c -> local5 [30:6..30:7): d -> local6 [31:5..31:5): -> scala/collection/IterableOps#withFilter(). -[32:7..32:8): e -> local7 +[32:7..32:8): e -> local8 [32:9..32:11): == -> scala/Any#`==`(). [32:24..32:24): -> scala/collection/WithFilter#flatMap(). +[33:4..33:5): f <- local9 [33:9..33:13): List -> scala/package.List. [33:13..33:13): -> scala/collection/IterableFactory#apply(). -[33:14..33:15): e -> local7 +[33:14..33:15): e -> local8 [33:16..33:16): -> scala/collection/immutable/List#map(). [36:6..36:7): a -> local3 [37:6..37:7): b -> local4 [38:6..38:7): c -> local5 [39:6..39:7): d -> local6 -[40:6..40:7): e -> local7 -[41:6..41:7): f -> local8 +[40:6..40:7): e -> local8 +[41:6..41:7): f -> local9 expect/Givens.scala ___________________ @@ -2266,8 +2294,8 @@ Schema => SemanticDB v4 Uri => Synthetic.scala Text => empty Language => Scala -Symbols => 22 entries -Occurrences => 142 entries +Symbols => 32 entries +Occurrences => 152 entries Symbols: example/Synthetic# => class Synthetic @@ -2292,6 +2320,16 @@ example/Synthetic#s.apply(). => method apply example/Synthetic#x. => val method x example/Synthetic#xs. => val method xs local0 => val local name +local1 => param x +local2 => param y +local3 => param i +local4 => param j +local5 => param i +local6 => param j +local7 => param a +local8 => param b +local9 => param a +local10 => param b Occurrences: [0:8..0:15): example <- example/ @@ -2336,9 +2374,11 @@ Occurrences: [15:24..15:32): LazyList -> scala/package.LazyList. [15:33..15:38): empty -> scala/collection/immutable/LazyList.empty(). [15:38..15:38): -> scala/collection/immutable/LazyList.Deferrer#`#::`(). +[17:7..17:8): x <- local1 [17:12..17:12): -> scala/LowPriorityImplicits#intWrapper(). [17:14..17:16): to -> scala/runtime/RichInt#to(). [17:19..17:19): -> scala/collection/immutable/Range#foreach(). +[17:21..17:22): y <- local2 [17:26..17:26): -> scala/LowPriorityImplicits#intWrapper(). [17:28..17:33): until -> scala/runtime/RichInt#until(). [17:36..17:36): -> scala/collection/immutable/Range#foreach(). @@ -2346,26 +2386,30 @@ Occurrences: [17:46..17:47): x -> local1 [17:48..17:50): -> -> scala/Predef.ArrowAssoc#`->`(). [17:51..17:52): x -> local1 +[18:7..18:8): i <- local3 [18:12..18:12): -> scala/LowPriorityImplicits#intWrapper(). [18:14..18:16): to -> scala/runtime/RichInt#to(). [18:19..18:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[18:21..18:22): j <- local4 [18:26..18:26): -> scala/LowPriorityImplicits#intWrapper(). [18:28..18:33): until -> scala/runtime/RichInt#until(). [18:36..18:36): -> scala/collection/immutable/Range#map(). -[18:45..18:46): i -> local2 -[18:48..18:49): j -> local3 +[18:45..18:46): i -> local3 +[18:48..18:49): j -> local4 +[19:7..19:8): i <- local5 [19:12..19:12): -> scala/LowPriorityImplicits#intWrapper(). [19:14..19:16): to -> scala/runtime/RichInt#to(). [19:19..19:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[19:21..19:22): j <- local6 [19:26..19:26): -> scala/LowPriorityImplicits#intWrapper(). [19:28..19:33): until -> scala/runtime/RichInt#until(). [19:36..19:36): -> scala/collection/IterableOps#withFilter(). -[19:40..19:41): i -> local4 +[19:40..19:41): i -> local5 [19:42..19:43): % -> scala/Int#`%`(+3). [19:46..19:48): == -> scala/Int#`==`(+3). [19:50..19:50): -> scala/collection/WithFilter#map(). -[19:59..19:60): i -> local4 -[19:62..19:63): j -> local5 +[19:59..19:60): i -> local5 +[19:62..19:63): j -> local6 [21:9..21:10): s <- example/Synthetic#s. [22:8..22:13): apply <- example/Synthetic#s.apply(). [23:5..23:5): -> example/Synthetic#s.apply(). @@ -2406,35 +2450,39 @@ Occurrences: [36:26..36:42): ExecutionContext -> scala/concurrent/ExecutionContext. [36:43..36:52): Implicits -> scala/concurrent/ExecutionContext.Implicits. [36:53..36:59): global -> scala/concurrent/ExecutionContext.Implicits.global(). +[38:4..38:5): a <- local7 [38:9..38:14): scala -> scala/ [38:15..38:25): concurrent -> scala/concurrent/ [38:26..38:32): Future -> scala/concurrent/Future. [38:33..38:43): successful -> scala/concurrent/Future.successful(). [38:46..38:46): -> scala/concurrent/Future#foreach(). +[39:4..39:5): b <- local8 [39:9..39:14): scala -> scala/ [39:15..39:25): concurrent -> scala/concurrent/ [39:26..39:32): Future -> scala/concurrent/Future. [39:33..39:43): successful -> scala/concurrent/Future.successful(). [39:46..39:46): -> scala/concurrent/Future#foreach(). [40:4..40:11): println -> scala/Predef.println(+1). -[40:12..40:13): a -> local6 +[40:12..40:13): a -> local7 [40:14..40:14): -> scala/concurrent/ExecutionContext.Implicits.global(). +[42:4..42:5): a <- local9 [42:9..42:14): scala -> scala/ [42:15..42:25): concurrent -> scala/concurrent/ [42:26..42:32): Future -> scala/concurrent/Future. [42:33..42:43): successful -> scala/concurrent/Future.successful(). [42:46..42:46): -> scala/concurrent/Future#flatMap(). +[43:4..43:5): b <- local10 [43:9..43:14): scala -> scala/ [43:15..43:25): concurrent -> scala/concurrent/ [43:26..43:32): Future -> scala/concurrent/Future. [43:33..43:43): successful -> scala/concurrent/Future.successful(). [43:46..43:46): -> scala/concurrent/Future#withFilter(). -[44:7..44:8): a -> local7 +[44:7..44:8): a -> local9 [44:9..44:10): < -> scala/Int#`<`(+3). -[44:11..44:12): b -> local8 +[44:11..44:12): b -> local10 [44:12..44:12): -> scala/concurrent/Future#map(). [44:12..44:12): -> scala/concurrent/ExecutionContext.Implicits.global(). -[45:10..45:11): a -> local7 +[45:10..45:11): a -> local9 [45:11..45:11): -> scala/concurrent/ExecutionContext.Implicits.global(). expect/Traits.scala diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md index 480e14b50bef..1aef287ec5a3 100644 --- a/tests/semanticdb/todo.md +++ b/tests/semanticdb/todo.md @@ -4,4 +4,3 @@ Differences between scalameta implementation and dotc. - [ ] For comprehension in Synthetic section. - [ ] Implicit conversions in Synthetic section. - [ ] Record all definitions in Symbols section. -- [ ] give definitions in Anonymous functions occurrences From 83ae6da99d9167e1200fba6dfe5113f4bc7983a7 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Mon, 18 Nov 2019 17:11:41 +0100 Subject: [PATCH 081/107] more symbols in symbol section --- .../dotc/semanticdb/ExtractSemanticDB.scala | 40 ++- .../expect/ForComprehension.expect.scala | 48 ++-- tests/semanticdb/expect/Methods.expect.scala | 2 +- .../semanticdb/expect/Synthetic.expect.scala | 2 +- tests/semanticdb/metac.expect | 236 +++++++++++++----- 5 files changed, 227 insertions(+), 101 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index fc33a9d3a209..45fa4e11725d 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -165,12 +165,24 @@ class ExtractSemanticDB extends Phase with || sym.is(Synthetic) || sym.owner.is(Synthetic) && !sym.owner.isAnonymous && !sym.isAllOf(EnumCase) || sym.isConstructor && sym.owner.is(ModuleClass) - || sym.isAnonymous || excludeDefStrict(sym) private def excludeDefStrict(sym: Symbol)(given Context): Boolean = sym.name.is(NameKinds.DefaultGetterName) - || sym.name.isWildcard + || excludeSymbolStrict(sym) + + private inline def (name: Name) isEmptyNumbered: Boolean = name match + case NameKinds.AnyNumberedName(nme.EMPTY, _) => true + case _ => false + + private def excludeSymbolStrict(sym: Symbol)(given Context): Boolean = + sym.name.isWildcard + || sym.isAnonymous + || sym.name.isEmptyNumbered + + private def excludeChildren(sym: Symbol)(given Context): Boolean = + sym.isAllOf(HigherKinded | Param) + || !sym.isAnonymous && sym.is(Synthetic, butNot=Module) /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = @@ -359,7 +371,7 @@ class ExtractSemanticDB extends Phase with vparams <- vparamss vparam <- vparams do - if !vparam.name.isWildcard + if !excludeSymbolStrict(vparam.symbol) val symkinds = getters.get(vparam.name).fold(SymbolKind.emptySet)(getter => if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet) @@ -392,13 +404,16 @@ class ExtractSemanticDB extends Phase with traverse(qual) case tree => registerDefinition(tree.symbol, tree.span, Set.empty) tree.stats.foreach(traverse) - case tree: ValDef if tree.symbol.is(Module) => // skip module val - case tree: NamedDefTree - if !excludeDef(tree.symbol) && tree.span.hasLength => - registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree)) - val privateWithin = tree.symbol.privateWithin - if privateWithin.exists - registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) + case tree: NamedDefTree => + if tree.symbol.isAllOf(ModuleValCreationFlags) + return + if !excludeDef(tree.symbol) && tree.span.hasLength + registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree)) + val privateWithin = tree.symbol.privateWithin + if privateWithin.exists + registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) + else if !excludeSymbolStrict(tree.symbol) + registerSymbol(tree.symbol, symbolName(tree.symbol), symbolKinds(tree)) tree match case tree: ValDef if tree.symbol.isAllOf(EnumValue) => tree.rhs match @@ -411,8 +426,9 @@ class ExtractSemanticDB extends Phase with case tree: DefDef if tree.symbol.isConstructor => // ignore typeparams for secondary ctors tree.vparamss.foreach(_.foreach(traverse)) traverse(tree.rhs) - case _ => traverseChildren(tree) - case tree: (ValDef|DefDef|TypeDef) if tree.symbol.is(Synthetic, butNot=Module) && !tree.symbol.isAnonymous => // skip + case tree => + if !excludeChildren(tree.symbol) + traverseChildren(tree) case tree: Template => val ctorSym = tree.constr.symbol if !excludeDef(ctorSym) diff --git a/tests/semanticdb/expect/ForComprehension.expect.scala b/tests/semanticdb/expect/ForComprehension.expect.scala index 64a64f12f045..f2e2dca08a3e 100644 --- a/tests/semanticdb/expect/ForComprehension.expect.scala +++ b/tests/semanticdb/expect/ForComprehension.expect.scala @@ -8,38 +8,38 @@ class ForComprehension/*<-example::ForComprehension#*/ { c/*<-local2*//*->local2*/ = a/*->local0*/ +/*->scala::Int#`+`(+4).*/ b/*->local1*//*->scala::collection::immutable::List#map().*/ } yield (a/*->local0*/, b/*->local1*/, c/*->local2*/) for { - a/*<-local3*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ - b/*<-local4*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(a/*->local3*/)/*->scala::collection::IterableOps#withFilter().*/ + a/*<-local4*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ + b/*<-local5*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(a/*->local4*/)/*->scala::collection::IterableOps#withFilter().*/ if ( - a/*->local3*/, - b/*->local4*/ + a/*->local4*/, + b/*->local5*/ ) ==/*->scala::Any#`==`().*/ (1, 2)/*->scala::collection::WithFilter#flatMap().*/ ( - /*<-local7*/ c/*<-local5*/, - d/*<-local6*/ - ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((a/*->local3*/, b/*->local4*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/ + c/*<-local7*/, + d/*<-local8*/ + ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((a/*->local4*/, b/*->local5*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/ if ( - a/*->local3*/, - b/*->local4*/, - c/*->local5*/, - d/*->local6*/ + a/*->local4*/, + b/*->local5*/, + c/*->local7*/, + d/*->local8*/ ) ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#map().*/ - e/*<-local8*//*->local7*//*->local8*/ = ( - a/*->local3*/, - b/*->local4*/, - c/*->local5*/, - d/*->local6*/ + e/*<-local9*//*->local9*/ = ( + a/*->local4*/, + b/*->local5*/, + c/*->local7*/, + d/*->local8*/ )/*->scala::collection::IterableOps#withFilter().*/ - if e/*->local8*/ ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/ - f/*<-local9*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(e/*->local8*/)/*->scala::collection::immutable::List#map().*/ + if e/*->local9*/ ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/ + f/*<-local10*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(e/*->local9*/)/*->scala::collection::immutable::List#map().*/ } yield { ( - a/*->local3*/, - b/*->local4*/, - c/*->local5*/, - d/*->local6*/, - e/*->local8*/, - f/*->local9*/ + a/*->local4*/, + b/*->local5*/, + c/*->local7*/, + d/*->local8*/, + e/*->local9*/, + f/*->local10*/ ) } } diff --git a/tests/semanticdb/expect/Methods.expect.scala b/tests/semanticdb/expect/Methods.expect.scala index 29c2a063c3aa..c07f9680f7b4 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]*//*<-example::Methods#m7().(evidence$1)*/: 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]*/: Ordering/*->scala::math::Ordering#*//*->example::Methods#m7().[U]*/](c/*<-example::Methods#m7().(c)*/: Methods/*->example::Methods#*/[T/*->example::Methods#[T]*/], l/*<-example::Methods#m7().(l)*/: List/*->example::Methods#List#*/[U/*->example::Methods#m7().[U]*/]) = ???/*->scala::Predef.`???`().*/ def `m8().`() =/*<-example::Methods#`m8().`().*/ ???/*->scala::Predef.`???`().*/ class `m9().` d/*<-example::Methods#`m9().`#*/ef m9/*<-example::Methods#m9().*/(x/*<-example::Methods#m9().(x)*/: `m9().`/*->example::Methods#`m9().`#*/) = ???/*->scala::Predef.`???`().*/ diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala index 4f404e8e7567..836d9dbf8147 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -28,7 +28,7 @@ class Synthetic/*<-example::Synthetic#*/ { null.asInstanceOf/*->scala::Any#asInstanceOf().*/[Int/*->scala::Int#*/ => Int/*->scala::Int#*/]/*->scala::Function1#apply().*/(2) } - class J/*<-example::Synthetic#J#*/[T/*<-example::Synthetic#J#[T]*//*<-example::Synthetic#J#evidence$2.*/: 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]*/]/*->example::Synthetic#J#evidence$2.*/ } + class J/*<-example::Synthetic#J#*/[T/*<-example::Synthetic#J#[T]*/: Manifest/*->scala::Predef.Manifest#*//*->example::Synthetic#J#[T]*/] { val arr/*<-example::Synthetic#J#arr.*/ = Array/*->scala::Array.*/.empty/*->scala::Array.empty().*/[T/*->example::Synthetic#J#[T]*/] } class F/*<-example::Synthetic#F#*/ implicit val ordering/*<-example::Synthetic#ordering.*/: Ordering/*->scala::package.Ordering#*/[F/*->example::Synthetic#F#*/] = ???/*->scala::Predef.`???`().*/ diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index cf107d217426..677f795fbcfc 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -344,7 +344,7 @@ Schema => SemanticDB v4 Uri => Classes.scala Text => empty Language => Scala -Symbols => 46 entries +Symbols => 65 entries Occurrences => 60 entries Symbols: @@ -352,24 +352,42 @@ 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#x. => val method x +classes/C3. => final object C3 +classes/C3.apply(). => method apply +classes/C3.unapply(). => method unapply 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#x. => val method x classes/C4. => final object C4 +classes/C4.apply(). => method apply +classes/C4.unapply(). => method unapply 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#x. => val method x +classes/C6. => final object C6 +classes/C6.apply(). => method apply +classes/C6.unapply(). => method unapply classes/C7# => class C7 classes/C7#``(). => primary ctor classes/C7#``().(x) => param x @@ -387,6 +405,7 @@ classes/M.C5# => class C5 classes/M.C5#``(). => primary ctor classes/M.C5#``().(x) => param x classes/M.C5#x. => val method x +classes/M.C5(). => final implicit method C5 classes/N. => final object N classes/N.anonClass. => val method anonClass classes/N.anonFun. => val method anonFun @@ -465,7 +484,7 @@ Schema => SemanticDB v4 Uri => Definitions.scala Text => empty Language => Scala -Symbols => 9 entries +Symbols => 10 entries Occurrences => 10 entries Symbols: @@ -475,6 +494,7 @@ 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 @@ -548,7 +568,7 @@ Schema => SemanticDB v4 Uri => Enums.scala Text => empty Language => Scala -Symbols => 88 entries +Symbols => 132 entries Occurrences => 183 entries Symbols: @@ -557,29 +577,52 @@ _empty_/Enums.Coin# => abstract sealed enum class Coin _empty_/Enums.Coin#``(). => primary ctor _empty_/Enums.Coin#``().(value) => param value _empty_/Enums.Coin#value. => val method value +_empty_/Enums.Coin. => final object Coin +_empty_/Enums.Coin.$values. => val method $values _empty_/Enums.Coin.Dime. => case val static enum method Dime _empty_/Enums.Coin.Dollar. => case val static enum method Dollar _empty_/Enums.Coin.Nickel. => case val static enum method Nickel _empty_/Enums.Coin.Penny. => case val static enum method Penny _empty_/Enums.Coin.Quarter. => case val static enum method Quarter +_empty_/Enums.Coin.valueOf(). => method valueOf +_empty_/Enums.Coin.values(). => method values _empty_/Enums.Colour# => abstract sealed enum class Colour _empty_/Enums.Colour#``(). => primary ctor +_empty_/Enums.Colour. => final object Colour +_empty_/Enums.Colour.$new(). => method $new +_empty_/Enums.Colour.$values. => val method $values _empty_/Enums.Colour.Blue. => case val static enum method Blue _empty_/Enums.Colour.Green. => case val static enum method Green _empty_/Enums.Colour.Red. => case val static enum method Red +_empty_/Enums.Colour.valueOf(). => method valueOf +_empty_/Enums.Colour.values(). => method values _empty_/Enums.Directions# => abstract sealed enum class Directions _empty_/Enums.Directions#``(). => primary ctor +_empty_/Enums.Directions. => final object Directions +_empty_/Enums.Directions.$new(). => method $new +_empty_/Enums.Directions.$values. => val method $values _empty_/Enums.Directions.East. => case val static enum method East _empty_/Enums.Directions.North. => case val static enum method North _empty_/Enums.Directions.South. => case val static enum method South _empty_/Enums.Directions.West. => case val static enum method West +_empty_/Enums.Directions.valueOf(). => method valueOf +_empty_/Enums.Directions.values(). => method values _empty_/Enums.Maybe# => abstract sealed enum class Maybe _empty_/Enums.Maybe#[A] => covariant typeparam A _empty_/Enums.Maybe#``(). => primary ctor +_empty_/Enums.Maybe. => final object Maybe _empty_/Enums.Maybe.Just# => final case enum class Just +_empty_/Enums.Maybe.Just#$ordinal(). => method $ordinal +_empty_/Enums.Maybe.Just#[A] => typeparam A +_empty_/Enums.Maybe.Just#_1(). => method _1 _empty_/Enums.Maybe.Just#``(). => primary ctor _empty_/Enums.Maybe.Just#``().(value) => val param value +_empty_/Enums.Maybe.Just#copy$default$1(). => method copy$default$1 +_empty_/Enums.Maybe.Just#copy(). => method copy _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.unapply(). => method unapply _empty_/Enums.Maybe.None. => case val static enum method None _empty_/Enums.Planet# => abstract sealed enum class Planet _empty_/Enums.Planet#G. => final val method G @@ -591,6 +634,8 @@ _empty_/Enums.Planet#radius. => val method radius _empty_/Enums.Planet#surfaceGravity(). => method surfaceGravity _empty_/Enums.Planet#surfaceWeight(). => method surfaceWeight _empty_/Enums.Planet#surfaceWeight().(otherMass) => param otherMass +_empty_/Enums.Planet. => final object Planet +_empty_/Enums.Planet.$values. => val method $values _empty_/Enums.Planet.Earth. => case val static enum method Earth _empty_/Enums.Planet.Jupiter. => case val static enum method Jupiter _empty_/Enums.Planet.Mars. => case val static enum method Mars @@ -599,24 +644,35 @@ _empty_/Enums.Planet.Neptune. => case val static enum method Neptune _empty_/Enums.Planet.Saturn. => case val static enum method Saturn _empty_/Enums.Planet.Uranus. => case val static enum method Uranus _empty_/Enums.Planet.Venus. => case val static enum method Venus +_empty_/Enums.Planet.valueOf(). => method valueOf +_empty_/Enums.Planet.values(). => method values _empty_/Enums.Suits# => abstract sealed enum class Suits _empty_/Enums.Suits#``(). => primary ctor _empty_/Enums.Suits. => final object Suits +_empty_/Enums.Suits.$new(). => method $new +_empty_/Enums.Suits.$values. => val method $values _empty_/Enums.Suits.Clubs. => case val static enum method Clubs _empty_/Enums.Suits.Diamonds. => case val static enum method Diamonds _empty_/Enums.Suits.Hearts. => case val static enum method Hearts _empty_/Enums.Suits.Spades. => case val static enum method Spades +_empty_/Enums.Suits.derived$Eql(). => implicit method derived$Eql _empty_/Enums.Suits.isBlack(). => method isBlack _empty_/Enums.Suits.isBlack().(suit) => param suit _empty_/Enums.Suits.isRed(). => method isRed _empty_/Enums.Suits.isRed().(suit) => param suit +_empty_/Enums.Suits.valueOf(). => method valueOf +_empty_/Enums.Suits.values(). => method values _empty_/Enums.Tag# => abstract sealed enum class Tag _empty_/Enums.Tag#[A] => typeparam A _empty_/Enums.Tag#``(). => primary ctor +_empty_/Enums.Tag. => final object Tag _empty_/Enums.Tag.BooleanTag. => case val static enum method BooleanTag _empty_/Enums.Tag.IntTag. => case val static enum method IntTag _empty_/Enums.WeekDays# => abstract sealed enum class WeekDays _empty_/Enums.WeekDays#``(). => primary ctor +_empty_/Enums.WeekDays. => final object WeekDays +_empty_/Enums.WeekDays.$new(). => method $new +_empty_/Enums.WeekDays.$values. => val method $values _empty_/Enums.WeekDays.Friday. => case val static enum method Friday _empty_/Enums.WeekDays.Monday. => case val static enum method Monday _empty_/Enums.WeekDays.Saturday. => case val static enum method Saturday @@ -624,14 +680,21 @@ _empty_/Enums.WeekDays.Sunday. => case val static enum method Sunday _empty_/Enums.WeekDays.Thursday. => case val static enum method Thursday _empty_/Enums.WeekDays.Tuesday. => case val static enum method Tuesday _empty_/Enums.WeekDays.Wednesday. => case val static enum method Wednesday +_empty_/Enums.WeekDays.valueOf(). => method valueOf +_empty_/Enums.WeekDays.values(). => method values _empty_/Enums.`<:<`# => abstract sealed enum class <:< _empty_/Enums.`<:<`#[A] => contravariant typeparam A _empty_/Enums.`<:<`#[B] => typeparam B _empty_/Enums.`<:<`#``(). => primary ctor _empty_/Enums.`<:<`. => final object <:< _empty_/Enums.`<:<`.Refl# => final case enum class Refl +_empty_/Enums.`<:<`.Refl#$ordinal(). => method $ordinal _empty_/Enums.`<:<`.Refl#[C] => typeparam C _empty_/Enums.`<:<`.Refl#``(). => primary ctor +_empty_/Enums.`<:<`.Refl#copy(). => method copy +_empty_/Enums.`<:<`.Refl. => final object Refl +_empty_/Enums.`<:<`.Refl.apply(). => method apply +_empty_/Enums.`<:<`.Refl.unapply(). => method unapply _empty_/Enums.`<:<`.given_T(). => final implicit method given_T _empty_/Enums.`<:<`.given_T().[T] => typeparam T _empty_/Enums.some1. => val method some1 @@ -640,6 +703,7 @@ _empty_/Enums.unwrap().(ev) => implicit param ev _empty_/Enums.unwrap().(opt) => param opt _empty_/Enums.unwrap().[A] => typeparam A _empty_/Enums.unwrap().[B] => typeparam B +local0 => param x Occurrences: [0:7..0:12): Enums <- _empty_/Enums. @@ -834,12 +898,13 @@ Schema => SemanticDB v4 Uri => EtaExpansion.scala Text => empty Language => Scala -Symbols => 2 entries +Symbols => 3 entries Occurrences => 10 entries Symbols: example/EtaExpansion# => class EtaExpansion example/EtaExpansion#``(). => primary ctor +local0 => param x Occurrences: [0:8..0:15): example <- example/ @@ -907,7 +972,7 @@ Schema => SemanticDB v4 Uri => Flags.scala Text => empty Language => Scala -Symbols => 49 entries +Symbols => 51 entries Occurrences => 87 entries Symbols: @@ -918,6 +983,7 @@ flags/p/package.AA#``().(x) => param x flags/p/package.AA#``().(y) => val param y flags/p/package.AA#``().(z) => var param z flags/p/package.AA#`z_=`(). => var method z_= +flags/p/package.AA#`z_=`().(x$1) => param x$1 flags/p/package.AA#x. => val method x flags/p/package.AA#y. => val method y flags/p/package.AA#z(). => var method z @@ -950,6 +1016,7 @@ flags/p/package.Y#``(). => primary ctor flags/p/package.Z# => sealed trait Z flags/p/package.Z#``(). => primary ctor flags/p/package.`y_=`(). => var method y_= +flags/p/package.`y_=`().(x$1) => param x$1 flags/p/package.m(). => method m flags/p/package.m().[TT] => typeparam TT flags/p/package.x. => lazy val method x @@ -1058,8 +1125,8 @@ Schema => SemanticDB v4 Uri => ForComprehension.scala Text => empty Language => Scala -Symbols => 15 entries -Occurrences => 74 entries +Symbols => 16 entries +Occurrences => 72 entries Symbols: example/ForComprehension# => class ForComprehension @@ -1069,14 +1136,15 @@ local1 => val local b local1 => param b local2 => local c local2 => val local c -local3 => param a -local4 => param b -local5 => val local c -local6 => val local d -local7 => val local $1$ -local8 => val local e -local8 => local e -local9 => param f +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 +local9 => local e +local10 => param f Occurrences: [0:8..0:15): example <- example/ @@ -1103,56 +1171,54 @@ Occurrences: [8:11..8:12): a -> local0 [8:14..8:15): b -> local1 [8:17..8:18): c -> local2 -[10:4..10:5): a <- local3 +[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 <- local4 +[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 -> local3 +[11:14..11:15): a -> local4 [11:16..11:16): -> scala/collection/IterableOps#withFilter(). -[13:6..13:7): a -> local3 -[14:6..14:7): b -> local4 +[13:6..13:7): a -> local4 +[14:6..14:7): b -> local5 [15:6..15:8): == -> scala/Any#`==`(). [15:15..15:15): -> scala/collection/WithFilter#flatMap(). -[16:4..17:1): <- local7 -[17:6..17:7): c <- local5 -[18:6..18:7): d <- local6 +[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:16): a -> local3 -[19:18..19:19): b -> local4 +[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:7): a -> local3 -[22:6..22:7): b -> local4 -[23:6..23:7): c -> local5 -[24:6..24:7): d -> local6 +[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:21..25:21): -> scala/collection/WithFilter#map(). -[26:4..26:5): e <- local8 -[26:4..26:4): -> local7 -[26:4..26:5): e -> local8 -[27:6..27:7): a -> local3 -[28:6..28:7): b -> local4 -[29:6..29:7): c -> local5 -[30:6..30:7): d -> local6 +[26:4..26:5): e <- local9 +[26:4..26:5): e -> local9 +[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 -> local8 +[32:7..32:8): e -> local9 [32:9..32:11): == -> scala/Any#`==`(). [32:24..32:24): -> scala/collection/WithFilter#flatMap(). -[33:4..33:5): f <- local9 +[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 -> local8 +[33:14..33:15): e -> local9 [33:16..33:16): -> scala/collection/immutable/List#map(). -[36:6..36:7): a -> local3 -[37:6..37:7): b -> local4 -[38:6..38:7): c -> local5 -[39:6..39:7): d -> local6 -[40:6..40:7): e -> local8 -[41:6..41:7): f -> local9 +[36:6..36:7): a -> local4 +[37:6..37:7): b -> local5 +[38:6..38:7): c -> local7 +[39:6..39:7): d -> local8 +[40:6..40:7): e -> local9 +[41:6..41:7): f -> local10 expect/Givens.scala ___________________ @@ -1277,7 +1343,7 @@ Schema => SemanticDB v4 Uri => ImplicitConversion.scala Text => empty Language => Scala -Symbols => 19 entries +Symbols => 21 entries Occurrences => 58 entries Symbols: @@ -1300,6 +1366,8 @@ example/ImplicitConversion.newAny2stringadd#`+`().(other) => param other example/ImplicitConversion.newAny2stringadd#``(). => primary ctor example/ImplicitConversion.newAny2stringadd#``().(self) => param self example/ImplicitConversion.newAny2stringadd#self. => val method self +example/ImplicitConversion.newAny2stringadd(). => final implicit method newAny2stringadd +example/ImplicitConversion.newAny2stringadd. => final object newAny2stringadd Occurrences: [0:8..0:15): example <- example/ @@ -1761,8 +1829,8 @@ Schema => SemanticDB v4 Uri => Methods.scala Text => empty Language => Scala -Symbols => 69 entries -Occurrences => 139 entries +Symbols => 70 entries +Occurrences => 138 entries Symbols: example/Methods# => class Methods @@ -1795,7 +1863,6 @@ 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().(evidence$1) => implicit param evidence$1 example/Methods#m7().(l) => param l example/Methods#m7().[U] => typeparam U example/Methods#m9(). => method m9 @@ -1827,6 +1894,8 @@ 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 @@ -1893,7 +1962,6 @@ 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) @@ -1984,29 +2052,47 @@ Schema => SemanticDB v4 Uri => NamedApplyBlock.scala Text => empty Language => Scala -Symbols => 19 entries +Symbols => 37 entries Occurrences => 35 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#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.unapply(). => method unapply 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 => local b$1 +local1 => local c$1 +local2 => local b$3 +local3 => val local head$1 Occurrences: [0:8..0:15): example <- example/ @@ -2053,15 +2139,21 @@ Schema => SemanticDB v4 Uri => NamedArguments.scala Text => empty Language => Scala -Symbols => 6 entries +Symbols => 12 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#name. => val method name +example/NamedArguments#User. => final object User +example/NamedArguments#User.apply(). => method apply +example/NamedArguments#User.unapply(). => method unapply example/NamedArguments#``(). => primary ctor Occurrences: @@ -2294,8 +2386,8 @@ Schema => SemanticDB v4 Uri => Synthetic.scala Text => empty Language => Scala -Symbols => 32 entries -Occurrences => 152 entries +Symbols => 34 entries +Occurrences => 150 entries Symbols: example/Synthetic# => class Synthetic @@ -2304,9 +2396,7 @@ example/Synthetic#F#``(). => primary ctor example/Synthetic#J# => class J example/Synthetic#J#[T] => typeparam T example/Synthetic#J#``(). => primary ctor -example/Synthetic#J#``().(evidence$2) => implicit param evidence$2 example/Synthetic#J#arr. => val method arr -example/Synthetic#J#evidence$2. => implicit val method evidence$2 example/Synthetic#Name. => val method Name example/Synthetic#``(). => primary ctor example/Synthetic#f. => val method f @@ -2316,6 +2406,10 @@ example/Synthetic#ordering. => implicit val method ordering example/Synthetic#s. => final object s example/Synthetic#s.Bar# => case class Bar example/Synthetic#s.Bar#``(). => primary ctor +example/Synthetic#s.Bar#copy(). => method copy +example/Synthetic#s.Bar. => final object Bar +example/Synthetic#s.Bar.apply(). => method apply +example/Synthetic#s.Bar.unapply(). => method unapply example/Synthetic#s.apply(). => method apply example/Synthetic#x. => val method x example/Synthetic#xs. => val method xs @@ -2424,14 +2518,12 @@ Occurrences: [30:8..30:9): J <- example/Synthetic#J# [30:9..30:22): <- example/Synthetic#J#``(). [30:10..30:11): T <- example/Synthetic#J#[T] -[30:11..30:11): <- example/Synthetic#J#evidence$2. [30:13..30:21): Manifest -> scala/Predef.Manifest# [30:21..30:21): -> example/Synthetic#J#[T] [30:29..30:32): arr <- example/Synthetic#J#arr. [30:35..30:40): Array -> scala/Array. [30:41..30:46): empty -> scala/Array.empty(). [30:47..30:48): T -> example/Synthetic#J#[T] -[30:49..30:49): -> example/Synthetic#J#evidence$2. [32:2..32:2): <- example/Synthetic#F#``(). [32:8..32:9): F <- example/Synthetic#F# [33:15..33:23): ordering <- example/Synthetic#ordering. @@ -2539,7 +2631,7 @@ Schema => SemanticDB v4 Uri => Types.scala Text => empty Language => Scala -Symbols => 119 entries +Symbols => 123 entries Occurrences => 249 entries Symbols: @@ -2594,11 +2686,15 @@ 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.unapplySeq(). => method unapplySeq types/Test.C#TypeType. => final object TypeType types/Test.C#TypeType.T1# => type T1 types/Test.C#TypeType.T4# => type T4 @@ -2922,15 +3018,18 @@ Schema => SemanticDB v4 Uri => ValPattern.scala Text => empty Language => Scala -Symbols => 22 entries +Symbols => 25 entries Occurrences => 57 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 @@ -2946,8 +3045,8 @@ local4 => local number1 local4 => val local number1 local5 => local leftVar local6 => local rightVar -local7 => val local number1Var local7 => local number1Var +local7 => val local number1Var Occurrences: [0:8..0:15): example <- example/ @@ -3016,7 +3115,7 @@ Schema => SemanticDB v4 Uri => Vals.scala Text => empty Language => Scala -Symbols => 33 entries +Symbols => 38 entries Occurrences => 122 entries Symbols: @@ -3028,10 +3127,15 @@ example/Vals#``().(p) => param p example/Vals#``().(xp) => val param xp example/Vals#``().(yp) => var param yp 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#m(). => method m example/Vals#p. => val method p example/Vals#xam. => abstract val method xam @@ -3263,15 +3367,21 @@ Schema => SemanticDB v4 Uri => semanticdb-extract.scala Text => empty Language => Scala -Symbols => 8 entries +Symbols => 14 entries Occurrences => 22 entries Symbols: _empty_/AnObject. => final object AnObject _empty_/AnObject.Foo# => case class Foo +_empty_/AnObject.Foo#_1(). => method _1 _empty_/AnObject.Foo#``(). => primary ctor _empty_/AnObject.Foo#``().(x) => val param x +_empty_/AnObject.Foo#copy$default$1(). => method copy$default$1 +_empty_/AnObject.Foo#copy(). => method copy _empty_/AnObject.Foo#x. => val method x +_empty_/AnObject.Foo. => final object Foo +_empty_/AnObject.Foo.apply(). => method apply +_empty_/AnObject.Foo.unapply(). => method unapply _empty_/AnObject.foo(). => method foo _empty_/AnObject.foo().(x) => param x _empty_/AnObject.foo(+1). => method foo From fef188c02e49bf400fedc11da8c1568e74872797 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Mon, 18 Nov 2019 18:30:56 +0100 Subject: [PATCH 082/107] better properties for symbols --- .../dotc/semanticdb/ExtractSemanticDB.scala | 24 +++++++---- tests/semanticdb/metac.expect | 40 ++++++++----------- 2 files changed, 33 insertions(+), 31 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 45fa4e11725d..48240c01d5fd 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -42,7 +42,7 @@ class ExtractSemanticDB extends Phase with val unit = ctx.compilationUnit val extract = Extractor() extract.traverse(unit.tpdTree) - ExtractSemanticDB.write(unit.source, extract.occurrences.toList, extract.symbols.toList) + ExtractSemanticDB.write(unit.source, extract.occurrences.toList, extract.symbolInfos.toList) /** Extractor of symbol occurrences from trees */ class Extractor extends TreeTraverser with @@ -60,7 +60,10 @@ class ExtractSemanticDB extends Phase with val occurrences = new mutable.ListBuffer[SymbolOccurrence]() /** The extracted symbol infos */ - val symbols = new mutable.HashSet[SymbolInformation]() + val symbolInfos = new mutable.HashSet[SymbolInformation]() + + /** A cache of localN names */ + val localNames = new mutable.HashSet[String]() /** The symbol occurrences generated so far, as a set */ private val generated = new mutable.HashSet[SymbolOccurrence] @@ -76,7 +79,7 @@ class ExtractSemanticDB extends Phase with if isJavaIdent(str) then b append str else b append '`' append str append '`' - /** Is symbol global? Non-global symbols get localX names */ + /** Is symbol global? Non-global symbols get localNå names */ def isGlobal(sym: Symbol): Boolean = sym.is(Package) || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) @@ -265,7 +268,11 @@ class ExtractSemanticDB extends Phase with ) private def registerSymbol(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(given Context): Unit = - symbols += symbolInfo(sym, symbolName, symkinds) + val isLocal = symbolName.isLocal + if !isLocal || !localNames.contains(symbolName) + if isLocal + localNames += symbolName + symbolInfos += symbolInfo(sym, symbolName, symkinds) private def registerOccurrence(symbol: String, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = val occ = SymbolOccurrence(symbol, range(span), role) @@ -351,7 +358,7 @@ class ExtractSemanticDB extends Phase with val symkinds = mutable.HashSet.empty[SymbolKind] tree match case tree: ValDef => - if !tree.symbol.owner.is(Method) + if !tree.symbol.is(Param) symkinds += (if tree.mods is Mutable then SymbolKind.Var else SymbolKind.Val) if tree.rhs.isEmpty && !tree.symbol.isOneOf(TermParam | CaseAccessor | ParamAccessor) symkinds += SymbolKind.Abstract @@ -360,7 +367,8 @@ class ExtractSemanticDB extends Phase with symkinds += SymbolKind.Setter else if tree.rhs.isEmpty symkinds += SymbolKind.Abstract - case tree: Bind => symkinds += SymbolKind.Val + case tree: Bind => + symkinds += SymbolKind.Val case _ => symkinds.toSet @@ -493,7 +501,7 @@ object ExtractSemanticDB with val name: String = "extractSemanticDB" - def write(source: SourceFile, occurrences: List[SymbolOccurrence], symbols: List[SymbolInformation])(given ctx: Context): Unit = + def write(source: SourceFile, occurrences: List[SymbolOccurrence], symbolInfos: List[SymbolInformation])(given ctx: Context): Unit = def absolutePath(path: Path): Path = path.toAbsolutePath.normalize val sourcePath = absolutePath(source.file.jpath) val sourceRoot = absolutePath(Paths.get(ctx.settings.sourceroot.value)) @@ -516,7 +524,7 @@ object ExtractSemanticDB with uri = relPath.toString, text = "", md5 = internal.MD5.compute(String(source.content)), - symbols = symbols, + symbols = symbolInfos, occurrences = occurrences ) val docs = TextDocuments(List(doc)) diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 677f795fbcfc..c972ba588261 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -219,7 +219,7 @@ annot/M.m().[TT] => typeparam TT annot/T# => trait T annot/T#``(). => primary ctor local0 => selfparam self -local1 => local local +local1 => val local local Occurrences: [0:8..0:13): annot <- annot/ @@ -412,7 +412,7 @@ classes/N.anonFun. => val method anonFun local0 => primary ctor local1 => val method local local2 => param i -local3 => local local +local3 => val local local Occurrences: [0:8..0:15): classes <- classes/ @@ -1125,16 +1125,14 @@ Schema => SemanticDB v4 Uri => ForComprehension.scala Text => empty Language => Scala -Symbols => 16 entries +Symbols => 13 entries Occurrences => 72 entries Symbols: example/ForComprehension# => class ForComprehension example/ForComprehension#``(). => primary ctor local0 => param a -local1 => val local b local1 => param b -local2 => local c local2 => val local c local3 => param x$1 local4 => param a @@ -1143,7 +1141,6 @@ local6 => param x$1 local7 => val local c local8 => val local d local9 => val local e -local9 => local e local10 => param f Occurrences: @@ -2089,9 +2086,9 @@ example/NamedApplyBlockMethods.foo().(b) => param b example/NamedApplyBlockMethods.foo().(c) => param c example/NamedApplyBlockMethods.local. => val method local example/NamedApplyBlockMethods.recursive(). => method recursive -local0 => local b$1 -local1 => local c$1 -local2 => local b$3 +local0 => val local b$1 +local1 => val local c$1 +local2 => val local b$3 local3 => val local head$1 Occurrences: @@ -3018,7 +3015,7 @@ Schema => SemanticDB v4 Uri => ValPattern.scala Text => empty Language => Scala -Symbols => 25 entries +Symbols => 23 entries Occurrences => 57 entries Symbols: @@ -3039,14 +3036,12 @@ example/ValPattern#right. => val method right example/ValPattern#rightVar(). => var method rightVar local0 => val local number1 local1 => val local number1Var -local2 => local left -local3 => local right -local4 => local number1 +local2 => val local left +local3 => val local right local4 => val local number1 -local5 => local leftVar -local6 => local rightVar -local7 => local number1Var -local7 => val local number1Var +local5 => var local leftVar +local6 => var local rightVar +local7 => var local number1Var Occurrences: [0:8..0:15): example <- example/ @@ -3152,11 +3147,11 @@ example/Vals#yim(). => implicit var method yim example/Vals#ylm(). => var method ylm example/Vals#ym(). => var method ym example/Vals#yp(). => var method yp -local0 => local xl -local1 => lazy local xzl -local2 => implicit local xil -local3 => local yl -local4 => implicit local yil +local0 => val local xl +local1 => lazy val local xzl +local2 => implicit val local xil +local3 => var local yl +local4 => implicit var local yil Occurrences: [0:8..0:15): example <- example/ @@ -3459,4 +3454,3 @@ 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(). - From 9bcf22733934be9eb657328446f963c181276348 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Mon, 18 Nov 2019 23:29:13 +0100 Subject: [PATCH 083/107] adjust extension method syntax --- .../dotty/tools/dotc/semanticdb/Scala.scala | 84 +++++++++++++------ 1 file changed, 57 insertions(+), 27 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala index cbde9dddbf68..10dd7a3e785d 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala @@ -1,6 +1,6 @@ package dotty.tools.dotc.semanticdb -import dotty.tools.dotc.core.Symbols.{ Symbol, defn } +import dotty.tools.dotc.core.Symbols.{ Symbol , defn } import dotty.tools.dotc.core.Contexts.Context import dotty.tools.dotc.core.Names import dotty.tools.dotc.core.Names.Name @@ -14,6 +14,7 @@ import scala.annotation.internal.sharable import scala.annotation.switch object Scala with + import Symbols._ import NameOps.given @sharable private val unicodeEscape = raw"\$$u(\p{XDigit}{4})".r @@ -30,15 +31,16 @@ object Scala with def isVar: Boolean = kind match case Var | Setter => true case _ => false - def isVal: Boolean = kind == Val - def isVarOrVal: Boolean = kind.isVar || kind.isVal + end SymbolKind + object SymbolKind with val ValSet = Set(Val) val VarSet = Set(Var) val emptySet = Set.empty[SymbolKind] + end SymbolKind object Symbols with @@ -62,9 +64,7 @@ object Scala with else symbol.name.show - given symbolOps: (symbol: String) with - def unescapeUnicode = - unicodeEscape.replaceAllIn(symbol, m => String.valueOf(Integer.parseInt(m.group(1), 16).toChar)) + end Symbols given nameOps: (name: Name) with @@ -79,6 +79,7 @@ object Scala with case NameKinds.ModuleClassName(original) => original.isScala2PackageObjectName case _ => false + end nameOps given symbolOps: (sym: Symbol) with @@ -100,22 +101,29 @@ object Scala with sym.owner.info.decls.find(s => s.name == setterName && s.info.matchingType) + end symbolOps + object LocalSymbol with def unapply(symbolInfo: SymbolInformation): Option[Int] = - symbolInfo.symbol match - case locals(ints) => - val bi = BigInt(ints) - if bi.isValidInt then Some(bi.toInt) else None - case _ => None - - given (symbol: String) with - - def isNoSymbol: Boolean = - symbol == Symbols.NoSymbol - def isRootPackage: Boolean = - symbol == Symbols.RootPackage - def isEmptyPackage: Boolean = - symbol == Symbols.EmptyPackage + symbolInfo.symbol match + + case locals(ints) => + val bi = BigInt(ints) + if bi.isValidInt + Some(bi.toInt) + else + None + + case _ => None + + end LocalSymbol + + given stringOps: (symbol: String) with + + def isNoSymbol: Boolean = NoSymbol == symbol + def isRootPackage: Boolean = RootPackage == symbol + def isEmptyPackage: Boolean = EmptyPackage == symbol + def isGlobal: Boolean = !symbol.isNoSymbol && !symbol.isMulti @@ -123,10 +131,10 @@ object Scala with case '.' | '#' | '/' | ')' | ']' => true case _ => false } - def isLocal: Boolean = - locals matches symbol - def isMulti: Boolean = - symbol startsWith ";" + + def isLocal: Boolean = !symbol.isGlobal + def isMulti: Boolean = symbol startsWith ";" + def isConstructor: Boolean = ctor matches symbol def isTerm: Boolean = @@ -140,33 +148,55 @@ object Scala with def isTypeParameter: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ']' - given (info: SymbolInformation) with + def unescapeUnicode = + unicodeEscape.replaceAllIn(symbol, m => String.valueOf(Integer.parseInt(m.group(1), 16).toChar)) + + end stringOps + + given infoOps: (info: SymbolInformation) with - def isPrimary: Boolean = - (info.properties & SymbolInformation.Property.PRIMARY.value) != 0 def isAbstract: Boolean = (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0 + def isFinal: Boolean = (info.properties & SymbolInformation.Property.FINAL.value) != 0 + def isSealed: Boolean = (info.properties & SymbolInformation.Property.SEALED.value) != 0 + def isImplicit: Boolean = (info.properties & SymbolInformation.Property.IMPLICIT.value) != 0 + def isLazy: Boolean = (info.properties & SymbolInformation.Property.LAZY.value) != 0 + def isCase: Boolean = (info.properties & SymbolInformation.Property.CASE.value) != 0 + def isCovariant: Boolean = (info.properties & SymbolInformation.Property.COVARIANT.value) != 0 + def isContravariant: Boolean = (info.properties & SymbolInformation.Property.CONTRAVARIANT.value) != 0 + + def isPrimary: Boolean = + (info.properties & SymbolInformation.Property.PRIMARY.value) != 0 + def isVal: Boolean = (info.properties & SymbolInformation.Property.VAL.value) != 0 + def isVar: Boolean = (info.properties & SymbolInformation.Property.VAR.value) != 0 + def isStatic: Boolean = (info.properties & SymbolInformation.Property.STATIC.value) != 0 + def isEnum: Boolean = (info.properties & SymbolInformation.Property.ENUM.value) != 0 + def isDefault: Boolean = (info.properties & SymbolInformation.Property.DEFAULT.value) != 0 + + end infoOps + +end Scala From 6e731a20589d2b811af0a57cce4aa94c6320ed8d Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 19 Nov 2019 11:43:37 +0100 Subject: [PATCH 084/107] More definitions in Symbols section. Rename Scala to Scala3 --- .../dotc/semanticdb/ExtractSemanticDB.scala | 280 +++++++++--------- .../semanticdb/{Scala.scala => Scala3.scala} | 41 ++- .../tools/dotc/semanticdb/Semanticdbs.scala | 2 +- tests/semanticdb/metac.expect | 70 ++++- 4 files changed, 225 insertions(+), 168 deletions(-) rename compiler/src/dotty/tools/dotc/semanticdb/{Scala.scala => Scala3.scala} (84%) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 48240c01d5fd..ce861d2aed67 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -27,7 +27,7 @@ import scala.annotation.{ threadUnsafe => tu, tailrec } * TODO: Also extract type information */ class ExtractSemanticDB extends Phase with - import Scala.{_, given} + import Scala3.{_, given} import Symbols.given override val phaseName: String = ExtractSemanticDB.name @@ -68,6 +68,146 @@ class ExtractSemanticDB extends Phase with /** The symbol occurrences generated so far, as a set */ private val generated = new mutable.HashSet[SymbolOccurrence] + /** Definitions of this symbol should be excluded from semanticdb */ + private def excludeDef(sym: Symbol)(given Context): Boolean = + !sym.exists + || sym.isLocalDummy + || sym.is(Synthetic) + || sym.isConstructor && sym.owner.is(ModuleClass) + || excludeDefStrict(sym) + + private def excludeDefStrict(sym: Symbol)(given Context): Boolean = + sym.name.is(NameKinds.DefaultGetterName) + || excludeSymbolStrict(sym) + + private def excludeSymbolStrict(sym: Symbol)(given Context): Boolean = + sym.name.isWildcard + || sym.isAnonymous + || sym.name.isEmptyNumbered + + private def excludeChildren(sym: Symbol)(given Context): Boolean = + sym.isAllOf(HigherKinded | Param) + + /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ + private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = + excludeDefStrict(sym) + || excludeDef(sym) && span.zeroLength + + override def traverse(tree: Tree)(given Context): Unit = + + inline def traverseCtorParamTpt(ctorSym: Symbol, tpt: Tree): Unit = + val tptSym = tpt.symbol + if tptSym.owner == ctorSym + val found = matchingMemberType(tptSym, ctorSym.owner) + if !excludeUseStrict(found, tpt.span) && tpt.span.hasLength + registerUse(found, tpt.span) + else + traverse(tpt) + + for annot <- tree.symbol.annotations do + if annot.tree.span.exists + && annot.symbol.owner != defn.ScalaAnnotationInternal + then + traverse(annot.tree) + + tree match + case tree: PackageDef => + if !excludeDef(tree.pid.symbol) && tree.pid.span.hasLength + tree.pid match + case tree @ Select(qual, name) => + registerDefinition(tree.symbol, adjustSpanToName(tree.span, qual.span, name), Set.empty) + traverse(qual) + case tree => registerDefinition(tree.symbol, tree.span, Set.empty) + tree.stats.foreach(traverse) + case tree: NamedDefTree => + if tree.symbol.isAllOf(ModuleValCreationFlags) + return + if !excludeDef(tree.symbol) && tree.span.hasLength + registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree)) + val privateWithin = tree.symbol.privateWithin + if privateWithin.exists + registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) + else if !excludeSymbolStrict(tree.symbol) + registerSymbol(tree.symbol, symbolName(tree.symbol), symbolKinds(tree)) + tree match + case tree: ValDef if tree.symbol.isAllOf(EnumValue) => + tree.rhs match + case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause + template.parents.foreach(traverse) + case _ => // calls $new + case tree: ValDef if tree.symbol.isSelfSym => + if tree.tpt.span.hasLength + traverse(tree.tpt) + case tree: DefDef if tree.symbol.isConstructor => // ignore typeparams for secondary ctors + tree.vparamss.foreach(_.foreach(traverse)) + traverse(tree.rhs) + case tree: (DefDef | ValDef) if tree.symbol.isSyntheticWithIdent => + tree match + case tree: DefDef => + tree.tparams.foreach(tparam => registerSymbolSimple(tparam.symbol)) + tree.vparamss.foreach(_.foreach(vparam => registerSymbolSimple(vparam.symbol))) + case _ => + // ignore rhs + case tree => + if !excludeChildren(tree.symbol) + traverseChildren(tree) + case tree: Template => + val ctorSym = tree.constr.symbol + if !excludeDef(ctorSym) + registerDefinition(ctorSym, tree.constr.span, Set.empty) + ctorParams(tree.constr.vparamss, tree.body)(traverseCtorParamTpt(ctorSym, _)) + for parent <- tree.parentsOrDerived do + if + parent.symbol != defn.ObjectClass.primaryConstructor + && parent.tpe.dealias != defn.SerializableType + && parent.symbol != defn.ProductClass + then + traverse(parent) + val selfSpan = tree.self.span + if selfSpan.exists && selfSpan.hasLength then + traverse(tree.self) + if tree.symbol.owner.is(Enum, butNot=Case) + tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement + else + tree.body.foreach(traverse) + case tree: Assign => + if !excludeUseStrict(tree.lhs.symbol, tree.lhs.span) + val lhs = tree.lhs.symbol + val setter = lhs.matchingSetter.orElse(lhs) + tree.lhs match + case tree @ Select(qual, name) => registerUse(setter, adjustSpanToName(tree.span, qual.span, name)) + case tree => registerUse(setter, tree.span) + traverseChildren(tree.lhs) + traverse(tree.rhs) + case tree: Ident => + if tree.name != nme.WILDCARD then + val sym = tree.symbol.adjustIfCtorTyparam + if !excludeUseStrict(sym, tree.span) then + registerUse(sym, tree.span) + case tree: Select => + val qualSpan = tree.qualifier.span + val sym = tree.symbol.adjustIfCtorTyparam + if !excludeUseStrict(sym, tree.span) then + registerUse(sym, adjustSpanToName(tree.span, qualSpan, tree.name)) + if qualSpan.exists && qualSpan.hasLength then + traverseChildren(tree) + case tree: Import => + if tree.span.exists && tree.span.hasLength then + for sel <- tree.selectors do + val imported = sel.imported.name + if imported != nme.WILDCARD then + for alt <- tree.expr.tpe.member(imported).alternatives do + registerUse(alt.symbol, sel.imported.span) + if (alt.symbol.companionClass.exists) + registerUse(alt.symbol.companionClass, sel.imported.span) + traverseChildren(tree) + case tree: Inlined => + traverse(tree.call) + case tree: Annotated => // skip the annotation (see `@param` in https://github.com/scalameta/scalameta/blob/633824474e99bbfefe12ad0cc73da1fe064b3e9b/tests/jvm/src/test/resources/example/Annotations.scala#L37) + traverse(tree.arg) + case _ => + traverseChildren(tree) + /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = @@ -161,37 +301,10 @@ class ExtractSemanticDB extends Phase with val (endLine, endCol) = lineCol(span.end) Some(Range(startLine, startCol, endLine, endCol)) - /** Definitions of this symbol should be excluded from semanticdb */ - private def excludeDef(sym: Symbol)(given Context): Boolean = - !sym.exists - || sym.isLocalDummy - || sym.is(Synthetic) - || sym.owner.is(Synthetic) && !sym.owner.isAnonymous && !sym.isAllOf(EnumCase) - || sym.isConstructor && sym.owner.is(ModuleClass) - || excludeDefStrict(sym) - - private def excludeDefStrict(sym: Symbol)(given Context): Boolean = - sym.name.is(NameKinds.DefaultGetterName) - || excludeSymbolStrict(sym) - private inline def (name: Name) isEmptyNumbered: Boolean = name match case NameKinds.AnyNumberedName(nme.EMPTY, _) => true case _ => false - private def excludeSymbolStrict(sym: Symbol)(given Context): Boolean = - sym.name.isWildcard - || sym.isAnonymous - || sym.name.isEmptyNumbered - - private def excludeChildren(sym: Symbol)(given Context): Boolean = - sym.isAllOf(HigherKinded | Param) - || !sym.isAnonymous && sym.is(Synthetic, butNot=Module) - - /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ - private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = - excludeDefStrict(sym) - || excludeDef(sym) && span.zeroLength - private def symbolKind(sym: Symbol, symkinds: Set[SymbolKind])(given Context): SymbolInformation.Kind = if sym.isTypeParam SymbolInformation.Kind.TYPE_PARAMETER @@ -274,6 +387,9 @@ class ExtractSemanticDB extends Phase with localNames += symbolName symbolInfos += symbolInfo(sym, symbolName, symkinds) + private def registerSymbolSimple(sym: Symbol)(given Context): Unit = + registerSymbol(sym, symbolName(sym), Set.empty) + private def registerOccurrence(symbol: String, span: Span, role: SymbolOccurrence.Role)(given Context): Unit = val occ = SymbolOccurrence(symbol, range(span), role) if !generated.contains(occ) && occ.symbol.nonEmpty then @@ -386,114 +502,6 @@ class ExtractSemanticDB extends Phase with registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds) traverseTpt(vparam.tpt) - override def traverse(tree: Tree)(given Context): Unit = - - inline def traverseCtorParamTpt(ctorSym: Symbol, tpt: Tree): Unit = - val tptSym = tpt.symbol - if tptSym.owner == ctorSym - val found = matchingMemberType(tptSym, ctorSym.owner) - if !excludeUseStrict(found, tpt.span) && tpt.span.hasLength - registerUse(found, tpt.span) - else - traverse(tpt) - - for annot <- tree.symbol.annotations do - if annot.tree.span.exists - && annot.symbol.owner != defn.ScalaAnnotationInternal - then - traverse(annot.tree) - - tree match - case tree: PackageDef => - if !excludeDef(tree.pid.symbol) && tree.pid.span.hasLength - tree.pid match - case tree @ Select(qual, name) => - registerDefinition(tree.symbol, adjustSpanToName(tree.span, qual.span, name), Set.empty) - traverse(qual) - case tree => registerDefinition(tree.symbol, tree.span, Set.empty) - tree.stats.foreach(traverse) - case tree: NamedDefTree => - if tree.symbol.isAllOf(ModuleValCreationFlags) - return - if !excludeDef(tree.symbol) && tree.span.hasLength - registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree)) - val privateWithin = tree.symbol.privateWithin - if privateWithin.exists - registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) - else if !excludeSymbolStrict(tree.symbol) - registerSymbol(tree.symbol, symbolName(tree.symbol), symbolKinds(tree)) - tree match - case tree: ValDef if tree.symbol.isAllOf(EnumValue) => - tree.rhs match - case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause - template.parents.foreach(traverse) - case _ => // calls $new - case tree: ValDef if tree.symbol.isSelfSym => - if tree.tpt.span.hasLength - traverse(tree.tpt) - case tree: DefDef if tree.symbol.isConstructor => // ignore typeparams for secondary ctors - tree.vparamss.foreach(_.foreach(traverse)) - traverse(tree.rhs) - case tree => - if !excludeChildren(tree.symbol) - traverseChildren(tree) - case tree: Template => - val ctorSym = tree.constr.symbol - if !excludeDef(ctorSym) - registerDefinition(ctorSym, tree.constr.span, Set.empty) - ctorParams(tree.constr.vparamss, tree.body)(traverseCtorParamTpt(ctorSym, _)) - for parent <- tree.parentsOrDerived do - if - parent.symbol != defn.ObjectClass.primaryConstructor - && parent.tpe.dealias != defn.SerializableType - && parent.symbol != defn.ProductClass - then - traverse(parent) - val selfSpan = tree.self.span - if selfSpan.exists && selfSpan.hasLength then - traverse(tree.self) - if tree.symbol.owner.is(Enum, butNot=Case) - tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement - else - tree.body.foreach(traverse) - case tree: Assign => - if !excludeUseStrict(tree.lhs.symbol, tree.lhs.span) - val lhs = tree.lhs.symbol - val setter = lhs.matchingSetter.orElse(lhs) - tree.lhs match - case tree @ Select(qual, name) => registerUse(setter, adjustSpanToName(tree.span, qual.span, name)) - case tree => registerUse(setter, tree.span) - traverseChildren(tree.lhs) - traverse(tree.rhs) - case tree: Ident => - if tree.name != nme.WILDCARD then - val sym = tree.symbol.adjustIfCtorTyparam - if !excludeUseStrict(sym, tree.span) then - registerUse(sym, tree.span) - case tree: Select => - val qualSpan = tree.qualifier.span - val sym = tree.symbol.adjustIfCtorTyparam - if !excludeUseStrict(sym, tree.span) then - registerUse(sym, adjustSpanToName(tree.span, qualSpan, tree.name)) - if qualSpan.exists && qualSpan.hasLength then - traverseChildren(tree) - case tree: Import => - if tree.span.exists && tree.span.hasLength then - for sel <- tree.selectors do - val imported = sel.imported.name - if imported != nme.WILDCARD then - for alt <- tree.expr.tpe.member(imported).alternatives do - registerUse(alt.symbol, sel.imported.span) - if (alt.symbol.companionClass.exists) - registerUse(alt.symbol.companionClass, sel.imported.span) - traverseChildren(tree) - case tree: Inlined => - traverse(tree.call) - case tree: Annotated => // skip the annotation (see `@param` in https://github.com/scalameta/scalameta/blob/633824474e99bbfefe12ad0cc73da1fe064b3e9b/tests/jvm/src/test/resources/example/Annotations.scala#L37) - traverse(tree.arg) - case _ => - traverseChildren(tree) - object ExtractSemanticDB with import java.nio.file.Path import scala.collection.JavaConverters._ diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala similarity index 84% rename from compiler/src/dotty/tools/dotc/semanticdb/Scala.scala rename to compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index 10dd7a3e785d..e9a49190c4fe 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -13,7 +13,7 @@ import dotty.tools.dotc.core.StdNames.nme import scala.annotation.internal.sharable import scala.annotation.switch -object Scala with +object Scala3 with import Symbols._ import NameOps.given @@ -101,6 +101,10 @@ object Scala with sym.owner.info.decls.find(s => s.name == setterName && s.info.matchingType) + + def isSyntheticWithIdent(given Context): Boolean = + sym.is(Synthetic) && !sym.isAnonymous + end symbolOps object LocalSymbol with @@ -118,35 +122,26 @@ object Scala with end LocalSymbol + private inline def (char: Char) `is/.#])` = (char: @switch) match + case '/' | '.' | '#' | ']' | ')' => true + case _ => false + given stringOps: (symbol: String) with def isNoSymbol: Boolean = NoSymbol == symbol def isRootPackage: Boolean = RootPackage == symbol def isEmptyPackage: Boolean = EmptyPackage == symbol - def isGlobal: Boolean = - !symbol.isNoSymbol - && !symbol.isMulti - && { (symbol.last: @switch) match - case '.' | '#' | '/' | ')' | ']' => true - case _ => false - } - - def isLocal: Boolean = !symbol.isGlobal + def isGlobal: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last.`is/.#])` + def isLocal: Boolean = !symbol.isNoSymbol && !symbol.isMulti && !symbol.last.`is/.#])` def isMulti: Boolean = symbol startsWith ";" - def isConstructor: Boolean = - ctor matches symbol - def isTerm: Boolean = - !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '.' - def isType: Boolean = - !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '#' - def isPackage: Boolean = - !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '/' - def isParameter: Boolean = - !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ')' - def isTypeParameter: Boolean = - !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ']' + def isConstructor: Boolean = ctor matches symbol + def isPackage: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '/' + def isTerm: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '.' + def isType: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '#' + def isTypeParameter: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ']' + def isParameter: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ')' def unescapeUnicode = unicodeEscape.replaceAllIn(symbol, m => String.valueOf(Integer.parseInt(m.group(1), 16).toChar)) @@ -199,4 +194,4 @@ object Scala with end infoOps -end Scala +end Scala3 diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala index 669b959a825b..aea8202198c0 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala @@ -4,7 +4,7 @@ import java.nio.file._ import java.nio.charset.StandardCharsets import scala.collection.JavaConverters._ import dotty.tools.dotc.util.SourceFile -import dotty.tools.dotc.semanticdb.Scala.{_, given} +import dotty.tools.dotc.semanticdb.Scala3.{_, given} object Semanticdbs with diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index c972ba588261..14d95fb200c2 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -344,7 +344,7 @@ Schema => SemanticDB v4 Uri => Classes.scala Text => empty Language => Scala -Symbols => 65 entries +Symbols => 75 entries Occurrences => 60 entries Symbols: @@ -364,30 +364,39 @@ classes/C3#``(). => primary ctor classes/C3#``().(x) => val param x classes/C3#copy$default$1(). => method copy$default$1 classes/C3#copy(). => method copy +classes/C3#copy().(x) => param x classes/C3#x. => val method x classes/C3. => final object C3 classes/C3.apply(). => method apply +classes/C3.apply().(x) => param x classes/C3.unapply(). => method unapply +classes/C3.unapply().(x$1) => param x$1 classes/C4# => case class C4 classes/C4#_1(). => method _1 classes/C4#``(). => primary ctor classes/C4#``().(x) => val param x classes/C4#copy$default$1(). => method copy$default$1 classes/C4#copy(). => method copy +classes/C4#copy().(x) => param x classes/C4#x. => val method x classes/C4. => final object C4 classes/C4.apply(). => method apply +classes/C4.apply().(x) => param x classes/C4.unapply(). => method unapply +classes/C4.unapply().(x$1) => param x$1 classes/C6# => case class C6 classes/C6#_1(). => method _1 classes/C6#``(). => primary ctor classes/C6#``().(x) => param x classes/C6#copy$default$1(). => method copy$default$1 classes/C6#copy(). => method copy +classes/C6#copy().(x) => param x classes/C6#x. => val method x classes/C6. => final object C6 classes/C6.apply(). => method apply +classes/C6.apply().(x) => param x classes/C6.unapply(). => method unapply +classes/C6.unapply().(x$1) => param x$1 classes/C7# => class C7 classes/C7#``(). => primary ctor classes/C7#``().(x) => param x @@ -406,6 +415,7 @@ classes/M.C5#``(). => primary ctor classes/M.C5#``().(x) => param x classes/M.C5#x. => val method x classes/M.C5(). => final implicit method C5 +classes/M.C5().(x) => param x classes/N. => final object N classes/N.anonClass. => val method anonClass classes/N.anonFun. => val method anonFun @@ -568,7 +578,7 @@ Schema => SemanticDB v4 Uri => Enums.scala Text => empty Language => Scala -Symbols => 132 entries +Symbols => 157 entries Occurrences => 183 entries Symbols: @@ -585,27 +595,34 @@ _empty_/Enums.Coin.Nickel. => case val static enum method Nickel _empty_/Enums.Coin.Penny. => case val static enum method Penny _empty_/Enums.Coin.Quarter. => case val static enum method Quarter _empty_/Enums.Coin.valueOf(). => method valueOf +_empty_/Enums.Coin.valueOf().($name) => param $name _empty_/Enums.Coin.values(). => method values _empty_/Enums.Colour# => abstract sealed enum class Colour _empty_/Enums.Colour#``(). => primary ctor _empty_/Enums.Colour. => final object Colour _empty_/Enums.Colour.$new(). => method $new +_empty_/Enums.Colour.$new().($name) => param $name +_empty_/Enums.Colour.$new().(_$ordinal) => param _$ordinal _empty_/Enums.Colour.$values. => val method $values _empty_/Enums.Colour.Blue. => case val static enum method Blue _empty_/Enums.Colour.Green. => case val static enum method Green _empty_/Enums.Colour.Red. => case val static enum method Red _empty_/Enums.Colour.valueOf(). => method valueOf +_empty_/Enums.Colour.valueOf().($name) => param $name _empty_/Enums.Colour.values(). => method values _empty_/Enums.Directions# => abstract sealed enum class Directions _empty_/Enums.Directions#``(). => primary ctor _empty_/Enums.Directions. => final object Directions _empty_/Enums.Directions.$new(). => method $new +_empty_/Enums.Directions.$new().($name) => param $name +_empty_/Enums.Directions.$new().(_$ordinal) => param _$ordinal _empty_/Enums.Directions.$values. => val method $values _empty_/Enums.Directions.East. => case val static enum method East _empty_/Enums.Directions.North. => case val static enum method North _empty_/Enums.Directions.South. => case val static enum method South _empty_/Enums.Directions.West. => case val static enum method West _empty_/Enums.Directions.valueOf(). => method valueOf +_empty_/Enums.Directions.valueOf().($name) => param $name _empty_/Enums.Directions.values(). => method values _empty_/Enums.Maybe# => abstract sealed enum class Maybe _empty_/Enums.Maybe#[A] => covariant typeparam A @@ -618,11 +635,18 @@ _empty_/Enums.Maybe.Just#_1(). => method _1 _empty_/Enums.Maybe.Just#``(). => primary ctor _empty_/Enums.Maybe.Just#``().(value) => val param value _empty_/Enums.Maybe.Just#copy$default$1(). => method copy$default$1 +_empty_/Enums.Maybe.Just#copy$default$1().[A] => typeparam A _empty_/Enums.Maybe.Just#copy(). => method copy +_empty_/Enums.Maybe.Just#copy().(value) => param value +_empty_/Enums.Maybe.Just#copy().[A] => typeparam A _empty_/Enums.Maybe.Just#value. => val method value _empty_/Enums.Maybe.Just. => final object Just _empty_/Enums.Maybe.Just.apply(). => method apply +_empty_/Enums.Maybe.Just.apply().(value) => param value +_empty_/Enums.Maybe.Just.apply().[A] => typeparam A _empty_/Enums.Maybe.Just.unapply(). => method unapply +_empty_/Enums.Maybe.Just.unapply().(x$1) => param x$1 +_empty_/Enums.Maybe.Just.unapply().[A] => typeparam A _empty_/Enums.Maybe.None. => case val static enum method None _empty_/Enums.Planet# => abstract sealed enum class Planet _empty_/Enums.Planet#G. => final val method G @@ -645,11 +669,14 @@ _empty_/Enums.Planet.Saturn. => case val static enum method Saturn _empty_/Enums.Planet.Uranus. => case val static enum method Uranus _empty_/Enums.Planet.Venus. => case val static enum method Venus _empty_/Enums.Planet.valueOf(). => method valueOf +_empty_/Enums.Planet.valueOf().($name) => param $name _empty_/Enums.Planet.values(). => method values _empty_/Enums.Suits# => abstract sealed enum class Suits _empty_/Enums.Suits#``(). => primary ctor _empty_/Enums.Suits. => final object Suits _empty_/Enums.Suits.$new(). => method $new +_empty_/Enums.Suits.$new().($name) => param $name +_empty_/Enums.Suits.$new().(_$ordinal) => param _$ordinal _empty_/Enums.Suits.$values. => val method $values _empty_/Enums.Suits.Clubs. => case val static enum method Clubs _empty_/Enums.Suits.Diamonds. => case val static enum method Diamonds @@ -661,6 +688,7 @@ _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 @@ -672,6 +700,8 @@ _empty_/Enums.WeekDays# => abstract sealed enum class WeekDays _empty_/Enums.WeekDays#``(). => primary ctor _empty_/Enums.WeekDays. => final object WeekDays _empty_/Enums.WeekDays.$new(). => method $new +_empty_/Enums.WeekDays.$new().($name) => param $name +_empty_/Enums.WeekDays.$new().(_$ordinal) => param _$ordinal _empty_/Enums.WeekDays.$values. => val method $values _empty_/Enums.WeekDays.Friday. => case val static enum method Friday _empty_/Enums.WeekDays.Monday. => case val static enum method Monday @@ -681,6 +711,7 @@ _empty_/Enums.WeekDays.Thursday. => case val static enum method Thursday _empty_/Enums.WeekDays.Tuesday. => case val static enum method Tuesday _empty_/Enums.WeekDays.Wednesday. => case val static enum method Wednesday _empty_/Enums.WeekDays.valueOf(). => method valueOf +_empty_/Enums.WeekDays.valueOf().($name) => param $name _empty_/Enums.WeekDays.values(). => method values _empty_/Enums.`<:<`# => abstract sealed enum class <:< _empty_/Enums.`<:<`#[A] => contravariant typeparam A @@ -692,9 +723,13 @@ _empty_/Enums.`<:<`.Refl#$ordinal(). => method $ordinal _empty_/Enums.`<:<`.Refl#[C] => typeparam C _empty_/Enums.`<:<`.Refl#``(). => primary ctor _empty_/Enums.`<:<`.Refl#copy(). => method copy +_empty_/Enums.`<:<`.Refl#copy().[C] => typeparam C _empty_/Enums.`<:<`.Refl. => final object Refl _empty_/Enums.`<:<`.Refl.apply(). => method apply +_empty_/Enums.`<:<`.Refl.apply().[C] => typeparam C _empty_/Enums.`<:<`.Refl.unapply(). => method unapply +_empty_/Enums.`<:<`.Refl.unapply().(x$1) => param x$1 +_empty_/Enums.`<:<`.Refl.unapply().[C] => typeparam C _empty_/Enums.`<:<`.given_T(). => final implicit method given_T _empty_/Enums.`<:<`.given_T().[T] => typeparam T _empty_/Enums.some1. => val method some1 @@ -1340,7 +1375,7 @@ Schema => SemanticDB v4 Uri => ImplicitConversion.scala Text => empty Language => Scala -Symbols => 21 entries +Symbols => 23 entries Occurrences => 58 entries Symbols: @@ -1364,6 +1399,8 @@ example/ImplicitConversion.newAny2stringadd#``(). => primary ctor example/ImplicitConversion.newAny2stringadd#``().(self) => param self example/ImplicitConversion.newAny2stringadd#self. => val method self example/ImplicitConversion.newAny2stringadd(). => final implicit method newAny2stringadd +example/ImplicitConversion.newAny2stringadd().(self) => param self +example/ImplicitConversion.newAny2stringadd().[A] => typeparam A example/ImplicitConversion.newAny2stringadd. => final object newAny2stringadd Occurrences: @@ -2049,7 +2086,7 @@ Schema => SemanticDB v4 Uri => NamedApplyBlock.scala Text => empty Language => Scala -Symbols => 37 entries +Symbols => 44 entries Occurrences => 35 entries Symbols: @@ -2067,12 +2104,19 @@ example/NamedApplyBlockCaseClassConstruction.Msg#copy$default$1(). => method cop example/NamedApplyBlockCaseClassConstruction.Msg#copy$default$2(). => method copy$default$2 example/NamedApplyBlockCaseClassConstruction.Msg#copy$default$3(). => method copy$default$3 example/NamedApplyBlockCaseClassConstruction.Msg#copy(). => method copy +example/NamedApplyBlockCaseClassConstruction.Msg#copy().(body) => param body +example/NamedApplyBlockCaseClassConstruction.Msg#copy().(head) => param head +example/NamedApplyBlockCaseClassConstruction.Msg#copy().(tail) => param tail example/NamedApplyBlockCaseClassConstruction.Msg#head. => val method head example/NamedApplyBlockCaseClassConstruction.Msg#tail. => val method tail example/NamedApplyBlockCaseClassConstruction.Msg. => final object Msg example/NamedApplyBlockCaseClassConstruction.Msg.$lessinit$greater$default$2(). => method $lessinit$greater$default$2 example/NamedApplyBlockCaseClassConstruction.Msg.apply(). => method apply +example/NamedApplyBlockCaseClassConstruction.Msg.apply().(body) => param body +example/NamedApplyBlockCaseClassConstruction.Msg.apply().(head) => param head +example/NamedApplyBlockCaseClassConstruction.Msg.apply().(tail) => param tail example/NamedApplyBlockCaseClassConstruction.Msg.unapply(). => method unapply +example/NamedApplyBlockCaseClassConstruction.Msg.unapply().(x$1) => param x$1 example/NamedApplyBlockCaseClassConstruction.bodyText. => val method bodyText example/NamedApplyBlockCaseClassConstruction.msg. => val method msg example/NamedApplyBlockMethods. => final object NamedApplyBlockMethods @@ -2136,7 +2180,7 @@ Schema => SemanticDB v4 Uri => NamedArguments.scala Text => empty Language => Scala -Symbols => 12 entries +Symbols => 15 entries Occurrences => 10 entries Symbols: @@ -2147,10 +2191,13 @@ example/NamedArguments#User#``(). => primary ctor example/NamedArguments#User#``().(name) => val param name example/NamedArguments#User#copy$default$1(). => method copy$default$1 example/NamedArguments#User#copy(). => method copy +example/NamedArguments#User#copy().(name) => param name example/NamedArguments#User#name. => val method name example/NamedArguments#User. => final object User example/NamedArguments#User.apply(). => method apply +example/NamedArguments#User.apply().(name) => param name example/NamedArguments#User.unapply(). => method unapply +example/NamedArguments#User.unapply().(x$1) => param x$1 example/NamedArguments#``(). => primary ctor Occurrences: @@ -2383,7 +2430,7 @@ Schema => SemanticDB v4 Uri => Synthetic.scala Text => empty Language => Scala -Symbols => 34 entries +Symbols => 35 entries Occurrences => 150 entries Symbols: @@ -2407,6 +2454,7 @@ example/Synthetic#s.Bar#copy(). => method copy example/Synthetic#s.Bar. => final object Bar example/Synthetic#s.Bar.apply(). => method apply example/Synthetic#s.Bar.unapply(). => method unapply +example/Synthetic#s.Bar.unapply().(x$1) => param x$1 example/Synthetic#s.apply(). => method apply example/Synthetic#x. => val method x example/Synthetic#xs. => val method xs @@ -2628,7 +2676,7 @@ Schema => SemanticDB v4 Uri => Types.scala Text => empty Language => Scala -Symbols => 123 entries +Symbols => 125 entries Occurrences => 249 entries Symbols: @@ -2691,7 +2739,9 @@ types/Test.C#RepeatedType#m1().(x) => param x types/Test.C#RepeatedType#s. => val method s types/Test.C#RepeatedType. => final object RepeatedType types/Test.C#RepeatedType.apply(). => method apply +types/Test.C#RepeatedType.apply().(s) => param s types/Test.C#RepeatedType.unapplySeq(). => method unapplySeq +types/Test.C#RepeatedType.unapplySeq().(x$1) => param x$1 types/Test.C#TypeType. => final object TypeType types/Test.C#TypeType.T1# => type T1 types/Test.C#TypeType.T4# => type T4 @@ -3362,7 +3412,7 @@ Schema => SemanticDB v4 Uri => semanticdb-extract.scala Text => empty Language => Scala -Symbols => 14 entries +Symbols => 17 entries Occurrences => 22 entries Symbols: @@ -3373,10 +3423,13 @@ _empty_/AnObject.Foo#``(). => primary ctor _empty_/AnObject.Foo#``().(x) => val param x _empty_/AnObject.Foo#copy$default$1(). => method copy$default$1 _empty_/AnObject.Foo#copy(). => method copy +_empty_/AnObject.Foo#copy().(x) => param x _empty_/AnObject.Foo#x. => val method x _empty_/AnObject.Foo. => final object Foo _empty_/AnObject.Foo.apply(). => method apply +_empty_/AnObject.Foo.apply().(x) => param x _empty_/AnObject.Foo.unapply(). => method unapply +_empty_/AnObject.Foo.unapply().(x$1) => param x$1 _empty_/AnObject.foo(). => method foo _empty_/AnObject.foo().(x) => param x _empty_/AnObject.foo(+1). => method foo @@ -3454,3 +3507,4 @@ 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(). + From b31542b061599ef85a708c87f916ac0b762bc67f Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 19 Nov 2019 11:49:53 +0100 Subject: [PATCH 085/107] add kind queries to Scala3.infoOps --- .../dotty/tools/dotc/semanticdb/Scala3.scala | 72 ++++++++----------- 1 file changed, 31 insertions(+), 41 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index e9a49190c4fe..94eca9491167 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -150,47 +150,37 @@ object Scala3 with given infoOps: (info: SymbolInformation) with - def isAbstract: Boolean = - (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0 - - def isFinal: Boolean = - (info.properties & SymbolInformation.Property.FINAL.value) != 0 - - def isSealed: Boolean = - (info.properties & SymbolInformation.Property.SEALED.value) != 0 - - def isImplicit: Boolean = - (info.properties & SymbolInformation.Property.IMPLICIT.value) != 0 - - def isLazy: Boolean = - (info.properties & SymbolInformation.Property.LAZY.value) != 0 - - def isCase: Boolean = - (info.properties & SymbolInformation.Property.CASE.value) != 0 - - def isCovariant: Boolean = - (info.properties & SymbolInformation.Property.COVARIANT.value) != 0 - - def isContravariant: Boolean = - (info.properties & SymbolInformation.Property.CONTRAVARIANT.value) != 0 - - def isPrimary: Boolean = - (info.properties & SymbolInformation.Property.PRIMARY.value) != 0 - - def isVal: Boolean = - (info.properties & SymbolInformation.Property.VAL.value) != 0 - - def isVar: Boolean = - (info.properties & SymbolInformation.Property.VAR.value) != 0 - - def isStatic: Boolean = - (info.properties & SymbolInformation.Property.STATIC.value) != 0 - - def isEnum: Boolean = - (info.properties & SymbolInformation.Property.ENUM.value) != 0 - - def isDefault: Boolean = - (info.properties & SymbolInformation.Property.DEFAULT.value) != 0 + def isAbstract: Boolean = (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0 + def isFinal: Boolean = (info.properties & SymbolInformation.Property.FINAL.value) != 0 + def isSealed: Boolean = (info.properties & SymbolInformation.Property.SEALED.value) != 0 + def isImplicit: Boolean = (info.properties & SymbolInformation.Property.IMPLICIT.value) != 0 + def isLazy: Boolean = (info.properties & SymbolInformation.Property.LAZY.value) != 0 + def isCase: Boolean = (info.properties & SymbolInformation.Property.CASE.value) != 0 + def isCovariant: Boolean = (info.properties & SymbolInformation.Property.COVARIANT.value) != 0 + def isContravariant: Boolean = (info.properties & SymbolInformation.Property.CONTRAVARIANT.value) != 0 + def isPrimary: Boolean = (info.properties & SymbolInformation.Property.PRIMARY.value) != 0 + def isVal: Boolean = (info.properties & SymbolInformation.Property.VAL.value) != 0 + def isVar: Boolean = (info.properties & SymbolInformation.Property.VAR.value) != 0 + def isStatic: Boolean = (info.properties & SymbolInformation.Property.STATIC.value) != 0 + def isEnum: Boolean = (info.properties & SymbolInformation.Property.ENUM.value) != 0 + def isDefault: Boolean = (info.properties & SymbolInformation.Property.DEFAULT.value) != 0 + + def isUnknownKind: Boolean = info.kind.isUnknownKind + def isLocal: Boolean = info.kind.isLocal + def isField: Boolean = info.kind.isField + def isMethod: Boolean = info.kind.isMethod + def isConstructor: Boolean = info.kind.isConstructor + def isMacro: Boolean = info.kind.isMacro + def isType: Boolean = info.kind.isType + def isParameter: Boolean = info.kind.isParameter + def isSelfParameter: Boolean = info.kind.isSelfParameter + def isTypeParameter: Boolean = info.kind.isTypeParameter + def isObject: Boolean = info.kind.isObject + def isPackage: Boolean = info.kind.isPackage + def isPackageObject: Boolean = info.kind.isPackageObject + def isClass: Boolean = info.kind.isClass + def isTrait: Boolean = info.kind.isTrait + def isInterface: Boolean = info.kind.isInterface end infoOps From 9cb1d0a06b192b08bc3d24bdf906c2a1362beef2 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 19 Nov 2019 14:46:17 +0100 Subject: [PATCH 086/107] inspect inside definitions with a numbered empty name --- compiler/src/dotty/tools/dotc/ast/Trees.scala | 2 +- .../dotc/semanticdb/ExtractSemanticDB.scala | 37 +++----- .../dotty/tools/dotc/semanticdb/Scala3.scala | 92 +++++++++++-------- .../semanticdb/expect/Synthetic.expect.scala | 24 ++--- tests/semanticdb/metac.expect | 74 ++++++++------- tests/semanticdb/todo.md | 44 ++++++++- 6 files changed, 168 insertions(+), 105 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala index d22a1963aecd..25df57f6da92 100644 --- a/compiler/src/dotty/tools/dotc/ast/Trees.scala +++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala @@ -342,7 +342,7 @@ object Trees { * a calling chain from `viewExists`), in that case the return position is NoSpan. * Overridden in Bind */ - def nameSpan: Span = + def nameSpan: Span = if (span.exists) { val point = span.point if (rawMods.is(Synthetic) || name.toTermName == nme.ERROR) Span(point) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index ce861d2aed67..8584f6f6a7ea 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -13,7 +13,6 @@ import StdNames.nme import util.Spans.Span import util.{SourceFile, SourcePosition} import collection.mutable -import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} import java.nio.file.Paths import ast.untpd.given @@ -112,7 +111,8 @@ class ExtractSemanticDB extends Phase with tree match case tree: PackageDef => - if !excludeDef(tree.pid.symbol) && tree.pid.span.hasLength + if !excludeDef(tree.pid.symbol) + && tree.pid.span.hasLength tree.pid match case tree @ Select(qual, name) => registerDefinition(tree.symbol, adjustSpanToName(tree.span, qual.span, name), Set.empty) @@ -122,7 +122,8 @@ class ExtractSemanticDB extends Phase with case tree: NamedDefTree => if tree.symbol.isAllOf(ModuleValCreationFlags) return - if !excludeDef(tree.symbol) && tree.span.hasLength + if !excludeDef(tree.symbol) + && tree.span.hasLength registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree)) val privateWithin = tree.symbol.privateWithin if privateWithin.exists @@ -130,18 +131,22 @@ class ExtractSemanticDB extends Phase with else if !excludeSymbolStrict(tree.symbol) registerSymbol(tree.symbol, symbolName(tree.symbol), symbolKinds(tree)) tree match - case tree: ValDef if tree.symbol.isAllOf(EnumValue) => + case tree: ValDef + if tree.symbol.isAllOf(EnumValue) => tree.rhs match case Block(TypeDef(_, template: Template) :: _, _) => // simple case with specialised extends clause template.parents.foreach(traverse) case _ => // calls $new - case tree: ValDef if tree.symbol.isSelfSym => + case tree: ValDef + if tree.symbol.isSelfSym => if tree.tpt.span.hasLength traverse(tree.tpt) - case tree: DefDef if tree.symbol.isConstructor => // ignore typeparams for secondary ctors + case tree: DefDef + if tree.symbol.isConstructor => // ignore typeparams for secondary ctors tree.vparamss.foreach(_.foreach(traverse)) traverse(tree.rhs) - case tree: (DefDef | ValDef) if tree.symbol.isSyntheticWithIdent => + case tree: (DefDef | ValDef) + if tree.symbol.isSyntheticWithIdent => tree match case tree: DefDef => tree.tparams.foreach(tparam => registerSymbolSimple(tparam.symbol)) @@ -211,19 +216,11 @@ class ExtractSemanticDB extends Phase with /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = - def isJavaIdent(str: String) = - isJavaIdentifierStart(str.head) && str.tail.forall(isJavaIdentifierPart) - def addName(name: Name) = val str = name.toString.unescapeUnicode - if isJavaIdent(str) then b append str + if str.isJavaIdent then b append str else b append '`' append str append '`' - /** Is symbol global? Non-global symbols get localNå names */ - def isGlobal(sym: Symbol): Boolean = - sym.is(Package) - || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && isGlobal(sym.owner) - def addOwner(owner: Symbol): Unit = if !owner.isRoot then addSymName(b, owner) @@ -280,7 +277,7 @@ class ExtractSemanticDB extends Phase with locals.getOrElseUpdate(sym, computeLocalIdx()) if sym.exists then - if isGlobal(sym) then + if sym.isGlobal then addOwner(sym.owner); addDescriptor(sym) else b.append(Symbols.LocalPrefix).append(localIdx(sym)) @@ -301,10 +298,6 @@ class ExtractSemanticDB extends Phase with val (endLine, endCol) = lineCol(span.end) Some(Range(startLine, startCol, endLine, endCol)) - private inline def (name: Name) isEmptyNumbered: Boolean = name match - case NameKinds.AnyNumberedName(nme.EMPTY, _) => true - case _ => false - private def symbolKind(sym: Symbol, symkinds: Set[SymbolKind])(given Context): SymbolInformation.Kind = if sym.isTypeParam SymbolInformation.Kind.TYPE_PARAMETER @@ -457,7 +450,7 @@ class ExtractSemanticDB extends Phase with case Nil => Nil private def (sym: Symbol) adjustIfCtorTyparam(given Context) = - if sym.isType && sym.owner.isConstructor + if sym.isType && sym.owner.exists && sym.owner.isConstructor matchingMemberType(sym, sym.owner.owner) else sym diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index 94eca9491167..b29f027eeb60 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -1,21 +1,23 @@ package dotty.tools.dotc.semanticdb -import dotty.tools.dotc.core.Symbols.{ Symbol , defn } -import dotty.tools.dotc.core.Contexts.Context -import dotty.tools.dotc.core.Names -import dotty.tools.dotc.core.Names.Name -import dotty.tools.dotc.core.Types.Type -import dotty.tools.dotc.core.Flags._ -import dotty.tools.dotc.core.NameKinds -import dotty.tools.dotc.core.NameOps -import dotty.tools.dotc.core.StdNames.nme +import dotty.tools.dotc.core +import core.Symbols.{ Symbol , defn } +import core.Contexts.Context +import core.Names +import core.Names.Name +import core.Types.Type +import core.Flags._ +import core.NameKinds +import core.StdNames.nme + +import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart} import scala.annotation.internal.sharable import scala.annotation.switch object Scala3 with import Symbols._ - import NameOps.given + import core.NameOps.given @sharable private val unicodeEscape = raw"\$$u(\p{XDigit}{4})".r @sharable private val locals = raw"local(\d+)".r @@ -44,7 +46,6 @@ object Scala3 with object Symbols with - val NoSymbol: String = "" val RootPackage: String = "_root_/" val EmptyPackage: String = "_empty_/" val LocalPrefix: String = "local" @@ -66,7 +67,7 @@ object Scala3 with end Symbols - given nameOps: (name: Name) with + given NameOps: (name: Name) with def isWildcard = name match case nme.WILDCARD | WILDCARDTypeName => true @@ -79,9 +80,16 @@ object Scala3 with case NameKinds.ModuleClassName(original) => original.isScala2PackageObjectName case _ => false - end nameOps + def isEmptyNumbered: Boolean = + !name.is(NameKinds.WildcardParamName) + && { name match + case NameKinds.AnyNumberedName(nme.EMPTY, _) => true + case _ => false + } - given symbolOps: (sym: Symbol) with + end NameOps + + given SymbolOps: (sym: Symbol) with def isScala2PackageObject(given Context): Boolean = sym.name.isScala2PackageObjectName && sym.owner.is(Package) && sym.is(Module) @@ -101,24 +109,31 @@ object Scala3 with sym.owner.info.decls.find(s => s.name == setterName && s.info.matchingType) + /** Is symbol global? Non-global symbols get localN names */ + def isGlobal(given Context): Boolean = + sym.is(Package) + || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && sym.owner.isGlobal + + def isLocalWithinSameName(given Context): Boolean = + sym.exists && !sym.isGlobal && sym.name == sym.owner.name + /** Synthetic symbols that are not anonymous or numbered empty ident */ def isSyntheticWithIdent(given Context): Boolean = - sym.is(Synthetic) && !sym.isAnonymous + sym.is(Synthetic) && !sym.isAnonymous && !sym.name.isEmptyNumbered - end symbolOps + end SymbolOps object LocalSymbol with - def unapply(symbolInfo: SymbolInformation): Option[Int] = - symbolInfo.symbol match - case locals(ints) => - val bi = BigInt(ints) - if bi.isValidInt - Some(bi.toInt) - else - None + def unapply(symbolInfo: SymbolInformation): Option[Int] = symbolInfo.symbol match + case locals(ints) => + val bi = BigInt(ints) + if bi.isValidInt + Some(bi.toInt) + else + None - case _ => None + case _ => None end LocalSymbol @@ -126,29 +141,32 @@ object Scala3 with case '/' | '.' | '#' | ']' | ')' => true case _ => false - given stringOps: (symbol: String) with + given StringOps: (symbol: String) with - def isNoSymbol: Boolean = NoSymbol == symbol + def isSymbol: Boolean = !symbol.isEmpty def isRootPackage: Boolean = RootPackage == symbol def isEmptyPackage: Boolean = EmptyPackage == symbol - def isGlobal: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last.`is/.#])` - def isLocal: Boolean = !symbol.isNoSymbol && !symbol.isMulti && !symbol.last.`is/.#])` + def isGlobal: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last.`is/.#])` + def isLocal: Boolean = !symbol.isEmpty && !symbol.isMulti && !symbol.last.`is/.#])` def isMulti: Boolean = symbol startsWith ";" def isConstructor: Boolean = ctor matches symbol - def isPackage: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '/' - def isTerm: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '.' - def isType: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == '#' - def isTypeParameter: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ']' - def isParameter: Boolean = !symbol.isNoSymbol && !symbol.isMulti && symbol.last == ')' + def isPackage: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == '/' + def isTerm: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == '.' + def isType: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == '#' + def isTypeParameter: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == ']' + def isParameter: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last == ')' def unescapeUnicode = unicodeEscape.replaceAllIn(symbol, m => String.valueOf(Integer.parseInt(m.group(1), 16).toChar)) - end stringOps + def isJavaIdent = + isJavaIdentifierStart(symbol.head) && symbol.tail.forall(isJavaIdentifierPart) + + end StringOps - given infoOps: (info: SymbolInformation) with + given InfoOps: (info: SymbolInformation) with def isAbstract: Boolean = (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0 def isFinal: Boolean = (info.properties & SymbolInformation.Property.FINAL.value) != 0 @@ -182,6 +200,6 @@ object Scala3 with def isTrait: Boolean = info.kind.isTrait def isInterface: Boolean = info.kind.isInterface - end infoOps + end InfoOps end Scala3 diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala index 836d9dbf8147..3486bb82773a 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -9,15 +9,15 @@ class Synthetic/*<-example::Synthetic#*/ { // See https://github.com/scalameta/scalameta/issues/977 val Name/*<-example::Synthetic#Name.*/ = /*->scala::Predef.augmentString().*/"name:(.*)".r/*->scala::collection::StringOps#r().*/ - /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/val x/*<-example::Synthetic#x.*/ #:: xs/*<-example::Synthetic#xs.*/ = LazyList(1, 2) - val Name/*->example::Synthetic#Name.*//*->scala::util::matching::Regex#unapplySeq().*/(name/*<-example::Synthetic#name.*//*<-local0*/)/*->local0*/ = "name:foo" + /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/val x/*<-local0*//*<-example::Synthetic#x.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ xs/*<-local1*//*<-example::Synthetic#xs.*//*->local0*//*->local1*/ = LazyList/*->scala::package.LazyList.*//*->scala::collection::IterableFactory#apply().*/(1, 2) + val Name/*->example::Synthetic#Name.*//*->scala::util::matching::Regex#unapplySeq().*/(name/*<-example::Synthetic#name.*//*<-local2*/)/*->local2*/ = "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 lst/*<-example::Synthetic#lst.*/ = 1 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/2 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*//*->scala::collection::immutable::LazyList.Deferrer#`#::`().*/ - for (x/*<-local1*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y/*<-local2*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(x/*->local1*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local1*/) - for (i/*<-local3*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local4*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (i/*->local3*/, j/*->local4*/) - for (i/*<-local5*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local6*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::IterableOps#withFilter().*/ if i/*->local5*/ %/*->scala::Int#`%`(+3).*/ 2 ==/*->scala::Int#`==`(+3).*/ 0/*->scala::collection::WithFilter#map().*/) yield (i/*->local5*/, j/*->local6*/) + for (x/*<-local3*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y/*<-local4*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(x/*->local3*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local3*/) + for (i/*<-local5*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local6*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (i/*->local5*/, j/*->local6*/) + for (i/*<-local7*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local8*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::IterableOps#withFilter().*/ if i/*->local7*/ %/*->scala::Int#`%`(+3).*/ 2 ==/*->scala::Int#`==`(+3).*/ 0/*->scala::collection::WithFilter#map().*/) yield (i/*->local7*/, j/*->local8*/) object s/*<-example::Synthetic#s.*/ { def apply/*<-example::Synthetic#s.apply().*/() = 2 @@ -36,13 +36,13 @@ class Synthetic/*<-example::Synthetic#*/ { import scala.concurrent.ExecutionContext/*->scala::concurrent::ExecutionContext.*/.Implicits/*->scala::concurrent::ExecutionContext.Implicits.*/.global/*->scala::concurrent::ExecutionContext.Implicits.global().*/ for { - a/*<-local7*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#foreach().*/ - b/*<-local8*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#foreach().*/ - } println/*->scala::Predef.println(+1).*/(a/*->local7*/)/*->scala::concurrent::ExecutionContext.Implicits.global().*/ + a/*<-local9*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#foreach().*/ + b/*<-local10*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#foreach().*/ + } println/*->scala::Predef.println(+1).*/(a/*->local9*/)/*->scala::concurrent::ExecutionContext.Implicits.global().*/ for { - a/*<-local9*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#flatMap().*/ - b/*<-local10*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#withFilter().*/ - if a/*->local9*/ scala::Int#`<`(+3).*/ b/*->local10*//*->scala::concurrent::Future#map().*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ - } yield a/*->local9*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ + a/*<-local11*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#flatMap().*/ + b/*<-local12*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#withFilter().*/ + if a/*->local11*/ scala::Int#`<`(+3).*/ b/*->local12*//*->scala::concurrent::Future#map().*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ + } yield a/*->local11*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ } diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 14d95fb200c2..224bd080add3 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -2430,8 +2430,8 @@ Schema => SemanticDB v4 Uri => Synthetic.scala Text => empty Language => Scala -Symbols => 35 entries -Occurrences => 150 entries +Symbols => 37 entries +Occurrences => 158 entries Symbols: example/Synthetic# => class Synthetic @@ -2458,17 +2458,19 @@ 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 => val local name -local1 => param x -local2 => param y -local3 => param i -local4 => param j +local0 => val local x +local1 => val local xs +local2 => val local name +local3 => param x +local4 => param y local5 => param i local6 => param j -local7 => param a -local8 => param b +local7 => param i +local8 => param j local9 => param a local10 => param b +local11 => param a +local12 => param b Occurrences: [0:8..0:15): example <- example/ @@ -2495,13 +2497,21 @@ Occurrences: [10:25..10:26): r -> scala/collection/StringOps#r(). [11:2..11:2): -> scala/Tuple2#_1. [11:2..11:2): -> scala/Tuple2#_2. +[11:6..11:7): x <- local0 [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 <- local1 [11:12..11:14): xs <- example/Synthetic#xs. +[11:14..11:14): -> local0 +[11:14..11:14): -> local1 +[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. -[12:11..12:15): name <- local0 -[12:16..12:16): -> local0 +[12:11..12:15): name <- local2 +[12:16..12:16): -> local2 [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. @@ -2513,42 +2523,42 @@ Occurrences: [15:24..15:32): LazyList -> scala/package.LazyList. [15:33..15:38): empty -> scala/collection/immutable/LazyList.empty(). [15:38..15:38): -> scala/collection/immutable/LazyList.Deferrer#`#::`(). -[17:7..17:8): x <- local1 +[17:7..17:8): x <- local3 [17:12..17:12): -> scala/LowPriorityImplicits#intWrapper(). [17:14..17:16): to -> scala/runtime/RichInt#to(). [17:19..17:19): -> scala/collection/immutable/Range#foreach(). -[17:21..17:22): y <- local2 +[17:21..17:22): y <- local4 [17:26..17:26): -> scala/LowPriorityImplicits#intWrapper(). [17:28..17:33): until -> scala/runtime/RichInt#until(). [17:36..17:36): -> scala/collection/immutable/Range#foreach(). [17:38..17:45): println -> scala/Predef.println(+1). -[17:46..17:47): x -> local1 +[17:46..17:47): x -> local3 [17:48..17:50): -> -> scala/Predef.ArrowAssoc#`->`(). -[17:51..17:52): x -> local1 -[18:7..18:8): i <- local3 +[17:51..17:52): x -> local3 +[18:7..18:8): i <- local5 [18:12..18:12): -> scala/LowPriorityImplicits#intWrapper(). [18:14..18:16): to -> scala/runtime/RichInt#to(). [18:19..18:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). -[18:21..18:22): j <- local4 +[18:21..18:22): j <- local6 [18:26..18:26): -> scala/LowPriorityImplicits#intWrapper(). [18:28..18:33): until -> scala/runtime/RichInt#until(). [18:36..18:36): -> scala/collection/immutable/Range#map(). -[18:45..18:46): i -> local3 -[18:48..18:49): j -> local4 -[19:7..19:8): i <- local5 +[18:45..18:46): i -> local5 +[18:48..18:49): j -> local6 +[19:7..19:8): i <- local7 [19:12..19:12): -> scala/LowPriorityImplicits#intWrapper(). [19:14..19:16): to -> scala/runtime/RichInt#to(). [19:19..19:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). -[19:21..19:22): j <- local6 +[19:21..19:22): j <- local8 [19:26..19:26): -> scala/LowPriorityImplicits#intWrapper(). [19:28..19:33): until -> scala/runtime/RichInt#until(). [19:36..19:36): -> scala/collection/IterableOps#withFilter(). -[19:40..19:41): i -> local5 +[19:40..19:41): i -> local7 [19:42..19:43): % -> scala/Int#`%`(+3). [19:46..19:48): == -> scala/Int#`==`(+3). [19:50..19:50): -> scala/collection/WithFilter#map(). -[19:59..19:60): i -> local5 -[19:62..19:63): j -> local6 +[19:59..19:60): i -> local7 +[19:62..19:63): j -> local8 [21:9..21:10): s <- example/Synthetic#s. [22:8..22:13): apply <- example/Synthetic#s.apply(). [23:5..23:5): -> example/Synthetic#s.apply(). @@ -2587,39 +2597,39 @@ Occurrences: [36:26..36:42): ExecutionContext -> scala/concurrent/ExecutionContext. [36:43..36:52): Implicits -> scala/concurrent/ExecutionContext.Implicits. [36:53..36:59): global -> scala/concurrent/ExecutionContext.Implicits.global(). -[38:4..38:5): a <- local7 +[38:4..38:5): a <- local9 [38:9..38:14): scala -> scala/ [38:15..38:25): concurrent -> scala/concurrent/ [38:26..38:32): Future -> scala/concurrent/Future. [38:33..38:43): successful -> scala/concurrent/Future.successful(). [38:46..38:46): -> scala/concurrent/Future#foreach(). -[39:4..39:5): b <- local8 +[39:4..39:5): b <- local10 [39:9..39:14): scala -> scala/ [39:15..39:25): concurrent -> scala/concurrent/ [39:26..39:32): Future -> scala/concurrent/Future. [39:33..39:43): successful -> scala/concurrent/Future.successful(). [39:46..39:46): -> scala/concurrent/Future#foreach(). [40:4..40:11): println -> scala/Predef.println(+1). -[40:12..40:13): a -> local7 +[40:12..40:13): a -> local9 [40:14..40:14): -> scala/concurrent/ExecutionContext.Implicits.global(). -[42:4..42:5): a <- local9 +[42:4..42:5): a <- local11 [42:9..42:14): scala -> scala/ [42:15..42:25): concurrent -> scala/concurrent/ [42:26..42:32): Future -> scala/concurrent/Future. [42:33..42:43): successful -> scala/concurrent/Future.successful(). [42:46..42:46): -> scala/concurrent/Future#flatMap(). -[43:4..43:5): b <- local10 +[43:4..43:5): b <- local12 [43:9..43:14): scala -> scala/ [43:15..43:25): concurrent -> scala/concurrent/ [43:26..43:32): Future -> scala/concurrent/Future. [43:33..43:43): successful -> scala/concurrent/Future.successful(). [43:46..43:46): -> scala/concurrent/Future#withFilter(). -[44:7..44:8): a -> local9 +[44:7..44:8): a -> local11 [44:9..44:10): < -> scala/Int#`<`(+3). -[44:11..44:12): b -> local10 +[44:11..44:12): b -> local12 [44:12..44:12): -> scala/concurrent/Future#map(). [44:12..44:12): -> scala/concurrent/ExecutionContext.Implicits.global(). -[45:10..45:11): a -> local9 +[45:10..45:11): a -> local11 [45:11..45:11): -> scala/concurrent/ExecutionContext.Implicits.global(). expect/Traits.scala diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md index 1aef287ec5a3..99fd4705a557 100644 --- a/tests/semanticdb/todo.md +++ b/tests/semanticdb/todo.md @@ -1,6 +1,48 @@ -## Todo List +# Todo List Differences between scalameta implementation and dotc. - [ ] For comprehension in Synthetic section. - [ ] Implicit conversions in Synthetic section. - [ ] Record all definitions in Symbols section. + +## ValPatterns + +Val patterns are tricky due to desugaring before ExtractSemanticDB sees them. + +### Tuples +```scala +val (left, right) = (1, 2) +``` +desugars to +```scala +private[this] val $3$: (Int, Int) = Tuple2.apply[Int, Int](1, 2) +val left: Int = this.$3$._1 +val right: Int = this.$3$._2 +``` + +### Product1 Pattern +```scala +val Some(number1) = Some(1) +``` +desugars to +```scala +val number1: Int = Some.apply[Int](1):Some[Int] @unchecked match { + case Some.unapply[Int](number1 @ _):Some[Int] => number1:Int +} +``` + +### ProductN Pattern +```scala +val x #:: xs = LazyList(1, 2) +``` +desugars to +```scala +private[this] val $2$: (Int, LazyList[Int]) = + LazyList.apply[Int]([1,2 : Int]:Int*):LazyList[Int] @unchecked match { + case #::.unapply[Int](x @ _, xs @ _):LazyList[Int] => Tuple2.apply[Int, LazyList[Int]](x, xs) + } +val x: Int = this.$2$._1 +val xs: LazyList[Int] = this.$2$._2 +``` + +perhaps it is safe to recognise these patterns if the binds were made synthetic. From a051a03e42477dc602ca467b562b3d4c4a68bd97 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 20 Nov 2019 13:58:24 +0100 Subject: [PATCH 087/107] define anon classes --- .../dotc/semanticdb/ExtractSemanticDB.scala | 13 +++-- .../dotty/tools/dotc/semanticdb/Scala3.scala | 4 ++ tests/semanticdb/expect/Advanced.expect.scala | 4 +- .../semanticdb/expect/Anonymous.expect.scala | 2 +- tests/semanticdb/expect/Classes.expect.scala | 2 +- tests/semanticdb/expect/Traits.expect.scala | 2 +- tests/semanticdb/expect/Types.expect.scala | 6 +-- tests/semanticdb/metac.expect | 50 ++++++++----------- 8 files changed, 43 insertions(+), 40 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 8584f6f6a7ea..8ef09a86879c 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -72,7 +72,7 @@ class ExtractSemanticDB extends Phase with !sym.exists || sym.isLocalDummy || sym.is(Synthetic) - || sym.isConstructor && sym.owner.is(ModuleClass) + || sym.isConstructor && (sym.owner.is(ModuleClass) || !sym.isGlobal) || excludeDefStrict(sym) private def excludeDefStrict(sym: Symbol)(given Context): Boolean = @@ -81,7 +81,8 @@ class ExtractSemanticDB extends Phase with private def excludeSymbolStrict(sym: Symbol)(given Context): Boolean = sym.name.isWildcard - || sym.isAnonymous + || sym.isAnonymousFunction + || sym.isAnonymousModuleVal || sym.name.isEmptyNumbered private def excludeChildren(sym: Symbol)(given Context): Boolean = @@ -124,7 +125,7 @@ class ExtractSemanticDB extends Phase with return if !excludeDef(tree.symbol) && tree.span.hasLength - registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree)) + registerDefinition(tree.symbol, tree.adjustedNameSpan, symbolKinds(tree)) val privateWithin = tree.symbol.privateWithin if privateWithin.exists registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) @@ -213,6 +214,12 @@ class ExtractSemanticDB extends Phase with case _ => traverseChildren(tree) + private def (tree: NamedDefTree) adjustedNameSpan(given Context): Span = + if tree.span.exists && tree.name.isAnonymousFunctionName || tree.name.isAnonymousClassName + Span(tree.span.point) + else + tree.nameSpan + /** Add semanticdb name of the given symbol to string builder */ private def addSymName(b: StringBuilder, sym: Symbol)(given ctx: Context): Unit = diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index b29f027eeb60..478d9c81d012 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -202,4 +202,8 @@ object Scala3 with end InfoOps + given RangeOps: (range: Range) with + def hasLength = range.endLine > range.startLine || range.endCharacter > range.startCharacter + end RangeOps + end Scala3 diff --git a/tests/semanticdb/expect/Advanced.expect.scala b/tests/semanticdb/expect/Advanced.expect.scala index e4ae3370cba8..6597e002315f 100644 --- a/tests/semanticdb/expect/Advanced.expect.scala +++ b/tests/semanticdb/expect/Advanced.expect.scala @@ -11,8 +11,8 @@ 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#*/ } = /*<-local2*/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#*/ } = /*<-local6*/new { def m/*<-local7*/(x/*<-local8*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } } class Wildcards/*<-advanced::Wildcards#*/ { diff --git a/tests/semanticdb/expect/Anonymous.expect.scala b/tests/semanticdb/expect/Anonymous.expect.scala index ee2d433facb5..a2b05c89eaa7 100644 --- a/tests/semanticdb/expect/Anonymous.expect.scala +++ b/tests/semanticdb/expect/Anonymous.expect.scala @@ -16,5 +16,5 @@ class Anonymous/*<-example::Anonymous#*/ { } trait Foo/*<-example::Anonymous#Foo#*/ - val foo/*<-example::Anonymous#foo.*/ = new Foo/*->example::Anonymous#Foo#*/ {} + val foo/*<-example::Anonymous#foo.*/ = /*<-local1*/new Foo/*->example::Anonymous#Foo#*/ {} } diff --git a/tests/semanticdb/expect/Classes.expect.scala b/tests/semanticdb/expect/Classes.expect.scala index c7418107c372..571887c48600 100644 --- a/tests/semanticdb/expect/Classes.expect.scala +++ b/tests/semanticdb/expect/Classes.expect.scala @@ -23,7 +23,7 @@ class C8/*<-classes::C8#*/(private[this] val x/*<-classes::C8#x.*/: Int/*->scala class C9/*<-classes::C9#*/(private[this] var x/*<-classes::C9#x().*/: Int/*->scala::Int#*/) object N/*<-classes::N.*/ { - val anonClass/*<-classes::N.anonClass.*/ = new C7/*->classes::C7#*/(42) { + val anonClass/*<-classes::N.anonClass.*/ = /*<-local0*/new C7/*->classes::C7#*/(42) { val local/*<-local1*/ = ???/*->scala::Predef.`???`().*/ } val anonFun/*<-classes::N.anonFun.*/ = List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).map/*->scala::collection::immutable::List#map().*/ { i/*<-local2*/ => diff --git a/tests/semanticdb/expect/Traits.expect.scala b/tests/semanticdb/expect/Traits.expect.scala index 193390b38826..f45d91a78098 100644 --- a/tests/semanticdb/expect/Traits.expect.scala +++ b/tests/semanticdb/expect/Traits.expect.scala @@ -6,7 +6,7 @@ trait T/*<-traits::T#*/ { sealed trait U/*<-traits::U#*/ object U/*<-traits::U.*/ { - def u/*<-traits::U.u().*/: U/*->traits::U#*/ = new U/*->traits::U#*/ {} + def u/*<-traits::U.u().*/: U/*->traits::U#*/ = /*<-local0*/new U/*->traits::U#*/ {} } class C/*<-traits::C#*/ diff --git a/tests/semanticdb/expect/Types.expect.scala b/tests/semanticdb/expect/Types.expect.scala index 5f5267258824..57cc3e8131b2 100644 --- a/tests/semanticdb/expect/Types.expect.scala +++ b/tests/semanticdb/expect/Types.expect.scala @@ -55,9 +55,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 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 compoundType4/*<-types::Test.C#compoundType4.*/ = /*<-local2*/new { def k/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + val compoundType5/*<-types::Test.C#compoundType5.*/ = /*<-local4*/new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ + val compoundType6/*<-types::Test.C#compoundType6.*/ = /*<-local5*/new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ { def k/*<-local6*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } val annType1/*<-types::Test.C#annType1.*/: T/*->types::T#*/ @ann(42) = ???/*->scala::Predef.`???`().*/ val annType2/*<-types::Test.C#annType2.*/: T/*->types::T#*/ @ann1 @ann2 = ???/*->scala::Predef.`???`().*/ diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 224bd080add3..76f63e39ba07 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -50,7 +50,7 @@ Uri => Advanced.scala Text => empty Language => Scala Symbols => 34 entries -Occurrences => 96 entries +Occurrences => 94 entries Symbols: advanced/C# => class C @@ -78,11 +78,11 @@ advanced/Wildcards#``(). => primary ctor advanced/Wildcards#e1(). => method e1 local0 => abstract val method x local1 => abstract val method x -local2 => primary ctor +local2 => final class $anon local3 => val method x local4 => abstract method m local5 => param x -local6 => primary ctor +local6 => final class $anon local7 => method m local8 => param x local9 => val local e3 @@ -115,23 +115,21 @@ Occurrences: [13:6..13:8): s2 <- advanced/Structural#s2(). [13:16..13:17): x <- local1 [13:19..13:22): Int -> scala/Int# -[13:33..13:33): <- local2 +[13:27..13:27): <- local2 [13:37..13:38): x <- local3 [13:40..13:43): Int -> scala/Int# [13:46..13:49): ??? -> scala/Predef.`???`(). -[13:51..13:51): -> local2 [14:6..14:8): s3 <- advanced/Structural#s3(). [14:16..14:17): m <- local4 [14:18..14:19): x <- local5 [14:21..14:24): Int -> scala/Int# [14:27..14:30): Int -> scala/Int# -[14:41..14:41): <- local6 +[14:35..14:35): <- local6 [14:45..14:46): m <- local7 [14:47..14:48): x <- local8 [14:50..14:53): Int -> scala/Int# [14:56..14:59): Int -> scala/Int# [14:62..14:65): ??? -> scala/Predef.`???`(). -[14:67..14:67): -> local6 [17:6..17:15): Wildcards <- advanced/Wildcards# [18:2..18:2): <- advanced/Wildcards#``(). [18:6..18:8): e1 <- advanced/Wildcards#e1(). @@ -283,7 +281,7 @@ Uri => Anonymous.scala Text => empty Language => Scala Symbols => 13 entries -Occurrences => 34 entries +Occurrences => 33 entries Symbols: example/Anonymous# => class Anonymous @@ -298,7 +296,7 @@ example/Anonymous#m1(). => method m1 example/Anonymous#m1().[T] => typeparam T example/Anonymous#m2(). => method m2 local0 => val local x -local1 => primary ctor +local1 => final class $anon Occurrences: [0:8..0:15): example <- example/ @@ -332,9 +330,8 @@ Occurrences: [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:16): <- local1 +[18:12..18:12): <- local1 [18:16..18:19): Foo -> example/Anonymous#Foo# -[18:22..18:22): -> local1 expect/Classes.scala ____________________ @@ -345,7 +342,7 @@ Uri => Classes.scala Text => empty Language => Scala Symbols => 75 entries -Occurrences => 60 entries +Occurrences => 59 entries Symbols: classes/C1# => final class C1 @@ -419,7 +416,7 @@ classes/M.C5().(x) => param x classes/N. => final object N classes/N.anonClass. => val method anonClass classes/N.anonFun. => val method anonFun -local0 => primary ctor +local0 => final class $anon local1 => val method local local2 => param i local3 => val local local @@ -471,12 +468,11 @@ Occurrences: [22:30..22:33): Int -> scala/Int# [24:7..24:8): N <- classes/N. [25:6..25:15): anonClass <- classes/N.anonClass. -[25:22..25:22): <- local0 +[25:18..25:18): <- local0 [25:22..25:24): C7 -> classes/C7# [25:24..25:24): -> classes/C7#``(). [26:8..26:13): local <- local1 [26:16..26:19): ??? -> scala/Predef.`???`(). -[27:3..27:3): -> local0 [28:6..28:13): anonFun <- classes/N.anonFun. [28:16..28:20): List -> scala/package.List. [28:20..28:20): -> scala/collection/IterableFactory#apply(). @@ -2641,10 +2637,10 @@ Uri => Traits.scala Text => empty Language => Scala Symbols => 13 entries -Occurrences => 18 entries +Occurrences => 17 entries Symbols: -local0 => primary ctor +local0 => final class $anon local1 => selfparam self traits/C# => class C traits/C#``(). => primary ctor @@ -2668,9 +2664,8 @@ Occurrences: [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:17): <- local0 +[8:13..8:13): <- local0 [8:17..8:18): U -> traits/U# -[8:21..8:21): -> local0 [11:0..11:0): <- traits/C#``(). [11:6..11:7): C <- traits/C# [12:6..12:7): V <- traits/V# @@ -2687,15 +2682,15 @@ Uri => Types.scala Text => empty Language => Scala Symbols => 125 entries -Occurrences => 249 entries +Occurrences => 246 entries Symbols: local0 => abstract method k local1 => abstract method k -local2 => primary ctor +local2 => final class $anon local3 => method k -local4 => primary ctor -local5 => primary ctor +local4 => final class $anon +local5 => final class $anon local6 => method k local7 => type L local8 => typeparam T @@ -2939,26 +2934,23 @@ Occurrences: [56:41..56:44): Int -> scala/Int# [56:49..56:52): ??? -> scala/Predef.`???`(). [57:8..57:21): compoundType4 <- types/Test.C#compoundType4. -[57:30..57:30): <- local2 +[57:24..57:24): <- local2 [57:34..57:35): k <- local3 [57:37..57:40): Int -> scala/Int# [57:43..57:46): ??? -> scala/Predef.`???`(). -[57:48..57:48): -> local2 [58:8..58:21): compoundType5 <- types/Test.C#compoundType5. -[58:28..58:28): <- local4 +[58:24..58:24): <- local4 [58:28..58:29): M -> types/Test.M# [58:29..58:29): -> types/Test.M#``(). [58:35..58:36): N -> types/Test.N# -[58:36..58:36): -> local4 [59:8..59:21): compoundType6 <- types/Test.C#compoundType6. -[59:28..59:28): <- local5 +[59:24..59:24): <- local5 [59:28..59:29): M -> types/Test.M# [59:29..59:29): -> types/Test.M#``(). [59:35..59:36): N -> types/Test.N# [59:43..59:44): k <- local6 [59:46..59:49): Int -> scala/Int# [59:52..59:55): ??? -> scala/Predef.`???`(). -[59:57..59:57): -> local5 [61:8..61:16): annType1 <- types/Test.C#annType1. [61:18..61:19): T -> types/T# [61:31..61:34): ??? -> scala/Predef.`???`(). From eb3ba6c6d5564becb861e15ffa278ee777d5505f Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 20 Nov 2019 14:19:28 +0100 Subject: [PATCH 088/107] refactor tools --- .../dotty/tools/dotc/semanticdb/Scala3.scala | 61 +++++++ .../dotty/tools/dotc/semanticdb/Tools.scala} | 151 ++++-------------- .../dotc/semanticdb/SemanticdbTests.scala | 47 +++++- 3 files changed, 133 insertions(+), 126 deletions(-) rename compiler/{test/dotty/tools/dotc/semanticdb/Semanticdbs.scala => src/dotty/tools/dotc/semanticdb/Tools.scala} (57%) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index 478d9c81d012..363d8cdbfac2 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -206,4 +206,65 @@ object Scala3 with def hasLength = range.endLine > range.startLine || range.endCharacter > range.startCharacter end RangeOps + /** Sort symbol occurrences by their start position. */ + given OccurrenceOrdering: Ordering[SymbolOccurrence] = (x, y) => + x.range -> y.range match + case None -> _ | _ -> None => 0 + case Some(a) -> Some(b) => + val byLine = Integer.compare(a.startLine, b.startLine) + if (byLine != 0) + byLine + else // byCharacter + Integer.compare(a.startCharacter, b.startCharacter) + end OccurrenceOrdering + + given Ordering[SymbolInformation] = Ordering.by[SymbolInformation, String](_.symbol)(IdentifierOrdering()) + + /** + * A comparator for identifier like "Predef" or "Function10". + * + * Differences from the default string comparator: + * - works with CharSequences like compiler `Name` + * - orders numbers by their numerical value instead of lexicographical + * - Good: `Function1`, `Function2`, `Function10` + * - Bad: `Function1`, `Function10`, `Function2` + * + * taken from https://github.com/scalameta/scalameta/blob/master/semanticdb/metap/src/main/scala/scala/meta/internal/metap/IdentifierOrdering.scala + */ + private class IdentifierOrdering[T <: CharSequence] extends Ordering[T] with + + override def compare(o1: T, o2: T): Int = + val len = math.min(o1.length(), o2.length()) + var i = 0 + while i < len do + val a = o1.charAt(i) + val b = o2.charAt(i) + if a.isDigit && b.isDigit + val byDigit = Integer.compare(toDigit(o1, i), toDigit(o2, i)) + if (byDigit != 0) return byDigit + else + i = seekNonDigit(o1, i) + else + val result = Character.compare(a, b) + if result != 0 + return result + i += 1 + end while + Integer.compare(o1.length(), o2.length()) + end compare + + private def seekNonDigit(cs: T, i: Int): Int = + var curr = i + while curr < cs.length && cs.charAt(curr).isDigit do + curr += 1 + curr + end seekNonDigit + + private def toDigit(cs: T, i: Int): Int = + val digit = cs.subSequence(i, seekNonDigit(cs, i)) + Integer.parseUnsignedInt(digit.toString) + end toDigit + + end IdentifierOrdering + end Scala3 diff --git a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala similarity index 57% rename from compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala rename to compiler/src/dotty/tools/dotc/semanticdb/Tools.scala index aea8202198c0..dc962b7fb05b 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/Semanticdbs.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala @@ -6,7 +6,7 @@ import scala.collection.JavaConverters._ import dotty.tools.dotc.util.SourceFile import dotty.tools.dotc.semanticdb.Scala3.{_, given} -object Semanticdbs with +object Tools with /** Load SemanticDB TextDocument for a single Scala source file * @@ -35,45 +35,33 @@ object Semanticdbs with end loadTextDocument /** Parses SemanticDB text documents from an absolute path to a `*.semanticdb` file. */ - def parseTextDocuments(path: Path): TextDocuments = + private def parseTextDocuments(path: Path): TextDocuments = val bytes = Files.readAllBytes(path) // NOTE: a semanticdb file is a TextDocuments message, not TextDocument TextDocuments.parseFrom(bytes) - /** Prettyprint a text document with symbol occurrences next to each resolved identifier. - * - * Useful for testing purposes to ensure that SymbolOccurrence values make sense and are correct. - * Example output (NOTE, slightly modified to avoid "unclosed comment" errors): - * {{{ - * class Example *example/Example#* { - * val a *example/Example#a.* : String *scala/Predef.String#* = "1" - * } - * }}} - **/ - def printTextDocument(doc: TextDocument): String = - val symtab = doc.symbols.iterator.map(info => info.symbol -> info).toMap - val sb = StringBuilder(1000) - val sourceFile = SourceFile.virtual(doc.uri, doc.text) - var offset = 0 - for occ <- doc.occurrences.sorted do - val range = occ.range.get - val end = math.max( - offset, - sourceFile.lineToOffset(range.endLine) + range.endCharacter - ) - val isPrimaryConstructor = - symtab.get(occ.symbol).exists(_.isPrimary) - if !occ.symbol.isPackage && !isPrimaryConstructor - sb.append(doc.text.substring(offset, end)) - sb.append("/*") - .append(if (occ.role.isDefinition) "<-" else "->") - .append(occ.symbol.replace("/", "::")) - .append("*/") - offset = end - sb.append(doc.text.substring(offset)) - sb.toString - end printTextDocument + def metac(doc: TextDocument, realPath: Path)(given sb: StringBuilder): StringBuilder = + val realURI = realPath.toString + given SourceFile = SourceFile.virtual(doc.uri, doc.text) + sb.append(realURI).nl + sb.append("_" * realURI.length).nl + sb.nl + sb.append("Summary:").nl + sb.append("Schema => ").append(schemaString(doc.schema)).nl + sb.append("Uri => ").append(doc.uri).nl + sb.append("Text => empty").nl + sb.append("Language => ").append(languageString(doc.language)).nl + sb.append("Symbols => ").append(doc.symbols.length).append(" entries").nl + sb.append("Occurrences => ").append(doc.occurrences.length).append(" entries").nl + sb.nl + sb.append("Symbols:").nl + doc.symbols.sorted.foreach(processSymbol) + sb.nl + sb.append("Occurrences:").nl + doc.occurrences.sorted.foreach(processOccurrence) + sb.nl + end metac - def schemaString(schema: Schema) = + private def schemaString(schema: Schema) = import Schema._ schema match case SEMANTICDB3 => "SemanticDB v3" @@ -82,7 +70,7 @@ object Semanticdbs with case Unrecognized(_) => "unknown" end schemaString - def languageString(language: Language) = + private def languageString(language: Language) = import Language._ language match case SCALA => "Scala" @@ -90,7 +78,7 @@ object Semanticdbs with case UNKNOWN_LANGUAGE | Unrecognized(_) => "unknown" end languageString - def processSymbol(info: SymbolInformation)(given sb: StringBuilder): Unit = + private def processSymbol(info: SymbolInformation)(given sb: StringBuilder): Unit = import SymbolInformation.Kind._ sb.append(info.symbol).append(" => ") if info.isAbstract then sb.append("abstract ") @@ -127,7 +115,7 @@ object Semanticdbs with sb.append(info.displayName).nl end processSymbol - def processOccurrence(occ: SymbolOccurrence)(given sb: StringBuilder, sourceFile: SourceFile): Unit = + private def processOccurrence(occ: SymbolOccurrence)(given sb: StringBuilder, sourceFile: SourceFile): Unit = occ.range match case Some(range) => sb.append('[') @@ -146,87 +134,4 @@ object Semanticdbs with sb.append(if occ.role.isReference then " -> " else " <- ").append(occ.symbol).nl end processOccurrence - def metac(doc: TextDocument, realPath: Path)(given sb: StringBuilder): StringBuilder = - val realURI = realPath.toString - given SourceFile = SourceFile.virtual(doc.uri, doc.text) - sb.append(realURI).nl - sb.append("_" * realURI.length).nl - sb.nl - sb.append("Summary:").nl - sb.append("Schema => ").append(schemaString(doc.schema)).nl - sb.append("Uri => ").append(doc.uri).nl - sb.append("Text => empty").nl - sb.append("Language => ").append(languageString(doc.language)).nl - sb.append("Symbols => ").append(doc.symbols.length).append(" entries").nl - sb.append("Occurrences => ").append(doc.occurrences.length).append(" entries").nl - sb.nl - sb.append("Symbols:").nl - doc.symbols.sorted.foreach(processSymbol) - sb.nl - sb.append("Occurrences:").nl - doc.occurrences.sorted.foreach(processOccurrence) - sb.nl - end metac - - /** Sort symbol occurrences by their start position. */ - given buildOccurrenceOrdering: Ordering[SymbolOccurrence] = (x, y) => - x.range -> y.range match - case None -> _ | _ -> None => 0 - case Some(a) -> Some(b) => - val byLine = Integer.compare(a.startLine, b.startLine) - if (byLine != 0) - byLine - else // byCharacter - Integer.compare(a.startCharacter, b.startCharacter) - end buildOccurrenceOrdering - - given Ordering[SymbolInformation] = Ordering.by[SymbolInformation, String](_.symbol)(IdentifierOrdering()) - - /** - * A comparator for identifier like "Predef" or "Function10". - * - * Differences from the default string comparator: - * - works with CharSequences like compiler `Name` - * - orders numbers by their numerical value instead of lexicographical - * - Good: `Function1`, `Function2`, `Function10` - * - Bad: `Function1`, `Function10`, `Function2` - * - * taken from https://github.com/scalameta/scalameta/blob/master/semanticdb/metap/src/main/scala/scala/meta/internal/metap/IdentifierOrdering.scala - */ - class IdentifierOrdering[T <: CharSequence] extends Ordering[T] with - - override def compare(o1: T, o2: T): Int = - val len = math.min(o1.length(), o2.length()) - var i = 0 - while i < len do - val a = o1.charAt(i) - val b = o2.charAt(i) - if a.isDigit && b.isDigit - val byDigit = Integer.compare(toDigit(o1, i), toDigit(o2, i)) - if (byDigit != 0) return byDigit - else - i = seekNonDigit(o1, i) - else - val result = Character.compare(a, b) - if result != 0 - return result - i += 1 - end while - Integer.compare(o1.length(), o2.length()) - end compare - - private def seekNonDigit(cs: T, i: Int): Int = - var curr = i - while curr < cs.length && cs.charAt(curr).isDigit do - curr += 1 - curr - end seekNonDigit - - private def toDigit(cs: T, i: Int): Int = - val digit = cs.subSequence(i, seekNonDigit(cs, i)) - Integer.parseUnsignedInt(digit.toString) - end toDigit - - end IdentifierOrdering - - inline def (sb: StringBuilder) nl = sb.append(System.lineSeparator) + private inline def (sb: StringBuilder) nl = sb.append(System.lineSeparator) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 1f6e1545eadb..e8353572b24c 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -18,6 +18,8 @@ import org.junit.experimental.categories.Category import dotty.BootstrappedOnlyTests import dotty.tools.dotc.Main import dotty.tools.dotc.semanticdb.DiffAssertions._ +import dotty.tools.dotc.semanticdb.Scala3.given +import dotty.tools.dotc.util.SourceFile @main def updateExpect = SemanticdbTests().runExpectTest(updateExpectFiles = true) @@ -47,9 +49,9 @@ class SemanticdbTests with .resolve(relpath) .resolveSibling(filename + ".semanticdb") val expectPath = source.resolveSibling(filename.replaceAllLiterally(".scala", ".expect.scala")) - val doc = Semanticdbs.loadTextDocument(source, relpath, semanticdbPath) - Semanticdbs.metac(doc, rootSrc.relativize(source))(given metacSb) - val obtained = trimTrailingWhitespace(Semanticdbs.printTextDocument(doc)) + val doc = Tools.loadTextDocument(source, relpath, semanticdbPath) + Tools.metac(doc, rootSrc.relativize(source))(given metacSb) + val obtained = trimTrailingWhitespace(SemanticdbTests.printTextDocument(doc)) if updateExpectFiles Files.write(expectPath, obtained.getBytes(StandardCharsets.UTF_8)) println("updated: " + expectPath) @@ -102,3 +104,42 @@ class SemanticdbTests with val exit = Main.process(args) assertFalse(s"dotc errors: ${exit.errorCount}", exit.hasErrors) target + +end SemanticdbTests + +object SemanticdbTests with + /** Prettyprint a text document with symbol occurrences next to each resolved identifier. + * + * Useful for testing purposes to ensure that SymbolOccurrence values make sense and are correct. + * Example output (NOTE, slightly modified to avoid "unclosed comment" errors): + * {{{ + * class Example *example/Example#* { + * val a *example/Example#a.* : String *scala/Predef.String#* = "1" + * } + * }}} + **/ + def printTextDocument(doc: TextDocument): String = + val symtab = doc.symbols.iterator.map(info => info.symbol -> info).toMap + val sb = StringBuilder(1000) + val sourceFile = SourceFile.virtual(doc.uri, doc.text) + var offset = 0 + for occ <- doc.occurrences.sorted do + val range = occ.range.get + val end = math.max( + offset, + sourceFile.lineToOffset(range.endLine) + range.endCharacter + ) + val isPrimaryConstructor = + symtab.get(occ.symbol).exists(_.isPrimary) + if !occ.symbol.isPackage && !isPrimaryConstructor + sb.append(doc.text.substring(offset, end)) + sb.append("/*") + .append(if (occ.role.isDefinition) "<-" else "->") + .append(occ.symbol.replace("/", "::")) + .append("*/") + offset = end + sb.append(doc.text.substring(offset)) + sb.toString + end printTextDocument + +end SemanticdbTests From 6aea65342a6c0faa05a015af90a7462291f41879 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 20 Nov 2019 16:03:45 +0100 Subject: [PATCH 089/107] Dont make occurrences for setters, test def with explicit setter syntax --- .../dotc/semanticdb/ExtractSemanticDB.scala | 1 + .../expect/Definitions.expect.scala | 2 +- tests/semanticdb/expect/Flags.expect.scala | 4 +- .../semanticdb/expect/ValPattern.expect.scala | 4 +- tests/semanticdb/expect/Vals.expect.scala | 14 +- tests/semanticdb/expect/Vals.scala | 4 + tests/semanticdb/metac.expect | 187 +++++++++--------- tests/semanticdb/todo.md | 4 +- 8 files changed, 118 insertions(+), 102 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 8ef09a86879c..cb397164d88e 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -73,6 +73,7 @@ class ExtractSemanticDB extends Phase with || sym.isLocalDummy || sym.is(Synthetic) || sym.isConstructor && (sym.owner.is(ModuleClass) || !sym.isGlobal) + || sym.isSetter || excludeDefStrict(sym) private def excludeDefStrict(sym: Symbol)(given Context): Boolean = diff --git a/tests/semanticdb/expect/Definitions.expect.scala b/tests/semanticdb/expect/Definitions.expect.scala index 5e706341cf95..92a956c37c17 100644 --- a/tests/semanticdb/expect/Definitions.expect.scala +++ b/tests/semanticdb/expect/Definitions.expect.scala @@ -1,7 +1,7 @@ package a object Definitions/*<-a::Definitions.*/ { val a/*<-a::Definitions.a.*/ = 1 - var b/*<-a::Definitions.b().*/ =/*<-a::Definitions.`b_=`().*/ 2 + var b/*<-a::Definitions.b().*/ = 2 def c/*<-a::Definitions.c().*/ = 3 class D/*<-a::Definitions.D#*/ trait E/*<-a::Definitions.E#*/ diff --git a/tests/semanticdb/expect/Flags.expect.scala b/tests/semanticdb/expect/Flags.expect.scala index 25188c017220..5dc7eb9ecb0f 100644 --- a/tests/semanticdb/expect/Flags.expect.scala +++ b/tests/semanticdb/expect/Flags.expect.scala @@ -4,7 +4,7 @@ import scala.language/*->scalaShadowing::language.*/.experimental/*->scalaShadow package object p { p/*<-flags::p::package.*/rivate lazy val x/*<-flags::p::package.x.*/ = 1 - protected implicit var y/*<-flags::p::package.y().*/: /*<-flags::p::package.`y_=`().*/Int/*->scala::Int#*/ = 2 + protected implicit var y/*<-flags::p::package.y().*/: Int/*->scala::Int#*/ = 2 def z/*<-flags::p::package.z().*/(pp/*<-flags::p::package.z().(pp)*/: Int/*->scala::Int#*/) = 3 def m/*<-flags::p::package.m().*/[TT/*<-flags::p::package.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ??? abstract class C/*<-flags::p::package.C#*/[+T/*<-flags::p::package.C#[T]*/, -U/*<-flags::p::package.C#[U]*/, V/*<-flags::p::package.C#[V]*/](x/*<-flags::p::package.C#x.*/: T/*->flags::p::package.C#[T]*/, y/*<-flags::p::package.C#y.*/: U/*->flags::p::package.C#[U]*/, z/*<-flags::p::package.C#z.*/: V/*->flags::p::package.C#[V]*/) { @@ -19,7 +19,7 @@ package object p { case object X/*<-flags::p::package.X.*/ final class Y/*<-flags::p::package.Y#*/ sealed trait Z/*<-flags::p::package.Z#*/ - class AA/*<-flags::p::package.AA#*/(x/*<-flags::p::package.AA#x.*/: Int/*->scala::Int#*/, val y/*<-flags::p::package.AA#y.*/: Int/*->scala::Int#*/, var z/*<-flags::p::package.AA#z().*/: /*<-flags::p::package.AA#`z_=`().*/Int/*->scala::Int#*/) + 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#*//*->scala::specialized#``(+2).*/ T/*<-flags::p::package.S#[T]*/] val List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs1/*<-flags::p::package.xs1.*//*<-local0*/)/*->local0*/ = ???/*->scala::Predef.`???`().*/ ???/*->scala::Predef.`???`().*/ match { case List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs2/*<-local1*/) => ???/*->scala::Predef.`???`().*/ } diff --git a/tests/semanticdb/expect/ValPattern.expect.scala b/tests/semanticdb/expect/ValPattern.expect.scala index 7d1a589039d3..3ffb3e41782f 100644 --- a/tests/semanticdb/expect/ValPattern.expect.scala +++ b/tests/semanticdb/expect/ValPattern.expect.scala @@ -6,8 +6,8 @@ class ValPattern/*<-example::ValPattern#*/ { val Some/*->scala::Some.*/(number1/*<-example::ValPattern#number1.*//*<-local0*/)/*->local0*/ = Some/*->scala::Some.*/(1) - /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/var (leftVar/*<-example::ValPattern#leftVar().*/, /*<-example::ValPattern#`leftVar_=`().*/rightVar/*<-example::ValPattern#rightVar().*/) /*<-example::ValPattern#`rightVar_=`().*/= (1, 2) - var Some/*->scala::Some.*/(number1Var/*<-example::ValPattern#number1Var().*//*<-local1*/) /*<-example::ValPattern#`number1Var_=`().*//*->local1*/= + /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/var (leftVar/*<-example::ValPattern#leftVar().*/, rightVar/*<-example::ValPattern#rightVar().*/) = (1, 2) + var Some/*->scala::Some.*/(number1Var/*<-example::ValPattern#number1Var().*//*<-local1*/)/*->local1*/ = Some/*->scala::Some.*/(1) def app/*<-example::ValPattern#app().*/(): Unit/*->scala::Unit#*/ = { diff --git a/tests/semanticdb/expect/Vals.expect.scala b/tests/semanticdb/expect/Vals.expect.scala index 3f2c681ddab2..d3c865665813 100644 --- a/tests/semanticdb/expect/Vals.expect.scala +++ b/tests/semanticdb/expect/Vals.expect.scala @@ -1,6 +1,6 @@ package example -abstract class Vals/*<-example::Vals#*/(p/*<-example::Vals#p.*/: Int/*->scala::Int#*/, val xp/*<-example::Vals#xp.*/: Int/*->scala::Int#*/, var yp/*<-example::Vals#yp().*/: /*<-example::Vals#`yp_=`().*/Int/*->scala::Int#*/) { +abstract class Vals/*<-example::Vals#*/(p/*<-example::Vals#p.*/: Int/*->scala::Int#*/, val xp/*<-example::Vals#xp.*/: Int/*->scala::Int#*/, var yp/*<-example::Vals#yp().*/: Int/*->scala::Int#*/) { val xm/*<-example::Vals#xm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ val xam/*<-example::Vals#xam.*/: Int/*->scala::Int#*/ private[this] val xlm/*<-example::Vals#xlm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ @@ -8,14 +8,17 @@ abstract class Vals/*<-example::Vals#*/(p/*<-example::Vals#p.*/: Int/*->scala::I private[this] lazy val xzlm/*<-example::Vals#xzlm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ final val xfm/*<-example::Vals#xfm.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ implicit val xim/*<-example::Vals#xim.*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ - var ym/*<-example::Vals#ym().*/: /*<-example::Vals#`ym_=`().*/Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ - var yam/*<-example::Vals#yam().*/: /*<-example::Vals#`yam_=`().*/Int/*->scala::Int#*/ + var ym/*<-example::Vals#ym().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + var yam/*<-example::Vals#yam().*/: Int/*->scala::Int#*/ private[this] var ylm/*<-example::Vals#ylm().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + private[this] var _explicitSetter/*<-example::Vals#_explicitSetter().*/: Int/*->scala::Int#*/ = 0 + def explicitSetter/*<-example::Vals#explicitSetter().*/ = _explicitSetter/*->example::Vals#_explicitSetter().*/ + def explicitSetter_=/*<-example::Vals#`explicitSetter_=`().*/(x/*<-example::Vals#`explicitSetter_=`().(x)*/: Int/*->scala::Int#*/): Unit/*->scala::Unit#*/ = _explicitSetter/*->example::Vals#_explicitSetter().*/ = x/*->example::Vals#`explicitSetter_=`().(x)*/ // NOTE: lazy not allowed here. Only vals can be lazy // lazy var xzm: Int = ??? // private[this] lazy var yzlm: Int = ??? - final var yfm/*<-example::Vals#yfm().*/: /*<-example::Vals#`yfm_=`().*/Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ - implicit var yim/*<-example::Vals#yim().*/: /*<-example::Vals#`yim_=`().*/Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + final var yfm/*<-example::Vals#yfm().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ + implicit var yim/*<-example::Vals#yim().*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ def m/*<-example::Vals#m().*/ = { val xl/*<-local0*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ lazy val xzl/*<-local1*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ @@ -44,4 +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 } diff --git a/tests/semanticdb/expect/Vals.scala b/tests/semanticdb/expect/Vals.scala index 64e8026448bc..2ea132729bb0 100644 --- a/tests/semanticdb/expect/Vals.scala +++ b/tests/semanticdb/expect/Vals.scala @@ -11,6 +11,9 @@ abstract class Vals(p: Int, val xp: Int, var yp: Int) { var ym: Int = ??? var yam: Int private[this] var ylm: Int = ??? + private[this] var _explicitSetter: Int = 0 + def explicitSetter = _explicitSetter + def explicitSetter_=(x: Int): Unit = _explicitSetter = x // NOTE: lazy not allowed here. Only vals can be lazy // lazy var xzm: Int = ??? // private[this] lazy var yzlm: Int = ??? @@ -44,4 +47,5 @@ object ValUsages { println(v.xzm) v.yfm = v.xfm + v.yfm v.yim = v.xim + v.yim + v.explicitSetter = 25 } diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 76f63e39ba07..711cdcfd548a 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -491,7 +491,7 @@ Uri => Definitions.scala Text => empty Language => Scala Symbols => 10 entries -Occurrences => 10 entries +Occurrences => 9 entries Symbols: a/Definitions. => final object Definitions @@ -510,7 +510,6 @@ Occurrences: [1:7..1:18): Definitions <- a/Definitions. [2:6..2:7): a <- a/Definitions.a. [3:6..3:7): b <- a/Definitions.b(). -[3:6..3:9): 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# @@ -1004,7 +1003,7 @@ Uri => Flags.scala Text => empty Language => Scala Symbols => 51 entries -Occurrences => 87 entries +Occurrences => 85 entries Symbols: flags/p/package. => final package object p @@ -1069,7 +1068,6 @@ Occurrences: [5:2..5:3): p -> flags/p/ [5:19..5:20): x <- flags/p/package.x. [6:25..6:26): y <- flags/p/package.y(). -[6:25..6:28): y: <- flags/p/package.`y_=`(). [6:28..6:31): Int -> scala/Int# [7:6..7:7): z <- flags/p/package.z(). [7:8..7:10): pp <- flags/p/package.z().(pp) @@ -1125,7 +1123,6 @@ Occurrences: [21:23..21:24): y <- flags/p/package.AA#y. [21:26..21:29): Int -> scala/Int# [21:35..21:36): z <- flags/p/package.AA#z(). -[21:35..21:38): z: <- flags/p/package.AA#`z_=`(). [21:38..21:41): Int -> scala/Int# [22:8..22:9): S <- flags/p/package.S# [22:9..22:25): <- flags/p/package.S#``(). @@ -3068,7 +3065,7 @@ Uri => ValPattern.scala Text => empty Language => Scala Symbols => 23 entries -Occurrences => 57 entries +Occurrences => 54 entries Symbols: example/ValPattern# => class ValPattern @@ -3111,13 +3108,10 @@ Occurrences: [8:2..8:2): -> scala/Tuple2#_1. [8:2..8:2): -> scala/Tuple2#_2. [8:7..8:14): leftVar <- example/ValPattern#leftVar(). -[8:7..8:16): leftVar, <- example/ValPattern#`leftVar_=`(). [8:16..8:24): rightVar <- example/ValPattern#rightVar(). -[8:16..8:26): rightVar) <- example/ValPattern#`rightVar_=`(). [9:6..9:10): Some -> scala/Some. [9:11..9:21): number1Var <- example/ValPattern#number1Var(). [9:11..9:21): number1Var <- local1 -[9:11..9:23): number1Var) <- example/ValPattern#`number1Var_=`(). [9:22..9:22): -> local1 [10:4..10:8): Some -> scala/Some. [12:6..12:9): app <- example/ValPattern#app(). @@ -3162,17 +3156,20 @@ Schema => SemanticDB v4 Uri => Vals.scala Text => empty Language => Scala -Symbols => 38 entries -Occurrences => 122 entries +Symbols => 42 entries +Occurrences => 129 entries Symbols: example/ValUsages. => final object ValUsages example/ValUsages.v. => val method v example/Vals# => abstract class Vals +example/Vals#_explicitSetter(). => var method _explicitSetter example/Vals#``(). => primary ctor example/Vals#``().(p) => param p example/Vals#``().(xp) => val param xp example/Vals#``().(yp) => var param yp +example/Vals#`explicitSetter_=`(). => method explicitSetter_= +example/Vals#`explicitSetter_=`().(x) => param x example/Vals#`yam_=`(). => var method yam_= example/Vals#`yam_=`().(x$1) => param x$1 example/Vals#`yfm_=`(). => final var method yfm_= @@ -3183,6 +3180,7 @@ example/Vals#`ym_=`(). => var method ym_= example/Vals#`ym_=`().(x$1) => param x$1 example/Vals#`yp_=`(). => var method yp_= example/Vals#`yp_=`().(x$1) => param x$1 +example/Vals#explicitSetter(). => method explicitSetter example/Vals#m(). => method m example/Vals#p. => val method p example/Vals#xam. => abstract val method xam @@ -3214,7 +3212,6 @@ Occurrences: [2:32..2:34): xp <- example/Vals#xp. [2:36..2:39): Int -> scala/Int# [2:45..2:47): yp <- example/Vals#yp(). -[2:45..2:49): yp: <- example/Vals#`yp_=`(). [2:49..2:52): Int -> scala/Int# [3:6..3:8): xm <- example/Vals#xm. [3:10..3:13): Int -> scala/Int# @@ -3237,97 +3234,105 @@ Occurrences: [9:20..9:23): Int -> scala/Int# [9:26..9:29): ??? -> scala/Predef.`???`(). [10:6..10:8): ym <- example/Vals#ym(). -[10:6..10:10): ym: <- example/Vals#`ym_=`(). [10:10..10:13): Int -> scala/Int# [10:16..10:19): ??? -> scala/Predef.`???`(). [11:6..11:9): yam <- example/Vals#yam(). -[11:6..11:11): yam: <- example/Vals#`yam_=`(). [11:11..11:14): Int -> scala/Int# [12:20..12:23): ylm <- example/Vals#ylm(). [12:25..12:28): Int -> scala/Int# [12:31..12:34): ??? -> scala/Predef.`???`(). -[16:12..16:15): yfm <- example/Vals#yfm(). -[16:12..16:17): yfm: <- example/Vals#`yfm_=`(). -[16:17..16:20): Int -> scala/Int# -[16:23..16:26): ??? -> scala/Predef.`???`(). -[17:15..17:18): yim <- example/Vals#yim(). -[17:15..17:20): yim: <- example/Vals#`yim_=`(). -[17:20..17:23): Int -> scala/Int# -[17:26..17:29): ??? -> scala/Predef.`???`(). -[18:6..18:7): m <- example/Vals#m(). -[19:8..19:10): xl <- local0 -[19:12..19:15): Int -> scala/Int# -[19:18..19:21): ??? -> scala/Predef.`???`(). -[20:13..20:16): xzl <- local1 -[20:18..20:21): Int -> scala/Int# -[20:24..20:27): ??? -> scala/Predef.`???`(). -[23:17..23:20): xil <- local2 -[23:22..23:25): Int -> scala/Int# -[23:28..23:31): ??? -> scala/Predef.`???`(). -[24:8..24:10): yl <- local3 -[24:12..24:15): Int -> scala/Int# -[24:18..24:21): ??? -> scala/Predef.`???`(). -[29:17..29:20): yil <- local4 -[29:22..29:25): Int -> scala/Int# -[29:28..29:31): ??? -> scala/Predef.`???`(). -[30:4..30:6): yl -> local3 -[30:9..30:11): xl -> local0 -[30:12..30:13): + -> scala/Int#`+`(+4). -[30:14..30:16): yl -> local3 -[31:4..31:11): println -> scala/Predef.println(+1). -[31:12..31:15): xzl -> local1 -[32:4..32:7): yil -> local4 -[32:10..32:13): xil -> local2 -[32:14..32:15): + -> scala/Int#`+`(+4). -[32:16..32:19): yil -> local4 -[34:2..34:9): println -> scala/Predef.println(+1). -[34:10..34:14): xzlm -> example/Vals#xzlm. -[35:2..35:5): ylm -> example/Vals#ylm(). -[35:8..35:11): xlm -> example/Vals#xlm. -[35:12..35:13): + -> scala/Int#`+`(+4). -[35:14..35:17): ylm -> example/Vals#ylm(). -[38:7..38:16): ValUsages <- example/ValUsages. -[39:6..39:7): v <- example/ValUsages.v. -[39:9..39:13): Vals -> example/Vals# -[39:16..39:19): ??? -> scala/Predef.`???`(). -[40:2..40:3): v -> example/ValUsages.v. -[40:4..40:6): yp -> example/Vals#`yp_=`(). -[40:9..40:10): v -> example/ValUsages.v. -[40:11..40:13): xp -> example/Vals#xp. -[40:14..40:15): + -> scala/Int#`+`(+4). -[40:16..40:17): v -> example/ValUsages.v. -[40:18..40:20): yp -> example/Vals#yp(). -[41:2..41:3): v -> example/ValUsages.v. -[41:4..41:6): ym -> example/Vals#`ym_=`(). -[41:9..41:10): v -> example/ValUsages.v. -[41:11..41:13): xm -> example/Vals#xm. -[41:14..41:15): + -> scala/Int#`+`(+4). -[41:16..41:17): v -> example/ValUsages.v. -[41:18..41:20): ym -> example/Vals#ym(). -[42:2..42:3): v -> example/ValUsages.v. -[42:4..42:7): yam -> example/Vals#`yam_=`(). -[42:10..42:11): v -> example/ValUsages.v. -[42:12..42:15): xam -> example/Vals#xam. -[42:16..42:17): + -> scala/Int#`+`(+4). -[42:18..42:19): v -> example/ValUsages.v. -[42:20..42:23): yam -> example/Vals#yam(). -[43:2..43:9): println -> scala/Predef.println(+1). -[43:10..43:11): v -> example/ValUsages.v. -[43:12..43:15): xzm -> example/Vals#xzm. +[13:20..13:35): _explicitSetter <- example/Vals#_explicitSetter(). +[13:37..13:40): Int -> scala/Int# +[14:6..14:20): explicitSetter <- example/Vals#explicitSetter(). +[14:23..14:38): _explicitSetter -> example/Vals#_explicitSetter(). +[15:6..15:22): explicitSetter_= <- example/Vals#`explicitSetter_=`(). +[15:23..15:24): x <- example/Vals#`explicitSetter_=`().(x) +[15:26..15:29): Int -> scala/Int# +[15:32..15:36): Unit -> scala/Unit# +[15:39..15:54): _explicitSetter -> example/Vals#_explicitSetter(). +[15:57..15:58): x -> example/Vals#`explicitSetter_=`().(x) +[19:12..19:15): yfm <- example/Vals#yfm(). +[19:17..19:20): Int -> scala/Int# +[19:23..19:26): ??? -> scala/Predef.`???`(). +[20:15..20:18): yim <- example/Vals#yim(). +[20:20..20:23): Int -> scala/Int# +[20:26..20:29): ??? -> scala/Predef.`???`(). +[21:6..21:7): m <- example/Vals#m(). +[22:8..22:10): xl <- local0 +[22:12..22:15): Int -> scala/Int# +[22:18..22:21): ??? -> scala/Predef.`???`(). +[23:13..23:16): xzl <- local1 +[23:18..23:21): Int -> scala/Int# +[23:24..23:27): ??? -> scala/Predef.`???`(). +[26:17..26:20): xil <- local2 +[26:22..26:25): Int -> scala/Int# +[26:28..26:31): ??? -> scala/Predef.`???`(). +[27:8..27:10): yl <- local3 +[27:12..27:15): Int -> scala/Int# +[27:18..27:21): ??? -> scala/Predef.`???`(). +[32:17..32:20): yil <- local4 +[32:22..32:25): Int -> scala/Int# +[32:28..32:31): ??? -> scala/Predef.`???`(). +[33:4..33:6): yl -> local3 +[33:9..33:11): xl -> local0 +[33:12..33:13): + -> scala/Int#`+`(+4). +[33:14..33:16): yl -> local3 +[34:4..34:11): println -> scala/Predef.println(+1). +[34:12..34:15): xzl -> local1 +[35:4..35:7): yil -> local4 +[35:10..35:13): xil -> local2 +[35:14..35:15): + -> scala/Int#`+`(+4). +[35:16..35:19): yil -> local4 +[37:2..37:9): println -> scala/Predef.println(+1). +[37:10..37:14): xzlm -> example/Vals#xzlm. +[38:2..38:5): ylm -> example/Vals#ylm(). +[38:8..38:11): xlm -> example/Vals#xlm. +[38:12..38:13): + -> scala/Int#`+`(+4). +[38:14..38:17): ylm -> example/Vals#ylm(). +[41:7..41:16): ValUsages <- example/ValUsages. +[42:6..42:7): v <- example/ValUsages.v. +[42:9..42:13): Vals -> example/Vals# +[42:16..42:19): ??? -> scala/Predef.`???`(). +[43:2..43:3): v -> example/ValUsages.v. +[43:4..43:6): yp -> example/Vals#`yp_=`(). +[43:9..43:10): v -> example/ValUsages.v. +[43:11..43:13): xp -> example/Vals#xp. +[43:14..43:15): + -> scala/Int#`+`(+4). +[43:16..43:17): v -> example/ValUsages.v. +[43:18..43:20): yp -> example/Vals#yp(). [44:2..44:3): v -> example/ValUsages.v. -[44:4..44:7): yfm -> example/Vals#`yfm_=`(). -[44:10..44:11): v -> example/ValUsages.v. -[44:12..44:15): xfm -> example/Vals#xfm. -[44:16..44:17): + -> scala/Int#`+`(+4). -[44:18..44:19): v -> example/ValUsages.v. -[44:20..44:23): yfm -> example/Vals#yfm(). +[44:4..44:6): ym -> example/Vals#`ym_=`(). +[44:9..44:10): v -> example/ValUsages.v. +[44:11..44:13): xm -> example/Vals#xm. +[44:14..44:15): + -> scala/Int#`+`(+4). +[44:16..44:17): v -> example/ValUsages.v. +[44:18..44:20): ym -> example/Vals#ym(). [45:2..45:3): v -> example/ValUsages.v. -[45:4..45:7): yim -> example/Vals#`yim_=`(). +[45:4..45:7): yam -> example/Vals#`yam_=`(). [45:10..45:11): v -> example/ValUsages.v. -[45:12..45:15): xim -> example/Vals#xim. +[45:12..45:15): xam -> example/Vals#xam. [45:16..45:17): + -> scala/Int#`+`(+4). [45:18..45:19): v -> example/ValUsages.v. -[45:20..45:23): yim -> example/Vals#yim(). +[45:20..45:23): yam -> example/Vals#yam(). +[46:2..46:9): println -> scala/Predef.println(+1). +[46:10..46:11): v -> example/ValUsages.v. +[46:12..46:15): xzm -> example/Vals#xzm. +[47:2..47:3): v -> example/ValUsages.v. +[47:4..47:7): yfm -> example/Vals#`yfm_=`(). +[47:10..47:11): v -> example/ValUsages.v. +[47:12..47:15): xfm -> example/Vals#xfm. +[47:16..47:17): + -> scala/Int#`+`(+4). +[47:18..47:19): v -> example/ValUsages.v. +[47:20..47:23): yfm -> example/Vals#yfm(). +[48:2..48:3): v -> example/ValUsages.v. +[48:4..48:7): yim -> example/Vals#`yim_=`(). +[48:10..48:11): v -> example/ValUsages.v. +[48:12..48:15): xim -> example/Vals#xim. +[48:16..48:17): + -> scala/Int#`+`(+4). +[48:18..48:19): v -> example/ValUsages.v. +[48:20..48:23): yim -> example/Vals#yim(). +[49:2..49:3): v -> example/ValUsages.v. +[49:3..49:18): .explicitSetter -> example/Vals#`explicitSetter_=`(). expect/Vararg.scala ___________________ diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md index 99fd4705a557..6ed2e972e454 100644 --- a/tests/semanticdb/todo.md +++ b/tests/semanticdb/todo.md @@ -3,7 +3,9 @@ Differences between scalameta implementation and dotc. - [ ] For comprehension in Synthetic section. - [ ] Implicit conversions in Synthetic section. -- [ ] Record all definitions in Symbols section. +- [ ] Record signature information in Symbols section. +- [ ] Record access modifier information in Symbols section. +- [x] Record all definitions in Symbols section. ## ValPatterns From d774f5abdb9761be14901fe70be8b566ab64f953 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Wed, 20 Nov 2019 18:06:52 +0100 Subject: [PATCH 090/107] better support paths and pattern defs --- .../dotc/semanticdb/ExtractSemanticDB.scala | 56 +++++----- .../dotty/tools/dotc/semanticdb/Scala3.scala | 2 + .../expect/Annotations.expect.scala | 22 ++-- tests/semanticdb/expect/Enums.expect.scala | 6 +- .../expect/EtaExpansion.expect.scala | 2 +- .../expect/ForComprehension.expect.scala | 26 ++--- tests/semanticdb/expect/Givens.expect.scala | 6 +- .../expect/ImplicitConversion.expect.scala | 8 +- .../semanticdb/expect/Issue1749.expect.scala | 4 +- .../expect/NamedApplyBlock.expect.scala | 6 +- .../expect/NamedArguments.expect.scala | 2 +- .../semanticdb/expect/Synthetic.expect.scala | 10 +- .../semanticdb/expect/ValPattern.expect.scala | 28 ++--- tests/semanticdb/metac.expect | 102 ++++++++++++++---- 14 files changed, 174 insertions(+), 106 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index cb397164d88e..2e0187adef4a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -15,6 +15,8 @@ import util.{SourceFile, SourcePosition} import collection.mutable import java.nio.file.Paths +import PartialFunction.condOpt + import ast.untpd.given import NameOps.given @@ -72,17 +74,20 @@ class ExtractSemanticDB extends Phase with !sym.exists || sym.isLocalDummy || sym.is(Synthetic) - || sym.isConstructor && (sym.owner.is(ModuleClass) || !sym.isGlobal) || sym.isSetter - || excludeDefStrict(sym) + || excludeDefOrUse(sym) - private def excludeDefStrict(sym: Symbol)(given Context): Boolean = + private def excludeDefOrUse(sym: Symbol)(given Context): Boolean = sym.name.is(NameKinds.DefaultGetterName) - || excludeSymbolStrict(sym) + || sym.isConstructor && (sym.owner.is(ModuleClass) || !sym.isGlobal) + || excludeSymbol(sym) - private def excludeSymbolStrict(sym: Symbol)(given Context): Boolean = + private def excludeSymbol(sym: Symbol)(given Context): Boolean = sym.name.isWildcard - || sym.isAnonymousFunction + || excludeQual(sym) + + private def excludeQual(sym: Symbol)(given Context): Boolean = + sym.isAnonymousFunction || sym.isAnonymousModuleVal || sym.name.isEmptyNumbered @@ -90,9 +95,10 @@ class ExtractSemanticDB extends Phase with sym.isAllOf(HigherKinded | Param) /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ - private def excludeUseStrict(sym: Symbol, span: Span)(given Context): Boolean = - excludeDefStrict(sym) - || excludeDef(sym) && span.zeroLength + private def excludeUse(qualifier: Option[Symbol], sym: Symbol)(given Context): Boolean = + excludeDefOrUse(sym) + || sym == defn.Any_typeCast + || qualifier.exists(excludeQual) override def traverse(tree: Tree)(given Context): Unit = @@ -100,8 +106,8 @@ class ExtractSemanticDB extends Phase with val tptSym = tpt.symbol if tptSym.owner == ctorSym val found = matchingMemberType(tptSym, ctorSym.owner) - if !excludeUseStrict(found, tpt.span) && tpt.span.hasLength - registerUse(found, tpt.span) + if tpt.span.hasLength + registerUseGuarded(None, found, tpt.span) else traverse(tpt) @@ -129,8 +135,8 @@ class ExtractSemanticDB extends Phase with registerDefinition(tree.symbol, tree.adjustedNameSpan, symbolKinds(tree)) val privateWithin = tree.symbol.privateWithin if privateWithin.exists - registerUse(privateWithin, spanOfSymbol(privateWithin, tree.span)) - else if !excludeSymbolStrict(tree.symbol) + registerUseGuarded(None, privateWithin, spanOfSymbol(privateWithin, tree.span)) + else if !excludeSymbol(tree.symbol) registerSymbol(tree.symbol, symbolName(tree.symbol), symbolKinds(tree)) tree match case tree: ValDef @@ -178,7 +184,8 @@ class ExtractSemanticDB extends Phase with else tree.body.foreach(traverse) case tree: Assign => - if !excludeUseStrict(tree.lhs.symbol, tree.lhs.span) + val qualSym = condOpt(tree.lhs) { case Select(qual, _) if qual.symbol.exists => qual.symbol } + if !excludeUse(qualSym, tree.lhs.symbol) val lhs = tree.lhs.symbol val setter = lhs.matchingSetter.orElse(lhs) tree.lhs match @@ -189,24 +196,22 @@ class ExtractSemanticDB extends Phase with case tree: Ident => if tree.name != nme.WILDCARD then val sym = tree.symbol.adjustIfCtorTyparam - if !excludeUseStrict(sym, tree.span) then - registerUse(sym, tree.span) + registerUseGuarded(None, sym, tree.span) case tree: Select => val qualSpan = tree.qualifier.span val sym = tree.symbol.adjustIfCtorTyparam - if !excludeUseStrict(sym, tree.span) then - registerUse(sym, adjustSpanToName(tree.span, qualSpan, tree.name)) + registerUseGuarded(tree.qualifier.symbol.ifExists, sym, adjustSpanToName(tree.span, qualSpan, tree.name)) if qualSpan.exists && qualSpan.hasLength then - traverseChildren(tree) + traverse(tree.qualifier) case tree: Import => if tree.span.exists && tree.span.hasLength then for sel <- tree.selectors do val imported = sel.imported.name if imported != nme.WILDCARD then for alt <- tree.expr.tpe.member(imported).alternatives do - registerUse(alt.symbol, sel.imported.span) + registerUseGuarded(None, alt.symbol, sel.imported.span) if (alt.symbol.companionClass.exists) - registerUse(alt.symbol.companionClass, sel.imported.span) + registerUseGuarded(None, alt.symbol.companionClass, sel.imported.span) traverseChildren(tree) case tree: Inlined => traverse(tree.call) @@ -397,9 +402,12 @@ class ExtractSemanticDB extends Phase with occurrences += occ generated += occ + private def registerUseGuarded(qualSym: Option[Symbol], sym: Symbol, span: Span)(given Context) = + if !excludeUse(qualSym, sym) then + registerUse(sym, span) + private def registerUse(sym: Symbol, span: Span)(given Context) = - if !excludeUseStrict(sym, span) then - registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE) + registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE) private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind])(given Context) = val symbol = symbolName(sym) @@ -496,7 +504,7 @@ class ExtractSemanticDB extends Phase with vparams <- vparamss vparam <- vparams do - if !excludeSymbolStrict(vparam.symbol) + if !excludeSymbol(vparam.symbol) val symkinds = getters.get(vparam.name).fold(SymbolKind.emptySet)(getter => if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index 363d8cdbfac2..f7e6f4247699 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -91,6 +91,8 @@ object Scala3 with given SymbolOps: (sym: Symbol) with + def ifExists(given Context): Option[Symbol] = if sym.exists then Some(sym) else None + def isScala2PackageObject(given Context): Boolean = sym.name.isScala2PackageObjectName && sym.owner.is(Package) && sym.is(Module) diff --git a/tests/semanticdb/expect/Annotations.expect.scala b/tests/semanticdb/expect/Annotations.expect.scala index 70685535ddc8..d6c97991aa91 100644 --- a/tests/semanticdb/expect/Annotations.expect.scala +++ b/tests/semanticdb/expect/Annotations.expect.scala @@ -4,33 +4,33 @@ import com.javacp.annot._ import scala.annotation.meta._ import scala.language/*->scalaShadowing::language.*/.experimental/*->scalaShadowing::language.experimental.*/.macros/*->scalaShadowing::language.experimental.macros.*/ -@ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/ -class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => - @FieldAnnotation/*->com::javacp::annot::FieldAnnotation#*/ +@ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*//*->com::javacp::annot::ClassAnnotation#``().*/ +class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*//*->com::javacp::annot::TypeParameterAnnotation#``().*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*//*->com::javacp::annot::ParameterAnnotation#``().*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => + @FieldAnnotation/*->com::javacp::annot::FieldAnnotation#*//*->com::javacp::annot::FieldAnnotation#``().*/ val field/*<-annot::Annotations#field.*/ = 42 - @MethodAnnotation/*->com::javacp::annot::MethodAnnotation#*/ + @MethodAnnotation/*->com::javacp::annot::MethodAnnotation#*//*->com::javacp::annot::MethodAnnotation#``().*/ def method/*<-annot::Annotations#method().*/ = { - @LocalAnnotation/*->com::javacp::annot::LocalAnnotation#*/ + @LocalAnnotation/*->com::javacp::annot::LocalAnnotation#*//*->com::javacp::annot::LocalAnnotation#``().*/ val local/*<-local1*/ = 42 local/*->local1*/ } - @TypeAnnotation/*->com::javacp::annot::TypeAnnotation#*/ + @TypeAnnotation/*->com::javacp::annot::TypeAnnotation#*//*->com::javacp::annot::TypeAnnotation#``().*/ type S/*<-annot::Annotations#S#*/ } -class B/*<-annot::B#*/ @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/()(x/*<-annot::B#x.*/: Int/*->scala::Int#*/) { - @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/ +class B/*<-annot::B#*/ @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*//*->com::javacp::annot::ConstructorAnnotation#``().*/()(x/*<-annot::B#x.*/: Int/*->scala::Int#*/) { + @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*//*->com::javacp::annot::ConstructorAnnotation#``().*/ def this()/*<-annot::B#``(+1).*/ = this(42) } -@ObjectAnnotation/*->com::javacp::annot::ObjectAnnotation#*/ +@ObjectAnnotation/*->com::javacp::annot::ObjectAnnotation#*//*->com::javacp::annot::ObjectAnnotation#``().*/ object M/*<-annot::M.*/ { - @MacroAnnotation/*->com::javacp::annot::MacroAnnotation#*/ + @MacroAnnotation/*->com::javacp::annot::MacroAnnotation#*//*->com::javacp::annot::MacroAnnotation#``().*/ def m/*<-annot::M.m().*/[TT/*<-annot::M.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ??? } -@TraitAnnotation/*->com::javacp::annot::TraitAnnotation#*/ +@TraitAnnotation/*->com::javacp::annot::TraitAnnotation#*//*->com::javacp::annot::TraitAnnotation#``().*/ trait T/*<-annot::T#*/ object Alias/*<-annot::Alias.*/ { diff --git a/tests/semanticdb/expect/Enums.expect.scala b/tests/semanticdb/expect/Enums.expect.scala index c7dc21c3ed65..47e3d493ba28 100644 --- a/tests/semanticdb/expect/Enums.expect.scala +++ b/tests/semanticdb/expect/Enums.expect.scala @@ -47,12 +47,12 @@ object Enums/*<-_empty_::Enums.*/ with 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]*/ <:_empty_::Enums.`<:<`#*/ T/*->_empty_::Enums.`<:<`.given_T().[T]*/) = Refl/*->_empty_::Enums.`<:<`.Refl.*/() + given [T]: (T/*<-_empty_::Enums.`<:<`.given_T().*//*<-_empty_::Enums.`<:<`.given_T().[T]*//*->_empty_::Enums.`<:<`.given_T().[T]*/ <:_empty_::Enums.`<:<`#*/ T/*->_empty_::Enums.`<:<`.given_T().[T]*/) = Refl/*->_empty_::Enums.`<:<`.Refl.*//*->_empty_::Enums.`<:<`.Refl.apply().*/() def [A, B]/*<-_empty_::Enums.unwrap().*//*<-_empty_::Enums.unwrap().[A]*//*<-_empty_::Enums.unwrap().[B]*/(opt/*<-_empty_::Enums.unwrap().(opt)*/: Option/*->scala::Option#*/[A/*->_empty_::Enums.unwrap().[A]*/]) unwrap(given ev/*<-_empty_::Enums.unwrap().(ev)*/: A/*->_empty_::Enums.unwrap().[A]*/ <:_empty_::Enums.`<:<`#*/ Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]): Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/] = ev/*->_empty_::Enums.unwrap().(ev)*/ match - case Refl/*->_empty_::Enums.`<:<`.Refl.*/() => opt/*->_empty_::Enums.unwrap().(opt)*/.flatMap/*->scala::Option#flatMap().*/(identity/*->scala::Predef.identity().*/[Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]]) + case Refl/*->_empty_::Enums.`<:<`.Refl.*//*->_empty_::Enums.`<:<`.Refl.unapply().*/() => opt/*->_empty_::Enums.unwrap().(opt)*/.flatMap/*->scala::Option#flatMap().*/(identity/*->scala::Predef.identity().*//*->local0*/[Option/*->scala::Option#*/[B/*->_empty_::Enums.unwrap().[B]*/]]) - val some1/*<-_empty_::Enums.some1.*/ = /*->_empty_::Enums.unwrap().*/Some/*->scala::Some.*/(Some/*->scala::Some.*/(1))/*->_empty_::Enums.`<:<`.given_T().*/.unwrap + val some1/*<-_empty_::Enums.some1.*/ = /*->_empty_::Enums.unwrap().*/Some/*->scala::Some.*//*->scala::Some.apply().*/(Some/*->scala::Some.*//*->scala::Some.apply().*/(1))/*->_empty_::Enums.`<:<`.given_T().*/.unwrap enum Planet/*<-_empty_::Enums.Planet#*/(mass/*<-_empty_::Enums.Planet#mass.*/: Double/*->scala::Double#*/, radius/*<-_empty_::Enums.Planet#radius.*/: Double/*->scala::Double#*/) extends java.lang.Enum/*->java::lang::Enum#*/[Planet/*->_empty_::Enums.Planet#*/]/*->java::lang::Enum#``().*/ with private final val G/*<-_empty_::Enums.Planet#G.*/ = 6.67300E-11 diff --git a/tests/semanticdb/expect/EtaExpansion.expect.scala b/tests/semanticdb/expect/EtaExpansion.expect.scala index 41e623395955..55207ffa5ff2 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.*/(1).map/*->scala::Option#map().*/(identity/*->scala::Predef.identity().*/) + Some/*->scala::Some.*//*->scala::Some.apply().*/(1).map/*->scala::Option#map().*/(identity/*->scala::Predef.identity().*//*->local0*/) List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).foldLeft/*->scala::collection::LinearSeqOps#foldLeft().*/("")(_ +/*->java::lang::String#`+`().*/ _) } diff --git a/tests/semanticdb/expect/ForComprehension.expect.scala b/tests/semanticdb/expect/ForComprehension.expect.scala index f2e2dca08a3e..c4d3340bc84c 100644 --- a/tests/semanticdb/expect/ForComprehension.expect.scala +++ b/tests/semanticdb/expect/ForComprehension.expect.scala @@ -3,38 +3,38 @@ 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*//*->local1*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::IterableOps#withFilter().*/ + 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 (a/*->local0*/, b/*->local1*/, c/*->local2*/) + } yield (/*->scala::Tuple3.apply().*/a/*->local0*/, b/*->local1*/, c/*->local2*/) for { a/*<-local4*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1)/*->scala::collection::immutable::List#flatMap().*/ b/*<-local5*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(a/*->local4*/)/*->scala::collection::IterableOps#withFilter().*/ if ( - a/*->local4*/, + /*->scala::Tuple2.apply().*/a/*->local4*/, b/*->local5*/ - ) ==/*->scala::Any#`==`().*/ (1, 2)/*->scala::collection::WithFilter#flatMap().*/ - ( - c/*<-local7*/, + ) ==/*->scala::Any#`==`().*/ (/*->scala::Tuple2.apply().*/1, 2)/*->scala::collection::WithFilter#flatMap().*/ + /*->local6*//*->scala::Tuple2.unapply().*/( + /*->scala::Tuple2.unapply().*/c/*<-local7*/, d/*<-local8*/ - ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((a/*->local4*/, b/*->local5*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/ + ) <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/((/*->scala::Tuple2.apply().*/a/*->local4*/, b/*->local5*/))/*->scala::collection::WithFilter#withFilter().*//*->scala::collection::IterableOps#withFilter().*/ if ( - a/*->local4*/, + /*->scala::Tuple4.apply().*/a/*->local4*/, b/*->local5*/, c/*->local7*/, d/*->local8*/ - ) ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#map().*/ - e/*<-local9*//*->local9*/ = ( - a/*->local4*/, + ) ==/*->scala::Any#`==`().*/ (/*->scala::Tuple4.apply().*/1, 2, 3, 4)/*->scala::collection::WithFilter#map().*/ + e/*<-local9*//*->scala::Tuple2.apply().*//*->local9*/ = ( + /*->scala::Tuple4.apply().*/a/*->local4*/, b/*->local5*/, c/*->local7*/, d/*->local8*/ )/*->scala::collection::IterableOps#withFilter().*/ - if e/*->local9*/ ==/*->scala::Any#`==`().*/ (1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/ + if e/*->local9*/ ==/*->scala::Any#`==`().*/ (/*->scala::Tuple4.apply().*/1, 2, 3, 4)/*->scala::collection::WithFilter#flatMap().*/ f/*<-local10*/ <- List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(e/*->local9*/)/*->scala::collection::immutable::List#map().*/ } yield { ( - a/*->local4*/, + /*->scala::Tuple6.apply().*/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 80d89954e06b..c66407f5f5ce 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.*/ given :[A](any: A) - de/*<-a::b::Givens.given_sayHello_of_A.*//*<-a::b::Givens.given_sayHello_of_A.sayHello().[A]*//*<-a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->a::b::Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<-a::b::Givens.given_sayHello_of_A.sayHello().*/ = s"Hello, I am $any/*->a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->scala::StringContext#s().*/" + de/*<-a::b::Givens.given_sayHello_of_A.*//*<-a::b::Givens.given_sayHello_of_A.sayHello().[A]*//*<-a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->a::b::Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<-a::b::Givens.given_sayHello_of_A.sayHello().*/ = s"/*->scala::StringContext.apply().*/Hello, I am $any/*->a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->scala::StringContext#s().*/" given :[B](any: B) - def /*<-a::b::Givens.given_sayGoodbye_of_B.*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*/sayGoodbye/*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/ = s"Goodbye, from $any/*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*->scala::StringContext#s().*/" - def saySoLong/*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().*/ = s"So Long, from $any/*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->scala::StringContext#s().*/" + def /*<-a::b::Givens.given_sayGoodbye_of_B.*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*/sayGoodbye/*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/ = s"/*->scala::StringContext.apply().*/Goodbye, from $any/*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*->scala::StringContext#s().*/" + def saySoLong/*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().*/ = s"/*->scala::StringContext.apply().*/So Long, from $any/*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->scala::StringContext#s().*/" val hello1/*<-a::b::Givens.hello1.*/ = /*->a::b::Givens.given_sayHello_of_A.sayHello().*/1.sayHello val goodbye1/*<-a::b::Givens.goodbye1.*/ = /*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/1.sayGoodbye diff --git a/tests/semanticdb/expect/ImplicitConversion.expect.scala b/tests/semanticdb/expect/ImplicitConversion.expect.scala index d46d03f4a573..0d13a0af558c 100644 --- a/tests/semanticdb/expect/ImplicitConversion.expect.scala +++ b/tests/semanticdb/expect/ImplicitConversion.expect.scala @@ -9,20 +9,20 @@ class ImplicitConversion/*<-example::ImplicitConversion#*/ { ): Int/*->scala::Int#*/ = 42 val message/*<-example::ImplicitConversion#message.*/ = "" val number/*<-example::ImplicitConversion#number.*/ = 42 - val tuple/*<-example::ImplicitConversion#tuple.*/ = (1, 2) + val tuple/*<-example::ImplicitConversion#tuple.*/ = (/*->scala::Tuple2.apply().*/1, 2) val char/*<-example::ImplicitConversion#char.*/: Char/*->scala::Char#*/ = 'a' // extension methods /*->scala::Predef.augmentString().*/message/*->example::ImplicitConversion#message.*/ .stripSuffix/*->scala::collection::StringOps#stripSuffix().*/("h") - tuple/*->example::ImplicitConversion#tuple.*/ +/*->example::ImplicitConversion.newAny2stringadd#`+`().*/ "Hello" + /*->example::ImplicitConversion.newAny2stringadd().*/tuple/*->example::ImplicitConversion#tuple.*/ +/*->example::ImplicitConversion.newAny2stringadd#`+`().*/ "Hello" // implicit conversions val x/*<-example::ImplicitConversion#x.*/: Int/*->scala::Int#*/ = /*->example::ImplicitConversion#string2Number().*/message/*->example::ImplicitConversion#message.*/ // interpolators - s"Hello $message/*->example::ImplicitConversion#message.*/ $number/*->example::ImplicitConversion#number.*//*->scala::StringContext#s().*/" - /*->scala::Predef.augmentString().*/s"""Hello + s"/*->scala::StringContext.apply().*/Hello $message/*->example::ImplicitConversion#message.*/ $number/*->example::ImplicitConversion#number.*//*->scala::StringContext#s().*/" + /*->scala::Predef.augmentString().*/s"""/*->scala::StringContext.apply().*/Hello |$message/*->example::ImplicitConversion#message.*/ |$number/*->example::ImplicitConversion#number.*//*->scala::StringContext#s().*/""".stripMargin/*->scala::collection::StringOps#stripMargin(+1).*/ diff --git a/tests/semanticdb/expect/Issue1749.expect.scala b/tests/semanticdb/expect/Issue1749.expect.scala index 185b2cd86318..b047b771e9ea 100644 --- a/tests/semanticdb/expect/Issue1749.expect.scala +++ b/tests/semanticdb/expect/Issue1749.expect.scala @@ -6,8 +6,8 @@ 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().*/(x1/*->example::Issue1749#x1.*/, x1/*->example::Issue1749#x1.*/)/*->scala::math::Ordering.Tuple2().*//*->scala::math::Ordering.Int.*/ - .compare/*->scala::math::Ordered#compare().*/((x2/*->example::Issue1749#x2.*/, x2/*->example::Issue1749#x2.*/)) + /*->scala::math::Ordered.orderingToOrdered().*/(/*->scala::Tuple2.apply().*/x1/*->example::Issue1749#x1.*/, x1/*->example::Issue1749#x1.*/)/*->scala::math::Ordering.Tuple2().*//*->scala::math::Ordering.Int.*/ + .compare/*->scala::math::Ordered#compare().*/((/*->scala::Tuple2.apply().*/x2/*->example::Issue1749#x2.*/, x2/*->example::Issue1749#x2.*/)) } class Issue1854/*<-example::Issue1854#*/ { diff --git a/tests/semanticdb/expect/NamedApplyBlock.expect.scala b/tests/semanticdb/expect/NamedApplyBlock.expect.scala index a527c523bda5..2a9b1d6bbaf8 100644 --- a/tests/semanticdb/expect/NamedApplyBlock.expect.scala +++ b/tests/semanticdb/expect/NamedApplyBlock.expect.scala @@ -3,12 +3,12 @@ package example object NamedApplyBlockMethods/*<-example::NamedApplyBlockMethods.*/ { val local/*<-example::NamedApplyBlockMethods.local.*/ = 1 def foo/*<-example::NamedApplyBlockMethods.foo().*/(a/*<-example::NamedApplyBlockMethods.foo().(a)*/: Int/*->scala::Int#*/ = 1, b/*<-example::NamedApplyBlockMethods.foo().(b)*/: Int/*->scala::Int#*/ = 2, c/*<-example::NamedApplyBlockMethods.foo().(c)*/: Int/*->scala::Int#*/ = 3): Int/*->scala::Int#*/ = a/*->example::NamedApplyBlockMethods.foo().(a)*/ +/*->scala::Int#`+`(+4).*/ b/*->example::NamedApplyBlockMethods.foo().(b)*/ +/*->scala::Int#`+`(+4).*/ c/*->example::NamedApplyBlockMethods.foo().(c)*/ - def baseCase/*<-example::NamedApplyBlockMethods.baseCase().*/ = foo/*->example::NamedApplyBlockMethods.foo().*/(local/*->example::NamedApplyBlockMethods.local.*/, c = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter - def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*/(local/*->example::NamedApplyBlockMethods.local.*/, c = foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter + def baseCase/*<-example::NamedApplyBlockMethods.baseCase().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local0*/(local/*->example::NamedApplyBlockMethods.local.*/, c = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter + def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local2*/(local/*->example::NamedApplyBlockMethods.local.*/, c = /*->local1*/foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter } 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.*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail = "tail") + val msg/*<-example::NamedApplyBlockCaseClassConstruction.msg.*/ = Msg/*->example::NamedApplyBlockCaseClassConstruction.Msg.*//*->local3*//*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail = "tail") } diff --git a/tests/semanticdb/expect/NamedArguments.expect.scala b/tests/semanticdb/expect/NamedArguments.expect.scala index 346525953482..ee0fd5457dfa 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.*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg + User/*->example::NamedArguments#User.*//*->example::NamedArguments#User.apply().*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg User/*->example::NamedArguments#User.*/.apply/*->example::NamedArguments#User.apply().*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg } diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala index 3486bb82773a..6906ab3f83f6 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -9,22 +9,22 @@ class Synthetic/*<-example::Synthetic#*/ { // See https://github.com/scalameta/scalameta/issues/977 val Name/*<-example::Synthetic#Name.*/ = /*->scala::Predef.augmentString().*/"name:(.*)".r/*->scala::collection::StringOps#r().*/ - /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/val x/*<-local0*//*<-example::Synthetic#x.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ xs/*<-local1*//*<-example::Synthetic#xs.*//*->local0*//*->local1*/ = LazyList/*->scala::package.LazyList.*//*->scala::collection::IterableFactory#apply().*/(1, 2) + val x/*<-local0*//*<-example::Synthetic#x.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ xs/*<-local1*//*<-example::Synthetic#xs.*//*->scala::Tuple2.apply().*//*->local0*//*->local1*/ = LazyList/*->scala::package.LazyList.*//*->scala::collection::IterableFactory#apply().*/(1, 2) val Name/*->example::Synthetic#Name.*//*->scala::util::matching::Regex#unapplySeq().*/(name/*<-example::Synthetic#name.*//*<-local2*/)/*->local2*/ = "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 lst/*<-example::Synthetic#lst.*/ = 1 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/2 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*//*->scala::collection::immutable::LazyList.Deferrer#`#::`().*/ - for (x/*<-local3*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y/*<-local4*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(x/*->local3*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local3*/) - for (i/*<-local5*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local6*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (i/*->local5*/, j/*->local6*/) - for (i/*<-local7*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local8*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::IterableOps#withFilter().*/ if i/*->local7*/ %/*->scala::Int#`%`(+3).*/ 2 ==/*->scala::Int#`==`(+3).*/ 0/*->scala::collection::WithFilter#map().*/) yield (i/*->local7*/, j/*->local8*/) + for (x/*<-local3*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y/*<-local4*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(/*->scala::Predef.ArrowAssoc().*/x/*->local3*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local3*/) + for (i/*<-local5*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local6*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (/*->scala::Tuple2.apply().*/i/*->local5*/, j/*->local6*/) + for (i/*<-local7*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local8*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::IterableOps#withFilter().*/ if i/*->local7*/ %/*->scala::Int#`%`(+3).*/ 2 ==/*->scala::Int#`==`(+3).*/ 0/*->scala::collection::WithFilter#map().*/) yield (/*->scala::Tuple2.apply().*/i/*->local7*/, j/*->local8*/) object s/*<-example::Synthetic#s.*/ { def apply/*<-example::Synthetic#s.apply().*/() = 2 s/*->example::Synthetic#s.apply().*/() s.apply/*->example::Synthetic#s.apply().*/() case class Bar/*<-example::Synthetic#s.Bar#*/() - Bar/*->example::Synthetic#s.Bar.*/() + 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) } diff --git a/tests/semanticdb/expect/ValPattern.expect.scala b/tests/semanticdb/expect/ValPattern.expect.scala index 3ffb3e41782f..7c03a24d1c61 100644 --- a/tests/semanticdb/expect/ValPattern.expect.scala +++ b/tests/semanticdb/expect/ValPattern.expect.scala @@ -2,18 +2,18 @@ package example class ValPattern/*<-example::ValPattern#*/ { - /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/val (left/*<-example::ValPattern#left.*/, right/*<-example::ValPattern#right.*/) = (1, 2) - val Some/*->scala::Some.*/(number1/*<-example::ValPattern#number1.*//*<-local0*/)/*->local0*/ = - Some/*->scala::Some.*/(1) + 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.*//*<-local0*/)/*->local0*/ = + Some/*->scala::Some.*//*->scala::Some.apply().*/(1) - /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/var (leftVar/*<-example::ValPattern#leftVar().*/, rightVar/*<-example::ValPattern#rightVar().*/) = (1, 2) - var Some/*->scala::Some.*/(number1Var/*<-example::ValPattern#number1Var().*//*<-local1*/)/*->local1*/ = - Some/*->scala::Some.*/(1) + 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().*//*<-local1*/)/*->local1*/ = + Some/*->scala::Some.*//*->scala::Some.apply().*/(1) def app/*<-example::ValPattern#app().*/(): Unit/*->scala::Unit#*/ = { println/*->scala::Predef.println(+1).*/( ( - number1/*->example::ValPattern#number1.*/, + /*->scala::Tuple6.apply().*/number1/*->example::ValPattern#number1.*/, left/*->example::ValPattern#left.*/, right/*->example::ValPattern#right.*/, number1Var/*->example::ValPattern#number1Var().*/, @@ -22,16 +22,16 @@ class ValPattern/*<-example::ValPattern#*/ { ) ) locally/*->dotty::DottyPredef.locally().*/ { - /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/val (left/*<-local2*/, right/*<-local3*/) = (1, 2) - val Some/*->scala::Some.*/(number1/*<-local4*/)/*->local4*/ = - Some/*->scala::Some.*/(1) + val (left/*<-local2*/, right/*<-local3*/) = (/*->scala::Tuple2.apply().*/1, 2) + val Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1/*<-local4*/)/*->local4*/ = + Some/*->scala::Some.*//*->scala::Some.apply().*/(1) - /*->scala::Tuple2#_1.*//*->scala::Tuple2#_2.*/var (leftVar/*<-local5*/, rightVar/*<-local6*/) = (1, 2) - var Some/*->scala::Some.*/(number1Var/*<-local7*/)/*->local7*/ = - Some/*->scala::Some.*/(1) + var (leftVar/*<-local5*/, rightVar/*<-local6*/) = (/*->scala::Tuple2.apply().*/1, 2) + var Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1Var/*<-local7*/)/*->local7*/ = + Some/*->scala::Some.*//*->scala::Some.apply().*/(1) println/*->scala::Predef.println(+1).*/( ( - number1/*->local4*/, + /*->scala::Tuple6.apply().*/number1/*->local4*/, left/*->local2*/, right/*->local3*/, number1Var/*->local7*/, diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 711cdcfd548a..cd96f83e5378 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -193,7 +193,7 @@ Uri => Annotations.scala Text => empty Language => Scala Symbols => 22 entries -Occurrences => 51 entries +Occurrences => 63 entries Symbols: annot/Alias. => final object Alias @@ -232,41 +232,53 @@ Occurrences: [4:22..4:34): experimental -> scalaShadowing/language.experimental. [4:35..4:41): macros -> scalaShadowing/language.experimental.macros. [6:1..6:16): ClassAnnotation -> com/javacp/annot/ClassAnnotation# +[6:16..6:16): -> com/javacp/annot/ClassAnnotation#``(). [7:6..7:17): Annotations <- annot/Annotations# [7:17..7:72): <- annot/Annotations#``(). [7:19..7:42): TypeParameterAnnotation -> com/javacp/annot/TypeParameterAnnotation# +[7:42..7:42): -> com/javacp/annot/TypeParameterAnnotation#``(). [7:43..7:44): T <- annot/Annotations#[T] [7:47..7:66): ParameterAnnotation -> com/javacp/annot/ParameterAnnotation# +[7:66..7:66): -> com/javacp/annot/ParameterAnnotation#``(). [7:67..7:68): x <- annot/Annotations#x. [7:70..7:71): T -> annot/Annotations#[T] [7:75..7:79): self <- local0 [7:81..7:87): AnyRef -> scala/AnyRef# [8:3..8:18): FieldAnnotation -> com/javacp/annot/FieldAnnotation# +[8:18..8:18): -> com/javacp/annot/FieldAnnotation#``(). [9:6..9:11): field <- annot/Annotations#field. [11:3..11:19): MethodAnnotation -> com/javacp/annot/MethodAnnotation# +[11:19..11:19): -> com/javacp/annot/MethodAnnotation#``(). [12:6..12:12): method <- annot/Annotations#method(). [13:5..13:20): LocalAnnotation -> com/javacp/annot/LocalAnnotation# +[13:20..13:20): -> com/javacp/annot/LocalAnnotation#``(). [14:8..14:13): local <- local1 [15:4..15:9): local -> local1 [17:3..17:17): TypeAnnotation -> com/javacp/annot/TypeAnnotation# +[17:17..17:17): -> com/javacp/annot/TypeAnnotation#``(). [18:7..18:8): S <- annot/Annotations#S# [21:6..21:7): B <- annot/B# [21:7..21:40): <- annot/B#``(). [21:9..21:30): ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# +[21:30..21:30): -> 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# +[22:24..22:24): -> com/javacp/annot/ConstructorAnnotation#``(). [23:6..23:12): <- annot/B#``(+1). [23:20..23:20): -> annot/B#``(). [26:1..26:17): ObjectAnnotation -> com/javacp/annot/ObjectAnnotation# +[26:17..26:17): -> com/javacp/annot/ObjectAnnotation#``(). [27:7..27:8): M <- annot/M. [28:3..28:18): MacroAnnotation -> com/javacp/annot/MacroAnnotation# +[28:18..28:18): -> com/javacp/annot/MacroAnnotation#``(). [29:6..29:7): m <- annot/M.m(). [29:8..29:10): TT <- annot/M.m().[TT] [29:13..29:16): Int -> scala/Int# [29:16..29:16): -> scala/Predef.`???`(). [32:0..32:0): <- annot/T#``(). [32:1..32:16): TraitAnnotation -> com/javacp/annot/TraitAnnotation# +[32:16..32:16): -> com/javacp/annot/TraitAnnotation#``(). [33:6..33:7): T <- annot/T# [35:7..35:12): Alias <- annot/Alias. [36:7..36:8): A <- annot/Alias.A# @@ -574,7 +586,7 @@ Uri => Enums.scala Text => empty Language => Scala Symbols => 157 entries -Occurrences => 183 entries +Occurrences => 188 entries Symbols: _empty_/Enums. => final object Enums @@ -844,6 +856,7 @@ Occurrences: [49:18..49:21): <:< -> _empty_/Enums.`<:<`# [49:22..49:23): T -> _empty_/Enums.`<:<`.given_T().[T] [49:27..49:31): Refl -> _empty_/Enums.`<:<`.Refl. +[49:31..49:31): -> _empty_/Enums.`<:<`.Refl.apply(). [51:6..51:12): [A, B] <- _empty_/Enums.unwrap(). [51:7..51:8): A <- _empty_/Enums.unwrap().[A] [51:10..51:11): B <- _empty_/Enums.unwrap().[B] @@ -859,15 +872,19 @@ Occurrences: [51:71..51:72): B -> _empty_/Enums.unwrap().[B] [51:76..51:78): ev -> _empty_/Enums.unwrap().(ev) [52:9..52:13): Refl -> _empty_/Enums.`<:<`.Refl. +[52:13..52:13): -> _empty_/Enums.`<:<`.Refl.unapply(). [52:19..52:22): opt -> _empty_/Enums.unwrap().(opt) [52:23..52:30): flatMap -> scala/Option#flatMap(). [52:31..52:39): identity -> scala/Predef.identity(). +[52:31..52:31): -> local0 [52:40..52:46): Option -> scala/Option# [52:47..52:48): B -> _empty_/Enums.unwrap().[B] [54:6..54:11): some1 <- _empty_/Enums.some1. [54:14..54:14): -> _empty_/Enums.unwrap(). [54:14..54:18): Some -> scala/Some. +[54:18..54:18): -> scala/Some.apply(). [54:19..54:23): Some -> scala/Some. +[54:23..54:23): -> scala/Some.apply(). [54:27..54:27): -> _empty_/Enums.`<:<`.given_T(). [56:7..56:13): Planet <- _empty_/Enums.Planet# [56:13..56:43): <- _empty_/Enums.Planet#``(). @@ -929,7 +946,7 @@ Uri => EtaExpansion.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 10 entries +Occurrences => 12 entries Symbols: example/EtaExpansion# => class EtaExpansion @@ -941,8 +958,10 @@ Occurrences: [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(). @@ -1154,7 +1173,7 @@ Uri => ForComprehension.scala Text => empty Language => Scala Symbols => 13 entries -Occurrences => 72 entries +Occurrences => 88 entries Symbols: example/ForComprehension# => class ForComprehension @@ -1180,7 +1199,10 @@ Occurrences: [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(). @@ -1193,6 +1215,7 @@ Occurrences: [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 @@ -1205,26 +1228,36 @@ Occurrences: [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 @@ -1232,12 +1265,14 @@ Occurrences: [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 @@ -1254,7 +1289,7 @@ Uri => Givens.scala Text => empty Language => Scala Symbols => 31 entries -Occurrences => 69 entries +Occurrences => 72 entries Symbols: a/b/Givens. => final object Givens @@ -1298,6 +1333,7 @@ Occurrences: [5:13..5:16): any <- a/b/Givens.given_sayHello_of_A.sayHello().(any) [5:18..5:19): A -> a/b/Givens.given_sayHello_of_A.sayHello().[A] [6:8..6:16): sayHello <- a/b/Givens.given_sayHello_of_A.sayHello(). +[6:21..6:21): -> scala/StringContext.apply(). [6:34..6:37): any -> a/b/Givens.given_sayHello_of_A.sayHello().(any) [6:37..6:37): -> scala/StringContext#s(). [8:8..9:8): <- a/b/Givens.given_sayGoodbye_of_B. @@ -1308,9 +1344,11 @@ Occurrences: [8:18..8:19): B -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] [8:18..8:19): B -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] [9:8..9:18): sayGoodbye <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). +[9:23..9:23): -> scala/StringContext.apply(). [9:38..9:41): any -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) [9:41..9:41): -> scala/StringContext#s(). [10:8..10:17): saySoLong <- a/b/Givens.given_sayGoodbye_of_B.saySoLong(). +[10:22..10:22): -> scala/StringContext.apply(). [10:37..10:40): any -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) [10:40..10:40): -> scala/StringContext#s(). [12:6..12:12): hello1 <- a/b/Givens.hello1. @@ -1369,7 +1407,7 @@ Uri => ImplicitConversion.scala Text => empty Language => Scala Symbols => 23 entries -Occurrences => 58 entries +Occurrences => 62 entries Symbols: example/ImplicitConversion# => class ImplicitConversion @@ -1411,21 +1449,25 @@ 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:26): -> scala/StringContext#s(). [24:2..24:2): -> scala/Predef.augmentString(). +[24:6..24:6): -> scala/StringContext.apply(). [25:7..25:14): message -> example/ImplicitConversion#message. [26:7..26:13): number -> example/ImplicitConversion#number. [26:13..26:13): -> scala/StringContext#s(). @@ -1561,7 +1603,7 @@ Uri => Issue1749.scala Text => empty Language => Scala Symbols => 7 entries -Occurrences => 28 entries +Occurrences => 30 entries Symbols: example/Issue1749# => class Issue1749 @@ -1583,11 +1625,13 @@ Occurrences: [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# @@ -2080,7 +2124,7 @@ Uri => NamedApplyBlock.scala Text => empty Language => Scala Symbols => 44 entries -Occurrences => 35 entries +Occurrences => 40 entries Symbols: example/NamedApplyBlockCaseClassConstruction. => final object NamedApplyBlockCaseClassConstruction @@ -2147,10 +2191,13 @@ Occurrences: [4:61..4:62): c -> example/NamedApplyBlockMethods.foo().(c) [5:6..5:14): baseCase <- example/NamedApplyBlockMethods.baseCase(). [5:17..5:20): foo -> example/NamedApplyBlockMethods.foo(). +[5:17..5:17): -> local0 [5:21..5:26): local -> example/NamedApplyBlockMethods.local. [6:6..6:15): recursive <- example/NamedApplyBlockMethods.recursive(). [6:18..6:21): foo -> example/NamedApplyBlockMethods.foo(). +[6:18..6:18): -> local2 [6:22..6:27): local -> example/NamedApplyBlockMethods.local. +[6:33..6:33): -> local1 [9:7..9:43): NamedApplyBlockCaseClassConstruction <- example/NamedApplyBlockCaseClassConstruction. [10:13..10:16): Msg <- example/NamedApplyBlockCaseClassConstruction.Msg# [10:16..10:70): <- example/NamedApplyBlockCaseClassConstruction.Msg#``(). @@ -2163,6 +2210,8 @@ 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:12..12:12): -> local3 +[12:15..12:15): -> example/NamedApplyBlockCaseClassConstruction.Msg.apply(). [12:16..12:24): bodyText -> example/NamedApplyBlockCaseClassConstruction.bodyText. expect/NamedArguments.scala @@ -2174,7 +2223,7 @@ Uri => NamedArguments.scala Text => empty Language => Scala Symbols => 15 entries -Occurrences => 10 entries +Occurrences => 11 entries Symbols: example/NamedArguments# => class NamedArguments @@ -2202,6 +2251,7 @@ Occurrences: [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(). [5:2..5:6): User -> example/NamedArguments#User. [5:7..5:12): apply -> example/NamedArguments#User.apply(). @@ -2424,7 +2474,7 @@ Uri => Synthetic.scala Text => empty Language => Scala Symbols => 37 entries -Occurrences => 158 entries +Occurrences => 161 entries Symbols: example/Synthetic# => class Synthetic @@ -2488,14 +2538,13 @@ Occurrences: [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:2..11:2): -> scala/Tuple2#_1. -[11:2..11:2): -> scala/Tuple2#_2. [11:6..11:7): x <- local0 [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 <- local1 [11:12..11:14): xs <- example/Synthetic#xs. +[11:14..11:14): -> scala/Tuple2.apply(). [11:14..11:14): -> local0 [11:14..11:14): -> local1 [11:17..11:25): LazyList -> scala/package.LazyList. @@ -2525,6 +2574,7 @@ Occurrences: [17:28..17:33): until -> scala/runtime/RichInt#until(). [17:36..17:36): -> scala/collection/immutable/Range#foreach(). [17:38..17:45): println -> scala/Predef.println(+1). +[17:46..17:46): -> scala/Predef.ArrowAssoc(). [17:46..17:47): x -> local3 [17:48..17:50): -> -> scala/Predef.ArrowAssoc#`->`(). [17:51..17:52): x -> local3 @@ -2536,6 +2586,7 @@ Occurrences: [18:26..18:26): -> scala/LowPriorityImplicits#intWrapper(). [18:28..18:33): until -> scala/runtime/RichInt#until(). [18:36..18:36): -> scala/collection/immutable/Range#map(). +[18:45..18:45): -> scala/Tuple2.apply(). [18:45..18:46): i -> local5 [18:48..18:49): j -> local6 [19:7..19:8): i <- local7 @@ -2550,6 +2601,7 @@ Occurrences: [19:42..19:43): % -> scala/Int#`%`(+3). [19:46..19:48): == -> scala/Int#`==`(+3). [19:50..19:50): -> scala/collection/WithFilter#map(). +[19:59..19:59): -> scala/Tuple2.apply(). [19:59..19:60): i -> local7 [19:62..19:63): j -> local8 [21:9..21:10): s <- example/Synthetic#s. @@ -2559,6 +2611,7 @@ Occurrences: [25:15..25:18): Bar <- example/Synthetic#s.Bar# [25:18..25:20): <- example/Synthetic#s.Bar#``(). [26:4..26:7): Bar -> example/Synthetic#s.Bar. +[26:7..26:7): -> example/Synthetic#s.Bar.apply(). [27:9..27:21): asInstanceOf -> scala/Any#asInstanceOf(). [27:22..27:25): Int -> scala/Int# [27:29..27:32): Int -> scala/Int# @@ -3065,7 +3118,7 @@ Uri => ValPattern.scala Text => empty Language => Scala Symbols => 23 entries -Occurrences => 54 entries +Occurrences => 60 entries Symbols: example/ValPattern# => class ValPattern @@ -3096,27 +3149,30 @@ Occurrences: [0:8..0:15): example <- example/ [2:6..2:16): ValPattern <- example/ValPattern# [4:2..4:2): <- example/ValPattern#``(). -[4:2..4:2): -> scala/Tuple2#_1. -[4:2..4:2): -> scala/Tuple2#_2. [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. [5:11..5:18): number1 <- local0 [5:19..5:19): -> local0 [6:4..6:8): Some -> scala/Some. -[8:2..8:2): -> scala/Tuple2#_1. -[8:2..8:2): -> scala/Tuple2#_2. +[6:8..6:8): -> scala/Some.apply(). [8:7..8:14): leftVar <- example/ValPattern#leftVar(). [8:16..8:24): rightVar <- example/ValPattern#rightVar(). +[8:29..8:29): -> scala/Tuple2.apply(). [9:6..9:10): Some -> scala/Some. +[9:10..9:10): -> scala/Some.unapply(). [9:11..9:21): number1Var <- example/ValPattern#number1Var(). [9:11..9:21): number1Var <- local1 [9:22..9:22): -> local1 [10:4..10:8): Some -> scala/Some. +[10:8..10:8): -> scala/Some.apply(). [12:6..12:9): app <- example/ValPattern#app(). [12:13..12:17): Unit -> scala/Unit# [13:4..13:11): println -> scala/Predef.println(+1). +[15:8..15:8): -> scala/Tuple6.apply(). [15:8..15:15): number1 -> example/ValPattern#number1. [16:8..16:12): left -> example/ValPattern#left. [17:8..17:13): right -> example/ValPattern#right. @@ -3124,23 +3180,26 @@ Occurrences: [19:8..19:15): leftVar -> example/ValPattern#leftVar(). [20:8..20:16): rightVar -> example/ValPattern#rightVar(). [23:4..23:11): locally -> dotty/DottyPredef.locally(). -[24:6..24:6): -> scala/Tuple2#_1. -[24:6..24:6): -> scala/Tuple2#_2. [24:11..24:15): left <- local2 [24:17..24:22): right <- local3 +[24:27..24:27): -> scala/Tuple2.apply(). [25:10..25:14): Some -> scala/Some. +[25:14..25:14): -> scala/Some.unapply(). [25:15..25:22): number1 <- local4 [25:23..25:23): -> local4 [26:8..26:12): Some -> scala/Some. -[28:6..28:6): -> scala/Tuple2#_1. -[28:6..28:6): -> scala/Tuple2#_2. +[26:12..26:12): -> scala/Some.apply(). [28:11..28:18): leftVar <- local5 [28:20..28:28): rightVar <- local6 +[28:33..28:33): -> scala/Tuple2.apply(). [29:10..29:14): Some -> scala/Some. +[29:14..29:14): -> scala/Some.unapply(). [29:15..29:25): number1Var <- local7 [29:26..29:26): -> local7 [30:8..30:12): Some -> scala/Some. +[30:12..30:12): -> scala/Some.apply(). [31:6..31:13): println -> scala/Predef.println(+1). +[33:10..33:10): -> scala/Tuple6.apply(). [33:10..33:17): number1 -> local4 [34:10..34:14): left -> local2 [35:10..35:15): right -> local3 @@ -3514,4 +3573,3 @@ 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(). - From 69f3d603208af82497d277929feedd729936a902 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Wed, 20 Nov 2019 23:19:22 +0100 Subject: [PATCH 091/107] exclude use occurrences of annotation constructors --- .../dotc/semanticdb/ExtractSemanticDB.scala | 1 + .../dotty/tools/dotc/semanticdb/Scala3.scala | 3 +++ .../expect/Annotations.expect.scala | 22 +++++++++--------- tests/semanticdb/expect/Flags.expect.scala | 2 +- tests/semanticdb/expect/Types.expect.scala | 6 ++--- tests/semanticdb/metac.expect | 23 ++++--------------- 6 files changed, 23 insertions(+), 34 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 2e0187adef4a..7268dc2614b3 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -97,6 +97,7 @@ class ExtractSemanticDB extends Phase with /** Uses of this symbol where the reference has given span should be excluded from semanticdb */ private def excludeUse(qualifier: Option[Symbol], sym: Symbol)(given Context): Boolean = excludeDefOrUse(sym) + || sym.isConstructor && sym.owner.isAnnotation || sym == defn.Any_typeCast || qualifier.exists(excludeQual) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index f7e6f4247699..75a65bafd9c1 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -123,6 +123,9 @@ object Scala3 with def isSyntheticWithIdent(given Context): Boolean = sym.is(Synthetic) && !sym.isAnonymous && !sym.name.isEmptyNumbered + def isAnnotation(given Context): Boolean = + sym.derivesFrom(defn.AnnotationClass) + end SymbolOps object LocalSymbol with diff --git a/tests/semanticdb/expect/Annotations.expect.scala b/tests/semanticdb/expect/Annotations.expect.scala index d6c97991aa91..70685535ddc8 100644 --- a/tests/semanticdb/expect/Annotations.expect.scala +++ b/tests/semanticdb/expect/Annotations.expect.scala @@ -4,33 +4,33 @@ import com.javacp.annot._ import scala.annotation.meta._ import scala.language/*->scalaShadowing::language.*/.experimental/*->scalaShadowing::language.experimental.*/.macros/*->scalaShadowing::language.experimental.macros.*/ -@ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*//*->com::javacp::annot::ClassAnnotation#``().*/ -class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*//*->com::javacp::annot::TypeParameterAnnotation#``().*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*//*->com::javacp::annot::ParameterAnnotation#``().*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => - @FieldAnnotation/*->com::javacp::annot::FieldAnnotation#*//*->com::javacp::annot::FieldAnnotation#``().*/ +@ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/ +class Annotations/*<-annot::Annotations#*/[@TypeParameterAnnotation/*->com::javacp::annot::TypeParameterAnnotation#*/ T/*<-annot::Annotations#[T]*/](@ParameterAnnotation/*->com::javacp::annot::ParameterAnnotation#*/ x/*<-annot::Annotations#x.*/: T/*->annot::Annotations#[T]*/) { self/*<-local0*/: AnyRef/*->scala::AnyRef#*/ => + @FieldAnnotation/*->com::javacp::annot::FieldAnnotation#*/ val field/*<-annot::Annotations#field.*/ = 42 - @MethodAnnotation/*->com::javacp::annot::MethodAnnotation#*//*->com::javacp::annot::MethodAnnotation#``().*/ + @MethodAnnotation/*->com::javacp::annot::MethodAnnotation#*/ def method/*<-annot::Annotations#method().*/ = { - @LocalAnnotation/*->com::javacp::annot::LocalAnnotation#*//*->com::javacp::annot::LocalAnnotation#``().*/ + @LocalAnnotation/*->com::javacp::annot::LocalAnnotation#*/ val local/*<-local1*/ = 42 local/*->local1*/ } - @TypeAnnotation/*->com::javacp::annot::TypeAnnotation#*//*->com::javacp::annot::TypeAnnotation#``().*/ + @TypeAnnotation/*->com::javacp::annot::TypeAnnotation#*/ type S/*<-annot::Annotations#S#*/ } -class B/*<-annot::B#*/ @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*//*->com::javacp::annot::ConstructorAnnotation#``().*/()(x/*<-annot::B#x.*/: Int/*->scala::Int#*/) { - @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*//*->com::javacp::annot::ConstructorAnnotation#``().*/ +class B/*<-annot::B#*/ @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/()(x/*<-annot::B#x.*/: Int/*->scala::Int#*/) { + @ConstructorAnnotation/*->com::javacp::annot::ConstructorAnnotation#*/ def this()/*<-annot::B#``(+1).*/ = this(42) } -@ObjectAnnotation/*->com::javacp::annot::ObjectAnnotation#*//*->com::javacp::annot::ObjectAnnotation#``().*/ +@ObjectAnnotation/*->com::javacp::annot::ObjectAnnotation#*/ object M/*<-annot::M.*/ { - @MacroAnnotation/*->com::javacp::annot::MacroAnnotation#*//*->com::javacp::annot::MacroAnnotation#``().*/ + @MacroAnnotation/*->com::javacp::annot::MacroAnnotation#*/ def m/*<-annot::M.m().*/[TT/*<-annot::M.m().[TT]*/]: Int/*->scala::Int#*//*->scala::Predef.`???`().*/ = macro ??? } -@TraitAnnotation/*->com::javacp::annot::TraitAnnotation#*//*->com::javacp::annot::TraitAnnotation#``().*/ +@TraitAnnotation/*->com::javacp::annot::TraitAnnotation#*/ trait T/*<-annot::T#*/ object Alias/*<-annot::Alias.*/ { diff --git a/tests/semanticdb/expect/Flags.expect.scala b/tests/semanticdb/expect/Flags.expect.scala index 5dc7eb9ecb0f..7e5304fd0e4d 100644 --- a/tests/semanticdb/expect/Flags.expect.scala +++ b/tests/semanticdb/expect/Flags.expect.scala @@ -20,7 +20,7 @@ package object p { final class Y/*<-flags::p::package.Y#*/ sealed trait Z/*<-flags::p::package.Z#*/ class AA/*<-flags::p::package.AA#*/(x/*<-flags::p::package.AA#x.*/: Int/*->scala::Int#*/, val y/*<-flags::p::package.AA#y.*/: Int/*->scala::Int#*/, var z/*<-flags::p::package.AA#z().*/: Int/*->scala::Int#*/) - class S/*<-flags::p::package.S#*/[@specialized/*->scala::specialized#*//*->scala::specialized#``(+2).*/ T/*<-flags::p::package.S#[T]*/] + 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.*//*<-local0*/)/*->local0*/ = ???/*->scala::Predef.`???`().*/ ???/*->scala::Predef.`???`().*/ match { case List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs2/*<-local1*/) => ???/*->scala::Predef.`???`().*/ } ???/*->scala::Predef.`???`().*/ match { case _: List/*->scala::package.List#*/[t/*<-local2*/] => ???/*->scala::Predef.`???`().*/ } diff --git a/tests/semanticdb/expect/Types.expect.scala b/tests/semanticdb/expect/Types.expect.scala index 57cc3e8131b2..75aae003f9a0 100644 --- a/tests/semanticdb/expect/Types.expect.scala +++ b/tests/semanticdb/expect/Types.expect.scala @@ -3,9 +3,9 @@ package types import scala.language/*->scalaShadowing::language.*/.existentials/*->scalaShadowing::language.existentials.*/ import scala.language/*->scalaShadowing::language.*/.higherKinds/*->scalaShadowing::language.higherKinds.*/ -class ann/*<-types::ann#*//*->scala::annotation::Annotation#``().*/[T/*<-types::ann#[T]*/](x/*<-types::ann#x.*/: T/*->types::ann#[T]*/) extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ -class ann1/*<-types::ann1#*//*->scala::annotation::Annotation#``().*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ -class ann2/*<-types::ann2#*//*->scala::annotation::Annotation#``().*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class ann/*<-types::ann#*/[T/*<-types::ann#[T]*/](x/*<-types::ann#x.*/: T/*->types::ann#[T]*/) extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class ann1/*<-types::ann1#*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ +class ann2/*<-types::ann2#*/ extends scala.annotation.StaticAnnotation/*->scala::annotation::StaticAnnotation#*/ class B/*<-types::B#*/ diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index cd96f83e5378..a3cc381d9e54 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -193,7 +193,7 @@ Uri => Annotations.scala Text => empty Language => Scala Symbols => 22 entries -Occurrences => 63 entries +Occurrences => 51 entries Symbols: annot/Alias. => final object Alias @@ -232,53 +232,41 @@ Occurrences: [4:22..4:34): experimental -> scalaShadowing/language.experimental. [4:35..4:41): macros -> scalaShadowing/language.experimental.macros. [6:1..6:16): ClassAnnotation -> com/javacp/annot/ClassAnnotation# -[6:16..6:16): -> com/javacp/annot/ClassAnnotation#``(). [7:6..7:17): Annotations <- annot/Annotations# [7:17..7:72): <- annot/Annotations#``(). [7:19..7:42): TypeParameterAnnotation -> com/javacp/annot/TypeParameterAnnotation# -[7:42..7:42): -> com/javacp/annot/TypeParameterAnnotation#``(). [7:43..7:44): T <- annot/Annotations#[T] [7:47..7:66): ParameterAnnotation -> com/javacp/annot/ParameterAnnotation# -[7:66..7:66): -> com/javacp/annot/ParameterAnnotation#``(). [7:67..7:68): x <- annot/Annotations#x. [7:70..7:71): T -> annot/Annotations#[T] [7:75..7:79): self <- local0 [7:81..7:87): AnyRef -> scala/AnyRef# [8:3..8:18): FieldAnnotation -> com/javacp/annot/FieldAnnotation# -[8:18..8:18): -> com/javacp/annot/FieldAnnotation#``(). [9:6..9:11): field <- annot/Annotations#field. [11:3..11:19): MethodAnnotation -> com/javacp/annot/MethodAnnotation# -[11:19..11:19): -> com/javacp/annot/MethodAnnotation#``(). [12:6..12:12): method <- annot/Annotations#method(). [13:5..13:20): LocalAnnotation -> com/javacp/annot/LocalAnnotation# -[13:20..13:20): -> com/javacp/annot/LocalAnnotation#``(). [14:8..14:13): local <- local1 [15:4..15:9): local -> local1 [17:3..17:17): TypeAnnotation -> com/javacp/annot/TypeAnnotation# -[17:17..17:17): -> com/javacp/annot/TypeAnnotation#``(). [18:7..18:8): S <- annot/Annotations#S# [21:6..21:7): B <- annot/B# [21:7..21:40): <- annot/B#``(). [21:9..21:30): ConstructorAnnotation -> com/javacp/annot/ConstructorAnnotation# -[21:30..21:30): -> 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# -[22:24..22:24): -> com/javacp/annot/ConstructorAnnotation#``(). [23:6..23:12): <- annot/B#``(+1). [23:20..23:20): -> annot/B#``(). [26:1..26:17): ObjectAnnotation -> com/javacp/annot/ObjectAnnotation# -[26:17..26:17): -> com/javacp/annot/ObjectAnnotation#``(). [27:7..27:8): M <- annot/M. [28:3..28:18): MacroAnnotation -> com/javacp/annot/MacroAnnotation# -[28:18..28:18): -> com/javacp/annot/MacroAnnotation#``(). [29:6..29:7): m <- annot/M.m(). [29:8..29:10): TT <- annot/M.m().[TT] [29:13..29:16): Int -> scala/Int# [29:16..29:16): -> scala/Predef.`???`(). [32:0..32:0): <- annot/T#``(). [32:1..32:16): TraitAnnotation -> com/javacp/annot/TraitAnnotation# -[32:16..32:16): -> com/javacp/annot/TraitAnnotation#``(). [33:6..33:7): T <- annot/T# [35:7..35:12): Alias <- annot/Alias. [36:7..36:8): A <- annot/Alias.A# @@ -1022,7 +1010,7 @@ Uri => Flags.scala Text => empty Language => Scala Symbols => 51 entries -Occurrences => 85 entries +Occurrences => 84 entries Symbols: flags/p/package. => final package object p @@ -1146,7 +1134,6 @@ Occurrences: [22:8..22:9): S <- flags/p/package.S# [22:9..22:25): <- flags/p/package.S#``(). [22:11..22:22): specialized -> scala/specialized# -[22:22..22:22): -> scala/specialized#``(+2). [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(). @@ -2732,7 +2719,7 @@ Uri => Types.scala Text => empty Language => Scala Symbols => 125 entries -Occurrences => 246 entries +Occurrences => 243 entries Symbols: local0 => abstract method k @@ -2870,7 +2857,6 @@ Occurrences: [3:13..3:21): language -> scalaShadowing/language. [3:22..3:33): higherKinds -> scalaShadowing/language.higherKinds. [5:6..5:9): ann <- types/ann# -[5:6..5:6): -> scala/annotation/Annotation#``(). [5:9..5:18): <- types/ann#``(). [5:10..5:11): T <- types/ann#[T] [5:13..5:14): x <- types/ann#x. @@ -2879,13 +2865,11 @@ Occurrences: [5:33..5:43): annotation -> scala/annotation/ [5:44..5:60): StaticAnnotation -> scala/annotation/StaticAnnotation# [6:6..6:10): ann1 <- types/ann1# -[6:6..6:6): -> scala/annotation/Annotation#``(). [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:6..7:6): -> scala/annotation/Annotation#``(). [7:19..7:19): <- types/ann2#``(). [7:19..7:24): scala -> scala/ [7:25..7:35): annotation -> scala/annotation/ @@ -3573,3 +3557,4 @@ 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(). + From dc1e127876cc6243eca4f45df7f58d1aea116269 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Thu, 21 Nov 2019 01:04:57 +0100 Subject: [PATCH 092/107] traverse parents if span exists --- .../dotc/semanticdb/ExtractSemanticDB.scala | 9 +- .../dotty/tools/dotc/semanticdb/Tools.scala | 2 +- .../expect/filename with spaces.expect.scala | 2 +- .../expect/filename with spaces.scala | 2 +- tests/semanticdb/metac.expect | 84 +++++++++---------- 5 files changed, 46 insertions(+), 53 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 7268dc2614b3..61544ade16e8 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -170,13 +170,8 @@ class ExtractSemanticDB extends Phase with if !excludeDef(ctorSym) registerDefinition(ctorSym, tree.constr.span, Set.empty) ctorParams(tree.constr.vparamss, tree.body)(traverseCtorParamTpt(ctorSym, _)) - for parent <- tree.parentsOrDerived do - if - parent.symbol != defn.ObjectClass.primaryConstructor - && parent.tpe.dealias != defn.SerializableType - && parent.symbol != defn.ProductClass - then - traverse(parent) + for parent <- tree.parentsOrDerived if parent.span.hasLength do + traverse(parent) val selfSpan = tree.self.span if selfSpan.exists && selfSpan.hasLength then traverse(tree.self) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala index dc962b7fb05b..cda7b6b5c418 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala @@ -43,7 +43,7 @@ object Tools with val realURI = realPath.toString given SourceFile = SourceFile.virtual(doc.uri, doc.text) sb.append(realURI).nl - sb.append("_" * realURI.length).nl + sb.append("-" * realURI.length).nl sb.nl sb.append("Summary:").nl sb.append("Schema => ").append(schemaString(doc.schema)).nl diff --git a/tests/semanticdb/expect/filename with spaces.expect.scala b/tests/semanticdb/expect/filename with spaces.expect.scala index 90ffb6265a64..29a4e899ca31 100644 --- a/tests/semanticdb/expect/filename with spaces.expect.scala +++ b/tests/semanticdb/expect/filename with spaces.expect.scala @@ -1,3 +1,3 @@ package example -class FilenameWithSpaces/*<-example::FilenameWithSpaces#*//*<=example.FilenameWithSpaces#*/ +class FilenameWithSpaces/*<-example::FilenameWithSpaces#*/ diff --git a/tests/semanticdb/expect/filename with spaces.scala b/tests/semanticdb/expect/filename with spaces.scala index 0a7c02c4d87b..b7f79c3ecac2 100644 --- a/tests/semanticdb/expect/filename with spaces.scala +++ b/tests/semanticdb/expect/filename with spaces.scala @@ -1,3 +1,3 @@ package example -class FilenameWithSpaces/*<=example.FilenameWithSpaces#*/ +class FilenameWithSpaces diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index a3cc381d9e54..b96e6d5d840c 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -1,5 +1,5 @@ expect/Access.scala -___________________ +------------------- Summary: Schema => SemanticDB v4 @@ -42,7 +42,7 @@ Occurrences: [9:11..9:14): ??? -> scala/Predef.`???`(). expect/Advanced.scala -_____________________ +--------------------- Summary: Schema => SemanticDB v4 @@ -185,7 +185,7 @@ Occurrences: [37:21..37:25): head -> scala/collection/IterableOps#head(). expect/Annotations.scala -________________________ +------------------------ Summary: Schema => SemanticDB v4 @@ -273,7 +273,7 @@ Occurrences: [36:11..36:26): ClassAnnotation -> com/javacp/annot/ClassAnnotation# expect/Anonymous.scala -______________________ +---------------------- Summary: Schema => SemanticDB v4 @@ -334,7 +334,7 @@ Occurrences: [18:16..18:19): Foo -> example/Anonymous#Foo# expect/Classes.scala -____________________ +-------------------- Summary: Schema => SemanticDB v4 @@ -483,7 +483,7 @@ Occurrences: [30:10..30:11): + -> scala/Int#`+`(+4). expect/Definitions.scala -________________________ +------------------------ Summary: Schema => SemanticDB v4 @@ -517,7 +517,7 @@ Occurrences: [6:8..6:9): E <- a/Definitions.E# expect/Empty.scala -__________________ +------------------ Summary: Schema => SemanticDB v4 @@ -548,7 +548,7 @@ Occurrences: [5:13..5:16): ??? -> scala/Predef.`???`(). expect/EmptyObject.scala -________________________ +------------------------ Summary: Schema => SemanticDB v4 @@ -566,7 +566,7 @@ Occurrences: [2:7..2:18): EmptyObject <- example/EmptyObject. expect/Enums.scala -__________________ +------------------ Summary: Schema => SemanticDB v4 @@ -574,7 +574,7 @@ Uri => Enums.scala Text => empty Language => Scala Symbols => 157 entries -Occurrences => 188 entries +Occurrences => 187 entries Symbols: _empty_/Enums. => final object Enums @@ -808,7 +808,6 @@ Occurrences: [37:7..37:12): Maybe <- _empty_/Enums.Maybe# [37:12..37:16): <- _empty_/Enums.Maybe#``(). [37:14..37:15): A <- _empty_/Enums.Maybe#[A] -[38:4..38:4): -> _empty_/Enums.Maybe#``(). [38:9..38:13): Just <- _empty_/Enums.Maybe.Just# [38:13..38:23): <- _empty_/Enums.Maybe.Just#``(). [38:14..38:19): value <- _empty_/Enums.Maybe.Just#value. @@ -926,7 +925,7 @@ Occurrences: [68:31..68:31): -> _empty_/Enums.Planet#``(). expect/EtaExpansion.scala -_________________________ +------------------------- Summary: Schema => SemanticDB v4 @@ -956,7 +955,7 @@ Occurrences: [4:25..4:26): + -> java/lang/String#`+`(). expect/Example.scala -____________________ +-------------------- Summary: Schema => SemanticDB v4 @@ -1002,7 +1001,7 @@ Occurrences: [9:37..9:37): -> java/lang/Integer#TYPE. expect/Flags.scala -__________________ +------------------ Summary: Schema => SemanticDB v4 @@ -1152,7 +1151,7 @@ Occurrences: [25:33..25:36): ??? -> scala/Predef.`???`(). expect/ForComprehension.scala -_____________________________ +----------------------------- Summary: Schema => SemanticDB v4 @@ -1268,7 +1267,7 @@ Occurrences: [41:6..41:7): f -> local10 expect/Givens.scala -___________________ +------------------- Summary: Schema => SemanticDB v4 @@ -1386,7 +1385,7 @@ Occurrences: [26:59..26:64): empty -> a/b/Givens.Monoid#empty(). expect/ImplicitConversion.scala -_______________________________ +------------------------------- Summary: Schema => SemanticDB v4 @@ -1486,7 +1485,7 @@ Occurrences: [34:58..34:63): other -> example/ImplicitConversion.newAny2stringadd#`+`().(other) expect/Imports.scala -____________________ +-------------------- Summary: Schema => SemanticDB v4 @@ -1505,7 +1504,7 @@ Occurrences: [0:26..0:34): NonFatal -> scala/util/control/NonFatal. expect/InstrumentTyper.scala -____________________________ +---------------------------- Summary: Schema => SemanticDB v4 @@ -1582,7 +1581,7 @@ Occurrences: [24:37..24:40): Int -> scala/Int# expect/Issue1749.scala -______________________ +---------------------- Summary: Schema => SemanticDB v4 @@ -1634,7 +1633,7 @@ Occurrences: [14:5..14:5): -> scala/collection/mutable/MapOps#update(). expect/Local.scala -__________________ +------------------ Summary: Schema => SemanticDB v4 @@ -1666,7 +1665,7 @@ Occurrences: [5:4..5:6): id -> local0 expect/Locals.scala -___________________ +------------------- Summary: Schema => SemanticDB v4 @@ -1691,7 +1690,7 @@ Occurrences: [5:9..5:10): x -> local0 expect/MetacJava.scala -______________________ +---------------------- Summary: Schema => SemanticDB v4 @@ -1788,7 +1787,7 @@ Occurrences: [18:38..18:41): Int -> scala/Int# expect/MethodUsages.scala -_________________________ +------------------------- Summary: Schema => SemanticDB v4 @@ -1880,7 +1879,7 @@ Occurrences: [30:4..30:7): m18 -> example/Methods#m18(+1). expect/Methods.scala -____________________ +-------------------- Summary: Schema => SemanticDB v4 @@ -2103,7 +2102,7 @@ Occurrences: [35:44..35:47): ??? -> scala/Predef.`???`(). expect/NamedApplyBlock.scala -____________________________ +---------------------------- Summary: Schema => SemanticDB v4 @@ -2202,7 +2201,7 @@ Occurrences: [12:16..12:24): bodyText -> example/NamedApplyBlockCaseClassConstruction.bodyText. expect/NamedArguments.scala -___________________________ +--------------------------- Summary: Schema => SemanticDB v4 @@ -2243,7 +2242,7 @@ Occurrences: [5:7..5:12): apply -> example/NamedArguments#User.apply(). expect/NewModifiers.scala -_________________________ +------------------------- Summary: Schema => SemanticDB v4 @@ -2265,7 +2264,7 @@ Occurrences: [2:18..2:21): Int -> scala/Int# expect/Objects.scala -____________________ +-------------------- Summary: Schema => SemanticDB v4 @@ -2285,7 +2284,7 @@ Occurrences: [3:9..3:10): Y <- objects/X.Y. expect/Overrides.scala -______________________ +---------------------- Summary: Schema => SemanticDB v4 @@ -2316,7 +2315,7 @@ Occurrences: [3:31..3:34): Int -> scala/Int# expect/Prefixes.scala -_____________________ +--------------------- Summary: Schema => SemanticDB v4 @@ -2399,7 +2398,7 @@ Occurrences: [31:14..31:17): ??? -> scala/Predef.`???`(). expect/Selfs.scala -__________________ +------------------ Summary: Schema => SemanticDB v4 @@ -2453,7 +2452,7 @@ Occurrences: [13:27..13:28): B -> selfs/B# expect/Synthetic.scala -______________________ +---------------------- Summary: Schema => SemanticDB v4 @@ -2666,7 +2665,7 @@ Occurrences: [45:11..45:11): -> scala/concurrent/ExecutionContext.Implicits.global(). expect/Traits.scala -___________________ +------------------- Summary: Schema => SemanticDB v4 @@ -2711,7 +2710,7 @@ Occurrences: [12:16..12:17): C -> traits/C# expect/Types.scala -__________________ +------------------ Summary: Schema => SemanticDB v4 @@ -3094,7 +3093,7 @@ Occurrences: [112:39..112:42): Int -> scala/Int# expect/ValPattern.scala -_______________________ +----------------------- Summary: Schema => SemanticDB v4 @@ -3192,7 +3191,7 @@ Occurrences: [38:10..38:18): rightVar -> local6 expect/Vals.scala -_________________ +----------------- Summary: Schema => SemanticDB v4 @@ -3378,7 +3377,7 @@ Occurrences: [49:3..49:18): .explicitSetter -> example/Vals#`explicitSetter_=`(). expect/Vararg.scala -___________________ +------------------- Summary: Schema => SemanticDB v4 @@ -3410,7 +3409,7 @@ Occurrences: [4:26..4:30): Unit -> scala/Unit# expect/filename with spaces.scala -_________________________________ +--------------------------------- Summary: Schema => SemanticDB v4 @@ -3430,7 +3429,7 @@ Occurrences: [2:6..2:24): FilenameWithSpaces <- example/FilenameWithSpaces# expect/local-file.scala -_______________________ +----------------------- Summary: Schema => SemanticDB v4 @@ -3455,7 +3454,7 @@ Occurrences: [5:10..5:11): + -> scala/Int#`+`(+4). expect/semanticdb-extract.scala -_______________________________ +------------------------------- Summary: Schema => SemanticDB v4 @@ -3509,7 +3508,7 @@ Occurrences: [16:20..16:23): Int -> scala/Int# expect/toplevel.scala -_____________________ +--------------------- Summary: Schema => SemanticDB v4 @@ -3557,4 +3556,3 @@ 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(). - From 298b2b4b78a28ef7623fbcfb63cef34d471c7c88 Mon Sep 17 00:00:00 2001 From: bishabosha Date: Thu, 21 Nov 2019 01:44:24 +0100 Subject: [PATCH 093/107] implicit objects have correct props --- .../src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala | 6 ++++-- tests/semanticdb/metac.expect | 6 +++--- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 61544ade16e8..09748520b080 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -342,6 +342,8 @@ class ExtractSemanticDB extends Phase with SymbolInformation.Kind.UNKNOWN_KIND private def symbolProps(sym: Symbol, symkinds: Set[SymbolKind])(given Context): Int = + if sym.is(ModuleClass) + return symbolProps(sym.sourceModule, symkinds) var props = 0 if sym.isPrimaryConstructor props |= SymbolInformation.Property.PRIMARY.value @@ -353,9 +355,9 @@ class ExtractSemanticDB extends Phase with props |= SymbolInformation.Property.SEALED.value if sym.isOneOf(GivenOrImplicit) props |= SymbolInformation.Property.IMPLICIT.value - if sym.is(Lazy) + if sym.is(Lazy, butNot=Module) props |= SymbolInformation.Property.LAZY.value - if sym.isAllOf(CaseClass) || sym.isAllOf(EnumCase) + if sym.isAllOf(Case | Module) || sym.is(CaseClass) || sym.isAllOf(EnumCase) props |= SymbolInformation.Property.CASE.value if sym.is(Covariant) props |= SymbolInformation.Property.COVARIANT.value diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index b96e6d5d840c..fcc2528a5d27 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -1289,19 +1289,19 @@ a/b/Givens.Monoid#empty(). => abstract method empty a/b/Givens.foo(). => method foo a/b/Givens.foo().(A) => implicit param A a/b/Givens.foo().[A] => typeparam A -a/b/Givens.given_Monoid_String. => final object given_Monoid_String +a/b/Givens.given_Monoid_String. => final implicit object given_Monoid_String a/b/Givens.given_Monoid_String.combine(). => method combine a/b/Givens.given_Monoid_String.combine().(x) => param x a/b/Givens.given_Monoid_String.combine().(y) => param y a/b/Givens.given_Monoid_String.empty(). => method empty -a/b/Givens.given_sayGoodbye_of_B. => final object given_sayGoodbye_of_B +a/b/Givens.given_sayGoodbye_of_B. => final implicit object given_sayGoodbye_of_B a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). => method sayGoodbye a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) => param any a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] => typeparam B a/b/Givens.given_sayGoodbye_of_B.saySoLong(). => method saySoLong a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) => param any a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] => typeparam B -a/b/Givens.given_sayHello_of_A. => final object given_sayHello_of_A +a/b/Givens.given_sayHello_of_A. => final implicit object given_sayHello_of_A a/b/Givens.given_sayHello_of_A.sayHello(). => method sayHello a/b/Givens.given_sayHello_of_A.sayHello().(any) => param any a/b/Givens.given_sayHello_of_A.sayHello().[A] => typeparam A From afff105439a7db9cb276c0b2924c607ef8971365 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 21 Nov 2019 14:32:04 +0100 Subject: [PATCH 094/107] support pattern vals --- .../dotc/semanticdb/ExtractSemanticDB.scala | 41 ++- .../dotty/tools/dotc/semanticdb/Tools.scala | 3 + .../dotc/semanticdb/SemanticdbTests.scala | 3 + tests/semanticdb/expect/Flags.expect.scala | 6 +- .../semanticdb/expect/Synthetic.expect.scala | 26 +- tests/semanticdb/expect/Synthetic.scala | 2 + .../semanticdb/expect/ValPattern.expect.scala | 24 +- tests/semanticdb/metac.expect | 331 +++++++++--------- 8 files changed, 236 insertions(+), 200 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 09748520b080..f592668880ea 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -114,9 +114,10 @@ class ExtractSemanticDB extends Phase with for annot <- tree.symbol.annotations do if annot.tree.span.exists - && annot.symbol.owner != defn.ScalaAnnotationInternal - then - traverse(annot.tree) + && annot.tree.span.hasLength + annot.tree match + case tree: Typed => () // hack for inline code + case tree => traverse(tree) tree match case tree: PackageDef => @@ -162,6 +163,9 @@ class ExtractSemanticDB extends Phase with tree.vparamss.foreach(_.foreach(vparam => registerSymbolSimple(vparam.symbol))) case _ => // ignore rhs + case PatternValDef(pat, rhs) => + traverse(rhs) + PatternValDef.collectUnapplyFuncs(pat).foreach(traverse) case tree => if !excludeChildren(tree.symbol) traverseChildren(tree) @@ -216,6 +220,37 @@ class ExtractSemanticDB extends Phase with case _ => traverseChildren(tree) + end traverse + + private object PatternValDef with + + def unapply(tree: ValDef)(given Context): Option[(Tree, Tree)] = tree.rhs match + + case Match(Typed(selected: Tree, tpt: TypeTree), CaseDef(pat: Tree, _, _) :: Nil) + if tpt.span.exists && !tpt.span.hasLength && tpt.tpe.isAnnotatedByUnchecked => + Some((pat, selected)) + + case _ => None + + private inline def (tpe: Types.Type) isAnnotatedByUnchecked(given Context) = tpe match + case Types.AnnotatedType(_, annot) => annot.symbol == defn.UncheckedAnnot + case _ => false + + def collectUnapplyFuncs(pat: Tree): List[Tree] = + + @tailrec + def impl(acc: List[Tree], pats: List[Tree]): List[Tree] = pats match + case pat::pats => pat match + case Typed(UnApply(fun: Tree, _, args), _) => impl(fun::acc, args:::pats) + case UnApply(fun: Tree, _, args) => impl(fun::acc, args:::pats) + case _ => impl(acc, pats) + + case Nil => acc + + impl(Nil, pat::Nil) + + end PatternValDef + private def (tree: NamedDefTree) adjustedNameSpan(given Context): Span = if tree.span.exists && tree.name.isAnonymousFunctionName || tree.name.isAnonymousClassName Span(tree.span.point) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala index cda7b6b5c418..08b1a15590de 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Tools.scala @@ -127,6 +127,9 @@ object Tools with && range.startCharacter != range.endCharacter && !(occ.symbol.isConstructor && occ.role.isDefinition) val line = sourceFile.lineContent(sourceFile.lineToOffset(range.startLine)) + assert(range.startCharacter <= line.length && range.endCharacter <= line.length, + s"Line is only ${line.length} - start line was ${range.startLine} in source ${sourceFile.name}" + ) sb.append(" ").append(line.substring(range.startCharacter, range.endCharacter)) case _ => sb.append("[):") diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index e8353572b24c..27fb485450fc 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -132,12 +132,15 @@ object SemanticdbTests with val isPrimaryConstructor = symtab.get(occ.symbol).exists(_.isPrimary) if !occ.symbol.isPackage && !isPrimaryConstructor + assert(end <= doc.text.length, + s"doc is only ${doc.text.length} - offset=$offset, end=$end , symbol=${occ.symbol} in source ${sourceFile.name}") sb.append(doc.text.substring(offset, end)) sb.append("/*") .append(if (occ.role.isDefinition) "<-" else "->") .append(occ.symbol.replace("/", "::")) .append("*/") offset = end + assert(offset <= doc.text.length, s"absurd offset = $offset when doc is length ${doc.text.length}") sb.append(doc.text.substring(offset)) sb.toString end printTextDocument diff --git a/tests/semanticdb/expect/Flags.expect.scala b/tests/semanticdb/expect/Flags.expect.scala index 7e5304fd0e4d..be6660f99c4e 100644 --- a/tests/semanticdb/expect/Flags.expect.scala +++ b/tests/semanticdb/expect/Flags.expect.scala @@ -21,7 +21,7 @@ package object p { 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.*//*<-local0*/)/*->local0*/ = ???/*->scala::Predef.`???`().*/ - ???/*->scala::Predef.`???`().*/ match { case List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs2/*<-local1*/) => ???/*->scala::Predef.`???`().*/ } - ???/*->scala::Predef.`???`().*/ match { case _: List/*->scala::package.List#*/[t/*<-local2*/] => ???/*->scala::Predef.`???`().*/ } + val List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs1/*<-flags::p::package.xs1.*/) = ???/*->scala::Predef.`???`().*/ + ???/*->scala::Predef.`???`().*/ match { case List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(xs2/*<-local0*/) => ???/*->scala::Predef.`???`().*/ } + ???/*->scala::Predef.`???`().*/ match { case _: List/*->scala::package.List#*/[t/*<-local1*/] => ???/*->scala::Predef.`???`().*/ } } diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala index 6906ab3f83f6..a0c7d6aa1c9a 100644 --- a/tests/semanticdb/expect/Synthetic.expect.scala +++ b/tests/semanticdb/expect/Synthetic.expect.scala @@ -9,15 +9,17 @@ class Synthetic/*<-example::Synthetic#*/ { // See https://github.com/scalameta/scalameta/issues/977 val Name/*<-example::Synthetic#Name.*/ = /*->scala::Predef.augmentString().*/"name:(.*)".r/*->scala::collection::StringOps#r().*/ - val x/*<-local0*//*<-example::Synthetic#x.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ xs/*<-local1*//*<-example::Synthetic#xs.*//*->scala::Tuple2.apply().*//*->local0*//*->local1*/ = LazyList/*->scala::package.LazyList.*//*->scala::collection::IterableFactory#apply().*/(1, 2) - val Name/*->example::Synthetic#Name.*//*->scala::util::matching::Regex#unapplySeq().*/(name/*<-example::Synthetic#name.*//*<-local2*/)/*->local2*/ = "name:foo" + val x/*<-example::Synthetic#x.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ xs/*<-example::Synthetic#xs.*/ = LazyList/*->scala::package.LazyList.*//*->scala::collection::IterableFactory#apply().*/(1, 2) + val Name/*->example::Synthetic#Name.*//*->scala::util::matching::Regex#unapplySeq().*/(name/*<-example::Synthetic#name.*/) = "name:foo" 1 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/2 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*//*->scala::collection::immutable::LazyList.Deferrer#`#::`().*/ + val a1/*<-example::Synthetic#a1.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ a2/*<-example::Synthetic#a2.*/ #::/*->scala::package.`#::`.*//*->scala::package.`#::`.unapply().*/ as/*<-example::Synthetic#as.*/ = LazyList/*->scala::package.LazyList.*//*->scala::collection::IterableFactory#apply().*/(1, 2) + val lst/*<-example::Synthetic#lst.*/ = 1 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/2 #:: /*->scala::collection::immutable::LazyList.toDeferrer().*/LazyList/*->scala::package.LazyList.*/.empty/*->scala::collection::immutable::LazyList.empty().*//*->scala::collection::immutable::LazyList.Deferrer#`#::`().*/ - for (x/*<-local3*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y/*<-local4*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(/*->scala::Predef.ArrowAssoc().*/x/*->local3*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local3*/) - for (i/*<-local5*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local6*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (/*->scala::Tuple2.apply().*/i/*->local5*/, j/*->local6*/) - for (i/*<-local7*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local8*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::IterableOps#withFilter().*/ if i/*->local7*/ %/*->scala::Int#`%`(+3).*/ 2 ==/*->scala::Int#`==`(+3).*/ 0/*->scala::collection::WithFilter#map().*/) yield (/*->scala::Tuple2.apply().*/i/*->local7*/, j/*->local8*/) + for (x/*<-local0*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::immutable::Range#foreach().*/; y/*<-local1*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#foreach().*/) println/*->scala::Predef.println(+1).*/(/*->scala::Predef.ArrowAssoc().*/x/*->local0*/ ->/*->scala::Predef.ArrowAssoc#`->`().*/ x/*->local0*/) + for (i/*<-local2*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local3*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::immutable::Range#map().*/) yield (/*->scala::Tuple2.apply().*/i/*->local2*/, j/*->local3*/) + for (i/*<-local4*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/1 to/*->scala::runtime::RichInt#to().*/ 10/*->scala::collection::StrictOptimizedIterableOps#flatMap().*/; j/*<-local5*/ <- /*->scala::LowPriorityImplicits#intWrapper().*/0 until/*->scala::runtime::RichInt#until().*/ 10/*->scala::collection::IterableOps#withFilter().*/ if i/*->local4*/ %/*->scala::Int#`%`(+3).*/ 2 ==/*->scala::Int#`==`(+3).*/ 0/*->scala::collection::WithFilter#map().*/) yield (/*->scala::Tuple2.apply().*/i/*->local4*/, j/*->local5*/) object s/*<-example::Synthetic#s.*/ { def apply/*<-example::Synthetic#s.apply().*/() = 2 @@ -36,13 +38,13 @@ class Synthetic/*<-example::Synthetic#*/ { import scala.concurrent.ExecutionContext/*->scala::concurrent::ExecutionContext.*/.Implicits/*->scala::concurrent::ExecutionContext.Implicits.*/.global/*->scala::concurrent::ExecutionContext.Implicits.global().*/ for { - a/*<-local9*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#foreach().*/ - b/*<-local10*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#foreach().*/ - } println/*->scala::Predef.println(+1).*/(a/*->local9*/)/*->scala::concurrent::ExecutionContext.Implicits.global().*/ + a/*<-local6*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#foreach().*/ + b/*<-local7*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#foreach().*/ + } println/*->scala::Predef.println(+1).*/(a/*->local6*/)/*->scala::concurrent::ExecutionContext.Implicits.global().*/ for { - a/*<-local11*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#flatMap().*/ - b/*<-local12*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#withFilter().*/ - if a/*->local11*/ scala::Int#`<`(+3).*/ b/*->local12*//*->scala::concurrent::Future#map().*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ - } yield a/*->local11*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ + a/*<-local8*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(1)/*->scala::concurrent::Future#flatMap().*/ + b/*<-local9*/ <- scala.concurrent.Future/*->scala::concurrent::Future.*/.successful/*->scala::concurrent::Future.successful().*/(2)/*->scala::concurrent::Future#withFilter().*/ + if a/*->local8*/ scala::Int#`<`(+3).*/ b/*->local9*//*->scala::concurrent::Future#map().*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ + } yield a/*->local8*//*->scala::concurrent::ExecutionContext.Implicits.global().*/ } diff --git a/tests/semanticdb/expect/Synthetic.scala b/tests/semanticdb/expect/Synthetic.scala index 05fc74619078..484e07098877 100644 --- a/tests/semanticdb/expect/Synthetic.scala +++ b/tests/semanticdb/expect/Synthetic.scala @@ -13,6 +13,8 @@ class Synthetic { val Name(name) = "name:foo" 1 #:: 2 #:: LazyList.empty + val a1 #:: a2 #:: as = LazyList(1, 2) + val lst = 1 #:: 2 #:: LazyList.empty for (x <- 1 to 10; y <- 0 until 10) println(x -> x) diff --git a/tests/semanticdb/expect/ValPattern.expect.scala b/tests/semanticdb/expect/ValPattern.expect.scala index 7c03a24d1c61..588c705dcdf2 100644 --- a/tests/semanticdb/expect/ValPattern.expect.scala +++ b/tests/semanticdb/expect/ValPattern.expect.scala @@ -3,11 +3,11 @@ 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.*//*<-local0*/)/*->local0*/ = + val Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1/*<-example::ValPattern#number1.*/) = Some/*->scala::Some.*//*->scala::Some.apply().*/(1) 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().*//*<-local1*/)/*->local1*/ = + var Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1Var/*<-example::ValPattern#number1Var().*/) = Some/*->scala::Some.*//*->scala::Some.apply().*/(1) def app/*<-example::ValPattern#app().*/(): Unit/*->scala::Unit#*/ = { @@ -22,21 +22,21 @@ class ValPattern/*<-example::ValPattern#*/ { ) ) locally/*->dotty::DottyPredef.locally().*/ { - val (left/*<-local2*/, right/*<-local3*/) = (/*->scala::Tuple2.apply().*/1, 2) - val Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1/*<-local4*/)/*->local4*/ = + val (left/*<-local0*/, right/*<-local1*/) = (/*->scala::Tuple2.apply().*/1, 2) + val Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1/*<-local2*/) = Some/*->scala::Some.*//*->scala::Some.apply().*/(1) - var (leftVar/*<-local5*/, rightVar/*<-local6*/) = (/*->scala::Tuple2.apply().*/1, 2) - var Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1Var/*<-local7*/)/*->local7*/ = + var (leftVar/*<-local3*/, rightVar/*<-local4*/) = (/*->scala::Tuple2.apply().*/1, 2) + var Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1Var/*<-local5*/) = Some/*->scala::Some.*//*->scala::Some.apply().*/(1) println/*->scala::Predef.println(+1).*/( ( - /*->scala::Tuple6.apply().*/number1/*->local4*/, - left/*->local2*/, - right/*->local3*/, - number1Var/*->local7*/, - leftVar/*->local5*/, - rightVar/*->local6*/ + /*->scala::Tuple6.apply().*/number1/*->local2*/, + left/*->local0*/, + right/*->local1*/, + number1Var/*->local5*/, + leftVar/*->local3*/, + rightVar/*->local4*/ ) ) } diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index fcc2528a5d27..0ef5d784258f 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -1008,8 +1008,8 @@ Schema => SemanticDB v4 Uri => Flags.scala Text => empty Language => Scala -Symbols => 51 entries -Occurrences => 84 entries +Symbols => 50 entries +Occurrences => 82 entries Symbols: flags/p/package. => final package object p @@ -1060,9 +1060,8 @@ flags/p/package.xs1. => val method xs1 flags/p/package.y(). => implicit var method y flags/p/package.z(). => method z flags/p/package.z().(pp) => param pp -local0 => val local xs1 -local1 => val local xs2 -local2 => case val method t +local0 => val local xs2 +local1 => case val method t Occurrences: [0:8..0:13): flags <- flags/ @@ -1137,17 +1136,15 @@ Occurrences: [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:11..23:14): xs1 <- local0 -[23:15..23:15): -> local0 [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 <- local1 +[24:24..24:27): xs2 <- local0 [24:32..24:35): ??? -> scala/Predef.`???`(). [25:2..25:5): ??? -> scala/Predef.`???`(). [25:22..25:26): List -> scala/package.List# -[25:27..25:28): t <- local2 +[25:27..25:28): t <- local1 [25:33..25:36): ??? -> scala/Predef.`???`(). expect/ForComprehension.scala @@ -2460,7 +2457,7 @@ Uri => Synthetic.scala Text => empty Language => Scala Symbols => 37 entries -Occurrences => 161 entries +Occurrences => 163 entries Symbols: example/Synthetic# => class Synthetic @@ -2472,6 +2469,9 @@ 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 @@ -2487,19 +2487,16 @@ 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 => val local x -local1 => val local xs -local2 => val local name -local3 => param x -local4 => param y -local5 => param i -local6 => param j -local7 => param i -local8 => param j -local9 => param a -local10 => param b -local11 => param a -local12 => param b +local0 => param x +local1 => param y +local2 => param i +local3 => param j +local4 => param i +local5 => param j +local6 => param a +local7 => param b +local8 => param a +local9 => param b Occurrences: [0:8..0:15): example <- example/ @@ -2524,145 +2521,147 @@ Occurrences: [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 <- local0 [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 <- local1 [11:12..11:14): xs <- example/Synthetic#xs. -[11:14..11:14): -> scala/Tuple2.apply(). -[11:14..11:14): -> local0 -[11:14..11:14): -> local1 [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. -[12:11..12:15): name <- local2 -[12:16..12:16): -> local2 [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:9): lst <- example/Synthetic#lst. -[15:18..15:18): -> scala/collection/immutable/LazyList.toDeferrer(). -[15:24..15:24): -> scala/collection/immutable/LazyList.toDeferrer(). -[15:24..15:32): LazyList -> scala/package.LazyList. -[15:33..15:38): empty -> scala/collection/immutable/LazyList.empty(). -[15:38..15:38): -> scala/collection/immutable/LazyList.Deferrer#`#::`(). -[17:7..17:8): x <- local3 -[17:12..17:12): -> scala/LowPriorityImplicits#intWrapper(). -[17:14..17:16): to -> scala/runtime/RichInt#to(). -[17:19..17:19): -> scala/collection/immutable/Range#foreach(). -[17:21..17:22): y <- local4 -[17:26..17:26): -> scala/LowPriorityImplicits#intWrapper(). -[17:28..17:33): until -> scala/runtime/RichInt#until(). -[17:36..17:36): -> scala/collection/immutable/Range#foreach(). -[17:38..17:45): println -> scala/Predef.println(+1). -[17:46..17:46): -> scala/Predef.ArrowAssoc(). -[17:46..17:47): x -> local3 -[17:48..17:50): -> -> scala/Predef.ArrowAssoc#`->`(). -[17:51..17:52): x -> local3 -[18:7..18:8): i <- local5 -[18:12..18:12): -> scala/LowPriorityImplicits#intWrapper(). -[18:14..18:16): to -> scala/runtime/RichInt#to(). -[18:19..18:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). -[18:21..18:22): j <- local6 -[18:26..18:26): -> scala/LowPriorityImplicits#intWrapper(). -[18:28..18:33): until -> scala/runtime/RichInt#until(). -[18:36..18:36): -> scala/collection/immutable/Range#map(). -[18:45..18:45): -> scala/Tuple2.apply(). -[18:45..18:46): i -> local5 -[18:48..18:49): j -> local6 -[19:7..19:8): i <- local7 +[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/StrictOptimizedIterableOps#flatMap(). -[19:21..19:22): j <- local8 +[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/IterableOps#withFilter(). -[19:40..19:41): i -> local7 -[19:42..19:43): % -> scala/Int#`%`(+3). -[19:46..19:48): == -> scala/Int#`==`(+3). -[19:50..19:50): -> scala/collection/WithFilter#map(). -[19:59..19:59): -> scala/Tuple2.apply(). -[19:59..19:60): i -> local7 -[19:62..19:63): j -> local8 -[21:9..21:10): s <- example/Synthetic#s. -[22:8..22:13): apply <- example/Synthetic#s.apply(). -[23:5..23:5): -> example/Synthetic#s.apply(). -[24:6..24:11): apply -> example/Synthetic#s.apply(). -[25:15..25:18): Bar <- example/Synthetic#s.Bar# -[25:18..25:20): <- example/Synthetic#s.Bar#``(). -[26:4..26:7): Bar -> example/Synthetic#s.Bar. -[26:7..26:7): -> example/Synthetic#s.Bar.apply(). -[27:9..27:21): asInstanceOf -> scala/Any#asInstanceOf(). -[27:22..27:25): Int -> scala/Int# -[27:29..27:32): Int -> scala/Int# -[27:33..27:33): -> scala/Function1#apply(). -[30:8..30:9): J <- example/Synthetic#J# -[30:9..30:22): <- example/Synthetic#J#``(). -[30:10..30:11): T <- example/Synthetic#J#[T] -[30:13..30:21): Manifest -> scala/Predef.Manifest# -[30:21..30:21): -> example/Synthetic#J#[T] -[30:29..30:32): arr <- example/Synthetic#J#arr. -[30:35..30:40): Array -> scala/Array. -[30:41..30:46): empty -> scala/Array.empty(). -[30:47..30:48): T -> example/Synthetic#J#[T] -[32:2..32:2): <- example/Synthetic#F#``(). -[32:8..32:9): F <- example/Synthetic#F# -[33:15..33:23): ordering <- example/Synthetic#ordering. -[33:25..33:33): Ordering -> scala/package.Ordering# -[33:34..33:35): F -> example/Synthetic#F# -[33:39..33:42): ??? -> scala/Predef.`???`(). -[34:6..34:7): f <- example/Synthetic#f. -[34:9..34:16): Ordered -> scala/package.Ordered# -[34:17..34:18): F -> example/Synthetic#F# -[34:22..34:22): -> scala/math/Ordered.orderingToOrdered(). -[34:26..34:27): F -> example/Synthetic#F# -[34:27..34:27): -> example/Synthetic#F#``(). -[34:27..34:27): -> example/Synthetic#ordering. -[36:9..36:14): scala -> scala/ -[36:15..36:25): concurrent -> scala/concurrent/ -[36:26..36:42): ExecutionContext -> scala/concurrent/ExecutionContext. -[36:43..36:52): Implicits -> scala/concurrent/ExecutionContext.Implicits. -[36:53..36:59): global -> scala/concurrent/ExecutionContext.Implicits.global(). -[38:4..38:5): a <- local9 +[19:36..19:36): -> scala/collection/immutable/Range#foreach(). +[19:38..19:45): println -> scala/Predef.println(+1). +[19:46..19:46): -> scala/Predef.ArrowAssoc(). +[19:46..19:47): x -> local0 +[19:48..19:50): -> -> scala/Predef.ArrowAssoc#`->`(). +[19:51..19:52): x -> local0 +[20:7..20:8): i <- local2 +[20:12..20:12): -> scala/LowPriorityImplicits#intWrapper(). +[20:14..20:16): to -> scala/runtime/RichInt#to(). +[20:19..20:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[20:21..20:22): j <- local3 +[20:26..20:26): -> scala/LowPriorityImplicits#intWrapper(). +[20:28..20:33): until -> scala/runtime/RichInt#until(). +[20:36..20:36): -> scala/collection/immutable/Range#map(). +[20:45..20:45): -> scala/Tuple2.apply(). +[20:45..20:46): i -> local2 +[20:48..20:49): j -> local3 +[21:7..21:8): i <- local4 +[21:12..21:12): -> scala/LowPriorityImplicits#intWrapper(). +[21:14..21:16): to -> scala/runtime/RichInt#to(). +[21:19..21:19): -> scala/collection/StrictOptimizedIterableOps#flatMap(). +[21:21..21:22): j <- local5 +[21:26..21:26): -> scala/LowPriorityImplicits#intWrapper(). +[21:28..21:33): until -> scala/runtime/RichInt#until(). +[21:36..21:36): -> scala/collection/IterableOps#withFilter(). +[21:40..21:41): i -> local4 +[21:42..21:43): % -> scala/Int#`%`(+3). +[21:46..21:48): == -> scala/Int#`==`(+3). +[21:50..21:50): -> scala/collection/WithFilter#map(). +[21:59..21:59): -> scala/Tuple2.apply(). +[21:59..21:60): i -> local4 +[21:62..21:63): j -> local5 +[23:9..23:10): s <- example/Synthetic#s. +[24:8..24:13): apply <- example/Synthetic#s.apply(). +[25:5..25:5): -> example/Synthetic#s.apply(). +[26:6..26:11): apply -> example/Synthetic#s.apply(). +[27:15..27:18): Bar <- example/Synthetic#s.Bar# +[27:18..27:20): <- example/Synthetic#s.Bar#``(). +[28:4..28:7): Bar -> example/Synthetic#s.Bar. +[28:7..28:7): -> example/Synthetic#s.Bar.apply(). +[29:9..29:21): asInstanceOf -> scala/Any#asInstanceOf(). +[29:22..29:25): Int -> scala/Int# +[29:29..29:32): Int -> scala/Int# +[29:33..29:33): -> scala/Function1#apply(). +[32:8..32:9): J <- example/Synthetic#J# +[32:9..32:22): <- example/Synthetic#J#``(). +[32:10..32:11): T <- example/Synthetic#J#[T] +[32:13..32:21): Manifest -> scala/Predef.Manifest# +[32:21..32:21): -> example/Synthetic#J#[T] +[32:29..32:32): arr <- example/Synthetic#J#arr. +[32:35..32:40): Array -> scala/Array. +[32:41..32:46): empty -> scala/Array.empty(). +[32:47..32:48): T -> example/Synthetic#J#[T] +[34:2..34:2): <- example/Synthetic#F#``(). +[34:8..34:9): F <- example/Synthetic#F# +[35:15..35:23): ordering <- example/Synthetic#ordering. +[35:25..35:33): Ordering -> scala/package.Ordering# +[35:34..35:35): F -> example/Synthetic#F# +[35:39..35:42): ??? -> scala/Predef.`???`(). +[36:6..36:7): f <- example/Synthetic#f. +[36:9..36:16): Ordered -> scala/package.Ordered# +[36:17..36:18): F -> example/Synthetic#F# +[36:22..36:22): -> scala/math/Ordered.orderingToOrdered(). +[36:26..36:27): F -> example/Synthetic#F# +[36:27..36:27): -> example/Synthetic#F#``(). +[36:27..36:27): -> example/Synthetic#ordering. [38:9..38:14): scala -> scala/ [38:15..38:25): concurrent -> scala/concurrent/ -[38:26..38:32): Future -> scala/concurrent/Future. -[38:33..38:43): successful -> scala/concurrent/Future.successful(). -[38:46..38:46): -> scala/concurrent/Future#foreach(). -[39:4..39:5): b <- local10 -[39:9..39:14): scala -> scala/ -[39:15..39:25): concurrent -> scala/concurrent/ -[39:26..39:32): Future -> scala/concurrent/Future. -[39:33..39:43): successful -> scala/concurrent/Future.successful(). -[39:46..39:46): -> scala/concurrent/Future#foreach(). -[40:4..40:11): println -> scala/Predef.println(+1). -[40:12..40:13): a -> local9 -[40:14..40:14): -> scala/concurrent/ExecutionContext.Implicits.global(). -[42:4..42:5): a <- local11 -[42:9..42:14): scala -> scala/ -[42:15..42:25): concurrent -> scala/concurrent/ -[42:26..42:32): Future -> scala/concurrent/Future. -[42:33..42:43): successful -> scala/concurrent/Future.successful(). -[42:46..42:46): -> scala/concurrent/Future#flatMap(). -[43:4..43:5): b <- local12 -[43:9..43:14): scala -> scala/ -[43:15..43:25): concurrent -> scala/concurrent/ -[43:26..43:32): Future -> scala/concurrent/Future. -[43:33..43:43): successful -> scala/concurrent/Future.successful(). -[43:46..43:46): -> scala/concurrent/Future#withFilter(). -[44:7..44:8): a -> local11 -[44:9..44:10): < -> scala/Int#`<`(+3). -[44:11..44:12): b -> local12 -[44:12..44:12): -> scala/concurrent/Future#map(). -[44:12..44:12): -> scala/concurrent/ExecutionContext.Implicits.global(). -[45:10..45:11): a -> local11 -[45:11..45:11): -> scala/concurrent/ExecutionContext.Implicits.global(). +[38:26..38:42): ExecutionContext -> scala/concurrent/ExecutionContext. +[38:43..38:52): Implicits -> scala/concurrent/ExecutionContext.Implicits. +[38:53..38:59): global -> scala/concurrent/ExecutionContext.Implicits.global(). +[40:4..40:5): a <- local6 +[40:9..40:14): scala -> scala/ +[40:15..40:25): concurrent -> scala/concurrent/ +[40:26..40:32): Future -> scala/concurrent/Future. +[40:33..40:43): successful -> scala/concurrent/Future.successful(). +[40:46..40:46): -> scala/concurrent/Future#foreach(). +[41:4..41:5): b <- local7 +[41:9..41:14): scala -> scala/ +[41:15..41:25): concurrent -> scala/concurrent/ +[41:26..41:32): Future -> scala/concurrent/Future. +[41:33..41:43): successful -> scala/concurrent/Future.successful(). +[41:46..41:46): -> scala/concurrent/Future#foreach(). +[42:4..42:11): println -> scala/Predef.println(+1). +[42:12..42:13): a -> local6 +[42:14..42:14): -> scala/concurrent/ExecutionContext.Implicits.global(). +[44:4..44:5): a <- local8 +[44:9..44:14): scala -> scala/ +[44:15..44:25): concurrent -> scala/concurrent/ +[44:26..44:32): Future -> scala/concurrent/Future. +[44:33..44:43): successful -> scala/concurrent/Future.successful(). +[44:46..44:46): -> scala/concurrent/Future#flatMap(). +[45:4..45:5): b <- local9 +[45:9..45:14): scala -> scala/ +[45:15..45:25): concurrent -> scala/concurrent/ +[45:26..45:32): Future -> scala/concurrent/Future. +[45:33..45:43): successful -> scala/concurrent/Future.successful(). +[45:46..45:46): -> scala/concurrent/Future#withFilter(). +[46:7..46:8): a -> local8 +[46:9..46:10): < -> scala/Int#`<`(+3). +[46:11..46:12): b -> local9 +[46:12..46:12): -> scala/concurrent/Future#map(). +[46:12..46:12): -> scala/concurrent/ExecutionContext.Implicits.global(). +[47:10..47:11): a -> local8 +[47:11..47:11): -> scala/concurrent/ExecutionContext.Implicits.global(). expect/Traits.scala ------------------- @@ -3100,8 +3099,8 @@ Schema => SemanticDB v4 Uri => ValPattern.scala Text => empty Language => Scala -Symbols => 23 entries -Occurrences => 60 entries +Symbols => 21 entries +Occurrences => 54 entries Symbols: example/ValPattern# => class ValPattern @@ -3119,14 +3118,12 @@ example/ValPattern#number1. => val method number1 example/ValPattern#number1Var(). => var method number1Var example/ValPattern#right. => val method right example/ValPattern#rightVar(). => var method rightVar -local0 => val local number1 -local1 => val local number1Var -local2 => val local left -local3 => val local right -local4 => val local number1 -local5 => var local leftVar -local6 => var local rightVar -local7 => var local number1Var +local0 => val local left +local1 => val local right +local2 => val local number1 +local3 => var local leftVar +local4 => var local rightVar +local5 => var local number1Var Occurrences: [0:8..0:15): example <- example/ @@ -3138,8 +3135,6 @@ Occurrences: [5:6..5:10): Some -> scala/Some. [5:10..5:10): -> scala/Some.unapply(). [5:11..5:18): number1 <- example/ValPattern#number1. -[5:11..5:18): number1 <- local0 -[5:19..5:19): -> local0 [6:4..6:8): Some -> scala/Some. [6:8..6:8): -> scala/Some.apply(). [8:7..8:14): leftVar <- example/ValPattern#leftVar(). @@ -3148,8 +3143,6 @@ Occurrences: [9:6..9:10): Some -> scala/Some. [9:10..9:10): -> scala/Some.unapply(). [9:11..9:21): number1Var <- example/ValPattern#number1Var(). -[9:11..9:21): number1Var <- local1 -[9:22..9:22): -> local1 [10:4..10:8): Some -> scala/Some. [10:8..10:8): -> scala/Some.apply(). [12:6..12:9): app <- example/ValPattern#app(). @@ -3163,32 +3156,30 @@ Occurrences: [19:8..19:15): leftVar -> example/ValPattern#leftVar(). [20:8..20:16): rightVar -> example/ValPattern#rightVar(). [23:4..23:11): locally -> dotty/DottyPredef.locally(). -[24:11..24:15): left <- local2 -[24:17..24:22): right <- local3 +[24:11..24:15): left <- local0 +[24:17..24:22): right <- local1 [24:27..24:27): -> scala/Tuple2.apply(). [25:10..25:14): Some -> scala/Some. [25:14..25:14): -> scala/Some.unapply(). -[25:15..25:22): number1 <- local4 -[25:23..25:23): -> local4 +[25:15..25:22): number1 <- local2 [26:8..26:12): Some -> scala/Some. [26:12..26:12): -> scala/Some.apply(). -[28:11..28:18): leftVar <- local5 -[28:20..28:28): rightVar <- local6 +[28:11..28:18): leftVar <- local3 +[28:20..28:28): rightVar <- local4 [28:33..28:33): -> scala/Tuple2.apply(). [29:10..29:14): Some -> scala/Some. [29:14..29:14): -> scala/Some.unapply(). -[29:15..29:25): number1Var <- local7 -[29:26..29:26): -> local7 +[29:15..29:25): number1Var <- local5 [30:8..30:12): Some -> scala/Some. [30:12..30:12): -> scala/Some.apply(). [31:6..31:13): println -> scala/Predef.println(+1). [33:10..33:10): -> scala/Tuple6.apply(). -[33:10..33:17): number1 -> local4 -[34:10..34:14): left -> local2 -[35:10..35:15): right -> local3 -[36:10..36:20): number1Var -> local7 -[37:10..37:17): leftVar -> local5 -[38:10..38:18): rightVar -> local6 +[33:10..33:17): number1 -> local2 +[34:10..34:14): left -> local0 +[35:10..35:15): right -> local1 +[36:10..36:20): number1Var -> local5 +[37:10..37:17): leftVar -> local3 +[38:10..38:18): rightVar -> local4 expect/Vals.scala ----------------- From 057b158425d53db6fe678fca550505744f030b21 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 21 Nov 2019 14:58:28 +0100 Subject: [PATCH 095/107] update TODO --- tests/semanticdb/todo.md | 63 ++++++++++++---------------------------- 1 file changed, 18 insertions(+), 45 deletions(-) diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md index 6ed2e972e454..8e8e5df7cfaf 100644 --- a/tests/semanticdb/todo.md +++ b/tests/semanticdb/todo.md @@ -1,50 +1,23 @@ # Todo List Differences between scalameta implementation and dotc. -- [ ] For comprehension in Synthetic section. -- [ ] Implicit conversions in Synthetic section. -- [ ] Record signature information in Symbols section. -- [ ] Record access modifier information in Symbols section. -- [x] Record all definitions in Symbols section. +- Generally put all zero length method calls or arguments in Synthetics section + - Pattern val defs -- [unapply|unapplySeq is zero-length] + - For comprehensions -- [map|flatMap|withFilter|foreach etc is zero-length]. + - Implicit conversions -- [span of Apply node is same as its single argument (which has a length)]. + - Implicit arguments -- [span of argument is zero length]. +- Record signature information in Symbols section. +- Record access modifier information in Symbols section. -## ValPatterns +## Completed -Val patterns are tricky due to desugaring before ExtractSemanticDB sees them. - -### Tuples -```scala -val (left, right) = (1, 2) -``` -desugars to -```scala -private[this] val $3$: (Int, Int) = Tuple2.apply[Int, Int](1, 2) -val left: Int = this.$3$._1 -val right: Int = this.$3$._2 -``` - -### Product1 Pattern -```scala -val Some(number1) = Some(1) -``` -desugars to -```scala -val number1: Int = Some.apply[Int](1):Some[Int] @unchecked match { - case Some.unapply[Int](number1 @ _):Some[Int] => number1:Int -} -``` - -### ProductN Pattern -```scala -val x #:: xs = LazyList(1, 2) -``` -desugars to -```scala -private[this] val $2$: (Int, LazyList[Int]) = - LazyList.apply[Int]([1,2 : Int]:Int*):LazyList[Int] @unchecked match { - case #::.unapply[Int](x @ _, xs @ _):LazyList[Int] => Tuple2.apply[Int, LazyList[Int]](x, xs) - } -val x: Int = this.$2$._1 -val xs: LazyList[Int] = this.$2$._2 -``` - -perhaps it is safe to recognise these patterns if the binds were made synthetic. +- [x] Recognise pattern val definitions. +- [x] Recognise anonymous functions. +- [x] Recognise specialised constant enum values. +- [x] Use setter symbol when assigning to a var. +- [x] Substitute constructor type params for the class parameters. +- [x] Skip the synthetic import statement in an Enum class. +- [x] Do not traverse RHS of synthetic val|var|def unless anonymous. +- [x] Avoid symbols with volatile names. - [$1$, $2$, etc]. +- [x] Skip module val +- [x] Add metac printer. From bfbe08df3a1b38f705b01ffe3155ded169a6bb18 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 21 Nov 2019 15:13:47 +0100 Subject: [PATCH 096/107] Resupport Ident patterns in pattern defs --- .../dotc/semanticdb/ExtractSemanticDB.scala | 13 ++- .../semanticdb/expect/ValPattern.expect.scala | 2 + tests/semanticdb/expect/ValPattern.scala | 2 + tests/semanticdb/metac.expect | 100 ++++++++++-------- 4 files changed, 67 insertions(+), 50 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index f592668880ea..bc28efd44a7a 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -165,7 +165,7 @@ class ExtractSemanticDB extends Phase with // ignore rhs case PatternValDef(pat, rhs) => traverse(rhs) - PatternValDef.collectUnapplyFuncs(pat).foreach(traverse) + PatternValDef.collectPats(pat).foreach(traverse) case tree => if !excludeChildren(tree.symbol) traverseChildren(tree) @@ -236,14 +236,17 @@ class ExtractSemanticDB extends Phase with case Types.AnnotatedType(_, annot) => annot.symbol == defn.UncheckedAnnot case _ => false - def collectUnapplyFuncs(pat: Tree): List[Tree] = + def collectPats(pat: Tree): List[Tree] = @tailrec def impl(acc: List[Tree], pats: List[Tree]): List[Tree] = pats match + case pat::pats => pat match - case Typed(UnApply(fun: Tree, _, args), _) => impl(fun::acc, args:::pats) - case UnApply(fun: Tree, _, args) => impl(fun::acc, args:::pats) - case _ => impl(acc, pats) + case Typed(UnApply(fun: Tree, _, args), tpt: Tree) => impl(fun::tpt::acc, args:::pats) + case Typed(obj: Ident, tpt: Tree) => impl(obj::tpt::acc, pats) + case UnApply(fun: Tree, _, args) => impl(fun::acc, args:::pats) + case obj: Ident => impl(obj::acc, pats) + case _ => impl(acc, pats) case Nil => acc diff --git a/tests/semanticdb/expect/ValPattern.expect.scala b/tests/semanticdb/expect/ValPattern.expect.scala index 588c705dcdf2..e50b3f2b502e 100644 --- a/tests/semanticdb/expect/ValPattern.expect.scala +++ b/tests/semanticdb/expect/ValPattern.expect.scala @@ -6,6 +6,8 @@ class ValPattern/*<-example::ValPattern#*/ { val Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1/*<-example::ValPattern#number1.*/) = Some/*->scala::Some.*//*->scala::Some.apply().*/(1) + val List/*->scala::package.List.*//*->scala::collection::SeqFactory#unapplySeq().*/(Some/*->scala::Some.*//*->scala::Some.unapply().*/(q1/*<-example::ValPattern#q1.*/), None/*->scala::None.*/: None/*->scala::None.*/.type, None/*->scala::None.*/) = ???/*->scala::Predef.`???`().*/ + var (leftVar/*<-example::ValPattern#leftVar().*/, rightVar/*<-example::ValPattern#rightVar().*/) = (/*->scala::Tuple2.apply().*/1, 2) var Some/*->scala::Some.*//*->scala::Some.unapply().*/(number1Var/*<-example::ValPattern#number1Var().*/) = Some/*->scala::Some.*//*->scala::Some.apply().*/(1) diff --git a/tests/semanticdb/expect/ValPattern.scala b/tests/semanticdb/expect/ValPattern.scala index 2c802afdb374..b4e4ea3363c1 100644 --- a/tests/semanticdb/expect/ValPattern.scala +++ b/tests/semanticdb/expect/ValPattern.scala @@ -6,6 +6,8 @@ class ValPattern { val Some(number1) = Some(1) + val List(Some(q1), None: None.type, None) = ??? + var (leftVar, rightVar) = (1, 2) var Some(number1Var) = Some(1) diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 0ef5d784258f..e9315c860593 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -3099,8 +3099,8 @@ Schema => SemanticDB v4 Uri => ValPattern.scala Text => empty Language => Scala -Symbols => 21 entries -Occurrences => 54 entries +Symbols => 22 entries +Occurrences => 63 entries Symbols: example/ValPattern# => class ValPattern @@ -3116,6 +3116,7 @@ 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 @@ -3137,49 +3138,58 @@ Occurrences: [5:11..5:18): number1 <- example/ValPattern#number1. [6:4..6:8): Some -> scala/Some. [6:8..6:8): -> scala/Some.apply(). -[8:7..8:14): leftVar <- example/ValPattern#leftVar(). -[8:16..8:24): rightVar <- example/ValPattern#rightVar(). -[8:29..8:29): -> scala/Tuple2.apply(). -[9:6..9:10): Some -> scala/Some. -[9:10..9:10): -> scala/Some.unapply(). -[9:11..9:21): number1Var <- example/ValPattern#number1Var(). -[10:4..10:8): Some -> scala/Some. -[10:8..10:8): -> scala/Some.apply(). -[12:6..12:9): app <- example/ValPattern#app(). -[12:13..12:17): Unit -> scala/Unit# -[13:4..13:11): println -> scala/Predef.println(+1). -[15:8..15:8): -> scala/Tuple6.apply(). -[15:8..15:15): number1 -> example/ValPattern#number1. -[16:8..16:12): left -> example/ValPattern#left. -[17:8..17:13): right -> example/ValPattern#right. -[18:8..18:18): number1Var -> example/ValPattern#number1Var(). -[19:8..19:15): leftVar -> example/ValPattern#leftVar(). -[20:8..20:16): rightVar -> example/ValPattern#rightVar(). -[23:4..23:11): locally -> dotty/DottyPredef.locally(). -[24:11..24:15): left <- local0 -[24:17..24:22): right <- local1 -[24:27..24:27): -> scala/Tuple2.apply(). -[25:10..25:14): Some -> scala/Some. -[25:14..25:14): -> scala/Some.unapply(). -[25:15..25:22): number1 <- local2 -[26:8..26:12): Some -> scala/Some. -[26:12..26:12): -> scala/Some.apply(). -[28:11..28:18): leftVar <- local3 -[28:20..28:28): rightVar <- local4 -[28:33..28:33): -> scala/Tuple2.apply(). -[29:10..29:14): Some -> scala/Some. -[29:14..29:14): -> scala/Some.unapply(). -[29:15..29:25): number1Var <- local5 -[30:8..30:12): Some -> scala/Some. -[30:12..30:12): -> scala/Some.apply(). -[31:6..31:13): println -> scala/Predef.println(+1). -[33:10..33:10): -> scala/Tuple6.apply(). -[33:10..33:17): number1 -> local2 -[34:10..34:14): left -> local0 -[35:10..35:15): right -> local1 -[36:10..36:20): number1Var -> local5 -[37:10..37:17): leftVar -> local3 -[38:10..38:18): rightVar -> local4 +[8:6..8:10): List -> scala/package.List. +[8:10..8:10): -> scala/collection/SeqFactory#unapplySeq(). +[8:11..8:15): Some -> scala/Some. +[8:15..8:15): -> scala/Some.unapply(). +[8:16..8:18): q1 <- example/ValPattern#q1. +[8:21..8:25): None -> scala/None. +[8:27..8:31): None -> scala/None. +[8:38..8:42): None -> scala/None. +[8:46..8:49): ??? -> scala/Predef.`???`(). +[10:7..10:14): leftVar <- example/ValPattern#leftVar(). +[10:16..10:24): rightVar <- example/ValPattern#rightVar(). +[10:29..10:29): -> scala/Tuple2.apply(). +[11:6..11:10): Some -> scala/Some. +[11:10..11:10): -> scala/Some.unapply(). +[11:11..11:21): number1Var <- example/ValPattern#number1Var(). +[12:4..12:8): Some -> scala/Some. +[12:8..12:8): -> scala/Some.apply(). +[14:6..14:9): app <- example/ValPattern#app(). +[14:13..14:17): Unit -> scala/Unit# +[15:4..15:11): println -> scala/Predef.println(+1). +[17:8..17:8): -> scala/Tuple6.apply(). +[17:8..17:15): number1 -> example/ValPattern#number1. +[18:8..18:12): left -> example/ValPattern#left. +[19:8..19:13): right -> example/ValPattern#right. +[20:8..20:18): number1Var -> example/ValPattern#number1Var(). +[21:8..21:15): leftVar -> example/ValPattern#leftVar(). +[22:8..22:16): rightVar -> example/ValPattern#rightVar(). +[25:4..25:11): locally -> dotty/DottyPredef.locally(). +[26:11..26:15): left <- local0 +[26:17..26:22): right <- local1 +[26:27..26:27): -> scala/Tuple2.apply(). +[27:10..27:14): Some -> scala/Some. +[27:14..27:14): -> scala/Some.unapply(). +[27:15..27:22): number1 <- local2 +[28:8..28:12): Some -> scala/Some. +[28:12..28:12): -> scala/Some.apply(). +[30:11..30:18): leftVar <- local3 +[30:20..30:28): rightVar <- local4 +[30:33..30:33): -> scala/Tuple2.apply(). +[31:10..31:14): Some -> scala/Some. +[31:14..31:14): -> scala/Some.unapply(). +[31:15..31:25): number1Var <- local5 +[32:8..32:12): Some -> scala/Some. +[32:12..32:12): -> scala/Some.apply(). +[33:6..33:13): println -> scala/Predef.println(+1). +[35:10..35:10): -> scala/Tuple6.apply(). +[35:10..35:17): number1 -> local2 +[36:10..36:14): left -> local0 +[37:10..37:15): right -> local1 +[38:10..38:20): number1Var -> local5 +[39:10..39:17): leftVar -> local3 +[40:10..40:18): rightVar -> local4 expect/Vals.scala ----------------- From 0bf31a95c6671b9038030b28a7f586a26a709f6c Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 21 Nov 2019 16:21:07 +0100 Subject: [PATCH 097/107] Support named arguments --- .../dotc/semanticdb/ExtractSemanticDB.scala | 29 +++++++++++++++++-- .../expect/NamedApplyBlock.expect.scala | 6 ++-- tests/semanticdb/expect/NamedApplyBlock.scala | 4 +-- .../expect/NamedArguments.expect.scala | 4 +-- tests/semanticdb/expect/NamedArguments.scala | 4 +-- tests/semanticdb/metac.expect | 21 ++++++++++---- tests/semanticdb/todo.md | 1 + 7 files changed, 52 insertions(+), 17 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index bc28efd44a7a..faa299eb0f01 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -53,6 +53,9 @@ class ExtractSemanticDB extends Phase with /** The index of a local symbol */ private val locals = mutable.HashMap[Symbol, Int]() + /** The bodies of synthetic localså */ + private val localBodies = mutable.HashMap[Symbol, Tree]() + /** The local symbol(s) starting at given offset */ private val symsAtOffset = new mutable.HashMap[Int, Set[Symbol]]() with override def default(key: Int) = Set[Symbol]() @@ -162,6 +165,8 @@ class ExtractSemanticDB extends Phase with tree.tparams.foreach(tparam => registerSymbolSimple(tparam.symbol)) tree.vparamss.foreach(_.foreach(vparam => registerSymbolSimple(vparam.symbol))) case _ => + if !tree.symbol.isGlobal + localBodies(tree.symbol) = tree.rhs // ignore rhs case PatternValDef(pat, rhs) => traverse(rhs) @@ -183,6 +188,15 @@ class ExtractSemanticDB extends Phase with tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement else tree.body.foreach(traverse) + case tree: Apply => + @tu lazy val genParamSymbol: Name => String = funParamSymbol(tree.fun.symbol) + traverse(tree.fun) + for arg <- tree.args do + arg match + case arg @ NamedArg(name, value) => + registerUse(genParamSymbol(name), arg.span.startPos.withEnd(arg.span.start + name.toString.length)) + traverse(localBodies.get(value.symbol).getOrElse(value)) + case _ => traverse(arg) case tree: Assign => val qualSym = condOpt(tree.lhs) { case Select(qual, _) if qual.symbol.exists => qual.symbol } if !excludeUse(qualSym, tree.lhs.symbol) @@ -222,6 +236,14 @@ class ExtractSemanticDB extends Phase with end traverse + private def funParamSymbol(funSym: Symbol)(given Context): Name => String = + if funSym.isGlobal then + val funSymbol = symbolName(funSym) + name => s"$funSymbol($name)" + else + name => locals.keys.find(local => local.isTerm && local.owner == funSym && local.name == name) + .fold("")(Symbols.LocalPrefix + _) + private object PatternValDef with def unapply(tree: ValDef)(given Context): Option[(Tree, Tree)] = tree.rhs match @@ -442,8 +464,11 @@ class ExtractSemanticDB extends Phase with if !excludeUse(qualSym, sym) then registerUse(sym, span) - private def registerUse(sym: Symbol, span: Span)(given Context) = - registerOccurrence(symbolName(sym), span, SymbolOccurrence.Role.REFERENCE) + private def registerUse(sym: Symbol, span: Span)(given Context): Unit = + registerUse(symbolName(sym), span) + + private def registerUse(symbol: String, span: Span)(given Context): Unit = + registerOccurrence(symbol, span, SymbolOccurrence.Role.REFERENCE) private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind])(given Context) = val symbol = symbolName(sym) diff --git a/tests/semanticdb/expect/NamedApplyBlock.expect.scala b/tests/semanticdb/expect/NamedApplyBlock.expect.scala index 2a9b1d6bbaf8..ef438d0e74f6 100644 --- a/tests/semanticdb/expect/NamedApplyBlock.expect.scala +++ b/tests/semanticdb/expect/NamedApplyBlock.expect.scala @@ -3,12 +3,12 @@ package example object NamedApplyBlockMethods/*<-example::NamedApplyBlockMethods.*/ { val local/*<-example::NamedApplyBlockMethods.local.*/ = 1 def foo/*<-example::NamedApplyBlockMethods.foo().*/(a/*<-example::NamedApplyBlockMethods.foo().(a)*/: Int/*->scala::Int#*/ = 1, b/*<-example::NamedApplyBlockMethods.foo().(b)*/: Int/*->scala::Int#*/ = 2, c/*<-example::NamedApplyBlockMethods.foo().(c)*/: Int/*->scala::Int#*/ = 3): Int/*->scala::Int#*/ = a/*->example::NamedApplyBlockMethods.foo().(a)*/ +/*->scala::Int#`+`(+4).*/ b/*->example::NamedApplyBlockMethods.foo().(b)*/ +/*->scala::Int#`+`(+4).*/ c/*->example::NamedApplyBlockMethods.foo().(c)*/ - def baseCase/*<-example::NamedApplyBlockMethods.baseCase().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local0*/(local/*->example::NamedApplyBlockMethods.local.*/, c = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter - def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local2*/(local/*->example::NamedApplyBlockMethods.local.*/, c = /*->local1*/foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter + def baseCase/*<-example::NamedApplyBlockMethods.baseCase().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local0*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = 3) + def recursive/*<-example::NamedApplyBlockMethods.recursive().*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local2*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = foo/*->example::NamedApplyBlockMethods.foo().*//*->local3*/(local/*->example::NamedApplyBlockMethods.local.*/, c/*->example::NamedApplyBlockMethods.foo().(c)*/ = 3)) } object NamedApplyBlockCaseClassConstruction/*<-example::NamedApplyBlockCaseClassConstruction.*/ { case class Msg/*<-example::NamedApplyBlockCaseClassConstruction.Msg#*/(body/*<-example::NamedApplyBlockCaseClassConstruction.Msg#body.*/: String/*->scala::Predef.String#*/, head/*<-example::NamedApplyBlockCaseClassConstruction.Msg#head.*/: String/*->scala::Predef.String#*/ = "default", tail/*<-example::NamedApplyBlockCaseClassConstruction.Msg#tail.*/: String/*->scala::Predef.String#*/) val bodyText/*<-example::NamedApplyBlockCaseClassConstruction.bodyText.*/ = "body" - val msg/*<-example::NamedApplyBlockCaseClassConstruction.msg.*/ = Msg/*->example::NamedApplyBlockCaseClassConstruction.Msg.*//*->local3*//*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail = "tail") + val msg/*<-example::NamedApplyBlockCaseClassConstruction.msg.*/ = Msg/*->example::NamedApplyBlockCaseClassConstruction.Msg.*//*->local4*//*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().*/(bodyText/*->example::NamedApplyBlockCaseClassConstruction.bodyText.*/, tail/*->example::NamedApplyBlockCaseClassConstruction.Msg.apply().(tail)*/ = "tail") } diff --git a/tests/semanticdb/expect/NamedApplyBlock.scala b/tests/semanticdb/expect/NamedApplyBlock.scala index 0a453b4dfe2b..ac78f248c953 100644 --- a/tests/semanticdb/expect/NamedApplyBlock.scala +++ b/tests/semanticdb/expect/NamedApplyBlock.scala @@ -3,8 +3,8 @@ package example object NamedApplyBlockMethods { val local = 1 def foo(a: Int = 1, b: Int = 2, c: Int = 3): Int = a + b + c - def baseCase = foo(local, c = 3) // as named apply is desugared, it would take more work to inspect within the body of the setter - def recursive = foo(local, c = foo(local, c = 3)) // as named apply is desugared, it would take more work to inspect within the body of the setter + def baseCase = foo(local, c = 3) + def recursive = foo(local, c = foo(local, c = 3)) } object NamedApplyBlockCaseClassConstruction { diff --git a/tests/semanticdb/expect/NamedArguments.expect.scala b/tests/semanticdb/expect/NamedArguments.expect.scala index ee0fd5457dfa..1d478decc4b4 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 = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg - User/*->example::NamedArguments#User.*/.apply/*->example::NamedArguments#User.apply().*/(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg + User/*->example::NamedArguments#User.*//*->example::NamedArguments#User.apply().*/(name/*->example::NamedArguments#User.apply().(name)*/ = "John") + User/*->example::NamedArguments#User.*/.apply/*->example::NamedArguments#User.apply().*/(name/*->example::NamedArguments#User.apply().(name)*/ = "John") } diff --git a/tests/semanticdb/expect/NamedArguments.scala b/tests/semanticdb/expect/NamedArguments.scala index 8a29aa46de42..009c4aa6e1ac 100644 --- a/tests/semanticdb/expect/NamedArguments.scala +++ b/tests/semanticdb/expect/NamedArguments.scala @@ -2,6 +2,6 @@ package example class NamedArguments { case class User(name: String) - User(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg - User.apply(name = "John") // as there is no API to get the symbols of method arguments, this proposes a problem for how to generate references from a NamedArg + User(name = "John") + User.apply(name = "John") } diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index e9315c860593..976c7e220a20 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -2106,8 +2106,8 @@ Schema => SemanticDB v4 Uri => NamedApplyBlock.scala Text => empty Language => Scala -Symbols => 44 entries -Occurrences => 40 entries +Symbols => 45 entries +Occurrences => 46 entries Symbols: example/NamedApplyBlockCaseClassConstruction. => final object NamedApplyBlockCaseClassConstruction @@ -2153,7 +2153,8 @@ example/NamedApplyBlockMethods.recursive(). => method recursive local0 => val local b$1 local1 => val local c$1 local2 => val local b$3 -local3 => val local head$1 +local3 => val local b$2 +local4 => val local head$1 Occurrences: [0:8..0:15): example <- example/ @@ -2176,11 +2177,16 @@ Occurrences: [5:17..5:20): foo -> example/NamedApplyBlockMethods.foo(). [5:17..5:17): -> local0 [5:21..5:26): local -> example/NamedApplyBlockMethods.local. +[5:28..5:29): c -> example/NamedApplyBlockMethods.foo().(c) [6:6..6:15): recursive <- example/NamedApplyBlockMethods.recursive(). [6:18..6:21): foo -> example/NamedApplyBlockMethods.foo(). [6:18..6:18): -> local2 [6:22..6:27): local -> example/NamedApplyBlockMethods.local. -[6:33..6:33): -> local1 +[6:29..6:30): c -> example/NamedApplyBlockMethods.foo().(c) +[6:33..6:36): foo -> example/NamedApplyBlockMethods.foo(). +[6:33..6:33): -> local3 +[6:37..6:42): local -> example/NamedApplyBlockMethods.local. +[6:44..6:45): c -> example/NamedApplyBlockMethods.foo().(c) [9:7..9:43): NamedApplyBlockCaseClassConstruction <- example/NamedApplyBlockCaseClassConstruction. [10:13..10:16): Msg <- example/NamedApplyBlockCaseClassConstruction.Msg# [10:16..10:70): <- example/NamedApplyBlockCaseClassConstruction.Msg#``(). @@ -2193,9 +2199,10 @@ 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:12..12:12): -> local3 +[12:12..12:12): -> local4 [12:15..12:15): -> example/NamedApplyBlockCaseClassConstruction.Msg.apply(). [12:16..12:24): bodyText -> example/NamedApplyBlockCaseClassConstruction.bodyText. +[12:26..12:30): tail -> example/NamedApplyBlockCaseClassConstruction.Msg.apply().(tail) expect/NamedArguments.scala --------------------------- @@ -2206,7 +2213,7 @@ Uri => NamedArguments.scala Text => empty Language => Scala Symbols => 15 entries -Occurrences => 11 entries +Occurrences => 13 entries Symbols: example/NamedArguments# => class NamedArguments @@ -2235,8 +2242,10 @@ Occurrences: [3:24..3:30): String -> scala/Predef.String# [4:2..4:6): User -> example/NamedArguments#User. [4:6..4:6): -> example/NamedArguments#User.apply(). +[4:7..4:11): name -> example/NamedArguments#User.apply().(name) [5:2..5:6): User -> example/NamedArguments#User. [5:7..5:12): apply -> example/NamedArguments#User.apply(). +[5:13..5:17): name -> example/NamedArguments#User.apply().(name) expect/NewModifiers.scala ------------------------- diff --git a/tests/semanticdb/todo.md b/tests/semanticdb/todo.md index 8e8e5df7cfaf..ecb5f5da6ff7 100644 --- a/tests/semanticdb/todo.md +++ b/tests/semanticdb/todo.md @@ -11,6 +11,7 @@ Differences between scalameta implementation and dotc. ## Completed +- [x] Recognise named arguments and traverse their bodies. - [x] Recognise pattern val definitions. - [x] Recognise anonymous functions. - [x] Recognise specialised constant enum values. From 4a3071f38298dcd5fb0a7a80af134e04e308699b Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Tue, 10 Dec 2019 10:53:38 +0100 Subject: [PATCH 098/107] syntax changes and test result improvements --- .../tools/dotc/config/ScalaSettings.scala | 3 ++ .../dotc/semanticdb/ExtractSemanticDB.scala | 3 +- .../dotty/tools/dotc/semanticdb/Scala3.scala | 10 +++--- tests/semanticdb/expect/Givens.expect.scala | 8 ++--- tests/semanticdb/expect/Givens.scala | 4 +-- .../expect/MethodUsages.expect.scala | 2 +- tests/semanticdb/expect/MethodUsages.scala | 2 +- tests/semanticdb/expect/Methods.expect.scala | 6 ++-- tests/semanticdb/metac.expect | 32 ++++++++++--------- 9 files changed, 38 insertions(+), 32 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala index b65e14e01844..1cf2b4d5b2a2 100644 --- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala +++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala @@ -17,6 +17,9 @@ class ScalaSettings extends Settings.SettingGroup { val javabootclasspath: Setting[String] = PathSetting("-javabootclasspath", "Override java boot classpath.", Defaults.javaBootClassPath) withAbbreviation "--java-boot-class-path" val javaextdirs: Setting[String] = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs) withAbbreviation "--java-extension-directories" val sourcepath: Setting[String] = PathSetting("-sourcepath", "Specify location(s) of source files.", Defaults.scalaSourcePath) withAbbreviation "--source-path" + val scansource: Setting[Boolean] = BooleanSetting("-scansource", "Scan source files to locate classes for which class-name != file-name") withAbbreviation "--scan-source" + val sourceroot: Setting[String] = PathSetting("-sourceroot", "Specify workspace root directory", ".") + val targetroot: Setting[String] = PathSetting("-targetroot", "Specify output directory", "") val classpath: Setting[String] = PathSetting("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp" withAbbreviation "--class-path" val outputDir: Setting[AbstractFile] = OutputSetting("-d", "directory|jar", "destination for generated classfiles.", diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index faa299eb0f01..d75b76a33ec2 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -511,9 +511,10 @@ class ExtractSemanticDB extends Phase with else limit Span(start max limit, end) - private given spanOps: (span: Span) with + private given extension (span: Span) with def hasLength: Boolean = span.start != span.end def zeroLength: Boolean = span.start == span.end + end given /**Consume head while not an import statement. * Returns the rest of the list after the first import, or else the empty list diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index 75a65bafd9c1..c05d65f355e6 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -67,7 +67,7 @@ object Scala3 with end Symbols - given NameOps: (name: Name) with + given NameOps: extension (name: Name) with def isWildcard = name match case nme.WILDCARD | WILDCARDTypeName => true @@ -89,7 +89,7 @@ object Scala3 with end NameOps - given SymbolOps: (sym: Symbol) with + given SymbolOps: extension (sym: Symbol) with def ifExists(given Context): Option[Symbol] = if sym.exists then Some(sym) else None @@ -146,7 +146,7 @@ object Scala3 with case '/' | '.' | '#' | ']' | ')' => true case _ => false - given StringOps: (symbol: String) with + given StringOps: extension (symbol: String) with def isSymbol: Boolean = !symbol.isEmpty def isRootPackage: Boolean = RootPackage == symbol @@ -171,7 +171,7 @@ object Scala3 with end StringOps - given InfoOps: (info: SymbolInformation) with + given InfoOps: extension (info: SymbolInformation) with def isAbstract: Boolean = (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0 def isFinal: Boolean = (info.properties & SymbolInformation.Property.FINAL.value) != 0 @@ -207,7 +207,7 @@ object Scala3 with end InfoOps - given RangeOps: (range: Range) with + given RangeOps: extension (range: Range) with def hasLength = range.endLine > range.startLine || range.endCharacter > range.startCharacter end RangeOps diff --git a/tests/semanticdb/expect/Givens.expect.scala b/tests/semanticdb/expect/Givens.expect.scala index c66407f5f5ce..d827c41f7e86 100644 --- a/tests/semanticdb/expect/Givens.expect.scala +++ b/tests/semanticdb/expect/Givens.expect.scala @@ -3,11 +3,11 @@ package b object Givens/*<-a::b::Givens.*/ - given :[A](any: A) - de/*<-a::b::Givens.given_sayHello_of_A.*//*<-a::b::Givens.given_sayHello_of_A.sayHello().[A]*//*<-a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->a::b::Givens.given_sayHello_of_A.sayHello().[A]*/f sayHello/*<-a::b::Givens.given_sayHello_of_A.sayHello().*/ = s"/*->scala::StringContext.apply().*/Hello, I am $any/*->a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->scala::StringContext#s().*/" + given extension [A](any: /*<-a::b::Givens.given_sayHello_of_A.*//*<-a::b::Givens.given_sayHello_of_A.sayHello().[A]*//*<-a::b::Givens.given_sayHello_of_A.sayHello().(any)*/A/*->a::b::Givens.given_sayHello_of_A.sayHello().[A]*/) + def sayHello/*<-a::b::Givens.given_sayHello_of_A.sayHello().*/ = s"/*->scala::StringContext.apply().*/Hello, I am $any/*->a::b::Givens.given_sayHello_of_A.sayHello().(any)*//*->scala::StringContext#s().*/" - given :[B](any: B) - def /*<-a::b::Givens.given_sayGoodbye_of_B.*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*/sayGoodbye/*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/ = s"/*->scala::StringContext.apply().*/Goodbye, from $any/*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*->scala::StringContext#s().*/" + given extension [B](any: B)/*<-a::b::Givens.given_sayGoodbye_of_B.*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*//*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().[B]*//*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().[B]*/ + def sayGoodbye/*<-a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().*/ = s"/*->scala::StringContext.apply().*/Goodbye, from $any/*->a::b::Givens.given_sayGoodbye_of_B.sayGoodbye().(any)*//*->scala::StringContext#s().*/" def saySoLong/*<-a::b::Givens.given_sayGoodbye_of_B.saySoLong().*/ = s"/*->scala::StringContext.apply().*/So Long, from $any/*->a::b::Givens.given_sayGoodbye_of_B.saySoLong().(any)*//*->scala::StringContext#s().*/" val hello1/*<-a::b::Givens.hello1.*/ = /*->a::b::Givens.given_sayHello_of_A.sayHello().*/1.sayHello diff --git a/tests/semanticdb/expect/Givens.scala b/tests/semanticdb/expect/Givens.scala index b12d514fddb2..9460d5cba0fd 100644 --- a/tests/semanticdb/expect/Givens.scala +++ b/tests/semanticdb/expect/Givens.scala @@ -3,10 +3,10 @@ package b object Givens - given :[A](any: A) + given extension [A](any: A) def sayHello = s"Hello, I am $any" - given :[B](any: B) + given extension [B](any: B) def sayGoodbye = s"Goodbye, from $any" def saySoLong = s"So Long, from $any" diff --git a/tests/semanticdb/expect/MethodUsages.expect.scala b/tests/semanticdb/expect/MethodUsages.expect.scala index e98486a0a663..ab1397975510 100644 --- a/tests/semanticdb/expect/MethodUsages.expect.scala +++ b/tests/semanticdb/expect/MethodUsages.expect.scala @@ -13,7 +13,7 @@ class MethodUsages/*<-example::MethodUsages#*/ { m/*->example::MethodUsages#m.*/.m6/*->example::Methods#m6(+2).*/(Nil/*->scala::package.Nil.*/) m/*->example::MethodUsages#m.*/.m7/*->example::Methods#m7().*/(m/*->example::MethodUsages#m.*/, new m/*->example::MethodUsages#m.*/.List/*->example::Methods#List#*/[Int/*->scala::Int#*/]/*->example::Methods#List#``().*/)/*->scala::math::Ordering.Int.*/ m/*->example::MethodUsages#m.*/.`m8().`/*->example::Methods#`m8().`().*/() - // m.m9(null) suspended due to issue https://github.com/lampepfl/dotty/issues/7514 + m/*->example::MethodUsages#m.*/.m9/*->example::Methods#m9().*/(null) m/*->example::MethodUsages#m.*/.m10/*->example::Methods#m10().*/(null) m/*->example::MethodUsages#m.*/.m11/*->example::Methods#m11().*/(Predef/*->scala::Predef.*/) m/*->example::MethodUsages#m.*/.m11/*->example::Methods#m11(+1).*/(Example/*->example::Example.*/) diff --git a/tests/semanticdb/expect/MethodUsages.scala b/tests/semanticdb/expect/MethodUsages.scala index 8c9bb3a3fd25..b5982e8563a5 100644 --- a/tests/semanticdb/expect/MethodUsages.scala +++ b/tests/semanticdb/expect/MethodUsages.scala @@ -13,7 +13,7 @@ class MethodUsages { m.m6(Nil) m.m7(m, new m.List[Int]) m.`m8().`() - // m.m9(null) suspended due to issue https://github.com/lampepfl/dotty/issues/7514 + m.m9(null) m.m10(null) m.m11(Predef) m.m11(Example) diff --git a/tests/semanticdb/expect/Methods.expect.scala b/tests/semanticdb/expect/Methods.expect.scala index c07f9680f7b4..1b2bbae9e3ea 100644 --- a/tests/semanticdb/expect/Methods.expect.scala +++ b/tests/semanticdb/expect/Methods.expect.scala @@ -16,9 +16,9 @@ class Methods/*<-example::Methods#*/[T/*<-example::Methods#[T]*/] { def m6/*<-example::Methods#m6(+1).*/(x/*<-example::Methods#m6(+1).(x)*/: List/*->example::Methods#List#*/[T/*->example::Methods#[T]*/]) = ???/*->scala::Predef.`???`().*/ def m6/*<-example::Methods#m6(+2).*/(x/*<-example::Methods#m6(+2).(x)*/: scala.List/*->scala::package.List#*/[T/*->example::Methods#[T]*/]) = ???/*->scala::Predef.`???`().*/ def m7/*<-example::Methods#m7().*/[U/*<-example::Methods#m7().[U]*/: Ordering/*->scala::math::Ordering#*//*->example::Methods#m7().[U]*/](c/*<-example::Methods#m7().(c)*/: Methods/*->example::Methods#*/[T/*->example::Methods#[T]*/], l/*<-example::Methods#m7().(l)*/: List/*->example::Methods#List#*/[U/*->example::Methods#m7().[U]*/]) = ???/*->scala::Predef.`???`().*/ - def `m8().`() =/*<-example::Methods#`m8().`().*/ ???/*->scala::Predef.`???`().*/ - class `m9().` - d/*<-example::Methods#`m9().`#*/ef m9/*<-example::Methods#m9().*/(x/*<-example::Methods#m9().(x)*/: `m9().`/*->example::Methods#`m9().`#*/) = ???/*->scala::Predef.`???`().*/ + def `m8()./*<-example::Methods#`m8().`().*/`() = ???/*->scala::Predef.`???`().*/ + class `m9()./*<-example::Methods#`m9().`#*/` + def m9/*<-example::Methods#m9().*/(x/*<-example::Methods#m9().(x)*/: `m9().`/*->example::Methods#`m9().`#*/) = ???/*->scala::Predef.`???`().*/ def m10/*<-example::Methods#m10().*/(x/*<-example::Methods#m10().(x)*/: AList/*->example::Methods#AList#*/[T/*->example::Methods#[T]*/]) = ???/*->scala::Predef.`???`().*/ def m11/*<-example::Methods#m11().*/(x/*<-example::Methods#m11().(x)*/: Predef/*->scala::Predef.*/.type) = ???/*->scala::Predef.`???`().*/ def m11/*<-example::Methods#m11(+1).*/(x/*<-example::Methods#m11(+1).(x)*/: Example/*->example::Example.*/.type) = ???/*->scala::Predef.`???`().*/ diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index 976c7e220a20..e6ad320ff994 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -1311,21 +1311,21 @@ Occurrences: [0:8..0:9): a <- a/ [1:8..1:9): b <- a/b/ [3:7..3:13): Givens <- a/b/Givens. -[5:8..6:6): <- a/b/Givens.given_sayHello_of_A. -[5:10..5:11): A <- a/b/Givens.given_sayHello_of_A.sayHello().[A] -[5:13..5:16): any <- a/b/Givens.given_sayHello_of_A.sayHello().(any) -[5:18..5:19): A -> a/b/Givens.given_sayHello_of_A.sayHello().[A] +[5:8..5:27): extension [A](any: <- a/b/Givens.given_sayHello_of_A. +[5:19..5:20): A <- a/b/Givens.given_sayHello_of_A.sayHello().[A] +[5:22..5:25): any <- a/b/Givens.given_sayHello_of_A.sayHello().(any) +[5:27..5:28): A -> a/b/Givens.given_sayHello_of_A.sayHello().[A] [6:8..6:16): sayHello <- a/b/Givens.given_sayHello_of_A.sayHello(). [6:21..6:21): -> scala/StringContext.apply(). [6:34..6:37): any -> a/b/Givens.given_sayHello_of_A.sayHello().(any) [6:37..6:37): -> scala/StringContext#s(). -[8:8..9:8): <- a/b/Givens.given_sayGoodbye_of_B. -[8:10..8:11): B <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] -[8:10..8:11): B <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] -[8:13..8:16): any <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) -[8:13..8:16): any <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) -[8:18..8:19): B -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] -[8:18..8:19): B -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] +[8:8..8:29): extension [B](any: B) <- a/b/Givens.given_sayGoodbye_of_B. +[8:19..8:20): B <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] +[8:19..8:20): B <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] +[8:22..8:25): any <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) +[8:22..8:25): any <- a/b/Givens.given_sayGoodbye_of_B.saySoLong().(any) +[8:27..8:28): B -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().[B] +[8:27..8:28): B -> a/b/Givens.given_sayGoodbye_of_B.saySoLong().[B] [9:8..9:18): sayGoodbye <- a/b/Givens.given_sayGoodbye_of_B.sayGoodbye(). [9:23..9:23): -> scala/StringContext.apply(). [9:38..9:41): any -> a/b/Givens.given_sayGoodbye_of_B.sayGoodbye().(any) @@ -1792,7 +1792,7 @@ Uri => MethodUsages.scala Text => empty Language => Scala Symbols => 3 entries -Occurrences => 74 entries +Occurrences => 76 entries Symbols: example/MethodUsages# => class MethodUsages @@ -1839,7 +1839,9 @@ Occurrences: [13:25..13:25): -> example/Methods#List#``(). [13:26..13:26): -> scala/math/Ordering.Int. [14:2..14:3): m -> example/MethodUsages#m. -[14:3..14:11): .`m8().` -> example/Methods#`m8().`(). +[14:4..14:11): `m8().` -> example/Methods#`m8().`(). +[15:2..15:3): m -> example/MethodUsages#m. +[15:4..15:6): m9 -> example/Methods#m9(). [16:2..16:3): m -> example/MethodUsages#m. [16:4..16:7): m10 -> example/Methods#m10(). [17:2..17:3): m -> example/MethodUsages#m. @@ -2025,10 +2027,10 @@ Occurrences: [17:40..17:44): List -> example/Methods#List# [17:45..17:46): U -> example/Methods#m7().[U] [17:51..17:54): ??? -> scala/Predef.`???`(). -[18:7..18:17): m8().`() = <- example/Methods#`m8().`(). +[18:7..18:12): m8(). <- example/Methods#`m8().`(). [18:18..18:21): ??? -> scala/Predef.`???`(). [19:2..19:2): <- example/Methods#`m9().`#``(). -[19:9..20:3): <- example/Methods#`m9().`# +[19:9..19:14): m9(). <- example/Methods#`m9().`# [20:6..20:8): m9 <- example/Methods#m9(). [20:9..20:10): x <- example/Methods#m9().(x) [20:12..20:19): `m9().` -> example/Methods#`m9().`# From ace6257be565c9ebae8315afc949787aafba6340 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 12 Dec 2019 16:04:25 +0100 Subject: [PATCH 099/107] delete dead code --- compiler/src/dotty/tools/dotc/ast/Trees.scala | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala index 25df57f6da92..7c2e63b85257 100644 --- a/compiler/src/dotty/tools/dotc/ast/Trees.scala +++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala @@ -348,20 +348,6 @@ object Trees { if (rawMods.is(Synthetic) || name.toTermName == nme.ERROR) Span(point) else { val realName = name.stripModuleClassSuffix.lastPart.toString - val nameStart = // TODO: This is not used - if (point != span.start) point - else { - // Point might be too far away from start to be recorded. In this case we fall back to scanning - // forwards from the start offset for the name. - // Note: This might be inaccurate since scanning might hit accidentally the same - // name (e.g. in a comment) before finding the real definition. - // To make this behavior more robust we'd have to change the trees for definitions to contain - // a fully positioned Ident in place of a name. - val contents = if source.exists then source.content() else Array.empty[Char] - val idx = contents.indexOfSlice(realName, point) - if (idx >= 0) idx - else point // use `point` anyway. This is important if no source exists so scanning fails - } Span(point, point + realName.length, point) } } From 196c90cf51ca21fabff00ca5007426cd0c3877e7 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Thu, 12 Dec 2019 16:43:06 +0100 Subject: [PATCH 100/107] output whole file and not diff in failure case --- .../dotc/semanticdb/DiffAssertions.scala | 4 +-- .../dotc/semanticdb/SemanticdbTests.scala | 27 +++++++++++++------ 2 files changed, 21 insertions(+), 10 deletions(-) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala b/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala index fbe9025ed4ac..c57b520a7ef6 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala @@ -3,10 +3,10 @@ package dotty.tools.dotc.semanticdb import scala.collection.JavaConverters._ object DiffAssertions { - def collectFailingDiff(obtained: String, expected: String, obtainedPath: String, expectedPath: String)(onFail: String => Unit): Unit = + def collectFailingDiff(obtained: String, expected: String, obtainedPath: String, expectedPath: String)(onFail: => Unit): Unit = val diff = compareContents(obtained, expected, obtainedPath, expectedPath) if diff.nonEmpty then - onFail(diff) + onFail private def stripTrailingWhitespace(str: String): String = str.replaceAll(" \n", "∙\n") diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 27fb485450fc..0921571184f8 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -38,9 +38,9 @@ class SemanticdbTests with def runExpectTest(updateExpectFiles: Boolean): Unit = val target = generateSemanticdb() - val errors = mutable.ArrayBuffer.empty[(Path, String)] + val errors = mutable.ArrayBuffer.empty[Path] given metacSb: StringBuilder = StringBuilder(5000) - inputFiles().sorted.foreach { source => + for source <- inputFiles().sorted do val filename = source.getFileName.toString val relpath = expectSrc.relativize(source) val semanticdbPath = target @@ -59,20 +59,31 @@ class SemanticdbTests with val expected = new String(Files.readAllBytes(expectPath), StandardCharsets.UTF_8) val expectName = expectPath.getFileName val relExpect = rootSrc.relativize(expectPath) - collectFailingDiff(expected, obtained, s"a/$relExpect", s"b/$relExpect")(errors += expectName -> _) - } - if updateExpectFiles + collectFailingDiff(expected, obtained, s"a/$relExpect", s"b/$relExpect") { + Files.write(expectPath.resolveSibling("" + expectName + ".out"), obtained.getBytes(StandardCharsets.UTF_8)) + errors += expectPath + } + if updateExpectFiles then Files.write(metacExpectFile, metacSb.toString.getBytes) println("updated: " + metacExpectFile) else val expected = new String(Files.readAllBytes(metacExpectFile), StandardCharsets.UTF_8) val expectName = metacExpectFile.getFileName val relExpect = rootSrc.relativize(metacExpectFile) - collectFailingDiff(expected, metacSb.toString, s"a/$relExpect", s"b/$relExpect")(errors += expectName -> _) - errors.foreach { (source, diff) => + val obtained = metacSb.toString + def writeOut = + collectFailingDiff(expected, obtained, s"a/$relExpect", s"b/$relExpect") { + Files.write(metacExpectFile.resolveSibling("" + expectName + ".out"), obtained.getBytes(StandardCharsets.UTF_8)); + errors += metacExpectFile + } + errors.foreach { expect => def red(msg: String) = Console.RED + msg + Console.RESET def blue(msg: String) = Console.BLUE + msg + Console.RESET - println(s"[${red("error")}] check file ${blue(source.toString)} does not match generated:\n${red(diff)}") + println(s"""[${red("error")}] check file ${blue(expect.toString)} does not match generated. + |If you meant to make a change, replace the expect file by: + | mv ${expect.resolveSibling("" + expect.getFileName + ".out")} $expect + |Or else update all expect files with + | sbt 'dotty-compiler-bootstrapped/test:runMain dotty.tools.dotc.semanticdb.updateExpect'""".stripMargin) } Files.walk(target).sorted(Comparator.reverseOrder).forEach(Files.delete) if errors.nonEmpty From f82a8c778d4b39b148cef664ffd6eb55b1f3d46c Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 13 Dec 2019 11:19:18 +0100 Subject: [PATCH 101/107] remove special case for Annotated, update expect for anon class change --- .../dotc/semanticdb/ExtractSemanticDB.scala | 2 -- .../dotc/semanticdb/SemanticdbTests.scala | 5 ++-- tests/semanticdb/expect/Advanced.expect.scala | 4 +-- .../expect/Annotations.expect.scala | 2 +- .../semanticdb/expect/Anonymous.expect.scala | 2 +- tests/semanticdb/expect/Classes.expect.scala | 2 +- .../expect/InstrumentTyper.expect.scala | 2 +- tests/semanticdb/expect/Methods.expect.scala | 2 +- tests/semanticdb/expect/Traits.expect.scala | 2 +- tests/semanticdb/expect/Types.expect.scala | 8 ++--- tests/semanticdb/metac.expect | 29 +++++++++---------- 11 files changed, 27 insertions(+), 33 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index d75b76a33ec2..1c6a115d41de 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -229,8 +229,6 @@ class ExtractSemanticDB extends Phase with traverseChildren(tree) case tree: Inlined => traverse(tree.call) - case tree: Annotated => // skip the annotation (see `@param` in https://github.com/scalameta/scalameta/blob/633824474e99bbfefe12ad0cc73da1fe064b3e9b/tests/jvm/src/test/resources/example/Annotations.scala#L37) - traverse(tree.arg) case _ => traverseChildren(tree) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 0921571184f8..f2ec1e47566f 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -39,7 +39,7 @@ class SemanticdbTests with def runExpectTest(updateExpectFiles: Boolean): Unit = val target = generateSemanticdb() val errors = mutable.ArrayBuffer.empty[Path] - given metacSb: StringBuilder = StringBuilder(5000) + val metacSb: StringBuilder = StringBuilder(5000) for source <- inputFiles().sorted do val filename = source.getFileName.toString val relpath = expectSrc.relativize(source) @@ -71,9 +71,8 @@ class SemanticdbTests with val expectName = metacExpectFile.getFileName val relExpect = rootSrc.relativize(metacExpectFile) val obtained = metacSb.toString - def writeOut = collectFailingDiff(expected, obtained, s"a/$relExpect", s"b/$relExpect") { - Files.write(metacExpectFile.resolveSibling("" + expectName + ".out"), obtained.getBytes(StandardCharsets.UTF_8)); + Files.write(metacExpectFile.resolveSibling("" + expectName + ".out"), obtained.getBytes(StandardCharsets.UTF_8)) errors += metacExpectFile } errors.foreach { expect => diff --git a/tests/semanticdb/expect/Advanced.expect.scala b/tests/semanticdb/expect/Advanced.expect.scala index 6597e002315f..e4ae3370cba8 100644 --- a/tests/semanticdb/expect/Advanced.expect.scala +++ b/tests/semanticdb/expect/Advanced.expect.scala @@ -11,8 +11,8 @@ 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#*/ } = /*<-local2*/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#*/ } = /*<-local6*/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/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + def s3/*<-advanced::Structural#s3().*/: { def m/*<-local4*/(x/*<-local5*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ } = new { def m/*<-local7*/(x/*<-local8*/: Int/*->scala::Int#*/): Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } } class Wildcards/*<-advanced::Wildcards#*/ { diff --git a/tests/semanticdb/expect/Annotations.expect.scala b/tests/semanticdb/expect/Annotations.expect.scala index 70685535ddc8..08d5fc54806d 100644 --- a/tests/semanticdb/expect/Annotations.expect.scala +++ b/tests/semanticdb/expect/Annotations.expect.scala @@ -34,5 +34,5 @@ object M/*<-annot::M.*/ { trait T/*<-annot::T#*/ object Alias/*<-annot::Alias.*/ { - type A/*<-annot::Alias.A#*/ = ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/ @param + type A/*<-annot::Alias.A#*/ = ClassAnnotation/*->com::javacp::annot::ClassAnnotation#*/ @param/*->scala::annotation::meta::param#*/ } diff --git a/tests/semanticdb/expect/Anonymous.expect.scala b/tests/semanticdb/expect/Anonymous.expect.scala index a2b05c89eaa7..ee2d433facb5 100644 --- a/tests/semanticdb/expect/Anonymous.expect.scala +++ b/tests/semanticdb/expect/Anonymous.expect.scala @@ -16,5 +16,5 @@ class Anonymous/*<-example::Anonymous#*/ { } trait Foo/*<-example::Anonymous#Foo#*/ - val foo/*<-example::Anonymous#foo.*/ = /*<-local1*/new Foo/*->example::Anonymous#Foo#*/ {} + val foo/*<-example::Anonymous#foo.*/ = new Foo/*->example::Anonymous#Foo#*/ {} } diff --git a/tests/semanticdb/expect/Classes.expect.scala b/tests/semanticdb/expect/Classes.expect.scala index 571887c48600..c7418107c372 100644 --- a/tests/semanticdb/expect/Classes.expect.scala +++ b/tests/semanticdb/expect/Classes.expect.scala @@ -23,7 +23,7 @@ class C8/*<-classes::C8#*/(private[this] val x/*<-classes::C8#x.*/: Int/*->scala class C9/*<-classes::C9#*/(private[this] var x/*<-classes::C9#x().*/: Int/*->scala::Int#*/) object N/*<-classes::N.*/ { - val anonClass/*<-classes::N.anonClass.*/ = /*<-local0*/new C7/*->classes::C7#*/(42) { + val anonClass/*<-classes::N.anonClass.*/ = new C7/*->classes::C7#*/(42) { val local/*<-local1*/ = ???/*->scala::Predef.`???`().*/ } val anonFun/*<-classes::N.anonFun.*/ = List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/(1).map/*->scala::collection::immutable::List#map().*/ { i/*<-local2*/ => diff --git a/tests/semanticdb/expect/InstrumentTyper.expect.scala b/tests/semanticdb/expect/InstrumentTyper.expect.scala index 69cf23a1c0f8..5cd370ce3b42 100644 --- a/tests/semanticdb/expect/InstrumentTyper.expect.scala +++ b/tests/semanticdb/expect/InstrumentTyper.expect.scala @@ -20,7 +20,7 @@ class InstrumentTyper/*<-example::InstrumentTyper#*/ { self/*<-local0*/: AnyRef/ Literal/*->types::Test.Literal.*/.clazzOf/*->types::Test.Literal.clazzOf.*/, List/*->scala::package.List.*//*->scala::collection::IterableFactory#apply().*/() ) - type AnnotatedType/*<-example::InstrumentTyper#AnnotatedType#*/ = Int/*->scala::Int#*/ @param + type AnnotatedType/*<-example::InstrumentTyper#AnnotatedType#*/ = Int/*->scala::Int#*/ @param/*->scala::annotation::meta::param#*/ def singletonType/*<-example::InstrumentTyper#singletonType().*/(x/*<-example::InstrumentTyper#singletonType().(x)*/: Predef/*->scala::Predef.*/.type) = ???/*->scala::Predef.`???`().*/ final val clazzOf/*<-example::InstrumentTyper#clazzOf.*/ = classOf/*->scala::Predef.classOf().*/[Option/*->scala::Option#*/[Int/*->scala::Int#*/]] } diff --git a/tests/semanticdb/expect/Methods.expect.scala b/tests/semanticdb/expect/Methods.expect.scala index 1b2bbae9e3ea..58990ecb1401 100644 --- a/tests/semanticdb/expect/Methods.expect.scala +++ b/tests/semanticdb/expect/Methods.expect.scala @@ -24,7 +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 m13/*<-example::Methods#m13().*/(x/*<-example::Methods#m13().(x)*/: Int/*->scala::Int#*/ @unchecked) = ???/*->scala::Predef.`???`().*/ + def m13/*<-example::Methods#m13().*/(x/*<-example::Methods#m13().(x)*/: Int/*->scala::Int#*/ @unchecked/*->scala::unchecked#*/) = ???/*->scala::Predef.`???`().*/ def m15/*<-example::Methods#m15().*/(x/*<-example::Methods#m15().(x)*/: => Int/*->scala::Int#*/) = ???/*->scala::Predef.`???`().*/ def m16/*<-example::Methods#m16().*/(x/*<-example::Methods#m16().(x)*/: Int/*->scala::Int#*/*) = ???/*->scala::Predef.`???`().*/ object m17/*<-example::Methods#m17.*/ { def m/*<-example::Methods#m17.m().*/() = ???/*->scala::Predef.`???`().*/ } diff --git a/tests/semanticdb/expect/Traits.expect.scala b/tests/semanticdb/expect/Traits.expect.scala index f45d91a78098..193390b38826 100644 --- a/tests/semanticdb/expect/Traits.expect.scala +++ b/tests/semanticdb/expect/Traits.expect.scala @@ -6,7 +6,7 @@ trait T/*<-traits::T#*/ { sealed trait U/*<-traits::U#*/ object U/*<-traits::U.*/ { - def u/*<-traits::U.u().*/: U/*->traits::U#*/ = /*<-local0*/new U/*->traits::U#*/ {} + def u/*<-traits::U.u().*/: U/*->traits::U#*/ = new U/*->traits::U#*/ {} } class C/*<-traits::C#*/ diff --git a/tests/semanticdb/expect/Types.expect.scala b/tests/semanticdb/expect/Types.expect.scala index 75aae003f9a0..3da1549f3b4b 100644 --- a/tests/semanticdb/expect/Types.expect.scala +++ b/tests/semanticdb/expect/Types.expect.scala @@ -55,12 +55,12 @@ 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.*/ = /*<-local2*/new { def k/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } - val compoundType5/*<-types::Test.C#compoundType5.*/ = /*<-local4*/new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ - val compoundType6/*<-types::Test.C#compoundType6.*/ = /*<-local5*/new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ { def k/*<-local6*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + val compoundType4/*<-types::Test.C#compoundType4.*/ = new { def k/*<-local3*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } + val compoundType5/*<-types::Test.C#compoundType5.*/ = new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ + val compoundType6/*<-types::Test.C#compoundType6.*/ = new M/*->types::Test.M#*/ with N/*->types::Test.N#*/ { def k/*<-local6*/: Int/*->scala::Int#*/ = ???/*->scala::Predef.`???`().*/ } val annType1/*<-types::Test.C#annType1.*/: T/*->types::T#*/ @ann(42) = ???/*->scala::Predef.`???`().*/ - val annType2/*<-types::Test.C#annType2.*/: T/*->types::T#*/ @ann1 @ann2 = ???/*->scala::Predef.`???`().*/ + val annType2/*<-types::Test.C#annType2.*/: T/*->types::T#*/ @ann1/*->types::ann1#*/ @ann2/*->types::ann2#*/ = ???/*->scala::Predef.`???`().*/ val existentialType2/*<-types::Test.C#existentialType2.*/: List/*->scala::package.List#*/[_] = ???/*->scala::Predef.`???`().*/ val existentialType3/*<-types::Test.C#existentialType3.*/ = Class/*->java::lang::Class#*/.forName/*->java::lang::Class#forName().*/("foo.Bar") diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect index e6ad320ff994..23fce826a326 100644 --- a/tests/semanticdb/metac.expect +++ b/tests/semanticdb/metac.expect @@ -50,7 +50,7 @@ Uri => Advanced.scala Text => empty Language => Scala Symbols => 34 entries -Occurrences => 94 entries +Occurrences => 92 entries Symbols: advanced/C# => class C @@ -115,7 +115,6 @@ Occurrences: [13:6..13:8): s2 <- advanced/Structural#s2(). [13:16..13:17): x <- local1 [13:19..13:22): Int -> scala/Int# -[13:27..13:27): <- local2 [13:37..13:38): x <- local3 [13:40..13:43): Int -> scala/Int# [13:46..13:49): ??? -> scala/Predef.`???`(). @@ -124,7 +123,6 @@ Occurrences: [14:18..14:19): x <- local5 [14:21..14:24): Int -> scala/Int# [14:27..14:30): Int -> scala/Int# -[14:35..14:35): <- local6 [14:45..14:46): m <- local7 [14:47..14:48): x <- local8 [14:50..14:53): Int -> scala/Int# @@ -193,7 +191,7 @@ Uri => Annotations.scala Text => empty Language => Scala Symbols => 22 entries -Occurrences => 51 entries +Occurrences => 52 entries Symbols: annot/Alias. => final object Alias @@ -271,6 +269,7 @@ Occurrences: [35:7..35:12): Alias <- annot/Alias. [36:7..36:8): A <- annot/Alias.A# [36:11..36:26): ClassAnnotation -> com/javacp/annot/ClassAnnotation# +[36:28..36:33): param -> scala/annotation/meta/param# expect/Anonymous.scala ---------------------- @@ -281,7 +280,7 @@ Uri => Anonymous.scala Text => empty Language => Scala Symbols => 13 entries -Occurrences => 33 entries +Occurrences => 32 entries Symbols: example/Anonymous# => class Anonymous @@ -330,7 +329,6 @@ Occurrences: [17:2..17:2): <- example/Anonymous#Foo#``(). [17:8..17:11): Foo <- example/Anonymous#Foo# [18:6..18:9): foo <- example/Anonymous#foo. -[18:12..18:12): <- local1 [18:16..18:19): Foo -> example/Anonymous#Foo# expect/Classes.scala @@ -342,7 +340,7 @@ Uri => Classes.scala Text => empty Language => Scala Symbols => 75 entries -Occurrences => 59 entries +Occurrences => 58 entries Symbols: classes/C1# => final class C1 @@ -468,7 +466,6 @@ Occurrences: [22:30..22:33): Int -> scala/Int# [24:7..24:8): N <- classes/N. [25:6..25:15): anonClass <- classes/N.anonClass. -[25:18..25:18): <- local0 [25:22..25:24): C7 -> classes/C7# [25:24..25:24): -> classes/C7#``(). [26:8..26:13): local <- local1 @@ -1509,7 +1506,7 @@ Uri => InstrumentTyper.scala Text => empty Language => Scala Symbols => 8 entries -Occurrences => 54 entries +Occurrences => 55 entries Symbols: example/InstrumentTyper# => class InstrumentTyper @@ -1568,6 +1565,7 @@ Occurrences: [20:8..20:8): -> scala/collection/IterableFactory#apply(). [22:7..22:20): AnnotatedType <- example/InstrumentTyper#AnnotatedType# [22:23..22:26): Int -> scala/Int# +[22:28..22:33): param -> scala/annotation/meta/param# [23:6..23:19): singletonType <- example/InstrumentTyper#singletonType(). [23:20..23:21): x <- example/InstrumentTyper#singletonType().(x) [23:23..23:29): Predef -> scala/Predef. @@ -1886,7 +1884,7 @@ Uri => Methods.scala Text => empty Language => Scala Symbols => 70 entries -Occurrences => 138 entries +Occurrences => 139 entries Symbols: example/Methods# => class Methods @@ -2059,6 +2057,7 @@ Occurrences: [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) @@ -2683,7 +2682,7 @@ Uri => Traits.scala Text => empty Language => Scala Symbols => 13 entries -Occurrences => 17 entries +Occurrences => 16 entries Symbols: local0 => final class $anon @@ -2710,7 +2709,6 @@ Occurrences: [7:7..7:8): U <- traits/U. [8:6..8:7): u <- traits/U.u(). [8:9..8:10): U -> traits/U# -[8:13..8:13): <- local0 [8:17..8:18): U -> traits/U# [11:0..11:0): <- traits/C#``(). [11:6..11:7): C <- traits/C# @@ -2728,7 +2726,7 @@ Uri => Types.scala Text => empty Language => Scala Symbols => 125 entries -Occurrences => 243 entries +Occurrences => 242 entries Symbols: local0 => abstract method k @@ -2977,17 +2975,14 @@ Occurrences: [56:41..56:44): Int -> scala/Int# [56:49..56:52): ??? -> scala/Predef.`???`(). [57:8..57:21): compoundType4 <- types/Test.C#compoundType4. -[57:24..57:24): <- local2 [57:34..57:35): k <- local3 [57:37..57:40): Int -> scala/Int# [57:43..57:46): ??? -> scala/Predef.`???`(). [58:8..58:21): compoundType5 <- types/Test.C#compoundType5. -[58:24..58:24): <- local4 [58:28..58:29): M -> types/Test.M# [58:29..58:29): -> types/Test.M#``(). [58:35..58:36): N -> types/Test.N# [59:8..59:21): compoundType6 <- types/Test.C#compoundType6. -[59:24..59:24): <- local5 [59:28..59:29): M -> types/Test.M# [59:29..59:29): -> types/Test.M#``(). [59:35..59:36): N -> types/Test.N# @@ -2999,6 +2994,8 @@ Occurrences: [61:31..61:34): ??? -> scala/Predef.`???`(). [62:8..62:16): annType2 <- types/Test.C#annType2. [62:18..62:19): T -> types/T# +[62:21..62:25): ann1 -> types/ann1# +[62:27..62:31): ann2 -> types/ann2# [62:34..62:37): ??? -> scala/Predef.`???`(). [64:8..64:24): existentialType2 <- types/Test.C#existentialType2. [64:26..64:30): List -> scala/package.List# From 25fdafa825a371a217b99f66575635720b29d321 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 13 Dec 2019 11:26:31 +0100 Subject: [PATCH 102/107] refactor names and remove dead code --- compiler/src/dotty/tools/dotc/core/Definitions.scala | 1 - .../src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala | 2 +- compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala | 6 +++--- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala index 6a2bc8b401fb..d057817c9b79 100644 --- a/compiler/src/dotty/tools/dotc/core/Definitions.scala +++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala @@ -750,7 +750,6 @@ class Definitions { @tu lazy val RefiningAnnotationClass: ClassSymbol = ctx.requiredClass("scala.annotation.RefiningAnnotation") // Annotation classes - @tu lazy val ScalaAnnotationInternal: ClassSymbol = ctx.requiredClass("scala.annotation.internal") @tu lazy val AliasAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.Alias") @tu lazy val AnnotationDefaultAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.AnnotationDefault") @tu lazy val BodyAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.Body") diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 1c6a115d41de..932c04b758cb 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -53,7 +53,7 @@ class ExtractSemanticDB extends Phase with /** The index of a local symbol */ private val locals = mutable.HashMap[Symbol, Int]() - /** The bodies of synthetic localså */ + /** The bodies of synthetic locals */ private val localBodies = mutable.HashMap[Symbol, Tree]() /** The local symbol(s) starting at given offset */ diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala index c05d65f355e6..9d2622183391 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala @@ -142,7 +142,7 @@ object Scala3 with end LocalSymbol - private inline def (char: Char) `is/.#])` = (char: @switch) match + private inline def (char: Char) isGlobalTerminal = (char: @switch) match case '/' | '.' | '#' | ']' | ')' => true case _ => false @@ -152,8 +152,8 @@ object Scala3 with def isRootPackage: Boolean = RootPackage == symbol def isEmptyPackage: Boolean = EmptyPackage == symbol - def isGlobal: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last.`is/.#])` - def isLocal: Boolean = !symbol.isEmpty && !symbol.isMulti && !symbol.last.`is/.#])` + def isGlobal: Boolean = !symbol.isEmpty && !symbol.isMulti && symbol.last.isGlobalTerminal + def isLocal: Boolean = !symbol.isEmpty && !symbol.isMulti && !symbol.last.isGlobalTerminal def isMulti: Boolean = symbol startsWith ";" def isConstructor: Boolean = ctor matches symbol From 6a47cf6813e57e5a231f4dce03b8529cf6756f83 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 13 Dec 2019 11:38:48 +0100 Subject: [PATCH 103/107] drop -scansource setting --- compiler/src/dotty/tools/dotc/config/ScalaSettings.scala | 1 - 1 file changed, 1 deletion(-) diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala index 1cf2b4d5b2a2..2d4402c948ef 100644 --- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala +++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala @@ -17,7 +17,6 @@ class ScalaSettings extends Settings.SettingGroup { val javabootclasspath: Setting[String] = PathSetting("-javabootclasspath", "Override java boot classpath.", Defaults.javaBootClassPath) withAbbreviation "--java-boot-class-path" val javaextdirs: Setting[String] = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs) withAbbreviation "--java-extension-directories" val sourcepath: Setting[String] = PathSetting("-sourcepath", "Specify location(s) of source files.", Defaults.scalaSourcePath) withAbbreviation "--source-path" - val scansource: Setting[Boolean] = BooleanSetting("-scansource", "Scan source files to locate classes for which class-name != file-name") withAbbreviation "--scan-source" val sourceroot: Setting[String] = PathSetting("-sourceroot", "Specify workspace root directory", ".") val targetroot: Setting[String] = PathSetting("-targetroot", "Specify output directory", "") From 31aff2946c9ee5186c54c092e0d9a4cbe20f34ab Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 13 Dec 2019 11:50:42 +0100 Subject: [PATCH 104/107] DRY SemanticdbTests --- .../dotc/semanticdb/SemanticdbTests.scala | 40 +++++++------------ 1 file changed, 15 insertions(+), 25 deletions(-) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index f2ec1e47566f..6a720437ca45 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -40,6 +40,18 @@ class SemanticdbTests with val target = generateSemanticdb() val errors = mutable.ArrayBuffer.empty[Path] val metacSb: StringBuilder = StringBuilder(5000) + def collectErrorOrUpdate(expectPath: Path, obtained: String) = + if updateExpectFiles + Files.write(expectPath, obtained.getBytes(StandardCharsets.UTF_8)) + println("updated: " + expectPath) + else + val expected = new String(Files.readAllBytes(expectPath), StandardCharsets.UTF_8) + val expectName = expectPath.getFileName + val relExpect = rootSrc.relativize(expectPath) + collectFailingDiff(expected, obtained, s"a/$relExpect", s"b/$relExpect") { + Files.write(expectPath.resolveSibling("" + expectName + ".out"), obtained.getBytes(StandardCharsets.UTF_8)) + errors += expectPath + } for source <- inputFiles().sorted do val filename = source.getFileName.toString val relpath = expectSrc.relativize(source) @@ -52,30 +64,9 @@ class SemanticdbTests with val doc = Tools.loadTextDocument(source, relpath, semanticdbPath) Tools.metac(doc, rootSrc.relativize(source))(given metacSb) val obtained = trimTrailingWhitespace(SemanticdbTests.printTextDocument(doc)) - if updateExpectFiles - Files.write(expectPath, obtained.getBytes(StandardCharsets.UTF_8)) - println("updated: " + expectPath) - else - val expected = new String(Files.readAllBytes(expectPath), StandardCharsets.UTF_8) - val expectName = expectPath.getFileName - val relExpect = rootSrc.relativize(expectPath) - collectFailingDiff(expected, obtained, s"a/$relExpect", s"b/$relExpect") { - Files.write(expectPath.resolveSibling("" + expectName + ".out"), obtained.getBytes(StandardCharsets.UTF_8)) - errors += expectPath - } - if updateExpectFiles then - Files.write(metacExpectFile, metacSb.toString.getBytes) - println("updated: " + metacExpectFile) - else - val expected = new String(Files.readAllBytes(metacExpectFile), StandardCharsets.UTF_8) - val expectName = metacExpectFile.getFileName - val relExpect = rootSrc.relativize(metacExpectFile) - val obtained = metacSb.toString - collectFailingDiff(expected, obtained, s"a/$relExpect", s"b/$relExpect") { - Files.write(metacExpectFile.resolveSibling("" + expectName + ".out"), obtained.getBytes(StandardCharsets.UTF_8)) - errors += metacExpectFile - } - errors.foreach { expect => + collectErrorOrUpdate(expectPath, obtained) + collectErrorOrUpdate(metacExpectFile, metacSb.toString) + for expect <- errors do def red(msg: String) = Console.RED + msg + Console.RESET def blue(msg: String) = Console.BLUE + msg + Console.RESET println(s"""[${red("error")}] check file ${blue(expect.toString)} does not match generated. @@ -83,7 +74,6 @@ class SemanticdbTests with | mv ${expect.resolveSibling("" + expect.getFileName + ".out")} $expect |Or else update all expect files with | sbt 'dotty-compiler-bootstrapped/test:runMain dotty.tools.dotc.semanticdb.updateExpect'""".stripMargin) - } Files.walk(target).sorted(Comparator.reverseOrder).forEach(Files.delete) if errors.nonEmpty fail(s"${errors.size} errors in expect test.") From 740c86467180f807f15270c7bde3f04cffe345f7 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 13 Dec 2019 12:02:43 +0100 Subject: [PATCH 105/107] remove dependency on google diffutil --- .../dotc/semanticdb/DiffAssertions.scala | 34 ------------------- .../dotc/semanticdb/SemanticdbTests.scala | 4 +-- project/Build.scala | 1 - 3 files changed, 1 insertion(+), 38 deletions(-) delete mode 100644 compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala diff --git a/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala b/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala deleted file mode 100644 index c57b520a7ef6..000000000000 --- a/compiler/test/dotty/tools/dotc/semanticdb/DiffAssertions.scala +++ /dev/null @@ -1,34 +0,0 @@ -package dotty.tools.dotc.semanticdb - -import scala.collection.JavaConverters._ - -object DiffAssertions { - def collectFailingDiff(obtained: String, expected: String, obtainedPath: String, expectedPath: String)(onFail: => Unit): Unit = - val diff = compareContents(obtained, expected, obtainedPath, expectedPath) - if diff.nonEmpty then - onFail - - private def stripTrailingWhitespace(str: String): String = str.replaceAll(" \n", "∙\n") - - private def splitIntoLines(string: String): Seq[String] = - string.trim.replace("\r\n", "\n").split("\n").toSeq - - private def compareContents(original: String, revised: String, obtainedPath: String, expectedPath: String): String = - compareContents(splitIntoLines(original), splitIntoLines(revised), obtainedPath, expectedPath) - - private def compareContents(original: Seq[String], revised: Seq[String], obtainedPath: String, expectedPath: String): String = { - val diff = difflib.DiffUtils.diff(original.asJava, revised.asJava) - if (diff.getDeltas.isEmpty) "" - else - difflib.DiffUtils - .generateUnifiedDiff( - obtainedPath, - expectedPath, - original.asJava, - diff, - 1 - ) - .asScala - .mkString("\n") - } -} diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 6a720437ca45..8040be93f3b8 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -17,7 +17,6 @@ import org.junit.experimental.categories.Category import dotty.BootstrappedOnlyTests import dotty.tools.dotc.Main -import dotty.tools.dotc.semanticdb.DiffAssertions._ import dotty.tools.dotc.semanticdb.Scala3.given import dotty.tools.dotc.util.SourceFile @@ -48,10 +47,9 @@ class SemanticdbTests with val expected = new String(Files.readAllBytes(expectPath), StandardCharsets.UTF_8) val expectName = expectPath.getFileName val relExpect = rootSrc.relativize(expectPath) - collectFailingDiff(expected, obtained, s"a/$relExpect", s"b/$relExpect") { + if expected.trim != obtained.trim then Files.write(expectPath.resolveSibling("" + expectName + ".out"), obtained.getBytes(StandardCharsets.UTF_8)) errors += expectPath - } for source <- inputFiles().sorted do val filename = source.getFileName.toString val relpath = expectSrc.relativize(source) diff --git a/project/Build.scala b/project/Build.scala index dd879e320197..fd3bc760c1ca 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -502,7 +502,6 @@ object Build { libraryDependencies ++= Seq( "org.scala-lang.modules" % "scala-asm" % "7.0.0-scala-1", // used by the backend Dependencies.`compiler-interface`, - "com.googlecode.java-diff-utils" % "diffutils" % "1.3.0", // for SemanticdbTests "org.jline" % "jline-reader" % "3.9.0", // used by the REPL "org.jline" % "jline-terminal" % "3.9.0", "org.jline" % "jline-terminal-jna" % "3.9.0" // needed for Windows From f02321a5b2ef1f62758a91bf7453c991cdb34a17 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 13 Dec 2019 13:23:29 +0100 Subject: [PATCH 106/107] rename target setting to semanticdbTarget --- .../src/dotty/tools/dotc/config/ScalaSettings.scala | 2 +- .../tools/dotc/semanticdb/ExtractSemanticDB.scala | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala index 2d4402c948ef..643e69aa2471 100644 --- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala +++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala @@ -18,7 +18,7 @@ class ScalaSettings extends Settings.SettingGroup { val javaextdirs: Setting[String] = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs) withAbbreviation "--java-extension-directories" val sourcepath: Setting[String] = PathSetting("-sourcepath", "Specify location(s) of source files.", Defaults.scalaSourcePath) withAbbreviation "--source-path" val sourceroot: Setting[String] = PathSetting("-sourceroot", "Specify workspace root directory", ".") - val targetroot: Setting[String] = PathSetting("-targetroot", "Specify output directory", "") + val semanticdbTarget: Setting[String] = PathSetting("-semanticdb-target", "Specify an alternative output directory for SemanticDB files", "") val classpath: Setting[String] = PathSetting("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp" withAbbreviation "--class-path" val outputDir: Setting[AbstractFile] = OutputSetting("-d", "directory|jar", "destination for generated classfiles.", diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala index 932c04b758cb..57f92a71d640 100644 --- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala +++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala @@ -582,14 +582,14 @@ object ExtractSemanticDB with def absolutePath(path: Path): Path = path.toAbsolutePath.normalize val sourcePath = absolutePath(source.file.jpath) val sourceRoot = absolutePath(Paths.get(ctx.settings.sourceroot.value)) - val targetRoot = - val targetRootSetting = ctx.settings.targetroot.value + val semanticdbTarget = + val semanticdbTargetSetting = ctx.settings.semanticdbTarget.value absolutePath( - if targetRootSetting.isEmpty then ctx.settings.outputDir.value.jpath - else Paths.get(targetRootSetting) + if semanticdbTargetSetting.isEmpty then ctx.settings.outputDir.value.jpath + else Paths.get(semanticdbTargetSetting) ) val relPath = sourceRoot.relativize(sourcePath) - val outpath = targetRoot + val outpath = semanticdbTarget .resolve("META-INF") .resolve("semanticdb") .resolve(relPath) From d594863cc2718190daa9569f3015f04523b08418 Mon Sep 17 00:00:00 2001 From: Jamie Thompson Date: Fri, 13 Dec 2019 14:53:08 +0100 Subject: [PATCH 107/107] compile javacp files as part of expect tests --- .../dotc/semanticdb/SemanticdbTests.scala | 20 +++++++++++++++++-- project/Build.scala | 1 - .../javacp}/com/javacp/ClassSuffix.java | 0 .../semanticdb/javacp}/com/javacp/Coin.java | 0 .../javacp}/com/javacp/Interface.java | 0 .../semanticdb/javacp}/com/javacp/Logger.java | 0 .../javacp}/com/javacp/MetacJava.java | 0 .../javacp}/com/javacp/NonGeneric.java | 0 .../javacp}/com/javacp/Recursive.java | 0 .../semanticdb/javacp}/com/javacp/Test.java | 0 .../com/javacp/annot/ClassAnnotation.java | 0 .../javacp/annot/ConstructorAnnotation.java | 0 .../com/javacp/annot/FieldAnnotation.java | 0 .../com/javacp/annot/InterfaceAnnotation.java | 0 .../com/javacp/annot/LocalAnnotation.java | 0 .../com/javacp/annot/MacroAnnotation.java | 0 .../com/javacp/annot/MethodAnnotation.java | 0 .../com/javacp/annot/ObjectAnnotation.java | 0 .../com/javacp/annot/PackageAnnotation.java | 0 .../javacp/annot/PackageObjectAnnotation.java | 0 .../com/javacp/annot/ParameterAnnotation.java | 0 .../javacp/annot/SelfParameterAnnotation.java | 0 .../com/javacp/annot/TraitAnnotation.java | 0 .../com/javacp/annot/TypeAnnotation.java | 0 .../javacp/annot/TypeParameterAnnotation.java | 0 .../annot/usage/AnnotatedInterface.java | 0 .../javacp/annot/usage/AnnotatedPackage.java | 0 27 files changed, 18 insertions(+), 3 deletions(-) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/ClassSuffix.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/Coin.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/Interface.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/Logger.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/MetacJava.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/NonGeneric.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/Recursive.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/Test.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/ClassAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/ConstructorAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/FieldAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/InterfaceAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/LocalAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/MacroAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/MethodAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/ObjectAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/PackageAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/PackageObjectAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/ParameterAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/SelfParameterAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/TraitAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/TypeAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/TypeParameterAnnotation.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/usage/AnnotatedInterface.java (100%) rename {compiler/test-bootstrapped/dotty/tools/dotc/semanticdb => tests/semanticdb/javacp}/com/javacp/annot/usage/AnnotatedPackage.java (100%) diff --git a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala index 8040be93f3b8..008b10acdabc 100644 --- a/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala +++ b/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala @@ -11,6 +11,8 @@ import scala.util.control.NonFatal import scala.collection.mutable import scala.jdk.CollectionConverters._ +import javax.tools.ToolProvider + import org.junit.Assert._ import org.junit.Test import org.junit.experimental.categories.Category @@ -25,11 +27,12 @@ import dotty.tools.dotc.util.SourceFile @Category(Array(classOf[BootstrappedOnlyTests])) class SemanticdbTests with + val javaFile = FileSystems.getDefault.getPathMatcher("glob:**.java") val scalaFile = FileSystems.getDefault.getPathMatcher("glob:**.scala") val expectFile = FileSystems.getDefault.getPathMatcher("glob:**.expect.scala") - // val semanticdbFile = FileSystems.getDefault.getPathMatcher("glob:**.scala.semanticdb") val rootSrc = Paths.get(System.getProperty("dotty.tools.dotc.semanticdb.test")) val expectSrc = rootSrc.resolve("expect") + val javaRoot = rootSrc.resolve("javacp") val metacExpectFile = rootSrc.resolve("metac.expect") @Category(Array(classOf[dotty.SlowTests])) @@ -87,8 +90,20 @@ class SemanticdbTests with require(files.nonEmpty, s"No input files! $expectSrc") files.toList + def javaFiles(): List[Path] = + val ls = Files.walk(javaRoot) + val files = + try ls.filter(p => javaFile.matches(p)).collect(Collectors.toList).asScala + finally ls.close() + require(files.nonEmpty, s"No input files! $expectSrc") + files.toList + def generateSemanticdb(): Path = val target = Files.createTempDirectory("semanticdb") + val javaArgs = Array("-d", target.toString) ++ javaFiles().map(_.toString) + val javac = ToolProvider.getSystemJavaCompiler + val exitJava = javac.run(null, null, null, javaArgs:_*) + assert(exitJava == 0, "java compiler has errors") val args = Array( "-Ysemanticdb", "-d", target.toString, @@ -97,7 +112,8 @@ class SemanticdbTests with // "-Ydebug-flags", // "-Xprint:extractSemanticDB", "-sourceroot", expectSrc.toString, - "-usejavacp", + "-classpath", target.toString, + "-usejavacp" ) ++ inputFiles().map(_.toString) val exit = Main.process(args) assertFalse(s"dotc errors: ${exit.errorCount}", exit.hasErrors) diff --git a/project/Build.scala b/project/Build.scala index fd3bc760c1ca..007d676506e6 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -271,7 +271,6 @@ object Build { // Settings used when compiling dotty with a non-bootstrapped dotty lazy val commonBootstrappedSettings = commonDottySettings ++ Seq( unmanagedSourceDirectories in Compile += baseDirectory.value / "src-bootstrapped", - unmanagedSourceDirectories in Test += baseDirectory.value / "test-bootstrapped", version := dottyVersion, scalaVersion := dottyNonBootstrappedVersion, diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java b/tests/semanticdb/javacp/com/javacp/ClassSuffix.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/ClassSuffix.java rename to tests/semanticdb/javacp/com/javacp/ClassSuffix.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Coin.java b/tests/semanticdb/javacp/com/javacp/Coin.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Coin.java rename to tests/semanticdb/javacp/com/javacp/Coin.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Interface.java b/tests/semanticdb/javacp/com/javacp/Interface.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Interface.java rename to tests/semanticdb/javacp/com/javacp/Interface.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Logger.java b/tests/semanticdb/javacp/com/javacp/Logger.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Logger.java rename to tests/semanticdb/javacp/com/javacp/Logger.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java b/tests/semanticdb/javacp/com/javacp/MetacJava.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/MetacJava.java rename to tests/semanticdb/javacp/com/javacp/MetacJava.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java b/tests/semanticdb/javacp/com/javacp/NonGeneric.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/NonGeneric.java rename to tests/semanticdb/javacp/com/javacp/NonGeneric.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java b/tests/semanticdb/javacp/com/javacp/Recursive.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Recursive.java rename to tests/semanticdb/javacp/com/javacp/Recursive.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Test.java b/tests/semanticdb/javacp/com/javacp/Test.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/Test.java rename to tests/semanticdb/javacp/com/javacp/Test.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/ClassAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ClassAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/ClassAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/ConstructorAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ConstructorAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/ConstructorAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/FieldAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/FieldAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/FieldAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/InterfaceAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/InterfaceAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/InterfaceAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/LocalAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/LocalAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/LocalAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/MacroAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/MacroAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/MacroAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/MethodAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/MethodAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/MethodAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/ObjectAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ObjectAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/ObjectAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/PackageAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/PackageAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/PackageObjectAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/PackageObjectAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/PackageObjectAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/ParameterAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/ParameterAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/ParameterAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/SelfParameterAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/SelfParameterAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/SelfParameterAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/TraitAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TraitAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/TraitAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/TypeAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/TypeAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java b/tests/semanticdb/javacp/com/javacp/annot/TypeParameterAnnotation.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/TypeParameterAnnotation.java rename to tests/semanticdb/javacp/com/javacp/annot/TypeParameterAnnotation.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java b/tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedInterface.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedInterface.java rename to tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedInterface.java diff --git a/compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java b/tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedPackage.java similarity index 100% rename from compiler/test-bootstrapped/dotty/tools/dotc/semanticdb/com/javacp/annot/usage/AnnotatedPackage.java rename to tests/semanticdb/javacp/com/javacp/annot/usage/AnnotatedPackage.java