ask for init if current folder is not an initialized root module

internal/terraform/exec/exec.go

@@ -87,6 +87,17 @@ func (e *Executor) setLogPath(method string) error {
  return e.tf.SetLogPath(logPath)
 }
 
+func (e *Executor) Init(ctx context.Context) error {
+ ctx, cancel := e.withTimeout(ctx)
+ defer cancel()
+ err := e.setLogPath("Init")
+ if err != nil {
+ return err
+ }
+
+ return e.contextfulError(ctx, "Init", e.tf.Init(ctx))
+}
+
 func (e *Executor) Format(ctx context.Context, input []byte) ([]byte, error) {
  ctx, cancel := e.withTimeout(ctx)
  defer cancel()

internal/terraform/exec/types.go

@@ -22,6 +22,7 @@ type TerraformExecutor interface {
  SetExecLogPath(path string) error
  SetTimeout(duration time.Duration)
  GetExecPath() string
+ Init(ctx context.Context) error
  Format(ctx context.Context, input []byte) ([]byte, error)
  Version(ctx context.Context) (*version.Version, error)
  ProviderSchemas(ctx context.Context) (*tfjson.ProviderSchemas, error)

internal/terraform/rootmodule/root_module.go

@@ -302,6 +302,16 @@ func (rm *rootModule) discoverTerraformExecutor(ctx context.Context) error {
  return nil
 }
 
+func (rm *rootModule) ExecuteTerraformInit(ctx context.Context) error {
+ if !rm.IsTerraformAvailable() {
+ if err := rm.discoverTerraformExecutor(ctx); err != nil {
+ return err
+ }
+ }
+
+ return rm.tfExec.Init(ctx)
+}
+
 func (rm *rootModule) discoverTerraformVersion(ctx context.Context) error {
  if rm.tfExec == nil {
  return errors.New("no terraform executor - unable to read version")

internal/terraform/rootmodule/root_module_manager.go

@@ -98,6 +98,21 @@ func (rmm *rootModuleManager) SetLogger(logger *log.Logger) {
  rmm.logger = logger
 }
 
+func (rmm *rootModuleManager) InitAndUpdateRootModule(ctx context.Context, dir string) (RootModule, error) {
+ rm, err := rmm.RootModuleByPath(dir)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get root module: %+v", err)
+ }
+
+ if err := rm.ExecuteTerraformInit(ctx); err != nil {
+ return nil, fmt.Errorf("failed to init root module: %+v", err)
+ }
+
+ rootModule := rm.(*rootModule)
+ rootModule.discoverCaches(ctx, dir)
+ return rm, rootModule.UpdateProviderSchemaCache(ctx, rootModule.pluginLockFile)
+}
+
 func (rmm *rootModuleManager) AddAndStartLoadingRootModule(ctx context.Context, dir string) (RootModule, error) {
  dir = filepath.Clean(dir)
 

internal/terraform/rootmodule/types.go

@@ -40,6 +40,7 @@ type RootModuleManager interface {
  SetTerraformExecLogPath(logPath string)
  SetTerraformExecTimeout(timeout time.Duration)
 
+ InitAndUpdateRootModule(ctx context.Context, dir string) (RootModule, error)
  AddAndStartLoadingRootModule(ctx context.Context, dir string) (RootModule, error)
  WorkerPoolSize() int
  WorkerQueueSize() int
@@ -81,6 +82,7 @@ type RootModule interface {
  TerraformFormatter() (exec.Formatter, error)
  HasTerraformDiscoveryFinished() bool
  IsTerraformAvailable() bool
+ ExecuteTerraformInit(ctx context.Context) error
  Modules() []ModuleRecord
 }
 

langserver/handlers/did_open.go

@@ -3,13 +3,15 @@ package handlers
 import (
  "context"
  "fmt"
+ "log"
  "path/filepath"
  "strings"
 
  "github.com/creachadair/jrpc2"
  lsctx "github.com/hashicorp/terraform-ls/internal/context"
  ilsp "github.com/hashicorp/terraform-ls/internal/lsp"
  "github.com/hashicorp/terraform-ls/internal/terraform/rootmodule"
+ "github.com/hashicorp/terraform-ls/internal/watcher"
  lsp "github.com/sourcegraph/go-lsp"
 )
 
@@ -42,6 +44,11 @@ func (lh *logHandler) TextDocumentDidOpen(ctx context.Context, params lsp.DidOpe
  return err
  }
 
+ w, err := lsctx.Watcher(ctx)
+ if err != nil {
+ return err
+ }
+
  rootDir, _ := lsctx.RootDirectory(ctx)
  readableDir := humanReadablePath(rootDir, f.Dir())
 
@@ -78,16 +85,10 @@ func (lh *logHandler) TextDocumentDidOpen(ctx context.Context, params lsp.DidOpe
  lh.logger.Printf("walker has not finished walking yet, data may be inaccurate for %s", f.FullPath())
  } else if len(candidates) == 0 {
  // TODO: Only notify once per f.Dir() per session
- msg := fmt.Sprintf("No root module found for %q."+
- " Functionality may be limited."+
- // Unfortunately we can't be any more specific wrt where
- // because we don't gather "init-able folders" in any way
- " You may need to run terraform init"+
- " and reload your editor.", readableDir)
- return jrpc2.PushNotify(ctx, "window/showMessage", lsp.ShowMessageParams{
- Type: lsp.MTWarning,
- Message: msg,
- })
+ // TODO: if there is any change for the provider/module, ask for init. The did change handler should also implement this
+ if !rm.ParsedDiagnostics().HasErrors() && len(f.Text()) != 0 {
+ go askInitForEmptyRootModule(ctx, lh.logger, w, rootDir, f.Dir())
+ }
  }
 
  if len(candidates) > 1 {
@@ -134,3 +135,50 @@ func humanReadablePath(rootDir, path string) string {
 
  return relDir
 }
+
+func askInitForEmptyRootModule(ctx context.Context, logger *log.Logger, w watcher.Watcher, rootDir, dir string) {
+ msg := fmt.Sprintf("No root module found for %q."+
+ " Functionality may be limited."+
+ // Unfortunately we can't be any more specific wrt where
+ // because we don't gather "init-able folders" in any way
+ " You may need to run terraform init.", humanReadablePath(rootDir, dir))
+ title := "run `terraform init`"
+ resp, err := jrpc2.PushCall(ctx, "window/showMessageRequest", lsp.ShowMessageRequestParams{
+ Type: lsp.MTWarning,
+ Message: msg,
+ Actions: []lsp.MessageActionItem{
+ {
+ Title: title,
+ },
+ },
+ })
+ if err != nil {
+ logger.Printf("%+v", err)
+ return
+ }
+ var action lsp.MessageActionItem
+ if err := resp.UnmarshalResult(&action); err != nil {
+ logger.Printf("unmarshal MessageActionItem: %+v", err)
+ return
+ }
+ if action.Title == title {
+ rmm, err := lsctx.RootModuleManager(ctx)
+ if err != nil {
+ logger.Printf("%+v", err)
+ return
+ }
+
+ rm, err := rmm.InitAndUpdateRootModule(ctx, dir)
+ if err != nil {
+ logger.Printf("failed to init root module %+v", err)
+ return
+ }
+
+ paths := rm.PathsToWatch()
+ logger.Printf("Adding %d paths of root module for watching (%s)", len(paths), dir)
+ err = w.AddPaths(paths)
+ if err != nil {
+ logger.Printf("failed to add watch for dir (%s): %+v", dir, err)
+ }
+ }
+}

langserver/handlers/service.go

@@ -192,6 +192,7 @@ func (svc *service) Assigner() (jrpc2.Assigner, error) {
  ctx = lsctx.WithRootDirectory(ctx, &rootDir)
  ctx = lsctx.WithRootModuleManager(ctx, svc.modMgr)
  ctx = lsctx.WithRootModuleWalker(ctx, svc.walker)
+ ctx = lsctx.WithWatcher(ctx, ww)
  return handle(ctx, req, lh.TextDocumentDidOpen)
  },
  "textDocument/didClose": func(ctx context.Context, req *jrpc2.Request) (interface{}, error) {