From 97257371e1594b25395c7c4baaaa92fb98a0ce97 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Mon, 7 Sep 2015 20:57:17 +0200 Subject: work in progress on updating Dokka to latest Kotlin (compiles but does not run yet) --- src/Analysis/AnalysisEnvironment.kt | 27 ++++++++++++++------------- src/Analysis/CompilerAPI.kt | 24 +++++++++++++----------- src/Formats/FormatService.kt | 2 +- src/Formats/OutlineService.kt | 2 +- src/Formats/StructuredFormatService.kt | 2 +- src/Generation/ConsoleGenerator.kt | 2 +- src/Kotlin/ContentBuilder.kt | 28 ++++++++++++++-------------- src/Kotlin/DocumentationBuilder.kt | 22 +++++++++++++--------- src/Model/Content.kt | 2 +- src/Model/PackageDocs.kt | 4 ++-- src/Model/SourceLinks.kt | 7 +++---- 11 files changed, 64 insertions(+), 58 deletions(-) (limited to 'src') diff --git a/src/Analysis/AnalysisEnvironment.kt b/src/Analysis/AnalysisEnvironment.kt index 39a05604..8fdb0b51 100644 --- a/src/Analysis/AnalysisEnvironment.kt +++ b/src/Analysis/AnalysisEnvironment.kt @@ -4,24 +4,25 @@ import com.intellij.core.CoreApplicationEnvironment import com.intellij.core.CoreModuleManager import com.intellij.mock.MockComponentManager import com.intellij.openapi.Disposable -import com.intellij.openapi.module.Module import com.intellij.openapi.module.ModuleManager -import com.intellij.openapi.roots.ContentIterator -import com.intellij.openapi.roots.OrderEntry import com.intellij.openapi.roots.ProjectFileIndex import com.intellij.openapi.util.Disposer -import com.intellij.openapi.vfs.VirtualFile -import org.jetbrains.jps.model.module.JpsModuleSourceRootType import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys import org.jetbrains.kotlin.cli.common.messages.MessageCollector import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import org.jetbrains.kotlin.cli.jvm.config.* -import org.jetbrains.kotlin.config.* +import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot +import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot +import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots +import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots +import org.jetbrains.kotlin.config.CommonConfigurationKeys +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.ContentRoot +import org.jetbrains.kotlin.config.KotlinSourceRoot import org.jetbrains.kotlin.idea.caches.resolve.KotlinCacheService import org.jetbrains.kotlin.idea.caches.resolve.KotlinOutOfBlockCompletionModificationTracker import org.jetbrains.kotlin.idea.caches.resolve.LibraryModificationTracker -import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade +import org.jetbrains.kotlin.idea.resolve.ResolutionFacade import org.jetbrains.kotlin.resolve.lazy.ResolveSession import java.io.File @@ -51,15 +52,15 @@ public class AnalysisEnvironment(val messageCollector: MessageCollector, body: A val moduleManager = CoreModuleManager(environment.project, this) CoreApplicationEnvironment.registerComponentInstance(projectComponentManager.getPicoContainer(), - javaClass(), moduleManager) + ModuleManager::class.java, moduleManager) - projectComponentManager.registerService(javaClass(), + projectComponentManager.registerService(ProjectFileIndex::class.java, CoreProjectFileIndex()) - projectComponentManager.registerService(javaClass(), + projectComponentManager.registerService(LibraryModificationTracker::class.java, LibraryModificationTracker(environment.project)) - projectComponentManager.registerService(javaClass(), + projectComponentManager.registerService(KotlinCacheService::class.java, KotlinCacheService(environment.project)) - projectComponentManager.registerService(javaClass(), + projectComponentManager.registerService(KotlinOutOfBlockCompletionModificationTracker::class.java, KotlinOutOfBlockCompletionModificationTracker()) val sourceFiles = environment.getSourceFiles() diff --git a/src/Analysis/CompilerAPI.kt b/src/Analysis/CompilerAPI.kt index 8b877204..f4382bbb 100644 --- a/src/Analysis/CompilerAPI.kt +++ b/src/Analysis/CompilerAPI.kt @@ -1,17 +1,16 @@ package org.jetbrains.dokka -import org.jetbrains.kotlin.cli.common.arguments.* -import org.jetbrains.kotlin.cli.jvm.compiler.* -import org.jetbrains.kotlin.utils.* -import java.io.* -import org.jetbrains.kotlin.resolve.jvm.* -import org.jetbrains.kotlin.analyzer.* -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.resolve.scopes.* -import org.jetbrains.kotlin.context.GlobalContext import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.analyzer.ModuleContent +import org.jetbrains.kotlin.analyzer.ModuleInfo +import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.context.ProjectContext import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.CompilerEnvironment +import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade +import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters import org.jetbrains.kotlin.resolve.lazy.ResolveSession fun KotlinCoreEnvironment.analyze(): ResolveSession { @@ -26,7 +25,10 @@ fun KotlinCoreEnvironment.analyze(): ResolveSession { projectContext, listOf(module), { ModuleContent(sourceFiles, GlobalSearchScope.allScope(project)) }, - JvmPlatformParameters { module } + JvmPlatformParameters { module }, + CompilerEnvironment, + packagePartProviderFactory = { module, content -> JvmPackagePartProvider(this) } ) - return resolverForProject.resolverForModule(module).lazyResolveSession + + return resolverForProject.resolverForModule(module).componentProvider.get() } diff --git a/src/Formats/FormatService.kt b/src/Formats/FormatService.kt index 93470a4c..642fad04 100644 --- a/src/Formats/FormatService.kt +++ b/src/Formats/FormatService.kt @@ -17,4 +17,4 @@ public interface FormatService { } /** Format content to [String] using specified [location] */ -fun FormatService.format(location: Location, nodes: Iterable): String = StringBuilder { appendNodes(location, this, nodes) }.toString() +fun FormatService.format(location: Location, nodes: Iterable): String = kotlin.StringBuilder { appendNodes(location, this, nodes) }.toString() diff --git a/src/Formats/OutlineService.kt b/src/Formats/OutlineService.kt index 6c7e882e..31128d6d 100644 --- a/src/Formats/OutlineService.kt +++ b/src/Formats/OutlineService.kt @@ -16,7 +16,7 @@ public interface OutlineFormatService { for (node in nodes) { appendOutlineHeader(location, node, to) if (node.members.any()) { - val sortedMembers = node.members.sortBy { it.name } + val sortedMembers = node.members.sortedBy { it.name } appendOutlineLevel(to) { appendOutline(location, to, sortedMembers) } diff --git a/src/Formats/StructuredFormatService.kt b/src/Formats/StructuredFormatService.kt index a90c60b1..41db84a3 100644 --- a/src/Formats/StructuredFormatService.kt +++ b/src/Formats/StructuredFormatService.kt @@ -225,7 +225,7 @@ public abstract class StructuredFormatService(locationService: LocationService, if (nodes.any()) { appendHeader(to, caption, 3) - val children = nodes.sortBy { it.name } + val children = nodes.sortedBy { it.name } val membersMap = children.groupBy { link(node, it) } appendTable(to) { diff --git a/src/Generation/ConsoleGenerator.kt b/src/Generation/ConsoleGenerator.kt index 2f2daa55..803a16e4 100644 --- a/src/Generation/ConsoleGenerator.kt +++ b/src/Generation/ConsoleGenerator.kt @@ -20,7 +20,7 @@ public class ConsoleGenerator(val signatureGenerator: LanguageService, val locat } public fun generateMembers(node: DocumentationNode, indent: String = "") { - val items = node.members.sortBy { it.name } + val items = node.members.sortedBy { it.name } for (child in items) generate(child, indent + IndentStep) } diff --git a/src/Kotlin/ContentBuilder.kt b/src/Kotlin/ContentBuilder.kt index 273009ab..4d9b0c06 100644 --- a/src/Kotlin/ContentBuilder.kt +++ b/src/Kotlin/ContentBuilder.kt @@ -1,14 +1,18 @@ package org.jetbrains.dokka -import java.util.ArrayDeque -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.resolve.* -import org.jetbrains.kotlin.resolve.scopes.* -import org.jetbrains.kotlin.name.* +import org.intellij.markdown.MarkdownElementTypes +import org.intellij.markdown.MarkdownTokenTypes +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.idea.kdoc.getResolutionScope -import org.intellij.markdown.* -import org.jetbrains.kotlin.psi.JetDeclarationWithBody +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.JetBlockExpression +import org.jetbrains.kotlin.psi.JetDeclarationWithBody +import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils +import org.jetbrains.kotlin.resolve.scopes.JetScope +import org.jetbrains.kotlin.resolve.scopes.utils.asJetScope +import java.util.* public fun buildContent(tree: MarkdownNode, linkResolver: (String) -> ContentBlock): MutableContent { val result = MutableContent() @@ -84,10 +88,6 @@ public fun buildContentTo(tree: MarkdownNode, target: ContentBlock, linkResolver parent.append(block) } - MarkdownTokenTypes.HTML_ENTITY -> { - parent.append(ContentEntity(node.text)) - } - MarkdownTokenTypes.TEXT, MarkdownTokenTypes.COLON, MarkdownTokenTypes.DOUBLE_QUOTE, @@ -120,8 +120,8 @@ fun DocumentationBuilder.functionBody(descriptor: DeclarationDescriptor, functio logger.warn("Missing function name in @sample in ${descriptor.signature()}") return ContentBlockCode().let() { it.append(ContentText("Missing function name in @sample")); it } } - val scope = getResolutionScope(resolutionFacade, descriptor) - val rootPackage = session.getModuleDescriptor().getPackage(FqName.ROOT)!! + val scope = getResolutionScope(resolutionFacade, descriptor).asJetScope() + val rootPackage = resolutionFacade.moduleDescriptor.getPackage(FqName.ROOT) val rootScope = rootPackage.memberScope val symbol = resolveInScope(functionName, scope) ?: resolveInScope(functionName, rootScope) if (symbol == null) { @@ -169,7 +169,7 @@ private fun DocumentationBuilder.resolveInScope(functionName: String, scope: Jet currentScope = if (partSymbol is ClassDescriptor) partSymbol.getDefaultType().getMemberScope() else - getResolutionScope(resolutionFacade, partSymbol) + getResolutionScope(resolutionFacade, partSymbol).asJetScope() symbol = partSymbol } diff --git a/src/Kotlin/DocumentationBuilder.kt b/src/Kotlin/DocumentationBuilder.kt index eda69841..bf336935 100644 --- a/src/Kotlin/DocumentationBuilder.kt +++ b/src/Kotlin/DocumentationBuilder.kt @@ -8,9 +8,10 @@ import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotated import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.impl.EnumEntrySyntheticClassDescriptor -import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade import org.jetbrains.kotlin.idea.kdoc.KDocFinder import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink +import org.jetbrains.kotlin.idea.resolve.ResolutionFacade +import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.kdoc.psi.impl.KDocSection import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag import org.jetbrains.kotlin.lexer.JetSingleValueToken @@ -35,8 +36,8 @@ public data class DocumentationOptions(val includeNonPublic: Boolean = false, val sourceLinks: List) private fun isSamePackage(descriptor1: DeclarationDescriptor, descriptor2: DeclarationDescriptor): Boolean { - val package1 = DescriptorUtils.getParentOfType(descriptor1, javaClass()) - val package2 = DescriptorUtils.getParentOfType(descriptor2, javaClass()) + val package1 = DescriptorUtils.getParentOfType(descriptor1, PackageFragmentDescriptor::class.java) + val package2 = DescriptorUtils.getParentOfType(descriptor2, PackageFragmentDescriptor::class.java) return package1 != null && package2 != null && package1.fqName == package2.fqName } @@ -103,9 +104,10 @@ class DocumentationBuilder(val resolutionFacade: ResolutionFacade, deepestDescriptor = deepestDescriptor.getOverriddenDescriptors().first() } if (DescriptorUtils.getFqName(deepestDescriptor.getContainingDeclaration()).asString() == "kotlin.Any") { - val anyClassDescriptors = session.getTopLevelClassDescriptors(FqName.fromSegments(listOf("kotlin", "Any"))) + val anyClassDescriptors = session.getTopLevelClassDescriptors(FqName.fromSegments(listOf("kotlin", "Any")), + NoLookupLocation.UNSORTED) anyClassDescriptors.forEach { - val anyMethod = it.getMemberScope(listOf()).getFunctions(descriptor.getName()).single() + val anyMethod = it.getMemberScope(listOf()).getFunctions(descriptor.getName(), NoLookupLocation.UNSORTED).single() val kdoc = KDocFinder.findKDoc(anyMethod) if (kdoc != null) { return kdoc @@ -205,7 +207,7 @@ class DocumentationBuilder(val resolutionFacade: ResolutionFacade, return symbol } - fun KDocSection.getTags(): Array = PsiTreeUtil.getChildrenOfType(this, javaClass()) ?: arrayOf() + fun KDocSection.getTags(): Array = PsiTreeUtil.getChildrenOfType(this, KDocTag::class.java) ?: arrayOf() private fun MutableContent.addTagToSeeAlso(descriptor: DeclarationDescriptor, seeTag: KDocTag) { val subjectName = seeTag.getSubjectName() @@ -330,11 +332,13 @@ class DocumentationBuilder(val resolutionFacade: ResolutionFacade, val annotationNode = it.build() if (annotationNode != null) { append(annotationNode, - if (annotationNode.name == "deprecated") DocumentationReference.Kind.Deprecation else DocumentationReference.Kind.Annotation) + if (annotationNode.isDeprecation()) DocumentationReference.Kind.Deprecation else DocumentationReference.Kind.Annotation) } } } + fun DocumentationNode.isDeprecation() = name == "Deprecated" || name == "deprecated" + fun DocumentationNode.appendSourceLink(sourceElement: SourceElement) { appendSourceLink(sourceElement.getPsi(), options.sourceLinks) } @@ -626,7 +630,7 @@ class DocumentationBuilder(val resolutionFacade: ResolutionFacade, } else { node.appendType(getType()) } - if (hasDefaultValue()) { + if (declaresDefaultValue()) { val psi = getSource().getPsi() as? JetParameter if (psi != null) { val defaultValueText = psi.getDefaultValue()?.getText() @@ -685,7 +689,7 @@ class DocumentationBuilder(val resolutionFacade: ResolutionFacade, return null } val node = DocumentationNode(annotationClass.getName().asString(), Content.Empty, DocumentationNode.Kind.Annotation) - val arguments = getAllValueArguments().toList().sortBy { it.first.getIndex() } + val arguments = getAllValueArguments().toList().sortedBy { it.first.getIndex() } arguments.forEach { val valueNode = it.second.toDocumentationNode() if (valueNode != null) { diff --git a/src/Model/Content.kt b/src/Model/Content.kt index 810d6417..032de268 100644 --- a/src/Model/Content.kt +++ b/src/Model/Content.kt @@ -142,7 +142,7 @@ public open class MutableContent() : Content() { public override val summary: ContentNode get() = children.firstOrNull() ?: ContentEmpty - public override val description: ContentNode by Delegates.lazy { + public override val description: ContentNode by lazy { val descriptionNodes = children.drop(1) if (descriptionNodes.isEmpty()) { ContentEmpty diff --git a/src/Model/PackageDocs.kt b/src/Model/PackageDocs.kt index 3b0be547..b5ef2126 100644 --- a/src/Model/PackageDocs.kt +++ b/src/Model/PackageDocs.kt @@ -13,8 +13,8 @@ public class PackageDocs(val documentationBuilder: DocumentationBuilder, public val packageContent: Map get() = _packageContent - fun parse(file: String) { - val file = File(file) + fun parse(fileName: String) { + val file = File(fileName) if (file.exists()) { val text = file.readText() val tree = parseMarkdown(text) diff --git a/src/Model/SourceLinks.kt b/src/Model/SourceLinks.kt index 4530518f..52de586c 100644 --- a/src/Model/SourceLinks.kt +++ b/src/Model/SourceLinks.kt @@ -50,8 +50,7 @@ fun PsiElement.lineNumber(): Int? { } fun PsiElement.columnNumber(): Int? { - val doc = PsiDocumentManager.getInstance(project).getDocument(containingFile) - // IJ uses 0-based line-numbers; external source browsers use 1-based - val lineNumber = doc?.getLineNumber(textRange.startOffset)?.plus(1) ?: return null - return startOffset - doc!!.getLineStartOffset(lineNumber) + val doc = PsiDocumentManager.getInstance(project).getDocument(containingFile) ?: return null + val lineNumber = doc.getLineNumber(textRange.startOffset) + return startOffset - doc.getLineStartOffset(lineNumber) } \ No newline at end of file -- cgit