fix[lang]: fix list typing issues

tests/functional/codegen/types/test_dynamic_array.py

@@ -235,6 +235,18 @@ def uoo(inp: DynArray[Foobar, 2]) -> DynArray[DynArray[Foobar, 2], 2]:
     print("Passed list output tests")
 
 
+def test_nested_dynarray_empty_and_flag_literal(get_contract):
+    code = """
+flag Foo:
+    Member1
+
+@external
+def foo():
+    tmp: DynArray[DynArray[Foo, 5], 5] = [[], [Foo.Member1]]
+    """
+    get_contract(code)
+
+
 def test_array_accessor(get_contract):
     array_accessor = """
 @external

tests/functional/syntax/test_dynamic_array.py

@@ -1,7 +1,13 @@
 import pytest
 
 from vyper import compile_code
-from vyper.exceptions import CodegenPanic, StructureException, TypeMismatch, UndeclaredDefinition
+from vyper.exceptions import (
+    CodegenPanic,
+    CompilerPanic,
+    StructureException,
+    TypeMismatch,
+    UndeclaredDefinition,
+)
 
 fail_list = [
     (
@@ -64,6 +70,15 @@ def foo(x: DynArray[uint256, INF]) -> DynArray[uint256, 5]:
     """,
         TypeMismatch,
     ),
+    pytest.param(
+        """
+@external
+def foo():
+    x: uint256 = [].pop()
+    """,
+        StructureException,
+        marks=pytest.mark.xfail(raises=CompilerPanic),
+    ),
 ]
 
 
@@ -112,6 +127,16 @@ def bar() -> DynArray[uint256, INF]: nonpayable
 interface IFoo:
     def bar() -> DynArray[uint256, ...]: nonpayable
     """,  # DynArray with wildcard in interface return type
+    """
+@external
+def foo():
+    tmp: DynArray[Bytes[3], 1] = [[b"abc"], []][0]
+    """,
+    """
+@external
+def foo():
+    tmp: DynArray[Bytes[3], 1] = [[], [b"abc"]][1]
+    """,
 ]
 
 

tests/functional/syntax/test_nested_list.py

@@ -49,6 +49,15 @@ def foo(x: int128[2][2]) -> int128:
     """,
         TypeMismatch,
     ),
+    (
+        """
+bar: int128[2][2]
+@external
+def foo():
+    self.bar = [[], [1, 2]]
+    """,
+        TypeMismatch,
+    ),
 ]
 
 
@@ -58,6 +67,22 @@ def test_nested_list_fail(bad_code, exc):
         compiler.compile_code(bad_code)
 
 
+def test_nested_dynarray_mismatched_inner_bytes():
+    code = """
+@external
+def foo():
+    tmp1: DynArray[Bytes[3], 5] = []
+    tmp2: DynArray[Bytes[5], 5] = []
+    tmp: DynArray[DynArray[Bytes[3], 5], 5] = [tmp1, tmp2]
+    """
+    with pytest.raises(TypeMismatch) as excinfo:
+        compiler.compile_code(code)
+    assert excinfo.value.message == (
+        "Expected DynArray[DynArray[Bytes[3], 5], 5] but literal can only be cast as"
+        " DynArray[Bytes[5], 5][2] or DynArray[DynArray[Bytes[5], 5], 2]."
+    )
+
+
 valid_list = [
     """
 bar: int128[3][3]
@@ -66,11 +91,26 @@ def foo():
     self.bar = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
     """,
     """
+bar: int128[3][3][3]
+@external
+def foo():
+    self.bar = [
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+        [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+    ]
+    """,
+    """
 bar: decimal[3][3]
 @external
 def foo():
     self.bar = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]
     """,
+    """
+@external
+def foo():
+    tmp: uint256 = [[], [1]][1][0]
+    """,
 ]
 
 

vyper/semantics/analysis/local.py

@@ -60,7 +60,6 @@
     StructT,
     TupleT,
     VyperType,
-    _BytestringT,
     is_type_t,
     map_void,
 )
