plum

#![allow(non_snake_case)]
use plum_checker::monomorphize::*;
use plum_checker::types::PlumType;
use plum_core::ast;

#[test]
fn isGenericParamNameAcceptsSingleUppercaseLettersOnly() {
    assert!(isGenericParamName("T"));
    assert!(isGenericParamName("W"));
    assert!(!isGenericParamName("Int"));
    assert!(!isGenericParamName("TU"));
    assert!(!isGenericParamName("a"));
    assert!(!isGenericParamName(""));
}

#[test]
fn classGenericParamsReadsDeclaredGenericsList() {
    let c = ast::Class {
        name: "Box".to_string(),
        implements: vec![],
        generics: vec![ast::GenericParam { name: "T".to_string(), bounds: vec![] }],
        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "T".to_string(), generics: vec![] } }],
    };
    assert_eq!(classGenericParams(&c), vec!["T".to_string()]);
}

#[test]
fn fnGenericParamsDetectsImplicitUppercaseLetterTypesInOrder() {
    let f = ast::Fn {
        is_extern: false,
        name: "pair".to_string(),
        type_param: None,
        params: vec![
            ast::Param { name: "first".to_string(), ty: ast::ParamType::Type(ast::Type { name: "T".to_string(), generics: vec![] }), default: None },
            ast::Param { name: "second".to_string(), ty: ast::ParamType::Type(ast::Type { name: "U".to_string(), generics: vec![] }), default: None },
        ],
        returns: Some(ast::Type { name: "Bool".to_string(), generics: vec![] }),
        body: ast::FnBody::Block(ast::Block { stmts: vec![] }),
    };
    assert_eq!(fnGenericParams(&f), vec!["T".to_string(), "U".to_string()]);
}

#[test]
fn enumGenericParamsDetectsImplicitUppercaseLetterVariantFields() {
    let e = ast::Enum {
        name: "Option".to_string(),
        params: vec![],
        variants: vec![
            ast::EnumVariant { name: "Some".to_string(), fields: vec!["T".to_string()], values: vec![] },
            ast::EnumVariant { name: "None".to_string(), fields: vec![], values: vec![] },
        ],
    };
    assert_eq!(enumGenericParams(&e), vec!["T".to_string()]);
}

#[test]
fn mangleJoinsBaseNameAndTypeArgs() {
    assert_eq!(mangle("Box", &[PlumType::TInt]), "Box$Int");
    assert_eq!(mangle("Pair", &[PlumType::TInt, PlumType::TStr]), "Pair$Int$Str");
    assert_eq!(mangle("Green", &[]), "Green");
}

#[test]
fn specializeClassSubstitutesGenericFieldTypesAndClearsGenericsList() {
    let c = ast::Class {
        name: "Box".to_string(),
        implements: vec![],
        generics: vec![ast::GenericParam { name: "T".to_string(), bounds: vec![] }],
        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "T".to_string(), generics: vec![] } }],
    };
    let mut bindings = std::collections::BTreeMap::new();
    bindings.insert("T".to_string(), PlumType::TInt);
    let specialized = specializeClass(&c, &Substitution(bindings), "Box$Int");
    assert_eq!(specialized.name, "Box$Int");
    assert!(specialized.generics.is_empty());
    assert_eq!(specialized.fields[0].ty.name, "Int");
}

#[test]
fn specializeFnSubstitutesGenericParamAndReturnTypes() {
    let f = ast::Fn {
        is_extern: false,
        name: "wrap".to_string(),
        type_param: None,
        params: vec![ast::Param { name: "value".to_string(), ty: ast::ParamType::Type(ast::Type { name: "T".to_string(), generics: vec![] }), default: None }],
        returns: Some(ast::Type { name: "T".to_string(), generics: vec![] }),
        body: ast::FnBody::Expr(ast::Expr::Var("value".to_string())),
    };
    let mut bindings = std::collections::BTreeMap::new();
    bindings.insert("T".to_string(), PlumType::TInt);
    let specialized = specializeFn(&f, &Substitution(bindings), "wrap$Int", None);
    assert_eq!(specialized.name, "wrap$Int");
    match &specialized.params[0].ty {
        ast::ParamType::Type(t) => assert_eq!(t.name, "Int"),
        _ => panic!("expected ParamType::Type"),
    }
    assert_eq!(specialized.returns.unwrap().name, "Int");
}

#[test]
fn specializeFnSetsNewReceiverForAMethod() {
    let f = ast::Fn {
        is_extern: false,
        name: "getValue".to_string(),
        type_param: Some("Box".to_string()),
        params: vec![],
        returns: Some(ast::Type { name: "T".to_string(), generics: vec![] }),
        body: ast::FnBody::Expr(ast::Expr::Self_),
    };
    let mut bindings = std::collections::BTreeMap::new();
    bindings.insert("T".to_string(), PlumType::TStr);
    let specialized = specializeFn(&f, &Substitution(bindings), "getValue", Some("Box$Str".to_string()));
    assert_eq!(specialized.name, "getValue");
    assert_eq!(specialized.type_param, Some("Box$Str".to_string()));
    assert_eq!(specialized.returns.unwrap().name, "Str");
}

#[test]
fn specializeEnumSubstitutesGenericVariantFieldNames() {
    let e = ast::Enum {
        name: "Option".to_string(),
        params: vec![],
        variants: vec![
            ast::EnumVariant { name: "Some".to_string(), fields: vec!["T".to_string()], values: vec![] },
            ast::EnumVariant { name: "None".to_string(), fields: vec![], values: vec![] },
        ],
    };
    let mut bindings = std::collections::BTreeMap::new();
    bindings.insert("T".to_string(), PlumType::TInt);
    let specialized = specializeEnum(&e, &Substitution(bindings), "Option$Int");
    assert_eq!(specialized.name, "Option$Int");
    assert_eq!(specialized.variants[0].fields, vec!["Int".to_string()]);
    assert!(specialized.variants[1].fields.is_empty());
}