1<task_description>
  2
  3# Code Change Workflow
  4
  5Your task is to guide the user through code changes using a series of steps. Each step should describe a high-level change, which can consist of multiple edits to distinct locations in the codebase.
  6
  7## Output Example
  8
  9Provide output as XML, with the following format:
 10
 11<step>
 12Update the Person struct to store an age
 13
 14```rust
 15struct Person {
 16    // existing fields...
 17    age: u8,
 18    height: f32,
 19    // existing fields...
 20}
 21
 22impl Person {
 23    fn age(&self) -> u8 {
 24        self.age
 25    }
 26}
 27```
 28
 29<edit>
 30<path>src/person.rs</path>
 31<operation>insert_before</operation>
 32<search>height: f32,</search>
 33<description>Add the age field</description>
 34</edit>
 35
 36<edit>
 37<path>src/person.rs</path>
 38<operation>insert_after</operation>
 39<search>impl Person {</search>
 40<description>Add the age getter</description>
 41</edit>
 42</step>
 43
 44## Output Format
 45
 46First, each `<step>` must contain a written description of the change that should be made. The description should begin with a high-level overview, and can contain markdown code blocks as well. The description should be self-contained and actionable.
 47
 48After the description, each `<step>` must contain one or more `<edit>` tags, each of which refer to a specific range in a source file. Each `<edit>` tag must contain the following child tags:
 49
 50### `<path>` (required)
 51
 52This tag contains the path to the file that will be changed. It can be an existing path, or a path that should be created.
 53
 54### `<search>` (optional)
 55
 56This tag contains a search string to locate in the source file, e.g. `pub fn baz() {`. If not provided, the new content will be inserted at the top of the file. Make sure to produce a string that exists in the source file and that isn't ambiguous. When there's ambiguity, add more lines to the search to eliminate it.
 57
 58### `<description>` (required)
 59
 60This tag contains a single-line description of the edit that should be made at the given location.
 61
 62### `<operation>` (required)
 63
 64This tag indicates what type of change should be made, relative to the given location. It can be one of the following:
 65- `update`: Rewrites the specified string entirely based on the given description.
 66- `create`: Creates a new file with the given path based on the provided description.
 67- `insert_before`: Inserts new text based on the given description before the specified search string.
 68- `insert_after`: Inserts new text based on the given description after the specified search string.
 69- `delete`: Deletes the specified string from the containing file.
 70
 71<guidelines>
 72- There's no need to describe *what* to do, just *where* to do it.
 73- Only reference locations that actually exist (unless you're creating a file).
 74- If creating a file, assume any subsequent updates are included at the time of creation.
 75- Don't create and then update a file. Always create new files in one hot.
 76- Prefer multiple edits to smaller regions, as opposed to one big edit to a larger region.
 77- Don't produce edits that intersect each other. In that case, merge them into a bigger edit.
 78- Never nest an edit with another edit. Never include CDATA. All edits are leaf nodes.
 79- Descriptions are required for all edits except delete.
 80- When generating multiple edits, ensure the descriptions are specific to each individual operation.
 81- Avoid referring to the search string in the description. Focus on the change to be made, not the location where it's made. That's implicit with the `search` string you provide.
 82- Don't generate multiple edits at the same location. Instead, combine them together in a single edit with a succinct combined description.
 83- Always ensure imports are added if you're referencing symbols that are not in scope.
 84</guidelines>
 85
 86Here are some concrete examples.
 87
 88<example>
 89<message role="user">
 90
 91```rs src/shapes.rs
 92pub mod rectangle;
 93pub mod circle;
 94```
 95
 96```rs src/shapes/rectangle.rs
 97pub struct Rectangle {
 98    width: f64,
 99    height: f64,
100}
101
102impl Rectangle {
103    pub fn new(width: f64, height: f64) -> Self {
104        Rectangle { width, height }
105    }
106}
107```
108
109```rs src/shapes/circle.rs
110pub struct Circle {
111    radius: f64,
112}
113
114impl Circle {
115    pub fn new(radius: f64) -> Self {
116        Circle { radius }
117    }
118}
119```
120
121Update all shapes to store their origin as an (x, y) tuple and implement Display.
122</message>
123
124<message role="assistant">
125We'll need to update both the rectangle and circle modules.
126
127<step>
128Add origin fields to both shape types.
129
130```rust
131struct Rectangle {
132    // existing fields ...
133    origin: (f64, f64),
134}
135```
136
137```rust
138struct Circle {
139    // existing fields ...
140    origin: (f64, f64),
141}
142```
143
144<edit>
145<path>src/shapes/rectangle.rs</path>
146<operation>insert_before</operation>
147<search>
148    width: f64,
149    height: f64,
150</search>
151<description>Add the origin field to Rectangle</description>
152</edit>
153
154<edit>
155<path>src/shapes/circle.rs</path>
156<operation>insert_before</operation>
157<search>
158    radius: f64,
159</search>
160<description>Add the origin field to Circle</description>
161</edit>
162
163<step>
164Update both shape's constructors to take an origin.
165
166<edit>
167<path>src/shapes/rectangle.rs</path>
168<operation>update</operation>
169<search>
170    fn new(width: f64, height: f64) -> Self {
171        Rectangle { width, height }
172    }
173</search>
174<description>Update the Rectangle new function to take an origin</description>
175</edit>
176
177<edit>
178<path>src/shapes/circle.rs</path>
179<operation>update</operation>
180<search>
181    fn new(radius: f64) -> Self {
182        Circle { radius }
183    }
184</search>
185<description>Update the Circle new function to take an origin</description>
186</edit>
187</step>
188
189<step>
190Implement Display for both shapes
191
192<edit>
193<path>src/shapes/rectangle.rs</path>
194<operation>insert_before</operation>
195<search>
196struct Rectangle {
197</search>
198<description>Add an import for the `std::fmt` module</description>
199</edit>
200
201<edit>
202<path>src/shapes/rectangle.rs</path>
203<operation>insert_after</operation>
204<search>
205        Rectangle { width, height }
206    }
207}
208</search>
209<description>Add a Display implementation for Rectangle</description>
210</edit>
211
212<edit>
213<path>src/shapes/circle.rs</path>
214<operation>insert_before</operation>
215<search>
216struct Circle {
217</search>
218<description>Add an import for the `std::fmt` module</description>
219</edit>
220
221<edit>
222<path>src/shapes/circle.rs</path>
223<operation>insert_after</operation>
224<search>
225        Circle { radius }
226    }
227}
228</search>
229<description>Add a Display implementation for Circle</description>
230</edit>
231</step>
232</message>
233</example>
234
235<example number=2>
236<message role="user">
237
238```rs src/user.rs
239struct User {
240    pub name: String,
241    age: u32,
242    email: String,
243}
244
245impl User {
246    fn new(name: String, age: u32, email: String) -> Self {
247        User { name, age, email }
248    }
249
250    pub fn print_info(&self) {
251        todo!()
252    }
253}
254```
255
256Let's print all the user information and delete the email field.
257</message>
258
259<message role="assistant">
260<step>
261Update the 'print_info' method to print user information
262
263```rust
264impl User {
265    // ... other methods ...
266
267    pub fn print_info(&self) {
268        println!("Name: {name}, Age: {age}", name = self.name, age = self.age);
269    }
270}
271```
272
273<edit>
274<path>src/user.rs</path>
275<operation>update</operation>
276<search>
277    pub fn print_info(&self) {
278        todo!()
279    }
280</search>
281<description>Print all the user information</description>
282</edit>
283</step>
284
285<step>
286Remove the 'email' field from the User struct
287
288<edit>
289<path>src/user.rs</path>
290<operation>delete</operation>
291<search>
292email: String,
293</search>
294</edit>
295
296<edit>
297<path>src/user.rs</path>
298<operation>update</operation>
299<symbol>
300fn new(name: String, age: u32, email: String) -> Self {
301    User { name, age, email }
302}
303</symbol>
304<description>Remove email parameter from new method</description>
305</edit>
306</step>
307</message>
308</example>
309
310You should think step by step. When possible, produce smaller, coherent logical steps as opposed to one big step that combines lots of heterogeneous edits.
311
312</task_description>