@@ -1087,18 +1086,9 @@ def visit_Compare(self, node: vy_ast.Compare, typ: VyperType) -> None:
         else:
             # ex. a < b
             cmp_typ = get_common_types(node.left, node.right).pop()
-            if isinstance(cmp_typ, _BytestringT):
-                # for bytestrings, get_common_types automatically downcasts
-                # to the smaller common type - that will annotate with the
-                # wrong type, instead use get_exact_type_from_node (which
-                # resolves to the right type for bytestrings anyways).
-                ltyp = get_exact_type_from_node(node.left)
-                rtyp = get_exact_type_from_node(node.right)
-            else:
-                ltyp = rtyp = cmp_typ
 
-            self.visit(node.left, ltyp)
-            self.visit(node.right, rtyp)
+            self.visit(node.left, cmp_typ)
+            self.visit(node.right, cmp_typ)
 
     def visit_Constant(self, node: vy_ast.Constant, typ: VyperType) -> None:
         pass

vyper/semantics/analysis/utils.py

@@ -24,7 +24,7 @@
 from vyper.semantics.analysis.base import ExprInfo, Modifiability, ModuleInfo, VarAccess, VarInfo
 from vyper.semantics.analysis.levenshtein_utils import get_levenshtein_error_suggestions
 from vyper.semantics.namespace import get_namespace
-from vyper.semantics.types.base import TYPE_T, VyperType
+from vyper.semantics.types.base import TYPE_T, BottomT, VyperType
 from vyper.semantics.types.bytestrings import BytesT, StringT
 from vyper.semantics.types.infinity import is_bounded_length
 
@@ -349,28 +349,10 @@ def types_from_IfExp(self, node):
 
     def types_from_List(self, node):
         # literal array
-        if _is_empty_list(node):
-            ret = []
 
-            if len(node.elements) > 0:
-                # empty nested list literals `[[], []]`
-                subtypes = self.get_possible_types_from_node(node.elements[0])
-            else:
-                # empty list literal `[]`
-                # subtype can be anything
-                subtypes = types.PRIMITIVE_TYPES.values()
-
-            for t in subtypes:
-                # 1 is minimum possible length for dynarray,
-                # can be assigned to anything
-                if isinstance(t, VyperType):
-                    ret.append(DArrayT(t, 1))
-                elif isinstance(t, type) and issubclass(t, VyperType):
-                    # for typeclasses like bytestrings, use a generic type acceptor
-                    ret.append(DArrayT(t.any(), 1))
-                else:
-                    raise CompilerPanic(f"busted type {t}", node)
-            return ret
+        if len(node.elements) == 0:
+            # can't have an empty SArrayT
+            return [DArrayT(BottomT(), 1)]
 
         types_list = get_common_types(*node.elements)
 
@@ -432,18 +414,6 @@ def types_from_UnaryOp(self, node):
         return _validate_op(node, types_list, "validate_numeric_op")
 
 
-def _is_empty_list(node):
-    # Checks if a node is a `List` node with an empty list for `elements`,
-    # including any nested `List` nodes. ex. `[]` or `[[]]` will return True,
-    # [1] will return False.
-    if not isinstance(node, vy_ast.List):
-        return False
-
-    if not node.elements:
-        return True
-    return all(_is_empty_list(t) for t in node.elements)
-
-
 def _is_type_in_list(obj, types_list):
     # check if a type object is in a list of types
     return any(i.is_equivalent_to(obj) for i in types_list)
@@ -528,12 +498,16 @@ def get_common_types(*nodes: vy_ast.VyperNode, filter_fn: Callable = None) -> Li
         tmp = []
         for c in common_types:
             for t in new_types:
-                # TODO: This can add either the supertype or the subtype to tmp depending on
-                # the order
-                if t.compare_type(c) or c.compare_type(t):
+                # The common type is the one such that both are subtypes
+
+                if t.is_subtype_of(c):
                     tmp.append(c)
                     break
 
+                if c.is_subtype_of(t):
+                    tmp.append(t)
+                    break
+
         common_types = tmp
 
     if filter_fn is not None:
@@ -598,17 +572,9 @@ def validate_expected_type(node, expected_type):
 
     given_types = _ExprAnalyser().get_possible_types_from_node(node)
 
