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) {