Fixing two incorrect type comparisons

Author: blast-hardcheese

src/replit_river/codegen/client.py

@@ -30,6 +30,7 @@
     ListTypeExpr,
     LiteralTypeExpr,
     ModuleName,
+    NoneTypeExpr,
     OpenUnionTypeExpr,
     RenderedPath,
     TypeExpression,
@@ -170,7 +171,7 @@ def encode_type(
     encoder_name: TypeName | None = None  # defining this up here to placate mypy
     chunks: List[FileContents] = []
     if isinstance(type, RiverNotType):
-        return (TypeName("None"), [], [], set())
+        return (NoneTypeExpr(), [], [], set())
     elif isinstance(type, RiverUnionType):
         typeddict_encoder = list[str]()
         encoder_names: set[TypeName] = set()
@@ -379,17 +380,15 @@ def flatten_union(tpe: RiverType) -> list[RiverType]:
                             typeddict_encoder.append(
                                 f"encode_{render_literal_type(inner_type_name)}(x)"
                             )
-                        case DictTypeExpr(_):
-                            raise ValueError(
-                                "What does it mean to try and encode a dict in"
-                                " this position?"
-                            )
                         case LiteralTypeExpr(const):
                             typeddict_encoder.append(repr(const))
+                        case TypeName(value):
+                            typeddict_encoder.append(f"encode_{value}(x)")
+                        case NoneTypeExpr():
+                            typeddict_encoder.append("None")
                         case other:
-                            typeddict_encoder.append(
-                                f"encode_{render_literal_type(other)}(x)"
-                            )
+                            _o2: DictTypeExpr | OpenUnionTypeExpr | UnionTypeExpr = other
+                            raise ValueError(f"What does it mean to have {_o2} here?")
         if permit_unknown_members:
             union = OpenUnionTypeExpr(UnionTypeExpr(any_of))
         else:
@@ -471,7 +470,7 @@ def extract_props(tpe: RiverType) -> list[dict[str, RiverType]]:
             return (TypeName("bool"), [], [], set())
         elif type.type == "null" or type.type == "undefined":
             typeddict_encoder.append("None")
-            return (TypeName("None"), [], [], set())
+            return (NoneTypeExpr(), [], [], set())
         elif type.type == "Date":
             typeddict_encoder.append("TODO: dstewart")
             return (TypeName("datetime.datetime"), [], [], set())
@@ -511,8 +510,11 @@ def extract_props(tpe: RiverType) -> list[dict[str, RiverType]]:
                     )
                 case LiteralTypeExpr(const):
                     typeddict_encoder.append(repr(const))
+                case TypeName(value):
+                    typeddict_encoder.append(f"encode_{value}(x)")
                 case other:
-                    typeddict_encoder.append(f"encode_{render_literal_type(other)}(x)")
+                    _o1: NoneTypeExpr | OpenUnionTypeExpr | UnionTypeExpr = other
+                    raise ValueError(f"What does it mean to have {_o1} here?")
             return (DictTypeExpr(type_name), module_info, type_chunks, encoder_names)
         assert type.type == "object", type.type
 
@@ -823,7 +825,7 @@ def __init__(self, client: river.Client[Any]):
                 module_names,
                 permit_unknown_members=True,
             )
-            if error_type == "None":
+            if isinstance(error_type, NoneTypeExpr):
                 error_type = TypeName("RiverError")
             else:
                 serdes.append(
@@ -916,7 +918,7 @@ def __init__(self, client: river.Client[Any]):
             f"Unable to derive the input encoder from: {input_type}"
         )
 
-        if output_type == "None":
+        if isinstance(output_type, NoneTypeExpr):
             parse_output_method = "lambda x: None"
 
         if procedure.type == "rpc":

src/replit_river/codegen/typing.py

@@ -17,6 +17,12 @@ def __str__(self) -> str:
         raise Exception("Complex type must be put through render_type_expr!")
 
 
+@dataclass(frozen=True)
+class NoneTypeExpr:
+    def __str__(self) -> str:
+        raise Exception("Complex type must be put through render_type_expr!")
+
+
 @dataclass(frozen=True)
 class DictTypeExpr:
     nested: "TypeExpression"
@@ -59,6 +65,7 @@ def __str__(self) -> str:
 
 TypeExpression = (
     TypeName
+    | NoneTypeExpr
     | DictTypeExpr
     | ListTypeExpr
     | LiteralTypeExpr
@@ -86,6 +93,8 @@ def render_type_expr(value: TypeExpression) -> str:
             )
         case TypeName(name):
             return name
+        case NoneTypeExpr():
+            return "None"
         case other:
             assert_never(other)
 
@@ -112,33 +121,17 @@ def extract_inner_type(value: TypeExpression) -> TypeName:
             )
         case TypeName(name):
             return TypeName(name)
+        case NoneTypeExpr():
+            raise ValueError(f"Attempting to extract from a literal 'None': {value}")
         case other:
             assert_never(other)
 
 
 def ensure_literal_type(value: TypeExpression) -> TypeName:
     match value:
-        case DictTypeExpr(_):
-            raise ValueError(
-                f"Unexpected expression when expecting a type name: {value}"
-            )
-        case ListTypeExpr(_):
-            raise ValueError(
-                f"Unexpected expression when expecting a type name: {value}"
-            )
-        case LiteralTypeExpr(_):
-            raise ValueError(
-                f"Unexpected expression when expecting a type name: {value}"
-            )
-        case UnionTypeExpr(_):
-            raise ValueError(
-                f"Unexpected expression when expecting a type name: {value}"
-            )
-        case OpenUnionTypeExpr(_):
-            raise ValueError(
-                f"Unexpected expression when expecting a type name: {value}"
-            )
         case TypeName(name):
             return TypeName(name)
         case other:
-            assert_never(other)
+            raise ValueError(
+                f"Unexpected expression when expecting a type name: {other}"
+            )