feat: Std::String, Std::Map, Result/Option, ? operator, sizeof fix, docs

Add standard library modules: - Std::String: strlen, strcmp, concat, copy, starts_with wrappers - Std::Map: linear-probing hash map with String keys, int values Add error handling: - Result and Option algebraic enum examples - ? try operator for automatic error propagation in HIR lowering Compiler bugfixes: - Fix sizeof() for user-defined structs (new hSizeOf HIR node) - Fix HIR type lowering for char8, bool8, int8, uint8, etc. - Fix let statement lowering for pointer types (*char8 → int* bug) - Fix PrintInt ABI mismatch (int64_t → int in io.c) - Fix Makefile test bug (_test_tmp_pkg already exists) Documentation: - Rewrite README.md with features, examples, project structure - Add docs/LanguageRef.md — complete language reference - Add docs/Stdlib.md — standard library documentation - Add docs/BuildAndTest.md — build and test guide New examples: strings, map, result_option, try_operator (13 total)
2026-05-31 10:15:44 +03:00
parent e328af6eee
commit 7ee6a73ea4
22 changed files with 1475 additions and 55 deletions
@@ -113,6 +113,7 @@ type
    ekTuple
    ekCast
    ekIs
+    ekTry
    ekBlock
    ekMatch

@@ -186,6 +187,9 @@ type
    of ekIs:
      exprIsOperand*: Expr
      exprIsType*: TypeExpr
+    of ekTry:
+      exprTryOperand*: Expr
+      exprTryType*: TypeExpr  # nil for Result?, or explicit target type
    of ekBlock:
      exprBlock*: Block
    of ekMatch:
@@ -235,6 +235,10 @@ proc emitExpr(be: var CBackend, node: HirNode): string =
  of hIs:
    return "true"  # TODO: proper type checking

+  of hSizeOf:
+    let typ = typeToC(node.sizeOfType)
+    return &"sizeof({typ})"
+
  of hIf:
    # Ternary expression
    let cond = be.emitExpr(node.ifCond)
@@ -30,6 +30,7 @@ type
    # Type operations
    hCast
    hIs
+    hSizeOf
    # Composite
    hBlock
    hStructInit
@@ -104,6 +105,8 @@ type
    of hIs:
      isOperand*: HirNode
      isType*: Type
+    of hSizeOf:
+      sizeOfType*: Type
    of hBlock:
      blockStmts*: seq[HirNode]
      blockExpr*: HirNode
@@ -9,6 +9,8 @@ type
    currentFuncRetType*: Type
    currentFuncDecl*: Decl
    varCounter*: int
+    tryCounter*: int
+    pendingStmts*: seq[HirNode]
    typeSubst*: Table[string, Type]  # Type parameter substitution for generics
    importTable*: Table[string, string]  # Local name → fully qualified name for imports

@@ -16,6 +18,18 @@ proc freshName(ctx: var LowerCtx): string =
  inc ctx.varCounter
  result = "__tmp_" & $ctx.varCounter

+proc freshTryVar(ctx: var LowerCtx): string =
+  inc ctx.tryCounter
+  result = "__try_" & $ctx.tryCounter
+
+proc flushPending(ctx: var LowerCtx, node: HirNode): HirNode =
+  if ctx.pendingStmts.len > 0:
+    var stmts = ctx.pendingStmts
+    ctx.pendingStmts = @[]
+    stmts.add(node)
+    return hirBlock(stmts, nil, makeVoid(), node.loc)
+  return node
+
 proc lowerMatch(ctx: var LowerCtx, subject: HirNode, arms: seq[HirMatchArm], typ: Type, loc: SourceLocation): HirNode =
  # Lower match expression to a block with if-else chain.
  # For now, supports enum tag matching and wildcard/ident fallbacks.
@@ -100,6 +114,8 @@ proc initLowerCtx*(module: Module, sema: Sema): LowerCtx =
  result.globalScope = sema.globalScope
  result.methodTable = sema.methodTable
  result.varCounter = 0
