Validate Mojo Patterns

Check Mojo code for correct usage of language patterns and conventions.

When to Use

• •Code review to catch pattern violations
• •Pre-commit validation of Mojo standards
• •Verifying constructor signatures are correct
• •Checking memory safety patterns
• •Validating trait conformances

Quick Reference

# Find incorrect constructor patterns
grep -n "fn __init__.*mut self\|fn __init__.*var self" *.mojo

# Find non-copyable returns without transfer
grep -n "-> List\|-> Dict\|-> String" *.mojo | grep -v "^"

# Check for deprecated patterns
grep -n "inout\|@value\|DynamicVector" *.mojo

# Verify trait conformances
grep -n "struct.*:" *.mojo | grep -v "Copyable\|Movable"

# Check method signatures
grep -n "fn.*self" *.mojo | grep -v "read\|mut\|var"

# Build package (validates all library files together)
mojo package shared

Pattern Validation Rules

Constructor Patterns:

• •✅ fn __init__(out self, ...) - Correct for constructors
• •✅ fn __moveinit__(out self, deinit existing: Self) - Move constructor
• •✅ fn __copyinit__(out self, existing: Self) - Copy constructor
• •❌ fn __init__(mut self, ...) - WRONG for constructors
• •❌ fn __init__(var self, ...) - WRONG for constructors

Method Patterns:

• •✅ fn method(self) -> Value - Read-only (implicit read)
• •✅ fn modify(mut self) - Mutable operations
• •✅ fn get_data(self) -> List[Int] - Return copyable
• •❌ fn modify(self) - Misleading (looks immutable)
• •❌ fn method(read self) - Unnecessary (implicit)

Ownership Patterns:

• •✅ fn take(var data: List[Int]) - Takes ownership
• •✅ return self.list^ - Transfer operator for non-copyable
• •✅ fn use(data: ExTensor) - Borrowed reference
• •❌ return self.list - Missing transfer for List
• •❌ fn take(data: List[Int]) - Ambiguous (appears borrowed)

Trait Conformances:

• •✅ struct Data(Copyable, Movable) - Value type traits
• •✅ struct Model(Copyable, Movable, Stringable) - With extras
• •❌ struct Data(Copyable) - Missing Movable
• •❌ struct Data(ImplicitlyCopyable) - Only for simple types

Validation Workflow

1. •Extract patterns: Find all fn signatures and struct definitions
2. •Categorize: Group by pattern type (constructors, methods, ownership)
3. •Validate: Check each against rules
4. •Identify violations: Mark incorrect patterns
5. •Suggest fixes: Provide correction for each violation
6. •Summarize: Report all pattern issues
7. •Verify: Use mojo package to validate packages, not mojo build on individual library files

v0.26.1 Validation Patterns

Relative imports are valid in library files, invalid in executables:

• •Library files (in shared/): Can use from ..module import X - part of package structure
• •Executable files (in examples/): Must use from shared.module import X with -I . flag

Use mojo package to validate packages:

• •Build entire package: mojo package shared
• •DO NOT validate individual library files: mojo build shared/core/__init__.mojo will fail with expected errors

Output Format

Report validation results with:

1. •Total Checks - Number of patterns validated
2. •Violations Found - Count of pattern violations
3. •Issues by Type - Grouped by pattern type
4. •Details - File, line, pattern, violation, fix
5. •Severity - Will break compilation or warning
6. •Summary - Pass/fail overall validation

Common Violations & Fixes

Issue: Constructor uses mut self

• •Location: fn __init__(mut self, ...)
• •Fix: Change to fn __init__(out self, ...)
• •Impact: Critical - won't compile

Issue: Missing transfer operator

• •Location: return self.data (where data is List/Dict)
• •Fix: Change to return self.data^
• •Impact: Critical - won't compile

Issue: Missing trait conformance

• •Location: struct Type(Copyable) (missing Movable)
• •Fix: Add struct Type(Copyable, Movable)
• •Impact: High - can cause use-after-move

Issue: ImplicitlyCopyable on non-trivial type

• •Location: struct Layer(ImplicitlyCopyable) with List fields
• •Fix: Remove ImplicitlyCopyable, use default traits
• •Impact: Critical - won't compile

Error Handling

References

• •See CLAUDE.md for complete pattern guidelines
• •See mojo-lint-syntax for syntax validation
• •See check-memory-safety for memory safety issues