refactor: variable rename

gabotechs · Dec 25, 2023 · 4dcb843 · 4dcb843
1 parent f451fd7
commit 4dcb843
Show file tree

Hide file tree

Showing 7 changed files with 22 additions and 26 deletions.
diff --git a/internal/language/exports.go b/internal/language/exports.go
@@ -49,7 +49,7 @@ type ExportsResult struct {
 
 type parseExportsKey string
 
-func (p *Parser[F]) ParseExports(
+func (p *Parser[F]) parseExports(
 	ctx context.Context,
 	id string,
 	unwrappedExports bool,
@@ -140,14 +140,13 @@ func (p *Parser[F]) gatherExportsFromFile(
 	if cached, ok := ctx.Value(cacheKey).(*ExportsEntries); ok {
 		return ctx, cached, nil
 	}
-	ctx, file, err := p.CachedParseFile(ctx, filePath)
+	ctx, file, err := p.parseFile(ctx, filePath)
 	if err != nil {
 		return ctx, nil, err
 	}
 	result, err := p.lang.ParseExports(file)
 	if err != nil {
 		return ctx, nil, err
 	}
-	ctx = context.WithValue(ctx, cacheKey, result)
-	return ctx, result, err
+	return context.WithValue(ctx, cacheKey, result), result, err
 }
diff --git a/internal/language/exports_test.go b/internal/language/exports_test.go
@@ -229,12 +229,12 @@ func TestParser_CachedUnwrappedParseExports(t *testing.T) {
 			}
 			parser := lang.testParser(tt.Path)
 
-			_, exports, err := parser.ParseExports(context.Background(), "1", true)
+			_, exports, err := parser.parseExports(context.Background(), "1", true)
 			a.NoError(err)
 
 			a.Equal(tt.ExpectedUnwrapped, exports.Exports)
 
-			_, exports, err = parser.ParseExports(context.Background(), "1", false)
+			_, exports, err = parser.parseExports(context.Background(), "1", false)
 			a.NoError(err)
 
 			a.Equal(tt.ExpectedWrapped, exports.Exports)

diff --git a/internal/language/file.go b/internal/language/file.go
@@ -4,16 +4,14 @@ import "context"
 
 type FileCacheKey string
 
-func (p *Parser[F]) CachedParseFile(ctx context.Context, id string) (context.Context, *F, error) {
+func (p *Parser[F]) parseFile(ctx context.Context, id string) (context.Context, *F, error) {
 	cacheKey := FileCacheKey(id)
 	if cached, ok := ctx.Value(cacheKey).(*F); ok {
 		return ctx, cached, nil
-	} else {
-		result, err := p.lang.ParseFile(id)
-		if err != nil {
-			return ctx, nil, err
-		}
-		ctx = context.WithValue(ctx, cacheKey, result)
-		return ctx, result, err
 	}
+	result, err := p.lang.ParseFile(id)
+	if err != nil {
+		return ctx, nil, err
+	}
+	return context.WithValue(ctx, cacheKey, result), result, err
 }
diff --git a/internal/language/file_test.go b/internal/language/file_test.go
@@ -16,12 +16,12 @@ func TestParser_parseFile_IsCached(t *testing.T) {
 	parser := lang.testParser("1")
 
 	start := time.Now()
-	ctx, _, err := parser.CachedParseFile(ctx, "1")
+	ctx, _, err := parser.parseFile(ctx, "1")
 	a.NoError(err)
 	nonCached := time.Since(start)
 
 	start = time.Now()
-	_, _, err = parser.CachedParseFile(ctx, "1")
+	_, _, err = parser.parseFile(ctx, "1")
 	a.NoError(err)
 	cached := time.Since(start)
 

diff --git a/internal/language/imports.go b/internal/language/imports.go
@@ -23,22 +23,21 @@ type ImportsResult struct {
 
 type ImportsCacheKey string
 
-func (p *Parser[F]) CachedParseImports(
+func (p *Parser[F]) gatherImportsFromFile(
 	ctx context.Context,
 	id string,
 ) (context.Context, *ImportsResult, error) {
 	cacheKey := ImportsCacheKey(id)
 	if cached, ok := ctx.Value(cacheKey).(*ImportsResult); ok {
 		return ctx, cached, nil
 	}
-	ctx, file, err := p.CachedParseFile(ctx, id)
+	ctx, file, err := p.parseFile(ctx, id)
 	if err != nil {
 		return ctx, nil, err
 	}
 	result, err := p.lang.ParseImports(file)
 	if err != nil {
 		return ctx, nil, err
 	}
-	ctx = context.WithValue(ctx, cacheKey, result)
-	return ctx, result, err
+	return context.WithValue(ctx, cacheKey, result), result, err
 }
diff --git a/internal/language/imports_test.go b/internal/language/imports_test.go
@@ -23,12 +23,12 @@ func TestParser_parseImports_IsCached(t *testing.T) {
 	parser := lang.testParser("1")
 
 	start := time.Now()
-	ctx, _, err := parser.CachedParseImports(ctx, "1")
+	ctx, _, err := parser.gatherImportsFromFile(ctx, "1")
 	a.NoError(err)
 	nonCached := time.Since(start)
 
 	start = time.Now()
-	_, _, err = parser.CachedParseImports(ctx, "1")
+	_, _, err = parser.gatherImportsFromFile(ctx, "1")
 	a.NoError(err)
 	cached := time.Since(start)
 

diff --git a/internal/language/parser.go b/internal/language/parser.go
@@ -104,7 +104,7 @@ func (p *Parser[F]) Entrypoint() (*Node, error) {
 }
 
 func (p *Parser[F]) updateNodeInfo(ctx context.Context, n *Node) (context.Context, error) {
-	ctx, file, err := p.CachedParseFile(ctx, n.Id)
+	ctx, file, err := p.parseFile(ctx, n.Id)
 	if err != nil {
 		return ctx, err
 	}
@@ -115,7 +115,7 @@ func (p *Parser[F]) updateNodeInfo(ctx context.Context, n *Node) (context.Contex
 
 func (p *Parser[F]) Deps(ctx context.Context, n *Node) (context.Context, []*Node, error) {
 	ctx, _ = p.updateNodeInfo(ctx, n)
-	ctx, imports, err := p.CachedParseImports(ctx, n.Id)
+	ctx, imports, err := p.gatherImportsFromFile(ctx, n.Id)
 	if err != nil {
 		return ctx, nil, err
 	}
@@ -136,7 +136,7 @@ func (p *Parser[F]) Deps(ctx context.Context, n *Node) (context.Context, []*Node
 		//  technically is true, but it's not true to say that `foo` is imported from `bar.ts`.
 		//  It's more accurate to say that `bar` is imported from `bar.ts`, even if the alias is `foo`.
 		//  Instead we never unwrap export to avoid this.
-		ctx, exports, err = p.ParseExports(ctx, n.Id, false)
+		ctx, exports, err = p.parseExports(ctx, n.Id, false)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -161,7 +161,7 @@ func (p *Parser[F]) Deps(ctx context.Context, n *Node) (context.Context, []*Node
 		}
 
 		var exports *ExportsResult
-		ctx, exports, err = p.ParseExports(ctx, importEntry.Path, true)
+		ctx, exports, err = p.parseExports(ctx, importEntry.Path, true)
 		if err != nil {
 			return ctx, nil, err
 		}