make lint-6v1 handle anchor constraints that are not comma-delimited

Author: oslfmt

lints/duplicate-mutable-accounts/src/lib.rs

@@ -10,7 +10,7 @@ use std::default::Default;
 
 use rustc_ast::{
     token::{Delimiter, Token, TokenKind},
-    tokenstream::{CursorRef, DelimSpan, TokenStream, TokenTree, TreeAndSpacing},
+    tokenstream::{DelimSpan, TokenStream, TokenTree, TreeAndSpacing},
     AttrKind, Attribute, MacArgs,
 };
 use rustc_hir::{def::Res, FieldDef, GenericArg, QPath, TyKind, VariantData};
@@ -84,9 +84,10 @@ impl<'tcx> LateLintPass<'tcx> for DuplicateMutableAccounts {
             if let MacArgs::Delimited(_, _, token_stream) = &attr_item.args;
             then {
                 // Parse each constraint as a separate TokenStream
-                for delimited_stream in split(token_stream.trees(), TokenKind::Comma) {
-                    self.streams.0.push(delimited_stream);
-                }
+                // for delimited_stream in split(token_stream.trees(), TokenKind::Comma) {
+                //     self.streams.0.push(delimited_stream);
+                // }
+                self.streams.0.push(token_stream.clone());
             }
         }
     }
@@ -107,6 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for DuplicateMutableAccounts {
                             || self.streams.contains(&symmetric_stream))
                         {
                             // NOTE: for some reason, will only print out 2 messages, not 3
+                            // println!("spanning lint");
                             span_lint_and_help(
                                 cx,
                                 DUPLICATE_MUTABLE_ACCOUNTS,
@@ -155,31 +157,11 @@ fn get_def_id(ty: &rustc_hir::Ty) -> Option<DefId> {
     }
 }
 
-/// Splits `stream` into a vector of substreams, separated by `delimiter`.
-fn split(stream: CursorRef, delimiter: TokenKind) -> Vec<TokenStream> {
-    let mut split_streams: Vec<TokenStream> = Vec::new();
-    let mut temp: Vec<TreeAndSpacing> = Vec::new();
-    let delim = TokenTree::Token(Token::new(delimiter, DUMMY_SP));
-
-    stream.for_each(|t| {
-        if t.eq_unspanned(&delim) {
-            split_streams.push(TokenStream::new(temp.clone()));
-            temp.clear();
-        } else {
-            temp.push(TreeAndSpacing::from(t.clone()));
-        }
-    });
-    split_streams.push(TokenStream::new(temp));
-    split_streams
-}
-
-/// Returns a `TokenStream` of form: constraint = `a`.key() != `b`.key().
+/// Returns a `TokenStream` of form: `a`.key() != `b`.key().
 fn create_key_check_constraint_tokenstream(a: Symbol, b: Symbol) -> TokenStream {
     // TODO: may be more efficient way to do this, since the stream is effectively fixed
     // and determined. Only two tokens are variable.
     let constraint = vec![
-        TreeAndSpacing::from(create_token_from_ident("constraint")),
-        TreeAndSpacing::from(TokenTree::Token(Token::new(TokenKind::Eq, DUMMY_SP))),
         TreeAndSpacing::from(create_token_from_ident(a.as_str())),
         TreeAndSpacing::from(TokenTree::Token(Token::new(TokenKind::Dot, DUMMY_SP))),
         TreeAndSpacing::from(create_token_from_ident("key")),
@@ -212,13 +194,59 @@ fn create_token_from_ident(s: &str) -> TokenTree {
 pub struct Streams(Vec<TokenStream>);
 
 impl Streams {
-    /// Returns true if `self` contains `other`, by comparing if there is an
-    /// identical `TokenStream` in `self` regardless of span.
+    /// Returns true if `self` has a TokenStream that `other` is a substream of
     fn contains(&self, other: &TokenStream) -> bool {
-        self.0.iter().any(|stream| stream.eq_unspanned(other))
+        self.0
+            .iter()
+            .any(|token_stream| Self::is_substream(token_stream, other))
+    }
+
+    /// Returns true if `other` is a substream of `stream`. By substream we mean in the
+    /// sense of a substring.
+    // NOTE: a possible optimization is when a match is found, to remove the matched
+    // TokenTrees from the TokenStream, since the constraint has been "checked" so it never
+    // needs to be validated again. This cuts down the number of comparisons.
+    fn is_substream(stream: &TokenStream, other: &TokenStream) -> bool {
+        let other_len = other.len();
+        for i in 0..stream.len() {
+            for (j, other_token) in other.trees().enumerate() {
+                match stream.trees().nth(i + j) {
+                    Some(token_tree) => {
+                        // println!("Comparing {:#?} with {:#?}", token_tree, other_tokens[j]);
+                        if !token_tree.eq_unspanned(other_token) {
+                            break;
+                        }
+                        // reached last index, so we have a match
+                        if j == other_len - 1 {
+                            return true;
+                        }
+                    }
+                    None => return false, // reached end of stream
+                }
+            }
+        }
+        false
     }
 }
 
+// /// Splits `stream` into a vector of substreams, separated by `delimiter`.
+// fn split(stream: CursorRef, delimiter: TokenKind) -> Vec<TokenStream> {
+//     let mut split_streams: Vec<TokenStream> = Vec::new();
+//     let mut temp: Vec<TreeAndSpacing> = Vec::new();
+//     let delim = TokenTree::Token(Token::new(delimiter, DUMMY_SP));
+
+//     stream.for_each(|t| {
+//         if t.eq_unspanned(&delim) {
+//             split_streams.push(TokenStream::new(temp.clone()));
+//             temp.clear();
+//         } else {
+//             temp.push(TreeAndSpacing::from(t.clone()));
+//         }
+//     });
+//     split_streams.push(TokenStream::new(temp));
+//     split_streams
+// }
+
 #[test]
 fn insecure() {
     dylint_testing::ui_test_example(env!("CARGO_PKG_NAME"), "insecure");

lints/duplicate-mutable-accounts/ui/recommended-2/src/lib.rs

@@ -22,8 +22,7 @@ pub mod duplicate_mutable_accounts_recommended {
 
 #[derive(Accounts)]
 pub struct Update<'info> {
-    #[account(constraint = user_a.key() != user_b.key())]
-    #[account(constraint = user_a.key() != user_c.key())]
+    #[account(constraint = user_a.key() != user_b.key() && user_a.key() != user_c.key())]
     #[account(constraint = user_c.key() != user_b.key())]
     user_a: Account<'info, User>,
     user_b: Account<'info, User>,