M13 code cleanup

21 files changed, 380 insertions, 380 deletions

diff --git a/ant/src/dokka.kt b/ant/src/dokka.kt
index 882dbdb7..6538f083 100644
--- a/ant/src/dokka.kt
+++ b/ant/src/dokka.kt
@@ -37,7 +37,7 @@ class DokkaAntTask(): Task() {
     }
 
     public fun setClasspathRef(ref: Reference) {
-        compileClasspath.createPath().setRefid(ref)
+        compileClasspath.createPath().refid = ref
     }
 
     public fun setSrc(src: Path) {
@@ -45,7 +45,7 @@ class DokkaAntTask(): Task() {
     }
 
     public fun setSrcRef(ref: Reference) {
-        sourcePath.createPath().setRefid(ref)
+        sourcePath.createPath().refid = ref
     }
 
     public fun setSamples(samples: Path) {
@@ -53,7 +53,7 @@ class DokkaAntTask(): Task() {
     }
 
     public fun setSamplesRef(ref: Reference) {
-        samplesPath.createPath().setRefid(ref)
+        samplesPath.createPath().refid = ref
     }
 
     public fun setInclude(include: Path) {
@@ -85,11 +85,11 @@ class DokkaAntTask(): Task() {
             if (url == null) {
                 throw BuildException("Path attribute of a <sourceLink> element is required")
             }
-            SourceLinkDefinition(File(path).getCanonicalFile().getAbsolutePath(), url, it.lineSuffix)
+            SourceLinkDefinition(File(path).canonicalFile.absolutePath, url, it.lineSuffix)
         }
 
-        val url = javaClass<DokkaAntTask>().getResource("/org/jetbrains/dokka/ant/DokkaAntTask.class")
-        val jarRoot = url.getPath().substringBefore("!/").removePrefix("file:")
+        val url = DokkaAntTask::class.java.getResource("/org/jetbrains/dokka/ant/DokkaAntTask.class")
+        val jarRoot = url.path.substringBefore("!/").removePrefix("file:")
 
         val generator = DokkaGenerator(
                 AntLogger(this),
diff --git a/gradle-plugin/src/main/kotlin/main.kt b/gradle-plugin/src/main/kotlin/main.kt
index 418af00f..e56b2371 100644
--- a/gradle-plugin/src/main/kotlin/main.kt
+++ b/gradle-plugin/src/main/kotlin/main.kt
@@ -15,29 +15,29 @@ import java.util.ArrayList
 
 public open class DokkaPlugin : Plugin<Project> {
     override fun apply(project: Project) {
-        val ext = project.getExtensions().create("dokka", javaClass<DokkaExtension>())
-        project.getTasks().create("dokka", javaClass<DokkaTask>())
+        val ext = project.extensions.create("dokka", DokkaExtension::class.java)
+        project.tasks.create("dokka", DokkaTask::class.java)
 
-        ext.moduleName = project.getName()
-        ext.outputDirectory = File(project.getBuildDir(), "dokka").getAbsolutePath()
+        ext.moduleName = project.name
+        ext.outputDirectory = File(project.buildDir, "dokka").absolutePath
     }
 }
 
 public open class DokkaTask : DefaultTask() {
     init {
-        setGroup(JavaBasePlugin.DOCUMENTATION_GROUP)
-        setDescription("Generates dokka documentation for Kotlin")
+        group = JavaBasePlugin.DOCUMENTATION_GROUP
+        description = "Generates dokka documentation for Kotlin"
     }
 
-    TaskAction
+    @TaskAction
     fun generate() {
-        val project = getProject()
-        val conf = getProject().getExtensions().getByType(javaClass<DokkaExtension>())
-        val javaPluginConvention = getProject().getConvention().getPlugin(javaClass<JavaPluginConvention>())
+        val project = project
+        val conf = project.extensions.getByType(DokkaExtension::class.java)
+        val javaPluginConvention = project.convention.getPlugin(JavaPluginConvention::class.java)
 
-        val sourceSets = javaPluginConvention.getSourceSets()?.findByName(SourceSet.MAIN_SOURCE_SET_NAME)
-        val sourceDirectories = sourceSets?.getAllSource()?.getSrcDirs()?.filter { it.exists() } ?: emptyList()
-        val allConfigurations = getProject().getConfigurations()
+        val sourceSets = javaPluginConvention.sourceSets?.findByName(SourceSet.MAIN_SOURCE_SET_NAME)
+        val sourceDirectories = sourceSets?.allSource?.srcDirs?.filter { it.exists() } ?: emptyList()
+        val allConfigurations = project.configurations
 
         val classpath =
                 conf.processConfigurations
@@ -45,20 +45,20 @@ public open class DokkaTask : DefaultTask() {
                 .flatMap { it }
 
         if (sourceDirectories.isEmpty()) {
-            getLogger().warn("No source directories found: skipping dokka generation")
+            logger.warn("No source directories found: skipping dokka generation")
             return
         }
 
         DokkaGenerator(
-                DokkaGradleLogger(getLogger()),
-                classpath.map { it.getAbsolutePath() },
-                sourceDirectories.map { it.getAbsolutePath() },
+                DokkaGradleLogger(logger),
+                classpath.map { it.absolutePath },
+                sourceDirectories.map { it.absolutePath },
                 conf.samples,
                 conf.includes,
                 conf.moduleName,
                 conf.outputDirectory,
                 conf.outputFormat,
-                conf.linkMappings.map { SourceLinkDefinition(project.file(it.dir).getAbsolutePath(), it.url, it.suffix) },
+                conf.linkMappings.map { SourceLinkDefinition(project.file(it.dir).absolutePath, it.url, it.suffix) },
                 false
         ).generate()
     }
@@ -76,7 +76,7 @@ public open class DokkaExtension {
 
     fun linkMapping(closure: Closure<Any?>) {
         val mapping = LinkMapping()
-        closure.setDelegate(mapping)
+        closure.delegate = mapping
         closure.call()
 
         if (mapping.dir.isEmpty()) {
diff --git a/maven-plugin/src/main/kotlin/DokkaMojo.kt b/maven-plugin/src/main/kotlin/DokkaMojo.kt
index 80f00c42..fae9d856 100644
--- a/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -9,53 +9,53 @@ import org.jetbrains.dokka.DokkaGenerator
 import org.jetbrains.dokka.SourceLinkDefinition
 
 public class SourceLinkMapItem {
-    Parameter(name = "dir", required = true)
+    @Parameter(name = "dir", required = true)
     var dir: String = ""
 
-    Parameter(name = "url", required = true)
+    @Parameter(name = "url", required = true)
     var url: String = ""
 
-    Parameter(name = "urlSuffix")
+    @Parameter(name = "urlSuffix")
     var urlSuffix: String? = null
 }
 
-Mojo(name = "dokka", defaultPhase = LifecyclePhase.PRE_SITE, threadSafe = true, requiresDependencyResolution = ResolutionScope.COMPILE, requiresProject = true)
+@Mojo(name = "dokka", defaultPhase = LifecyclePhase.PRE_SITE, threadSafe = true, requiresDependencyResolution = ResolutionScope.COMPILE, requiresProject = true)
 public class DokkaMojo : AbstractMojo() {
-    Parameter(required = true, defaultValue = "\${project.compileSourceRoots}")
+    @Parameter(required = true, defaultValue = "\${project.compileSourceRoots}")
     var sourceDirectories: List<String> = emptyList()
 
-    Parameter
+    @Parameter
     var samplesDirs: List<String> = emptyList()
 
-    Parameter
+    @Parameter
     var includeDirs: List<String> = emptyList()
 
-    Parameter(required = true, defaultValue = "\${project.compileClasspathElements}")
+    @Parameter(required = true, defaultValue = "\${project.compileClasspathElements}")
     var classpath: List<String> = emptyList()
 
-    Parameter(required = true, defaultValue = "\${project.basedir}/target/dokka")
+    @Parameter(required = true, defaultValue = "\${project.basedir}/target/dokka")
     var outputDir: String = ""
 
-    Parameter(required = true, defaultValue = "html")
+    @Parameter(required = true, defaultValue = "html")
     var outputFormat: String = "html"
 
-    Parameter
+    @Parameter
     var sourceLinks: Array<SourceLinkMapItem> = emptyArray()
 
-    Parameter(required = true, defaultValue = "\${project.artifactId}")
+    @Parameter(required = true, defaultValue = "\${project.artifactId}")
     var moduleName: String = ""
 
-    Parameter(required = false, defaultValue = "false")
+    @Parameter(required = false, defaultValue = "false")
     var skip: Boolean = false
 
     override fun execute() {
         if (skip) {
-            getLog().info("Dokka skip parameter is true so no dokka output will be produced")
+            log.info("Dokka skip parameter is true so no dokka output will be produced")
             return
         }
 
         val gen = DokkaGenerator(
-                MavenDokkaLogger(getLog()),
+                MavenDokkaLogger(log),
                 classpath,
                 sourceDirectories,
                 samplesDirs,
diff --git a/src/Analysis/AnalysisEnvironment.kt b/src/Analysis/AnalysisEnvironment.kt
index 060a3170..dfea46d2 100644
--- a/src/Analysis/AnalysisEnvironment.kt
+++ b/src/Analysis/AnalysisEnvironment.kt
@@ -71,7 +71,7 @@ public class AnalysisEnvironment(val messageCollector: MessageCollector, body: A
         val projectComponentManager = environment.project as MockComponentManager
 
         val moduleManager = CoreModuleManager(environment.project, this)
-        CoreApplicationEnvironment.registerComponentInstance(projectComponentManager.getPicoContainer(),
+        CoreApplicationEnvironment.registerComponentInstance(projectComponentManager.picoContainer,
                 ModuleManager::class.java, moduleManager)
 
         projectComponentManager.registerService(ProjectFileIndex::class.java,
diff --git a/src/Generation/FileGenerator.kt b/src/Generation/FileGenerator.kt
index abe4257f..40645b51 100644
--- a/src/Generation/FileGenerator.kt
+++ b/src/Generation/FileGenerator.kt
@@ -14,7 +14,7 @@ public class FileGenerator(val signatureGenerator: LanguageService,
     public fun buildPages(nodes: Iterable<DocumentationNode>) {
         for ((location, items) in nodes.groupBy { locationService.location(it) }) {
             val file = location.file
-            file.getParentFile()?.mkdirs()
+            file.parentFile?.mkdirs()
             FileOutputStream(file).use {
                 OutputStreamWriter(it, Charsets.UTF_8).use {
                     it.write(formatService.format(location, items))
@@ -30,7 +30,7 @@ public class FileGenerator(val signatureGenerator: LanguageService,
         }
         for ((location, items) in nodes.groupBy { locationService.location(it) }) {
             val file = outlineService.getOutlineFileName(location)
-            file.getParentFile()?.mkdirs()
+            file.parentFile?.mkdirs()
             FileOutputStream(file).use {
                 OutputStreamWriter(it, Charsets.UTF_8).use {
                     it.write(outlineService.formatOutline(location, items))
diff --git a/src/Java/JavaDocumentationBuilder.kt b/src/Java/JavaDocumentationBuilder.kt
index 13bed113..217a6a41 100644
--- a/src/Java/JavaDocumentationBuilder.kt
+++ b/src/Java/JavaDocumentationBuilder.kt
@@ -11,11 +11,11 @@ import org.jsoup.nodes.TextNode
 public class JavaDocumentationBuilder(private val options: DocumentationOptions,
                                       private val refGraph: NodeReferenceGraph) {
     fun appendFile(file: PsiJavaFile, module: DocumentationModule) {
-        if (file.getClasses().all { skipElement(it) }) {
+        if (file.classes.all { skipElement(it) }) {
             return
         }
-        val packageNode = module.findOrCreatePackageNode(file.getPackageName(), emptyMap())
-        packageNode.appendChildren(file.getClasses()) { build() }
+        val packageNode = module.findOrCreatePackageNode(file.packageName, emptyMap())
+        packageNode.appendChildren(file.classes) { build() }
     }
 
     data class JavadocParseResult(val content: Content, val deprecatedContent: Content?)
@@ -26,9 +26,9 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
         var deprecatedContent: Content? = null
         val para = ContentParagraph()
         result.append(para)
-        para.convertJavadocElements(docComment.getDescriptionElements().dropWhile { it.getText().trim().isEmpty() })
-        docComment.getTags().forEach { tag ->
-            when(tag.getName()) {
+        para.convertJavadocElements(docComment.descriptionElements.dropWhile { it.text.trim().isEmpty() })
+        docComment.tags.forEach { tag ->
+            when(tag.name) {
                 "see" -> result.convertSeeTag(tag)
                 "deprecated" -> {
                     deprecatedContent = Content()
@@ -36,7 +36,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
                 }
                 else -> {
                     val subjectName = tag.getSubjectName()
-                    val section = result.addSection(javadocSectionDisplayName(tag.getName()), subjectName)
+                    val section = result.addSection(javadocSectionDisplayName(tag.name), subjectName)
 
                     section.convertJavadocElements(tag.contentElements())
                 }
@@ -46,10 +46,10 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
     }
 
     private fun PsiDocTag.contentElements(): Iterable<PsiElement> {
-        val tagValueElements = getChildren()
-                .dropWhile { it.getNode().getElementType() == JavaDocTokenType.DOC_TAG_NAME }
+        val tagValueElements = children
+                .dropWhile { it.node.elementType == JavaDocTokenType.DOC_TAG_NAME }
                 .dropWhile { it is PsiWhiteSpace }
-                .filterNot { it.getNode().getElementType() == JavaDocTokenType.DOC_COMMENT_LEADING_ASTERISKS }
+                .filterNot { it.node.elementType == JavaDocTokenType.DOC_COMMENT_LEADING_ASTERISKS }
         return if (getSubjectName() != null) tagValueElements.dropWhile { it is PsiDocTagValue } else tagValueElements
     }
 
@@ -59,7 +59,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
             if (it is PsiInlineDocTag) {
                 htmlBuilder.append(convertInlineDocTag(it))
             } else {
-                htmlBuilder.append(it.getText())
+                htmlBuilder.append(it.text)
             }
         }
         val doc = Jsoup.parse(htmlBuilder.toString().trimStart())
@@ -114,9 +114,9 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
         }
         val seeSection = findSectionByTag("See Also") ?: addSection("See Also", null)
         val linkSignature = resolveLink(linkElement)
-        val text = ContentText(linkElement.getText())
+        val text = ContentText(linkElement.text)
         if (linkSignature != null) {
-            val linkNode = ContentNodeLazyLink(tag.getValueElement()!!.getText(), { -> refGraph.lookup(linkSignature)})
+            val linkNode = ContentNodeLazyLink(tag.valueElement!!.text, { -> refGraph.lookup(linkSignature)})
             linkNode.append(text)
             seeSection.append(linkNode)
         } else {
@@ -124,35 +124,35 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
         }
     }
 
-    private fun convertInlineDocTag(tag: PsiInlineDocTag) = when (tag.getName()) {
+    private fun convertInlineDocTag(tag: PsiInlineDocTag) = when (tag.name) {
         "link", "linkplain" -> {
             val valueElement = tag.linkElement()
             val linkSignature = resolveLink(valueElement)
             if (linkSignature != null) {
-                val labelText = tag.getDataElements().firstOrNull { it is PsiDocToken }?.getText() ?: valueElement!!.getText()
+                val labelText = tag.dataElements.firstOrNull { it is PsiDocToken }?.text ?: valueElement!!.text
                 val link = "<a docref=\"$linkSignature\">${labelText.htmlEscape()}</a>"
-                if (tag.getName() == "link") "<code>$link</code>" else link
+                if (tag.name == "link") "<code>$link</code>" else link
             }
             else if (valueElement != null) {
-                valueElement.getText()
+                valueElement.text
             } else {
                 ""
             }
         }
         "code", "literal" -> {
             val text = StringBuilder()
-            tag.getDataElements().forEach { text.append(it.getText()) }
+            tag.dataElements.forEach { text.append(it.text) }
             val escaped = text.toString().trimStart().htmlEscape()
-            if (tag.getName() == "code") "<code>$escaped</code>" else escaped
+            if (tag.name == "code") "<code>$escaped</code>" else escaped
         }
-        else -> tag.getText()
+        else -> tag.text
     }
 
     private fun PsiDocTag.linkElement(): PsiElement? =
-            getValueElement() ?: getDataElements().firstOrNull { it !is PsiWhiteSpace }
+            valueElement ?: dataElements.firstOrNull { it !is PsiWhiteSpace }
 
     private fun resolveLink(valueElement: PsiElement?): String? {
-        val target = valueElement?.getReference()?.resolve()
+        val target = valueElement?.reference?.resolve()
         if (target != null) {
             return getSignature(target)
         }
@@ -160,8 +160,8 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
     }
 
     fun PsiDocTag.getSubjectName(): String? {
-        if (getName() == "param" || getName() == "throws" || getName() == "exception") {
-            return getValueElement()?.getText()
+        if (name == "param" || name == "throws" || name == "exception") {
+            return valueElement?.text
         }
         return null
     }
@@ -188,32 +188,32 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
     }
 
     private fun getSignature(element: PsiElement?) = when(element) {
-        is PsiClass -> element.getQualifiedName()
-        is PsiField -> element.getContainingClass()!!.getQualifiedName() + "#" + element.getName()
+        is PsiClass -> element.qualifiedName
+        is PsiField -> element.containingClass!!.qualifiedName + "#" + element.name
         is PsiMethod ->
-            element.getContainingClass()!!.getQualifiedName() + "#" + element.getName() + "(" +
-            element.getParameterList().getParameters().map { it.getType().typeSignature() }.join(",") + ")"
+            element.containingClass!!.qualifiedName + "#" + element.name + "(" +
+            element.parameterList.parameters.map { it.type.typeSignature() }.join(",") + ")"
         else -> null
     }
 
     private fun PsiType.typeSignature(): String = when(this) {
-        is PsiArrayType -> "Array<${getComponentType().typeSignature()}>"
+        is PsiArrayType -> "Array<${componentType.typeSignature()}>"
         else -> mapTypeName(this)
     }
 
     fun DocumentationNode(element: PsiNamedElement,
                           kind: Kind,
-                          name: String = element.getName() ?: "<anonymous>"): DocumentationNode {
-        val (docComment, deprecatedContent) = parseDocumentation((element as? PsiDocCommentOwner)?.getDocComment())
+                          name: String = element.name ?: "<anonymous>"): DocumentationNode {
+        val (docComment, deprecatedContent) = parseDocumentation((element as? PsiDocCommentOwner)?.docComment)
         val node = DocumentationNode(name, docComment, kind)
         if (element is PsiModifierListOwner) {
             node.appendModifiers(element)
-            val modifierList = element.getModifierList()
+            val modifierList = element.modifierList
             if (modifierList != null) {
-                modifierList.getAnnotations().filter { !ignoreAnnotation(it) }.forEach {
+                modifierList.annotations.filter { !ignoreAnnotation(it) }.forEach {
                     val annotation = it.build()
                     node.append(annotation,
-                            if (it.getQualifiedName() == "java.lang.Deprecated") DocumentationReference.Kind.Deprecation else DocumentationReference.Kind.Annotation)
+                            if (it.qualifiedName == "java.lang.Deprecated") DocumentationReference.Kind.Deprecation else DocumentationReference.Kind.Annotation)
                 }
             }
         }
@@ -224,7 +224,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
         return node
     }
 
-    fun ignoreAnnotation(annotation: PsiAnnotation) = when(annotation.getQualifiedName()) {
+    fun ignoreAnnotation(annotation: PsiAnnotation) = when(annotation.qualifiedName) {
         "java.lang.SuppressWarnings" -> true
         else -> false
     }
@@ -246,7 +246,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
                 (element.hasModifierProperty(PsiModifier.PRIVATE) || element.hasModifierProperty(PsiModifier.PACKAGE_LOCAL))
 
     private fun hasSuppressTag(element: Any) =
-        element is PsiDocCommentOwner && element.getDocComment()?.let { it.findTagByName("suppress") != null } ?: false
+        element is PsiDocCommentOwner && element.docComment?.let { it.findTagByName("suppress") != null } ?: false
 
     fun DocumentationNode.appendMembers<T : Any>(elements: Array<T>, buildFn: T.() -> DocumentationNode) =
             appendChildren(elements, DocumentationReference.Kind.Member, buildFn)
@@ -256,23 +256,23 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
 
     fun PsiClass.build(): DocumentationNode {
         val kind = when {
-            isInterface() -> DocumentationNode.Kind.Interface
-            isEnum() -> DocumentationNode.Kind.Enum
-            isAnnotationType() -> DocumentationNode.Kind.AnnotationClass
+            isInterface -> DocumentationNode.Kind.Interface
+            isEnum -> DocumentationNode.Kind.Enum
+            isAnnotationType -> DocumentationNode.Kind.AnnotationClass
             else -> DocumentationNode.Kind.Class
         }
         val node = DocumentationNode(this, kind)
-        getSuperTypes().filter { !ignoreSupertype(it) }.forEach {
+        superTypes.filter { !ignoreSupertype(it) }.forEach {
             node.appendType(it, Kind.Supertype)
             val superClass = it.resolve()
             if (superClass != null) {
                 link(superClass, node, DocumentationReference.Kind.Inheritor)
             }
         }
-        node.appendDetails(getTypeParameters()) { build() }
-        node.appendMembers(getMethods()) { build() }
-        node.appendMembers(getFields()) { build() }
-        node.appendMembers(getInnerClasses()) { build() }
+        node.appendDetails(typeParameters) { build() }
+        node.appendMembers(methods) { build() }
+        node.appendMembers(fields) { build() }
+        node.appendMembers(innerClasses) { build() }
         register(this, node)
         return node
     }
@@ -282,9 +282,9 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
 
     fun PsiClassType.isClass(qName: String): Boolean {
         val shortName = qName.substringAfterLast('.')
-        if (getClassName() == shortName) {
+        if (className == shortName) {
             val psiClass = resolve()
-            return psiClass?.getQualifiedName() == qName
+            return psiClass?.qualifiedName == qName
         }
         return false
     }
@@ -294,7 +294,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
         if (!hasModifierProperty(PsiModifier.FINAL)) {
             node.appendTextNode("var", Kind.Modifier)
         }
-        node.appendType(getType())
+        node.appendType(type)
         register(this, node)
         return node
     }
@@ -307,27 +307,27 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
 
     fun PsiMethod.build(): DocumentationNode {
         val node = DocumentationNode(this, nodeKind(),
-                if (isConstructor()) "<init>" else getName())
+                if (isConstructor) "<init>" else name)
 
-        if (!isConstructor()) {
-            node.appendType(getReturnType())
+        if (!isConstructor) {
+            node.appendType(returnType)
         }
-        node.appendDetails(getParameterList().getParameters()) { build() }
-        node.appendDetails(getTypeParameters()) { build() }
+        node.appendDetails(parameterList.parameters) { build() }
+        node.appendDetails(typeParameters) { build() }
         register(this, node)
         return node
     }
 
     private fun PsiMethod.nodeKind(): Kind = when {
-        isConstructor() -> Kind.Constructor
+        isConstructor -> Kind.Constructor
         hasModifierProperty(PsiModifier.STATIC) -> Kind.CompanionObjectFunction
         else -> Kind.Function
     }
 
     fun PsiParameter.build(): DocumentationNode {
         val node = DocumentationNode(this, Kind.Parameter)
-        node.appendType(getType())
-        if (getType() is PsiEllipsisType) {
+        node.appendType(type)
+        if (type is PsiEllipsisType) {
             node.appendTextNode("vararg", Kind.Annotation, DocumentationReference.Kind.Annotation)
         }
         return node
@@ -335,13 +335,13 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
 
     fun PsiTypeParameter.build(): DocumentationNode {
         val node = DocumentationNode(this, Kind.TypeParameter)
-        getExtendsListTypes().forEach { node.appendType(it, Kind.UpperBound) }
-        getImplementsListTypes().forEach { node.appendType(it, Kind.UpperBound) }
+        extendsListTypes.forEach { node.appendType(it, Kind.UpperBound) }
+        implementsListTypes.forEach { node.appendType(it, Kind.UpperBound) }
         return node
     }
 
     fun DocumentationNode.appendModifiers(element: PsiModifierListOwner) {
-        val modifierList = element.getModifierList()
+        val modifierList = element.modifierList
         if (modifierList == null) {
             return
         }
@@ -350,7 +350,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
                 appendTextNode(it, Kind.Modifier)
             }
         }
-        if ((element is PsiClass || (element is PsiMethod && !element.isConstructor())) &&
+        if ((element is PsiClass || (element is PsiMethod && !element.isConstructor)) &&
                 !element.hasModifierProperty(PsiModifier.FINAL)) {
             appendTextNode("open", Kind.Modifier)
         }
@@ -367,34 +367,34 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions,
         val name = mapTypeName(this)
         val node = DocumentationNode(name, Content.Empty, kind)
         if (this is PsiClassType) {
-            node.appendDetails(getParameters()) { build(Kind.Type) }
+            node.appendDetails(parameters) { build(Kind.Type) }
             link(node, resolve())
         }
         if (this is PsiArrayType && this !is PsiEllipsisType) {
-            node.append(getComponentType().build(Kind.Type), DocumentationReference.Kind.Detail)
+            node.append(componentType.build(Kind.Type), DocumentationReference.Kind.Detail)
         }
         return node
     }
 
     private fun mapTypeName(psiType: PsiType): String = when (psiType) {
         PsiType.VOID -> "Unit"
-        is PsiPrimitiveType -> psiType.getCanonicalText().capitalize()
+        is PsiPrimitiveType -> psiType.canonicalText.capitalize()
         is PsiClassType -> {
             val psiClass = psiType.resolve()
-            if (psiClass?.getQualifiedName() == "java.lang.Object") "Any" else psiType.getClassName()
+            if (psiClass?.qualifiedName == "java.lang.Object") "Any" else psiType.className
         }
-        is PsiEllipsisType -> mapTypeName(psiType.getComponentType())
+        is PsiEllipsisType -> mapTypeName(psiType.componentType)
         is PsiArrayType -> "Array"
-        else -> psiType.getCanonicalText()
+        else -> psiType.canonicalText
     }
 
     fun PsiAnnotation.build(): DocumentationNode {
-        val node = DocumentationNode(getNameReferenceElement()?.getText() ?: "<?>", Content.Empty, DocumentationNode.Kind.Annotation)
-        getParameterList().getAttributes().forEach {
-            val parameter = DocumentationNode(it.getName() ?: "value", Content.Empty, DocumentationNode.Kind.Parameter)
-            val value = it.getValue()
+        val node = DocumentationNode(nameReferenceElement?.text ?: "<?>", Content.Empty, DocumentationNode.Kind.Annotation)
+        parameterList.attributes.forEach {
+            val parameter = DocumentationNode(it.name ?: "value", Content.Empty, DocumentationNode.Kind.Parameter)
+            val value = it.value
             if (value != null) {
-                val valueText = (value as? PsiLiteralExpression)?.getValue() as? String ?: value.getText()
+                val valueText = (value as? PsiLiteralExpression)?.value as? String ?: value.text
                 val valueNode = DocumentationNode(valueText, Content.Empty, DocumentationNode.Kind.Value)
                 parameter.append(valueNode, DocumentationReference.Kind.Detail)
             }
diff --git a/src/Kotlin/ContentBuilder.kt b/src/Kotlin/ContentBuilder.kt
index ff6eafb0..95ff9f91 100644
--- a/src/Kotlin/ContentBuilder.kt
+++ b/src/Kotlin/ContentBuilder.kt
@@ -156,13 +156,13 @@ fun DocumentationBuilder.functionBody(descriptor: DeclarationDescriptor, functio
 
     val text = when (psiElement) {
         is JetDeclarationWithBody -> ContentBlockCode().let() {
-            val bodyExpression = psiElement.getBodyExpression()
+            val bodyExpression = psiElement.bodyExpression
             when (bodyExpression) {
-                is JetBlockExpression -> bodyExpression.getText().removeSurrounding("{", "}")
-                else -> bodyExpression!!.getText()
+                is JetBlockExpression -> bodyExpression.text.removeSurrounding("{", "}")
+                else -> bodyExpression!!.text
             }
         }
-        else -> psiElement.getText()
+        else -> psiElement.text
     }
 
     val lines = text.trimEnd().split("\n".toRegex()).toTypedArray().filterNot { it.length() == 0 }
@@ -180,14 +180,14 @@ private fun DocumentationBuilder.resolveInScope(functionName: String, scope: Jet
     for (part in parts) {
         // short name
         val symbolName = Name.guess(part)
-        val partSymbol = currentScope.getAllDescriptors().filter { it.getName() == symbolName }.firstOrNull()
+        val partSymbol = currentScope.getAllDescriptors().filter { it.name == symbolName }.firstOrNull()
 
         if (partSymbol == null) {
             symbol = null
             break
         }
         currentScope = if (partSymbol is ClassDescriptor)
-            partSymbol.getDefaultType().getMemberScope()
+            partSymbol.defaultType.memberScope
         else
             getResolutionScope(resolutionFacade, partSymbol).asJetScope()
         symbol = partSymbol
diff --git a/src/Kotlin/DocumentationBuilder.kt b/src/Kotlin/DocumentationBuilder.kt
index 4729fbab..9321e5ca 100644
--- a/src/Kotlin/DocumentationBuilder.kt
+++ b/src/Kotlin/DocumentationBuilder.kt
@@ -79,13 +79,13 @@ class DocumentationBuilder(val resolutionFacade: ResolutionFacade,
         if (kdoc is KDocSection) {
             val tags = kdoc.getTags()
             tags.forEach {
-                when (it.getName()) {
+                when (it.name) {
                     "sample" ->
                         content.append(functionBody(descriptor, it.getSubjectName()))
                     "see" ->
                         content.addTagToSeeAlso(descriptor, it)
                     else -> {
-                        val section = content.addSection(javadocSectionDisplayName(it.getName()), it.getSubjectName())
+                        val section = content.addSection(javadocSectionDisplayName(it.name), it.getSubjectName())
                         val sectionContent = it.getContent()
                         val markdownNode = parseMarkdown(sectionContent)
                         buildInlineContentTo(markdownNode, section, { href -> resolveContentLink(descriptor, href) })
@@ -104,17 +104,17 @@ class DocumentationBuilder(val resolutionFacade: ResolutionFacade,
         if (descriptor !is CallableMemberDescriptor) {
             return null
         }
-        val name = descriptor.getName().asString()
+        val name = descriptor.name.asString()
         if (name == "equals" || name == "hashCode" || name == "toString") {
             var deepestDescriptor: CallableMemberDescriptor = descriptor
-            while (!deepestDescriptor.getOverriddenDescriptors().isEmpty()) {
-                deepestDescriptor = deepestDescriptor.getOverriddenDescriptors().first()
+            while (!deepestDescriptor.overriddenDescriptors.isEmpty()) {
+                deepestDescriptor = deepestDescriptor.overriddenDescriptors.first()
             }
-            if (DescriptorUtils.getFqName(deepestDescriptor.getContainingDeclaration()).asString() == "kotlin.Any") {
+            if (DescriptorUtils.getFqName(deepestDescriptor.containingDeclaration).asString() == "kotlin.Any") {
                 val anyClassDescriptors = session.getTopLevelClassDescriptors(FqName.fromSegments(listOf("kotlin", "Any")),
                         NoLookupLocation.UNSORTED)
                 anyClassDescriptors.forEach {
-                    val anyMethod = it.getMemberScope(listOf()).getFunctions(descriptor.getName(), NoLookupLocation.UNSORTED).single()
+                    val anyMethod = it.getMemberScope(listOf()).getFunctions(descriptor.name, NoLookupLocation.UNSORTED).single()
                     val kdoc = KDocFinder.findKDoc(anyMethod)
                     if (kdoc != null) {
                         return kdoc
@@ -125,51 +125,51 @@ class DocumentationBuilder(val resolutionFacade: ResolutionFacade,
         return null
     }
 
-    fun DeclarationDescriptor.isDeprecated(): Boolean = getAnnotations().any {
-        DescriptorUtils.getFqName(it.getType().getConstructor().getDeclarationDescriptor()!!).asString() == "kotlin.Deprecated"
-    } || (this is ConstructorDescriptor &&