Tell lsp about variable bindings in match statements

lsp/nls/src/usage.rs

@@ -4,7 +4,7 @@ use nickel_lang_core::{
  environment::Environment as GenericEnvironment,
  identifier::Ident,
  position::RawSpan,
- term::{RichTerm, Term, Traverse, TraverseControl},
+ term::{MatchData, RichTerm, Term, Traverse, TraverseControl},
 };
 
 use crate::{field_walker::Def, identifier::LocIdent, pattern::Bindings};
@@ -90,6 +90,46 @@ impl UsageLookup {
  self.syms.insert(def.ident(), def);
  }
 
+ // In general, a match is like a function in that it needs to be applied before we
+ // know what's being matched on. So for example, in
+ // ```
+ // match { x => x.ba }
+ // ```
+ // we can't do much to auto-complete "ba". But it's very common in practice for the match to
+ // be applied immediately, like
+ // ```
+ // y |> match { x => x.ba }
+ // ```
+ // and in this case we can look into `y` to extract completions for "ba".
+ //
+ // This is a long-winded way of saying that we can treat pattern bindings like we treat
+ // function bindings (if we don't know where the application is) or like we treat let bindings
+ // (if we know what the match gets applied to). Here, `value` is the value that the match
+ // is applied to, if we know it.
+ fn fill_match(&mut self, env: &Environment, data: &MatchData, value: Option<&RichTerm>) {
+ for branch in &data.branches {
+ let mut new_env = env.clone();
+ for (path, ident, _field) in branch.pattern.bindings() {
+ let def = match value {
+ Some(v) => Def::Let {
+ ident: ident.into(),
+ value: v.clone(),
+ path: path.into_iter().map(|x| x.ident()).collect(),
+ },
+ None => Def::Fn {
+ ident: ident.into(),
+ },
+ };
+ new_env.insert_def(def.clone());
+ self.add_sym(def);
+ }
+ self.fill(&branch.body, &new_env);
+ if let Some(guard) = &branch.guard {
+ self.fill(guard, &new_env);
+ }
+ }
+ }
+
  fn fill(&mut self, rt: &RichTerm, env: &Environment) {
  rt.traverse_ref(
  &mut |term: &RichTerm, env: &Environment| {
@@ -162,6 +202,23 @@ impl UsageLookup {
 
  TraverseControl::ContinueWithScope(new_env)
  }
+ Term::App(f, value) => {
+ if let Term::Match(data) = f.as_ref() {
+ self.fill_match(env, data, Some(value));
+
+ // We've already traversed the branch bodies. We don't want to continue
+ // traversal because that will traverse them again. But we need to traverse
+ // the value we're matching on.
+ self.fill(value, env);
+ TraverseControl::SkipBranch
+ } else {
+ TraverseControl::Continue
+ }
+ }
+ Term::Match(data) => {
+ self.fill_match(env, data, None);
+ TraverseControl::SkipBranch
+ }
  Term::Var(id) => {
  let id = LocIdent::from(*id);
  if let Some(def) = env.get(&id.ident) {

lsp/nls/tests/inputs/completion-match-typed.ncl

@@ -0,0 +1,7 @@
+### /input.ncl
+fun x => match { y => y.fo }
+: { foo: Number, fo: Number } -> Number
+### [[request]]
+### type = "Completion"
+### textDocument.uri = "file:///input.ncl"
+### position = { line = 0, character = 26 }

lsp/nls/tests/inputs/completion-match.ncl

@@ -0,0 +1,37 @@
+### /input.ncl
+let p = 1 in
+{
+ foo = { bar = 1 },
+ baz,
+} |> match {
+ 'Bar payload => p,
+ x => x.foo.ba,
+ { foo = x } if x.ba == 1 => 3,
+ # In this next one, the match isn't applied so there will be no completions for the `blah`,
+ # but there should be a completion for `p`.
+ y => match { payload => p.blah },
+}
+### [[request]]
+### type = "Completion"
+### textDocument.uri = "file:///input.ncl"
+### position = { line = 5, character = 18 }
+###
+### [[request]]
+### type = "Completion"
+### textDocument.uri = "file:///input.ncl"
+### position = { line = 6, character = 14 }
+###
+### [[request]]
+### type = "Completion"
+### textDocument.uri = "file:///input.ncl"
+### position = { line = 7, character = 20 }
+###
+### [[request]]
+### type = "Completion"
+### textDocument.uri = "file:///input.ncl"
+### position = { line = 10, character = 26 }
+###
+### [[request]]
+### type = "Completion"
+### textDocument.uri = "file:///input.ncl"
+### position = { line = 10, character = 29 }

lsp/nls/tests/snapshots/main__lsp__nls__tests__inputs__completion-match-typed.ncl.snap

@@ -0,0 +1,5 @@
+---
+source: lsp/nls/tests/main.rs
+expression: output
+---
+[fo, foo]

lsp/nls/tests/snapshots/main__lsp__nls__tests__inputs__completion-match.ncl.snap

@@ -0,0 +1,9 @@
+---
+source: lsp/nls/tests/main.rs
+expression: output
+---
+[p, payload, std]
+[bar]
+[bar]
+[p, payload, std, y]
+[]