nixd: path completion

libnixf/src/Parse/Lexer.cpp

@@ -220,6 +220,8 @@ bool Lexer::consumePathStart() {
   // And also check if it contains a slash.
   LexerCursor Saved = cur();
 
+  bool IsStartedWithDot = peek() == '.';
+
   // {PATH_CHAR}*
   consumeManyPathChar();
 
@@ -233,6 +235,10 @@ bool Lexer::consumePathStart() {
     // This should be parsed as path-interpolation.
     if (peekPrefix("${"))
       return true;
+    // Or, look back to see if is a './'.
+    // This should be parsed as path
+    if (IsStartedWithDot)
+      return true;
   }
 
   // Otherwise, it is not a path, restore cursor.

libnixf/test/Parse/Lexer.cpp

@@ -1,8 +1,10 @@
 #include <gtest/gtest.h>
 
 #include "Lexer.h"
+#include "Token.h"
 
 #include "nixf/Basic/Diagnostic.h"
+#include "nixf/Basic/TokenKinds.h"
 
 #include <cstddef>
 
@@ -173,6 +175,18 @@ TEST_F(LexerTest, lexIDPath) {
   ASSERT_EQ(Tokens.size(), sizeof(Match) / sizeof(TokenKind));
 }
 
+TEST_F(LexerTest, lexPathStart) {
+  Lexer Lexer(R"(./)", Diags);
+  const TokenKind Match[] = {
+      tok_path_fragment,
+  };
+  auto Tokens = collect(Lexer, &Lexer::lex);
+  for (size_t I = 0; I < sizeof(Match) / sizeof(TokenKind); I++) {
+    ASSERT_EQ(Tokens[I].kind(), Match[I]);
+  }
+  ASSERT_EQ(Tokens.size(), sizeof(Match) / sizeof(TokenKind));
+}
+
 TEST_F(LexerTest, lexKW) {
   // FIXME: test  pp//a to see that we can lex this as Update(pp, a)
   Lexer Lexer(R"(if then)", Diags);

nixd/lib/Controller/Completion.cpp

@@ -12,6 +12,8 @@
 
 #include <boost/asio/post.hpp>
 
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/Path.h>
 #include <semaphore>
 #include <set>
 #include <utility>
@@ -250,6 +252,43 @@ class OptionCompletionProvider {
   }
 };
 
+void completeExprPath(const std::string &CurFilePath,
+                      const nixf::ExprPath &ExprPath,
+                      std::vector<CompletionItem> &Items) {
+  using namespace llvm::sys;
+
+  if (!ExprPath.parts().isLiteral()) {
+    return;
+  }
+
+  const auto &PathLiteral = ExprPath.parts().literal();
+  if (PathLiteral.empty()) {
+    return;
+  }
+
+  llvm::SmallVector<char, 32> Path{PathLiteral.begin(), PathLiteral.end()};
+  if (PathLiteral[0] == '.') {
+    const auto &CurFileDir = path::parent_path(CurFilePath);
+    fs::make_absolute(CurFileDir, Path);
+  }
+
+  if (fs::exists(Path) && fs::is_directory(Path)) {
+    std::error_code EC;
+    for (auto Iter = fs::directory_iterator(Path, EC, false);
+         Iter != fs::directory_iterator(); Iter.increment(EC)) {
+      if (EC) {
+        vlog("failed to read directory: {0}", EC.message());
+        break;
+      }
+      addItem(Items, CompletionItem{
+                         .label = path::filename(Iter->path()).str(),
+                         .kind = CompletionItemKind::File,
+                         .data = ExprPath.parts().literal(),
+                     });
+    }
+  }
+}
+
 void completeAttrName(const std::vector<std::string> &Scope,
                       const std::string &Prefix,
                       Controller::OptionMapTy &Options, bool CompletionSnippets,
@@ -299,15 +338,24 @@ void Controller::onCompletion(const CompletionParams &Params,
                                ClientCaps.CompletionSnippets, List.items);
             }
           } else {
-            const VariableLookupAnalysis &VLA = *TU->variableLookup();
-            VLACompletionProvider VLAP(VLA);
-            VLAP.complete(*Desc, List.items, PM);
-            if (havePackageScope(*Desc, VLA, PM)) {
-              // Append it with nixpkgs completion
-              // FIXME: handle null nixpkgsClient()
-              NixpkgsCompletionProvider NCP(*nixpkgsClient());
-              auto [Scope, Prefix] = getScopeAndPrefix(*Desc, PM);
-              NCP.completePackages(Scope, Prefix, List.items);
+            const auto *Parent = PM.upExpr(*Desc);
+            // if we are in a literal path, use PathCompletionProvider
+            if (Parent->kind() == Node::NK_ExprPath) {
+              const auto &Path = static_cast<const nixf::ExprPath &>(*Parent);
+              if (Path.parts().isLiteral()) {
+                completeExprPath(File, Path, List.items);
+              }
+            } else {
+              const VariableLookupAnalysis &VLA = *TU->variableLookup();
+              VLACompletionProvider VLAP(VLA);
+              VLAP.complete(*Desc, List.items, PM);
+              if (havePackageScope(*Desc, VLA, PM)) {
+                // Append it with nixpkgs completion
+                // FIXME: handle null nixpkgsClient()
+                NixpkgsCompletionProvider NCP(*nixpkgsClient());
+                auto [Scope, Prefix] = getScopeAndPrefix(*Desc, PM);
+                NCP.completePackages(Scope, Prefix, List.items);
+              }
             }
           }
           // Next, add nixpkgs provided names.

nixd/tools/nixd/test/completion-path.md

@@ -0,0 +1,79 @@
+# RUN: sed "s|ROOT|%S|g" < %s | nixd --lit-test | FileCheck %s
+
+<-- initialize(0)
+
+```json
+{
+   "jsonrpc":"2.0",
+   "id":0,
+   "method":"initialize",
+   "params":{
+      "processId":123,
+      "rootPath":"",
+      "capabilities": {
+      },
+      "trace":"off"
+   }
+}
+```
+
+
+<-- textDocument/didOpen
+
+
+```json
+{
+   "jsonrpc":"2.0",
+   "method":"textDocument/didOpen",
+   "params":{
+      "textDocument":{
+         "uri":"file://ROOT/completion-path-root/main.nix",
+         "languageId":"nix",
+         "version":1,
+         "text":"{ bar = ./ }"
+      }
+   }
+}
+```
+
+```json
+{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "textDocument/completion",
+    "params": {
+        "textDocument": {
+            "uri": "file://ROOT/completion-path-root/main.nix"
+        },
+        "position": {
+            "line": 0,
+            "character": 9
+        },
+        "context": {
+            "triggerKind": 1,
+            "triggerCharacter": "/"
+        }
+    }
+}
+```
+
+```
+     CHECK:   "id": 1,
+CHECK-NEXT:   "jsonrpc": "2.0",
+CHECK-NEXT:   "result": {
+CHECK-NEXT:     "isIncomplete": false,
+CHECK-NEXT:     "items": [
+CHECK-NEXT:       {
+CHECK-NEXT:         "data": "./",
+CHECK-NEXT:         "kind": 17,
+CHECK-NEXT:         "label": "main.nix",
+CHECK-NEXT:         "score": 0
+CHECK-NEXT:       }
+CHECK-NEXT:     ]
+CHECK-NEXT:   }
+```
+
+
+```json
+{"jsonrpc":"2.0","method":"exit"}
+```