Add {.alias.} pragma

Closes nim-lang/RFCs#466

changelog.md

@@ -139,6 +139,22 @@
   
   ```nim
   let foo: seq[(float, byte, cstring)] = @[(1, 2, "abc")]
+- Alias-style templates and macros can now optionally be annotated with the
+  `{.alias.}` pragma. For templates, this has the behavior of disallowing
+  redefinitions.
+
+  ```nim
+  type Foo = object
+    bar: int
+  
+  var foo = Foo(bar: 10)
+  template bar: untyped {.alias.} = foo.bar
+  assert bar == 10
+  bar = 15
+  assert bar == 15
+  var foo2 = Foo(bar: -10)
+  # error:
+  template bar: untyped {.alias.} = foo.bar
   ```
 
 - `cstring` is now accepted as a selector in `case` statements, removing the

compiler/ast.nim

@@ -232,7 +232,7 @@ type
   TNodeKinds* = set[TNodeKind]
 
 type
-  TSymFlag* = enum    # 48 flags!
+  TSymFlag* = enum    # 49 flags!
     sfUsed,           # read access of sym (for warnings) or simply used
     sfExported,       # symbol is exported from module
     sfFromGeneric,    # symbol is instantiation of a generic; this is needed
@@ -304,6 +304,7 @@ type
     sfSingleUsedTemp  # For temporaries that we know will only be used once
     sfNoalias         # 'noalias' annotation, means C's 'restrict'
     sfEffectsDelayed  # an 'effectsDelayed' parameter
+    sfAlias           # an alias-style template or macro
 
   TSymFlags* = set[TSymFlag]
 

compiler/condsyms.nim

@@ -143,3 +143,4 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasTopDownInference")
   defineSymbol("nimHasTemplateRedefinitionPragma")
   defineSymbol("nimHasCstringCase")
+  defineSymbol("nimHasAliasPragma")

compiler/pragmas.nim

@@ -38,10 +38,10 @@ const
   converterPragmas* = procPragmas
   methodPragmas* = procPragmas+{wBase}-{wImportCpp}
   templatePragmas* = {wDeprecated, wError, wGensym, wInject, wDirty,
-    wDelegator, wExportNims, wUsed, wPragma, wRedefine}
+    wDelegator, wExportNims, wUsed, wPragma, wRedefine, wAlias}
   macroPragmas* = declPragmas + {FirstCallConv..LastCallConv,
     wMagic, wNoSideEffect, wCompilerProc, wNonReloadable, wCore,
-    wDiscardable, wGensym, wInject, wDelegator}
+    wDiscardable, wGensym, wInject, wDelegator, wAlias}
   iteratorPragmas* = declPragmas + {FirstCallConv..LastCallConv, wNoSideEffect, wSideEffect,
     wMagic, wBorrow,
     wDiscardable, wGensym, wInject, wRaises, wEffectsOf,
@@ -1243,6 +1243,8 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         pragmaEnsures(c, it)
       of wEnforceNoRaises:
         sym.flags.incl sfNeverRaises
+      of wAlias:
+        sym.flags.incl sfAlias
       else: invalidPragma(c, it)
     elif comesFromPush and whichKeyword(ident) != wInvalid:
       discard "ignore the .push pragma; it doesn't apply"

compiler/semtempl.nim

@@ -688,8 +688,11 @@ proc semTemplateDef(c: PContext, n: PNode): PNode =
     addInterfaceOverloadableSymAt(c, c.currentScope, s)
   elif not comesFromShadowscope:
     if {sfTemplateRedefinition, sfGenSym} * s.flags == {}:
-      #wrongRedefinition(c, n.info, proto.name.s, proto.info)
-      message(c.config, n.info, warnTemplateRedefinition, s.name.s)
+      if sfAlias in (proto.flags + s.flags):
+        # cannot implicitly redefine alias templates
+        wrongRedefinition(c, n.info, proto.name.s, proto.info)
+      else:
+        message(c.config, n.info, warnTemplateRedefinition, s.name.s)
     symTabReplace(c.currentScope.symbols, proto, s)
   if n[patternPos].kind != nkEmpty:
     c.patterns.add(s)

compiler/wordrecg.nim

@@ -87,7 +87,7 @@ type
     wGlobal = "global", wCodegenDecl = "codegenDecl", wUnchecked = "unchecked",
     wGuard = "guard", wLocks = "locks", wPartial = "partial", wExplain = "explain",
     wLiftLocals = "liftlocals", wEnforceNoRaises = "enforceNoRaises",
-    wRedefine = "redefine",
+    wRedefine = "redefine", wAlias = "alias",
 
     wAuto = "auto", wBool = "bool", wCatch = "catch", wChar = "char",
     wClass = "class", wCompl = "compl", wConstCast = "const_cast", wDefault = "default",

doc/manual_experimental.md

@@ -512,8 +512,8 @@ Assuming `foo` is a macro or a template, this is roughly equivalent to:
   ```
 
 
-Symbols as template/macro calls
-===============================
+Alias-style templates and macros
+================================
 
 Templates and macros that take no arguments can be called as lone symbols,
 i.e. without parentheses. This is useful for repeated uses of complex
@@ -530,9 +530,25 @@ expressions that cannot conveniently be represented as runtime values.
   assert bar == 15
   ```
 
-In the future, this may require more specific information on template or macro
-signatures to be used. Specializations for some applications of this may also
-be introduced to guarantee consistency and circumvent bugs.
+These templates/macros can be annotated with the `{.alias.}` pragma
+to denote their intended use, however this annotation is currently
+not required. For templates, this induces the behavior of
+disallowing redefinitions.
+
+.. code-block:: nim
+  type Foo = object
+    bar: int
+
+  var foo = Foo(bar: 10)
+  template bar: untyped {.alias.} = foo.bar
+  assert bar == 10
+  bar = 15
+  assert bar == 15
+  var foo2 = Foo(bar: -10)
+  # error:
+  template bar: untyped {.alias.} = foo.bar
+
+In the future, this annotation or the lack of it may gain more meanings.
 
 
 Not nil annotation

lib/std/decls.nim

@@ -26,7 +26,12 @@ macro byaddr*(sect) =
     typ = def[1]
     ex = def[2]
     addrTyp = if typ.kind == nnkEmpty: typ else: newTree(nnkPtrTy, typ)
-  result = quote do:
-    let tmp: `addrTyp` = addr(`ex`)
-    template `lhs`: untyped = tmp[]
+  when defined(nimHasAliasPragma):
+    result = quote do:
+      let tmp: `addrTyp` = addr(`ex`)
+      template `lhs`: untyped {.alias.} = tmp[]
+  else:
+    result = quote do:
+      let tmp: `addrTyp` = addr(`ex`)
+      template `lhs`: untyped = tmp[]
   result.copyLineInfo(def)

tests/stdlib/tdecls.nim

@@ -13,8 +13,8 @@ template fun() =
   var b {.byaddr.}: int = s[0]
   doAssert a.addr == b.addr
 
-  when false:
-    # template specific redeclaration issue
+  when defined(nimHasAliasPragma):
+    # use of {.alias.} pragma disallows redefinitions
     # see https://github.com/nim-lang/Nim/issues/8275
     doAssert not compiles(block:
       # redeclaration not allowed