diff --git a/evaluation/c/verified/20251226_RepoRepair_Claude-4-Sonnet/all_preds.jsonl b/evaluation/c/verified/20251226_RepoRepair_Claude-4-Sonnet/all_preds.jsonl new file mode 100644 index 000000000..d7c4404c8 --- /dev/null +++ b/evaluation/c/verified/20251226_RepoRepair_Claude-4-Sonnet/all_preds.jsonl @@ -0,0 +1,110 @@ +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1008", "model_patch": "--- a/lib/compress/zstdmt_compress.c\n+++ b/lib/compress/zstdmt_compress.c\n@@ -352,7 +352,8 @@\n \n /* init */\n if (job->cdict) {\n- size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dm_auto, job->cdict, job->params, job->fullFrameSize);\n+ ZSTD_CCtx_params jobParams = ZSTDMT_initJobCCtxParams(job->params);\n+ size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dm_auto, job->cdict, jobParams, job->fullFrameSize);\n assert(job->firstJob); /* only allowed for first job */\n if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }\n } else { /* srcStart points at reloaded section */\n\n--- a/lib/compress/zstd_compress.c\n+++ b/lib/compress/zstd_compress.c\n@@ -1174,9 +1174,9 @@\n }\n \n /* copy tables */\n- { size_t const chainSize = (srcCCtx->appliedParams.cParams.strategy == ZSTD_fast) ? 0 : ((size_t)1 << srcCCtx->appliedParams.cParams.chainLog);\n- size_t const hSize = (size_t)1 << srcCCtx->appliedParams.cParams.hashLog;\n- size_t const h3Size = (size_t)1 << srcCCtx->blockState.matchState.hashLog3;\n+ { size_t const chainSize = (dstCCtx->appliedParams.cParams.strategy == ZSTD_fast) ? 0 : ((size_t)1 << dstCCtx->appliedParams.cParams.chainLog);\n+ size_t const hSize = (size_t)1 << dstCCtx->appliedParams.cParams.hashLog;\n+ size_t const h3Size = (size_t)1 << dstCCtx->blockState.matchState.hashLog3;\n size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);\n assert((U32*)dstCCtx->blockState.matchState.chainTable == (U32*)dstCCtx->blockState.matchState.hashTable + hSize); /* chainTable must follow hashTable */\n assert((U32*)dstCCtx->blockState.matchState.hashTable3 == (U32*)dstCCtx->blockState.matchState.chainTable + chainSize);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1080", "model_patch": "--- a/lib/decompress/zstd_decompress.c\n+++ b/lib/decompress/zstd_decompress.c\n@@ -298,7 +298,8 @@\n \n /** ZSTD_frameHeaderSize() :\n * srcSize must be >= ZSTD_frameHeaderSize_prefix.\n- * @return : size of the Frame Header */\n+ * @return : size of the Frame Header\n+ * or an error code, which can be tested with ZSTD_isError() */\n size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)\n {\n return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1105", "model_patch": "--- a/lib/compress/zstd_compress.c\n+++ b/lib/compress/zstd_compress.c\n@@ -330,6 +330,117 @@\n case ZSTD_p_ldmHashEveryLog:\n if (cctx->cdict) return ERROR(stage_wrong);\n return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);\n+\n+ default: return ERROR(parameter_unsupported);\n+ }\n+}\n+\n+size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned* value)\n+{\n+ DEBUGLOG(4, \"ZSTD_CCtx_getParameter (%u)\", (U32)param);\n+ if (!value) return ERROR(GENERIC);\n+\n+ switch(param)\n+ {\n+ case ZSTD_p_format :\n+ *value = (unsigned)cctx->requestedParams.format;\n+ return 0;\n+\n+ case ZSTD_p_compressionLevel:\n+ *value = (unsigned)cctx->requestedParams.compressionLevel;\n+ return 0;\n+\n+ case ZSTD_p_windowLog:\n+ *value = cctx->requestedParams.cParams.windowLog;\n+ return 0;\n+\n+ case ZSTD_p_hashLog:\n+ *value = cctx->requestedParams.cParams.hashLog;\n+ return 0;\n+\n+ case ZSTD_p_chainLog:\n+ *value = cctx->requestedParams.cParams.chainLog;\n+ return 0;\n+\n+ case ZSTD_p_searchLog:\n+ *value = cctx->requestedParams.cParams.searchLog;\n+ return 0;\n+\n+ case ZSTD_p_minMatch:\n+ *value = cctx->requestedParams.cParams.searchLength;\n+ return 0;\n+\n+ case ZSTD_p_targetLength:\n+ *value = cctx->requestedParams.cParams.targetLength;\n+ return 0;\n+\n+ case ZSTD_p_compressionStrategy:\n+ *value = (unsigned)cctx->requestedParams.cParams.strategy;\n+ return 0;\n+\n+ case ZSTD_p_compressLiterals:\n+ *value = !cctx->requestedParams.disableLiteralCompression;\n+ return 0;\n+\n+ case ZSTD_p_contentSizeFlag:\n+ *value = cctx->requestedParams.fParams.contentSizeFlag;\n+ return 0;\n+\n+ case ZSTD_p_checksumFlag:\n+ *value = cctx->requestedParams.fParams.checksumFlag;\n+ return 0;\n+\n+ case ZSTD_p_dictIDFlag:\n+ *value = !cctx->requestedParams.fParams.noDictIDFlag;\n+ return 0;\n+\n+ case ZSTD_p_forceMaxWindow:\n+ *value = cctx->requestedParams.forceWindow;\n+ return 0;\n+\n+ case ZSTD_p_nbWorkers:\n+#ifdef ZSTD_MULTITHREAD\n+ *value = cctx->requestedParams.nbWorkers;\n+#else\n+ *value = 0;\n+#endif\n+ return 0;\n+\n+ case ZSTD_p_jobSize:\n+#ifdef ZSTD_MULTITHREAD\n+ *value = cctx->requestedParams.jobSize;\n+#else\n+ return ERROR(parameter_unsupported);\n+#endif\n+ return 0;\n+\n+ case ZSTD_p_overlapSizeLog:\n+#ifdef ZSTD_MULTITHREAD\n+ *value = cctx->requestedParams.overlapSizeLog;\n+#else\n+ return ERROR(parameter_unsupported);\n+#endif\n+ return 0;\n+\n+ case ZSTD_p_enableLongDistanceMatching:\n+ *value = cctx->requestedParams.ldmParams.enableLdm;\n+ return 0;\n+\n+ case ZSTD_p_ldmHashLog:\n+ *value = cctx->requestedParams.ldmParams.hashLog;\n+ return 0;\n+\n+ case ZSTD_p_ldmMinMatch:\n+ *value = cctx->requestedParams.ldmParams.minMatchLength;\n+ return 0;\n+\n+ case ZSTD_p_ldmBucketSizeLog:\n+ *value = cctx->requestedParams.ldmParams.bucketSizeLog;\n+ return 0;\n+\n+ case ZSTD_p_ldmHashEveryLog:\n+ *value = cctx->requestedParams.ldmParams.hashEveryLog;\n+ return 0;\n \n default: return ERROR(parameter_unsupported);\n }\n\n--- a/lib/compress/zstd_compress.c\n+++ b/lib/compress/zstd_compress.c\n@@ -577,6 +577,14 @@\n {\n ZSTD_startNewCompression(cctx);\n cctx->cdict = NULL;\n+}\n+\n+/*! ZSTD_CCtx_isResetNeeded() :\n+ * @return : 1 if reset is needed before starting a new compression operation, 0 otherwise */\n+int ZSTD_CCtx_isResetNeeded(const ZSTD_CCtx* cctx)\n+{\n+ /* Context is ready for a new operation if it's in init or created stage */\n+ return (cctx->streamStage != zcss_init) && (cctx->stage != ZSTDcs_init) && (cctx->stage != ZSTDcs_created);\n }\n \n /** ZSTD_checkCParams() :\n\n--- a/lib/decompress/zstd_decompress.c\n+++ b/lib/decompress/zstd_decompress.c\n@@ -3002,3 +3002,15 @@\n dctx->format = ZSTD_f_zstd1;\n dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;\n }\n+\n+/*! ZSTD_DCtx_isResetNeeded() :\n+ * Checks if the decompression context needs to be reset before starting a new operation.\n+ * @return : 1 if reset is needed (context is in the middle of an operation)\n+ * 0 if context is ready for a new operation (no reset needed)\n+ * Note: This function helps callers determine if ZSTD_DCtx_reset() should be called\n+ * before starting a new decompression operation. */\n+int ZSTD_DCtx_isResetNeeded(const ZSTD_DCtx* dctx)\n+{\n+ /* Context is ready for new operation if it's in initial state */\n+ return (dctx->streamStage != zdss_init);\n+}\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1106", "model_patch": "--- a/lib/zstd.h\n+++ b/lib/zstd.h\n@@ -1079,13 +1079,25 @@\n \n /*! ZSTD_CCtx_setPledgedSrcSize() :\n * Total input data size to be compressed as a single frame.\n- * This value will be controlled at the end, and result in error if not respected.\n+ * Value will be written in frame header, unless if explicitly forbidden using ZSTD_p_contentSizeFlag.\n+ * This value will also be controlled at the end, and trigger an error if not respected.\n * @result : 0, or an error code (which can be tested with ZSTD_isError()).\n- * Note 1 : 0 means zero, empty.\n+ * Note 1 : pledgedSrcSize==0 actually means zero, empty.\n * In order to mean \"unknown content size\", pass constant ZSTD_CONTENTSIZE_UNKNOWN.\n * ZSTD_CONTENTSIZE_UNKNOWN is default value for any new compression job.\n- * Note 2 : If all data is provided and consumed in a single round,\n- * this value is overriden by srcSize instead. */\n+ * Note 2 : pledgedSrcSize is only valid for a single frame.\n+ * It is discarded at the end of each frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN.\n+ * Note 3 : Whenever all input data is provided and consumed in a single round,\n+ * for example with ZSTD_compress2(),\n+ * or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),\n+ * this pledge is ignored, and replaced by srcSize,\n+ * since the actual srcSize is necessarily known.\n+ * In such cases, the pledged value is only used to enable or disable writing of the content size field into the frame header.\n+ * Note 4 : When frame content size is not known (ZSTD_CONTENTSIZE_UNKNOWN),\n+ * but ZSTD_p_contentSizeFlag is enabled (default),\n+ * pledgedSrcSize verification is not enforced.\n+ * Only when pledgedSrcSize is specified and frame content size flag is enabled\n+ * will the size be verified at compression completion. */\n ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);\n \n /*! ZSTD_CCtx_loadDictionary() :\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1107", "model_patch": "--- a/lib/zstd.h\n+++ b/lib/zstd.h\n@@ -1142,8 +1142,9 @@\n * Useful after an error, or to interrupt an ongoing compression job and start a new one.\n * Any internal data not yet flushed is cancelled.\n * Dictionary (if any) is dropped.\n- * All parameters are back to default values (compression level is ZSTD_CLEVEL_DEFAULT).\n- * After a reset, all compression parameters can be modified again.\n+ * Parameters set using ZSTD_CCtx_setParameter() and similar functions are preserved.\n+ * Only the internal stream stage and pledged source size are reset.\n+ * After a reset, compression parameters can still be modified.\n */\n ZSTDLIB_API void ZSTD_CCtx_reset(ZSTD_CCtx* cctx);\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1243", "model_patch": "--- a/lib/compress/zstd_lazy.c\n+++ b/lib/compress/zstd_lazy.c\n@@ -636,7 +636,7 @@\n \n /* init */\n ip += (dictAndPrefixLength == 0);\n- ms->nextToUpdate3 = ms->nextToUpdate;\n+ ms->nextToUpdate3 = (U32)(ip - base);\n if (dictMode == ZSTD_noDict) {\n U32 const maxRep = (U32)(ip - prefixLowest);\n if (offset_2 > maxRep) savedOffset = offset_2, offset_2 = 0;\n\n--- a/lib/compress/zstd_ldm.c\n+++ b/lib/compress/zstd_ldm.c\n@@ -499,6 +499,8 @@\n U32 const correction = ZSTD_window_correctOverflow(\n &ldmState->window, /* cycleLog */ 0, maxDist, src);\n ZSTD_ldm_reduceTable(ldmState->hashTable, ldmHSize, correction);\n+ /* Reset bucket offsets after reducing table */\n+ memset(ldmState->bucketOffsets, 0, ldmHSize);\n }\n /* 2. We enforce the maximum offset allowed.\n *\n\n--- a/lib/compress/zstd_opt.c\n+++ b/lib/compress/zstd_opt.c\n@@ -796,6 +796,10 @@\n DEBUGLOG(5, \"ZSTD_compressBlock_opt_generic\");\n assert(optLevel <= 2);\n ms->nextToUpdate3 = ms->nextToUpdate;\n+ /* Ensure deterministic behavior: if we're starting from the beginning, clear stats */\n+ if (ip == prefixStart && ms->nextToUpdate == ms->window.dictLimit) {\n+ optStatePtr->litLengthSum = 0;\n+ }\n ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel);\n ip += (ip==prefixStart);\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1390", "model_patch": "--- a/lib/decompress/zstd_decompress.c\n+++ b/lib/decompress/zstd_decompress.c\n@@ -459,8 +459,11 @@\n static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,\n const void* src, size_t srcSize)\n {\n- if (dst==NULL) return ERROR(dstSize_tooSmall);\n if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);\n+ if (dst==NULL) {\n+ if (srcSize > 0) return ERROR(dstSize_tooSmall);\n+ return 0;\n+ }\n memcpy(dst, src, srcSize);\n return srcSize;\n }\n\n--- a/lib/legacy/zstd_v07.c\n+++ b/lib/legacy/zstd_v07.c\n@@ -2521,17 +2521,17 @@\n static const decompressionAlgo decompress[2] = { HUFv07_decompress4X2, HUFv07_decompress4X4 };\n \n /* validation checks */\n+ if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */\n+ if (cSrcSize == dstSize) { if (dstSize == 0) return 0; memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */\n+ if (cSrcSize == 1) { if (dstSize == 0) return 0; memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */\n if (dstSize == 0) return ERROR(dstSize_tooSmall);\n- if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */\n- if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */\n- if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */\n \n { U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);\n return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);\n }\n \n //return HUFv07_decompress4X2(dst, dstSize, cSrc, cSrcSize); /* multi-streams single-symbol decoding */\n- //return HUFv07_decompress4X4(dst, dstSize, cSrc, cSrcSize); /* multi-streams double-symbols decoding */\n+ //return HUFv07_decompress4X4(dst, dstSize, cSrc, cSrcSize); /* multi-streams double-symbols decoder */\n }\n \n size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1416", "model_patch": "--- a/lib/zstd.h\n+++ b/lib/zstd.h\n@@ -76,10 +76,9 @@\n #define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)\n ZSTDLIB_API unsigned ZSTD_versionNumber(void); /**< useful to check dll version */\n \n-#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE\n #define ZSTD_QUOTE(str) #str\n #define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str)\n-#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION)\n+#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_VERSION_MAJOR) \".\" ZSTD_EXPAND_AND_QUOTE(ZSTD_VERSION_MINOR) \".\" ZSTD_EXPAND_AND_QUOTE(ZSTD_VERSION_RELEASE)\n ZSTDLIB_API const char* ZSTD_versionString(void); /* v1.3.0+ */\n \n /***************************************\n\n--- a/programs/zstdcli.c\n+++ b/programs/zstdcli.c\n@@ -1067,9 +1067,9 @@\n #ifndef ZSTD_NODECOMPRESS\n if (memLimit == 0) {\n if (compressionParams.windowLog == 0)\n- memLimit = (U32)1 << g_defaultMaxWindowLog;\n+ memLimit = (U32)((U64)1 << g_defaultMaxWindowLog);\n else {\n- memLimit = (U32)1 << (compressionParams.windowLog & 31);\n+ memLimit = (U32)((U64)1 << (compressionParams.windowLog & 31));\n }\n }\n FIO_setMemLimit(memLimit);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1459", "model_patch": "--- a/programs/fileio.c\n+++ b/programs/fileio.c\n@@ -1112,6 +1112,22 @@\n assert(ress.srcFile != NULL);\n \n if (ress.dstFile == NULL) {\n+ /* Check if source and destination are the same file */\n+ if (strcmp(srcFileName, stdinmark) && strcmp(dstFileName, stdoutmark)) {\n+ stat_t srcStatbuf, dstStatbuf;\n+ if (UTIL_getFileStat(srcFileName, &srcStatbuf) && UTIL_getFileStat(dstFileName, &dstStatbuf)) {\n+ /* Both files exist, check if they're the same */\n+#if defined(_MSC_VER)\n+ if (srcStatbuf.st_dev == dstStatbuf.st_dev && srcStatbuf.st_ino == dstStatbuf.st_ino) {\n+#else\n+ if (srcStatbuf.st_dev == dstStatbuf.st_dev && srcStatbuf.st_ino == dstStatbuf.st_ino) {\n+#endif\n+ DISPLAYLEVEL(1, \"zstd: %s: cannot write to same file as input \\n\", dstFileName);\n+ return 1;\n+ }\n+ }\n+ }\n+ \n closeDstFile = 1;\n DISPLAYLEVEL(6, \"FIO_compressFilename_dstFile: opening dst: %s\", dstFileName);\n ress.dstFile = FIO_openDstFile(dstFileName);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1530", "model_patch": "--- a/lib/compress/zstdmt_compress.c\n+++ b/lib/compress/zstdmt_compress.c\n@@ -861,13 +861,14 @@\n \n \n /* ZSTDMT_CCtxParam_setNbWorkers():\n- * Internal use only */\n+ * Internal use only\n+ * Note: When changing nbWorkers, this function does NOT reset overlapLog or jobSize.\n+ * These parameters are independent and should be set separately.\n+ * Initial values (overlapLog=0, jobSize=0) mean \"use automatic defaults\". */\n size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers)\n {\n if (nbWorkers > ZSTDMT_NBWORKERS_MAX) nbWorkers = ZSTDMT_NBWORKERS_MAX;\n params->nbWorkers = nbWorkers;\n- params->overlapLog = ZSTDMT_OVERLAPLOG_DEFAULT;\n- params->jobSize = 0;\n return nbWorkers;\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1726", "model_patch": "--- a/programs/benchzstd.c\n+++ b/programs/benchzstd.c\n@@ -419,6 +419,7 @@\n cctxprep.cLevel = cLevel;\n cctxprep.comprParams = comprParams;\n cctxprep.adv = adv;\n+ cctxprep.srcSize = srcSize;\n \n dbp.benchFn = local_defaultDecompress;\n dbp.benchPayload = dctx;\n\n--- a/programs/fileio.c\n+++ b/programs/fileio.c\n@@ -700,7 +700,6 @@\n /* dictionary */\n CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, srcSize) ); /* set the value temporarily for dictionary loading, to adapt compression parameters */\n CHECK( ZSTD_CCtx_loadDictionary(ress.cctx, dictBuffer, dictBuffSize) );\n- CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, ZSTD_CONTENTSIZE_UNKNOWN) ); /* reset */\n \n free(dictBuffer);\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-1733", "model_patch": "--- a/lib/compress/zstd_compress.c\n+++ b/lib/compress/zstd_compress.c\n@@ -3634,7 +3634,10 @@\n memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict)); /* single usage */\n assert(prefixDict.dict==NULL || cctx->cdict==NULL); /* only one can be set */\n DEBUGLOG(4, \"ZSTD_compressStream2 : transparent init stage\");\n- if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1; /* auto-fix pledgedSrcSize */\n+ if (endOp == ZSTD_e_end) {\n+ cctx->pledgedSrcSizePlusOne = input->size + 1; /* auto-fix pledgedSrcSize */\n+ params.fParams.contentSizeFlag = 1; /* known size, can enable content size flag */\n+ }\n params.cParams = ZSTD_getCParamsFromCCtxParams(\n &cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/);\n \n\n--- a/programs/benchzstd.c\n+++ b/programs/benchzstd.c\n@@ -233,6 +233,7 @@\n void* addArgs)\n {\n ZSTD_CCtx* const cctx = (ZSTD_CCtx*)addArgs;\n+ ZSTD_CCtx_setPledgedSrcSize(cctx, srcSize);\n return ZSTD_compress2(cctx, dstBuffer, dstSize, srcBuffer, srcSize);\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-2094", "model_patch": "--- a/lib/zstd.h\n+++ b/lib/zstd.h\n@@ -754,6 +754,16 @@\n * or any other value > 0, which means there is still some decoding or flushing to do to complete current frame :\n * the return value is a suggested next input size (just a hint for better latency)\n * that will never request more than the remaining frame size.\n+*\n+* Memory requirements for streaming decompression:\n+* - Input data does NOT need to be preserved after being consumed by ZSTD_decompressStream().\n+* Once input.pos advances, that input data can be discarded/overwritten.\n+* - The decompressor maintains an internal window buffer (size determined by the windowSize parameter\n+* from compression) to store previously decompressed output for back-references.\n+* - You can decompress from a non-memory-mapped stream (e.g., serial input) to a fixed output buffer.\n+* This is the primary use case for streaming decompression.\n+* - For embedded systems with limited RAM: allocate the output buffer in main memory and the\n+* DCtx (which includes the window buffer) can use SRAM if available.\n * *******************************************************************************/\n \n typedef ZSTD_DCtx ZSTD_DStream; /**< DCtx and DStream are now effectively same object (>= v1.3.0) */\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-2130", "model_patch": "--- a/lib/zstd.h\n+++ b/lib/zstd.h\n@@ -1338,6 +1338,10 @@\n * ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().\n * Limitation 2 : static cctx currently not compatible with multi-threading.\n * Limitation 3 : static dctx is incompatible with legacy support.\n+ * Limitation 4 : when using ZSTD_compressCCtx() with a static context, the context must be\n+ * initialized with ZSTD_compressBegin() or similar before each compression,\n+ * otherwise memory allocation errors may occur. Consider using ZSTD_compress2()\n+ * with the advanced API for better control with static contexts.\n */\n ZSTDLIB_API ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize);\n ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticCCtx() */\n\n--- a/programs/fileio.c\n+++ b/programs/fileio.c\n@@ -1195,7 +1195,12 @@\n \n DISPLAYLEVEL(6, \"compression using zstd format \\n\");\n \n- /* init */\n+ /* init - Note: For context reuse (especially with static contexts from ZSTD_initStaticCCtx),\n+ * the context should be reset before each compression session. This is handled internally\n+ * by ZSTD_CCtx_setPledgedSrcSize() or can be done explicitly with ZSTD_CCtx_reset().\n+ * When using the simple API ZSTD_compressCCtx() with static contexts, you must call\n+ * ZSTD_compressBegin() or ZSTD_CCtx_reset() before each compression to avoid\n+ * memory allocation errors. */\n if (fileSize != UTIL_FILESIZE_UNKNOWN) {\n CHECK(ZSTD_CCtx_setPledgedSrcSize(ress.cctx, fileSize));\n } else if (prefs->streamSrcSize > 0) {\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-2451", "model_patch": "--- a/lib/compress/zstd_compress.c\n+++ b/lib/compress/zstd_compress.c\n@@ -1188,12 +1188,12 @@\n const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);\n assert(ZSTD_checkCParams(cPar)==0);\n \n- if (dictSize && srcSize == ZSTD_CONTENTSIZE_UNKNOWN)\n- srcSize = minSrcSize;\n-\n switch (mode) {\n case ZSTD_cpm_noAttachDict:\n case ZSTD_cpm_unknown:\n+ if (dictSize && srcSize == ZSTD_CONTENTSIZE_UNKNOWN)\n+ srcSize = minSrcSize;\n+ break;\n case ZSTD_cpm_createCDict:\n break;\n case ZSTD_cpm_attachDict:\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-3223", "model_patch": "--- a/programs/fileio.c\n+++ b/programs/fileio.c\n@@ -2391,7 +2391,7 @@\n DISPLAYLEVEL(1, \"zstd: %s: lz4 file cannot be uncompressed (zstd compiled without HAVE_LZ4) -- ignored \\n\", srcFileName);\n return 1;\n #endif\n- } else if ((prefs->overwrite) && !strcmp (dstFileName, stdoutmark)) { /* pass-through mode */\n+ } else if (prefs->overwrite) { /* pass-through mode */\n return FIO_passThrough(&ress);\n } else {\n DISPLAYLEVEL(1, \"zstd: %s: unsupported format \\n\", srcFileName);\n\n--- a/programs/zstdcli.c\n+++ b/programs/zstdcli.c\n@@ -877,7 +877,7 @@\n dictCLevel = cLevel = 6; /* gzip default is -6 */\n }\n if (exeNameMatch(programName, ZSTD_GUNZIP)) { operation=zom_decompress; FIO_setRemoveSrcFile(prefs, 1); } /* behave like gunzip, also supports multiple formats */\n- if (exeNameMatch(programName, ZSTD_GZCAT)) { operation=zom_decompress; FIO_overwriteMode(prefs); forceStdout=1; followLinks=1; outFileName=stdoutmark; g_displayLevel=1; } /* behave like gzcat, also supports multiple formats */\n+ if (exeNameMatch(programName, ZSTD_GZCAT)) { operation=zom_decompress; FIO_overwriteMode(prefs); forceStdout=1; forceStdin=1; followLinks=1; allowBlockDevices=1; outFileName=stdoutmark; g_displayLevel=1; } /* behave like gzcat, also supports multiple formats */\n if (exeNameMatch(programName, ZSTD_LZMA)) { suffix = LZMA_EXTENSION; FIO_setCompressionType(prefs, FIO_lzmaCompression); FIO_setRemoveSrcFile(prefs, 1); } /* behave like lzma */\n if (exeNameMatch(programName, ZSTD_UNLZMA)) { operation=zom_decompress; FIO_setCompressionType(prefs, FIO_lzmaCompression); FIO_setRemoveSrcFile(prefs, 1); } /* behave like unlzma, also supports multiple formats */\n if (exeNameMatch(programName, ZSTD_XZ)) { suffix = XZ_EXTENSION; FIO_setCompressionType(prefs, FIO_xzCompression); FIO_setRemoveSrcFile(prefs, 1); } /* behave like xz */\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-3438", "model_patch": "--- a/programs/fileio.c\n+++ b/programs/fileio.c\n@@ -962,7 +962,19 @@\n CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_useRowMatchFinder, prefs->useRowMatchFinder));\n /* compression parameters */\n CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_windowLog, (int)comprParams.windowLog) );\n+ /* Cap chainLog to avoid undefined behavior (shift larger than type width) */\n+ if (comprParams.chainLog > 24) {\n+ DISPLAYLEVEL(2, \"NOTE: chainLog capped at 24 (from %u) to avoid potential undefined behavior\\n\", comprParams.chainLog);\n+ comprParams.chainLog = 24;\n+ }\n CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_chainLog, (int)comprParams.chainLog) );\n+ /* Cap hashLog: 24 bits normally, 28 bits (24+4) for row match finder */\n+ { unsigned const maxHashLog = prefs->useRowMatchFinder ? 28 : 24;\n+ if (comprParams.hashLog > maxHashLog) {\n+ DISPLAYLEVEL(2, \"NOTE: hashLog capped at %u (from %u) to avoid potential undefined behavior\\n\", maxHashLog, comprParams.hashLog);\n+ comprParams.hashLog = maxHashLog;\n+ }\n+ }\n CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_hashLog, (int)comprParams.hashLog) );\n CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_searchLog, (int)comprParams.searchLog) );\n CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_minMatch, (int)comprParams.minMatch) );\n\n--- a/programs/zstdcli.c\n+++ b/programs/zstdcli.c\n@@ -1539,6 +1539,21 @@\n if (adaptMin > cLevel) cLevel = adaptMin;\n if (adaptMax < cLevel) cLevel = adaptMax;\n \n+ /* Validate hashLog and chainLog to prevent undefined behavior */\n+ if (compressionParams.chainLog > 24) {\n+ DISPLAYLEVEL(2, \"Warning : chainLog capped at 24 (was %u) \\n\", compressionParams.chainLog);\n+ compressionParams.chainLog = 24;\n+ }\n+ /* For row-based matchfinder, hashLog must be <= 28 (24 + 4) */\n+ if (useRowMatchFinder && compressionParams.hashLog > 28) {\n+ DISPLAYLEVEL(2, \"Warning : hashLog capped at 28 for row-based matchfinder (was %u) \\n\", compressionParams.hashLog);\n+ compressionParams.hashLog = 28;\n+ } else if (compressionParams.hashLog > 24) {\n+ /* For non-row matchfinder, cap at 24 */\n+ DISPLAYLEVEL(2, \"Warning : hashLog capped at 24 (was %u) \\n\", compressionParams.hashLog);\n+ compressionParams.hashLog = 24;\n+ }\n+\n /* Compare strategies constant with the ground truth */\n { ZSTD_bounds strategyBounds = ZSTD_cParam_getBounds(ZSTD_c_strategy);\n assert(ZSTD_NB_STRATEGIES == strategyBounds.upperBound);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-3530", "model_patch": "--- a/lib/compress/zstd_compress.c\n+++ b/lib/compress/zstd_compress.c\n@@ -1191,6 +1191,44 @@\n return 0;\n }\n \n+size_t ZSTD_CCtx_setFParams(ZSTD_CCtx* cctx, ZSTD_frameParameters fparams)\n+{\n+ DEBUGLOG(4, \"ZSTD_CCtx_setFParams\");\n+ RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,\n+ \"Can't set fParams when not in init stage.\");\n+ cctx->requestedParams.fParams = fparams;\n+ return 0;\n+}\n+\n+size_t ZSTD_CCtx_setParameters(ZSTD_CCtx* cctx, ZSTD_parameters params)\n+{\n+ DEBUGLOG(4, \"ZSTD_CCtx_setParameters\");\n+ RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,\n+ \"Can't set parameters when not in init stage.\");\n+ FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), \"\");\n+ cctx->requestedParams.cParams = params.cParams;\n+ cctx->requestedParams.fParams = params.fParams;\n+ return 0;\n+}\n+\n+size_t ZSTD_CCtxParams_setFParams(ZSTD_CCtx_params* cctxParams, ZSTD_frameParameters fparams)\n+{\n+ DEBUGLOG(4, \"ZSTD_CCtxParams_setFParams\");\n+ RETURN_ERROR_IF(!cctxParams, GENERIC, \"NULL pointer!\");\n+ cctxParams->fParams = fparams;\n+ return 0;\n+}\n+\n+size_t ZSTD_CCtxParams_setParameters(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params)\n+{\n+ DEBUGLOG(4, \"ZSTD_CCtxParams_setParameters\");\n+ RETURN_ERROR_IF(!cctxParams, GENERIC, \"NULL pointer!\");\n+ FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), \"\");\n+ cctxParams->cParams = params.cParams;\n+ cctxParams->fParams = params.fParams;\n+ return 0;\n+}\n+\n size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize)\n {\n DEBUGLOG(4, \"ZSTD_CCtx_setPledgedSrcSize to %llu bytes\", pledgedSrcSize);\n\n--- a/programs/zstdcli.c\n+++ b/programs/zstdcli.c\n@@ -1575,6 +1575,19 @@\n }\n }\n \n+ /* Normalize compression parameters: replace 0 values with defaults */\n+ { unsigned long long const fileSize = (filenames->tableSize > 0) ? UTIL_getFileSize(filenames->fileNames[0]) : UTIL_FILESIZE_UNKNOWN;\n+ const size_t dictSize = dictFileName != NULL ? (size_t)UTIL_getFileSize(dictFileName) : 0;\n+ ZSTD_compressionParameters defaultParams = ZSTD_getCParams(cLevel, fileSize, dictSize);\n+ if (compressionParams.windowLog == 0) compressionParams.windowLog = defaultParams.windowLog;\n+ if (compressionParams.chainLog == 0) compressionParams.chainLog = defaultParams.chainLog;\n+ if (compressionParams.hashLog == 0) compressionParams.hashLog = defaultParams.hashLog;\n+ if (compressionParams.searchLog == 0) compressionParams.searchLog = defaultParams.searchLog;\n+ if (compressionParams.minMatch == 0) compressionParams.minMatch = defaultParams.minMatch;\n+ if (compressionParams.targetLength == 0) compressionParams.targetLength = defaultParams.targetLength;\n+ if (compressionParams.strategy == 0) compressionParams.strategy = defaultParams.strategy;\n+ }\n+\n if (g_displayLevel >= 4)\n FIO_displayCompressionParameters(prefs);\n if ((filenames->tableSize==1) && outFileName)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-3942", "model_patch": "--- a/programs/zstdcli.c\n+++ b/programs/zstdcli.c\n@@ -962,7 +962,7 @@ int main(int argCount, const char* argv[])\n if (!strcmp(argument, \"--help\")) { usageAdvanced(programName); CLEAN_RETURN(0); }\n if (!strcmp(argument, \"--verbose\")) { g_displayLevel++; continue; }\n if (!strcmp(argument, \"--quiet\")) { g_displayLevel--; continue; }\n- if (!strcmp(argument, \"--stdout\")) { forceStdout=1; outFileName=stdoutmark; removeSrcFile=0; continue; }\n+ if (!strcmp(argument, \"--stdout\")) { forceStdout=1; outFileName=stdoutmark; /* removeSrcFile=0; */ continue; }\n if (!strcmp(argument, \"--ultra\")) { ultra=1; continue; }\n if (!strcmp(argument, \"--check\")) { FIO_setChecksumFlag(prefs, 2); continue; }\n if (!strcmp(argument, \"--no-check\")) { FIO_setChecksumFlag(prefs, 0); continue; }\n@@ -1176,7 +1176,7 @@ int main(int argCount, const char* argv[])\n operation=zom_decompress; argument++; break;\n \n /* Force stdout, even if stdout==console */\n- case 'c': forceStdout=1; outFileName=stdoutmark; removeSrcFile=0; argument++; break;\n+ case 'c': forceStdout=1; outFileName=stdoutmark; argument++; break;\n \n /* do not store filename - gzip compatibility - nothing to do */\n case 'n': argument++; break;\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-637", "model_patch": "--- a/lib/compress/zstdmt_compress.c\n+++ b/lib/compress/zstdmt_compress.c\n@@ -235,7 +235,7 @@\n if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }\n } else { /* srcStart points at reloaded section */\n size_t const dictModeError = ZSTD_setCCtxParameter(job->cctx, ZSTD_p_forceRawDict, 1); /* Force loading dictionary in \"content-only\" mode (no header analysis) */\n- size_t const initError = ZSTD_compressBegin_advanced(job->cctx, job->srcStart, job->dictSize, job->params, 0);\n+ size_t const initError = ZSTD_compressBegin_advanced(job->cctx, job->srcStart, job->dictSize, job->params, job->fullFrameSize);\n if (ZSTD_isError(initError) || ZSTD_isError(dictModeError)) { job->cSize = initError; goto _endJob; }\n ZSTD_setCCtxParameter(job->cctx, ZSTD_p_forceWindow, 1);\n }\n\n--- a/programs/fileio.c\n+++ b/programs/fileio.c\n@@ -533,11 +533,12 @@\n \n /* init */\n #ifdef ZSTD_MULTITHREAD\n- { size_t const resetError = ZSTDMT_resetCStream(ress.cctx, fileSize);\n+ { size_t const resetError = ZSTDMT_initCStream(ress.cctx, compressionLevel);\n+ if (ZSTD_isError(resetError)) EXM_THROW(21, \"Error initializing compression : %s\", ZSTD_getErrorName(resetError));\n #else\n { size_t const resetError = ZSTD_resetCStream(ress.cctx, fileSize);\n-#endif\n if (ZSTD_isError(resetError)) EXM_THROW(21, \"Error initializing compression : %s\", ZSTD_getErrorName(resetError));\n+#endif\n }\n \n /* Main compression loop */\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-809", "model_patch": "--- a/lib/dictBuilder/cover.c\n+++ b/lib/dictBuilder/cover.c\n@@ -608,6 +608,10 @@\n * We will select at least one segment from each epoch.\n */\n const U32 epochs = (U32)(dictBufferCapacity / parameters.k);\n+ /* Check if epochs is 0 to avoid division by zero */\n+ if (epochs == 0) {\n+ return ERROR(dstSize_tooSmall);\n+ }\n const U32 epochSize = (U32)(ctx->suffixSize / epochs);\n size_t epoch;\n DISPLAYLEVEL(2, \"Breaking content into %u epochs of size %u\\n\", epochs,\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-836", "model_patch": "--- a/lib/common/zstd_internal.h\n+++ b/lib/common/zstd_internal.h\n@@ -128,7 +128,16 @@\n \tmemcpy(dst, src, 8);\n }\n /*! ZSTD_wildcopy() :\n-* custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */\n+* custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) \n+* \n+* WILDCOPY_OVERLENGTH : Extra bytes that may be written by wildcopy operations.\n+* - For single-block frames: WILDCOPY_OVERLENGTH is NOT needed if you know the exact\n+* decompressed size and pass a buffer of exactly that size to ZSTD_decompressBlock().\n+* - For multi-block frames: Buffer size should be at least:\n+* windowSize + MIN(windowSize, ZSTD_BLOCKSIZE_MAX) + (WILDCOPY_OVERLENGTH * 2)\n+* \n+* Note: This constant should be exposed in zstd.h under ZSTD_STATIC_LINKING_ONLY\n+* for users who need to use ZSTD_decompressBlock() directly. */\n #define WILDCOPY_OVERLENGTH 8\n ZSTD_STATIC void ZSTD_wildcopy(void *dst, const void *src, ptrdiff_t length)\n {\n\n--- a/lib/zstd.h\n+++ b/lib/zstd.h\n@@ -524,6 +524,17 @@\n ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);\n ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);\n \n+/*! ZSTD_decompressBufferBound() :\n+ * `windowSize` is the window size from the frame header.\n+ * @return : maximum size required for a decompression output buffer\n+ * to decompress a frame that uses the given window size.\n+ * This is the output buffer size needed for block-level decompression,\n+ * accounting for the windowSize and internal decoder requirements.\n+ * Note : This function is provided to help size output buffers when using\n+ * low-level block decompression APIs like ZSTD_decompressBlock().\n+ * For single-block frames, a buffer of exact block size may be sufficient. */\n+ZSTDLIB_API size_t ZSTD_decompressBufferBound(size_t windowSize);\n+\n typedef enum {\n ZSTD_dlm_byCopy = 0, /* Copy dictionary content internally. */\n ZSTD_dlm_byRef, /* Reference dictionary content -- the dictionary buffer must outlives its users. */\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-938", "model_patch": "--- a/programs/util.h\n+++ b/programs/util.h\n@@ -173,8 +173,11 @@\n UTIL_STATIC UTIL_time_t UTIL_getTime(void)\n {\n UTIL_time_t time;\n- if (clock_gettime(CLOCK_MONOTONIC, &time))\n- UTIL_DISPLAYLEVEL(1, \"ERROR: Failed to get time\\n\"); /* we could also exit() */\n+ if (clock_gettime(CLOCK_MONOTONIC, &time)) {\n+ UTIL_DISPLAYLEVEL(1, \"ERROR: Failed to get time\\n\");\n+ time.tv_sec = 0;\n+ time.tv_nsec = 0;\n+ }\n return time;\n }\n UTIL_STATIC UTIL_time_t UTIL_getSpanTime(UTIL_time_t begin, UTIL_time_t end)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "facebook__zstd-983", "model_patch": "--- a/lib/compress/zstd_double_fast.c\n+++ b/lib/compress/zstd_double_fast.c\n@@ -115,10 +115,10 @@\n \n if (ip <= ilimit) {\n /* Fill Table */\n- hashLong[ZSTD_hashPtr(base+current+2, hBitsL, 8)] =\n- hashSmall[ZSTD_hashPtr(base+current+2, hBitsS, mls)] = current+2; /* here because current+2 could be > iend-8 */\n- hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] =\n- hashSmall[ZSTD_hashPtr(ip-2, hBitsS, mls)] = (U32)(ip-2-base);\n+ hashSmall[ZSTD_hashPtr(base+current+2, hBitsS, mls)] = current+2; /* here because current+2 could be > iend-8 */\n+ hashLong[ZSTD_hashPtr(base+current+2, hBitsL, 8)] = current+2;\n+ hashSmall[ZSTD_hashPtr(ip-2, hBitsS, mls)] = (U32)(ip-2-base);\n+ hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);\n \n /* check immediate repcode */\n while ( (ip <= ilimit)\n\n--- a/lib/compress/zstd_fast.c\n+++ b/lib/compress/zstd_fast.c\n@@ -217,7 +217,8 @@\n } } }\n \n /* save reps for next block */\n- seqStorePtr->repToConfirm[0] = offset_1; seqStorePtr->repToConfirm[1] = offset_2;\n+ seqStorePtr->repToConfirm[0] = offset_1 ? offset_1 : offsetSaved;\n+ seqStorePtr->repToConfirm[1] = offset_2 ? offset_2 : offsetSaved;\n \n /* Return the last literals size */\n return iend - anchor;\n\n--- a/lib/compress/zstd_opt.c\n+++ b/lib/compress/zstd_opt.c\n@@ -75,7 +75,7 @@\n }\n optPtr->matchLengthSum = 0;\n for (u=0; u<=MaxML; u++) {\n- optPtr->matchLengthFreq[u] = 1 + (optPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV);\n+ optPtr->matchLengthFreq[u] = 1 + (optPtr->matchLengthFreq[u]>>(ZSTD_FREQ_DIV+1));\n optPtr->matchLengthSum += optPtr->matchLengthFreq[u];\n }\n optPtr->offCodeSum = 0;\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-1793", "model_patch": "--- a/src/builtin.c\n+++ b/src/builtin.c\n@@ -398,11 +398,36 @@\n }\n \n static jv f_contains(jq_state *jq, jv a, jv b) {\n- if (jv_get_kind(a) == jv_get_kind(b)) {\n- return jv_bool(jv_contains(a, b));\n- } else {\n+ if (jv_get_kind(a) != jv_get_kind(b)) {\n return type_error2(a, b, \"cannot have their containment checked\");\n }\n+ \n+ // Special handling for strings to properly support NUL characters\n+ if (jv_get_kind(a) == JV_KIND_STRING) {\n+ const char *haystack = jv_string_value(a);\n+ const char *needle = jv_string_value(b);\n+ int haystack_len = jv_string_length_bytes(jv_copy(a));\n+ int needle_len = jv_string_length_bytes(jv_copy(b));\n+ jv ret = jv_false();\n+ \n+ if (needle_len == 0) {\n+ ret = jv_true();\n+ } else if (needle_len <= haystack_len) {\n+ // Search for needle in haystack using byte-by-byte comparison\n+ for (int i = 0; i <= haystack_len - needle_len; i++) {\n+ if (memcmp(haystack + i, needle, needle_len) == 0) {\n+ ret = jv_true();\n+ break;\n+ }\n+ }\n+ }\n+ \n+ jv_free(a);\n+ jv_free(b);\n+ return ret;\n+ }\n+ \n+ return jv_bool(jv_contains(a, b));\n }\n \n static jv f_dump(jq_state *jq, jv input) {\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2133", "model_patch": "--- a/src/main.c\n+++ b/src/main.c\n@@ -171,7 +171,7 @@\n RAW_INPUT = 2,\n PROVIDE_NULL = 4,\n RAW_OUTPUT = 8,\n- RAW_NUL = 16,\n+ RAW_OUTPUT0 = 16,\n ASCII_OUTPUT = 32,\n COLOR_OUTPUT = 64,\n NO_COLOR_OUTPUT = 128,\n@@ -213,11 +213,16 @@\n while (jv_is_valid(result = jq_next(jq))) {\n if ((options & RAW_OUTPUT) && jv_get_kind(result) == JV_KIND_STRING) {\n if (options & ASCII_OUTPUT) {\n jv_dumpf(jv_copy(result), stdout, JV_PRINT_ASCII);\n- } else {\n+ } else if ((options & RAW_OUTPUT0) && strlen(jv_string_value(result)) != (unsigned long)jv_string_length_bytes(jv_copy(result))) {\n+ jv_free(result);\n+ result = jv_invalid_with_msg(jv_string(\n+ \"Cannot dump a string containing NUL with --raw-output0 option\"));\n+ break;\n+ } else {\n priv_fwrite(jv_string_value(result), jv_string_length_bytes(jv_copy(result)),\n stdout, dumpopts & JV_PRINT_ISATTY);\n }\n@@ -233,7 +238,7 @@\n }\n if (!(options & RAW_NO_LF))\n priv_fwrite(\"\\n\", 1, stdout, dumpopts & JV_PRINT_ISATTY);\n- if (options & RAW_NUL)\n+ if (options & RAW_OUTPUT0)\n priv_fwrite(\"\\0\", 1, stdout, dumpopts & JV_PRINT_ISATTY);\n if (options & UNBUFFERED_OUTPUT)\n fflush(stdout);\n@@ -450,8 +455,8 @@\n options |= RAW_OUTPUT | RAW_NO_LF;\n if (!short_opts) continue;\n }\n- if (isoption(argv[i], '0', \"nul-output\", &short_opts)) {\n- options |= RAW_OUTPUT | RAW_NO_LF | RAW_NUL;\n+ if (isoption(argv[i], 0, \"raw-output0\", &short_opts)) {\n+ options |= RAW_OUTPUT | RAW_NO_LF | RAW_OUTPUT0;\n if (!short_opts) continue;\n }\n if (isoption(argv[i], 'b', \"binary\", &short_opts)) {"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2157", "model_patch": "--- a/src/builtin.c\n+++ b/src/builtin.c\n@@ -642,7 +642,8 @@ static jv f_format(jq_state *jq, jv input, jv fmt) {\n input = f_tostring(jq, input);\n \n int unreserved[128] = {0};\n- const char* p = CHARS_ALPHANUM \"-_.!~*'()\";\n+ // RFC 3986 section 2.3: Unreserved Characters\n+ const char* p = CHARS_ALPHANUM \"-._~\";\n while (*p) unreserved[(int)*p++] = 1;\n \n jv line = jv_string(\"\");\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2624", "model_patch": "--- a/src/builtin.c\n+++ b/src/builtin.c\n@@ -927,7 +927,13 @@\n match = jv_object_set(match, jv_string(\"string\"), jv_string(\"\"));\n match = jv_object_set(match, jv_string(\"captures\"), jv_array());\n result = jv_array_append(result, match);\n- start += 1;\n+ // Advance at least one byte to avoid infinite loop on zero-width matches\n+ // If we're not at the end, advance by one UTF-8 character\n+ if (start < end) {\n+ start += jvp_utf8_decode_length(*start);\n+ } else {\n+ break;\n+ }\n continue;\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2646", "model_patch": "--- a/src/builtin.c\n+++ b/src/builtin.c\n@@ -1200,6 +1200,14 @@\n static jv f_string_implode(jq_state *jq, jv a) {\n if (jv_get_kind(a) != JV_KIND_ARRAY) {\n return ret_error(a, jv_string(\"implode input must be an array\"));\n+ }\n+ // Validate that all array elements are numbers\n+ jv_array_foreach(a, i, elem) {\n+ if (jv_get_kind(elem) != JV_KIND_NUMBER) {\n+ jv_free(a);\n+ return type_error(elem, \"cannot be imploded, only integers are implodeable\");\n+ }\n+ jv_free(elem);\n }\n return jv_string_implode(a);\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2654", "model_patch": "--- a/src/main.c\n+++ b/src/main.c\n@@ -689,7 +689,7 @@\n jv msg = jv_invalid_get_msg(value);\n if (!(options & SEQ)) {\n // --seq -> errors are not fatal\n- ret = JQ_OK_NO_OUTPUT;\n+ ret = JQ_ERROR_COMPILE;\n fprintf(stderr, \"jq: parse error: %s\\n\", jv_string_value(msg));\n jv_free(msg);\n break;\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2658", "model_patch": "--- a/src/main.c\n+++ b/src/main.c\n@@ -317,7 +317,15 @@\n if (further_args_are_strings) {\n ARGS = jv_array_append(ARGS, jv_string(argv[i]));\n } else if (further_args_are_json) {\n- ARGS = jv_array_append(ARGS, jv_parse(argv[i]));\n+ jv val = jv_parse(argv[i]);\n+ if (!jv_is_valid(val)) {\n+ jv msg = jv_invalid_get_msg(val);\n+ fprintf(stderr, \"%s: invalid JSON text passed as argument: %s\\n\", progname, jv_string_value(msg));\n+ jv_free(msg);\n+ ret = JQ_ERROR_SYSTEM;\n+ goto out;\n+ }\n+ ARGS = jv_array_append(ARGS, val);\n } else {\n jq_util_input_add_input(input_state, argv[i]);\n nfiles++;\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2728", "model_patch": "--- a/src/main.c\n+++ b/src/main.c\n@@ -594,6 +594,10 @@\n if (options & ASCII_OUTPUT) dumpopts |= JV_PRINT_ASCII;\n if (options & COLOR_OUTPUT) dumpopts |= JV_PRINT_COLOR;\n if (options & NO_COLOR_OUTPUT) dumpopts &= ~JV_PRINT_COLOR;\n+ // Support NO_COLOR environment variable (https://no-color.org/)\n+ // Only disable color if NO_COLOR is set and not overridden by -C flag\n+ if (getenv(\"NO_COLOR\") != NULL && !(options & COLOR_OUTPUT))\n+ dumpopts &= ~JV_PRINT_COLOR;\n \n if (getenv(\"JQ_COLORS\") != NULL && !jq_set_colors(getenv(\"JQ_COLORS\")))\n fprintf(stderr, \"Failed to set $JQ_COLORS\\n\");\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2821", "model_patch": "--- a/src/locfile.c\n+++ b/src/locfile.c\n@@ -32,7 +32,7 @@\n int locfile_get_line(struct locfile* l, int pos) {\n assert(pos < l->length);\n int line = 1;\n- while (l->linemap[line] <= pos) line++;\n+ while (line <= l->nlines && l->linemap[line] <= pos) line++;\n assert(line-1 < l->nlines);\n return line-1;\n }"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2824", "model_patch": "--- a/src/main.c\n+++ b/src/main.c\n@@ -65,11 +65,11 @@\n \"jq is a tool for processing JSON inputs, applying the given filter to\\n\"\n \"its JSON text inputs and producing the filter's results as JSON on\\n\"\n \"standard output.\\n\\n\"\n- \"The simplest filter is ., which copies jq's input to its output\\n\"\n- \"unmodified (except for formatting, but note that IEEE754 is used\\n\"\n- \"for number representation internally, with all that that implies).\\n\\n\"\n- \"For more advanced filters see the jq(1) manpage (\\\"man jq\\\")\\n\"\n- \"and/or https://jqlang.github.io/jq\\n\\n\"\n+ \"The simplest filter is ., which copies jq's input to its output\\n\"\n+ \"unmodified except for formatting. For more advanced filters see\\n\"\n+ \"the jq(1) manpage (\\\"man jq\\\") and/or https://jqlang.github.io/jq/.\\n\\n\"\n \"Example:\\n\\n\\t$ echo '{\\\"foo\\\": 0}' | jq .\\n\"\n- \"\\t{\\n\\t\\t\\\"foo\\\": 0\\n\\t}\\n\\n\",\n+ \"\\t{\\n\\t \\\"foo\\\": 0\\n\\t}\\n\\n\",\n JQ_VERSION, progname, progname, progname);\n if (keep_it_short) {\n fprintf(f,"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2839", "model_patch": "--- a/src/builtin.c\n+++ b/src/builtin.c\n@@ -442,6 +442,55 @@\n };\n \n static jv order_cmp(jv a, jv b, enum cmp_op op) {\n+ // Check for numbers with extreme exponents that could cause overflow in decNumber\n+ // When both are numbers, check if we can short-circuit the comparison\n+ if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {\n+ double da = jv_number_value(jv_copy(a));\n+ double db = jv_number_value(jv_copy(b));\n+ \n+ // Handle special cases: NaN, infinity, zero\n+ int a_is_nan = isnan(da);\n+ int b_is_nan = isnan(db);\n+ int a_is_inf = isinf(da);\n+ int b_is_inf = isinf(db);\n+ \n+ // If either is NaN or both are infinity with same sign, or we can determine\n+ // the result from the double comparison alone (for extreme exponent differences),\n+ // we can avoid calling jv_cmp which might overflow in decNumber\n+ if (a_is_nan || b_is_nan || \n+ (a_is_inf && b_is_inf) ||\n+ (a_is_inf && !b_is_inf) ||\n+ (!a_is_inf && b_is_inf) ||\n+ (da == 0.0 && db != 0.0) ||\n+ (da != 0.0 && db == 0.0)) {\n+ // For these cases, we can use the double comparison result\n+ int r = (da < db) ? -1 : (da > db) ? 1 : 0;\n+ jv_free(a);\n+ jv_free(b);\n+ return jv_bool((op == CMP_OP_LESS && r < 0) ||\n+ (op == CMP_OP_LESSEQ && r <= 0) ||\n+ (op == CMP_OP_GREATEREQ && r >= 0) ||\n+ (op == CMP_OP_GREATER && r > 0));\n+ }\n+ \n+ // For very extreme exponent differences, the double comparison is sufficient\n+ // Check if the exponent difference would likely overflow (> INT_MAX/2 difference)\n+ if (fabs(da) > 0 && fabs(db) > 0 && !a_is_inf && !b_is_inf) {\n+ double log_a = log10(fabs(da));\n+ double log_b = log10(fabs(db));\n+ // If the difference in order of magnitude is huge, use double comparison\n+ if (fabs(log_a - log_b) > 1e9) {\n+ int r = (da < db) ? -1 : (da > db) ? 1 : 0;\n+ jv_free(a);\n+ jv_free(b);\n+ return jv_bool((op == CMP_OP_LESS && r < 0) ||\n+ (op == CMP_OP_LESSEQ && r <= 0) ||\n+ (op == CMP_OP_GREATEREQ && r >= 0) ||\n+ (op == CMP_OP_GREATER && r > 0));\n+ }\n+ }\n+ }\n+ \n int r = jv_cmp(a, b);\n return jv_bool((op == CMP_OP_LESS && r < 0) ||\n (op == CMP_OP_LESSEQ && r <= 0) ||\n\n--- a/src/decNumber/decNumber.c\n+++ b/src/decNumber/decNumber.c\n@@ -6206,6 +6206,27 @@\n rhs=temp;\n result=-result;\n }\n+ // Calculate exponent difference, checking for overflow\n+ // If the difference would be huge, we can determine the result without\n+ // detailed coefficient comparison\n+ if (rhs->exponent >= 0 && lhs->exponent < 0) {\n+ // rhs->exponent - lhs->exponent would be positive and potentially overflow\n+ // Check if lhs->exponent negation would overflow when added to rhs->exponent\n+ if (rhs->exponent > DECNUMMAXE/2 || -lhs->exponent > DECNUMMAXE/2) {\n+ // Exponent difference is definitely larger than any reasonable coefficient difference\n+ return result; // rhs is larger\n+ }\n+ }\n+ // Also check if the magnitude of the difference would be unreasonably large\n+ // A difference larger than (both coefficients' lengths + safety margin) means\n+ // the number with larger exponent is definitely bigger\n+ {\n+ Int expDiff = rhs->exponent - lhs->exponent;\n+ Int maxReasonableDiff = lhs->digits + rhs->digits + 1;\n+ if (expDiff > maxReasonableDiff) {\n+ return result; // rhs is definitely larger\n+ }\n+ }\n compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),\n rhs->lsu, D2U(rhs->digits),\n rhs->exponent-lhs->exponent);\n\n--- a/src/jv_aux.c\n+++ b/src/jv_aux.c\n@@ -565,7 +565,23 @@\n } else if (jvp_number_is_nan(b)) {\n r = jv_cmp(jv_copy(a), jv_null());\n } else {\n- r = jvp_number_cmp(a, b);\n+ // For numbers with extreme exponents, decNumber comparison can overflow\n+ // and cause crashes. Use double comparison as a fallback for such cases.\n+ double val_a = jv_number_value(jv_copy(a));\n+ double val_b = jv_number_value(jv_copy(b));\n+ \n+ // If either number is infinite (overflow) or zero (underflow) in double precision,\n+ // the exponents are too extreme for safe decNumber comparison\n+ if (!isfinite(val_a) || !isfinite(val_b) || \n+ (val_a == 0.0 && !jvp_number_is_zero(jv_copy(a))) ||\n+ (val_b == 0.0 && !jvp_number_is_zero(jv_copy(b)))) {\n+ // Use double comparison for extreme values\n+ if (val_a < val_b) r = -1;\n+ else if (val_a > val_b) r = 1;\n+ else r = 0;\n+ } else {\n+ r = jvp_number_cmp(a, b);\n+ }\n }\n break;\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "jqlang__jq-2919", "model_patch": "--- a/src/main.c\n+++ b/src/main.c\n@@ -354,7 +354,9 @@\n jv lib_search_paths = jv_null();\n for (int i=1; inum_regs; ++i) {\n jv cap = jv_object();\n- cap = jv_object_set(cap, jv_string(\"offset\"), jv_number(idx));\n- cap = jv_object_set(cap, jv_string(\"string\"), jv_string(\"\"));\n+ if (region->beg[i] == -1) {\n+ cap = jv_object_set(cap, jv_string(\"offset\"), jv_number(-1));\n+ cap = jv_object_set(cap, jv_string(\"string\"), jv_null());\n+ } else {\n+ cap = jv_object_set(cap, jv_string(\"offset\"), jv_number(idx));\n+ cap = jv_object_set(cap, jv_string(\"string\"), jv_string(\"\"));\n+ }\n cap = jv_object_set(cap, jv_string(\"length\"), jv_number(0));\n cap = jv_object_set(cap, jv_string(\"name\"), jv_null());\n captures = jv_array_append(captures, cap);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1035", "model_patch": "--- a/src/libponyc/pass/names.c\n+++ b/src/libponyc/pass/names.c\n@@ -300,7 +300,7 @@\n {\n ast_error(opt->check.errors, type_id,\n \"can't find definition of '%s'\", name);\n- r = false;\n+ return false;\n } else {\n // Check for a private type.\n if(!local_package && is_name_private(name))\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1051", "model_patch": "--- a/src/libponyc/codegen/gencontrol.c\n+++ b/src/libponyc/codegen/gencontrol.c\n@@ -20,6 +20,11 @@\n \n if(value == NULL)\n return NULL;\n+\n+ // If this expression is a control flow terminator (return, break,\n+ // continue, error), stop processing the sequence.\n+ if(value == GEN_NOVALUE)\n+ return GEN_NOVALUE;\n \n child = ast_sibling(child);\n }\n\n--- a/src/libponyc/pass/syntax.c\n+++ b/src/libponyc/pass/syntax.c\n@@ -621,6 +621,39 @@\n ast_error(opt->check.errors,\n ast_childidx(value_seq, max_value_count), \"Unreachable code\");\n return AST_ERROR;\n+ }\n+\n+ // Check if this control flow statement is at the end of its sequence\n+ ast_t* parent = ast_parent(ast);\n+ if(parent != NULL && ast_id(parent) == TK_SEQ)\n+ {\n+ ast_t* last_child = ast_childlast(parent);\n+ if(last_child == ast)\n+ {\n+ // This is the last statement in the sequence\n+ // Check if the parent sequence is the method body\n+ if(opt->check.frame->method_body != NULL &&\n+ parent == opt->check.frame->method_body)\n+ {\n+ const char* stmt_name = NULL;\n+ switch(ast_id(ast))\n+ {\n+ case TK_RETURN: stmt_name = \"return\"; break;\n+ case TK_BREAK: stmt_name = \"break\"; break;\n+ case TK_CONTINUE: stmt_name = \"continue\"; break;\n+ case TK_ERROR: stmt_name = \"error\"; break;\n+ default: break;\n+ }\n+ \n+ if(stmt_name != NULL)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"use %s only to exit early from a method, not at the end\",\n+ stmt_name);\n+ return AST_ERROR;\n+ }\n+ }\n+ }\n }\n \n if(ast_id(ast) == TK_RETURN)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1057", "model_patch": "--- a/src/libponyc/ast/error.c\n+++ b/src/libponyc/ast/error.c\n@@ -314,7 +314,7 @@\n bool errorframe_has_errors(errorframe_t* frame)\n {\n assert(frame != NULL);\n- return frame != NULL;\n+ return *frame != NULL;\n }\n \n void errorframe_report(errorframe_t* frame, errors_t* errors)\n\n--- a/src/libponyc/pass/syntax.c\n+++ b/src/libponyc/pass/syntax.c\n@@ -414,18 +414,39 @@\n \"can only use 'this' for a viewpoint in a method\");\n r = AST_ERROR;\n } else {\n- ast_t* cap = ast_child(opt->check.frame->method);\n-\n- switch(ast_id(cap))\n- {\n- case TK_BOX:\n- case TK_NONE:\n+ // Check if we're inside a recover block\n+ bool in_recover = false;\n+ ast_t* check = ast;\n+ while(check != NULL)\n+ {\n+ if(ast_id(check) == TK_RECOVER)\n+ {\n+ in_recover = true;\n break;\n-\n- default:\n- ast_error(opt->check.errors, ast,\n- \"can only use 'this' for a viewpoint in a box function\");\n- r = AST_ERROR;\n+ }\n+ // Stop at method boundary\n+ token_id check_id = ast_id(check);\n+ if(check_id == TK_FUN || check_id == TK_BE || check_id == TK_NEW)\n+ break;\n+ check = ast_parent(check);\n+ }\n+\n+ // Allow this->T viewpoint in recover blocks regardless of method cap\n+ if(!in_recover)\n+ {\n+ ast_t* cap = ast_child(opt->check.frame->method);\n+\n+ switch(ast_id(cap))\n+ {\n+ case TK_BOX:\n+ case TK_NONE:\n+ break;\n+\n+ default:\n+ ast_error(opt->check.errors, ast,\n+ \"can only use 'this' for a viewpoint in a box function\");\n+ r = AST_ERROR;\n+ }\n }\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1095", "model_patch": "--- a/src/libponyc/expr/reference.c\n+++ b/src/libponyc/expr/reference.c\n@@ -256,6 +256,26 @@\n if(is_typecheck_error(l_type))\n return false;\n \n+ // Check if this is a method being accessed (not a field)\n+ token_id find_id = ast_id(find);\n+ if(find_id == TK_FUN || find_id == TK_BE || find_id == TK_NEW)\n+ {\n+ // Check if we're trying to use a method reference in a match\n+ ast_t* parent = ast_parent(ast);\n+ while(parent != NULL && ast_id(parent) == TK_SEQ)\n+ parent = ast_parent(parent);\n+ \n+ if(parent != NULL && ast_id(parent) == TK_MATCH)\n+ {\n+ AST_GET_CHILDREN(find, method_id, f_type, init);\n+ ast_error(opt->check.errors, ast,\n+ \"can't match on a method, you need to call the method with ()\");\n+ ast_error_continue(opt->check.errors, find,\n+ \"method '%s' is defined here\", ast_name(method_id));\n+ return false;\n+ }\n+ }\n+\n AST_GET_CHILDREN(find, id, f_type, init);\n \n // Viewpoint adapted type of the field.\n\n--- a/src/libponyc/type/matchtype.c\n+++ b/src/libponyc/type/matchtype.c\n@@ -200,6 +200,9 @@\n case TK_ARROW:\n return MATCHTYPE_REJECT;\n \n+ case TK_FUNTYPE:\n+ return MATCHTYPE_REJECT;\n+\n default: {}\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1124", "model_patch": "--- a/src/libponyc/type/alias.c\n+++ b/src/libponyc/type/alias.c\n@@ -72,12 +72,39 @@\n }\n \n case TK_TRN:\n- case TK_REF:\n- // These recover as iso, so any rcap is acceptable. We also set the rcap\n+ // This recovers as iso, so any rcap is acceptable. We also set the rcap\n // as ephemeral to allow direct recovery to iso or trn.\n if(rcap == TK_NONE)\n rcap = TK_ISO;\n rec_eph = true;\n+ break;\n+\n+ case TK_REF:\n+ // ref recovers as val, so mutable rcaps are not acceptable.\n+ if(rcap == TK_NONE)\n+ rcap = TK_VAL;\n+\n+ switch(rcap)\n+ {\n+ case TK_ISO:\n+ case TK_TRN:\n+ case TK_REF:\n+ case TK_CAP_READ:\n+ case TK_CAP_SEND:\n+ case TK_CAP_ALIAS:\n+ case TK_CAP_ANY:\n+ return NULL;\n+\n+ case TK_VAL:\n+ case TK_BOX:\n+ case TK_TAG:\n+ case TK_CAP_SHARE:\n+ break;\n+\n+ default:\n+ assert(0);\n+ return NULL;\n+ }\n break;\n \n case TK_VAL:\n\n--- a/src/libponyc/type/safeto.c\n+++ b/src/libponyc/type/safeto.c\n@@ -104,6 +104,49 @@\n }\n \n assert(type_child == NULL);\n+ \n+ // Check that no element appears multiple times with incompatible caps.\n+ // If the same AST node appears multiple times in the tuple, all its\n+ // capabilities must be compatible (safe to alias together).\n+ ast_t* check_child = ast_child(ast);\n+ ast_t* check_type = ast_child(type);\n+ \n+ while(check_child != NULL)\n+ {\n+ ast_t* other_child = ast_sibling(check_child);\n+ ast_t* other_type = ast_sibling(check_type);\n+ \n+ while(other_child != NULL)\n+ {\n+ // Check if these reference the same variable/field\n+ if((ast_id(check_child) == TK_VARREF || ast_id(check_child) == TK_FLETREF || \n+ ast_id(check_child) == TK_FVARREF || ast_id(check_child) == TK_EMBEDREF) &&\n+ ast_id(check_child) == ast_id(other_child))\n+ {\n+ ast_t* check_name = ast_child(check_child);\n+ ast_t* other_name = ast_child(other_child);\n+ \n+ if((check_name != NULL) && (other_name != NULL) &&\n+ (ast_name(check_name) == ast_name(other_name)))\n+ {\n+ // Same variable - check capability compatibility\n+ token_id cap1 = cap_single(check_type);\n+ token_id cap2 = cap_single(other_type);\n+ \n+ // Both caps must be safe to write with each other\n+ if(!cap_safetowrite(cap1, cap2) || !cap_safetowrite(cap2, cap1))\n+ return false;\n+ }\n+ }\n+ \n+ other_child = ast_sibling(other_child);\n+ other_type = ast_sibling(other_type);\n+ }\n+ \n+ check_child = ast_sibling(check_child);\n+ check_type = ast_sibling(check_type);\n+ }\n+ \n return true;\n }\n \n\n--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -588,6 +588,62 @@\n \n sub_child = ast_sibling(sub_child);\n super_child = ast_sibling(super_child);\n+ }\n+\n+ // Check for capability conflicts between tuple elements with same nominal type.\n+ // This prevents aliases with incompatible capabilities like (Foo, Foo val).\n+ if(ret)\n+ {\n+ ast_t* check_i = ast_child(super);\n+ size_t i = 0;\n+ \n+ while(check_i != NULL)\n+ {\n+ if(ast_id(check_i) == TK_NOMINAL)\n+ {\n+ ast_t* check_j = ast_child(super);\n+ size_t j = 0;\n+ \n+ while(check_j != NULL)\n+ {\n+ if((i != j) && (ast_id(check_j) == TK_NOMINAL))\n+ {\n+ ast_t* def_i = (ast_t*)ast_data(check_i);\n+ ast_t* def_j = (ast_t*)ast_data(check_j);\n+ \n+ // Same nominal type with different type args could still alias\n+ if(def_i == def_j && is_eq_typeargs(check_i, check_j, NULL, opt))\n+ {\n+ ast_t* cap_i = cap_fetch(check_i);\n+ ast_t* cap_j = cap_fetch(check_j);\n+ token_id tcap_i = ast_id(cap_i);\n+ token_id tcap_j = ast_id(cap_j);\n+ \n+ // Check if capabilities are incompatible for potential aliases\n+ if(tcap_i != tcap_j && \n+ !is_cap_sub_cap(tcap_i, TK_NONE, tcap_j, TK_NONE) &&\n+ !is_cap_sub_cap(tcap_j, TK_NONE, tcap_i, TK_NONE))\n+ {\n+ if(errorf != NULL)\n+ {\n+ ast_error_frame(errorf, sub,\n+ \"%s is not a valid tuple type: \"\n+ \"elements %zd and %zd have the same type but incompatible \"\n+ \"capabilities %s and %s which could allow aliasing violations\",\n+ ast_print_type(super), i, j,\n+ ast_print_type(cap_i), ast_print_type(cap_j));\n+ }\n+ ret = false;\n+ }\n+ }\n+ }\n+ check_j = ast_sibling(check_j);\n+ j++;\n+ }\n+ }\n+ check_i = ast_sibling(check_i);\n+ i++;\n+ }\n }\n \n if(!ret && errorf != NULL)\n\n--- a/src/libponyc/type/viewpoint.c\n+++ b/src/libponyc/type/viewpoint.c\n@@ -355,7 +355,7 @@\n if(target_def == left_def)\n {\n AST_GET_CHILDREN(ast, id, cap, eph);\n- ast_t* a_with = with;\n+ ast_t* a_with = NULL;\n \n switch(ast_id(eph))\n {\n@@ -367,11 +367,9 @@\n a_with = alias(with);\n break;\n \n- default: {}\n+ default:\n+ a_with = ast_dup(with);\n }\n-\n- if(a_with == with)\n- a_with = ast_dup(with);\n \n ast_replace(astp, a_with);\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1339", "model_patch": "--- a/src/libponyc/pass/expr.c\n+++ b/src/libponyc/pass/expr.c\n@@ -316,7 +316,11 @@\n \n if(!r)\n {\n- assert(errors_get_count(options->check.errors) > 0);\n+ if(errors_get_count(options->check.errors) == 0)\n+ {\n+ ast_error(options->check.errors, *astp,\n+ \"invalid expression (possible circular type inference)\");\n+ }\n return AST_ERROR;\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1411", "model_patch": "--- a/src/libponyc/expr/call.c\n+++ b/src/libponyc/expr/call.c\n@@ -710,6 +710,9 @@\n case TK_NEWBEREF:\n case TK_BEREF:\n case TK_FUNREF:\n+ case TK_NEWCHAIN:\n+ case TK_BECHAIN:\n+ case TK_FUNCHAIN:\n return method_call(opt, ast);\n \n case TK_NEWAPP:\n\n--- a/src/libponyc/pass/sugar.c\n+++ b/src/libponyc/pass/sugar.c\n@@ -1425,6 +1425,7 @@\n case TK_ASSIGN: return sugar_update(astp);\n case TK_OBJECT: return sugar_object(options, astp);\n case TK_AS: return sugar_as(options, astp);\n+ case TK_CHAIN: return sugar_chain(options, astp);\n case TK_PLUS: return sugar_binop(astp, \"add\");\n case TK_MINUS: return sugar_binop(astp, \"sub\");\n case TK_MULTIPLY: return sugar_binop(astp, \"mul\");\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1486", "model_patch": "--- a/src/libponyc/expr/reference.c\n+++ b/src/libponyc/expr/reference.c\n@@ -670,9 +670,6 @@\n \n case TK_ID:\n {\n- if(!def_before_use(opt, def, ast, name))\n- return false;\n-\n ast_t* type = ast_type(def);\n \n if(type != NULL && ast_id(type) == TK_INFERTYPE)\n@@ -688,6 +685,9 @@\n return false;\n \n if(!valid_reference(opt, ast, type, status))\n+ return false;\n+\n+ if(!def_before_use(opt, def, ast, name))\n return false;\n \n ast_t* var = ast_parent(def);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1516", "model_patch": "--- a/src/libponyc_expr/match.c\n+++ b/src/libponyc_expr/match.c\n@@ -334,11 +334,15 @@\n case MATCHTYPE_DENY:\n {\n ast_error(opt->check.errors, pattern,\n- \"this capture violates capabilities\");\n+ \"cannot capture this pattern, match type and pattern type are not \"\n+ \"compatible due to differing capabilities\");\n ast_error_continue(opt->check.errors, match_type, \"match type: %s\",\n ast_print_type(operand_type));\n ast_error_continue(opt->check.errors, pattern, \"pattern type: %s\",\n ast_print_type(pattern_type));\n+ ast_error_continue(opt->check.errors, pattern,\n+ \"the match type contains union members with different capabilities, \"\n+ \"preventing a safe capture\");\n ok = false;\n break;\n }\n\n--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -452,15 +452,43 @@\n \n if(errorf != NULL)\n {\n+ // Check if this is a capability mismatch issue\n+ bool cap_mismatch = false;\n+ ast_t* sub_cap = cap_fetch(sub);\n+ \n for(ast_t* child = ast_child(super);\n child != NULL;\n child = ast_sibling(child))\n {\n+ ast_t* child_cap = cap_fetch(child);\n+ if(ast_id(sub_cap) != ast_id(child_cap))\n+ {\n+ cap_mismatch = true;\n+ break;\n+ }\n+ }\n+\n+ for(ast_t* child = ast_child(super);\n+ child != NULL;\n+ child = ast_sibling(child))\n+ {\n is_subtype(sub, child, errorf, opt);\n }\n \n- ast_error_frame(errorf, sub, \"%s is not a subtype of any element of %s\",\n- ast_print_type(sub), ast_print_type(super));\n+ if(cap_mismatch)\n+ {\n+ ast_error_frame(errorf, sub, \n+ \"%s is not a subtype of any element of %s: \"\n+ \"the union contains types with different capabilities, \"\n+ \"cannot safely extract %s from the union\",\n+ ast_print_type(sub), ast_print_type(super),\n+ ast_print_type(sub_cap));\n+ }\n+ else\n+ {\n+ ast_error_frame(errorf, sub, \"%s is not a subtype of any element of %s\",\n+ ast_print_type(sub), ast_print_type(super));\n+ }\n }\n \n return false;\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1536", "model_patch": "--- a/src/libponyc/codegen/gentype.c\n+++ b/src/libponyc/codegen/gentype.c\n@@ -407,6 +407,7 @@\n {\n LLVMTypeRef type;\n int extra = 0;\n+ bool packed = false;\n \n switch(t->underlying)\n {\n@@ -426,6 +427,11 @@\n return true;\n \n type = t->structure;\n+ \n+ // Check if the struct is marked as packed\n+ ast_t* def = (ast_t*)ast_data(t->ast);\n+ if(def != NULL && ast_has_annotation(def, \"packed\"))\n+ packed = true;\n break;\n \n case TK_PRIMITIVE:\n@@ -481,7 +487,7 @@\n }\n }\n \n- LLVMStructSetBody(type, elements, t->field_count + extra, false);\n+ LLVMStructSetBody(type, elements, t->field_count + extra, packed);\n ponyint_pool_free_size(buf_size, elements);\n return true;\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1852", "model_patch": "--- a/src/libponyc/codegen/gencall.c\n+++ b/src/libponyc/codegen/gencall.c\n@@ -356,6 +356,12 @@\n }\n }\n \n+ // Remove unnecessary bitcast for symbol loading to avoid incorrect indirection\n+ if(LLVMIsABitCastInst(funptr))\n+ {\n+ return LLVMGetOperand(funptr, 0);\n+ }\n+\n return funptr;\n }\n \n\n--- a/src/libponyc/codegen/gendesc.c\n+++ b/src/libponyc/codegen/gendesc.c\n@@ -535,11 +535,9 @@\n LLVMValueRef desc = gendesc_fetch(c, object);\n LLVMValueRef vtable = LLVMBuildStructGEP(c->builder, desc, DESC_VTABLE, \"\");\n \n- LLVMValueRef gep[2];\n- gep[0] = LLVMConstInt(c->i32, 0, false);\n- gep[1] = LLVMConstInt(c->i32, colour, false);\n-\n- LLVMValueRef func_ptr = LLVMBuildInBoundsGEP(c->builder, vtable, gep, 2, \"\");\n+ LLVMValueRef gep = LLVMConstInt(c->i32, colour, false);\n+\n+ LLVMValueRef func_ptr = LLVMBuildInBoundsGEP(c->builder, vtable, &gep, 1, \"\");\n LLVMValueRef fun = LLVMBuildLoad(c->builder, func_ptr, \"\");\n const char id[] = \"tbaa\";\n LLVMSetMetadata(fun, LLVMGetMDKindID(id, sizeof(id) - 1), c->tbaa_descriptor);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1858", "model_patch": "--- a/src/libponyc/codegen/gencall.c\n+++ b/src/libponyc/codegen/gencall.c\n@@ -319,9 +319,6 @@\n default: {}\n }\n \n- // Generate the receiver.\n- LLVMValueRef value = gen_expr(c, receiver);\n-\n // Get the receiver type.\n ast_t* type = ast_type(receiver);\n reach_type_t* t = reach_type(c->reach, type);\n@@ -330,7 +327,30 @@\n const char* name = ast_name(method);\n token_id cap = cap_dispatch(type);\n reach_method_t* m = reach_method(t, cap, name, typeargs);\n- LLVMValueRef funptr = dispatch_function(c, t, m, value);\n+\n+ // Check if this is a bare lambda (no receiver needed for FFI)\n+ bool is_bare = false;\n+ ast_t* annotation = ast_nearest(ast, TK_ANNOTATION);\n+ if(annotation != NULL)\n+ {\n+ const char* annotation_name = ast_name(ast_child(annotation));\n+ if(annotation_name != NULL && strcmp(annotation_name, \"ponyint_bare\") == 0)\n+ is_bare = true;\n+ }\n+\n+ LLVMValueRef funptr;\n+ \n+ if(is_bare)\n+ {\n+ // For bare lambdas, return the function directly without receiver dispatch\n+ funptr = m->func;\n+ }\n+ else\n+ {\n+ // Generate the receiver for normal function pointers.\n+ LLVMValueRef value = gen_expr(c, receiver);\n+ funptr = dispatch_function(c, t, m, value);\n+ }\n \n if(c->linkage != LLVMExternalLinkage)\n {\n\n--- a/src/libponyc/codegen/genfun.c\n+++ b/src/libponyc/codegen/genfun.c\n@@ -225,6 +225,25 @@\n t->final_fn = m->func;\n LLVMSetFunctionCallConv(m->func, LLVMCCallConv);\n LLVMSetLinkage(m->func, LLVMExternalLinkage);\n+ } else if(m->func != NULL) {\n+ // Check if this is a bare lambda (no receiver parameter for FFI)\n+ ast_t* annotations = ast_parent(ast_parent(m->r_fun));\n+ if(ast_id(annotations) == TK_ANNOTATIONS)\n+ {\n+ ast_t* annotation = ast_child(annotations);\n+ while(annotation != NULL)\n+ {\n+ if(ast_name(ast_child(annotation)) != NULL && \n+ strcmp(ast_name(ast_child(annotation)), \"bare\") == 0)\n+ {\n+ // Bare lambda: use C calling convention and external linkage\n+ LLVMSetFunctionCallConv(m->func, LLVMCCallConv);\n+ LLVMSetLinkage(m->func, LLVMExternalLinkage);\n+ break;\n+ }\n+ annotation = ast_sibling(annotation);\n+ }\n+ }\n }\n }\n \n\n--- a/src/libponyc/expr/lambda.c\n+++ b/src/libponyc/expr/lambda.c\n@@ -105,6 +105,44 @@\n ret_type, raises, body, reference_cap);\n ast_t* annotation = ast_consumeannotation(ast);\n \n+ // Check if this is a bare lambda\n+ bool is_bare = false;\n+ if(annotation != NULL)\n+ {\n+ for(ast_t* p = ast_child(annotation); p != NULL; p = ast_sibling(p))\n+ {\n+ if(strcmp(ast_name(ast_child(p)), \"bare\") == 0)\n+ {\n+ is_bare = true;\n+ break;\n+ }\n+ }\n+ }\n+\n+ // Bare lambdas cannot have captures\n+ if(is_bare && (ast_child(captures) != NULL))\n+ {\n+ ast_error(opt->check.errors, captures,\n+ \"a bare lambda cannot have captures\");\n+ return false;\n+ }\n+\n+ // Bare lambdas cannot have type parameters\n+ if(is_bare && (ast_id(t_params) != TK_NONE) && (ast_child(t_params) != NULL))\n+ {\n+ ast_error(opt->check.errors, t_params,\n+ \"a bare lambda cannot have type parameters\");\n+ return false;\n+ }\n+\n+ // Bare lambdas must have a receiver capability of @\n+ if(is_bare && (ast_id(receiver_cap) != TK_AT))\n+ {\n+ ast_error(opt->check.errors, receiver_cap,\n+ \"a bare lambda must have an @ receiver capability\");\n+ return false;\n+ }\n+\n ast_t* members = ast_from(ast, TK_MEMBERS);\n ast_t* last_member = NULL;\n bool failed = false;\n\n--- a/src/libponyc/pass/syntax.c\n+++ b/src/libponyc/pass/syntax.c\n@@ -1009,6 +1009,9 @@\n pony_assert(ast_id(ast) == TK_LAMBDA);\n AST_GET_CHILDREN(ast, receiver_cap, name, t_params, params, captures,\n ret_type, raises, body, reference_cap);\n+ \n+ bool is_bare = (ast_id(reference_cap) == TK_AT);\n+ \n switch(ast_id(ret_type))\n {\n case TK_ISO:\n@@ -1037,6 +1040,30 @@\n return AST_ERROR;\n }\n capture = ast_sibling(capture);\n+ }\n+\n+ if(is_bare)\n+ {\n+ if(ast_id(receiver_cap) != TK_NONE)\n+ {\n+ ast_error(opt->check.errors, receiver_cap,\n+ \"a bare lambda cannot specify a receiver capability\");\n+ return AST_ERROR;\n+ }\n+\n+ if(ast_child(captures) != NULL)\n+ {\n+ ast_error(opt->check.errors, captures,\n+ \"a bare lambda cannot have captures\");\n+ return AST_ERROR;\n+ }\n+\n+ if(ast_id(raises) != TK_NONE)\n+ {\n+ ast_error(opt->check.errors, raises,\n+ \"a bare lambda cannot have a '?' (partial functions not allowed)\");\n+ return AST_ERROR;\n+ }\n }\n \n if(ast_id(reference_cap) == TK_QUESTION)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1867", "model_patch": "--- a/src/libponyc/expr/reference.c\n+++ b/src/libponyc/expr/reference.c\n@@ -655,14 +655,16 @@\n if((ast_id(parent) == TK_DOT) && (ast_child(parent) == ast))\n {\n ast_t* def = (ast_t*)ast_data(ast);\n- pony_assert(def != NULL);\n-\n- switch(ast_id(def))\n- {\n- case TK_FVAR:\n- case TK_FLET:\n- case TK_EMBED: incomplete_ok = true; break;\n- default: {}\n+\n+ if(def != NULL)\n+ {\n+ switch(ast_id(def))\n+ {\n+ case TK_FVAR:\n+ case TK_FLET:\n+ case TK_EMBED: incomplete_ok = true; break;\n+ default: {}\n+ }\n }\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-1981", "model_patch": "--- a/src/libponyc/type/viewpoint.c\n+++ b/src/libponyc/type/viewpoint.c\n@@ -50,11 +50,15 @@\n upper = VIEW_UPPER_YES;\n break;\n \n- case TK_VAL:\n case TK_TAG:\n case TK_CAP_SHARE:\n // No refcap on the left modifies these.\n upper = VIEW_UPPER_FORCE;\n+ break;\n+\n+ case TK_VAL:\n+ // Val can be compacted like other refcaps.\n+ upper = VIEW_UPPER_YES;\n break;\n \n default: {}\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2007", "model_patch": "--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -1154,6 +1154,14 @@\n \n if(super_lower == NULL)\n {\n+ // If there's no lower bound, check if sub could be a subtype by checking\n+ // against the constraint. This handles cases where the type parameter has\n+ // been narrowed in an iftype block.\n+ ast_t* constraint = typeparam_constraint(super);\n+ \n+ if(constraint != NULL && is_x_sub_x(sub, constraint, check_cap, NULL, opt))\n+ return true;\n+\n if(errorf != NULL)\n {\n ast_error_frame(errorf, sub,\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2126", "model_patch": "--- a/src/libponyc/expr/array.c\n+++ b/src/libponyc/expr/array.c\n@@ -80,14 +80,23 @@\n \n BUILD(ref, ast, NODE(TK_REFERENCE, ID(\"Array\")));\n \n- ast_t* a_type = alias(type);\n+ ast_t* a_type;\n+ if(told_type)\n+ {\n+ // User specified the type explicitly, use it as the Array type argument\n+ a_type = type;\n+ }\n+ else\n+ {\n+ // Type was inferred from elements, use the alias as the Array type argument\n+ a_type = alias(type);\n+ ast_free_unattached(type);\n+ }\n \n BUILD(qualify, ast,\n NODE(TK_QUALIFY,\n TREE(ref)\n NODE(TK_TYPEARGS, TREE(a_type))));\n-\n- ast_free_unattached(type);\n \n BUILD(dot, ast, NODE(TK_DOT, TREE(qualify) ID(\"create\")));\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2168", "model_patch": "--- a/src/libponyc/type/assemble.c\n+++ b/src/libponyc/type/assemble.c\n@@ -216,7 +216,10 @@\n {\n // The new branch is a literal\n if(control_type == NULL)\n+ {\n control_type = ast_from(branch, TK_LITERAL);\n+ ast_settype(control_type, NULL);\n+ }\n \n if(ast_id(control_type) != TK_LITERAL)\n {\n@@ -239,8 +242,8 @@\n {\n // The branch's literal type has a non-literal component\n ast_t* non_literal_type = ast_type(control_type);\n- ast_settype(control_type, type_union(opt, non_literal_type,\n- branch_non_lit));\n+ non_literal_type = type_union(opt, non_literal_type, branch_non_lit);\n+ ast_settype(control_type, non_literal_type);\n }\n \n return control_type;\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2176", "model_patch": "--- a/src/libponyc/codegen/genreference.c\n+++ b/src/libponyc/codegen/genreference.c\n@@ -137,7 +137,8 @@\n \n LLVMValueRef l_value = gen_expr(c, left);\n \n- if(l_value == NULL)\n+ if((l_value == NULL) || (l_value == GEN_NOVALUE) ||\n+ (l_value == GEN_NOTNEEDED))\n return NULL;\n \n ast_t* type = ast_type(ast);\n\n--- a/src/libponyc/codegen/gentype.c\n+++ b/src/libponyc/codegen/gentype.c\n@@ -773,7 +773,7 @@\n {\n // Call the trace function indirectly depending on rcaps.\n LLVMValueRef value = LLVMBuildLoad(c->builder, field, \"\");\n- ast_t* field_type = t->fields[i].ast;\n+ ast_t* field_type = t->fields[i].type->ast;\n value = gen_assign_cast(c, f_c_t->use_type, value, field_type);\n gentrace(c, ctx, value, value, field_type, field_type);\n } else {\n\n--- a/src/libponyc/expr/reference.c\n+++ b/src/libponyc/expr/reference.c\n@@ -755,6 +755,7 @@\n type = ast_type(child);\n } else {\n type = ast_from(ast, TK_TUPLETYPE);\n+ bool has_literal = false;\n \n while(child != NULL)\n {\n@@ -762,24 +763,31 @@\n {\n ast_error(opt->check.errors, child,\n \"a tuple can't contain an expression that jumps away with no value\");\n+ ast_free_unattached(type);\n return false;\n }\n \n ast_t* c_type = ast_type(child);\n \n if((c_type == NULL) || (ast_id(c_type) == TK_ERRORTYPE))\n+ {\n+ ast_free_unattached(type);\n return false;\n+ }\n \n if(is_type_literal(c_type))\n- {\n- // At least one tuple member is literal, so whole tuple is\n- ast_free(type);\n- make_literal_type(ast);\n- return true;\n- }\n+ has_literal = true;\n \n ast_append(type, c_type);\n child = ast_sibling(child);\n+ }\n+\n+ if(has_literal)\n+ {\n+ // At least one tuple member is literal, so whole tuple is\n+ ast_free_unattached(type);\n+ make_literal_type(ast);\n+ return true;\n }\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2201", "model_patch": "--- a/src/libponyc/expr/call.c\n+++ b/src/libponyc/expr/call.c\n@@ -223,6 +223,15 @@\n \n if(is_typecheck_error(arg_type))\n return false;\n+\n+ // Check if this is an underscore (don't care) pattern being used as an argument\n+ ast_t* arg_child = ast_child(arg);\n+ if((arg_child != NULL) && (ast_id(arg_child) == TK_DONTCAREREF))\n+ {\n+ ast_error(opt->check.errors, arg, \"can't use '_' as a value\");\n+ return false;\n+ }\n+=======\n \n if(ast_checkflag(arg, AST_FLAG_JUMPS_AWAY))\n {\n\n--- a/src/libponyc/expr/reference.c\n+++ b/src/libponyc/expr/reference.c\n@@ -338,8 +338,52 @@\n \n bool expr_dontcareref(pass_opt_t* opt, ast_t* ast)\n {\n- (void)opt;\n pony_assert(ast_id(ast) == TK_DONTCAREREF);\n+\n+ // Don't care can only be used in certain contexts, not as a readable value\n+ ast_t* parent = ast_parent(ast);\n+ \n+ // Check if we're on the left side of an assignment or in a pattern match\n+ bool valid_context = false;\n+ \n+ if(parent != NULL)\n+ {\n+ switch(ast_id(parent))\n+ {\n+ case TK_ASSIGN:\n+ // Valid if on the left-hand side\n+ if(ast_child(parent) == ast)\n+ valid_context = true;\n+ break;\n+ \n+ case TK_VAR:\n+ case TK_LET:\n+ // Valid in variable declarations (pattern matching)\n+ valid_context = true;\n+ break;\n+ \n+ case TK_CASE:\n+ case TK_SEQ:\n+ {\n+ // Check if we're in a case pattern\n+ ast_t* p = parent;\n+ while(p != NULL && ast_id(p) == TK_SEQ)\n+ p = ast_parent(p);\n+ if(p != NULL && ast_id(p) == TK_CASE)\n+ valid_context = true;\n+ break;\n+ }\n+ \n+ default:\n+ break;\n+ }\n+ }\n+ \n+ if(!valid_context)\n+ {\n+ ast_error(opt->check.errors, ast, \"can't read from '_'\");\n+ return false;\n+ }\n \n ast_settype(ast, ast_from(ast, TK_DONTCARETYPE));\n \n\n--- a/src/libponyc/pass/expr.c\n+++ b/src/libponyc/pass/expr.c\n@@ -270,7 +270,15 @@\n case TK_ARRAY: r = expr_array(options, astp); break;\n \n case TK_DONTCAREREF:\n- r = expr_dontcareref(options, ast); break;\n+ {\n+ r = expr_dontcareref(options, ast);\n+ if(r && is_result_needed(ast))\n+ {\n+ ast_error(options->check.errors, ast, \"can't read from '_'\");\n+ r = false;\n+ }\n+ break;\n+ }\n case TK_TYPEREF: r = expr_typeref(options, astp); break;\n case TK_VARREF:\n case TK_LETREF: r = expr_localref(options, ast); break;\n\n--- a/src/libponyc/verify/call.c\n+++ b/src/libponyc/verify/call.c\n@@ -132,12 +132,32 @@\n \n bool verify_behaviour_call(pass_opt_t* opt, ast_t* ast)\n {\n- (void)opt;\n pony_assert((ast_id(ast) == TK_BEREF) || (ast_id(ast) == TK_BECHAIN) ||\n (ast_id(ast) == TK_NEWBEREF));\n \n ast_inheritflags(ast);\n ast_setsend(ast);\n+\n+ // Check arguments for invalid use of TK_DONTCARE\n+ ast_t* call = ast_parent(ast);\n+ if(ast_id(call) != TK_CALL)\n+ call = ast_parent(call);\n+ \n+ if(ast_id(call) == TK_CALL)\n+ {\n+ ast_t* args = ast_childidx(call, 1);\n+ ast_t* arg = ast_child(args);\n+ \n+ while(arg != NULL)\n+ {\n+ if(ast_id(arg) == TK_DONTCARE)\n+ {\n+ ast_error(opt->check.errors, arg, \"can't read from '_'\");\n+ return false;\n+ }\n+ arg = ast_sibling(arg);\n+ }\n+ }\n \n return true;\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2203", "model_patch": "--- a/src/libponyc/codegen/gentype.c\n+++ b/src/libponyc/codegen/gentype.c\n@@ -248,8 +248,6 @@\n c_t->mem_type = c->i32;\n else\n c_t->mem_type = c->i8;\n-\n- return true;\n }\n else if(name == c->str_Pointer)\n {\n\n--- a/src/libponyc/reach/reach.c\n+++ b/src/libponyc/reach/reach.c\n@@ -1296,7 +1296,10 @@\n ast_t* type = ast_type(ast);\n \n if(type != NULL)\n+ {\n+ add_type(r, type, opt);\n reachable_method(r, type, stringtab(\"create\"), NULL, opt);\n+ }\n break;\n }\n \n\n--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -1255,8 +1255,8 @@\n {\n ast_error_frame(errorf, sub, \"a bare type cannot be in an \"\n \"intersection type\");\n- return false;\n }\n+ return false;\n }\n \n return is_x_sub_isect(sub, super, check_cap, errorf, opt);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2205", "model_patch": "--- a/src/libponyc/codegen/gencall.c\n+++ b/src/libponyc/codegen/gencall.c\n@@ -1097,6 +1097,20 @@\n // Make it varargs.\n func = declare_ffi_vararg(c, f_name, t);\n }\n+ } else {\n+ // Function already exists, verify the return type matches\n+ LLVMTypeRef existing_type = LLVMGetElementType(LLVMTypeOf(func));\n+ LLVMTypeRef existing_ret = LLVMGetReturnType(existing_type);\n+ LLVMTypeRef expected_ret = ffi_return_type(c, t, \n+ !strncmp(f_name, \"llvm.\", 5) || !strncmp(f_name, \"internal.\", 9));\n+ \n+ if(existing_ret != expected_ret)\n+ {\n+ ast_error(c->opt->check.errors, ast,\n+ \"conflicting declarations for FFI function '%s': \"\n+ \"return type doesn't match previous declaration\", f_name);\n+ return NULL;\n+ }\n }\n \n // Generate the arguments.\n\n--- a/src/libponyc/codegen/genexpr.c\n+++ b/src/libponyc/codegen/genexpr.c\n@@ -331,7 +331,13 @@\n case LLVMHalfTypeKind:\n case LLVMFloatTypeKind:\n case LLVMDoubleTypeKind:\n- pony_assert(LLVMGetTypeKind(r_type) == LLVMPointerTypeKind);\n+ if(LLVMGetTypeKind(r_type) != LLVMPointerTypeKind)\n+ {\n+ // This can happen when FFI calls have inconsistent signatures.\n+ // The error should have been caught earlier in compilation.\n+ pony_assert(0);\n+ return NULL;\n+ }\n r_value = gen_unbox(c, type, r_value);\n // The value could be needed in either its value representation type or\n // its memory representation type. Cast the unboxed value to ensure the\n\n--- a/src/libponyc/expr/ffi.c\n+++ b/src/libponyc/expr/ffi.c\n@@ -151,7 +151,7 @@\n if(decl != NULL) // We have a declaration\n return declared_ffi(opt, ast, decl);\n \n- // We do not have a declaration\n+ // We do not have a declaration - validate and register as implicit declaration\n for(ast_t* arg = ast_child(args); arg != NULL; arg = ast_sibling(arg))\n {\n ast_t* a_type = ast_type(arg);\n@@ -196,5 +196,10 @@\n \n ast_settype(ast, return_type);\n \n+ // Register this undeclared call as an implicit declaration so future calls\n+ // to the same FFI function will be validated against this signature\n+ if(!ifdef_cond_ffi(&opt->check, ast_name(name), ast, opt))\n+ return false;\n+\n return true;\n }\n\n--- a/src/libponyc/pkg/ifdef.c\n+++ b/src/libponyc/pkg/ifdef.c\n@@ -481,8 +481,41 @@\n return false;\n }\n \n- // Store declaration found for next time, including if we found nothing.\n- symtab_add(symtab, ffi_name, decl, SYM_FFIDECL);\n+ if(decl == NULL)\n+ {\n+ // No declaration found - this is an undeclared FFI call.\n+ // Store the call site itself so we can check signature consistency.\n+ symtab_add(symtab, ffi_name, ast, SYM_FFIDECL);\n+ }\n+ else\n+ {\n+ // Store declaration found for next time.\n+ symtab_add(symtab, ffi_name, decl, SYM_FFIDECL);\n+ }\n+ }\n+ else if(decl != NULL && ast_id(decl) == TK_FFIDECL)\n+ {\n+ // We have a declared FFI, use it as normal.\n+ }\n+ else if(decl != NULL && ast_id(decl) == TK_FFICALL)\n+ {\n+ // We have a previous undeclared FFI call stored.\n+ // Check that the signatures match.\n+ AST_GET_CHILDREN(ast, ast_name_node, ast_ret_type, ast_params, ast_named_args, ast_error);\n+ AST_GET_CHILDREN(decl, decl_name_node, decl_ret_type, decl_params, decl_named_args, decl_error);\n+ \n+ // Compare return types and parameters\n+ if(!ast_equiv(ast_ret_type, decl_ret_type) || !ast_equiv(ast_params, decl_params))\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"FFI call signature does not match previous call\");\n+ ast_error_continue(opt->check.errors, decl,\n+ \"Previous FFI call is here\");\n+ return false;\n+ }\n+ \n+ // Signatures match, use NULL to indicate undeclared\n+ decl = NULL;\n }\n \n *out_decl = decl;\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2214", "model_patch": "--- a/src/libponyc/ast/lexer.c\n+++ b/src/libponyc/ast/lexer.c\n@@ -840,33 +840,54 @@\n lexint_t value;\n lexint_zero(&value);\n \n- while(true)\n- {\n- if(is_eof(lexer))\n- return literal_doesnt_terminate(lexer);\n-\n- int c = look(lexer);\n-\n- if(c == '\\'')\n- {\n+ if(is_eof(lexer))\n+ return literal_doesnt_terminate(lexer);\n+\n+ int c = look(lexer);\n+\n+ // Check for empty character literal\n+ if(c == '\\'')\n+ {\n+ lex_error(lexer, \"Empty character literal\");\n+ consume_chars(lexer, 1);\n+ return make_token(lexer, TK_LEX_ERROR);\n+ }\n+\n+ // Read exactly one character (or escape sequence)\n+ if(c == '\\\\')\n+ c = escape(lexer, false, false);\n+ else\n+ consume_chars(lexer, 1);\n+\n+ // Just ignore bad escapes here and carry on. They've already been\n+ // reported and this allows catching later errors.\n+ if(c >= 0)\n+ lexint_char(&value, c);\n+\n+ // Now we must have the closing quote\n+ if(is_eof(lexer))\n+ return literal_doesnt_terminate(lexer);\n+\n+ c = look(lexer);\n+\n+ if(c != '\\'')\n+ {\n+ lex_error(lexer, \"Character literal may only contain one character\");\n+ \n+ // Consume remaining characters until we find the closing quote or EOF\n+ while(!is_eof(lexer) && look(lexer) != '\\'')\n consume_chars(lexer, 1);\n- token_t* t = make_token(lexer, TK_INT);\n- token_set_int(t, &value);\n- return t;\n- }\n-\n- if(c == '\\\\')\n- c = escape(lexer, false, false);\n- else\n- consume_chars(lexer, 1);\n-\n- // Just ignore bad escapes here and carry on. They've already been\n- // reported and this allows catching later errors.\n- if(c >= 0)\n- lexint_char(&value, c);\n-\n- // TODO: Should we catch overflow and treat as an error?\n- }\n+ \n+ if(!is_eof(lexer))\n+ consume_chars(lexer, 1); // Consume closing '\n+ \n+ return make_token(lexer, TK_LEX_ERROR);\n+ }\n+\n+ consume_chars(lexer, 1); // Consume closing '\n+ token_t* t = make_token(lexer, TK_INT);\n+ token_set_int(t, &value);\n+ return t;\n }\n \n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2221", "model_patch": "--- a/src/libponyc/ast/lexer.c\n+++ b/src/libponyc/ast/lexer.c\n@@ -526,23 +526,29 @@\n \n // Trim a leading newline if there is one.\n char* buf = lexer->buffer;\n+ bool had_leading_newline = false;\n \n if((buf[0] == '\\r') && (buf[1] == '\\n'))\n {\n lexer->buflen -= 2;\n memmove(&buf[0], &buf[2], lexer->buflen);\n+ had_leading_newline = true;\n }\n else if(buf[0] == '\\n')\n {\n lexer->buflen--;\n memmove(&buf[0], &buf[1], lexer->buflen);\n+ had_leading_newline = true;\n }\n \n // Calculate leading whitespace.\n+ // Only consider lines after the first line if there was no leading newline,\n+ // to ensure consistent behavior regardless of first line content.\n size_t ws = lexer->buflen;\n size_t ws_this_line = 0;\n bool in_leading_ws = true;\n bool has_non_ws = false;\n+ bool first_line = !had_leading_newline;\n \n for(size_t i = 0; i < lexer->buflen; i++)\n {\n@@ -559,7 +565,9 @@\n if(!isspace(c))\n has_non_ws = true;\n \n- if(has_non_ws && (ws_this_line < ws))\n+ // Only count whitespace from lines after the first line if there was\n+ // no leading newline, to get consistent behavior\n+ if(has_non_ws && !first_line && (ws_this_line < ws))\n ws = ws_this_line;\n \n in_leading_ws = false;\n@@ -571,15 +579,17 @@\n ws_this_line = 0;\n has_non_ws = false;\n in_leading_ws = true;\n+ first_line = false;\n }\n }\n \n // Trim leading whitespace on each line.\n- if(ws > 0)\n+ if(ws > 0 && ws < lexer->buflen)\n {\n char* line_start = lexer->buffer;\n char* compacted = lexer->buffer;\n size_t rem = lexer->buflen;\n+ bool is_first_line = !had_leading_newline;\n \n while(rem > 0)\n {\n@@ -587,7 +597,13 @@\n size_t line_len =\n (line_end == NULL) ? rem : (size_t)(line_end - line_start + 1);\n \n- if(line_start != line_end)\n+ // Don't trim the first line if there was no leading newline\n+ if(is_first_line)\n+ {\n+ memmove(compacted, line_start, line_len);\n+ compacted += line_len;\n+ }\n+ else if(line_start != line_end)\n {\n size_t trim = (line_len < ws) ? line_len : ws;\n memmove(compacted, line_start + trim, line_len - trim);\n@@ -601,6 +617,7 @@\n \n line_start += line_len;\n rem -= line_len;\n+ is_first_line = false;\n }\n \n lexer->buflen = compacted - lexer->buffer;\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2261", "model_patch": "--- a/src/libponyc/expr/call.c\n+++ b/src/libponyc/expr/call.c\n@@ -689,7 +689,9 @@\n if(!bare)\n apply_cap = partial_application_cap(opt, type, receiver, positional);\n \n- token_id can_error = ast_id(ast_childidx(method_def, 5));\n+ // Get the error indicator from the function type, not from the method\n+ // definition, since the function type reflects the trait signature.\n+ token_id can_error = ast_id(ast_childidx(type, 4));\n const char* recv_name = package_hygienic_id(t);\n \n // Build lambda expression.\n\n--- a/src/libponyc/pass/refer.c\n+++ b/src/libponyc/pass/refer.c\n@@ -438,6 +438,47 @@\n \n sym_status_t status;\n ast_t* def = ast_get(ast, name, &status);\n+ \n+ // If we found a method definition and we're in a trait/interface context,\n+ // we should use the trait/interface method definition, not an implementation.\n+ if(def != NULL && opt->check.frame->type != NULL)\n+ {\n+ token_id type_id = ast_id(opt->check.frame->type);\n+ if((type_id == TK_TRAIT || type_id == TK_INTERFACE))\n+ {\n+ switch(ast_id(def))\n+ {\n+ case TK_NEW:\n+ case TK_BE:\n+ case TK_FUN:\n+ {\n+ // Look up the method in the trait/interface members instead\n+ ast_t* members = ast_childidx(opt->check.frame->type, 4);\n+ ast_t* member = ast_child(members);\n+ \n+ while(member != NULL)\n+ {\n+ if((ast_id(member) == TK_NEW || ast_id(member) == TK_BE || \n+ ast_id(member) == TK_FUN))\n+ {\n+ AST_GET_CHILDREN(member, cap, id, typeparams, params, rtype, \n+ error, body, docstring);\n+ if(ast_name(id) == name)\n+ {\n+ def = member;\n+ break;\n+ }\n+ }\n+ member = ast_sibling(member);\n+ }\n+ break;\n+ }\n+ \n+ default: {}\n+ }\n+ }\n+ }\n+ \n ast_setdata(ast, (void*)def);\n \n // If nothing was found, we fail, but also try to suggest an alternate name.\n\n--- a/src/libponyc/pass/traits.c\n+++ b/src/libponyc/pass/traits.c\n@@ -125,14 +125,12 @@\n {\n method_t* info = (method_t*)ast_data(p);\n pony_assert(info != NULL);\n- ast_t* body_donor = info->body_donor;\n POOL_FREE(method_t, info);\n \n- if(body_donor == NULL)\n- // No body, donor should indicate containing type.\n- body_donor = entity;\n-\n- ast_setdata(p, body_donor);\n+ // Always set data to the containing entity for signature checking.\n+ // The signature to check against should be the one in the current type,\n+ // not where the body comes from.\n+ ast_setdata(p, entity);\n }\n }\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2272", "model_patch": "--- a/src/libponyrt/gc/serialise.h\n+++ b/src/libponyrt/gc/serialise.h\n@@ -37,6 +37,8 @@\n PONY_API void* pony_deserialise_raw(pony_ctx_t* ctx, uintptr_t offset,\n deserialise_raw_fn ds_fn);\n \n+PONY_API const char* pony_serialise_signature();\n+\n PONY_EXTERN_C_END\n \n #endif\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2342", "model_patch": "--- a/src/libponyc/expr/match.c\n+++ b/src/libponyc/expr/match.c\n@@ -50,6 +50,8 @@\n // A value expression pattern that meets these conditions may be treated as\n // matching on type alone, because the value is a singleton for that type\n // and the result of the eq method will always be true if the type matches.\n+ // However, we must not treat references to primitive instances as matching\n+ // on type alone, because they match on structural equality via the eq method.\n \n ast_t* type = ast_type(case_expr);\n \n@@ -59,6 +61,11 @@\n ast_t* def = (ast_t*)ast_data(type);\n \n if((def == NULL) || (ast_id(def) != TK_PRIMITIVE) || is_machine_word(type))\n+ return false;\n+\n+ // If the case expression is a reference (not a type pattern), then it's\n+ // matching on structural equality, not type alone.\n+ if(ast_id(case_expr) == TK_REFERENCE)\n return false;\n \n ast_t* eq_def = ast_get(def, stringtab(\"eq\"), NULL);\n\n--- a/src/libponyc/pass/refer.c\n+++ b/src/libponyc/pass/refer.c\n@@ -319,6 +319,21 @@\n case TK_CLASS:\n case TK_ACTOR:\n {\n+ // Check if this is a primitive used as a value in a case pattern\n+ ast_t* parent = ast_parent(ast);\n+ bool in_case_pattern = (parent != NULL) && (ast_id(parent) == TK_CASE) &&\n+ (ast_child(parent) == ast);\n+ \n+ if((ast_id(def) == TK_PRIMITIVE) && in_case_pattern)\n+ {\n+ // This is a primitive singleton used as an instance pattern in a match case.\n+ // Keep it as a value reference rather than converting to a type reference.\n+ // This allows the match checker to properly distinguish between different\n+ // primitive instances rather than treating them all as the same type.\n+ ast_setid(ast, TK_FLETREF); // Treat as a field-like reference\n+ return true;\n+ }\n+\n ast_setid(ast, TK_TYPEREF);\n \n ast_add(ast, ast_from(ast, TK_NONE)); // 1st child: package reference\n\n--- a/src/libponyc/type/matchtype.c\n+++ b/src/libponyc/type/matchtype.c\n@@ -213,6 +213,15 @@\n AST_GET_CHILDREN(operand, o_pkg, o_id, o_typeargs, o_cap, o_eph);\n AST_GET_CHILDREN(pattern, p_pkg, p_id, p_typeargs, p_cap, p_eph);\n \n+ ast_t* operand_def = (ast_t*)ast_data(operand);\n+ ast_t* pattern_def = (ast_t*)ast_data(pattern);\n+\n+ // For primitives, we need an exact match on the definition, not just a\n+ // subtype relationship. This is because primitive instances are singletons\n+ // and matching should be based on identity.\n+ if(ast_id(pattern_def) == TK_PRIMITIVE && operand_def != pattern_def)\n+ return MATCHTYPE_REJECT;\n+\n // We say the pattern provides the operand if it is a subtype after changing\n // it to have the same refcap as the operand.\n token_id tcap = ast_id(p_cap);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2504", "model_patch": "--- a/src/libponyc/expr/call.c\n+++ b/src/libponyc/expr/call.c\n@@ -179,15 +179,15 @@\n \n if(!ast_passes_subtree(&location, opt, PASS_EXPR))\n return false;\n+ \n+ if(!expr_seq(opt, *argp))\n+ return false;\n }\n else\n {\n // Just use default argument.\n ast_replace(argp, def_arg);\n }\n-\n- if(!expr_seq(opt, *argp))\n- return false;\n \n return true;\n }\n\n--- a/src/libponyc/expr/literal.c\n+++ b/src/libponyc/expr/literal.c\n@@ -460,6 +460,10 @@\n \n return uifset_simple_type(opt, type);\n \n+ case TK_TYPEALIAS:\n+ // Resolve the alias and process the underlying type\n+ return uifset(opt, ast_childidx(type, 2), chain);\n+\n case TK_DONTCARETYPE:\n case TK_FUNTYPE:\n return UIF_NO_TYPES;\n\n--- a/src/libponyc/pass/expr.c\n+++ b/src/libponyc/pass/expr.c\n@@ -267,6 +267,16 @@\n {\n AST_GET_CHILDREN(parent, id, type, deflt);\n pony_assert(ast == deflt);\n+ \n+ // If the parameter type is a type parameter reference, we need to get\n+ // the actual type it has been reified to.\n+ if(ast_id(type) == TK_TYPEPARAMREF)\n+ {\n+ ast_t* param_type = ast_type(type);\n+ if(param_type != NULL)\n+ return param_type;\n+ }\n+ \n return type;\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2532", "model_patch": "--- a/src/libponyc/expr/match.c\n+++ b/src/libponyc/expr/match.c\n@@ -509,38 +509,62 @@\n ast_t* operand_type = alias(match_type);\n bool ok = true;\n \n- switch(is_matchtype(operand_type, pattern_type, opt))\n- {\n- case MATCHTYPE_ACCEPT:\n- break;\n-\n- case MATCHTYPE_REJECT:\n- {\n- ast_error(opt->check.errors, pattern, \"this pattern can never match\");\n- ast_error_continue(opt->check.errors, match_type, \"match type: %s\",\n- ast_print_type(operand_type));\n- // TODO report unaliased type when body is consume !\n- ast_error_continue(opt->check.errors, pattern, \"pattern type: %s\",\n- ast_print_type(pattern_type));\n- ok = false;\n- break;\n- }\n-\n- case MATCHTYPE_DENY:\n- {\n- ast_error(opt->check.errors, pattern,\n- \"this capture violates capabilities, because the match would \"\n- \"need to differentiate by capability at runtime instead of matching \"\n- \"on type alone\");\n- ast_error_continue(opt->check.errors, match_type, \"the match type \"\n- \"allows for more than one possibility with the same type as \"\n- \"pattern type, but different capabilities. match type: %s\",\n- ast_print_type(operand_type));\n- ast_error_continue(opt->check.errors, pattern, \"pattern type: %s\",\n- ast_print_type(pattern_type));\n-\n- ok = false;\n- break;\n+ // Special case: if operand is an empty interface and pattern is a tuple,\n+ // accept the match because tuples are subtypes of empty interfaces.\n+ bool is_empty_interface_tuple_match = false;\n+ if(ast_id(pattern_type) == TK_TUPLETYPE)\n+ {\n+ // Check if operand_type is an empty interface (like Any)\n+ // by checking if it's a subtype of the tuple pattern type\n+ // Since tuples are now subtypes of Any, Any should accept tuple patterns\n+ ast_t* unaliased_operand = ast_type(match_expr);\n+ \n+ // Check if the operand type is a union or interface that contains\n+ // an empty interface. If the pattern (tuple) is a subtype of the\n+ // operand type, then it should match.\n+ if(is_subtype(pattern_type, unaliased_operand, NULL, opt))\n+ is_empty_interface_tuple_match = true;\n+ }\n+\n+ if(is_empty_interface_tuple_match)\n+ {\n+ // Accept the match\n+ }\n+ else\n+ {\n+ switch(is_matchtype(operand_type, pattern_type, opt))\n+ {\n+ case MATCHTYPE_ACCEPT:\n+ break;\n+\n+ case MATCHTYPE_REJECT:\n+ {\n+ ast_error(opt->check.errors, pattern, \"this pattern can never match\");\n+ ast_error_continue(opt->check.errors, match_type, \"match type: %s\",\n+ ast_print_type(operand_type));\n+ // TODO report unaliased type when body is consume !\n+ ast_error_continue(opt->check.errors, pattern, \"pattern type: %s\",\n+ ast_print_type(pattern_type));\n+ ok = false;\n+ break;\n+ }\n+\n+ case MATCHTYPE_DENY:\n+ {\n+ ast_error(opt->check.errors, pattern,\n+ \"this capture violates capabilities, because the match would \"\n+ \"need to differentiate by capability at runtime instead of matching \"\n+ \"on type alone\");\n+ ast_error_continue(opt->check.errors, match_type, \"the match type \"\n+ \"allows for more than one possibility with the same type as \"\n+ \"pattern type, but different capabilities. match type: %s\",\n+ ast_print_type(operand_type));\n+ ast_error_continue(opt->check.errors, pattern, \"pattern type: %s\",\n+ ast_print_type(pattern_type));\n+\n+ ok = false;\n+ break;\n+ }\n }\n }\n \n\n--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -692,8 +692,41 @@\n static bool is_single_sub_tuple(ast_t* sub, ast_t* super, check_cap_t check_cap,\n errorframe_t* errorf, pass_opt_t* opt)\n {\n- (void)check_cap;\n- (void)opt;\n+ // Check if sub is an empty interface (nominal type with empty members)\n+ if(ast_id(sub) == TK_NOMINAL)\n+ {\n+ ast_t* sub_def = (ast_t*)ast_data(sub);\n+ \n+ if(ast_id(sub_def) == TK_INTERFACE)\n+ {\n+ ast_t* sub_members = ast_childidx(sub_def, 4);\n+ pony_assert(ast_id(sub_members) == TK_MEMBERS);\n+ \n+ if(ast_childcount(sub_members) == 0)\n+ {\n+ // This is an empty interface, so we let it be a subtype of the tuple\n+ // if it would be a subtype of each element of the tuple.\n+ for(ast_t* child = ast_child(super);\n+ child != NULL;\n+ child = ast_sibling(child))\n+ {\n+ if(!is_x_sub_x(sub, child, check_cap, errorf, opt))\n+ {\n+ if(errorf != NULL)\n+ {\n+ ast_error_frame(errorf, sub,\n+ \"%s is not a subtype of %s: %s is not a subtype of tuple element %s\",\n+ ast_print_type(sub), ast_print_type(super),\n+ ast_print_type(sub), ast_print_type(child));\n+ }\n+ return false;\n+ }\n+ }\n+ \n+ return true;\n+ }\n+ }\n+ }\n \n if(errorf != NULL)\n {\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2660", "model_patch": "--- a/src/libponyc/type/cap.c\n+++ b/src/libponyc/type/cap.c\n@@ -239,7 +239,7 @@\n return false;\n }\n \n- if((sub == super) || (super == TK_TAG))\n+ if(super == TK_TAG)\n return true;\n \n // Sub and super share the same initial bounds.\n@@ -256,6 +256,7 @@\n case TK_ISO:\n switch(super)\n {\n+ case TK_ISO:\n case TK_TRN:\n case TK_REF:\n case TK_VAL:\n@@ -274,6 +275,7 @@\n case TK_TRN:\n switch(super)\n {\n+ case TK_TRN:\n case TK_REF:\n case TK_VAL:\n case TK_BOX:\n@@ -289,6 +291,7 @@\n case TK_REF:\n switch(super)\n {\n+ case TK_REF:\n case TK_BOX:\n return true;\n \n@@ -299,8 +302,29 @@\n case TK_VAL:\n switch(super)\n {\n- case TK_BOX:\n- case TK_CAP_SHARE: // {val, tag}\n+ case TK_VAL:\n+ case TK_BOX:\n+ case TK_CAP_SHARE: // {val, tag}\n+ return true;\n+\n+ default: {}\n+ }\n+ break;\n+\n+ case TK_BOX:\n+ switch(super)\n+ {\n+ case TK_BOX:\n+ return true;\n+\n+ default: {}\n+ }\n+ break;\n+\n+ case TK_TAG:\n+ switch(super)\n+ {\n+ case TK_TAG:\n return true;\n \n default: {}\n@@ -311,6 +335,7 @@\n switch(super)\n {\n case TK_BOX:\n+ case TK_CAP_READ:\n case TK_CAP_SHARE: // {val, tag}\n case TK_CAP_ALIAS: // {ref, val, box, tag}\n return true;\n@@ -324,6 +349,7 @@\n {\n case TK_CAP_READ: // {ref, val, box}\n case TK_CAP_SHARE: // {val, tag}\n+ case TK_CAP_SEND:\n case TK_CAP_ALIAS: // {ref, val, box, tag}\n case TK_CAP_ANY: // {iso, trn, ref, val, box, tag}\n return true;\n@@ -337,6 +363,7 @@\n {\n case TK_CAP_READ: // {ref, val, box}\n case TK_CAP_SHARE: // {val, tag}\n+ case TK_CAP_ALIAS:\n return true;\n \n default: {}\n@@ -350,6 +377,7 @@\n case TK_CAP_SHARE: // {val, tag}\n case TK_CAP_SEND: // {iso, val, tag}\n case TK_CAP_ALIAS: // {ref, val, box, tag}\n+ case TK_CAP_ANY:\n return true;\n \n default: {}\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2664", "model_patch": "--- a/src/libponyc/codegen/genexpr.c\n+++ b/src/libponyc/codegen/genexpr.c\n@@ -236,16 +236,26 @@\n while(type_child != NULL)\n {\n LLVMValueRef r_child = LLVMBuildExtractValue(c->builder, r_value, i, \"\");\n- LLVMValueRef cast_value = gen_assign_cast(c, elements[i], r_child,\n- type_child);\n-\n- if(cast_value == NULL)\n- {\n- ponyint_pool_free_size(buf_size, elements);\n- return NULL;\n- }\n-\n- result = LLVMBuildInsertValue(c->builder, result, cast_value, i, \"\");\n+ LLVMValueRef cast_value;\n+ \n+ if(r_child == GEN_NOTNEEDED)\n+ {\n+ cast_value = GEN_NOTNEEDED;\n+ }\n+ else\n+ {\n+ cast_value = gen_assign_cast(c, elements[i], r_child, type_child);\n+\n+ if(cast_value == NULL)\n+ {\n+ ponyint_pool_free_size(buf_size, elements);\n+ return NULL;\n+ }\n+ }\n+\n+ if(cast_value != GEN_NOTNEEDED)\n+ result = LLVMBuildInsertValue(c->builder, result, cast_value, i, \"\");\n+ \n type_child = ast_sibling(type_child);\n i++;\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2853", "model_patch": "--- a/src/libponyc/codegen/gencontrol.c\n+++ b/src/libponyc/codegen/gencontrol.c\n@@ -683,12 +683,24 @@\n \n LLVMValueRef gen_error(compile_t* c, ast_t* ast)\n {\n- size_t clause;\n- ast_t* try_expr = ast_try_clause(ast, &clause);\n-\n- // Do the then block only if we error out in the else clause.\n- if((try_expr != NULL) && (clause == 1))\n- gen_expr(c, ast_childidx(try_expr, 2));\n+ // Execute then blocks for all enclosing try expressions.\n+ // We need to walk up from the innermost try to execute all then blocks.\n+ ast_t* current = ast;\n+ while(true)\n+ {\n+ size_t clause;\n+ ast_t* try_expr = ast_try_clause(current, &clause);\n+ \n+ if(try_expr == NULL)\n+ break;\n+ \n+ // Do the then block only if we error out in the else clause.\n+ if(clause == 1)\n+ gen_expr(c, ast_childidx(try_expr, 2));\n+ \n+ // Continue searching for outer try expressions\n+ current = try_expr;\n+ }\n \n codegen_scope_lifetime_end(c);\n codegen_debugloc(c, ast);\n\n--- a/src/libponyc/expr/control.c\n+++ b/src/libponyc/expr/control.c\n@@ -278,12 +278,6 @@\n type = control_type_add_branch(opt, type, else_clause);\n }\n \n- if((type == NULL) && (ast_sibling(ast) != NULL))\n- {\n- ast_error(opt->check.errors, ast_sibling(ast), \"unreachable code\");\n- return false;\n- }\n-\n ast_t* then_type = ast_type(then_clause);\n \n if(is_typecheck_error(then_type))\n@@ -293,6 +287,19 @@\n {\n ast_error(opt->check.errors, then_clause,\n \"Cannot infer type of unused literal\");\n+ return false;\n+ }\n+\n+ // The then clause always executes, so include its type even if body/else\n+ // jump away\n+ if(!ast_checkflag(then_clause, AST_FLAG_JUMPS_AWAY))\n+ {\n+ type = control_type_add_branch(opt, type, then_clause);\n+ }\n+\n+ if((type == NULL) && (ast_sibling(ast) != NULL))\n+ {\n+ ast_error(opt->check.errors, ast_sibling(ast), \"unreachable code\");\n return false;\n }\n \n\n--- a/src/libponyc/pass/expr.c\n+++ b/src/libponyc/pass/expr.c\n@@ -188,6 +188,15 @@\n \n if(ast_id(parent) == TK_RETURN)\n return true;\n+\n+ // Check if we're in a try block with a then clause\n+ if((ast_id(parent) == TK_TRY) || (ast_id(parent) == TK_TRY_NO_CHECK))\n+ {\n+ // If the try has a then block (finally), we're not a method return yet\n+ ast_t* then_block = ast_childidx(parent, 2);\n+ if(ast_id(then_block) != TK_NONE)\n+ return false;\n+ }\n }\n \n return is_method_result(t, ast);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2865", "model_patch": "--- a/src/libponyc/verify/call.c\n+++ b/src/libponyc/verify/call.c\n@@ -36,11 +36,14 @@\n pony_assert(ast_id(method_ast) == TK_FUN || ast_id(method_ast) == TK_BE ||\n ast_id(method_ast) == TK_NEW);\n \n- // If the receiver is a reference with a hygienic id, it's a sugared call,\n- // and we should skip the check for partiality at the call site.\n+ // If the receiver is a reference with a hygienic id, it's a sugared call.\n+ // We should skip the partial check only if the method is NOT partial,\n+ // because for partial operators (like +?, -?, etc.), we want to enforce\n+ // that the operator form matches the method's partiality.\n bool skip_partial_check = false;\n if((ast_child(receiver) != NULL) && (ast_id(ast_child(receiver)) == TK_ID) &&\n- is_name_internal_test(ast_name(ast_child(receiver)))\n+ is_name_internal_test(ast_name(ast_child(receiver))) &&\n+ (ast_id(ast_childidx(method_ast, 5)) != TK_QUESTION)\n )\n skip_partial_check = true;\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-2950", "model_patch": "--- a/src/libponyc/pass/docgen.c\n+++ b/src/libponyc/pass/docgen.c\n@@ -194,7 +194,7 @@\n if(has_private_name) // Ignore leading underscore for ordering\n name++;\n \n- doc_list_add(list, ast, name, false);\n+ doc_list_add(list, ast, name, true);\n }\n \n // Utilities\n\n--- a/src/libponyc/pkg/package.c\n+++ b/src/libponyc/pkg/package.c\n@@ -689,7 +689,8 @@\n \n // Allow ponyc to find the lib directory when it is installed.\n #ifdef PLATFORM_IS_WINDOWS\n- success = add_relative_path(path, \"..\\\\lib\", opt);\n+ if(!add_relative_path(path, \"..\\\\lib\", opt))\n+ return false;\n #else\n const char* link_arch = opt->link_arch != NULL ? opt->link_arch\n : PONY_ARCH;\n@@ -697,11 +698,11 @@\n char* lib_path = (char*)ponyint_pool_alloc_size(lib_len);\n snprintf(lib_path, lib_len, \"../lib/%s\", link_arch);\n \n- success = add_relative_path(path, lib_path, opt);\n+ bool result = add_relative_path(path, lib_path, opt);\n \n ponyint_pool_free_size(lib_len, lib_path);\n \n- if(!success)\n+ if(!result)\n return false;\n \n // for when run from build directory\n@@ -709,13 +710,13 @@\n lib_path = (char*)ponyint_pool_alloc_size(lib_len);\n snprintf(lib_path, lib_len, \"lib/%s\", link_arch);\n \n- success = add_relative_path(path, lib_path, opt);\n+ result = add_relative_path(path, lib_path, opt);\n \n ponyint_pool_free_size(lib_len, lib_path);\n+\n+ if(!result)\n+ return false;\n #endif\n-\n- if(!success)\n- return false;\n \n // Allow ponyc to find the packages directory when it is installed.\n #ifdef PLATFORM_IS_WINDOWS\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3006", "model_patch": "--- a/src/libponyc/pass/expr.c\n+++ b/src/libponyc/pass/expr.c\n@@ -541,8 +541,26 @@\n case TK_INTERFACE: r = expr_provides(options, ast); break;\n case TK_NOMINAL: r = expr_nominal(options, astp); break;\n case TK_FVAR:\n- case TK_FLET:\n- case TK_EMBED: r = expr_field(options, ast); break;\n+ case TK_FLET: r = expr_field(options, ast); break;\n+ case TK_EMBED:\n+ {\n+ // Check if the field type is embeddable\n+ ast_t* field_type = ast_childidx(ast, 1);\n+ if(ast_id(field_type) == TK_NOMINAL)\n+ {\n+ const char* type_name = ast_name(ast_childidx(field_type, 1));\n+ if((type_name == stringtab(\"Pointer\")) || \n+ (type_name == stringtab(\"MaybePointer\")))\n+ {\n+ ast_error(options->check.errors, ast,\n+ \"embedded fields cannot be Pointer or MaybePointer types\");\n+ r = false;\n+ break;\n+ }\n+ }\n+ r = expr_field(options, ast);\n+ break;\n+ }\n case TK_PARAM: r = expr_param(options, ast); break;\n case TK_NEW:\n case TK_BE:\n\n--- a/src/libponyc/pass/syntax.c\n+++ b/src/libponyc/pass/syntax.c\n@@ -800,6 +800,30 @@\n return AST_ERROR;\n }\n \n+ // Check the type of the embedded field\n+ AST_GET_CHILDREN(ast, id, type, init);\n+ \n+ if(ast_id(type) != TK_NONE)\n+ {\n+ ast_t* type_node = type;\n+ \n+ // If it's a nominal type, check the name\n+ if(ast_id(type_node) == TK_NOMINAL)\n+ {\n+ AST_GET_CHILDREN(type_node, package, name, typeargs, cap, ephemeral);\n+ const char* type_name = ast_name(name);\n+ \n+ if(strcmp(type_name, \"Pointer\") == 0 || \n+ strcmp(type_name, \"MaybePointer\") == 0)\n+ {\n+ ast_error(opt->check.errors, type,\n+ \"Cannot embed a %s field, %s types cannot be embedded\",\n+ type_name, type_name);\n+ return AST_ERROR;\n+ }\n+ }\n+ }\n+\n return AST_OK;\n }\n \n\n--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -1242,6 +1242,17 @@\n return false;\n }\n \n+ if(is_pointer(sub) || is_maybe(sub))\n+ {\n+ if(errorf != NULL)\n+ {\n+ ast_error_frame(errorf, sub,\n+ \"%s cannot be embedded or used in a union type\",\n+ ast_print_type(sub));\n+ }\n+ return false;\n+ }\n+\n if(is_bare(sub))\n {\n if(errorf != NULL)\n@@ -1261,6 +1272,17 @@\n if(ast_id(def) == TK_STRUCT)\n {\n struct_cant_be_x(sub, super, errorf, \"an intersection type\");\n+ return false;\n+ }\n+\n+ if(is_pointer(sub) || is_maybe(sub))\n+ {\n+ if(errorf != NULL)\n+ {\n+ ast_error_frame(errorf, sub,\n+ \"%s cannot be embedded or used in an intersection type\",\n+ ast_print_type(sub));\n+ }\n return false;\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3293", "model_patch": "--- a/src/libponyc/type/assemble.c\n+++ b/src/libponyc/type/assemble.c\n@@ -191,6 +191,30 @@\n return pointer;\n }\n \n+ast_t* type_nullable_pointer_to(pass_opt_t* opt, ast_t* to)\n+{\n+ BUILD(pointer, to,\n+ NODE(TK_NOMINAL,\n+ NONE // Package\n+ ID(\"NullablePointer\")\n+ NODE(TK_TYPEARGS,\n+ TREE(to)\n+ )\n+ NONE // Capability\n+ NONE // Ephemeral\n+ ));\n+\n+ if(!names_nominal(opt, to, &pointer, false))\n+ {\n+ ast_error(opt->check.errors, to, \"unable to create NullablePointer[%s]\",\n+ ast_print_type(to));\n+ ast_free(pointer);\n+ return NULL;\n+ }\n+\n+ return pointer;\n+}\n+\n ast_t* type_sugar(ast_t* from, const char* package, const char* name)\n {\n return type_base(from, package, name, NULL);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3442", "model_patch": "--- a/src/libponyc/options/options.c\n+++ b/src/libponyc/options/options.c\n@@ -292,7 +292,14 @@\n return EXIT_0;\n \n case OPT_HELP:\n- wants_help = true; break;\n+ if(s->arg_val == NULL || strcmp(s->arg_val, \"true\") == 0)\n+ wants_help = true;\n+ else if(strcmp(s->arg_val, \"false\") != 0)\n+ {\n+ printf(\"Invalid value for --help: %s (expected true or false)\\n\", s->arg_val);\n+ exit_code = EXIT_255;\n+ }\n+ break;\n case OPT_DEBUG: opt->release = false; break;\n case OPT_BUILDFLAG:\n define_build_flag(s->arg_val);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3586", "model_patch": "--- a/src/libponyc/pass/sugar.c\n+++ b/src/libponyc/pass/sugar.c\n@@ -538,11 +538,31 @@\n return;\n }\n \n- // We have a list of variables\n- pony_assert(ast_id(idseq) == TK_TUPLE);\n-\n- for(ast_t* p = ast_child(idseq); p != NULL; p = ast_sibling(p))\n- build_with_dispose(dispose_clause, p);\n+ if(ast_id(idseq) == TK_TUPLE)\n+ {\n+ // We have a list of variables\n+ for(ast_t* p = ast_child(idseq); p != NULL; p = ast_sibling(p))\n+ build_with_dispose(dispose_clause, p);\n+ return;\n+ }\n+\n+ // Handle plain identifiers (when tuple elements aren't wrapped in TK_LET)\n+ if(ast_id(idseq) == TK_ID)\n+ {\n+ // Don't call dispose() on don't cares\n+ if(is_name_dontcare(ast_name(idseq)))\n+ return;\n+\n+ BUILD(dispose, idseq,\n+ NODE(TK_CALL,\n+ NODE(TK_DOT, NODE(TK_REFERENCE, TREE(idseq)) ID(\"dispose\"))\n+ NONE\n+ NONE\n+ NONE));\n+\n+ ast_add(dispose_clause, dispose);\n+ return;\n+ }\n }\n \n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3603", "model_patch": "--- a/src/libponyc/expr/match.c\n+++ b/src/libponyc/expr/match.c\n@@ -193,7 +193,7 @@\n if(exhaustive_at == NULL)\n {\n // match might not be exhaustive\n- if ((ast_id(else_clause) == TK_NONE))\n+ if(ast_id(else_clause) == TK_NONE)\n {\n // If we have no else clause, and the match is not found to be exhaustive,\n // we must generate an implicit else clause that returns None as the value.\n@@ -210,6 +210,15 @@\n if(!expr_typeref(opt, &ref) || !expr_seq(opt, else_clause))\n return false;\n }\n+\n+ // Add the else clause type (either implicit or explicit) to the match type\n+ if(!ast_checkflag(else_clause, AST_FLAG_JUMPS_AWAY))\n+ {\n+ if(is_typecheck_error(ast_type(else_clause)))\n+ return false;\n+\n+ type = control_type_add_branch(opt, type, else_clause);\n+ }\n }\n else\n {\n@@ -222,24 +231,13 @@\n \"first unreachable case expression\");\n return false;\n }\n- else if((ast_id(else_clause) != TK_NONE))\n+ else if(ast_id(else_clause) != TK_NONE)\n {\n ast_error(opt->check.errors, ast,\n \"match is exhaustive, the else clause is unreachable\");\n ast_error_continue(opt->check.errors, else_clause,\n \"unreachable code\");\n return false;\n- }\n- }\n-\n- if((ast_id(else_clause) != TK_NONE))\n- {\n- if (!ast_checkflag(else_clause, AST_FLAG_JUMPS_AWAY))\n- {\n- if(is_typecheck_error(ast_type(else_clause)))\n- return false;\n-\n- type = control_type_add_branch(opt, type, else_clause);\n }\n }\n \n\n--- a/src/libponyc/pass/sugar.c\n+++ b/src/libponyc/pass/sugar.c\n@@ -694,8 +694,21 @@\n while(ast_id(next_body) == TK_NONE)\n {\n next = ast_sibling(next);\n- pony_assert(next != NULL);\n- pony_assert(ast_id(next) == TK_CASE);\n+ \n+ if(next == NULL)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"case with no body must be followed by a case with a body\");\n+ return AST_ERROR;\n+ }\n+ \n+ if(ast_id(next) != TK_CASE)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"case with no body must be followed by another case\");\n+ return AST_ERROR;\n+ }\n+ \n next_body = ast_childidx(next, 2);\n }\n \n\n--- a/src/libponyc/type/assemble.c\n+++ b/src/libponyc/type/assemble.c\n@@ -78,8 +78,9 @@\n \n while(child != NULL)\n {\n- append_one_to_typeexpr(opt, ast, child, is_union);\n- child = ast_sibling(child);\n+ ast_t* next = ast_sibling(child);\n+ append_one_to_typeexpr(opt, ast, ast_dup(child), is_union);\n+ child = next;\n }\n } else {\n append_one_to_typeexpr(opt, ast, append, is_union);\n\n--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -802,6 +802,15 @@\n // A bare type is a subtype of Pointer[None].\n if(is_none(super_typearg))\n return true;\n+\n+ // A bare type is not a subtype of Pointer[T] where T is not None.\n+ if(errorf != NULL)\n+ {\n+ ast_error_frame(errorf, sub, \"%s is not a subtype of %s\",\n+ ast_print_type(sub), ast_print_type(super));\n+ }\n+\n+ return false;\n }\n \n if(sub_def != super_def)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3647", "model_patch": "--- a/src/libponyc/ast/parser.c\n+++ b/src/libponyc/ast/parser.c\n@@ -959,12 +959,12 @@\n MAP_ID(TK_TEST_ALIASED, TK_ALIASED);\n DONE();\n \n-// CONSUME [cap | test_aliased] term\n+// CONSUME [cap | test_aliased] ref\n DEF(consume);\n PRINT_INLINE();\n TOKEN(\"consume\", TK_CONSUME);\n OPT RULE(\"capability\", cap, test_aliased);\n- RULE(\"expression\", term);\n+ RULE(\"expression\", ref);\n DONE();\n \n // $IFDEFNOT term\n\n--- a/src/libponyc/expr/postfix.c\n+++ b/src/libponyc/expr/postfix.c\n@@ -332,6 +332,10 @@\n \n ast_setid(ast, TK_TUPLEELEMREF);\n ast_settype(ast, type);\n+ \n+ // Tuple element access is not a simple identifier that can be consumed\n+ ast_clearflag(ast, AST_FLAG_CAN_CONSUME);\n+ \n return true;\n }\n \n\n--- a/src/libponyc/pass/refer.c\n+++ b/src/libponyc/pass/refer.c\n@@ -139,7 +139,9 @@\n \n default:\n {\n- pony_assert(0);\n+ // Return NULL to indicate this is not a simple field reference\n+ // (e.g., it contains function calls or other complex expressions)\n+ return NULL;\n }\n }\n \n\n--- a/src/libponyc/pass/syntax.c\n+++ b/src/libponyc/pass/syntax.c\n@@ -696,8 +696,17 @@\n {\n case TK_THIS:\n case TK_REFERENCE:\n+ return AST_OK;\n+\n case TK_DOT:\n- return AST_OK;\n+ {\n+ // For TK_DOT, only allow simple field access (identifier.field)\n+ // not complex expressions like method calls or tuple access\n+ ast_t* left = ast_child(term);\n+ if(ast_id(left) == TK_REFERENCE || ast_id(left) == TK_THIS)\n+ return AST_OK;\n+ break;\n+ }\n \n default: {}\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3650", "model_patch": "--- a/src/libponyc/pass/refer.c\n+++ b/src/libponyc/pass/refer.c\n@@ -137,10 +137,48 @@\n break;\n }\n \n+ case TK_CONSUME:\n+ {\n+ // Handle consume expressions - extract the actual reference\n+ AST_GET_CHILDREN(temp_ast, cap, term);\n+ temp_ast = term;\n+ \n+ // Now handle the term within the consume\n+ switch(ast_id(temp_ast))\n+ {\n+ case TK_LETREF:\n+ case TK_VARREF:\n+ case TK_REFERENCE:\n+ case TK_PARAMREF:\n+ {\n+ temp_ast = ast_child(temp_ast);\n+ len += strlen(ast_name(temp_ast));\n+ break;\n+ }\n+\n+ case TK_THIS:\n+ {\n+ temp_ast = ast_sibling(temp_ast);\n+ // string len already added by loop above\n+ // subtract 1 because we don't have to add '.'\n+ // since we're ignoring the `this`\n+ len -= 1;\n+ break;\n+ }\n+\n+ default:\n+ {\n+ pony_assert(0);\n+ }\n+ }\n+ break;\n+ }\n+\n default:\n {\n pony_assert(0);\n }\n+=======\n }\n \n if(def_found != NULL)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3723", "model_patch": "--- a/src/libponyc/codegen/gencall.c\n+++ b/src/libponyc/codegen/gencall.c\n@@ -924,6 +924,28 @@\n r = args[0];\n \n ponyint_pool_free_size(buf_size, args);\n+ \n+ // If we invoked and got a tuple return type, we need to handle it specially\n+ // to ensure the tuple value is properly materialized in memory\n+ if((r != NULL) && (r != c->none_instance) && \n+ ast_canerror(ast) && (c->frame->invoke_target != NULL))\n+ {\n+ ast_t* result_type = deferred_reify(reify, m->result->ast_cap, c->opt);\n+ if((result_type != NULL) && (ast_id(result_type) == TK_TUPLETYPE))\n+ {\n+ // For tuple returns from invoke, we need to ensure the value is\n+ // in memory so field access can work correctly\n+ LLVMTypeRef r_type = LLVMTypeOf(r);\n+ if(LLVMGetTypeKind(r_type) == LLVMStructTypeKind)\n+ {\n+ LLVMValueRef tuple_ptr = LLVMBuildAlloca(c->builder, r_type, \"\");\n+ LLVMBuildStore(c->builder, r, tuple_ptr);\n+ r = LLVMBuildLoad(c->builder, tuple_ptr, \"\");\n+ }\n+ }\n+ ast_free_unattached(result_type);\n+ }\n+ \n return r;\n }\n \n\n--- a/src/libponyc/codegen/genmatch.c\n+++ b/src/libponyc/codegen/genmatch.c\n@@ -560,8 +560,21 @@\n ast_t* pattern_expr = ast_child(pattern_child);\n LLVMValueRef elem = LLVMBuildExtractValue(c->builder, value, i, \"\");\n \n- if(!static_match(c, elem, type_child, pattern_expr, next_block))\n- return false;\n+ // Check if the element type is a union/intersection that needs dynamic handling\n+ ast_t* elem_type = type_child;\n+ if((ast_id(elem_type) == TK_UNIONTYPE || ast_id(elem_type) == TK_ISECTTYPE) &&\n+ LLVMTypeOf(elem) == c->object_ptr)\n+ {\n+ // The element is a boxed union/intersection type, use dynamic matching\n+ LLVMValueRef desc = gendesc_fetch(c, elem);\n+ if(!dynamic_match_object(c, elem, desc, pattern_expr, next_block))\n+ return false;\n+ }\n+ else\n+ {\n+ if(!static_match(c, elem, type_child, pattern_expr, next_block))\n+ return false;\n+ }\n \n type_child = ast_sibling(type_child);\n pattern_child = ast_sibling(pattern_child);\n\n--- a/src/libponyc/codegen/genoperator.c\n+++ b/src/libponyc/codegen/genoperator.c\n@@ -398,12 +398,12 @@\n pony_assert(0);\n }\n \n+ // Extract the tuple value.\n+ LLVMValueRef rvalue_child = LLVMBuildExtractValue(c->builder, r_value, i,\n+ \"\");\n+\n if(expr != NULL)\n {\n- // Extract the tuple value.\n- LLVMValueRef rvalue_child = LLVMBuildExtractValue(c->builder, r_value, i,\n- \"\");\n-\n // Recurse, assigning pairwise.\n if(assign_rvalue(c, expr, rtype_child, rvalue_child) == NULL)\n return false;\n\n--- a/src/libponyc/codegen/genreference.c\n+++ b/src/libponyc/codegen/genreference.c\n@@ -146,15 +146,19 @@\n \n deferred_reification_t* reify = c->frame->reify;\n \n- ast_t* type = deferred_reify(reify, ast_type(ast), c->opt);\n- reach_type_t* t = reach_type(c->reach, type);\n- pony_assert(t != NULL);\n- ast_free_unattached(type);\n- compile_type_t* c_t = (compile_type_t*)t->c_type;\n-\n ast_t* l_type = deferred_reify(reify, ast_type(left), c->opt);\n LLVMValueRef value = make_tupleelemptr(c, l_value, l_type, right);\n+ \n+ // Get the actual element type from the tuple type\n+ int index = (int)ast_int(right)->low;\n+ ast_t* elem_type = ast_childidx(l_type, index);\n+ ast_t* type = deferred_reify(reify, elem_type, c->opt);\n+ reach_type_t* t = reach_type(c->reach, type);\n+ pony_assert(t != NULL);\n+ ast_free_unattached(type);\n ast_free_unattached(l_type);\n+ compile_type_t* c_t = (compile_type_t*)t->c_type;\n+\n return gen_assign_cast(c, c_t->use_type, value, t->ast_cap);\n }\n \n\n--- a/src/libponyc/expr/postfix.c\n+++ b/src/libponyc/expr/postfix.c\n@@ -327,11 +327,11 @@\n return false;\n }\n \n- type = ast_childidx(type, right_idx);\n- pony_assert(type != NULL);\n+ ast_t* elem_type = ast_childidx(type, right_idx);\n+ pony_assert(elem_type != NULL);\n \n ast_setid(ast, TK_TUPLEELEMREF);\n- ast_settype(ast, type);\n+ ast_settype(ast, ast_dup(elem_type));\n return true;\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3725", "model_patch": "--- a/src/libponyc/ast/ast.c\n+++ b/src/libponyc/ast/ast.c\n@@ -990,7 +990,9 @@\n \n ast_t* ast_childidx(ast_t* ast, size_t idx)\n {\n- pony_assert(ast != NULL);\n+ if(ast == NULL)\n+ return NULL;\n+\n ast_t* child = ast->child;\n \n while((child != NULL) && (idx > 0))\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3739", "model_patch": "--- a/src/libponyc/expr/call.c\n+++ b/src/libponyc/expr/call.c\n@@ -572,29 +572,11 @@\n {\n case TK_FUNREF:\n case TK_FUNAPP:\n- if(ast_id(ast_child(type)) != TK_AT)\n- {\n- if(!check_receiver_cap(opt, ast, NULL))\n- return false;\n-\n- if(!check_nonsendable_recover(opt, ast))\n- return false;\n- } else {\n- ast_t* receiver = ast_child(lhs);\n-\n- // Dig through function qualification.\n- if((ast_id(receiver) == TK_FUNREF) || (ast_id(receiver) == TK_FUNAPP) ||\n- (ast_id(receiver) == TK_FUNCHAIN))\n- receiver = ast_child(receiver);\n-\n- ast_t* recv_type = ast_type(receiver);\n- if(!is_known(recv_type) && (ast_id(receiver) == TK_TYPEREF))\n- {\n- ast_error(opt->check.errors, lhs, \"a bare method cannot be called on \"\n- \"an abstract type reference\");\n- return false;\n- }\n- }\n+ if(!check_receiver_cap(opt, ast, NULL))\n+ return false;\n+\n+ if(!check_nonsendable_recover(opt, ast))\n+ return false;\n \n break;\n \n\n--- a/src/libponyc/expr/ffi.c\n+++ b/src/libponyc/expr/ffi.c\n@@ -156,53 +156,14 @@\n if(!ffi_get_decl(&opt->check, ast, &decl, opt))\n return false;\n \n- if(decl != NULL) // We have a declaration\n- return declared_ffi(opt, ast, decl);\n-\n- // We do not have a declaration\n- for(ast_t* arg = ast_child(args); arg != NULL; arg = ast_sibling(arg))\n+ if(decl == NULL)\n {\n- ast_t* a_type = ast_type(arg);\n-\n- if(a_type != NULL)\n- {\n- if(is_type_literal(a_type))\n- {\n- ast_error(opt->check.errors, arg,\n- \"Cannot pass number literals as unchecked FFI arguments\");\n- return false;\n- }\n-\n- if(ast_id(a_type) == TK_TUPLETYPE)\n- {\n- ast_error(opt->check.errors, arg, \"cannot pass tuples as FFI \"\n- \"arguments\");\n- return false;\n- }\n- }\n- }\n-\n- ast_t* return_type = ast_child(return_typeargs);\n-\n- if(return_type == NULL)\n- {\n+ // FFI declaration is mandatory\n ast_error(opt->check.errors, name,\n- \"FFIs without declarations must specify return type\");\n+ \"FFI call must have a declaration via a use statement\");\n return false;\n }\n \n- const char* f_name = ast_name(name) + 1;\n- bool intrinsic = !strncmp(f_name, \"llvm.\", 5) ||\n- !strncmp(f_name, \"internal.\", 9);\n-\n- if(!intrinsic && (ast_id(return_type) == TK_TUPLETYPE))\n- {\n- ast_error(opt->check.errors, return_type, \"an FFI function cannot return a \"\n- \"tuple\");\n- return false;\n- }\n-\n- ast_settype(ast, return_type);\n-\n- return true;\n+ // We have a declaration\n+ return declared_ffi(opt, ast, decl);\n }\n\n--- a/src/libponyc/pkg/use.c\n+++ b/src/libponyc/pkg/use.c\n@@ -176,7 +176,7 @@\n break;\n \n case TK_FFIDECL:\n- if(!ffi_command(options, alias))\n+ if(!ffi_command(options, spec, alias, guard))\n return AST_ERROR;\n \n break;\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3746", "model_patch": "--- a/src/libponyc/expr/match.c\n+++ b/src/libponyc/expr/match.c\n@@ -531,16 +531,37 @@\n case MATCHTYPE_DENY:\n {\n errorframe_t frame = NULL;\n- ast_error_frame(&frame, pattern,\n- \"this capture violates capabilities, because the match would \"\n- \"need to differentiate by capability at runtime instead of matching \"\n- \"on type alone\");\n- ast_error_frame(&frame, match_type, \"the match type allows for more than \"\n- \"one possibility with the same type as pattern type, but different \"\n- \"capabilities. match type: %s\",\n- ast_print_type(match_type));\n- ast_error_frame(&frame, pattern, \"pattern type: %s\",\n- ast_print_type(pattern_type));\n+ \n+ // Check if the pattern type involves a struct\n+ ast_t* pattern_def = (ast_t*)ast_data(pattern_type);\n+ bool is_struct_pattern = (pattern_def != NULL) && \n+ (ast_id(pattern_def) == TK_STRUCT);\n+ \n+ if(is_struct_pattern)\n+ {\n+ ast_error_frame(&frame, pattern,\n+ \"cannot pattern match on a struct type at runtime\");\n+ ast_error_frame(&frame, pattern,\n+ \"structs are passed by value and do not have runtime type information\");\n+ ast_error_frame(&frame, match_type, \"match type: %s\",\n+ ast_print_type(match_type));\n+ ast_error_frame(&frame, pattern, \"pattern type: %s\",\n+ ast_print_type(pattern_type));\n+ }\n+ else\n+ {\n+ ast_error_frame(&frame, pattern,\n+ \"this capture violates capabilities, because the match would \"\n+ \"need to differentiate by capability at runtime instead of matching \"\n+ \"on type alone\");\n+ ast_error_frame(&frame, match_type, \"the match type allows for more than \"\n+ \"one possibility with the same type as pattern type, but different \"\n+ \"capabilities. match type: %s\",\n+ ast_print_type(match_type));\n+ ast_error_frame(&frame, pattern, \"pattern type: %s\",\n+ ast_print_type(pattern_type));\n+ }\n+ \n errorframe_append(&frame, &info);\n errorframe_report(&frame, opt->check.errors);\n \n\n--- a/src/libponyc/type/matchtype.c\n+++ b/src/libponyc/type/matchtype.c\n@@ -571,7 +571,20 @@\n return MATCHTYPE_DENY;\n }\n \n- return is_nominal_match_entity(operand, pattern, errorf, report_reject, opt);\n+ matchtype_t result = is_nominal_match_entity(operand, pattern, errorf, false, opt);\n+ \n+ // If capabilities don't match, provide a struct-specific error message\n+ if((result == MATCHTYPE_DENY) && (errorf != NULL))\n+ {\n+ ast_error_frame(errorf, pattern,\n+ \"%s cannot match %s: pattern matching on a struct is not possible\",\n+ ast_print_type(operand), ast_print_type(pattern));\n+ ast_error_frame(errorf, pattern,\n+ \"structs have no type descriptor, so pattern matching cannot \"\n+ \"differentiate between different capabilities at runtime\");\n+ }\n+ \n+ return result;\n }\n \n static matchtype_t is_entity_match_trait(ast_t* operand, ast_t* pattern,\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3758", "model_patch": "--- a/src/libponyc/expr/ffi.c\n+++ b/src/libponyc/expr/ffi.c\n@@ -126,6 +126,31 @@\n return false;\n }\n \n+ // Validate the return type\n+ if(is_nullable_pointer(decl_ret_type))\n+ {\n+ ast_t* type_args = ast_childidx(decl_ret_type, 2);\n+ ast_t* type_arg = ast_child(type_args);\n+ \n+ if(type_arg != NULL)\n+ {\n+ ast_t* type_arg_def = (ast_t*)ast_data(type_arg);\n+ \n+ if(type_arg_def != NULL && ast_id(type_arg_def) == TK_TYPE)\n+ {\n+ ast_t* type_alias = ast_childidx(type_arg_def, 1);\n+ \n+ // Check if this is a tuple type alias, which is not allowed\n+ if(type_alias != NULL && ast_id(type_alias) == TK_TUPLETYPE)\n+ {\n+ ast_error(opt->check.errors, decl_ret_type,\n+ \"the type argument to NullablePointer must be a struct\");\n+ return false;\n+ }\n+ }\n+ }\n+ }\n+\n // Store the declaration so that codegen can generate a non-variadic\n // signature for the FFI call.\n ast_setdata(call, decl);\n\n--- a/src/libponyc/expr/reference.c\n+++ b/src/libponyc/expr/reference.c\n@@ -959,7 +959,43 @@\n ast_t* def = (ast_t*)ast_data(typearg);\n pony_assert(def != NULL);\n \n- ok = ast_id(def) == TK_STRUCT;\n+ // If this is a type alias, we need to check the aliased type\n+ if(ast_id(def) == TK_TYPE)\n+ {\n+ AST_GET_CHILDREN(def, type_id, type_typeparams, type_def);\n+ def = type_def;\n+ \n+ // Handle nested type aliases\n+ while(ast_id(def) == TK_NOMINAL)\n+ {\n+ ast_t* nested_def = (ast_t*)ast_data(def);\n+ if(nested_def != NULL && ast_id(nested_def) == TK_TYPE)\n+ {\n+ AST_GET_CHILDREN(nested_def, nested_id, nested_typeparams, nested_type_def);\n+ def = nested_type_def;\n+ }\n+ else\n+ {\n+ def = nested_def;\n+ break;\n+ }\n+ }\n+ \n+ // After resolving type aliases, check if we have a struct\n+ if(def != NULL && ast_id(def) == TK_NOMINAL)\n+ {\n+ ast_t* final_def = (ast_t*)ast_data(def);\n+ ok = (final_def != NULL) && (ast_id(final_def) == TK_STRUCT);\n+ }\n+ else\n+ {\n+ ok = (def != NULL) && (ast_id(def) == TK_STRUCT);\n+ }\n+ }\n+ else\n+ {\n+ ok = ast_id(def) == TK_STRUCT;\n+ }\n break;\n }\n \n\n--- a/src/libponyc/pass/expr.c\n+++ b/src/libponyc/pass/expr.c\n@@ -639,6 +639,19 @@\n \n case TK_FFICALL:\n r = expr_ffi(options, ast);\n+ break;\n+\n+ case TK_USE:\n+ {\n+ // Process FFI declarations but skip the guard to avoid false type errors\n+ AST_GET_CHILDREN(ast, alias, spec, guard, body);\n+ \n+ if(ast_id(spec) == TK_FFIDECL)\n+ {\n+ r = expr_ffi(options, spec);\n+ }\n+ break;\n+ }\n \n default: {}\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3781", "model_patch": "--- a/src/libponyc/verify/call.c\n+++ b/src/libponyc/verify/call.c\n@@ -140,7 +140,6 @@\n \n bool verify_behaviour_call(pass_opt_t* opt, ast_t* ast)\n {\n- (void)opt;\n pony_assert((ast_id(ast) == TK_BEREF) || (ast_id(ast) == TK_BECHAIN) ||\n (ast_id(ast) == TK_NEWBEREF));\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3819", "model_patch": "--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -537,6 +537,18 @@\n {\n // TODO: a tuple of unions may be a subtype of a union of tuples without\n // being a subtype of any one element.\n+\n+ // If sub is AmbientAuth and the union contains AmbientAuth, succeed\n+ if(is_literal(sub, \"AmbientAuth\"))\n+ {\n+ for(ast_t* child = ast_child(super);\n+ child != NULL;\n+ child = ast_sibling(child))\n+ {\n+ if(is_literal(child, \"AmbientAuth\"))\n+ return true;\n+ }\n+ }\n \n // T1 <: T2 or T1 <: T3\n // ---\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3953", "model_patch": "--- a/src/libponyc/pass/refer.c\n+++ b/src/libponyc/pass/refer.c\n@@ -1018,6 +1018,22 @@\n // will see things like consumes in the right side first.\n if(!ast_passes_subtree(&right, opt, PASS_REFER))\n return false;\n+\n+ // Check if the right side is a reference that could be consumed by assignment\n+ // This handles ephemeral references (e.g., trn^) being assigned\n+ if((ast_id(right) == TK_VARREF) || (ast_id(right) == TK_LETREF) || \n+ (ast_id(right) == TK_PARAMREF))\n+ {\n+ ast_t* id = ast_child(right);\n+ const char* name = ast_name(id);\n+ \n+ sym_status_t status;\n+ ast_get(right, name, &status);\n+ \n+ // Mark as consumed to prevent further use\n+ // The expr pass will validate if this consumption is valid\n+ ast_setstatus(ast, name, SYM_CONSUMED);\n+ }\n \n return true;\n }\n\n--- a/src/libponyc/type/alias.c\n+++ b/src/libponyc/type/alias.c\n@@ -191,6 +191,11 @@\n {\n case TK_NONE:\n ast_setid(eph, TK_EPHEMERAL);\n+ break;\n+\n+ case TK_EPHEMERAL:\n+ // Ephemeral capabilities are consumed, so remove the ephemeral marker\n+ ast_setid(eph, TK_NONE);\n break;\n \n case TK_ALIASED:\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3962", "model_patch": "--- a/src/libponyc/pkg/package.c\n+++ b/src/libponyc/pkg/package.c\n@@ -53,6 +53,7 @@\n \"trait val Real[A: Real[A] val]\\n\"\n \"type Number is (U8 | U32)\\n\"\n \"primitive None\\n\"\n+ \"primitive AmbientAuth\\n\"\n \"struct Pointer[A]\\n\"\n \"class val Env\\n\"\n \" new _create(argc: U32, argv: Pointer[Pointer[U8]] val,\\n\"\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3971", "model_patch": "--- a/src/libponyc/pass/syntax.c\n+++ b/src/libponyc/pass/syntax.c\n@@ -764,18 +764,36 @@\n \n if(value_count > 0)\n {\n- if(ast_id(opt->check.frame->method) == TK_NEW)\n+ // Check if we're inside a lambda - walk up the tree to see if we\n+ // encounter a lambda before we reach the method body\n+ bool in_lambda = false;\n+ ast_t* p = ast_parent(ast);\n+ while(p != NULL && p != opt->check.frame->method_body)\n {\n- ast_error(opt->check.errors, ast,\n- \"A return in a constructor must not have an expression\");\n- return AST_ERROR;\n+ if(ast_id(p) == TK_LAMBDA || ast_id(p) == TK_BARELAMBDA)\n+ {\n+ in_lambda = true;\n+ break;\n+ }\n+ p = ast_parent(p);\n }\n \n- if(ast_id(opt->check.frame->method) == TK_BE)\n+ // Only check constructor/behaviour return restrictions if we're not in a lambda\n+ if(!in_lambda)\n {\n- ast_error(opt->check.errors, ast,\n- \"A return in a behaviour must not have an expression\");\n- return AST_ERROR;\n+ if(ast_id(opt->check.frame->method) == TK_NEW)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"A return in a constructor must not have an expression\");\n+ return AST_ERROR;\n+ }\n+\n+ if(ast_id(opt->check.frame->method) == TK_BE)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"A return in a behaviour must not have an expression\");\n+ return AST_ERROR;\n+ }\n }\n }\n }\n\n--- a/src/libponyc/verify/fun.c\n+++ b/src/libponyc/verify/fun.c\n@@ -576,6 +576,52 @@\n return true;\n }\n \n+static bool verify_return_in_ctor_or_be(pass_opt_t* opt, ast_t* ast, \n+ bool in_ctor_or_be)\n+{\n+ // Don't recurse into nested functions/methods/lambdas (object literals)\n+ switch(ast_id(ast))\n+ {\n+ case TK_NEW:\n+ case TK_BE:\n+ case TK_FUN:\n+ case TK_OBJECT:\n+ return true;\n+ \n+ default:\n+ break;\n+ }\n+\n+ // Check if this is a return with an expression in a constructor or behavior\n+ if(in_ctor_or_be && (ast_id(ast) == TK_RETURN))\n+ {\n+ ast_t* return_value = ast_child(ast);\n+ if((return_value != NULL) && (ast_id(return_value) != TK_NONE))\n+ {\n+ if(in_ctor_or_be == 1)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"a return in a constructor must not have an expression\");\n+ } else {\n+ ast_error(opt->check.errors, ast,\n+ \"a return in a behaviour must not have an expression\");\n+ }\n+ return false;\n+ }\n+ }\n+\n+ // Recursively check children\n+ ast_t* child = ast_child(ast);\n+ while(child != NULL)\n+ {\n+ if(!verify_return_in_ctor_or_be(opt, child, in_ctor_or_be))\n+ return false;\n+ child = ast_sibling(child);\n+ }\n+\n+ return true;\n+}\n+\n bool verify_fun(pass_opt_t* opt, ast_t* ast)\n {\n pony_assert((ast_id(ast) == TK_BE) || (ast_id(ast) == TK_FUN) ||\n@@ -590,6 +636,18 @@\n !verify_any_serialise(opt, ast) ||\n !verify_behaviour_parameters(opt, ast))\n return false;\n+\n+ // Check that constructors and behaviours don't have return statements\n+ // with expressions (but allow them in nested functions/lambdas).\n+ // Use 1 for constructor, 2 for behaviour.\n+ if(ast_id(ast) == TK_NEW)\n+ {\n+ if(!verify_return_in_ctor_or_be(opt, body, 1))\n+ return false;\n+ } else if(ast_id(ast) == TK_BE) {\n+ if(!verify_return_in_ctor_or_be(opt, body, 2))\n+ return false;\n+ }\n \n // Check partial functions.\n if(ast_id(can_error) == TK_QUESTION)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3973", "model_patch": "--- a/src/libponyc/pass/traits.c\n+++ b/src/libponyc/pass/traits.c\n@@ -477,6 +477,28 @@\n method_body);\n \n const char* method_name = ast_name(id);\n+\n+ // Check if method is private (starts with _) and if so, verify same package\n+ if(method_name[0] == '_')\n+ {\n+ ast_t* trait_def = (ast_t*)ast_data(trait_ref);\n+ pony_assert(trait_def != NULL);\n+ \n+ package_t* entity_pkg = ast_get_package(entity);\n+ package_t* trait_pkg = ast_get_package(trait_def);\n+ \n+ if(entity_pkg != trait_pkg)\n+ {\n+ ast_error(opt->check.errors, entity,\n+ \"can't provide private method '%s' from a different package\", \n+ method_name);\n+ ast_error_continue(opt->check.errors, trait_ref,\n+ \"private method is defined here in trait '%s'\",\n+ ast_name(ast_child(trait_def)));\n+ return false;\n+ }\n+ }\n+\n ast_t* existing_method = find_method(entity, method_name);\n \n if(existing_method == NULL)\n\n--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -882,10 +882,35 @@\n ast_t* super_members = ast_childidx(super_def, 4);\n ast_t* super_member = ast_child(super_members);\n \n+ // Check if super has any private methods - if so, sub must be from same package\n+ ast_t* sub_pkg = ast_nearest(sub_def, TK_PACKAGE);\n+ ast_t* super_pkg = ast_nearest(super_def, TK_PACKAGE);\n+ bool same_package = (sub_pkg == super_pkg);\n+\n while(super_member != NULL)\n {\n ast_t* super_member_id = ast_childidx(super_member, 1);\n ast_t* sub_member = ast_get(sub_def, ast_name(super_member_id), NULL);\n+\n+ // Check if this is a private method\n+ ast_t* super_member_cap = ast_child(super_member);\n+ bool is_private = (ast_id(super_member_cap) == TK_PRIVATE);\n+\n+ // If the super method is private and packages differ, can't be a subtype\n+ if(is_private && !same_package)\n+ {\n+ if(errorf != NULL)\n+ {\n+ ast_error_frame(errorf, sub,\n+ \"%s is not a subtype of %s: '%s' has private method '%s' and they are in different packages\",\n+ ast_print_type(sub), ast_print_type(super),\n+ ast_print_type(super), ast_name(super_member_id));\n+ }\n+\n+ ret = false;\n+ super_member = ast_sibling(super_member);\n+ continue;\n+ }\n \n // If we don't provide a method, we aren't a subtype.\n if((sub_member == NULL) || (ast_id(sub_member) != TK_FUN &&\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-3991", "model_patch": "--- a/src/libponyc/codegen/genname.c\n+++ b/src/libponyc/codegen/genname.c\n@@ -57,6 +57,26 @@\n return;\n }\n \n+ case TK_TYPEPARAMREF:\n+ {\n+ // Type parameter reference - use the parameter name\n+ AST_GET_CHILDREN(type, id, cap, eph);\n+ printbuf(buf, \"%s\", ast_name(id));\n+\n+ if(!first)\n+ printbuf(buf, \"_%s\", ast_get_print(cap));\n+\n+ return;\n+ }\n+\n+ case TK_ARROW:\n+ {\n+ // Arrow type (this->T) - use the right side\n+ AST_GET_CHILDREN(type, left, right);\n+ type_append(buf, right, first);\n+ return;\n+ }\n+\n default: {}\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4005", "model_patch": "--- a/src/libponyc/type/typeparam.c\n+++ b/src/libponyc/type/typeparam.c\n@@ -331,10 +331,16 @@\n case TK_NOMINAL:\n return cap_single(type);\n \n+ case TK_TUPLETYPE:\n+ case TK_ARROW:\n+ // Tuples and arrows can't be used as constraints.\n+ // Return TK_CAP_ANY instead of asserting to avoid crashes.\n+ return TK_CAP_ANY;\n+\n default: {}\n }\n \n- // Tuples and arrows can't be used as constraints.\n+ // Unknown type in constraint.\n pony_assert(0);\n return TK_NONE;\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4006", "model_patch": "--- a/src/libponyc/expr/match.c\n+++ b/src/libponyc/expr/match.c\n@@ -74,14 +74,27 @@\n // Expect to see a body containing the following AST:\n // (is (this) (paramref (id that)))\n // where `that` is the name of the first parameter.\n- if((ast_childcount(eq_body) != 1) ||\n- (ast_id(ast_child(eq_body)) != TK_IS) ||\n- (ast_id(ast_child(ast_child(eq_body))) != TK_THIS) ||\n- (ast_id(ast_childidx(ast_child(eq_body), 1)) != TK_PARAMREF))\n+ // The body could also be wrapped in a consume expression.\n+ ast_t* body_expr = ast_child(eq_body);\n+ \n+ if(ast_childcount(eq_body) != 1)\n+ return false;\n+ \n+ // Unwrap consume if present\n+ if(ast_id(body_expr) == TK_CONSUME)\n+ {\n+ body_expr = ast_childidx(body_expr, 1);\n+ if(ast_id(body_expr) == TK_SEQ && ast_childcount(body_expr) == 1)\n+ body_expr = ast_child(body_expr);\n+ }\n+ \n+ if((ast_id(body_expr) != TK_IS) ||\n+ (ast_id(ast_child(body_expr)) != TK_THIS) ||\n+ (ast_id(ast_childidx(body_expr, 1)) != TK_PARAMREF))\n return false;\n \n const char* that_param_name =\n- ast_name(ast_child(ast_childidx(ast_child(eq_body), 1)));\n+ ast_name(ast_child(ast_childidx(body_expr, 1)));\n \n if(ast_name(ast_child(ast_child(eq_params))) != that_param_name)\n return false;\n\n--- a/src/libponyc/verify/call.c\n+++ b/src/libponyc/verify/call.c\n@@ -56,8 +56,6 @@\n ast_t* method_error = ast_childidx(method_ast, 5);\n if(ast_id(method_error) == TK_QUESTION)\n {\n- ast_seterror(ast);\n-\n if((ast_id(call_error) != TK_QUESTION) && !skip_partial_check) {\n ast_error(opt->check.errors, call_error,\n \"call is not partial but the method is - \" \\\n@@ -65,6 +63,8 @@\n ast_error_continue(opt->check.errors, method_error,\n \"method is here\");\n r = false;\n+ } else {\n+ ast_seterror(ast);\n }\n } else {\n if((ast_id(call_error) == TK_QUESTION) && !skip_partial_check) {\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4017", "model_patch": "--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -229,6 +229,41 @@\n return ret;\n }\n \n+static bool scan_constraint_for_tuples(ast_t* constraint, errorframe_t* errorf)\n+{\n+ if(constraint == NULL)\n+ return true;\n+\n+ switch(ast_id(constraint))\n+ {\n+ case TK_TUPLETYPE:\n+ {\n+ if(errorf != NULL)\n+ {\n+ ast_error_frame(errorf, constraint,\n+ \"a tuple type cannot be used as a type parameter constraint\");\n+ }\n+ return false;\n+ }\n+\n+ case TK_UNIONTYPE:\n+ {\n+ // Check each element of the union for tuples\n+ ast_t* child = ast_child(constraint);\n+ while(child != NULL)\n+ {\n+ if(!scan_constraint_for_tuples(child, errorf))\n+ return false;\n+ child = ast_sibling(child);\n+ }\n+ return true;\n+ }\n+\n+ default:\n+ return true;\n+ }\n+}\n+\n static bool is_reified_fun_sub_fun(ast_t* sub, ast_t* super,\n errorframe_t* errorf, pass_opt_t* opt)\n {\n@@ -316,6 +351,13 @@\n {\n ast_t* sub_constraint = ast_childidx(sub_typeparam, 1);\n ast_t* super_constraint = ast_childidx(super_typeparam, 1);\n+\n+ // Check for tuples in constraints\n+ if(!scan_constraint_for_tuples(sub_constraint, errorf))\n+ return false;\n+\n+ if(!scan_constraint_for_tuples(super_constraint, errorf))\n+ return false;\n \n if(!is_x_sub_x(super_constraint, sub_constraint, CHECK_CAP_EQ, errorf,\n opt))\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4024", "model_patch": "--- a/src/libponyc/pass/sugar.c\n+++ b/src/libponyc/pass/sugar.c\n@@ -556,13 +556,15 @@\n ast_t* main_annotation = ast_consumeannotation(*astp);\n ast_t* else_annotation = ast_consumeannotation(else_clause);\n token_id try_token;\n-\n- if(ast_id(else_clause) == TK_NONE)\n+ bool has_else = (ast_id(else_clause) != TK_NONE);\n+\n+ if(has_else)\n+ try_token = TK_TRY;\n+ else\n try_token = TK_TRY_NO_CHECK;\n- else\n- try_token = TK_TRY;\n-\n- expand_none(else_clause, false);\n+\n+ if(has_else)\n+ expand_none(else_clause, false);\n \n // First build a skeleton try block without the \"with\" variables\n BUILD(replace, *astp,\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4034", "model_patch": "--- a/src/libponyc/pass/names.c\n+++ b/src/libponyc/pass/names.c\n@@ -181,11 +181,14 @@\n return false;\n }\n \n- if(ast_id(ast) == TK_NOMINAL) {\n- ast_t* module = ast_nearest(ast, TK_MODULE);\n- if(module && ast_get(module, ast_name(id), 0)) {\n+ ast_t* module = ast_nearest(ast, TK_MODULE);\n+ if(module != NULL)\n+ {\n+ ast_t* existing = ast_get(module, ast_name(id), NULL);\n+ if(existing != NULL)\n+ {\n ast_error(opt->check.errors, def,\n- \"type parameter shadows existing type\");\n+ \"type parameter shadows existing type\");\n return false;\n }\n }\n\n--- a/src/libponyc/pkg/package.c\n+++ b/src/libponyc/pkg/package.c\n@@ -852,6 +852,7 @@\n bool package_add_safe(const char* paths, pass_opt_t* opt)\n {\n add_safe(\"builtin\", opt);\n+ add_safe(\"ponycheck\", opt);\n return handle_path_list(paths, add_safe, opt);\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4057", "model_patch": "--- a/src/libponyc/codegen/genfun.c\n+++ b/src/libponyc/codegen/genfun.c\n@@ -444,6 +444,9 @@\n {\n ast_t* r_result = deferred_reify(m->fun, result, c->opt);\n \n+ if(r_result == NULL)\n+ return false;\n+\n if(finaliser || ((ast_id(cap) == TK_AT) && is_none(r_result)))\n {\n ast_free_unattached(r_result);\n@@ -455,6 +458,13 @@\n LLVMTypeRef r_type = LLVMGetReturnType(f_type);\n \n ast_t* body_type = deferred_reify(m->fun, ast_type(body), c->opt);\n+\n+ if(body_type == NULL)\n+ {\n+ ast_free_unattached(r_result);\n+ return false;\n+ }\n+\n LLVMValueRef ret = gen_assign_cast(c, r_type, value, body_type);\n \n ast_free_unattached(body_type);\n\n--- a/src/libponyc/type/reify.c\n+++ b/src/libponyc/type/reify.c\n@@ -28,12 +28,14 @@\n if(ref_def != typeparam)\n return;\n \n+ ast_t* new_typearg = typearg;\n+\n // Keep ephemerality.\n switch(ast_id(ast_childidx(ast, 2)))\n {\n case TK_EPHEMERAL:\n {\n- ast_t* new_typearg = consume_type(typearg, TK_NONE, true);\n+ new_typearg = consume_type(typearg, TK_NONE, true);\n // Will be NULL when instantiation produces double ephemerals A^^\n // or equivalent.\n //\n@@ -43,9 +45,9 @@\n //\n // It could be avoided if we require a constraint on the parameter\n // for this case.\n- if (new_typearg != NULL)\n+ if (new_typearg == NULL)\n {\n- typearg = new_typearg;\n+ new_typearg = typearg;\n }\n break;\n }\n@@ -54,14 +56,16 @@\n break;\n \n case TK_ALIASED:\n- typearg = alias(typearg);\n+ new_typearg = alias(typearg);\n break;\n \n default:\n pony_assert(0);\n }\n \n- ast_replace(astp, typearg);\n+ // Duplicate the typearg to avoid AST node sharing issues\n+ ast_t* dup_typearg = ast_dup(new_typearg);\n+ ast_replace(astp, dup_typearg);\n }\n \n static void reify_arrow(ast_t** astp)\n\n--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -1474,6 +1474,14 @@\n }\n \n return false;\n+ }\n+\n+ // Check if we've already assumed this relationship to prevent infinite\n+ // recursion when the constraint contains the type being defined.\n+ if(check_assume(sub_upper, super, opt))\n+ {\n+ ast_free_unattached(sub_upper);\n+ return true;\n }\n \n bool ok = is_x_sub_x(sub_upper, super, check_cap, errorf, opt);\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4061", "model_patch": "--- a/src/libponyc/ast/lexer.c\n+++ b/src/libponyc/ast/lexer.c\n@@ -1153,6 +1153,15 @@\n {\n size_t len = read_id(lexer);\n \n+ // If read_id returned 0, it means there was an error\n+ if(len == 0 && lexer->buflen > 0)\n+ {\n+ // There were characters but they formed an invalid identifier\n+ // Consume them and return an error token\n+ consume_chars(lexer, lexer->buflen);\n+ return make_token(lexer, TK_LEX_ERROR);\n+ }\n+\n for(const lextoken_t* p = keywords; p->text != NULL; p++)\n {\n if(!strcmp(lexer->buffer, p->text))\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4067", "model_patch": "--- a/src/libponyc/codegen/codegen.c\n+++ b/src/libponyc/codegen/codegen.c\n@@ -985,7 +985,9 @@\n \n if(pony_abi)\n {\n- LLVMValueRef md = LLVMMDNodeInContext(c->context, NULL, 0);\n+ LLVMValueRef md_vals[1];\n+ md_vals[0] = LLVMConstInt(c->i32, 1, false);\n+ LLVMValueRef md = LLVMMDNodeInContext(c->context, md_vals, 1);\n LLVMSetMetadataStr(fun, \"pony.abi\", md);\n }\n \n\n--- a/src/libponyc/codegen/gencall.c\n+++ b/src/libponyc/codegen/gencall.c\n@@ -913,8 +913,14 @@\n \n if(is_new_call)\n {\n- LLVMValueRef md = LLVMMDNodeInContext(c->context, NULL, 0);\n- LLVMSetMetadataStr(r, \"pony.newcall\", md);\n+ // Only set metadata on call instructions, not invoke instructions.\n+ // Invoke instructions have a different structure in LLVM's CallGraph\n+ // and setting metadata on them can cause issues during optimization.\n+ if(!ast_canerror(ast) || (c->frame->invoke_target == NULL))\n+ {\n+ LLVMValueRef md = LLVMMDNodeInContext(c->context, NULL, 0);\n+ LLVMSetMetadataStr(r, \"pony.newcall\", md);\n+ }\n }\n \n codegen_debugloc(c, NULL);\n\n--- a/src/libponyc/codegen/genfun.c\n+++ b/src/libponyc/codegen/genfun.c\n@@ -385,7 +385,6 @@\n // Call the handler.\n codegen_call(c, handler, args, count, true);\n LLVMBuildRetVoid(c->builder);\n- codegen_finishfun(c);\n ponyint_pool_free_size(args_buf_size, args);\n ponyint_pool_free_size(params_buf_size, param_types);\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4087", "model_patch": "--- a/src/libponyc/ast/ast.c\n+++ b/src/libponyc/ast/ast.c\n@@ -805,9 +805,9 @@\n set_scope_and_parent(type, ast);\n }\n \n- if((ast->annotation_type != NULL) &&\n- (ast_id(ast->annotation_type) == TK_ANNOTATION))\n- ast->annotation_type->annotation_type = type;\n+ ast_t* annotation = ast->annotation_type;\n+ if((annotation != NULL) && (ast_id(annotation) == TK_ANNOTATION))\n+ annotation->annotation_type = type;\n else\n ast->annotation_type = type;\n \n\n--- a/src/libponyc/pass/syntax.c\n+++ b/src/libponyc/pass/syntax.c\n@@ -646,8 +646,9 @@\n pony_assert(ast_id(ast) == TK_FFICALL);\n ast_result_t r = AST_OK;\n \n- if (ast_id(opt->check.frame->method) == TK_BE ||\n- ast_id(opt->check.frame->method )== TK_FUN)\n+ if (opt->check.frame->method != NULL &&\n+ (ast_id(opt->check.frame->method) == TK_BE ||\n+ ast_id(opt->check.frame->method) == TK_FUN))\n {\n ast_t* parent = ast_parent(ast);\n switch(ast_id(opt->check.frame->method))\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4182", "model_patch": "--- a/src/libponyc/pass/refer.c\n+++ b/src/libponyc/pass/refer.c\n@@ -1385,6 +1385,39 @@\n return false;\n }\n return true;\n+ case TK_CALL:\n+ {\n+ // Check if this is a constructor call (Type.create() or Type())\n+ AST_GET_CHILDREN(ast, lhs, positional, named, question);\n+ \n+ // Handle Type.create() pattern\n+ if(ast_id(lhs) == TK_DOT)\n+ {\n+ AST_GET_CHILDREN(lhs, left, right);\n+ if(ast_id(left) == TK_TYPEREF)\n+ {\n+ type = (ast_t*) ast_data(left);\n+ if(ast_id(type) != TK_PRIMITIVE)\n+ {\n+ ast_error(opt->check.errors, ast, \"identity comparison with a new object\"\n+ \" will always be false\");\n+ return false;\n+ }\n+ }\n+ }\n+ // Handle direct Type() pattern (though this becomes Type.create() in expr pass)\n+ else if(ast_id(lhs) == TK_TYPEREF)\n+ {\n+ type = (ast_t*) ast_data(lhs);\n+ if(ast_id(type) != TK_PRIMITIVE)\n+ {\n+ ast_error(opt->check.errors, ast, \"identity comparison with a new object\"\n+ \" will always be false\");\n+ return false;\n+ }\n+ }\n+ return true;\n+ }\n case TK_SEQ:\n type = ast_child(ast);\n while(type != NULL)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4263", "model_patch": "--- a/src/libponyc/expr/call.c\n+++ b/src/libponyc/expr/call.c\n@@ -219,7 +219,14 @@\n newref = child;\n \n ast_t* receiver_type = method_receiver_type(newref);\n- token_id rcap = ast_id(cap_fetch(receiver_type));\n+ if (receiver_type == NULL || is_typecheck_error(receiver_type))\n+ return false;\n+\n+ ast_t* rcap_ast = cap_fetch(receiver_type);\n+ if (rcap_ast == NULL)\n+ return false;\n+\n+ token_id rcap = ast_id(rcap_ast);\n if (!(rcap == TK_REF || rcap == TK_BOX))\n return false;\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4288", "model_patch": "--- a/src/libponyc/expr/operator.c\n+++ b/src/libponyc/expr/operator.c\n@@ -375,6 +375,14 @@\n default: {}\n }\n \n+ bool ok_mutable = safe_to_mutate(left);\n+ if(!ok_mutable)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"left side is immutable\");\n+ return false;\n+ }\n+\n ast_t* wl_type = consume_type(fl_type, TK_NONE, false);\n if(check_auto_recover_newref(fl_type, right))\n {\n@@ -439,15 +447,6 @@\n break;\n }\n \n- ast_free_unattached(wl_type);\n- return false;\n- }\n-\n- bool ok_mutable = safe_to_mutate(left);\n- if(!ok_mutable)\n- {\n- ast_error(opt->check.errors, ast,\n- \"left side is immutable\");\n ast_free_unattached(wl_type);\n return false;\n }\n\n--- a/src/libponyc/type/cap.c\n+++ b/src/libponyc/type/cap.c\n@@ -537,6 +537,33 @@\n case TK_TYPEPARAMREF:\n return ast_childidx(type, 1);\n \n+ case TK_ARROW:\n+ {\n+ // For arrow types (viewpoint adaptation), fetch from the right side\n+ ast_t* right = ast_childidx(type, 1);\n+ return cap_fetch(right);\n+ }\n+\n+ case TK_UNIONTYPE:\n+ case TK_ISECTTYPE:\n+ case TK_TUPLETYPE:\n+ {\n+ // For composite types, fetch from the first child\n+ ast_t* child = ast_child(type);\n+ if(child != NULL)\n+ return cap_fetch(child);\n+ break;\n+ }\n+\n+ case TK_ISO:\n+ case TK_TRN:\n+ case TK_REF:\n+ case TK_VAL:\n+ case TK_BOX:\n+ case TK_TAG:\n+ // For bare capability tokens, return the type itself\n+ return type;\n+\n default: {}\n }\n \n\n--- a/src/libponyc/type/safeto.c\n+++ b/src/libponyc/type/safeto.c\n@@ -216,6 +216,10 @@\n AST_GET_CHILDREN(ast, left, right);\n ast_t* l_type = ast_type(left);\n \n+ // Any viewpoint adapted type will not be safe to mutate.\n+ if(ast_id(l_type) != TK_NOMINAL)\n+ return false;\n+\n token_id l_cap = cap_single(l_type);\n return cap_mutable(l_cap);\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4294", "model_patch": "--- a/src/libponyc/codegen/genserialise.c\n+++ b/src/libponyc/codegen/genserialise.c\n@@ -294,7 +294,23 @@\n static void deserialise_bare_interface(compile_t* c, LLVMValueRef ptr)\n {\n LLVMValueRef type_id = LLVMBuildLoad_P(c->builder, ptr, \"\");\n-\n+ \n+ // Check if the type_id is null (offset 0)\n+ LLVMValueRef is_null = LLVMBuildIsNull(c->builder, type_id, \"\");\n+ \n+ LLVMBasicBlockRef null_block = codegen_block(c, \"deserialise_null\");\n+ LLVMBasicBlockRef non_null_block = codegen_block(c, \"deserialise_non_null\");\n+ LLVMBasicBlockRef post_block = codegen_block(c, \"deserialise_post\");\n+ \n+ LLVMBuildCondBr(c->builder, is_null, null_block, non_null_block);\n+ \n+ // Null case: store null\n+ LLVMPositionBuilderAtEnd(c->builder, null_block);\n+ LLVMBuildStore(c->builder, LLVMConstNull(LLVMGetElementType(LLVMTypeOf(ptr))), ptr);\n+ LLVMBuildBr(c->builder, post_block);\n+ \n+ // Non-null case: look up the function pointer\n+ LLVMPositionBuilderAtEnd(c->builder, non_null_block);\n LLVMValueRef args[2];\n args[0] = LLVMConstInt(c->i32, 0, false);\n args[1] = LLVMBuildPtrToInt(c->builder, type_id, c->intptr, \"\");\n@@ -304,6 +320,10 @@\n desc = LLVMBuildLoad_P(c->builder, desc, \"\");\n LLVMValueRef func = gendesc_instance(c, desc);\n LLVMBuildStore(c->builder, func, ptr);\n+ LLVMBuildBr(c->builder, post_block);\n+ \n+ // Continue after the conditional\n+ LLVMPositionBuilderAtEnd(c->builder, post_block);\n }\n \n void gendeserialise_element(compile_t* c, reach_type_t* t, bool embed,\n\n--- a/src/libponyc/codegen/gentrace.c\n+++ b/src/libponyc/codegen/gentrace.c\n@@ -988,40 +988,134 @@\n return;\n \n case TRACE_VAL_KNOWN:\n+ {\n+ LLVMValueRef test = LLVMBuildIsNull(c->builder, dst_value, \"\");\n+ LLVMBasicBlockRef is_false = codegen_block(c, \"\");\n+ LLVMBasicBlockRef is_true = codegen_block(c, \"\");\n+ LLVMBuildCondBr(c->builder, test, is_true, is_false);\n+\n+ LLVMPositionBuilderAtEnd(c->builder, is_false);\n trace_known(c, ctx, dst_value, src_type, PONY_TRACE_IMMUTABLE);\n- return;\n+ LLVMBuildBr(c->builder, is_true);\n+\n+ LLVMMoveBasicBlockAfter(is_true, LLVMGetInsertBlock(c->builder));\n+ LLVMPositionBuilderAtEnd(c->builder, is_true);\n+ return;\n+ }\n \n case TRACE_VAL_UNKNOWN:\n+ {\n+ LLVMValueRef test = LLVMBuildIsNull(c->builder, dst_value, \"\");\n+ LLVMBasicBlockRef is_false = codegen_block(c, \"\");\n+ LLVMBasicBlockRef is_true = codegen_block(c, \"\");\n+ LLVMBuildCondBr(c->builder, test, is_true, is_false);\n+\n+ LLVMPositionBuilderAtEnd(c->builder, is_false);\n trace_unknown(c, ctx, dst_value, PONY_TRACE_IMMUTABLE);\n- return;\n+ LLVMBuildBr(c->builder, is_true);\n+\n+ LLVMMoveBasicBlockAfter(is_true, LLVMGetInsertBlock(c->builder));\n+ LLVMPositionBuilderAtEnd(c->builder, is_true);\n+ return;\n+ }\n \n case TRACE_MUT_KNOWN:\n+ {\n+ LLVMValueRef test = LLVMBuildIsNull(c->builder, dst_value, \"\");\n+ LLVMBasicBlockRef is_false = codegen_block(c, \"\");\n+ LLVMBasicBlockRef is_true = codegen_block(c, \"\");\n+ LLVMBuildCondBr(c->builder, test, is_true, is_false);\n+\n+ LLVMPositionBuilderAtEnd(c->builder, is_false);\n trace_known(c, ctx, dst_value, src_type, PONY_TRACE_MUTABLE);\n- return;\n+ LLVMBuildBr(c->builder, is_true);\n+\n+ LLVMMoveBasicBlockAfter(is_true, LLVMGetInsertBlock(c->builder));\n+ LLVMPositionBuilderAtEnd(c->builder, is_true);\n+ return;\n+ }\n \n case TRACE_MUT_UNKNOWN:\n+ {\n+ LLVMValueRef test = LLVMBuildIsNull(c->builder, dst_value, \"\");\n+ LLVMBasicBlockRef is_false = codegen_block(c, \"\");\n+ LLVMBasicBlockRef is_true = codegen_block(c, \"\");\n+ LLVMBuildCondBr(c->builder, test, is_true, is_false);\n+\n+ LLVMPositionBuilderAtEnd(c->builder, is_false);\n trace_unknown(c, ctx, dst_value, PONY_TRACE_MUTABLE);\n- return;\n+ LLVMBuildBr(c->builder, is_true);\n+\n+ LLVMMoveBasicBlockAfter(is_true, LLVMGetInsertBlock(c->builder));\n+ LLVMPositionBuilderAtEnd(c->builder, is_true);\n+ return;\n+ }\n \n case TRACE_TAG_KNOWN:\n+ {\n+ LLVMValueRef test = LLVMBuildIsNull(c->builder, dst_value, \"\");\n+ LLVMBasicBlockRef is_false = codegen_block(c, \"\");\n+ LLVMBasicBlockRef is_true = codegen_block(c, \"\");\n+ LLVMBuildCondBr(c->builder, test, is_true, is_false);\n+\n+ LLVMPositionBuilderAtEnd(c->builder, is_false);\n trace_known(c, ctx, dst_value, src_type, PONY_TRACE_OPAQUE);\n- return;\n+ LLVMBuildBr(c->builder, is_true);\n+\n+ LLVMMoveBasicBlockAfter(is_true, LLVMGetInsertBlock(c->builder));\n+ LLVMPositionBuilderAtEnd(c->builder, is_true);\n+ return;\n+ }\n \n case TRACE_TAG_UNKNOWN:\n+ {\n+ LLVMValueRef test = LLVMBuildIsNull(c->builder, dst_value, \"\");\n+ LLVMBasicBlockRef is_false = codegen_block(c, \"\");\n+ LLVMBasicBlockRef is_true = codegen_block(c, \"\");\n+ LLVMBuildCondBr(c->builder, test, is_true, is_false);\n+\n+ LLVMPositionBuilderAtEnd(c->builder, is_false);\n trace_unknown(c, ctx, dst_value, PONY_TRACE_OPAQUE);\n- return;\n+ LLVMBuildBr(c->builder, is_true);\n+\n+ LLVMMoveBasicBlockAfter(is_true, LLVMGetInsertBlock(c->builder));\n+ LLVMPositionBuilderAtEnd(c->builder, is_true);\n+ return;\n+ }\n \n case TRACE_STATIC:\n+ {\n+ LLVMValueRef test = LLVMBuildIsNull(c->builder, dst_value, \"\");\n+ LLVMBasicBlockRef is_false = codegen_block(c, \"\");\n+ LLVMBasicBlockRef is_true = codegen_block(c, \"\");\n+ LLVMBuildCondBr(c->builder, test, is_true, is_false);\n+\n+ LLVMPositionBuilderAtEnd(c->builder, is_false);\n trace_static(c, ctx, dst_value, src_type, dst_type);\n- return;\n+ LLVMBuildBr(c->builder, is_true);\n+\n+ LLVMMoveBasicBlockAfter(is_true, LLVMGetInsertBlock(c->builder));\n+ LLVMPositionBuilderAtEnd(c->builder, is_true);\n+ return;\n+ }\n \n case TRACE_DYNAMIC:\n {\n+ LLVMValueRef test = LLVMBuildIsNull(c->builder, dst_value, \"\");\n+ LLVMBasicBlockRef is_false = codegen_block(c, \"\");\n+ LLVMBasicBlockRef is_true = codegen_block(c, \"\");\n+ LLVMBuildCondBr(c->builder, test, is_true, is_false);\n+\n+ LLVMPositionBuilderAtEnd(c->builder, is_false);\n LLVMBasicBlockRef next_block = codegen_block(c, \"\");\n trace_dynamic(c, ctx, dst_value, src_type, dst_type, NULL, next_block);\n LLVMBuildBr(c->builder, next_block);\n LLVMMoveBasicBlockAfter(next_block, LLVMGetInsertBlock(c->builder));\n LLVMPositionBuilderAtEnd(c->builder, next_block);\n+ LLVMBuildBr(c->builder, is_true);\n+\n+ LLVMMoveBasicBlockAfter(is_true, LLVMGetInsertBlock(c->builder));\n+ LLVMPositionBuilderAtEnd(c->builder, is_true);\n return;\n }\n \n\n--- a/src/libponyrt/gc/trace.c\n+++ b/src/libponyrt/gc/trace.c\n@@ -117,6 +117,9 @@\n \n PONY_API void pony_traceunknown(pony_ctx_t* ctx, void* p, int m)\n {\n+ if(p == NULL)\n+ return;\n+\n pony_type_t* t = *(pony_type_t**)p;\n \n if(t->dispatch != NULL)\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4458", "model_patch": "--- a/src/libponyc/expr/reference.c\n+++ b/src/libponyc/expr/reference.c\n@@ -516,6 +516,64 @@\n if(opt->check.frame->recover != def_recover)\n {\n ast_t* parent = ast_parent(ast);\n+ \n+ // Check if this reference is the direct child of the recover\n+ // (i.e., the value being recovered)\n+ bool is_recover_value = false;\n+ ast_t* check_parent = parent;\n+ while(check_parent != NULL && ast_id(check_parent) != TK_RECOVER)\n+ {\n+ // If we hit a SEQ, check if we're the last child (the value)\n+ if(ast_id(check_parent) == TK_SEQ)\n+ {\n+ if(ast_childlast(check_parent) == ast || \n+ ast_childlast(check_parent) == parent)\n+ {\n+ check_parent = ast_parent(check_parent);\n+ continue;\n+ }\n+ break;\n+ }\n+ parent = check_parent;\n+ check_parent = ast_parent(check_parent);\n+ }\n+ \n+ if(check_parent != NULL && ast_id(check_parent) == TK_RECOVER)\n+ {\n+ // This is the value being recovered\n+ // Check the recover capability\n+ ast_t* recover_cap = ast_child(check_parent);\n+ token_id rcap = ast_id(recover_cap);\n+ \n+ // If recovering as val or iso, the original type must be sendable\n+ // or at least not box/tag\n+ if((rcap == TK_VAL || rcap == TK_ISO) && \n+ (ast_id(type) == TK_NOMINAL || ast_id(type) == TK_ARROW))\n+ {\n+ ast_t* type_cap_ast = NULL;\n+ if(ast_id(type) == TK_NOMINAL)\n+ type_cap_ast = ast_childidx(type, 3);\n+ else if(ast_id(type) == TK_ARROW)\n+ {\n+ ast_t* right = ast_childidx(type, 1);\n+ if(ast_id(right) == TK_NOMINAL)\n+ type_cap_ast = ast_childidx(right, 3);\n+ }\n+ \n+ if(type_cap_ast != NULL)\n+ {\n+ token_id orig_cap = ast_id(type_cap_ast);\n+ if(orig_cap == TK_BOX || orig_cap == TK_TAG)\n+ {\n+ ast_error(opt->check.errors, ast, \n+ \"can't recover a '%s' reference from outside as '%s'\",\n+ token_print(orig_cap), token_print(rcap));\n+ return false;\n+ }\n+ }\n+ }\n+ }\n+ \n if((ast_id(parent) != TK_DOT) && (ast_id(parent) != TK_CHAIN))\n type = set_cap_and_ephemeral(type, TK_TAG, TK_NONE);\n \n\n--- a/src/libponyc/type/safeto.c\n+++ b/src/libponyc/type/safeto.c\n@@ -171,17 +171,17 @@\n case TK_ARROW:\n {\n // If the receiver is an arrow type, it's safe to autorecover if the\n- // type being considered is safe to move into/out of the upper bounds of the\n- // receiver.\n- ast_t* upper = viewpoint_upper(receiver_type);\n-\n- if(upper == NULL)\n- return false;\n-\n- bool ok = safe_to_autorecover(upper, type, direction);\n-\n- if(upper != receiver_type)\n- ast_free_unattached(upper);\n+ // type being considered is safe to move into/out of the lower bounds of the\n+ // receiver for TO direction (extracting), or upper bounds for FROM direction.\n+ ast_t* bounds = (direction == TO) ? viewpoint_lower(receiver_type) : viewpoint_upper(receiver_type);\n+\n+ if(bounds == NULL)\n+ return false;\n+\n+ bool ok = safe_to_autorecover(bounds, type, direction);\n+\n+ if(bounds != receiver_type)\n+ ast_free_unattached(bounds);\n \n return ok;\n }\n\n--- a/src/libponyc/type/subtype.c\n+++ b/src/libponyc/type/subtype.c\n@@ -1502,6 +1502,30 @@\n // Failing fast can avoid expensive ast_dup operations in viewpoint functions.\n if(!is_x_sub_x(ast_childidx(sub, 1), super, CHECK_CAP_IGNORE, errorf, opt))\n return false;\n+\n+ // Check if we're trying to recover a sendable capability (iso/val/tag) from\n+ // a box viewpoint, which is unsound because box doesn't prevent mutable aliases\n+ ast_t* left = ast_child(sub);\n+ ast_t* right = ast_childidx(sub, 1);\n+ \n+ if(ast_id(left) == TK_NOMINAL)\n+ {\n+ ast_t* left_cap = cap_fetch(left);\n+ ast_t* super_cap = cap_fetch(super);\n+ \n+ // If the left side is box and we're trying to get val/iso, reject it\n+ if((ast_id(left_cap) == TK_BOX) && \n+ (ast_id(super_cap) == TK_VAL || ast_id(super_cap) == TK_ISO))\n+ {\n+ if(errorf != NULL)\n+ {\n+ ast_error_frame(errorf, sub,\n+ \"%s is not a subtype of %s: cannot recover %s from a box viewpoint\",\n+ ast_print_type(sub), ast_print_type(super), ast_print_type(super_cap));\n+ }\n+ return false;\n+ }\n+ }\n \n // upperbound(T1->T2) <: N k\n // ---\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4505", "model_patch": "--- a/src/libponyc/expr/postfix.c\n+++ b/src/libponyc/expr/postfix.c\n@@ -235,6 +235,22 @@\n return false;\n }\n \n+ // Check if this type access is being consumed\n+ ast_t* parent = ast_parent(ast);\n+ while(parent != NULL)\n+ {\n+ if(ast_id(parent) == TK_CONSUME)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"can't consume a field from a type, only from an instance\");\n+ return false;\n+ }\n+ // Stop searching if we hit certain boundaries\n+ if(ast_id(parent) == TK_SEQ || ast_id(parent) == TK_RECOVER)\n+ break;\n+ parent = ast_parent(parent);\n+ }\n+\n ast_t* dot = ast_from(ast, TK_DOT);\n ast_add(dot, ast_from_string(ast, \"create\"));\n ast_swap(left, dot);\n\n--- a/src/libponyc/expr/reference.c\n+++ b/src/libponyc/expr/reference.c\n@@ -248,6 +248,15 @@\n bool expr_fieldref(pass_opt_t* opt, ast_t* ast, ast_t* find, token_id tid)\n {\n AST_GET_CHILDREN(ast, left, right);\n+ \n+ // Check if we're trying to access a field on a type reference instead of an instance\n+ if(ast_id(left) == TK_TYPEREF)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"can't access a field on a type, only on an instance of that type\");\n+ return false;\n+ }\n+ \n ast_t* l_type = ast_type(left);\n \n if(is_typecheck_error(l_type))\n\n--- a/src/libponyc/pass/names.c\n+++ b/src/libponyc/pass/names.c\n@@ -356,6 +356,19 @@\n case TK_STRUCT:\n case TK_CLASS:\n case TK_ACTOR:\n+ // If we're in an expression context and this nominal appears to be\n+ // used as a value (has a parent that's a dot operation), error out\n+ if(expr)\n+ {\n+ ast_t* parent = ast_parent(ast);\n+ if((parent != NULL) && (ast_id(parent) == TK_DOT))\n+ {\n+ ast_error(opt->check.errors, type_id,\n+ \"can't use a type name as a value\");\n+ r = false;\n+ break;\n+ }\n+ }\n r = names_type(opt, astp, def);\n break;\n \n\n--- a/src/libponyc/pass/refer.c\n+++ b/src/libponyc/pass/refer.c\n@@ -139,9 +139,10 @@\n \n default:\n {\n- if (def == NULL)\n- return stringtab(\"\");\n- pony_assert(0);\n+ // If we have no definition or an unhandled reference type,\n+ // return an empty string to avoid assertion failure.\n+ // This will be caught as an error in later validation.\n+ return stringtab(\"\");\n }\n }\n \n\n--- a/src/libponyc/pass/syntax.c\n+++ b/src/libponyc/pass/syntax.c\n@@ -748,6 +748,19 @@\n AST_GET_CHILDREN(term, left, right);\n if (ast_id(left) != TK_CALL && ast_id(left) != TK_SEQ)\n {\n+ // Check if left is a type reference (not an instance)\n+ if(ast_id(left) == TK_REFERENCE)\n+ {\n+ // Type names start with uppercase, local/field names with lowercase\n+ const char* name = ast_name(ast_child(left));\n+ if(name != NULL && isupper((unsigned char)name[0]))\n+ {\n+ ast_error(opt->check.errors, term,\n+ \"Consume expressions cannot consume from a type name, only from \"\n+ \"an instance\");\n+ return AST_ERROR;\n+ }\n+ }\n return AST_OK;\n }\n }\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4506", "model_patch": "--- a/src/libponyc/codegen/gencontrol.c\n+++ b/src/libponyc/codegen/gencontrol.c\n@@ -697,7 +697,10 @@\n gen_expr(c, then_clause);\n \n else_block = LLVMGetInsertBlock(c->builder);\n- LLVMBuildBr(c->builder, post_block);\n+ \n+ // Only branch if the block doesn't already have a terminator\n+ if(LLVMGetBasicBlockTerminator(else_block) == NULL)\n+ LLVMBuildBr(c->builder, post_block);\n }\n \n // If both sides return, we return a sentinel value.\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4583", "model_patch": "--- a/src/libponyrt/actor/actor.c\n+++ b/src/libponyrt/actor/actor.c\n@@ -667,6 +667,16 @@\n \n if (has_internal_flag(actor, FLAG_BLOCKED))\n {\n+ // Pinned actors should not participate in termination detection when blocked.\n+ // They are managed by dedicated threads and should only terminate when explicitly\n+ // unpinned or when their dedicated thread stops.\n+ if (has_internal_flag(actor, FLAG_PINNED))\n+ {\n+ // For pinned actors, just return true to keep them scheduled\n+ // if they have messages, or false if they don't\n+ return !ponyint_messageq_markempty(&actor->q);\n+ }\n+\n if (actor->gc.rc == 0)\n {\n // Here, we is what we know to be true:\n\n--- a/src/libponyrt/sched/scheduler.c\n+++ b/src/libponyrt/sched/scheduler.c\n@@ -1472,6 +1472,13 @@\n } else {\n pony_assert(ponyint_actor_is_pinned(actor));\n \n+ // Send unblock message if we previously sent a block message\n+ if(block_sent)\n+ {\n+ send_msg(sched->index, 0, SCHED_UNBLOCK, 0);\n+ block_sent = false;\n+ }\n+\n tsc = ponyint_cpu_tick();\n \n // Run the current actor and get the next actor.\n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4588", "model_patch": "--- a/src/libponyc/expr/match.c\n+++ b/src/libponyc/expr/match.c\n@@ -584,7 +584,6 @@\n \n bool expr_match_capture(pass_opt_t* opt, ast_t* ast)\n {\n- (void)opt;\n pony_assert(ast != NULL);\n \n AST_GET_CHILDREN(ast, id, type);\n@@ -593,6 +592,40 @@\n ast_setid(ast, TK_MATCH_DONTCARE);\n \n pony_assert(type != NULL);\n+\n+ // Get the match expression to check if it's ephemeral\n+ ast_t* case_ast = ast_parent(ast);\n+ while((case_ast != NULL) && (ast_id(case_ast) != TK_CASE))\n+ case_ast = ast_parent(case_ast);\n+ \n+ if(case_ast != NULL)\n+ {\n+ ast_t* cases = ast_parent(case_ast);\n+ ast_t* match = ast_parent(cases);\n+ ast_t* match_expr = ast_child(match);\n+ ast_t* match_type = ast_type(match_expr);\n+ \n+ if(!is_typecheck_error(match_type))\n+ {\n+ // If the match expression is not ephemeral (e.g., a field reference),\n+ // the capture type should also not be ephemeral, even if annotated as such.\n+ // This prevents consuming non-ephemeral values through pattern matching.\n+ if(!is_ephemeral(match_type))\n+ {\n+ ast_t* non_ephemeral_type = remove_ephemeral(type);\n+ if(non_ephemeral_type != type)\n+ {\n+ ast_error(opt->check.errors, ast,\n+ \"can't capture as ephemeral when the match operand is not ephemeral\");\n+ ast_error_continue(opt->check.errors, match_expr,\n+ \"match operand type: %s\", ast_print_type(match_type));\n+ ast_error_continue(opt->check.errors, type,\n+ \"capture type: %s\", ast_print_type(type));\n+ return false;\n+ }\n+ }\n+ }\n+ }\n \n // Capture type is as specified.\n ast_settype(ast, type);\n\n--- a/src/libponyc/type/cap.c\n+++ b/src/libponyc/type/cap.c\n@@ -1152,10 +1152,14 @@\n \n bool unisolated_mod(token_id* cap, token_id* eph)\n {\n- // Ephemeral caps have no isolation guarantees\n- // to maintain\n+ bool modified = false;\n+\n+ // Remove ephemeral status when unisolating\n if (*eph == TK_EPHEMERAL)\n- return false;\n+ {\n+ *eph = TK_NONE;\n+ modified = true;\n+ }\n \n switch(*cap)\n {\n@@ -1165,7 +1169,7 @@\n return true;\n \n default:\n- return false;\n+ return modified;\n }\n }\n \n"} +{"model_name_or_path": "Claude-4-Sonnet", "instance_id": "ponylang__ponyc-4595", "model_patch": "--- a/src/libponyc/codegen/genexpr.c\n+++ b/src/libponyc/codegen/genexpr.c\n@@ -282,7 +282,9 @@\n \n while((sub = reach_type_cache_next(&t->subtypes, &i)) != NULL)\n {\n- pony_assert(sub->underlying == TK_TUPLETYPE);\n+ // Skip non-tuple types in the union when assigning to a tuple\n+ if(sub->underlying != TK_TUPLETYPE)\n+ continue;\n \n LLVMBasicBlockRef sub_block = codegen_block(c, \"assign_union_tuple_sub\");\n LLVMAddCase(type_switch, LLVMConstInt(c->i32, sub->type_id, false),\n\n--- a/src/libponyc/codegen/genmatch.c\n+++ b/src/libponyc/codegen/genmatch.c\n@@ -252,6 +252,21 @@\n static bool dynamic_tuple_element(compile_t* c, LLVMValueRef ptr,\n LLVMValueRef desc, ast_t* pattern, LLVMBasicBlockRef next_block, int elem)\n {\n+ // Treat a one element tuple as its component expression.\n+ if(ast_id(pattern) == TK_TUPLE)\n+ {\n+ ast_t* child = ast_child(pattern);\n+\n+ if((child != NULL) && (ast_sibling(child) == NULL))\n+ {\n+ // Skip over the SEQ node if present.\n+ if(ast_id(child) == TK_SEQ)\n+ child = ast_child(child);\n+ \n+ pattern = child;\n+ }\n+ }\n+\n // If we have a capture, generate the alloca now.\n switch(ast_id(pattern))\n {\n\n--- a/src/libponyc/expr/match.c\n+++ b/src/libponyc/expr/match.c\n@@ -322,7 +322,17 @@\n \n // Treat a one element tuple as a normal expression.\n if(ast_sibling(pattern_child) == NULL)\n- return make_pattern_type(opt, pattern_child);\n+ {\n+ ast_t* child_type = make_pattern_type(opt, pattern_child);\n+ \n+ if(child_type != NULL)\n+ {\n+ // Set the type on the tuple pattern itself to match the unwrapped child\n+ ast_settype(pattern, child_type);\n+ }\n+ \n+ return child_type;\n+ }\n \n // Check every element pairwise.\n ast_t* tuple_type = ast_from(pattern, TK_TUPLETYPE);\n\n--- a/src/libponyc/type/matchtype.c\n+++ b/src/libponyc/type/matchtype.c\n@@ -545,11 +545,26 @@\n case TK_ARROW:\n return is_arrow_match_x(operand, pattern, errorf, report_reject, opt);\n \n+ case TK_FUNTYPE:\n+ if((errorf != NULL) && report_reject)\n+ {\n+ ast_error_frame(errorf, pattern,\n+ \"%s cannot match %s: the pattern type is a tuple\",\n+ ast_print_type(operand), ast_print_type(pattern));\n+ }\n+ return MATCHTYPE_REJECT;\n+\n default: {}\n }\n \n- pony_assert(0);\n- return MATCHTYPE_DENY_CAP;\n+ if((errorf != NULL) && report_reject)\n+ {\n+ ast_error_frame(errorf, pattern,\n+ \"%s cannot match %s: the pattern type is a tuple\",\n+ ast_print_type(operand), ast_print_type(pattern));\n+ }\n+\n+ return MATCHTYPE_REJECT;\n }\n \n static matchtype_t is_nominal_match_entity(ast_t* operand, ast_t* pattern,\n"} diff --git a/evaluation/c/verified/20251226_RepoRepair_Claude-4-Sonnet/metadata.yaml b/evaluation/c/verified/20251226_RepoRepair_Claude-4-Sonnet/metadata.yaml new file mode 100644 index 000000000..5b89e1e4b --- /dev/null +++ b/evaluation/c/verified/20251226_RepoRepair_Claude-4-Sonnet/metadata.yaml @@ -0,0 +1,4 @@ +name: RepoRepair + Claude-4-Sonnet +oss: true +site: https://github.com/JXTZZ/M-RepoRepair +verified: False \ No newline at end of file diff --git a/evaluation/c/verified/20251226_RepoRepair_Claude-4-Sonnet/results/results.json b/evaluation/c/verified/20251226_RepoRepair_Claude-4-Sonnet/results/results.json new file mode 100644 index 000000000..aa3047544 --- /dev/null +++ b/evaluation/c/verified/20251226_RepoRepair_Claude-4-Sonnet/results/results.json @@ -0,0 +1,357 @@ +{ + "total_instances": 111, + "submitted_instances": 111, + "completed_instances": 110, + "incomplete_instances": 1, + "resolved_instances": 14, + "unresolved_instances": 96, + "empty_error_patch_instances": 1, + "unstopped_instances": 0, + "completed_ids": [ + "ponylang/ponyc:pr-4288", + "ponylang/ponyc:pr-4087", + "ponylang/ponyc:pr-4182", + "ponylang/ponyc:pr-2203", + "ponylang/ponyc:pr-1536", + "jqlang/jq:pr-3238", + "jqlang/jq:pr-2919", + "jqlang/jq:pr-2157", + "jqlang/jq:pr-1793", + "facebook/zstd:pr-3942", + "facebook/zstd:pr-1390", + "facebook/zstd:pr-1105", + "facebook/zstd:pr-809", + "facebook/zstd:pr-637", + "ponylang/ponyc:pr-4595", + "ponylang/ponyc:pr-4588", + "ponylang/ponyc:pr-4506", + "ponylang/ponyc:pr-4583", + "ponylang/ponyc:pr-4458", + "ponylang/ponyc:pr-4294", + "ponylang/ponyc:pr-4505", + "ponylang/ponyc:pr-4263", + "ponylang/ponyc:pr-4067", + "ponylang/ponyc:pr-4057", + "ponylang/ponyc:pr-4061", + "ponylang/ponyc:pr-4034", + "ponylang/ponyc:pr-4024", + "ponylang/ponyc:pr-4017", + "ponylang/ponyc:pr-4006", + "ponylang/ponyc:pr-4005", + "ponylang/ponyc:pr-3991", + "ponylang/ponyc:pr-3971", + "ponylang/ponyc:pr-3973", + "ponylang/ponyc:pr-3962", + "ponylang/ponyc:pr-3953", + "ponylang/ponyc:pr-3781", + "ponylang/ponyc:pr-3819", + "ponylang/ponyc:pr-3758", + "ponylang/ponyc:pr-3746", + "ponylang/ponyc:pr-3739", + "ponylang/ponyc:pr-3723", + "ponylang/ponyc:pr-3725", + "ponylang/ponyc:pr-3650", + "ponylang/ponyc:pr-3647", + "ponylang/ponyc:pr-3603", + "ponylang/ponyc:pr-3586", + "ponylang/ponyc:pr-3442", + "ponylang/ponyc:pr-3006", + "ponylang/ponyc:pr-2865", + "ponylang/ponyc:pr-3293", + "ponylang/ponyc:pr-2950", + "ponylang/ponyc:pr-2853", + "ponylang/ponyc:pr-2664", + "ponylang/ponyc:pr-2660", + "ponylang/ponyc:pr-2504", + "ponylang/ponyc:pr-2532", + "ponylang/ponyc:pr-2272", + "ponylang/ponyc:pr-2342", + "ponylang/ponyc:pr-2261", + "ponylang/ponyc:pr-2214", + "ponylang/ponyc:pr-2221", + "ponylang/ponyc:pr-2205", + "ponylang/ponyc:pr-2176", + "ponylang/ponyc:pr-2201", + "ponylang/ponyc:pr-2168", + "ponylang/ponyc:pr-2007", + "ponylang/ponyc:pr-1981", + "ponylang/ponyc:pr-2126", + "ponylang/ponyc:pr-1867", + "ponylang/ponyc:pr-1858", + "ponylang/ponyc:pr-1852", + "ponylang/ponyc:pr-1516", + "ponylang/ponyc:pr-1486", + "ponylang/ponyc:pr-1124", + "ponylang/ponyc:pr-1339", + "ponylang/ponyc:pr-1411", + "ponylang/ponyc:pr-1095", + "ponylang/ponyc:pr-1057", + "ponylang/ponyc:pr-1035", + "ponylang/ponyc:pr-1051", + "jqlang/jq:pr-3165", + "jqlang/jq:pr-3161", + "jqlang/jq:pr-2839", + "jqlang/jq:pr-2824", + "jqlang/jq:pr-2821", + "jqlang/jq:pr-2658", + "jqlang/jq:pr-2728", + "jqlang/jq:pr-2654", + "jqlang/jq:pr-2624", + "jqlang/jq:pr-2646", + "jqlang/jq:pr-2133", + "facebook/zstd:pr-3530", + "facebook/zstd:pr-3438", + "facebook/zstd:pr-2130", + "facebook/zstd:pr-3223", + "facebook/zstd:pr-2451", + "facebook/zstd:pr-1726", + "facebook/zstd:pr-1733", + "facebook/zstd:pr-2094", + "facebook/zstd:pr-1530", + "facebook/zstd:pr-1459", + "facebook/zstd:pr-1416", + "facebook/zstd:pr-1243", + "facebook/zstd:pr-1106", + "facebook/zstd:pr-1107", + "facebook/zstd:pr-983", + "facebook/zstd:pr-1008", + "facebook/zstd:pr-1080", + "facebook/zstd:pr-836", + "facebook/zstd:pr-938" + ], + "incomplete_ids": [ + "ponylang/ponyc:pr-1726" + ], + "submitted_ids": [ + "ponylang/ponyc:pr-4288", + "ponylang/ponyc:pr-4087", + "ponylang/ponyc:pr-4182", + "ponylang/ponyc:pr-2203", + "ponylang/ponyc:pr-1536", + "jqlang/jq:pr-3238", + "jqlang/jq:pr-2919", + "jqlang/jq:pr-2157", + "jqlang/jq:pr-1793", + "facebook/zstd:pr-3942", + "facebook/zstd:pr-1390", + "facebook/zstd:pr-1105", + "facebook/zstd:pr-809", + "facebook/zstd:pr-637", + "ponylang/ponyc:pr-4595", + "ponylang/ponyc:pr-4588", + "ponylang/ponyc:pr-4506", + "ponylang/ponyc:pr-4583", + "ponylang/ponyc:pr-4458", + "ponylang/ponyc:pr-4294", + "ponylang/ponyc:pr-4505", + "ponylang/ponyc:pr-4263", + "ponylang/ponyc:pr-4067", + "ponylang/ponyc:pr-4057", + "ponylang/ponyc:pr-4061", + "ponylang/ponyc:pr-4034", + "ponylang/ponyc:pr-4024", + "ponylang/ponyc:pr-4017", + "ponylang/ponyc:pr-4006", + "ponylang/ponyc:pr-4005", + "ponylang/ponyc:pr-3991", + "ponylang/ponyc:pr-3971", + "ponylang/ponyc:pr-3973", + "ponylang/ponyc:pr-3962", + "ponylang/ponyc:pr-3953", + "ponylang/ponyc:pr-3781", + "ponylang/ponyc:pr-3819", + "ponylang/ponyc:pr-3758", + "ponylang/ponyc:pr-3746", + "ponylang/ponyc:pr-3739", + "ponylang/ponyc:pr-3723", + "ponylang/ponyc:pr-3725", + "ponylang/ponyc:pr-3650", + "ponylang/ponyc:pr-3647", + "ponylang/ponyc:pr-3603", + "ponylang/ponyc:pr-3586", + "ponylang/ponyc:pr-3442", + "ponylang/ponyc:pr-3006", + "ponylang/ponyc:pr-2865", + "ponylang/ponyc:pr-3293", + "ponylang/ponyc:pr-2950", + "ponylang/ponyc:pr-2853", + "ponylang/ponyc:pr-2664", + "ponylang/ponyc:pr-2660", + "ponylang/ponyc:pr-2504", + "ponylang/ponyc:pr-2532", + "ponylang/ponyc:pr-2272", + "ponylang/ponyc:pr-2342", + "ponylang/ponyc:pr-2261", + "ponylang/ponyc:pr-2214", + "ponylang/ponyc:pr-2221", + "ponylang/ponyc:pr-2205", + "ponylang/ponyc:pr-2176", + "ponylang/ponyc:pr-2201", + "ponylang/ponyc:pr-2168", + "ponylang/ponyc:pr-2007", + "ponylang/ponyc:pr-1981", + "ponylang/ponyc:pr-2126", + "ponylang/ponyc:pr-1867", + "ponylang/ponyc:pr-1858", + "ponylang/ponyc:pr-1852", + "ponylang/ponyc:pr-1516", + "ponylang/ponyc:pr-1486", + "ponylang/ponyc:pr-1124", + "ponylang/ponyc:pr-1339", + "ponylang/ponyc:pr-1411", + "ponylang/ponyc:pr-1095", + "ponylang/ponyc:pr-1057", + "ponylang/ponyc:pr-1035", + "ponylang/ponyc:pr-1051", + "jqlang/jq:pr-3165", + "jqlang/jq:pr-3161", + "jqlang/jq:pr-2839", + "jqlang/jq:pr-2824", + "jqlang/jq:pr-2821", + "jqlang/jq:pr-2658", + "jqlang/jq:pr-2728", + "jqlang/jq:pr-2654", + "jqlang/jq:pr-2624", + "jqlang/jq:pr-2646", + "jqlang/jq:pr-2133", + "facebook/zstd:pr-3530", + "facebook/zstd:pr-3438", + "facebook/zstd:pr-2130", + "facebook/zstd:pr-3223", + "facebook/zstd:pr-2451", + "facebook/zstd:pr-1726", + "facebook/zstd:pr-1733", + "facebook/zstd:pr-2094", + "facebook/zstd:pr-1530", + "facebook/zstd:pr-1459", + "facebook/zstd:pr-1416", + "facebook/zstd:pr-1243", + "facebook/zstd:pr-1106", + "facebook/zstd:pr-1107", + "facebook/zstd:pr-983", + "facebook/zstd:pr-1008", + "facebook/zstd:pr-1080", + "facebook/zstd:pr-836", + "facebook/zstd:pr-938", + "ponylang/ponyc:pr-1726" + ], + "resolved": [ + "ponylang/ponyc:pr-4288", + "ponylang/ponyc:pr-4087", + "ponylang/ponyc:pr-4182", + "ponylang/ponyc:pr-2203", + "ponylang/ponyc:pr-1536", + "jqlang/jq:pr-3238", + "jqlang/jq:pr-2919", + "jqlang/jq:pr-2157", + "jqlang/jq:pr-1793", + "facebook/zstd:pr-3942", + "facebook/zstd:pr-1390", + "facebook/zstd:pr-1105", + "facebook/zstd:pr-809", + "facebook/zstd:pr-637" + ], + "unresolved_ids": [ + "ponylang/ponyc:pr-4595", + "ponylang/ponyc:pr-4588", + "ponylang/ponyc:pr-4506", + "ponylang/ponyc:pr-4583", + "ponylang/ponyc:pr-4458", + "ponylang/ponyc:pr-4294", + "ponylang/ponyc:pr-4505", + "ponylang/ponyc:pr-4263", + "ponylang/ponyc:pr-4067", + "ponylang/ponyc:pr-4057", + "ponylang/ponyc:pr-4061", + "ponylang/ponyc:pr-4034", + "ponylang/ponyc:pr-4024", + "ponylang/ponyc:pr-4017", + "ponylang/ponyc:pr-4006", + "ponylang/ponyc:pr-4005", + "ponylang/ponyc:pr-3991", + "ponylang/ponyc:pr-3971", + "ponylang/ponyc:pr-3973", + "ponylang/ponyc:pr-3962", + "ponylang/ponyc:pr-3953", + "ponylang/ponyc:pr-3781", + "ponylang/ponyc:pr-3819", + "ponylang/ponyc:pr-3758", + "ponylang/ponyc:pr-3746", + "ponylang/ponyc:pr-3739", + "ponylang/ponyc:pr-3723", + "ponylang/ponyc:pr-3725", + "ponylang/ponyc:pr-3650", + "ponylang/ponyc:pr-3647", + "ponylang/ponyc:pr-3603", + "ponylang/ponyc:pr-3586", + "ponylang/ponyc:pr-3442", + "ponylang/ponyc:pr-3006", + "ponylang/ponyc:pr-2865", + "ponylang/ponyc:pr-3293", + "ponylang/ponyc:pr-2950", + "ponylang/ponyc:pr-2853", + "ponylang/ponyc:pr-2664", + "ponylang/ponyc:pr-2660", + "ponylang/ponyc:pr-2504", + "ponylang/ponyc:pr-2532", + "ponylang/ponyc:pr-2272", + "ponylang/ponyc:pr-2342", + "ponylang/ponyc:pr-2261", + "ponylang/ponyc:pr-2214", + "ponylang/ponyc:pr-2221", + "ponylang/ponyc:pr-2205", + "ponylang/ponyc:pr-2176", + "ponylang/ponyc:pr-2201", + "ponylang/ponyc:pr-2168", + "ponylang/ponyc:pr-2007", + "ponylang/ponyc:pr-1981", + "ponylang/ponyc:pr-2126", + "ponylang/ponyc:pr-1867", + "ponylang/ponyc:pr-1858", + "ponylang/ponyc:pr-1852", + "ponylang/ponyc:pr-1516", + "ponylang/ponyc:pr-1486", + "ponylang/ponyc:pr-1124", + "ponylang/ponyc:pr-1339", + "ponylang/ponyc:pr-1411", + "ponylang/ponyc:pr-1095", + "ponylang/ponyc:pr-1057", + "ponylang/ponyc:pr-1035", + "ponylang/ponyc:pr-1051", + "jqlang/jq:pr-3165", + "jqlang/jq:pr-3161", + "jqlang/jq:pr-2839", + "jqlang/jq:pr-2824", + "jqlang/jq:pr-2821", + "jqlang/jq:pr-2658", + "jqlang/jq:pr-2728", + "jqlang/jq:pr-2654", + "jqlang/jq:pr-2624", + "jqlang/jq:pr-2646", + "jqlang/jq:pr-2133", + "facebook/zstd:pr-3530", + "facebook/zstd:pr-3438", + "facebook/zstd:pr-2130", + "facebook/zstd:pr-3223", + "facebook/zstd:pr-2451", + "facebook/zstd:pr-1726", + "facebook/zstd:pr-1733", + "facebook/zstd:pr-2094", + "facebook/zstd:pr-1530", + "facebook/zstd:pr-1459", + "facebook/zstd:pr-1416", + "facebook/zstd:pr-1243", + "facebook/zstd:pr-1106", + "facebook/zstd:pr-1107", + "facebook/zstd:pr-983", + "facebook/zstd:pr-1008", + "facebook/zstd:pr-1080", + "facebook/zstd:pr-836", + "facebook/zstd:pr-938" + ], + "empty_error_patch_ids": [ + "ponylang/ponyc:pr-1726" + ], + "unstopped_containers": [], + "unremoved_images": [] +} \ No newline at end of file