@NotNull
public XPathType getExpectedType(XPathExpression expr) {
final XmlTag tag = PsiTreeUtil.getContextOfType(expr, XmlTag.class, true);
if (tag != null && XsltSupport.isXsltTag(tag)) {
final XsltElement element =
XsltElementFactory.getInstance().wrapElement(tag, XsltElement.class);
if (element instanceof XsltVariable) {
return ((XsltVariable) element).getType();
} else {
final XmlAttribute attr = PsiTreeUtil.getContextOfType(expr, XmlAttribute.class, true);
if (attr != null) {
if (element instanceof XsltWithParam) {
final XmlAttribute nameAttr = tag.getAttribute("name", null);
if (nameAttr != null) {
final XmlAttributeValue valueElement = nameAttr.getValueElement();
if (valueElement != null) {
final PsiReference[] references = valueElement.getReferences();
for (PsiReference reference : references) {
final PsiElement psiElement = reference.resolve();
if (psiElement instanceof XsltVariable) {
return ((XsltVariable) psiElement).getType();
}
}
}
}
} else {
final String name = attr.getName();
return getTypeForTag(tag, name);
}
}
}
}
return XPathType.UNKNOWN;
}
protected XmlElement recomputeXmlElement(@NotNull final DomInvocationHandler parent) {
if (!parent.isValid()) return null;
final XmlTag tag = parent.getXmlTag();
if (tag == null) return null;
return tag.getAttribute(getXmlElementName(), getXmlApiCompatibleNamespace(parent));
}
private static void addMissingAttributes(XmlTag tag, List<Pair<String, String>> value) {
List<Pair<String, String>> attr2value = new ArrayList<Pair<String, String>>(value);
for (Iterator<Pair<String, String>> iterator = attr2value.iterator(); iterator.hasNext(); ) {
Pair<String, String> pair = iterator.next();
if (tag.getAttribute(pair.first) != null) {
iterator.remove();
}
}
addAttributesBefore(tag, attr2value);
}
private static boolean isHrefScripted(final XmlTag tag) {
final XmlAttribute attribute = tag.getAttribute(HREF_ATTR);
if (attribute != null) {
final XmlAttributeValue value = attribute.getValueElement();
if (value != null) {
if (PsiTreeUtil.getChildOfType(value, OuterLanguageElement.class) != null) {
return true;
}
}
}
return false;
}
@Nullable
private static String getAttributeValue(final XmlTag tag, final String attrName) {
final XmlAttribute attribute = tag.getAttribute(attrName);
if (attribute != null) {
final XmlAttributeValue value = attribute.getValueElement();
if (value != null) {
if (PsiTreeUtil.getChildOfType(value, OuterLanguageElement.class) == null) {
return value.getValue();
}
}
}
return null;
}
private static void collectDependencies(
@Nullable XmlTag myTag, @NotNull XmlFile myFile, @NotNull Set<PsiFile> visited) {
if (visited.contains(myFile)) return;
visited.add(myFile);
if (myTag == null) return;
XmlTag[] tags = myTag.getSubTags();
for (final XmlTag tag : tags) {
if (equalsToSchemaName(tag, INCLUDE_TAG_NAME) || equalsToSchemaName(tag, IMPORT_TAG_NAME)) {
final XmlAttribute schemaLocation = tag.getAttribute("schemaLocation", null);
if (schemaLocation != null) {
final XmlFile xmlFile =
XmlUtil.findNamespaceByLocation(myFile, schemaLocation.getValue());
addDependency(xmlFile, visited);
}
} else if (equalsToSchemaName(tag, REDEFINE_TAG_NAME)) {
myRedefinedDescriptorsInProcessing.set(visited);
try {
final XmlFile file = getRedefinedElementDescriptorFile(tag);
addDependency(file, visited);
} finally {
myRedefinedDescriptorsInProcessing.set(null);
}
}
}
final String schemaLocationDeclaration =
myTag.getAttributeValue("schemaLocation", XmlUtil.XML_SCHEMA_INSTANCE_URI);
if (schemaLocationDeclaration != null) {
final StringTokenizer tokenizer = new StringTokenizer(schemaLocationDeclaration);
while (tokenizer.hasMoreTokens()) {
final String uri = tokenizer.nextToken();
if (tokenizer.hasMoreTokens()) {
PsiFile resourceLocation =
ExternalResourceManager.getInstance()
.getResourceLocation(tokenizer.nextToken(), myFile, null);
if (resourceLocation == null && uri != null)
resourceLocation =
ExternalResourceManager.getInstance().getResourceLocation(uri, myFile, null);
if (resourceLocation instanceof XmlFile)
addDependency((XmlFile) resourceLocation, visited);
}
}
}
}
private void checkRequiredAttributes(
XmlTag tag, String name, XmlElementDescriptor elementDescriptor) {
XmlAttributeDescriptor[] attributeDescriptors = elementDescriptor.getAttributesDescriptors(tag);
Set<String> requiredAttributes = null;
for (XmlAttributeDescriptor attribute : attributeDescriptors) {
if (attribute != null && attribute.isRequired()) {
if (requiredAttributes == null) {
requiredAttributes = new HashSet<String>();
}
requiredAttributes.add(attribute.getName(tag));
}
}
if (requiredAttributes != null) {
for (final String attrName : requiredAttributes) {
if (tag.getAttribute(attrName, "") == null
&& !XmlExtension.getExtension(tag.getContainingFile())
.isRequiredAttributeImplicitlyPresent(tag, attrName)) {
final InsertRequiredAttributeFix insertRequiredAttributeIntention =
new InsertRequiredAttributeFix(tag, attrName, null);
final String localizedMessage =
XmlErrorMessages.message("element.doesnt.have.required.attribute", name, attrName);
final InspectionProfile profile =
InspectionProjectProfileManager.getInstance(tag.getProject()).getInspectionProfile();
final LocalInspectionToolWrapper toolWrapper =
(LocalInspectionToolWrapper)
profile.getInspectionTool(RequiredAttributesInspection.SHORT_NAME, tag);
if (toolWrapper != null) {
RequiredAttributesInspection inspection =
(RequiredAttributesInspection) toolWrapper.getTool();
reportOneTagProblem(
tag,
attrName,
localizedMessage,
insertRequiredAttributeIntention,
HighlightDisplayKey.find(RequiredAttributesInspection.SHORT_NAME),
inspection,
XmlEntitiesInspection.NOT_REQUIRED_ATTRIBUTE);
}
}
}
}
}
public static XmlFile getRedefinedElementDescriptorFile(final XmlTag parentTag) {
final String schemaL = parentTag.getAttributeValue(XmlUtil.SCHEMA_LOCATION_ATT);
if (schemaL != null) {
final PsiReference[] references =
parentTag
.getAttribute(XmlUtil.SCHEMA_LOCATION_ATT, null)
.getValueElement()
.getReferences();
if (references.length > 0) {
final PsiElement psiElement = references[references.length - 1].resolve();
if (psiElement instanceof XmlFile) {
return ((XmlFile) psiElement);
}
}
}
return null;
}
@Nullable
public String getInstalledPluginNameByPath(Project project, @NotNull VirtualFile pluginPath) {
VirtualFile pluginXml = pluginPath.findChild("plugin.xml");
if (pluginXml == null) return null;
PsiFile pluginXmlPsi = PsiManager.getInstance(project).findFile(pluginXml);
if (!(pluginXmlPsi instanceof XmlFile)) return null;
XmlTag rootTag = ((XmlFile) pluginXmlPsi).getRootTag();
if (rootTag == null || !"plugin".equals(rootTag.getName())) return null;
XmlAttribute attrName = rootTag.getAttribute("name");
if (attrName == null) return null;
String res = attrName.getValue();
if (res == null) return null;
res = res.trim();
if (res.length() == 0) return null;
return res;
}
@Nullable
private XmlAttributeDescriptor getAttributeImpl(
String localName, String namespace, Set<XmlTag> visited) {
if (myTag == null) return null;
XmlNSDescriptorImpl nsDescriptor = (XmlNSDescriptorImpl) myTag.getNSDescriptor(namespace, true);
if (nsDescriptor != this && nsDescriptor != null) {
return nsDescriptor.getAttributeImpl(localName, namespace, visited);
}
if (visited == null) visited = new HashSet<XmlTag>(1);
else if (visited.contains(myTag)) return null;
visited.add(myTag);
XmlTag[] tags = myTag.getSubTags();
for (XmlTag tag : tags) {
if (equalsToSchemaName(tag, ATTRIBUTE_TAG_NAME)) {
String name = tag.getAttributeValue("name");
if (name != null) {
if (checkElementNameEquivalence(localName, namespace, name, tag)) {
return createAttributeDescriptor(tag);
}
}
} else if (equalsToSchemaName(tag, INCLUDE_TAG_NAME)
|| (equalsToSchemaName(tag, IMPORT_TAG_NAME)
&& namespace.equals(tag.getAttributeValue("namespace")))) {
final XmlAttribute schemaLocation = tag.getAttribute("schemaLocation", null);
if (schemaLocation != null) {
final XmlFile xmlFile =
XmlUtil.findNamespaceByLocation(myTag.getContainingFile(), schemaLocation.getValue());
if (xmlFile != null) {
final XmlDocument includedDocument = xmlFile.getDocument();
if (includedDocument != null) {
final PsiMetaData data = includedDocument.getMetaData();
if (data instanceof XmlNSDescriptorImpl) {
final XmlAttributeDescriptor attributeDescriptor =
((XmlNSDescriptorImpl) data).getAttributeImpl(localName, namespace, visited);
if (attributeDescriptor != null) {
final CachedValue<XmlAttributeDescriptor> value =
CachedValuesManager.getManager(includedDocument.getProject())
.createCachedValue(
new CachedValueProvider<XmlAttributeDescriptor>() {
public Result<XmlAttributeDescriptor> compute() {
return new Result<XmlAttributeDescriptor>(
attributeDescriptor, attributeDescriptor.getDependences());
}
},
false);
return value.getValue();
}
}
}
}
}
}
}
return null;
}
@Nullable
public XmlElementDescriptor getElementDescriptor(
String localName, String namespace, Set<XmlNSDescriptorImpl> visited, boolean reference) {
if (visited.contains(this)) return null;
final QNameKey pair = new QNameKey(namespace, localName);
final CachedValue<XmlElementDescriptor> descriptor = myDescriptorsMap.get(pair);
if (descriptor != null) {
final XmlElementDescriptor value = descriptor.getValue();
if (value == null || value.getDeclaration().isValid()) return value;
}
final XmlTag rootTag = myTag;
if (rootTag == null) return null;
XmlTag[] tags = rootTag.getSubTags();
visited.add(this);
for (final XmlTag tag : tags) {
if (equalsToSchemaName(tag, ELEMENT_TAG_NAME)) {
String name = tag.getAttributeValue("name");
if (name != null) {
if (checkElementNameEquivalence(localName, namespace, name, tag)) {
final CachedValue<XmlElementDescriptor> cachedValue =
CachedValuesManager.getManager(tag.getProject())
.createCachedValue(
new CachedValueProvider<XmlElementDescriptor>() {
public Result<XmlElementDescriptor> compute() {
final String name = tag.getAttributeValue("name");
if (name != null && !name.equals(pair.second)) {
myDescriptorsMap.remove(pair);
return new Result<XmlElementDescriptor>(null);
}
final XmlElementDescriptor xmlElementDescriptor =
createElementDescriptor(tag);
return new Result<XmlElementDescriptor>(
xmlElementDescriptor, xmlElementDescriptor.getDependences());
}
},
false);
myDescriptorsMap.put(pair, cachedValue);
return cachedValue.getValue();
}
}
} else if (equalsToSchemaName(tag, INCLUDE_TAG_NAME)
|| (reference
&& equalsToSchemaName(tag, IMPORT_TAG_NAME)
&& (namespace.equals(tag.getAttributeValue("namespace"))
|| namespace.length() == 0 && tag.getAttributeValue("namespace") == null))) {
final XmlAttribute schemaLocation = tag.getAttribute("schemaLocation", null);
if (schemaLocation != null) {
final XmlFile xmlFile =
XmlUtil.findNamespaceByLocation(
rootTag.getContainingFile(), schemaLocation.getValue());
if (xmlFile != null) {
final XmlDocument includedDocument = xmlFile.getDocument();
if (includedDocument != null) {
final PsiMetaData data = includedDocument.getMetaData();
if (data instanceof XmlNSDescriptorImpl) {
final XmlElementDescriptor elementDescriptor =
((XmlNSDescriptorImpl) data)
.getElementDescriptor(localName, namespace, visited, reference);
if (elementDescriptor != null) {
// final CachedValue<XmlElementDescriptor> value =
// includedDocument.getManager().getCachedValuesManager()
// .createCachedValue(new CachedValueProvider<XmlElementDescriptor>() {
// public Result<XmlElementDescriptor> compute() {
// return new Result<XmlElementDescriptor>(elementDescriptor,
// elementDescriptor.getDependences());
// }
// }, false);
// return value.getValue();
return elementDescriptor;
}
}
}
}
}
} else if (equalsToSchemaName(tag, REDEFINE_TAG_NAME)) {
final XmlNSDescriptorImpl nsDescriptor = getRedefinedElementDescriptor(tag);
if (nsDescriptor != null) {
final XmlElementDescriptor xmlElementDescriptor =
nsDescriptor.getElementDescriptor(localName, namespace, visited, reference);
if (xmlElementDescriptor != null) return xmlElementDescriptor;
}
}
}
return null;
}
public void visitXmlTag(XmlTag tag) {
final PsiFile file = tag.getContainingFile();
if (file.getFileType() != StdFileTypes.XML) {
return;
}
if (!tag.getLocalName().equals("define")) {
return;
}
if (!tag.getNamespace().equals(ApplicationLoader.RNG_NAMESPACE)) {
return;
}
if (tag.getAttribute("combine") != null) {
return; // ?
}
final XmlAttribute attr = tag.getAttribute("name");
if (attr == null) return;
final XmlAttributeValue value = attr.getValueElement();
if (value == null) return;
final String s = value.getValue();
if (s == null || s.length() == 0) {
return;
}
final PsiElement parent = value.getParent();
if (!(parent instanceof XmlAttribute)) {
return;
}
if (!"name".equals(((XmlAttribute) parent).getName())) {
return;
}
final PsiElement grandParent = parent.getParent();
if (!(grandParent instanceof XmlTag)) {
return;
}
final DomElement element = DomManager.getDomManager(tag.getProject()).getDomElement(tag);
if (element == null) {
return;
}
final RngGrammar rngGrammar = element.getParentOfType(RngGrammar.class, true);
if (rngGrammar != null) {
if (processUsages(tag, value, new LocalSearchScope(rngGrammar.getXmlTag()))) return;
} else {
if (processUsages(tag, value, new LocalSearchScope(file))) return;
}
final PsiElementProcessor.CollectElements<XmlFile> collector =
new PsiElementProcessor.CollectElements<XmlFile>();
RelaxIncludeIndex.processBackwardDependencies((XmlFile) file, collector);
if (processUsages(tag, value, new LocalSearchScope(collector.toArray()))) return;
myHolder.registerProblem(
value,
"Unreferenced define",
ProblemHighlightType.LIKE_UNUSED_SYMBOL,
new MyFix<XmlTag>(tag));
}
