supports string/char/int/uint/float literals

demotomohiro · demotomohiro · commit d55634ff28dd · 2025-10-12T20:24:39.000+09:00
diff --git a/compiler/icnif/nifdecoder.nim b/compiler/icnif/nifdecoder.nim
@@ -22,6 +22,7 @@ proc getSysType(typeKind: TTypeKind): PType =
     result = sysTypes[typeKind]
   else:
     result = PType(itemId: ItemId(module: 0, item: typeKind.int32), kind: typeKind)
+    sysTypes[typeKind] = result
 
 type
   SplittedNifSym = object
@@ -122,17 +123,106 @@ proc fromNifImport(c: var DecodeContext; n: var Cursor): PNode =
     result.add fromNifSymDef(c, n, nkImportStmt)
   inc n
 
+proc fromNifSuf(c: var DecodeContext; n: var Cursor): PNode =
+  inc n
+  case n.kind:
+  of StringLit:
+    let v = pool.strings[n.litId]
+    inc n
+    assert n.kind == StringLit
+    let suffix = pool.strings[n.litId]
+    let kind = case suffix
+      of "R":
+        nkRStrLit
+      of "T":
+        nkTripleStrLit
+      else:
+        assert false, "Unknown string literal suffix " & suffix
+        nkNone
+    result = newStrNode(kind, v)
+  of IntLit:
+    let v = pool.integers[n.intId]
+    inc n
+    assert n.kind == StringLit
+    let suffix = pool.strings[n.litId]
+    let kind = case suffix
+      of "i8":
+        tyInt8
+      of "i16":
+        tyInt16
+      of "i32":
+        tyInt32
+      of "i64":
+        tyInt64
+      else:
+        assert false, "Unknown int literal suffix " & suffix
+        tyNone
+    result = newIntTypeNode(v, getSysType(kind))
+  of UIntLit:
+    let v = pool.uintegers[n.uintId]
+    inc n
+    assert n.kind == StringLit
+    let suffix = pool.strings[n.litId]
+    let kind = case suffix
+      of "u8":
+        tyUInt8
+      of "u16":
+        tyUInt16
+      of "u32":
+        tyUInt32
+      of "u64":
+        tyUInt64
+      else:
+        assert false, "Unknown uint literal suffix " & suffix
+        tyNone
+    result = newIntTypeNode(cast[BiggestInt](v), getSysType(kind))
+  of FloatLit:
+    let v = pool.floats[n.floatId]
+    inc n
+    assert n.kind == StringLit
+    let suffix = pool.strings[n.litId]
+    let kind = case suffix
+      of "f32":
+        (nkFloat32Lit, tyFloat32)
+      of "f64":
+        (nkFloat64Lit, tyFloat64)
+      of "f128":
+        (nkFloat128Lit, tyFloat128)
+      else:
+        assert false, "Unknown uint literal suffix " & suffix
+        (nkNone, tyNone)
+    result = newFloatNode(kind[0], v)
+    result.typ() = getSysType(kind[1])
+  else:
+    assert false, "invalid node in suf node " & $n.kind
+  inc n
+  assert n.kind == ParRi
+  inc n
+
 proc fromNif(c: var DecodeContext; n: var Cursor): PNode =
   result = nil
   case n.kind:
   of DotToken:
     result = newNode(nkEmpty)
     inc n
+  of Symbol:
+    result = newSymNode(fromNifSymbol(c, n))
+  of StringLit:
+    result = newStrNode(nkStrLit, pool.strings[n.litId])
+    inc n
+  of CharLit:
+    result = newIntNode(nkCharLit, n.charLit.int)
+    inc n
   of IntLit:
     result = newIntTypeNode(pool.integers[n.intId], getSysType(tyInt))
     inc n
-  of Symbol:
-    result = newSymNode(fromNifSymbol(c, n))
+  of UIntLit:
+    result = newIntTypeNode(cast[BiggestInt](pool.uintegers[n.uintId]), getSysType(tyUInt))
+    inc n
+  of FloatLit:
+    result = newFloatNode(nkFloatLit, pool.floats[n.floatId])
+    result.typ() = getSysType(tyFloat)
+    inc n
   of ParLe:
     let kind = n.nodeKind
     case kind:
@@ -146,6 +236,12 @@ proc fromNif(c: var DecodeContext; n: var Cursor): PNode =
       result = fromNifLocal(c, n, kind)
     of nkImportStmt:
       result = fromNifImport(c, n)
+    of nkNone:
+      case pool.tags[n.tagId]:
+      of "suf":
+        result = fromNifSuf(c, n)
+      else:
+        assert false, "Unknown tag " & pool.tags[n.tagId]
     else:
       assert false, "Not yet implemented " & $kind
   else:
diff --git a/compiler/icnif/nifencoder.nim b/compiler/icnif/nifencoder.nim
@@ -19,6 +19,16 @@ proc modname(c: var EncodeContext; idx: FileIndex): string =
     result = moduleSuffix(fp, cast[seq[string]](c.conf.searchPaths))
     c.toSuffix[idx] = result
 
