path: root/plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/JavaFxPsiUtil.java

/*
 * Copyright 2000-2013 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.plugins.javaFX.fxml;

import com.intellij.codeInsight.AnnotationUtil;
import com.intellij.codeInsight.daemon.impl.analysis.HighlightUtil;
import com.intellij.codeInsight.daemon.impl.analysis.JavaGenericsUtil;
import com.intellij.lang.ASTNode;
import com.intellij.lang.xml.XMLLanguage;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.fileTypes.StdFileTypes;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.*;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.*;
import com.intellij.psi.impl.source.PostprocessReformattingAspect;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.search.searches.ClassInheritorsSearch;
import com.intellij.psi.search.searches.ReferencesSearch;
import com.intellij.psi.util.*;
import com.intellij.psi.xml.*;
import com.intellij.util.Processor;
import com.intellij.xml.XmlElementDescriptor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxClassBackedElementDescriptor;
import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxDefaultPropertyElementDescriptor;
import org.jetbrains.plugins.javaFX.fxml.descriptors.JavaFxPropertyElementDescriptor;

import java.util.*;

/**
 * User: anna
 */
public class JavaFxPsiUtil {

  private static final Logger LOG = Logger.getInstance("#" + JavaFxPsiUtil.class.getName());

  public static XmlProcessingInstruction createSingleImportInstruction(String qualifiedName, Project project) {
    final String importText = "<?import " + qualifiedName + "?>";
    final PsiElement child =
      PsiFileFactory.getInstance(project).createFileFromText("a.fxml", XMLLanguage.INSTANCE, importText).getFirstChild();
    return PsiTreeUtil.findChildOfType(child, XmlProcessingInstruction.class);
  }

  public static List<String> parseImports(XmlFile file) {
    return parseInstructions(file, "import");
  }

  public static List<String> parseInjectedLanguages(XmlFile file) {
    return parseInstructions(file, "language");
  }

  private static List<String> parseInstructions(XmlFile file, String instructionName) {
    List<String> definedImports = new ArrayList<String>();
    XmlDocument document = file.getDocument();
    if (document != null) {
      XmlProlog prolog = document.getProlog();

      final Collection<XmlProcessingInstruction>
        instructions = new ArrayList<XmlProcessingInstruction>(PsiTreeUtil.findChildrenOfType(prolog, XmlProcessingInstruction.class));
      for (final XmlProcessingInstruction instruction : instructions) {
        final String instructionTarget = getInstructionTarget(instructionName, instruction);
        if (instructionTarget != null) {
          definedImports.add(instructionTarget);
        }
      }
    }
    return definedImports;
  }

  @Nullable
  public static String getInstructionTarget(String instructionName, XmlProcessingInstruction instruction) {
    final ASTNode node = instruction.getNode();
    ASTNode xmlNameNode = node.findChildByType(XmlTokenType.XML_NAME);
    ASTNode importNode = node.findChildByType(XmlTokenType.XML_TAG_CHARACTERS);
    if (!(xmlNameNode == null || !instructionName.equals(xmlNameNode.getText()) || importNode == null)) {
      return importNode.getText();
    }
    return null;
  }

  public static PsiClass findPsiClass(String name, XmlTag tag) {
    final Project project = tag.getProject();
    if (!StringUtil.getShortName(name).equals(name)) {
      return JavaPsiFacade.getInstance(project).findClass(name, GlobalSearchScope.allScope(project));
    }
    return findPsiClass(name, parseImports((XmlFile)tag.getContainingFile()), tag, project);
  }

