@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    if (classFqn.isEmpty()) {
        return ResolveResult.EMPTY_ARRAY;
    }

    List<ResolveResult> results = new ArrayList<>();
    PsiElement[] psiElements = SignalSlotDispatcherUtil.getSignalPsiElements(myElement.getProject(), classFqn, methodName);

    for (PsiElement psiElement : psiElements) {
        results.add(new PsiElementResolveResult(psiElement));
    }

    return results.toArray(new ResolveResult[0]);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    if (this.methodName == null) {

        return ResolveResult.EMPTY_ARRAY;
    }

    if (this.className == null) {
        Collection<Function> functionsByName = PhpIndex.getInstance(myElement.getProject()).getFunctionsByName(methodName);

        return PsiElementResolveResult.createResults(functionsByName);
    }

    String s = "#M#C\\" + this.className.replace("\\\\", "\\") + "." + this.methodName;
    Collection<? extends PhpNamedElement> bySignature = PhpIndex.getInstance(myElement.getProject()).getBySignature(s);

    return PsiElementResolveResult.createResults(bySignature);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    if (myElement instanceof FluidViewHelperReference) {
        FluidViewHelperExpr viewHelperExpr = (FluidViewHelperExpr) PsiTreeUtil.findFirstParent(myElement, e -> e instanceof FluidViewHelperExpr);
        String presentableName = viewHelperExpr.getPresentableName();
        ViewHelper viewHelperByName = ViewHelperUtil.getViewHelperByName(myElement, presentableName);
        if (viewHelperByName == null) {

            return ResolveResult.EMPTY_ARRAY;
        }

        return PsiElementResolveResult.createResults(PhpIndex.getInstance(myElement.getProject()).getClassesByFQN(viewHelperByName.fqn));
    }

    return ResolveResult.EMPTY_ARRAY;
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    String nodeTypeNameToFindReferenceFor = yamlElement.getKeyText();

    // files which contain the NodeType definition
    Collection<VirtualFile> files = FileBasedIndex.getInstance().getContainingFiles(NodeTypesYamlFileIndex.KEY, nodeTypeNameToFindReferenceFor, GlobalSearchScope.allScope(yamlElement.getProject()));

    return files
            .stream()
            // get the PSI for each file
            .map(file -> PsiManager.getInstance(yamlElement.getProject()).findFile(file))
            // ensure we only have YAML files
            .filter(psiFile -> psiFile instanceof YAMLFile)
            .map(psiFile -> (YAMLFile) psiFile)
            // get all YAML keys in these files
            .flatMap(yamlFile -> YAMLUtil.getTopLevelKeys(yamlFile).stream())
            // get the correct YAML key
            .filter(yamlKeyValue -> yamlKeyValue.getKeyText().equals(nodeTypeNameToFindReferenceFor))
            // remove "current" element if it exists
            .filter(yamlKeyValue -> yamlElement != yamlKeyValue)
            // build up the result object
            .map(yamlKeyValue -> new PsiElementResolveResult(yamlKeyValue, true))
            .toArray(PsiElementResolveResult[]::new);
}
 

