quantrs2_circuit/linter/
types.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4
5use crate::builder::Circuit;
6use crate::scirs2_integration::{AnalyzerConfig, GraphMetrics, GraphMotif, SciRS2CircuitAnalyzer};
7use quantrs2_core::{
8    error::{QuantRS2Error, QuantRS2Result},
9    gate::GateOp,
10    qubit::QubitId,
11};
12use serde::{Deserialize, Serialize};
13use std::collections::{HashMap, HashSet, VecDeque};
14use std::sync::{Arc, RwLock};
15use std::time::{Duration, Instant, SystemTime};
16
17/// Best practice rules
18#[derive(Debug, Clone, Serialize, Deserialize)]
19pub enum BestPracticeRule {
20    /// Proper error handling
21    ErrorHandling {
22        required_error_handling: Vec<String>,
23    },
24    /// Resource management
25    ResourceManagement {
26        max_resource_usage: HashMap<String, f64>,
27    },
28    /// Documentation standards
29    Documentation {
30        min_documentation_coverage: f64,
31        required_documentation_types: Vec<String>,
32    },
33    /// Testing requirements
34    Testing {
35        min_test_coverage: f64,
36        required_test_types: Vec<String>,
37    },
38    /// Performance guidelines
39    Performance {
40        performance_targets: HashMap<String, f64>,
41    },
42    /// Security practices
43    Security { security_requirements: Vec<String> },
44    /// Maintainability practices
45    Maintainability {
46        maintainability_metrics: HashMap<String, f64>,
47    },
48}
49/// Importance levels
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub enum Importance {
52    /// Low importance
53    Low,
54    /// Medium importance
55    Medium,
56    /// High importance
57    High,
58    /// Critical importance
59    Critical,
60}
61/// Pattern analysis result
62#[derive(Debug, Clone, Serialize, Deserialize)]
63pub struct PatternAnalysisResult {
64    /// Detected patterns
65    pub detected_patterns: Vec<PatternDetectionResult>,
66    /// Pattern interactions
67    pub pattern_interactions: Vec<PatternInteraction>,
68    /// Overall pattern score
69    pub pattern_score: f64,
70    /// Pattern diversity
71    pub pattern_diversity: f64,
72}
73/// Style checker for quantum circuits
74pub struct StyleChecker<const N: usize> {
75    /// Style rules
76    rules: Vec<StyleRule>,
77    /// Checking results
78    results: HashMap<String, StyleCheckResult>,
79    /// Style configuration
80    config: StyleConfig,
81}
82impl<const N: usize> StyleChecker<N> {
83    /// Create new style checker
84    #[must_use]
85    pub fn new() -> Self {
86        Self {
87            rules: Vec::new(),
88            results: HashMap::new(),
89            config: StyleConfig {
90                enabled_rules: Vec::new(),
91                custom_settings: HashMap::new(),
92                strictness: StyleStrictness::Moderate,
93                suggest_auto_format: true,
94            },
95        }
96    }
97    /// Check all style rules
98    pub const fn check_all_styles(
99        &self,
100        circuit: &Circuit<N>,
101        config: &LinterConfig,
102    ) -> QuantRS2Result<(Vec<LintIssue>, StyleAnalysisResult)> {
103        let issues = Vec::new();
104        let analysis = StyleAnalysisResult {
105            overall_score: 1.0,
106            check_results: Vec::new(),
107            consistency_score: 1.0,
108            readability_score: 1.0,
109        };
110        Ok((issues, analysis))
111    }
112}
113/// Complexity analysis result
114#[derive(Debug, Clone, Serialize, Deserialize)]
115pub struct ComplexityAnalysisResult {
116    /// Complexity metrics
117    pub metrics: ComplexityMetrics,
118    /// Complexity trends
119    pub trends: Vec<ComplexityTrend>,
120    /// Simplification suggestions
121    pub simplification_suggestions: Vec<SimplificationSuggestion>,
122}
123/// Circuit location
124#[derive(Debug, Clone, Serialize, Deserialize)]
125pub struct CircuitLocation {
126    /// Gate index range
127    pub gate_range: (usize, usize),
128    /// Affected qubits
129    pub qubits: Vec<usize>,
130    /// Circuit depth range
131    pub depth_range: (usize, usize),
132    /// Line/column information if available
133    pub line_col: Option<(usize, usize)>,
134}
135/// Indentation styles
136#[derive(Debug, Clone, Serialize, Deserialize)]
137pub enum IndentationStyle {
138    /// Spaces
139    Spaces { count: usize },
140    /// Tabs
141    Tabs,
142    /// Mixed
143    Mixed { tab_size: usize },
144}
145/// Anti-pattern detection result
146#[derive(Debug, Clone, Serialize, Deserialize)]
147pub struct AntiPatternDetectionResult {
148    /// Anti-pattern name
149    pub antipattern_name: String,
150    /// Detection confidence
151    pub confidence: f64,
152    /// Anti-pattern locations
153    pub locations: Vec<CircuitLocation>,
154    /// Severity assessment
155    pub severity: Severity,
156    /// Performance cost
157    pub performance_cost: PerformanceImpact,
158    /// Suggested remediation
159    pub remediation: String,
160}
161/// Parameter constraints
162#[derive(Debug, Clone, Serialize, Deserialize)]
163pub struct ParameterConstraint {
164    /// Parameter name
165    pub parameter: String,
166    /// Constraint type
167    pub constraint: ConstraintType,
168    /// Constraint value
169    pub value: f64,
170    /// Tolerance
171    pub tolerance: f64,
172}
173/// Style violation
174#[derive(Debug, Clone, Serialize, Deserialize)]
175pub struct StyleViolation {
176    /// Violation type
177    pub violation_type: String,
178    /// Location
179    pub location: CircuitLocation,
180    /// Description
181    pub description: String,
182    /// Suggested fix
183    pub suggested_fix: String,
184    /// Auto-fixable
185    pub auto_fixable: bool,
186}
187/// Custom guideline
188#[derive(Debug, Clone, Serialize, Deserialize)]
189pub struct CustomGuideline {
190    /// Guideline name
191    pub name: String,
192    /// Description
193    pub description: String,
194    /// Importance level
195    pub importance: Importance,
196    /// Compliance checker
197    pub checker: String,
198}
199/// Compliance levels
200#[derive(Debug, Clone, Serialize, Deserialize)]
201pub enum ComplianceLevel {
202    /// Excellent compliance
203    Excellent,
204    /// Good compliance
205    Good,
206    /// Fair compliance
207    Fair,
208    /// Poor compliance
209    Poor,
210    /// Non-compliant
211    NonCompliant,
212}
213/// Qubit ordering styles
214#[derive(Debug, Clone, Serialize, Deserialize)]
215pub enum QubitOrderingStyle {
216    /// Sequential (0, 1, 2, ...)
217    Sequential,
218    /// Reverse sequential
219    ReverseSequential,
220    /// Logical ordering
221    Logical,
222    /// Custom ordering
223    Custom { ordering: Vec<usize> },
224}
225/// Performance projection after optimization
226#[derive(Debug, Clone, Serialize, Deserialize)]
227pub struct PerformanceProjection {
228    /// Current performance
229    pub current_performance: PerformanceMetrics,
230    /// Projected performance
231    pub projected_performance: PerformanceMetrics,
232    /// Improvement confidence
233    pub improvement_confidence: f64,
234}
235/// Risk levels
236#[derive(Debug, Clone, Serialize, Deserialize)]
237pub enum Risk {
238    /// Low risk
239    Low,
240    /// Medium risk
241    Medium,
242    /// High risk
243    High,
244    /// Very high risk
245    VeryHigh,
246}
247/// Individual lint issue
248#[derive(Debug, Clone, Serialize, Deserialize)]
249pub struct LintIssue {
250    /// Issue type
251    pub issue_type: IssueType,
252    /// Severity level
253    pub severity: Severity,
254    /// Issue title
255    pub title: String,
256    /// Detailed description
257    pub description: String,
258    /// Location in circuit
259    pub location: CircuitLocation,
260    /// Suggested fix
261    pub suggested_fix: Option<String>,
262    /// Auto-fix available
263    pub auto_fixable: bool,
264    /// Rule that triggered this issue
265    pub rule_id: String,
266    /// Confidence score
267    pub confidence: f64,
268    /// Performance impact
269    pub performance_impact: Option<PerformanceImpact>,
270}
271/// Pattern flexibility settings
272#[derive(Debug, Clone, Serialize, Deserialize)]
273pub struct PatternFlexibility {
274    /// Allow gate reordering
275    pub allow_reordering: bool,
276    /// Allow additional gates
277    pub allow_additional_gates: bool,
278    /// Allow parameter variations
279    pub allow_parameter_variations: bool,
280    /// Maximum pattern distance
281    pub max_distance: usize,
282}
283/// Style rules
284#[derive(Debug, Clone, Serialize, Deserialize)]
285pub enum StyleRule {
286    /// Consistent gate naming
287    ConsistentGateNaming { naming_convention: NamingConvention },
288    /// Proper qubit ordering
289    ProperQubitOrdering { ordering_style: QubitOrderingStyle },
290    /// Circuit formatting
291    CircuitFormatting {
292        max_line_length: usize,
293        indentation_style: IndentationStyle,
294    },
295    /// Comment requirements
296    CommentRequirements {
297        min_comment_density: f64,
298        required_sections: Vec<String>,
299    },
300    /// Gate grouping
301    GateGrouping { grouping_style: GateGroupingStyle },
302    /// Parameter formatting
303    ParameterFormatting {
304        precision: usize,
305        scientific_notation_threshold: f64,
306    },
307    /// Measurement placement
308    MeasurementPlacement {
309        placement_style: MeasurementPlacementStyle,
310    },
311    /// Barrier usage
312    BarrierUsage { usage_style: BarrierUsageStyle },
313}
314/// Scaling behavior
315#[derive(Debug, Clone, Serialize, Deserialize)]
316pub struct ScalingBehavior {
317    /// Time complexity
318    pub time_complexity: String,
319    /// Space complexity
320    pub space_complexity: String,
321    /// Scaling exponent
322    pub scaling_exponent: f64,
323    /// Scaling confidence
324    pub scaling_confidence: f64,
325}
326/// Simplification suggestion
327#[derive(Debug, Clone, Serialize, Deserialize)]
328pub struct SimplificationSuggestion {
329    /// Simplification type
330    pub simplification_type: SimplificationType,
331    /// Target location
332    pub location: CircuitLocation,
333    /// Expected complexity reduction
334    pub complexity_reduction: f64,
335    /// Implementation strategy
336    pub strategy: String,
337    /// Risk assessment
338    pub risk: Risk,
339}
340/// Complexity classification
341#[derive(Debug, Clone, Serialize, Deserialize)]
342pub enum ComplexityClassification {
343    /// Low complexity
344    Low,
345    /// Medium complexity
346    Medium,
347    /// High complexity
348    High,
349    /// Very high complexity
350    VeryHigh,
351    /// Intractable complexity
352    Intractable,
353}
354/// Constraint types
355#[derive(Debug, Clone, Serialize, Deserialize)]
356pub enum ConstraintType {
357    /// Equal to value
358    Equal,
359    /// Less than value
360    LessThan,
361    /// Greater than value
362    GreaterThan,
363    /// Between two values
364    Between { min: f64, max: f64 },
365    /// Multiple of value
366    MultipleOf,
367}
368/// Pattern detector for quantum circuits
369pub struct PatternDetector<const N: usize> {
370    /// Patterns to detect
371    patterns: Vec<QuantumPattern<N>>,
372    /// Pattern detection results
373    detection_results: HashMap<String, PatternDetectionResult>,
374    /// `SciRS2` analyzer
375    analyzer: SciRS2CircuitAnalyzer,
376}
377impl<const N: usize> PatternDetector<N> {
378    /// Create new pattern detector
379    #[must_use]
380    pub fn new() -> Self {
381        Self {
382            patterns: Vec::new(),
383            detection_results: HashMap::new(),
384            analyzer: SciRS2CircuitAnalyzer::new(),
385        }
386    }
387    /// Detect all patterns
388    pub const fn detect_all_patterns(
389        &self,
390        circuit: &Circuit<N>,
391        config: &LinterConfig,
392    ) -> QuantRS2Result<PatternAnalysisResult> {
393        Ok(PatternAnalysisResult {
394            detected_patterns: Vec::new(),
395            pattern_interactions: Vec::new(),
396            pattern_score: 1.0,
397            pattern_diversity: 0.0,
398        })
399    }
400}
401/// Pattern statistics
402#[derive(Debug, Clone, Serialize, Deserialize)]
403pub struct PatternStatistics {
404    /// Number of occurrences
405    pub occurrences: usize,
406    /// Total gates involved
407    pub total_gates: usize,
408    /// Pattern coverage
409    pub coverage: f64,
410    /// Pattern complexity
411    pub complexity: f64,
412    /// Pattern efficiency
413    pub efficiency: f64,
414}
415/// Implementation difficulty levels
416#[derive(Debug, Clone, Serialize, Deserialize)]
417pub enum Difficulty {
418    /// Easy to implement
419    Easy,
420    /// Moderate difficulty
421    Moderate,
422    /// Hard to implement
423    Hard,
424    /// Expert level required
425    Expert,
426}
427/// Optimization analysis result
428#[derive(Debug, Clone, Serialize, Deserialize)]
429pub struct OptimizationAnalysisResult {
430    /// Optimization opportunities found
431    pub opportunities: Vec<OptimizationSuggestion>,
432    /// Overall optimization potential
433    pub optimization_potential: f64,
434    /// Recommended optimizations
435    pub recommended_optimizations: Vec<String>,
436    /// Performance projection
437    pub performance_projection: PerformanceProjection,
438}
439/// Practice guidelines
440#[derive(Debug, Clone, Serialize, Deserialize)]
441pub struct PracticeGuidelines {
442    /// Industry standards
443    pub industry_standards: Vec<String>,
444    /// Custom guidelines
445    pub custom_guidelines: Vec<CustomGuideline>,
446    /// Compliance requirements
447    pub compliance_requirements: Vec<String>,
448}
449/// Style analysis result
450#[derive(Debug, Clone, Serialize, Deserialize)]
451pub struct StyleAnalysisResult {
452    /// Overall style score
453    pub overall_score: f64,
454    /// Style check results
455    pub check_results: Vec<StyleCheckResult>,
456    /// Style consistency
457    pub consistency_score: f64,
458    /// Readability score
459    pub readability_score: f64,
460}
461/// Auto-fix types
462#[derive(Debug, Clone, Serialize, Deserialize)]
463pub enum AutoFixType {
464    /// Simple text replacement
465    TextReplacement,
466    /// Gate substitution
467    GateSubstitution,
468    /// Code restructuring
469    Restructuring,
470    /// Parameter adjustment
471    ParameterAdjustment,
472    /// Format correction
473    FormatCorrection,
474}
475/// Style strictness levels
476#[derive(Debug, Clone, Serialize, Deserialize)]
477pub enum StyleStrictness {
478    /// Lenient style checking
479    Lenient,
480    /// Moderate style checking
481    Moderate,
482    /// Strict style checking
483    Strict,
484    /// Pedantic style checking
485    Pedantic,
486}
487/// Pattern matcher for custom patterns
488#[derive(Debug, Clone, Serialize, Deserialize)]
489pub struct PatternMatcher {
490    /// Gate sequence pattern
491    pub gate_sequence: Vec<String>,
492    /// Qubit connectivity requirements
493    pub connectivity: ConnectivityPattern,
494    /// Parameter constraints
495    pub parameter_constraints: Vec<ParameterConstraint>,
496    /// Flexibility settings
497    pub flexibility: PatternFlexibility,
498}
499/// Performance metrics
500#[derive(Debug, Clone, Serialize, Deserialize)]
501pub struct PerformanceMetrics {
502    /// Gate count
503    pub gate_count: usize,
504    /// Circuit depth
505    pub circuit_depth: usize,
506    /// Execution time estimate
507    pub execution_time: Duration,
508    /// Memory usage estimate
509    pub memory_usage: usize,
510    /// Error rate estimate
511    pub error_rate: f64,
512    /// Quantum volume
513    pub quantum_volume: f64,
514}
515/// Safety levels for auto-fixes
516#[derive(Debug, Clone, Serialize, Deserialize)]
517pub enum SafetyLevel {
518    /// Safe to apply automatically
519    Safe,
520    /// Review recommended
521    ReviewRecommended,
522    /// Manual review required
523    ManualReviewRequired,
524    /// Unsafe for automatic application
525    Unsafe,
526}
527/// Pattern performance profile
528#[derive(Debug, Clone, Serialize, Deserialize)]
529pub struct PatternPerformanceProfile {
530    /// Execution time estimate
531    pub execution_time: Duration,
532    /// Memory requirement
533    pub memory_requirement: usize,
534    /// Error susceptibility
535    pub error_susceptibility: f64,
536    /// Optimization potential
537    pub optimization_potential: f64,
538}
539/// Optimization suggestion
540#[derive(Debug, Clone, Serialize, Deserialize)]
541pub struct OptimizationSuggestion {
542    /// Suggestion type
543    pub suggestion_type: OptimizationType,
544    /// Description
545    pub description: String,
546    /// Location
547    pub location: CircuitLocation,
548    /// Expected improvement
549    pub expected_improvement: OptimizationImprovement,
550    /// Implementation difficulty
551    pub difficulty: Difficulty,
552    /// Confidence score
553    pub confidence: f64,
554    /// Auto-apply available
555    pub auto_applicable: bool,
556}
557/// Quantum circuit patterns
558#[derive(Debug, Clone, Serialize, Deserialize)]
559pub enum QuantumPattern<const N: usize> {
560    /// Bell state preparation pattern
561    BellStatePreparation { confidence_threshold: f64 },
562    /// Quantum Fourier Transform pattern
563    QuantumFourierTransform {
564        min_qubits: usize,
565        max_qubits: usize,
566    },
567    /// Grover diffusion operator
568    GroverDiffusion { target_qubits: Vec<usize> },
569    /// Phase kickback pattern
570    PhaseKickback {
571        control_qubits: Vec<usize>,
572        target_qubits: Vec<usize>,
573    },
574    /// Quantum error correction code
575    ErrorCorrectionCode {
576        code_type: String,
577        logical_qubits: usize,
578    },
579    /// Variational quantum eigensolver pattern
580    VqePattern {
581        ansatz_depth: usize,
582        parameter_count: usize,
583    },
584    /// Quantum approximate optimization algorithm
585    QaoaPattern { layers: usize, problem_size: usize },
586    /// Teleportation protocol
587    QuantumTeleportation {
588        input_qubit: usize,
589        epr_qubits: (usize, usize),
590    },
591    /// Superdense coding
592    SuperdenseCoding { shared_qubits: (usize, usize) },
593    /// Custom pattern
594    Custom {
595        name: String,
596        description: String,
597        pattern_matcher: PatternMatcher,
598    },
599}
600/// Complexity metrics result
601#[derive(Debug, Clone, Serialize, Deserialize)]
602pub struct ComplexityMetrics {
603    /// Overall complexity score
604    pub overall_complexity: f64,
605    /// Individual metric scores
606    pub metric_scores: HashMap<String, f64>,
607    /// Complexity classification
608    pub classification: ComplexityClassification,
609    /// Scaling behavior
610    pub scaling_behavior: ScalingBehavior,
611}
612/// Simplification types
613#[derive(Debug, Clone, Serialize, Deserialize)]
614pub enum SimplificationType {
615    /// Algorithm simplification
616    Algorithm,
617    /// Gate sequence simplification
618    GateSequence,
619    /// Decomposition simplification
620    Decomposition,
621    /// Structure simplification
622    Structure,
623    /// Parameter simplification
624    Parameter,
625}
626/// Best practice result
627#[derive(Debug, Clone, Serialize, Deserialize)]
628pub struct BestPracticeResult {
629    /// Practice name
630    pub practice_name: String,
631    /// Compliance status
632    pub compliant: bool,
633    /// Compliance score
634    pub compliance_score: f64,
635    /// Violations
636    pub violations: Vec<BestPracticeViolation>,
637    /// Recommendations
638    pub recommendations: Vec<String>,
639}
640/// Linting statistics
641#[derive(Debug, Clone, Serialize, Deserialize)]
642pub struct LintingStatistics {
643    /// Total analysis time
644    pub total_time: Duration,
645    /// Issues found by severity
646    pub issues_by_severity: HashMap<Severity, usize>,
647    /// Issues found by type
648    pub issues_by_type: HashMap<IssueType, usize>,
649    /// Patterns detected
650    pub patterns_detected: usize,
651    /// Anti-patterns detected
652    pub antipatterns_detected: usize,
653    /// Auto-fixes available
654    pub auto_fixes_available: usize,
655    /// Lines of circuit analyzed
656    pub lines_analyzed: usize,
657}
658/// Linting metadata
659#[derive(Debug, Clone, Serialize, Deserialize)]
660pub struct LintingMetadata {
661    /// Analysis timestamp
662    pub timestamp: SystemTime,
663    /// Linter version
664    pub linter_version: String,
665    /// Configuration used
666    pub config: LinterConfig,
667    /// `SciRS2` analysis enabled
668    pub scirs2_enabled: bool,
669    /// Analysis scope
670    pub analysis_scope: AnalysisScope,
671}
672/// Quantum anti-patterns (bad practices)
673#[derive(Debug, Clone, Serialize, Deserialize)]
674pub enum QuantumAntiPattern<const N: usize> {
675    /// Redundant gates
676    RedundantGates {
677        gate_types: Vec<String>,
678        max_distance: usize,
679    },
680    /// Inefficient decomposition
681    InefficientDecomposition {
682        target_gates: Vec<String>,
683        efficiency_threshold: f64,
684    },
685    /// Unnecessary entanglement
686    UnnecessaryEntanglement { threshold: f64 },
687    /// Deep circuit without optimization
688    DeepCircuit {
689        depth_threshold: usize,
690        optimization_potential: f64,
691    },
692    /// Wide circuit without parallelization
693    WideCircuit {
694        width_threshold: usize,
695        parallelization_potential: f64,
696    },
697    /// Measurement in middle of computation
698    EarlyMeasurement { computation_continues_after: bool },
699    /// Repeated identical subcircuits
700    RepeatedSubcircuits {
701        min_repetitions: usize,
702        min_subcircuit_size: usize,
703    },
704    /// Poor gate scheduling
705    PoorGateScheduling { idle_time_threshold: f64 },
706    /// Unnecessary reset operations
707    UnnecessaryResets { optimization_potential: f64 },
708    /// Overcomplicated simple operations
709    Overcomplicated { simplification_threshold: f64 },
710}
711/// Optimization rules
712#[derive(Debug, Clone, Serialize, Deserialize)]
713pub enum OptimizationRule {
714    /// Gate cancellation opportunities
715    GateCancellation {
716        gate_pairs: Vec<(String, String)>,
717        distance_threshold: usize,
718    },
719    /// Gate merging opportunities
720    GateMerging {
721        mergeable_gates: Vec<String>,
722        efficiency_gain: f64,
723    },
724    /// Parallelization opportunities
725    Parallelization {
726        min_parallel_gates: usize,
727        efficiency_threshold: f64,
728    },
729    /// Circuit depth reduction
730    DepthReduction {
731        target_reduction: f64,
732        complexity_increase_limit: f64,
733    },
734    /// Gate count reduction
735    GateCountReduction {
736        target_reduction: f64,
737        accuracy_threshold: f64,
738    },
739    /// Entanglement optimization
740    EntanglementOptimization { efficiency_threshold: f64 },
741}
742/// Types of lint issues
743#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
744pub enum IssueType {
745    /// Pattern-related issue
746    Pattern,
747    /// Anti-pattern detected
748    AntiPattern,
749    /// Style violation
750    Style,
751    /// Optimization opportunity
752    Optimization,
753    /// Complexity issue
754    Complexity,
755    /// Best practice violation
756    BestPractice,
757    /// Correctness issue
758    Correctness,
759    /// Performance issue
760    Performance,
761    /// Maintainability issue
762    Maintainability,
763}
764/// Optimization improvement metrics
765#[derive(Debug, Clone, Serialize, Deserialize)]
766pub struct OptimizationImprovement {
767    /// Gate count reduction
768    pub gate_count_reduction: i32,
769    /// Depth reduction
770    pub depth_reduction: i32,
771    /// Execution time improvement
772    pub execution_time_improvement: f64,
773    /// Memory usage improvement
774    pub memory_improvement: f64,
775    /// Error rate improvement
776    pub error_rate_improvement: f64,
777}
778/// Best practices checker
779pub struct BestPracticesChecker<const N: usize> {
780    /// Best practice rules
781    rules: Vec<BestPracticeRule>,
782    /// Compliance results
783    results: HashMap<String, BestPracticeResult>,
784    /// Practice guidelines
785    guidelines: PracticeGuidelines,
786}
787impl<const N: usize> BestPracticesChecker<N> {
788    /// Create new best practices checker
789    #[must_use]
790    pub fn new() -> Self {
791        Self {
792            rules: Vec::new(),
793            results: HashMap::new(),
794            guidelines: PracticeGuidelines {
795                industry_standards: Vec::new(),
796                custom_guidelines: Vec::new(),
797                compliance_requirements: Vec::new(),
798            },
799        }
800    }
801    /// Check all best practices
802    pub fn check_all_practices(
803        &self,
804        circuit: &Circuit<N>,
805        config: &LinterConfig,
806    ) -> QuantRS2Result<(Vec<LintIssue>, BestPracticesCompliance)> {
807        let issues = Vec::new();
808        let compliance = BestPracticesCompliance {
809            overall_score: 0.9,
810            category_scores: HashMap::new(),
811            compliance_level: ComplianceLevel::Good,
812            improvement_areas: Vec::new(),
813        };
814        Ok((issues, compliance))
815    }
816}
817/// Severity levels
818#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
819pub enum Severity {
820    /// Informational
821    Info,
822    /// Minor issue
823    Minor,
824    /// Warning
825    Warning,
826    /// Error
827    Error,
828    /// Critical error
829    Critical,
830}
831/// Performance impact assessment
832#[derive(Debug, Clone, Serialize, Deserialize)]
833pub struct PerformanceImpact {
834    /// Impact on execution time
835    pub execution_time_impact: f64,
836    /// Impact on memory usage
837    pub memory_impact: f64,
838    /// Impact on gate count
839    pub gate_count_impact: i32,
840    /// Impact on circuit depth
841    pub depth_impact: i32,
842    /// Overall performance score change
843    pub overall_impact: f64,
844}
845/// Measurement placement styles
846#[derive(Debug, Clone, Serialize, Deserialize)]
847pub enum MeasurementPlacementStyle {
848    /// All measurements at end
849    AtEnd,
850    /// Measurements when needed
851    WhenNeeded,
852    /// Grouped measurements
853    Grouped,
854}
855/// Style configuration
856#[derive(Debug, Clone, Serialize, Deserialize)]
857pub struct StyleConfig {
858    /// Enabled style rules
859    pub enabled_rules: Vec<String>,
860    /// Custom style settings
861    pub custom_settings: HashMap<String, String>,
862    /// Strictness level
863    pub strictness: StyleStrictness,
864    /// Auto-format suggestions
865    pub suggest_auto_format: bool,
866}
867/// Auto-fix suggestion
868#[derive(Debug, Clone, Serialize, Deserialize)]
869pub struct AutoFix {
870    /// Fix type
871    pub fix_type: AutoFixType,
872    /// Target issue
873    pub target_issue: String,
874    /// Fix description
875    pub description: String,
876    /// Implementation details
877    pub implementation: String,
878    /// Safety level
879    pub safety: SafetyLevel,
880    /// Confidence score
881    pub confidence: f64,
882    /// Preview available
883    pub preview_available: bool,
884}
885/// Comprehensive linting result
886#[derive(Debug, Clone, Serialize, Deserialize)]
887pub struct LintingResult {
888    /// Overall quality score (0.0 to 1.0)
889    pub quality_score: f64,
890    /// Detected issues
891    pub issues: Vec<LintIssue>,
892    /// Pattern analysis results
893    pub pattern_analysis: PatternAnalysisResult,
894    /// Style analysis results
895    pub style_analysis: StyleAnalysisResult,
896    /// Optimization suggestions
897    pub optimization_suggestions: Vec<OptimizationSuggestion>,
898    /// Complexity metrics
899    pub complexity_metrics: ComplexityMetrics,
900    /// Best practices compliance
901    pub best_practices_compliance: BestPracticesCompliance,
902    /// Auto-fix suggestions
903    pub auto_fixes: Vec<AutoFix>,
904    /// Analysis statistics
905    pub statistics: LintingStatistics,
906    /// Linting metadata
907    pub metadata: LintingMetadata,
908}
909/// Connectivity patterns
910#[derive(Debug, Clone, Serialize, Deserialize)]
911pub enum ConnectivityPattern {
912    /// Linear connectivity
913    Linear,
914    /// All-to-all connectivity
915    AllToAll,
916    /// Ring connectivity
917    Ring,
918    /// Grid connectivity
919    Grid { rows: usize, cols: usize },
920    /// Custom connectivity
921    Custom { adjacency_matrix: Vec<Vec<bool>> },
922}
923/// Trend direction
924#[derive(Debug, Clone, Serialize, Deserialize)]
925pub enum TrendDirection {
926    /// Increasing complexity
927    Increasing,
928    /// Decreasing complexity
929    Decreasing,
930    /// Stable complexity
931    Stable,
932    /// Oscillating complexity
933    Oscillating,
934}
935/// Best practices compliance
936#[derive(Debug, Clone, Serialize, Deserialize)]
937pub struct BestPracticesCompliance {
938    /// Overall compliance score
939    pub overall_score: f64,
940    /// Category scores
941    pub category_scores: HashMap<String, f64>,
942    /// Compliance level
943    pub compliance_level: ComplianceLevel,
944    /// Improvement areas
945    pub improvement_areas: Vec<String>,
946}
947/// Optimization analyzer
948pub struct OptimizationAnalyzer<const N: usize> {
949    /// Optimization rules
950    rules: Vec<OptimizationRule>,
951    /// Analysis results
952    results: HashMap<String, OptimizationAnalysisResult>,
953    /// `SciRS2` analyzer
954    analyzer: SciRS2CircuitAnalyzer,
955}
956impl<const N: usize> OptimizationAnalyzer<N> {
957    /// Create new optimization analyzer
958    #[must_use]
959    pub fn new() -> Self {
960        Self {
961            rules: Vec::new(),
962            results: HashMap::new(),
963            analyzer: SciRS2CircuitAnalyzer::new(),
964        }
965    }
966    /// Analyze optimization opportunities
967    pub fn analyze_optimizations(
968        &self,
969        circuit: &Circuit<N>,
970        config: &LinterConfig,
971    ) -> QuantRS2Result<Vec<OptimizationSuggestion>> {
972        // Heuristic gate-level analysis: detect adjacent self-inverse single
973        // qubit gates (e.g. H·H, X·X) and emit a `GateElimination` suggestion
974        // for each pair found. This costs O(num_gates) and never depends on
975        // randomness or external solvers, satisfying the no-`rand` policy.
976        let mut suggestions = Vec::new();
977        let gates = circuit.gates();
978        let total = gates.len();
979        let mut idx = 0;
980        while idx + 1 < total {
981            let a = &gates[idx];
982            let b = &gates[idx + 1];
983            let same_name = a.name() == b.name();
984            let aq = a.qubits();
985            let bq = b.qubits();
986            if same_name
987                && aq.len() == 1
988                && bq.len() == 1
989                && aq[0] == bq[0]
990                && matches!(a.name(), "H" | "X" | "Y" | "Z")
991            {
992                let qubit_idx = aq.first().map(|q| q.id() as usize).unwrap_or(0);
993                suggestions.push(OptimizationSuggestion {
994                    suggestion_type: OptimizationType::GateElimination,
995                    description: format!(
996                        "Adjacent self-inverse '{}' gates at indices {idx},{} cancel out",
997                        a.name(),
998                        idx + 1
999                    ),
1000                    location: CircuitLocation {
1001                        gate_range: (idx, idx + 2),
1002                        qubits: vec![qubit_idx],
1003                        depth_range: (idx, idx + 2),
1004                        line_col: None,
1005                    },
1006                    expected_improvement: OptimizationImprovement {
1007                        gate_count_reduction: 2,
1008                        depth_reduction: 1,
1009                        execution_time_improvement: 0.05,
1010                        memory_improvement: 0.0,
1011                        error_rate_improvement: 0.02,
1012                    },
1013                    difficulty: Difficulty::Easy,
1014                    confidence: config.pattern_confidence_threshold.max(0.9),
1015                    auto_applicable: true,
1016                });
1017                idx += 2;
1018            } else {
1019                idx += 1;
1020            }
1021        }
1022        // When the gate count crosses the configured performance threshold,
1023        // surface a `DepthReduction` opportunity at the circuit scope.
1024        if total as f64 > config.performance_threshold && config.performance_threshold > 0.0 {
1025            suggestions.push(OptimizationSuggestion {
1026                suggestion_type: OptimizationType::DepthReduction,
1027                description: format!(
1028                    "Circuit has {total} gates; consider commuting parallelisable subsequences",
1029                ),
1030                location: CircuitLocation {
1031                    gate_range: (0, total),
1032                    qubits: Vec::new(),
1033                    depth_range: (0, total),
1034                    line_col: None,
1035                },
1036                expected_improvement: OptimizationImprovement {
1037                    gate_count_reduction: 0,
1038                    depth_reduction: (total / 4) as i32,
1039                    execution_time_improvement: 0.10,
1040                    memory_improvement: 0.0,
1041                    error_rate_improvement: 0.0,
1042                },
1043                difficulty: Difficulty::Moderate,
1044                confidence: 0.7,
1045                auto_applicable: false,
1046            });
1047        }
1048        Ok(suggestions)
1049    }
1050}
1051/// Types of optimizations
1052#[derive(Debug, Clone, Serialize, Deserialize)]
1053pub enum OptimizationType {
1054    /// Gate elimination
1055    GateElimination,
1056    /// Gate reordering
1057    GateReordering,
1058    /// Gate substitution
1059    GateSubstitution,
1060    /// Parallelization
1061    Parallelization,
1062    /// Depth reduction
1063    DepthReduction,
1064    /// Memory optimization
1065    MemoryOptimization,
1066    /// Error reduction
1067    ErrorReduction,
1068}
1069/// Comprehensive quantum circuit linter with `SciRS2` pattern matching
1070pub struct QuantumLinter<const N: usize> {
1071    /// Circuit being analyzed
1072    circuit: Circuit<N>,
1073    /// Linter configuration
1074    pub config: LinterConfig,
1075    /// `SciRS2` analyzer for pattern recognition
1076    analyzer: SciRS2CircuitAnalyzer,
1077    /// Pattern detector
1078    pattern_detector: Arc<RwLock<PatternDetector<N>>>,
1079    /// Anti-pattern detector
1080    antipattern_detector: Arc<RwLock<AntiPatternDetector<N>>>,
1081    /// Style checker
1082    style_checker: Arc<RwLock<StyleChecker<N>>>,
1083    /// Optimization analyzer
1084    optimization_analyzer: Arc<RwLock<OptimizationAnalyzer<N>>>,
1085    /// Complexity analyzer
1086    complexity_analyzer: Arc<RwLock<ComplexityAnalyzer<N>>>,
1087    /// Best practices checker
1088    best_practices_checker: Arc<RwLock<BestPracticesChecker<N>>>,
1089}
1090impl<const N: usize> QuantumLinter<N> {
1091    /// Create a new quantum linter
1092    #[must_use]
1093    pub fn new(circuit: Circuit<N>) -> Self {
1094        Self {
1095            circuit,
1096            config: LinterConfig::default(),
1097            analyzer: SciRS2CircuitAnalyzer::new(),
1098            pattern_detector: Arc::new(RwLock::new(PatternDetector::new())),
1099            antipattern_detector: Arc::new(RwLock::new(AntiPatternDetector::new())),
1100            style_checker: Arc::new(RwLock::new(StyleChecker::new())),
1101            optimization_analyzer: Arc::new(RwLock::new(OptimizationAnalyzer::new())),
1102            complexity_analyzer: Arc::new(RwLock::new(ComplexityAnalyzer::new())),
1103            best_practices_checker: Arc::new(RwLock::new(BestPracticesChecker::new())),
1104        }
1105    }
1106    /// Create linter with custom configuration
1107    #[must_use]
1108    pub fn with_config(circuit: Circuit<N>, config: LinterConfig) -> Self {
1109        Self {
1110            circuit,
1111            config,
1112            analyzer: SciRS2CircuitAnalyzer::new(),
1113            pattern_detector: Arc::new(RwLock::new(PatternDetector::new())),
1114            antipattern_detector: Arc::new(RwLock::new(AntiPatternDetector::new())),
1115            style_checker: Arc::new(RwLock::new(StyleChecker::new())),
1116            optimization_analyzer: Arc::new(RwLock::new(OptimizationAnalyzer::new())),
1117            complexity_analyzer: Arc::new(RwLock::new(ComplexityAnalyzer::new())),
1118            best_practices_checker: Arc::new(RwLock::new(BestPracticesChecker::new())),
1119        }
1120    }
1121    /// Perform comprehensive circuit linting
1122    pub fn lint_circuit(&mut self) -> QuantRS2Result<LintingResult> {
1123        let start_time = Instant::now();
1124        let mut issues = Vec::new();
1125        let pattern_analysis = if self.config.enable_pattern_detection {
1126            self.detect_patterns()?
1127        } else {
1128            PatternAnalysisResult {
1129                detected_patterns: Vec::new(),
1130                pattern_interactions: Vec::new(),
1131                pattern_score: 1.0,
1132                pattern_diversity: 0.0,
1133            }
1134        };
1135        if self.config.enable_antipattern_detection {
1136            let antipattern_issues = self.detect_antipatterns()?;
1137            issues.extend(antipattern_issues);
1138        }
1139        let style_analysis = if self.config.enable_style_checking {
1140            let style_issues = self.check_style()?;
1141            issues.extend(style_issues.0);
1142            style_issues.1
1143        } else {
1144            StyleAnalysisResult {
1145                overall_score: 1.0,
1146                check_results: Vec::new(),
1147                consistency_score: 1.0,
1148                readability_score: 1.0,
1149            }
1150        };
1151        let optimization_suggestions = if self.config.enable_optimization_analysis {
1152            self.analyze_optimizations()?
1153        } else {
1154            Vec::new()
1155        };
1156        let complexity_metrics = if self.config.enable_complexity_analysis {
1157            self.analyze_complexity()?
1158        } else {
1159            ComplexityMetrics {
1160                overall_complexity: 0.0,
1161                metric_scores: HashMap::new(),
1162                classification: ComplexityClassification::Low,
1163                scaling_behavior: ScalingBehavior {
1164                    time_complexity: "O(1)".to_string(),
1165                    space_complexity: "O(1)".to_string(),
1166                    scaling_exponent: 1.0,
1167                    scaling_confidence: 1.0,
1168                },
1169            }
1170        };
1171        let best_practices_compliance = if self.config.enable_best_practices {
1172            let bp_issues = self.check_best_practices()?;
1173            issues.extend(bp_issues.0);
1174            bp_issues.1
1175        } else {
1176            BestPracticesCompliance {
1177                overall_score: 1.0,
1178                category_scores: HashMap::new(),
1179                compliance_level: ComplianceLevel::Excellent,
1180                improvement_areas: Vec::new(),
1181            }
1182        };
1183        issues.retain(|issue| issue.severity >= self.config.severity_threshold);
1184        let auto_fixes = if self.config.enable_auto_fix {
1185            self.generate_auto_fixes(&issues)?
1186        } else {
1187            Vec::new()
1188        };
1189        let quality_score = self.calculate_quality_score(
1190            &issues,
1191            &pattern_analysis,
1192            &style_analysis,
1193            &complexity_metrics,
1194            &best_practices_compliance,
1195        );
1196        let statistics = self.generate_statistics(&issues, &auto_fixes, start_time.elapsed());
1197        Ok(LintingResult {
1198            quality_score,
1199            issues,
1200            pattern_analysis,
1201            style_analysis,
1202            optimization_suggestions,
1203            complexity_metrics,
1204            best_practices_compliance,
1205            auto_fixes,
1206            statistics,
1207            metadata: LintingMetadata {
1208                timestamp: SystemTime::now(),
1209                linter_version: "0.1.0".to_string(),
1210                config: self.config.clone(),
1211                scirs2_enabled: self.config.enable_scirs2_analysis,
1212                analysis_scope: AnalysisScope {
1213                    total_gates: self.circuit.num_gates(),
1214                    qubits_analyzed: (0..N).collect(),
1215                    depth_analyzed: self.circuit.calculate_depth(),
1216                    coverage: 1.0,
1217                },
1218            },
1219        })
1220    }
1221    /// Detect patterns in the circuit
1222    fn detect_patterns(&self) -> QuantRS2Result<PatternAnalysisResult> {
1223        let detector = self.pattern_detector.read().map_err(|_| {
1224            QuantRS2Error::InvalidOperation("Failed to acquire pattern detector lock".to_string())
1225        })?;
1226        detector.detect_all_patterns(&self.circuit, &self.config)
1227    }
1228    /// Detect anti-patterns in the circuit
1229    fn detect_antipatterns(&self) -> QuantRS2Result<Vec<LintIssue>> {
1230        let detector = self.antipattern_detector.read().map_err(|_| {
1231            QuantRS2Error::InvalidOperation(
1232                "Failed to acquire antipattern detector lock".to_string(),
1233            )
1234        })?;
1235        detector.detect_all_antipatterns(&self.circuit, &self.config)
1236    }
1237    /// Check style compliance
1238    fn check_style(&self) -> QuantRS2Result<(Vec<LintIssue>, StyleAnalysisResult)> {
1239        let checker = self.style_checker.read().map_err(|_| {
1240            QuantRS2Error::InvalidOperation("Failed to acquire style checker lock".to_string())
1241        })?;
1242        checker.check_all_styles(&self.circuit, &self.config)
1243    }
1244    /// Analyze optimization opportunities
1245    fn analyze_optimizations(&self) -> QuantRS2Result<Vec<OptimizationSuggestion>> {
1246        let analyzer = self.optimization_analyzer.read().map_err(|_| {
1247            QuantRS2Error::InvalidOperation(
1248                "Failed to acquire optimization analyzer lock".to_string(),
1249            )
1250        })?;
1251        analyzer.analyze_optimizations(&self.circuit, &self.config)
1252    }
1253    /// Analyze circuit complexity
1254    fn analyze_complexity(&self) -> QuantRS2Result<ComplexityMetrics> {
1255        let analyzer = self.complexity_analyzer.read().map_err(|_| {
1256            QuantRS2Error::InvalidOperation(
1257                "Failed to acquire complexity analyzer lock".to_string(),
1258            )
1259        })?;
1260        analyzer.analyze_complexity(&self.circuit, &self.config)
1261    }
1262    /// Check best practices compliance
1263    fn check_best_practices(&self) -> QuantRS2Result<(Vec<LintIssue>, BestPracticesCompliance)> {
1264        let checker = self.best_practices_checker.read().map_err(|_| {
1265            QuantRS2Error::InvalidOperation(
1266                "Failed to acquire best practices checker lock".to_string(),
1267            )
1268        })?;
1269        checker.check_all_practices(&self.circuit, &self.config)
1270    }
1271    /// Generate auto-fix suggestions
1272    fn generate_auto_fixes(&self, issues: &[LintIssue]) -> QuantRS2Result<Vec<AutoFix>> {
1273        let mut auto_fixes = Vec::new();
1274        for issue in issues {
1275            if issue.auto_fixable {
1276                let auto_fix = self.create_auto_fix(issue)?;
1277                auto_fixes.push(auto_fix);
1278            }
1279        }
1280        Ok(auto_fixes)
1281    }
1282    /// Create auto-fix for an issue
1283    fn create_auto_fix(&self, issue: &LintIssue) -> QuantRS2Result<AutoFix> {
1284        Ok(AutoFix {
1285            fix_type: AutoFixType::TextReplacement,
1286            target_issue: issue.rule_id.clone(),
1287            description: format!("Auto-fix for {}", issue.title),
1288            implementation: issue
1289                .suggested_fix
1290                .clone()
1291                .unwrap_or_else(|| "No implementation".to_string()),
1292            safety: SafetyLevel::ReviewRecommended,
1293            confidence: 0.8,
1294            preview_available: true,
1295        })
1296    }
1297    /// Calculate overall quality score
1298    fn calculate_quality_score(
1299        &self,
1300        issues: &[LintIssue],
1301        pattern_analysis: &PatternAnalysisResult,
1302        style_analysis: &StyleAnalysisResult,
1303        complexity_metrics: &ComplexityMetrics,
1304        best_practices: &BestPracticesCompliance,
1305    ) -> f64 {
1306        let issue_score = 1.0 - (issues.len() as f64 * 0.1).min(0.5);
1307        let pattern_score = pattern_analysis.pattern_score;
1308        let style_score = style_analysis.overall_score;
1309        let complexity_score = 1.0 - complexity_metrics.overall_complexity.min(1.0);
1310        let practices_score = best_practices.overall_score;
1311        (issue_score + pattern_score + style_score + complexity_score + practices_score) / 5.0
1312    }
1313    /// Generate linting statistics
1314    fn generate_statistics(
1315        &self,
1316        issues: &[LintIssue],
1317        auto_fixes: &[AutoFix],
1318        total_time: Duration,
1319    ) -> LintingStatistics {
1320        let mut issues_by_severity = HashMap::new();
1321        let mut issues_by_type = HashMap::new();
1322        for issue in issues {
1323            *issues_by_severity
1324                .entry(issue.severity.clone())
1325                .or_insert(0) += 1;
1326            *issues_by_type.entry(issue.issue_type.clone()).or_insert(0) += 1;
1327        }
1328        LintingStatistics {
1329            total_time,
1330            issues_by_severity,
1331            issues_by_type,
1332            patterns_detected: 0,
1333            antipatterns_detected: issues
1334                .iter()
1335                .filter(|i| i.issue_type == IssueType::AntiPattern)
1336                .count(),
1337            auto_fixes_available: auto_fixes.len(),
1338            lines_analyzed: self.circuit.num_gates(),
1339        }
1340    }
1341}
1342/// Anti-pattern detector
1343pub struct AntiPatternDetector<const N: usize> {
1344    /// Anti-patterns to detect
1345    antipatterns: Vec<QuantumAntiPattern<N>>,
1346    /// Detection results
1347    detection_results: HashMap<String, AntiPatternDetectionResult>,
1348    /// `SciRS2` analyzer
1349    analyzer: SciRS2CircuitAnalyzer,
1350}
1351impl<const N: usize> AntiPatternDetector<N> {
1352    /// Create new anti-pattern detector
1353    #[must_use]
1354    pub fn new() -> Self {
1355        Self {
1356            antipatterns: Vec::new(),
1357            detection_results: HashMap::new(),
1358            analyzer: SciRS2CircuitAnalyzer::new(),
1359        }
1360    }
1361    /// Detect all anti-patterns
1362    pub fn detect_all_antipatterns(
1363        &self,
1364        circuit: &Circuit<N>,
1365        config: &LinterConfig,
1366    ) -> QuantRS2Result<Vec<LintIssue>> {
1367        // Surface common anti-patterns: an empty circuit is rarely intended,
1368        // and oversize gate counts often indicate that an algorithm is missing
1369        // a transpiler pass. Both are flagged at low severity so the linter
1370        // user can choose to act on them.
1371        let mut issues = Vec::new();
1372        let total = circuit.num_gates();
1373        if total == 0 {
1374            issues.push(LintIssue {
1375                issue_type: IssueType::AntiPattern,
1376                severity: Severity::Warning,
1377                title: "empty_circuit".to_string(),
1378                description: "Circuit contains no gates; verify intent.".to_string(),
1379                location: CircuitLocation {
1380                    gate_range: (0, 0),
1381                    qubits: Vec::new(),
1382                    depth_range: (0, 0),
1383                    line_col: None,
1384                },
1385                suggested_fix: Some("Add at least one gate or remove the circuit".to_string()),
1386                auto_fixable: false,
1387                rule_id: "QR-AP001".to_string(),
1388                confidence: 1.0,
1389                performance_impact: None,
1390            });
1391        }
1392        let limit = (config.max_analysis_depth.saturating_mul(64)).max(64);
1393        if total > limit {
1394            issues.push(LintIssue {
1395                issue_type: IssueType::AntiPattern,
1396                severity: Severity::Minor,
1397                title: "circuit_too_deep".to_string(),
1398                description: format!(
1399                    "Gate count {total} exceeds soft cap {limit}; transpilation passes recommended.",
1400                ),
1401                location: CircuitLocation {
1402                    gate_range: (0, total),
1403                    qubits: Vec::new(),
1404                    depth_range: (0, total),
1405                    line_col: None,
1406                },
1407                suggested_fix: Some(
1408                    "Run gate fusion / depth reduction passes before execution".to_string(),
1409                ),
1410                auto_fixable: false,
1411                rule_id: "QR-AP002".to_string(),
1412                confidence: 0.85,
1413                performance_impact: None,
1414            });
1415        }
1416        Ok(issues)
1417    }
1418}
1419/// Naming conventions
1420#[derive(Debug, Clone, Serialize, Deserialize)]
1421pub enum NamingConvention {
1422    /// CamelCase
1423    CamelCase,
1424    /// `snake_case`
1425    SnakeCase,
1426    /// kebab-case
1427    KebabCase,
1428    /// `UPPER_CASE`
1429    UpperCase,
1430    /// Custom convention
1431    Custom { pattern: String },
1432}
1433/// Pattern interaction
1434#[derive(Debug, Clone, Serialize, Deserialize)]
1435pub struct PatternInteraction {
1436    /// First pattern
1437    pub pattern1: String,
1438    /// Second pattern
1439    pub pattern2: String,
1440    /// Interaction type
1441    pub interaction_type: InteractionType,
1442    /// Interaction strength
1443    pub strength: f64,
1444    /// Impact on performance
1445    pub performance_impact: f64,
1446}
1447/// Gate grouping styles
1448#[derive(Debug, Clone, Serialize, Deserialize)]
1449pub enum GateGroupingStyle {
1450    /// Group by gate type
1451    ByType,
1452    /// Group by qubit
1453    ByQubit,
1454    /// Group by functionality
1455    ByFunctionality,
1456    /// No grouping
1457    None,
1458}
1459/// Barrier usage styles
1460#[derive(Debug, Clone, Serialize, Deserialize)]
1461pub enum BarrierUsageStyle {
1462    /// Minimal barriers
1463    Minimal,
1464    /// Liberal barriers
1465    Liberal,
1466    /// Functional barriers only
1467    FunctionalOnly,
1468    /// No barriers
1469    None,
1470}
1471/// Complexity metrics
1472#[derive(Debug, Clone, Serialize, Deserialize)]
1473pub enum ComplexityMetric {
1474    /// Cyclomatic complexity
1475    Cyclomatic,
1476    /// Entanglement complexity
1477    Entanglement,
1478    /// Information complexity
1479    Information,
1480    /// Computational complexity
1481    Computational,
1482    /// Spatial complexity
1483    Spatial,
1484    /// Temporal complexity
1485    Temporal,
1486}
1487/// Complexity analyzer
1488pub struct ComplexityAnalyzer<const N: usize> {
1489    /// Complexity metrics
1490    metrics: Vec<ComplexityMetric>,
1491    /// Analysis results
1492    results: HashMap<String, ComplexityAnalysisResult>,
1493    /// `SciRS2` analyzer
1494    analyzer: SciRS2CircuitAnalyzer,
1495}
1496impl<const N: usize> ComplexityAnalyzer<N> {
1497    /// Create new complexity analyzer
1498    #[must_use]
1499    pub fn new() -> Self {
1500        Self {
1501            metrics: Vec::new(),
1502            results: HashMap::new(),
1503            analyzer: SciRS2CircuitAnalyzer::new(),
1504        }
1505    }
1506    /// Analyze circuit complexity
1507    pub fn analyze_complexity(
1508        &self,
1509        circuit: &Circuit<N>,
1510        config: &LinterConfig,
1511    ) -> QuantRS2Result<ComplexityMetrics> {
1512        Ok(ComplexityMetrics {
1513            overall_complexity: 0.5,
1514            metric_scores: HashMap::new(),
1515            classification: ComplexityClassification::Medium,
1516            scaling_behavior: ScalingBehavior {
1517                time_complexity: "O(n)".to_string(),
1518                space_complexity: "O(n)".to_string(),
1519                scaling_exponent: 1.0,
1520                scaling_confidence: 0.9,
1521            },
1522        })
1523    }
1524}
1525/// Analysis scope
1526#[derive(Debug, Clone, Serialize, Deserialize)]
1527pub struct AnalysisScope {
1528    /// Total gates analyzed
1529    pub total_gates: usize,
1530    /// Qubits analyzed
1531    pub qubits_analyzed: Vec<usize>,
1532    /// Circuit depth analyzed
1533    pub depth_analyzed: usize,
1534    /// Analysis coverage
1535    pub coverage: f64,
1536}
1537/// Linter configuration options
1538#[derive(Debug, Clone, Serialize, Deserialize)]
1539pub struct LinterConfig {
1540    /// Enable pattern detection
1541    pub enable_pattern_detection: bool,
1542    /// Enable anti-pattern detection
1543    pub enable_antipattern_detection: bool,
1544    /// Enable style checking
1545    pub enable_style_checking: bool,
1546    /// Enable optimization analysis
1547    pub enable_optimization_analysis: bool,
1548    /// Enable complexity analysis
1549    pub enable_complexity_analysis: bool,
1550    /// Enable best practices checking
1551    pub enable_best_practices: bool,
1552    /// Severity threshold for reporting
1553    pub severity_threshold: Severity,
1554    /// Maximum analysis depth
1555    pub max_analysis_depth: usize,
1556    /// Enable `SciRS2` advanced analysis
1557    pub enable_scirs2_analysis: bool,
1558    /// Pattern matching confidence threshold
1559    pub pattern_confidence_threshold: f64,
1560    /// Enable auto-fix suggestions
1561    pub enable_auto_fix: bool,
1562    /// Performance threshold for optimization suggestions
1563    pub performance_threshold: f64,
1564    /// Code style strictness level
1565    pub style_strictness: StyleStrictness,
1566}
1567/// Style check result
1568#[derive(Debug, Clone, Serialize, Deserialize)]
1569pub struct StyleCheckResult {
1570    /// Rule name
1571    pub rule_name: String,
1572    /// Compliance status
1573    pub compliant: bool,
1574    /// Violations found
1575    pub violations: Vec<StyleViolation>,
1576    /// Overall style score
1577    pub score: f64,
1578}
1579/// Best practice violation
1580#[derive(Debug, Clone, Serialize, Deserialize)]
1581pub struct BestPracticeViolation {
1582    /// Violation type
1583    pub violation_type: String,
1584    /// Severity
1585    pub severity: Severity,
1586    /// Description
1587    pub description: String,
1588    /// Location
1589    pub location: CircuitLocation,
1590    /// Remediation steps
1591    pub remediation_steps: Vec<String>,
1592}
1593/// Complexity trend
1594#[derive(Debug, Clone, Serialize, Deserialize)]
1595pub struct ComplexityTrend {
1596    /// Metric name
1597    pub metric: String,
1598    /// Trend direction
1599    pub direction: TrendDirection,
1600    /// Trend strength
1601    pub strength: f64,
1602    /// Trend confidence
1603    pub confidence: f64,
1604}
1605/// Pattern detection result
1606#[derive(Debug, Clone, Serialize, Deserialize)]
1607pub struct PatternDetectionResult {
1608    /// Pattern name
1609    pub pattern_name: String,
1610    /// Detection confidence
1611    pub confidence: f64,
1612    /// Pattern locations
1613    pub locations: Vec<CircuitLocation>,
1614    /// Pattern statistics
1615    pub statistics: PatternStatistics,
1616    /// Performance characteristics
1617    pub performance_profile: PatternPerformanceProfile,
1618}
1619/// Interaction types between patterns
1620#[derive(Debug, Clone, Serialize, Deserialize)]
1621pub enum InteractionType {
1622    /// Patterns complement each other
1623    Synergistic,
1624    /// Patterns interfere with each other
1625    Conflicting,
1626    /// Patterns are independent
1627    Independent,
1628    /// One pattern subsumes another
1629    Subsumption,
1630    /// Patterns are equivalent
1631    Equivalent,
1632}
quantrs2_circuit/linter/types.rs

quantrs2_circuit/linter/
types.rs
