refactor struct_literals, rename variables for consistency

vyper/codegen/expr.py

@@ -683,9 +683,7 @@ def parse_Call(self):
 
         # Struct constructor
         if is_type_t(func_type, StructT):
-            return Expr.struct_literals(
-                self.expr.keywords, self.context, self.expr._metadata["type"]
-            )
+            return self.handle_struct_literal()
 
         # Interface constructor. Bar(<address>).
         if is_type_t(func_type, InterfaceT):
@@ -750,15 +748,15 @@ def parse_IfExp(self):
         location = body.location
         return IRnode.from_list(["if", test, body, orelse], typ=typ, location=location)
 
-    @staticmethod
-    def struct_literals(expr, context, typ):
+    def handle_struct_literal(self):
+        expr = self.expr
+        typ = expr._metadata["type"]
         member_subs = {}
-        for key in expr:
-            value = key.value
-            assert key.arg not in member_subs
+        for kwarg in expr.keywords:
+            assert kwarg.arg not in member_subs
 
-            sub = Expr(value, context).ir_node
-            member_subs[key.arg] = sub
+            sub = Expr(kwarg.value, self.context).ir_node
+            member_subs[kwarg.arg] = sub
 
         return IRnode.from_list(
             ["multi"] + [member_subs[key] for key in member_subs.keys()], typ=typ

vyper/semantics/analysis/local.py

@@ -731,8 +731,8 @@ def visit_Call(self, node: vy_ast.Call, typ: VyperType) -> None:
             # struct ctors
             # ctors have no kwargs
             expected_types = func_type.typedef.members.values()  # type: ignore
-            for arg, arg_type in zip(node.keywords, expected_types):
-                self.visit(arg.value, arg_type)
+            for kwarg, arg_type in zip(node.keywords, expected_types):
+                self.visit(kwarg.value, arg_type)
         elif isinstance(func_type, MemberFunctionT):
             if func_type.is_modifying and self.function_analyzer is not None:
                 # TODO refactor this

vyper/semantics/types/user.py

@@ -395,21 +395,22 @@ def _ctor_call_return(self, node: vy_ast.Call) -> "StructT":
         # relying on `validate_call_args`
         members = self.member_types.copy()
         keys = list(self.member_types.keys())
-        for i, arg in enumerate(node.keywords):
-            if arg.arg not in members:
-                hint = get_levenshtein_error_suggestions(arg.arg, members, 1.0)
-                raise UnknownAttribute("Unknown or duplicate struct member.", arg, hint=hint)
+        for i, kwarg in enumerate(node.keywords):
+            if kwarg.arg not in members:
+                hint = get_levenshtein_error_suggestions(kwarg.arg, members, 1.0)
+                raise UnknownAttribute("Unknown or duplicate struct member.", kwarg, hint=hint)
             expected_key = keys[i]
-            if arg.arg != expected_key:
+            if kwarg.arg != expected_key:
+                name = kwarg.arg
                 raise InvalidAttribute(
                     "Struct keys are required to be in order, but got "
-                    f"`{arg.arg}` instead of `{expected_key}`. (Reminder: the "
+                    f"`{name}` instead of `{expected_key}`. (Reminder: the "
                     f"keys in this struct are {list(self.member_types.items())})",
-                    arg,
+                    kwarg,
                 )
 
-            expected_type = members.pop(arg.arg)
-            validate_expected_type(arg.value, expected_type)
+            expected_type = members.pop(kwarg.arg)
+            validate_expected_type(kwarg.value, expected_type)
 
         if members:
             raise VariableDeclarationException(