Uast: Add Uast visitor extensions instead of additional checkers

plugins/uast-common/src/org/jetbrains/uast/UastCallback.java

@@ -1,20 +0,0 @@
-/*
- * Copyright 2000-2016 JetBrains s.r.o.
- *
- * 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.
- */
-package org.jetbrains.uast;
-
-public interface UastCallback {
-    void invoke(UElement element);
-}

plugins/uast-common/src/org/jetbrains/uast/UastLanguagePlugin.kt

@@ -15,6 +15,8 @@
  */
 package org.jetbrains.uast
 
+import org.jetbrains.uast.visitor.UastVisitor
+
 interface UastConverter {
     fun convert(element: Any?, parent: UElement): UElement?
     fun convertWithParent(element: Any?): UElement?
@@ -24,11 +26,11 @@ interface UastConverter {
 
 interface UastLanguagePlugin {
     val converter: UastConverter
-    val additionalCheckers: List<UastAdditionalChecker>
+    val visitorExtensions: List<UastVisitorExtension>
 }
 
-interface UastAdditionalChecker {
-    operator fun invoke(element: UElement, callback: UastCallback, context: UastContext)
+interface UastVisitorExtension {
+    operator fun invoke(element: UElement, visitor: UastVisitor, context: UastContext)
 }
 
 object UastConverterUtils {

plugins/uast-common/src/org/jetbrains/uast/baseElements/UElement.kt

@@ -75,6 +75,12 @@ interface UElement {
     }
 }
 
+/**
+ * An interface for the [UElement] which was synthesized by an [UastExtendableVisitor].
+ * A synthesized element is not processed by an [UastExtendableVisitor].
+ */
+interface SynthesizedUElement : UElement
+
 /**
  * An interface for the [UElement] which has a name.
  */

plugins/uast-common/src/org/jetbrains/uast/visitor/DelegatingUastVisitor.kt

@@ -0,0 +1,189 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * 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.
+ */
+
+package org.jetbrains.uast.visitor
+
+import org.jetbrains.uast.*
+
+class DelegatingUastVisitor(private val visitors: List<UastVisitor>): UastVisitor {
+    override fun visitElement(node: UElement): Boolean {
+        return visitors.all { it.visitElement(node) }
+    }
+
+    override fun visitFile(node: UFile): Boolean {
+        return visitors.all { it.visitFile(node) }
+    }
+
+    override fun visitImportStatement(node: UImportStatement): Boolean {
+        return visitors.all { it.visitImportStatement(node) }
+    }
+
+    override fun visitAnnotation(node: UAnnotation): Boolean {
+        return visitors.all { it.visitAnnotation(node) }
+    }
+
+    override fun visitCatchClause(node: UCatchClause): Boolean {
+        return visitors.all { it.visitCatchClause(node) }
+    }
+
+    override fun visitType(node: UType): Boolean {
+        return visitors.all { it.visitType(node) }
+    }
+
+    override fun visitClass(node: UClass): Boolean {
+        return visitors.all { it.visitClass(node) }
+    }
+
+    override fun visitFunction(node: UFunction): Boolean {
+        return visitors.all { it.visitFunction(node) }
+    }
+
+    override fun visitVariable(node: UVariable): Boolean {
+        return visitors.all { it.visitVariable(node) }
+    }
+
+    override fun visitLabeledExpression(node: ULabeledExpression): Boolean {
+        return visitors.all { it.visitLabeledExpression(node) }
+    }
+
+    override fun visitDeclarationsExpression(node: UDeclarationsExpression): Boolean {
+        return visitors.all { it.visitDeclarationsExpression(node) }
+    }
+
+    override fun visitBlockExpression(node: UBlockExpression): Boolean {
+        return visitors.all { it.visitBlockExpression(node) }
+    }
+
+    override fun visitQualifiedExpression(node: UQualifiedExpression): Boolean {
+        return visitors.all { it.visitQualifiedExpression(node) }
+    }
+
+    override fun visitSimpleReferenceExpression(node: USimpleReferenceExpression): Boolean {
+        return visitors.all { it.visitSimpleReferenceExpression(node) }
+    }
+
+    override fun visitCallExpression(node: UCallExpression): Boolean {
+        return visitors.all { it.visitCallExpression(node) }
+    }
+
+    override fun visitBinaryExpression(node: UBinaryExpression): Boolean {
+        return visitors.all { it.visitBinaryExpression(node) }
+    }
+
+    override fun visitBinaryExpressionWithType(node: UBinaryExpressionWithType): Boolean {
+        return visitors.all { it.visitBinaryExpressionWithType(node) }
+    }
+
+    override fun visitParenthesizedExpression(node: UParenthesizedExpression): Boolean {
+        return visitors.all { it.visitParenthesizedExpression(node) }
+    }
+
+    override fun visitUnaryExpression(node: UUnaryExpression): Boolean {
+        return visitors.all { it.visitUnaryExpression(node) }
+    }
+
+    override fun visitPrefixExpression(node: UPrefixExpression): Boolean {
+        return visitors.all { it.visitPrefixExpression(node) }
+    }
+
+    override fun visitPostfixExpression(node: UPostfixExpression): Boolean {
+        return visitors.all { it.visitPostfixExpression(node) }
+    }
+
+    override fun visitSpecialExpressionList(node: USpecialExpressionList): Boolean {
+        return visitors.all { it.visitSpecialExpressionList(node) }
+    }
+
+    override fun visitIfExpression(node: UIfExpression): Boolean {
+        return visitors.all { it.visitIfExpression(node) }
+    }
+
+    override fun visitSwitchExpression(node: USwitchExpression): Boolean {
+        return visitors.all { it.visitSwitchExpression(node) }
+    }
+
+    override fun visitSwitchClauseExpression(node: USwitchClauseExpression): Boolean {
+        return visitors.all { it.visitSwitchClauseExpression(node) }
+    }
+
+    override fun visitWhileExpression(node: UWhileExpression): Boolean {
+        return visitors.all { it.visitWhileExpression(node) }
+    }
+
+    override fun visitDoWhileExpression(node: UDoWhileExpression): Boolean {
+        return visitors.all { it.visitDoWhileExpression(node) }
+    }
+
+    override fun visitForExpression(node: UForExpression): Boolean {
+        return visitors.all { it.visitForExpression(node) }
+    }
+
+    override fun visitForEachExpression(node: UForEachExpression): Boolean {
+        return visitors.all { it.visitForEachExpression(node) }
+    }
+
+    override fun visitTryExpression(node: UTryExpression): Boolean {
+        return visitors.all { it.visitTryExpression(node) }
+    }
+
+    override fun visitLiteralExpression(node: ULiteralExpression): Boolean {
+        return visitors.all { it.visitLiteralExpression(node) }
+    }
+
+    override fun visitThisExpression(node: UThisExpression): Boolean {
+        return visitors.all { it.visitThisExpression(node) }
+    }
+
+    override fun visitSuperExpression(node: USuperExpression): Boolean {
+        return visitors.all { it.visitSuperExpression(node) }
+    }
+
+    override fun visitReturnExpression(node: UReturnExpression): Boolean {
+        return visitors.all { it.visitReturnExpression(node) }
+    }
+
+    override fun visitBreakExpression(node: UBreakExpression): Boolean {
+        return visitors.all { it.visitBreakExpression(node) }
+    }
+
+    override fun visitContinueExpression(node: UContinueExpression): Boolean {
+        return visitors.all { it.visitContinueExpression(node) }
+    }
+
+    override fun visitThrowExpression(node: UThrowExpression): Boolean {
+        return visitors.all { it.visitThrowExpression(node) }
+    }
+
+    override fun visitArrayAccessExpression(node: UArrayAccessExpression): Boolean {
+        return visitors.all { it.visitArrayAccessExpression(node) }
+    }
+
+    override fun visitCallableReferenceExpression(node: UCallableReferenceExpression): Boolean {
+        return visitors.all { it.visitCallableReferenceExpression(node) }
+    }
+
+    override fun visitClassLiteralExpression(node: UClassLiteralExpression): Boolean {
+        return visitors.all { it.visitClassLiteralExpression(node) }
+    }
+
+    override fun visitLambdaExpression(node: ULambdaExpression): Boolean {
+        return visitors.all { it.visitLambdaExpression(node) }
+    }
+
+    override fun visitObjectLiteralExpression(node: UObjectLiteralExpression): Boolean {
+        return visitors.all { it.visitObjectLiteralExpression(node) }
+    }
+}

plugins/uast-common/src/org/jetbrains/uast/visitor/UastExtendableVisitor.kt

@@ -0,0 +1,244 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * 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.
+ */
+
+package org.jetbrains.uast.visitor
+
+import org.jetbrains.uast.*
+import org.jetbrains.uast.visitor.UastVisitor
+
+class UastExtendableVisitor(
+        private val original: UastVisitor,
+        private val context: UastContext,
+        private val extensions: List<UastVisitorExtension>
+) : UastVisitor {
+    private fun handleExtensions(node: UElement) {
+        if (node !is SynthesizedUElement) {
+            for (extension in extensions) {
+                extension.invoke(node, this, context)
+            }
+        }
+    }
+
+    override fun visitElement(node: UElement): Boolean {
+        handleExtensions(node)
+        return original.visitElement(node)
+    }
+
+    override fun visitFile(node: UFile): Boolean {
+        handleExtensions(node)
+        return original.visitFile(node)
+    }
+
+    override fun visitImportStatement(node: UImportStatement): Boolean {
+        handleExtensions(node)
+        return original.visitImportStatement(node)
+    }
+
+    override fun visitAnnotation(node: UAnnotation): Boolean {
+        handleExtensions(node)
+        return original.visitAnnotation(node)
+    }
+
+    override fun visitCatchClause(node: UCatchClause): Boolean {
+        handleExtensions(node)
+        return original.visitCatchClause(node)
+    }
+
+    override fun visitType(node: UType): Boolean {
+        handleExtensions(node)
+        return original.visitType(node)
+    }
+
+    override fun visitClass(node: UClass): Boolean {
+        handleExtensions(node)
+        return original.visitClass(node)
+    }
+
+    override fun visitFunction(node: UFunction): Boolean {
+        handleExtensions(node)
+        return original.visitFunction(node)
+    }
+
+    override fun visitVariable(node: UVariable): Boolean {
+        handleExtensions(node)
+        return original.visitVariable(node)
+    }
+
+    override fun visitLabeledExpression(node: ULabeledExpression): Boolean {
+        handleExtensions(node)
+        return original.visitLabeledExpression(node)
+    }
+
+    override fun visitDeclarationsExpression(node: UDeclarationsExpression): Boolean {
+        handleExtensions(node)
+        return original.visitDeclarationsExpression(node)
+    }
+
+    override fun visitBlockExpression(node: UBlockExpression): Boolean {
+        handleExtensions(node)
+        return original.visitBlockExpression(node)
+    }
+
+    override fun visitQualifiedExpression(node: UQualifiedExpression): Boolean {
+        handleExtensions(node)
+        return original.visitQualifiedExpression(node)
+    }
+
+    override fun visitSimpleReferenceExpression(node: USimpleReferenceExpression): Boolean {
+        handleExtensions(node)
+        return original.visitSimpleReferenceExpression(node)
+    }
+
+    override fun visitCallExpression(node: UCallExpression): Boolean {
+        handleExtensions(node)
+        return original.visitCallExpression(node)
+    }
+
+    override fun visitBinaryExpression(node: UBinaryExpression): Boolean {
+        handleExtensions(node)
+        return original.visitBinaryExpression(node)
+    }
+
+    override fun visitBinaryExpressionWithType(node: UBinaryExpressionWithType): Boolean {
+        handleExtensions(node)
+        return original.visitBinaryExpressionWithType(node)
+    }
+
+    override fun visitParenthesizedExpression(node: UParenthesizedExpression): Boolean {
+        handleExtensions(node)
+        return original.visitParenthesizedExpression(node)
+    }
+
+    override fun visitUnaryExpression(node: UUnaryExpression): Boolean {
+        handleExtensions(node)
+        return original.visitUnaryExpression(node)
+    }
+
+    override fun visitPrefixExpression(node: UPrefixExpression): Boolean {
+        handleExtensions(node)
+        return original.visitPrefixExpression(node)
+    }
+
+    override fun visitPostfixExpression(node: UPostfixExpression): Boolean {
+        handleExtensions(node)
+        return original.visitPostfixExpression(node)
+    }
+
+    override fun visitSpecialExpressionList(node: USpecialExpressionList): Boolean {
+        handleExtensions(node)
+        return original.visitSpecialExpressionList(node)
+    }
+
+    override fun visitIfExpression(node: UIfExpression): Boolean {
+        handleExtensions(node)
+        return original.visitIfExpression(node)
+    }
+
+    override fun visitSwitchExpression(node: USwitchExpression): Boolean {
+        handleExtensions(node)
+        return original.visitSwitchExpression(node)
+    }
+
+    override fun visitSwitchClauseExpression(node: USwitchClauseExpression): Boolean {
+        handleExtensions(node)
+        return original.visitSwitchClauseExpression(node)
+    }
+
+    override fun visitWhileExpression(node: UWhileExpression): Boolean {
+        handleExtensions(node)
+        return original.visitWhileExpression(node)
+    }
+
+    override fun visitDoWhileExpression(node: UDoWhileExpression): Boolean {
+        handleExtensions(node)
+        return original.visitDoWhileExpression(node)
+    }
+
+    override fun visitForExpression(node: UForExpression): Boolean {
+        handleExtensions(node)
+        return original.visitForExpression(node)
+    }
+
+    override fun visitForEachExpression(node: UForEachExpression): Boolean {
+        handleExtensions(node)
+        return original.visitForEachExpression(node)
+    }
+
+    override fun visitTryExpression(node: UTryExpression): Boolean {
+        handleExtensions(node)
+        return original.visitTryExpression(node)
+    }
+
+    override fun visitLiteralExpression(node: ULiteralExpression): Boolean {
+        handleExtensions(node)
+        return original.visitLiteralExpression(node)
+    }
+
+    override fun visitThisExpression(node: UThisExpression): Boolean {
+        handleExtensions(node)
+        return original.visitThisExpression(node)
+    }
+
+    override fun visitSuperExpression(node: USuperExpression): Boolean {
+        handleExtensions(node)
+        return original.visitSuperExpression(node)
+    }
+
+    override fun visitReturnExpression(node: UReturnExpression): Boolean {
+        handleExtensions(node)
+        return super.visitReturnExpression(node)
+    }
+
+    override fun visitBreakExpression(node: UBreakExpression): Boolean {
+        handleExtensions(node)
+        return original.visitBreakExpression(node)
+    }
+
+    override fun visitContinueExpression(node: UContinueExpression): Boolean {
+        handleExtensions(node)
+        return original.visitContinueExpression(node)
+    }
+
+    override fun visitThrowExpression(node: UThrowExpression): Boolean {
+        handleExtensions(node)
+        return original.visitThrowExpression(node)
+    }
+
+    override fun visitArrayAccessExpression(node: UArrayAccessExpression): Boolean {
+        handleExtensions(node)
+        return original.visitArrayAccessExpression(node)
+    }
+
+    override fun visitCallableReferenceExpression(node: UCallableReferenceExpression): Boolean {
+        handleExtensions(node)
+        return original.visitCallableReferenceExpression(node)
+    }
+
+    override fun visitClassLiteralExpression(node: UClassLiteralExpression): Boolean {
+        handleExtensions(node)
+        return original.visitClassLiteralExpression(node)
+    }
+
+    override fun visitLambdaExpression(node: ULambdaExpression): Boolean {
+        handleExtensions(node)
+        return original.visitLambdaExpression(node)
+    }
+
+    override fun visitObjectLiteralExpression(node: UObjectLiteralExpression): Boolean {
+        handleExtensions(node)
+        return original.visitObjectLiteralExpression(node)
+    }
+}

plugins/uast-common/src/org/jetbrains/uast/visitor/UastVisitor.kt

@@ -17,8 +17,8 @@ package org.jetbrains.uast.visitor
 
 import org.jetbrains.uast.*
 
-abstract class UastVisitor {
-    open fun visitElement(node: UElement): Boolean = false
+interface UastVisitor {
+    open fun visitElement(node: UElement): Boolean
 
     open fun visitFile(node: UFile) = visitElement(node)
     open fun visitImportStatement(node: UImportStatement) = visitElement(node)
@@ -31,7 +31,6 @@ abstract class UastVisitor {
     open fun visitFunction(node: UFunction) = visitElement(node)
     open fun visitVariable(node: UVariable) = visitElement(node)
 
-
     // Expressions
     open fun visitLabeledExpression(node: ULabeledExpression) = visitElement(node)
     open fun visitDeclarationsExpression(node: UDeclarationsExpression) = visitElement(node)
@@ -82,7 +81,6 @@ abstract class UastVisitor {
     open fun afterVisitFunction(node: UFunction) {}
     open fun afterVisitVariable(node: UVariable) {}
 
-
     // Expressions
     open fun afterVisitLabeledExpression(node: ULabeledExpression) {}
     open fun afterVisitDeclarationsExpression(node: UDeclarationsExpression) {}
@@ -119,4 +117,8 @@ abstract class UastVisitor {
     open fun afterVisitObjectLiteralExpression(node: UObjectLiteralExpression) {}
 }
 
-object EmptyUastVisitor : UastVisitor()
+abstract class AbstractUastVisitor : UastVisitor {
+    override fun visitElement(node: UElement): Boolean = false
+}
+
+object EmptyUastVisitor : AbstractUastVisitor()