odem_rs_meta/

lib.rs

//! This crate provides procedural macros for meta-programming purposes to be
//! used in concert with the ODEM-rs library.
//!
//! It includes four main macros:
//!
//! - `until`: Parses a condition into a `ControlExpr` that can be awaited.
//! - `derive_config`: Derives the `Config` trait for a structure, supporting
//!   customizations through attributes.
//! - `derive_publisher`: Generates the `Publisher` trait by subscribing to
//!   marked attributes.
//! - `sim_main`: Wraps a user-defined `async fn` with optional arguments and
//!   return values into a synchronous wrapper-function that initializes and
//!   runs a simulation, returning its results.
//!
//! For more details, refer to the documentation of each macro.
#![doc(
	html_logo_url = "data:image/svg+xml;base64,<svg width="400" height="400" xmlns="http://www.w3.org/2000/svg" fill-rule="evenodd"><circle cy="197.5" cx="200.5" stroke="#000" fill="#fff" r="152.5"/><path d="M191.247 3.626c-10.02.61-10.085.71-12.839 19.476-1.541 10.496-2.116 11.566-6.732 12.523-12.722 2.637-20.863 4.849-29.987 8.148-11.452 4.14-19.972 8.209-30.57 14.599-7.213 4.349-5.838 4.797-18.908-6.158-9.084-7.613-10.007-8.077-13.916-6.992-4.325 1.201-22.675 18.459-25.003 23.515-1.725 3.744-1.417 4.428 7.141 15.863 8.243 11.015 8.101 10.623 5.239 14.41-14.366 19.007-25.366 43.603-30.066 67.225-1.608 8.084.625 6.926-21.108 10.947C3.812 179.158 3.816 179.152 3.833 198c.02 20.471-2.085 18.483 23.967 22.644 6.48 1.035 6.443.992 7.825 9.12 3.993 23.47 14.154 48.102 27.483 66.622 4.095 5.69 4.737 7.174 3.853 8.905-.824 1.613-5.655 8.666-9.844 14.373-5.119 6.974-5.766 9.592-3.265 13.22 1.766 2.563 13.088 13.776 17.384 17.217 9.171 7.346 9.501 7.297 22.564-3.342 11.744-9.564 10.311-9.198 17.988-4.592 17.074 10.244 35.637 17.292 57.554 21.852 7.025 1.461 7.021 1.453 9.659 16.031 2.323 12.834 3.024 14.437 6.799 15.542 2.235.654 19.847.998 24.874.485 7.805-.796 7.858-.872 10.73-15.442 2.978-15.11 2.963-15.087 10.716-16.612 19.304-3.799 38.147-10.833 56.875-21.229 3.958-2.197 7.501-3.994 7.875-3.994 1.002 0 4.649 2.714 12.091 9 12.138 10.253 13.546 10.021 28.602-4.723 12.483-12.225 13.008-14.179 6.252-23.277-11.842-15.947-11.633-15.464-8.594-19.87 17.403-25.233 25.665-44.971 30.556-72.993.971-5.562.438-5.315 17.223-7.983 9.797-1.557 11.322-2.07 12.408-4.17 2.132-4.123 2.37-28.113.329-33.223-.985-2.466-2.157-2.988-10.194-4.539-21.057-4.065-18.596-2.569-20.751-12.622-4.723-22.027-13.741-42.553-26.888-61.2-6.007-8.519-6.081-7.609 1.384-17.057 8.733-11.054 9.633-12.722 8.712-16.142-1.329-4.938-20.82-23.488-26.067-24.809-3.638-.916-4.468-.428-15.478 9.113-9.882 8.562-9.209 8.353-15.015 4.666-15.841-10.06-37.018-18.323-58.749-22.925-8.745-1.851-7.656.189-12.048-22.561-1.412-7.315-2.486-8.8-6.848-9.463-3.717-.565-16.176-.784-22.548-.396M209.4 55.211c96.114 6.381 159.631 99.642 129.667 190.389-33.954 102.833-164.677 133.45-241.692 56.607-42.335-42.241-54.503-99.142-33.236-155.429 21.23-56.186 83.827-95.646 145.261-91.567m-22.6 10.587c-24.726 2.293-45.331 10.811-55.281 22.851l-1.613 1.951 70.147.2 70.291.123c.896-.48-7.197-7.823-12.544-11.379-16.447-10.94-43.917-16.258-71-13.746m95.631 28.568c3.794 11.796 4.093 26.576.758 37.374-1.054 3.415-1.735 3.262 6.208 1.39l6.798-1.602 1.134 1.336c3.2 3.77 11.071 17.493 11.071 19.302 0 .752-4.45 4.848-14.6 13.441l-11.072 9.513c-1.653 1.559-2.489 1.504-2.901-.188-.528-2.172-5.381-11.562-7.994-15.467-3.135-4.685-3.049-3.502-.656-9.065 5.331-12.39 7.584-31.866 5.323-46l-.736-4.6-9.515.066c-10.456.072-10.292.044-9.111 1.546 3.923 4.988 5.563 20.063 3.341 30.704-3.734 17.871-12.971 31.521-32.136 47.488-13.512 11.256-15.9 14.556-15.933 22.012-.031 7.035 2.31 10.536 13.19 19.729 15.31 12.934 23.108 21.944 28.861 33.342 7.656 15.171 9.209 33.951 3.733 45.169-.767 1.57-1.394 2.965-1.394 3.1s4.144.244 9.21.244h9.21l.355-.935c1.241-3.263 2.232-18.024 1.652-24.605-.994-11.294-2.95-18.863-7.391-28.608l-1.41-3.095 2.447-3.634c2.873-4.266 6.507-11.447 8.362-16.523.723-1.98 1.446-3.756 1.606-3.946s2.151 1.348 4.425 3.417a447 447 0 0 0 8.534 7.527c7.093 6.068 12.635 11.273 13.672 12.839l.965 1.458-2.546 5.353c-2.773 5.826-6.557 12.31-8.202 14.052-1.333 1.412-1.529 1.401-9.077-.497-7.386-1.857-6.828-1.956-5.8 1.031 3.353 9.744 3.699 27.118.759 38.094-1.305 4.875-.994 4.715 9.165-4.7 62.994-58.378 59.303-155.545-7.877-207.359-3.78-2.915-3.782-2.914-2.428 1.297M115.4 93.044c-3.145 2.355-8.148 6.9-13.6 12.356-55.811 55.85-50.5 150.802 11.123 198.831 4.516 3.52 4.603 3.521 3.535.064-3.284-10.635-3.205-25.625.194-36.382 1.24-3.926 1.906-3.717-5.743-1.799-7.397 1.855-6.822 1.958-9.495-1.707-1.736-2.38-7.052-12.002-8.21-14.862-1.492-3.682-2.637-2.33 16.33-19.286l6.364-5.725c3.217-2.911 4.102-3.282 4.102-1.721 0 2.251 4.551 11.553 8.985 18.363l2.625 4.033-1.996 4.095c-6.735 13.819-9.48 34.946-6.511 50.096l.706 3.6 9.187.108c11.03.129 10.531.258 8.828-2.273-5.117-7.603-5.599-22.678-1.152-36.03 5.167-15.515 15.364-28.928 33.41-43.951 9.017-7.506 11.367-10.536 12.608-16.254 1.726-7.956-.968-12.894-11.82-21.665-24.995-20.202-35.177-35.972-36.955-57.236-.864-10.338.266-17.524 3.658-23.26.912-1.543 1.142-2.244.802-2.454-.724-.448-18.13.046-18.434.522-.556.873-1.529 8.788-1.781 14.493-.594 13.392 2.021 27.47 7.022 37.813.878 1.814 1.482 3.499 1.344 3.743s-1.19 1.884-2.336 3.644c-2.895 4.445-6.15 10.99-7.927 15.933-.298.831-.967.385-5.691-3.788-1.335-1.18-4.568-3.945-7.186-6.145-10.772-9.055-14.986-13.103-14.986-14.394 0-2.189 7.369-15.132 10.536-18.506 1.526-1.625 2.169-1.634 8.661-.124 5.857 1.362 5.402 1.507 4.631-1.47-3.233-12.475-2.888-25.506.983-37.139 1.153-3.464.978-3.611-1.811-1.523m38.329 7.784c-4.919 2.435-8.918 10.171-6.55 12.672l.852.9h103.551l.682-1.042c1.66-2.533-1.271-8.575-5.605-11.554l-2.334-1.604-39.362-.106c-21.65-.058-39.363-.034-39.363.055s.269.675.598 1.305c1.746 3.35-.507 6.946-4.353 6.946-3.486 0-5.816-3.547-4.511-6.868l.602-1.532h-1.268c-.697 0-2.02.373-2.939.828m42.071 25.423c-16.311 2.382-31.409 7.628-41.1 14.281-4.073 2.796-3.887 2.272-2.034 5.731 4.759 8.881 12.233 17.077 24.93 27.337 10.531 8.509 12.781 10.982 15.852 17.419 3.239 6.79 3.152 5.82 3.152 35.181v26l-.931 1.891c-.513 1.04-1.803 2.675-2.868 3.632-1.778 1.598-3.126 2.287-10.401 5.312-19.772 8.222-31.991 16.136-35.223 22.813-2.481 5.125.372 13.178 5.795 16.356l1.721 1.009 45.154-.106L245 303l1.837-1.08c4.739-2.786 7.243-9.611 5.392-14.695-2.318-6.366-12.109-13.235-31.229-21.91-13.796-6.259-15.286-7.211-17.316-11.06L202.6 252.2v-25.8c0-36.51.266-37.259 18.658-52.601 17.239-14.379 30.342-30.465 30.342-37.248 0-2.196-13.981-7.062-26.4-9.189-5.979-1.023-25.06-1.745-29.4-1.111m.4 3.172c-.22.089-1.998.62-3.951 1.182-8.528 2.452-23.51 10.093-24.415 12.451-.139.361.884 2.16 2.564 4.514 4.266 5.976 4.968 8.716 2.626 10.251-1.304.854-2.536.443-4.921-1.643-1.781-1.558-6.103-6.879-6.103-7.513 0-.131-.72-1.352-1.6-2.714-2.019-3.123-2.107-2.77 1.3-5.192 5.325-3.787 12.087-6.558 22.372-9.17 6.088-1.546 14.193-2.993 12.128-2.166m-5.227 16.238c1.819.828 1.65 3.56-.257 4.166-2.165.687-3.705-2.689-1.827-4.004 1.06-.743.847-.726 2.084-.162m-9.053 15.219c.664.664.603 2.92-.096 3.5-.941.781-2.731.341-3.388-.834-1.146-2.051 1.825-4.325 3.484-2.666m79.88 14.42c7.406 16.175 7.193 35.567-.573 52.139-1.841 3.928-1.695 3.929-5.227-.053-3.017-3.403-11.701-11.52-18.6-17.386-5.919-5.033-8.6-7.614-8.6-8.278 0-.28 1.929-2.087 4.287-4.015 10.275-8.406 20.681-18.356 24.48-23.407 2.234-2.972 2.436-2.924 4.233 1m-118.7.4c4.299 5.091 12.407 12.869 19.9 19.089 3.74 3.104 7.061 6.018 7.38 6.475.686.982 1.548.121-11.392 11.39-8.033 6.997-13.052 11.824-16.514 15.88-1.622 1.901-1.788 1.787-4.054-2.787-7.374-14.881-7.452-34.106-.201-49.647 2.07-4.437 1.512-4.391 4.881-.4m-24.441 6.008c-2.213 8.819-2.599 23.004-.888 32.692.291 1.65.487 3.05.435 3.111-.303.356-33.436-4.838-35.241-5.524-2.198-.836-2.796-22.772-.676-24.826.296-.288 2.767-.765 18.311-3.535 18.146-3.234 18.396-3.26 18.059-1.918m166.501-.516c1.138.216 6.068 1.031 10.955 1.811 8.523 1.361 17.694 3.054 20.715 3.825 3.846.982 3.741 24.693-.112 25.356-12.658 2.179-34.388 5.422-34.673 5.174-.085-.073.153-1.979.529-4.233 1.742-10.458 1.39-23.956-.826-31.625-.239-.827.379-.883 3.412-.308M204 264c0 .22-.419.4-.93.4-2.113 0-9.636 2.624-14.956 5.216-13.761 6.707-21.485 13.671-26.263 23.681-2.504 5.247-6.406 5.903-8.674 1.458-4.038-7.915 9.244-20.07 30.023-27.477 3.482-1.241 12.207-2.964 16.589-3.275l4.111-.344c.055-.032.1.121.1.341m-12.4 22.4c1.733 1.733.352 5.2-2.072 5.2-1.157 0-2.728-1.789-2.728-3.106 0-2.484 3.071-3.823 4.8-2.094m-17.829 3.429c1.809 1.808-.68 4.597-2.997 3.357-.887-.475-1.076-2.724-.294-3.506.68-.68 2.548-.595 3.291.149M132.8 314.85c24.15 22.64 84.689 27.432 120.421 9.534 5.445-2.728 14.911-9.588 15.976-11.579l.431-.805-69.914.019-69.914.019z" fill="#173241"/></svg>",
	html_favicon_url = "data:image/svg+xml;base64,<svg width="400" height="400" xmlns="http://www.w3.org/2000/svg" fill-rule="evenodd"><circle cy="197.5" cx="200.5" stroke="#000" fill="#fff" r="152.5"/><path d="M191.247 3.626c-10.02.61-10.085.71-12.839 19.476-1.541 10.496-2.116 11.566-6.732 12.523-12.722 2.637-20.863 4.849-29.987 8.148-11.452 4.14-19.972 8.209-30.57 14.599-7.213 4.349-5.838 4.797-18.908-6.158-9.084-7.613-10.007-8.077-13.916-6.992-4.325 1.201-22.675 18.459-25.003 23.515-1.725 3.744-1.417 4.428 7.141 15.863 8.243 11.015 8.101 10.623 5.239 14.41-14.366 19.007-25.366 43.603-30.066 67.225-1.608 8.084.625 6.926-21.108 10.947C3.812 179.158 3.816 179.152 3.833 198c.02 20.471-2.085 18.483 23.967 22.644 6.48 1.035 6.443.992 7.825 9.12 3.993 23.47 14.154 48.102 27.483 66.622 4.095 5.69 4.737 7.174 3.853 8.905-.824 1.613-5.655 8.666-9.844 14.373-5.119 6.974-5.766 9.592-3.265 13.22 1.766 2.563 13.088 13.776 17.384 17.217 9.171 7.346 9.501 7.297 22.564-3.342 11.744-9.564 10.311-9.198 17.988-4.592 17.074 10.244 35.637 17.292 57.554 21.852 7.025 1.461 7.021 1.453 9.659 16.031 2.323 12.834 3.024 14.437 6.799 15.542 2.235.654 19.847.998 24.874.485 7.805-.796 7.858-.872 10.73-15.442 2.978-15.11 2.963-15.087 10.716-16.612 19.304-3.799 38.147-10.833 56.875-21.229 3.958-2.197 7.501-3.994 7.875-3.994 1.002 0 4.649 2.714 12.091 9 12.138 10.253 13.546 10.021 28.602-4.723 12.483-12.225 13.008-14.179 6.252-23.277-11.842-15.947-11.633-15.464-8.594-19.87 17.403-25.233 25.665-44.971 30.556-72.993.971-5.562.438-5.315 17.223-7.983 9.797-1.557 11.322-2.07 12.408-4.17 2.132-4.123 2.37-28.113.329-33.223-.985-2.466-2.157-2.988-10.194-4.539-21.057-4.065-18.596-2.569-20.751-12.622-4.723-22.027-13.741-42.553-26.888-61.2-6.007-8.519-6.081-7.609 1.384-17.057 8.733-11.054 9.633-12.722 8.712-16.142-1.329-4.938-20.82-23.488-26.067-24.809-3.638-.916-4.468-.428-15.478 9.113-9.882 8.562-9.209 8.353-15.015 4.666-15.841-10.06-37.018-18.323-58.749-22.925-8.745-1.851-7.656.189-12.048-22.561-1.412-7.315-2.486-8.8-6.848-9.463-3.717-.565-16.176-.784-22.548-.396M209.4 55.211c96.114 6.381 159.631 99.642 129.667 190.389-33.954 102.833-164.677 133.45-241.692 56.607-42.335-42.241-54.503-99.142-33.236-155.429 21.23-56.186 83.827-95.646 145.261-91.567m-22.6 10.587c-24.726 2.293-45.331 10.811-55.281 22.851l-1.613 1.951 70.147.2 70.291.123c.896-.48-7.197-7.823-12.544-11.379-16.447-10.94-43.917-16.258-71-13.746m95.631 28.568c3.794 11.796 4.093 26.576.758 37.374-1.054 3.415-1.735 3.262 6.208 1.39l6.798-1.602 1.134 1.336c3.2 3.77 11.071 17.493 11.071 19.302 0 .752-4.45 4.848-14.6 13.441l-11.072 9.513c-1.653 1.559-2.489 1.504-2.901-.188-.528-2.172-5.381-11.562-7.994-15.467-3.135-4.685-3.049-3.502-.656-9.065 5.331-12.39 7.584-31.866 5.323-46l-.736-4.6-9.515.066c-10.456.072-10.292.044-9.111 1.546 3.923 4.988 5.563 20.063 3.341 30.704-3.734 17.871-12.971 31.521-32.136 47.488-13.512 11.256-15.9 14.556-15.933 22.012-.031 7.035 2.31 10.536 13.19 19.729 15.31 12.934 23.108 21.944 28.861 33.342 7.656 15.171 9.209 33.951 3.733 45.169-.767 1.57-1.394 2.965-1.394 3.1s4.144.244 9.21.244h9.21l.355-.935c1.241-3.263 2.232-18.024 1.652-24.605-.994-11.294-2.95-18.863-7.391-28.608l-1.41-3.095 2.447-3.634c2.873-4.266 6.507-11.447 8.362-16.523.723-1.98 1.446-3.756 1.606-3.946s2.151 1.348 4.425 3.417a447 447 0 0 0 8.534 7.527c7.093 6.068 12.635 11.273 13.672 12.839l.965 1.458-2.546 5.353c-2.773 5.826-6.557 12.31-8.202 14.052-1.333 1.412-1.529 1.401-9.077-.497-7.386-1.857-6.828-1.956-5.8 1.031 3.353 9.744 3.699 27.118.759 38.094-1.305 4.875-.994 4.715 9.165-4.7 62.994-58.378 59.303-155.545-7.877-207.359-3.78-2.915-3.782-2.914-2.428 1.297M115.4 93.044c-3.145 2.355-8.148 6.9-13.6 12.356-55.811 55.85-50.5 150.802 11.123 198.831 4.516 3.52 4.603 3.521 3.535.064-3.284-10.635-3.205-25.625.194-36.382 1.24-3.926 1.906-3.717-5.743-1.799-7.397 1.855-6.822 1.958-9.495-1.707-1.736-2.38-7.052-12.002-8.21-14.862-1.492-3.682-2.637-2.33 16.33-19.286l6.364-5.725c3.217-2.911 4.102-3.282 4.102-1.721 0 2.251 4.551 11.553 8.985 18.363l2.625 4.033-1.996 4.095c-6.735 13.819-9.48 34.946-6.511 50.096l.706 3.6 9.187.108c11.03.129 10.531.258 8.828-2.273-5.117-7.603-5.599-22.678-1.152-36.03 5.167-15.515 15.364-28.928 33.41-43.951 9.017-7.506 11.367-10.536 12.608-16.254 1.726-7.956-.968-12.894-11.82-21.665-24.995-20.202-35.177-35.972-36.955-57.236-.864-10.338.266-17.524 3.658-23.26.912-1.543 1.142-2.244.802-2.454-.724-.448-18.13.046-18.434.522-.556.873-1.529 8.788-1.781 14.493-.594 13.392 2.021 27.47 7.022 37.813.878 1.814 1.482 3.499 1.344 3.743s-1.19 1.884-2.336 3.644c-2.895 4.445-6.15 10.99-7.927 15.933-.298.831-.967.385-5.691-3.788-1.335-1.18-4.568-3.945-7.186-6.145-10.772-9.055-14.986-13.103-14.986-14.394 0-2.189 7.369-15.132 10.536-18.506 1.526-1.625 2.169-1.634 8.661-.124 5.857 1.362 5.402 1.507 4.631-1.47-3.233-12.475-2.888-25.506.983-37.139 1.153-3.464.978-3.611-1.811-1.523m38.329 7.784c-4.919 2.435-8.918 10.171-6.55 12.672l.852.9h103.551l.682-1.042c1.66-2.533-1.271-8.575-5.605-11.554l-2.334-1.604-39.362-.106c-21.65-.058-39.363-.034-39.363.055s.269.675.598 1.305c1.746 3.35-.507 6.946-4.353 6.946-3.486 0-5.816-3.547-4.511-6.868l.602-1.532h-1.268c-.697 0-2.02.373-2.939.828m42.071 25.423c-16.311 2.382-31.409 7.628-41.1 14.281-4.073 2.796-3.887 2.272-2.034 5.731 4.759 8.881 12.233 17.077 24.93 27.337 10.531 8.509 12.781 10.982 15.852 17.419 3.239 6.79 3.152 5.82 3.152 35.181v26l-.931 1.891c-.513 1.04-1.803 2.675-2.868 3.632-1.778 1.598-3.126 2.287-10.401 5.312-19.772 8.222-31.991 16.136-35.223 22.813-2.481 5.125.372 13.178 5.795 16.356l1.721 1.009 45.154-.106L245 303l1.837-1.08c4.739-2.786 7.243-9.611 5.392-14.695-2.318-6.366-12.109-13.235-31.229-21.91-13.796-6.259-15.286-7.211-17.316-11.06L202.6 252.2v-25.8c0-36.51.266-37.259 18.658-52.601 17.239-14.379 30.342-30.465 30.342-37.248 0-2.196-13.981-7.062-26.4-9.189-5.979-1.023-25.06-1.745-29.4-1.111m.4 3.172c-.22.089-1.998.62-3.951 1.182-8.528 2.452-23.51 10.093-24.415 12.451-.139.361.884 2.16 2.564 4.514 4.266 5.976 4.968 8.716 2.626 10.251-1.304.854-2.536.443-4.921-1.643-1.781-1.558-6.103-6.879-6.103-7.513 0-.131-.72-1.352-1.6-2.714-2.019-3.123-2.107-2.77 1.3-5.192 5.325-3.787 12.087-6.558 22.372-9.17 6.088-1.546 14.193-2.993 12.128-2.166m-5.227 16.238c1.819.828 1.65 3.56-.257 4.166-2.165.687-3.705-2.689-1.827-4.004 1.06-.743.847-.726 2.084-.162m-9.053 15.219c.664.664.603 2.92-.096 3.5-.941.781-2.731.341-3.388-.834-1.146-2.051 1.825-4.325 3.484-2.666m79.88 14.42c7.406 16.175 7.193 35.567-.573 52.139-1.841 3.928-1.695 3.929-5.227-.053-3.017-3.403-11.701-11.52-18.6-17.386-5.919-5.033-8.6-7.614-8.6-8.278 0-.28 1.929-2.087 4.287-4.015 10.275-8.406 20.681-18.356 24.48-23.407 2.234-2.972 2.436-2.924 4.233 1m-118.7.4c4.299 5.091 12.407 12.869 19.9 19.089 3.74 3.104 7.061 6.018 7.38 6.475.686.982 1.548.121-11.392 11.39-8.033 6.997-13.052 11.824-16.514 15.88-1.622 1.901-1.788 1.787-4.054-2.787-7.374-14.881-7.452-34.106-.201-49.647 2.07-4.437 1.512-4.391 4.881-.4m-24.441 6.008c-2.213 8.819-2.599 23.004-.888 32.692.291 1.65.487 3.05.435 3.111-.303.356-33.436-4.838-35.241-5.524-2.198-.836-2.796-22.772-.676-24.826.296-.288 2.767-.765 18.311-3.535 18.146-3.234 18.396-3.26 18.059-1.918m166.501-.516c1.138.216 6.068 1.031 10.955 1.811 8.523 1.361 17.694 3.054 20.715 3.825 3.846.982 3.741 24.693-.112 25.356-12.658 2.179-34.388 5.422-34.673 5.174-.085-.073.153-1.979.529-4.233 1.742-10.458 1.39-23.956-.826-31.625-.239-.827.379-.883 3.412-.308M204 264c0 .22-.419.4-.93.4-2.113 0-9.636 2.624-14.956 5.216-13.761 6.707-21.485 13.671-26.263 23.681-2.504 5.247-6.406 5.903-8.674 1.458-4.038-7.915 9.244-20.07 30.023-27.477 3.482-1.241 12.207-2.964 16.589-3.275l4.111-.344c.055-.032.1.121.1.341m-12.4 22.4c1.733 1.733.352 5.2-2.072 5.2-1.157 0-2.728-1.789-2.728-3.106 0-2.484 3.071-3.823 4.8-2.094m-17.829 3.429c1.809 1.808-.68 4.597-2.997 3.357-.887-.475-1.076-2.724-.294-3.506.68-.68 2.548-.595 3.291.149M132.8 314.85c24.15 22.64 84.689 27.432 120.421 9.534 5.445-2.728 14.911-9.588 15.976-11.579l.431-.805-69.914.019-69.914.019z" fill="#173241"/></svg>"
)]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![warn(missing_docs)]