@Override
public void updateUI(Object p, @NotNull ParameterInfoUIContext context) {
    if (p instanceof PsiElementResolveResult) p = ((PsiElementResolveResult) p).getElement();
    if (!(p instanceof GLSLFunctionDeclaration)) return;
    GLSLFunctionDeclaration declaration = (GLSLFunctionDeclaration) p;
    GLSLParameterDeclaration[] parameters = declaration.getParameters();

    StringBuilder buffer = new StringBuilder();
    buffer.append(declaration.getType().getReturnType().getTypename())
            .append(' ').append(declaration.getName()).append('(');

    final int currentParameter = context.getCurrentParameterIndex();
    int highlightStartOffset = -1, highlightEndOffset = -1;

    for (int i = 0; i < parameters.length; i++) {
        if (i == currentParameter) highlightStartOffset = buffer.length();
        buffer.append(parameters[i].getText());
        if (i == currentParameter) highlightEndOffset = buffer.length();
        if (i < parameters.length - 1) buffer.append(", ");
    }
    buffer.append(')');

    context.setupUIComponentPresentation(buffer.toString(), highlightStartOffset, highlightEndOffset, false, false, false, context.getDefaultParameterColor());
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    XQueryFile file = (XQueryFile) myElement.getContainingFile();
    List<ResolveResult> results = new ArrayList<ResolveResult>();
    Collection<ResolveResult> primaryReferences = getPrimaryReferences();
    results.addAll(primaryReferences);
    if (shouldAddOtherReferences(primaryReferences)) {
        results.addAll(getReferencesFromNamespaceDeclarations(file.getNamespaceDeclarations()));
        results.addAll(getReferencesFromModuleImports(file.getModuleImports()));
        results.addAll(getReferencesFromModuleName(file.getModuleNamespaceName()));
    }
    if (results.isEmpty() && file.isPredeclaredNamespacePrefix(myElement.getText())) {
        results.add(new PsiElementResolveResult(getElement()));
    }
    return results.toArray(new ResolveResult[results.size()]);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean b) {

    List<PsiElement> psiElements = new ArrayList<>();

    String content = ((StringLiteralExpression) getElement()).getContents();
    for(Field field: constraintPhpClass.getFields()) {
        String name = field.getName();
        if(!field.isConstant() && field.getModifier().isPublic() && content.equals(name)) {
            psiElements.add(field);
        }
    }

    return PsiElementResolveResult.createResults(psiElements);
}
 

static public List<ResolveResult> getClassInterfaceResolveResult(Project project, String FQNClassOrInterfaceName) {

        PhpIndex phpIndex = PhpIndex.getInstance(project);
        Collection<PhpClass> phpClasses = phpIndex.getClassesByFQN(FQNClassOrInterfaceName);
        Collection<PhpClass> phpInterfaces = phpIndex.getInterfacesByFQN(FQNClassOrInterfaceName);

        List<ResolveResult> results = new ArrayList<ResolveResult>();
        for (PhpClass phpClass : phpClasses) {
            results.add(new PsiElementResolveResult(phpClass));
        }
        for (PhpClass phpInterface : phpInterfaces) {
            results.add(new PsiElementResolveResult(phpInterface));
        }

        return results;
    }
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    if (myElement instanceof StringLiteralExpression) {
        String aspectFQN = TYPO3Utility.getFQNByAspectName(((StringLiteralExpression) myElement).getContents());
        if (aspectFQN == null) {
            return ResolveResult.EMPTY_ARRAY;
        }

        return PsiElementResolveResult.createResults(PhpIndex.getInstance(myElement.getProject()).getClassesByFQN(aspectFQN));
    }

    return ResolveResult.EMPTY_ARRAY;
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
  return PsiElementResolveResult.createResults(
      TemplateNameUtils.findTemplateDeclarations(this.getElement(), templateName)
          .stream()
          .map(SoyTemplateBlock::getDefinitionIdentifier)
          .collect(Collectors.toList()));
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean b) {
    List<ResolveResult> results = new ArrayList<>();

    final PsiMethod[] methodsByName = getPsiClass().findMethodsByName(methodNameOnly, true);
    for (PsiMethod psiMethod : getJavaMethodUtils().getBeanMethods(Arrays.asList(methodsByName))) {
        if (getCamelIdeaUtils().isAnnotatedWithHandler(psiMethod)) {
            return new ResolveResult[] {new PsiElementResolveResult(psiMethod)};
        }
        results.add(new PsiElementResolveResult(psiMethod));
    }
    return results.toArray(new ResolveResult[results.size()]);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    return Optional.ofNullable(ModuleUtilCore.findModuleForPsiElement(myElement))
        .map(module -> CamelIdeaUtils.getService().findEndpointDeclarations(module, endpoint))
        .map(this::wrapAsDirectEndpointPsiElements)
        .map(PsiElementResolveResult::createResults)
        .orElse(ResolveResult.EMPTY_ARRAY);
}
 

