Static Code Analysis with Kotlin

Detekt is a static code analysis tool for Kotlin. It can analyze your Kotlin projects for various types of code smells. The tool contains rules for style, performance and potential bugs. The tool is fully configurable so that you may turn off and set thresholds for these rules. It is also extensible so that you could create your own custom rules from your style guide. This tool goes a long way to enforcing good practices in your code base.

Under the hood, the library performs checks against these rules by analyzing the abstract syntax tree provided by the Kotlin Compiler. In this talk, we will learn about how to setup Detekt and how to create custom rules. We will also take a deep dive into how the library enforces these rules by using the abstract syntax tree.

Transcript

1. Static Code Analysis 
 with Kotlin Mohit Sarveiya
 Android Engineer @ Vimeo
2. Static Code Analysis with Kotlin • Why Static Code Analysis? • Setup & Configure Detekt • Program Structure Interface (PSI) • How Detekt uses the PSI to find code smells • Write your own Detekt rules
3. • 100,000+ lines of Java • Started 5 years ago • Legacy code base • Migrating to Kotlin Problem
4. Legacy code problems • Maintainability • Performance • Code smells • Defects • Warnings • Security • Inconsistent styles
5. Maintainability class MainActivity : AppCompatActivity() { fun loadPost() { … } fun loadComments() { … } fun showComments() { … } fun likePost() { … } fun comment() { … } … }
6. Maintainability class MainActivity : AppCompatActivity() { 2000+ lines of code 30+ methods }
7. Potential Bugs class FeedActivity extends AppCompatActivity { @Nullable FeedAdapter feedAdapter; public void showFeed() { feedAdapter.getItemCount(); feedAdapter.registerAdapterDataObserver(…); feedAdapter.submitList(…); } }
8. Potential Bugs class FeedActivity : AppCompatActivity() { var feedAdapter: FeedAdapter? = null fun showFeed() { feedAdapter!!!.itemCount feedAdapter!!!.registerAdapterDataObserver(…) feedAdapter!!!.submitList(…) }
9. Potential Bugs class FeedActivity : AppCompatActivity() { var feedAdapter: FeedAdapter? = null fun showFeed() { feedAdapter!?.itemCount feedAdapter!?.registerAdapterDataObserver(…) feedAdapter!?.submitList(…) }
10. Kotlin Idioms public class Post { private Integer id; private String title; private String message; 
 …
 
 }
11. Kotlin Idioms public class Post { public Integer getId() { return id; } public String getTitle() { return title; } public String getMessage() { return message; }
 
 … }
12. Kotlin Idioms public class Post { @Override public boolean equals(Object o) { … } @Override public int hashCode() { … } 
 }
13. Kotlin Idioms class Post { var id: Int? = null var title: String? = null var message: String? = null override fun equals(o: Any?): Boolean { … } override fun hashCode(): Int { … } }
14. Kotlin Idioms data class Post( val id: Int? = null, val title: String? = null, val message: String? = null )
16. Single Expression Style fun getItemCount(): Int { return items.size }
17. Single Expression Style fun getItemCount() = items.size
18. Enforcing Code Quality Java Kotlin
19. Enforcing Code Quality Kotlin
 Source Analysis Style Guide Code Smells Performance Bugs
20. Static Code Analysis Kotlin
 Source PSI KtFile KtClass KtNamedFunction KtNamedFunction
21. Static Code Analysis Analysis KtFile KtClass KtNamedFunction KtNamedFunction Code Smells Performance Bugs Style Guide
24. Static Code Analysis with Kotlin • Why Static Code Analysis? • Setup & Configure Detekt • Program Structure Interface (PSI) • How Detekt uses the PSI to find code smells • Write your own Detekt rules
25. Setup Detekt 1. Add Detekt Gradle Plugin
 2. Generate Detekt Config YML file
26. Add Detekt Plugin plugins { id "io.gitlab.arturbosch.detekt" version "1.0.0.RC8" } detekt { version = "1.0.0.RC8" profile(“main") { input = "$projectDir" config = "$project.rootDir/detekt-config.yml" filters = ".!*/resources/.*,.!*/build/.*" } }
27. Generate Detekt Config ./gradlew detektGenerateConfig YML 
 File
28. YML Configs complexity: active: true MethodOverloading: active: true threshold: 3 potential-bugs: active: true UnsafeCallOnNullableType: active: true Rule Rule Set
29. YML Configs output-reports: active: true exclude: # - 'HtmlOutputReport' # - 'PlainOutputReport' # - 'XmlOutputReport'
30. Report 182 kotlin files were analyzed. Ruleset: complexity
 MethodOverloading - [createPost] at ApiClient.kt:3:1 Ruleset: comments Ruleset: empty-blocks Ruleset: exceptions Ruleset: naming Ruleset: performance Ruleset: potential-bugs Ruleset: style
31. Report Complexity Report: - 16662 lines of code (loc) - 9633 source lines of code (sloc) - 6380 logical lines of code (lloc) - 4605 comment lines of code (cloc) - 1884 McCabe complexity (mcc) - 2 number of total code smells - 47 % comment source ratio - 295 mcc per 1000 lloc - 0 code smells per 1000 lloc
32. YML Configs console-reports: active: true exclude: # - 'ProjectStatisticsReport' # - 'ComplexityReport' # - 'NotificationReport' # - 'FindingsReport' # - 'BuildFailureReport'
33. YML Configs failFast: false build: maxIssues: 10 weights: # complexity: 2 # LongParameterList: 1 # style: 1 # comments: 1
34. Kotlin Idiomatic Rules • Nullable types • Optional parameters • Data classes
35. class FeedActivity : AppCompatActivity() { var feedAdapter: FeedAdapter? = null !// Non-Compliant fun showFeed() { feedAdapter!!!.itemCount feedAdapter!!!.registerAdapterDataObserver(…) feedAdapter!!!.submitList(…) } Nullable Types
36. class FeedActivity : AppCompatActivity() { var feedAdapter: FeedAdapter? = null !// Compliant fun showFeed() { feedAdapter!?.itemCount feedAdapter!?.registerAdapterDataObserver(…) feedAdapter!?.submitList(…) } Nullable Types
37. Rule: Unsafe Call on Nullable Type Description: • Guard your code to prevent NullPointerExceptions Severity: • Defect
38. Configure Rules in YML potential-bugs: UnsafeCallOnNullableType: active: true
39. Run Detekt ./gradlew detektCheck
40. Detekt Check Report 5 kotlin files were analyzed. Ruleset: potential-bugs UnsafeCallOnNullableType - [showFeed] at FeedActivity.kt:8:17 Ruleset: comments Ruleset: complexity Ruleset: empty-block Ruleset: exceptions Ruleset: naming Ruleset: performance Ruleset: style
41. Use Optional Parameters !// Non-Compliant fun createPost(title: String) {} fun createPost(title: String, message: String) {}
 fun createPost(title: String, message: String, images: List<Images>) { }
42. Use Optional Parameters !// Compliant fun createPost(title: String = “Untitled", message: String? = null, images: List<Image>? = null) { }
43. Rule: Method Overloading Description: • Enforce usage of optional parameters in Kotlin Severity: • Maintainability
44. Configure Rule in YML complexity: MethodOverloading: active: true threshold: 3 Max # of params allowed
45. Use Data Classes public class Post { @Override public boolean equals(Object o) { … } @Override public int hashCode() { … } 
 }
46. Use Data Classes !// Non-Compliant class Post { var id: Int? = null var title: String? = null var message: String? = null override fun equals(o: Any?): Boolean { … } override fun hashCode(): Int { … } }
47. Use Data Classes !// Compliant data class Post( val id: Int? = null, val title: String? = null, val message: String? = null )
48. Rule: Use Data Class Description: • Enforce the usage of data classes for POJOs. Severity: • Style
49. Configure Rule in YML UseDataClass: active: true excludeAnnotatedClasses: “LegacyClass" Exclude classes with this annotation
50. Rule Sets • Comments • Complexity • Empty-blocks • Exceptions • Formatting • Naming • Performance • Potential-Bugs • Style
51. Integrating with your workflow • Git workflow • Continuous integration (CI)
52. Git Pre-commit Hook ##!/usr/bin/env bash
 echo "Running detekt check##..." OUTPUT="/tmp/detekt-$(date +%s)" ./gradlew detektCheck > $OUTPUT EXIT_CODE=$? if [ $EXIT_CODE -ne 0 ]; then cat $OUTPUT rm $OUTPUT echo "***********************************************" echo " Detekt failed " echo " Please fix the above issues before committing " echo "***********************************************" exit $EXIT_CODE fi rm $OUTPUT
53. Integrating with CI git push Detekt
 Check Run
 Tests Build
 APK
54. Static Code Analysis with Kotlin • Why Static Code Analysis? • Setup & Configure Detekt • Program Structure Interface (PSI) • Finding Code Smells with PSI • Write your own Detekt rules.
55. IntelliJ Platform IntelliJ Platform
56. Program Structure Interface Program Structure Interface is a layer in the Intellij Platform for parsing files into a semantic model. 
 Source PsiElement PsiElement PsiElement PsiElement Java, Kotlin, Python, etc..
57. • Code completion • Syntax highlighting • Refactoring • Building indexes Features Powered by PSI
58. Intellij Platform public interface PsiBuilder { Project getProject(); @NotNull Marker mark(); @NotNull ASTNode getTreeBuilt(); } PsiElement PsiElement PsiElement PsiElement intellij-community/platform/core-api/src/com/intellij/lang/PsiBuilder.java
59. Kotlin Embeddable Compiler public class KotlinParsing { void parseFile() { PsiBuilder.Marker fileMarker = mark(); parsePreamble(); while (!eof()) { parseTopLevelDeclaration(); } checkUnclosedBlockComment(); fileMarker.done(KT_FILE); } } KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction kotlin/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java
60. Intellij Platform SDK Kotlin Embeddable Compiler Detekt
61. How Detekt Works Analysis KtFile KtClass KtNamedFunction KtNamedFunction Code Smells Performance Bugs Style Guide
62. How PSI is created Kotlin
 Source Tokens AST PSI
 Tree
63. Kotlin Source class ApiClient { fun createPost(title: String, message: String) { } }
64. class ApiClient { fun createPost(
 title: String, 
 message: String) { } } Parse into Tokens CLASS_KEYWORD LBRACE FUN_KEYWORD WHITE_SPACE RBRACE IDENTIFIER
65. Parsing Source to Tokens … “typealias" { return KtTokens.TYPE_ALIAS_KEYWORD ;} "object" { return KtTokens.OBJECT_KEYWORD ;} "while" { return KtTokens.WHILE_KEYWORD ;} "break" { return KtTokens.BREAK_KEYWORD ;} "class" { return KtTokens.CLASS_KEYWORD ;} "throw" { return KtTokens.THROW_KEYWORD ;} "false" { return KtTokens.FALSE_KEYWORD ;} … kotlin/compiler/psi/src/org/jetbrains/kotlin/lexer/Kotlin.flex
66. Abstract Syntax Tree ElementType.FILE ElementType.CLASS ElementType.FUN ElementType.FUN class ApiClient { fun createPost(
 title: String, 
 message: String) { } }
67. PSI Tree KtFile KtClass KtNamedFunction KtNamedFunction class ApiClient { fun createPost(
 title: String, 
 message: String) { } }
68. PSI Viewer Plugin
70. Creating/Traverse PSI Tree 1. Configure the compiler.
 2. Get PSI Tree for a Kotlin file.
 3. Use visitor pattern to traverse PSI Tree
71. Configure Compiler !// Configure Compiler val configuration = CompilerConfiguration() configuration.put( CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, PrintingMessageCollector(System.err, MessageRenderer.PLAIN_FULL_PATHS, false)) !// Create Project val psiProject: Project = KotlinCoreEnvironment.createForProduction( Disposer.newDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES ).project
72. Create PSI Tree val psiFactory = PsiFileFactory(psiProject)
73. Create PSI Tree val psiFactory = PsiFileFactory(psiProject) !// Get Kotlin File Content val path = Paths.get(“/path/to/kotlin/file.kt”) val content = path.toFile().readText()
74. Create PSI Tree val psiFactory = PsiFileFactory(psiProject) !// Get Kotlin File Content val path = Paths.get(“/path/to/kotlin/file.kt”) val content = path.toFile().readText() !// Create PSI Tree val ktFile: PsiFile = psiFactory.createFileFromText( path.fileName.toString(), KotlinLanguage.INSTANCE, content,
 …)
75. Create PSI Tree !// Create PSI Tree val ktFile: PsiFile = psiFactory.createFileFromText( path.fileName.toString(), KotlinLanguage.INSTANCE, content,
 …) KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
76. How do I traverse it? class ApiClient { fun createPost() { … } fun deletePost() { … } } KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
77. Visitor Provided by Compiler public class KtTreeVisitorVoid extends KtVisitor<Void, Void> { void visitKtElement(@NotNull KtElement element) { } void visitClass(@NotNull KtClass klass) { } void visitNamedFunction(@NotNull KtNamedFunction function) { } … } kotlin/compiler/psi/src/org/jetbrains/kotlin/KtVisitorVoid.java
78. Create Visitor class MyVisitor: KtTreeVisitorVoid() { override fun visitKtFile(file: KtFile) { } override fun visitClass(klass: KtClass) { } override fun visitNamedFunction(function: KtNamedFunction) { } }
79. Create Visitor !// Create PSI Tree val ktFile: PsiFile = psiFactory.createFileFromText( path.fileName.toString(), KotlinLanguage.INSTANCE, content,
 …) !// Specify visitor to traverse tree val visitor = MyVisitor()
 psiFile.accept(visitor) Start Traversing Tree
80. Order of Traversal of PSI Tree class MyVisitor: KtTreeVisitorVoid() { override fun visitKtFile(file: KtFile) { println("visitKtFile") } override fun visitClass(klass: KtClass) { println("visitClass") } override fun visitNamedFunction(function: KtNamedFunction) { println(“visitNamedFunction") } }
81. Output: visitNamedFunction visitNamedFunction visitClassBody visitClass visitKtFile Order of Traversal of PSI Tree KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
82. Output: visitNamedFunction visitNamedFunction visitClassBody visitClass visitKtFile Order of Traversal of PSI Tree KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
83. Output: visitNamedFunction visitNamedFunction visitClassBody visitClass visitKtFile Order of Traversal of PSI Tree KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
84. Output: visitNamedFunction visitNamedFunction visitClassBody visitClass visitKtFile Order of Traversal of PSI Tree KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
85. Static Code Analysis with Kotlin • Why Static Code Analysis? • Setup & Configure Detekt • Program Structure Interface (PSI) • How Detekt uses the PSI to find code smells • Write your own Detekt rules.
86. Finding Code Smells KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction Code Smells Style Performance Bugs Analysis
87. How Detekt Implements Rules • Data classes • Complexity in Kotlin files
88. Rule: Keep Data Classes Simple Description: • Data classes should ONLY hold data. • Data classes should NOT contain extra functions. • Overridden methods in data classes are OK.
89. Rule: Keep Data Classes Simple !// Non-Compliant data class Post(val id: Int, val message: String) { fun create() { … } fun delete() { … } }
90. Rule: Keep Data Classes Simple !// Non-Compliant data class Post(val id: Int, val message: String) { fun create() { … } fun delete() { … } } Should only store data
91. Rule: Keep Data Classes Simple !// Compliant data class Post(val id: Int, val message: String) fun Post.create(apiClient: ApiClient) { … } fun Post.delete(apiClient: ApiClient) { … }
92. Rule: Keep Data Classes Simple !// Compliant data class Post(val id: Int, val message: String) { override fun hashCode(): Int { … } override fun equals(other: Any?): Boolean { … } override fun toString(): String { … } }
93. Strategy for Implementation • Determine class is data class • Does it any methods? • Are the methods are overridden? KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
94. Implementation Check type of KtClass • Enum • Object • Data class • Sealed class KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
95. KtClass API public open class KtClass : KtClassOrObject { public final fun isData(): Boolean { … } public final fun isEnum(): Boolean { … } public final fun isSealed(): Boolean { … } …
 } kotlin/compiler/psi/src/org/jetbrains/kotlin/parsing/KtClass.kt
96. Implementation Get all declaration in the class • Properties • Companion Objects • Functions • Inner classes • etc… KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
97. KtClassBody API public final class KtClassBody { public open fun getDeclarations(): MutableList<KtDeclaration> { … } } kotlin/compiler/psi/src/org/jetbrains/kotlin/parsing/KtClassBody.kt
98. Implementation • Are the methods overridden? KtFile KtClass KtClassBody KtNamedFunction KtNamedFunction
99. Override Modifier Token override fun hashCode(): Int { … } KtTokens.OVERRIDE_MODIFER
100. KtNamedFunction API public class KtNamedFunction extends KtModifierListOwner { boolean hasModifier(@NotNull KtModifierKeywordToken token); … } kotlin/compiler/psi/src/org/jetbrains/kotlin/parsing/KtNamedFunction.kt
101. class DataClassContainsFunctions: KtTreeVisitorVoid() { override fun visitClass(klass: KtClass) { if (klass.isData()) { } } } Implementation
102. class DataClassContainsFunctions: KtTreeVisitorVoid() { override fun visitClass(klass: KtClass) { if (klass.isData()) { klass.getBody()!?.declarations } } } Implementation
103. class DataClassContainsFunctions: KtTreeVisitorVoid() { override fun visitClass(klass: KtClass) { if (klass.isData()) { klass.getBody()!?.declarations !?.filterIsInstance<KtNamedFunction>() } } } Implementation
104. class DataClassContainsFunctions: KtTreeVisitorVoid() { override fun visitClass(klass: KtClass) { 
 if (klass.isData()) {
 klass.getBody()!?.declarations !?.filterIsInstance<KtNamedFunction>() !?.filterNot { it.hasModifier(KtTokens.OVERRIDE_KEYWORD) } } } } Implementation
105. class DataClassContainsFunctions: KtTreeVisitorVoid() { override fun visitClass(klass: KtClass) { 
 if (klass.isData()) {
 klass.getBody()!?.declarations !?.filterIsInstance<KtNamedFunction>() !?.filterNot { it.hasModifier(KtTokens.OVERRIDE_KEYWORD) } !?.forEach { reportCodeSmell(it.name) } } } } Implementation
106. Rule Set: Complexity Description: • Enforce single responsibility principle in conditions, functions and classes. Rules: • Too Many Functions
107. Rule: Too Many Functions Description: • Set a limit to # of functions you could have in a file, class, interfaces, etc… Threshold (default 11): • Files • Classes • Interfaces • Objects • Enums • Private
108. Threshold: 11 !// Non-Compliant fun isPostPublished(…) { }
 
 fun isCommentingEnabled(…) { }
 
 fun sharePost(…) { }
 
 30+ methods 
 Rule: Too Many Functions
109. Threshold: 11 !// Non-Compliant fun isPostPublished(…) { }
 
 @Deprecated
 fun isCommentingEnabled(…) { }
 
 fun sharePost(…) { }
 
 30+ methods
 Rule: Too Many Functions Do not count deprecated methods
110. Threshold: 11 !// Non-Compliant fun isPostPublished(…) { }
 
 @Deprecated
 fun isCommentingEnabled(…) { }
 
 fun sharePost(…) { }
 
 
 Strategy for Implementing Rule KtFile KtNamedFunction KtNamedFunction KtNamedFunction
111. Strategy for Implementing Rule KtFile KtNamedFunction KtNamedFunction KtNamedFunction • Count each method in the tree. • Compare # of methods to threshold. • Exclude from counting methods that are deprecated.
112. • Check function is top level 
 
 
 Implementation KtFile KtNamedFunction KtNamedFunction KtNamedFunction
113. KtNamedFunction API public class KtNamedFunction extends KtFunction, KtAnnotated { public boolean isTopLevel() { KotlinFunctionStub stub = (KotlinFunctionStub)this.getStub(); return stub !!= null ? stub.isTopLevel() : this.getParent() instanceof KtFile; } } kotlin/compiler/psi/src/org/jetbrains/kotlin/psi/KtNamedFunction.java
114. • Get all the annotations of a function • Check if function has @Deprecated annotation
 
 
 Determine function is deprecated KtFile KtNamedFunction KtNamedFunction KtNamedFunction
115. @Deprecated
 fun isCommentingEnabled(…) { }
 
 
 
 KtNamedFunction KtAnnotationEntry Determine Function is Deprecated
116. Get all annotations public class KtNamedFunction extends KtAnnotated { @NotNull List<KtAnnotationEntry> getAnnotationEntries(); } kotlin/compiler/psi/src/org/jetbrains/kotlin/psi/KtAnnotated.java KtNamedFunction KtAnnotationEntry
117. Determine Function is Deprecated 
 fun KtNamedFunction.isDeprecated() = annotationEntries.any { it.typeReference!?.text !== "Deprecated" } KtNamedFunction KtAnnotationEntry
118. Implementation class TooManyFunctions: KtTreeVisitorVoid() { var thresholdInFiles: Int = 11 
 var numOfTopLevelFunctions: Int = 0 } Limit for # functions Counter
119. class TooManyFunctions: KtTreeVisitorVoid() { var numOfTopLevelFunctions: Int = 0 override fun visitNamedFunction(function: KtNamedFunction) { } } Implementation KtNamedFunction KtNamedFunction KtNamedFunction
120. Implementation class TooManyFunctions: KtTreeVisitorVoid() { var numOfTopLevelFunctions: Int = 0 override fun visitNamedFunction(function: KtNamedFunction) { if (function.isTopLevel !&& !function.isDeprecated()) { } } } KtNamedFunction KtNamedFunction KtNamedFunction
121. Implementation class TooManyFunctions: KtTreeVisitorVoid() { var numOfTopLevelFunctions: Int = 0 override fun visitNamedFunction(function: KtNamedFunction) { if (function.isTopLevel !&& !function.isDeprecated()) { numOfTopLevelFunctions!++ } } } KtNamedFunction KtNamedFunction KtNamedFunction
122. Rule: Too Many Functions class TooManyFunctions: KtTreeVisitorVoid() { var thresholdInFiles: Int = 11 override fun visitKtFile(file: KtFile) { if (numOfTopLevelFunctions !>= thresholdInFiles) { reportCodeSmell() } } } KtFile KtNamedFunction KtNamedFunction KtNamedFunction
123. Static Code Analysis with Kotlin • Why Static Code Analysis? • Setup & Configure Detekt • Program Structure Interface (PSI) • How Detekt uses the PSI to find code smells • Write your own Detekt rules
124. Writing Custom Rules 1. Create a custom rules modules
 2. Write your custom rule
 3. Write a provider for your custom rules
 4. Specify fully qualify name of custom rule in a META-INF file.
125. Create Custom Rules Module dependencies { compileOnly “io.gitlab.arturbosch.detekt:detekt-api:1.0.0.RC7–4" testCompile "junit:junit:4.12" testCompile "org.assertj:assertj-core:3.10.0" testCompile “io.gitlab.arturbosch.detekt:detekt-test:1.0.0.RC7–4" }
126. Custom Rule Rule: Importing Internal API Description: Prevent internal APIs in certain modules
127. Detekt’s Visitor abstract class Rule(val config: Config) : KtTreeVisitorVoid { abstract val issue: Issue … } detekt-api/src/main/kotlin/io/gitlab/arturbosch/detekt/api/Rule.kt
128. Create Rule class ImportingInternalAPI(config: Config) : Rule(config) { override val issue = Issue(“Importing Internal API", Severity.Maintainability, “Do not import internal API", Debt.TWENTY_MINS) }
129. import org.jetbrains.kotlin.psi.KtImportDirective import com.learn.detektplayground.internal.InternalPostClass import org.jetbrains.kotlin.com.intellij.psi.PsiFileFactory class SomeClass { … } Create Rule KtFile KtImportDirective KtImportDirective KtImportDirective
130. KtImportDirective API public class KtImportDirective { @Nullable public ImportPath getImportPath() { FqName importFqn = this.getImportedFqName(); if (importFqn !== null) { return null; } else { Name alias = null; String aliasName = this.getAliasName(); if (aliasName !!= null) { alias = Name.identifier(aliasName); } return new ImportPath(importFqn, this.isAllUnder(), alias); } kotlin/compiler/psi/src/org/jetbrains/kotlin/parsing/KtImportDirective.java
131. Custom Rule class ImportingInternalAPI(config: Config) : Rule(config) { override fun visitImportDirective(importDirective: KtImportDirective) { val import = importDirective.importPath!?.pathStr if (import!?.contains(“api.internal”) !== true) { report(CodeSmell(issue, 
 Entity.from(importDirective), “You are using an internal API.”)) } } }
132. Create Rule Set Provider class CustomRuleSetProvider : RuleSetProvider { override val ruleSetId: String = “custom-rules" override fun instance(config: Config) = RuleSet( ruleSetId, 
 listOf(ImportingInternalAPI(config)) ) }
133. Create META-INF Location: custom-rules/src/main/resources/META-INF/services/ 
 com.app.customrules.CustomRuleSetProvider
134. Benefits of Static Code Analysis • Building tools around Kotlin using PSI • Understanding Kotlin Compiler • Building Intellij Plugins
137. Thank you! twitter.com/heyitsmohit /msya github.com