use proc_macro::TokenStream;
use syn::{DeriveInput, Expr, ItemFn, parse_macro_input};

mod config;
mod control;
mod publisher;
mod sim_main;

/// Creates a `ControlExpr` from a boolean expression, allowing asynchronous
/// code to efficiently await a specific condition.
///
/// This macro is a cornerstone of the `odem-rs` reactive system. It parses the
/// provided expression, identifies parts of it that refer to reactive data
/// sources (termed "control variables"), and constructs a `ControlExpr`.
///
/// `ControlExpr` implements [`IntoFuture`], meaning its result can be directly
/// `.await`ed. The future will be ready when the boolean expression evaluates
/// to `true`. The underlying mechanism uses the [`Waker`] associated with the
/// current process to re-evaluate the expression only when one of its
/// identified control variables changes.
///
/// # What are *Control Variables*?
///
/// A "control variable" is a part of the expression that the `until!`
/// macro identifies as a reactive data source. Specifically, any expression
/// segment that implements the `Publisher` trait is treated as a control
/// variable. This means it can be subscribed to, and it will notify subscribers
/// (like the `ControlExpr`) when its underlying value or state changes.
///
/// The macro identifies control variables based on their structure when they
/// form a path to a `Publisher`:
/// * **Paths:** Simple identifiers (e.g., `my_control_var`) or qualified paths
///   (e.g., `my_module::reactive_data`) that resolve to a `Publisher`.
/// * **Field Accesses:** Accessing fields of a struct that ultimately yield a
///   `Publisher` (e.g., `data_struct.control_field`).
/// * **Index Operations:** Indexing into collections where the element itself
///   is a `Publisher` (e.g., `control_array[0]`).
///
/// These can be combined. For example, `config.settings[exp_no].duration`
/// would be treated as a single control variable if this entire expression
/// resolves to a type that implements `Publisher`.
///
/// A common reactive primitive is `Control<T>`, which implements `Publisher`
/// and provides a `Cell`-like API for interior mutability.
///
/// ## What is NOT a Control Variable (in terms of triggering updates)?
///
/// * **Literals:** Constants like `true`, `false`, `0`, `"hello"`.
/// * **Non-Reactive Variables:** Variables in the lexical context of the
///   closure that do not implement `Publisher`. Their values at the time of
///   evaluation are used.
/// * **Local Variables:** Variables declared and used inside the closure.
/// * **Expressions within Index Calculations:** If an index itself is an
///   expression (e.g., `my_array[some_offset + 1]`), variables used within that
///   index calculation (like `some_offset`) are not treated as control
///   variables for the outer expression `my_array[...]`. This is to prevent
///   dynamic sets of dependencies.
/// * **Function/Method Call Results:** The results of function or method calls
///   are not treated as control variables.
///
/// # How It Works (Transformation)
///
/// The macro transforms the input expression (e.g., `my_control > 10 && another_control.is_full()`)
/// into roughly the following structure:
///
/// ```ignore
/// ControlExpr::new(
///     // Tuple of references to identified control variables (Publishers)
///     (&my_control, &another_control),
///     |args| { // Closure taking current values/states from control variables
///         // Original expression, rewritten:
///         // If `my_control` implements `Expr` (e.g., `Control<T: Copy>`),
///         // `my_control` is rewritten as `args.0.get() > 10` (conceptual).
///         // If `another_control` is just a `Publisher`, its state is used directly.
///         // The macro uses autoref specialization to handle these cases.
///         (args.0 /* .get() if Expr */) > 10 && (args.1 /* .get() if Expr */).is_full()
///     }
/// )
/// ```
///
/// ## `Expr` Trait Convenience
///
/// If a control variable (which implements `Publisher`) also implements the
/// `Expr` trait, the macro provides a convenience:
/// * For types like `Control<T>` where `T: Copy`, `Expr` is implemented.
/// * Inside the generated closure, the macro will automatically call the
///   `Expr::get()` method to retrieve the inner value. This means users can
///   write `my_control_var > 0` instead of `my_control_var.get() > 0` in the
///   expression passed to the macro.
///
/// ## Error Handling
///
/// * **Non-`Publisher` External Variables:** If a non-local identifier (a path
///   that is not a simple local variable) used in the expression does not
///   resolve to a type implementing `Publisher`, it is treated like a local
///   variable. If it does neither implement `Publisher` nor `Expr`, a
///   compile-time error will be issued. All external dependencies that are
///   meant to drive the reactivity must be `Publisher`s.
///
/// The specialized handling of different expression types (e.g., a direct
/// `Publisher` versus a `Publisher + Expr`) leverages an autoref specialization
/// technique to provide a seamless experience.
///
/// # Why Control Variables in Index Calculations Are Not Supported
///
/// Allowing variables within index expressions (e.g., `slice[index_variable]`)
/// to be control variables themselves would imply that the set of *other*
/// control variables the `ControlExpr` depends on could change dynamically if
/// `index_variable` changes. For example, if `index_variable` changed from `0`
/// to `1`, the expression would effectively switch its dependency from
/// `slice[0]` to `slice[1]`.
///
/// Supporting such dynamic dependencies would:
/// 1. Significantly complicate the dispatch and notification mechanisms.
/// 2. Prevent optimizations related to a fixed set of dependencies.
/// 3. Make reasoning about the reactive flow more difficult.
///
/// Therefore, expressions within an index are evaluated when the `ControlExpr`
/// is created or re-evaluated, but variables used solely within them do not
/// register as separate control variables for the overall expression.
///
/// # Limitations
///
/// * **Maximum Control Variables:** The macro currently supports a maximum of
///   12 distinct control variables within a single `until!` invocation.
///   If more are detected, a compile-time error will occur.
/// * **Complexity:** While powerful, overuse, or overly complex expressions
///   within `until!` can make the reactive logic harder to follow.
///
/// # Examples
///
/// **1. Awaiting a simple `Control<T>` variable change:**
///
/// ```
/// # use odem_rs::prelude::*;
/// # async fn sim_main(sim: &Sim) {
/// let i: Control<i32> = Control::new(0);
///
/// sim.fork(async {
///     // In another task or later in the code:
///     i.set(1);
/// }).and(async {
///     // `i.get()` is implicitly called due to `Expr` trait
///     until!(i > 0).await;
///     println!("i is now greater than 0!");
/// }).await;
/// # }
/// ```
/// *Actual expansion:*
/// `ControlExpr::new((&i,), |args| args.0.get() > 0).await;`
///
/// **2. Awaiting a condition involving multiple `Control<bool>` variables:**
///
/// ```
/// # use odem_rs::prelude::*;
/// # async fn sim_main(sim: &Sim) {
/// let is_ready = Control::new(false);
/// let has_permission = Control::new(false);
///
/// sim.fork(async {
///     sim.advance(1.0).await;
///     is_ready.set(true);
/// }).and(async {
///     sim.advance(2.0).await;
///     has_permission.set(true);
/// }).and(async {
///     until!(is_ready && has_permission).await;
///     println!("Both conditions met!");
/// }).await;
/// # }
/// ```
/// *Actual expansion:*
/// `ControlExpr::new((&is_ready, &has_permission), |args| args.0.get() && args.1.get()).await;`
///
/// **3. Using complex paths to `Control<T>` fields:**
///
/// ```
/// # use odem_rs::prelude::*;
/// # struct AppConfig { settings: Settings }
/// # struct Settings { font_size: Control<i32>, dark_mode: Control<bool> }
/// # async fn sim_main(sim: &Sim) {
/// let app_config = AppConfig {
///     settings: Settings {
///         font_size: Control::new(12),
///         dark_mode: Control::new(false),
///     }
/// };
/// let min_font_size = 10; // Local non-control variable
///
/// // Later...
///
/// until!(app_config.settings.font_size > min_font_size && app_config.settings.dark_mode).await;
/// println!("Font size is adequate and dark mode is enabled!");
/// # }
/// ```
///
/// **4. Interaction with local, non-control variables:**
///
/// ```
/// # use odem_rs::prelude::*;
/// # async fn sim_main(sim: &Sim) {
/// let val: Control<i32> = Control::new(5);
/// let local_modifier = 2; // Not a Publisher
/// let enabled_flag = true;  // Not a Publisher
///
/// until!(val * local_modifier > 10 && enabled_flag).await;
/// println!("Condition with local variables met!");
/// # }
/// ```
/// Here, `val` is the control variable. The closure captures 'local_modifier'
/// and 'enabled_flag'. Changes to them after `ControlExpr` creation
/// won't trigger re-evaluation unless `val` also changes.
///
/// **5. Usage in an async function:**
///
/// ```
/// # use odem_rs::prelude::*;
/// async fn wait_for_signal(signal_strength: &Control<u32>) {
///     // The current task will sleep until signal_strength.get() is 5 or greater.
///     until!(signal_strength >= 5).await;
/// }
/// ```
///
/// [`Waker`]: core::task::Waker
#[proc_macro]
pub fn until(input: TokenStream) -> TokenStream {
	match odem_rs_crate("odem-rs-sync") {
		Ok(sync) => control::control_expr_impl(parse_macro_input!(input as Expr), sync),
		Err(msg) => msg,
	}
	.into()
}

