fix warnings

Author: myfreess

cli_args.mbt

@@ -27,68 +27,60 @@ fn runtime_cli_args(argv : Array[String]) -> Array[String] {
 }
 
 ///|
-let scan_command : @argparse.Command = @argparse.Command(
+let scan_command : @argparse.Command = Command(
   "scan",
   about="Scan MoonBit source files with structural and taint rules.",
   flags=[
-    @argparse.FlagArg(
+    FlagArg(
       "verbose",
       long="verbose",
       about="Print loaded rule ids and directory traversal progress.",
     ),
-    @argparse.FlagArg(
+    FlagArg(
       "enable-builtin-rules",
       long="enable-builtin-rules",
       about="Enable embedded builtin rules.",
     ),
   ],
   options=[
-    @argparse.OptionArg(
+    OptionArg(
       "rules",
       short='r',
-      action=@argparse.OptionAction::Append,
+      action=Append,
       about="Directory containing YAML rules.",
     ),
-    @argparse.OptionArg(
-      "rule",
-      action=@argparse.OptionAction::Append,
-      about="Single YAML rule file.",
-    ),
-    @argparse.OptionArg(
+    OptionArg("rule", action=Append, about="Single YAML rule file."),
+    OptionArg(
       "pattern",
-      action=@argparse.OptionAction::Append,
+      action=Append,
       about="Anonymous structural pattern to match.",
     ),
-    @argparse.OptionArg(
+    OptionArg(
       "guard",
-      action=@argparse.OptionAction::Append,
+      action=Append,
       about="YAML guard map for the preceding anonymous pattern.",
     ),
-    @argparse.OptionArg(
+    OptionArg(
       "exclude-dir",
-      action=@argparse.OptionAction::Append,
+      action=Append,
       about="Directory name or path to skip while recursively scanning.",
     ),
   ],
-  positionals=[@argparse.PositionArg("scan-root", about="Directory to scan.")],
+  positionals=[PositionArg("scan-root", about="Directory to scan.")],
 )
 
 ///|
-let docs_command : @argparse.Command = @argparse.Command(
+let docs_command : @argparse.Command = Command(
   "docs",
   about="Print embedded moongrep documentation.",
   flags=[
-    @argparse.FlagArg(
-      "list",
-      long="list",
-      about="List available embedded documents.",
-    ),
+    FlagArg("list", long="list", about="List available embedded documents."),
   ],
   positionals=[
-    @argparse.PositionArg(
+    PositionArg(
       "doc-name",
       about="Document name to print.",
-      num_args=@argparse.ValueRange(lower=0, upper=1),
+      num_args=ValueRange(lower=0, upper=1),
     ),
   ],
 )
@@ -108,7 +100,7 @@ let dump_command : @argparse.Command = Command(
 )
 
 ///|
-let moongrep_command : @argparse.Command = @argparse.Command(
+let moongrep_command : @argparse.Command = Command(
   "moongrep",
   about="Scan MoonBit source files with structural and taint rules.",
   subcommands=[scan_command, docs_command, dump_command],

matching/matching.mbt

@@ -32,7 +32,7 @@ pub fn match_expr_pattern(
   compiled : CompiledExprPattern,
   candidate : @untyped_ast.Node,
 ) -> ExprMatch? {
-  let bindings : @hashmap.HashMap[String, BoundValue] = @hashmap.HashMap([])
+  let bindings : @hashmap.HashMap[String, BoundValue] = HashMap([])
   match_expr_pattern_with_bindings(compiled, candidate, bindings)
 }
 

matching/matching_test.mbt

@@ -22,7 +22,7 @@ fn test_loc() -> @basic.Location {
 
 ///|
 fn test_var(name : String) -> @syntax.Var {
-  { name: @syntax.LongIdent::Ident(name~), loc: test_loc() }
+  { name: Ident(name~), loc: test_loc() }
 }
 
 ///|
@@ -37,17 +37,15 @@ fn test_pattern_var(name : String) -> @syntax.Pattern {
 
 ///|
 fn test_pattern_tuple(items : Array[@syntax.Pattern]) -> @syntax.Pattern {
-  Tuple(pats=@list.from_array(items), loc=test_loc())
+  Tuple(pats=List(items), loc=test_loc())
 }
 
 ///|
 fn test_match_pattern(pattern : @syntax.Pattern) -> @untyped_ast.Node {
   @untyped_ast.from_expr(
     Match(
       expr=test_ident("input"),
-      cases=@list.from_array([
-        { pattern, guard_: None, body: test_ident("body") },
-      ]),
+      cases=List([{ pattern, guard_: None, body: test_ident("body") }]),
       match_loc=test_loc(),
       loc=test_loc(),
     ),
@@ -66,17 +64,13 @@ fn test_field_def(label : String, expr : @syntax.Expr) -> @syntax.FieldDef {
 
 ///|
 fn test_ident(name : String) -> @syntax.Expr {
-  @syntax.Expr::Ident(id=test_var(name), loc=test_loc())
+  Ident(id=test_var(name), loc=test_loc())
 }
 
 ///|
 fn test_implies(lhs : String, rhs : String) -> @untyped_ast.Node {
   @untyped_ast.from_expr(
-    @syntax.Expr::Implies(
-      lhs=test_ident(lhs),
-      rhs=test_ident(rhs),
-      loc=test_loc(),
-    ),
+    Implies(lhs=test_ident(lhs), rhs=test_ident(rhs), loc=test_loc()),
   )
 }
 
@@ -86,19 +80,15 @@ fn test_foreach_syntax(
   continue_value : String,
   where_value : String,
 ) -> @syntax.Expr {
-  @syntax.Expr::ForEach(
-    binders=@list.from_array([Some(test_binder("item"))]),
+  ForEach(
+    binders=List([Some(test_binder("item"))]),
     expr=test_ident("items"),
-    init=@list.from_array([(test_binder("start"), test_ident(init))]),
-    continue_block=@list.from_array([
-      (test_binder("next"), test_ident(continue_value)),
-    ]),
+    init=List([(test_binder("start"), test_ident(init))]),
+    continue_block=List([(test_binder("next"), test_ident(continue_value))]),
     body=test_ident("body"),
     else_block=None,
     where_clause=Some({
-      fields: @list.from_array([
-        test_field_def("field", test_ident(where_value)),
-      ]),
+      fields: List([test_field_def("field", test_ident(where_value))]),
       loc: test_loc(),
     }),
     label=None,

matching/untyped_matching_test.mbt

@@ -53,13 +53,13 @@ fn untyped_test_pattern_var(name : String) -> @syntax.Pattern {
 fn untyped_test_pattern_tuple(
   items : Array[@syntax.Pattern],
 ) -> @syntax.Pattern {
-  Tuple(pats=@list.from_array(items), loc=untyped_test_loc())
+  Tuple(pats=List(items), loc=untyped_test_loc())
 }
 
 ///|
 fn untyped_test_ident(name : String) -> @syntax.Expr {
-  @syntax.Expr::Ident(
-    id={ name: @syntax.LongIdent::Ident(name~), loc: untyped_test_loc() },
+  Ident(
+    id={ name: Ident(name~), loc: untyped_test_loc() },
     loc=untyped_test_loc(),
   )
 }
@@ -68,9 +68,7 @@ fn untyped_test_ident(name : String) -> @syntax.Expr {
 fn untyped_test_match_pattern(pattern : @syntax.Pattern) -> @syntax.Expr {
   Match(
     expr=untyped_test_ident("input"),
-    cases=@list.from_array([
-      { pattern, guard_: None, body: untyped_test_ident("body") },
-    ]),
+    cases=List([{ pattern, guard_: None, body: untyped_test_ident("body") }]),
     match_loc=untyped_test_loc(),
     loc=untyped_test_loc(),
   )

query/query.mbt

@@ -80,7 +80,7 @@ fn anonymous_pattern_rule(pattern : String) -> RawRuleSpec {
       inside_expr: None,
       patterns: [{ shape: pattern, guards: {} }],
       patterns_not: [],
-      patterns_not_mode: @rule_model.StructuralPatternsNotMode::PruneOnNegative,
+      patterns_not_mode: PruneOnNegative,
     }),
   }
 }
@@ -93,7 +93,7 @@ fn collect_node_matches(
 ) -> Unit {
   @untyped_ast.visit_node_scoped_expr_roots(ast, fn(scoped_expr) {
     collect_scoped_node_matches(pattern, scoped_expr, matches)
-    @untyped_ast.NodeVisitAction::NodeVisitPrune
+    NodeVisitPrune
   })
 }
 

render.mbt

@@ -75,7 +75,7 @@ fn render_source_context_line(
 
 ///|
 fn render_gray(text : String) -> String {
-  @chalk.chalk().color(@chalk.Colors::BlackBright).render(text)
+  @chalk.chalk().color(BlackBright).render(text)
 }
 
 ///|

rule/apply/apply.mbt

@@ -59,7 +59,7 @@ pub fn apply_structural_rules_to_node(
     apply_ast_structural_rule_entries_to_scoped_expr(
       file, entries, scoped_expr, hits,
     )
-    @untyped_ast.NodeVisitAction::NodeVisitPrune
+    NodeVisitPrune
   })
   hits
 }
@@ -171,7 +171,7 @@ pub fn apply_taint_rules(
   rules : Array[CompiledRule],
 ) -> Array[RuleFinding] raise {
   let hits : Array[RuleFinding] = []
-  if root_node.kind == @untyped_ast.NodeKind::ImplList {
+  if root_node.kind == ImplList {
     for entry in root_node.children {
       let (_, node) = entry
       let node_hits = apply_taint_rules_to_node(file, node, rules)
@@ -274,7 +274,7 @@ fn apply_inside_expr_ast_bucketed(
         )
       } else {
         match structural.patterns_not_mode {
-          @model.StructuralPatternsNotMode::RejectUncoveredNegative =>
+          RejectUncoveredNegative =>
             apply_ast_bucketed_covered_patterns_in_target_subtree(
               file,
               rule,
@@ -286,7 +286,7 @@ fn apply_inside_expr_ast_bucketed(
               inside.compiled.identifier_metavars,
               hits,
             )
-          @model.StructuralPatternsNotMode::PruneOnNegative =>
+          PruneOnNegative =>
             apply_ast_bucketed_patterns_in_target_subtree(
               file,
               rule,
@@ -322,8 +322,8 @@ fn apply_ast_bucketed_patterns_in_target_subtree(
         file, rule, pattern_buckets, negative_pattern_buckets, scoped_expr, outer_loc,
         outer_bindings, inherited_identifier_metavars, hits,
       ) {
-      RulePrune => @untyped_ast.NodeVisitAction::NodeVisitPrune
-      RuleContinue => @untyped_ast.NodeVisitAction::NodeVisitContinue
+      RulePrune => NodeVisitPrune
+      RuleContinue => NodeVisitContinue
     }
   })
 }
@@ -344,19 +344,19 @@ fn apply_ast_bucketed_covered_patterns_in_target_subtree(
   let mut rejected = false
   @untyped_ast.visit_node_scoped_exprs(target, fn(scoped_expr) {
     if rejected {
-      @untyped_ast.NodeVisitAction::NodeVisitPrune
+      NodeVisitPrune
     } else {
       match
         apply_ast_bucketed_covered_patterns_at_scoped_expr(
           file, rule, pattern_buckets, negative_pattern_buckets, scoped_expr, outer_loc,
           outer_bindings, inherited_identifier_metavars, pending_hits,
         ) {
-        InsideTargetPrune => @untyped_ast.NodeVisitAction::NodeVisitPrune
+        InsideTargetPrune => NodeVisitPrune
         InsideTargetReject => {
           rejected = true
-          @untyped_ast.NodeVisitAction::NodeVisitPrune
+          NodeVisitPrune
         }
-        InsideTargetContinue => @untyped_ast.NodeVisitAction::NodeVisitContinue
+        InsideTargetContinue => NodeVisitContinue
       }
     }
   })
@@ -641,7 +641,7 @@ fn ast_guards_match(
 ) -> Bool {
   for guard_entry in guards {
     match guard_entry.capture_kind {
-      @model.RuleGuardCaptureKind::IdentifierGuard =>
+      IdentifierGuard =>
         match bindings.get(guard_entry.name) {
           Some(value) => {
             guard node_leaf_string(value) is Some(text) else { return false }
@@ -651,7 +651,7 @@ fn ast_guards_match(
           }
           _ => return false
         }
-      @model.RuleGuardCaptureKind::ConstantGuard =>
+      ConstantGuard =>
         match bindings.get(guard_entry.name) {
           Some(value) => {
             guard constant_guard_value(value) is Some(text) else {