merge lint-6v2 into lint-6v1, creating single lint

oslfmt · oslfmt · commit e42f6448fcd1 · 2022-07-19T13:00:45.000-05:00
diff --git a/lints/duplicate-mutable-accounts/src/alternate_constraint.rs b/lints/duplicate-mutable-accounts/src/alternate_constraint.rs
@@ -0,0 +1,107 @@
+use std::collections::HashMap;
+
+use rustc_hir::{
+    def_id::DefId,
+    intravisit::{walk_expr, Visitor},
+    BinOpKind, Body, Expr, ExprKind, Mutability,
+};
+use rustc_lint::LateContext;
+use rustc_middle::ty::TyKind as MiddleTyKind;
+
+use crate::ANCHOR_ACCOUNT_GENERIC_ARG_COUNT;
+use clippy_utils::{ty::match_type, SpanlessEq};
+use if_chain::if_chain;
+use solana_lints::paths;
+
+pub struct Values<'cx, 'tcx> {
+    cx: &'cx LateContext<'tcx>,
+    pub accounts: HashMap<DefId, Vec<&'tcx Expr<'tcx>>>,
+    pub if_statements: Vec<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>,
+}
+
+impl<'cx, 'tcx> Values<'cx, 'tcx> {
+    pub fn new(cx: &'cx LateContext<'tcx>) -> Self {
+        Values {
+            cx,
+            accounts: HashMap::new(),
+            if_statements: Vec::new(),
+        }
+    }
+
+    pub fn get_referenced_accounts_and_if_statements(&mut self, body: &'tcx Body<'tcx>) -> &Self {
+        self.visit_expr(&body.value);
+        self
+    }
+
+    /// Checks if there is a valid key constraint for `first_account` and `second_account`.
+    /// NOTE: currently only considers `first.key() == second.key()` or the symmetric relation as valid constraints.
+    /// TODO: if == relation used, should return some error in the THEN block
+    pub fn check_key_constraint(
+        &self,
+        first_account: &Expr<'_>,
+        second_account: &Expr<'_>,
+    ) -> bool {
+        for (left, right) in &self.if_statements {
+            if_chain! {
+                if let ExprKind::MethodCall(path_seg_left, exprs_left, _span) = left.kind;
+                if let ExprKind::MethodCall(path_seg_right, exprs_right, _span) = right.kind;
+                if path_seg_left.ident.name.as_str() == "key" && path_seg_right.ident.name.as_str() == "key";
+                if !exprs_left.is_empty() && !exprs_right.is_empty();
+                let mut spanless_eq = SpanlessEq::new(self.cx);
+                if (spanless_eq.eq_expr(&exprs_left[0], first_account) && spanless_eq.eq_expr(&exprs_right[0], second_account))
+                || (spanless_eq.eq_expr(&exprs_left[0], second_account) && spanless_eq.eq_expr(&exprs_right[0], first_account));
+                then {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+}
+
+impl<'cx, 'tcx> Visitor<'tcx> for Values<'cx, 'tcx> {
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        if_chain! {
+            // get mutable reference expressions
+            if let ExprKind::AddrOf(_, mutability, mut_expr) = expr.kind;
+            if let Mutability::Mut = mutability;
+            // check type of expr == Account<'info, T>
+            let middle_ty = self.cx.typeck_results().expr_ty(mut_expr);
+            // let mut_expr_def_id = self.cx.tcx.hir().local_def_id(mut_expr.hir_id).to_def_id();
+            // let middle_ty = self.cx.tcx.type_of(mut_expr_def_id);
+            if match_type(self.cx, middle_ty, &paths::ANCHOR_ACCOUNT);
+            // grab T generic parameter
+            if let MiddleTyKind::Adt(_adt_def, substs) = middle_ty.kind();
+            if substs.len() == ANCHOR_ACCOUNT_GENERIC_ARG_COUNT;
+            let account_type = substs[1].expect_ty();
+            if let Some(adt_def) = account_type.ty_adt_def();
+            then {
+                let def_id = adt_def.did();
+                if let Some(exprs) = self.accounts.get_mut(&def_id) {
+                    let mut spanless_eq = SpanlessEq::new(self.cx);
+                    // check that expr is not a duplicate within its particular key-pair
+                    if exprs.iter().all(|e| !spanless_eq.eq_expr(e, mut_expr)) {
+                        exprs.push(mut_expr);
+                    }
+                } else {
+                    self.accounts.insert(def_id, vec![mut_expr]);
+                }
+            }
+        }
+
+        // get if statements
+        if_chain! {
+            if let ExprKind::If(wrapped_if_expr, _then, _else_opt) = expr.kind;
+            if let ExprKind::DropTemps(if_expr) = wrapped_if_expr.kind;
+            if let ExprKind::Binary(op, left, right) = if_expr.kind;
+            // TODO: leaves out || or &&. Could implement something that pulls apart
+            // an if expr that is of this form into individual == or != comparisons
+            if let BinOpKind::Ne | BinOpKind::Eq = op.node;
+            then {
+                // println!("{:#?}, {:#?}", expr, then);
+                self.if_statements.push((left, right));
+            }
+        }
+        walk_expr(self, expr);
+    }
+}
diff --git a/lints/duplicate-mutable-accounts/src/anchor_constraint.rs b/lints/duplicate-mutable-accounts/src/anchor_constraint.rs
@@ -0,0 +1,118 @@
+use std::default::Default;
+
+use rustc_ast::{
+    token::{Delimiter, Token, TokenKind},
+    tokenstream::{DelimSpan, TokenStream, TokenTree, TreeAndSpacing},
+};
+use rustc_hir::{def::Res, FieldDef, GenericArg, QPath, TyKind};
+use rustc_span::{
+    def_id::DefId,
+    symbol::{Ident, Symbol},
+    DUMMY_SP,
+};
+
+use crate::ANCHOR_ACCOUNT_GENERIC_ARG_COUNT;
+use if_chain::if_chain;
+
+/// Returns the `DefId` of the anchor account type, ie, `T` in `Account<'info, T>`.
+/// Returns `None` if the type of `field` is not an anchor account.
+pub fn get_anchor_account_type_def_id(field: &FieldDef) -> Option<DefId> {
+    if_chain! {
+        if let TyKind::Path(qpath) = &field.ty.kind;
+        if let QPath::Resolved(_, path) = qpath;
+        if !path.segments.is_empty();
+        if let Some(generic_args) = path.segments[0].args;
+        if generic_args.args.len() == ANCHOR_ACCOUNT_GENERIC_ARG_COUNT;
+        if let GenericArg::Type(hir_ty) = &generic_args.args[1];
+        then {
+            get_def_id(hir_ty)
+        } else {
+            None
+        }
+    }
+}
+
+/// Returns the `DefId` of `ty`, an hir type. Returns `None` if cannot resolve type.
+pub fn get_def_id(ty: &rustc_hir::Ty) -> Option<DefId> {
+    if_chain! {
+        if let TyKind::Path(qpath) = &ty.kind;
+        if let QPath::Resolved(_, path) = qpath;
+        if let Res::Def(_, def_id) = path.res;
+        then {
+            Some(def_id)
+        } else {
+            None
+        }
+    }
+}
+
+/// Returns a `TokenStream` of form: `a`.key() != `b`.key().
+pub 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(a.as_str())),
+        TreeAndSpacing::from(TokenTree::Token(Token::new(TokenKind::Dot, DUMMY_SP))),
+        TreeAndSpacing::from(create_token_from_ident("key")),
+        TreeAndSpacing::from(TokenTree::Delimited(
+            DelimSpan::dummy(),
+            Delimiter::Parenthesis,
+            TokenStream::new(vec![]),
+        )),
+        TreeAndSpacing::from(TokenTree::Token(Token::new(TokenKind::Ne, DUMMY_SP))),
+        TreeAndSpacing::from(create_token_from_ident(b.as_str())),
+        TreeAndSpacing::from(TokenTree::Token(Token::new(TokenKind::Dot, DUMMY_SP))),
+        TreeAndSpacing::from(create_token_from_ident("key")),
+        TreeAndSpacing::from(TokenTree::Delimited(
+            DelimSpan::dummy(),
+            Delimiter::Parenthesis,
+            TokenStream::new(vec![]),
+        )),
+    ];
+
+    TokenStream::new(constraint)
+}
+
+/// Returns a `TokenTree::Token` which has `TokenKind::Ident`, with the string set to `s`.
+fn create_token_from_ident(s: &str) -> TokenTree {
+    let ident = Ident::from_str(s);
+    TokenTree::Token(Token::from_ast_ident(ident))
+}
+
+#[derive(Debug, Default)]
+pub struct Streams(pub Vec<TokenStream>);
+
+impl Streams {
+    /// Returns true if `self` has a TokenStream that `other` is a substream of
+    pub fn contains(&self, other: &TokenStream) -> bool {
+        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) => {
+                        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
+    }
+}
diff --git a/lints/duplicate-mutable-accounts/src/lib.rs b/lints/duplicate-mutable-accounts/src/lib.rs
