feat(tfsearch): TF-26847 TF-27074: Added: init search feature

Author: anubhav-goel

internal/features/search/ast/search.go

@@ -0,0 +1,119 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package ast
+
+import (
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+	globalAst "github.com/hashicorp/terraform-ls/internal/terraform/ast"
+)
+
+type Filename interface {
+	String() string
+	IsJSON() bool
+	IsIgnored() bool
+}
+
+// SearchFilename is a custom type for search configuration files
+type SearchFilename string
+
+func (mf SearchFilename) String() string {
+	return string(mf)
+}
+
+func (mf SearchFilename) IsJSON() bool {
+	return strings.HasSuffix(string(mf), ".json")
+}
+
+func (mf SearchFilename) IsIgnored() bool {
+	return globalAst.IsIgnoredFile(string(mf))
+}
+
+func IsSearchFilename(name string) bool {
+	return strings.HasSuffix(name, ".tfquery.hcl") ||
+		strings.HasSuffix(name, ".tfquery.json")
+}
+
+// FilenameFromName returns a valid SearchFilename
+func FilenameFromName(name string) Filename {
+	if IsSearchFilename(name) {
+		return SearchFilename(name)
+	}
+
+	return nil
+}
+
+type Files map[Filename]*hcl.File
+
+func (sf Files) Copy() Files {
+	m := make(Files, len(sf))
+	for name, file := range sf {
+		m[name] = file
+	}
+	return m
+}
+
+func (mf Files) AsMap() map[string]*hcl.File {
+	m := make(map[string]*hcl.File, len(mf))
+	for name, file := range mf {
+		m[name.String()] = file
+	}
+	return m
+}
+
+type Diagnostics map[Filename]hcl.Diagnostics
+
+func (sd Diagnostics) Copy() Diagnostics {
+	m := make(Diagnostics, len(sd))
+	for name, diags := range sd {
+		m[name] = diags
+	}
+	return m
+}
+
+// AutoloadedOnly returns only diagnostics that are not from ignored files
+func (sd Diagnostics) AutoloadedOnly() Diagnostics {
+	diags := make(Diagnostics)
+	for name, f := range sd {
+		if !name.IsIgnored() {
+			diags[name] = f
+		}
+	}
+	return diags
+}
+
+func (sd Diagnostics) AsMap() map[string]hcl.Diagnostics {
+	m := make(map[string]hcl.Diagnostics, len(sd))
+	for name, diags := range sd {
+		m[name.String()] = diags
+	}
+	return m
+}
+
+func (sd Diagnostics) Count() int {
+	count := 0
+	for _, diags := range sd {
+		count += len(diags)
+	}
+	return count
+}
+
+func DiagnosticsFromMap(m map[string]hcl.Diagnostics) Diagnostics {
+	mf := make(Diagnostics, len(m))
+	for name, file := range m {
+		mf[FilenameFromName(name)] = file
+	}
+	return mf
+}
+
+type SourceDiagnostics map[globalAst.DiagnosticSource]Diagnostics
+
+func (svd SourceDiagnostics) Count() int {
+	count := 0
+	for _, diags := range svd {
+		count += diags.Count()
+	}
+	return count
+}

internal/features/search/decoder/path_reader.go