@Override
protected ResolveResult[] resolveInner(boolean incompleteCode, PsiFile containingFile) {
  File containingDirectory = ((BuildFile) containingFile).getFile().getParentFile();
  if (containingDirectory == null) {
    return ResolveResult.EMPTY_ARRAY;
  }
  List<String> includes = resolveListContents(element.getIncludes());
  List<String> excludes = resolveListContents(element.getExcludes());
  boolean directoriesExcluded = element.areDirectoriesExcluded();
  if (includes.isEmpty()) {
    return ResolveResult.EMPTY_ARRAY;
  }
  Project project = element.getProject();
  try {
    List<File> files =
        UnixGlob.forPath(containingDirectory)
            .addPatterns(includes)
            .addExcludes(excludes)
            .setExcludeDirectories(directoriesExcluded)
            .setDirectoryFilter(directoryFilter(project, containingDirectory.getPath()))
            .glob();

    List<ResolveResult> results = Lists.newArrayListWithCapacity(files.size());
    for (File file : files) {
      PsiFileSystemItem psiFile = BuildReferenceManager.getInstance(project).resolveFile(file);
      if (psiFile != null) {
        results.add(new PsiElementResolveResult(psiFile));
      }
    }
    return results.toArray(ResolveResult.EMPTY_ARRAY);

  } catch (Exception e) {
    return ResolveResult.EMPTY_ARRAY;
  }
}
 

static ResolveResult[] doResolve(BlazeGoPackage goPackage, int index) {
  return Stream.of(goPackage)
      .map(BlazeGoPackage::getImportReferences)
      .filter(Objects::nonNull)
      .filter(list -> index < list.length)
      .map(list -> list[index])
      .filter(Objects::nonNull)
      .map(GoPackageFileSystemItem::getInstance)
      .filter(Objects::nonNull)
      .map(PsiElementResolveResult::new)
      .toArray(ResolveResult[]::new);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
	final PsiElement resolve = resolve();
	if(resolve != null) {
		return new ResolveResult[] { new PsiElementResolveResult(resolve) };
	}
	return ResolveResult.EMPTY_ARRAY;
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean b) {
    final List<PsiElement> targets = new ArrayList<>();

    ShopwareUtil.collectControllerAction(getElement().getProject(), this.controllerName, (method, methodStripped, moduleName1, controllerName1) -> {
        if (methodStripped.equalsIgnoreCase(content)) {
            targets.add(method);
        }
    }, moduleName);

    return PsiElementResolveResult.createResults(targets);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean b) {
    final List<PsiElement> targets = new ArrayList<>();

    ShopwareUtil.collectControllerClass(getElement().getProject(), (phpClass, moduleName1, controllerName) -> {
        if (controllerName.equalsIgnoreCase(content)) {
            targets.add(phpClass);
        }
    }, moduleName);

    return PsiElementResolveResult.createResults(targets);
}
 

public static List<PsiElementResolveResult> matchGlobalNamesQualified(
        List<FoundDefinition> namedElements, String qualifiedCallName){
    List<PsiElementResolveResult> results = Lists.newArrayList();
    for (FoundDefinition possibleReference : namedElements) {
        if(possibleReference.imprt != null && possibleReference.imprt.alias != null &&
                possibleReference.imprt.alias.equals(qualifiedCallName)){
            results.add(new PsiElementResolveResult(possibleReference.element));
        }
    }
    return results;

}
 

@NotNull
public ResolveResult[] multiResolve(boolean incompleteCode) {
    final List<GLSLFunctionType> functions = sourceExpression.getPossibleCalledFunctions();
    ResolveResult[] result = new ResolveResult[functions.size()];
    for (int i = 0; i < result.length; i++) {
        result[i] = new PsiElementResolveResult(functions.get(i).getDefinition());
    }
    return result;
}
 

private ResolveResult[] convertToResolveResults(List<XQueryVarName> resolveResults) {
    ResolveResult[] convertedResults = new ResolveResult[resolveResults.size()];
    for (int i = 0; i < resolveResults.size(); i++) {
        convertedResults[i] = new PsiElementResolveResult(resolveResults.get(i));
    }
    return convertedResults;
}
 

private ResolveResult[] convertToResolveResults(List<XQueryFunctionName> resolveResults) {
    ResolveResult[] convertedResults = new ResolveResult[resolveResults.size()];
    for (int i = 0; i < resolveResults.size(); i++) {
        convertedResults[i] = new PsiElementResolveResult(resolveResults.get(i));
    }
    return convertedResults;
}
 

