Merge pull request #570 from nevalang/fix_cli

fix(cli): use module root to correctly identify main pkg name (path)

.vscode/launch.json

@@ -19,8 +19,8 @@
  "request": "launch",
  "mode": "auto",
  "program": "${workspaceFolder}/cmd/neva",
- "cwd": "${workspaceFolder}",
- "args": ["run", "examples/struct_selector"]
+ "cwd": "${workspaceFolder}/e2e/run_cli_not_from_module_root/foo",
+ "args": ["run", "bar"]
  },
  // === LSP ===
  {

cmd/lsp/indexer/indexer.go

@@ -20,7 +20,7 @@ type Indexer struct {
 }
 
 func (i Indexer) FullIndex(ctx context.Context, path string) (src.Build, *compiler.Error, error) {
- rawBuild, err := i.builder.Build(ctx, path)
+ rawBuild, _, err := i.builder.Build(ctx, path)
  if err != nil {
  return src.Build{}, nil, fmt.Errorf("builder: %w", err)
  }

e2e/run_cli_not_from_module_root/e2e_test.go

@@ -0,0 +1,55 @@
+package test
+
+// in this file we test files designed specifically for e2e.
+
+import (
+ "os"
+ "os/exec"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+// Test that CLI will go from up to down and find module's manifest
+func Test_UpperThanManifest(t *testing.T) {
+ // go one level up (and go back after test is finished)
+ wd, err := os.Getwd()
+ require.NoError(t, err)
+ defer os.Chdir(wd)
+ require.NoError(t, os.Chdir(".."))
+
+ cmd := exec.Command("neva", "run", "run_cli_not_from_module_root/foo/bar")
+
+ out, err := cmd.CombinedOutput()
+ require.NoError(t, err)
+ require.Equal(
+ t,
+ "42\n",
+ string(out),
+ )
+
+ require.Equal(t, 0, cmd.ProcessState.ExitCode())
+}
+
+// Test that CLI will go from down to up and find module's manifest
+func Test_DownToManifest(t *testing.T) {
+ t.Skip() // FIXME https://github.com/nevalang/neva/issues/571
+
+ // go one level down (and go back after test is finished)
+ wd, err := os.Getwd()
+ require.NoError(t, err)
+ defer os.Chdir(wd)
+ require.NoError(t, os.Chdir("foo"))
+
+ cmd := exec.Command("neva", "run", "bar")
+
+ out, err := cmd.CombinedOutput()
+ require.NoError(t, err)
+ require.Equal(
+ t,
+ "42\n",
+ string(out),
+ )
+
+ require.Equal(t, 0, cmd.ProcessState.ExitCode())
+}

e2e/run_cli_not_from_module_root/foo/bar/main.neva

@@ -0,0 +1,4 @@
+component Main(start) (stop) {
+ nodes { Println }
+ net { :start -> (42 -> println -> :stop) }
+}

e2e/run_cli_not_from_module_root/neva.yml

@@ -0,0 +1 @@
+neva: 0.10.0

internal/builder/builder.go

@@ -26,11 +26,11 @@ type ManifestParser interface {
 func (b Builder) Build(
  ctx context.Context,
  wd string,
-) (compiler.RawBuild, *compiler.Error) {
+) (compiler.RawBuild, string, *compiler.Error) {
  // load entry module from disk
- entryMod, err := b.LoadModuleByPath(ctx, wd)
+ entryMod, entryModRootPath, err := b.LoadModuleByPath(ctx, wd)
  if err != nil {
- return compiler.RawBuild{}, &compiler.Error{
+ return compiler.RawBuild{}, "", &compiler.Error{
  Err: fmt.Errorf("build entry mod: %w", err),
  }
  }
@@ -48,9 +48,9 @@ func (b Builder) Build(
  }
 
  // load stdlib module
- stdMod, err := b.LoadModuleByPath(ctx, b.stdLibPath)
+ stdMod, _, err := b.LoadModuleByPath(ctx, b.stdLibPath)
  if err != nil {
- return compiler.RawBuild{}, &compiler.Error{
+ return compiler.RawBuild{}, "", &compiler.Error{
  Err: fmt.Errorf("build stdlib mod: %w", err),
  }
  }
@@ -60,7 +60,7 @@ func (b Builder) Build(
 
  release, err := acquireLockFile()
  if err != nil {
- return compiler.RawBuild{}, &compiler.Error{
+ return compiler.RawBuild{}, "", &compiler.Error{
  Err: fmt.Errorf("failed to acquire lock file: %w", err),
  }
  }
@@ -77,14 +77,14 @@ func (b Builder) Build(
 
  depWD, _, err := b.downloadDep(depModRef)
  if err != nil {
- return compiler.RawBuild{}, &compiler.Error{
+ return compiler.RawBuild{}, "", &compiler.Error{
  Err: fmt.Errorf("download dep: %w", err),
  }
  }
 
- depMod, err := b.LoadModuleByPath(ctx, depWD)
+ depMod, _, err := b.LoadModuleByPath(ctx, depWD)
  if err != nil {
- return compiler.RawBuild{}, &compiler.Error{
+ return compiler.RawBuild{}, "", &compiler.Error{
  Err: fmt.Errorf("build dep mod: %w", err),
  }
  }
@@ -103,7 +103,7 @@ func (b Builder) Build(
  return compiler.RawBuild{
  EntryModRef: src.ModuleRef{Path: "@"},
  Modules: mods,
- }, nil
+ }, entryModRootPath, nil
 }
 
 func getThirdPartyPath() (string, error) {

internal/builder/mod.go

@@ -15,21 +15,21 @@ import (
 func (p Builder) LoadModuleByPath(
  ctx context.Context,
  wd string,
-) (compiler.RawModule, error) {
+) (compiler.RawModule, string, error) {
  manifest, modRootPath, err := p.getNearestManifest(wd)
  if err != nil {
- return compiler.RawModule{}, fmt.Errorf("retrieve manifest: %w", err)
+ return compiler.RawModule{}, "", fmt.Errorf("retrieve manifest: %w", err)
  }
 
  pkgs := map[string]compiler.RawPackage{}
  if err := retrieveSourceCode(modRootPath, pkgs); err != nil {
- return compiler.RawModule{}, fmt.Errorf("walk: %w", err)
+ return compiler.RawModule{}, "", fmt.Errorf("walk: %w", err)
  }
 
  return compiler.RawModule{
  Manifest: manifest,
  Packages: pkgs,
- }, nil
+ }, modRootPath, nil
 }
 
 // retrieveSourceCode recursively walks the given tree and fills given pkgs with neva files

internal/builder/tests/intergration_test.go

@@ -13,7 +13,7 @@ func TestBuilder_WDIsModRoot(t *testing.T) {
  prsr := parser.New(false)
  bldr := builder.MustNew(prsr)
 
- build, err := bldr.Build(context.Background(), "testmod")
+ build, _, err := bldr.Build(context.Background(), "testmod")
  require.True(t, err == nil)
 
  mod, ok := build.Modules[build.EntryModRef]
@@ -36,7 +36,7 @@ func TestBuilder_WDIsPkg(t *testing.T) {
  prsr := parser.New(false)
  bldr := builder.MustNew(prsr)
 
- build, err := bldr.Build(context.Background(), "testmod/do_nothing")
+ build, _, err := bldr.Build(context.Background(), "testmod/do_nothing")
  require.True(t, err == nil)
 
  mod, ok := build.Modules[build.EntryModRef]

internal/compiler/compiler.go

@@ -31,15 +31,18 @@ func (c Compiler) Compile(
  return c.backend.Emit(dstPath, ir)
 }
 
-func (c Compiler) CompileToIR(whereCLIExecuted string, whereEntryPkg string) (*ir.Program, *Error) {
- rawBuild, err := c.builder.Build(
+func (c Compiler) CompileToIR(
+ wd string,
+ mainPkgPath string,
+) (*ir.Program, *Error) {
+ rawBuild, entryModRoot, err := c.builder.Build(
  context.Background(),
- whereEntryPkg,
+ mainPkgPath,
  )
  if err != nil {
  return nil, Error{
  Location: &sourcecode.Location{
- PkgName: whereEntryPkg,
+ PkgName: mainPkgPath,
  },
  }.Wrap(err)
  }
@@ -54,9 +57,13 @@ func (c Compiler) CompileToIR(whereCLIExecuted string, whereEntryPkg string) (*i
  Modules: parsedMods,
  }
 
- whereEntryPkg = strings.TrimPrefix(whereEntryPkg, "./")
+ mainPkgPath = strings.TrimPrefix(mainPkgPath, "./")
+ mainPkgPath = strings.TrimPrefix(mainPkgPath, entryModRoot+"/")
 
- analyzedBuild, err := c.analyzer.AnalyzeExecutableBuild(parsedBuild, whereEntryPkg)
+ analyzedBuild, err := c.analyzer.AnalyzeExecutableBuild(
+ parsedBuild,
+ mainPkgPath,
+ )
  if err != nil {
  return nil, err
  }
@@ -66,7 +73,7 @@ func (c Compiler) CompileToIR(whereCLIExecuted string, whereEntryPkg string) (*i
  return nil, err
  }
 
- irProg, err := c.irgen.Generate(desugaredBuild, whereEntryPkg)
+ irProg, err := c.irgen.Generate(desugaredBuild, mainPkgPath)
  if err != nil {
  return nil, err
  }

internal/compiler/contract.go

@@ -15,7 +15,7 @@ const (
 
 type (
  Builder interface {
- Build(ctx context.Context, wd string) (RawBuild, *Error)
+ Build(ctx context.Context, wd string) (RawBuild, string, *Error)
  }
 
  RawBuild struct {