implements `cast`

[ringabout]

there is a more serious problem, cast it is not implemented, currently it is a strange type pruning (i.e respects how pointer casting works in old compiler, but not general type casting), which is not cast at all, for example

import std/syncio
echo cast[float](42)

Will produce 42, not converted int bytes to float
see ASVIEST#1

Originally posted by @ASVIEST in #1478

[Araq]

This should be fixed in the Hexer tool, keeps NIFC from having to generate temporaries.

[ASVIEST]

This should be fixed in the Hexer tool, keeps NIFC from having to generate temporaries.

Does this mean making hexer platform-dependent? Since for something like wasm you need expr, but for c you need stmt.

[Araq]

I have no idea what you're talking about. Hexer would generate a union and thus do it like Nim's backend does. NIFC supports union and it all works out. Mapping NIFC to wasm is its own problem, requiring a more complex tanslator than the one that maps NIFC to C.

[ASVIEST]

I have no idea what you're talking about. Hexer would generate a union and thus do it like Nim's backend does. NIFC supports union and it all works out. Mapping NIFC to wasm is its own problem, requiring a more complex tanslator than the one that maps NIFC to C.

It feels like hexer should just be universal across backends. By the way, it should generate memcpy instead of a union at the very least, but that’s a separate issue (ASVIEST#1) and doesn't change the core point. Just because NIFC -> wasm has complex parts doesn't mean nifc should boil down to C in one form (without any abstraction) -> C in another form. i.e. it has no abstraction over c, and therefore has no value. Currently, nifc lacks the mechanisms to generate C stmts from nifc exprs. This was even discussed on Discord: https://discord.com/channels/371759389889003530/768367394547957761/1390698749164130434

[Araq]

It feels like hexer should just be universal across backends.

Yeah well, it always generates nifc...

i.e. it has no abstraction over c, and therefore has no value

It does the name mangling and type reordering, it adds typedef and proc forward declarations, and that is a big win for a code generator. These are very tricky to get right.

Currently, nifc lacks the mechanisms to generate C stmts from nifc exprs.

Yes. So? It's not hard to do that for wasm.

[Shawtysixgoods]

Implementation Proposal for cast in Hexer

Based on the discussion and looking at the hexer architecture, here's a concrete proposal for implementing proper cast semantics:

Current Problem

Currently, cast[float](42) produces 42 instead of reinterpreting the int's bit pattern as a float. This is because cast is treated as a type annotation rather than a bitwise reinterpretation operation.

Proposed Solution: Union-Based Cast in Hexer

As @Araq mentioned, hexer should generate a union for type casting. Here's the approach:

1. Detect Cast Operations in Hexer

In hexer's lowering phase, identify CastS operations:

proc lowerCast(c: var Context; n: Cursor): TokenBuf =
  # Extract source and target types
  let srcType = getType(n[1])
  let dstType = getType(n[0])
  
  if srcType.sizeof == dstType.sizeof:
    # Generate union-based cast
    result = generateUnionCast(c, n, srcType, dstType)
  else:
    # Error: incompatible sizes
    error("Cannot cast between types of different sizes")

2. Generate NIFC Union Structure

proc generateUnionCast(c: var Context; n: Cursor; src, dst: Type): TokenBuf =
  result = createTokenBuf()
  
  # Create unique temporary name
  let tmpName = c.getTempName("cast_union")
  
  # Generate union declaration
  result.addParLe UnionS
  result.addIdent tmpName
  result.addParLe FieldS
  result.addIdent "src"
  result.addType src
  result.addParRi()
  result.addParLe FieldS
  result.addIdent "dst"
  result.addType dst
  result.addParRi()
  result.addParRi()
  
  # Generate: {.union.} tmp = (src: value)
  # Then access: tmp.dst
  result.addParLe VarS
  result.addIdent tmpName
  result.addParLe InitS
  result.addParLe FieldInitS
  result.addIdent "src"
  result.takeTree n[1]  # source expression
  result.addParRi()
  result.addParRi()
  result.addParRi()
  
  # Return access to dst field
  result.addParLe DotS
  result.addIdent tmpName
  result.addIdent "dst"
  result.addParRi()

3. NIFC Output Example

For cast[float](42), hexer would generate NIFC like:

(union cast_union_1
  (field src int)
  (field dst float))

(var tmp cast_union_1 (init (field_init src 42)))
(dot tmp dst)  # returns the float reinterpretation

4. Integration Points

• File: src/hexer/cps.nim or create new src/hexer/casts.nim
• Hook into: The expression lowering pass after lambda lifting
• Test cases: tests/hexer/tcasts.nim

Alternative: Memcpy-Based Approach

As @ASVIEST noted, another approach is using memcpy:

proc generateMemcpyCast(c: var Context; n: Cursor; src, dst: Type): TokenBuf =
  result = createTokenBuf()
  let tmp = c.getTempName("cast_tmp")
  
  # var tmp_src: SrcType = value
  result.addVar(tmp & "_src", src, n[1])
  
  # var tmp_dst: DstType
  result.addVar(tmp & "_dst", dst)
  
  # memcpy(addr tmp_dst, addr tmp_src, sizeof(SrcType))
  result.addCall("memcpy",
    [addrOf(tmp & "_dst"), addrOf(tmp & "_src"), sizeOf(src)])
  
  # return tmp_dst
  result.addIdent(tmp & "_dst")

This is safer for strict aliasing rules but requires more NIFC code.

Implementation Checklist

• Add CastS handling in hexer's main lowering pass
• Implement union generation for same-size types
• Add size checking and error reporting
• Generate proper NIFC union syntax
• Add test cases for:
  • int to float cast
  • float to int cast
  • pointer casts
  • different-size cast errors
• Update documentation in doc/language.md

Questions

1. Should we prefer union or memcpy approach? Union is more concise but memcpy might be safer for some targets.
2. Should cast work on expressions or require lvalues? Current design assumes expressions work.
3. Do we need special handling for pointer casts vs value casts?

I'm ready to start implementing this if the approach looks good!

[Shawtysixgoods]

Implementation Proposal for cast in Hexer

I'd like to propose an implementation approach for the cast operator. Based on the code examples provided, here are two viable strategies:

1. Union-Based Approach (More Concise)

This generates a union type in NIFC and uses field access:

proc generateCast(cast: var context; n: cursor; src, dst: Type): TokenBuf =
  result = createTokenBuf()
  let tmp = c.getTempName("cast_tmp")
  
  # Create union of source and destination types
  let unionType = c.createUnionType(src, dst)
  
  # var tmp: union{src: SrcType, dst: DstType}
  result.addVar(tmp, unionType)
  
  # tmp.src = <source_expression>
  result.addAssign(tmp & ".src", n[])
  
  # return tmp.dst
  result.addReturn(tmp & ".dst")

2. Memcpy-Based Approach (Safer for Aliasing)

This uses explicit memory copying via addCall:

proc generateMemcpyCast(c: var context; n: cursor; src, dst: Type): TokenBuf =
  result = createTokenBuf()
  let tmp_src = c.getTempName("cast_src")
  let tmp_dst = c.getTempName("cast_dst")
  
  # var tmp_src: SrcType = value
  result.addVar(tmp_src & ": " & src, n[])
  
  # var tmp_dst: DstType
  result.addVar(tmp_dst & ": " & dst, "")
  
  # memcpy(addr tmp_dst, addr tmp_src, sizeof(SrcType))
  result.addCall("memcpy",
    [addrOf(tmp_dst), addrOf(tmp_src), sizeOf(src)])
  
  # return tmp_dst
  result.addReturn(tmp_dst)

Integration Points

File: src/hexer/cps.nim or create new src/hexer/casts.nim

Hook into: The expression lowering pass after lambda lifting (as noted in the memcpy example)

Test cases: tests/hexer/tcasts.nim

Implementation Checklist

• Add CastS handling in hexer's main lowering pass
• Implement union generation for same-size types
• Add size checking and error reporting
• Generate proper NIFC union syntax
• Add test cases for:
  • int to float cast
  • float to int cast
  • pointer casts
  • different-size cast errors
• Update documentation in doc/language.md

Questions

1. Should we prefer union or memcpy approach? Union is more concise but memcpy might be safer for some targets.
2. Should cast work on expressions or require lvalues? Current design assumes expressions work.
3. Do we need special handling for pointer casts vs value casts?

This is safer for strict aliasing rules but requires more NIFC code.

I'm ready to start implementing this if the approach looks good!

[Araq]

Can be done in desugar.nim, the approach with memcpy is fine, copy into a temp, instead of the cast use the temp, done. Use the ExprX node kind so that you can have a memcpy inside an expression. After desugar.nim xelim.nim runs over it, eliminating the ExprX, no need to think about it.