  private static PsiClass findPsiClass(String name, List<String> imports, XmlTag tag, Project project) {
    PsiClass psiClass = null;
    if (imports != null) {
      JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);

      PsiFile file = tag.getContainingFile();
      for (String anImport : imports) {
        if (StringUtil.getShortName(anImport).equals(name)) {
          psiClass = psiFacade.findClass(anImport, file.getResolveScope());
        } else if (StringUtil.endsWith(anImport, ".*")) {
          psiClass = psiFacade.findClass(StringUtil.trimEnd(anImport, "*") + name, file.getResolveScope());
        }
        if (psiClass != null) {
          return psiClass;
        }
      }
    }
    return psiClass;
  }

  public static void insertImportWhenNeeded(XmlFile xmlFile,
                                            String shortName,
                                            String qualifiedName) {
    if (shortName != null && findPsiClass(shortName, xmlFile.getRootTag()) == null) {
      final XmlDocument document = xmlFile.getDocument();
      if (document != null) {
        final XmlProcessingInstruction processingInstruction = createSingleImportInstruction(qualifiedName, xmlFile.getProject());
        final XmlProlog prolog = document.getProlog();
        if (prolog != null) {
          prolog.add(processingInstruction);
        } else {
          document.addBefore(processingInstruction, document.getRootTag());
        }
        PostprocessReformattingAspect.getInstance(xmlFile.getProject()).doPostponedFormatting(xmlFile.getViewProvider());
      }
    }
  }

  public static PsiClass getPropertyClass(PsiElement field) {
    final PsiClassType classType = getPropertyClassType(field);
    return classType != null ? classType.resolve() : null;
  }

  public static PsiClassType getPropertyClassType(PsiElement field) {
    return getPropertyClassType(field, JavaFxCommonClassNames.JAVAFX_BEANS_PROPERTY_OBJECT_PROPERTY);
  }

  public static PsiClassType getPropertyClassType(PsiElement field, final String superTypeFQN) {
    if (field instanceof PsiMember) {
      final PsiType type = PropertyUtil.getPropertyType((PsiMember)field);
      if (type instanceof PsiClassType) {
        final PsiClassType.ClassResolveResult resolveResult = ((PsiClassType)type).resolveGenerics();
        final PsiClass attributeClass = resolveResult.getElement();
        if (attributeClass != null) {
          final PsiClass objectProperty = JavaPsiFacade.getInstance(attributeClass.getProject())
            .findClass(superTypeFQN, attributeClass.getResolveScope());
          if (objectProperty != null) {
            final PsiSubstitutor superClassSubstitutor = TypeConversionUtil
              .getClassSubstitutor(objectProperty, attributeClass, resolveResult.getSubstitutor());
            if (superClassSubstitutor != null) {
              final PsiType propertyType = superClassSubstitutor.substitute(objectProperty.getTypeParameters()[0]);
              if (propertyType instanceof PsiClassType) {
                return (PsiClassType)propertyType;
              }
            }
            else {
              return (PsiClassType)type;
            }
          }
        }
      }
    }
    return null;
  }

  public static PsiMethod findPropertySetter(String attributeName, XmlTag context) {
    final String packageName = StringUtil.getPackageName(attributeName);
    if (context != null && !StringUtil.isEmptyOrSpaces(packageName)) {
      final PsiClass classWithStaticProperty = findPsiClass(packageName, context);
      if (classWithStaticProperty != null) {
        return findPropertySetter(attributeName, classWithStaticProperty);
      }
    }
    return null;
  }

  public static PsiMethod findPropertySetter(String attributeName, PsiClass classWithStaticProperty) {
    final String setterName = PropertyUtil.suggestSetterName(StringUtil.getShortName(attributeName));
    final PsiMethod[] setters = classWithStaticProperty.findMethodsByName(setterName, true);
    if (setters.length >= 1) {
      return setters[0];
    }
    return null;
  }

  public static PsiMethod findPropertyGetter(String attributeName, PsiClass classWithStaticProperty) {
    PsiMethod getter = findPropertyGetter(attributeName, classWithStaticProperty, null);
    if (getter != null) {
      return getter;
    }
    return findPropertyGetter(attributeName, classWithStaticProperty, PsiType.BOOLEAN);
  }

  private static PsiMethod findPropertyGetter(final String attributeName,
                                              final PsiClass classWithStaticProperty,
                                              final PsiType propertyType) {
    final String getterName = PropertyUtil.suggestGetterName(StringUtil.getShortName(attributeName), propertyType);
    final PsiMethod[] getters = classWithStaticProperty.findMethodsByName(getterName, true);
    if (getters.length >= 1) {
      return getters[0];
    }
    return null;
  }

  private static final Key<CachedValue<PsiClass>> INJECTED_CONTROLLER = Key.create("javafx.injected.controller");
  private static final RecursionGuard ourGuard = RecursionManager.createGuard("javafx.controller");
  public static PsiClass getControllerClass(final PsiFile containingFile) {
    if (containingFile instanceof XmlFile) {
      final XmlTag rootTag = ((XmlFile)containingFile).getRootTag();
      final Project project = containingFile.getProject();
      if (rootTag != null) {
        XmlAttribute attribute = rootTag.getAttribute(FxmlConstants.FX_CONTROLLER);
        if (attribute != null) {
          final PsiClass controllerClass = findControllerClass(containingFile, project, attribute);
          if (controllerClass != null) {
            return controllerClass;
          }
        }
      }
      final CachedValuesManager manager = CachedValuesManager.getManager(containingFile.getProject());
      final PsiClass injectedControllerClass = ourGuard.doPreventingRecursion(containingFile, true, new Computable<PsiClass>() {
        @Override
        public PsiClass compute() {
          return manager.getCachedValue(containingFile, INJECTED_CONTROLLER,
                                        new JavaFxControllerCachedValueProvider(containingFile.getProject(), containingFile), true);
        }
      });
      if (injectedControllerClass != null) {
        return injectedControllerClass;
      }

      if (rootTag != null && FxmlConstants.FX_ROOT.equals(rootTag.getName())) {
        final XmlAttribute rootTypeAttr = rootTag.getAttribute(FxmlConstants.TYPE);
        if (rootTypeAttr != null) {
          return findControllerClass(containingFile, project, rootTypeAttr);
        }
      }
    }
    return null;
  }

  private static PsiClass findControllerClass(PsiFile containingFile, Project project, XmlAttribute attribute) {
    final String attributeValue = attribute.getValue();
    if (!StringUtil.isEmptyOrSpaces(attributeValue)) {
      final GlobalSearchScope customScope = GlobalSearchScope.projectScope(project).intersectWith(containingFile.getResolveScope());
      return  JavaPsiFacade.getInstance(project).findClass(attributeValue, customScope);
    }
    return null;
  }

  public static boolean checkIfAttributeHandler(XmlAttribute attribute) {
    final String attributeName = attribute.getName();
    final XmlTag xmlTag = attribute.getParent();
    final XmlElementDescriptor descriptor = xmlTag.getDescriptor();
    if (descriptor == null) return false;
    final PsiElement currentTagClass = descriptor.getDeclaration();
    if (!(currentTagClass instanceof PsiClass)) return false;
    final PsiField handlerField = ((PsiClass)currentTagClass).findFieldByName(attributeName, true);
    if (handlerField == null) {
      final String suggestedSetterName = PropertyUtil.suggestSetterName(attributeName);
      final PsiMethod[] existingSetters = ((PsiClass)currentTagClass).findMethodsByName(suggestedSetterName, true);
      for (PsiMethod setter : existingSetters) {
        final PsiParameter[] parameters = setter.getParameterList().getParameters();
        if (parameters.length == 1 && InheritanceUtil.isInheritor(parameters[0].getType(), JavaFxCommonClassNames.JAVAFX_EVENT_EVENT_HANDLER)) {
          return true;
        }
      }
      return false;
    }
    final PsiClass objectPropertyClass = getPropertyClass(handlerField);
    if (objectPropertyClass == null || !InheritanceUtil.isInheritor(objectPropertyClass, JavaFxCommonClassNames.JAVAFX_EVENT_EVENT_HANDLER)) {
      return false;
    }
    return true;
  }

  @Nullable
  public static PsiClass getTagClass(XmlAttributeValue xmlAttributeValue) {
    if (xmlAttributeValue == null) return null;
    final PsiElement xmlAttribute = xmlAttributeValue.getParent();
    final XmlTag xmlTag = ((XmlAttribute)xmlAttribute).getParent();
    if (xmlTag != null) {
      return getTagClass(xmlTag);
    }
    return null;
  }

  public static PsiClass getTagClass(XmlTag xmlTag) {
    final XmlElementDescriptor descriptor = xmlTag.getDescriptor();
    if (descriptor != null) {
      final PsiElement declaration = descriptor.getDeclaration();
      if (declaration instanceof PsiClass) {
        return (PsiClass)declaration;
      }
    }
    return null;
  }

  public static boolean isVisibleInFxml(PsiMember psiMember) {
    return psiMember.hasModifierProperty(PsiModifier.PUBLIC) ||
           AnnotationUtil.isAnnotated(psiMember, JavaFxCommonClassNames.JAVAFX_FXML_ANNOTATION, false);
  }

  public static PsiMethod findValueOfMethod(@NotNull final PsiClass tagClass) {
    final PsiMethod[] methods = tagClass.findMethodsByName(JavaFxCommonClassNames.VALUE_OF, false);
    for (PsiMethod method : methods) {
      if (method.hasModifierProperty(PsiModifier.STATIC)) {
        final PsiParameter[] parameters = method.getParameterList().getParameters();
        if (parameters.length == 1) {
          final PsiType type = parameters[0].getType();
          if (type.equalsToText(CommonClassNames.JAVA_LANG_STRING) || type.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) {
            if (method.hasModifierProperty(PsiModifier.STATIC) && tagClass.equals(PsiUtil.resolveClassInType(method.getReturnType()))) {
              return method;
            }
          }
        }
      }
    }
    return null;
  }

  public static boolean isReadOnly(String attributeName, XmlTag tag) {
    final XmlElementDescriptor descriptor = tag.getDescriptor();
    if (descriptor != null) {
      final PsiElement declaration = descriptor.getDeclaration();
      if (declaration instanceof PsiClass) {
        final PsiClass psiClass = (PsiClass)declaration;
        final PsiField psiField = psiClass.findFieldByName(attributeName, true);
        if (psiField != null) {
          return isReadOnly(psiClass, psiField);
        }
      }
    }
    return false;

  }

  public static boolean isReadOnly(PsiClass psiClass, PsiField psiField) {
    final String name = psiField.getName();
    if (findPropertySetter(name, psiClass) == null &&
        !InheritanceUtil.isInheritor(psiField.getType(), "javafx.collections.ObservableList")) {
      //todo read only condition?
      final PsiMethod[] constructors = psiClass.getConstructors();
      for (PsiMethod constructor : constructors) {
        for (PsiParameter parameter : constructor.getParameterList().getParameters()) {
          if (psiField.getType().equals(parameter.getType())) {
            return false;
          }
        }
      }
      return true;
    }
    return false;
  }

  public static boolean isExpressionBinding(String value) {
    if (!value.startsWith("$")) return false;
    value = value.substring(1);
    return value.startsWith("{") && value.endsWith("}") && value.contains(".");
  }

  @Nullable
  public static PsiType getPropertyType(final PsiType type, final Project project) {
    final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(type);
    final PsiClass psiClass = resolveResult.getElement();
    if (psiClass != null) {
      final PsiClass propertyClass = JavaPsiFacade.getInstance(project).findClass(JavaFxCommonClassNames.JAVAFX_BEANS_PROPERTY,
                                                                                  GlobalSearchScope.allScope(project));
      if (propertyClass != null) {
        final PsiSubstitutor substitutor =
          TypeConversionUtil.getClassSubstitutor(propertyClass, psiClass, resolveResult.getSubstitutor());
        if (substitutor != null) {
          return substitutor.substitute(propertyClass.getTypeParameters()[0]);
        }
      }
    }
    return null;
  }

  public static PsiType getDefaultPropertyExpectedType(PsiClass aClass) {
    final PsiAnnotation annotation = AnnotationUtil.findAnnotationInHierarchy(aClass, Collections.singleton(JavaFxCommonClassNames.JAVAFX_BEANS_DEFAULT_PROPERTY));
    if (annotation != null) {
      final PsiAnnotationMemberValue memberValue = annotation.findAttributeValue(null);
      if (memberValue != null) {
        final String propertyName = StringUtil.stripQuotesAroundValue(memberValue.getText());
        final PsiMethod getter = findPropertyGetter(propertyName, aClass);
        if (getter != null) {
          return getter.getReturnType();
        }
      }
    }
    return null;
  }

  public static String getDefaultPropertyName(PsiClass aClass) {
    final PsiAnnotation annotation = AnnotationUtil.findAnnotationInHierarchy(aClass,
                                                                              Collections.singleton(JavaFxCommonClassNames.JAVAFX_BEANS_DEFAULT_PROPERTY));
    if (annotation != null) {
      final PsiAnnotationMemberValue memberValue = annotation.findAttributeValue(null);
      if (memberValue != null) {
        return StringUtil.stripQuotesAroundValue(memberValue.getText());
      }
    }
    return null;
  }

  public static String isAbleToInstantiate(final PsiClass psiClass) {
    if(psiClass.getConstructors().length > 0) {
      for (PsiMethod constr : psiClass.getConstructors()) {
        if (constr.getParameterList().getParametersCount() == 0) return null;
      }
      final PsiMethod valueOf = findValueOfMethod(psiClass);
      if (valueOf == null) {
        if (!hasBuilder(psiClass)) return "Unable to instantiate";
      }
    }
    return null;
  }

  public static boolean hasBuilder(@NotNull final PsiClass psiClass) {
    final Project project = psiClass.getProject();
    return CachedValuesManager.getManager(project).getCachedValue(psiClass, new CachedValueProvider<Boolean>() {
      @Nullable
      @Override
      public Result<Boolean> compute() {
        final PsiClass builderClass = JavaPsiFacade.getInstance(project).findClass(JavaFxCommonClassNames.JAVAFX_FXML_BUILDER,
                                                                                   GlobalSearchScope.allScope(project));
        if (builderClass != null) {
          final PsiMethod[] buildMethods = builderClass.findMethodsByName("build", false);
          if (buildMethods.length == 1 && buildMethods[0].getParameterList().getParametersCount() == 0) {
            if (ClassInheritorsSearch.search(builderClass).forEach(new Processor<PsiClass>() {
              @Override
              public boolean process(PsiClass aClass) {
                PsiType returnType = null;
                final PsiMethod method = MethodSignatureUtil.findMethodBySuperMethod(aClass, buildMethods[0], false);
                if (method != null) {
                  returnType = method.getReturnType();
                }
                return !Comparing.equal(psiClass, PsiUtil.resolveClassInClassTypeOnly(returnType));
              }
            })) {
              return Result.create(false, PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT);
            }
          }
        }
        return Result.create(true, PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT);
      }
    });
  }

  public static String isClassAcceptable(@Nullable XmlTag parentTag, final PsiClass aClass) {
    if (parentTag == null) {
      return null;
    }
    if (aClass != null && aClass.isValid()) {
      XmlElementDescriptor descriptor = parentTag.getDescriptor();
      if (descriptor instanceof JavaFxDefaultPropertyElementDescriptor) {
        descriptor = ((JavaFxDefaultPropertyElementDescriptor)descriptor).getRootTagDescriptor(parentTag);
      }

      if (descriptor instanceof JavaFxPropertyElementDescriptor) {
        final PsiElement declaration = descriptor.getDeclaration();
        if (declaration instanceof PsiField) {
          return canCoerce(aClass, ((PsiField)declaration).getType());
        }
      }
      else if (descriptor instanceof JavaFxClassBackedElementDescriptor) {
        final PsiElement declaration = descriptor.getDeclaration();
        if (declaration instanceof PsiClass) {
          final PsiType type = getDefaultPropertyExpectedType((PsiClass)declaration);
          if (type != null) {
            return canCoerce(aClass, type);
          }
        }
      }
    }
    return null;
  }

  private static String canCoerce(PsiClass aClass, PsiType type) {
    PsiType collectionItemType = JavaGenericsUtil.getCollectionItemType(type, aClass.getResolveScope());
    if (collectionItemType == null && InheritanceUtil.isInheritor(type, JavaFxCommonClassNames.JAVAFX_BEANS_PROPERTY)) {
      collectionItemType = getPropertyType(type, aClass.getProject());
    }
    if (collectionItemType != null && PsiPrimitiveType.getUnboxedType(collectionItemType) == null) {
      final PsiClass baseClass = PsiUtil.resolveClassInType(collectionItemType);
      if (baseClass != null) {
        final String qualifiedName = baseClass.getQualifiedName();
        if (qualifiedName != null && !Comparing.strEqual(qualifiedName, CommonClassNames.JAVA_LANG_STRING)) {
          if (!InheritanceUtil.isInheritor(aClass, qualifiedName)) {
             return unableToCoerceMessage(aClass, qualifiedName);
          }
        }
      }
    }
    return null;
  }

  private static String unableToCoerceMessage(PsiClass aClass, String qualifiedName) {
    return "Unable to coerce " + HighlightUtil.formatClass(aClass)+ " to " + qualifiedName;
  }

  public static boolean isOutOfHierarchy(final XmlAttributeValue element) {
    XmlTag tag = PsiTreeUtil.getParentOfType(element, XmlTag.class);
    while (tag != null) {
      if (FxmlConstants.FX_DEFINE.equals(tag.getName())) {
        return true;
      }
      tag = tag.getParentTag();
    }
    return false;
  }

  public static PsiType getWrappedPropertyType(PsiField field, final Project project, final Map<String, PsiType> typeMap) {
    final PsiType fieldType = field.getType();
    final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(fieldType);
    final PsiClass fieldClass = resolveResult.getElement();
    if (fieldClass == null) return fieldType;
    return CachedValuesManager.getManager(project).getCachedValue(field, new CachedValueProvider<PsiType>() {
      @Nullable
      @Override
      public Result<PsiType> compute() {
        PsiType substitute = null;
        for (String typeName : typeMap.keySet()) {
          if (InheritanceUtil.isInheritor(fieldType, typeName)) {
            substitute = typeMap.get(typeName);
            break;
          }
        }
        if (substitute == null) {
          if (!InheritanceUtil.isInheritor(fieldType, JavaFxCommonClassNames.JAVAFX_BEANS_VALUE_OBSERVABLE_VALUE)) {
            return Result.create(fieldType, PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT);
          }
          final PsiClass aClass = JavaPsiFacade.getInstance(project)
            .findClass(JavaFxCommonClassNames.JAVAFX_BEANS_VALUE_OBSERVABLE_VALUE, GlobalSearchScope.allScope(project));
          LOG.assertTrue(aClass != null);
          final PsiSubstitutor substitutor =
            TypeConversionUtil.getSuperClassSubstitutor(aClass, fieldClass, resolveResult.getSubstitutor());
          final PsiMethod[] values = aClass.findMethodsByName("getValue", false);
          substitute = substitutor.substitute(values[0].getReturnType());
        }

        return Result.create(substitute, PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT);
      }
    });
  }

  private static class JavaFxControllerCachedValueProvider implements CachedValueProvider<PsiClass> {
    private final Project myProject;
    private final PsiFile myContainingFile;

    public JavaFxControllerCachedValueProvider(Project project, PsiFile containingFile) {
      myProject = project;
      myContainingFile = containingFile;
    }

    @Nullable
    @Override
    public Result<PsiClass> compute() {
      final Ref<PsiClass> injectedController = new Ref<PsiClass>();
      final Ref<PsiFile> dep = new Ref<PsiFile>();
      final PsiClass fxmlLoader =
        JavaPsiFacade.getInstance(myProject).findClass(JavaFxCommonClassNames.JAVAFX_FXML_FXMLLOADER, GlobalSearchScope.allScope(myProject));
      if (fxmlLoader != null) {
        final PsiMethod[] injectControllerMethods = fxmlLoader.findMethodsByName("setController", false);
        if (injectControllerMethods.length == 1) {
          final JavaFxRetrieveControllerProcessor processor = new JavaFxRetrieveControllerProcessor() {
            @Override
            protected boolean isResolveToSetter(PsiMethodCallExpression methodCallExpression) {
              return methodCallExpression.resolveMethod() == injectControllerMethods[0];
            }
          };
          final GlobalSearchScope globalSearchScope = GlobalSearchScope
                      .notScope(GlobalSearchScope.getScopeRestrictedByFileTypes(myContainingFile.getResolveScope(), StdFileTypes.XML));
          ReferencesSearch.search(myContainingFile, globalSearchScope).forEach(new Processor<PsiReference>() {
            @Override
            public boolean process(PsiReference reference) {
              final PsiElement element = reference.getElement();
              if (element instanceof PsiLiteralExpression) {
                final PsiNewExpression expression = PsiTreeUtil.getParentOfType(element, PsiNewExpression.class);
                if (expression != null) {
                  final PsiType type = expression.getType();
                  if (type != null && type.equalsToText(JavaFxCommonClassNames.JAVAFX_FXML_FXMLLOADER)) {
                    final PsiElement parent = expression.getParent();
                    if (parent instanceof PsiLocalVariable) {
                      ReferencesSearch.search(parent).forEach(processor);
                      final PsiClass controller = processor.getInjectedController();
                      if (controller != null) {
                        injectedController.set(controller);
                        dep.set(processor.getContainingFile());
                        return false;
                      }
                    }
                  }
                }
              }
              return true;
            }
          });
        }
      }
      return new Result<PsiClass>(injectedController.get(), dep.get() != null ? dep.get() : PsiModificationTracker.MODIFICATION_COUNT);
    }

    private static abstract class JavaFxRetrieveControllerProcessor implements Processor<PsiReference> {
      private final Ref<PsiClass> myInjectedController = new Ref<PsiClass>();
      private final Ref<PsiFile> myContainingFile = new Ref<PsiFile>();

      protected abstract boolean isResolveToSetter(PsiMethodCallExpression methodCallExpression);

      @Override
      public boolean process(PsiReference reference) {
        final PsiElement element = reference.getElement();
        if (element instanceof PsiReferenceExpression) {
          final PsiMethodCallExpression methodCallExpression = PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression.class);
          if (methodCallExpression != null && isResolveToSetter(methodCallExpression)) {
            final PsiExpression[] expressions = methodCallExpression.getArgumentList().getExpressions();
            if (expressions.length > 0) {
              final PsiClass psiClass = PsiUtil.resolveClassInType(expressions[0].getType());
              if (psiClass != null) {
                myInjectedController.set(psiClass);
                myContainingFile.set(methodCallExpression.getContainingFile());
                return false;
              }
            }
          }
        }
        return true;
      }

      private PsiClass getInjectedController() {
        return myInjectedController.get();
      }

      private PsiFile getContainingFile() {
        return myContainingFile.get();
      }
    }
  }
}