@@ -0,0 +1,160 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package decoder
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/go-version"
+	"github.com/hashicorp/hcl-lang/decoder"
+	"github.com/hashicorp/hcl-lang/lang"
+	"github.com/hashicorp/hcl-lang/reference"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/terraform-ls/internal/features/search/ast"
+	"github.com/hashicorp/terraform-ls/internal/features/search/state"
+	ilsp "github.com/hashicorp/terraform-ls/internal/lsp"
+	tfaddr "github.com/hashicorp/terraform-registry-address"
+	tfmod "github.com/hashicorp/terraform-schema/module"
+	tfschema "github.com/hashicorp/terraform-schema/schema"
+	searchSchema "github.com/hashicorp/terraform-schema/schema/search"
+	tfsearch "github.com/hashicorp/terraform-schema/search"
+)
+
+type PathReader struct {
+	StateReader  StateReader
+	ModuleReader ModuleReader
+	RootReader   RootReader
+}
+
+var _ decoder.PathReader = &PathReader{}
+
+type CombinedReader struct {
+	ModuleReader
+	StateReader
+	RootReader
+}
+
+type StateReader interface {
+	List() ([]*state.SearchRecord, error)
+	SearchRecordByPath(modPath string) (*state.SearchRecord, error)
+	ProviderSchema(modPath string, addr tfaddr.Provider, vc version.Constraints) (*tfschema.ProviderSchema, error)
+}
+
+type ModuleReader interface {
+	// LocalModuleMeta returns the module meta data for a local module. This is the result
+	// of the [earlydecoder] when processing module files
+	LocalModuleMeta(modPath string) (*tfmod.Meta, error)
+}
+
+type RootReader interface {
+	InstalledModulePath(rootPath string, normalizedSource string) (string, bool)
+}
+
+// PathContext returns a PathContext for the given path based on the language ID
+func (pr *PathReader) PathContext(path lang.Path) (*decoder.PathContext, error) {
+	record, err := pr.StateReader.SearchRecordByPath(path.Path)
+	if err != nil {
+		return nil, err
+	}
+
+	switch path.LanguageID {
+	case ilsp.Search.String():
+		return searchPathContext(record, CombinedReader{
+			StateReader:  pr.StateReader,
+			ModuleReader: pr.ModuleReader,
+			RootReader:   pr.RootReader,
+		})
+	}
+
+	return nil, fmt.Errorf("unknown language ID: %q", path.LanguageID)
+}
+
+func searchPathContext(record *state.SearchRecord, stateReader CombinedReader) (*decoder.PathContext, error) {
+	// TODO: this should only work for terraform 1.8 and above
+	version := record.RequiredTerraformVersion
+	if version == nil {
+		version = tfschema.LatestAvailableVersion
+	}
+
+	schema, err := searchSchema.CoreSearchSchemaForVersion(version)
+	if err != nil {
+		return nil, err
+	}
+
+	sm := searchSchema.NewSearchSchemaMerger(schema)
+	sm.SetStateReader(stateReader)
+
+	meta := &tfsearch.Meta{
+		Path:      record.Path(),
+		Lists:     record.Meta.Lists,
+		Variables: record.Meta.Variables,
+		Filenames: record.Meta.Filenames,
+	}
+
+	mergedSchema, err := sm.SchemaForSearch(meta)
+	if err != nil {
+		return nil, err
+	}
+
+	pathCtx := &decoder.PathContext{
+		Schema:           mergedSchema,
+		ReferenceOrigins: make(reference.Origins, 0),
+		ReferenceTargets: make(reference.Targets, 0),
+		Files:            make(map[string]*hcl.File, 0),
+		Validators:       searchValidators,
+	}
+
+	// TODO: Add reference origins and targets if needed
+	for _, origin := range record.RefOrigins {
+		if ast.IsSearchFilename(origin.OriginRange().Filename) {
+			pathCtx.ReferenceOrigins = append(pathCtx.ReferenceOrigins, origin)
+		}
+	}
+
+	for _, target := range record.RefTargets {
+		if target.RangePtr != nil && ast.IsSearchFilename(target.RangePtr.Filename) {
+			pathCtx.ReferenceTargets = append(pathCtx.ReferenceTargets, target)
+		} else if target.RangePtr == nil {
+			pathCtx.ReferenceTargets = append(pathCtx.ReferenceTargets, target)
+		}
+	}
+
+	for name, f := range record.ParsedFiles {
+		if _, ok := name.(ast.SearchFilename); ok {
+			pathCtx.Files[name.String()] = f
+		}
+	}
+
+	return pathCtx, nil
+}
+
+func (pr *PathReader) Paths(ctx context.Context) []lang.Path {
+	paths := make([]lang.Path, 0)
+
+	searchRecords, err := pr.StateReader.List()
+	if err != nil {
+		return paths
+	}
+
+	for _, record := range searchRecords {
+		foundSearch := false
+		for name := range record.ParsedFiles {
+			if _, ok := name.(ast.SearchFilename); ok {
+				foundSearch = true
+			}
+
+		}
+
+		if foundSearch {
+			paths = append(paths, lang.Path{
+				Path:       record.Path(),
+				LanguageID: ilsp.Search.String(),
+			})
+		}
+
+	}
+
+	return paths
+}

internal/features/search/decoder/validators.go

@@ -0,0 +1,19 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package decoder
+
+import (
+	"github.com/hashicorp/hcl-lang/validator"
+)
+
+var searchValidators = []validator.Validator{
+	validator.BlockLabelsLength{},
+	validator.DeprecatedAttribute{},
+	validator.DeprecatedBlock{},
+	validator.MaxBlocks{},
+	validator.MinBlocks{},
+	validator.MissingRequiredAttribute{},
+	validator.UnexpectedAttribute{},
+	validator.UnexpectedBlock{},
+}