/// Derives the `Config`-trait for a structure.
///
/// The behavior of the derived `Config` implementation can be customized using
/// attributes at both the struct level and the field level.
///
/// ### Struct-Level Attributes: `#[time(...)]` and `#[rank(...)]`
///
/// These attributes can be applied to the struct definition to specify the
/// `Config::Time` and `Config::Rank` associated types and their default initial
/// values.
///
/// The following syntaxes are supported for `#[time(...)]` (and analogously for
/// `#[rank(...)]`):
///
/// 1.  **`#[time = "MyTimeType"]`**:
///     * Sets `Config::Time` to `MyTimeType`.
///     * The default time value (returned by `default_time()`) will be
///       `MyTimeType::default()`.
///     * `MyTimeType` must be a valid path to a type, enclosed in quotes.
///
/// 2.  **`#[time(MyTimeType)]`**:
///     * Sets `Config::Time` to `MyTimeType`.
///     * The default time value will be `MyTimeType::default()`.
///
/// 3.  **`#[time(MyTimeType = expression)]`**:
///     * Sets `Config::Time` to `MyTimeType`.
///     * The default time value will be the result of evaluating `expression`.
///       `expression` should be a valid Rust expression that yields a value of
///       `MyTimeType`.
///
/// If no struct-level `#[time]` attribute is provided, `Config::Time` defaults
/// to `f64`, and `default_time()` is `0.0`. For `rank`, the default type is
/// `()`.
///
/// ### Field-Level Attributes: `#[time]` and `#[rank]`
///
/// If a field within the struct is annotated with `#[time]` (or `#[rank]`):
///
/// * The **type** of that field becomes the `Config::Time` (or `Config::Rank`)
///   associated type.
/// * The **value** of that field becomes the value returned by `default_time()`
///   (or `default_rank()`).
///
/// If multiple fields are annotated with `#[time]` (or `#[rank]`), the derive
/// macro will use the type and value from the field that appears last in the
/// struct definition.
///
/// ### `Config::Data`
///
/// The `Config::Data` associated type is always set to `Self`.
/// The `global_data()` method returns a reference to `self`.
///
/// # Examples
///
/// **1. Configuration with default settings:**
///
/// ```
/// # use odem_rs::prelude::*;
/// #[derive(Config)]
/// struct ModelConfig;
///
/// async fn sim_main(sim: &Sim<ModelConfig>) {
///     // Config::Time will be the default (f64)
///     // Config::Rank will be the default (())
///     // Config::Data will be ModelConfig
/// }
/// ```
///
/// **2. Configuration with user-defined `Data` (implicit):**
///
/// The struct itself becomes the `Data`.
///
/// ```
/// # use odem_rs::prelude::*;
/// #[derive(Config)]
/// struct ExperimentData {
///     participant_id: String,
///     trial_count: u32,
/// }
///
/// async fn sim_main(sim: &Sim<ExperimentData>) {
///     // Config::Time: default
///     // Config::Rank: default
///     println!("Data: Participant {}, Trials {}",
///              sim.global().participant_id,
///              sim.global().trial_count);
/// }
/// ```
///
/// **3. Configuration with `Time` and `Rank` specified by field attributes:**
///
/// ```
/// # use odem_rs::prelude::*;
/// #[derive(Config)]
/// struct TimedRankedConfig {
///     // The simulator uses the type of `model_time` as Config::Time.
///     // The value of `model_time` is used by `default_time()`.
///     #[time]
///     model_time: i32,
///
///     // The simulator uses the type of `process_rank` as Config::Rank.
///     // The value of `process_rank` is used by `default_rank()`.
///     #[rank]
///     process_rank: u8,
/// }
///
/// async fn sim_main(sim: &Sim<TimedRankedConfig>) {
///     // Config::Time is i32, default_time() returns self.model_time
///     // Config::Rank is u8, default_rank() returns self.process_rank
/// }
/// ```
///
/// **4. Configuration with `Time` and `Rank` types specified by struct-level attributes:**
///
/// ```
/// # use odem_rs::prelude::*;
/// #[derive(Config)]
/// #[time = "Time<f64>"]
/// #[rank(u16)]
/// struct CustomTypedConfig {
///     setting_value: i32,
/// }
///
/// async fn sim_main(sim: &Sim<CustomTypedConfig>) {
///     // Config::Time is Time<f64>
///     // Config::Rank is u16
/// }
/// ```
///
/// **5. Configuration with `Time` and `Rank` types and specific default values via struct-level attributes:**
///
/// ```
/// # use odem_rs::prelude::*;
/// #[derive(Config)]
/// #[time(Time<f64> = hour::new(8.0))]
/// #[rank(u8 = 100)]
/// struct ExplicitDefaultsConfig {
///     max_iterations: u32,
/// }
///
/// async fn sim_main(sim: &Sim<ExplicitDefaultsConfig>) {
///     // Config::Time is Time<f64>, initial time is hour::new(8.0)
///     // Config::Rank is u8, default rank is 100
/// }
/// ```
///
/// **6. Overriding struct-level type with a field-level attribute:**
///
/// Field-level attributes take precedence for determining both the type and the
/// default value.
///
/// ```
/// # use odem_rs::prelude::*;
/// #[derive(Config)]
/// #[time = "u64"] // Suggests u64, but the field below overrides.
/// struct FieldOverrideConfig {
///     #[time]
///     model_time: f64,
///     some_other_data: bool,
/// }
///
/// async fn sim_main(sim: &Sim<FieldOverrideConfig>) {
///     // Config::Time is f64 due to the #[time] on `model_time`.
///     // default_time() will return the value of `sim.global().model_time`.
/// }
/// ```
#[proc_macro_derive(Config, attributes(time, rank))]
pub fn derive_config(input: TokenStream) -> TokenStream {
	match odem_rs_crate("odem-rs-core") {
		Ok(core) => config::config_derive_impl(parse_macro_input!(input as DeriveInput), core),
		Err(msg) => msg,
	}
	.into()
}

