internal: prepare a dedicated module for all operators

Author: matklad

crates/syntax/src/ast.rs

@@ -5,6 +5,7 @@ mod traits;
 mod token_ext;
 mod node_ext;
 mod expr_ext;
+mod operators;
 pub mod edit;
 pub mod edit_in_place;
 pub mod make;
@@ -17,14 +18,21 @@ use crate::{
 };
 
 pub use self::{
-    expr_ext::{ArrayExprKind, BinOp, Effect, ElseBranch, LiteralKind, PrefixOp, RangeOp},
+    expr_ext::{ArrayExprKind, BinOp, Effect, ElseBranch, LiteralKind},
     generated::{nodes::*, tokens::*},
     node_ext::{
         AttrKind, AttrsOwnerNode, FieldKind, Macro, NameLike, NameOrNameRef, PathSegmentKind,
         SelfParamKind, SlicePatComponents, StructKind, TypeBoundKind, VisibilityKind,
     },
-    token_ext::*,
-    traits::*,
+    operators::{PrefixOp, RangeOp},
+    token_ext::{
+        CommentKind, CommentPlacement, CommentShape, HasFormatSpecifier, IsString, QuoteOffsets,
+        Radix,
+    },
+    traits::{
+        ArgListOwner, AttrsOwner, CommentIter, DocCommentsOwner, GenericParamsOwner, LoopBodyOwner,
+        ModuleItemOwner, NameOwner, TypeBoundsOwner, VisibilityOwner,
+    },
 };
 
 /// The main trait to go from untyped `SyntaxNode`  to a typed ast. The

crates/syntax/src/ast/expr_ext.rs

@@ -3,7 +3,11 @@
 use rowan::WalkEvent;
 
 use crate::{
-    ast::{self, support, AstChildren, AstNode},
+    ast::{
+        self,
+        operators::{PrefixOp, RangeOp},
+        support, AstChildren, AstNode,
+    },
     AstToken,
     SyntaxKind::*,
     SyntaxToken, T,
@@ -193,24 +197,15 @@ impl ast::IfExpr {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum PrefixOp {
-    /// The `*` operator for dereferencing
-    Deref,
-    /// The `!` operator for logical inversion
-    Not,
-    /// The `-` operator for negation
-    Neg,
-}
-
 impl ast::PrefixExpr {
     pub fn op_kind(&self) -> Option<PrefixOp> {
-        match self.op_token()?.kind() {
-            T![*] => Some(PrefixOp::Deref),
-            T![!] => Some(PrefixOp::Not),
-            T![-] => Some(PrefixOp::Neg),
-            _ => None,
-        }
+        let res = match self.op_token()?.kind() {
+            T![*] => PrefixOp::Deref,
+            T![!] => PrefixOp::Not,
+            T![-] => PrefixOp::Neg,
+            _ => return None,
+        };
+        Some(res)
     }
 
     pub fn op_token(&self) -> Option<SyntaxToken> {
@@ -398,14 +393,6 @@ impl std::fmt::Display for BinOp {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum RangeOp {
-    /// `..`
-    Exclusive,
-    /// `..=`
-    Inclusive,
-}
-
 impl ast::RangeExpr {
     fn op_details(&self) -> Option<(usize, SyntaxToken, RangeOp)> {
         self.syntax().children_with_tokens().enumerate().find_map(|(ix, child)| {

crates/syntax/src/ast/operators.rs

@@ -0,0 +1,17 @@
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum PrefixOp {
+    /// The `*` operator for dereferencing
+    Deref,
+    /// The `!` operator for logical inversion
+    Not,
+    /// The `-` operator for negation
+    Neg,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum RangeOp {
+    /// `..`
+    Exclusive,
+    /// `..=`
+    Inclusive,
+}