Fix unused import detection in Cadence linter

Author: holyfuchs

internal/cadence/lint_test.go

@@ -89,6 +89,65 @@ func Test_Lint(t *testing.T) {
 		)
 	})
 
+	t.Run("detects unused import", func(t *testing.T) {
+		t.Parallel()
+
+		state := setupMockState(t)
+
+		results, err := lintFiles(state, false, "UnusedImport.cdc")
+		require.NoError(t, err)
+
+		require.Len(t, results.Results, 1)
+		require.Len(t, results.Results[0].Diagnostics, 1)
+
+		diagnostic := results.Results[0].Diagnostics[0]
+		require.Equal(t, "unused-import-hint", diagnostic.Category)
+		require.Equal(t, "unused import", diagnostic.Message)
+		require.Equal(t, 0, results.exitCode)
+	})
+
+	t.Run("detects unused contract-name import", func(t *testing.T) {
+		t.Parallel()
+
+		state := setupMockState(t)
+
+		results, err := lintFiles(state, false, "UnusedContractNameImport.cdc")
+		require.NoError(t, err)
+
+		require.Len(t, results.Results, 1)
+		require.Len(t, results.Results[0].Diagnostics, 1)
+
+		diagnostic := results.Results[0].Diagnostics[0]
+		require.Equal(t, "unused-import-hint", diagnostic.Category)
+		require.Equal(t, 0, results.exitCode)
+	})
+
+	t.Run("does not flag import used only in resource conformance", func(t *testing.T) {
+		t.Parallel()
+
+		state := setupMockState(t)
+
+		results, err := lintFiles(state, false, "ConformanceUser.cdc")
+		require.NoError(t, err)
+
+		require.Len(t, results.Results, 1)
+		require.Empty(t, results.Results[0].Diagnostics)
+		require.Equal(t, 0, results.exitCode)
+	})
+
+	t.Run("does not flag import used only in entitlement access specifier", func(t *testing.T) {
+		t.Parallel()
+
+		state := setupMockState(t)
+
+		results, err := lintFiles(state, false, "EntitlementUser.cdc")
+		require.NoError(t, err)
+
+		require.Len(t, results.Results, 1)
+		require.Empty(t, results.Results[0].Diagnostics)
+		require.Equal(t, 0, results.exitCode)
+	})
+
 	t.Run("lints multiple files", func(t *testing.T) {
 		t.Parallel()
 
@@ -503,6 +562,20 @@ func setupMockState(t *testing.T) *flowkit.State {
 	_ = afero.WriteFile(mockFs, "foo/WithImports.cdc", []byte(`
 	import "../NoError.cdc"
 	access(all) contract WithImports {
+		init() {
+			let _ = NoError.getType()
+		}
+	}
+	`), 0644)
+	_ = afero.WriteFile(mockFs, "UnusedImport.cdc", []byte(`
+	import "NoError.cdc"
+	access(all) contract UnusedImport {
+		init() {}
+	}
+	`), 0644)
+	_ = afero.WriteFile(mockFs, "UnusedContractNameImport.cdc", []byte(`
+	import "NoError"
+	access(all) contract UnusedContractNameImport {
 		init() {}
 	}
 	`), 0644)
@@ -636,6 +709,10 @@ func setupMockState(t *testing.T) *flowkit.State {
 		Name:     "ContractWithNestedImports",
 		Location: "ContractWithNestedImports.cdc",
 	})
+	state.Contracts().AddOrUpdate(config.Contract{
+		Name:     "Scheduler",
+		Location: "Scheduler.cdc",
+	})
 
 	return state
 }

internal/cadence/linter.go

@@ -42,10 +42,12 @@ import (
 )
 
 type linter struct {
-	checkers              map[string]*sema.Checker
-	state                 *flowkit.State
-	checkerStandardConfig *sema.Config
-	checkerScriptConfig   *sema.Config
+	checkers                map[string]*sema.Checker
+	exportedIdentifiers     map[string][]ast.Identifier
+	state                   *flowkit.State
+	checkerStandardConfig   *sema.Config
+	checkerScriptConfig     *sema.Config
+	currentLocation         common.Location
 }
 
 type positionedError interface {
@@ -64,8 +66,9 @@ var analyzers = maps.Values(cdclint.Analyzers)
 
 func newLinter(state *flowkit.State) *linter {
 	l := &linter{
-		checkers: make(map[string]*sema.Checker),
-		state:    state,
+		checkers:            make(map[string]*sema.Checker),
+		exportedIdentifiers: make(map[string][]ast.Identifier),
+		state:               state,
 	}
 
 	// Create checker configs for both standard and script
@@ -102,6 +105,8 @@ func (l *linter) lintCode(
 	diagnostics = make([]analysis.Diagnostic, 0)
 	codeStr := string(code)
 
+	l.currentLocation = location
+
 	// Parse program & convert any parsing errors to diagnostics
 	program, parseProgramErr := parser.ParseProgram(nil, code, parser.Config{})
 	if parseProgramErr != nil {
@@ -332,6 +337,7 @@ func (l *linter) newCheckerConfig(standardLibrary *util.StandardLibrary) *sema.C
 		PositionInfoEnabled:        true, // Must be enabled for linters
 		ExtendedElaborationEnabled: true, // Must be enabled for linters
 		ImportHandler:              l.handleImport,
+		LocationHandler:            l.resolveLocation,
 		SuggestionsEnabled:         true, // Must be enabled to offer semantic suggestions
 	}
 }
@@ -437,7 +443,13 @@ func (l *linter) handleImport(
 			}
 
 			l.checkers[filepath] = importedChecker
+			// Pre-populate so resolveLocation doesn't re-parse during sub-checking
+			l.exportedIdentifiers[filepath] = exportedIdentifiersFromProgram(importedProgram)
+
+			prevLocation := l.currentLocation
+			l.currentLocation = fileLocation
 			err = importedChecker.Check()
+			l.currentLocation = prevLocation
 			if err != nil {
 				return nil, err
 			}
@@ -474,6 +486,82 @@ func (l *linter) resolveImportFilepath(
 	}
 }
 
+// resolveLocation is the LocationHandler for the sema.Checker config.
+// For implicit imports (no explicit identifiers), it resolves the exported names
+// from the imported file so the unused-import analyzer can track usage.
+func (l *linter) resolveLocation(
+	identifiers []ast.Identifier,
+	location common.Location,
+) ([]sema.ResolvedLocation, error) {
+	defaultResolution := []sema.ResolvedLocation{{
+		Location:    location,
+		Identifiers: identifiers,
+	}}
+
+	// Explicit imports already carry their identifiers — nothing to add
+	if len(identifiers) > 0 {
+		return defaultResolution, nil
+	}
+
+	// Only handle string locations (path-based or contract-name imports)
+	if _, ok := location.(common.StringLocation); !ok {
+		return defaultResolution, nil
+	}
+
+	// Normalize relative path imports against the current file's location,
+	// then resolve to a file path (handles both .cdc paths and contract names)
+	resolvedLoc := location
+	if l.currentLocation != nil && util.IsPathLocation(location) {
+		resolvedLoc = util.NormalizePathLocation(l.currentLocation, location)
+	}
+
+	filePath, err := l.resolveImportFilepath(resolvedLoc, l.currentLocation)
+	if err != nil {
+		return defaultResolution, nil
+	}
+
+	exportedIdents := l.getExportedIdentifiers(filePath)
+	if len(exportedIdents) == 0 {
+		return defaultResolution, nil
+	}
+
+	return []sema.ResolvedLocation{{
+		Location:    location,
+		Identifiers: exportedIdents,
+	}}, nil
+}
+
+func (l *linter) getExportedIdentifiers(filePath string) []ast.Identifier {
+	if cached, ok := l.exportedIdentifiers[filePath]; ok {
+		return cached
+	}
+
+	code, err := l.state.ReadFile(filePath)
+	if err != nil {
+		return nil
+	}
+
+	program, err := parser.ParseProgram(nil, code, parser.Config{})
+	if err != nil || program == nil {
+		return nil
+	}
+
+	identifiers := exportedIdentifiersFromProgram(program)
+	l.exportedIdentifiers[filePath] = identifiers
+	return identifiers
+}
+
+func exportedIdentifiersFromProgram(program *ast.Program) []ast.Identifier {
+	var identifiers []ast.Identifier
+	for _, decl := range program.CompositeDeclarations() {
+		identifiers = append(identifiers, decl.Identifier)
+	}
+	for _, decl := range program.InterfaceDeclarations() {
+		identifiers = append(identifiers, decl.Identifier)
+	}
+	return identifiers
+}
+
 // helpers
 
 func getDiagnosticsFromParentError(err cdcerrors.ParentError, location common.Location, code string) ([]analysis.Diagnostic, error) {