/// Derives the `Publisher`-trait for a structure.
///
/// The macro allows the attributes of a structure to be annotated with
/// `#[subscribe]` and generates an implementation of `Publisher` that will
/// subscribe and unsubscribe to all the annotated attributes. This allows
/// the structure to be used inside the `until!`-macro.
///
/// # Examples
///
/// Simple `Publisher`:
/// ```
/// # use odem_rs::prelude::*;
/// # async fn sim_main() {
/// #[derive(Publisher)]
/// struct Foo(#[subscribe] Control<bool>);
///
/// impl Foo {
///     fn is_false(&self) -> bool {
///         !self.0.get()
///     }
/// }
///
/// let foo = Foo(Control::new(true));
///
/// // will wake up, once another part of the simulation sets
/// // the inner `Control` to `true`
/// until!(foo.is_false()).await;
/// # }
/// ```
///
/// Multiple fields:
/// ```
/// # use odem_rs::prelude::*;
/// #[derive(Publisher)]
/// struct Foo {
///     field1: i32,
///     #[subscribe]
///     field2: Control<i32>,
///     #[subscribe]
///     field3: Control<bool>,
/// }
/// ```
///
/// Nesting of `Publisher` is possible, and generics are permitted:
/// ```
/// # use odem_rs::prelude::*;
/// # #[derive(Publisher)] struct Foo;
/// #[derive(Publisher)]
/// struct Bar<T: ?Sized> {
///     #[subscribe]
///     foo: Foo,
///     data: T,
/// }
/// ```
///
/// Generic `Publisher` are also supported and qualify their implementation
/// using an extended `where`-bound for the individual subscriber fields.
/// ```
/// # use odem_rs::prelude::*;
/// #[derive(Publisher)]
/// struct Bar<T> {
///     #[subscribe]
///     maybe_publisher: T
/// }
/// ```
#[proc_macro_derive(Publisher, attributes(subscribe))]
pub fn derive_publisher(input: TokenStream) -> TokenStream {
	match odem_rs_crate("odem-rs-sync") {
		Ok(sync) => {
			publisher::publisher_derive_impl(parse_macro_input!(input as DeriveInput), sync)
		}
		Err(msg) => msg,
	}
	.into()
}

