From 2d91e1f1dba7873cb580f0a26f1b5a9898a8e9ba Mon Sep 17 00:00:00 2001 From: hlaaftana <10591326+metagn@users.noreply.github.com> Date: Sat, 3 Sep 2022 04:40:06 +0300 Subject: [PATCH] overloadable enums no longer experimental depends on #20126 --- changelog.md | 3 +++ compiler/lookups.nim | 2 -- compiler/options.nim | 2 +- compiler/semexprs.nim | 5 +---- compiler/semgnrc.nim | 6 +----- compiler/semtempl.nim | 10 +++------- compiler/semtypes.nim | 5 +---- doc/manual_experimental.md | 6 +++--- tests/enum/{mregression.nim => mcrossmodule.nim} | 2 ++ tests/enum/tcrossmodule.nim | 10 ++++++++++ tests/enum/tregression.nim | 13 ------------- tests/sets/tsets.nim | 4 ++-- 12 files changed, 27 insertions(+), 41 deletions(-) rename tests/enum/{mregression.nim => mcrossmodule.nim} (52%) create mode 100644 tests/enum/tcrossmodule.nim delete mode 100644 tests/enum/tregression.nim diff --git a/changelog.md b/changelog.md index d2a3544a4b964..50d42cbe4adc4 100644 --- a/changelog.md +++ b/changelog.md @@ -31,6 +31,9 @@ - The `{.this.}` pragma, deprecated since 0.19, has been removed. - `nil` is no longer a valid value for distinct pointer types. +- [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:" diff --git a/compiler/lookups.nim b/compiler/lookups.nim index d61e15915ad3d..63e4920f7a1c4 100644 --- a/compiler/lookups.nim +++ b/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: diff --git a/compiler/options.nim b/compiler/options.nim index 9031e86c177c3..afbfdc7cf832f 100644 --- a/compiler/options.nim +++ b/compiler/options.nim @@ -213,7 +213,7 @@ type strictFuncs, views, strictNotNil, - overloadableEnums, + overloadableEnums, # not experimental anymore strictEffects, unicodeOperators, flexibleOptionalParams diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim index 42f720c487ca1..29a5c787beb57 100644 --- a/compiler/semexprs.nim +++ b/compiler/semexprs.nim @@ -2882,10 +2882,7 @@ 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) + result = enumFieldSymChoice(c, n, s) else: result = semSym(c, n, s, flags) if expectedType != nil and isSymChoice(result): diff --git a/compiler/semgnrc.nim b/compiler/semgnrc.nim index ca0b05fa214ca..d1c4acef683ac 100644 --- a/compiler/semgnrc.nim +++ b/compiler/semgnrc.nim @@ -108,11 +108,7 @@ 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) + result = symChoice(c, n, s, scOpen) else: result = newSymNode(s, n.info) onUse(n.info, s) diff --git a/compiler/semtempl.nim b/compiler/semtempl.nim index c72e9db05d7b5..6b71892a0d823 100644 --- a/compiler/semtempl.nim +++ b/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: - result = symChoice(c, n, s, scOpen, isField) - elif isField and sfGenSym in s.flags: - result = n - else: - result = newSymNode(s, n.info) + if 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) diff --git a/compiler/semtypes.nim b/compiler/semtypes.nim index e807e087048f7..eefcd3069a18c 100644 --- a/compiler/semtypes.nim +++ b/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) + addInterfaceOverloadableSymAt(c, c.currentScope, e) else: declarePureEnumField(c, e) if isPure and (let conflict = strTableInclReportConflict(symbols, e); conflict != nil): diff --git a/doc/manual_experimental.md b/doc/manual_experimental.md index 0e4b317fbc0e5..ac7c37ccb9a3a 100644 --- a/doc/manual_experimental.md +++ b/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 ======================= diff --git a/tests/enum/mregression.nim b/tests/enum/mcrossmodule.nim similarity index 52% rename from tests/enum/mregression.nim rename to tests/enum/mcrossmodule.nim index 9c3e3cf8bf370..e534a202c2ca4 100644 --- a/tests/enum/mregression.nim +++ b/tests/enum/mcrossmodule.nim @@ -2,3 +2,5 @@ type OtherEnum* = enum Success, Failed, More + +proc some*(x: OtherEnum): bool = x == Success diff --git a/tests/enum/tcrossmodule.nim b/tests/enum/tcrossmodule.nim new file mode 100644 index 0000000000000..1e97fd1ee49d1 --- /dev/null +++ b/tests/enum/tcrossmodule.nim @@ -0,0 +1,10 @@ +import mcrossmodule + +type + MyEnum = enum + Success + +template t = + doAssert some(Success) + +t() diff --git a/tests/enum/tregression.nim b/tests/enum/tregression.nim deleted file mode 100644 index 597f0c80aa08a..0000000000000 --- a/tests/enum/tregression.nim +++ /dev/null @@ -1,13 +0,0 @@ -discard """ - action: "compile" -""" -import options, mregression - -type - MyEnum = enum - Success - -template t = - echo some(Success) - -t() diff --git a/tests/sets/tsets.nim b/tests/sets/tsets.nim index 9ccf7a0c2acf1..517c0b89cbac1 100644 --- a/tests/sets/tsets.nim +++ b/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