drafting of upgrade

Author: oslfmt

lints/duplicate-mutable-accounts/Cargo.toml

@@ -13,6 +13,10 @@ crate-type = ["cdylib"]
 name = "insecure"
 path = "ui/insecure/src/lib.rs"
 
+[[example]]
+name = "insecure-2"
+path = "ui/insecure-2/src/lib.rs"
+
 [[example]]
 name = "secure"
 path = "ui/secure/src/lib.rs"
@@ -21,6 +25,8 @@ path = "ui/secure/src/lib.rs"
 clippy_utils = { git = "https://github.com/rust-lang/rust-clippy", rev = "7b2896a8fc9f0b275692677ee6d2d66a7cbde16a" }
 dylint_linting = "2.0.1"
 if_chain = "1.0.2"
+proc-macro2 = "1.0.40"
+quote = "1.0.20"
 solana-lints = { path = "../../crate" }
 
 [dev-dependencies]

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

@@ -5,6 +5,10 @@ extern crate rustc_ast;
 extern crate rustc_hir;
 extern crate rustc_span;
 
+use proc_macro2::*;
+use quote::quote;
+use std::str::FromStr;
+
 use rustc_ast::{
     token::TokenKind,
     tokenstream::{TokenStream, TokenTree},
@@ -14,7 +18,7 @@ use rustc_hir::def::Res;
 use rustc_hir::*;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_span::{def_id::DefId, symbol::Symbol, Span};
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet, VecDeque};
 use std::default::Default;
 
 use clippy_utils::{diagnostics::span_lint_and_help, ty::match_type};
