Cuttlebone 0.16.0

Milestone 16: answers a client that relies on Cuttlebone lost:
diagnostics past a module that doesn't parse, implementations,
hierarchies and file renames past a declaration error elsewhere, code
lenses with every declaration's implementations and supertypes in one
request, a status for every file rename, a selection step with a
declaration's doc comment, and a trait's required and default methods.
Report.

• Diagnostics past a module that doesn't parse: the rest of the
  project is checked without it and what imports it, as inko check
  checks a copy of the project without them; those keep inko check's.
• Implementations, incoming calls, supertypes, subtypes and file
  renames past a declaration error elsewhere: refused only where a unit
  the error makes unsafe names what they're about, as references; so
  callers also in a document being edited.
• Code lenses (textDocument/codeLens, for a client with them):
  every declaration's implementations and supertypes, and each impl's
  trait and its methods' trait's methods, in one request, with their
  locations in the command's arguments, and covered in the status.
• A status for every file rename, fresh where no module's name
  changes, naming the request's files.
• A selection step with a declaration's doc comment.
• A trait's default methods have { ... } after the signature in
  document symbols' detail; required ones don't.
• For Inko 0.21.1, as before. Seven patch lines (a project check can leave files out), no new extension.

Each archive works with one Inko version, which its name says.
Machine-readable list of the builds, with sizes and SHA-256:
https://github.com/setdef/Cuttlebone/releases/download/v0.16.0/manifest.json
Every release, with its Inko versions and manifest:
https://github.com/setdef/Cuttlebone/releases/latest/download/index.json
(docs/releases.md).

Cuttlebone 0.15.0

Milestone 15: what a client that indexes Inko itself still needed.
Report.

• Quick fixes in files with other errors: a fix is offered when it
  removes its diagnostic and adds no error, not only when the file then
  has none. Imports are offered for the names in the requested range,
  also for a client that sends no diagnostics in the context.
• Four more quick fixes: missing-field (the field added with a
  value of its type), invalid-implementation (every method the impl
  block lacks, stubbed, in one action for all its diagnostics),
  missing-trait (impl R for T with its methods), unreachable (the
  code removed). Each still passes inko check.
• Completion of names in code being edited is refused only where a
  change or an error can bind or hide a name, not whenever any
  declaration differs; and keywords, where the grammar takes them.
• Document symbols hold still: a brace a method's body opens and
  nothing closes yet leaves out only that method, not the type it's in.
• Signature help for a type's constructor (Point(x: 1)), from its
  fields.
• Folding ranges' collapsedText, for clients that take it.
• Workspace symbols for an index: impl blocks, every symbol for an
  empty query, and every match of any query as partial results.
• For Inko 0.21.1, as before. No patch change, no new extension.

Each archive works with one Inko version, which its name says.
Machine-readable list of the builds, with sizes and SHA-256:
https://github.com/setdef/Cuttlebone/releases/download/v0.15.0/manifest.json
Every release, with its Inko versions and manifest:
https://github.com/setdef/Cuttlebone/releases/latest/download/index.json
(docs/releases.md).

Cuttlebone 0.14.0

Milestone 14: implementations, declarations, call and type hierarchies,
selection ranges, imports rewritten when files move, pull diagnostics, and
latency limits scaled by each CI runner's measured speed.
Report.

• textDocument/implementation: a trait's implementing types, and a
  trait's method's implementations (required, or a default redefined),
  from the type database, across the project, its dependencies and std.
• textDocument/declaration: a type's method that implements a
  trait's is declared by the trait's method; anything else as definition.
• Call hierarchy (prepareCallHierarchy, incomingCalls,
  outgoingCalls) and type hierarchy (prepareTypeHierarchy,
  supertypes, subtypes: traits a trait requires, traits a type
  implements), by the compiler's ids.
• textDocument/selectionRange: tokens, chains, elements,
  statements, brackets and declarations, from the syntax, also in code
  that doesn't parse.
