overloadable enums no longer experimental (#20298)

depends on #20126

changelog.md

@@ -33,6 +33,9 @@
 - Removed two type pragma syntaxes deprecated since 0.20, namely
   `type Foo = object {.final.}`, and `type Foo {.final.} [T] = object`.
 
+- [Overloadable enums](https://nim-lang.github.io/Nim/manual_experimental.html#overloadable-enum-value-names)
+  are no longer experimental.
+
 ## Standard library additions and changes
 
 [//]: # "Changes:"

compiler/lookups.nim

@@ -182,8 +182,6 @@ iterator allSyms*(c: PContext): (PSym, int, bool) =
 proc someSymFromImportTable*(c: PContext; name: PIdent; ambiguous: var bool): PSym =
   var marked = initIntSet()
   var symSet = OverloadableSyms
-  if overloadableEnums notin c.features:
-    symSet.excl skEnumField
   result = nil
   block outer:
     for im in c.imports.mitems:

compiler/options.nim

@@ -213,7 +213,7 @@ type
     strictFuncs,
     views,
     strictNotNil,
-    overloadableEnums,
+    overloadableEnums, # not experimental anymore
     strictEffects,
     unicodeOperators,
     flexibleOptionalParams

compiler/semexprs.nim

@@ -2882,12 +2882,9 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
       if optOwnedRefs in c.config.globalOptions:
         result.typ = makeVarType(c, result.typ, tyOwned)
     of skEnumField:
-      if overloadableEnums in c.features:
       result = enumFieldSymChoice(c, n, s)
     else:
       result = semSym(c, n, s, flags)
-    else:
-      result = semSym(c, n, s, flags)
     if expectedType != nil and isSymChoice(result):
       result = fitNode(c, expectedType, result, n.info)
       if result.kind == nkSym:

compiler/semgnrc.nim

@@ -108,14 +108,10 @@ proc semGenericStmtSymbol(c: PContext, n: PNode, s: PSym,
       result = n
     onUse(n.info, s)
   of skEnumField:
-    if overloadableEnums in c.features:
     result = symChoice(c, n, s, scOpen)
   else:
     result = newSymNode(s, n.info)
     onUse(n.info, s)
-  else:
-    result = newSymNode(s, n.info)
-    onUse(n.info, s)
 
 proc lookup(c: PContext, n: PNode, flags: TSemGenericFlags,
             ctx: var GenericCtx): PNode =

compiler/semtempl.nim

@@ -250,7 +250,7 @@ proc semTemplSymbol(c: PContext, n: PNode, s: PSym; isField: bool): PNode =
   of skUnknown:
     # Introduced in this pass! Leave it as an identifier.
     result = n
-  of OverloadableSyms-{skEnumField}:
+  of OverloadableSyms:
     result = symChoice(c, n, s, scOpen, isField)
   of skGenericParam:
     if isField and sfGenSym in s.flags: result = n
@@ -261,12 +261,8 @@ proc semTemplSymbol(c: PContext, n: PNode, s: PSym; isField: bool): PNode =
     if isField and sfGenSym in s.flags: result = n
     else: result = newSymNodeTypeDesc(s, c.idgen, n.info)
   else:
-    if s.kind == skEnumField and overloadableEnums in c.features:
+    if isField and sfGenSym in s.flags: result = n
-      result = symChoice(c, n, s, scOpen, isField)
+    else: result = newSymNode(s, n.info)
-    elif isField and sfGenSym in s.flags:
-      result = n
-    else:
-      result = newSymNode(s, n.info)
     # Issue #12832
     when defined(nimsuggest):
       suggestSym(c.graph, n.info, s, c.graph.usageSym, false)

compiler/semtypes.nim

@@ -143,10 +143,7 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
     onDef(e.info, e)
     if sfGenSym notin e.flags:
       if not isPure:
-        if overloadableEnums in c.features:
         addInterfaceOverloadableSymAt(c, c.currentScope, e)
-        else:
-          addInterfaceDecl(c, e)
       else:
         declarePureEnumField(c, e)
     if isPure and (let conflict = strTableInclReportConflict(symbols, e); conflict != nil):

doc/manual_experimental.md

@@ -89,8 +89,6 @@ No Unicode normalization step is performed.
 Overloadable enum value names
 =============================
 
-Enabled via `{.experimental: "overloadableEnums".}`.
-
 Enum value names are overloadable, much like routines. If both of the enums
 `T` and `U` have a member named `foo`, then the identifier `foo` corresponds
 to a choice between `T.foo` and `U.foo`. During overload resolution,
@@ -98,7 +96,6 @@ the correct type of `foo` is decided from the context. If the type of `foo` is
 ambiguous, a static error will be produced.
 
   ```nim  test = "nim c $1"
-  {.experimental: "overloadableEnums".}
 
   type
     E1 = enum
@@ -124,6 +121,9 @@ ambiguous, a static error will be produced.
   p value2
   ```
 
+Previously required `{.experimental: "overloadableEnums".}` to enable,
+now always enabled.
+
 Top-down type inference
 =======================
 

tests/enum/mcrossmodule.nim

@@ -2,3 +2,5 @@
 type
   OtherEnum* = enum
     Success, Failed, More
+
+proc some*(x: OtherEnum): bool = x == Success

tests/enum/tcrossmodule.nim

@@ -0,0 +1,10 @@
+import mcrossmodule
+
+type
+  MyEnum = enum
+    Success
+
+template t =
+  doAssert some(Success)
+
+t()

tests/enum/tregression.nim

@@ -1,13 +0,0 @@
-discard """
-  action: "compile"
-"""
-import options, mregression
-
-type
-  MyEnum = enum
-    Success
-
-template t =
-  echo some(Success)
-
-t()

tests/sets/tsets.nim

@@ -76,11 +76,11 @@ block:
       k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k50, k51, k52, k53, k54, k55, k56, k57, k58, k59, k60, k61, k62, k63, k64, k65, k66, k67, k68, k69, k70, k71, k72, k73, k74, k75, k76, k77, k78, k79, k80, k81, k82, k83, k84, k85, k86, k87, k88, k89, k90, k91, k92, k93, k94, k95, k96, k97, k98, k99, k100
 
   type
-    FakeMsgKind2 = range[k50..high(FakeMsgKind)]
+    FakeMsgKind2 = range[FakeMsgKind.k50..high(FakeMsgKind)]
     FakeMsgKind2s = set[FakeMsgKind2]
 
   const
-    a1: array[0..0, FakeMsgKind2s] = [{low(FakeMsgKind2)..high(FakeMsgKind2)} - {k99}]
+    a1: array[0..0, FakeMsgKind2s] = [{low(FakeMsgKind2)..high(FakeMsgKind2)} - {FakeMsgKind.k99}]
     a2 = a1[0]
 
   var