+  result.tryCounter = 0
+  result.pendingStmts = @[]
  result.typeSubst = initTable[string, Type]()
  result.importTable = initTable[string, string]()

@@ -110,14 +126,26 @@ proc resolveTypeExpr(ctx: var LowerCtx, te: TypeExpr): Type =
    case te.typeName
    of "void": return makeVoid()
    of "bool": return makeBool()
+    of "bool8": return makeBool8()
+    of "bool16": return makeBool16()
+    of "bool32": return makeBool32()
+    of "char8": return makeChar8()
+    of "char16": return makeChar16()
+    of "char32": return makeChar32()
+    of "String", "str": return makeStr()
    of "int": return makeInt()
-    of "int32": return makeInt()
+    of "int8": return makeInt8()
+    of "int16": return makeInt16()
+    of "int32": return makeInt32()
    of "int64": return makeInt64()
-    of "float64": return makeFloat64()
-    of "float32": return makeFloat32()
    of "uint": return makeUInt()
-    of "uint32": return makeUInt()
+    of "uint8": return makeUInt8()
+    of "uint16": return makeUInt16()
+    of "uint32": return makeUInt32()
    of "uint64": return makeUInt64()
+    of "float": return makeFloat64()
+    of "float32": return makeFloat32()
+    of "float64": return makeFloat64()
    else: return makeNamed(te.typeName)
  of tekPointer: return makePointer(ctx.resolveTypeExpr(te.pointerPointee))
  of tekSlice: return makeSlice(ctx.resolveTypeExpr(te.sliceElement))
@@ -241,6 +269,9 @@ proc resolveExprType(ctx: var LowerCtx, expr: Expr): Type =
    if expr.exprCastType != nil:
      return ctx.resolveTypeExpr(expr.exprCastType)
    return makeUnknown()
+  of ekTry:
+    # For now, assume Result<int, String> -> int or Option<int> -> int
+    return makeInt()
  of ekBlock:
    if expr.exprBlock.stmts.len > 0:
      let last = expr.exprBlock.stmts[^1]
@@ -426,6 +457,60 @@ proc lowerExpr(ctx: var LowerCtx, expr: Expr): HirNode =
    return HirNode(kind: hIs, isOperand: operand, isType: isType,
                   typ: makeBool(), loc: loc)

+  of ekTry:
+    let operand = ctx.lowerExpr(expr.exprTryOperand)
+    let operandType = ctx.resolveExprType(expr.exprTryOperand)
+
+    var typeName = ""
+    var errTag = ""
+    var okField = ""
+    if operandType.kind == tkNamed:
+      typeName = operandType.name
+      case typeName
+      of "Result":
+        errTag = "Result_Err"
+        okField = "Ok_0"
+      of "Option":
+        errTag = "Option_None"
+        okField = "Some_0"
+      else:
+        errTag = typeName & "_Err"
+        okField = "Ok_0"
+    else:
+      errTag = "Result_Err"
+      okField = "Ok_0"
+      typeName = "Result"
+
+    let tmpName = ctx.freshTryVar()
+    let tmpAlloca = hirAlloca(tmpName, operandType, loc)
+    let tmpVar = hirVar(tmpName, makePointer(operandType), loc)
+    let tmpStore = hirStore(tmpVar, operand, loc)
+
+    let tagPtr = HirNode(kind: hFieldPtr, fieldPtrBase: tmpVar, fieldName: "tag",
+                         typ: makePointer(makeNamed(typeName & "_Tag")), loc: loc)
+    let tagLoad = HirNode(kind: hLoad, loadPtr: tagPtr,
+                          typ: makeNamed(typeName & "_Tag"), loc: loc)
+    let errConst = hirVar(errTag, makeNamed(typeName & "_Tag"), loc)
+    let cond = hirBinary(tkEq, tagLoad, errConst, makeBool(), loc)
+
+    let retNode = hirReturn(tmpVar, loc)
+    let thenBlock = hirBlock(@[retNode], nil, makeVoid(), loc)
+    let ifNode = HirNode(kind: hIf, ifCond: cond, ifThen: thenBlock,
+                         ifElse: nil, typ: makeVoid(), loc: loc)
+
+    let dataPtr = HirNode(kind: hFieldPtr, fieldPtrBase: tmpVar, fieldName: "data",
+                          typ: makePointer(makeNamed(typeName & "_Data")), loc: loc)
+    let dataLoad = HirNode(kind: hLoad, loadPtr: dataPtr,
+                           typ: makeNamed(typeName & "_Data"), loc: loc)
+    let okPtr = HirNode(kind: hFieldPtr, fieldPtrBase: dataLoad, fieldName: okField,
+                        typ: makePointer(makeInt()), loc: loc)
+    let okLoad = HirNode(kind: hLoad, loadPtr: okPtr, typ: makeInt(), loc: loc)
+
+    ctx.pendingStmts.add(tmpAlloca)
+    ctx.pendingStmts.add(tmpStore)
+    ctx.pendingStmts.add(ifNode)
+    return okLoad
+
  of ekMatch:
    let subject = ctx.lowerExpr(expr.exprMatchSubject)
    var arms: seq[HirMatchArm] = @[]
