WIP

crates/cairo-lint-core/src/lints/loops.rs

@@ -0,0 +1,67 @@
+use cairo_lang_defs::ids::{FileIndex, ModuleFileId, ModuleId, NamedLanguageElementId};
+use cairo_lang_defs::plugin::PluginDiagnostic;
+use cairo_lang_diagnostics::DiagnosticsBuilder;
+use cairo_lang_semantic::db::SemanticGroup;
+use cairo_lang_semantic::diagnostic::NotFoundItemType;
+use cairo_lang_semantic::expr::inference::InferenceId;
+use cairo_lang_semantic::resolve::{ResolvedConcreteItem, ResolvedGenericItem, Resolver};
+use cairo_lang_semantic::{ExprFunctionCall, ExprMatch};
+use cairo_lang_syntax::node::ast::{Expr, ExprLoop, Statement, TerminalIdentifier};
+use cairo_lang_syntax::node::TypedSyntaxNode;
+use cairo_lang_utils::try_extract_matches;
+
+pub fn check_loop_match_pop_front(
+    db: &dyn SemanticGroup,
+    loop_expr: &ExprLoop,
+    diagnostics: &mut Vec<PluginDiagnostic>,
+    module_id: &ModuleId,
+) {
+    let statements = loop_expr.body(db.upcast()).statements(db.upcast()).elements(db.upcast());
+    for statement in statements {
+        if let Statement::Expr(expr) = statement
+            && let Expr::Match(expr_match) = expr.expr(db.upcast())
+        {
+            let res = match expr_match.expr(db.upcast()) {
+                Expr::FunctionCall(func_call) => "".to_owned(),
+                Expr::Binary(binary_expr) => {
+                    if let Expr::FunctionCall(func_call) =
+                        Expr::from_syntax_node(db.upcast(), binary_expr.rhs(db.upcast()).as_syntax_node())
+                    {
+                        let mut diagnostics = DiagnosticsBuilder::default();
+                        if let Expr::Path(pat) =
+                            Expr::from_syntax_node(db.upcast(), binary_expr.lhs(db.upcast()).as_syntax_node())
+                        {
+                            let identifier = TerminalIdentifier::from_syntax_node(
+                                db.upcast(),
+                                pat.as_syntax_node().parent().unwrap(),
+                            );
+                            db.upcast().find_lookup_item(pat.as_syntax_node());
+                            let item =
+                                db.lookup_resolved_generic_item_by_ptr(lookup_item_id, identifier.stable_ptr())?;
+                            Some(format!("`{}`", item.full_path(db)));
+                            println!("Path {}", pat.node.get_text(db.upcast()));
+                            let item =
+                                Resolver::new(db, ModuleFileId(*module_id, FileIndex(0)), InferenceId::NoContext)
+                                    .resolve_generic_path(
+                                        &mut diagnostics,
+                                        &func_call.path(db.upcast()),
+                                        NotFoundItemType::Identifier,
+                                    )
+                                    .unwrap();
+                            let generic_variant = try_extract_matches!(item, ResolvedGenericItem::Variable).unwrap();
+                            println!("Func {:?}", generic_variant)
+                        };
+                    };
+                    format!(
+                        "Right {}",
+                        binary_expr.rhs(db.upcast()).as_syntax_node().get_text_without_trivia(db.upcast())
+                    )
+                }
+                _ => "".to_owned(),
+            };
+
+            println!("{}", res);
+        }
+        // println!("Statement: {:?}", statement);
+    }
+}

crates/cairo-lint-core/src/lints/mod.rs

@@ -1 +1,2 @@
+pub mod loops;
 pub mod single_match;

crates/cairo-lint-core/src/plugin.rs

@@ -2,11 +2,11 @@ use cairo_lang_defs::ids::{ModuleId, ModuleItemId};
 use cairo_lang_defs::plugin::PluginDiagnostic;
 use cairo_lang_semantic::db::SemanticGroup;
 use cairo_lang_semantic::plugin::{AnalyzerPlugin, PluginSuite};
-use cairo_lang_syntax::node::ast::ExprMatch;
+use cairo_lang_syntax::node::ast::{ExprLoop, ExprMatch};
 use cairo_lang_syntax::node::kind::SyntaxKind;
 use cairo_lang_syntax::node::TypedSyntaxNode;
 
-use crate::lints::single_match;
+use crate::lints::{loops, single_match};
 
 pub fn cairo_lint_plugin_suite() -> PluginSuite {
     let mut suite = PluginSuite::default();
@@ -51,6 +51,12 @@ impl AnalyzerPlugin for CairoLint {
                                 &mut diags,
                                 &module_id,
                             ),
+                            SyntaxKind::ExprLoop => loops::check_loop_match_pop_front(
+                                db,
+                                &ExprLoop::from_syntax_node(db.upcast(), descendant),
+                                &mut diags,
+                                &module_id,
+                            ),
                             SyntaxKind::ItemExternFunction => (),
                             _ => (),
                         }

crates/cairo-lint-core/tests/test_files/loops/loop_match_pop_front

@@ -0,0 +1,11 @@
+//! > simple loop match pop front
+//! > cairo_code
+fn main() {
+    let a: Span<felt252> = array![1, 2, 3, 4, 5].span();
+    loop {
+        match a.pop_front() {
+            Option::Some(val) => println!("{val}"),
+            Option::None => break,
+        }
+    }
+}

crates/cairo-lint-core/tests/tests.rs

@@ -33,3 +33,5 @@ test_file!(
     "simple destructuring match with unit and comment in scope",
     "simple destructuring match with comment in scope"
 );
+
+test_file!(loops, loop_match_pop_front, "simple loop match pop front");