From 8fc48fc3572f97671bd5cde89195cf198bf7a856 Mon Sep 17 00:00:00 2001 From: Raphael Amorim Date: Thu, 21 May 2026 11:05:51 +0200 Subject: [PATCH] format code --- src/astgen.cpp | 60 +++++++++++++------------------ src/jam_llvm.cpp | 15 ++++---- src/jam_llvm.h | 9 ++--- src/jir_codegen.cpp | 12 +++---- src/parser.cpp | 4 +-- tests/cpp/test_codegen_errors.cpp | 5 ++- 6 files changed, 43 insertions(+), 62 deletions(-) diff --git a/src/astgen.cpp b/src/astgen.cpp index 5eb826b..b883a44 100644 --- a/src/astgen.cpp +++ b/src/astgen.cpp @@ -727,7 +727,7 @@ static void astgenVarDecl(AstGenCtx &gctx, const AstNode &n) { // expression at each read site. Constant folding makes this cheap; // non-constant inits would require a runtime global slot (deferred). static JirRef astgenVariable(AstGenCtx &gctx, const AstNode &n, - TypeIdx expected = kNoType) { + TypeIdx expected = kNoType) { const std::string &name = gctx.ctx.getStringPool().get(static_cast(n.lhs)); auto it = gctx.locals.find(name); @@ -751,15 +751,14 @@ static JirRef astgenVariable(AstGenCtx &gctx, const AstNode &n, // at this point in lowering. if (const FunctionAST *fn = gctx.ctx.getFunctionAST(name)) { if (fn->isGeneric()) { - return recoverHere(gctx, - "cannot take address of generic fn `" + name + - "`", - kNoType); + return recoverHere( + gctx, "cannot take address of generic fn `" + name + "`", + kNoType); } JirInst fnref{}; fnref.tag = JirTag::FnRef; - fnref.a = static_cast( - gctx.ctx.getStringPool().intern(fn->Name)); + fnref.a = + static_cast(gctx.ctx.getStringPool().intern(fn->Name)); // If the consumer asked for a Fn type, give them one; otherwise // fall back to u64 (legacy raw-address shape). Future cleanup: // always emit the typed Fn and let consumers cast to u64 @@ -785,8 +784,7 @@ static JirRef astgenVariable(AstGenCtx &gctx, const AstNode &n, // then-spill fallback, so misuse is reported as "not assignable" // rather than silently spilling into a temporary that dies at // expression-end. -static JirRef astgenLvalue(AstGenCtx &gctx, NodeIdx node, - TypeIdx &outLeafTy) { +static JirRef astgenLvalue(AstGenCtx &gctx, NodeIdx node, TypeIdx &outLeafTy) { const NodeStore &ns = gctx.ctx.getNodeStore(); const AstNode &n = ns.get(node); switch (n.tag) { @@ -842,9 +840,8 @@ static void astgenAssign(AstGenCtx &gctx, const AstNode &n) { astgenExpr(gctx, baseIdx, kNoType, ResultLoc::Pointer); baseTy = gctx.jfn.getInst(basePtr).ty; } - const auto *sinfo = baseTy != kNoType - ? gctx.ctx.lookupStruct(baseTy) - : nullptr; + const auto *sinfo = + baseTy != kNoType ? gctx.ctx.lookupStruct(baseTy) : nullptr; if (sinfo != nullptr) { const std::string qualified = sinfo->name + ".setAt"; const FunctionAST *method = gctx.ctx.getFunctionAST(qualified); @@ -1320,8 +1317,7 @@ static JirRef astgenIndex(AstGenCtx &gctx, const AstNode &n) { const TypeKey &lk = gctx.ctx.getTypePool().get(leafTy); if (lk.kind == TypeKind::Array) { TypeIdx elemTy = static_cast(lk.a); - JirRef idxRef = - astgenExpr(gctx, idxIdx, BuiltinType::U64); + JirRef idxRef = astgenExpr(gctx, idxIdx, BuiltinType::U64); TypeIdx elemPtrTy = gctx.ctx.getTypePool().intern( TypeKey{TypeKind::PtrSingle, 0, 0, elemTy, 0}); JirInst ia{}; @@ -3295,10 +3291,10 @@ static JirRef astgenCall(AstGenCtx &gctx, const AstNode &n) { recvNode.tag == AstTag::MemberAccess || recvNode.tag == AstTag::Index || recvNode.tag == AstTag::Deref; - if (recvIsLvalueable && (methodName == "asPtr" || - methodName == "asMutPtr")) { - JirRef basePtr = astgenExpr(gctx, recvExprIdx, kNoType, - ResultLoc::Pointer); + if (recvIsLvalueable && + (methodName == "asPtr" || methodName == "asMutPtr")) { + JirRef basePtr = + astgenExpr(gctx, recvExprIdx, kNoType, ResultLoc::Pointer); TypeIdx leafTy = gctx.jfn.getInst(basePtr).ty; const TypeKey &lk = gctx.ctx.getTypePool().get(leafTy); if (lk.kind == TypeKind::Array) { @@ -3607,8 +3603,7 @@ static JirRef astgenCall(AstGenCtx &gctx, const AstNode &n) { const TypeKey &instKey = gctx.ctx.getTypePool().get(instTy); if (instKey.kind == TypeKind::Array) { if (methodName == "asPtr" || methodName == "asMutPtr") { - TypeIdx elemTy = - static_cast(instKey.a); + TypeIdx elemTy = static_cast(instKey.a); TypeIdx ptrTy = gctx.ctx.getTypePool().intern( TypeKey{TypeKind::PtrMany, 0, 0, elemTy, 0}); JirInst zeroI{}; @@ -3740,8 +3735,7 @@ static JirRef astgenCall(AstGenCtx &gctx, const AstNode &n) { for (size_t i = 0; i < sinfo->fields.size(); ++i) { if (sinfo->fields[i].first != fieldName) continue; TypeIdx fieldTy = sinfo->fields[i].second; - const TypeKey &fk = - gctx.ctx.getTypePool().get(fieldTy); + const TypeKey &fk = gctx.ctx.getTypePool().get(fieldTy); if (fk.kind != TypeKind::Fn) break; // Load recv as a value, ExtractValue the field. JirInst loadRecv{}; @@ -3827,8 +3821,8 @@ static JirRef astgenExpr(AstGenCtx &gctx, NodeIdx node, TypeIdx expected, } case AstTag::Deref: { // `p.* = ...` — operand IS the pointer value. - JirRef innerPtr = astgenExpr( - gctx, static_cast(n.lhs), kNoType); + JirRef innerPtr = + astgenExpr(gctx, static_cast(n.lhs), kNoType); TypeIdx pty = gctx.jfn.getInst(innerPtr).ty; const TypeKey &pk = gctx.ctx.getTypePool().get(pty); if (pk.kind != TypeKind::PtrSingle && @@ -3841,9 +3835,8 @@ static JirRef astgenExpr(AstGenCtx &gctx, NodeIdx node, TypeIdx expected, } case AstTag::MemberAccess: { TypeIdx baseTy = kNoType; - JirRef basePtr = - astgenExpr(gctx, static_cast(n.lhs), kNoType, - ResultLoc::Pointer, &baseTy); + JirRef basePtr = astgenExpr(gctx, static_cast(n.lhs), + kNoType, ResultLoc::Pointer, &baseTy); StringIdx memberId = static_cast(n.rhs); const std::string &memberName = gctx.ctx.getStringPool().get(memberId); @@ -3889,21 +3882,18 @@ static JirRef astgenExpr(AstGenCtx &gctx, NodeIdx node, TypeIdx expected, } case AstTag::Index: { TypeIdx baseTy = kNoType; - JirRef basePtr = - astgenExpr(gctx, static_cast(n.lhs), kNoType, - ResultLoc::Pointer, &baseTy); + JirRef basePtr = astgenExpr(gctx, static_cast(n.lhs), + kNoType, ResultLoc::Pointer, &baseTy); NodeIdx idxIdxN = static_cast(n.rhs); JirRef idxRef = astgenExpr(gctx, idxIdxN, BuiltinType::U64); const TypeKey &lk = gctx.ctx.getTypePool().get(baseTy); TypeIdx elemTy = kNoType; - if (lk.kind == TypeKind::Array || - lk.kind == TypeKind::Slice || + if (lk.kind == TypeKind::Array || lk.kind == TypeKind::Slice || lk.kind == TypeKind::PtrMany) { elemTy = static_cast(lk.a); } else { - failHere( - gctx, - "astgen: lvalue index on non-array/slice/ptr-many"); + failHere(gctx, + "astgen: lvalue index on non-array/slice/ptr-many"); } // PtrMany base: the alloca holds the pointer value // itself; Load to follow it. Array base: alloca holds diff --git a/src/jam_llvm.cpp b/src/jam_llvm.cpp index 964efdf..dca9b0e 100644 --- a/src/jam_llvm.cpp +++ b/src/jam_llvm.cpp @@ -792,18 +792,17 @@ JamValueRef JamLLVMBuildCall(JamBuilderRef builder, JamFunctionRef func, // address (an opaque ptr under LLVM 15+). Used to lower JirTag:: // CallIndirect, where the JIR's Fn type is the source of truth for // the LLVM function-type the call instruction needs. -JamValueRef JamLLVMBuildIndirectCall(JamBuilderRef builder, - JamTypeRef funcType, JamValueRef callee, - JamValueRef *args, unsigned numArgs, - const char *name) { +JamValueRef JamLLVMBuildIndirectCall(JamBuilderRef builder, JamTypeRef funcType, + JamValueRef callee, JamValueRef *args, + unsigned numArgs, const char *name) { std::vector argValues; for (unsigned i = 0; i < numArgs; i++) { argValues.push_back(UNWRAP_VALUE(args[i])); } llvm::FunctionType *ft = llvm::cast(UNWRAP_TYPE(funcType)); - return WRAP_VALUE(UNWRAP_BUILDER(builder)->CreateCall(ft, UNWRAP_VALUE(callee), - argValues, name)); + return WRAP_VALUE(UNWRAP_BUILDER(builder)->CreateCall( + ft, UNWRAP_VALUE(callee), argValues, name)); } JamValueRef JamLLVMBuildPhi(JamBuilderRef builder, JamTypeRef type, @@ -834,13 +833,13 @@ JamValueRef JamLLVMBuildIntCast(JamBuilderRef builder, JamValueRef val, } JamValueRef JamLLVMBuildPtrToInt(JamBuilderRef builder, JamValueRef val, - JamTypeRef destType, const char *name) { + JamTypeRef destType, const char *name) { return WRAP_VALUE(UNWRAP_BUILDER(builder)->CreatePtrToInt( UNWRAP_VALUE(val), UNWRAP_TYPE(destType), name)); } JamValueRef JamLLVMBuildIntToPtr(JamBuilderRef builder, JamValueRef val, - JamTypeRef destType, const char *name) { + JamTypeRef destType, const char *name) { return WRAP_VALUE(UNWRAP_BUILDER(builder)->CreateIntToPtr( UNWRAP_VALUE(val), UNWRAP_TYPE(destType), name)); } diff --git a/src/jam_llvm.h b/src/jam_llvm.h index 1191d7c..123f4e0 100644 --- a/src/jam_llvm.h +++ b/src/jam_llvm.h @@ -325,12 +325,9 @@ JAM_EXTERN_C JamValueRef JamLLVMBuildCall(JamBuilderRef builder, // FunctionType built from the Jam-level Fn TypeIdx (return + params); // `callee` is the ptr-typed Value holding the code address. Used by // JirTag::CallIndirect lowering. -JAM_EXTERN_C JamValueRef JamLLVMBuildIndirectCall(JamBuilderRef builder, - JamTypeRef funcType, - JamValueRef callee, - JamValueRef *args, - unsigned numArgs, - const char *name); +JAM_EXTERN_C JamValueRef JamLLVMBuildIndirectCall( + JamBuilderRef builder, JamTypeRef funcType, JamValueRef callee, + JamValueRef *args, unsigned numArgs, const char *name); JAM_EXTERN_C JamValueRef JamLLVMBuildPhi(JamBuilderRef builder, JamTypeRef type, const char *name); JAM_EXTERN_C void JamLLVMAddIncoming(JamValueRef phi, JamValueRef *values, diff --git a/src/jir_codegen.cpp b/src/jir_codegen.cpp index f276a27..f472f79 100644 --- a/src/jir_codegen.cpp +++ b/src/jir_codegen.cpp @@ -667,9 +667,8 @@ static JamValueRef emitInstImpl(JirCodegenCtx &lctx, JirRef r) { for (TypeIdx pt : paramTys) { llvmParamTys.push_back(lctx.ctx.getLLVMType(pt)); } - JamTypeRef llvmRetTy = (retTy == kNoType) - ? lctx.ctx.getVoidType() - : lctx.ctx.getLLVMType(retTy); + JamTypeRef llvmRetTy = (retTy == kNoType) ? lctx.ctx.getVoidType() + : lctx.ctx.getLLVMType(retTy); JamTypeRef llvmFnTy = JamLLVMFunctionType( llvmRetTy, llvmParamTys.data(), static_cast(llvmParamTys.size()), /*isVarArgs=*/false); @@ -685,10 +684,9 @@ static JamValueRef emitInstImpl(JirCodegenCtx &lctx, JirRef r) { } const char *resultName = (inst.ty == kNoType) ? "" : "call.indirect"; - return JamLLVMBuildIndirectCall(lctx.ctx.getBuilder(), llvmFnTy, - calleeVal, args.data(), - static_cast(args.size()), - resultName); + return JamLLVMBuildIndirectCall( + lctx.ctx.getBuilder(), llvmFnTy, calleeVal, args.data(), + static_cast(args.size()), resultName); } // === Control === case JirTag::Br: { diff --git a/src/parser.cpp b/src/parser.cpp index dc91b01..a19a85b 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -571,9 +571,7 @@ TypeIdx Parser::parseType() { consume(TOK_OPEN_PAREN, "Expected `(` after `fn` in type"); std::vector paramTys; if (!check(TOK_CLOSE_PAREN)) { - do { - paramTys.push_back(parseType()); - } while (match(TOK_COMMA)); + do { paramTys.push_back(parseType()); } while (match(TOK_COMMA)); } consume(TOK_CLOSE_PAREN, "Expected `)` after fn-type parameters"); TypeIdx retTy = parseType(); diff --git a/tests/cpp/test_codegen_errors.cpp b/tests/cpp/test_codegen_errors.cpp index ab0c73a..6bc383c 100644 --- a/tests/cpp/test_codegen_errors.cpp +++ b/tests/cpp/test_codegen_errors.cpp @@ -169,9 +169,8 @@ class CodegenErrorTests { framework.addTest( "FnRef - generic fn rejected with `cannot take address` diagnostic", testFnRefGenericRejected); - framework.addTest( - "FnRef - ptr as u32 (narrower than u64) is rejected", - testPtrAsNarrowIntRejected); + framework.addTest("FnRef - ptr as u32 (narrower than u64) is rejected", + testPtrAsNarrowIntRejected); framework.addTest( "FnRef - u32 as *mut[] u8 (narrower than u64) is rejected", testNarrowIntAsPtrRejected); -- 2.51.2