🥮 mooncakes.io

    moonsmith-contracts

    Language-neutral contracts for MoonSmith compiler testing

    Download zip
    Author
    Version
    0.0.1
    License
    GPL-3.0-only
    Repository
    Last updated
    7 hours ago
    Downloads
    8

    No dependencies

    #MoonSmith Contracts

    实现共享契约， 包含语言无关的命令、进程结果、执行观察、异常指纹、判定、案例和执行记录。

    OracleResult 以 Oracle、配置和阶段标识一项判断，结果区分满足、违反、不适用和证据不足。 Assessment 保存这些结果的不可变快照；完整性要求所提交的结果非空、无重复标识且无证据不足， 不会推断调用方未声明的检查。FailurePredicate 为原型的异常类别加上 Oracle 身份， PredicateStatus 区分保持、不保持、不可判定和不适用。更复杂的关系判据由后续 Oracle 扩展。 Assessment 用于库内交互，PredicateStatus 也用于保存归约确认状态； 现有 Attempt 继续保存原型主结论与原始观察。

    Case 保存原始生成配置与参考结果，Attempt 保存一次实际执行的工具链、命令和输出。 记录通过标准库 JSON 编解码；format_version = 1 标识参考案例格式。

    原始进程输出与可选故障注入输出分别保存。数据结构不包含语言 AST 或宿主资源句柄。

    #差分记录

    Comparison 表达无参考值的差分结果：全部配置一致、两个有效配置结果不同，或比较未完成。 它与已有参考判定 Verdict 分开表示，避免改变旧案例结论的含义。

    DifferentialCase 与 DifferentialAttempt 使用 format_version = 2，不要求参考值。 案例包含 GenerationRecord（种子、生成器版本、有效预算和实际规模）、生成源码与构建文件、 观察协议、计划配置和执行超时；输入嵌入源码，程序无参数且 stdin 为空。 执行记录保存当前工具链和平台探测的 ProcessEvidence、各配置的原始观察及 Comparison。 版本 2 的重执行使用保存材料，不要求仍能运行当时的生成器，也不转换旧参考结论。

    DifferentialReduction 是独立的版本 3 归约摘要，关联原始尝试、固定配置对、候选预算及计数、 最佳结果和独立确认尝试。cost_model 说明成本定义，original_cost 与 best_cost 保存 ReductionCost 的节点数、整数常量量级与源码字节数；顺序及计算语义由语言适配器解释。 节点数直接读取成本记录，不维护另一份副本。记录还明确停止原因、确认状态和操作错误， elapsed_ms 保存搜索及独立确认的单调时钟耗时。 版本 1、2 的旧摘要保持原样；源码重放读取案例和尝试材料，不依赖归约摘要。 摘要升版不改变版本 2 的案例、尝试或原始生成记录，也不表示搜索可以恢复。

    ReductionProgress 与 ReductionTrial 表达运行时搜索摘要和逐候选判定； BuildFailureReduction 关联专用 FailurePredicate。构建异常继续使用本地报告，已有差分归约仍保存上述版本 3 格式。 ReductionProgress 与 ReductionTrial 同时支持 JSON 编解码，供组归约记录保存搜索事实。

    EquivalentComparison 是应用和报告之间的运行时视图，以程序标签限定观察配置名， 关联各份已保存尝试、总体 Comparison 与操作错误；各尝试的原始配置名和观察保持原样。 它本身不提供独立 JSON 编解码；本地报告和组记录关联各份执行材料。

    EquivalentGroupRecord 使用独立的 format_version = 1，保存 等价程序组的 成员身份、变换版本、源码、相对尝试路径，以及所属案例原源码、配置计划、观察协议、注入标记和总体比较。 每个 GroupMember 关联既有版本 2 尝试；重放前检查材料一致性，不修改原尝试。 EquivalentGroupReduction 的版本 1 记录固定的成员与配置对、变换关系和 ReductionProgress， 其中原组、候选组、最佳组和确认组均以相对目录关联。记录不提供搜索恢复或通用格式迁移。

    #有限任务记录

    版本 2 的 TaskSample 关联显式种子与结果：TaskOutcome 区分取得比较结果和操作失败。 取得结果时，TaskObservation 链接原始案例与尝试，并保留比较结论及可选操作错误。 因此已经观察到分歧但保存失败时，两项事实可以同时记录。启用等价变换时，样本结论 涵盖原程序和变换程序，具体关系由原始尝试旁的本地报告和组记录关联。

    样本保留成功构造并完成内部检查的 GenerationRecord，生成失败时缺省；后续保存失败 不会把已经完成的内部检查改记为失败。baseline_build 区分构建正常退出、未正常退出和没有基线构建观察， comparable_results 与 planned_results 保留有效结果数量和计划分母，elapsed_ms 记录样本处理耗时。

    TaskSummary 的 format_version = 2 独立于单案例格式，保存任务名、计划与已尝试样本数、 各比较结论、操作错误、内部检查通过、基线构建尝试与接受、全部配置取得有效结果的计数， 以及处理样本至汇总前的单调时钟耗时。操作错误可以与比较结论重叠。 旧任务汇总保持原样，案例源码重放不读取任务汇总。 这些类型只描述事实，不读取 TOML、不调度执行，也不包含具体语言的生成预算类型。

    Assessment

    source
    pub struct Assessment {
      // private fields
    } derive(Eq, 
    Debug    )

    A snapshot of independent results; callers cannot mutate the retained array.

    Assessment::equal

    source
    fn Assessment::equal(Assessment, Assessment) -> Bool

    Assessment::is_complete

    source
    fn Assessment::is_complete(self : Assessment) -> Bool

    Assessment::new

    source
    fn Assessment::new(results : Array[OracleResult]) -> Assessment

    Assessment::not_equal

    source
    fn Assessment::not_equal(x : Assessment, y : Assessment) -> Bool

    Assessment::results

    source
    fn Assessment::results(self : Assessment) -> Array[OracleResult]

    Assessment::to_repr

    source

    Attempt

    source
    pub(all) struct Attempt {
      purpose : String
      compiler : String
      source : String
      expected : String
      nodes : Int
      observations : Array[Observation]
      verdict : Verdict
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Attempt::equal

    source
    fn Attempt::equal(Attempt, Attempt) -> Bool

    Attempt::from_json

    source

    Attempt::not_equal

    source
    fn Attempt::not_equal(x : Attempt, y : Attempt) -> Bool

    Attempt::to_json

    source
    fn Attempt::to_json(Attempt) -> Json

    Attempt::to_repr

    source

    BuildFailureReduction

    source
    pub(all) struct BuildFailureReduction {
      predicate : FailurePredicate
      progress : ReductionProgress
    } derive(Eq, 
    Debug    )

    BuildFailureReduction::equal

    source

    BuildFailureReduction::not_equal

    source

    BuildFailureReduction::to_repr

    source

    Case

    source
    pub(all) struct Case {
      format_version : Int
      generator : String
      seed : Int
      depth : Int
      source : String
      expected : String
      nodes : Int
      injected : Bool
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Case::equal

    source
    fn Case::equal(Case, Case) -> Bool

    Case::from_json

    source

    Case::not_equal

    source
    fn Case::not_equal(x : Case, y : Case) -> Bool

    Case::to_json

    source
    fn Case::to_json(Case) -> Json

    Case::to_repr

    source

    CheckOutcome

    source
    pub(all) enum CheckOutcome {
      Satisfied
      Violated(FailureKind)
      NotApplicable
      Insufficient(FailureKind)
    } derive(Eq, 
    Debug    )

    CheckOutcome::equal

    source

    CheckOutcome::not_equal

    source
    fn CheckOutcome::not_equal(x : CheckOutcome, y : CheckOutcome) -> Bool

    CheckOutcome::to_repr

    source

    Command

    source
    pub(all) struct Command {
      program : String
      args : Array[String]
      cwd : String
      timeout_ms : Int
      output_limit : Int
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Command::equal

    source
    fn Command::equal(Command, Command) -> Bool

    Command::from_json

    source

    Command::not_equal

    source
    fn Command::not_equal(x : Command, y : Command) -> Bool

    Command::to_json

    source
    fn Command::to_json(Command) -> Json

    Command::to_repr

    source

    Comparison

    source
    pub(all) enum Comparison {
      Consistent
      Difference(String, String)
      Incomplete
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A difference identifies two disagreeing configurations, not a faulty compiler.

    Comparison::equal

    source
    fn Comparison::equal(Comparison, Comparison) -> Bool

    Comparison::from_json

    source

    Comparison::not_equal

    source
    fn Comparison::not_equal(x : Comparison, y : Comparison) -> Bool

    Comparison::to_json

    source
    fn Comparison::to_json(Comparison) -> Json

    Comparison::to_repr

    source

    DifferentialAttempt

    source
    pub(all) struct DifferentialAttempt {
      format_version : Int
      purpose : String
      source : String
      configurations : Array[String]
      result_protocol : String
      toolchain : ProcessEvidence
      platform : ProcessEvidence
      injected : Bool
      observations : Array[Observation]
      comparison : Comparison
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    DifferentialAttempt::equal

    source

    DifferentialAttempt::from_json

    source

    DifferentialAttempt::not_equal

    source

    DifferentialAttempt::to_json

    source

    DifferentialAttempt::to_repr

    source

    DifferentialCase

    source
    pub(all) struct DifferentialCase {
      format_version : Int
      generation : GenerationRecord
      source : String
      module_source : String
      package_source : String
      result_protocol : String
      configurations : Array[String]
      build_timeout_ms : Int
      run_timeout_ms : Int
      injected : Bool
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Inputs are embedded in source; this format executes a closed program with empty stdin.

    DifferentialCase::equal

    source

    DifferentialCase::from_json

    source

    DifferentialCase::not_equal

    source
    fn DifferentialCase::not_equal(x : DifferentialCase, y : DifferentialCase) -> Bool

    DifferentialCase::to_json

    source

    DifferentialCase::to_repr

    source

    DifferentialReduction

    source
    pub(all) struct DifferentialReduction {
      format_version : Int
      first_configuration : String
      second_configuration : String
      original_attempt : String
      cost_model : String
      original_cost : ReductionCost
      candidate_limit : Int
      candidates : Int
      accepted : Int
      elapsed_ms : Int64
      best_cost : ReductionCost
      best_attempt : String
      stop_reason : String
      confirmation_attempt : String?
      confirmation : PredicateStatus?
      error : String?
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A reduction links immutable execution records; it does not replace the original case.

    DifferentialReduction::equal

    source

    DifferentialReduction::from_json

    source

    DifferentialReduction::not_equal

    source

    DifferentialReduction::to_json

    source

    DifferentialReduction::to_repr

    source

    EquivalentComparison

    source
    pub(all) struct EquivalentComparison {
      configurations : Array[String]
      observations : Array[Observation]
      attempts : Array[(String, String)]
      comparison : Comparison
      injected : Bool
      error : String?
    }

    Runtime view linking separately saved executions; not a versioned archive.

    EquivalentGroupRecord

    source
    pub(all) struct EquivalentGroupRecord {
      format_version : Int
      purpose : String
      case_source : String
      configurations : Array[String]
      result_protocol : String
      injected : Bool
      members : Array[GroupMember]
      comparison : Comparison
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    All associations are relative to the group's directory inside its owning case.

    EquivalentGroupRecord::equal

    source

    EquivalentGroupRecord::from_json

    source

    EquivalentGroupRecord::not_equal

    source

    EquivalentGroupRecord::to_json

    source

    EquivalentGroupRecord::to_repr

    source

    EquivalentGroupReduction

    source
    pub(all) struct EquivalentGroupReduction {
      format_version : Int
      first_configuration : String
      second_configuration : String
      relations : Array[(String, String)]
      progress : ReductionProgress
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    FailureKind

    source
    pub(all) enum FailureKind {
      Exit(Int)
      Mismatch
      Timeout
      OutputExceeded
      Infrastructure
      MissingObservation
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    FailureKind::equal

    source
    fn FailureKind::equal(FailureKind, FailureKind) -> Bool

    FailureKind::from_json

    source

    FailureKind::not_equal

    source
    fn FailureKind::not_equal(x : FailureKind, y : FailureKind) -> Bool

    FailureKind::to_json

    source
    fn FailureKind::to_json(FailureKind) -> Json

    FailureKind::to_repr

    source

    FailurePredicate

    source
    pub(all) struct FailurePredicate {
      oracle : String
      fingerprint : Fingerprint
    } derive(Eq, 
    Debug    )

    One observed failure condition, scoped to its oracle and execution phase.

    FailurePredicate::equal

    source

    FailurePredicate::not_equal

    source
    fn FailurePredicate::not_equal(x : FailurePredicate, y : FailurePredicate) -> Bool

    FailurePredicate::to_repr

    source

    Fingerprint

    source
    pub(all) struct Fingerprint {
      configuration : String
      phase : Phase
      kind : FailureKind
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Fingerprint::equal

    source
    fn Fingerprint::equal(Fingerprint, Fingerprint) -> Bool

    Fingerprint::from_json

    source

    Fingerprint::not_equal

    source
    fn Fingerprint::not_equal(x : Fingerprint, y : Fingerprint) -> Bool

    Fingerprint::to_json

    source
    fn Fingerprint::to_json(Fingerprint) -> Json

    Fingerprint::to_repr

    source

    GenerationRecord

    source
    pub(all) struct GenerationRecord {
      generator : String
      seed : Int
      max_nodes : Int
      max_depth : Int
      max_attempts : Int
      construction_attempts : Int
      nodes : Int
      depth : Int
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    GenerationRecord::equal

    source

    GenerationRecord::from_json

    source

    GenerationRecord::not_equal

    source
    fn GenerationRecord::not_equal(x : GenerationRecord, y : GenerationRecord) -> Bool

    GenerationRecord::to_json

    source

    GenerationRecord::to_repr

    source

    GroupMember

    source
    pub(all) struct GroupMember {
      id : String
      transformation : String
      source : String
      attempt : String
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    GroupMember::equal

    source
    fn GroupMember::equal(GroupMember, GroupMember) -> Bool

    GroupMember::from_json

    source

    GroupMember::not_equal

    source
    fn GroupMember::not_equal(x : GroupMember, y : GroupMember) -> Bool

    GroupMember::to_json

    source
    fn GroupMember::to_json(GroupMember) -> Json

    GroupMember::to_repr

    source

    Observation

    source
    pub(all) struct Observation {
      configuration : String
      phase : Phase
      command : Command
      output : Output
      injected_stdout : String?
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Observation::equal

    source
    fn Observation::equal(Observation, Observation) -> Bool

    Observation::from_json

    source

    Observation::not_equal

    source
    fn Observation::not_equal(x : Observation, y : Observation) -> Bool

    Observation::to_json

    source
    fn Observation::to_json(Observation) -> Json

    Observation::to_repr

    source

    OracleResult

    source
    pub(all) struct OracleResult {
      oracle : String
      configuration : String
      phase : Phase
      outcome : CheckOutcome
    } derive(Eq, 
    Debug    )

    OracleResult::equal

    source

    OracleResult::not_equal

    source
    fn OracleResult::not_equal(x : OracleResult, y : OracleResult) -> Bool

    OracleResult::to_repr

    source

    Output

    source
    pub(all) struct Output {
      status : ProcessStatus
      stdout : String
      stderr : String
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Output::equal

    source
    fn Output::equal(Output, Output) -> Bool

    Output::from_json

    source

    Output::not_equal

    source
    fn Output::not_equal(x : Output, y : Output) -> Bool

    Output::to_json

    source
    fn Output::to_json(Output) -> Json

    Output::to_repr

    source

    Phase

    source

    Phase::equal

    source
    fn Phase::equal(Phase, Phase) -> Bool

    Phase::from_json

    source

    Phase::hash

    source
    fn Phase::hash(self : Phase) -> Int

    Phase::hash_combine

    source
    fn Phase::hash_combine(Phase, Hasher) -> Unit

    Phase::not_equal

    source
    fn Phase::not_equal(x : Phase, y : Phase) -> Bool

    Phase::to_json

    source
    fn Phase::to_json(Phase) -> Json

    Phase::to_repr

    source

    PredicateStatus

    source
    pub(all) enum PredicateStatus {
      Preserved
      NotPreserved
      Undetermined
      Inapplicable
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    PredicateStatus::equal

    source

    PredicateStatus::from_json

    source

    PredicateStatus::not_equal

    source
    fn PredicateStatus::not_equal(x : PredicateStatus, y : PredicateStatus) -> Bool

    PredicateStatus::to_json

    source

    PredicateStatus::to_repr

    source

    ProcessEvidence

    source
    pub(all) struct ProcessEvidence {
      command : Command
      output : Output
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    ProcessEvidence::equal

    source

    ProcessEvidence::from_json

    source

    ProcessEvidence::not_equal

    source
    fn ProcessEvidence::not_equal(x : ProcessEvidence, y : ProcessEvidence) -> Bool

    ProcessEvidence::to_json

    source

    ProcessEvidence::to_repr

    source

    ProcessStatus

    source
    pub(all) enum ProcessStatus {
      Exited(Int)
      TimedOut
      OutputLimit
      HostError(String)
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    ProcessStatus::equal

    source

    ProcessStatus::from_json

    source

    ProcessStatus::not_equal

    source
    fn ProcessStatus::not_equal(x : ProcessStatus, y : ProcessStatus) -> Bool

    ProcessStatus::to_json

    source

    ProcessStatus::to_repr

    source

    ReductionCost

    source
    pub(all) struct ReductionCost {
      nodes : Int
      integer_magnitude : Int64
      source_bytes : Int
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Components of the current MoonBit reduction cost; the adapter owns their ordering.

    ReductionCost::equal

    source

    ReductionCost::from_json

    source

    ReductionCost::not_equal

    source
    fn ReductionCost::not_equal(x : ReductionCost, y : ReductionCost) -> Bool

    ReductionCost::to_json

    source

    ReductionCost::to_repr

    source

    ReductionProgress

    source
    pub(all) struct ReductionProgress {
      original_attempt : String
      cost_model : String
      original_cost : ReductionCost
      candidate_limit : Int
      candidates : Int
      accepted : Int
      elapsed_ms : Int64
      best_cost : ReductionCost
      best_attempt : String
      stop_reason : String
      confirmation_attempt : String?
      confirmation : PredicateStatus?
      error : String?
      trials : Array[ReductionTrial]
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Search results linking the original material, candidates, and independent confirmation.

    ReductionProgress::equal

    source

    ReductionProgress::from_json

    source

    ReductionProgress::not_equal

    source
    fn ReductionProgress::not_equal(x : ReductionProgress, y : ReductionProgress) -> Bool

    ReductionProgress::to_json

    source

    ReductionProgress::to_repr

    source

    ReductionTrial

    source
    pub(all) struct ReductionTrial {
      attempt : String
      cost : ReductionCost
      status : PredicateStatus
      accepted : Bool
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    ReductionTrial::equal

    source

    ReductionTrial::from_json

    source

    ReductionTrial::not_equal

    source
    fn ReductionTrial::not_equal(x : ReductionTrial, y : ReductionTrial) -> Bool

    ReductionTrial::to_json

    source

    ReductionTrial::to_repr

    source

    TaskObservation

    source
    pub(all) struct TaskObservation {
      case_directory : String
      attempt_directory : String
      comparison : Comparison
      error : String?
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    TaskObservation::equal

    source

    TaskObservation::from_json

    source

    TaskObservation::not_equal

    source
    fn TaskObservation::not_equal(x : TaskObservation, y : TaskObservation) -> Bool

    TaskObservation::to_json

    source

    TaskObservation::to_repr

    source

    TaskOutcome

    source
    pub(all) enum TaskOutcome {
      Observed(TaskObservation)
      Failed(String)
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    TaskOutcome::equal

    source
    fn TaskOutcome::equal(TaskOutcome, TaskOutcome) -> Bool

    TaskOutcome::from_json

    source

    TaskOutcome::not_equal

    source
    fn TaskOutcome::not_equal(x : TaskOutcome, y : TaskOutcome) -> Bool

    TaskOutcome::to_json

    source
    fn TaskOutcome::to_json(TaskOutcome) -> Json

    TaskOutcome::to_repr

    source

    TaskSample

    source
    pub(all) struct TaskSample {
      format_version : Int
      seed : Int
      generation : GenerationRecord?
      baseline_build : Bool?
      comparable_results : Int
      planned_results : Int
      elapsed_ms : Int64
      outcome : TaskOutcome
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    TaskSample::equal

    source
    fn TaskSample::equal(TaskSample, TaskSample) -> Bool

    TaskSample::from_json

    source

    TaskSample::not_equal

    source
    fn TaskSample::not_equal(x : TaskSample, y : TaskSample) -> Bool

    TaskSample::to_json

    source
    fn TaskSample::to_json(TaskSample) -> Json

    TaskSample::to_repr

    source

    TaskSummary

    source
    pub(all) struct TaskSummary {
      format_version : Int
      name : String
      sample_count : Int
      attempted : Int
      consistent : Int
      differences : Int
      incomplete : Int
      operation_errors : Int
      generated_valid : Int
      baseline_configuration : String?
      baseline_attempted : Int
      baseline_accepted : Int
      comparisons_complete : Int
      elapsed_ms : Int64
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    TaskSummary::equal

    source
    fn TaskSummary::equal(TaskSummary, TaskSummary) -> Bool

    TaskSummary::from_json

    source

    TaskSummary::not_equal

    source
    fn TaskSummary::not_equal(x : TaskSummary, y : TaskSummary) -> Bool

    TaskSummary::to_json

    source
    fn TaskSummary::to_json(TaskSummary) -> Json

    TaskSummary::to_repr

    source

    Verdict

    source
    pub(all) enum Verdict {
      Match
      Finding(Fingerprint)
      Inconclusive(Fingerprint)
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Verdict::equal

    source
    fn Verdict::equal(Verdict, Verdict) -> Bool

    Verdict::from_json

    source

    Verdict::not_equal

    source
    fn Verdict::not_equal(x : Verdict, y : Verdict) -> Bool

    Verdict::to_json

    source
    fn Verdict::to_json(Verdict) -> Json

    Verdict::to_repr

    source

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io