private void visitReferenceExpression(@NotNull UExpression node) {
                         UElement uastParent = node.getUastParent();
                         if (uastParent instanceof UQualifiedReferenceExpression qualifiedReference && qualifiedReference.getSelector() == node) {
                           return;
                         }
                         PsiElement psiResolved = null;
                         if (node instanceof UCallExpression callExpression &&
                             "invoke".equals(callExpression.getMethodName()) &&
                             callExpression.getReceiver() instanceof UResolvable resolvable) {
                           psiResolved = resolvable.resolve();
                         }
                         else if (node instanceof UResolvable resolvable) {
                           psiResolved = resolvable.resolve();
                         }
                         else if (node instanceof UBinaryExpression binaryExpression) {
                           psiResolved = binaryExpression.resolveOperator();
                         }
                         else if (node instanceof UUnaryExpression unaryExpression) {
                           psiResolved = unaryExpression.resolveOperator();
                         }

                         psiResolved = returnToPhysical(psiResolved);
                         RefElement refResolved = refManager.getReference(psiResolved);
                         boolean writing = isAccessedForWriting(node);
                         boolean reading = isAccessedForReading(node);
                         if (refResolved != null) refResolved.initializeIfNeeded();
                         refFrom.addReference(refResolved, psiResolved, decl, writing, reading, node);

                         if (refResolved instanceof RefMethodImpl refMethod) {
                           updateRefMethod(psiResolved, refMethod, node, decl);
                         }
                         else if (refResolved instanceof RefField) {
                           if (node instanceof UResolvable resolvable) {
                             UMethod uProperty = UastContextKt.toUElement(resolvable.resolve(), UMethod.class);
                             if (uProperty != null) {
                             //  PsiMethod property = uProperty.getJavaPsi();
                             //  RefElement refProperty = refManager.getReference(uProperty);
                             //  if (refProperty != null) {
                             //    refProperty.waitForInitialized();
                             //    refFrom.addReference(refProperty, property, decl, false, true, node);
                             //  }
                             }
                           }
                         }
                         else if (refResolved ==  null && psiResolved instanceof PsiMethod method) {
                           markEnumUsedIfValuesMethod(method, node);
                         }

                         if (psiResolved instanceof PsiMember psiMember) {
                           //TODO support kotlin
                           addClassReferenceForStaticImport(node, psiMember, refFrom, decl);
                         }
                       }
private void visitReferenceExpression(@NotNull UExpression node)