Improve resolver

Author: jayvdb

.mise.toml

@@ -1,2 +1,3 @@
 [tools]
+act = "latest"
 rust = "1.75"

CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2025-11-26
+
+### Added
+
+- `TypeGroups` struct for controlling automatic type resolution (primitives, prelude, common std types)
+- Expanded list of Rust std types that can be automatically resolved
+
+### Changed
+
+- Set Rust edition to 2021
+- Set MSRV to 1.75
+
+## [0.1.0] - Initial Release
+
+Initial release of desynt library.

Cargo.lock

@@ -3,7 +3,7 @@ name = "desynt"
 description = "Convert syn paths & idents to normalised names"
 repository = "https://github.com/jayvdb/desynt"
 license = "MIT OR Apache-2.0"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 rust-version = "1.75"
 

Cargo.toml

@@ -11,11 +11,61 @@ A Rust library for handling syn objects with raw identifier prefixes and path no
 `desynt` provides utilities for working with [`syn`](https://github.com/dtolnay/syn) objects, particularly focusing on:
 
 - **Stripping raw identifier prefixes** (`r#`) from `Ident`, `Path`, and `PathSegment` objects
-- **Path normalization** and canonical type resolution
-- **Type mapping** from various path representations to canonical forms
+- **Path resolution and normalization** via `PathResolver` for canonical type mapping
+- **Built-in type support** for Rust primitives, prelude types, and common std types
+- **Multiple storage backends** - HashMap (dynamic) or phf::Map (static)
 
 This library is especially useful when working with proc macros or code analysis tools where you need to normalize type references regardless of how they're written in the source code.
 
+## Features
+
+### Raw Identifier Stripping
+
+Use the `StripRaw` trait to remove `r#` prefixes from syn objects:
+
+```rust
+use syn::Ident;
+use desynt::StripRaw;
+
+let ident: Ident = syn::parse_str("r#type").unwrap();
+let stripped = ident.strip_raw();
+assert_eq!(stripped.to_string(), "type");
+```
+
+### Path Resolution
+
+Use `PathResolver` to normalize type paths and resolve them to canonical forms. This is particularly useful in proc macros where types can be referenced in multiple ways:
+
+```rust
+use desynt::{TypeGroups, DynamicPathResolver};
+use std::collections::HashMap;
+use syn::Path;
+
+let mut mappings = HashMap::new();
+mappings.insert("my_crate::types::UserId".to_string(), "UserId".to_string());
+
+let resolver = DynamicPathResolver::from_map(mappings, TypeGroups::ALL);
+
+// Resolves custom types
+let path: Path = syn::parse_str("my_crate::types::UserId").unwrap();
+assert_eq!(resolver.resolve(&path), Some("UserId"));
+
+// Also handles type groups with various path forms
+let path: Path = syn::parse_str("std::option::Option").unwrap();
+assert_eq!(resolver.resolve(&path), Some("Option"));
+
+let path: Path = syn::parse_str("Option<String>").unwrap();
+assert_eq!(resolver.resolve(&path), Some("Option"));
+```
+
+### Type Group Categories
+
+The `TypeGroups` struct lets you control which standard types are automatically resolved:
+
+- **Primitives**: Language primitives (i8, u32, f64, bool, char, str, etc.)
+- **Prelude**: Types in the Rust prelude (String, Vec, Option, Result, Box)
+- **Common std**: Frequently used std types (HashMap, HashSet)
+
 ## License
 
 This project is licensed under either of

README.md

@@ -1,5 +1,6 @@
 use desynt::{
-    DynamicPathResolver, EmptyStorage, PRIMITIVE_RESOLVER, PathResolver, create_static_resolver,
+    DynamicPathResolver, EmptyStorage, PRIMITIVE_RESOLVER, PathResolver, TypeGroups,
+    create_static_resolver,
 };
 use phf::{Map, phf_map};
 
@@ -42,9 +43,9 @@ const EMPTY_RESOLVER: PathResolver<EmptyStorage> = PathResolver::empty();
 
 // Static resolver with custom mappings - truly const!
 const FULL_STATIC_RESOLVER: PathResolver<&'static Map<&'static str, &'static str>> =
-    create_static_resolver(&CUSTOM_MAPPINGS, true);
+    create_static_resolver(&CUSTOM_MAPPINGS, TypeGroups::ALL);
 const CUSTOM_ONLY_RESOLVER: PathResolver<&'static Map<&'static str, &'static str>> =
-    create_static_resolver(&CUSTOM_MAPPINGS, false);
+    create_static_resolver(&CUSTOM_MAPPINGS, TypeGroups::NONE);
 
 fn main() {
     println!("=== Unified PathResolver Examples ===\n");
@@ -141,7 +142,7 @@ fn test_dynamic_resolver() {
     }
 
     // Test modification
-    resolver.set_use_primitives(false);
+    resolver.set_groups(TypeGroups::NONE);
     println!("  After disabling primitives:");
     let primitive_path: syn::Path = syn::parse_str("std::primitive::i32").unwrap();
     match resolver.resolve(&primitive_path) {

examples/const_example.rs

@@ -1,4 +1,4 @@
-use desynt::{DynamicPathResolver, PathResolver, create_static_resolver};
+use desynt::{DynamicPathResolver, PathResolver, TypeGroups, create_static_resolver};
 use phf::{Map, phf_map};
 
 // Domain-specific type mappings for web applications
@@ -62,10 +62,10 @@ const DATABASE_MAPPINGS: Map<&'static str, &'static str> = phf_map! {
 
 // Create const resolvers for different domains
 const WEB_RESOLVER: PathResolver<&'static Map<&'static str, &'static str>> =
-    create_static_resolver(&WEB_MAPPINGS, true);
+    create_static_resolver(&WEB_MAPPINGS, TypeGroups::ALL);
 
 const DATABASE_RESOLVER: PathResolver<&'static Map<&'static str, &'static str>> =
-    create_static_resolver(&DATABASE_MAPPINGS, true);
+    create_static_resolver(&DATABASE_MAPPINGS, TypeGroups::ALL);
 
 fn main() {
     println!("=== Domain-Specific PathResolver Examples ===\n");

examples/domain_specific.rs

@@ -5,7 +5,7 @@ fn main() {
     println!("=== Generic Type Resolution Demo ===");
     println!();
 
-    let resolver = DynamicPathResolver::with_primitives();
+    let resolver = DynamicPathResolver::with_prelude();
 
     // Test cases that should now work automatically
     let test_cases = vec![