iter 23.5: prelude free fns + E2E — Eq/Ord milestone close
Five polymorphic prelude free fns (ne/lt/le/gt/ge) plus three E2E fixtures: positive composition over Int/Bool/Str, user-ADT with user-written Eq/Ord on IntBox, and Float-NoInstance with a Float-aware diagnostic addendum cross-referencing DESIGN.md §"Float semantics". Two checker-side fixes were needed alongside the prelude additions, both symmetric to the iter 23.4-prep visibility fix: - linearity::check_module_with_visible — workspace-aware callee-mode resolution so a Borrow-mode user fn forwarding into a prelude poly fn (e.g. `at_most x y = not (gt x y)`) doesn't false-fire consume-while-borrowed. - mono::collect_mono_targets — distinguish rigid forall vars from unbound metavars; rigid-bearing free-fn targets skip (they get re-collected with concrete subst when the enclosing fn itself monomorphises). Without this, a polymorphic body calling another polymorphic free fn produced a spurious __Unit specialisation whose body referenced compare at Unit. Roadmap split: shipped Eq/Ord half checked, Show + print-rewire half remains pending behind the heap-Str ABI prerequisite. DESIGN.md §"Prelude classes" amended. One pre-existing fixture (test_22b1_missing_method) renamed its class method ne → tne to avoid collision with the new prelude `ne`. Bench: check.py + cross_lang.py exit 0; compile_check.py exits 1 with one sub-ms check_ms.local_rec_capture at +26% (tolerance 25%) — prelude-growth-related noise-band fluctuation, ratifiable per spec §248-249 and journal Concerns.
This commit is contained in:
@@ -0,0 +1,45 @@
|
||||
//! Pins the Float-aware `NoInstance` diagnostic added in milestone 23.
|
||||
//!
|
||||
//! Property protected: a polymorphic Eq/Ord helper invoked at Float
|
||||
//! fires `no-instance` (since Float has neither Eq nor Ord instance
|
||||
//! per DESIGN.md §"Float semantics") AND the diagnostic message
|
||||
//! cross-references the canonical Float-semantics section so the
|
||||
//! LLM author immediately learns the partial-Float story rather
|
||||
//! than seeing a bare "no instance" message.
|
||||
|
||||
use ailang_check::check_workspace;
|
||||
use ailang_core::workspace::load_workspace;
|
||||
use std::path::PathBuf;
|
||||
|
||||
fn fixture(name: &str) -> PathBuf {
|
||||
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("../../examples")
|
||||
.join(name)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn eq_at_float_fires_float_aware_noinstance() {
|
||||
let ws = load_workspace(&fixture("eq_float_noinstance.ail.json")).expect("load");
|
||||
let diags = check_workspace(&ws);
|
||||
|
||||
assert!(!diags.is_empty(), "expected NoInstance diagnostic, got none");
|
||||
|
||||
let no_inst = diags
|
||||
.iter()
|
||||
.find(|d| d.code == "no-instance")
|
||||
.unwrap_or_else(|| panic!("expected diagnostic with code 'no-instance', got: {diags:#?}"));
|
||||
|
||||
assert!(
|
||||
no_inst.message.contains("Float"),
|
||||
"expected Float-aware NoInstance diagnostic, got message: {:?}",
|
||||
no_inst.message
|
||||
);
|
||||
|
||||
// Cross-ref to DESIGN.md §Float semantics — the LLM author should be
|
||||
// pointed at the canonical explanation of partial Float orderability.
|
||||
assert!(
|
||||
no_inst.message.contains("Float semantics") || no_inst.message.contains("DESIGN"),
|
||||
"expected NoInstance message to cross-reference DESIGN.md §Float semantics, got: {:?}",
|
||||
no_inst.message
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
//! End-to-end tests for the Eq/Ord prelude shipped in milestone 23.
|
||||
//!
|
||||
//! These tests compile a `.ail.json` workspace via the `ail build`
|
||||
//! subcommand, run the resulting native binary, and assert on stdout.
|
||||
//! Together they protect:
|
||||
//!
|
||||
//! 1. Polymorphic-helper composition over the prelude free fns at
|
||||
//! three primitive types (`eq_ord_polymorphic_runs_end_to_end`).
|
||||
//! Property: a user-defined `forall a. Ord a => …` helper that
|
||||
//! calls `gt`/`not` is monomorphised correctly at Int / Bool / Str.
|
||||
//! 2. User-ADT integration with the unified mono pass
|
||||
//! (`eq_ord_user_adt_runs_end_to_end`). Property: `instance Eq T`
|
||||
//! + `instance Ord T` for a user-defined `T` produces working
|
||||
//! mono symbols when invoked through the prelude.
|
||||
//! 3. Mono-symbol body-hash stability for `eq__IntBox`
|
||||
//! (`eq_ord_user_adt_eq_intbox_hash_stable`). Property: the user
|
||||
//! instance body that the unified pass emits for IntBox is
|
||||
//! bit-stable across refactors; drift here means either a
|
||||
//! legitimate emission change (re-record) or a regression
|
||||
//! (investigate). Mirrors `crates/ail/tests/mono_hash_stability.rs`.
|
||||
|
||||
use ailang_check::{check_workspace, monomorphise_workspace};
|
||||
use ailang_core::ast::Def;
|
||||
use ailang_core::hash::def_hash;
|
||||
use ailang_core::workspace::load_workspace;
|
||||
use std::path::PathBuf;
|
||||
use std::process::Command;
|
||||
|
||||
fn fixture_path(name: &str) -> PathBuf {
|
||||
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("../../examples")
|
||||
.join(name)
|
||||
}
|
||||
|
||||
fn build_and_run(fixture: &str) -> String {
|
||||
let src = fixture_path(fixture);
|
||||
let out = std::env::temp_dir().join(format!("ail_{}.bin", fixture.replace('.', "_")));
|
||||
|
||||
let build = Command::new(env!("CARGO_BIN_EXE_ail"))
|
||||
.args(["build", src.to_str().unwrap(), "-o", out.to_str().unwrap()])
|
||||
.output()
|
||||
.expect("ail build");
|
||||
assert!(
|
||||
build.status.success(),
|
||||
"ail build failed:\nstdout: {}\nstderr: {}",
|
||||
String::from_utf8_lossy(&build.stdout),
|
||||
String::from_utf8_lossy(&build.stderr),
|
||||
);
|
||||
|
||||
let run = Command::new(&out).output().expect("run binary");
|
||||
assert!(
|
||||
run.status.success(),
|
||||
"binary exited non-zero:\nstdout: {}\nstderr: {}",
|
||||
String::from_utf8_lossy(&run.stdout),
|
||||
String::from_utf8_lossy(&run.stderr),
|
||||
);
|
||||
String::from_utf8_lossy(&run.stdout).trim().to_string()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn eq_ord_polymorphic_runs_end_to_end() {
|
||||
let stdout = build_and_run("eq_ord_polymorphic.ail.json");
|
||||
// Helper `at_most(3, 5)` at Int = true → 1
|
||||
// `at_most(true, false)` at Bool = false → 0
|
||||
// `at_most("abc", "abd")` at Str = true → 1
|
||||
// `io/print_int` emits one int per line, so stdout is "1\n0\n1"
|
||||
// after `.trim()` strips the trailing newline.
|
||||
assert_eq!(stdout, "1\n0\n1", "expected 1\\n0\\n1, got {stdout:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn eq_ord_user_adt_runs_end_to_end() {
|
||||
let stdout = build_and_run("eq_ord_user_adt.ail.json");
|
||||
// eq(MkIntBox 3, MkIntBox 3) = true → 1
|
||||
// eq(MkIntBox 3, MkIntBox 5) = false → 0
|
||||
// `io/print_int` emits one int per line; trimmed stdout is "1\n0".
|
||||
assert_eq!(stdout, "1\n0", "expected 1\\n0, got {stdout:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn eq_ord_user_adt_eq_intbox_hash_stable() {
|
||||
let ws = load_workspace(&fixture_path("eq_ord_user_adt.ail.json")).expect("load");
|
||||
let diags = check_workspace(&ws);
|
||||
assert!(diags.is_empty(), "typecheck failed: {diags:#?}");
|
||||
let mono = monomorphise_workspace(&ws).expect("mono");
|
||||
|
||||
// The mono symbol for `eq` at a user-defined ADT uses the
|
||||
// `<method>__<8-hex-prefix>` mangling per DESIGN.md
|
||||
// §"Mangling scheme" (primitives use the bare type name; compound
|
||||
// / user-defined types use the 8-hex BLAKE3 prefix of the
|
||||
// canonical type bytes). We look up the single `eq__` symbol
|
||||
// synthesised at `IntBox` — there is only one user instance,
|
||||
// so the find-by-prefix is unambiguous in this fixture.
|
||||
let eq_intbox = mono
|
||||
.modules
|
||||
.values()
|
||||
.flat_map(|m| m.defs.iter())
|
||||
.find_map(|d| match d {
|
||||
Def::Fn(f) if f.name.starts_with("eq__") && f.name != "eq__Int"
|
||||
&& f.name != "eq__Bool" && f.name != "eq__Str" =>
|
||||
{
|
||||
Some(f)
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
.expect("eq__<IntBox-hash> not synthesised");
|
||||
|
||||
// The 8-hex-prefix in the mono-symbol name is the BLAKE3 prefix
|
||||
// of the canonical IntBox type bytes (DESIGN.md §"Mangling
|
||||
// scheme"). Drift here means either the canonical-form encoding
|
||||
// changed or the type's canonical bytes changed — both warrant
|
||||
// investigation before re-pinning.
|
||||
assert_eq!(
|
||||
eq_intbox.name, "eq__cde77856",
|
||||
"eq__IntBox mono-symbol name drifted — type-mangling regression?"
|
||||
);
|
||||
|
||||
// The body hash pins the unified mono pass's IntBox eq emission.
|
||||
// Drift means either a legitimate refactor (re-record) or a
|
||||
// regression in user-instance body propagation (investigate).
|
||||
let h = def_hash(&Def::Fn(eq_intbox.clone()));
|
||||
assert_eq!(
|
||||
h, "9daaffa7528d2a1c",
|
||||
"eq__IntBox body hash drifted — see mono_hash_stability.rs for the resolution pattern"
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
//! Workspace-level tests for the polymorphic prelude free fns
|
||||
//! `ne` / `lt` / `le` / `gt` / `ge` shipped in milestone 23.
|
||||
//!
|
||||
//! Property protected: each free fn is monomorphised on demand at the
|
||||
//! call site's concrete type, producing a mono symbol named
|
||||
//! `<fn>__<TypeName>`. If the unified mono pass (iter 23.4) stops
|
||||
//! emitting the free-fn mono arm, or the prelude entry for the fn
|
||||
//! gets renamed / dropped, these tests fail.
|
||||
//!
|
||||
//! See `crates/ail/tests/mono_unification.rs` (iter 23.4) for the
|
||||
//! end-to-end runtime correctness checks; this file checks only that
|
||||
//! the mono symbols are produced.
|
||||
|
||||
use ailang_check::{check_workspace, monomorphise_workspace};
|
||||
use ailang_core::workspace::load_workspace;
|
||||
use std::path::PathBuf;
|
||||
|
||||
fn fixture(name: &str) -> PathBuf {
|
||||
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("../../examples")
|
||||
.join(name)
|
||||
}
|
||||
|
||||
fn mono_symbol_names(workspace_name: &str) -> Vec<String> {
|
||||
let ws = load_workspace(&fixture(workspace_name)).expect("load");
|
||||
let diags = check_workspace(&ws);
|
||||
assert!(diags.is_empty(), "typecheck failed: {:#?}", diags);
|
||||
let mono = monomorphise_workspace(&ws).expect("mono");
|
||||
mono.modules
|
||||
.values()
|
||||
.flat_map(|m| m.defs.iter())
|
||||
.filter_map(|d| match d {
|
||||
ailang_core::ast::Def::Fn(f) => Some(f.name.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ne_at_int_produces_mono_symbol() {
|
||||
let names = mono_symbol_names("ne_at_int_smoke.ail.json");
|
||||
assert!(
|
||||
names.iter().any(|n| n == "ne__Int"),
|
||||
"expected ne__Int in workspace, found: {names:#?}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lt_at_int_produces_mono_symbol() {
|
||||
let names = mono_symbol_names("lt_at_int_smoke.ail.json");
|
||||
assert!(
|
||||
names.iter().any(|n| n == "lt__Int"),
|
||||
"expected lt__Int in workspace, found: {names:#?}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn le_at_str_produces_mono_symbol() {
|
||||
let names = mono_symbol_names("le_at_str_smoke.ail.json");
|
||||
assert!(
|
||||
names.iter().any(|n| n == "le__Str"),
|
||||
"expected le__Str in workspace, found: {names:#?}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gt_at_bool_produces_mono_symbol() {
|
||||
let names = mono_symbol_names("gt_at_bool_smoke.ail.json");
|
||||
assert!(
|
||||
names.iter().any(|n| n == "gt__Bool"),
|
||||
"expected gt__Bool in workspace, found: {names:#?}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ge_at_int_produces_mono_symbol() {
|
||||
let names = mono_symbol_names("ge_at_int_smoke.ail.json");
|
||||
assert!(
|
||||
names.iter().any(|n| n == "ge__Int"),
|
||||
"expected ge__Int in workspace, found: {names:#?}"
|
||||
);
|
||||
}
|
||||
@@ -706,6 +706,24 @@ impl CheckError {
|
||||
body_form_a.clone(),
|
||||
);
|
||||
}
|
||||
// Iter 23.5: Float-aware addendum on `NoInstance`. When the
|
||||
// unresolved class is `Eq` or `Ord` AND the type is `Float`,
|
||||
// append a cross-reference to DESIGN.md §"Float semantics" so
|
||||
// the LLM author learns the partial-Float story immediately
|
||||
// rather than seeing a bare "no instance" message. Float has
|
||||
// neither Eq nor Ord by design (partial orderability per
|
||||
// IEEE-754), and the polymorphic prelude helpers
|
||||
// (`ne` / `lt` / `le` / `gt` / `ge` / direct `eq` / `compare`)
|
||||
// are the natural surface where the LLM hits this.
|
||||
if let CheckError::NoInstance { class, at_type, .. } = self.inner() {
|
||||
if (class == "Eq" || class == "Ord") && at_type == "Float" {
|
||||
d.message = format!(
|
||||
"{} — Float has no Eq/Ord instance by design (partial \
|
||||
orderability per IEEE-754); see DESIGN.md §\"Float semantics\".",
|
||||
d.message
|
||||
);
|
||||
}
|
||||
}
|
||||
d
|
||||
}
|
||||
}
|
||||
@@ -852,7 +870,28 @@ pub fn check_workspace(ws: &Workspace) -> Vec<Diagnostic> {
|
||||
// all-explicit-mode fn are exactly the surface the check is
|
||||
// designed to inspect.
|
||||
if !had_typecheck_errors {
|
||||
module_diags.extend(linearity::check_module(m));
|
||||
// Iter 23.5: linearity check needs visibility into
|
||||
// polymorphic free fns + class methods from implicitly-
|
||||
// imported modules (currently just the auto-injected
|
||||
// prelude). Without this, a Borrow-mode user fn that
|
||||
// forwards its borrow params into a prelude poly fn
|
||||
// (e.g. `gt x y`) fires `consume-while-borrowed`
|
||||
// false positives because `callee_arg_modes` defaults
|
||||
// to Consume when it cannot see the callee's
|
||||
// `param_modes`. Symmetric to the class-method case
|
||||
// closed in iter 23.4-prep.
|
||||
let visible_extra: Vec<&Module> = ws
|
||||
.modules
|
||||
.iter()
|
||||
.filter_map(|(other_name, other_mod)| {
|
||||
if other_name == name {
|
||||
None
|
||||
} else {
|
||||
Some(other_mod)
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
module_diags.extend(linearity::check_module_with_visible(m, &visible_extra));
|
||||
// Iter 18d.2: reuse-as shape compatibility check. Runs on
|
||||
// the same activation gate as linearity (all-explicit-mode
|
||||
// fns only). The check resolves each `(reuse-as <var>
|
||||
|
||||
@@ -183,13 +183,58 @@ struct BinderState {
|
||||
///
|
||||
/// Output ordering: defs in declaration order; within a def, diagnostics
|
||||
/// in source-order discovery (depth-first left-to-right walk).
|
||||
/// Test-only convenience entry: linearity check on a single Module
|
||||
/// with no extra-visible siblings. Production code (`check_workspace`)
|
||||
/// uses [`check_module_with_visible`] directly to give the walker
|
||||
/// visibility into other workspace modules — in particular, the
|
||||
/// auto-injected prelude's polymorphic free fns and class methods.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn check_module(m: &Module) -> Vec<Diagnostic> {
|
||||
check_module_with_visible(m, &[])
|
||||
}
|
||||
|
||||
/// Iter 23.5: workspace-aware entry. `visible_extra` is a slice of
|
||||
/// modules whose top-level fns and class methods should be visible
|
||||
/// to `callee_arg_modes` (so a Borrow-mode user fn that forwards its
|
||||
/// borrow params into an imported polymorphic free fn — e.g. the
|
||||
/// prelude's `gt` / `ne` / `lt` — sees the imported fn's
|
||||
/// `param_modes` and does not false-fire `consume-while-borrowed`).
|
||||
///
|
||||
/// Symmetric to the iter 23.4-prep extension that made class methods
|
||||
/// visible. Bodies of the visible-extra modules are NOT walked here
|
||||
/// — they are checked when their own module is processed.
|
||||
pub(crate) fn check_module_with_visible(m: &Module, visible_extra: &[&Module]) -> Vec<Diagnostic> {
|
||||
let mut globals: HashMap<String, Type> = HashMap::new();
|
||||
// Iter 19a.1: ctor name → field types, used by the
|
||||
// `over-strict-mode` lint to filter out primitive-typed
|
||||
// pattern-binders (Int / Bool / Str / Unit) — their consume
|
||||
// does not force ownership of the scrutinee.
|
||||
let mut ctors: HashMap<String, Vec<Type>> = HashMap::new();
|
||||
|
||||
// Iter 23.5: register fns + class methods from visible-extra
|
||||
// modules first, so a name-clash inside `m` overwrites the
|
||||
// imported entry (matching the synth-side scope rule that
|
||||
// local-defs shadow implicit imports).
|
||||
for em in visible_extra {
|
||||
for def in &em.defs {
|
||||
match def {
|
||||
Def::Fn(f) => {
|
||||
globals.insert(f.name.clone(), strip_forall(&f.ty).clone());
|
||||
}
|
||||
Def::Class(c) => {
|
||||
for cm in &c.methods {
|
||||
globals.insert(cm.name.clone(), strip_forall(&cm.ty).clone());
|
||||
}
|
||||
}
|
||||
// Const / Type / Instance: not relevant for callee-arg-mode
|
||||
// resolution (Const can't be a callee; Type's ctors are
|
||||
// construction sites not fn calls; Instance bodies are
|
||||
// walked separately as Def::Fn post-mono).
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for def in &m.defs {
|
||||
match def {
|
||||
Def::Fn(f) => {
|
||||
|
||||
@@ -650,18 +650,40 @@ pub fn collect_mono_targets(
|
||||
// would have rejected; the Unit default is sound and
|
||||
// deterministic.
|
||||
for fc in free_fn_calls {
|
||||
let type_args: Vec<Type> = fc
|
||||
.metas
|
||||
.iter()
|
||||
.map(|m| {
|
||||
let resolved = subst.apply(m);
|
||||
if crate::is_fully_concrete(&resolved) {
|
||||
resolved
|
||||
} else {
|
||||
Type::unit()
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
// Iter 23.5: if any resolved type-arg is a rigid Type::Var
|
||||
// (i.e. a forall var of the *enclosing* polymorphic fn,
|
||||
// not a free metavar), skip this target. The enclosing fn
|
||||
// will be monomorphised in its own right, and that mono
|
||||
// synthesis re-walks the body with rigid → concrete
|
||||
// substitution, at which point this same call site is
|
||||
// re-observed with concrete type-args. Without the skip, a
|
||||
// body like `at_most x y = not (gt x y)` (a polymorphic
|
||||
// free fn calling another polymorphic free fn) would
|
||||
// produce a spurious `gt__Unit` target whose body
|
||||
// references `compare` at Unit — which has no Ord
|
||||
// instance, so the synthesised body fails to typecheck.
|
||||
//
|
||||
// Unit-default for unbound metavars (e.g. `is_empty(Nil)`
|
||||
// where the elem type is unobservable from the args alone)
|
||||
// is preserved: a metavar resolves to a `$m`-prefixed
|
||||
// Var via `subst.apply`, distinct from a rigid Var.
|
||||
let mut type_args: Vec<Type> = Vec::with_capacity(fc.metas.len());
|
||||
let mut has_rigid = false;
|
||||
for m in &fc.metas {
|
||||
let resolved = subst.apply(m);
|
||||
if crate::is_fully_concrete(&resolved) {
|
||||
type_args.push(resolved);
|
||||
} else if contains_rigid_var(&resolved) {
|
||||
has_rigid = true;
|
||||
break;
|
||||
} else {
|
||||
// Unbound metavar — default to Unit (iter 23.4 behaviour).
|
||||
type_args.push(Type::unit());
|
||||
}
|
||||
}
|
||||
if has_rigid {
|
||||
continue;
|
||||
}
|
||||
out.push(MonoTarget::FreeFn {
|
||||
name: fc.name.clone(),
|
||||
type_args,
|
||||
@@ -671,6 +693,24 @@ pub fn collect_mono_targets(
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Iter 23.5: true iff `t` contains a non-metavar `Type::Var` anywhere.
|
||||
/// Used by free-fn target collection to distinguish rigid forall vars
|
||||
/// (skip — wait for the enclosing fn's mono pass) from unbound metavars
|
||||
/// (Unit-default — no later round will pin them). The naming
|
||||
/// convention is: metavars are `Type::Var { name: "$m<id>" }`; rigid
|
||||
/// forall vars use their source name (`a`, `b`, …) which cannot start
|
||||
/// with `$` per the identifier rules.
|
||||
fn contains_rigid_var(t: &Type) -> bool {
|
||||
match t {
|
||||
Type::Var { name } => !name.starts_with("$m"),
|
||||
Type::Con { args, .. } => args.iter().any(contains_rigid_var),
|
||||
Type::Fn { params, ret, .. } => {
|
||||
params.iter().any(contains_rigid_var) || contains_rigid_var(ret)
|
||||
}
|
||||
Type::Forall { body, .. } => contains_rigid_var(body),
|
||||
}
|
||||
}
|
||||
|
||||
/// Iter 22b.3: produce a `FnDef` for a single (target, class,
|
||||
/// instance) triple. The synthesised fn:
|
||||
///
|
||||
|
||||
@@ -1780,10 +1780,11 @@ mod tests {
|
||||
|
||||
/// Iter 22b.1: an instance that omits a required (non-default)
|
||||
/// method of its class fires `MissingMethod`. The fixture's
|
||||
/// `class TEq` declares `teq` and `ne` as both non-default; the
|
||||
/// instance only specifies `ne`, leaving `teq` missing.
|
||||
/// (Class is `TEq` rather than `Eq` to avoid colliding with the
|
||||
/// auto-loaded prelude's `class Eq`.)
|
||||
/// `class TEq` declares `teq` and `tne` as both non-default; the
|
||||
/// instance only specifies `tne`, leaving `teq` missing.
|
||||
/// (Class is `TEq` (and method `tne`) rather than `Eq` / `ne` to
|
||||
/// avoid colliding with the auto-loaded prelude's `class Eq` and
|
||||
/// — since iter 23.5 — the prelude's polymorphic free fn `ne`.)
|
||||
#[test]
|
||||
fn iter22b1_missing_method_fires_diagnostic() {
|
||||
let entry = examples_dir().join("test_22b1_missing_method.ail.json");
|
||||
|
||||
Reference in New Issue
Block a user