Trait holes: supertrait at the impl's type, pins need Equal, blanket impl error, type-named variants

docs/language/error-codes.md

@@ -94,7 +94,6 @@ numbers that are missing belong to codes that are gone.
 | `E0338` | A field named twice in a record type, literal, pattern or update. |
 | `E0339` | A top-level `let` whose initialiser can reach the `let` itself. |
 | `E0340` | A statement whose value nothing uses. |
-| `E0341` | An impl that gives a record type a method named like one of the type's fields. |
 | `E0342` | A type given to a decoder that has no decoder for it (a field of a type no decoder exists for, an enum, a generic type, ...). |
 
 ## Compiling and the entry point (4xx, 5xx)

docs/language/generics.md

@@ -619,7 +619,7 @@ trait Stream for Wrap {
 ```
 
 Inside the trait body, `Self::Item` refers to whatever the impl will
-bind. At the call site (`w.first()` on a `Wrap`), the compiler reduces
+bind. At the call site (`Stream.first(w)` on a `Wrap`), the compiler reduces
 the projection to `Int` via the impl's `type Item = Int` binding.
 
 A trait may declare more than one associated type:

docs/language/pattern-matching.md

@@ -252,6 +252,11 @@ The variable is one from outside the pattern. A name the pattern binds
 itself is not it: `(x, ^x)` compares the second element with an `x` bound
 before the `match`, and is an error when there is none.
 
+A pin compares as `==` does: the value's type has `Equal`. A function has
+none, so pinning one is an error at the pin (`the pin '^f' requires a
+comparable type, got 'Fn(Int) -> Int'`); a channel is equal to itself
+only, and is pinned as below.
+
 Works in any pattern position. Common with `channel.select`:
 
 ```silt

docs/language/traits.md

@@ -81,30 +81,32 @@ illustrate trait *declaration* use a fresh local name; impls of the
 real built-in `Display` trait look identical and are shown in
 [Built-in Traits](#built-in-traits) below.)
 
-An impl gives a record type no method named like one of the record's
-fields, whether the impl writes the method or takes it as the trait's
-default: `job.run(5)` calls the function the field `run` holds, and a
-method of that name would read as the same thing.
+A record may have a field and an impl a method of one name: a dot after
+a value is always the field, and a trait's method is called through its
+trait. `job.run(5)` calls the function the field `run` holds,
+`Runner.run(job, 5)` the method of the impl.
 
 ```silt
 type Job {
   name: String,
   run: Fn(Int) -> Int,
 }
 
-trait Run {
+trait Runner {
   fn run(self, x: Int) -> Int
 }
 
--- error: method 'run' of the impl of 'Run' for 'Job' is named like a
--- field of 'Job'
--- help: a field and a method of one type cannot share a name: rename
--- the method or the field
-trait Run for Job {
+trait Runner for Job {
   fn run(self, x: Int) -> Int {
-    x
+    x + 100
   }
 }
+
+fn main() {
+  let job = Job { name: "double", run: { x -> x * 2 } }
+  println(job.run(5)) -- 10
+  println(Runner.run(job, 5)) -- 105
+}
 ```
 
 ## Supertrait Bounds
@@ -190,6 +192,28 @@ trait Ordered for MyInt { ... }
 -- (only when MyInt has no Equal, e.g. it has a function field)
 ```
 
+An impl for a parameterized type has the supertrait at its own type,
+with what its header gives the type's variables: a `Box(a)` has `Equal`
+when its `a` does, so the header says so:
+
+```silt
+trait Same: Equal {
+  fn same(self, other: Self) -> Bool {
+    self == other
+  }
+}
+
+type Box(a) {
+  Bx(a),
+}
+
+trait Same for Box(a) {}
+-- error: type 'Box(a)' implements 'Same' but does not implement supertrait 'Equal': 'a' needs 'Equal'
+-- help: add `where a: Equal` to the impl
+```
+
+`trait Same for Box(a) where a: Equal {}` is the impl.
+
 ## Default Methods
 
 A trait method can carry a body inside the trait declaration itself. The
@@ -334,6 +358,9 @@ use — a single `trait Wrap for Box(a)` impl handles both `Box(42)` and
 
 Rules:
 
+- **An impl is for a declared type.** `trait X for a` is an error
+  (`trait impl target 'a' is not a declared type`): a function bounded by
+  the trait says "every type that has it", `fn x(v: a) where a: Show`.
 - **Only lowercase binders.** `trait X for Box(Int)` is a parse error —
   silt has no specialization.
 - **Binders must be distinct.** `trait X for Pair(a, a)` is a parse error.
@@ -477,9 +504,11 @@ trait From(Celsius) for Fahrenheit {
 ```
 
 Parameterized traits may have supertraits (`trait Child(a): Parent(a)`) and
-`where` clauses on both the trait declaration and its methods. The full
-specification — including how trait parameters flow through `where` clauses
-and how multiple impls with different arguments coexist — lives in
+`where` clauses on both the trait declaration and its methods. A type has
+at most one impl of a trait, whatever its arguments: `trait From(Celsius)
+for Fahrenheit` and `trait From(Kelvin) for Fahrenheit` are a duplicate.
+The full specification — including how trait parameters flow through
+`where` clauses — lives in
 [Generics — Parameterized trait declarations](generics.md#parameterized-trait-declarations).
 
 ## Methods That Make a Value
@@ -530,6 +559,11 @@ concrete type passed in. See
 [Generics — Trait methods on types](generics.md#trait-methods-on-types) for
 the full rules.
 
+A type with a variant of its own name (`type Box(a) { Box(a), Empty }`)
+is the type where a type is meant: `Box.default()` calls the method of
+its impl, and `make(Box)` gives the type to a `type t` parameter;
+`Box(1)` is the variant.
+
 ## Method References
 
 A method named through its trait is a function value, as a module's

fuzz/corpus/fuzz_compiler/http_client.silt

@@ -16,7 +16,7 @@ type Repo {
 fn fetch_repos(user) {
   -- http.get returns HttpError, bytes.to_string BytesError and
   -- json.parse_list JsonError. Fold them into a single `String` channel
-  -- via `e.message()` so fetch_repos surfaces one uniform error type to
+  -- via `Error.message(e)` so fetch_repos surfaces one uniform error type to
   -- its caller.
   let resp = match http.get("https://api.github.com/users/{user}/repos") {
     Ok(r) -> r

fuzz/corpus/fuzz_compiler/text_stats.silt

@@ -98,7 +98,7 @@ fn main() {
   let filename = get_filename()
   match io.read_file(filename) {
     Err(e) -> {
-      println("Error reading file '{filename}': {e.message()}")
+      println("Error reading file '{filename}': {Error.message(e)}")
     }
     Ok(content) -> {
       let lines = content

fuzz/corpus/fuzz_formatter/http_client.silt

@@ -16,7 +16,7 @@ type Repo {
 fn fetch_repos(user) {
   -- http.get returns HttpError, bytes.to_string BytesError and
   -- json.parse_list JsonError. Fold them into a single `String` channel
-  -- via `e.message()` so fetch_repos surfaces one uniform error type to
+  -- via `Error.message(e)` so fetch_repos surfaces one uniform error type to
   -- its caller.
   let resp = match http.get("https://api.github.com/users/{user}/repos") {
     Ok(r) -> r

fuzz/corpus/fuzz_formatter/regression_bug3_trailing_on_block_comment_closer_line

@@ -102,7 +102,7 @@ fn main() {
               }
               Err(err_info) -> {
                 let (path, d Ped Perierr) = err_info
-                println("[Worker {worker_id}] FAILED {path}: {err.message()}")
+                println("[Worker {worker_id}] FAILED {path}: {Error.message(err)}")
                 loop(collected + 1, successes, failures + 1)
               }
             }

fuzz/corpus/fuzz_formatter/text_stats.silt

@@ -96,7 +96,7 @@ fn main() {
   let filename = get_filename()
   match io.read_file(filename) {
     Err(e) -> {
-      println("Error reading file '{filename}': {e.message()}")
+      println("Error reading file '{filename}': {Error.message(e)}")
     }
     Ok(content) -> {
       let lines = content

fuzz/corpus/fuzz_lexer/http_client.silt

@@ -16,7 +16,7 @@ type Repo {
 fn fetch_repos(user) {
   -- http.get returns HttpError, bytes.to_string BytesError and
   -- json.parse_list JsonError. Fold them into a single `String` channel
-  -- via `e.message()` so fetch_repos surfaces one uniform error type to
+  -- via `Error.message(e)` so fetch_repos surfaces one uniform error type to
   -- its caller.
   let resp = match http.get("https://api.github.com/users/{user}/repos") {
     Ok(r) -> r

fuzz/corpus/fuzz_lexer/text_stats.silt

@@ -96,7 +96,7 @@ fn main() {
   let filename = get_filename()
   match io.read_file(filename) {
     Err(e) -> {
-      println("Error reading file '{filename}': {e.message()}")
+      println("Error reading file '{filename}': {Error.message(e)}")
     }
     Ok(content) -> {
       let lines = content

fuzz/corpus/fuzz_parser/http_client.silt

@@ -16,7 +16,7 @@ type Repo {
 fn fetch_repos(user) {
   -- http.get returns HttpError, bytes.to_string BytesError and
   -- json.parse_list JsonError. Fold them into a single `String` channel
-  -- via `e.message()` so fetch_repos surfaces one uniform error type to
+  -- via `Error.message(e)` so fetch_repos surfaces one uniform error type to
   -- its caller.
   let resp = match http.get("https://api.github.com/users/{user}/repos") {
     Ok(r) -> r

fuzz/corpus/fuzz_parser/text_stats.silt

@@ -96,7 +96,7 @@ fn main() {
   let filename = get_filename()
   match io.read_file(filename) {
     Err(e) -> {
-      println("Error reading file '{filename}': {e.message()}")
+      println("Error reading file '{filename}': {Error.message(e)}")
     }
     Ok(content) -> {
       let lines = content

fuzz/corpus/fuzz_roundtrip/http_client.silt

@@ -16,7 +16,7 @@ type Repo {
 fn fetch_repos(user) {
   -- http.get returns HttpError, bytes.to_string BytesError and
   -- json.parse_list JsonError. Fold them into a single `String` channel
-  -- via `e.message()` so fetch_repos surfaces one uniform error type to
+  -- via `Error.message(e)` so fetch_repos surfaces one uniform error type to
   -- its caller.
   let resp = match http.get("https://api.github.com/users/{user}/repos") {
     Ok(r) -> r

fuzz/corpus/fuzz_roundtrip/text_stats.silt

@@ -96,7 +96,7 @@ fn main() {
   let filename = get_filename()
   match io.read_file(filename) {
     Err(e) -> {
-      println("Error reading file '{filename}': {e.message()}")
+      println("Error reading file '{filename}': {Error.message(e)}")
     }
     Ok(content) -> {
       let lines = content

fuzz/corpus/fuzz_typechecker/cross_module_errors.silt

@@ -26,7 +26,7 @@ type Config {
 
 -- Wrapper enum: one variant per module whose errors we want to
 -- surface, plus a Custom for ad-hoc domain errors. Silt's auto-derived
--- Display renders each variant cleanly; `.message()` falls through to
+-- Display renders each variant cleanly; `Error.message` falls through to
 -- the underlying module's trait impl.
 
 type AppError {
@@ -62,11 +62,11 @@ fn main() {
     Err(e) -> match e {
       -- Granular handling per domain.
       ConfigRead(NotFound(path)) -> println("create a config at: {path}")
-      ConfigRead(inner) -> println("config file: {inner.message()}")
-      ConfigParse(inner) -> println("config JSON invalid: {inner.message()}")
+      ConfigRead(inner) -> println("config file: {Error.message(inner)}")
+      ConfigParse(inner) -> println("config JSON invalid: {Error.message(inner)}")
       ApiCall(Timeout) -> println("API timed out — retry later")
-      ApiCall(inner) -> println("API call failed: {inner.message()}")
-      ApiResponse(inner) -> println("API response invalid: {inner.message()}")
+      ApiCall(inner) -> println("API call failed: {Error.message(inner)}")
+      ApiResponse(inner) -> println("API response invalid: {Error.message(inner)}")
       Custom(msg) -> println("app: {msg}")
     }
   }

fuzz/corpus/fuzz_typechecker/http_client.silt

@@ -16,7 +16,7 @@ type Repo {
 fn fetch_repos(user) {
   -- http.get returns HttpError, bytes.to_string BytesError and
   -- json.parse_list JsonError. Fold them into a single `String` channel
-  -- via `e.message()` so fetch_repos surfaces one uniform error type to
+  -- via `Error.message(e)` so fetch_repos surfaces one uniform error type to
   -- its caller.
   let resp = match http.get("https://api.github.com/users/{user}/repos") {
     Ok(r) -> r

fuzz/corpus/fuzz_typechecker/text_stats.silt

@@ -98,7 +98,7 @@ fn main() {
   let filename = get_filename()
   match io.read_file(filename) {
     Err(e) -> {
-      println("Error reading file '{filename}': {e.message()}")
+      println("Error reading file '{filename}': {Error.message(e)}")
     }
     Ok(content) -> {
       let lines = content

src/bytecode/verify.rs

@@ -365,7 +365,8 @@ fn check(
             if at >= argc =>
         {
             return fail(format!(
-                "`{op}` finds its method by argument {at} of {argc}"
+                "`{op}` finds its method by argument {} of {argc}",
+                at + 1
             ));
         }
         Instr::CallBuiltin { builtin: id, argc } => {
@@ -735,7 +736,7 @@ mod tests {
         ];
         assert_eq!(
             rejected(code, vec![Value::String("foo".into())]),
-            "at offset 1: `CallMethod` finds its method by argument 1 of 1"
+            "at offset 1: `CallMethod` finds its method by argument 2 of 1"
         );
     }
 

src/diagnostic.rs

@@ -200,9 +200,6 @@ codes! {
     InitCycle = "E0339", Type;
     /// A statement whose value nothing uses.
     UnusedValue = "E0340", Type;
-    /// An impl that gives a record type a method named like one of the
-    /// type's fields.
-    MethodNamedLikeField = "E0341", Type;
     /// A type given to a decoder that has no decoder for it (a field of
     /// a type no decoder exists for, an enum, a generic type, ...).
     Undecodable = "E0342", Type;

src/disassemble.rs

@@ -190,9 +190,10 @@ fn disassemble_instruction(
                 Some(t) => format!("{line} of {t}"),
                 None => line,
             };
+            // (Arguments counted from 1, as a reader counts them.)
             match at {
                 0 => line,
-                at => format!("{line}, by argument {at}"),
+                at => format!("{line}, by argument {}", at + 1),
             }
         }