/// Generates a synchronous main function that sets up a simulator, runs the
/// provided asynchronous simulation logic, and handles the results.
///
/// The user's function to which the attribute is applied **must**:
/// 1.  Be an `async fn`.
/// 2.  Accept a simulation context as its first argument (e.g., `sim: &Sim`).  
///     This argument is provided by the `simulator.run()` call.
/// 3.  Any later arguments to the user's `async fn` will become arguments
///     of the generated synchronous wrapper function.
/// 4.  The return type of the user's `async fn` will be the return type of the
///     generated synchronous wrapper, with specialized handling for `Result`
///     types (see below).
///
/// The attribute can optionally take an expression as an argument, which will
/// be used to initialize the configuration (e.g.,
/// `#[odem_rs::main(custom_init())]`). The initialization expression can also
/// refer to the arguments passed during the function call. If no argument is
/// provided, the configuration is default-constructed.
///
/// # Generated Code Structure
///
/// The macro transforms the user's `async fn sim_main(sim: &Sim, arg1: T) -> R`
/// into a synchronous function like:
///
/// ```ignore
/// pub fn sim_main(arg1: T) -> R {
///     use odem_rs::core::simulator::{Simulator, details::*};
///
///     // Simulator setup
///     let simulator = Simulator::new(init_expr_or_default);
///
///     // Running the simulation
///     let result = simulator.run(async move |sim: &Sim| {
///         // User's original async fn
///     });
///
///     // Specialized result handling
///     (&result).classify().unwrap(result)
/// }
/// ```
///
/// # Specialized `Result` Handling
///
/// The generated code uses a `classify().unwrap()` pattern on the `Result`
/// returned by `simulator.run()`. This leverages helper traits and
/// implementations in `odem_rs::core::simulator::details` to achieve
/// compile-time specialization adapted from **David Tolnay** and described
/// [here](https://github.com/dtolnay/case-studies/blob/master/autoref-specialization/README.md):
///
/// * **Generic Case**: If the user's `async fn` returns `R` (which becomes
///   `Result<R, Deadlock>` after `simulator.run()`), or `Result<R, Err>`
///   (becoming `Result<Result<R, Err>, Deadlock>`), and `Err` cannot be
///   converted from `Deadlock`, the `unwrap` call will return `R` or
///   `Result<R, Err>` respectively, and panic if `Deadlock` occurred.
///
/// * **Specialized Case**: If the user's `async fn` returns `Result<R, Err>`
///   (becoming `Result<Result<R, Err>, Deadlock>` after `simulator.run()`),
///   *and* `Err` implements `From<Deadlock>`, the `unwrap` call will convert
///   the `Deadlock` into an `Err` if the simulation run results in
///   `Err(Deadlock)`. The final return type in this case is `Result<R, Err>`,
///   and the function *does not panic* on `Deadlock`, instead folding it into
///   `Err`.
///
/// This allows for cleaner error handling by automatically propagating the
/// simulator-specific `Deadlock` error into the user's defined error type,
/// provided the necessary `From` trait is implemented. For example,
/// `SimResult<R>` implements `From<Deadlock>` for its error variant.
///
/// # Examples
///
/// **1. Basic simulation with no extra arguments and no return type**
///
/// ```no_run
/// # use odem_rs::prelude::*;
/// #[odem_rs::main]
/// async fn main(sim: &Sim) {
///     // simulation logic using `sim`
/// }
/// ```
///
/// **2. Simulation with arguments and custom simulator initialization**
///
/// ```no_run
/// # use odem_rs::prelude::*;
/// # #[derive(Config)] struct MyConfig;
/// # fn my_custom_sim_config(_: i32) -> MyConfig { MyConfig }
/// #[odem_rs::main(my_custom_sim_config(steps))]
/// async fn with_args(sim: &Sim<MyConfig>, steps: i32) -> String {
///     "simulation logic using `sim` and `steps`, returning a `String`".to_string()
/// }
///
/// fn main() {
///     let _: String = with_args(10);
/// }
/// ```
///
/// **3. Handling `Result` with a generic error (panics on `Deadlock`)**
///
/// ```should_panic
/// # use odem_rs::prelude::*;
/// #[derive(Debug, PartialEq)]
/// struct CustomError(String); // Does NOT implement From<Deadlock>
///
/// #[odem_rs::main]
/// async fn with_custom_error(sim: &Sim) -> Result<String, CustomError> {
///     sleep().await;
///     Ok("Data".to_string())
/// }
///
/// fn main() {
///     let result = with_custom_error(); // panics due to the `sleep().await`
///     assert_eq!(result, Ok("Data".to_string()));
/// }
/// ```
///
/// **4. Specialized `Result` handling (converts `Deadlock` to `UserError`)**
///
/// This example uses `SimResult`, which implements `From<Deadlock>`.
///
/// ```
/// # use odem_rs::prelude::*;
/// # #[derive(Config, Default)] struct MyConfig;
/// #[odem_rs::main]
/// async fn with_specialized_error(sim: &Sim<MyConfig>) -> SimResult<String> {
///     sleep().await;
///     Ok("Data".to_string())
/// }
///
/// fn main() {
///     match with_specialized_error() {
///         Ok(value) => println!("Success: {}", value),
///         Err(err) => {
///             // If sleep().await was called, and Deadlock was converted,
///             // this arm would be hit.
///             println!("Handled SimError: {}", err);
///         }
///     }
/// }
/// ```
#[proc_macro_attribute]
pub fn sim_main(attr: TokenStream, code: TokenStream) -> TokenStream {
	match odem_rs_crate("odem-rs-core") {
		Ok(core) => sim_main::sim_main_impl(
			if !attr.is_empty() {
				Some(parse_macro_input!(attr as Expr))
			} else {
				None
			},
			parse_macro_input!(code as ItemFn),
			core,
		),
		Err(msg) => msg,
	}
	.into()
}