-    if isinstance(node, vy_ast.List):
-        # special case - for literal arrays we individually validate each item
-        for expected in expected_type:
-            if not isinstance(expected, (DArrayT, SArrayT)):
-                continue
-            if _validate_literal_array(node, expected):
-                return
-    else:
-        for given, expected in itertools.product(given_types, expected_type):
-            if given.is_subtype_of(expected):
-                return
+    for given, expected in itertools.product(given_types, expected_type):
+        if given.is_subtype_of(expected):
+            return
 
     # validation failed, prepare a meaningful error message
     if len(expected_type) > 1:

vyper/semantics/types/base.py

@@ -37,6 +37,9 @@ def is_equivalent_to(self, other):
         return self.compare_type(other) and other.compare_type(self)
 
     def compare_type(self, other):
+        if isinstance(other, BottomT):
+            return True
+
         if isinstance(other, self.type_):
             return True
         # compare two GenericTypeAcceptors -- they are the same if the base
@@ -407,6 +410,9 @@ def compare_type(self, other: "VyperType") -> bool:
         bool
             Indicates if the types are equivalent.
         """
+        if isinstance(other, BottomT):
+            return True
+
         return isinstance(other, type(self))
 
     def fetch_call_return(self, node: vy_ast.Call) -> Optional["VyperType"]:
@@ -480,6 +486,17 @@ def __init__(self, typ, default, require_literal=False):
         self.require_literal = require_literal
 
 
+class BottomT(VyperType):
+    """
+    Bottom type, the ultimate subtype: is a subtype of every other type.
+    It is unhabited: no value has this type.
+
+    It is for example the element type for empty lists: `[]: DynArray[Never, 1]`
+    """
+
+    _id = "Never"  # see python's typing.Never
+
+
 class _VoidType(VyperType):
     _id = "(void)"
 

vyper/semantics/types/bytestrings.py

@@ -1,7 +1,7 @@
 from vyper import ast as vy_ast
 from vyper.abi_types import ABI_Bytes, ABI_String, ABIType
 from vyper.exceptions import CodegenPanic, StructureException, UnexpectedNodeType, UnexpectedValue
-from vyper.semantics.types.base import VyperType
+from vyper.semantics.types.base import BottomT, VyperType
 from vyper.semantics.types.infinity import INF, WILDCARD, LengthUpperBound, length_to_json
 from vyper.semantics.types.utils import get_index_value
 from vyper.utils import ceil32
@@ -79,6 +79,9 @@ def resolve_wildcard(self):
         return self
 
     def compare_type(self, other):
+        if isinstance(other, BottomT):
+            return True
+
         if not super().compare_type(other):
             return False
 

vyper/semantics/types/primitives.py

@@ -15,7 +15,7 @@
 )
 from vyper.utils import checksum_encode, int_bounds, is_checksum_encoded
 
-from .base import VyperType
+from .base import BottomT, VyperType
 from .bytestrings import BytesT
 from .infinity import INF
 
@@ -126,6 +126,9 @@ def validate_literal(self, node: vy_ast.Constant) -> None:
             raise InvalidLiteral(f"Cannot mix uppercase and lowercase for {self} literal", node)
 
     def compare_type(self, other: VyperType) -> bool:
+        if isinstance(other, BottomT):
+            return True
+
         if not super().compare_type(other):
             return False
         assert isinstance(other, BytesM_T)
@@ -317,6 +320,9 @@ def abi_type(self) -> ABIType:
         return ABI_GIntM(self.bits, self.is_signed)
 
     def compare_type(self, other: VyperType) -> bool:
+        if isinstance(other, BottomT):
+            return True
+
         # this function is performance sensitive
         # originally:
         # if not super().compare_type(other):
@@ -440,6 +446,8 @@ class SelfT(AddressT):
     _id = "self"
 
     def compare_type(self, other):
+        if isinstance(other, BottomT):
+            return True
         # compares true to AddressT
         # This checks if either is a subtype of the other, which doesn't seem correct
         return isinstance(other, type(self)) or isinstance(self, type(other))