@@ -434,8 +519,8 @@ proc lowerExpr(ctx: var LowerCtx, expr: Expr): HirNode =
    return lowerMatch(ctx, subject, arms, typ, loc)

  of ekSizeOf:
-    return HirNode(kind: hLit, litToken: Token(kind: tkIntLiteral, text: "0", loc: loc),
-                   typ: makeInt(), loc: loc)
+    let ty = ctx.resolveTypeExpr(expr.exprSizeOfType)
+    return HirNode(kind: hSizeOf, sizeOfType: ty, typ: makeInt(), loc: loc)

  of ekIntrinsic:
    return HirNode(kind: hLit, litToken: Token(kind: tkStringLiteral, text: "\"\"", loc: loc),
@@ -451,21 +536,20 @@ proc lowerStmt(ctx: var LowerCtx, stmt: Stmt): HirNode =

  case stmt.kind
  of skExpr:
-    return ctx.lowerExpr(stmt.stmtExpr)
+    return ctx.flushPending(ctx.lowerExpr(stmt.stmtExpr))

  of skLet:
    let initHir = ctx.lowerExpr(stmt.stmtLetInit)
    let allocaType = if stmt.stmtLetType != nil:
      case stmt.stmtLetType.kind
      of tekNamed:
-        case stmt.stmtLetType.typeName
-        of "int", "int32": makeInt()
-        of "int64": makeInt64()
-        of "float64": makeFloat64()
-        of "float32": makeFloat32()
-        of "bool": makeBool()
-        else: makeNamed(stmt.stmtLetType.typeName)
-      of tekPointer: makePointer(makeUnknown())
+        ctx.resolveTypeExpr(stmt.stmtLetType)
+      of tekPointer:
+        let pointeeType = ctx.resolveTypeExpr(stmt.stmtLetType.pointerPointee)
+        makePointer(pointeeType)
+      of tekSlice:
+        let elemType = ctx.resolveTypeExpr(stmt.stmtLetType.sliceElement)
+        makeSlice(elemType)
      else: makeUnknown()
    else:
      ctx.resolveExprType(stmt.stmtLetInit)
@@ -473,12 +557,15 @@ proc lowerStmt(ctx: var LowerCtx, stmt: Stmt): HirNode =
    let alloca = hirAlloca(stmt.stmtLetName, allocaType, loc)
    let varNode = hirVar(stmt.stmtLetName, makePointer(allocaType), loc)
    let store = hirStore(varNode, initHir, loc)
-    return HirNode(kind: hBlock, blockStmts: @[alloca, store],
-                   blockExpr: nil, typ: makeVoid(), loc: loc)
+    var stmts = ctx.pendingStmts
+    ctx.pendingStmts = @[]
+    stmts.add(alloca)
+    stmts.add(store)
+    return hirBlock(stmts, nil, makeVoid(), loc)

  of skReturn:
    let value = if stmt.stmtReturnValue != nil: ctx.lowerExpr(stmt.stmtReturnValue) else: nil
-    return hirReturn(value, loc)
+    return ctx.flushPending(hirReturn(value, loc))

  of skIf:
    let cond = ctx.lowerExpr(stmt.stmtIfCond)
@@ -496,26 +583,26 @@ proc lowerStmt(ctx: var LowerCtx, stmt: Stmt): HirNode =
        current = HirNode(kind: hIf, ifCond: elifCond, ifThen: elifBlock,
                         ifElse: current, typ: makeVoid(), loc: elifBranch.loc)
      elseBlock = current
-    return HirNode(kind: hIf, ifCond: cond, ifThen: thenBlock, ifElse: elseBlock,
-                   typ: makeVoid(), loc: loc)
+    return ctx.flushPending(HirNode(kind: hIf, ifCond: cond, ifThen: thenBlock, ifElse: elseBlock,
+                   typ: makeVoid(), loc: loc))

  of skWhile:
    let cond = ctx.lowerExpr(stmt.stmtWhileCond)
    let body = ctx.lowerBlock(stmt.stmtWhileBody)
-    return HirNode(kind: hWhile, whileCond: cond, whileBody: body,
-                   typ: makeVoid(), loc: loc)
+    return ctx.flushPending(HirNode(kind: hWhile, whileCond: cond, whileBody: body,
+                   typ: makeVoid(), loc: loc))

  of skLoop:
    let body = ctx.lowerBlock(stmt.stmtLoopBody)
-    return HirNode(kind: hLoop, loopBody: body, typ: makeVoid(), loc: loc)
+    return ctx.flushPending(HirNode(kind: hLoop, loopBody: body, typ: makeVoid(), loc: loc))

  of skBreak:
-    return HirNode(kind: hBreak, breakLabel: stmt.stmtBreakLabel,
-                   typ: makeVoid(), loc: loc)
+    return ctx.flushPending(HirNode(kind: hBreak, breakLabel: stmt.stmtBreakLabel,
+                   typ: makeVoid(), loc: loc))

  of skContinue:
-    return HirNode(kind: hContinue, continueLabel: stmt.stmtContinueLabel,
-                   typ: makeVoid(), loc: loc)
+    return ctx.flushPending(HirNode(kind: hContinue, continueLabel: stmt.stmtContinueLabel,
+                   typ: makeVoid(), loc: loc))

  of skFor:
    let iterExpr = stmt.stmtForIter
@@ -559,28 +646,28 @@ proc lowerStmt(ctx: var LowerCtx, stmt: Stmt): HirNode =
      
      # Wrap in a block so loop variable doesn't leak into outer scope
      let forBlock = hirBlock(@[initStmt, initStore, whileNode], nil, makeVoid(), loc, isScope = true)
-      return forBlock
+      return ctx.flushPending(forBlock)
    
    # Generic iterator for loop (simplified - just infinite loop for now)
    let loweredIter = ctx.lowerExpr(iterExpr)
    let loweredBody = ctx.lowerBlock(body)
-    return HirNode(kind: hLoop, loopBody: loweredBody, typ: makeVoid(), loc: loc)
+    return ctx.flushPending(HirNode(kind: hLoop, loopBody: loweredBody, typ: makeVoid(), loc: loc))

  of skDoWhile:
    let body = ctx.lowerBlock(stmt.stmtDoWhileBody)
    let cond = ctx.lowerExpr(stmt.stmtDoWhileCond)
    let whileNode = HirNode(kind: hWhile, whileCond: cond, whileBody: body,
                           typ: makeVoid(), loc: loc)
-    return HirNode(kind: hBlock, blockStmts: @[body, whileNode],
-                   blockExpr: nil, typ: makeVoid(), loc: loc)
+    return ctx.flushPending(HirNode(kind: hBlock, blockStmts: @[body, whileNode],
+                   blockExpr: nil, typ: makeVoid(), loc: loc))

  of skMatch:
    let subject = ctx.lowerExpr(stmt.stmtMatchSubject)
    var arms: seq[HirMatchArm] = @[]
    for arm in stmt.stmtMatchArms:
      arms.add(HirMatchArm(pattern: arm.pattern, body: ctx.lowerExpr(arm.body)))
-    return HirNode(kind: hMatch, matchSubject: subject, matchArms: arms,
-                   typ: makeVoid(), loc: loc)
+    return ctx.flushPending(HirNode(kind: hMatch, matchSubject: subject, matchArms: arms,
+                   typ: makeVoid(), loc: loc))

  of skDecl:
    return HirNode(kind: hLit, litToken: Token(kind: tkIntLiteral, text: "0", loc: loc),
@@ -642,14 +729,7 @@ proc lowerFunc*(ctx: var LowerCtx, decl: Decl): HirFunc =
        if ctx.typeSubst.hasKey(p.ptype.typeName):
          pType = ctx.typeSubst[p.ptype.typeName]
        else:
-          case p.ptype.typeName
-          of "int", "int32": pType = makeInt()
-          of "int64": pType = makeInt64()
-          of "float64": pType = makeFloat64()
-          of "float32": pType = makeFloat32()
-          of "bool": pType = makeBool()
-          of "Point", "Self": pType = makeNamed(p.ptype.typeName)
-          else: pType = makeNamed(p.ptype.typeName)
+          pType = ctx.resolveTypeExpr(p.ptype)
      of tekPointer:
        let pointeeType = ctx.resolveTypeExpr(p.ptype.pointerPointee)
        pType = makePointer(pointeeType)
@@ -664,13 +744,7 @@ proc lowerFunc*(ctx: var LowerCtx, decl: Decl): HirFunc =
      if ctx.typeSubst.hasKey(funcReturnType.typeName):
        retType = ctx.typeSubst[funcReturnType.typeName]
      else:
-        case funcReturnType.typeName
-        of "int", "int32": retType = makeInt()
-        of "int64": retType = makeInt64()
-        of "float64": retType = makeFloat64()
-        of "float32": retType = makeFloat32()
-        of "bool": retType = makeBool()
-        else: retType = makeNamed(funcReturnType.typeName)
+        retType = ctx.resolveTypeExpr(funcReturnType)
    of tekPointer:
      let pointeeType = ctx.resolveTypeExpr(funcReturnType.pointerPointee)
      retType = makePointer(pointeeType)
@@ -751,6 +825,8 @@ proc lowerModule*(module: Module, sema: Sema): HirModule =
      result.add(findGenericCalls(expr.exprBinaryRight))
    of ekUnary:
      result.add(findGenericCalls(expr.exprUnaryOperand))
+    of ekTry:
+      result.add(findGenericCalls(expr.exprTryOperand))
    of ekAssign:
      result.add(findGenericCalls(expr.exprAssignTarget))
      result.add(findGenericCalls(expr.exprAssignValue))
@@ -499,6 +499,9 @@ proc parsePostfix(p: var Parser): Expr =
      discard p.advance()
      let ty = p.parseType()
      left = Expr(kind: ekIs, loc: loc, exprIsOperand: left, exprIsType: ty)
+    of tkQuestion:
+      discard p.advance()
+      left = Expr(kind: ekTry, loc: loc, exprTryOperand: left, exprTryType: nil)
    of tkLBrace:
      if p.structInitAllowed and left.kind in {ekIdent, ekPath}:
        discard p.advance()
@@ -562,6 +562,11 @@ proc checkExpr(sema: var Sema, expr: Expr, scope: Scope): Type =
  of ekIs:
    discard sema.checkExpr(expr.exprIsOperand, scope)
    return makeBool()
+  of ekTry:
+    let operandType = sema.checkExpr(expr.exprTryOperand, scope)
+    # For now, assume Result<int, String> -> int
+    # TODO: check operand is Result/Option and current function returns same type
+    return makeInt()
  of ekBlock:
    var blockScope = newScope(scope)
    var lastType = makeVoid()