private Collection<ResolveResult> getReferencesFromModuleName(XQueryNamespacePrefix moduleNamespaceName) {
    if (moduleNamespaceName != null && myElement.getText().equals(moduleNamespaceName.getText())) {
        return Arrays.asList(new ResolveResult[]{new PsiElementResolveResult(moduleNamespaceName)});
    } else {
        return emptyList();
    }
}
 

private Collection<ResolveResult> getReferencesFromModuleImports(Collection<XQueryModuleImport> moduleImports) {
    if (moduleImports.size() > 0) {
        List<ResolveResult> results = new ArrayList<ResolveResult>();
        for (XQueryModuleImport moduleImport : moduleImports) {
            XQueryNamespacePrefix namespaceName = moduleImport.getNamespacePrefix();
            if (namespaceName != null && myElement.getText().equals(namespaceName.getText())) {
                results.add(new PsiElementResolveResult(moduleImport.getNamespacePrefix()));
            }
        }
        return results;
    } else {
        return emptyList();
    }
}
 

private Collection<ResolveResult> getReferencesFromNamespaceDeclarations(Collection<XQueryNamespaceDecl>
                                                                                 namespaceDeclarations) {
    if (namespaceDeclarations.size() > 0) {
        List<ResolveResult> results = new ArrayList<ResolveResult>();
        for (XQueryNamespaceDecl namespaceDeclaration : namespaceDeclarations) {
            if (myElement.getText().equals(namespaceDeclaration.getNamespacePrefix().getText())) {
                results.add(new PsiElementResolveResult(namespaceDeclaration.getNamespacePrefix()));
            }
        }
        return results;
    } else {
        return emptyList();
    }
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    String contents = getElement().getContents();
    if(org.apache.commons.lang.StringUtils.isBlank(contents)) {
        return new ResolveResult[0];
    }

    Collection<PsiElement> psiElements = new ArrayList<>();

    Set<String> methods = getCamelizeAndUnderscoreString(contents);

    // provide setter fallback for non model class or or unknown methods
    for (String value : methods) {
        Method method = phpClass.findMethodByName("set" + value);
        if (method != null) {
            psiElements.add(method);
        }
    }

    // property path
    psiElements.addAll(this.phpClass.getFields().stream()
        .filter(field -> !field.isConstant() && field.getModifier().isPublic() && methods.contains(field.getName()))
        .collect(Collectors.toList())
    );

    return PsiElementResolveResult.createResults(psiElements);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    ContainerCollectionResolver.ServiceCollector collector = ContainerCollectionResolver
        .ServiceCollector.create(getElement().getProject());

    // Return the PsiElement for the class corresponding to the serviceId
    String serviceClass = collector.resolve(serviceId);
    if (serviceClass == null) {
        return new ResolveResult[0];
    }

    return PsiElementResolveResult.createResults(PhpIndex.getInstance(getElement().getProject()).getAnyByFQN(serviceClass));
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {

    List<ResolveResult> results = new ArrayList<>();

    for (PsiElement psiParameter : RouteHelper.getRouteParameterPsiElements(getElement().getProject(), this.routeName, parameterName)) {
        results.add(new PsiElementResolveResult(psiParameter));
    }

    return results.toArray(new ResolveResult[results.size()]);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {

    List<ResolveResult> resolveResults = new ArrayList<>();

    for(PsiElement psiElement: EventDispatcherSubscriberUtil.getEventPsiElements(getElement().getProject(), this.eventName)) {
        resolveResults.add(new PsiElementResolveResult(psiElement));
    }

    return resolveResults.toArray(new ResolveResult[resolveResults.size()]);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    PhpClass phpClass = ServiceUtil.getResolvedClassDefinition(getElement().getProject(), this.className);
    if(phpClass == null) {
        return new ResolveResult[0];
    }

    Method targetMethod = phpClass.findMethodByName(this.method);
    if(targetMethod == null) {
        return new ResolveResult[0];
    }

    return PsiElementResolveResult.createResults(targetMethod);
}
 

@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
    Collection<PsiElement> targets = new ArrayList<>();

    targets.addAll(
        DotEnvUtil.getEnvironmentVariableTargetsForParameter(getElement().getProject(), this.parameterName)
    );

    targets.addAll(ServiceUtil.getServiceClassTargets(getElement().getProject(), this.parameterName));

    return PsiElementResolveResult.createResults(targets);
}