protected Collection<PsiElement> classGoToDeclaration(PsiElement psiElement, String className) {
Collection<PsiElement> psiElements = new HashSet<PsiElement>();
// Class::method
// Class::FooAction
// Class:Foo
if (className.contains(":")) {
String[] split = className.replaceAll("(:)\\1", "$1").split(":");
if (split.length == 2) {
for (String append : new String[] {"", "Action"}) {
Method classMethod =
PhpElementsUtil.getClassMethod(psiElement.getProject(), split[0], split[1] + append);
if (classMethod != null) {
psiElements.add(classMethod);
}
}
}
return psiElements;
}
// ClassName
psiElements.addAll(PhpElementsUtil.getClassesInterface(psiElement.getProject(), className));
return psiElements;
}
@Nullable
@Override
public String getType(PsiElement e) {
if (DumbService.getInstance(e.getProject()).isDumb()
|| !Settings.getInstance(e.getProject()).pluginEnabled
|| !Settings.getInstance(e.getProject()).objectManagerFindTypeProvider) {
return null;
}
if (!(e instanceof MethodReference)
|| !PhpElementsUtil.isMethodWithFirstStringOrFieldReference(e, "find")) {
return null;
}
String refSignature = ((MethodReference) e).getSignature();
if (StringUtil.isEmpty(refSignature)) {
return null;
}
// we need the param key on getBySignature(), since we are already in the resolved method there
// attach it to signature
// param can have dotted values split with \
PsiElement[] parameters = ((MethodReference) e).getParameters();
if (parameters.length == 2) {
return PhpTypeProviderUtil.getReferenceSignature((MethodReference) e, TRIM_KEY, 2);
}
return null;
}
@Nullable
@Override
public PhpType getType(PsiElement e) {
if (DumbService.getInstance(e.getProject()).isDumb()) {
return null;
}
if (!ContainerGetHelper.isContainerGetCall(e)) {
return null;
}
String serviceId = ContainerGetHelper.getServiceId((MethodReference) e);
if (null == serviceId) {
return null;
}
Symfony2ProjectComponent symfony2ProjectComponent =
e.getProject().getComponent(Symfony2ProjectComponent.class);
ServiceMap serviceMap = symfony2ProjectComponent.getServicesMap();
if (null == serviceMap) {
return null;
}
String serviceClass = serviceMap.getMap().get(serviceId);
if (null == serviceClass) {
return null;
}
return new PhpType().add(serviceClass);
}
public LineMarkerInfo getLineMarkerInfo(@NotNull PsiElement element) {
if (ApplicationManager.getApplication().isUnitTestMode()) {
return null;
}
if (!(element instanceof PsiMethod) && !(element instanceof PsiClass)) {
return null;
}
if (!PsiUtil.isPluginProject(element.getProject())) {
return null;
}
final VirtualFile file = PsiUtilCore.getVirtualFile(element);
if (file == null
|| !ProjectFileIndex.SERVICE
.getInstance(element.getProject())
.isInTestSourceContent(file)) {
return null;
}
if (element instanceof PsiMethod) {
final PsiMethod method = (PsiMethod) element;
if (isTestMethod(method)) {
return new LineMarkerInfo<PsiMethod>(
method,
method.getModifierList().getTextRange(),
PlatformIcons.TEST_SOURCE_FOLDER,
Pass.UPDATE_ALL,
null,
new TestDataNavigationHandler(),
GutterIconRenderer.Alignment.LEFT);
}
} else {
final PsiClass psiClass = (PsiClass) element;
final String basePath = getTestDataBasePath(psiClass);
if (basePath != null) {
PsiModifierList modifierList = psiClass.getModifierList();
assert modifierList != null;
return new LineMarkerInfo<PsiClass>(
psiClass,
modifierList.getTextRange(),
PlatformIcons.TEST_SOURCE_FOLDER,
Pass.UPDATE_ALL,
new TooltipProvider(basePath),
new GutterIconNavigationHandler<PsiClass>() {
@Override
public void navigate(MouseEvent e, PsiClass elt) {
final VirtualFile baseDir = VfsUtil.findFileByIoFile(new File(basePath), true);
if (baseDir != null) {
new OpenFileDescriptor(psiClass.getProject(), baseDir).navigate(true);
}
}
},
GutterIconRenderer.Alignment.LEFT);
}
}
return null;
}
public void showParameterInfo(@NotNull PsiElement element, CreateParameterInfoContext context) {
ResolveResult[] variants = ResolveResult.EMPTY_ARRAY;
if (element instanceof PsiPolyVariantReference) {
variants = ((PsiPolyVariantReference) element).multiResolve(true);
if (variants.length != 0) {
context.setItemsToShow(
ContainerUtil.map2Array(
variants,
CfmlFunctionDescription.class,
new Function<ResolveResult, CfmlFunctionDescription>() {
public CfmlFunctionDescription fun(ResolveResult resolveResult) {
final PsiElement element1 = resolveResult.getElement();
if (CfmlPsiUtil.isFunctionDefinition(element1)) {
CfmlFunction function = CfmlPsiUtil.getFunctionDefinition(element1);
if (function != null) {
return function.getFunctionInfo();
}
} else if (element1 instanceof PsiMethod) {
PsiMethod function = (PsiMethod) element1;
CfmlFunctionDescription javaMethodDescr =
new CfmlFunctionDescription(
function.getName(), function.getReturnType().getPresentableText());
final PsiParameter[] psiParameters =
function.getParameterList().getParameters();
final int paramsNum = psiParameters.length;
for (int i = 0; i < paramsNum; i++) {
PsiParameter psiParameter = psiParameters[i];
javaMethodDescr.addParameter(
new CfmlFunctionDescription.CfmlParameterDescription(
psiParameter.getName(),
psiParameter.getType().getPresentableText(),
true));
}
return javaMethodDescr;
}
return null;
}
}));
context.showHint(element, element.getTextRange().getStartOffset(), this);
return;
}
}
if (element instanceof CfmlReferenceExpression) {
String functionName = element.getText().toLowerCase();
if (ArrayUtil.find(
CfmlLangInfo.getInstance(element.getProject()).getPredefinedFunctionsLowCase(),
functionName)
!= -1) {
context.setItemsToShow(
new Object[] {
CfmlLangInfo.getInstance(element.getProject())
.getFunctionParameters()
.get(functionName)
});
context.showHint(element, element.getTextRange().getStartOffset(), this);
}
}
}
public static String cleanRefIdForPsiElement(PsiElement element) {
final Language language = element.getLanguage();
if (language instanceof JavaLanguage) {
if (element instanceof PsiModifierList) {
PsiAnnotation[] annotations = ((PsiAnnotationOwner) element).getAnnotations();
for (PsiAnnotation annotation : annotations) {
if (AnnoRefConfigSettings.getInstance(element.getProject())
.getAnnoRefState()
.ANNOREF_ANNOTATION_FQN
.equals(annotation.getQualifiedName())) {
String refKey =
SQLRefNamingUtil.cleanAnnoRefForName(annotation.getContainingFile(), annotation);
if (refKey != null) {
return refKey;
}
}
}
}
if (element instanceof PsiAnnotation) {
final PsiAnnotation psiAnnotation = (PsiAnnotation) element;
if (AnnoRefConfigSettings.getInstance(element.getProject())
.getAnnoRefState()
.ANNOREF_ANNOTATION_FQN
.equals(psiAnnotation.getQualifiedName())) {
String cleanedAnnoRef =
SQLRefNamingUtil.cleanAnnoRefForName(
psiAnnotation.getContainingFile(), psiAnnotation);
if (cleanedAnnoRef != null) {
return cleanedAnnoRef;
}
}
if (element instanceof PsiJavaToken
&& ((PsiJavaToken) element).getTokenType() == JavaTokenType.STRING_LITERAL) {
final String refKey = StringUtils.cleanQuote(element.getText());
if (refKey != null) {
return refKey;
}
}
}
}
if (language instanceof XMLLanguage) {
if (SQLRefNamingUtil.isPropitiousXmlFile(element.getContainingFile())) {
final boolean isXmlTokenValid =
new FilterElementProcessor(
new XmlTokenTypeFilter(XmlTokenType.XML_ATTRIBUTE_VALUE_TOKEN))
.execute(element);
if (isXmlTokenValid) {
final String refKey = getSqlRefKey(element);
if (refKey != null) {
return refKey;
}
}
}
}
return null;
}
public static PsiClass getTypeOfElement(PsiElement element) {
final String name;
if (element instanceof PsiVariable) {
name = Util.getErasedCanonicalText(((PsiVariable) element).getType().getCanonicalText());
} else {
return null;
}
return JavaPsiFacade.getInstance(element.getProject())
.findClass(name, GlobalSearchScope.allScope(element.getProject()));
}
/**
* Try to visit possible class name for PsiElements with text like "Foo\|Bar", "Foo|\Bar",
* "\Foo|\Bar" Cursor must have position in PsiElement
*
* @param psiElement the element context, cursor should be in it
* @param cursorOffset current cursor editor eg from completion context
* @param visitor callback on matching class
*/
public static void visitNamespaceClassForCompletion(
PsiElement psiElement, int cursorOffset, ClassForCompletionVisitor visitor) {
int cursorOffsetClean = cursorOffset - psiElement.getTextOffset();
if (cursorOffsetClean < 1) {
return;
}
String content = psiElement.getText();
int length = content.length();
if (!(length >= cursorOffsetClean)) {
return;
}
String beforeCursor = content.substring(0, cursorOffsetClean);
boolean isValid;
// espend\|Container, espend\Cont|ainer <- fallback to last full namespace
// espend|\Container <- only on known namespace "espend"
String namespace = beforeCursor;
// if no backslash or its equal in first position, fallback on namespace completion
int lastSlash = beforeCursor.lastIndexOf("\\");
if (lastSlash <= 0) {
isValid = PhpIndexUtil.hasNamespace(psiElement.getProject(), beforeCursor);
} else {
isValid = true;
namespace = beforeCursor.substring(0, lastSlash);
}
if (!isValid) {
return;
}
// format namespaces and add prefix for fluent completion
String prefix = "";
if (namespace.startsWith("\\")) {
prefix = "\\";
} else {
namespace = "\\" + namespace;
}
// search classes in current namespace and child namespaces
for (PhpClass phpClass :
PhpIndexUtil.getPhpClassInsideNamespace(psiElement.getProject(), namespace)) {
String presentableFQN = phpClass.getPresentableFQN();
if (presentableFQN != null
&& fr.adrienbrault.idea.symfony2plugin.util.StringUtils.startWithEqualClassname(
presentableFQN, beforeCursor)) {
visitor.visit(phpClass, presentableFQN, prefix);
}
}
}
@NotNull
public Collection<PsiElement> findTestsForClass(@NotNull PsiElement element) {
PsiClass klass = findSourceElement(element);
if (klass == null) return Collections.emptySet();
GlobalSearchScope scope;
Module module = getModule(element);
if (module != null) {
scope = GlobalSearchScope.moduleWithDependentsScope(module);
} else {
scope = GlobalSearchScope.projectScope(element.getProject());
}
PsiShortNamesCache cache = JavaPsiFacade.getInstance(element.getProject()).getShortNamesCache();
String klassName = klass.getName();
Pattern pattern = Pattern.compile(".*" + klassName + ".*");
List<Pair<PsiClass, Integer>> classesWithProximities = new ArrayList<Pair<PsiClass, Integer>>();
HashSet<String> names = new HashSet<String>();
cache.getAllClassNames(names);
for (String eachName : names) {
if (pattern.matcher(eachName).matches()) {
for (PsiClass eachClass : cache.getClassesByName(eachName, scope)) {
if (TestUtil.isTestClass(eachClass)) {
classesWithProximities.add(
new Pair<PsiClass, Integer>(eachClass, calcTestNameProximity(klassName, eachName)));
}
}
}
}
Collections.sort(
classesWithProximities,
new Comparator<Pair<PsiClass, Integer>>() {
public int compare(Pair<PsiClass, Integer> o1, Pair<PsiClass, Integer> o2) {
int result = o1.second.compareTo(o2.second);
if (result == 0) {
result = o1.first.getName().compareTo(o2.first.getName());
}
return result;
}
});
List<PsiElement> result = new ArrayList<PsiElement>();
for (Pair<PsiClass, Integer> each : classesWithProximities) {
result.add(each.first);
}
return result;
}
public KotlinPrimaryConstructorParameterTableModel(
KotlinMethodDescriptor methodDescriptor,
PsiElement typeContext,
PsiElement defaultValueContext) {
super(
methodDescriptor,
typeContext,
defaultValueContext,
new ValVarColumn(),
new NameColumn(typeContext.getProject()),
new TypeColumn(typeContext.getProject(), KotlinFileType.INSTANCE),
new DefaultValueColumn<
KotlinParameterInfo, ParameterTableModelItemBase<KotlinParameterInfo>>(
typeContext.getProject(), KotlinFileType.INSTANCE));
}
private void fixReferencesToStatic(PsiElement classMember) throws IncorrectOperationException {
final StaticReferencesCollector collector = new StaticReferencesCollector();
classMember.accept(collector);
ArrayList<PsiJavaCodeReferenceElement> refs = collector.getReferences();
ArrayList<PsiElement> members = collector.getReferees();
ArrayList<PsiClass> classes = collector.getRefereeClasses();
PsiElementFactory factory =
JavaPsiFacade.getInstance(classMember.getProject()).getElementFactory();
for (int i = 0; i < refs.size(); i++) {
PsiJavaCodeReferenceElement ref = refs.get(i);
PsiElement namedElement = members.get(i);
PsiClass aClass = classes.get(i);
if (namedElement instanceof PsiNamedElement) {
PsiReferenceExpression newRef =
(PsiReferenceExpression)
factory.createExpressionFromText(
"a." + ((PsiNamedElement) namedElement).getName(), null);
PsiExpression qualifierExpression = newRef.getQualifierExpression();
assert qualifierExpression != null;
qualifierExpression =
(PsiExpression) qualifierExpression.replace(factory.createReferenceExpression(aClass));
qualifierExpression.putCopyableUserData(PRESERVE_QUALIFIER, ref.isQualified());
ref.replace(newRef);
}
}
}
@NotNull
@Override
public Collection<PsiReference> findReferences(PsiElement element) {
assert element instanceof GrField;
ArrayList<PsiReference> refs = new ArrayList<>();
GrField field = (GrField) element;
GlobalSearchScope projectScope = GlobalSearchScope.projectScope(element.getProject());
PsiMethod setter = field.getSetter();
if (setter != null) {
refs.addAll(
RenameAliasedUsagesUtil.filterAliasedRefs(
MethodReferencesSearch.search(setter, projectScope, true).findAll(), setter));
}
GrAccessorMethod[] getters = field.getGetters();
for (GrAccessorMethod getter : getters) {
refs.addAll(
RenameAliasedUsagesUtil.filterAliasedRefs(
MethodReferencesSearch.search(getter, projectScope, true).findAll(), getter));
}
refs.addAll(
RenameAliasedUsagesUtil.filterAliasedRefs(
ReferencesSearch.search(field, projectScope, false).findAll(), field));
return refs;
}
private static void qualify(PsiMember member, PsiElement renamed, String name) {
if (!(renamed instanceof GrReferenceExpression)) return;
final PsiClass clazz = member.getContainingClass();
if (clazz == null) return;
final GrReferenceExpression refExpr = (GrReferenceExpression) renamed;
if (refExpr.getQualifierExpression() != null) return;
final PsiElement replaced;
if (member.hasModifierProperty(PsiModifier.STATIC)) {
final GrReferenceExpression newRefExpr =
GroovyPsiElementFactory.getInstance(member.getProject())
.createReferenceExpressionFromText(clazz.getQualifiedName() + "." + name);
replaced = refExpr.replace(newRefExpr);
} else {
final PsiClass containingClass = PsiTreeUtil.getParentOfType(renamed, PsiClass.class);
if (member.getManager().areElementsEquivalent(containingClass, clazz)) {
final GrReferenceExpression newRefExpr =
GroovyPsiElementFactory.getInstance(member.getProject())
.createReferenceExpressionFromText("this." + name);
replaced = refExpr.replace(newRefExpr);
} else {
final GrReferenceExpression newRefExpr =
GroovyPsiElementFactory.getInstance(member.getProject())
.createReferenceExpressionFromText(clazz.getQualifiedName() + ".this." + name);
replaced = refExpr.replace(newRefExpr);
}
}
JavaCodeStyleManager.getInstance(replaced.getProject()).shortenClassReferences(replaced);
}
@Override
public void apply(
@NotNull PsiElement startElement,
@NotNull PsiElement endElement,
@NotNull AndroidQuickfixContexts.Context context) {
PsiFile file = startElement.getContainingFile();
if (file instanceof XmlFile) {
ResourceFolderType folderType = ResourceHelper.getFolderType(file);
if (folderType != null) {
if (folderType != ResourceFolderType.VALUES) {
forkResourceFile((XmlFile) file, myFolder, true);
} else {
XmlTag tag =
getValueTag(PsiTreeUtil.getParentOfType(startElement, XmlTag.class, false));
if (tag != null) {
AndroidFacet facet = AndroidFacet.getInstance(startElement);
if (facet != null) {
PsiDirectory dir = null;
if (myFolder != null) {
PsiDirectory resFolder = findRes(file);
if (resFolder != null) {
dir = resFolder.findSubdirectory(myFolder);
if (dir == null) {
dir = resFolder.createSubdirectory(myFolder);
}
}
}
forkResourceValue(startElement.getProject(), tag, file, facet, dir);
}
}
}
}
}
}
@NotNull
private static String getPresentableElementPosition(
@NotNull final CodeInsightTestFixture fixture, final @Nullable PsiElement element) {
if (element == null) return "";
final StringBuilder buf = new StringBuilder(element.getText());
DartComponent component = PsiTreeUtil.getParentOfType(element, DartComponent.class);
while (component != null) {
final DartComponentName componentName = component.getComponentName();
if (componentName != null && componentName != element) {
buf.insert(0, component.getName() + " -> ");
}
component = PsiTreeUtil.getParentOfType(component, DartComponent.class);
}
String path =
element instanceof PsiDirectoryImpl
? ((PsiDirectoryImpl) element).getVirtualFile().getPath()
: element.getContainingFile().getVirtualFile().getPath();
final String contentRoot =
ModuleRootManager.getInstance(fixture.getModule()).getContentRoots()[0].getPath();
if (path.equals(contentRoot)) path = "[content root]";
final String contentRootWithSlash = contentRoot + "/";
if (path.startsWith(contentRootWithSlash)) path = path.substring(contentRootWithSlash.length());
final DartSdk sdk = DartSdk.getDartSdk(element.getProject());
if (sdk != null && path.startsWith(sdk.getHomePath()))
path = "[Dart SDK]" + path.substring(sdk.getHomePath().length());
if (buf.length() > 0) buf.insert(0, " -> ");
buf.insert(0, path);
return buf.toString();
}
@NotNull
private static PyExpression invertExpression(@NotNull final PsiElement expression) {
final PyElementGenerator elementGenerator =
PyElementGenerator.getInstance(expression.getProject());
if (expression instanceof PyBoolLiteralExpression) {
final String value =
((PyBoolLiteralExpression) expression).getValue() ? PyNames.FALSE : PyNames.TRUE;
return elementGenerator.createExpressionFromText(LanguageLevel.forElement(expression), value);
}
if (expression instanceof PyReferenceExpression
&& (PyNames.FALSE.equals(expression.getText())
|| PyNames.TRUE.equals(expression.getText()))) {
final String value = PyNames.TRUE.equals(expression.getText()) ? PyNames.FALSE : PyNames.TRUE;
return elementGenerator.createExpressionFromText(LanguageLevel.forElement(expression), value);
} else if (expression instanceof PyPrefixExpression) {
if (((PyPrefixExpression) expression).getOperator() == PyTokenTypes.NOT_KEYWORD) {
final PyExpression operand = ((PyPrefixExpression) expression).getOperand();
if (operand != null)
return elementGenerator.createExpressionFromText(
LanguageLevel.forElement(expression), operand.getText());
}
}
return elementGenerator.createExpressionFromText(
LanguageLevel.forElement(expression), "not " + expression.getText());
}
private void updateEditorText() {
disposeNonTextEditor();
final PsiElement elt = myElements[myIndex].getNavigationElement();
Project project = elt.getProject();
PsiFile psiFile = getContainingFile(elt);
final VirtualFile vFile = psiFile.getVirtualFile();
if (vFile == null) return;
final FileEditorProvider[] providers =
FileEditorProviderManager.getInstance().getProviders(project, vFile);
for (FileEditorProvider provider : providers) {
if (provider instanceof TextEditorProvider) {
updateTextElement(elt);
myBinarySwitch.show(myViewingPanel, TEXT_PAGE_KEY);
break;
} else if (provider.accept(project, vFile)) {
myCurrentNonTextEditorProvider = provider;
myNonTextEditor = myCurrentNonTextEditorProvider.createEditor(project, vFile);
myBinaryPanel.removeAll();
myBinaryPanel.add(myNonTextEditor.getComponent());
myBinarySwitch.show(myViewingPanel, BINARY_PAGE_KEY);
break;
}
}
}
@NotNull
@Override
public Collection<PsiReference> findReferences(final PsiElement element) {
if (element instanceof GrField) {
ArrayList<PsiReference> refs = new ArrayList<PsiReference>();
GrField field = (GrField) element;
PsiMethod setter = GroovyPropertyUtils.findSetterForField(field);
GlobalSearchScope projectScope = GlobalSearchScope.projectScope(element.getProject());
if (setter != null && setter instanceof GrAccessorMethod) {
refs.addAll(
RenameAliasedUsagesUtil.filterAliasedRefs(
MethodReferencesSearch.search(setter, projectScope, true).findAll(), setter));
}
GrAccessorMethod[] getters = field.getGetters();
for (GrAccessorMethod getter : getters) {
refs.addAll(
RenameAliasedUsagesUtil.filterAliasedRefs(
MethodReferencesSearch.search(getter, projectScope, true).findAll(), getter));
}
refs.addAll(
RenameAliasedUsagesUtil.filterAliasedRefs(
ReferencesSearch.search(field, projectScope, true).findAll(), field));
return refs;
}
return super.findReferences(element);
}
public AddModuleDependencyFix(
Module currentModule, VirtualFile classVFile, PsiClass[] classes, PsiReference reference) {
final PsiElement psiElement = reference.getElement();
final Project project = psiElement.getProject();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
for (PsiClass aClass : classes) {
if (!facade.getResolveHelper().isAccessible(aClass, psiElement, aClass)) continue;
PsiFile psiFile = aClass.getContainingFile();
if (psiFile == null) continue;
VirtualFile virtualFile = psiFile.getVirtualFile();
if (virtualFile == null) continue;
final Module classModule = fileIndex.getModuleForFile(virtualFile);
if (classModule != null
&& classModule != currentModule
&& !ModuleRootManager.getInstance(currentModule).isDependsOn(classModule)) {
myModules.add(classModule);
}
}
myCurrentModule = currentModule;
myClassVFile = classVFile;
myClasses = classes;
myReference = reference;
}
@Nullable
public static PsiReferenceExpression createMockReference(
final PsiElement place, @NotNull PsiType qualifierType, LookupElement qualifierItem) {
PsiElementFactory factory = JavaPsiFacade.getElementFactory(place.getProject());
if (qualifierItem.getObject() instanceof PsiClass) {
final String qname = ((PsiClass) qualifierItem.getObject()).getQualifiedName();
if (qname == null) return null;
final String text = qname + ".xxx";
try {
final PsiExpression expr = factory.createExpressionFromText(text, place);
if (expr instanceof PsiReferenceExpression) {
return (PsiReferenceExpression) expr;
}
return null; // ignore ill-formed qualified names like "org.spark-project.jetty" that can't
// be used from Java code anyway
} catch (IncorrectOperationException e) {
LOG.info(e);
return null;
}
}
return (PsiReferenceExpression)
factory.createExpressionFromText(
"xxx.xxx", JavaCompletionUtil.createContextWithXxxVariable(place, qualifierType));
}
@Override
protected void addCompletions(
@NotNull CompletionParameters completionParameters,
ProcessingContext processingContext,
@NotNull CompletionResultSet completionResultSet) {
PsiElement position = completionParameters.getPosition();
if (!Symfony2ProjectComponent.isEnabled(position)) {
return;
}
YAMLCompoundValue yamlCompoundValue =
PsiTreeUtil.getParentOfType(position, YAMLCompoundValue.class);
if (yamlCompoundValue == null) {
return;
}
String className =
YamlHelper.getYamlKeyValueAsString(yamlCompoundValue, "targetEntity", false);
if (className == null) {
return;
}
PhpClass phpClass = PhpElementsUtil.getClass(position.getProject(), className);
if (phpClass == null) {
return;
}
for (DoctrineModelField field : EntityHelper.getModelFields(phpClass)) {
if (field.getRelation() != null) {
completionResultSet.addElement(new DoctrineModelFieldLookupElement(field));
}
}
}
@Override
protected void addCompletions(
@NotNull CompletionParameters completionParameters,
ProcessingContext processingContext,
@NotNull CompletionResultSet completionResultSet) {
if (!Symfony2ProjectComponent.isEnabled(completionParameters.getPosition())) {
return;
}
PsiElement psiElement = completionParameters.getPosition();
YAMLCompoundValue yamlCompoundValue =
PsiTreeUtil.getParentOfType(psiElement, YAMLCompoundValue.class);
if (yamlCompoundValue == null) {
return;
}
yamlCompoundValue = PsiTreeUtil.getParentOfType(yamlCompoundValue, YAMLCompoundValue.class);
if (yamlCompoundValue == null) {
return;
}
String value = YamlHelper.getYamlKeyValueAsString(yamlCompoundValue, "class", true);
if (value != null) {
PhpClass phpClass = ServiceUtil.getResolvedClassDefinition(psiElement.getProject(), value);
if (phpClass != null) {
FormUtil.attachFormAliasesCompletions(phpClass, completionResultSet);
}
}
}
@Override
protected void addCompletions(
@NotNull CompletionParameters parameters,
ProcessingContext processingContext,
@NotNull CompletionResultSet completionResultSet) {
PsiElement position = parameters.getPosition();
if (!Symfony2ProjectComponent.isEnabled(position)) {
return;
}
PsiElement prevSiblingOfType =
PsiElementUtils.getPrevSiblingOfType(
position, YamlElementPatternHelper.getPreviousCommaSibling());
if (prevSiblingOfType == null) {
return;
}
String service = PsiElementUtils.trimQuote(prevSiblingOfType.getText());
if (StringUtils.isBlank(service)) {
return;
}
PhpClass phpClass = ServiceUtil.getServiceClass(prevSiblingOfType.getProject(), service);
if (phpClass == null) {
return;
}
for (Method method : phpClass.getMethods()) {
if (method.getAccess().isPublic() && !(method.getName().startsWith("__"))) {
completionResultSet.addElement(new PhpLookupElement(method));
}
}
}
@Nullable
@Override
public InspectionToolWrapper getEnabledTool(
@Nullable PsiElement element, boolean includeDoNotShow) {
if (!myEnabled) return null;
if (myTools != null && element != null) {
final Project project = element.getProject();
final DependencyValidationManager manager = DependencyValidationManager.getInstance(project);
for (ScopeToolState state : myTools) {
final NamedScope scope = state.getScope(project);
if (scope != null) {
final PackageSet set = scope.getValue();
if (set != null && set.contains(element.getContainingFile(), manager)) {
return state.isEnabled()
&& (includeDoNotShow
|| !HighlightDisplayLevel.DO_NOT_SHOW.equals(state.getLevel()))
? state.getTool()
: null;
}
}
}
}
return myDefaultState.isEnabled()
&& (includeDoNotShow
|| !HighlightDisplayLevel.DO_NOT_SHOW.equals(myDefaultState.getLevel()))
? myDefaultState.getTool()
: null;
}
public TextRange getTextRangeForNavigation() {
TextRange textRange = getTextRange();
if (textRange == null) return null;
PsiElement element = getPsiElement();
return InjectedLanguageManager.getInstance(element.getProject())
.injectedToHost(element, textRange);
}
public void addCompletions(
@NotNull CompletionParameters parameters,
ProcessingContext context,
@NotNull CompletionResultSet resultSet) {
PsiElement element = parameters.getPosition().getParent();
Project project = element.getProject();
if (!SilexProjectComponent.isEnabled(project)) {
return;
}
if (!(element instanceof StringLiteralExpression)) {
return;
}
Container container =
Utils.findContainerForFirstParameterOfPimpleMethod((StringLiteralExpression) element);
if (container == null) {
return;
}
for (Service service : container.getServices().values()) {
resultSet.addElement(new ServiceLookupElement(service, project));
}
for (Parameter parameter : container.getParameters().values()) {
resultSet.addElement(new ParameterLookupElement(parameter));
}
resultSet.stopHere();
}
@Nullable
public static MavenProject findContainingProject(@NotNull PsiElement element) {
VirtualFile file = getVirtualFile(element);
if (file == null) return null;
MavenProjectsManager manager = MavenProjectsManager.getInstance(element.getProject());
return manager.findContainingProject(file);
}
@Override
public boolean canFindUsages(final PsiElement element) {
Project _project = element.getProject();
FindUsagesHandlerFactory[] delegates =
Extensions.<FindUsagesHandlerFactory>getExtensions(
FindUsagesHandlerFactory.EP_NAME, _project);
for (final FindUsagesHandlerFactory delegate : delegates) {
if ((delegate != this)) {
try {
boolean _canFindUsages = delegate.canFindUsages(element);
if (_canFindUsages) {
return true;
}
} catch (final Throwable _t) {
if (_t instanceof IndexNotReadyException) {
final IndexNotReadyException e = (IndexNotReadyException) _t;
throw e;
} else if (_t instanceof ProcessCanceledException) {
final ProcessCanceledException e_1 = (ProcessCanceledException) _t;
throw e_1;
} else if (_t instanceof Exception) {
final Exception e_2 = (Exception) _t;
GeneratedSourceAwareUsagesHandlerFactory.LOG.error(e_2);
} else {
throw Exceptions.sneakyThrow(_t);
}
}
}
}
return false;
}
@NotNull
private static ControlFlow getControlFlow(@NotNull PsiElement context)
throws AnalysisCanceledException {
LocalsOrMyInstanceFieldsControlFlowPolicy policy =
LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance();
return ControlFlowFactory.getInstance(context.getProject()).getControlFlow(context, policy);
}
public void disableTool(@NotNull PsiElement element) {
final Project project = element.getProject();
final DependencyValidationManager validationManager =
DependencyValidationManager.getInstance(project);
if (myTools != null) {
for (ScopeToolState state : myTools) {
final NamedScope scope = state.getScope(project);
if (scope != null) {
final PackageSet packageSet = scope.getValue();
if (packageSet != null) {
final PsiFile file = element.getContainingFile();
if (file != null) {
if (packageSet.contains(file, validationManager)) {
state.setEnabled(false);
return;
}
} else {
if (packageSet instanceof PackageSetBase
&& ((PackageSetBase) packageSet)
.contains(PsiUtilCore.getVirtualFile(element), project, validationManager)) {
state.setEnabled(false);
return;
}
}
}
}
}
myDefaultState.setEnabled(false);
} else {
myDefaultState.setEnabled(false);
setEnabled(false);
}
}