f47709e | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

f47709e — Peter John 2026-11-01T22:25:35+05:30

refactor: remove PlumType::TStr; Str is an ordinary named type

Files changed (6) hide show

plum-checker/src/lib.rs +8 -25
plum-checker/src/types.rs +5 -2
plum-checker/tests/checker_tests.rs +2 -2
plum-checker/tests/types_tests.rs +1 -1
plum-core/src/ast.rs +3 -0
plum-wasm-codegen/src/lib.rs +12 -31

plum-checker/src/lib.rs CHANGED Viewed

@@ -593,7 +593,7 @@ pub fn nullableErrPayload(ty: &PlumType) -> Option<&PlumType> {
         return None;
     }
     let is_ref = match &**t {
-        PlumType::TStr | PlumType::TByteSlice | PlumType::TFun(..) => true,
+        PlumType::TByteSlice | PlumType::TFun(..) => true,
         PlumType::TNamed(_) => true,
         PlumType::TApp(..) => true,
         _ => false,
@@ -625,7 +625,6 @@ pub fn plumTypeFromName(name: &str) -> PlumType {
         "Int" => PlumType::TInt,
         "Float" => PlumType::TFloat,
         "Bool" => PlumType::TBool,
-        "Str" => PlumType::TStr,
         "Byte" => PlumType::TByte,
         "[]Byte" => PlumType::TByteSlice,
         "Unit" => PlumType::TUnit,
@@ -662,7 +661,6 @@ pub fn methodReceiverName(ty: &PlumType) -> Option<String> {
         PlumType::TInt => Some("Int".to_string()),
         PlumType::TFloat => Some("Float".to_string()),
         PlumType::TBool => Some("Bool".to_string()),
-        PlumType::TStr => Some("Str".to_string()),
         PlumType::TByte => Some("Byte".to_string()),
         PlumType::TByteSlice => Some("ByteSlice".to_string()),
         _ => None,
@@ -767,19 +765,6 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
         (PlumType::TInt, PlumType::TInt) => Ok(()),
         (PlumType::TFloat, PlumType::TFloat) => Ok(()),
         (PlumType::TBool, PlumType::TBool) => Ok(()),
-        (PlumType::TStr, PlumType::TStr) => Ok(()),
-        // `Str` is an ordinary class (`type Str(...) = bytes: []Byte ...` in
-        // `str.plum`) — a bare `Str(...)` construction (e.g. `bytesToStr`'s own
-        // body) infers as `TNamed("Str")` via `inferClassCallRaw`, while a `Str`
-        // type ANNOTATION (a param/return type, a string literal) resolves via
-        // `plumTypeFromName` to the dedicated `TStr` variant instead — these are
-        // the same real type spelled two different ways depending on how the
-        // checker reached it, so they must unify with each other too.
-        (PlumType::TStr, PlumType::TNamed(n)) | (PlumType::TNamed(n), PlumType::TStr)
-            if n == "Str" =>
-        {
-            Ok(())
-        }
         (PlumType::TByte, PlumType::TByte) => Ok(()),
         (PlumType::TByteSlice, PlumType::TByteSlice) => Ok(()),
         (PlumType::TUnit, PlumType::TUnit) => Ok(()),
@@ -1093,7 +1078,7 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
                 let ty = match &c.value {
                     ast::Expr::Int(_) => PlumType::TInt,
                     ast::Expr::Float(_) => PlumType::TFloat,
-                    ast::Expr::String(_) => PlumType::TStr,
+                    ast::Expr::String(_) => types::strType(),
                     _ => PlumType::TVar("_".to_string()),
                 };
                 global_env.insert(c.name.clone(), TypeScheme::mono(ty));
@@ -2483,7 +2468,7 @@ fn checkStmtInner(
         ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
         ast::Stmt::Crash(e) => match inferExpr(e, env, ctx) {
             Ok(t) => {
-                if let Err(msg) = unify(&PlumType::TStr, &t, ctx) {
+                if let Err(msg) = unify(&types::strType(), &t, ctx) {
                     errors.push(CheckError::at(
                         fn_pos.0,
                         fn_pos.1,
@@ -3014,7 +2999,7 @@ pub(crate) fn checkPattern(
         ast::CasePattern::Wildcard => Ok(()),
         ast::CasePattern::Int(_) => unify(subject_ty, &PlumType::TInt, ctx),
         ast::CasePattern::Float(_) => unify(subject_ty, &PlumType::TFloat, ctx),
-        ast::CasePattern::String(_) => unify(subject_ty, &PlumType::TStr, ctx),
+        ast::CasePattern::String(_) => unify(subject_ty, &types::strType(), ctx),
         ast::CasePattern::Bool(_) => unify(subject_ty, &PlumType::TBool, ctx),
         ast::CasePattern::Name(n) => {
             let is_known_variant =n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
@@ -3304,7 +3289,6 @@ fn checkCallArgs(
 fn fieldTypeOf(obj_ty: &PlumType, field: &str, ctx: &CheckCtx) -> Result<PlumType, String> {
     match obj_ty {
         PlumType::TNamed(n) => lookupFieldType(n, field, ctx),
-        PlumType::TStr => lookupFieldType("Str", field, ctx),
         PlumType::TApp(n, args) => {
             let raw = lookupFieldType(n, field, ctx)?;
             let gens = enumGenericsOf(n, ctx);
@@ -3332,7 +3316,7 @@ fn inferMethodCall(
     let call_addr = CUR_EXPR.with(|c| c.get());
     // `e.name()` on an error value (`catch e`) is its text.
     if matches!(obj_ty, PlumType::TErrName(_)) && name == "name" && args.is_empty() {
-        return Ok(PlumType::TStr);
+        return Ok(types::strType());
     }
     // An error union has no methods of its own except the `?.` desugaring
     // (`a?.b` = `a.andThen(|x| x.b)`), which keeps the set and flattens `!U`.
@@ -3498,8 +3482,7 @@ fn startVariant(
 /// True for an operand whose operators are user methods (`add`, `eq`, ...): a
 /// declared class/enum, not a primitive, `Str`, `Bool` or an error name.
 pub fn isOperatorOperand(t: &PlumType) -> bool {
-    matches!(t, PlumType::TStr)
-        || matches!(t, PlumType::TNamed(n) | PlumType::TApp(n, _) if n != "Int" && n != "Float" && n != "Bool" && n != "Byte")
+    matches!(t, PlumType::TNamed(n) | PlumType::TApp(n, _) if n != "Int" && n != "Float" && n != "Bool" && n != "Byte")
 }
 /// Resolves operator `sym` on a non-primitive left operand to `left.method(right)`,
@@ -3792,7 +3775,7 @@ fn inferExprInner(
                     }
                 }
             }
-            Ok(PlumType::TStr)
+            Ok(types::strType())
         }
         ast::Expr::Var(name) => match env.get(name) {
             Some(s) if !s.vars.is_empty() => Ok(instSig(&s.body, &BTreeMap::new())),
@@ -4182,7 +4165,7 @@ fn inferExprInner(
                 ast::AttrKind::Field(field_name) => match &obj_ty {
                     // `Str` is an ordinary class with a real field; a generic
                     // class substitutes its receiver's type arguments.
-                    PlumType::TNamed(_) | PlumType::TStr | PlumType::TApp(..) => {
+                    PlumType::TNamed(_) | PlumType::TApp(..) => {
                         fieldTypeOf(&obj_ty, field_name, ctx)
                     }
                     // An unresolved generic return reaches here as a plain `TVar`;

plum-checker/src/types.rs CHANGED Viewed

@@ -5,7 +5,6 @@ pub enum PlumType {
     TInt,
     TFloat,
     TBool,
-    TStr,
     TByte,
     /// `[]Byte` — a fixed builtin, not a generic. The checker
     /// only ever produces this for the exact source spelling `[]Byte`
@@ -73,7 +72,6 @@ impl std::fmt::Display for PlumType {
             PlumType::TInt => write!(f, "Int"),
             PlumType::TFloat => write!(f, "Float"),
             PlumType::TBool => write!(f, "Bool"),
-            PlumType::TStr => write!(f, "Str"),
             PlumType::TByte => write!(f, "Byte"),
             PlumType::TByteSlice => write!(f, "[]Byte"),
             PlumType::TUnit => write!(f, "Unit"),
@@ -213,3 +211,8 @@ impl std::fmt::Display for CheckError {
 }
 pub type CheckResult<T> = Result<T, Vec<CheckError>>;
+/// The type of a string literal: the ordinary named record `Str`.
+pub fn strType() -> PlumType {
+    PlumType::TNamed(plum_core::ast::STR_TYPE.to_string())
+}

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1272,7 +1272,7 @@ fn method_own_generic_instantiated_per_call() {
     );
     assert_eq!(
         lastFnBodyType("fun f(xs: List[Int]) -> List[Str] =\n  xs.map(|n| \"{n}\")\n"),
-        tapp("List", vec![PlumType::TStr])
+        tapp("List", vec![plum_checker::types::strType()])
     );
     // The two instantiations are independent: Str result where Int is declared is an error.
     let bad = checkSource(&parseClean(&format!(
@@ -1371,7 +1371,7 @@ fn instantiation_set_listed() {
             .iter()
             .any(|i| i.item == "List.map" && i.type_args.first() == Some(&t))
     };
-    assert!(has(PlumType::TInt) && has(PlumType::TStr), "{:?}", info.instantiations);
+    assert!(has(PlumType::TInt) && has(plum_checker::types::strType()), "{:?}", info.instantiations);
     for i in &info.instantiations {
         assert_eq!(info.inst_index[&(i.item.clone(), i.type_args.clone())], i.id);
     }

plum-checker/tests/types_tests.rs CHANGED Viewed

@@ -44,7 +44,7 @@ fn display_round_trips() {
     assert_eq!(t.to_string(), "error{A}!Int");
     assert_eq!(TParam("T".into()).to_string(), "T");
     assert_eq!(
-        TApp("Map".into(), vec![TStr, TApp("List".into(), vec![TInt])]).to_string(),
+        TApp("Map".into(), vec![plum_checker::types::strType(), TApp("List".into(), vec![TInt])]).to_string(),
         "Map[Str, List[Int]]"
     );
 }

plum-core/src/ast.rs CHANGED Viewed

@@ -269,6 +269,9 @@ pub const FN_TYPE_NAME: &str = "fn";
 /// inline `error{A, B}` (`name` = `ERROR_SET_TYPE_NAME`, `generics` = the
 /// names). No parts means an inferred set. `!` cannot be a real type name.
 pub const ERROR_UNION_TYPE_NAME: &str = "!";
+/// Name of the std `Str` record (`record Str(bytes: []Byte)`). String literals,
+/// string match patterns and host boundaries are the only places that know its shape.
+pub const STR_TYPE: &str = "Str";
 /// The reserved error name of an absent optional: `T?` is `error{null}!T` inside
 /// the compiler, and `null` is the error value `error.null`. No source error

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -883,6 +883,10 @@ fn boxIfValue(ty: &PlumType, body: &mut Vec<u8>) {
     }
 }
+fn strType() -> PlumType {
+    plum_checker::types::strType()
+}
 fn plumTypeToValtype(t: &PlumType) -> ValType {
     withGcTypes(|r| plumTypeToGcValtype(t, r))
 }
@@ -998,7 +1002,6 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
         PlumType::TInt => ValType::I64,
         PlumType::TFloat => ValType::F64,
         PlumType::TBool => ValType::I32,
-        PlumType::TStr => strGcValtypeOrFallback(registry),
         PlumType::TByte => ValType::I32,
         PlumType::TByteSlice => gcRef(registry.byte_array_type_idx),
         PlumType::TNamed(name) => match registry
@@ -1525,7 +1528,7 @@ fn desugarTestsToFns(source: &ast::Source) -> (ast::Source, Vec<(String, String)
                     yields: None,
                     params: vec![],
                     returns: Some(ast::Type {
-                        name: "Str".to_string(),
+                        name: ast::STR_TYPE.to_string(),
                         generics: vec![],
                     }),
                     body: ast::FnBody::Block(ast::Block { stmts }),
@@ -2105,7 +2108,7 @@ fn compileSourceInner(
     {
         let uses_crash = sourceUsesCrash(&format!("{:?}", source.items));
         if uses_crash {
-            let str_vt = plumTypeToValtype(&PlumType::TStr);
+            let str_vt = plumTypeToValtype(&strType());
             let type_idx = module.addType(&[str_vt], &[]);
             let func_idx = module.addImport("plum", "crash", type_idx);
             func_ids.insert(CRASH_FN_KEY.to_string(), func_idx);
@@ -2269,7 +2272,7 @@ fn compileSourceInner(
     module.nameFunction(start_func_idx, "start");
     module.setStartFunction(start_func_idx);
-    if let Some(&str_idx) = gc_types.class_type_idx.get("Str") {
+    if let Some(&str_idx) = gc_types.class_type_idx.get(ast::STR_TYPE) {
         let mut b = vec![0u8];
         Instruction::LocalGet(0).encode(&mut b);
         Instruction::StructNew(str_idx).encode(&mut b);
@@ -2760,27 +2763,12 @@ fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
     }
 }
-/// `Str`'s wasm-gc valtype, exactly like `plumTypeToGcValtype(&PlumType::TStr,
-/// r)` — EXCEPT it tolerates a program compiled against a `lib_path` that
-/// never loaded `str.plum` at all (see `plum-core::loader::loadAndMerge`'s
-/// best-effort `std/str` prelude), falling back to the raw `array<i8>` type
-/// instead of panicking. Safe specifically because this is only used by the
-/// unconditionally registered string runtime helpers, which every compiled
-/// program gets regardless of whether it uses `Str`.
-fn strGcValtypeOrFallback(r: &GcTypeRegistry) -> ValType {
-    match r.class_type_idx.get("Str") {
-        Some(idx) => gcRef(*idx),
-        None => gcRef(r.byte_array_type_idx),
-    }
-}
 /// Wraps a just-pushed raw `array<i8>` (top of the value stack, whose length
 /// IS the string's length) into `Str`'s `{bytes: []Byte}` representation via
 /// `mk_str_fn`. Every codegen site that builds a `Str` from raw bytes goes
 /// through this.
 fn wrapBytesAsStr(body: &mut Vec<u8>) {
-    // No real `Str` registered at all (see `strGcValtypeOrFallback`'s doc
-    // comment) — a raw `array<i8>` already IS this program's "Str".
+    // No real `Str` registered at all — a raw `array<i8>` already IS this program's "Str".
     let Some(mk) = withGcTypes(|r| r.mk_str_fn) else {
         return;
     };
@@ -6085,7 +6073,7 @@ fn compileTagName(
         .ok_or_else(|| "internal codegen error: missing name() scratch".to_string())?;
     compileExpr(obj, body, ctx, state)?;
     Instruction::LocalSet(tmp).encode(body);
-    let svt = plumTypeToValtype(&PlumType::TStr);
+    let svt = plumTypeToValtype(&strType());
     // An open set (a `!T` parameter's) can be any error of the program.
     let all: std::collections::BTreeSet<String>;
     let names = if names.is_empty() {
@@ -6756,12 +6744,8 @@ fn compileFieldRead(
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
-    // `Str` is an ordinary record (`bytes: []Byte`) with no name of its own carried
-    // in `PlumType::TStr` — resolve it via the literal name "Str", same as a
-    // `TNamed`/`TApp` does via its own name.
     let class_name = match (plum_checker::nominalName(obj_ty), obj_ty) {
         (Some(n), _) => n.to_string(),
-        (None, PlumType::TStr) => "Str".to_string(),
         _ => {
             return Err(format!(
                 "codegen: cannot access field '{}' on non-class type {}",
@@ -6781,10 +6765,7 @@ fn compileFieldRead(
         }
         return Ok(());
     }
-    let ety = match obj_ty {
-        PlumType::TStr => PlumType::TNamed("Str".to_string()),
-        t => t.clone(),
+    let ety = obj_ty.clone();
-    };
     // A discriminant enum's shared params are declared directly on the enum's
     // SUPERTYPE (see `buildGcTypeRegistry`'s `EnumSuper` arm) — no `ref.cast` to
     // any one variant needed.
@@ -7139,7 +7120,7 @@ fn compileInterpolatedString(
             ast::StringPart::Interp(expr) => {
                 let ty = inferLocalType(expr, ctx);
                 match ty {
-                    PlumType::TStr => {
+                    PlumType::TNamed(ref n) if n == ast::STR_TYPE => {
                         compileExpr(expr, body, ctx, state)?;
                     }
                     PlumType::TInt => {
@@ -7150,7 +7131,7 @@ fn compileInterpolatedString(
                         Instruction::Call(func_idx).encode(body);
                     }
                     PlumType::TBool => {
-                        let str_ref = withGcTypes(|r| plumTypeToGcValtype(&PlumType::TStr, r));
+                        let str_ref = withGcTypes(|r| plumTypeToGcValtype(&strType(), r));
                         compileBoolConditionAsI32(expr, body, ctx, state)?;
                         Instruction::If(BlockType::Result(str_ref)).encode(body);
                         compileStaticString("true", body, state);