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 const fn analyze_optimizations(
968        &self,
969        circuit: &Circuit<N>,
970        config: &LinterConfig,
971    ) -> QuantRS2Result<Vec<OptimizationSuggestion>> {
972        Ok(Vec::new())
973    }
974}
975/// Types of optimizations
976#[derive(Debug, Clone, Serialize, Deserialize)]
977pub enum OptimizationType {
978    /// Gate elimination
979    GateElimination,
980    /// Gate reordering
981    GateReordering,
982    /// Gate substitution
983    GateSubstitution,
984    /// Parallelization
985    Parallelization,
986    /// Depth reduction
987    DepthReduction,
988    /// Memory optimization
989    MemoryOptimization,
990    /// Error reduction
991    ErrorReduction,
992}
993/// Comprehensive quantum circuit linter with `SciRS2` pattern matching
994pub struct QuantumLinter<const N: usize> {
995    /// Circuit being analyzed
996    circuit: Circuit<N>,
997    /// Linter configuration
998    pub config: LinterConfig,
999    /// `SciRS2` analyzer for pattern recognition
1000    analyzer: SciRS2CircuitAnalyzer,
1001    /// Pattern detector
1002    pattern_detector: Arc<RwLock<PatternDetector<N>>>,
1003    /// Anti-pattern detector
1004    antipattern_detector: Arc<RwLock<AntiPatternDetector<N>>>,
1005    /// Style checker
1006    style_checker: Arc<RwLock<StyleChecker<N>>>,
1007    /// Optimization analyzer
1008    optimization_analyzer: Arc<RwLock<OptimizationAnalyzer<N>>>,
1009    /// Complexity analyzer
1010    complexity_analyzer: Arc<RwLock<ComplexityAnalyzer<N>>>,
1011    /// Best practices checker
1012    best_practices_checker: Arc<RwLock<BestPracticesChecker<N>>>,
1013}
1014impl<const N: usize> QuantumLinter<N> {
1015    /// Create a new quantum linter
1016    #[must_use]
1017    pub fn new(circuit: Circuit<N>) -> Self {
1018        Self {
1019            circuit,
1020            config: LinterConfig::default(),
1021            analyzer: SciRS2CircuitAnalyzer::new(),
1022            pattern_detector: Arc::new(RwLock::new(PatternDetector::new())),
1023            antipattern_detector: Arc::new(RwLock::new(AntiPatternDetector::new())),
1024            style_checker: Arc::new(RwLock::new(StyleChecker::new())),
1025            optimization_analyzer: Arc::new(RwLock::new(OptimizationAnalyzer::new())),
1026            complexity_analyzer: Arc::new(RwLock::new(ComplexityAnalyzer::new())),
1027            best_practices_checker: Arc::new(RwLock::new(BestPracticesChecker::new())),
1028        }
1029    }
1030    /// Create linter with custom configuration
1031    #[must_use]
1032    pub fn with_config(circuit: Circuit<N>, config: LinterConfig) -> Self {
1033        Self {
1034            circuit,
1035            config,
1036            analyzer: SciRS2CircuitAnalyzer::new(),
1037            pattern_detector: Arc::new(RwLock::new(PatternDetector::new())),
1038            antipattern_detector: Arc::new(RwLock::new(AntiPatternDetector::new())),
1039            style_checker: Arc::new(RwLock::new(StyleChecker::new())),
1040            optimization_analyzer: Arc::new(RwLock::new(OptimizationAnalyzer::new())),
1041            complexity_analyzer: Arc::new(RwLock::new(ComplexityAnalyzer::new())),
1042            best_practices_checker: Arc::new(RwLock::new(BestPracticesChecker::new())),
1043        }
1044    }
1045    /// Perform comprehensive circuit linting
1046    pub fn lint_circuit(&mut self) -> QuantRS2Result<LintingResult> {
1047        let start_time = Instant::now();
1048        let mut issues = Vec::new();
1049        let pattern_analysis = if self.config.enable_pattern_detection {
1050            self.detect_patterns()?
1051        } else {
1052            PatternAnalysisResult {
1053                detected_patterns: Vec::new(),
1054                pattern_interactions: Vec::new(),
1055                pattern_score: 1.0,
1056                pattern_diversity: 0.0,
1057            }
1058        };
1059        if self.config.enable_antipattern_detection {
1060            let antipattern_issues = self.detect_antipatterns()?;
1061            issues.extend(antipattern_issues);
1062        }
1063        let style_analysis = if self.config.enable_style_checking {
1064            let style_issues = self.check_style()?;
1065            issues.extend(style_issues.0);
1066            style_issues.1
1067        } else {
1068            StyleAnalysisResult {
1069                overall_score: 1.0,
1070                check_results: Vec::new(),
1071                consistency_score: 1.0,
1072                readability_score: 1.0,
1073            }
1074        };
1075        let optimization_suggestions = if self.config.enable_optimization_analysis {
1076            self.analyze_optimizations()?
1077        } else {
1078            Vec::new()
1079        };
1080        let complexity_metrics = if self.config.enable_complexity_analysis {
1081            self.analyze_complexity()?
1082        } else {
1083            ComplexityMetrics {
1084                overall_complexity: 0.0,
1085                metric_scores: HashMap::new(),
1086                classification: ComplexityClassification::Low,
1087                scaling_behavior: ScalingBehavior {
1088                    time_complexity: "O(1)".to_string(),
1089                    space_complexity: "O(1)".to_string(),
1090                    scaling_exponent: 1.0,
1091                    scaling_confidence: 1.0,
1092                },
1093            }
1094        };
1095        let best_practices_compliance = if self.config.enable_best_practices {
1096            let bp_issues = self.check_best_practices()?;
1097            issues.extend(bp_issues.0);
1098            bp_issues.1
1099        } else {
1100            BestPracticesCompliance {
1101                overall_score: 1.0,
1102                category_scores: HashMap::new(),
1103                compliance_level: ComplianceLevel::Excellent,
1104                improvement_areas: Vec::new(),
1105            }
1106        };
1107        issues.retain(|issue| issue.severity >= self.config.severity_threshold);
1108        let auto_fixes = if self.config.enable_auto_fix {
1109            self.generate_auto_fixes(&issues)?
1110        } else {
1111            Vec::new()
1112        };
1113        let quality_score = self.calculate_quality_score(
1114            &issues,
1115            &pattern_analysis,
1116            &style_analysis,
1117            &complexity_metrics,
1118            &best_practices_compliance,
1119        );
1120        let statistics = self.generate_statistics(&issues, &auto_fixes, start_time.elapsed());
1121        Ok(LintingResult {
1122            quality_score,
1123            issues,
1124            pattern_analysis,
1125            style_analysis,
1126            optimization_suggestions,
1127            complexity_metrics,
1128            best_practices_compliance,
1129            auto_fixes,
1130            statistics,
1131            metadata: LintingMetadata {
1132                timestamp: SystemTime::now(),
1133                linter_version: "0.1.0".to_string(),
1134                config: self.config.clone(),
1135                scirs2_enabled: self.config.enable_scirs2_analysis,
1136                analysis_scope: AnalysisScope {
1137                    total_gates: self.circuit.num_gates(),
1138                    qubits_analyzed: (0..N).collect(),
1139                    depth_analyzed: self.circuit.calculate_depth(),
1140                    coverage: 1.0,
1141                },
1142            },
1143        })
1144    }
1145    /// Detect patterns in the circuit
1146    fn detect_patterns(&self) -> QuantRS2Result<PatternAnalysisResult> {
1147        let detector = self.pattern_detector.read().map_err(|_| {
1148            QuantRS2Error::InvalidOperation("Failed to acquire pattern detector lock".to_string())
1149        })?;
1150        detector.detect_all_patterns(&self.circuit, &self.config)
1151    }
1152    /// Detect anti-patterns in the circuit
1153    fn detect_antipatterns(&self) -> QuantRS2Result<Vec<LintIssue>> {
1154        let detector = self.antipattern_detector.read().map_err(|_| {
1155            QuantRS2Error::InvalidOperation(
1156                "Failed to acquire antipattern detector lock".to_string(),
1157            )
1158        })?;
1159        detector.detect_all_antipatterns(&self.circuit, &self.config)
1160    }
1161    /// Check style compliance
1162    fn check_style(&self) -> QuantRS2Result<(Vec<LintIssue>, StyleAnalysisResult)> {
1163        let checker = self.style_checker.read().map_err(|_| {
1164            QuantRS2Error::InvalidOperation("Failed to acquire style checker lock".to_string())
1165        })?;
1166        checker.check_all_styles(&self.circuit, &self.config)
1167    }
1168    /// Analyze optimization opportunities
1169    fn analyze_optimizations(&self) -> QuantRS2Result<Vec<OptimizationSuggestion>> {
1170        let analyzer = self.optimization_analyzer.read().map_err(|_| {
1171            QuantRS2Error::InvalidOperation(
1172                "Failed to acquire optimization analyzer lock".to_string(),
1173            )
1174        })?;
1175        analyzer.analyze_optimizations(&self.circuit, &self.config)
1176    }
1177    /// Analyze circuit complexity
1178    fn analyze_complexity(&self) -> QuantRS2Result<ComplexityMetrics> {
1179        let analyzer = self.complexity_analyzer.read().map_err(|_| {
1180            QuantRS2Error::InvalidOperation(
1181                "Failed to acquire complexity analyzer lock".to_string(),
1182            )
1183        })?;
1184        analyzer.analyze_complexity(&self.circuit, &self.config)
1185    }
1186    /// Check best practices compliance
1187    fn check_best_practices(&self) -> QuantRS2Result<(Vec<LintIssue>, BestPracticesCompliance)> {
1188        let checker = self.best_practices_checker.read().map_err(|_| {
1189            QuantRS2Error::InvalidOperation(
1190                "Failed to acquire best practices checker lock".to_string(),
1191            )
1192        })?;
1193        checker.check_all_practices(&self.circuit, &self.config)
1194    }
1195    /// Generate auto-fix suggestions
1196    fn generate_auto_fixes(&self, issues: &[LintIssue]) -> QuantRS2Result<Vec<AutoFix>> {
1197        let mut auto_fixes = Vec::new();
1198        for issue in issues {
1199            if issue.auto_fixable {
1200                let auto_fix = self.create_auto_fix(issue)?;
1201                auto_fixes.push(auto_fix);
1202            }
1203        }
1204        Ok(auto_fixes)
1205    }
1206    /// Create auto-fix for an issue
1207    fn create_auto_fix(&self, issue: &LintIssue) -> QuantRS2Result<AutoFix> {
1208        Ok(AutoFix {
1209            fix_type: AutoFixType::TextReplacement,
1210            target_issue: issue.rule_id.clone(),
1211            description: format!("Auto-fix for {}", issue.title),
1212            implementation: issue
1213                .suggested_fix
1214                .clone()
1215                .unwrap_or_else(|| "No implementation".to_string()),
1216            safety: SafetyLevel::ReviewRecommended,
1217            confidence: 0.8,
1218            preview_available: true,
1219        })
1220    }
1221    /// Calculate overall quality score
1222    fn calculate_quality_score(
1223        &self,
1224        issues: &[LintIssue],
1225        pattern_analysis: &PatternAnalysisResult,
1226        style_analysis: &StyleAnalysisResult,
1227        complexity_metrics: &ComplexityMetrics,
1228        best_practices: &BestPracticesCompliance,
1229    ) -> f64 {
1230        let issue_score = 1.0 - (issues.len() as f64 * 0.1).min(0.5);
1231        let pattern_score = pattern_analysis.pattern_score;
1232        let style_score = style_analysis.overall_score;
1233        let complexity_score = 1.0 - complexity_metrics.overall_complexity.min(1.0);
1234        let practices_score = best_practices.overall_score;
1235        (issue_score + pattern_score + style_score + complexity_score + practices_score) / 5.0
1236    }
1237    /// Generate linting statistics
1238    fn generate_statistics(
1239        &self,
1240        issues: &[LintIssue],
1241        auto_fixes: &[AutoFix],
1242        total_time: Duration,
1243    ) -> LintingStatistics {
1244        let mut issues_by_severity = HashMap::new();
1245        let mut issues_by_type = HashMap::new();
1246        for issue in issues {
1247            *issues_by_severity
1248                .entry(issue.severity.clone())
1249                .or_insert(0) += 1;
1250            *issues_by_type.entry(issue.issue_type.clone()).or_insert(0) += 1;
1251        }
1252        LintingStatistics {
1253            total_time,
1254            issues_by_severity,
1255            issues_by_type,
1256            patterns_detected: 0,
1257            antipatterns_detected: issues
1258                .iter()
1259                .filter(|i| i.issue_type == IssueType::AntiPattern)
1260                .count(),
1261            auto_fixes_available: auto_fixes.len(),
1262            lines_analyzed: self.circuit.num_gates(),
1263        }
1264    }
1265}
1266/// Anti-pattern detector
1267pub struct AntiPatternDetector<const N: usize> {
1268    /// Anti-patterns to detect
1269    antipatterns: Vec<QuantumAntiPattern<N>>,
1270    /// Detection results
1271    detection_results: HashMap<String, AntiPatternDetectionResult>,
1272    /// `SciRS2` analyzer
1273    analyzer: SciRS2CircuitAnalyzer,
1274}
1275impl<const N: usize> AntiPatternDetector<N> {
1276    /// Create new anti-pattern detector
1277    #[must_use]
1278    pub fn new() -> Self {
1279        Self {
1280            antipatterns: Vec::new(),
1281            detection_results: HashMap::new(),
1282            analyzer: SciRS2CircuitAnalyzer::new(),
1283        }
1284    }
1285    /// Detect all anti-patterns
1286    pub const fn detect_all_antipatterns(
1287        &self,
1288        circuit: &Circuit<N>,
1289        config: &LinterConfig,
1290    ) -> QuantRS2Result<Vec<LintIssue>> {
1291        Ok(Vec::new())
1292    }
1293}
1294/// Naming conventions
1295#[derive(Debug, Clone, Serialize, Deserialize)]
1296pub enum NamingConvention {
1297    /// CamelCase
1298    CamelCase,
1299    /// `snake_case`
1300    SnakeCase,
1301    /// kebab-case
1302    KebabCase,
1303    /// `UPPER_CASE`
1304    UpperCase,
1305    /// Custom convention
1306    Custom { pattern: String },
1307}
1308/// Pattern interaction
1309#[derive(Debug, Clone, Serialize, Deserialize)]
1310pub struct PatternInteraction {
1311    /// First pattern
1312    pub pattern1: String,
1313    /// Second pattern
1314    pub pattern2: String,
1315    /// Interaction type
1316    pub interaction_type: InteractionType,
1317    /// Interaction strength
1318    pub strength: f64,
1319    /// Impact on performance
1320    pub performance_impact: f64,
1321}
1322/// Gate grouping styles
1323#[derive(Debug, Clone, Serialize, Deserialize)]
1324pub enum GateGroupingStyle {
1325    /// Group by gate type
1326    ByType,
1327    /// Group by qubit
1328    ByQubit,
1329    /// Group by functionality
1330    ByFunctionality,
1331    /// No grouping
1332    None,
1333}
1334/// Barrier usage styles
1335#[derive(Debug, Clone, Serialize, Deserialize)]
1336pub enum BarrierUsageStyle {
1337    /// Minimal barriers
1338    Minimal,
1339    /// Liberal barriers
1340    Liberal,
1341    /// Functional barriers only
1342    FunctionalOnly,
1343    /// No barriers
1344    None,
1345}
1346/// Complexity metrics
1347#[derive(Debug, Clone, Serialize, Deserialize)]
1348pub enum ComplexityMetric {
1349    /// Cyclomatic complexity
1350    Cyclomatic,
1351    /// Entanglement complexity
1352    Entanglement,
1353    /// Information complexity
1354    Information,
1355    /// Computational complexity
1356    Computational,
1357    /// Spatial complexity
1358    Spatial,
1359    /// Temporal complexity
1360    Temporal,
1361}
1362/// Complexity analyzer
1363pub struct ComplexityAnalyzer<const N: usize> {
1364    /// Complexity metrics
1365    metrics: Vec<ComplexityMetric>,
1366    /// Analysis results
1367    results: HashMap<String, ComplexityAnalysisResult>,
1368    /// `SciRS2` analyzer
1369    analyzer: SciRS2CircuitAnalyzer,
1370}
1371impl<const N: usize> ComplexityAnalyzer<N> {
1372    /// Create new complexity analyzer
1373    #[must_use]
1374    pub fn new() -> Self {
1375        Self {
1376            metrics: Vec::new(),
1377            results: HashMap::new(),
1378            analyzer: SciRS2CircuitAnalyzer::new(),
1379        }
1380    }
1381    /// Analyze circuit complexity
1382    pub fn analyze_complexity(
1383        &self,
1384        circuit: &Circuit<N>,
1385        config: &LinterConfig,
1386    ) -> QuantRS2Result<ComplexityMetrics> {
1387        Ok(ComplexityMetrics {
1388            overall_complexity: 0.5,
1389            metric_scores: HashMap::new(),
1390            classification: ComplexityClassification::Medium,
1391            scaling_behavior: ScalingBehavior {
1392                time_complexity: "O(n)".to_string(),
1393                space_complexity: "O(n)".to_string(),
1394                scaling_exponent: 1.0,
1395                scaling_confidence: 0.9,
1396            },
1397        })
1398    }
1399}
1400/// Analysis scope
1401#[derive(Debug, Clone, Serialize, Deserialize)]
1402pub struct AnalysisScope {
1403    /// Total gates analyzed
1404    pub total_gates: usize,
1405    /// Qubits analyzed
1406    pub qubits_analyzed: Vec<usize>,
1407    /// Circuit depth analyzed
1408    pub depth_analyzed: usize,
1409    /// Analysis coverage
1410    pub coverage: f64,
1411}
1412/// Linter configuration options
1413#[derive(Debug, Clone, Serialize, Deserialize)]
1414pub struct LinterConfig {
1415    /// Enable pattern detection
1416    pub enable_pattern_detection: bool,
1417    /// Enable anti-pattern detection
1418    pub enable_antipattern_detection: bool,
1419    /// Enable style checking
1420    pub enable_style_checking: bool,
1421    /// Enable optimization analysis
1422    pub enable_optimization_analysis: bool,
1423    /// Enable complexity analysis
1424    pub enable_complexity_analysis: bool,
1425    /// Enable best practices checking
1426    pub enable_best_practices: bool,
1427    /// Severity threshold for reporting
1428    pub severity_threshold: Severity,
1429    /// Maximum analysis depth
1430    pub max_analysis_depth: usize,
1431    /// Enable `SciRS2` advanced analysis
1432    pub enable_scirs2_analysis: bool,
1433    /// Pattern matching confidence threshold
1434    pub pattern_confidence_threshold: f64,
1435    /// Enable auto-fix suggestions
1436    pub enable_auto_fix: bool,
1437    /// Performance threshold for optimization suggestions
1438    pub performance_threshold: f64,
1439    /// Code style strictness level
1440    pub style_strictness: StyleStrictness,
1441}
1442/// Style check result
1443#[derive(Debug, Clone, Serialize, Deserialize)]
1444pub struct StyleCheckResult {
1445    /// Rule name
1446    pub rule_name: String,
1447    /// Compliance status
1448    pub compliant: bool,
1449    /// Violations found
1450    pub violations: Vec<StyleViolation>,
1451    /// Overall style score
1452    pub score: f64,
1453}
1454/// Best practice violation
1455#[derive(Debug, Clone, Serialize, Deserialize)]
1456pub struct BestPracticeViolation {
1457    /// Violation type
1458    pub violation_type: String,
1459    /// Severity
1460    pub severity: Severity,
1461    /// Description
1462    pub description: String,
1463    /// Location
1464    pub location: CircuitLocation,
1465    /// Remediation steps
1466    pub remediation_steps: Vec<String>,
1467}
1468/// Complexity trend
1469#[derive(Debug, Clone, Serialize, Deserialize)]
1470pub struct ComplexityTrend {
1471    /// Metric name
1472    pub metric: String,
1473    /// Trend direction
1474    pub direction: TrendDirection,
1475    /// Trend strength
1476    pub strength: f64,
1477    /// Trend confidence
1478    pub confidence: f64,
1479}
1480/// Pattern detection result
1481#[derive(Debug, Clone, Serialize, Deserialize)]
1482pub struct PatternDetectionResult {
1483    /// Pattern name
1484    pub pattern_name: String,
1485    /// Detection confidence
1486    pub confidence: f64,
1487    /// Pattern locations
1488    pub locations: Vec<CircuitLocation>,
1489    /// Pattern statistics
1490    pub statistics: PatternStatistics,
1491    /// Performance characteristics
1492    pub performance_profile: PatternPerformanceProfile,
1493}
1494/// Interaction types between patterns
1495#[derive(Debug, Clone, Serialize, Deserialize)]
1496pub enum InteractionType {
1497    /// Patterns complement each other
1498    Synergistic,
1499    /// Patterns interfere with each other
1500    Conflicting,
1501    /// Patterns are independent
1502    Independent,
1503    /// One pattern subsumes another
1504    Subsumption,
1505    /// Patterns are equivalent
1506    Equivalent,
1507}
quantrs2_circuit/linter/types.rs

quantrs2_circuit/linter/
types.rs