/// Helper function to locate the name of the specific `odem-rs` crate.
///
/// This function handles calls from within the corresponding crate itself, as
/// well as calls including the main `odem-rs` crate or the specific crate, even
/// if the dependency has been renamed in the `Cargo.toml`.
fn odem_rs_crate(name: &str) -> Result<proc_macro2::TokenStream, proc_macro2::TokenStream> {
	use proc_macro_crate::{FoundCrate, crate_name};
	use proc_macro2::Span;
	use quote::quote;
	use syn::Ident;

	// check if the `odem-rs` crate is in the list of cargo dependencies
	if let Ok(odem_rs) = crate_name("odem-rs") {
		let odem_rs = match odem_rs {
			FoundCrate::Itself => Ident::new("odem_rs", Span::call_site()),
			FoundCrate::Name(name) => Ident::new(&name, Span::call_site()),
		};
		let suffix = Ident::new(name.rsplit('-').next().unwrap(), Span::call_site());
		Ok(quote!(#odem_rs::#suffix))
	} else if let Ok(found) = crate_name(name) {
		// handle the crate itself being pulled in
		Ok(match found {
			FoundCrate::Itself => {
				// could be `crate` since we're probably in a unit test function
				// but is more robust for doctests that are compiled in a
				// separate crate, despite belonging to the same library;
				// my crates include themselves via `extern crate self as name`
				let name = Ident::new(&name.replace('-', "_"), Span::call_site());
				quote!(#name)
			}
			FoundCrate::Name(name) => {
				let name = Ident::new(&name, Span::call_site());
				quote!(#name)
			}
		})
	} else {
		Err(quote!(compile_error!(concat!(
			"neither `odem-rs` nor `", #name, "` found in dependency chain; \
			 did you include `odem-rs` in your Cargo.toml?"
		))))
	}
}