refactor: get library from libpaths

config/config.go

@@ -13,11 +13,8 @@ type lspConfig struct {
 	Severity []string `json:"severity"`
 }
 
-type libPath string
-
 type Config struct {
-	Lsp     *lspConfig `json:"lsp"`
-	Library libPath    `json:"library"`
+	Lsp *lspConfig `json:"lsp"`
 }
 
 func makeConfigPath(conf string) string {
@@ -44,7 +41,6 @@ func hasConfig(conf string) bool {
 
 func ReadConfig() *Config {
 	configuration := &Config{
-		Library: "",
 		Lsp: &lspConfig{
 			When:     []string{"open", "save", "close", "text"},
 			Severity: []string{"fatal", "warn", "info", "hint"},

environment/environment.go

@@ -20,10 +20,10 @@ type Environment struct {
 	outer      *Environment
 }
 
-var library string
+var library []string
 
-func SetLibrary(path string) {
-	library = path
+func SetLibrary(paths []string) {
+	library = paths
 }
 
 func Enclose(outer *Environment, t ast.Types) *Environment {

environment/types.go

@@ -114,63 +114,63 @@ func isLoaded(library string) bool {
 	return false
 }
 
-func (env *Environment) LoadPackageTypes(pkg string) error {
-	if library == "" {
-		return nil
+func (env *Environment) LoadPackageTypes(pkg string) {
+	if len(library) == 0 {
+		return
 	}
 
 	if isLoaded(pkg) {
-		return nil
+		return
 	}
 
-	packagesLoaded = append(packagesLoaded, library)
+	packagesLoaded = append(packagesLoaded, pkg)
 
-	typeFile := path.Join(library, pkg, "types.vp")
+	for _, lib := range library {
+		typeFile := path.Join(lib, pkg, "types.vp")
 
-	if _, err := os.Stat(typeFile); errors.Is(err, os.ErrNotExist) {
-		return err
-	}
+		if _, err := os.Stat(typeFile); errors.Is(err, os.ErrNotExist) {
+			continue
+		}
 
-	content, err := os.ReadFile(typeFile)
+		content, err := os.ReadFile(typeFile)
 
-	if err != nil {
-		return err
-	}
+		if err != nil {
+			continue
+		}
 
-	// lex
-	l := lexer.NewCode(typeFile, string(content))
-	l.Run()
+		// lex
+		l := lexer.NewCode(typeFile, string(content))
+		l.Run()
 
-	if l.HasError() {
-		return errors.New("failed to lex types file")
-	}
+		if l.HasError() {
+			continue
+		}
 
-	// parse
-	p := parser.New(l)
-	prog := p.Run()
+		// parse
+		p := parser.New(l)
+		prog := p.Run()
 
-	if p.HasError() {
-		return errors.New("failed to lex types file")
-	}
+		if p.HasError() {
+			continue
+		}
 
-	// range over the Statements
-	// these should all be type declarations
-	for _, p := range prog.Statements {
-		switch node := p.(type) {
-		case *ast.TypeStatement:
-			env.SetType(
-				Type{
-					Token:      node.Token,
-					Type:       node.Type,
-					Attributes: node.Attributes,
-					Object:     node.Object,
-					Name:       node.Name,
-					Package:    pkg,
-					Used:       true,
-				},
-			)
+		// range over the Statements
+		// these should all be type declarations
+		for _, p := range prog.Statements {
+			switch node := p.(type) {
+			case *ast.TypeStatement:
+				env.SetType(
+					Type{
+						Token:      node.Token,
+						Type:       node.Type,
+						Attributes: node.Attributes,
+						Object:     node.Object,
+						Name:       node.Name,
+						Package:    pkg,
+						Used:       true,
+					},
+				)
+			}
 		}
 	}
-
-	return nil
 }

r/libpath.go

@@ -0,0 +1,24 @@
+package r
+
+import (
+	"encoding/json"
+)
+
+func LibPath() []string {
+	var paths []string
+	output, err := Callr(`paths <- paste0(.libPaths(), collapse = "\",\"")
+	paths <- paste0("[\"", paths, "\"]")
+	cat(paths)`)
+
+	if err != nil {
+		return paths
+	}
+
+	err = json.Unmarshal(output, &paths)
+
+	if err != nil {
+		return paths
+	}
+
+	return paths
+}

run.go

@@ -11,6 +11,7 @@ import (
 	"github.com/devOpifex/vapour/devtools"
 	"github.com/devOpifex/vapour/environment"
 	"github.com/devOpifex/vapour/lsp"
+	"github.com/devOpifex/vapour/r"
 )
 
 func run(code string) {
@@ -34,7 +35,7 @@ func run(code string) {
 func (v *vapour) Run(args cli.CLI) {
 	v.config = config.ReadConfig()
 
-	environment.SetLibrary(string(v.config.Library))
+	environment.SetLibrary(r.LibPath())
 
 	if *args.Indir != "" {
 		ok := v.transpile(args)

walker/walk.go

@@ -917,7 +917,7 @@ func (w *Walker) walkInfixExpressionNS(node *ast.InfixExpression, operator strin
 		)
 	}
 
-	_ = w.env.LoadPackageTypes(ln.Item().Value)
+	w.env.LoadPackageTypes(ln.Item().Value)
 
 	if node.Right == nil {
 		w.addFatalf(

walker/walk_test.go

@@ -5,8 +5,10 @@ import (
 	"testing"
 
 	"github.com/devOpifex/vapour/diagnostics"
+	"github.com/devOpifex/vapour/environment"
 	"github.com/devOpifex/vapour/lexer"
 	"github.com/devOpifex/vapour/parser"
+	"github.com/devOpifex/vapour/r"
 )
 
 func (w *Walker) testDiagnostics(t *testing.T, expected diagnostics.Diagnostics) {
@@ -1239,3 +1241,31 @@ print(c)
 
 	w.testDiagnostics(t, expected)
 }
+
+func TestTypeImport(t *testing.T) {
+	code := `
+let x: vape::user = vape::user(id = 1)
+
+let y: vape::user = vape::user(id = "char")
+let w: vape::user = vape::user(wrong = 2)
+`
+
+	l := lexer.NewTest(code)
+
+	l.Run()
+	p := parser.New(l)
+
+	prog := p.Run()
+
+	environment.SetLibrary(r.LibPath())
+	w := New()
+
+	w.Run(prog)
+
+	expected := diagnostics.Diagnostics{
+		{Severity: diagnostics.Fatal},
+		{Severity: diagnostics.Fatal},
+	}
+
+	w.testDiagnostics(t, expected)
+}