@@ -46,7 +50,7 @@ dylint_linting::impl_late_lint! {
 #[derive(Default, Debug)]
 struct DuplicateMutableAccounts {
     accounts: HashMap<DefId, Vec<(Symbol, Span)>>,
-    streams: Vec<Stream>,
+    streams: Streams,
 }
 
 impl<'tcx> LateLintPass<'tcx> for DuplicateMutableAccounts {
@@ -81,13 +85,16 @@ impl<'tcx> LateLintPass<'tcx> for DuplicateMutableAccounts {
         // println!("{:#?}", self.accounts);
         if_chain! {
             if let AttrKind::Normal(attr_item, _) = &attribute.kind;
-            let name = attr_item.path.segments[0].ident.name;
+            let name = attr_item.path.segments[0].ident.name; // TODO: can use name_or_empty
             // for some reason #[account] doesn't match when no args, maybe take away
             // the code to check name, and just check it has constraint args?
             if name.as_str() == "account";
             if let MacArgs::Delimited(_, _, token_stream) = &attr_item.args;
             then {
-                self.streams.push(Stream(token_stream.clone()));
+                // TODO: figure out stream representation. At this point, may parse?
+                // TODO: filter mechanism: only insert constraints that match form "constraint = _.key() != _.key()"
+                // TODO: may need to parse each constraint as a separate stream, as comma-delimited
+                self.streams.0.push(token_stream.clone());
                 // println!("{:#?}", attribute);
             }
         }
@@ -96,19 +103,22 @@ impl<'tcx> LateLintPass<'tcx> for DuplicateMutableAccounts {
     fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
         // println!("{:#?}", self);
         for (_k, v) in self.accounts.iter() {
-            // if multiple same accounts, check that there is a tokenstream such that
-            // all necessary expressions are in it: x.key(), y.key(), !=
-            // where x and y are the field name from self.accounts
             if v.len() > 1 {
-                if !has_satisfying_stream(&self.streams, v) {
-                    span_lint_and_help(
-                        cx,
-                        DUPLICATE_MUTABLE_ACCOUNTS,
-                        v[0].1,
-                        "identical account types",
-                        Some(v[1].1),
-                        &format!("add an anchor key check constraint: #[account(constraint = {}.key() != {}.key())]", v[0].0, v[1].0)
-                    );
+                // generate static set of possible constraints
+                let gen_constraints = generate_possible_expected_constraints(v);
+
+                // assert the following checks:
+                for (one, reflexive) in gen_constraints {
+                    if !(self.streams.contains(one) || self.streams.contains(reflexive)) {
+                        //     span_lint_and_help(
+                        //         cx,
+                        //         DUPLICATE_MUTABLE_ACCOUNTS,
+                        //         v[0].1,
+                        //         "identical account types",
+                        //         Some(v[1].1),
+                        //         &format!("add an anchor key check constraint: #[account(constraint = {}.key() != {}.key())]", v[0].0, v[1].0)
+                        //     );
+                    }
                 }
             }
         }
@@ -117,6 +127,7 @@ impl<'tcx> LateLintPass<'tcx> for DuplicateMutableAccounts {
 
 fn get_anchor_account_type(segment: &PathSegment<'_>) -> Option<DefId> {
     if_chain! {
+        // TODO: the following logic to get def_id is a repeated pattern
         if let Some(generic_args) = segment.args;
         if let GenericArg::Type(ty) = &generic_args.args[1]; // the account type is the second generic arg
         if let TyKind::Path(qpath) = &ty.kind;
@@ -130,34 +141,38 @@ fn get_anchor_account_type(segment: &PathSegment<'_>) -> Option<DefId> {
     }
 }
 
-fn has_satisfying_stream(streams: &Vec<Stream>, field_names: &Vec<(Symbol, Span)>) -> bool {
-    for stream in streams {
-        if stream.contains(TokenKind::Ne)
-            && field_names
-                .iter()
-                // TODO: if true, will not match. figure out what the bool signifies
-                .all(|(sym, _)| stream.contains(TokenKind::Ident(*sym, false)))
-        {
-            return true;
+/// Generates a static set of a possible expected key check constraints necessary for `values`.
+fn generate_possible_expected_constraints(values: &Vec<(Symbol, Span)>) -> Vec<(proc_macro2::TokenStream, proc_macro2::TokenStream)> {
+    // TODO: may start with a VecDeque in the first place?
+    let mut deq = VecDeque::from(values.clone());
+    let mut gen_set = Vec::new();
+
+    for _ in 0..deq.len() - 1 {
+        let first = deq.pop_front().unwrap().0;
+        // generate stream for all other values in vec
+        for (other, _) in &deq {
+            let constraint = format!("constraint = {}.key() != {}.key()", first.as_str(), other.as_str());
+            let reflexive = format!("constraint = {}.key() != {}.key()", other.as_str(), first.as_str());      
+
+            // using quote
+            // let stream = quote!(constraint = first.as_str().key() != other.as_str().key());
+
+            let stream: proc_macro2::TokenStream = constraint.parse().unwrap();
+            let reflex_stream: proc_macro2::TokenStream = reflexive.parse().unwrap();
+            // println!("{:#?}", stream);
+
+            gen_set.push((stream, reflex_stream));
         }
     }
-    return false;
+    gen_set
 }
 
-#[derive(Debug)]
-pub struct Stream(TokenStream);
+#[derive(Debug, Default)]
+pub struct Streams(Vec<TokenStream>);
 
-impl Stream {
-    fn contains(&self, x: TokenKind) -> bool {
-        for token_tree in self.0.trees() {
-            if let TokenTree::Token(t) = token_tree {
-                if t.kind == x {
-                    // println!("The type {:?} matches {:?}", t.kind, x);
-                    return true;
-                }
-            }
-        }
-        return false;
+impl Streams {
+    fn contains(&self, other: TokenStream) -> bool {
+        self.0.iter().any(|stream| stream == &other)
     }
 }
 
@@ -166,7 +181,36 @@ fn insecure() {
     dylint_testing::ui_test_example(env!("CARGO_PKG_NAME"), "insecure");
 }
 
+#[test]
+fn insecure_2() {
+    dylint_testing::ui_test_example(env!("CARGO_PKG_NAME"), "insecure-2");
+}
+
 #[test]
 fn secure() {
     dylint_testing::ui_test_example(env!("CARGO_PKG_NAME"), "secure");
 }
+
+// fn has_satisfying_stream(streams: &Vec<Stream>, field_names: &Vec<(Symbol, Span)>) -> bool {
+//     for stream in streams {
+//         if stream.contains(TokenKind::Ne)
+//             && field_names
+//                 .iter()
+//                 // TODO: if true, will not match. figure out what the bool signifies
+//                 .all(|(sym, _)| stream.contains(TokenKind::Ident(*sym, false)))
+//         {
+//             return true;
+//         }
+//     }
+//     return false;
+// }
+
+// Generates a TokenStream that matches `constraint = a.key() != b.key()` and its reflexive
+// fn generate_key_check_constraint(a: Symbol, b: Symbol) -> (TokenStream, TokenStream) {
+//     let mut tree_and_spacing = vec![];
+//     // create token
+//     let tree = TokenTree::token(TokenKind::Ident(Symbol::intern("constraint"), false), span); // TODO: generate span somehow
+//     tree_and_spacing.push(TreeAndSpacing::from(tree));
+
+//     TokenStream::new(tree_and_spacing)
+// }