logic for typechecking

internal/lsp/check.go

@@ -0,0 +1,143 @@
+package lsp
+
+import (
+ "fmt"
+ "go/ast"
+ "go/parser"
+ "go/token"
+ "go/types"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/gnolang/gno/gnovm/pkg/gnomod"
+ "go.uber.org/multierr"
+)
+
+type FileInfo struct {
+ Name string
+ Body string
+}
+
+type PackageInfo struct {
+ Dir, ImportPath string
+ Files []*FileInfo
+}
+
+type PackageGetter interface {
+ GetPackageInfo(path string) *PackageInfo
+}
+
+func GetPackageInfo(path string) (*PackageInfo, error) {
+ // TODO: fix
+ if strings.HasPrefix(path, "/") {
+ // No op
+ } else if strings.HasPrefix(path, "gno.land/") {
+ path = "/Users/harry/Desktop/work/gno/examples/" + path
+ } else {
+ path = "/Users/harry/Desktop/work/gno/gnovm/stdlibs/" + path
+ }
+ return getPackageInfo(path)
+}
+
+func getPackageInfo(path string) (*PackageInfo, error) {
+ filenames, err := ListGnoFiles(path)
+ if err != nil {
+ return nil, err
+ }
+ var importpath string
+ gm, gmErr := gnomod.ParseAt(path)
+ if gmErr != nil {
+ importpath = "" // TODO
+ } else {
+ importpath = gm.Module.Mod.Path
+ }
+ files := []*FileInfo{}
+ for _, fname := range filenames {
+ if strings.HasSuffix(fname, "_test.gno") ||
+ strings.HasSuffix(fname, "_filetest.gno") {
+ continue
+ }
+ absPath, err := filepath.Abs(fname)
+ if err != nil {
+ return nil, err
+ }
+ bsrc, err := os.ReadFile(absPath)
+ if err != nil {
+ return nil, err
+ }
+ text := string(bsrc)
+ files = append(files, &FileInfo{Name: filepath.Base(fname), Body: text})
+ }
+ return &PackageInfo{
+ ImportPath: importpath,
+ Dir: path,
+ Files: files,
+ }, nil
+}
+
+type TypeCheckResult struct {
+ pkg *types.Package
+ fset *token.FileSet
+ files []*ast.File
+ info *types.Info
+ err error
+}
+
+type TypeCheck struct {
+ cache map[string]*TypeCheckResult
+ cfg *types.Config
+}
+
+// Unused, but satisfies the Importer interface.
+func (tc *TypeCheck) Import(path string) (*types.Package, error) {
+ return tc.ImportFrom(path, "", 0)
+}
+
+// ImportFrom returns the imported package for the given import
+// path when imported by a package file located in dir.
+func (tc *TypeCheck) ImportFrom(path, _ string, _ types.ImportMode) (*types.Package, error) {
+ if pkg, ok := tc.cache[path]; ok {
+ return pkg.pkg, pkg.err
+ }
+ pkg, err := GetPackageInfo(path)
+ if err != nil {
+ err := fmt.Errorf("package %q not found", path)
+ tc.cache[path] = &TypeCheckResult{err: err}
+ return nil, err
+ }
+ res := pkg.TypeCheck(tc)
+ tc.cache[path] = res
+ return res.pkg, res.err
+}
+
+func (pi *PackageInfo) TypeCheck(tc *TypeCheck) *TypeCheckResult {
+ fset := token.NewFileSet()
+ info := &types.Info{
+ Types: make(map[ast.Expr]types.TypeAndValue),
+ Defs: make(map[*ast.Ident]types.Object),
+ Uses: make(map[*ast.Ident]types.Object),
+ }
+ files := make([]*ast.File, 0, len(pi.Files))
+ var errs error
+ for _, f := range pi.Files {
+ if !strings.HasSuffix(f.Name, ".gno") ||
+ strings.HasSuffix(f.Name, "_filetest.gno") ||
+ strings.HasSuffix(f.Name, "_test.gno") {
+ continue
+ }
+
+ pgf, err := parser.ParseFile(fset, f.Name, f.Body, parser.ParseComments|parser.DeclarationErrors|parser.SkipObjectResolution)
+ if err != nil {
+ errs = multierr.Append(errs, err)
+ continue
+ }
+
+ files = append(files, pgf)
+ }
+ pkg, err := tc.cfg.Check(pi.ImportPath, fset, files, info)
+ if err != nil {
+ return &TypeCheckResult{err: err}
+ }
+ return &TypeCheckResult{pkg: pkg, fset: fset, files: files, info: info, err: nil}
+}