RES: Fix resolve of enum variants in match pattern in some cases

src/main/kotlin/org/rust/lang/core/resolve/Namespace.kt

@@ -42,7 +42,7 @@ val RsNamedElement.namespaces: Set<Namespace> get() = when (this) {
     is RsConstant -> VALUES
     is RsFunction -> if (this.isProcMacroDef) MACROS else VALUES
 
-    is RsEnumVariant -> namespaces
+    is RsEnumVariant -> ENUM_VARIANT_NS
 
     is RsStructItem -> if (blockFields == null) TYPES_N_VALUES else TYPES
 
@@ -64,7 +64,7 @@ fun StubElement<*>.getNamespaces(crate: Crate): Set<Namespace> = when (this) {
     is RsConstantStub -> VALUES
     is RsFunctionStub -> if (IS_PROC_MACRO_DEF_PROP.getByStub(this, crate)) MACROS else VALUES
 
-    is RsEnumVariantStub -> namespaces
+    is RsEnumVariantStub -> ENUM_VARIANT_NS
 
     is RsStructItemStub -> if (blockFields == null) TYPES_N_VALUES else TYPES
 
@@ -75,8 +75,8 @@ fun StubElement<*>.getNamespaces(crate: Crate): Set<Namespace> = when (this) {
     else -> TYPES_N_VALUES
 }
 
-inline val RsEnumVariant.namespaces: Set<Namespace> get() = if (blockFields === null) VALUES else TYPES
-inline val RsEnumVariantStub.namespaces: Set<Namespace> get() = if (blockFields === null) VALUES else TYPES
+// https://rust-lang.github.io/rfcs/0234-variants-namespace.html
+val ENUM_VARIANT_NS: Set<Namespace> = TYPES_N_VALUES
 
 val RsUseSpeck.namespaces: Set<Namespace>
     get() = path

src/main/kotlin/org/rust/lang/core/resolve2/FacadeResolve.kt

@@ -602,7 +602,7 @@ fun VisItem.toPsi(info: RsModInfo, ns: Namespace): List<RsNamedElement> {
         val containingEnums = containingModData.toRsEnum(info)
         containingEnums.flatMap { containingEnum ->
             containingEnum.variants
-                .filter { it.name == name && ns in it.namespaces && matchesIsEnabledByCfg(it, this) }
+                .filter { it.name == name && ns in ENUM_VARIANT_NS && matchesIsEnabledByCfg(it, this) }
         }
     } else {
         val containingMods = containingModData.toScope(info)

src/main/kotlin/org/rust/lang/core/resolve2/ModCollector.kt

@@ -22,7 +22,7 @@ import org.rust.lang.core.psi.RsBlock
 import org.rust.lang.core.psi.RsFile
 import org.rust.lang.core.psi.RsFileBase
 import org.rust.lang.core.psi.ext.*
-import org.rust.lang.core.resolve.namespaces
+import org.rust.lang.core.resolve.ENUM_VARIANT_NS
 import org.rust.lang.core.resolve.processModDeclResolveVariants
 import org.rust.lang.core.resolve2.util.DollarCrateHelper
 import org.rust.lang.core.resolve2.util.DollarCrateMap
@@ -288,7 +288,7 @@ private class ModCollector(
             val isVariantDeeplyEnabledByCfg = enumData.isDeeplyEnabledByCfg && variantPsi.isEnabledByCfgSelf(crate)
             val variantVisibility = if (isVariantDeeplyEnabledByCfg) Visibility.Public else Visibility.CfgDisabled
             val variant = VisItem(variantPath, variantVisibility)
-            val variantPerNs = PerNs.from(variant, variantPsi.namespaces)
+            val variantPerNs = PerNs.from(variant, ENUM_VARIANT_NS)
             enumData.addVisibleItem(variantName, variantPerNs)
         }
         return enumData

src/test/kotlin/org/rust/lang/core/resolve/RsConstArgumentResolveTest.kt

@@ -52,11 +52,11 @@ class RsConstArgumentResolveTest : RsResolveTestBase() {
     """)
 
     fun `test in the case of ambiguity const argument is resolved to a type 3`() = checkByCode("""
-        enum E { S, B }
+        mod inner { pub fn S() {} }
         struct S {}
              //X
 
-        use E::*;
+        use inner::*;
         struct Foo<const C: i32>();
         type Bar = Foo<S>;
                      //^

src/test/kotlin/org/rust/lang/core/resolve/RsResolveTest.kt

@@ -675,6 +675,17 @@ class RsResolveTest : RsResolveTestBase() {
         }
     """)
 
+    fun `test enum variant in match pattern`() = checkByCode("""
+        pub enum E { A }
+                   //X
+        use E::*;
+        fn func(x: E) {
+            match x {
+                A { .. } => {}
+            } //^
+        }
+    """)
+
     fun `test enum variant with alias`() = checkByCode("""
         enum E { A }
                //X