+proc addIntLit(b: var Builder; i: int64; suffix: string) =
+  withTree(b, "suf"):
+    addIntLit(b, i)
+    addStrLit(b, suffix)
+
+proc addFloatLit(b: var Builder; f: float; suffix: string) =
+  withTree(b, "suf"):
+    addFloatLit(b, f)
+    addStrLit(b, suffix)
+
 proc toNifSym(c: var EncodeContext; sym: PSym): string =
   result = sym.name.s & '.' & $sym.disamb
   let owner = sym.skipGenericOwner()
@@ -74,8 +84,42 @@ proc toNif(c: var EncodeContext; n: PNode) =
   case n.kind:
   of nkEmpty:
     c.b.addEmpty()
+  of nkCharLit:
+    c.b.addCharLit n.intVal.char
   of nkIntLit:
     c.b.addIntLit n.intVal
+  of nkInt8Lit:
+    c.b.addIntLit n.intVal, "i8"
+  of nkInt16Lit:
+    c.b.addIntLit n.intVal, "i16"
+  of nkInt32Lit:
+    c.b.addIntLit n.intVal, "i32"
+  of nkInt64Lit:
+    c.b.addIntLit n.intVal, "i64"
+  of nkUIntLit:
+    c.b.addUIntLit cast[BiggestUInt](n.intVal)
+  of nkUInt8Lit:
+    c.b.addUIntLit cast[BiggestUInt](n.intVal), "u8"
+  of nkUInt16Lit:
+    c.b.addUIntLit cast[BiggestUInt](n.intVal), "u16"
+  of nkUInt32Lit:
+    c.b.addUIntLit cast[BiggestUInt](n.intVal), "u32"
+  of nkUInt64Lit:
+    c.b.addUIntLit cast[BiggestUInt](n.intVal), "u64"
+  of nkFloatLit:
+    c.b.addFloatLit n.floatVal
+  of nkFloat32Lit:
+    c.b.addFloatLit n.floatVal, "f32"
+  of nkFloat64Lit:
+    c.b.addFloatLit n.floatVal, "f64"
+  of nkFloat128Lit:
+    c.b.addFloatLit n.floatVal, "f128"
+  of nkStrLit:
+    c.b.addStrLit n.strVal
+  of nkRStrLit:
+    c.b.addStrLit n.strVal, "R"
+  of nkTripleStrLit:
+    c.b.addStrLit n.strVal, "T"
   of nkIdentDefs:
     c.b.addTree toNifTag(n.kind)
     assert n.len == 3
diff --git a/tests/icnif/tencode_node2node.nim b/tests/icnif/tencode_node2node.nim
@@ -2,12 +2,17 @@ import std/assertions
 import "../../compiler/icnif" / [nifencoder, nifdecoder]
 import "../../compiler" / [idents, ast, astalgo, options, pathutils, modulegraphs, modules, msgs, pipelines, syntaxes, sem, llstream, lineinfos]
 
+# This test generates PNode by semchecks test code.
+# Then it is used to test icnif/nifencoder and nifdecoder.
+
 const TestCodeDir = currentSourcePath().AbsoluteFile.splitFile().dir / RelativeDir"testcode"
 
 proc newConfigRefForTest(): ConfigRef =
   var conf = newConfigRef()
   conf.setDefaultLibpath()
   conf.searchPaths.add(conf.libpath)
+  excl(conf.notes, hintProcessing)
+  excl(conf.mainPackageNotes, hintProcessing)
   result = conf
  
 proc newModuleGraphForSem(cache: IdentCache; conf: ConfigRef): ModuleGraph =
@@ -105,9 +110,12 @@ proc testNifEncDec(graph: ModuleGraph; src: string) =
   let n2 = loadNifFromBuffer(nif, fullPath, graphForLoad)
   #debug(n)
   #debug(n2)
+  #if src == "modtestliterals.nim":
+  #  echo nif
   assert eql(n, n2)
 
 var conf = newConfigRefForTest()
 var cache = newIdentCache()
 var graph = newModuleGraphForSem(cache, conf)
 testNifEncDec(graph, "modtest1.nim")
+testNifEncDec(graph, "modtestliterals.nim")
diff --git a/tests/icnif/testcode/modtestliterals.nim b/tests/icnif/testcode/modtestliterals.nim
@@ -0,0 +1,27 @@
+var strlit = "test string"
+var rstrlit = r"test\t raw"
+var triplestrlit = """Triple
+string
+literal
+"""
+var charlit = 'a'
+var intlit1 = 123456
+var intlit2 = -123456
+var int8litH = 127'i8
+var int8litL = -128'i8
+var int16litH = 32767'i16
+var int16litL = -32768'i16
+var int32litH = 2147483647'i32
+var int32litL = -2147483648'i32
+var int64litH = 9223372036854775807'i64
+var int64litL = -9223372036854775808'i64
+
+var uintlitH = 18446744073709551615'u
+var uint8litH = 255'u8
+var uint16litH = 65535'u16
+var uint32litH = 4294967295'u32
+var uint64litH = 18446744073709551615'u64
+
+var floatlit = 1.25
+var float32lit = 1.25'f32
+var float64lit = 1.25'f64