• workspace/willRenameFiles: the edits to every import of a module
  (or a directory's modules) that moves, and to its uses by its own name,
  for clients that rename files.
• Pull diagnostics (textDocument/diagnostic, workspace/diagnostic)
  for clients that pull them, which then get no pushes: the same as
  inko check, for files open or not, with result ids and a long poll.
• Fixed: nothing that's in a release; the call hierarchy's first
  version panicked at an external function (fn extern), found by the
  std oracle before any release.
• The strict latency limits are scaled by each machine's measured
  baseline (scripts/latency.sh), and the latency job is a workflow of its
  own (.github/workflows/latency.yml). No patch change, no new
  extension.

Each archive works with one Inko version, which its name says.
Machine-readable list of the builds, with sizes and SHA-256:
https://github.com/setdef/Cuttlebone/releases/download/v0.14.0/manifest.json
Every release, with its Inko versions and manifest:
https://github.com/setdef/Cuttlebone/releases/latest/download/index.json
(docs/releases.md).

Cuttlebone 0.13.0

Milestone 13: answers after an edit is undone, folding ranges, formatting,
quick fixes, and the exhaustive checks in CI before each release.
Report.

• Fixed: a document edited, closed, and then changed on disk (or
  opened again with other text) had its edits paired with the file's new
  text: a worker crash (checkCrashed) if the file got shorter, and
  possibly wrong answers from the last good check if it kept its length.
  0.10.0 to 0.12.0 have it.
• textDocument/foldingRange: blocks, comment lines and imports,
  from the tokens alone, so also in code that doesn't parse. Kinds and
  rangeLimit as the client says.
• textDocument/formatting: exactly inko fmt's text, from the
  upstream formatter, as one edit; nothing written.
• textDocument/codeAction: quick fixes by diagnostic ID (imports,
  unused imports, variables and results, mut for immutable variables
  and fields), each applied to a copy and checked in full, offered only
  if that leaves no error. For clients with codeActionLiteralSupport.
• Definition at a refused assignment (to an immutable variable or
  field) goes to what the compiler looked up.
• Workspace symbols do less per keystroke.
• Releases wait for the release tier in CI: every test, the latency
  limits as written, and every mutation.
• One patch change (+3 −3, the formatter's Document made public); no
  new extension.

Each archive works with one Inko version, which its name says.
Machine-readable list of the builds, with sizes and SHA-256:
https://github.com/setdef/Cuttlebone/releases/download/v0.13.0/manifest.json
Every release, with its Inko versions and manifest:
https://github.com/setdef/Cuttlebone/releases/latest/download/index.json
(docs/releases.md).

Cuttlebone 0.12.0

Milestone 12: documentation in hover, document and workspace symbols, and
completion of names. Report.

• Hover shows the declaration, after the type: its signature as the
  source writes it, Defined in its module and type, and its doc comment
  as Markdown, the text inko doc reads (a trait's for an implementation
  without its own). For std, dependencies and the project; on a
  declaration's own name too. Sections are separated by ---; the type
  is still the first code block where there's an expression.
• textDocument/documentSymbol: types, traits, impl blocks,
  methods, fields, constructors and constants, nested, with their
  signatures as detail, from the syntax alone: in code that doesn't type
  check, and (from a copy with lines blank, repaired) in code that
  doesn't parse. SymbolInformation[] for clients without hierarchy.
• workspace/symbol: the same declarations of the project, its
  dependencies and std, matched as clients filter (the characters in
  order, any case), the project's first, at most 500. Fresh with every
  file on disk and open document; nothing is written.
• Completion of names: variables in scope, what self has, fields
  after @, what the module binds, types in a type's name; public
  symbols of modules not imported, with additionalTextEdits that add the
  import as inko fmt would; modules and symbols in an import. @ is a
  trigger character. Names are isIncomplete. In code being edited, names
  come only where no declaration differs.
• No new extension, and the patch is unchanged.

Each archive works with one Inko version, which its name says.
Machine-readable list of the builds, with sizes and SHA-256:
https://github.com/setdef/Cuttlebone/releases/download/v0.12.0/manifest.json
Every release, with its Inko versions and manifest:
https://github.com/setdef/Cuttlebone/releases/latest/download/index.json
(docs/releases.md).

Cuttlebone 0.11.0

Milestone 11: a license, a release index, and requests from a client's
reports. Report.

• License: MPL-2.0, as Inko's. LICENSE is at the repository's root,
  and every release archive now holds it beside the compiler's
  LICENSE-MPL-2.0.
• A release index, index.json, with each release, and at
  releases/latest/download/index.json: every release's version, the
  Inko versions it has builds for, and its manifest's URL, so a client
  can find a build for an older Inko (docs/releases.md).
  The manifest is unchanged.
• Declaration errors by ids. An error in a declaration no longer
  refuses code that only mentions its name by another symbol's id: with
  an error in A.size's signature, a method that only calls B.size is
  answered.
• An import of a module that doesn't exist (noHir) is blank in the
  repaired copy, so the rest of the file is answered, fresh and
  repaired, even before any good check. A whole import now counts only
  the names it binds, not its path's leading ones.
• Definition at c.value += 1 answers the setter and the getter, as
  a Location[]. Every other position still answers one Location.
• Saving keeps kept checks. A save (in place, or by renaming a new
  file over the old) no longer makes the next question a whole check.
• References at a declaration outside the project (std's, or a
  dependency's in dep/) answer the project's uses, instead of
  noHir or the declaring library's own.

Each archive works with one Inko version, which its name says.
Machine-readable list of the builds, with sizes and SHA-256:
https://github.com/setdef/Cuttlebone/releases/download/v0.11.0/manifest.json
Every release, with its Inko versions and manifest:
https://github.com/setdef/Cuttlebone/releases/latest/download/index.json
(docs/releases.md).

Cuttlebone 0.10.0

Milestone 10: prebuilt binaries.
Report.

• Prebuilt binaries for macOS and Linux, on AMD64 and ARM64 (Linux's
  static, for musl and glibc distributions alike), on each GitHub
  release, built by its own workflow. Each build works with one Inko
  version, which its name says.
• A manifest with each release (manifest.json): per build, the Inko
  version, target, URL, size and SHA-256, so a client can pick the build
  for the user's platform and Inko without scraping
  (docs/releases.md).
• No change to the server's behaviour.

Each archive works with one Inko version, which its name says.
Machine-readable list of the builds, with sizes and SHA-256:
https://github.com/setdef/Cuttlebone/releases/download/v0.10.0/manifest.json
(docs/releases.md).