IDEA-60895 No completion for enumerated and boolean values of xml tags

platform/core-api/src/com/intellij/psi/ElementManipulators.java

@@ -60,6 +60,7 @@ public class ElementManipulators extends ClassExtension<ElementManipulator> {
     return manipulator == null ? TextRange.from(0, element.getTextLength()) : manipulator.getRangeInElement(element);
   }
 
+  @NotNull
   public static String getValueText(final PsiElement element) {
     final TextRange valueTextRange = getValueTextRange(element);
     if (valueTextRange.isEmpty()) return "";

plugins/javaFX/src/org/jetbrains/plugins/javaFX/fxml/descriptors/JavaFxPropertyAttributeDescriptor.java

@@ -8,6 +8,7 @@ import com.intellij.util.ArrayUtil;
 import com.intellij.xml.XmlAttributeDescriptor;
 import com.intellij.xml.XmlElementDescriptor;
 import com.intellij.xml.impl.BasicXmlAttributeDescriptor;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.javaFX.fxml.FxmlConstants;
 import org.jetbrains.plugins.javaFX.fxml.JavaFxCommonClassNames;
@@ -209,9 +210,8 @@ public class JavaFxPropertyAttributeDescriptor extends BasicXmlAttributeDescript
   }
 
   @Override
-  public PsiReference[] getValueReferences(XmlAttributeValue value) {
-    String s = value.getValue();
-    return s != null && !s.startsWith("${") ? super.getValueReferences(value) : PsiReference.EMPTY_ARRAY;
+  public PsiReference[] getValueReferences(XmlElement element, @NotNull String text) {
+    return !text.startsWith("${") ? super.getValueReferences(element, text) : PsiReference.EMPTY_ARRAY;
   }
 
   @Override

xml/impl/src/com/intellij/xml/util/XmlEnumeratedValueReferenceProvider.java

@@ -17,15 +17,11 @@ package com.intellij.xml.util;
 
 import com.intellij.codeInsight.daemon.impl.analysis.XmlHighlightVisitor;
 import com.intellij.openapi.util.Key;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiLanguageInjectionHost;
-import com.intellij.psi.PsiReference;
-import com.intellij.psi.PsiReferenceProvider;
+import com.intellij.psi.*;
 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
-import com.intellij.psi.xml.XmlAttribute;
-import com.intellij.psi.xml.XmlAttributeValue;
+import com.intellij.psi.xml.*;
+import com.intellij.util.ArrayUtil;
 import com.intellij.util.ProcessingContext;
-import com.intellij.xml.XmlAttributeDescriptor;
 import com.intellij.xml.impl.XmlEnumerationDescriptor;
 import com.intellij.xml.impl.schema.XmlSchemaTagsProcessor;
 import org.jetbrains.annotations.NotNull;
@@ -34,7 +30,7 @@ import org.jetbrains.annotations.NotNull;
  * @author Dmitry Avdeev
  *         Date: 15.08.13
  */
-public class XmlEnumeratedValueReferenceProvider extends PsiReferenceProvider {
+public class XmlEnumeratedValueReferenceProvider<T extends PsiElement> extends PsiReferenceProvider {
 
   public final static Key<Boolean> SUPPRESS = Key.create("suppress attribute value references");
 
@@ -45,22 +41,49 @@ public class XmlEnumeratedValueReferenceProvider extends PsiReferenceProvider {
     if (XmlSchemaTagsProcessor.PROCESSING_FLAG.get() != null || context.get(SUPPRESS) != null) {
       return PsiReference.EMPTY_ARRAY;
     }
-    XmlAttributeValue value = (XmlAttributeValue)element;
-    if (value instanceof PsiLanguageInjectionHost && InjectedLanguageUtil.hasInjections((PsiLanguageInjectionHost)value)) {
+    @SuppressWarnings("unchecked") PsiElement host = getHost((T)element);
+    if (host instanceof PsiLanguageInjectionHost && InjectedLanguageUtil.hasInjections((PsiLanguageInjectionHost)host)) {
       return PsiReference.EMPTY_ARRAY;
     }
-    String unquotedValue = value.getValue();
-    if (unquotedValue == null || XmlHighlightVisitor.skipValidation(value) || !XmlUtil.isSimpleXmlAttributeValue(unquotedValue, value)) {
+    String unquotedValue = ElementManipulators.getValueText(element);
+    if (XmlHighlightVisitor.skipValidation(element) || !XmlUtil.isSimpleValue(unquotedValue, element)) {
       return PsiReference.EMPTY_ARRAY;
     }
-    PsiElement parent = value.getParent();
-    if (parent instanceof XmlAttribute) {
-      final XmlAttributeDescriptor descriptor = ((XmlAttribute)parent).getDescriptor();
-      if (descriptor instanceof XmlEnumerationDescriptor &&
-          (descriptor.isFixed() || descriptor.isEnumerated() || unquotedValue.equals(descriptor.getDefaultValue()))) { // todo case insensitive
-        return ((XmlEnumerationDescriptor)descriptor).getValueReferences(value);
+    @SuppressWarnings("unchecked") final Object descriptor = getDescriptor((T)element);
+    if (descriptor instanceof XmlEnumerationDescriptor) {
+      XmlEnumerationDescriptor enumerationDescriptor = (XmlEnumerationDescriptor)descriptor;
+      if (enumerationDescriptor.isFixed() ||
+          enumerationDescriptor.isEnumerated((XmlElement)element) ||
+          unquotedValue.equals(enumerationDescriptor.getDefaultValue())) { // todo case insensitive
+        //noinspection unchecked
+        return enumerationDescriptor.getValueReferences((XmlElement)element, unquotedValue);
       }
     }
     return PsiReference.EMPTY_ARRAY;
   }
+
+  protected PsiElement getHost(T element) {
+    return element;
+  }
+
+  protected Object getDescriptor(T element) {
+    PsiElement parent = element.getParent();
+    return parent instanceof XmlAttribute ? ((XmlAttribute)parent).getDescriptor() : null;
+  }
+
+  public static XmlEnumeratedValueReferenceProvider forTags() {
+    return new XmlEnumeratedValueReferenceProvider<XmlTag>() {
+
+      @Override
+      protected Object getDescriptor(XmlTag element) {
+        return element.getDescriptor();
+      }
+
+      @Override
+      protected PsiElement getHost(XmlTag element) {
+        XmlText[] textElements = element.getValue().getTextElements();
+        return ArrayUtil.getFirstElement(textElements);
+      }
+    };
+  }
 }

xml/impl/src/com/intellij/xml/util/XmlInvalidIdInspection.java

@@ -40,7 +40,7 @@ public class XmlInvalidIdInspection extends XmlDuplicatedIdInspection {
       idRef = idRef.toLowerCase();
     }
 
-    if (XmlUtil.isSimpleXmlAttributeValue(idRef, value) && refHolder.isIdReferenceValue(value)) {
+    if (XmlUtil.isSimpleValue(idRef, value) && refHolder.isIdReferenceValue(value)) {
       boolean hasIdDeclaration = refHolder.hasIdDeclaration(idRef);
       if (!hasIdDeclaration && tag instanceof HtmlTag) {
         hasIdDeclaration = refHolder.hasIdDeclaration(value.getValue());

xml/impl/src/com/intellij/xml/util/XmlRefCountHolder.java

@@ -266,7 +266,7 @@ public class XmlRefCountHolder {
 
     private void updateMap(@NotNull final XmlAttribute attribute, @NotNull final XmlAttributeValue value, final boolean soft) {
       final String id = XmlHighlightVisitor.getUnquotedValue(value, attribute.getParent());
-      if (XmlUtil.isSimpleXmlAttributeValue(id, value) &&
+      if (XmlUtil.isSimpleValue(id, value) &&
           PsiTreeUtil.getChildOfType(value, OuterLanguageElement.class) == null) {
         myHolder.registerId(id, value, soft);
       }

xml/impl/src/com/intellij/xml/util/XmlReferenceContributor.java

@@ -90,5 +90,6 @@ public class XmlReferenceContributor extends PsiReferenceContributor {
 
     registrar.registerReferenceProvider(xmlAttributeValue(), new XmlPrefixReferenceProvider());
     registrar.registerReferenceProvider(xmlAttributeValue(), new XmlEnumeratedValueReferenceProvider(), PsiReferenceRegistrar.LOWER_PRIORITY);
+    registrar.registerReferenceProvider(xmlTag(), XmlEnumeratedValueReferenceProvider.forTags(), PsiReferenceRegistrar.LOWER_PRIORITY);
   }
 }

xml/relaxng/src/org/intellij/plugins/relaxNG/model/descriptors/RngXmlAttributeDescriptor.java

@@ -21,7 +21,6 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiReference;
 import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.xml.XmlAttributeValue;
 import com.intellij.psi.xml.XmlElement;
 import com.intellij.psi.xml.XmlTag;
 import com.intellij.util.ArrayUtil;
@@ -32,6 +31,7 @@ import com.intellij.xml.util.XmlEnumeratedValueReference;
 import gnu.trove.THashSet;
 import gnu.trove.TObjectHashingStrategy;
 import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.kohsuke.rngom.digested.DAttributePattern;
 import org.xml.sax.Locator;
@@ -206,10 +206,8 @@ public class RngXmlAttributeDescriptor extends BasicXmlAttributeDescriptor {
   }
 
   @Override
-  public PsiReference[] getValueReferences(final XmlAttributeValue value) {
-    String text = value.getValue();
-    if (text == null) return PsiReference.EMPTY_ARRAY;
-    return new PsiReference[] { new XmlEnumeratedValueReference(value, this) {
+  public PsiReference[] getValueReferences(final XmlElement element, @NotNull String text) {
+    return new PsiReference[] { new XmlEnumeratedValueReference(element, this) {
       @Nullable
       @Override
       public PsiElement resolve() {

xml/tests/src/com/intellij/codeInsight/completion/XmlCompletionTest.java

@@ -670,5 +670,11 @@ public class XmlCompletionTest extends LightCodeInsightFixtureTestCase {
     myFixture.configureByFiles("Substitute/schema-a.xsd", "Substitute/schema-b.xsd");
     myFixture.testCompletionVariants("Substitute/test.xml", "b:instance", "instance");
   }
+
+  public void testEnumeratedTagValue() throws Exception {
+    myFixture.configureByFile("tagValue/enumerated.xsd");
+    myFixture.testCompletionVariants("tagValue/completeEnum.xml", "none", "standard");
+    myFixture.testCompletionVariants("tagValue/completeBoolean.xml", "false", "true");
+  }
 }
 

xml/tests/testData/completion/tagValue/completeBoolean.xml

@@ -0,0 +1 @@
+<bar xmlns="foo.bar"><caret></bar>

xml/tests/testData/completion/tagValue/completeEnum.xml

@@ -0,0 +1 @@
+<foo xmlns="foo.bar"><caret></foo>

xml/tests/testData/completion/tagValue/enumerated.xsd

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified"
+        targetNamespace="foo.bar">
+    <xs:element name="foo">
+        <xs:simpleType>
+          <xs:restriction base="xs:string">
+            <xs:enumeration value="none"/>
+            <xs:enumeration value="standard"/>
+          </xs:restriction>
+        </xs:simpleType>
+    </xs:element>
+
+    <xs:element name="bar" type="xs:boolean"/>
+    
+    <xs:element name="def" type="xs:string" default="my default"/>
+</xs:schema>

xml/xml-psi-impl/resources/messages/XmlErrorMessages.properties

@@ -20,7 +20,7 @@ duplicate.id.reference=Duplicate id reference
 invalid.id.reference=Invalid id reference
 uri.is.not.registered=URI is not registered (Settings | Project Settings | Schemas and DTDs)
 registered.resource.is.not.recognized=Resource registered by this uri is not recognized (Settings | Project Settings | Schemas and DTDs)
-attribute.should.have.fixed.value=Attribute should have fixed value {0}
+should.have.fixed.value={0} should have fixed value {1}
 
 #quickfixes
 insert.required.attribute.quickfix.text=Insert Required Attribute {0}
@@ -44,7 +44,7 @@ tag.start.is.not.closed=Tag start is not closed
 unescaped.ampersand.or.nonterminated.character.entity.reference=Unescaped \\& or nonterminated character/entity reference
 expected.prologue.tag.termination.expected='?>' expected
 expected.whitespace=Whitespace expected
-wrong.attribute.value=Wrong attribute value
+wrong.value=Wrong {0} value
 way.too.unbalanced=Way too unbalanced. Stopping attempt to balance tags properly at this point
 
 cannot.resolve.taglib.uri=Cannot resolve taglib with uri {0}

xml/xml-psi-impl/src/com/intellij/xml/impl/BasicXmlAttributeDescriptor.java

@@ -44,6 +44,11 @@ public abstract class BasicXmlAttributeDescriptor extends XmlEnumerationDescript
     return getEnumeratedValues();
   }
 
+  @Override
+  public boolean isEnumerated(XmlElement context) {
+    return isEnumerated();
+  }
+
   @Override
   public String toString() {
     return getName();

xml/xml-psi-impl/src/com/intellij/xml/impl/XmlEnumerationDescriptor.java

@@ -3,20 +3,23 @@ package com.intellij.xml.impl;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiReference;
-import com.intellij.psi.xml.XmlAttributeValue;
 import com.intellij.psi.xml.XmlElement;
 import com.intellij.xml.util.XmlEnumeratedValueReference;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * @author Dmitry Avdeev
  *         Date: 22.08.13
  */
-public abstract class XmlEnumerationDescriptor {
+public abstract class XmlEnumerationDescriptor<T extends XmlElement> {
 
   public abstract boolean isFixed();
 
   public abstract String getDefaultValue();
 
+  public abstract boolean isEnumerated(@Nullable XmlElement context);
+
   public abstract String[] getEnumeratedValues();
 
   public PsiElement getValueDeclaration(XmlElement attributeValue, String value) {
@@ -31,8 +34,7 @@ public abstract class XmlEnumerationDescriptor {
 
   protected abstract PsiElement getDefaultValueDeclaration();
 
-  public PsiReference[] getValueReferences(XmlAttributeValue value) {
-    return new PsiReference[] { new XmlEnumeratedValueReference(value, this)};
+  public PsiReference[] getValueReferences(T element, @NotNull String text) {
+    return new PsiReference[] { new XmlEnumeratedValueReference(element, this)};
   }
-
 }

xml/xml-psi-impl/src/com/intellij/xml/impl/schema/XmlElementDescriptorImpl.java

@@ -16,14 +16,17 @@
 package com.intellij.xml.impl.schema;
 
 import com.intellij.codeInsight.daemon.Validator;
+import com.intellij.psi.ElementManipulators;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiReference;
 import com.intellij.psi.meta.PsiWritableMetaData;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.xml.*;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.IncorrectOperationException;
 import com.intellij.xml.*;
+import com.intellij.xml.util.XmlEnumeratedValueReference;
 import com.intellij.xml.util.XmlUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
@@ -36,7 +39,7 @@ import java.util.List;
 /**
  * @author Mike
  */
-public class XmlElementDescriptorImpl extends XsdEnumerationDescriptor
+public class XmlElementDescriptorImpl extends XsdEnumerationDescriptor<XmlTag>
   implements XmlElementDescriptor, PsiWritableMetaData, Validator<XmlTag>,
                                                  XmlElementDescriptorAwareAboutChildren {
   protected XmlTag myDescriptorTag;
@@ -473,8 +476,9 @@ public class XmlElementDescriptorImpl extends XsdEnumerationDescriptor
   }
 
   public String getQualifiedName() {
-    if (!"".equals(getNS())) {
-      return getNS() + ":" + getName();
+    String ns = getNS();
+    if (ns != null && !ns.isEmpty()) {
+      return ns + ":" + getName();
     }
 
     return getName();
@@ -519,6 +523,16 @@ public class XmlElementDescriptorImpl extends XsdEnumerationDescriptor
     }
   }
 
+  @Override
+  public PsiReference[] getValueReferences(XmlTag xmlTag, @NotNull String text) {
+    XmlTagValue value = xmlTag.getValue();
+    XmlText[] elements = value.getTextElements();
+    if (elements.length == 0 || xmlTag.getSubTags().length > 0) return PsiReference.EMPTY_ARRAY;
+    return new PsiReference[] {
+      new XmlEnumeratedValueReference(xmlTag, this, ElementManipulators.getValueTextRange(xmlTag))
+    };
+  }
+
   public boolean allowElementsFromNamespace(final String namespace, final XmlTag context) {
     final TypeDescriptor type = getType(context);
     

xml/xml-psi-impl/src/com/intellij/xml/impl/schema/XsdEnumerationDescriptor.java

@@ -21,7 +21,7 @@ import java.util.List;
  * @author Dmitry Avdeev
  *         Date: 22.08.13
  */
-public abstract class XsdEnumerationDescriptor extends XmlEnumerationDescriptor {
+public abstract class XsdEnumerationDescriptor<T extends XmlElement> extends XmlEnumerationDescriptor<T> {
 
   private boolean myExhaustiveEnum;
 
@@ -60,7 +60,7 @@ public abstract class XsdEnumerationDescriptor extends XmlEnumerationDescriptor
   }
 
   private boolean processEnumeration(XmlElement context, PairProcessor<PsiElement, String> processor) {
-    XmlTag contextTag = context != null ? PsiTreeUtil.getContextOfType(context, XmlTag.class, true) : null;
+    XmlTag contextTag = context != null ? PsiTreeUtil.getContextOfType(context, XmlTag.class, false) : null;
     final XmlElementDescriptorImpl elementDescriptor = (XmlElementDescriptorImpl)XmlUtil.findXmlDescriptorByType(getDeclaration(), contextTag);
 
     if (elementDescriptor!=null && elementDescriptor.getType() instanceof ComplexTypeDescriptor) {

xml/xml-psi-impl/src/com/intellij/xml/util/XmlEnumeratedValueReference.java

@@ -17,9 +17,12 @@ package com.intellij.xml.util;
 
 import com.intellij.codeInsight.daemon.EmptyResolveMessageProvider;
 import com.intellij.codeInsight.daemon.XmlErrorMessages;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiReferenceBase;
-import com.intellij.psi.xml.XmlAttributeValue;
+import com.intellij.psi.xml.XmlElement;
+import com.intellij.psi.xml.XmlTag;
 import com.intellij.util.ArrayUtil;
 import com.intellij.xml.impl.XmlEnumerationDescriptor;
 import org.jetbrains.annotations.NotNull;
@@ -29,14 +32,19 @@ import org.jetbrains.annotations.Nullable;
 * @author Dmitry Avdeev
 *         Date: 16.08.13
 */
-public class XmlEnumeratedValueReference extends PsiReferenceBase<XmlAttributeValue> implements EmptyResolveMessageProvider {
+public class XmlEnumeratedValueReference extends PsiReferenceBase<XmlElement> implements EmptyResolveMessageProvider {
   private final XmlEnumerationDescriptor myDescriptor;
 
-  public XmlEnumeratedValueReference(XmlAttributeValue value, XmlEnumerationDescriptor descriptor) {
+  public XmlEnumeratedValueReference(XmlElement value, XmlEnumerationDescriptor descriptor) {
     super(value);
     myDescriptor = descriptor;
   }
 
+  public XmlEnumeratedValueReference(XmlElement value, XmlEnumerationDescriptor descriptor, TextRange range) {
+    super(value, range);
+    myDescriptor = descriptor;
+  }
+
   @Nullable
   @Override
   public PsiElement resolve() {
@@ -59,8 +67,9 @@ public class XmlEnumeratedValueReference extends PsiReferenceBase<XmlAttributeVa
   @NotNull
   @Override
   public String getUnresolvedMessagePattern() {
+    String name = getElement() instanceof XmlTag ? "tag" : "attribute";
     return myDescriptor.isFixed()
-           ? XmlErrorMessages.message("attribute.should.have.fixed.value", myDescriptor.getDefaultValue())
-           : XmlErrorMessages.message("wrong.attribute.value");
+           ? XmlErrorMessages.message("should.have.fixed.value", StringUtil.capitalize(name), myDescriptor.getDefaultValue())
+           : XmlErrorMessages.message("wrong.value", name);
   }
 }

xml/xml-psi-impl/src/com/intellij/xml/util/XmlUtil.java

@@ -933,6 +933,8 @@ public class XmlUtil {
     });
   }
 
+  private final static Set<String> doNotVisitTags = new HashSet<String>(Arrays.asList("annotation", "element", "attribute"));
+
   /**
    * @return true if enumeration is exhaustive
    */
@@ -954,7 +956,7 @@ public class XmlUtil {
         exhaustiveEnum = false;
         processEnumerationValues(tag, tagProcessor);
       }
-      else if (!localName.equals("annotation")) {
+      else if (!doNotVisitTags.contains(localName)) {
         // don't go into annotation
         exhaustiveEnum &= processEnumerationValues(tag, tagProcessor);
       }
@@ -1070,7 +1072,7 @@ public class XmlUtil {
     return new Pair<XmlTagChild, XmlTagChild>(first, last);
   }
 
-  public static boolean isSimpleXmlAttributeValue(@NotNull final String unquotedValue, final XmlAttributeValue context) {
+  public static boolean isSimpleValue(@NotNull final String unquotedValue, final PsiElement context) {
     for (int i = 0; i < unquotedValue.length(); ++i) {
       final char ch = unquotedValue.charAt(i);
       if (!Character.isJavaIdentifierPart(ch) && ch != ':' && ch != '-') {