Add cadence_lint tool using AST-based cadence-tools analyzers

Author: peterargue

internal/mcp/lint.go

@@ -0,0 +1,181 @@
+/*
+ * Flow CLI
+ *
+ * Copyright Flow Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mcp
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	cdclint "github.com/onflow/cadence-tools/lint"
+	cdctests "github.com/onflow/cadence-tools/test/helpers"
+	"github.com/onflow/cadence/ast"
+	"github.com/onflow/cadence/common"
+	cdcerrors "github.com/onflow/cadence/errors"
+	"github.com/onflow/cadence/parser"
+	"github.com/onflow/cadence/sema"
+	"github.com/onflow/cadence/stdlib"
+	"github.com/onflow/cadence/tools/analysis"
+	"golang.org/x/exp/maps"
+
+	"github.com/onflow/flow-cli/internal/util"
+)
+
+// lintCode runs all registered cadence-tools lint analyzers on the given code.
+// Returns analysis diagnostics (not LSP protocol diagnostics).
+func lintCode(code string) ([]analysis.Diagnostic, error) {
+	location := common.StringLocation("code.cdc")
+	codeBytes := []byte(code)
+
+	// Parse
+	program, parseErr := parser.ParseProgram(nil, codeBytes, parser.Config{})
+	if parseErr != nil {
+		var parentErr cdcerrors.ParentError
+		if errors.As(parseErr, &parentErr) {
+			return collectPositionedErrors(parentErr, location), nil
+		}
+		return nil, fmt.Errorf("parse error: %w", parseErr)
+	}
+	if program == nil {
+		return nil, nil
+	}
+
+	// Choose standard library based on program type
+	var stdLib *util.StandardLibrary
+	if program.SoleTransactionDeclaration() != nil || program.SoleContractDeclaration() != nil {
+		stdLib = util.NewStandardLibrary()
+	} else {
+		stdLib = util.NewScriptStandardLibrary()
+	}
+
+	checkerConfig := &sema.Config{
+		BaseValueActivationHandler: func(_ common.Location) *sema.VariableActivation {
+			return stdLib.BaseValueActivation
+		},
+		AccessCheckMode:            sema.AccessCheckModeNotSpecifiedUnrestricted,
+		PositionInfoEnabled:        true,
+		ExtendedElaborationEnabled: true,
+		ImportHandler:              lintImportHandler,
+	}
+
+	// Type check
+	checker, err := sema.NewChecker(program, location, nil, checkerConfig)
+	if err != nil {
+		return nil, fmt.Errorf("checker creation error: %w", err)
+	}
+
+	var diagnostics []analysis.Diagnostic
+
+	checkErr := checker.Check()
+	if checkErr != nil {
+		var checkerErr *sema.CheckerError
+		if errors.As(checkErr, &checkerErr) {
+			diagnostics = append(diagnostics, collectPositionedErrors(checkerErr, location)...)
+		}
+	}
+
+	// Run lint analyzers
+	analyzers := maps.Values(cdclint.Analyzers)
+	analysisProgram := analysis.Program{
+		Program:  program,
+		Checker:  checker,
+		Location: location,
+		Code:     codeBytes,
+	}
+	analysisProgram.Run(analyzers, func(d analysis.Diagnostic) {
+		diagnostics = append(diagnostics, d)
+	})
+
+	return diagnostics, nil
+}
+
+// lintImportHandler resolves standard library imports for lint analysis.
+func lintImportHandler(
+	checker *sema.Checker,
+	importedLocation common.Location,
+	_ ast.Range,
+) (sema.Import, error) {
+	switch importedLocation {
+	case stdlib.TestContractLocation:
+		return sema.ElaborationImport{
+			Elaboration: stdlib.GetTestContractType().Checker.Elaboration,
+		}, nil
+	case cdctests.BlockchainHelpersLocation:
+		return sema.ElaborationImport{
+			Elaboration: cdctests.BlockchainHelpersChecker().Elaboration,
+		}, nil
+	default:
+		return nil, fmt.Errorf("cannot resolve import: %s", importedLocation)
+	}
+}
+
+type positionedError interface {
+	error
+	ast.HasPosition
+}
+
+// collectPositionedErrors extracts positioned errors from a parent error.
+func collectPositionedErrors(err cdcerrors.ParentError, location common.Location) []analysis.Diagnostic {
+	var diagnostics []analysis.Diagnostic
+	for _, childErr := range err.ChildErrors() {
+		var posErr positionedError
+		if !errors.As(childErr, &posErr) {
+			continue
+		}
+		diagnostics = append(diagnostics, analysis.Diagnostic{
+			Location: location,
+			Category: "error",
+			Message:  posErr.Error(),
+			Range: ast.Range{
+				StartPos: posErr.StartPosition(),
+				EndPos:   posErr.EndPosition(nil),
+			},
+		})
+	}
+	return diagnostics
+}
+
+// formatLintDiagnostics formats analysis diagnostics as human-readable text.
+func formatLintDiagnostics(diagnostics []analysis.Diagnostic) string {
+	if len(diagnostics) == 0 {
+		return "Lint passed — no issues found."
+	}
+
+	var b strings.Builder
+	errors := 0
+	warnings := 0
+	for _, d := range diagnostics {
+		severity := "warning"
+		if d.Category == "error" || d.Category == "semantic-error" || d.Category == "syntax-error" {
+			severity = "error"
+			errors++
+		} else {
+			warnings++
+		}
+		fmt.Fprintf(&b, "[%s] line %d:%d (%s): %s\n",
+			severity,
+			d.Range.StartPos.Line,
+			d.Range.StartPos.Column,
+			d.Category,
+			d.Message,
+		)
+	}
+	fmt.Fprintf(&b, "\n%d error(s), %d warning(s)\n", errors, warnings)
+	return b.String()
+}

internal/mcp/lint_test.go

@@ -0,0 +1,89 @@
+/*
+ * Flow CLI
+ *
+ * Copyright Flow Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package mcp
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLintCode_ValidCode(t *testing.T) {
+	t.Parallel()
+
+	code := `access(all) fun main(): String { return "hello" }`
+	diags, err := lintCode(code)
+	require.NoError(t, err)
+	// Valid code should only have lint hints, no errors
+	for _, d := range diags {
+		assert.NotEqual(t, "error", d.Category)
+		assert.NotEqual(t, "semantic-error", d.Category)
+		assert.NotEqual(t, "syntax-error", d.Category)
+	}
+}
+
+func TestLintCode_SyntaxError(t *testing.T) {
+	t.Parallel()
+
+	code := `access(all) fun main( {`
+	diags, err := lintCode(code)
+	require.NoError(t, err)
+	assert.NotEmpty(t, diags, "syntax errors should produce diagnostics")
+}
+
+func TestLintCode_TypeError(t *testing.T) {
+	t.Parallel()
+
+	code := `access(all) fun main(): String { return 42 }`
+	diags, err := lintCode(code)
+	require.NoError(t, err)
+	assert.NotEmpty(t, diags, "type errors should produce diagnostics")
+
+	hasError := false
+	for _, d := range diags {
+		if d.Category == "error" || d.Category == "semantic-error" {
+			hasError = true
+		}
+	}
+	assert.True(t, hasError, "should have error-level diagnostics")
+}
+
+func TestLintCode_AnalyzersRun(t *testing.T) {
+	t.Parallel()
+
+	// Redundant cast should be detected by lint analyzers
+	code := `
+		access(all) fun main(): Int {
+			let x: Int = 42
+			return x as Int
+		}
+	`
+	diags, err := lintCode(code)
+	require.NoError(t, err)
+	// Should have at least one lint diagnostic (redundant cast or similar)
+	assert.NotEmpty(t, diags, "lint analyzers should produce diagnostics for redundant cast")
+}
+
+func TestFormatLintDiagnostics_Empty(t *testing.T) {
+	t.Parallel()
+
+	result := formatLintDiagnostics(nil)
+	assert.Contains(t, result, "Lint passed")
+}

internal/mcp/mcp.go

@@ -62,6 +62,7 @@ Available tools:
   cadence_completion     Get completions at a position
   get_contract_source    Fetch on-chain contract manifest
   get_contract_code      Fetch contract source code from an address
+  cadence_lint           Run Cadence lint analyzers (AST-based)
   cadence_code_review    Review Cadence code for common issues
   cadence_execute_script Execute a read-only Cadence script on-chain`,
 	Run: runMCP,

internal/mcp/tools.go

@@ -129,6 +129,14 @@ func registerTools(s *mcpserver.MCPServer, mctx *mcpContext) {
 		mctx.getContractCode,
 	)
 
+	s.AddTool(
+		mcplib.NewTool("cadence_lint",
+			mcplib.WithDescription("Run Cadence lint analyzers on code. Detects common issues like unnecessary casts, deprecated patterns, unused variables, and more using AST-based analysis."),
+			mcplib.WithString("code", mcplib.Required(), mcplib.Description("Cadence source code to lint")),
+		),
+		mctx.cadenceLint,
+	)
+
 	s.AddTool(
 		mcplib.NewTool("cadence_code_review",
 			mcplib.WithDescription("Review Cadence code for common issues and anti-patterns."),
@@ -361,6 +369,19 @@ func (m *mcpContext) getContractCode(ctx context.Context, req mcplib.CallToolReq
 	return mcplib.NewToolResultText(b.String()), nil
 }
 
+func (m *mcpContext) cadenceLint(_ context.Context, req mcplib.CallToolRequest) (*mcplib.CallToolResult, error) {
+	code, err := resolveCode(req)
+	if err != nil {
+		return mcplib.NewToolResultError(err.Error()), nil
+	}
+
+	diagnostics, err := lintCode(code)
+	if err != nil {
+		return mcplib.NewToolResultError(fmt.Sprintf("lint failed: %v", err)), nil
+	}
+	return mcplib.NewToolResultText(formatLintDiagnostics(diagnostics)), nil
+}
+
 func (m *mcpContext) cadenceCodeReview(_ context.Context, req mcplib.CallToolRequest) (*mcplib.CallToolResult, error) {
 	code, err := resolveCode(req)
 	if err != nil {