fixes

Author: smklimenko

CHANGELOG.md

@@ -7,6 +7,7 @@
 - Implicit variables (x,y,z) are not highlighted in Rainbow
 - Implicit variables (x,y,z) shown as undefined if lambda defined in a context (\d)
 - Global variable assignment marked by rainbow as local
+- Local variable declaration is searched from right-to-left inside lambda expression per expression
 
 ## 6.3.1
 

src/main/java/org/kdb/inside/brains/psi/QLambda.java

@@ -11,6 +11,8 @@ public interface QLambda extends QPsiElement {
     @Nullable
     QParameters getParameters();
 
+    @Nullable
+    QExpressions getExpressions();
 
 //    boolean isImplicitVariable(String name);
 

src/main/java/org/kdb/inside/brains/psi/QPsiUtil.java

@@ -318,8 +318,4 @@ public static PsiElement createCustomCode(Project project, String code) {
     public static QVarDeclaration createVarDeclaration(Project project, String name) {
         return PsiTreeUtil.findChildOfType(QFileType.createFactoryFile(project, name + ":`"), QVarDeclaration.class);
     }
-
-    public static boolean isLocalContextElement(@NotNull PsiElement element) {
-        return element instanceof QLambdaExpr || element instanceof QQueryExpr || element instanceof QTableExpr || element instanceof QDictExpr;
-    }
 }

src/main/java/org/kdb/inside/brains/psi/mixin/QLambdaMixin.java

@@ -1,15 +1,16 @@
 package org.kdb.inside.brains.psi.mixin;
 
 import com.intellij.lang.ASTNode;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiRecursiveElementWalkingVisitor;
+import com.intellij.psi.*;
+import com.intellij.psi.templateLanguages.OuterLanguageElement;
 import icons.KdbIcons;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.kdb.inside.brains.psi.*;
 import org.kdb.inside.brains.psi.impl.QExpressionImpl;
 
 import javax.swing.*;
+import java.util.List;
 
 public abstract class QLambdaMixin extends QExpressionImpl implements QLambda {
     public QLambdaMixin(ASTNode node) {
@@ -48,29 +49,77 @@ public boolean isImplicitDeclaration(@NotNull QVariable variable) {
             return null;
         }
 
+        final QExpressions expressions = getExpressions();
+        if (expressions == null) {
+            return null;
+        }
+
+        final List<QExpression> list = expressions.getExpressionList();
+        if (list.isEmpty()) {
+            return null;
+        }
+
         final String name = variable.getName();
-        final QVarDeclaration[] res = new QVarDeclaration[1];
-        acceptChildren(new PsiRecursiveElementWalkingVisitor() {
-            @Override
-            public void visitElement(@NotNull PsiElement element) {
-                // we don't search inside others lambda, query, table or dict
-                if (QPsiUtil.isLocalContextElement(element)) {
-                    return;
-                }
 
-                // no reason to search after the definition.// In a lambda it can't be below.
-                if (element.equals(variable)) {
-                    stopWalking();
-                } else if (element instanceof QVarDeclaration d) {
-                    if (name.equals(d.getName()) && !QPsiUtil.isGlobalDeclaration(d)) {
-                        res[0] = d;
-                        stopWalking();
+        final SearchResult result = new SearchResult();
+        for (QExpression expression : list) {
+            // We iterate over each expression and takes the right as the best because Q is right-to-left language
+            expression.accept(new PsiRecursiveElementWalkingVisitor() {
+                @Override
+                public void visitElement(@NotNull PsiElement element) {
+                    // we don't search inside others lambda, query, table or dict
+                    if (isContextualElement(element)) {
+                        return;
                     }
-                } else {
-                    super.visitElement(element);
+
+                    // no reason to search after the definition.// In a lambda it can't be below.
+                    if (element.equals(variable)) {
+                        result.containsVariable = true;
+                    } else if (element instanceof QVarDeclaration d) {
+                        if (name.equals(d.getName()) && !QPsiUtil.isGlobalDeclaration(d)) {
+                            result.declaration = d;
+                        }
+                    } else {
+                        super.visitElement(element);
+                    }
+                }
+
+                @Override
+                public void visitComment(@NotNull PsiComment ignore) {
+                }
+
+                @Override
+                public void visitPlainText(@NotNull PsiPlainText ignore) {
                 }
+
+                @Override
+                public void visitWhiteSpace(@NotNull PsiWhiteSpace ignore) {
+                }
+
+                @Override
+                public void visitErrorElement(@NotNull PsiErrorElement ignore) {
+                }
+
+                @Override
+                public void visitOuterLanguageElement(@NotNull OuterLanguageElement ignore) {
+                }
+            });
+
+            // if the declaration found - grate;
+            // if the expression contains the original variable and no declaration in the expression, we stop anyway.
+            if (result.declaration != null || result.containsVariable) {
+                return result.declaration;
             }
-        });
-        return res[0];
+        }
+        return null;
+    }
+
+    private boolean isContextualElement(@NotNull PsiElement element) {
+        return element instanceof QLambdaExpr || element instanceof QQueryExpr || element instanceof QTableExpr || element instanceof QDictExpr;
+    }
+
+    private static class SearchResult {
+        boolean containsVariable;
+        QVarDeclaration declaration;
     }
 }