Treat method calls on builtin literals as side-effect-free

Summary:
A method call whose receiver is a freshly-constructed builtin literal, e.g.
`[].append(x)`, operates on a value with no external aliasing, so it cannot
have an import-time side effect.

Rather than try to infer the type and find the corresponding builtin method, we
just return early. (Without this fix we would get a false positive
`unknown-method`).

Reviewed By: brittanyrey

Differential Revision: D108094683

fbshipit-source-id: b7cb0f7a9123bfb8ae6f403e6a87fa3e2e6c0a5e

Author: martindemello

src/source_analyzer.rs

@@ -137,6 +137,25 @@ fn get_qualified_import(res: &ResolvedName, attribute_module: &ModuleName) -> Op
     Some(full_module)
 }
 
+fn is_builtin_literal(expr: &Expr) -> bool {
+    matches!(
+        expr,
+        Expr::StringLiteral(_)
+            | Expr::BytesLiteral(_)
+            | Expr::NumberLiteral(_)
+            | Expr::BooleanLiteral(_)
+            | Expr::FString(_)
+            | Expr::TString(_)
+            | Expr::List(_)
+            | Expr::Dict(_)
+            | Expr::Set(_)
+            | Expr::Tuple(_)
+            | Expr::ListComp(_)
+            | Expr::SetComp(_)
+            | Expr::DictComp(_)
+    )
+}
+
 /// Implementation of Analyzer for source files (.py).
 pub struct SourceAnalyzer<'a> {
     parsed_module: &'a ParsedModule,
@@ -319,6 +338,13 @@ impl<'a> SourceAnalyzer<'a> {
     }
 
     fn unknown_function_name(&self, func: &Expr, output: &mut ModuleEffects) {
+        // A method call whose receiver is a freshly-constructed builtin literal operates on a value
+        // with no external aliasing, so it cannot have an import-time side effect.
+        if let Expr::Attribute(e) = func
+            && is_builtin_literal(&e.value)
+        {
+            return;
+        }
         trace!("Unknown call: {}(...)", format::format_expr(func));
         let name = match func {
             Expr::Attribute(e) => match *e.value {

tests/calls.rs

@@ -175,6 +175,34 @@ def f(x):
         check(code);
     }
 
+    #[test]
+    fn test_method_call_on_literal_safe() {
+        // A method call on a freshly-constructed builtin literal is safe.
+        let code = r#"
+a = ":".join(["x", "y"])
+b = "hello".upper()
+c = [1, 2].index(1)
+d = {"k": 1}.get("k")
+e = (1, 2).count(1)
+f = {1, 2}.union({3})
+g = b"x".decode()
+h = f"v={a}".strip()
+i = [x for x in range(3)].pop()
+"#;
+        check(code);
+    }
+
+    #[test]
+    fn test_method_call_on_literal_still_checks_args() {
+        // The spurious unknown-method-call effect is suppressed, but an imported
+        // argument passed to the literal's method is still flagged.
+        let code = r#"
+import os
+[].append(os)  # E: imported-var-argument
+"#;
+        check_effects(code);
+    }
+
     #[test]
     fn test_imported_method_call() {
         let code1 = r#"