Rename CstAssign -> CstAssignTarget

Summary:
Because it is typedef to `AssignTargetP`:

```
type CstAssignTarget = AstAssignTargetP<CstPayload>;
```

Minor code cleanup.

Reviewed By: cjhopman

Differential Revision: D48957721

fbshipit-source-id: f2e4a5498daf5431383a5176e3fd5bfe62931728

Author: stepancheg

starlark/src/eval/compiler/compr.rs

@@ -103,7 +103,7 @@ impl Compiler<'_, '_, '_> {
             match next_for {
                 None => {
                     let last = ClauseCompiled {
-                        var: self.assign(&for_.var),
+                        var: self.assign_target(&for_.var),
                         over,
                         ifs,
                     };
@@ -112,7 +112,7 @@ impl Compiler<'_, '_, '_> {
                 Some(f) => {
                     res.push(ClauseCompiled {
                         over: self.expr(&f.over),
-                        var: self.assign(&f.var),
+                        var: self.assign_target(&f.var),
                         ifs,
                     });
                 }

starlark/src/eval/compiler/scope/mod.rs

@@ -54,8 +54,8 @@ use crate::environment::Globals;
 use crate::environment::Module;
 use crate::errors::did_you_mean::did_you_mean;
 use crate::eval::compiler::def::CopySlotFromParent;
-use crate::eval::compiler::scope::payload::CstAssign;
 use crate::eval::compiler::scope::payload::CstAssignIdent;
+use crate::eval::compiler::scope::payload::CstAssignTarget;
 use crate::eval::compiler::scope::payload::CstExpr;
 use crate::eval::compiler::scope::payload::CstIdent;
 use crate::eval::compiler::scope::payload::CstParameter;
@@ -570,7 +570,7 @@ impl<'f> ModuleScopeBuilder<'f> {
         }
     }
 
-    fn resolve_idents_in_assign(&mut self, assign: &mut CstAssign) {
+    fn resolve_idents_in_assign(&mut self, assign: &mut CstAssignTarget) {
         assign.visit_expr_mut(|expr| self.resolve_idents_in_expr(expr));
     }
 
@@ -762,7 +762,7 @@ impl<'f> ModuleScopeBuilder<'f> {
         self.unscopes.push(Unscope::default());
     }
 
-    fn add_compr<'x>(&mut self, var: impl IntoIterator<Item = &'x mut CstAssign>) {
+    fn add_compr<'x>(&mut self, var: impl IntoIterator<Item = &'x mut CstAssignTarget>) {
         let scope_id = self.top_scope_id();
         let mut locals = SmallMap::new();
         for var in var {
@@ -992,7 +992,7 @@ impl AssignIdentCollect for AssignIdent {
 
 trait AssignTargetCollectDefinesLvalue {
     fn collect_defines_lvalue<'a>(
-        expr: &'a mut CstAssign,
+        expr: &'a mut CstAssignTarget,
         in_loop: InLoop,
         scope_data: &mut ModuleScopeData,
         frozen_heap: &FrozenHeap,
@@ -1004,7 +1004,7 @@ impl AssignTargetCollectDefinesLvalue for AssignTarget {
     // Collect variables defined in an expression on the LHS of an assignment (or
     // for variable etc)
     fn collect_defines_lvalue<'a>(
-        expr: &'a mut CstAssign,
+        expr: &'a mut CstAssignTarget,
         in_loop: InLoop,
         scope_data: &mut ModuleScopeData,
         frozen_heap: &FrozenHeap,

starlark/src/eval/compiler/scope/payload.rs

@@ -145,7 +145,7 @@ impl CstAssignIdentExt for CstAssignIdent {
 
 pub(crate) type CstExpr = AstExprP<CstPayload>;
 pub(crate) type CstTypeExpr = AstTypeExprP<CstPayload>;
-pub(crate) type CstAssign = AstAssignTargetP<CstPayload>;
+pub(crate) type CstAssignTarget = AstAssignTargetP<CstPayload>;
 pub(crate) type CstAssignIdent = AstAssignIdentP<CstPayload>;
 pub(crate) type CstIdent = AstIdentP<CstPayload>;
 pub(crate) type CstArgument = AstArgumentP<CstPayload>;

starlark/src/eval/compiler/scope/tests.rs

@@ -29,8 +29,8 @@ use starlark_syntax::syntax::uniplate::Visit;
 
 use crate::environment::names::MutableNames;
 use crate::environment::Globals;
-use crate::eval::compiler::scope::payload::CstAssign;
 use crate::eval::compiler::scope::payload::CstAssignIdent;
+use crate::eval::compiler::scope::payload::CstAssignTarget;
 use crate::eval::compiler::scope::payload::CstExpr;
 use crate::eval::compiler::scope::payload::CstStmt;
 use crate::eval::compiler::scope::AssignCount;
@@ -115,7 +115,7 @@ fn test_with_module(program: &str, expected: &str, module: &MutableNames) {
             });
         }
 
-        fn visit_assign(&mut self, assign: &CstAssign) {
+        fn visit_assign(&mut self, assign: &CstAssignTarget) {
             assign.visit_lvalue(|ident| self.visit_lvalue(ident));
         }
 

starlark/src/eval/compiler/stmt.rs

@@ -45,7 +45,7 @@ use crate::eval::compiler::expr::ExprLogicalBinOp;
 use crate::eval::compiler::expr_bool::ExprCompiledBool;
 use crate::eval::compiler::known::list_to_tuple;
 use crate::eval::compiler::opt_ctx::OptCtx;
-use crate::eval::compiler::scope::payload::CstAssign;
+use crate::eval::compiler::scope::payload::CstAssignTarget;
 use crate::eval::compiler::scope::payload::CstExpr;
 use crate::eval::compiler::scope::payload::CstStmt;
 use crate::eval::compiler::scope::Captured;
@@ -393,7 +393,7 @@ impl IrSpanned<AssignCompiledValue> {
 }
 
 impl Compiler<'_, '_, '_> {
-    pub fn assign(&mut self, expr: &CstAssign) -> IrSpanned<AssignCompiledValue> {
+    pub fn assign_target(&mut self, expr: &CstAssignTarget) -> IrSpanned<AssignCompiledValue> {
         let span = FrameSpan::new(FrozenFileSpan::new(self.codemap, expr.span));
         let assign = match &expr.node {
             AssignTargetP::Dot(e, s) => {
@@ -408,7 +408,7 @@ impl Compiler<'_, '_, '_> {
                 AssignCompiledValue::Index(e, idx)
             }
             AssignTargetP::Tuple(v) => {
-                let v = v.map(|x| self.assign(x));
+                let v = v.map(|x| self.assign_target(x));
                 AssignCompiledValue::Tuple(v)
             }
             AssignTargetP::Identifier(ident) => {
@@ -436,7 +436,7 @@ impl Compiler<'_, '_, '_> {
     fn assign_modify(
         &mut self,
         span_stmt: Span,
-        lhs: &CstAssign,
+        lhs: &CstAssignTarget,
         rhs: IrSpanned<ExprCompiled>,
         op: AssignOp,
     ) -> StmtsCompiled {
@@ -728,7 +728,7 @@ impl Compiler<'_, '_, '_> {
                     ),
                     span,
                 };
-                let lhs = self.assign(&Spanned {
+                let lhs = self.assign_target(&Spanned {
                     span: name.span,
                     node: AssignTargetP::Identifier(name.clone()),
                 });
@@ -739,7 +739,7 @@ impl Compiler<'_, '_, '_> {
             }
             StmtP::For(ForP { var, over, body }) => {
                 let over = list_to_tuple(over);
-                let var = self.assign(var);
+                let var = self.assign_target(var);
                 let over = self.expr(&over);
                 let st = self.stmt(body, false);
                 StmtsCompiled::for_stmt(span, var, over, st)
@@ -774,7 +774,7 @@ impl Compiler<'_, '_, '_> {
             StmtP::Assign(AssignP { lhs, ty, rhs }) => {
                 let rhs = self.expr(rhs);
                 let ty = self.expr_for_type(ty.as_ref());
-                let lhs = self.assign(lhs);
+                let lhs = self.assign_target(lhs);
                 StmtsCompiled::one(IrSpanned {
                     span,
                     node: StmtCompiled::Assign(lhs, ty, rhs),

starlark/src/typing/bindings.rs

@@ -35,8 +35,8 @@ use starlark_syntax::syntax::uniplate::Visit;
 use crate::codemap::CodeMap;
 use crate::codemap::Span;
 use crate::codemap::Spanned;
-use crate::eval::compiler::scope::payload::CstAssign;
 use crate::eval::compiler::scope::payload::CstAssignIdentExt;
+use crate::eval::compiler::scope::payload::CstAssignTarget;
 use crate::eval::compiler::scope::payload::CstExpr;
 use crate::eval::compiler::scope::payload::CstPayload;
 use crate::eval::compiler::scope::payload::CstStmt;
@@ -58,7 +58,7 @@ pub(crate) enum BindExpr<'a> {
     /// Get this position from the expression
     GetIndex(usize, Box<BindExpr<'a>>),
     Iter(Box<BindExpr<'a>>),
-    AssignModify(&'a CstAssign, AssignOp, &'a CstExpr),
+    AssignModify(&'a CstAssignTarget, AssignOp, &'a CstExpr),
     /// Set this index in the variable
     SetIndex(BindingId, &'a CstExpr, Box<BindExpr<'a>>),
     ListAppend(BindingId, &'a CstExpr),
@@ -122,7 +122,7 @@ impl<'a, 'b> BindingsCollect<'a, 'b> {
 
     fn assign(
         &mut self,
-        lhs: &'a CstAssign,
+        lhs: &'a CstAssignTarget,
         rhs: BindExpr<'a>,
         codemap: &CodeMap,
     ) -> Result<(), InternalError> {

starlark/src/typing/ctx.rs

@@ -32,7 +32,7 @@ use starlark_syntax::syntax::ast::ForClauseP;
 use crate::codemap::Span;
 use crate::codemap::Spanned;
 use crate::eval::compiler::scope::payload::CstArgument;
-use crate::eval::compiler::scope::payload::CstAssign;
+use crate::eval::compiler::scope::payload::CstAssignTarget;
 use crate::eval::compiler::scope::payload::CstExpr;
 use crate::eval::compiler::scope::payload::CstIdent;
 use crate::eval::compiler::scope::payload::CstPayload;
@@ -225,7 +225,7 @@ impl TypingContext<'_> {
     }
 
     /// Used to get the type of an expression when used as part of a ModifyAssign operation
-    fn expression_assign(&self, x: &CstAssign) -> Result<Ty, InternalError> {
+    fn expression_assign(&self, x: &CstAssignTarget) -> Result<Ty, InternalError> {
         match &**x {
             AssignTargetP::Tuple(_) => Ok(self.approximation("expression_assignment", x)),
             AssignTargetP::Index(a_b) => self.expr_index(x.span, &a_b.0, &a_b.1),
@@ -245,7 +245,7 @@ impl TypingContext<'_> {
         }
     }
 
-    fn expression_assign_spanned(&self, x: &CstAssign) -> Result<Spanned<Ty>, InternalError> {
+    fn expression_assign_spanned(&self, x: &CstAssignTarget) -> Result<Spanned<Ty>, InternalError> {
         Ok(Spanned {
             span: x.span,
             node: self.expression_assign(x)?,