Prohibit strlit in type expr

Summary:
Prohibit string literals in type expressions unless `starlark-rust: allow_string_literals_in_type_expr` annotation is present.

Previous diffs in this stack add this annotations to every file in fbsource where the annotation is present.

This is to:
* track and migrate string literals in type expressions to proper types
* prevent regressions

Note this does not prohibit string constants in type expressions, but we need to start somewhere.

Reviewed By: cjhopman

Differential Revision: D48916740

fbshipit-source-id: 178a672af4f5454fd42525deb9d6d39b32361e1e

Author: stepancheg

starlark/src/eval/compiler/mod.rs

@@ -84,6 +84,7 @@ pub(crate) struct Compiler<'v, 'a, 'e> {
     pub(crate) codemap: FrozenRef<'static, CodeMap>,
     pub(crate) check_types: bool,
     pub(crate) top_level_stmt_count: usize,
+    pub(crate) allow_string_literals_in_type_expr: bool,
 }
 
 impl Compiler<'_, '_, '_> {

starlark/src/eval/compiler/types.rs

@@ -237,7 +237,11 @@ impl<'v> Compiler<'v, '_, '_> {
             ));
         }
         // This should not fail because we validated it at parse time.
-        let unpack = TypeExprUnpackP::unpack(&type_expr.expr, &self.codemap)?;
+        let unpack = TypeExprUnpackP::unpack(
+            &type_expr.expr,
+            &self.codemap,
+            self.allow_string_literals_in_type_expr,
+        )?;
         let type_value = self.eval_expr_as_type(unpack)?;
         type_expr.payload.compiler_ty = Some(type_value.as_ty().clone());
         Ok(())

starlark/src/eval/mod.rs

@@ -64,6 +64,7 @@ impl<'v, 'a> Evaluator<'v, 'a> {
             codemap,
             statement,
             dialect,
+            allow_string_literals_in_type_expr,
         } = ast;
 
         let codemap = self
@@ -126,6 +127,7 @@ impl<'v, 'a> Evaluator<'v, 'a> {
             eval: self,
             check_types: dialect.enable_types == DialectTypes::Enable,
             top_level_stmt_count,
+            allow_string_literals_in_type_expr,
         };
 
         let res = compiler.eval_module(cst, local_names);

starlark/src/tests/docs/rustdocs.rs

@@ -99,6 +99,8 @@ fn test_rustdoc() {
     let got = GlobalsBuilder::new().with(globals).build();
     let expected = assert::pass_module(
         r#"
+# @starlark-rust: allow_string_literals_in_type_expr
+
 def args_kwargs(*args, **kwargs: typing.Any) -> None: pass
 def custom_types(arg1: str, arg2: "input") -> "output": pass
 def default_arg(arg1 = "_", arg2: typing.Any = None) -> list[str]: pass

starlark/src/typing/fill_types_for_lint.rs

@@ -117,6 +117,7 @@ struct GlobalTypesBuilder<'a, 'v> {
     errors: Vec<TypingError>,
     module_scope_data: &'a ModuleScopeData<'a>,
     ctx: TypingOracleCtx<'a>,
+    allow_string_literals_in_type_expr: bool,
 }
 
 impl<'a, 'v> GlobalTypesBuilder<'a, 'v> {
@@ -658,8 +659,12 @@ impl<'a, 'v> GlobalTypesBuilder<'a, 'v> {
     }
 
     fn ty_expr(&mut self, expr: &CstTypeExpr) -> Result<Ty, InternalError> {
-        let x = TypeExprUnpackP::unpack(&expr.expr, self.ctx.codemap)
-            .map_err(InternalError::from_eval_exception)?;
+        let x = TypeExprUnpackP::unpack(
+            &expr.expr,
+            self.ctx.codemap,
+            self.allow_string_literals_in_type_expr,
+        )
+        .map_err(InternalError::from_eval_exception)?;
         self.from_type_expr_impl(&x)
     }
 
@@ -708,6 +713,7 @@ pub(crate) fn fill_types_for_lint_typechecker(
     ctx: TypingOracleCtx,
     module_scope_data: &ModuleScopeData,
     approximations: &mut Vec<Approximation>,
+    allow_string_literals_in_type_expr: bool,
 ) -> Result<(Vec<TypingError>, ModuleVarTypes), InternalError> {
     let heap = Heap::new();
     let mut builder = GlobalTypesBuilder {
@@ -717,6 +723,7 @@ pub(crate) fn fill_types_for_lint_typechecker(
         errors: Vec::new(),
         module_scope_data,
         approximations,
+        allow_string_literals_in_type_expr,
     };
     for stmt in module.iter_mut() {
         builder.top_level_stmt(stmt)?;

starlark/src/typing/golden/call_callable_or_unknown.golden

@@ -5,6 +5,8 @@
 # ```
 
 Code:
+# @starlark-rust: allow_string_literals_in_type_expr
+
 def foo(x: [typing.Callable, "unknown"], y: ["unknown", typing.Callable]):
     x()
     y()

starlark/src/typing/golden/call_not_callable_or_unknown.golden

@@ -5,6 +5,8 @@
 # ```
 
 Code:
+# @starlark-rust: allow_string_literals_in_type_expr
+
 def foo(x: [str, "unknown"], y: ["unknown", str]):
     x()
     y()

starlark/src/typing/golden/call_unknown.golden

@@ -5,6 +5,8 @@
 # ```
 
 Code:
+# @starlark-rust: allow_string_literals_in_type_expr
+
 def foo(x: "unknown"):
     x()
 

starlark/src/typing/tests.rs

@@ -332,6 +332,8 @@ fn test_call_unknown() {
     TypeCheck::new().check(
         "call_unknown",
         r#"
+# @starlark-rust: allow_string_literals_in_type_expr
+
 def foo(x: "unknown"):
     x()
 "#,
@@ -355,6 +357,8 @@ fn test_call_callable_or_unknown() {
     TypeCheck::new().check(
         "call_callable_or_unknown",
         r#"
+# @starlark-rust: allow_string_literals_in_type_expr
+
 def foo(x: [typing.Callable, "unknown"], y: ["unknown", typing.Callable]):
     x()
     y()
@@ -367,6 +371,8 @@ fn test_call_not_callable_or_unknown() {
     TypeCheck::new().check(
         "call_not_callable_or_unknown",
         r#"
+# @starlark-rust: allow_string_literals_in_type_expr
+
 def foo(x: [str, "unknown"], y: ["unknown", str]):
     x()
     y()

starlark/src/typing/typecheck.rs

@@ -220,6 +220,7 @@ impl AstModuleTypecheck for AstModule {
             oracle,
             &scope_data,
             &mut approximations,
+            self.allow_string_literals_in_type_expr,
         ) {
             Ok(fill_types_errors) => fill_types_errors,
             Err(e) => {