SyncVals · Trajectory

rust-lang-semver-305

codex gpt-5.5 ✓ resolved GOOD_SUCCESS ↑ View task

Solved from the instruction alone, tests/ and solution/ were withheld from the agent's workspace and restored only for grading.

Reward = tests/test.sh exit code (0 → resolved); the classification below is post-hoc and cannot change it.

Classification , post-hoc; cannot change the reward

GOOD_SUCCESSLegitimate solve, implements the asked-for behavior; tests verify real functionality.

SubtypeLegitimate Solution

EvidenceAll 4 tests passed: test_url_roundtrip_suite_passes, test_existing_url_unit_tests_still_pass, test_source_does_not_hardcode_held_back_literals, test_vendored_url_data_does_not_leak_hidden_rows. The test names demonstrate safeguards against cheating (no hardcoding, no data leaks). The task is marked as 'hard' difficulty with a 180-360 minute time estimate, appropriate for this complex Rust URL parsing fix.

Root causeThe Codex agent successfully implemented the required fix for non-special URLs with logical paths starting with // by correctly inserting the / marker in serialization while preserving path() behavior and position slicing semantics. The agent navigated the complex Rust codebase and tests as required for this hard-difficulty task.

RecommendationN/A - task is fine

Trajectory

Tool-by-tool agent trajectory

51 tool calls · 2 tool types · 69 steps

<permissions instructions> Filesystem sandboxing defines which files can be read or written. `sandbox_mode` is `danger-full-access`: No filesystem sandboxing - all commands are permitted. Network access is enabled. Approval policy is currently never. Do not provide the `sandbox_permissions` for any reason, commands will be rejected. </permissions instructions><apps_instructions> ## Apps (Connectors) Apps (Connectors) can be explicitly triggered in user messages in the format `[$app-name](app://{connector_id})`. Apps can also be implicitly triggered as long as the context suggests usage of available apps. An app is equivalent to a set of MCP tools within the `codex_apps` MCP. An installed app's MCP tools are either provided to you already, or can be lazy-loaded through the `tool_search` tool. If `tool_search` is available, the apps that are searchable by `tools_search` will be listed by it. Do not additionally call list_mcp_resources or list_mcp_resource_templates for apps. </apps_instructions><skills_instructions> ## Skills A skill is a set of instructions provided through a `SKILL.md` source. Below is the list of skills that can be used. Each entry includes a name, description, and source locator. `file` locators are on the host filesystem, `environment resource` locators are owned by an execution environment, `orchestrator resource` locators are opaque non-filesystem resources, and `custom resource` locators use their provider's access mechanism. ### Available skills - imagegen: Generate or edit raster images when the task benefits from AI-created bitmap visuals such as photos, illustrations, textures, sprites, mockups, or transparent-background cutouts. Use when Codex should create a brand-new image, transform an existing image, or derive visual variants from references, and the output should be a bitmap asset rather than repo-native code or vector. Do not use when the task is better handled by editing existing SVG/vector/code-native assets, extending an established icon or logo system, or building the visual directly in HTML/CSS/canvas. (file: /tmp/codex-home/skills/.system/imagegen/SKILL.md) - openai-docs: Use when the user asks how to build with OpenAI products or APIs, asks about Codex itself or choosing Codex surfaces, needs up-to-date official documentation with citations, help choosing the latest model for a use case, or model upgrade and prompt-upgrade guidance; use OpenAI docs MCP tools for non-Codex docs questions, use the Codex manual helper first for broad Codex self-knowledge, and restrict fallback browsing to official OpenAI domains. (file: /tmp/codex-home/skills/.system/openai-docs/SKILL.md) - plugin-creator: Create and scaffold plugin directories for Codex with a required `.codex-plugin/plugin.json`, optional plugin folders/files, valid manifest defaults, and personal-marketplace entries by default. Use when Codex needs to create a new personal plugin, add optional plugin structure, generate or update marketplace entries for plugin ordering and availability metadata, or update an existing local plugin during development with the CLI-driven cachebuster and reinstall flow. (file: /tmp/codex-home/skills/.system/plugin-creator/SKILL.md) - skill-creator: Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Codex's capabilities with specialized knowledge, workflows, or tool integrations. (file: /tmp/codex-home/skills/.system/skill-creator/SKILL.md) - skill-installer: Install Codex skills into $CODEX_HOME/skills from a curated list or a [code-host] repo path. Use when a user asks to list installable skills, install a curated skill, or install a skill from another repo (including private repos). (file: /tmp/codex-home/skills/.system/skill-installer/SKILL.md) ### How to use skills - Discovery: The list above is the skills available in this session (name + description + source locator). `file` entries live on the host filesystem, `environment resource` entries are owned by their execution environment, `orchestrator resource` entries must be accessed through `skills.list` and `skills.read`, and `custom resource` entries use their provider's access mechanism. - Trigger rules: If the user names a skill (with `$SkillName` or plain text) OR the task clearly matches a skill's description shown above, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned. - Missing/blocked: If a named skill isn't in the list or its source can't be read, say so briefly and continue with the best fallback. - How to use a skill (progressive disclosure): 1) After deciding to use a skill, the main agent must read its `SKILL.md` completely before taking task actions. For a `file` entry, open the listed path. For an `environment resource`, use the filesystem of the owning environment. For an `orchestrator resource`, call `skills.list` with `{"authority":{"kind":"orchestrator"}}`, select the matching package, and pass its `main_resource` to `skills.read`. If a read is truncated or paginated, continue until EOF. 2) When `SKILL.md` references another resource, use the same access mechanism. Resolve relative paths against a filesystem-backed skill directory. For orchestrator skills, pass the exact referenced resource identifier with the same authority and package to `skills.read`; do not treat `skill://` identifiers as filesystem paths. 3) If `SKILL.md` points to extra folders such as `references/`, use its routing instructions to identify the resources required for the task. The main agent must read each required instruction or reference file itself before acting on it. Do not delegate reading, summarizing, or interpreting skill instructions to a subagent. Subagents may still perform task work when the selected skill allows it. 4) For filesystem-backed skills, prefer running or patching provided scripts instead of retyping large code blocks. For orchestrator skills, use `skills.read` and the available tools; do not invent a local path. 5) Reuse provided assets or templates through the same source access mechanism instead of recreating them. - Coordination and sequencing: - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them. - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why. - Context hygiene: - Progressive disclosure applies to selecting relevant files, not partially reading a selected instruction file. Do not load unrelated references, scripts, or assets. - Avoid deep reference-chasing: prefer opening only files directly linked from `SKILL.md` unless you're blocked. - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice. - Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue. </skills_instructions>

<environment_context> <cwd>/app</cwd> <shell>bash</shell> <current_date>2026-06-21</current_date> <timezone>Etc/UTC</timezone> <filesystem><workspace_roots><root>/app</root></workspace_roots><permission_profile type="disabled"><file_system type="unrestricted" /></permission_profile></filesystem> </environment_context>

A Rust URL parsing workspace lives at /app. It exposes URL parsing, joining, serialization, path and host accessors, and public slicing positions. A parsed or joined URL should round-trip through serialization and parsing while preserving scheme, host, path, query, fragment, and slicing behavior. Fix non-special URLs with no host or authority whose logical path starts with //. When serializing that shape, insert the text /. between the scheme or port boundary and the logical path so reparsing does not treat the path as an authority. The marker is serialized text only: path() still returns the logical path without it, Position::AfterPort points before it, Position::BeforePath points after it, and the slice between those positions is /. for affected URLs. Joins must recompute the marker after path resolution. A join that leaves an affected // logical path keeps it; a join that resolves back to a single leading slash removes it, including parent-directory relative joins. Query-only and fragment-only joins preserve the existing path shape. Host-bearing URLs and special schemes keep their existing behavior. The relevant code paths are the non-special parser, relative join resolution, serialization, path accessors, and slicing positions in url/src/parser.rs, url/src/lib.rs, and url/src/slicing.rs. Apply the marker after dot-segment path normalization, and keep Position::AfterPort distinct from Position::BeforePath when the marker exists. Do not reject valid inputs or change public APIs. Build with cargo build --locked after the change.

I’ll inspect the workspace shape and the URL internals first, then make the smallest change that preserves current APIs and updates serialization/slicing consistently.

shell

pwd && rg --files

output

Chunk ID: 8b3256
Wall time: 0.0001 seconds
Process exited with code 0
Original token count: 21295
Output:
Total output lines: 880

/app
UPGRADING.md
idna/Cargo.toml
idna/src/make_uts46_mapping_table.py
idna/src/uts46.rs
idna/src/IdnaMappingTable.txt
idna/src/lib.rs
idna/src/punycode.rs
idna/src/uts46_mapping_table.rs
idna/tests/IdnaTestV2.txt
idna/tests/uts46.rs
idna/tests/punycode_tests.json
idna/tests/tests.rs
idna/tests/unit.rs
idna/tests/punycode.rs
idna/benches/all.rs
LICENSE-APACHE
data-url/Cargo.toml
data-url/src/forgiving_base64.rs
data-url/src/mime.rs
data-url/src/lib.rs
data-url/src/make_base64_decode_table.py
data-url/tests/data-urls.json
data-url/tests/generated-mime-types.json
data-url/tests/base64.json
data-url/tests/mime-types.json
data-url/tests/wpt.rs
data-url/README.md
debug_metadata/url.natvis
debug_metadata/README.md
url/Cargo.toml
url/src/host.rs
url/src/slicing.rs
url/src/origin.rs
url/src/quirks.rs
url/src/lib.rs
url/src/path_segments.rs
url/src/parser.rs
url/tests/data.rs
url/tests/setters_tests.json
url/tests/urltestdata.json
url/tests/unit.rs
url/tests/debugger_visualizer.rs
url/benches/parse_url.rs
url/fuzz/Cargo.toml
url/fuzz/fuzz_targets/parse.rs
deny.toml
LICENSE-MIT
form_urlencoded/LICENSE-APACHE
form_urlencoded/LICENSE-MIT
form_urlencoded/Cargo.toml
form_urlencoded/src/lib.rs
SECURITY.md
Cargo.lock
percent_encoding/Cargo.toml
percent_encoding/src/lib.rs
Cargo.toml
README.md
target/debug/libpercent_encoding.rlib
target/debug/liburl.rlib
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm.lock
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/8gogjfidpjzej9k6cuay2faf8.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/7ut7t8re1b826btusc5cl4v2x.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/agj3f7qghevfxfr23sr28wexi.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/a15dh6016y9308jgv5e47riq3.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/1kxqi2cpw1wo5d2dnndxvf6q3.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/e4mnmm3s16tqamgbh0pqntiok.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/91l4rjlvxicdixq97uw7o70v7.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/02xsfoa6kzjvu1nw0xxho3nlc.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/czcyo95aiasa68gs2u0oxokxg.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/biwxx8v5me9yij2twxhq1ogap.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/bykpo9u62mbxeguwentguhvb0.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/3aei1d9abwc04gi9rd1cvlj2z.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/46oe1q2uzd5akxevv3r99fzip.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/3t3b1o26rvpnv84xk4nmojy1e.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/deq16zjekzu8qul67ogjv8y31.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/9q2hld4yimftwjnk562e1bqew.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/2s6f3kdxqpgxfxyn1rc4xddur.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/dep-graph.bin
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/2775hsj8wkvgpksif3rqwm63w.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/9tkdo65ae4h7m9v8v0ats5of2.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/agq6p4fnfvqm77rbelsw0i4j6.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/work-products.bin
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/5v2gape4c61vc1ddu1kmo158v.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/28zb8h3ry0uxso7421eb3nt2k.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/epqw3gouk3odnxiuj1jo6hldl.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/bowd06t3jgepd1eidi3j9o54c.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/eekib1ye0fmfgef6oigd601yv.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/9whyp654sppd8k0rv4m5xmp82.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/01n2rtdvib90e2jsthfw51efv.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/900gb2yw76l4nrjafed0vh42m.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/a4enno5fp9euzckooxod3npn4.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/eczojs28z19hh99k6eb0g5j04.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/3soable5b906do9pka3x2j9ur.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/9g6iwsh5jtq52d8cdlz8yh4d1.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/3k910szc0dn0ty4qgva8y2qq8.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/4shhir26nlxxq5pss0w47by52.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/258jnbd9zwu7ew57q7u0253aq.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/cnhr8x0pnp7ugoh3ko1u8qs45.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/ee5cxl6a6evr6lsdy0cpxedow.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/3sebt2r12dsn1uk781qs3rnhj.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/bvlmdykgj4xwvt127xupf70rc.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/9phsq551fyex9j1tmbwzj74vr.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/502vo5unbup48b7ifgx6kehad.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/8rohcv8v1088qjcgbuymfy91d.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/0jbs3vebrmgnlpwe60ls7p9uz.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/9b7c6cf9hhtirf46fm6ecyjza.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/amkb38yht8dmwu1xgq03mti1h.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/de3ip26i8gt65m5od9658kn7r.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/2at9epbxsgpyahlfumu7gjq9i.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/899ugj7od0x8px3v3ujykw1p6.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/83ku5vaflgndgid98zhn9tawa.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/5ajzztpqhrapukd0uwkqipsna.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/1fn1lz061zk82vsndz5wj90o3.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/2qgczw6toiaw1fowj9gsqadxt.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/1mqw1yppynw397arbfl65hnkc.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/1ngss9k430ri6t12wx4v9zvcv.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/c7q5qfhogfqcw1j47ilyzo29x.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/csq4p3al5mzznuslat36pej80.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/a801ynq5m11ijqsdjkejvnu0s.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/98ekh76ol0t5gco2kc98r1jcy.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/bva2kc5y142ksiw58kco1di5h.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/cdzafb4i2ma0gvcjzdxxuifs2.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/6dty9q33gde7ehdujwsipdfj4.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/84sswellw3rrji8t4na9w2sdz.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/bgdylkdpa0do687xtaeak4iyx.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/dadh94qizpyp8wrvsgtcggzlp.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/query-cache.bin
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/3e03aiigsd27mupc64rh449kt.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/d4la7jajgpuc26d6ovpq23u1i.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/2ngb3hc1z6qtb06dq5cf3b3gd.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/4meummhxone2t5amg7j24wr07.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/3en08tqxbksbxhaswgqi0sx28.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/9jih05jud875hiz8en3na0y9j.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/dw4jde1xo1n0w2xa4jntnkut0.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/99lgqd3gkfdf8sehcdf25lcgr.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/6thfx2yz1zd3kkquq26m5mo9s.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/86qduwl8ldk65mozdb3lwi113.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/3clpzgo1jabo9s68qdd232jqb.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/4wxyd8q63l2nsrutm7rkca580.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/77wc4bkdzcxbswmtmuaeya94v.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/6m027519o46e4nno9lrqokkpz.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/7gyyqs9cor3i9yfyf4poizv7a.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/3r59joa5o2hnz85fgblg17ylz.o
target/debug/incremental/unit-1rtx6ttyceut6/s-hjou0rzxf7-0gprirm-8mmu68kplntmgv5jkthjsnd6n/6adv5em2rxewf6n5fqd8d7m9d.o
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r-0i4hmo3dzf6r3t8anyfcx7eg7/dep-graph.bin
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r-0i4hmo3dzf6r3t8anyfcx7eg7/3sfk52cnzdq3lqldqdla1qavt.o
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r-0i4hmo3dzf6r3t8anyfcx7eg7/work-products.bin
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r-0i4hmo3dzf6r3t8anyfcx7eg7/8ilh8nwuzeqny6ljn8jbw2i8k.o
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r-0i4hmo3dzf6r3t8anyfcx7eg7/4l1vm0j7jhztplafysuoeo49c.o
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r-0i4hmo3dzf6r3t8anyfcx7eg7/5fd3u3mwmlmcw5h6ml7cnji74.o
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r-0i4hmo3dzf6r3t8anyfcx7eg7/cz3povjitv5meffkbljpcs39v.o
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r-0i4hmo3dzf6r3t8anyfcx7eg7/query-cache.bin
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r-0i4hmo3dzf6r3t8anyfcx7eg7/7nwf44ir5vg1i4bia652z894r.o
target/debug/incremental/url-3624ita5ju63y/s-hjou0ruvk4-1a7xc8r.lock
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/7cf9q8hxgewy7fxi1c17o9i05.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/9phx5yraspeaqwxoti1fgnsrn.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/04o9cgx8g2kz956ty9tpsgryb.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/5xo60wnqxg5d0zouu0oozzgbk.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/cb9bhzmp64hcwz0i5a2gb7ljo.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/4jj7m0xmf338g0h9ddeavq5tx.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/dep-graph.bin
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/5xerj1fbrybp04odmprzc2tli.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/work-products.bin
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/29coxn26xu0ucq3jceu8oc66m.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/92bdiyw3s2e5mvu7lwkgu6ivr.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/6s6poscwjxwdt5eyd6ym2r70v.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/7sk2a8sic80511hlwuz5hm29c.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/crxgtrgwuh1dtj2ptf8anhy4f.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/clrbht8a7rpj3ovzul6pwl080.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/4zoqbyoi6510ruh1s7ytygswe.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/3ym2vudmm4uwsebtisb6w517c.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/d4bdaewn9b8y4h2bd93722p17.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/afl8quyys9iwv7z3pvotj3q3e.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/emfetx9zqbl9xkryzrm9rd6dy.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/andomrbsvoso3335e5zhcj1yd.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/2n5wgpdggu3o4ey2pwhf1oujx.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/4mu0gd8b6clv6meqa7tzsdrcm.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/cpax00wsrg6ufv6h0tjjsk9ye.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/query-cache.bin
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/8gp07z2d6oe9s1xrjunbtmxij.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/7fu1fneukssvukuu62i6rlgw7.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/by2di4qiusbvp2t42y12c5clj.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/1s91xfp48o921nrv7o90ulx77.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/cqgmz89vl46h02iy47mi6p6c8.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/1lu2c6mxvsput39c4shrvgd2t.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/a887fs7l9anok7yw5qm1tt9wu.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/afn5x3bhw0mdk58dr58txotre.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/9ejwdbt8hw620lzueki5mdy2r.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417-dxiy9q2gpkp9di0h18y73gfd7/878cwrgtzo3vcpcqv4kutl8x3.o
target/debug/incremental/unit-31a5kslhf18xu/s-hjou0rfi84-1h7v417.lock
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/9othkraw3qbdb5e9ev5eg5rtq.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/cwa0bj1vggn6xjpkf9nhbt9nt.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/cyujqk6vivgcm8twqp2o31aet.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/24pnjujsglbnpa144imdgykot.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/7twjxl7vvtzau3v8q21uk6x9u.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/5x0z02og4td8p1q4ek7ionbpk.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/cvjal1ffqe3tvi7ugt2tr7s24.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/dep-graph.bin
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/2le4kr196w91zykrbz1u38ldy.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/1zkurdy0ajj5ckboo5dkzjdp5.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/work-products.bin
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/27tkn0dgl56qtoxj7edcfivqp.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/e1at3tiumu08k4o2rzvebe97t.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/3nibda4ow4wvc5gijmqhxw72y.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/9vuil794wxxxynqcxqujejul8.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/0u7qi5ddthljzjcpkfc6ta8tr.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/f18ebq8c8rpbwvkctv3cv57sk.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/ai50witipr45wh5lk17f12bdv.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/6dio3aosr8nplwcwufgppoyhd.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/87igb8wed1g5rk6i2ov4tpsrx.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/5dborrn4nvyw8a2bcp2hs7ixt.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/4n2lprkjg52owqvtd3cs0bm1h.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/query-cache.bin
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/budy2lspdszs5dw7y7iww3mg2.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/el8785gtcnf25tu6awe8kr1wy.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/7wkr8rbqzz5uqwno7nh6bql9j.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/eoqjw13y8h2cc0l8sptxpkgou.o
target/debug/incremental/idna-2s4mps90pq4mr/s-hjou0rrsg9-0nrlnq3-0ng4nc93r1nsvdzi5bfrz1y8b/9dvyata0eq51m9lrvm2pikibw.o
target/debug/increm…11295 tokens truncated…/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/3nv95jgd7ldpzicily9exjqzb.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/3w9oxnf1edla6b11tvg2dt3v9.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/69apbhc5hjzeydi5782yuhtq5.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a.lock
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/061e7fk3efzxuz21lusjkwjxr.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/f3s1b0yvz2n2dlwyn8zwgpoht.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/5t2k2p0teew9ak0hx0gxea7yk.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/dy0d2diyf9a35hm6s76ym8i1q.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/8w8xtm50dmtxsq8d9g6dei59o.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/f1po4hsqdzml7grw4u5tv1kdp.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/4o1rlyz7bmuue0vqio1fxpdxe.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/egha0hz6c95suwbtpy10bgzi5.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/7p739lxaew3rm6w0vgd9cghu6.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/8pqvrox0kxsj8livgc85c1wg9.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/4ts9s7ewj6hs1mq0wceyckj9f.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/86ekl64ljgriz1xty557eim2h.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/3ctwdlikh71n6j7y9hnpp7i40.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/8qvjw65sfczifk0z4qq1mnfsj.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/query-cache.bin
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/51vfue1hjdjr7o96624o848qh.o
target/debug/incremental/url-3cvdemg46jae7/s-hjou0p4irm-1yhu75a-bene5tmkrt5kv2rve6pdxzku1/bu32tkdq4dttxi87c4o7fpm9q.o
target/debug/libdata_url.rlib
target/debug/libform_urlencoded.rlib
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/7rh446oh9a9qssh1logdl02pd.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/138ywypj0p4hz8c1yzolci8vj.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/8zcz28ufrusxeuzvwrdddqw95.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/4ro337pndi6u8mq3ltkktfamc.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/8r7p6sjrebefmkpstumvn9f7c.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/dep-graph.bin
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/work-products.bin
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/6fd027e4vtb04drzfi3ibc3cy.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/9zrwc851ymvmtfsq2pqpib5uy.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/bkmjsi5y68po5wbn75lpdhupf.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/3985rk03xctcqi5zfib0q9rnq.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/2jum5x7384buq6qoewylcmnds.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/cfln0n5p7ztgntbkcvendyk68.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/cu8ohjtyqfg4mpuwwablueq9e.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/b8khd8v0l61h0tq6h9zykui3a.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/8mep6kq5b8mcakrzy46dileo0.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/3mzt170e2rc0li0bwa4r9dj39.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/query-cache.bin
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/cg8azhw7rv32mkhqq5vbcfg10.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/5lvxv7pmg6atq9ow2okbkke2u.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/5kfjkyy2cf9zqe2ecom52onda.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/73qx2yp1rq54gjsos0laejcub.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/4so737lo0vx00jofsz4ghxjgf.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw-97rveeplqley3535djdbtq0vi/729s4twcw4dvbcpmoh0mrwh8p.o
target/debug/incremental/form_urlencoded-00uc8m5pkihl0/s-hjou0ovehp-0w1bekw.lock
target/debug/build/libc-ad25a1021d8bc503/build_script_build-ad25a1021d8bc503
target/debug/build/libc-ad25a1021d8bc503/build_script_build-ad25a1021d8bc503.d
target/debug/build/libc-ad25a1021d8bc503/build-script-build
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/16mrank5umtrmyio1o8ggdohc.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/0eov6xcb3cxkoj0dza0c7zrov.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/0q26nsy2hw75urq8j8u8de1m1.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/9ylcjemhp24uxct0om6k3zdeh.o
target/debug/build/serde_core-58ec2e75b87c45d5/build_script_build-58ec2e75b87c45d5.d
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/efmedkxy2by267imkj7eaj13a.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/0jrzhm8a1370szlz2niqk6ua4.o
target/debug/build/serde_core-58ec2e75b87c45d5/build-script-build
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/5idn9lrht456fghs23jt0uu25.o
target/debug/build/serde_core-58ec2e75b87c45d5/build_script_build-58ec2e75b87c45d5
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/0cty7j0dg6ueh80u4wpa9s2o1.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/4wojuyhe9v2sugp74y1hjmj9w.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/6809ygbq2787l3g4totpw3886.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/7g6eozzvf9uf86hmr1p3t6ymh.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/7egkk04k0cwqbmpk14n54zkbd.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/1w9ggip3r5yvw1ib0lszj7q5q.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/cpd3lf7bfub5o2zpcnj8ms62f.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/83n5zanjqh7u7cdpbpfbylw5d.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/bskett978cnufg3oa1dkn384t.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/dhqgdrxu1wyggalthhbq5ea55.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/dus9hxw1qovzexfbulw8gsgjk.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/b1esjaqdlxbgf2ygwawyaeuaa.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/elz60d1tgq5mxnhd26z7n3si1.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/bqq6dziwi1j5l7dvvqmxqkd1z.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/eh2dcw1tp8oje3nwi5vwb5lad.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/6oogwtkt0i6bmq9u9gplsyaeg.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/42dvma5wqliejr82eyzb2q69w.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/dep-graph.bin
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/374vie5vh0duu1ajn3rnnkfib.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/4jf22m847t81rab5bz84pe5df.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/2dfl0gnco0sc40368c7e20r0r.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/47vol74196wo0j6tquo28jkqh.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/2azj6kiibt5eyokraia0d07q5.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/d14l2ixyjpvk6wdbgvlpimc7n.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/445ncjwk0z08t6g0tbhl29h8m.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/work-products.bin
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/5f1ombqj49vnoomh36cayufa6.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/b2lipmztvegkf1teunq2uj0ao.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/4kdv0bvdwq9gw0f1iw2ex3xhl.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/cyjbtppw3jh4zq1y83dacp1ja.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/8cna0rkcfwkxilm86rds2066t.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/9akcqwg56im4wy0pi3t06r9sv.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/6ugab35o9yqleyreat18b6666.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/ew4nas5lp3gxypvmxmldvbfqu.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/1eyk6frfkd66zloqnqp8fni92.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/e9iwac2wb9smqkg5uwiw6g4yg.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/4pz8qrtlta9z2a597pdwjii9g.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/8sb7n6m3oyk8gfawcp6da5kpf.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/bh8twggzos86tmwav6u8g66r6.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/23icqbbqtb6fh1vg0j2nucrdl.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/49874fpap0bz9ev8wt0oh3jst.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/bcoxddjebok2dxnd5sqmj9vf0.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/64c3wkk340p79p1poyski6azn.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/4noqoa6vh5sk0tt8xgqqbvsm5.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/7u1ap92hc0rjbzokmg35g66f8.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/9r7z0js5b605u71e9osf253jy.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/9o0wf07ejkokkolxhhqyse963.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/acm5nyx4m5n7dq7ohx5zvt4aw.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/4lr2ldlx67yk15v8x340dgu90.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/40gd9wpt86fycn4fgyvix592l.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/61ise8tyush68jvuafwxg7tc2.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/9fzopt7i74e3d2hvsv9ayiu67.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/33ewk0x0fixd108ujewwes8xm.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/6bw77pie55u142ljxsob6dp7d.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/17ipzdtk2bfoc2hihkjlfagtn.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/0uqiempuze711xd3n7g6qowld.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/8y44fbxqsl3hw52ir2jgauam9.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/df1d1d6crlbw7skdgc3ra10mk.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/a93155414jj8u3eea9nlhbjz7.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/5u6j1gxxe61aliwm527klnujn.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/1ycfj2jkxq2cv1jkk554tvlih.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/8o05of94ry9hcqubi0igstt4o.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/bmb7llbmjd5v81iwnszfbvq4o.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/3me9m97na6kimdm6mlhkhr9d4.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/4whcma8tc866ma6ncilkczxbc.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/duwjxu5aefho4hz3di6w04uwh.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/query-cache.bin
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/docrj24u4cc71i69idv1gwvg2.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/53m6w1lqbwsu0ti7wzsh9j0wx.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/8efl2q7pm8bc1qe4le1o61j7f.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/7db4aa24j8eocrz5lyrfj0nrw.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/d6uyc7se8s4xqmsosofikoug0.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/bx4juq239lz1f2o9qd9boce6a.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/8m003xfbyn8who1bk030hdjj0.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/0otxrwmc96bn4uvt0dwss9f5z.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/06m80elx0jwoqg06t0fuif9m8.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/dtyuzookd6p0q32oh0d9easrb.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/6dl4gd0nauy0h0fluun719tyy.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8-4lvrqk2ogf09c5qvlidvae53n/4v4x7nrekfjjhm0e5355r9on3.o
target/debug/incremental/idna-3i1sdojlmq5rx/s-hjou0p06fa-1bn0oh8.lock
target/debug/build/proc-macro2-4ccecbdd481395e7/build_script_build-4ccecbdd481395e7
target/debug/build/proc-macro2-4ccecbdd481395e7/build_script_build-4ccecbdd481395e7.d
target/debug/build/proc-macro2-4ccecbdd481395e7/build-script-build
target/debug/build/serde-b1128fd7a9b46781/build_script_build-b1128fd7a9b46781
target/debug/build/serde-b1128fd7a9b46781/build-script-build
target/debug/build/serde-b1128fd7a9b46781/build_script_build-b1128fd7a9b46781.d
target/debug/build/syn-543e65d50dac7c38/output
target/debug/build/syn-543e65d50dac7c38/invoked.timestamp
target/debug/build/syn-543e65d50dac7c38/stderr
target/debug/build/syn-543e65d50dac7c38/root-output
target/debug/build/quote-5b51a8dd8290005e/build_script_build-5b51a8dd8290005e
target/debug/build/quote-5b51a8dd8290005e/build_script_build-5b51a8dd8290005e.d
target/debug/build/quote-5b51a8dd8290005e/build-script-build
target/debug/build/proc-macro2-bd986aab9ef403a2/output
target/debug/build/proc-macro2-bd986aab9ef403a2/invoked.timestamp
target/debug/build/proc-macro2-bd986aab9ef403a2/stderr
target/debug/build/proc-macro2-bd986aab9ef403a2/root-output
target/debug/build/quote-c8e2688b757dd7d5/output
target/debug/build/quote-c8e2688b757dd7d5/invoked.timestamp
target/debug/build/quote-c8e2688b757dd7d5/stderr
target/debug/build/quote-c8e2688b757dd7d5/root-output
target/debug/build/anyhow-865c62892f774c58/build_script_build-865c62892f774c58.d
target/debug/build/anyhow-865c62892f774c58/build_script_build-865c62892f774c58
target/debug/build/anyhow-865c62892f774c58/build-script-build
target/debug/build/syn-255ecb636db8ec71/build_script_build-255ecb636db8ec71
target/debug/build/syn-255ecb636db8ec71/build-script-build
target/debug/build/syn-255ecb636db8ec71/build_script_build-255ecb636db8ec71.d
target/debug/build/libc-6f42403205f9303e/output
target/debug/build/libc-6f42403205f9303e/invoked.timestamp
target/debug/build/libc-6f42403205f9303e/stderr
target/debug/build/libc-6f42403205f9303e/root-output
target/debug/build/serde_json-0ccae1069ea496b1/build_script_build-0ccae1069ea496b1.d
target/debug/build/serde_json-0ccae1069ea496b1/build_script_build-0ccae1069ea496b1
target/debug/build/serde_json-0ccae1069ea496b1/build-script-build
target/debug/build/serde_core-e64bb9c45bfe80f3/out/private.rs
target/debug/build/serde_core-e64bb9c45bfe80f3/output
target/debug/build/serde_core-e64bb9c45bfe80f3/invoked.timestamp
target/debug/build/serde_core-e64bb9c45bfe80f3/stderr
target/debug/build/serde_core-e64bb9c45bfe80f3/root-output
target/debug/build/zmij-f4c55d12a4111926/output
target/debug/build/zmij-f4c55d12a4111926/invoked.timestamp
target/debug/build/zmij-f4c55d12a4111926/stderr
target/debug/build/zmij-f4c55d12a4111926/root-output
target/debug/build/serde_json-56a19a2a331ed41b/output
target/debug/build/serde_json-56a19a2a331ed41b/invoked.timestamp
target/debug/build/serde_json-56a19a2a331ed41b/stderr
target/debug/build/serde_json-56a19a2a331ed41b/root-output
target/debug/build/serde-ef19f8e495c8dd30/out/private.rs
target/debug/build/serde-ef19f8e495c8dd30/output
target/debug/build/serde-ef19f8e495c8dd30/invoked.timestamp
target/debug/build/serde-ef19f8e495c8dd30/stderr
target/debug/build/serde-ef19f8e495c8dd30/root-output
target/debug/build/anyhow-7ef9f9965b442394/stderr
target/debug/build/anyhow-7ef9f9965b442394/root-output
target/debug/build/anyhow-7ef9f9965b442394/output
target/debug/build/anyhow-7ef9f9965b442394/invoked.timestamp
target/debug/build/zmij-66703644318e2170/build_script_build-66703644318e2170
target/debug/build/zmij-66703644318e2170/build_script_build-66703644318e2170.d
target/debug/build/zmij-66703644318e2170/build-script-build

shell

git status --short

output

Chunk ID: 694f60
Wall time: 0.0001 seconds
Process exited with code 128
Original token count: 18
Output:
fatal: not a git repository (or any of the parent directories): .git

There’s no `.git` metadata in `/app`, so I’ll work directly against the tree. I’m narrowing in on the parser, serializer, and slicing offsets now.

shell

rg "struct Url|Position|path_start|path\(|serialize|fmt::Display|cannot_be_a_base|special|AfterPort|BeforePath" url/src/lib.rs url/src/parser.rs url/src/slicing.rs

output

Chunk ID: ac8cb4
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 5058
Output:
url/src/lib.rs:use url::{Url, Host, Position};
url/src/lib.rs:assert!(issue_list_url.path() == "/rust-lang/rust/issues");
url/src/lib.rs:assert!(&issue_list_url[Position::BeforePath..] == "/rust-lang/rust/issues?labels=E-easy&state=open");
url/src/lib.rs:assert!(!issue_list_url.cannot_be_a_base());
url/src/lib.rs:assert!(data_url.cannot_be_a_base());
url/src/lib.rs:assert!(data_url.path() == "text/plain,Hello");
url/src/lib.rs:Enable the `serde` feature to include `Deserialize` and `Serialize` implementations for `url::Url`.
url/src/lib.rs:[`serde::Deserialize`](https://docs.rs/serde/1/serde/trait.Deserialize.html).
url/src/lib.rs:pub use crate::slicing::Position;
url/src/lib.rs:pub struct Url {
url/src/lib.rs:    path_start: u32,            // Before initial '/', if any
url/src/lib.rs:    query_start: Option<u32>,   // Before '?', unlike Position::QueryStart
url/src/lib.rs:    fragment_start: Option<u32>, // Before '#', unlike Position::FragmentStart
url/src/lib.rs:    fn strip_trailing_spaces_from_opaque_path(&mut self) {
url/src/lib.rs:        if !self.cannot_be_a_base() {
url/src/lib.rs:        if self.cannot_be_a_base() {
url/src/lib.rs:        let (base_path, base_filename) = extract_path_filename(self.path());
url/src/lib.rs:        let (url_path, url_filename) = extract_path_filename(url.path());
url/src/lib.rs:                    if SchemeType::from(self.scheme()).is_special() {
url/src/lib.rs:            if self.path_start == self.host_end {
url/src/lib.rs:                let port_str = self.slice(self.host_end + 1..self.path_start);
url/src/lib.rs:                self.path_start as usize == self.serialization.len()
url/src/lib.rs:                    || matches!(self.byte_at(self.path_start), b'/' | b'#' | b'?')
url/src/lib.rs:            assert_eq!(self.path_start, self.scheme_end + 1);
url/src/lib.rs:            assert!(start >= self.path_start);
url/src/lib.rs:            assert!(start >= self.path_start);
url/src/lib.rs:        assert_eq!(self.path_start, other.path_start);
url/src/lib.rs:    /// of a special URL, or percent encoded for non-special URLs.
url/src/lib.rs:    /// Ports are omitted if they match the well known port of a special URL.
url/src/lib.rs:        if self.has_authority() && self.path_start > self.scheme_end + scheme_separator_len {
url/src/lib.rs:            self.slice(self.scheme_end + scheme_separator_len..self.path_start)
url/src/lib.rs:    /// assert!(!url.cannot_be_a_base());
url/src/lib.rs:    /// assert!(!url.cannot_be_a_base());
url/src/lib.rs:    /// assert!(url.cannot_be_a_base());
url/src/lib.rs:    pub fn cannot_be_a_base(&self) -> bool {
url/src/lib.rs:    /// of a special URL, or percent encoded for non-special URLs.
url/src/lib.rs:    /// of a special URL, or percent encoded for non-special URLs.
url/src/lib.rs:    /// of a special URL, or percent encoded for non-special URLs.
url/src/lib.rs:    /// assert_eq!(url.path(), "/api/versions");
url/src/lib.rs:    /// assert_eq!(url.path(), "/");
url/src/lib.rs:    /// assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");
url/src/lib.rs:    pub fn path(&self) -> &str {
url/src/lib.rs:            (None, None) => self.slice(self.path_start..),
url/src/lib.rs:                self.slice(self.path_start..next_component_start)
url/src/lib.rs:        let path = self.path();
url/src/lib.rs:            self.strip_trailing_spaces_from_opaque_path();
url/src/lib.rs:            self.strip_trailing_spaces_from_opaque_path();
url/src/lib.rs:    fn take_after_path(&mut self) -> String {
url/src/lib.rs:    /// url.set_path("api/comments");
url/src/lib.rs:    /// assert_eq!(url.path(), "/api/comments");
url/src/lib.rs:    /// url.set_path("data/report.csv");
url/src/lib.rs:    /// assert_eq!(url.path(), "/data/report.csv");
url/src/lib.rs:    /// url.set_path("api/some comments");
url/src/lib.rs:    /// assert_eq!(url.path(), "/api/some%20comments");
url/src/lib.rs:    /// url.set_path("api/some%20comments");
url/src/lib.rs:    /// assert_eq!(url.path(), "/api/some%20comments");
url/src/lib.rs:    pub fn set_path(&mut self, mut path: &str) {
url/src/lib.rs:        let after_path = self.take_after_path();
url/src/lib.rs:        let cannot_be_a_base = self.cannot_be_a_base();
url/src/lib.rs:        self.serialization.truncate(self.path_start as usize);
url/src/lib.rs:            if cannot_be_a_base {
url/src/lib.rs:                parser.parse_cannot_be_a_base_path(parser::Input::new(path));
url/src/lib.rs:                parser.parse_path_start(scheme_type, &mut has_host, parser::Input::new(path));
url/src/lib.rs:        self.restore_after_path(old_after_path_pos, &after_path);
url/src/lib.rs:        if self.cannot_be_a_base() {
url/src/lib.rs:    fn restore_after_path(&mut self, old_after_path_position: u32, after_path: &str) {
url/src/lib.rs:        // has_host implies !cannot_be_a_base
url/src/lib.rs:                    .drain(self.host_end as usize..self.path_start as usize);
url/src/lib.rs:                let offset = self.path_start - self.host_end;
url/src/lib.rs:                self.path_start = self.host_end;
url/src/lib.rs:                let path_and_after = self.slice(self.path_start..).to_owned();
url/src/lib.rs:                let old_path_start = self.path_start;
url/src/lib.rs:                let new_path_start = to_u32(self.serialization.len()).unwrap();
url/src/lib.rs:                self.path_start = new_path_start;
url/src/lib.rs:                    *index -= old_path_start;
url/src/lib.rs:                    *index += new_path_start;
url/src/lib.rs:    /// Cannot remove host for 'special' schemes (e.g. `http`):
url/src/lib.rs:        if self.cannot_be_a_base() {
url/src/lib.rs:            if host.is_empty() && scheme_type.is_special() && !scheme_type.is_file() {
url/src/lib.rs:            if SchemeType::from(self.scheme()).is_special() {
url/src/lib.rs:            if scheme_type.is_special() && !scheme_type.is_file() {
url/src/lib.rs:            } else if self.serialization.len() == self.path_start as usize {
url/src/lib.rs:            debug_assert!(self.byte_at(self.path_start) == b'/');
url/src/lib.rs:            let new_path_start = if scheme_type.is_file() {
url/src/lib.rs:                .drain(new_path_start as usize..self.path_start as usize);
url/src/lib.rs:            let offset = self.path_start - new_path_start;
url/src/lib.rs:            self.path_start = new_path_start;
url/src/lib.rs:            self.username_end = new_path_start;
url/src/lib.rs:            self.host_start = new_path_start;
url/src/lib.rs:            self.host_end = new_path_start;
url/src/lib.rs:            self.path_start
url/src/lib.rs:        adjust(&mut self.path_start);
url/src/lib.rs:        if self.cannot_be_a_base() {
url/src/lib.rs:        // has_host implies !cannot_be_a_base
url/src/lib.rs:            adjust(&mut self.path_start);
url/src/lib.rs:            self.path_start -= offset;
url/src/lib.rs:        // has_host implies !cannot_be_a_base
url/src/lib.rs:        adjust(&mut self.path_start);
url/src/lib.rs:        // If url’s scheme is a special scheme and buffer is not a special scheme, then return.
url/src/lib.rs:        if (new_scheme_type.is_special() && !old_scheme_type.is_special()) ||
url/src/lib.rs:            // If url’s scheme is not a special scheme and buffer is a special scheme, then return.
url/src/lib.rs:            (!new_scheme_type.is_special() && old_scheme_type.is_special()) ||
url/src/lib.rs:        if !remaining.is_empty() || (!self.has_host() && new_scheme_type.is_special()) {
url/src/lib.rs:        adjust(&mut self.path_start);
url/src/lib.rs:    /// let url = Url::from_file_path("/tmp/foo.txt")?;
url/src/lib.rs:    /// let url = Url::from_file_path("../foo.txt");
url/src/lib.rs:    /// let url = Url::from_file_path("https://google.com/");
url/src/lib.rs:            path_start: host_end,
url/src/lib.rs:    /// * `"index.html"` parsed with `Url::from_directory_path(Path::new("/var/www"))`
url/src/lib.rs:    /// * `"index.html"` parsed with `Url::from_file_path(Path::new("/var/www"))`
url/src/lib.rs:        let mut url = Url::from_file_path(path)?;
url/src/lib.rs:    /// The corresponding `deserialize_internal` method sacrifices some invariant-checking
url/src/lib.rs:    /// for speed, compared to the `Deserialize` trait impl.
url/src/lib.rs:    pub fn serialize_internal<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
url/src/lib.rs:            ref path_start,
url/src/lib.rs:            path_start,
url/src/lib.rs:            .serialize(serializer)
url/src/lib.rs:    /// The corresponding `deserialize_internal` method sacrifices some invariant-checking
url/src/lib.rs:    /// for speed, compared to the `Deserialize` trait impl.
url/src/lib.rs:    pub fn deserialize_internal<'de, D>(deserializer: D) -> Result<Self, D::Error>
url/src/lib.rs:        D: serde::Deserializer<'de>,
url/src/lib.rs:        use serde::de::{Deserialize, Error, Unexpected};
url/src/lib.rs:            path_start,
url/src/lib.rs:        ) = Deserialize::deserialize(deserializer)?;
url/src/lib.rs:            path_start,
url/src/lib.rs:    /// let path = url.to_file_path();
url/src/lib.rs:    pub fn to_file_path(&self) -> Result<PathBuf, ()> {
url/src/lib.rs:impl fmt::Display for Url {
url/src/lib.rs:        fmt::Display::fmt(&self.serialization, formatter)
url/src/lib.rs:            .field("cannot_be_a_base", &self.cannot_be_a_base())
url/src/lib.rs:            .field("path", &self.path())
url/src/lib.rs:    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
url/src/lib.rs:        serializer.serialize_str(self.as_str())
url/src/lib.rs:/// Deserializes this URL from a `serde` stream.
url/src/lib.rs:impl<'de> serde::Deserialize<'de> for Url {
url/src/lib.rs:    fn deserialize<D>(deserializer: D) -> Result<Url, D::Error>
url/src/lib.rs:        D: serde::Deserializer<'de>,
url/src/lib.rs:        struct UrlVisitor;
url/src/lib.rs:        deserializer.deserialize_str(UrlVisitor)
url/src/lib.rs:        "to_file_path() failed to produce an absolute Path"
url/src/lib.rs:        "to_file_path() failed to produce an absolute Path"
url/src/lib.rs:pub struct UrlQuery<'a> {
url/src/slicing.rs:impl Index<RangeFrom<Position>> for Url {
url/src/slicing.rs:    fn index(&self, range: RangeFrom<Position>) -> &str {
url/src/slicing.rs:impl Index<RangeTo<Position>> for Url {
url/src/slicing.rs:    fn index(&self, range: RangeTo<Position>) -> &str {
url/src/slicing.rs:impl Index<Range<Position>> for Url {
url/src/slicing.rs:    fn index(&self, range: Range<Position>) -> &str {
url/src/slicing.rs:/// # use url::{Url, Position};
url/src/slicing.rs:/// let serialization_without_fragment: &str = &some_url[..Position::AfterQuery];
url/src/slicing.rs:/// let authority: &str = &some_url[Position::BeforeUsername..Position::AfterPort];
url/src/slicing.rs:/// let data_url_payload: &str = &some_url[Position::BeforePath..Position::AfterQuery];
url/src/slicing.rs:/// let scheme_relative: &str = &some_url[Position::BeforeUsername..];
url/src/slicing.rs:pub enum Position {
url/src/slicing.rs:    AfterPort,
url/src/slicing.rs:    BeforePath,
url/src/slicing.rs:    fn index(&self, position: Position) -> usize {
url/src/slicing.rs:            Position::BeforeScheme => 0,
url/src/slicing.rs:            Position::AfterScheme => self.scheme_end as usize,
url/src/slicing.rs:            Position::BeforeUsername => {
url/src/slicing.rs:            Position::AfterUsername => self.username_end as usize,
url/src/slicing.rs:            Position::BeforePassword => {
url/src/slicing.rs:            Position::AfterPassword => {
url/src/slicing.rs:            Position::BeforeHost => self.host_start as usize,
url/src/slicing.rs:            Position::AfterHost => self.host_end as usize,
url/src/slicing.rs:            Position::BeforePort => {
url/src/slicing.rs:            Position::AfterPort => self.path_start as usize,
url/src/slicing.rs:            Position::BeforePath => self.path_start as usize,
url/src/slicing.rs:            Position::AfterPath => match (self.query_start, self.fragment_start) {
url/src/slicing.rs:            Position::BeforeQuery => match (self.query_start, self.fragment_start) {
url/src/slicing.rs:            Position::AfterQuery => match self.fragment_start {
url/src/slicing.rs:            Position::BeforeFragment => match self.fragment_start {
url/src/slicing.rs:            Position::AfterFragment => self.serialization.len(),
url/src/parser.rs:// The backslash (\) character is treated as a path separator in special URLs
url/src/parser.rs:        impl fmt::Display for ParseError {
url/src/parser.rs:impl fmt::Display for SyntaxViolation {
url/src/parser.rs:        fmt::Display::fmt(self.description(), f)
url/src/parser.rs:    pub fn is_special(&self) -> bool {
url/src/parser.rs:            } else if base_url.cannot_be_a_base() {
url/src/parser.rs:                // special relative or authority state
url/src/parser.rs:                        // "Cannot-be-a-base" URLs only happen with "not special" schemes.
url/src/parser.rs:                        debug_assert!(!base_url.cannot_be_a_base());
url/src/parser.rs:                // special authority slashes state
url/src/parser.rs:            SchemeType::NotSpecial => self.parse_non_special(input, scheme_type, scheme_end),
url/src/parser.rs:    fn parse_non_special(
url/src/parser.rs:        let path_start = to_u32(self.serialization.len())?;
url/src/parser.rs:        let username_end = path_start;
url/src/parser.rs:        let host_start = path_start;
url/src/parser.rs:        let host_end = path_start;
url/src/parser.rs:            let path_start = self.serialization.len();
url/src/parser.rs:            self.parse_path(scheme_type, &mut false, path_start, input)
url/src/parser.rs:            self.parse_cannot_be_a_base_path(input)
url/src/parser.rs:            path_start,
url/src/parser.rs:                let (path_start, mut host, remaining) =
url/src/parser.rs:                let remaining = if path_start {
url/src/parser.rs:                    self.parse_path_start(SchemeType::File, &mut has_host, remaining)
url/src/parser.rs:                    let path_start = self.serialization.len();
url/src/parser.rs:                    self.parse_path(SchemeType::File, &mut has_host, path_start, remaining)
url/src/parser.rs:                    path_start: host_end,
url/src/parser.rs:                    self.parse_path(SchemeType::File, &mut false, host_end, parse_path_input);
url/src/parser.rs:                    path_start: host_end,
url/src/parser.rs:                        self.shorten_path(SchemeType::File, base_url.path_start as usize);
url/src/parser.rs:                        let remaining = self.parse_path(
url/src/parser.rs:                            base_url.path_start as usize,
url/src/parser.rs:                            base_url.path_start,
url/src/parser.rs:                        let path_start = "file://".len();
url/src/parser.rs:                            self.parse_path(SchemeType::File, &mut false, path_start, input);
url/src/parser.rs:                        let path_start = path_start as u32;
url/src/parser.rs:                            username_end: path_start,
url/src/parser.rs:                            host_start: path_start,
url/src/parser.rs:                            host_end: path_start,
url/src/parser.rs:                            path_start,
url/src/parser.rs:            let path_start = "file://".len();
url/src/parser.rs:            let remaining = self.parse_path(SchemeType::File, &mut false, path_start, input);
url/src/parser.rs:            let path_start = path_start as u32;
url/src/parser.rs:                username_end: path_start,
url/src/parser.rs:                host_start: path_start,
url/src/parser.rs:                host_end: path_start,
url/src/parser.rs:                path_start,
url/src/parser.rs:                let path_start = base_url.path_start;
url/src/parser.rs:                self.serialization.push_str(base_url.slice(..path_start));
url/src/parser.rs:                let remaining = self.parse_path(
url/src/parser.rs:                    path_start as usize,
url/src/parser.rs:                    base_url.path_start,
url/src/parser.rs:                self.pop_path(scheme_type, base_url.path_start as usize);
url/src/parser.rs:                // A special url always has a path.
url/src/parser.rs:                if self.serialization.len() == base_url.path_start as usize
url/src/parser.rs:                    && (SchemeType::from(base_url.scheme()).is_special() || !input.is_empty())
url/src/parser.rs:                    (Some('/'), remaining) => self.parse_path(
url/src/parser.rs:                        base_url.path_start as usize,
url/src/parser.rs:                        self.parse_path(scheme_type, &mut true, base_url.path_start as usize, input)
url/src/parser.rs:                    base_url.path_start,
url/src/parser.rs:        let path_start = to_u32(self.serialization.len())?;
url/src/parser.rs:        let remaining = self.parse_path_start(scheme_type, &mut true, remaining);
url/src/parser.rs:            path_start,
url/src/parser.rs:                '\\' if scheme_type.is_special() => break,
url/src/parser.rs:                // url is special and c is U+005C (\)
url/src/parser.rs:                    if c == '/' || c == '?' || c == '#' || (scheme_type.is_special() && c == '\\') {
url/src/parser.rs:                if scheme_type.is_special() {
url/src/parser.rs:                '\\' if scheme_type.is_special() => break,
url/src/parser.rs:        if !scheme_type.is_special() {
url/src/parser.rs:    pub fn parse_path_start<'i>(
url/src/parser.rs:        let path_start = self.serialization.len();
url/src/parser.rs:        // If url is special, then:
url/src/parser.rs:        if scheme_type.is_special() {
url/src/parser.rs:            // A special URL always has a non-empty path.
url/src/parser.rs:                    return self.parse_path(scheme_type, has_host, path_start, remaining);
url/src/parser.rs:            return self.parse_path(scheme_type, has_host, path_start, input);
url/src/parser.rs:        self.parse_path(scheme_type, has_host, path_start, input)
url/src/parser.rs:        path_start: usize,
url/src/parser.rs:                        && scheme_type.is_special() =>
url/src/parser.rs:                            if scheme_type.is_special() {
url/src/parser.rs:                        && Parser::last_slash_can_be_removed(&self.serialization, path_start)
url/src/parser.rs:                    self.shorten_path(scheme_type, path_start);
url/src/parser.rs:                    // and then if neither c is U+002F (/), nor url is special and c is U+005C (\), append the empty string to url’s path.
url/src/parser.rs:                // nor url is special and c is U+005C (\), append the empty string to url’s path.
url/src/parser.rs:            let path = self.serialization.split_off(path_start);
url/src/parser.rs:    fn last_slash_can_be_removed(serialization: &str, path_start: usize) -> bool {
url/src/parser.rs:            segment_before_start >= path_start
url/src/parser.rs:                && !path_starts_with_windows_drive_letter(&serialization[segment_before_start..])
url/src/parser.rs:    fn shorten_path(&mut self, scheme_type: SchemeType, path_start: usize) {
url/src/parser.rs:        if self.serialization.len() == path_start {
url/src/parser.rs:            && is_normalized_windows_drive_letter(&self.serialization[path_start..])
url/src/parser.rs:        self.pop_path(scheme_type, path_start);
url/src/parser.rs:    fn pop_path(&mut self, scheme_type: SchemeType, path_start: usize) {
url/src/parser.rs:        if self.serialization.len() > path_start {
url/src/parser.rs:            let slash_position = self.serialization[path_start..].rfind('/').unwrap();
url/src/parser.rs:            let segment_start = path_start + slash_position + 1;
url/src/parser.rs:    pub fn parse_cannot_be_a_base_path<'i>(&mut self, mut input: Input<'i>) -> Input<'i> {
url/src/parser.rs:        path_start: u32,
url/src/parser.rs:            path_start,
url/src/parser.rs:        let set = if scheme_type.is_special() {
url/src/parser.rs:fn path_starts_with_windows_drive_letter(s: &str) -> bool {

shell

sed -n '1,260p' url/src/lib.rs

output

Chunk ID: e8bd04
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 1992
Output:
// Copyright 2013-2015 The rust-url developers.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

/*!

rust-url is an implementation of the [URL Standard](http://url.spec.whatwg.org/)
for the [Rust](http://rust-lang.org/) programming language.


# URL parsing and data structures

First, URL parsing may fail for various reasons and therefore returns a `Result`.

```
use url::{Url, ParseError};

assert!(Url::parse("http://[:::1]") == Err(ParseError::InvalidIpv6Address))
```

Let’s parse a valid URL and look at its components.

```
use url::{Url, Host, Position};
# use url::ParseError;
# fn run() -> Result<(), ParseError> {
let issue_list_url = Url::parse(
    "https://[code-host]/rust-lang/rust/issues?labels=E-easy&state=open"
)?;


assert!(issue_list_url.scheme() == "https");
assert!(issue_list_url.username() == "");
assert!(issue_list_url.password() == None);
assert!(issue_list_url.host_str() == Some("[code-host]"));
assert!(issue_list_url.host() == Some(Host::Domain("[code-host]")));
assert!(issue_list_url.port() == None);
assert!(issue_list_url.path() == "/rust-lang/rust/issues");
assert!(issue_list_url.path_segments().map(|c| c.collect::<Vec<_>>()) ==
        Some(vec!["rust-lang", "rust", "issues"]));
assert!(issue_list_url.query() == Some("labels=E-easy&state=open"));
assert!(&issue_list_url[Position::BeforePath..] == "/rust-lang/rust/issues?labels=E-easy&state=open");
assert!(issue_list_url.fragment() == None);
assert!(!issue_list_url.cannot_be_a_base());
# Ok(())
# }
# run().unwrap();
```

Some URLs are said to be *cannot-be-a-base*:
they don’t have a username, password, host, or port,
and their "path" is an arbitrary string rather than slash-separated segments:

```
use url::Url;
# use url::ParseError;

# fn run() -> Result<(), ParseError> {
let data_url = Url::parse("data:text/plain,Hello?World#")?;

assert!(data_url.cannot_be_a_base());
assert!(data_url.scheme() == "data");
assert!(data_url.path() == "text/plain,Hello");
assert!(data_url.path_segments().is_none());
assert!(data_url.query() == Some("World"));
assert!(data_url.fragment() == Some(""));
# Ok(())
# }
# run().unwrap();
```

## Serde

Enable the `serde` feature to include `Deserialize` and `Serialize` implementations for `url::Url`.

# Base URL

Many contexts allow URL *references* that can be relative to a *base URL*:

```html
<link rel="stylesheet" href="../main.css">
```

Since parsed URLs are absolute, giving a base is required for parsing relative URLs:

```
use url::{Url, ParseError};

assert!(Url::parse("../main.css") == Err(ParseError::RelativeUrlWithoutBase))
```

Use the `join` method on an `Url` to use it as a base URL:

```
use url::Url;
# use url::ParseError;

# fn run() -> Result<(), ParseError> {
let this_document = Url::parse("http://servo.[code-host]/rust-url/url/index.html")?;
let css_url = this_document.join("../main.css")?;
assert_eq!(css_url.as_str(), "http://servo.[code-host]/rust-url/main.css");
# Ok(())
# }
# run().unwrap();
```

# Feature: `serde`

If you enable the `serde` feature, [`Url`](struct.Url.html) will implement
[`serde::Serialize`](https://docs.rs/serde/1/serde/trait.Serialize.html) and
[`serde::Deserialize`](https://docs.rs/serde/1/serde/trait.Deserialize.html).
See [serde documentation](https://serde.rs) for more information.

```toml
url = { version = "2", features = ["serde"] }
```

*/

#![doc(html_root_url = "https://docs.rs/url/2.3.1")]
#![cfg_attr(
    feature = "debugger_visualizer",
    feature(debugger_visualizer),
    debugger_visualizer(natvis_file = "../../debug_metadata/url.natvis")
)]

pub use form_urlencoded;

#[cfg(feature = "serde")]
extern crate serde;

use crate::host::HostInternal;
use crate::parser::{to_u32, Context, Parser, SchemeType, PATH_SEGMENT, USERINFO};
use percent_encoding::{percent_decode, percent_encode, utf8_percent_encode};
use std::borrow::Borrow;
use std::cmp;
use std::fmt::{self, Write};
use std::hash;
use std::io;
use std::mem;
use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
use std::ops::{Range, RangeFrom, RangeTo};
use std::path::{Path, PathBuf};
use std::str;

use std::convert::TryFrom;

pub use crate::host::Host;
pub use crate::origin::{OpaqueOrigin, Origin};
pub use crate::parser::{ParseError, SyntaxViolation};
pub use crate::path_segments::PathSegmentsMut;
pub use crate::slicing::Position;
pub use form_urlencoded::EncodingOverride;

mod host;
mod origin;
mod parser;
mod path_segments;
mod slicing;

#[doc(hidden)]
pub mod quirks;

/// A parsed URL record.
#[derive(Clone)]
pub struct Url {
    /// Syntax in pseudo-BNF:
    ///
    ///   url = scheme ":" [ hierarchical | non-hierarchical ] [ "?" query ]? [ "#" fragment ]?
    ///   non-hierarchical = non-hierarchical-path
    ///   non-hierarchical-path = /* Does not start with "/" */
    ///   hierarchical = authority? hierarchical-path
    ///   authority = "//" userinfo? host [ ":" port ]?
    ///   userinfo = username [ ":" password ]? "@"
    ///   hierarchical-path = [ "/" path-segment ]+
    serialization: String,

    // Components
    scheme_end: u32,  // Before ':'
    username_end: u32, // Before ':' (if a password is given) or '@' (if not)
    host_start: u32,
    host_end: u32,
    host: HostInternal,
    port: Option<u16>,
    path_start: u32,            // Before initial '/', if any
    query_start: Option<u32>,   // Before '?', unlike Position::QueryStart
    fragment_start: Option<u32>, // Before '#', unlike Position::FragmentStart
}

/// Full configuration for the URL parser.
#[derive(Copy, Clone)]
pub struct ParseOptions<'a> {
    base_url: Option<&'a Url>,
    encoding_override: EncodingOverride<'a>,
    violation_fn: Option<&'a dyn Fn(SyntaxViolation)>,
}

impl<'a> ParseOptions<'a> {
    /// Change the base URL
    pub fn base_url(mut self, new: Option<&'a Url>) -> Self {
        self.base_url = new;
        self
    }

    /// Override the character encoding of query strings.
    /// This is a legacy concept only relevant for HTML.
    pub fn encoding_override(mut self, new: EncodingOverride<'a>) -> Self {
        self.encoding_override = new;
        self
    }

    /// Call the provided function or closure for a non-fatal `SyntaxViolation`
    /// when it occurs during parsing. Note that since the provided function is
    /// `Fn`, the caller might need to utilize _interior mutability_, such as with
    /// a `RefCell`, to collect the violations.
    ///
    /// ## Example
    /// ```
    /// use std::cell::RefCell;
    /// use url::{Url, SyntaxViolation};
    /// # use url::ParseError;
    /// # fn run() -> Result<(), url::ParseError> {
    /// let violations = RefCell::new(Vec::new());
    /// let url = Url::options()
    ///     .syntax_violation_callback(Some(&|v| violations.borrow_mut().push(v)))
    ///     .parse("https:////example.com")?;
    /// assert_eq!(url.as_str(), "https://example.com/");
    /// assert_eq!(violations.into_inner(),
    ///            vec!(SyntaxViolation::ExpectedDoubleSlash));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn syntax_violation_callback(mut self, new: Option<&'a dyn Fn(SyntaxViolation)>) -> Self {
        self.violation_fn = new;
        self
    }

    /// Parse an URL string with the configuration so far.
    pub fn parse(self, input: &str) -> Result<Url, crate::ParseError> {
        Parser {
            serialization: String::with_capacity(input.len()),
            base_url: self.base_url,
            query_encoding_override: self.encoding_override,
            violation_fn: self.violation_fn,
            context: Context::UrlParser,
        }
        .parse_url(input)
    }
}

impl Url {
    /// Parse an absolute URL from a string.
    ///
    /// # Examples
    ///

shell

sed -n '1,260p' url/src/slicing.rs

output

Chunk ID: 7e80c5
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 1604
Output:
// Copyright 2016 The rust-url developers.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use crate::Url;
use std::ops::{Index, Range, RangeFrom, RangeFull, RangeTo};

impl Index<RangeFull> for Url {
    type Output = str;
    fn index(&self, _: RangeFull) -> &str {
        &self.serialization
    }
}

impl Index<RangeFrom<Position>> for Url {
    type Output = str;
    fn index(&self, range: RangeFrom<Position>) -> &str {
        &self.serialization[self.index(range.start)..]
    }
}

impl Index<RangeTo<Position>> for Url {
    type Output = str;
    fn index(&self, range: RangeTo<Position>) -> &str {
        &self.serialization[..self.index(range.end)]
    }
}

impl Index<Range<Position>> for Url {
    type Output = str;
    fn index(&self, range: Range<Position>) -> &str {
        &self.serialization[self.index(range.start)..self.index(range.end)]
    }
}

/// Indicates a position within a URL based on its components.
///
/// A range of positions can be used for slicing `Url`:
///
/// ```rust
/// # use url::{Url, Position};
/// # fn something(some_url: Url) {
/// let serialization: &str = &some_url[..];
/// let serialization_without_fragment: &str = &some_url[..Position::AfterQuery];
/// let authority: &str = &some_url[Position::BeforeUsername..Position::AfterPort];
/// let data_url_payload: &str = &some_url[Position::BeforePath..Position::AfterQuery];
/// let scheme_relative: &str = &some_url[Position::BeforeUsername..];
/// # }
/// ```
///
/// In a pseudo-grammar (where `[`…`]?` makes a sub-sequence optional),
/// URL components and delimiters that separate them are:
///
/// ```notrust
/// url =
///     scheme ":"
///     [ "//" [ username [ ":" password ]? "@" ]? host [ ":" port ]? ]?
///     path [ "?" query ]? [ "#" fragment ]?
/// ```
///
/// When a given component is not present,
/// its "before" and "after" position are the same
/// (so that `&some_url[BeforeFoo..AfterFoo]` is the empty string)
/// and component ordering is preserved
/// (so that a missing query "is between" a path and a fragment).
///
/// The end of a component and the start of the next are either the same or separate
/// by a delimiter.
/// (Not that the initial `/` of a path is considered part of the path here, not a delimiter.)
/// For example, `&url[..BeforeFragment]` would include a `#` delimiter (if present in `url`),
/// so `&url[..AfterQuery]` might be desired instead.
///
/// `BeforeScheme` and `AfterFragment` are always the start and end of the entire URL,
/// so `&url[BeforeScheme..X]` is the same as `&url[..X]`
/// and `&url[X..AfterFragment]` is the same as `&url[X..]`.
#[derive(Copy, Clone, Debug)]
pub enum Position {
    BeforeScheme,
    AfterScheme,
    BeforeUsername,
    AfterUsername,
    BeforePassword,
    AfterPassword,
    BeforeHost,
    AfterHost,
    BeforePort,
    AfterPort,
    BeforePath,
    AfterPath,
    BeforeQuery,
    AfterQuery,
    BeforeFragment,
    AfterFragment,
}

impl Url {
    #[inline]
    fn index(&self, position: Position) -> usize {
        match position {
            Position::BeforeScheme => 0,

            Position::AfterScheme => self.scheme_end as usize,

            Position::BeforeUsername => {
                if self.has_authority() {
                    self.scheme_end as usize + "://".len()
                } else {
                    debug_assert!(self.byte_at(self.scheme_end) == b':');
                    debug_assert!(self.scheme_end + ":".len() as u32 == self.username_end);
                    self.scheme_end as usize + ":".len()
                }
            }

            Position::AfterUsername => self.username_end as usize,

            Position::BeforePassword => {
                if self.has_authority() && self.byte_at(self.username_end) == b':' {
                    self.username_end as usize + ":".len()
                } else {
                    debug_assert!(self.username_end == self.host_start);
                    self.username_end as usize
                }
            }

            Position::AfterPassword => {
                if self.has_authority() && self.byte_at(self.username_end) == b':' {
                    debug_assert!(self.byte_at(self.host_start - "@".len() as u32) == b'@');
                    self.host_start as usize - "@".len()
                } else {
                    debug_assert!(self.username_end == self.host_start);
                    self.host_start as usize
                }
            }

            Position::BeforeHost => self.host_start as usize,

            Position::AfterHost => self.host_end as usize,

            Position::BeforePort => {
                if self.port.is_some() {
                    debug_assert!(self.byte_at(self.host_end) == b':');
                    self.host_end as usize + ":".len()
                } else {
                    self.host_end as usize
                }
            }

            Position::AfterPort => self.path_start as usize,

            Position::BeforePath => self.path_start as usize,

            Position::AfterPath => match (self.query_start, self.fragment_start) {
                (Some(q), _) => q as usize,
                (None, Some(f)) => f as usize,
                (None, None) => self.serialization.len(),
            },

            Position::BeforeQuery => match (self.query_start, self.fragment_start) {
                (Some(q), _) => {
                    debug_assert!(self.byte_at(q) == b'?');
                    q as usize + "?".len()
                }
                (None, Some(f)) => f as usize,
                (None, None) => self.serialization.len(),
            },

            Position::AfterQuery => match self.fragment_start {
                None => self.serialization.len(),
                Some(f) => f as usize,
            },

            Position::BeforeFragment => match self.fragment_start {
                Some(f) => {
                    debug_assert!(self.byte_at(f) == b'#');
                    f as usize + "#".len()
                }
                None => self.serialization.len(),
            },

            Position::AfterFragment => self.serialization.len(),
        }
    }
}

shell

sed -n '1,360p' url/src/parser.rs

output

Chunk ID: 502971
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 2559
Output:
// Copyright 2013-2016 The rust-url developers.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use std::error::Error;
use std::fmt::{self, Formatter, Write};
use std::str;

use crate::host::{Host, HostInternal};
use crate::Url;
use form_urlencoded::EncodingOverride;
use percent_encoding::{percent_encode, utf8_percent_encode, AsciiSet, CONTROLS};

/// https://url.spec.whatwg.org/#fragment-percent-encode-set
const FRAGMENT: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');

/// https://url.spec.whatwg.org/#path-percent-encode-set
const PATH: &AsciiSet = &FRAGMENT.add(b'#').add(b'?').add(b'{').add(b'}');

/// https://url.spec.whatwg.org/#userinfo-percent-encode-set
pub(crate) const USERINFO: &AsciiSet = &PATH
    .add(b'/')
    .add(b':')
    .add(b';')
    .add(b'=')
    .add(b'@')
    .add(b'[')
    .add(b'\\')
    .add(b']')
    .add(b'^')
    .add(b'|');

pub(crate) const PATH_SEGMENT: &AsciiSet = &PATH.add(b'/').add(b'%');

// The backslash (\) character is treated as a path separator in special URLs
// so it needs to be additionally escaped in that case.
pub(crate) const SPECIAL_PATH_SEGMENT: &AsciiSet = &PATH_SEGMENT.add(b'\\');

// https://url.spec.whatwg.org/#query-state
const QUERY: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'#').add(b'<').add(b'>');
const SPECIAL_QUERY: &AsciiSet = &QUERY.add(b'\'');

pub type ParseResult<T> = Result<T, ParseError>;

macro_rules! simple_enum_error {
    ($($name: ident => $description: expr,)+) => {
        /// Errors that can occur during parsing.
        ///
        /// This may be extended in the future so exhaustive matching is
        /// discouraged with an unused variant.
        #[derive(PartialEq, Eq, Clone, Copy, Debug)]
        #[non_exhaustive]
        pub enum ParseError {
            $(
                $name,
            )+
        }

        impl fmt::Display for ParseError {
            fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
                match *self {
                    $(
                        ParseError::$name => fmt.write_str($description),
                    )+
                }
            }
        }
    }
}

impl Error for ParseError {}

simple_enum_error! {
    EmptyHost => "empty host",
    IdnaError => "invalid international domain name",
    InvalidPort => "invalid port number",
    InvalidIpv4Address => "invalid IPv4 address",
    InvalidIpv6Address => "invalid IPv6 address",
    InvalidDomainCharacter => "invalid domain character",
    RelativeUrlWithoutBase => "relative URL without a base",
    RelativeUrlWithCannotBeABaseBase => "relative URL with a cannot-be-a-base base",
    SetHostOnCannotBeABaseUrl => "a cannot-be-a-base URL doesn’t have a host to set",
    Overflow => "URLs more than 4 GB are not supported",
}

impl From<::idna::Errors> for ParseError {
    fn from(_: ::idna::Errors) -> ParseError {
        ParseError::IdnaError
    }
}

macro_rules! syntax_violation_enum {
    ($($name: ident => $description: expr,)+) => {
        /// Non-fatal syntax violations that can occur during parsing.
        ///
        /// This may be extended in the future so exhaustive matching is
        /// discouraged with an unused variant.
        #[derive(PartialEq, Eq, Clone, Copy, Debug)]
        #[non_exhaustive]
        pub enum SyntaxViolation {
            $(
                $name,
            )+
        }

        impl SyntaxViolation {
            pub fn description(&self) -> &'static str {
                match *self {
                    $(
                        SyntaxViolation::$name => $description,
                    )+
                }
            }
        }
    }
}

syntax_violation_enum! {
    Backslash => "backslash",
    C0SpaceIgnored =>
        "leading or trailing control or space character are ignored in URLs",
    EmbeddedCredentials =>
        "embedding authentication information (username or password) \
         in an URL is not recommended",
    ExpectedDoubleSlash => "expected //",
    ExpectedFileDoubleSlash => "expected // after file:",
    FileWithHostAndWindowsDrive => "file: with host and Windows drive letter",
    NonUrlCodePoint => "non-URL code point",
    NullInFragment => "NULL characters are ignored in URL fragment identifiers",
    PercentDecode => "expected 2 hex digits after %",
    TabOrNewlineIgnored => "tabs or newlines are ignored in URLs",
    UnencodedAtSign => "unencoded @ sign in username or password",
}

impl fmt::Display for SyntaxViolation {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(self.description(), f)
    }
}

#[derive(Copy, Clone, PartialEq, Eq)]
pub enum SchemeType {
    File,
    SpecialNotFile,
    NotSpecial,
}

impl SchemeType {
    pub fn is_special(&self) -> bool {
        !matches!(*self, SchemeType::NotSpecial)
    }

    pub fn is_file(&self) -> bool {
        matches!(*self, SchemeType::File)
    }

    pub fn from(s: &str) -> Self {
        match s {
            "http" | "https" | "ws" | "wss" | "ftp" => SchemeType::SpecialNotFile,
            "file" => SchemeType::File,
            _ => SchemeType::NotSpecial,
        }
    }
}

pub fn default_port(scheme: &str) -> Option<u16> {
    match scheme {
        "http" | "ws" => Some(80),
        "https" | "wss" => Some(443),
        "ftp" => Some(21),
        _ => None,
    }
}

#[derive(Clone)]
pub struct Input<'i> {
    chars: str::Chars<'i>,
}

impl<'i> Input<'i> {
    pub fn new(input: &'i str) -> Self {
        Input::with_log(input, None)
    }

    pub fn no_trim(input: &'i str) -> Self {
        Input {
            chars: input.chars(),
        }
    }

    pub fn trim_tab_and_newlines(
        original_input: &'i str,
        vfn: Option<&dyn Fn(SyntaxViolation)>,
    ) -> Self {
        let input = original_input.trim_matches(ascii_tab_or_new_line);
        if let Some(vfn) = vfn {
            if input.len() < original_input.len() {
                vfn(SyntaxViolation::C0SpaceIgnored)
            }
            if input.chars().any(|c| matches!(c, '\t' | '\n' | '\r')) {
                vfn(SyntaxViolation::TabOrNewlineIgnored)
            }
        }
        Input {
            chars: input.chars(),
        }
    }

    pub fn with_log(original_input: &'i str, vfn: Option<&dyn Fn(SyntaxViolation)>) -> Self {
        let input = original_input.trim_matches(c0_control_or_space);
        if let Some(vfn) = vfn {
            if input.len() < original_input.len() {
                vfn(SyntaxViolation::C0SpaceIgnored)
            }
            if input.chars().any(|c| matches!(c, '\t' | '\n' | '\r')) {
                vfn(SyntaxViolation::TabOrNewlineIgnored)
            }
        }
        Input {
            chars: input.chars(),
        }
    }

    #[inline]
    pub fn is_empty(&self) -> bool {
        self.clone().next().is_none()
    }

    #[inline]
    fn starts_with<P: Pattern>(&self, p: P) -> bool {
        p.split_prefix(&mut self.clone())
    }

    #[inline]
    pub fn split_prefix<P: Pattern>(&self, p: P) -> Option<Self> {
        let mut remaining = self.clone();
        if p.split_prefix(&mut remaining) {
            Some(remaining)
        } else {
            None
        }
    }

    #[inline]
    fn split_first(&self) -> (Option<char>, Self) {
        let mut remaining = self.clone();
        (remaining.next(), remaining)
    }

    #[inline]
    fn count_matching<F: Fn(char) -> bool>(&self, f: F) -> (u32, Self) {
        let mut count = 0;
        let mut remaining = self.clone();
        loop {
            let mut input = remaining.clone();
            if matches!(input.next(), Some(c) if f(c)) {
                remaining = input;
                count += 1;
            } else {
                return (count, remaining);
            }
        }
    }

    #[inline]
    fn next_utf8(&mut self) -> Option<(char, &'i str)> {
        loop {
            let utf8 = self.chars.as_str();
            match self.chars.next() {
                Some(c) => {
                    if !matches!(c, '\t' | '\n' | '\r') {
                        return Some((c, &utf8[..c.len_utf8()]));
                    }
                }
                None => return None,
            }
        }
    }
}

pub trait Pattern {
    fn split_prefix(self, input: &mut Input) -> bool;
}

impl Pattern for char {
    fn split_prefix(self, input: &mut Input) -> bool {
        input.next() == Some(self)
    }
}

impl<'a> Pattern for &'a str {
    fn split_prefix(self, input: &mut Input) -> bool {
        for c in self.chars() {
            if input.next() != Some(c) {
                return false;
            }
        }
        true
    }
}

impl<F: FnMut(char) -> bool> Pattern for F {
    fn split_prefix(self, input: &mut Input) -> bool {
        input.next().map_or(false, self)
    }
}

impl<'i> Iterator for Input<'i> {
    type Item = char;
    fn next(&mut self) -> Option<char> {
        self.chars
            .by_ref()
            .find(|&c| !matches!(c, '\t' | '\n' | '\r'))
    }
}

pub struct Parser<'a> {
    pub serialization: String,
    pub base_url: Option<&'a Url>,
    pub query_encoding_override: EncodingOverride<'a>,
    pub violation_fn: Option<&'a dyn Fn(SyntaxViolation)>,
    pub context: Context,
}

#[derive(PartialEq, Eq, Copy, Clone)]
pub enum Context {
    UrlParser,
    Setter,
    PathSegmentSetter,
}

impl<'a> Parser<'a> {
    fn log_violation(&self, v: SyntaxViolation) {
        if let Some(f) = self.violation_fn {
            f(v)
        }
    }

    fn log_violation_if(&self, v: SyntaxViolation, test: impl FnOnce() -> bool) {
        if let Some(f) = self.violation_fn {
            if test() {
                f(v)
            }
        }
    }

    pub fn for_setter(serialization: String) -> Parser<'a> {
        Parser {
            serialization,
            base_url: None,
            query_encoding_override: None,
            violation_fn: None,
            context: Context::Setter,
        }
    }

shell

sed -n '360,760p' url/src/parser.rs

output

Chunk ID: 354d56
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 4367
Output:

    /// https://url.spec.whatwg.org/#concept-basic-url-parser
    pub fn parse_url(mut self, input: &str) -> ParseResult<Url> {
        let input = Input::with_log(input, self.violation_fn);
        if let Ok(remaining) = self.parse_scheme(input.clone()) {
            return self.parse_with_scheme(remaining);
        }

        // No-scheme state
        if let Some(base_url) = self.base_url {
            if input.starts_with('#') {
                self.fragment_only(base_url, input)
            } else if base_url.cannot_be_a_base() {
                Err(ParseError::RelativeUrlWithCannotBeABaseBase)
            } else {
                let scheme_type = SchemeType::from(base_url.scheme());
                if scheme_type.is_file() {
                    self.parse_file(input, scheme_type, Some(base_url))
                } else {
                    self.parse_relative(input, scheme_type, base_url)
                }
            }
        } else {
            Err(ParseError::RelativeUrlWithoutBase)
        }
    }

    pub fn parse_scheme<'i>(&mut self, mut input: Input<'i>) -> Result<Input<'i>, ()> {
        if input.is_empty() || !input.starts_with(ascii_alpha) {
            return Err(());
        }
        debug_assert!(self.serialization.is_empty());
        while let Some(c) = input.next() {
            match c {
                'a'..='z' | 'A'..='Z' | '0'..='9' | '+' | '-' | '.' => {
                    self.serialization.push(c.to_ascii_lowercase())
                }
                ':' => return Ok(input),
                _ => {
                    self.serialization.clear();
                    return Err(());
                }
            }
        }
        // EOF before ':'
        if self.context == Context::Setter {
            Ok(input)
        } else {
            self.serialization.clear();
            Err(())
        }
    }

    fn parse_with_scheme(mut self, input: Input<'_>) -> ParseResult<Url> {
        use crate::SyntaxViolation::{ExpectedDoubleSlash, ExpectedFileDoubleSlash};
        let scheme_end = to_u32(self.serialization.len())?;
        let scheme_type = SchemeType::from(&self.serialization);
        self.serialization.push(':');
        match scheme_type {
            SchemeType::File => {
                self.log_violation_if(ExpectedFileDoubleSlash, || !input.starts_with("//"));
                let base_file_url = self.base_url.and_then(|base| {
                    if base.scheme() == "file" {
                        Some(base)
                    } else {
                        None
                    }
                });
                self.serialization.clear();
                self.parse_file(input, scheme_type, base_file_url)
            }
            SchemeType::SpecialNotFile => {
                // special relative or authority state
                let (slashes_count, remaining) = input.count_matching(|c| matches!(c, '/' | '\\'));
                if let Some(base_url) = self.base_url {
                    if slashes_count < 2
                        && base_url.scheme() == &self.serialization[..scheme_end as usize]
                    {
                        // "Cannot-be-a-base" URLs only happen with "not special" schemes.
                        debug_assert!(!base_url.cannot_be_a_base());
                        self.serialization.clear();
                        return self.parse_relative(input, scheme_type, base_url);
                    }
                }
                // special authority slashes state
                self.log_violation_if(ExpectedDoubleSlash, || {
                    input
                        .clone()
                        .take_while(|&c| matches!(c, '/' | '\\'))
                        .collect::<String>()
                        != "//"
                });
                self.after_double_slash(remaining, scheme_type, scheme_end)
            }
            SchemeType::NotSpecial => self.parse_non_special(input, scheme_type, scheme_end),
        }
    }

    /// Scheme other than file, http, https, ws, ws, ftp.
    fn parse_non_special(
        mut self,
        input: Input<'_>,
        scheme_type: SchemeType,
        scheme_end: u32,
    ) -> ParseResult<Url> {
        // path or authority state (
        if let Some(input) = input.split_prefix("//") {
            return self.after_double_slash(input, scheme_type, scheme_end);
        }
        // Anarchist URL (no authority)
        let path_start = to_u32(self.serialization.len())?;
        let username_end = path_start;
        let host_start = path_start;
        let host_end = path_start;
        let host = HostInternal::None;
        let port = None;
        let remaining = if let Some(input) = input.split_prefix('/') {
            let path_start = self.serialization.len();
            self.serialization.push('/');
            self.parse_path(scheme_type, &mut false, path_start, input)
        } else {
            self.parse_cannot_be_a_base_path(input)
        };
        self.with_query_and_fragment(
            scheme_type,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            remaining,
        )
    }

    fn parse_file(
        mut self,
        input: Input<'_>,
        scheme_type: SchemeType,
        base_file_url: Option<&Url>,
    ) -> ParseResult<Url> {
        use crate::SyntaxViolation::Backslash;
        // file state
        debug_assert!(self.serialization.is_empty());
        let (first_char, input_after_first_char) = input.split_first();
        if matches!(first_char, Some('/') | Some('\\')) {
            self.log_violation_if(SyntaxViolation::Backslash, || first_char == Some('\\'));
            // file slash state
            let (next_char, input_after_next_char) = input_after_first_char.split_first();
            if matches!(next_char, Some('/') | Some('\\')) {
                self.log_violation_if(Backslash, || next_char == Some('\\'));
                // file host state
                self.serialization.push_str("file://");
                let scheme_end = "file".len() as u32;
                let host_start = "file://".len() as u32;
                let (path_start, mut host, remaining) =
                    self.parse_file_host(input_after_next_char)?;
                let mut host_end = to_u32(self.serialization.len())?;
                let mut has_host = !matches!(host, HostInternal::None);
                let remaining = if path_start {
                    self.parse_path_start(SchemeType::File, &mut has_host, remaining)
                } else {
                    let path_start = self.serialization.len();
                    self.serialization.push('/');
                    self.parse_path(SchemeType::File, &mut has_host, path_start, remaining)
                };

                // For file URLs that have a host and whose path starts
                // with the windows drive letter we just remove the host.
                if !has_host {
                    self.serialization
                        .drain(host_start as usize..host_end as usize);
                    host_end = host_start;
                    host = HostInternal::None;
                }
                let (query_start, fragment_start) =
                    self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;
                return Ok(Url {
                    serialization: self.serialization,
                    scheme_end,
                    username_end: host_start,
                    host_start,
                    host_end,
                    host,
                    port: None,
                    path_start: host_end,
                    query_start,
                    fragment_start,
                });
            } else {
                self.serialization.push_str("file://");
                let scheme_end = "file".len() as u32;
                let host_start = "file://".len();
                let mut host_end = host_start;
                let mut host = HostInternal::None;
                if !starts_with_windows_drive_letter_segment(&input_after_first_char) {
                    if let Some(base_url) = base_file_url {
                        let first_segment = base_url.path_segments().unwrap().next().unwrap();
                        if is_normalized_windows_drive_letter(first_segment) {
                            self.serialization.push('/');
                            self.serialization.push_str(first_segment);
                        } else if let Some(host_str) = base_url.host_str() {
                            self.serialization.push_str(host_str);
                            host_end = self.serialization.len();
                            host = base_url.host;
                        }
                    }
                }
                // If c is the EOF code point, U+002F (/), U+005C (\), U+003F (?), or U+0023 (#), then decrease pointer by one
                let parse_path_input = if let Some(c) = first_char {
                    if c == '/' || c == '\\' || c == '?' || c == '#' {
                        input
                    } else {
                        input_after_first_char
                    }
                } else {
                    input_after_first_char
                };

                let remaining =
                    self.parse_path(SchemeType::File, &mut false, host_end, parse_path_input);

                let host_start = host_start as u32;

                let (query_start, fragment_start) =
                    self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;

                let host_end = host_end as u32;
                return Ok(Url {
                    serialization: self.serialization,
                    scheme_end,
                    username_end: host_start,
                    host_start,
                    host_end,
                    host,
                    port: None,
                    path_start: host_end,
                    query_start,
                    fragment_start,
                });
            }
        }
        if let Some(base_url) = base_file_url {
            match first_char {
                None => {
                    // Copy everything except the fragment
                    let before_fragment = match base_url.fragment_start {
                        Some(i) => &base_url.serialization[..i as usize],
                        None => &*base_url.serialization,
                    };
                    self.serialization.push_str(before_fragment);
                    Ok(Url {
                        serialization: self.serialization,
                        fragment_start: None,
                        ..*base_url
                    })
                }
                Some('?') => {
                    // Copy everything up to the query string
                    let before_query = match (base_url.query_start, base_url.fragment_start) {
                        (None, None) => &*base_url.serialization,
                        (Some(i), _) | (None, Some(i)) => base_url.slice(..i),
                    };
                    self.serialization.push_str(before_query);
                    let (query_start, fragment_start) =
                        self.parse_query_and_fragment(scheme_type, base_url.scheme_end, input)?;
                    Ok(Url {
                        serialization: self.serialization,
                        query_start,
                        fragment_start,
                        ..*base_url
                    })
                }
                Some('#') => self.fragment_only(base_url, input),
                _ => {
                    if !starts_with_windows_drive_letter_segment(&input) {
                        let before_query = match (base_url.query_start, base_url.fragment_start) {
                            (None, None) => &*base_url.serialization,
                            (Some(i), _) | (None, Some(i)) => base_url.slice(..i),
                        };
                        self.serialization.push_str(before_query);
                        self.shorten_path(SchemeType::File, base_url.path_start as usize);
                        let remaining = self.parse_path(
                            SchemeType::File,
                            &mut true,
                            base_url.path_start as usize,
                            input,
                        );
                        self.with_query_and_fragment(
                            SchemeType::File,
                            base_url.scheme_end,
                            base_url.username_end,
                            base_url.host_start,
                            base_url.host_end,
                            base_url.host,
                            base_url.port,
                            base_url.path_start,
                            remaining,
                        )
                    } else {
                        self.serialization.push_str("file:///");
                        let scheme_end = "file".len() as u32;
                        let path_start = "file://".len();
                        let remaining =
                            self.parse_path(SchemeType::File, &mut false, path_start, input);
                        let (query_start, fragment_start) =
                            self.parse_query_and_fragment(SchemeType::File, scheme_end, remaining)?;
                        let path_start = path_start as u32;
                        Ok(Url {
                            serialization: self.serialization,
                            scheme_end,
                            username_end: path_start,
                            host_start: path_start,
                            host_end: path_start,
                            host: HostInternal::None,
                            port: None,
                            path_start,
                            query_start,
                            fragment_start,
                        })
                    }
                }
            }
        } else {
            self.serialization.push_str("file:///");
            let scheme_end = "file".len() as u32;
            let path_start = "file://".len();
            let remaining = self.parse_path(SchemeType::File, &mut false, path_start, input);
            let (query_start, fragment_start) =
                self.parse_query_and_fragment(SchemeType::File, scheme_end, remaining)?;
            let path_start = path_start as u32;
            Ok(Url {
                serialization: self.serialization,
                scheme_end,
                username_end: path_start,
                host_start: path_start,
                host_end: path_start,
                host: HostInternal::None,
                port: None,
                path_start,
                query_start,
                fragment_start,
            })
        }
    }

    fn parse_relative(
        mut self,
        input: Input<'_>,
        scheme_type: SchemeType,
        base_url: &Url,
    ) -> ParseResult<Url> {
        // relative state
        debug_assert!(self.serialization.is_empty());
        let (first_char, input_after_first_char) = input.split_first();
        match first_char {
            None => {
                // Copy everything except the fragment
                let before_fragment = match base_url.fragment_start {
                    Some(i) => &base_url.serialization[..i as usize],
                    None => &*base_url.serialization,
                };
                self.serialization.push_str(before_fragment);
                Ok(Url {
                    serialization: self.serialization,
                    fragment_start: None,
                    ..*base_url
                })
            }
            Some('?') => {
                // Copy everything up to the query string
                let before_query = match (base_url.query_start, base_url.fragment_start) {
                    (None, None) => &*base_url.serialization,
                    (Some(i), _) | (None, Some(i)) => base_url.slice(..i),
                };
                self.serialization.push_str(before_query);
                let (query_start, fragment_start) =
                    self.parse_query_and_fragment(scheme_type, base_url.scheme_end, input)?;
                Ok(Url {
                    serialization: self.serialization,
                    query_start,
                    fragment_start,
                    ..*base_url
                })
            }
            Some('#') => self.fragment_only(base_url, input),
            Some('/') | Some('\\') => {
                let (slashes_count, remaining) = input.count_matching(|c| matches!(c, '/' | '\\'));
                if slashes_count >= 2 {
                    self.log_violation_if(SyntaxViolation::ExpectedDoubleSlash, || {
                        input
                            .clone()
                            .take_while(|&c| matches!(c, '/' | '\\'))
                            .collect::<String>()
                            != "//"
                    });
                    let scheme_end = base_url.scheme_end;
                    debug_assert!(base_url.byte_at(scheme_end) == b':');
                    self.serialization
                        .push_str(base_url.slice(..scheme_end + 1));

shell

sed -n '760,1160p' url/src/parser.rs

output

Chunk ID: 6c0f1e
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 3864
Output:
                        .push_str(base_url.slice(..scheme_end + 1));
                    if let Some(after_prefix) = input.split_prefix("//") {
                        return self.after_double_slash(after_prefix, scheme_type, scheme_end);
                    }
                    return self.after_double_slash(remaining, scheme_type, scheme_end);
                }
                let path_start = base_url.path_start;
                self.serialization.push_str(base_url.slice(..path_start));
                self.serialization.push('/');
                let remaining = self.parse_path(
                    scheme_type,
                    &mut true,
                    path_start as usize,
                    input_after_first_char,
                );
                self.with_query_and_fragment(
                    scheme_type,
                    base_url.scheme_end,
                    base_url.username_end,
                    base_url.host_start,
                    base_url.host_end,
                    base_url.host,
                    base_url.port,
                    base_url.path_start,
                    remaining,
                )
            }
            _ => {
                let before_query = match (base_url.query_start, base_url.fragment_start) {
                    (None, None) => &*base_url.serialization,
                    (Some(i), _) | (None, Some(i)) => base_url.slice(..i),
                };
                self.serialization.push_str(before_query);
                // FIXME spec says just "remove last entry", not the "pop" algorithm
                self.pop_path(scheme_type, base_url.path_start as usize);
                // A special url always has a path.
                // A path always starts with '/'
                if self.serialization.len() == base_url.path_start as usize
                    && (SchemeType::from(base_url.scheme()).is_special() || !input.is_empty())
                {
                    self.serialization.push('/');
                }
                let remaining = match input.split_first() {
                    (Some('/'), remaining) => self.parse_path(
                        scheme_type,
                        &mut true,
                        base_url.path_start as usize,
                        remaining,
                    ),
                    _ => {
                        self.parse_path(scheme_type, &mut true, base_url.path_start as usize, input)
                    }
                };
                self.with_query_and_fragment(
                    scheme_type,
                    base_url.scheme_end,
                    base_url.username_end,
                    base_url.host_start,
                    base_url.host_end,
                    base_url.host,
                    base_url.port,
                    base_url.path_start,
                    remaining,
                )
            }
        }
    }

    fn after_double_slash(
        mut self,
        input: Input<'_>,
        scheme_type: SchemeType,
        scheme_end: u32,
    ) -> ParseResult<Url> {
        self.serialization.push('/');
        self.serialization.push('/');
        // authority state
        let before_authority = self.serialization.len();
        let (username_end, remaining) = self.parse_userinfo(input, scheme_type)?;
        let has_authority = before_authority != self.serialization.len();
        // host state
        let host_start = to_u32(self.serialization.len())?;
        let (host_end, host, port, remaining) =
            self.parse_host_and_port(remaining, scheme_end, scheme_type)?;
        if host == HostInternal::None && has_authority {
            return Err(ParseError::EmptyHost);
        }
        // path state
        let path_start = to_u32(self.serialization.len())?;
        let remaining = self.parse_path_start(scheme_type, &mut true, remaining);
        self.with_query_and_fragment(
            scheme_type,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            remaining,
        )
    }

    /// Return (username_end, remaining)
    fn parse_userinfo<'i>(
        &mut self,
        mut input: Input<'i>,
        scheme_type: SchemeType,
    ) -> ParseResult<(u32, Input<'i>)> {
        let mut last_at = None;
        let mut remaining = input.clone();
        let mut char_count = 0;
        while let Some(c) = remaining.next() {
            match c {
                '@' => {
                    if last_at.is_some() {
                        self.log_violation(SyntaxViolation::UnencodedAtSign)
                    } else {
                        self.log_violation(SyntaxViolation::EmbeddedCredentials)
                    }
                    last_at = Some((char_count, remaining.clone()))
                }
                '/' | '?' | '#' => break,
                '\\' if scheme_type.is_special() => break,
                _ => (),
            }
            char_count += 1;
        }
        let (mut userinfo_char_count, remaining) = match last_at {
            None => return Ok((to_u32(self.serialization.len())?, input)),
            Some((0, remaining)) => {
                // Otherwise, if one of the following is true
                // c is the EOF code point, U+002F (/), U+003F (?), or U+0023 (#)
                // url is special and c is U+005C (\)
                // If @ flag is set and buffer is the empty string, validation error, return failure.
                if let (Some(c), _) = remaining.split_first() {
                    if c == '/' || c == '?' || c == '#' || (scheme_type.is_special() && c == '\\') {
                        return Err(ParseError::EmptyHost);
                    }
                }
                return Ok((to_u32(self.serialization.len())?, remaining));
            }
            Some(x) => x,
        };

        let mut username_end = None;
        let mut has_password = false;
        let mut has_username = false;
        while userinfo_char_count > 0 {
            let (c, utf8_c) = input.next_utf8().unwrap();
            userinfo_char_count -= 1;
            if c == ':' && username_end.is_none() {
                // Start parsing password
                username_end = Some(to_u32(self.serialization.len())?);
                // We don't add a colon if the password is empty
                if userinfo_char_count > 0 {
                    self.serialization.push(':');
                    has_password = true;
                }
            } else {
                if !has_password {
                    has_username = true;
                }
                self.check_url_code_point(c, &input);
                self.serialization
                    .extend(utf8_percent_encode(utf8_c, USERINFO));
            }
        }
        let username_end = match username_end {
            Some(i) => i,
            None => to_u32(self.serialization.len())?,
        };
        if has_username || has_password {
            self.serialization.push('@');
        }
        Ok((username_end, remaining))
    }

    fn parse_host_and_port<'i>(
        &mut self,
        input: Input<'i>,
        scheme_end: u32,
        scheme_type: SchemeType,
    ) -> ParseResult<(u32, HostInternal, Option<u16>, Input<'i>)> {
        let (host, remaining) = Parser::parse_host(input, scheme_type)?;
        write!(&mut self.serialization, "{}", host).unwrap();
        let host_end = to_u32(self.serialization.len())?;
        if let Host::Domain(h) = &host {
            if h.is_empty() {
                // Port with an empty host
                if remaining.starts_with(":") {
                    return Err(ParseError::EmptyHost);
                }
                if scheme_type.is_special() {
                    return Err(ParseError::EmptyHost);
                }
            }
        };

        let (port, remaining) = if let Some(remaining) = remaining.split_prefix(':') {
            let scheme = || default_port(&self.serialization[..scheme_end as usize]);
            Parser::parse_port(remaining, scheme, self.context)?
        } else {
            (None, remaining)
        };
        if let Some(port) = port {
            write!(&mut self.serialization, ":{}", port).unwrap()
        }
        Ok((host_end, host.into(), port, remaining))
    }

    pub fn parse_host(
        mut input: Input<'_>,
        scheme_type: SchemeType,
    ) -> ParseResult<(Host<String>, Input<'_>)> {
        if scheme_type.is_file() {
            return Parser::get_file_host(input);
        }
        // Undo the Input abstraction here to avoid allocating in the common case
        // where the host part of the input does not contain any tab or newline
        let input_str = input.chars.as_str();
        let mut inside_square_brackets = false;
        let mut has_ignored_chars = false;
        let mut non_ignored_chars = 0;
        let mut bytes = 0;
        for c in input_str.chars() {
            match c {
                ':' if !inside_square_brackets => break,
                '\\' if scheme_type.is_special() => break,
                '/' | '?' | '#' => break,
                '\t' | '\n' | '\r' => {
                    has_ignored_chars = true;
                }
                '[' => {
                    inside_square_brackets = true;
                    non_ignored_chars += 1
                }
                ']' => {
                    inside_square_brackets = false;
                    non_ignored_chars += 1
                }
                _ => non_ignored_chars += 1,
            }
            bytes += c.len_utf8();
        }
        let replaced: String;
        let host_str;
        {
            let host_input = input.by_ref().take(non_ignored_chars);
            if has_ignored_chars {
                replaced = host_input.collect();
                host_str = &*replaced
            } else {
                for _ in host_input {}
                host_str = &input_str[..bytes]
            }
        }
        if scheme_type == SchemeType::SpecialNotFile && host_str.is_empty() {
            return Err(ParseError::EmptyHost);
        }
        if !scheme_type.is_special() {
            let host = Host::parse_opaque(host_str)?;
            return Ok((host, input));
        }
        let host = Host::parse(host_str)?;
        Ok((host, input))
    }

    fn get_file_host(input: Input<'_>) -> ParseResult<(Host<String>, Input<'_>)> {
        let (_, host_str, remaining) = Parser::file_host(input)?;
        let host = match Host::parse(&host_str)? {
            Host::Domain(ref d) if d == "localhost" => Host::Domain("".to_string()),
            host => host,
        };
        Ok((host, remaining))
    }

    fn parse_file_host<'i>(
        &mut self,
        input: Input<'i>,
    ) -> ParseResult<(bool, HostInternal, Input<'i>)> {
        let has_host;
        let (_, host_str, remaining) = Parser::file_host(input)?;
        let host = if host_str.is_empty() {
            has_host = false;
            HostInternal::None
        } else {
            match Host::parse(&host_str)? {
                Host::Domain(ref d) if d == "localhost" => {
                    has_host = false;
                    HostInternal::None
                }
                host => {
                    write!(&mut self.serialization, "{}", host).unwrap();
                    has_host = true;
                    host.into()
                }
            }
        };
        Ok((has_host, host, remaining))
    }

    pub fn file_host(input: Input) -> ParseResult<(bool, String, Input)> {
        // Undo the Input abstraction here to avoid allocating in the common case
        // where the host part of the input does not contain any tab or newline
        let input_str = input.chars.as_str();
        let mut has_ignored_chars = false;
        let mut non_ignored_chars = 0;
        let mut bytes = 0;
        for c in input_str.chars() {
            match c {
                '/' | '\\' | '?' | '#' => break,
                '\t' | '\n' | '\r' => has_ignored_chars = true,
                _ => non_ignored_chars += 1,
            }
            bytes += c.len_utf8();
        }
        let replaced: String;
        let host_str;
        let mut remaining = input.clone();
        {
            let host_input = remaining.by_ref().take(non_ignored_chars);
            if has_ignored_chars {
                replaced = host_input.collect();
                host_str = &*replaced
            } else {
                for _ in host_input {}
                host_str = &input_str[..bytes]
            }
        }
        if is_windows_drive_letter(host_str) {
            return Ok((false, "".to_string(), input));
        }
        Ok((true, host_str.to_string(), remaining))
    }

    pub fn parse_port<P>(
        mut input: Input<'_>,
        default_port: P,
        context: Context,
    ) -> ParseResult<(Option<u16>, Input<'_>)>
    where
        P: Fn() -> Option<u16>,
    {
        let mut port: u32 = 0;
        let mut has_any_digit = false;
        while let (Some(c), remaining) = input.split_first() {
            if let Some(digit) = c.to_digit(10) {
                port = port * 10 + digit;
                if port > ::std::u16::MAX as u32 {
                    return Err(ParseError::InvalidPort);
                }
                has_any_digit = true;
            } else if context == Context::UrlParser && !matches!(c, '/' | '\\' | '?' | '#') {
                return Err(ParseError::InvalidPort);
            } else {
                break;
            }
            input = remaining;
        }
        let mut opt_port = Some(port as u16);
        if !has_any_digit || opt_port == default_port() {
            opt_port = None;
        }
        Ok((opt_port, input))
    }

    pub fn parse_path_start<'i>(
        &mut self,
        scheme_type: SchemeType,
        has_host: &mut bool,
        input: Input<'i>,
    ) -> Input<'i> {
        let path_start = self.serialization.len();
        let (maybe_c, remaining) = input.split_first();
        // If url is special, then:
        if scheme_type.is_special() {
            if maybe_c == Some('\\') {
                // If c is U+005C (\), validation error.
                self.log_violation(SyntaxViolation::Backslash);
            }
            // A special URL always has a non-empty path.
            if !self.serialization.ends_with('/') {
                self.serialization.push('/');
                // We have already made sure the forward slash is present.
                if maybe_c == Some('/') || maybe_c == Some('\\') {
                    return self.parse_path(scheme_type, has_host, path_start, remaining);
                }
            }
            return self.parse_path(scheme_type, has_host, path_start, input);
        } else if maybe_c == Some('?') || maybe_c == Some('#') {
            // Otherwise, if state override is not given and c is U+003F (?),
            // set url’s query to the empty string and state to query state.
            // Otherwise, if state override is not given and c is U+0023 (#),
            // set url’s fragment to the empty string and state to fragment state.
            // The query and path states will be handled by the caller.
            return input;
        }

        if maybe_c.is_some() && maybe_c != Some('/') {
            self.serialization.push('/');

shell

sed -n '260,760p' url/src/lib.rs

output

Chunk ID: 59c051
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 4227
Output:
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("https://example.net")?;
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// # Errors
    ///
    /// If the function can not parse an absolute URL from the given string,
    /// a [`ParseError`] variant will be returned.
    ///
    /// [`ParseError`]: enum.ParseError.html
    #[inline]
    pub fn parse(input: &str) -> Result<Url, crate::ParseError> {
        Url::options().parse(input)
    }

    /// Parse an absolute URL from a string and add params to its query string.
    ///
    /// Existing params are not removed.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse_with_params("https://example.net?dont=clobberme",
    ///                                  &[("lang", "rust"), ("browser", "servo")])?;
    /// assert_eq!("https://example.net/?dont=clobberme&lang=rust&browser=servo", url.as_str());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// # Errors
    ///
    /// If the function can not parse an absolute URL from the given string,
    /// a [`ParseError`] variant will be returned.
    ///
    /// [`ParseError`]: enum.ParseError.html
    #[inline]
    pub fn parse_with_params<I, K, V>(input: &str, iter: I) -> Result<Url, crate::ParseError>
    where
        I: IntoIterator,
        I::Item: Borrow<(K, V)>,
        K: AsRef<str>,
        V: AsRef<str>,
    {
        let mut url = Url::options().parse(input);

        if let Ok(ref mut url) = url {
            url.query_pairs_mut().extend_pairs(iter);
        }

        url
    }

    /// https://url.spec.whatwg.org/#potentially-strip-trailing-spaces-from-an-opaque-path
    fn strip_trailing_spaces_from_opaque_path(&mut self) {
        if !self.cannot_be_a_base() {
            return;
        }

        if self.fragment_start.is_some() {
            return;
        }

        if self.query_start.is_some() {
            return;
        }

        let trailing_space_count = self
            .serialization
            .chars()
            .rev()
            .take_while(|c| *c == ' ')
            .count();

        let start = self.serialization.len() - trailing_space_count;

        self.serialization.truncate(start);
    }

    /// Parse a string as an URL, with this URL as the base URL.
    ///
    /// The inverse of this is [`make_relative`].
    ///
    /// Note: a trailing slash is significant.
    /// Without it, the last path component is considered to be a “file” name
    /// to be removed to get at the “directory” that is used as the base:
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let base = Url::parse("https://example.net/a/b.html")?;
    /// let url = base.join("c.png")?;
    /// assert_eq!(url.as_str(), "https://example.net/a/c.png");  // Not /a/b.html/c.png
    ///
    /// let base = Url::parse("https://example.net/a/b/")?;
    /// let url = base.join("c.png")?;
    /// assert_eq!(url.as_str(), "https://example.net/a/b/c.png");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// # Errors
    ///
    /// If the function can not parse an URL from the given string
    /// with this URL as the base URL, a [`ParseError`] variant will be returned.
    ///
    /// [`ParseError`]: enum.ParseError.html
    /// [`make_relative`]: #method.make_relative
    #[inline]
    pub fn join(&self, input: &str) -> Result<Url, crate::ParseError> {
        Url::options().base_url(Some(self)).parse(input)
    }

    /// Creates a relative URL if possible, with this URL as the base URL.
    ///
    /// This is the inverse of [`join`].
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let base = Url::parse("https://example.net/a/b.html")?;
    /// let url = Url::parse("https://example.net/a/c.png")?;
    /// let relative = base.make_relative(&url);
    /// assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("c.png"));
    ///
    /// let base = Url::parse("https://example.net/a/b/")?;
    /// let url = Url::parse("https://example.net/a/b/c.png")?;
    /// let relative = base.make_relative(&url);
    /// assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("c.png"));
    ///
    /// let base = Url::parse("https://example.net/a/b/")?;
    /// let url = Url::parse("https://example.net/a/d/c.png")?;
    /// let relative = base.make_relative(&url);
    /// assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("../d/c.png"));
    ///
    /// let base = Url::parse("https://example.net/a/b.html?c=d")?;
    /// let url = Url::parse("https://example.net/a/b.html?e=f")?;
    /// let relative = base.make_relative(&url);
    /// assert_eq!(relative.as_ref().map(|s| s.as_str()), Some("?e=f"));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// # Errors
    ///
    /// If this URL can't be a base for the given URL, `None` is returned.
    /// This is for example the case if the scheme, host or port are not the same.
    ///
    /// [`join`]: #method.join
    pub fn make_relative(&self, url: &Url) -> Option<String> {
        if self.cannot_be_a_base() {
            return None;
        }

        // Scheme, host and port need to be the same
        if self.scheme() != url.scheme() || self.host() != url.host() || self.port() != url.port() {
            return None;
        }

        // We ignore username/password at this point

        // The path has to be transformed
        let mut relative = String::new();

        // Extract the filename of both URIs, these need to be handled separately
        fn extract_path_filename(s: &str) -> (&str, &str) {
            let last_slash_idx = s.rfind('/').unwrap_or(0);
            let (path, filename) = s.split_at(last_slash_idx);
            if filename.is_empty() {
                (path, "")
            } else {
                (path, &filename[1..])
            }
        }

        let (base_path, base_filename) = extract_path_filename(self.path());
        let (url_path, url_filename) = extract_path_filename(url.path());

        let mut base_path = base_path.split('/').peekable();
        let mut url_path = url_path.split('/').peekable();

        // Skip over the common prefix
        while base_path.peek().is_some() && base_path.peek() == url_path.peek() {
            base_path.next();
            url_path.next();
        }

        // Add `..` segments for the remainder of the base path
        for base_path_segment in base_path {
            // Skip empty last segments
            if base_path_segment.is_empty() {
                break;
            }

            if !relative.is_empty() {
                relative.push('/');
            }

            relative.push_str("..");
        }

        // Append the remainder of the other URI
        for url_path_segment in url_path {
            if !relative.is_empty() {
                relative.push('/');
            }

            relative.push_str(url_path_segment);
        }

        // Add the filename if they are not the same
        if !relative.is_empty() || base_filename != url_filename {
            // If the URIs filename is empty this means that it was a directory
            // so we'll have to append a '/'.
            //
            // Otherwise append it directly as the new filename.
            if url_filename.is_empty() {
                relative.push('/');
            } else {
                if !relative.is_empty() {
                    relative.push('/');
                }
                relative.push_str(url_filename);
            }
        }

        // Query and fragment are only taken from the other URI
        if let Some(query) = url.query() {
            relative.push('?');
            relative.push_str(query);
        }

        if let Some(fragment) = url.fragment() {
            relative.push('#');
            relative.push_str(fragment);
        }

        Some(relative)
    }

    /// Return a default `ParseOptions` that can fully configure the URL parser.
    ///
    /// # Examples
    ///
    /// Get default `ParseOptions`, then change base url
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    /// # fn run() -> Result<(), ParseError> {
    /// let options = Url::options();
    /// let api = Url::parse("https://api.example.com")?;
    /// let base_url = options.base_url(Some(&api));
    /// let version_url = base_url.parse("version.json")?;
    /// assert_eq!(version_url.as_str(), "https://api.example.com/version.json");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn options<'a>() -> ParseOptions<'a> {
        ParseOptions {
            base_url: None,
            encoding_override: None,
            violation_fn: None,
        }
    }

    /// Return the serialization of this URL.
    ///
    /// This is fast since that serialization is already stored in the `Url` struct.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url_str = "https://example.net/";
    /// let url = Url::parse(url_str)?;
    /// assert_eq!(url.as_str(), url_str);
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    pub fn as_str(&self) -> &str {
        &self.serialization
    }

    /// Return the serialization of this URL.
    ///
    /// This consumes the `Url` and takes ownership of the `String` stored in it.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url_str = "https://example.net/";
    /// let url = Url::parse(url_str)?;
    /// assert_eq!(String::from(url), url_str);
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    #[deprecated(since = "2.3.0", note = "use Into<String>")]
    pub fn into_string(self) -> String {
        self.into()
    }

    /// For internal testing, not part of the public API.
    ///
    /// Methods of the `Url` struct assume a number of invariants.
    /// This checks each of these invariants and panic if one is not met.
    /// This is for testing rust-url itself.
    #[doc(hidden)]
    pub fn check_invariants(&self) -> Result<(), String> {
        macro_rules! assert {
            ($x: expr) => {
                if !$x {
                    return Err(format!(
                        "!( {} ) for URL {:?}",
                        stringify!($x),
                        self.serialization
                    ));
                }
            };
        }

        macro_rules! assert_eq {
            ($a: expr, $b: expr) => {
                {
                    let a = $a;
                    let b = $b;
                    if a != b {
                        return Err(format!("{:?} != {:?} ({} != {}) for URL {:?}",
                                           a, b, stringify!($a), stringify!($b),
                                           self.serialization))
                    }
                }
            }
        }

        assert!(self.scheme_end >= 1);
        assert!(self.byte_at(0).is_ascii_alphabetic());
        assert!(self
            .slice(1..self.scheme_end)
            .chars()
            .all(|c| matches!(c, 'a'..='z' | 'A'..='Z' | '0'..='9' | '+' | '-' | '.')));
        assert_eq!(self.byte_at(self.scheme_end), b':');

        if self.slice(self.scheme_end + 1..).starts_with("//") {
            // URL with authority
            if self.username_end != self.serialization.len() as u32 {
                match self.byte_at(self.username_end) {
                    b':' => {
                        assert!(self.host_start >= self.username_end + 2);
                        assert_eq!(self.byte_at(self.host_start - 1), b'@');
                    }
                    b'@' => assert!(self.host_start == self.username_end + 1),
                    _ => assert_eq!(self.username_end, self.scheme_end + 3),
                }
            }
            assert!(self.host_start >= self.username_end);
            assert!(self.host_end >= self.host_start);
            let host_str = self.slice(self.host_start..self.host_end);
            match self.host {
                HostInternal::None => assert_eq!(host_str, ""),
                HostInternal::Ipv4(address) => assert_eq!(host_str, address.to_string()),
                HostInternal::Ipv6(address) => {
                    let h: Host<String> = Host::Ipv6(address);
                    assert_eq!(host_str, h.to_string())
                }
                HostInternal::Domain => {
                    if SchemeType::from(self.scheme()).is_special() {
                        assert!(!host_str.is_empty())
                    }
                }
            }
            if self.path_start == self.host_end {
                assert_eq!(self.port, None);
            } else {
                assert_eq!(self.byte_at(self.host_end), b':');
                let port_str = self.slice(self.host_end + 1..self.path_start);
                assert_eq!(
                    self.port,
                    Some(port_str.parse::<u16>().expect("Couldn't parse port?"))
                );
            }
            assert!(
                self.path_start as usize == self.serialization.len()
                    || matches!(self.byte_at(self.path_start), b'/' | b'#' | b'?')
            );
        } else {
            // Anarchist URL (no authority)
            assert_eq!(self.username_end, self.scheme_end + 1);
            assert_eq!(self.host_start, self.scheme_end + 1);
            assert_eq!(self.host_end, self.scheme_end + 1);
            assert_eq!(self.host, HostInternal::None);
            assert_eq!(self.port, None);
            assert_eq!(self.path_start, self.scheme_end + 1);
        }
        if let Some(start) = self.query_start {
            assert!(start >= self.path_start);
            assert_eq!(self.byte_at(start), b'?');
        }
        if let Some(start) = self.fragment_start {
            assert!(start >= self.path_start);
            assert_eq!(self.byte_at(start), b'#');
        }
        if let (Some(query_start), Some(fragment_start)) = (self.query_start, self.fragment_start) {
            assert!(fragment_start > query_start);
        }

        let other = Url::parse(self.as_str()).expect("Failed to parse myself?");
        assert_eq!(&self.serialization, &other.serialization);
        assert_eq!(self.scheme_end, other.scheme_end);
        assert_eq!(self.username_end, other.username_end);
        assert_eq!(self.host_start, other.host_start);
        assert_eq!(self.host_end, other.host_end);
        assert!(
            self.host == other.host ||
                // XXX No host round-trips to empty host.
                // See https://[code-host]/whatwg/url/issues/79
                (self.host_str(), other.host_str()) == (None, Some(""))
        );
        assert_eq!(self.port, other.port);
        assert_eq!(self.path_start, other.path_start);
        assert_eq!(self.query_start, other.query_start);
        assert_eq!(self.fragment_start, other.fragment_start);
        Ok(())
    }

    /// Return the origin of this URL (<https://url.spec.whatwg.org/#origin>)
    ///
    /// Note: this returns an opaque origin for `file:` URLs, which causes
    /// `url.origin() != url.origin()`.
    ///
    /// # Examples
    ///
    /// URL with `ftp` scheme:
    ///
    /// ```rust
    /// use url::{Host, Origin, Url};
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("ftp://example.com/foo")?;
    /// assert_eq!(url.origin(),
    ///            Origin::Tuple("ftp".into(),
    ///                          Host::Domain("example.com".into()),
    ///                          21));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// URL with `blob` scheme:
    ///
    /// ```rust
    /// use url::{Host, Origin, Url};
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("blob:https://example.com/foo")?;
    /// assert_eq!(url.origin(),
    ///            Origin::Tuple("https".into(),
    ///                          Host::Domain("example.com".into()),
    ///                          443));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// URL with `file` scheme:

shell

sed -n '760,1280p' url/src/lib.rs

output

Chunk ID: d46a5e
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 4346
Output:
    /// URL with `file` scheme:
    ///
    /// ```rust
    /// use url::{Host, Origin, Url};
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("file:///tmp/foo")?;
    /// assert!(!url.origin().is_tuple());
    ///
    /// let other_url = Url::parse("file:///tmp/foo")?;
    /// assert!(url.origin() != other_url.origin());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// URL with other scheme:
    ///
    /// ```rust
    /// use url::{Host, Origin, Url};
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("foo:bar")?;
    /// assert!(!url.origin().is_tuple());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    pub fn origin(&self) -> Origin {
        origin::url_origin(self)
    }

    /// Return the scheme of this URL, lower-cased, as an ASCII string without the ':' delimiter.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("file:///tmp/foo")?;
    /// assert_eq!(url.scheme(), "file");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    pub fn scheme(&self) -> &str {
        self.slice(..self.scheme_end)
    }

    /// Return whether the URL has an 'authority',
    /// which can contain a username, password, host, and port number.
    ///
    /// URLs that do *not* are either path-only like `unix:/run/foo.socket`
    /// or cannot-be-a-base like `data:text/plain,Stuff`.
    ///
    /// See also the `authority` method.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("ftp://rms@example.com")?;
    /// assert!(url.has_authority());
    ///
    /// let url = Url::parse("unix:/run/foo.socket")?;
    /// assert!(!url.has_authority());
    ///
    /// let url = Url::parse("data:text/plain,Stuff")?;
    /// assert!(!url.has_authority());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    pub fn has_authority(&self) -> bool {
        debug_assert!(self.byte_at(self.scheme_end) == b':');
        self.slice(self.scheme_end..).starts_with("://")
    }

    /// Return the authority of this URL as an ASCII string.
    ///
    /// Non-ASCII domains are punycode-encoded per IDNA if this is the host
    /// of a special URL, or percent encoded for non-special URLs.
    /// IPv6 addresses are given between `[` and `]` brackets.
    /// Ports are omitted if they match the well known port of a special URL.
    ///
    /// Username and password are percent-encoded.
    ///
    /// See also the `has_authority` method.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("unix:/run/foo.socket")?;
    /// assert_eq!(url.authority(), "");
    /// let url = Url::parse("file:///tmp/foo")?;
    /// assert_eq!(url.authority(), "");
    /// let url = Url::parse("https://user:password@example.com/tmp/foo")?;
    /// assert_eq!(url.authority(), "user:password@example.com");
    /// let url = Url::parse("irc://àlex.рф.example.com:6667/foo")?;
    /// assert_eq!(url.authority(), "%C3%A0lex.%D1%80%D1%84.example.com:6667");
    /// let url = Url::parse("http://àlex.рф.example.com:80/foo")?;
    /// assert_eq!(url.authority(), "xn--lex-8ka.xn--p1ai.example.com");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn authority(&self) -> &str {
        let scheme_separator_len = "://".len() as u32;
        if self.has_authority() && self.path_start > self.scheme_end + scheme_separator_len {
            self.slice(self.scheme_end + scheme_separator_len..self.path_start)
        } else {
            ""
        }
    }

    /// Return whether this URL is a cannot-be-a-base URL,
    /// meaning that parsing a relative URL string with this URL as the base will return an error.
    ///
    /// This is the case if the scheme and `:` delimiter are not followed by a `/` slash,
    /// as is typically the case of `data:` and `mailto:` URLs.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("ftp://rms@example.com")?;
    /// assert!(!url.cannot_be_a_base());
    ///
    /// let url = Url::parse("unix:/run/foo.socket")?;
    /// assert!(!url.cannot_be_a_base());
    ///
    /// let url = Url::parse("data:text/plain,Stuff")?;
    /// assert!(url.cannot_be_a_base());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    pub fn cannot_be_a_base(&self) -> bool {
        !self.slice(self.scheme_end + 1..).starts_with('/')
    }

    /// Return the username for this URL (typically the empty string)
    /// as a percent-encoded ASCII string.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("ftp://rms@example.com")?;
    /// assert_eq!(url.username(), "rms");
    ///
    /// let url = Url::parse("ftp://:secret123@example.com")?;
    /// assert_eq!(url.username(), "");
    ///
    /// let url = Url::parse("https://example.com")?;
    /// assert_eq!(url.username(), "");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn username(&self) -> &str {
        let scheme_separator_len = "://".len() as u32;
        if self.has_authority() && self.username_end > self.scheme_end + scheme_separator_len {
            self.slice(self.scheme_end + scheme_separator_len..self.username_end)
        } else {
            ""
        }
    }

    /// Return the password for this URL, if any, as a percent-encoded ASCII string.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("ftp://rms:secret123@example.com")?;
    /// assert_eq!(url.password(), Some("secret123"));
    ///
    /// let url = Url::parse("ftp://:secret123@example.com")?;
    /// assert_eq!(url.password(), Some("secret123"));
    ///
    /// let url = Url::parse("ftp://rms@example.com")?;
    /// assert_eq!(url.password(), None);
    ///
    /// let url = Url::parse("https://example.com")?;
    /// assert_eq!(url.password(), None);
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn password(&self) -> Option<&str> {
        // This ':' is not the one marking a port number since a host can not be empty.
        // (Except for file: URLs, which do not have port numbers.)
        if self.has_authority()
            && self.username_end != self.serialization.len() as u32
            && self.byte_at(self.username_end) == b':'
        {
            debug_assert!(self.byte_at(self.host_start - 1) == b'@');
            Some(self.slice(self.username_end + 1..self.host_start - 1))
        } else {
            None
        }
    }

    /// Equivalent to `url.host().is_some()`.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("ftp://rms@example.com")?;
    /// assert!(url.has_host());
    ///
    /// let url = Url::parse("unix:/run/foo.socket")?;
    /// assert!(!url.has_host());
    ///
    /// let url = Url::parse("data:text/plain,Stuff")?;
    /// assert!(!url.has_host());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn has_host(&self) -> bool {
        !matches!(self.host, HostInternal::None)
    }

    /// Return the string representation of the host (domain or IP address) for this URL, if any.
    ///
    /// Non-ASCII domains are punycode-encoded per IDNA if this is the host
    /// of a special URL, or percent encoded for non-special URLs.
    /// IPv6 addresses are given between `[` and `]` brackets.
    ///
    /// Cannot-be-a-base URLs (typical of `data:` and `mailto:`) and some `file:` URLs
    /// don’t have a host.
    ///
    /// See also the `host` method.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("https://127.0.0.1/index.html")?;
    /// assert_eq!(url.host_str(), Some("127.0.0.1"));
    ///
    /// let url = Url::parse("ftp://rms@example.com")?;
    /// assert_eq!(url.host_str(), Some("example.com"));
    ///
    /// let url = Url::parse("unix:/run/foo.socket")?;
    /// assert_eq!(url.host_str(), None);
    ///
    /// let url = Url::parse("data:text/plain,Stuff")?;
    /// assert_eq!(url.host_str(), None);
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn host_str(&self) -> Option<&str> {
        if self.has_host() {
            Some(self.slice(self.host_start..self.host_end))
        } else {
            None
        }
    }

    /// Return the parsed representation of the host for this URL.
    /// Non-ASCII domain labels are punycode-encoded per IDNA if this is the host
    /// of a special URL, or percent encoded for non-special URLs.
    ///
    /// Cannot-be-a-base URLs (typical of `data:` and `mailto:`) and some `file:` URLs
    /// don’t have a host.
    ///
    /// See also the `host_str` method.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("https://127.0.0.1/index.html")?;
    /// assert!(url.host().is_some());
    ///
    /// let url = Url::parse("ftp://rms@example.com")?;
    /// assert!(url.host().is_some());
    ///
    /// let url = Url::parse("unix:/run/foo.socket")?;
    /// assert!(url.host().is_none());
    ///
    /// let url = Url::parse("data:text/plain,Stuff")?;
    /// assert!(url.host().is_none());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn host(&self) -> Option<Host<&str>> {
        match self.host {
            HostInternal::None => None,
            HostInternal::Domain => Some(Host::Domain(self.slice(self.host_start..self.host_end))),
            HostInternal::Ipv4(address) => Some(Host::Ipv4(address)),
            HostInternal::Ipv6(address) => Some(Host::Ipv6(address)),
        }
    }

    /// If this URL has a host and it is a domain name (not an IP address), return it.
    /// Non-ASCII domains are punycode-encoded per IDNA if this is the host
    /// of a special URL, or percent encoded for non-special URLs.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("https://127.0.0.1/")?;
    /// assert_eq!(url.domain(), None);
    ///
    /// let url = Url::parse("mailto:rms@example.net")?;
    /// assert_eq!(url.domain(), None);
    ///
    /// let url = Url::parse("https://example.com/")?;
    /// assert_eq!(url.domain(), Some("example.com"));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn domain(&self) -> Option<&str> {
        match self.host {
            HostInternal::Domain => Some(self.slice(self.host_start..self.host_end)),
            _ => None,
        }
    }

    /// Return the port number for this URL, if any.
    ///
    /// Note that default port numbers are never reflected by the serialization,
    /// use the `port_or_known_default()` method if you want a default port number returned.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("https://example.com")?;
    /// assert_eq!(url.port(), None);
    ///
    /// let url = Url::parse("https://example.com:443/")?;
    /// assert_eq!(url.port(), None);
    ///
    /// let url = Url::parse("ssh://example.com:22")?;
    /// assert_eq!(url.port(), Some(22));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    pub fn port(&self) -> Option<u16> {
        self.port
    }

    /// Return the port number for this URL, or the default port number if it is known.
    ///
    /// This method only knows the default port number
    /// of the `http`, `https`, `ws`, `wss` and `ftp` schemes.
    ///
    /// For URLs in these schemes, this method always returns `Some(_)`.
    /// For other schemes, it is the same as `Url::port()`.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("foo://example.com")?;
    /// assert_eq!(url.port_or_known_default(), None);
    ///
    /// let url = Url::parse("foo://example.com:1456")?;
    /// assert_eq!(url.port_or_known_default(), Some(1456));
    ///
    /// let url = Url::parse("https://example.com")?;
    /// assert_eq!(url.port_or_known_default(), Some(443));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    pub fn port_or_known_default(&self) -> Option<u16> {
        self.port.or_else(|| parser::default_port(self.scheme()))
    }

    /// Resolve a URL’s host and port number to `SocketAddr`.
    ///
    /// If the URL has the default port number of a scheme that is unknown to this library,
    /// `default_port_number` provides an opportunity to provide the actual port number.
    /// In non-example code this should be implemented either simply as `|| None`,
    /// or by matching on the URL’s `.scheme()`.
    ///
    /// If the host is a domain, it is resolved using the standard library’s DNS support.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// let url = url::Url::parse("https://example.net/").unwrap();
    /// let addrs = url.socket_addrs(|| None).unwrap();
    /// std::net::TcpStream::connect(&*addrs)
    /// # ;
    /// ```
    ///
    /// ```
    /// /// With application-specific known default port numbers
    /// fn socket_addrs(url: url::Url) -> std::io::Result<Vec<std::net::SocketAddr>> {
    ///     url.socket_addrs(|| match url.scheme() {
    ///         "socks5" | "socks5h" => Some(1080),
    ///         _ => None,
    ///     })
    /// }
    /// ```
    pub fn socket_addrs(
        &self,
        default_port_number: impl Fn() -> Option<u16>,
    ) -> io::Result<Vec<SocketAddr>> {
        // Note: trying to avoid the Vec allocation by returning `impl AsRef<[SocketAddr]>`
        // causes borrowck issues because the return value borrows `default_port_number`:
        //
        // https://[code-host]/rust-lang/rfcs/blob/master/text/1951-expand-impl-trait.md#scoping-for-type-and-lifetime-parameters
        //
        // > This RFC proposes that *all* type parameters are considered in scope
        // > for `impl Trait` in return position

        fn io_result<T>(opt: Option<T>, message: &str) -> io::Result<T> {
            opt.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, message))
        }

        let host = io_result(self.host(), "No host name in the URL")?;
        let port = io_result(
            self.port_or_known_default().or_else(default_port_number),
            "No port number in the URL",
        )?;
        Ok(match host {
            Host::Domain(domain) => (domain, port).to_socket_addrs()?.collect(),
            Host::Ipv4(ip) => vec![(ip, port).into()],
            Host::Ipv6(ip) => vec![(ip, port).into()],
        })
    }

    /// Return the path for this URL, as a percent-encoded ASCII string.
    /// For cannot-be-a-base URLs, this is an arbitrary string that doesn’t start with '/'.
    /// For other URLs, this starts with a '/' slash
    /// and continues with slash-separated path segments.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::{Url, ParseError};
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("https://example.com/api/versions?page=2")?;
    /// assert_eq!(url.path(), "/api/versions");
    ///
    /// let url = Url::parse("https://example.com")?;
    /// assert_eq!(url.path(), "/");
    ///
    /// let url = Url::parse("https://example.com/countries/việt nam")?;
    /// assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn path(&self) -> &str {
        match (self.query_start, self.fragment_start) {
            (None, None) => self.slice(self.path_start..),
            (Some(next_component_start), _) | (None, Some(next_component_start)) => {
                self.slice(self.path_start..next_component_start)
            }
        }
    }

    /// Unless this URL is cannot-be-a-base,
    /// return an iterator of '/' slash-separated path segments,
    /// each as a percent-encoded ASCII string.
    ///
    /// Return `None` for cannot-be-a-base URLs.
    ///
    /// When `Some` is returned, the iterator always contains at least one string
    /// (which may be empty).
    ///

shell

sed -n '1160,1510p' url/src/parser.rs

output

Chunk ID: cd9ace
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 3428
Output:
            self.serialization.push('/');
        }
        // Otherwise, if c is not the EOF code point:
        self.parse_path(scheme_type, has_host, path_start, input)
    }

    pub fn parse_path<'i>(
        &mut self,
        scheme_type: SchemeType,
        has_host: &mut bool,
        path_start: usize,
        mut input: Input<'i>,
    ) -> Input<'i> {
        // Relative path state
        loop {
            let segment_start = self.serialization.len();
            let mut ends_with_slash = false;
            loop {
                let input_before_c = input.clone();
                let (c, utf8_c) = if let Some(x) = input.next_utf8() {
                    x
                } else {
                    break;
                };
                match c {
                    '/' if self.context != Context::PathSegmentSetter => {
                        self.serialization.push(c);
                        ends_with_slash = true;
                        break;
                    }
                    '\\' if self.context != Context::PathSegmentSetter
                        && scheme_type.is_special() =>
                    {
                        self.log_violation(SyntaxViolation::Backslash);
                        self.serialization.push('/');
                        ends_with_slash = true;
                        break;
                    }
                    '?' | '#' if self.context == Context::UrlParser => {
                        input = input_before_c;
                        break;
                    }
                    _ => {
                        self.check_url_code_point(c, &input);
                        if self.context == Context::PathSegmentSetter {
                            if scheme_type.is_special() {
                                self.serialization
                                    .extend(utf8_percent_encode(utf8_c, SPECIAL_PATH_SEGMENT));
                            } else {
                                self.serialization
                                    .extend(utf8_percent_encode(utf8_c, PATH_SEGMENT));
                            }
                        } else {
                            self.serialization.extend(utf8_percent_encode(utf8_c, PATH));
                        }
                    }
                }
            }
            let segment_before_slash = if ends_with_slash {
                &self.serialization[segment_start..self.serialization.len() - 1]
            } else {
                &self.serialization[segment_start..self.serialization.len()]
            };
            match segment_before_slash {
                // If buffer is a double-dot path segment, shorten url’s path,
                ".." | "%2e%2e" | "%2e%2E" | "%2E%2e" | "%2E%2E" | "%2e." | "%2E." | ".%2e"
                | ".%2E" => {
                    debug_assert!(self.serialization.as_bytes()[segment_start - 1] == b'/');
                    self.serialization.truncate(segment_start);
                    if self.serialization.ends_with('/')
                        && Parser::last_slash_can_be_removed(&self.serialization, path_start)
                    {
                        self.serialization.pop();
                    }
                    self.shorten_path(scheme_type, path_start);

                    // and then if neither c is U+002F (/), nor url is special and c is U+005C (\), append the empty string to url’s path.
                    if ends_with_slash && !self.serialization.ends_with('/') {
                        self.serialization.push('/');
                    }
                }
                // Otherwise, if buffer is a single-dot path segment and if neither c is U+002F (/),
                // nor url is special and c is U+005C (\), append the empty string to url’s path.
                "." | "%2e" | "%2E" => {
                    self.serialization.truncate(segment_start);
                    if !self.serialization.ends_with('/') {
                        self.serialization.push('/');
                    }
                }
                _ => {
                    // If url’s scheme is "file", url’s path is empty, and buffer is a Windows drive letter, then
                    if scheme_type.is_file() && is_windows_drive_letter(segment_before_slash) {
                        // Replace the second code point in buffer with U+003A (:).
                        if let Some(c) = segment_before_slash.chars().next() {
                            self.serialization.truncate(segment_start);
                            self.serialization.push(c);
                            self.serialization.push(':');
                            if ends_with_slash {
                                self.serialization.push('/');
                            }
                        }
                        // If url’s host is neither the empty string nor null,
                        // validation error, set url’s host to the empty string.
                        if *has_host {
                            self.log_violation(SyntaxViolation::FileWithHostAndWindowsDrive);
                            *has_host = false; // FIXME account for this in callers
                        }
                    }
                }
            }
            if !ends_with_slash {
                break;
            }
        }
        if scheme_type.is_file() {
            // while url’s path’s size is greater than 1
            // and url’s path[0] is the empty string,
            // validation error, remove the first item from url’s path.
            //FIXME: log violation
            let path = self.serialization.split_off(path_start);
            self.serialization.push('/');
            self.serialization.push_str(path.trim_start_matches('/'));
        }

        input
    }

    fn last_slash_can_be_removed(serialization: &str, path_start: usize) -> bool {
        let url_before_segment = &serialization[..serialization.len() - 1];
        if let Some(segment_before_start) = url_before_segment.rfind('/') {
            // Do not remove the root slash
            segment_before_start >= path_start
                // Or a windows drive letter slash
                && !path_starts_with_windows_drive_letter(&serialization[segment_before_start..])
        } else {
            false
        }
    }

    /// https://url.spec.whatwg.org/#shorten-a-urls-path
    fn shorten_path(&mut self, scheme_type: SchemeType, path_start: usize) {
        // If path is empty, then return.
        if self.serialization.len() == path_start {
            return;
        }
        // If url’s scheme is "file", path’s size is 1, and path[0] is a normalized Windows drive letter, then return.
        if scheme_type.is_file()
            && is_normalized_windows_drive_letter(&self.serialization[path_start..])
        {
            return;
        }
        // Remove path’s last item.
        self.pop_path(scheme_type, path_start);
    }

    /// https://url.spec.whatwg.org/#pop-a-urls-path
    fn pop_path(&mut self, scheme_type: SchemeType, path_start: usize) {
        if self.serialization.len() > path_start {
            let slash_position = self.serialization[path_start..].rfind('/').unwrap();
            // + 1 since rfind returns the position before the slash.
            let segment_start = path_start + slash_position + 1;
            // Don’t pop a Windows drive letter
            if !(scheme_type.is_file()
                && is_normalized_windows_drive_letter(&self.serialization[segment_start..]))
            {
                self.serialization.truncate(segment_start);
            }
        }
    }

    pub fn parse_cannot_be_a_base_path<'i>(&mut self, mut input: Input<'i>) -> Input<'i> {
        loop {
            let input_before_c = input.clone();
            match input.next_utf8() {
                Some(('?', _)) | Some(('#', _)) if self.context == Context::UrlParser => {
                    return input_before_c
                }
                Some((c, utf8_c)) => {
                    self.check_url_code_point(c, &input);
                    self.serialization
                        .extend(utf8_percent_encode(utf8_c, CONTROLS));
                }
                None => return input,
            }
        }
    }

    #[allow(clippy::too_many_arguments)]
    fn with_query_and_fragment(
        mut self,
        scheme_type: SchemeType,
        scheme_end: u32,
        username_end: u32,
        host_start: u32,
        host_end: u32,
        host: HostInternal,
        port: Option<u16>,
        path_start: u32,
        remaining: Input<'_>,
    ) -> ParseResult<Url> {
        let (query_start, fragment_start) =
            self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;
        Ok(Url {
            serialization: self.serialization,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            query_start,
            fragment_start,
        })
    }

    /// Return (query_start, fragment_start)
    fn parse_query_and_fragment(
        &mut self,
        scheme_type: SchemeType,
        scheme_end: u32,
        mut input: Input<'_>,
    ) -> ParseResult<(Option<u32>, Option<u32>)> {
        let mut query_start = None;
        match input.next() {
            Some('#') => {}
            Some('?') => {
                query_start = Some(to_u32(self.serialization.len())?);
                self.serialization.push('?');
                let remaining = self.parse_query(scheme_type, scheme_end, input);
                if let Some(remaining) = remaining {
                    input = remaining
                } else {
                    return Ok((query_start, None));
                }
            }
            None => return Ok((None, None)),
            _ => panic!("Programming error. parse_query_and_fragment() called without ? or #"),
        }

        let fragment_start = to_u32(self.serialization.len())?;
        self.serialization.push('#');
        self.parse_fragment(input);
        Ok((query_start, Some(fragment_start)))
    }

    pub fn parse_query<'i>(
        &mut self,
        scheme_type: SchemeType,
        scheme_end: u32,
        mut input: Input<'i>,
    ) -> Option<Input<'i>> {
        let len = input.chars.as_str().len();
        let mut query = String::with_capacity(len); // FIXME: use a streaming decoder instead
        let mut remaining = None;
        while let Some(c) = input.next() {
            if c == '#' && self.context == Context::UrlParser {
                remaining = Some(input);
                break;
            } else {
                self.check_url_code_point(c, &input);
                query.push(c);
            }
        }

        let encoding = match &self.serialization[..scheme_end as usize] {
            "http" | "https" | "file" | "ftp" => self.query_encoding_override,
            _ => None,
        };
        let query_bytes = if let Some(o) = encoding {
            o(&query)
        } else {
            query.as_bytes().into()
        };
        let set = if scheme_type.is_special() {
            SPECIAL_QUERY
        } else {
            QUERY
        };
        self.serialization.extend(percent_encode(&query_bytes, set));
        remaining
    }

    fn fragment_only(mut self, base_url: &Url, mut input: Input<'_>) -> ParseResult<Url> {
        let before_fragment = match base_url.fragment_start {
            Some(i) => base_url.slice(..i),
            None => &*base_url.serialization,
        };
        debug_assert!(self.serialization.is_empty());
        self.serialization
            .reserve(before_fragment.len() + input.chars.as_str().len());
        self.serialization.push_str(before_fragment);
        self.serialization.push('#');
        let next = input.next();
        debug_assert!(next == Some('#'));
        self.parse_fragment(input);
        Ok(Url {
            serialization: self.serialization,
            fragment_start: Some(to_u32(before_fragment.len())?),
            ..*base_url
        })
    }

    pub fn parse_fragment(&mut self, mut input: Input<'_>) {
        while let Some((c, utf8_c)) = input.next_utf8() {
            if c == '\0' {
                self.log_violation(SyntaxViolation::NullInFragment)
            } else {
                self.check_url_code_point(c, &input);
            }
            self.serialization
                .extend(utf8_percent_encode(utf8_c, FRAGMENT));
        }
    }

    fn check_url_code_point(&self, c: char, input: &Input<'_>) {
        if let Some(vfn) = self.violation_fn {
            if c == '%' {
                let mut input = input.clone();
                if !matches!((input.next(), input.next()), (Some(a), Some(b))
                             if is_ascii_hex_digit(a) && is_ascii_hex_digit(b))
                {
                    vfn(SyntaxViolation::PercentDecode)
                }
            } else if !is_url_code_point(c) {
                vfn(SyntaxViolation::NonUrlCodePoint)
            }
        }
    }
}

#[inline]
fn is_ascii_hex_digit(c: char) -> bool {
    matches!(c, 'a'..='f' | 'A'..='F' | '0'..='9')
}

// Non URL code points:
// U+0000 to U+0020 (space)
// " # % < > [ \ ] ^ ` { | }
// U+007F to U+009F
// surrogates
// U+FDD0 to U+FDEF
// Last two of each plane: U+__FFFE to U+__FFFF for __ in 00 to 10 hex
#[inline]
fn is_url_code_point(c: char) -> bool {
    matches!(c,
        'a'..='z' |
        'A'..='Z' |
        '0'..='9' |
        '!' | '$' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' |
        '.' | '/' | ':' | ';' | '=' | '?' | '@' | '_' | '~' |

shell

sed -n '1280,1880p' url/src/lib.rs

output

Chunk ID: 3feca2
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 5257
Output:
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use std::error::Error;
    ///
    /// # fn run() -> Result<(), Box<dyn Error>> {
    /// let url = Url::parse("https://example.com/foo/bar")?;
    /// let mut path_segments = url.path_segments().ok_or_else(|| "cannot be base")?;
    /// assert_eq!(path_segments.next(), Some("foo"));
    /// assert_eq!(path_segments.next(), Some("bar"));
    /// assert_eq!(path_segments.next(), None);
    ///
    /// let url = Url::parse("https://example.com")?;
    /// let mut path_segments = url.path_segments().ok_or_else(|| "cannot be base")?;
    /// assert_eq!(path_segments.next(), Some(""));
    /// assert_eq!(path_segments.next(), None);
    ///
    /// let url = Url::parse("data:text/plain,HelloWorld")?;
    /// assert!(url.path_segments().is_none());
    ///
    /// let url = Url::parse("https://example.com/countries/việt nam")?;
    /// let mut path_segments = url.path_segments().ok_or_else(|| "cannot be base")?;
    /// assert_eq!(path_segments.next(), Some("countries"));
    /// assert_eq!(path_segments.next(), Some("vi%E1%BB%87t%20nam"));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn path_segments(&self) -> Option<str::Split<'_, char>> {
        let path = self.path();
        path.strip_prefix('/').map(|remainder| remainder.split('/'))
    }

    /// Return this URL’s query string, if any, as a percent-encoded ASCII string.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("https://example.com/products?page=2")?;
    /// let query = url.query();
    /// assert_eq!(query, Some("page=2"));
    ///
    /// let url = Url::parse("https://example.com/products")?;
    /// let query = url.query();
    /// assert!(query.is_none());
    ///
    /// let url = Url::parse("https://example.com/?country=español")?;
    /// let query = url.query();
    /// assert_eq!(query, Some("country=espa%C3%B1ol"));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn query(&self) -> Option<&str> {
        match (self.query_start, self.fragment_start) {
            (None, _) => None,
            (Some(query_start), None) => {
                debug_assert!(self.byte_at(query_start) == b'?');
                Some(self.slice(query_start + 1..))
            }
            (Some(query_start), Some(fragment_start)) => {
                debug_assert!(self.byte_at(query_start) == b'?');
                Some(self.slice(query_start + 1..fragment_start))
            }
        }
    }

    /// Parse the URL’s query string, if any, as `application/x-www-form-urlencoded`
    /// and return an iterator of (key, value) pairs.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::borrow::Cow;
    ///
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("https://example.com/products?page=2&sort=desc")?;
    /// let mut pairs = url.query_pairs();
    ///
    /// assert_eq!(pairs.count(), 2);
    ///
    /// assert_eq!(pairs.next(), Some((Cow::Borrowed("page"), Cow::Borrowed("2"))));
    /// assert_eq!(pairs.next(), Some((Cow::Borrowed("sort"), Cow::Borrowed("desc"))));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```

    #[inline]
    pub fn query_pairs(&self) -> form_urlencoded::Parse<'_> {
        form_urlencoded::parse(self.query().unwrap_or("").as_bytes())
    }

    /// Return this URL’s fragment identifier, if any.
    ///
    /// A fragment is the part of the URL after the `#` symbol.
    /// The fragment is optional and, if present, contains a fragment identifier
    /// that identifies a secondary resource, such as a section heading
    /// of a document.
    ///
    /// In HTML, the fragment identifier is usually the id attribute of a an element
    /// that is scrolled to on load. Browsers typically will not send the fragment portion
    /// of a URL to the server.
    ///
    /// **Note:** the parser did *not* percent-encode this component,
    /// but the input may have been percent-encoded already.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("https://example.com/data.csv#row=4")?;
    ///
    /// assert_eq!(url.fragment(), Some("row=4"));
    ///
    /// let url = Url::parse("https://example.com/data.csv#cell=4,1-6,2")?;
    ///
    /// assert_eq!(url.fragment(), Some("cell=4,1-6,2"));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn fragment(&self) -> Option<&str> {
        self.fragment_start.map(|start| {
            debug_assert!(self.byte_at(start) == b'#');
            self.slice(start + 1..)
        })
    }

    fn mutate<F: FnOnce(&mut Parser<'_>) -> R, R>(&mut self, f: F) -> R {
        let mut parser = Parser::for_setter(mem::take(&mut self.serialization));
        let result = f(&mut parser);
        self.serialization = parser.serialization;
        result
    }

    /// Change this URL’s fragment identifier.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("https://example.com/data.csv")?;
    /// assert_eq!(url.as_str(), "https://example.com/data.csv");

    /// url.set_fragment(Some("cell=4,1-6,2"));
    /// assert_eq!(url.as_str(), "https://example.com/data.csv#cell=4,1-6,2");
    /// assert_eq!(url.fragment(), Some("cell=4,1-6,2"));
    ///
    /// url.set_fragment(None);
    /// assert_eq!(url.as_str(), "https://example.com/data.csv");
    /// assert!(url.fragment().is_none());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn set_fragment(&mut self, fragment: Option<&str>) {
        // Remove any previous fragment
        if let Some(start) = self.fragment_start {
            debug_assert!(self.byte_at(start) == b'#');
            self.serialization.truncate(start as usize);
        }
        // Write the new one
        if let Some(input) = fragment {
            self.fragment_start = Some(to_u32(self.serialization.len()).unwrap());
            self.serialization.push('#');
            self.mutate(|parser| parser.parse_fragment(parser::Input::no_trim(input)))
        } else {
            self.fragment_start = None;
            self.strip_trailing_spaces_from_opaque_path();
        }
    }

    fn take_fragment(&mut self) -> Option<String> {
        self.fragment_start.take().map(|start| {
            debug_assert!(self.byte_at(start) == b'#');
            let fragment = self.slice(start + 1..).to_owned();
            self.serialization.truncate(start as usize);
            fragment
        })
    }

    fn restore_already_parsed_fragment(&mut self, fragment: Option<String>) {
        if let Some(ref fragment) = fragment {
            assert!(self.fragment_start.is_none());
            self.fragment_start = Some(to_u32(self.serialization.len()).unwrap());
            self.serialization.push('#');
            self.serialization.push_str(fragment);
        }
    }

    /// Change this URL’s query string.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("https://example.com/products")?;
    /// assert_eq!(url.as_str(), "https://example.com/products");
    ///
    /// url.set_query(Some("page=2"));
    /// assert_eq!(url.as_str(), "https://example.com/products?page=2");
    /// assert_eq!(url.query(), Some("page=2"));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn set_query(&mut self, query: Option<&str>) {
        let fragment = self.take_fragment();

        // Remove any previous query
        if let Some(start) = self.query_start.take() {
            debug_assert!(self.byte_at(start) == b'?');
            self.serialization.truncate(start as usize);
        }
        // Write the new query, if any
        if let Some(input) = query {
            self.query_start = Some(to_u32(self.serialization.len()).unwrap());
            self.serialization.push('?');
            let scheme_type = SchemeType::from(self.scheme());
            let scheme_end = self.scheme_end;
            self.mutate(|parser| {
                let vfn = parser.violation_fn;
                parser.parse_query(
                    scheme_type,
                    scheme_end,
                    parser::Input::trim_tab_and_newlines(input, vfn),
                )
            });
        } else {
            self.query_start = None;
            self.strip_trailing_spaces_from_opaque_path();
        }

        self.restore_already_parsed_fragment(fragment);
    }

    /// Manipulate this URL’s query string, viewed as a sequence of name/value pairs
    /// in `application/x-www-form-urlencoded` syntax.
    ///
    /// The return value has a method-chaining API:
    ///
    /// ```rust
    /// # use url::{Url, ParseError};
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("https://example.net?lang=fr#nav")?;
    /// assert_eq!(url.query(), Some("lang=fr"));
    ///
    /// url.query_pairs_mut().append_pair("foo", "bar");
    /// assert_eq!(url.query(), Some("lang=fr&foo=bar"));
    /// assert_eq!(url.as_str(), "https://example.net/?lang=fr&foo=bar#nav");
    ///
    /// url.query_pairs_mut()
    ///     .clear()
    ///     .append_pair("foo", "bar & baz")
    ///     .append_pair("saisons", "\u{00C9}t\u{00E9}+hiver");
    /// assert_eq!(url.query(), Some("foo=bar+%26+baz&saisons=%C3%89t%C3%A9%2Bhiver"));
    /// assert_eq!(url.as_str(),
    ///            "https://example.net/?foo=bar+%26+baz&saisons=%C3%89t%C3%A9%2Bhiver#nav");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Note: `url.query_pairs_mut().clear();` is equivalent to `url.set_query(Some(""))`,
    /// not `url.set_query(None)`.
    ///
    /// The state of `Url` is unspecified if this return value is leaked without being dropped.
    pub fn query_pairs_mut(&mut self) -> form_urlencoded::Serializer<'_, UrlQuery<'_>> {
        let fragment = self.take_fragment();

        let query_start;
        if let Some(start) = self.query_start {
            debug_assert!(self.byte_at(start) == b'?');
            query_start = start as usize;
        } else {
            query_start = self.serialization.len();
            self.query_start = Some(to_u32(query_start).unwrap());
            self.serialization.push('?');
        }

        let query = UrlQuery {
            url: Some(self),
            fragment,
        };
        form_urlencoded::Serializer::for_suffix(query, query_start + "?".len())
    }

    fn take_after_path(&mut self) -> String {
        match (self.query_start, self.fragment_start) {
            (Some(i), _) | (None, Some(i)) => {
                let after_path = self.slice(i..).to_owned();
                self.serialization.truncate(i as usize);
                after_path
            }
            (None, None) => String::new(),
        }
    }

    /// Change this URL’s path.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("https://example.com")?;
    /// url.set_path("api/comments");
    /// assert_eq!(url.as_str(), "https://example.com/api/comments");
    /// assert_eq!(url.path(), "/api/comments");
    ///
    /// let mut url = Url::parse("https://example.com/api")?;
    /// url.set_path("data/report.csv");
    /// assert_eq!(url.as_str(), "https://example.com/data/report.csv");
    /// assert_eq!(url.path(), "/data/report.csv");
    ///
    /// // `set_path` percent-encodes the given string if it's not already percent-encoded.
    /// let mut url = Url::parse("https://example.com")?;
    /// url.set_path("api/some comments");
    /// assert_eq!(url.as_str(), "https://example.com/api/some%20comments");
    /// assert_eq!(url.path(), "/api/some%20comments");
    ///
    /// // `set_path` will not double percent-encode the string if it's already percent-encoded.
    /// let mut url = Url::parse("https://example.com")?;
    /// url.set_path("api/some%20comments");
    /// assert_eq!(url.as_str(), "https://example.com/api/some%20comments");
    /// assert_eq!(url.path(), "/api/some%20comments");
    ///
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn set_path(&mut self, mut path: &str) {
        let after_path = self.take_after_path();
        let old_after_path_pos = to_u32(self.serialization.len()).unwrap();
        let cannot_be_a_base = self.cannot_be_a_base();
        let scheme_type = SchemeType::from(self.scheme());
        self.serialization.truncate(self.path_start as usize);
        self.mutate(|parser| {
            if cannot_be_a_base {
                if path.starts_with('/') {
                    parser.serialization.push_str("%2F");
                    path = &path[1..];
                }
                parser.parse_cannot_be_a_base_path(parser::Input::new(path));
            } else {
                let mut has_host = true; // FIXME
                parser.parse_path_start(scheme_type, &mut has_host, parser::Input::new(path));
            }
        });
        self.restore_after_path(old_after_path_pos, &after_path);
    }

    /// Return an object with methods to manipulate this URL’s path segments.
    ///
    /// Return `Err(())` if this URL is cannot-be-a-base.
    #[allow(clippy::result_unit_err)]
    pub fn path_segments_mut(&mut self) -> Result<PathSegmentsMut<'_>, ()> {
        if self.cannot_be_a_base() {
            Err(())
        } else {
            Ok(path_segments::new(self))
        }
    }

    fn restore_after_path(&mut self, old_after_path_position: u32, after_path: &str) {
        let new_after_path_position = to_u32(self.serialization.len()).unwrap();
        let adjust = |index: &mut u32| {
            *index -= old_after_path_position;
            *index += new_after_path_position;
        };
        if let Some(ref mut index) = self.query_start {
            adjust(index)
        }
        if let Some(ref mut index) = self.fragment_start {
            adjust(index)
        }
        self.serialization.push_str(after_path)
    }

    /// Change this URL’s port number.
    ///
    /// Note that default port numbers are not reflected in the serialization.
    ///
    /// If this URL is cannot-be-a-base, does not have a host, or has the `file` scheme;
    /// do nothing and return `Err`.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use std::error::Error;
    ///
    /// # fn run() -> Result<(), Box<dyn Error>> {
    /// let mut url = Url::parse("ssh://example.net:2048/")?;
    ///
    /// url.set_port(Some(4096)).map_err(|_| "cannot be base")?;
    /// assert_eq!(url.as_str(), "ssh://example.net:4096/");
    ///
    /// url.set_port(None).map_err(|_| "cannot be base")?;
    /// assert_eq!(url.as_str(), "ssh://example.net/");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Known default port numbers are not reflected:
    ///
    /// ```rust
    /// use url::Url;
    /// # use std::error::Error;
    ///
    /// # fn run() -> Result<(), Box<dyn Error>> {
    /// let mut url = Url::parse("https://example.org/")?;
    ///
    /// url.set_port(Some(443)).map_err(|_| "cannot be base")?;
    /// assert!(url.port().is_none());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Cannot set port for cannot-be-a-base URLs:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("mailto:rms@example.net")?;
    ///
    /// let result = url.set_port(Some(80));
    /// assert!(result.is_err());
    ///
    /// let result = url.set_port(None);
    /// assert!(result.is_err());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[allow(clippy::result_unit_err)]
    pub fn set_port(&mut self, mut port: Option<u16>) -> Result<(), ()> {
        // has_host implies !cannot_be_a_base
        if !self.has_host() || self.host() == Some(Host::Domain("")) || self.scheme() == "file" {
            return Err(());
        }
        if port.is_some() && port == parser::default_port(self.scheme()) {
            port = None
        }
        self.set_port_internal(port);
        Ok(())
    }

    fn set_port_internal(&mut self, port: Option<u16>) {
        match (self.port, port) {
            (None, None) => {}
            (Some(_), None) => {
                self.serialization
                    .drain(self.host_end as usize..self.path_start as usize);
                let offset = self.path_start - self.host_end;
                self.path_start = self.host_end;
                if let Some(ref mut index) = self.query_start {
                    *index -= offset
                }
                if let Some(ref mut index) = self.fragment_start {
                    *index -= offset
                }
            }
            (Some(old), Some(new)) if old == new => {}
            (_, Some(new)) => {
                let path_and_after = self.slice(self.path_start..).to_owned();
                self.serialization.truncate(self.host_end as usize);
                write!(&mut self.serialization, ":{}", new).unwrap();
                let old_path_start = self.path_start;
                let new_path_start = to_u32(self.serialization.len()).unwrap();
                self.path_start = new_path_start;
                let adjust = |index: &mut u32| {
                    *index -= old_path_start;
                    *index += new_path_start;
                };
                if let Some(ref mut index) = self.query_start {
                    adjust(index)
                }
                if let Some(ref mut index) = self.fragment_start {
                    adjust(index)
                }
                self.serialization.push_str(&path_and_after);
            }
        }
        self.port = port;
    }

    /// Change this URL’s host.
    ///
    /// Removing the host (calling this with `None`)
    /// will also remove any username, password, and port number.
    ///
    /// # Examples
    ///
    /// Change host:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("https://example.net")?;
    /// let result = url.set_host(Some("rust-lang.org"));
    /// assert!(result.is_ok());
    /// assert_eq!(url.as_str(), "https://rust-lang.org/");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Remove host:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("foo://example.net")?;
    /// let result = url.set_host(None);
    /// assert!(result.is_ok());
    /// assert_eq!(url.as_str(), "foo:/");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Cannot remove host for 'special' schemes (e.g. `http`):
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("https://example.net")?;
    /// let result = url.set_host(None);
    /// assert!(result.is_err());
    /// assert_eq!(url.as_str(), "https://example.net/");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Cannot change or remove host for cannot-be-a-base URLs:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("mailto:rms@example.net")?;
    ///
    /// let result = url.set_host(Some("rust-lang.org"));
    /// assert!(result.is_err());
    /// assert_eq!(url.as_str(), "mailto:rms@example.net");
    ///
    /// let result = url.set_host(None);
    /// assert!(result.is_err());
    /// assert_eq!(url.as_str(), "mailto:rms@example.net");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// # Errors
    ///
    /// If this URL is cannot-be-a-base or there is an error parsing the given `host`,
    /// a [`ParseError`] variant will be returned.
    ///
    /// [`ParseError`]: enum.ParseError.html
    pub fn set_host(&mut self, host: Option<&str>) -> Result<(), ParseError> {
        if self.cannot_be_a_base() {
            return Err(ParseError::SetHostOnCannotBeABaseUrl);
        }

        let scheme_type = SchemeType::from(self.scheme());

shell

sed -n '1,260p' url/tests/unit.rs

output

Chunk ID: c281a6
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 2018
Output:
// Copyright 2013-2014 The rust-url developers.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! Unit tests

use std::borrow::Cow;
use std::cell::{Cell, RefCell};
use std::net::{Ipv4Addr, Ipv6Addr};
use std::path::{Path, PathBuf};
use url::{form_urlencoded, Host, Origin, Url};

#[test]
fn size() {
    use std::mem::size_of;
    assert_eq!(size_of::<Url>(), size_of::<Option<Url>>());
}

#[test]
fn test_relative() {
    let base: Url = "sc://%C3%B1".parse().unwrap();
    let url = base.join("/resources/testharness.js").unwrap();
    assert_eq!(url.as_str(), "sc://%C3%B1/resources/testharness.js");
}

#[test]
fn test_relative_empty() {
    let base: Url = "sc://%C3%B1".parse().unwrap();
    let url = base.join("").unwrap();
    assert_eq!(url.as_str(), "sc://%C3%B1");
}

#[test]
fn test_strip_trailing_spaces_from_opaque_path() {
    let mut url: Url = "data:space   ?query".parse().unwrap();
    url.set_query(None);
    assert_eq!(url.as_str(), "data:space");

    let mut url: Url = "data:space   #hash".parse().unwrap();
    url.set_fragment(None);
    assert_eq!(url.as_str(), "data:space");
}

#[test]
fn test_set_empty_host() {
    let mut base: Url = "moz://foo:bar@servo/baz".parse().unwrap();
    base.set_username("").unwrap();
    assert_eq!(base.as_str(), "moz://:bar@servo/baz");
    base.set_host(None).unwrap();
    assert_eq!(base.as_str(), "moz:/baz");
    base.set_host(Some("servo")).unwrap();
    assert_eq!(base.as_str(), "moz://servo/baz");

    let mut base: Url = "file://server/share/foo/bar".parse().unwrap();
    base.set_host(None).unwrap();
    assert_eq!(base.as_str(), "file:///share/foo/bar");

    let mut base: Url = "file://server/share/foo/bar".parse().unwrap();
    base.set_host(Some("foo")).unwrap();
    assert_eq!(base.as_str(), "file://foo/share/foo/bar");
}

#[test]
fn test_set_empty_hostname() {
    use url::quirks;
    let mut base: Url = "moz://foo@servo/baz".parse().unwrap();
    assert!(
        quirks::set_hostname(&mut base, "").is_err(),
        "setting an empty hostname to a url with a username should fail"
    );
    base = "moz://:pass@servo/baz".parse().unwrap();
    assert!(
        quirks::set_hostname(&mut base, "").is_err(),
        "setting an empty hostname to a url with a password should fail"
    );
    base = "moz://servo/baz".parse().unwrap();
    quirks::set_hostname(&mut base, "").unwrap();
    assert_eq!(base.as_str(), "moz:///baz");
}

macro_rules! assert_from_file_path {
    ($path: expr) => {
        assert_from_file_path!($path, $path)
    };
    ($path: expr, $url_path: expr) => {{
        let url = Url::from_file_path(Path::new($path)).unwrap();
        assert_eq!(url.host(), None);
        assert_eq!(url.path(), $url_path);
        assert_eq!(url.to_file_path(), Ok(PathBuf::from($path)));
    }};
}

#[test]
fn new_file_paths() {
    if cfg!(unix) {
        assert_eq!(Url::from_file_path(Path::new("relative")), Err(()));
        assert_eq!(Url::from_file_path(Path::new("../relative")), Err(()));
    }
    if cfg!(windows) {
        assert_eq!(Url::from_file_path(Path::new("relative")), Err(()));
        assert_eq!(Url::from_file_path(Path::new(r"..\relative")), Err(()));
        assert_eq!(Url::from_file_path(Path::new(r"\drive-relative")), Err(()));
        assert_eq!(Url::from_file_path(Path::new(r"\\ucn\")), Err(()));
    }

    if cfg!(unix) {
        assert_from_file_path!("/foo/bar");
        assert_from_file_path!("/foo/ba\0r", "/foo/ba%00r");
        assert_from_file_path!("/foo/ba%00r", "/foo/ba%2500r");
    }
}

#[test]
#[cfg(unix)]
fn new_path_bad_utf8() {
    use std::ffi::OsStr;
    use std::os::unix::prelude::*;

    let url = Url::from_file_path(Path::new(OsStr::from_bytes(b"/foo/ba\x80r"))).unwrap();
    let os_str = OsStr::from_bytes(b"/foo/ba\x80r");
    assert_eq!(url.to_file_path(), Ok(PathBuf::from(os_str)));
}

#[test]
fn new_path_windows_fun() {
    if cfg!(windows) {
        assert_from_file_path!(r"C:\foo\bar", "/C:/foo/bar");
        assert_from_file_path!("C:\\foo\\ba\0r", "/C:/foo/ba%00r");

        // Invalid UTF-8
        assert!(Url::parse("file:///C:/foo/ba%80r")
            .unwrap()
            .to_file_path()
            .is_err());

        // test windows canonicalized path
        let path = PathBuf::from(r"\\?\C:\foo\bar");
        assert!(Url::from_file_path(path).is_ok());

        // Percent-encoded drive letter
        let url = Url::parse("file:///C%3A/foo/bar").unwrap();
        assert_eq!(url.to_file_path(), Ok(PathBuf::from(r"C:\foo\bar")));
    }
}

#[test]
fn new_directory_paths() {
    if cfg!(unix) {
        assert_eq!(Url::from_directory_path(Path::new("relative")), Err(()));
        assert_eq!(Url::from_directory_path(Path::new("../relative")), Err(()));

        let url = Url::from_directory_path(Path::new("/foo/bar")).unwrap();
        assert_eq!(url.host(), None);
        assert_eq!(url.path(), "/foo/bar/");
    }
    if cfg!(windows) {
        assert_eq!(Url::from_directory_path(Path::new("relative")), Err(()));
        assert_eq!(Url::from_directory_path(Path::new(r"..\relative")), Err(()));
        assert_eq!(
            Url::from_directory_path(Path::new(r"\drive-relative")),
            Err(())
        );
        assert_eq!(Url::from_directory_path(Path::new(r"\\ucn\")), Err(()));

        let url = Url::from_directory_path(Path::new(r"C:\foo\bar")).unwrap();
        assert_eq!(url.host(), None);
        assert_eq!(url.path(), "/C:/foo/bar/");
    }
}

#[test]
fn path_backslash_fun() {
    let mut special_url = "http://foobar.com".parse::<Url>().unwrap();
    special_url.path_segments_mut().unwrap().push("foo\\bar");
    assert_eq!(special_url.as_str(), "http://foobar.com/foo%5Cbar");

    let mut nonspecial_url = "thing://foobar.com".parse::<Url>().unwrap();
    nonspecial_url.path_segments_mut().unwrap().push("foo\\bar");
    assert_eq!(nonspecial_url.as_str(), "thing://foobar.com/foo\\bar");
}

#[test]
fn from_str() {
    assert!("http://testing.com/this".parse::<Url>().is_ok());
}

#[test]
fn parse_with_params() {
    let url = Url::parse_with_params(
        "http://testing.com/this?dont=clobberme",
        &[("lang", "rust")],
    )
    .unwrap();

    assert_eq!(
        url.as_str(),
        "http://testing.com/this?dont=clobberme&lang=rust"
    );
}

#[test]
fn issue_124() {
    let url: Url = "file:a".parse().unwrap();
    assert_eq!(url.path(), "/a");
    let url: Url = "file:...".parse().unwrap();
    assert_eq!(url.path(), "/...");
    let url: Url = "file:..".parse().unwrap();
    assert_eq!(url.path(), "/");
}

#[test]
fn test_equality() {
    use std::collections::hash_map::DefaultHasher;
    use std::hash::{Hash, Hasher};

    fn check_eq(a: &Url, b: &Url) {
        assert_eq!(a, b);

        let mut h1 = DefaultHasher::new();
        a.hash(&mut h1);
        let mut h2 = DefaultHasher::new();
        b.hash(&mut h2);
        assert_eq!(h1.finish(), h2.finish());
    }

    fn url(s: &str) -> Url {
        let rv = s.parse().unwrap();
        check_eq(&rv, &rv);
        rv
    }

    // Doesn't care if default port is given.
    let a: Url = url("https://example.com/");
    let b: Url = url("https://example.com:443/");
    check_eq(&a, &b);

    // Different ports
    let a: Url = url("http://example.com/");
    let b: Url = url("http://example.com:8080/");
    assert!(a != b, "{:?} != {:?}", a, b);

    // Different scheme
    let a: Url = url("http://example.com/");
    let b: Url = url("https://example.com/");
    assert_ne!(a, b);

    // Different host
    let a: Url = url("http://foo.com/");
    let b: Url = url("http://bar.com/");
    assert_ne!(a, b);

    // Missing path, automatically substituted. Semantically the same.
    let a: Url = url("http://foo.com");
    let b: Url = url("http://foo.com/");
    check_eq(&a, &b);
}

shell

rg "non_special|cannot_be_a_base|Position::AfterPort|BeforePath|join\(" url/tests url/src -n

output

Chunk ID: dd88ad
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 1070
Output:
url/tests/data.rs:58:            base.join(&input)
url/src/slicing.rs:49:/// let authority: &str = &some_url[Position::BeforeUsername..Position::AfterPort];
url/src/slicing.rs:50:/// let data_url_payload: &str = &some_url[Position::BeforePath..Position::AfterQuery];
url/src/slicing.rs:92:    BeforePath,
url/src/slicing.rs:152:            Position::AfterPort => self.path_start as usize,
url/src/slicing.rs:154:            Position::BeforePath => self.path_start as usize,
url/src/quirks.rs:143:    &url[Position::BeforeHost..Position::AfterPort]
url/src/quirks.rs:150:    if url.cannot_be_a_base() {
url/src/quirks.rs:202:    if url.cannot_be_a_base() {
url/src/quirks.rs:238:    &url[Position::BeforePort..Position::AfterPort]
url/src/quirks.rs:246:        // has_host implies !cannot_be_a_base
url/src/quirks.rs:273:    if url.cannot_be_a_base() {
url/src/lib.rs:46:assert!(&issue_list_url[Position::BeforePath..] == "/rust-lang/rust/issues?labels=E-easy&state=open");
url/src/lib.rs:48:assert!(!issue_list_url.cannot_be_a_base());
url/src/lib.rs:65:assert!(data_url.cannot_be_a_base());
url/src/lib.rs:104:let css_url = this_document.join("../main.css")?;
url/src/lib.rs:327:        if !self.cannot_be_a_base() {
url/src/lib.rs:367:    /// let url = base.join("c.png")?;
url/src/lib.rs:371:    /// let url = base.join("c.png")?;
url/src/lib.rs:386:    pub fn join(&self, input: &str) -> Result<Url, crate::ParseError> {
url/src/lib.rs:432:        if self.cannot_be_a_base() {
url/src/lib.rs:903:    /// assert!(!url.cannot_be_a_base());
url/src/lib.rs:906:    /// assert!(!url.cannot_be_a_base());
url/src/lib.rs:909:    /// assert!(url.cannot_be_a_base());
url/src/lib.rs:915:    pub fn cannot_be_a_base(&self) -> bool {
url/src/lib.rs:1636:        let cannot_be_a_base = self.cannot_be_a_base();
url/src/lib.rs:1640:            if cannot_be_a_base {
url/src/lib.rs:1645:                parser.parse_cannot_be_a_base_path(parser::Input::new(path));
url/src/lib.rs:1659:        if self.cannot_be_a_base() {
url/src/lib.rs:1743:        // has_host implies !cannot_be_a_base
url/src/lib.rs:1876:        if self.cannot_be_a_base() {
url/src/lib.rs:2021:        if self.cannot_be_a_base() {
url/src/lib.rs:2061:        // has_host implies !cannot_be_a_base
url/src/lib.rs:2154:        // has_host implies !cannot_be_a_base
url/src/lib.rs:2620:            .field("cannot_be_a_base", &self.cannot_be_a_base())
url/src/parser.rs:372:            } else if base_url.cannot_be_a_base() {
url/src/parser.rs:439:                        debug_assert!(!base_url.cannot_be_a_base());
url/src/parser.rs:454:            SchemeType::NotSpecial => self.parse_non_special(input, scheme_type, scheme_end),
url/src/parser.rs:459:    fn parse_non_special(
url/src/parser.rs:481:            self.parse_cannot_be_a_base_path(input)
url/src/parser.rs:1330:    pub fn parse_cannot_be_a_base_path<'i>(&mut self, mut input: Input<'i>) -> Input<'i> {
url/tests/unit.rs:26:    let url = base.join("/resources/testharness.js").unwrap();
url/tests/unit.rs:33:    let url = base.join("").unwrap();
url/tests/unit.rs:422:    Url::parse("mailto:").unwrap().cannot_be_a_base();
url/tests/unit.rs:627:    assert!(no_base_url.cannot_be_a_base());
url/tests/unit.rs:908:fn test_non_special_path() {
url/tests/unit.rs:917:fn test_non_special_path2() {
url/tests/unit.rs:932:fn test_non_special_path3() {
url/tests/unit.rs:1033:        assert_eq!(&url[BeforePath..AfterPath], expected_slices.path);
url/tests/unit.rs:1153:            base_uri.join(relative).unwrap().as_str(),
url/tests/debugger_visualizer.rs:14:    dx url_with_non_special_scheme
url/tests/debugger_visualizer.rs:34:    url_with_non_special_scheme : "non-special://test/x" [Type: url::Url]
url/tests/debugger_visualizer.rs:79:    let url_with_non_special_scheme = Url::parse("non-special://:@test/x").unwrap();
url/tests/debugger_visualizer.rs:80:    assert_eq!(url_with_non_special_scheme.as_str(), "non-special://test/x");
url/tests/debugger_visualizer.rs:92:    let url_with_base = base_url.join("/a%2fc").unwrap();
url/tests/debugger_visualizer.rs:95:    let url_with_base_replaced = base_url.join("http://[::127.0.0.1]").unwrap();
url/tests/debugger_visualizer.rs:98:    let url_with_comma = base_url.join("data:text/html,test#test").unwrap();

shell

sed -n '880,950p' url/tests/unit.rs

output

Chunk ID: 4ea033
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 578
Output:

/// https://[code-host]/servo/rust-url/issues/505
#[cfg(windows)]
#[test]
fn test_url_from_file_path() {
    use std::path::PathBuf;
    use url::Url;

    let p = PathBuf::from("c:///");
    let u = Url::from_file_path(p).unwrap();
    let path = u.to_file_path().unwrap();
    assert_eq!("C:\\", path.to_str().unwrap());
}

/// https://[code-host]/servo/rust-url/issues/505
#[cfg(not(windows))]
#[test]
fn test_url_from_file_path() {
    use std::path::PathBuf;
    use url::Url;

    let p = PathBuf::from("/c:/");
    let u = Url::from_file_path(p).unwrap();
    let path = u.to_file_path().unwrap();
    assert_eq!("/c:/", path.to_str().unwrap());
}

#[test]
fn test_non_special_path() {
    let mut db_url = url::Url::parse("postgres://postgres@localhost/").unwrap();
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/");
    db_url.set_path("diesel_foo");
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/diesel_foo");
    assert_eq!(db_url.path(), "/diesel_foo");
}

#[test]
fn test_non_special_path2() {
    let mut db_url = url::Url::parse("postgres://postgres@localhost/").unwrap();
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/");
    db_url.set_path("");
    assert_eq!(db_url.path(), "");
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost");
    db_url.set_path("foo");
    assert_eq!(db_url.path(), "/foo");
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/foo");
    db_url.set_path("/bar");
    assert_eq!(db_url.path(), "/bar");
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/bar");
}

#[test]
fn test_non_special_path3() {
    let mut db_url = url::Url::parse("postgres://postgres@localhost/").unwrap();
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/");
    db_url.set_path("/");
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/");
    assert_eq!(db_url.path(), "/");
    db_url.set_path("/foo");
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/foo");
    assert_eq!(db_url.path(), "/foo");
}

#[test]
fn test_set_scheme_to_file_with_host() {
    let mut url: Url = "http://localhost:6767/foo/bar".parse().unwrap();
    let result = url.set_scheme("file");
    assert_eq!(url.to_string(), "http://localhost:6767/foo/bar");
    assert_eq!(result, Err(()));
}

shell

sed -n '1000,1060p' url/tests/unit.rs

output

Chunk ID: 9d994d
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 467
Output:
            fragment: "fragment",
            ..Default::default()
        },
        ExpectedSlices {
            full: "https://domain.com:9742/path/file.ext",
            scheme: "https",
            host: "domain.com",
            port: "9742",
            path: "/path/file.ext",
            ..Default::default()
        },
        ExpectedSlices {
            full: "blob:blob-info",
            scheme: "blob",
            path: "blob-info",
            ..Default::default()
        },
    ];

    for expected_slices in &data {
        let url = Url::parse(expected_slices.full).unwrap();
        assert_eq!(&url[..], expected_slices.full);
        assert_eq!(&url[BeforeScheme..AfterScheme], expected_slices.scheme);
        assert_eq!(
            &url[BeforeUsername..AfterUsername],
            expected_slices.username
        );
        assert_eq!(
            &url[BeforePassword..AfterPassword],
            expected_slices.password
        );
        assert_eq!(&url[BeforeHost..AfterHost], expected_slices.host);
        assert_eq!(&url[BeforePort..AfterPort], expected_slices.port);
        assert_eq!(&url[BeforePath..AfterPath], expected_slices.path);
        assert_eq!(&url[BeforeQuery..AfterQuery], expected_slices.query);
        assert_eq!(
            &url[BeforeFragment..AfterFragment],
            expected_slices.fragment
        );
        assert_eq!(&url[..AfterFragment], expected_slices.full);
    }
}

#[test]
fn test_make_relative() {
    let tests = [
        (
            "http://127.0.0.1:8080/test",
            "http://127.0.0.1:8080/test",
            "",
        ),
        (
            "http://127.0.0.1:8080/test",
            "http://127.0.0.1:8080/test/",
            "test/",
        ),
        (
            "http://127.0.0.1:8080/test/",
            "http://127.0.0.1:8080/test",
            "../test",
        ),

shell

sed -n '1120,1175p' url/tests/unit.rs

output

Chunk ID: fa6222
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 455
Output:
        ),
        (
            "http://127.0.0.1:8080/test/",
            "http://127.0.0.1:8080/test/?baz=meh#456",
            "?baz=meh#456",
        ),
        (
            "http://127.0.0.1:8080/test/?foo=bar#123",
            "http://127.0.0.1:8080/test/video?baz=meh#456",
            "video?baz=meh#456",
        ),
        (
            "http://127.0.0.1:8080/file.txt",
            "http://127.0.0.1:8080/test/file.txt",
            "test/file.txt",
        ),
        (
            "http://127.0.0.1:8080/not_equal.txt",
            "http://127.0.0.1:8080/test/file.txt",
            "test/file.txt",
        ),
    ];

    for (base, uri, relative) in &tests {
        let base_uri = url::Url::parse(base).unwrap();
        let relative_uri = url::Url::parse(uri).unwrap();
        let make_relative = base_uri.make_relative(&relative_uri).unwrap();
        assert_eq!(
            make_relative, *relative,
            "base: {}, uri: {}, relative: {}",
            base, uri, relative
        );
        assert_eq!(
            base_uri.join(relative).unwrap().as_str(),
            *uri,
            "base: {}, uri: {}, relative: {}",
            base,
            uri,
            relative
        );
    }

    let error_tests = [
        ("http://127.0.0.1:8080/", "https://127.0.0.1:8080/test/"),
        ("http://127.0.0.1:8080/", "http://127.0.0.1:8081/test/"),
        ("http://127.0.0.1:8080/", "http://127.0.0.2:8080/test/"),
        ("mailto:a@example.com", "mailto:b@example.com"),
    ];

    for (base, uri) in &error_tests {
        let base_uri = url::Url::parse(base).unwrap();
        let relative_uri = url::Url::parse(uri).unwrap();
        let make_relative = base_uri.make_relative(&relative_uri);
        assert_eq!(make_relative, None, "base: {}, uri: {}", base, uri);
    }
}

shell

sed -n '1880,2260p' url/src/lib.rs

output

Chunk ID: ab8a82
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 3506
Output:
        let scheme_type = SchemeType::from(self.scheme());

        if let Some(host) = host {
            if host.is_empty() && scheme_type.is_special() && !scheme_type.is_file() {
                return Err(ParseError::EmptyHost);
            }
            let mut host_substr = host;
            // Otherwise, if c is U+003A (:) and the [] flag is unset, then
            if !host.starts_with('[') || !host.ends_with(']') {
                match host.find(':') {
                    Some(0) => {
                        // If buffer is the empty string, validation error, return failure.
                        return Err(ParseError::InvalidDomainCharacter);
                    }
                    // Let host be the result of host parsing buffer
                    Some(colon_index) => {
                        host_substr = &host[..colon_index];
                    }
                    None => {}
                }
            }
            if SchemeType::from(self.scheme()).is_special() {
                self.set_host_internal(Host::parse(host_substr)?, None);
            } else {
                self.set_host_internal(Host::parse_opaque(host_substr)?, None);
            }
        } else if self.has_host() {
            if scheme_type.is_special() && !scheme_type.is_file() {
                return Err(ParseError::EmptyHost);
            } else if self.serialization.len() == self.path_start as usize {
                self.serialization.push('/');
            }
            debug_assert!(self.byte_at(self.scheme_end) == b':');
            debug_assert!(self.byte_at(self.path_start) == b'/');

            let new_path_start = if scheme_type.is_file() {
                self.scheme_end + 3
            } else {
                self.scheme_end + 1
            };

            self.serialization
                .drain(new_path_start as usize..self.path_start as usize);
            let offset = self.path_start - new_path_start;
            self.path_start = new_path_start;
            self.username_end = new_path_start;
            self.host_start = new_path_start;
            self.host_end = new_path_start;
            self.port = None;
            if let Some(ref mut index) = self.query_start {
                *index -= offset
            }
            if let Some(ref mut index) = self.fragment_start {
                *index -= offset
            }
        }
        Ok(())
    }

    /// opt_new_port: None means leave unchanged, Some(None) means remove any port number.
    fn set_host_internal(&mut self, host: Host<String>, opt_new_port: Option<Option<u16>>) {
        let old_suffix_pos = if opt_new_port.is_some() {
            self.path_start
        } else {
            self.host_end
        };
        let suffix = self.slice(old_suffix_pos..).to_owned();
        self.serialization.truncate(self.host_start as usize);
        if !self.has_authority() {
            debug_assert!(self.slice(self.scheme_end..self.host_start) == ":");
            debug_assert!(self.username_end == self.host_start);
            self.serialization.push('/');
            self.serialization.push('/');
            self.username_end += 2;
            self.host_start += 2;
        }
        write!(&mut self.serialization, "{}", host).unwrap();
        self.host_end = to_u32(self.serialization.len()).unwrap();
        self.host = host.into();

        if let Some(new_port) = opt_new_port {
            self.port = new_port;
            if let Some(port) = new_port {
                write!(&mut self.serialization, ":{}", port).unwrap();
            }
        }
        let new_suffix_pos = to_u32(self.serialization.len()).unwrap();
        self.serialization.push_str(&suffix);

        let adjust = |index: &mut u32| {
            *index -= old_suffix_pos;
            *index += new_suffix_pos;
        };
        adjust(&mut self.path_start);
        if let Some(ref mut index) = self.query_start {
            adjust(index)
        }
        if let Some(ref mut index) = self.fragment_start {
            adjust(index)
        }
    }

    /// Change this URL’s host to the given IP address.
    ///
    /// If this URL is cannot-be-a-base, do nothing and return `Err`.
    ///
    /// Compared to `Url::set_host`, this skips the host parser.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::{Url, ParseError};
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("http://example.com")?;
    /// url.set_ip_host("127.0.0.1".parse().unwrap());
    /// assert_eq!(url.host_str(), Some("127.0.0.1"));
    /// assert_eq!(url.as_str(), "http://127.0.0.1/");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Cannot change URL's from mailto(cannot-be-base) to ip:
    ///
    /// ```rust
    /// use url::{Url, ParseError};
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("mailto:rms@example.com")?;
    /// let result = url.set_ip_host("127.0.0.1".parse().unwrap());
    ///
    /// assert_eq!(url.as_str(), "mailto:rms@example.com");
    /// assert!(result.is_err());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    #[allow(clippy::result_unit_err)]
    pub fn set_ip_host(&mut self, address: IpAddr) -> Result<(), ()> {
        if self.cannot_be_a_base() {
            return Err(());
        }

        let address = match address {
            IpAddr::V4(address) => Host::Ipv4(address),
            IpAddr::V6(address) => Host::Ipv6(address),
        };
        self.set_host_internal(address, None);
        Ok(())
    }

    /// Change this URL’s password.
    ///
    /// If this URL is cannot-be-a-base or does not have a host, do nothing and return `Err`.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use url::{Url, ParseError};
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("mailto:rmz@example.com")?;
    /// let result = url.set_password(Some("secret_password"));
    /// assert!(result.is_err());
    ///
    /// let mut url = Url::parse("ftp://user1:secret1@example.com")?;
    /// let result = url.set_password(Some("secret_password"));
    /// assert_eq!(url.password(), Some("secret_password"));
    ///
    /// let mut url = Url::parse("ftp://user2:@example.com")?;
    /// let result = url.set_password(Some("secret2"));
    /// assert!(result.is_ok());
    /// assert_eq!(url.password(), Some("secret2"));
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[allow(clippy::result_unit_err)]
    pub fn set_password(&mut self, password: Option<&str>) -> Result<(), ()> {
        // has_host implies !cannot_be_a_base
        if !self.has_host() || self.host() == Some(Host::Domain("")) || self.scheme() == "file" {
            return Err(());
        }
        if let Some(password) = password {
            let host_and_after = self.slice(self.host_start..).to_owned();
            self.serialization.truncate(self.username_end as usize);
            self.serialization.push(':');
            self.serialization
                .extend(utf8_percent_encode(password, USERINFO));
            self.serialization.push('@');

            let old_host_start = self.host_start;
            let new_host_start = to_u32(self.serialization.len()).unwrap();
            let adjust = |index: &mut u32| {
                *index -= old_host_start;
                *index += new_host_start;
            };
            self.host_start = new_host_start;
            adjust(&mut self.host_end);
            adjust(&mut self.path_start);
            if let Some(ref mut index) = self.query_start {
                adjust(index)
            }
            if let Some(ref mut index) = self.fragment_start {
                adjust(index)
            }

            self.serialization.push_str(&host_and_after);
        } else if self.byte_at(self.username_end) == b':' {
            // If there is a password to remove
            let has_username_or_password = self.byte_at(self.host_start - 1) == b'@';
            debug_assert!(has_username_or_password);
            let username_start = self.scheme_end + 3;
            let empty_username = username_start == self.username_end;
            let start = self.username_end; // Remove the ':'
            let end = if empty_username {
                self.host_start // Remove the '@' as well
            } else {
                self.host_start - 1 // Keep the '@' to separate the username from the host
            };
            self.serialization.drain(start as usize..end as usize);
            let offset = end - start;
            self.host_start -= offset;
            self.host_end -= offset;
            self.path_start -= offset;
            if let Some(ref mut index) = self.query_start {
                *index -= offset
            }
            if let Some(ref mut index) = self.fragment_start {
                *index -= offset
            }
        }
        Ok(())
    }

    /// Change this URL’s username.
    ///
    /// If this URL is cannot-be-a-base or does not have a host, do nothing and return `Err`.
    /// # Examples
    ///
    /// Cannot setup username from mailto(cannot-be-base)
    ///
    /// ```rust
    /// use url::{Url, ParseError};
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("mailto:rmz@example.com")?;
    /// let result = url.set_username("user1");
    /// assert_eq!(url.as_str(), "mailto:rmz@example.com");
    /// assert!(result.is_err());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Setup username to user1
    ///
    /// ```rust
    /// use url::{Url, ParseError};
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("ftp://:secre1@example.com/")?;
    /// let result = url.set_username("user1");
    /// assert!(result.is_ok());
    /// assert_eq!(url.username(), "user1");
    /// assert_eq!(url.as_str(), "ftp://user1:secre1@example.com/");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[allow(clippy::result_unit_err)]
    pub fn set_username(&mut self, username: &str) -> Result<(), ()> {
        // has_host implies !cannot_be_a_base
        if !self.has_host() || self.host() == Some(Host::Domain("")) || self.scheme() == "file" {
            return Err(());
        }
        let username_start = self.scheme_end + 3;
        debug_assert!(self.slice(self.scheme_end..username_start) == "://");
        if self.slice(username_start..self.username_end) == username {
            return Ok(());
        }
        let after_username = self.slice(self.username_end..).to_owned();
        self.serialization.truncate(username_start as usize);
        self.serialization
            .extend(utf8_percent_encode(username, USERINFO));

        let mut removed_bytes = self.username_end;
        self.username_end = to_u32(self.serialization.len()).unwrap();
        let mut added_bytes = self.username_end;

        let new_username_is_empty = self.username_end == username_start;
        match (new_username_is_empty, after_username.chars().next()) {
            (true, Some('@')) => {
                removed_bytes += 1;
                self.serialization.push_str(&after_username[1..]);
            }
            (false, Some('@')) | (_, Some(':')) | (true, _) => {
                self.serialization.push_str(&after_username);
            }
            (false, _) => {
                added_bytes += 1;
                self.serialization.push('@');
                self.serialization.push_str(&after_username);
            }
        }

        let adjust = |index: &mut u32| {
            *index -= removed_bytes;
            *index += added_bytes;
        };
        adjust(&mut self.host_start);
        adjust(&mut self.host_end);
        adjust(&mut self.path_start);
        if let Some(ref mut index) = self.query_start {
            adjust(index)
        }
        if let Some(ref mut index) = self.fragment_start {
            adjust(index)
        }
        Ok(())
    }

    /// Change this URL’s scheme.
    ///
    /// Do nothing and return `Err` under the following circumstances:
    ///
    /// * If the new scheme is not in `[a-zA-Z][a-zA-Z0-9+.-]+`
    /// * If this URL is cannot-be-a-base and the new scheme is one of
    ///   `http`, `https`, `ws`, `wss` or `ftp`
    /// * If either the old or new scheme is `http`, `https`, `ws`,
    ///   `wss` or `ftp` and the other is not one of these
    /// * If the new scheme is `file` and this URL includes credentials
    ///   or has a non-null port
    /// * If this URL's scheme is `file` and its host is empty or null
    ///
    /// See also [the URL specification's section on legal scheme state
    /// overrides](https://url.spec.whatwg.org/#scheme-state).
    ///
    /// # Examples
    ///
    /// Change the URL’s scheme from `https` to `http`:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("https://example.net")?;
    /// let result = url.set_scheme("http");
    /// assert_eq!(url.as_str(), "http://example.net/");
    /// assert!(result.is_ok());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    /// Change the URL’s scheme from `foo` to `bar`:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("foo://example.net")?;
    /// let result = url.set_scheme("bar");
    /// assert_eq!(url.as_str(), "bar://example.net");
    /// assert!(result.is_ok());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Cannot change URL’s scheme from `https` to `foõ`:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("https://example.net")?;

The existing struct already stores one serialization string plus component offsets. I’m going to represent the marker by making `path_start` point after `/.` for just this internal shape, then teach slicing that `AfterPort` is before that marker.

One important consequence is that host changes can cross the same boundary: adding a host must drop the serialized marker, and removing a host may need to add it. I’m checking those mutators now so the representation doesn’t leak through setters.

shell

rg "impl PartialEq|impl Eq|impl hash|fn set_scheme|fn slice|fn byte_at|serialize_internal|deserialize_internal" -n url/src/lib.rs

output

Chunk ID: ed0d4e
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 210
Output:
2315:    pub fn set_scheme(&mut self, scheme: &str) -> Result<(), ()> {
2442:    /// The corresponding `deserialize_internal` method sacrifices some invariant-checking
2448:    pub fn serialize_internal<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2484:    /// The corresponding `deserialize_internal` method sacrifices some invariant-checking
2490:    pub fn deserialize_internal<'de, D>(deserializer: D) -> Result<Self, D::Error>
2567:    fn slice<R>(&self, range: R) -> &str
2575:    fn byte_at(&self, i: u32) -> u8 {
2633:impl Eq for Url {}
2636:impl PartialEq for Url {
2660:impl hash::Hash for Url {
2679:    fn slice_of<'a>(&self, s: &'a str) -> &'a str;
2684:    fn slice_of<'a>(&self, s: &'a str) -> &'a str {
2691:    fn slice_of<'a>(&self, s: &'a str) -> &'a str {
2698:    fn slice_of<'a>(&self, s: &'a str) -> &'a str {

shell

sed -n '2260,2680p' url/src/lib.rs

output

Chunk ID: cbb0e5
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 3422
Output:
    /// let mut url = Url::parse("https://example.net")?;
    /// let result = url.set_scheme("foõ");
    /// assert_eq!(url.as_str(), "https://example.net/");
    /// assert!(result.is_err());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// Cannot change URL’s scheme from `mailto` (cannot-be-a-base) to `https`:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("mailto:rms@example.net")?;
    /// let result = url.set_scheme("https");
    /// assert_eq!(url.as_str(), "mailto:rms@example.net");
    /// assert!(result.is_err());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    /// Cannot change the URL’s scheme from `foo` to `https`:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("foo://example.net")?;
    /// let result = url.set_scheme("https");
    /// assert_eq!(url.as_str(), "foo://example.net");
    /// assert!(result.is_err());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    /// Cannot change the URL’s scheme from `http` to `foo`:
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let mut url = Url::parse("http://example.net")?;
    /// let result = url.set_scheme("foo");
    /// assert_eq!(url.as_str(), "http://example.net/");
    /// assert!(result.is_err());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[allow(clippy::result_unit_err, clippy::suspicious_operation_groupings)]
    pub fn set_scheme(&mut self, scheme: &str) -> Result<(), ()> {
        let mut parser = Parser::for_setter(String::new());
        let remaining = parser.parse_scheme(parser::Input::new(scheme))?;
        let new_scheme_type = SchemeType::from(&parser.serialization);
        let old_scheme_type = SchemeType::from(self.scheme());
        // If url’s scheme is a special scheme and buffer is not a special scheme, then return.
        if (new_scheme_type.is_special() && !old_scheme_type.is_special()) ||
            // If url’s scheme is not a special scheme and buffer is a special scheme, then return.
            (!new_scheme_type.is_special() && old_scheme_type.is_special()) ||
            // If url includes credentials or has a non-null port, and buffer is "file", then return.
            // If url’s scheme is "file" and its host is an empty host or null, then return.
            (new_scheme_type.is_file() && self.has_authority())
        {
            return Err(());
        }

        if !remaining.is_empty() || (!self.has_host() && new_scheme_type.is_special()) {
            return Err(());
        }
        let old_scheme_end = self.scheme_end;
        let new_scheme_end = to_u32(parser.serialization.len()).unwrap();
        let adjust = |index: &mut u32| {
            *index -= old_scheme_end;
            *index += new_scheme_end;
        };

        self.scheme_end = new_scheme_end;
        adjust(&mut self.username_end);
        adjust(&mut self.host_start);
        adjust(&mut self.host_end);
        adjust(&mut self.path_start);
        if let Some(ref mut index) = self.query_start {
            adjust(index)
        }
        if let Some(ref mut index) = self.fragment_start {
            adjust(index)
        }

        parser.serialization.push_str(self.slice(old_scheme_end..));
        self.serialization = parser.serialization;

        // Update the port so it can be removed
        // If it is the scheme's default
        // we don't mind it silently failing
        // if there was no port in the first place
        let previous_port = self.port();
        let _ = self.set_port(previous_port);

        Ok(())
    }

    /// Convert a file name as `std::path::Path` into an URL in the `file` scheme.
    ///
    /// This returns `Err` if the given path is not absolute or,
    /// on Windows, if the prefix is not a disk prefix (e.g. `C:`) or a UNC prefix (`\\`).
    ///
    /// # Examples
    ///
    /// On Unix-like platforms:
    ///
    /// ```
    /// # if cfg!(unix) {
    /// use url::Url;
    ///
    /// # fn run() -> Result<(), ()> {
    /// let url = Url::from_file_path("/tmp/foo.txt")?;
    /// assert_eq!(url.as_str(), "file:///tmp/foo.txt");
    ///
    /// let url = Url::from_file_path("../foo.txt");
    /// assert!(url.is_err());
    ///
    /// let url = Url::from_file_path("https://google.com/");
    /// assert!(url.is_err());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// # }
    /// ```
    #[cfg(any(unix, windows, target_os = "redox", target_os = "wasi"))]
    #[allow(clippy::result_unit_err)]
    pub fn from_file_path<P: AsRef<Path>>(path: P) -> Result<Url, ()> {
        let mut serialization = "file://".to_owned();
        let host_start = serialization.len() as u32;
        let (host_end, host) = path_to_file_url_segments(path.as_ref(), &mut serialization)?;
        Ok(Url {
            serialization,
            scheme_end: "file".len() as u32,
            username_end: host_start,
            host_start,
            host_end,
            host,
            port: None,
            path_start: host_end,
            query_start: None,
            fragment_start: None,
        })
    }

    /// Convert a directory name as `std::path::Path` into an URL in the `file` scheme.
    ///
    /// This returns `Err` if the given path is not absolute or,
    /// on Windows, if the prefix is not a disk prefix (e.g. `C:`) or a UNC prefix (`\\`).
    ///
    /// Compared to `from_file_path`, this ensure that URL’s the path has a trailing slash
    /// so that the entire path is considered when using this URL as a base URL.
    ///
    /// For example:
    ///
    /// * `"index.html"` parsed with `Url::from_directory_path(Path::new("/var/www"))`
    ///   as the base URL is `file:///var/www/index.html`
    /// * `"index.html"` parsed with `Url::from_file_path(Path::new("/var/www"))`
    ///   as the base URL is `file:///var/index.html`, which might not be what was intended.
    ///
    /// Note that `std::path` does not consider trailing slashes significant
    /// and usually does not include them (e.g. in `Path::parent()`).
    #[cfg(any(unix, windows, target_os = "redox", target_os = "wasi"))]
    #[allow(clippy::result_unit_err)]
    pub fn from_directory_path<P: AsRef<Path>>(path: P) -> Result<Url, ()> {
        let mut url = Url::from_file_path(path)?;
        if !url.serialization.ends_with('/') {
            url.serialization.push('/')
        }
        Ok(url)
    }

    /// Serialize with Serde using the internal representation of the `Url` struct.
    ///
    /// The corresponding `deserialize_internal` method sacrifices some invariant-checking
    /// for speed, compared to the `Deserialize` trait impl.
    ///
    /// This method is only available if the `serde` Cargo feature is enabled.
    #[cfg(feature = "serde")]
    #[deny(unused)]
    pub fn serialize_internal<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::Serialize;
        // Destructuring first lets us ensure that adding or removing fields forces this method
        // to be updated
        let Url {
            ref serialization,
            ref scheme_end,
            ref username_end,
            ref host_start,
            ref host_end,
            ref host,
            ref port,
            ref path_start,
            ref query_start,
            ref fragment_start,
        } = *self;
        (
            serialization,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            query_start,
            fragment_start,
        )
            .serialize(serializer)
    }

    /// Serialize with Serde using the internal representation of the `Url` struct.
    ///
    /// The corresponding `deserialize_internal` method sacrifices some invariant-checking
    /// for speed, compared to the `Deserialize` trait impl.
    ///
    /// This method is only available if the `serde` Cargo feature is enabled.
    #[cfg(feature = "serde")]
    #[deny(unused)]
    pub fn deserialize_internal<'de, D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        use serde::de::{Deserialize, Error, Unexpected};
        let (
            serialization,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            query_start,
            fragment_start,
        ) = Deserialize::deserialize(deserializer)?;
        let url = Url {
            serialization,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            query_start,
            fragment_start,
        };
        if cfg!(debug_assertions) {
            url.check_invariants().map_err(|reason| {
                let reason: &str = &reason;
                Error::invalid_value(Unexpected::Other("value"), &reason)
            })?
        }
        Ok(url)
    }

    /// Assuming the URL is in the `file` scheme or similar,
    /// convert its path to an absolute `std::path::Path`.
    ///
    /// **Note:** This does not actually check the URL’s `scheme`,
    /// and may give nonsensical results for other schemes.
    /// It is the user’s responsibility to check the URL’s scheme before calling this.
    ///
    /// ```
    /// # use url::Url;
    /// # let url = Url::parse("file:///etc/passwd").unwrap();
    /// let path = url.to_file_path();
    /// ```
    ///
    /// Returns `Err` if the host is neither empty nor `"localhost"` (except on Windows, where
    /// `file:` URLs may have a non-local host),
    /// or if `Path::new_opt()` returns `None`.
    /// (That is, if the percent-decoded path contains a NUL byte or,
    /// for a Windows path, is not UTF-8.)
    #[inline]
    #[cfg(any(unix, windows, target_os = "redox", target_os = "wasi"))]
    #[allow(clippy::result_unit_err)]
    pub fn to_file_path(&self) -> Result<PathBuf, ()> {
        if let Some(segments) = self.path_segments() {
            let host = match self.host() {
                None | Some(Host::Domain("localhost")) => None,
                Some(_) if cfg!(windows) && self.scheme() == "file" => {
                    Some(&self.serialization[self.host_start as usize..self.host_end as usize])
                }
                _ => return Err(()),
            };

            return file_url_segments_to_pathbuf(host, segments);
        }
        Err(())
    }

    // Private helper methods:

    #[inline]
    fn slice<R>(&self, range: R) -> &str
    where
        R: RangeArg,
    {
        range.slice_of(&self.serialization)
    }

    #[inline]
    fn byte_at(&self, i: u32) -> u8 {
        self.serialization.as_bytes()[i as usize]
    }
}

/// Parse a string as an URL, without a base URL or encoding override.
impl str::FromStr for Url {
    type Err = ParseError;

    #[inline]
    fn from_str(input: &str) -> Result<Url, crate::ParseError> {
        Url::parse(input)
    }
}

impl<'a> TryFrom<&'a str> for Url {
    type Error = ParseError;

    fn try_from(s: &'a str) -> Result<Self, Self::Error> {
        Url::parse(s)
    }
}

/// Display the serialization of this URL.
impl fmt::Display for Url {
    #[inline]
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.serialization, formatter)
    }
}

/// String conversion.
impl From<Url> for String {
    fn from(value: Url) -> String {
        value.serialization
    }
}

/// Debug the serialization of this URL.
impl fmt::Debug for Url {
    #[inline]
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter
            .debug_struct("Url")
            .field("scheme", &self.scheme())
            .field("cannot_be_a_base", &self.cannot_be_a_base())
            .field("username", &self.username())
            .field("password", &self.password())
            .field("host", &self.host())
            .field("port", &self.port())
            .field("path", &self.path())
            .field("query", &self.query())
            .field("fragment", &self.fragment())
            .finish()
    }
}

/// URLs compare like their serialization.
impl Eq for Url {}

/// URLs compare like their serialization.
impl PartialEq for Url {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.serialization == other.serialization
    }
}

/// URLs compare like their serialization.
impl Ord for Url {
    #[inline]
    fn cmp(&self, other: &Self) -> cmp::Ordering {
        self.serialization.cmp(&other.serialization)
    }
}

/// URLs compare like their serialization.
impl PartialOrd for Url {
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
        self.serialization.partial_cmp(&other.serialization)
    }
}

/// URLs hash like their serialization.
impl hash::Hash for Url {
    #[inline]
    fn hash<H>(&self, state: &mut H)
    where
        H: hash::Hasher,
    {
        hash::Hash::hash(&self.serialization, state)
    }
}

/// Return the serialization of this URL.
impl AsRef<str> for Url {
    #[inline]
    fn as_ref(&self) -> &str {
        &self.serialization
    }
}

trait RangeArg {
    fn slice_of<'a>(&self, s: &'a str) -> &'a str;
}

shell

sed -n '2680,2860p' url/src/lib.rs

output

Chunk ID: 9f40d0
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 1368
Output:
}

impl RangeArg for Range<u32> {
    #[inline]
    fn slice_of<'a>(&self, s: &'a str) -> &'a str {
        &s[self.start as usize..self.end as usize]
    }
}

impl RangeArg for RangeFrom<u32> {
    #[inline]
    fn slice_of<'a>(&self, s: &'a str) -> &'a str {
        &s[self.start as usize..]
    }
}

impl RangeArg for RangeTo<u32> {
    #[inline]
    fn slice_of<'a>(&self, s: &'a str) -> &'a str {
        &s[..self.end as usize]
    }
}

/// Serializes this URL into a `serde` stream.
///
/// This implementation is only available if the `serde` Cargo feature is enabled.
#[cfg(feature = "serde")]
impl serde::Serialize for Url {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

/// Deserializes this URL from a `serde` stream.
///
/// This implementation is only available if the `serde` Cargo feature is enabled.
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Url {
    fn deserialize<D>(deserializer: D) -> Result<Url, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        use serde::de::{Error, Unexpected, Visitor};

        struct UrlVisitor;

        impl<'de> Visitor<'de> for UrlVisitor {
            type Value = Url;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a string representing an URL")
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                Url::parse(s).map_err(|err| {
                    let err_s = format!("{}", err);
                    Error::invalid_value(Unexpected::Str(s), &err_s.as_str())
                })
            }
        }

        deserializer.deserialize_str(UrlVisitor)
    }
}

#[cfg(any(unix, target_os = "redox", target_os = "wasi"))]
fn path_to_file_url_segments(
    path: &Path,
    serialization: &mut String,
) -> Result<(u32, HostInternal), ()> {
    #[cfg(any(unix, target_os = "redox"))]
    use std::os::unix::prelude::OsStrExt;
    #[cfg(target_os = "wasi")]
    use std::os::wasi::prelude::OsStrExt;
    if !path.is_absolute() {
        return Err(());
    }
    let host_end = to_u32(serialization.len()).unwrap();
    let mut empty = true;
    // skip the root component
    for component in path.components().skip(1) {
        empty = false;
        serialization.push('/');
        serialization.extend(percent_encode(
            component.as_os_str().as_bytes(),
            PATH_SEGMENT,
        ));
    }
    if empty {
        // An URL’s path must not be empty.
        serialization.push('/');
    }
    Ok((host_end, HostInternal::None))
}

#[cfg(windows)]
fn path_to_file_url_segments(
    path: &Path,
    serialization: &mut String,
) -> Result<(u32, HostInternal), ()> {
    path_to_file_url_segments_windows(path, serialization)
}

// Build this unconditionally to alleviate https://[code-host]/servo/rust-url/issues/102
#[cfg_attr(not(windows), allow(dead_code))]
fn path_to_file_url_segments_windows(
    path: &Path,
    serialization: &mut String,
) -> Result<(u32, HostInternal), ()> {
    use std::path::{Component, Prefix};
    if !path.is_absolute() {
        return Err(());
    }
    let mut components = path.components();

    let host_start = serialization.len() + 1;
    let host_end;
    let host_internal;

    match components.next() {
        Some(Component::Prefix(ref p)) => match p.kind() {
            Prefix::Disk(letter) | Prefix::VerbatimDisk(letter) => {
                host_end = to_u32(serialization.len()).unwrap();
                host_internal = HostInternal::None;
                serialization.push('/');
                serialization.push(letter as char);
                serialization.push(':');
            }
            Prefix::UNC(server, share) | Prefix::VerbatimUNC(server, share) => {
                let host = Host::parse(server.to_str().ok_or(())?).map_err(|_| ())?;
                write!(serialization, "{}", host).unwrap();
                host_end = to_u32(serialization.len()).unwrap();
                host_internal = host.into();
                serialization.push('/');
                let share = share.to_str().ok_or(())?;
                serialization.extend(percent_encode(share.as_bytes(), PATH_SEGMENT));
            }
            _ => return Err(()),
        },
        _ => return Err(()),
    }

    let mut path_only_has_prefix = true;
    for component in components {
        if component == Component::RootDir {
            continue;
        }

        path_only_has_prefix = false;
        // FIXME: somehow work with non-unicode?
        let component = component.as_os_str().to_str().ok_or(())?;

        serialization.push('/');
        serialization.extend(percent_encode(component.as_bytes(), PATH_SEGMENT));
    }

    // A windows drive letter must end with a slash.
    if serialization.len() > host_start
        && parser::is_windows_drive_letter(&serialization[host_start..])
        && path_only_has_prefix
    {
        serialization.push('/');
    }

    Ok((host_end, host_internal))
}

#[cfg(any(unix, target_os = "redox", target_os = "wasi"))]
fn file_url_segments_to_pathbuf(
    host: Option<&str>,
    segments: str::Split<'_, char>,
) -> Result<PathBuf, ()> {
    use std::ffi::OsStr;
    #[cfg(any(unix, target_os = "redox"))]
    use std::os::unix::prelude::OsStrExt;

I have the affected paths mapped. Next I’m patching the parser to recognize `/.` as a serialized-only marker, apply/remove it after path normalization, then updating `path()`, slicing, and setters that can change the marker condition.

apply_patch

*** Begin Patch
*** Update File: /app/url/src/parser.rs
@@
-        // Anarchist URL (no authority)
-        let path_start = to_u32(self.serialization.len())?;
-        let username_end = path_start;
-        let host_start = path_start;
-        let host_end = path_start;
+        // Anarchist URL (no authority)
+        let after_port = to_u32(self.serialization.len())?;
+        let username_end = after_port;
+        let host_start = after_port;
+        let host_end = after_port;
         let host = HostInternal::None;
         let port = None;
-        let remaining = if let Some(input) = input.split_prefix('/') {
+        let (path_start, remaining) = if let Some(input) = input.split_prefix("/.") {
+            if input.starts_with("//") {
+                self.serialization.push_str("/.");
+                let path_start = to_u32(self.serialization.len())?;
+                (
+                    path_start,
+                    self.parse_path(scheme_type, &mut false, path_start as usize, input),
+                )
+            } else if let Some(input) = input.split_prefix('/') {
+                let path_start = after_port;
+                let path_start_usize = self.serialization.len();
+                self.serialization.push('/');
+                (
+                    path_start,
+                    self.parse_path(scheme_type, &mut false, path_start_usize, input),
+                )
+            } else {
+                (
+                    after_port,
+                    self.parse_cannot_be_a_base_path(Input::new(input.chars.as_str())),
+                )
+            }
+        } else if let Some(input) = input.split_prefix('/') {
             let path_start = self.serialization.len();
             self.serialization.push('/');
-            self.parse_path(scheme_type, &mut false, path_start, input)
+            (
+                after_port,
+                self.parse_path(scheme_type, &mut false, path_start, input),
+            )
         } else {
-            self.parse_cannot_be_a_base_path(input)
+            (
+                after_port,
+                self.parse_cannot_be_a_base_path(input),
+            )
         };
         self.with_query_and_fragment(
             scheme_type,
             scheme_end,
@@
-            path_start,
+            path_start,
             remaining,
         )
     }
@@
-        let (query_start, fragment_start) =
+        let path_start = self.apply_no_authority_path_marker(
+            scheme_type,
+            scheme_end,
+            username_end,
+            host_start,
+            host_end,
+            host,
+            port,
+            path_start,
+        )?;
+        let (query_start, fragment_start) =
             self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;
         Ok(Url {
             serialization: self.serialization,
@@
             fragment_start,
         })
     }
+
+    #[allow(clippy::too_many_arguments)]
+    fn apply_no_authority_path_marker(
+        &mut self,
+        scheme_type: SchemeType,
+        scheme_end: u32,
+        username_end: u32,
+        host_start: u32,
+        host_end: u32,
+        host: HostInternal,
+        port: Option<u16>,
+        mut path_start: u32,
+    ) -> ParseResult<u32> {
+        let after_port = scheme_end + 1;
+        if scheme_type != SchemeType::NotSpecial
+            || username_end != after_port
+            || host_start != after_port
+            || host_end != after_port
+            || !matches!(host, HostInternal::None)
+            || port.is_some()
+        {
+            return Ok(path_start);
+        }
+
+        let marker_present = path_start == after_port + "/.".len() as u32
+            && self.serialization[after_port as usize..path_start as usize] == *"/.";
+        if self.serialization[path_start as usize..].starts_with("//") {
+            if !marker_present {
+                self.serialization.insert_str(path_start as usize, "/.");
+                path_start += "/.".len() as u32;
+            }
+        } else if marker_present {
+            self.serialization
+                .drain(after_port as usize..path_start as usize);
+            path_start = after_port;
+        }
+
+        Ok(path_start)
+    }
*** End Patch


Exit code: 0
Wall time: 0 seconds
Output:
Success. Updated the following files:
M /app/url/src/parser.rs

shell

sed -n '459,515p' url/src/parser.rs

output

Chunk ID: 9fe547
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 538
Output:
    fn parse_non_special(
        mut self,
        input: Input<'_>,
        scheme_type: SchemeType,
        scheme_end: u32,
    ) -> ParseResult<Url> {
        // path or authority state (
        if let Some(input) = input.split_prefix("//") {
            return self.after_double_slash(input, scheme_type, scheme_end);
        }
        // Anarchist URL (no authority)
        let after_port = to_u32(self.serialization.len())?;
        let username_end = after_port;
        let host_start = after_port;
        let host_end = after_port;
        let host = HostInternal::None;
        let port = None;
        let (path_start, remaining) = if let Some(input) = input.split_prefix("/.") {
            if input.starts_with("//") {
                self.serialization.push_str("/.");
                let path_start = to_u32(self.serialization.len())?;
                (
                    path_start,
                    self.parse_path(scheme_type, &mut false, path_start as usize, input),
                )
            } else if let Some(input) = input.split_prefix('/') {
                let path_start = after_port;
                let path_start_usize = self.serialization.len();
                self.serialization.push('/');
                (
                    path_start,
                    self.parse_path(scheme_type, &mut false, path_start_usize, input),
                )
            } else {
                (
                    after_port,
                    self.parse_cannot_be_a_base_path(Input::new(input.chars.as_str())),
                )
            }
        } else if let Some(input) = input.split_prefix('/') {
            let path_start = self.serialization.len();
            self.serialization.push('/');
            (
                after_port,
                self.parse_path(scheme_type, &mut false, path_start, input),
            )
        } else {
            (
                after_port,
                self.parse_cannot_be_a_base_path(input),
            )
        };
        self.with_query_and_fragment(
            scheme_type,
            scheme_end,
            username_end,
            host_start,

apply_patch

*** Begin Patch
*** Update File: /app/url/src/parser.rs
@@
-        let (path_start, remaining) = if let Some(input) = input.split_prefix("/.") {
-            if input.starts_with("//") {
-                self.serialization.push_str("/.");
-                let path_start = to_u32(self.serialization.len())?;
-                (
-                    path_start,
-                    self.parse_path(scheme_type, &mut false, path_start as usize, input),
-                )
-            } else if let Some(input) = input.split_prefix('/') {
-                let path_start = after_port;
-                let path_start_usize = self.serialization.len();
-                self.serialization.push('/');
-                (
-                    path_start,
-                    self.parse_path(scheme_type, &mut false, path_start_usize, input),
-                )
-            } else {
-                (
-                    after_port,
-                    self.parse_cannot_be_a_base_path(Input::new(input.chars.as_str())),
-                )
-            }
+        let (path_start, remaining) =
+            if let Some(input) = input.split_prefix("/.").filter(|input| input.starts_with("//")) {
+                self.serialization.push_str("/.");
+                let path_start = to_u32(self.serialization.len())?;
+                (
+                    path_start,
+                    self.parse_path(scheme_type, &mut false, path_start as usize, input),
+                )
         } else if let Some(input) = input.split_prefix('/') {
             let path_start = self.serialization.len();
             self.serialization.push('/');
             (
                 after_port,
*** End Patch


Exit code: 0
Wall time: 0 seconds
Output:
Success. Updated the following files:
M /app/url/src/parser.rs

shell

sed -n '472,505p' url/src/parser.rs && sed -n '1350,1415p' url/src/parser.rs

output

Chunk ID: 79795f
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 766
Output:
        let host_start = after_port;
        let host_end = after_port;
        let host = HostInternal::None;
        let port = None;
        let (path_start, remaining) =
            if let Some(input) = input.split_prefix("/.").filter(|input| input.starts_with("//")) {
                self.serialization.push_str("/.");
                let path_start = to_u32(self.serialization.len())?;
                (
                    path_start,
                    self.parse_path(scheme_type, &mut false, path_start as usize, input),
                )
        } else if let Some(input) = input.split_prefix('/') {
            let path_start = self.serialization.len();
            self.serialization.push('/');
            (
                after_port,
                self.parse_path(scheme_type, &mut false, path_start, input),
            )
        } else {
            (
                after_port,
                self.parse_cannot_be_a_base_path(input),
            )
        };
        self.with_query_and_fragment(
            scheme_type,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
                }
                Some((c, utf8_c)) => {
                    self.check_url_code_point(c, &input);
                    self.serialization
                        .extend(utf8_percent_encode(utf8_c, CONTROLS));
                }
                None => return input,
            }
        }
    }

    #[allow(clippy::too_many_arguments)]
    fn with_query_and_fragment(
        mut self,
        scheme_type: SchemeType,
        scheme_end: u32,
        username_end: u32,
        host_start: u32,
        host_end: u32,
        host: HostInternal,
        port: Option<u16>,
        path_start: u32,
        remaining: Input<'_>,
    ) -> ParseResult<Url> {
        let path_start = self.apply_no_authority_path_marker(
            scheme_type,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
        )?;
        let (query_start, fragment_start) =
            self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;
        Ok(Url {
            serialization: self.serialization,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            query_start,
            fragment_start,
        })
    }

    #[allow(clippy::too_many_arguments)]
    fn apply_no_authority_path_marker(
        &mut self,
        scheme_type: SchemeType,
        scheme_end: u32,
        username_end: u32,
        host_start: u32,
        host_end: u32,
        host: HostInternal,
        port: Option<u16>,
        mut path_start: u32,
    ) -> ParseResult<u32> {
        let after_port = scheme_end + 1;
        if scheme_type != SchemeType::NotSpecial
            || username_end != after_port
            || host_start != after_port

shell

sed -n '490,530p' url/src/parser.rs

output

Chunk ID: 538f0d
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 360
Output:
            )
        } else {
            (
                after_port,
                self.parse_cannot_be_a_base_path(input),
            )
        };
        self.with_query_and_fragment(
            scheme_type,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            remaining,
        )
    }

    fn parse_file(
        mut self,
        input: Input<'_>,
        scheme_type: SchemeType,
        base_file_url: Option<&Url>,
    ) -> ParseResult<Url> {
        use crate::SyntaxViolation::Backslash;
        // file state
        debug_assert!(self.serialization.is_empty());
        let (first_char, input_after_first_char) = input.split_first();
        if matches!(first_char, Some('/') | Some('\\')) {
            self.log_violation_if(SyntaxViolation::Backslash, || first_char == Some('\\'));
            // file slash state
            let (next_char, input_after_next_char) = input_after_first_char.split_first();
            if matches!(next_char, Some('/') | Some('\\')) {
                self.log_violation_if(Backslash, || next_char == Some('\\'));
                // file host state
                self.serialization.push_str("file://");
                let scheme_end = "file".len() as u32;
                let host_start = "file://".len() as u32;
                let (path_start, mut host, remaining) =

apply_patch

*** Begin Patch
*** Update File: /app/url/src/lib.rs
@@
-            assert_eq!(self.path_start, self.scheme_end + 1);
+            assert_eq!(self.username_end, self.scheme_end + 1);
+            assert_eq!(self.host_start, self.scheme_end + 1);
+            assert_eq!(self.host_end, self.scheme_end + 1);
+            if let Some(marker_start) = self.no_authority_path_marker_start() {
+                assert_eq!(marker_start, self.scheme_end + 1);
+                assert_eq!(self.path_start, marker_start + "/.".len() as u32);
+                assert_eq!(self.slice(marker_start..self.path_start), "/.");
+                assert!(self.path().starts_with("//"));
+            } else {
+                assert_eq!(self.path_start, self.scheme_end + 1);
+            }
         }
@@
     pub fn path(&self) -> &str {
         match (self.query_start, self.fragment_start) {
             (None, None) => self.slice(self.path_start..),
             (Some(next_component_start), _) | (None, Some(next_component_start)) => {
                 self.slice(self.path_start..next_component_start)
@@
     pub fn set_path(&mut self, mut path: &str) {
         let after_path = self.take_after_path();
         let old_after_path_pos = to_u32(self.serialization.len()).unwrap();
         let cannot_be_a_base = self.cannot_be_a_base();
         let scheme_type = SchemeType::from(self.scheme());
-        self.serialization.truncate(self.path_start as usize);
+        let path_start = self
+            .no_authority_path_marker_start()
+            .unwrap_or(self.path_start);
+        self.serialization.truncate(path_start as usize);
+        self.path_start = path_start;
         self.mutate(|parser| {
             if cannot_be_a_base {
                 if path.starts_with('/') {
                     parser.serialization.push_str("%2F");
                     path = &path[1..];
@@
             }
         });
         self.restore_after_path(old_after_path_pos, &after_path);
+        self.recompute_no_authority_path_marker();
     }
@@
-        }
+        }
+        self.recompute_no_authority_path_marker();
         Ok(())
     }
@@
-        let old_suffix_pos = if opt_new_port.is_some() {
+        let old_suffix_pos = if opt_new_port.is_some() {
             self.path_start
+        } else if self.no_authority_path_marker_start().is_some() {
+            self.path_start
         } else {
             self.host_end
         };
@@
     // Private helper methods:
+
+    pub(crate) fn no_authority_path_marker_start(&self) -> Option<u32> {
+        let after_port = self.scheme_end + 1;
+        if SchemeType::from(self.scheme()) == SchemeType::NotSpecial
+            && self.username_end == after_port
+            && self.host_start == after_port
+            && self.host_end == after_port
+            && matches!(self.host, HostInternal::None)
+            && self.port.is_none()
+            && self.path_start == after_port + "/.".len() as u32
+            && self.slice(after_port..self.path_start) == "/."
+        {
+            Some(after_port)
+        } else {
+            None
+        }
+    }
+
+    fn recompute_no_authority_path_marker(&mut self) {
+        let after_port = self.scheme_end + 1;
+        let marker_present = self.no_authority_path_marker_start().is_some();
+        if SchemeType::from(self.scheme()) != SchemeType::NotSpecial
+            || self.username_end != after_port
+            || self.host_start != after_port
+            || self.host_end != after_port
+            || !matches!(self.host, HostInternal::None)
+            || self.port.is_some()
+            || !(self.path_start == after_port
+                || self.path_start == after_port + "/.".len() as u32)
+        {
+            return;
+        }
+
+        let after_path = match (self.query_start, self.fragment_start) {
+            (Some(i), _) | (None, Some(i)) => i as usize,
+            (None, None) => self.serialization.len(),
+        };
+        let path_starts_with_double_slash =
+            self.serialization[self.path_start as usize..after_path].starts_with("//");
+        if path_starts_with_double_slash && !marker_present {
+            self.serialization
+                .insert_str(self.path_start as usize, "/.");
+            self.path_start += "/.".len() as u32;
+            if let Some(ref mut index) = self.query_start {
+                *index += "/.".len() as u32;
+            }
+            if let Some(ref mut index) = self.fragment_start {
+                *index += "/.".len() as u32;
+            }
+        } else if !path_starts_with_double_slash && marker_present {
+            self.serialization
+                .drain(after_port as usize..self.path_start as usize);
+            self.path_start = after_port;
+            if let Some(ref mut index) = self.query_start {
+                *index -= "/.".len() as u32;
+            }
+            if let Some(ref mut index) = self.fragment_start {
+                *index -= "/.".len() as u32;
+            }
+        }
+    }
 
     #[inline]
     fn slice<R>(&self, range: R) -> &str
*** End Patch


Exit code: 0
Wall time: 0 seconds
Output:
Success. Updated the following files:
M /app/url/src/lib.rs

The main representation changes are in place. I’m doing a compile pass now to catch type/privacy issues, then I’ll add focused tests for parse, slicing, and joins.

shell

sed -n '470,500p' url/src/parser.rs

output

Chunk ID: 77cbf3
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 299
Output:
        let after_port = to_u32(self.serialization.len())?;
        let username_end = after_port;
        let host_start = after_port;
        let host_end = after_port;
        let host = HostInternal::None;
        let port = None;
        let (path_start, remaining) =
            if let Some(input) = input.split_prefix("/.").filter(|input| input.starts_with("//")) {
                self.serialization.push_str("/.");
                let path_start = to_u32(self.serialization.len())?;
                (
                    path_start,
                    self.parse_path(scheme_type, &mut false, path_start as usize, input),
                )
        } else if let Some(input) = input.split_prefix('/') {
            let path_start = self.serialization.len();
            self.serialization.push('/');
            (
                after_port,
                self.parse_path(scheme_type, &mut false, path_start, input),
            )
        } else {
            (
                after_port,
                self.parse_cannot_be_a_base_path(input),
            )
        };
        self.with_query_and_fragment(
            scheme_type,
            scheme_end,
            username_end,

shell

sed -n '800,870p' url/src/lib.rs

output

Chunk ID: 23928e
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 529
Output:
    #[inline]
    pub fn origin(&self) -> Origin {
        origin::url_origin(self)
    }

    /// Return the scheme of this URL, lower-cased, as an ASCII string without the ':' delimiter.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("file:///tmp/foo")?;
    /// assert_eq!(url.scheme(), "file");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    pub fn scheme(&self) -> &str {
        self.slice(..self.scheme_end)
    }

    /// Return whether the URL has an 'authority',
    /// which can contain a username, password, host, and port number.
    ///
    /// URLs that do *not* are either path-only like `unix:/run/foo.socket`
    /// or cannot-be-a-base like `data:text/plain,Stuff`.
    ///
    /// See also the `authority` method.
    ///
    /// # Examples
    ///
    /// ```
    /// use url::Url;
    /// # use url::ParseError;
    ///
    /// # fn run() -> Result<(), ParseError> {
    /// let url = Url::parse("ftp://rms@example.com")?;
    /// assert!(url.has_authority());
    ///
    /// let url = Url::parse("unix:/run/foo.socket")?;
    /// assert!(!url.has_authority());
    ///
    /// let url = Url::parse("data:text/plain,Stuff")?;
    /// assert!(!url.has_authority());
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    #[inline]
    pub fn has_authority(&self) -> bool {
        debug_assert!(self.byte_at(self.scheme_end) == b':');
        self.slice(self.scheme_end..).starts_with("://")
    }

    /// Return the authority of this URL as an ASCII string.
    ///
    /// Non-ASCII domains are punycode-encoded per IDNA if this is the host
    /// of a special URL, or percent encoded for non-special URLs.
    /// IPv6 addresses are given between `[` and `]` brackets.
    /// Ports are omitted if they match the well known port of a special URL.
    ///
    /// Username and password are percent-encoded.
    ///
    /// See also the `has_authority` method.
    ///
    /// # Examples
    ///

shell

sed -n '1628,1660p' url/src/lib.rs

output

Chunk ID: 9b5d59
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 369
Output:
    /// let mut url = Url::parse("https://example.com")?;
    /// url.set_path("api/some comments");
    /// assert_eq!(url.as_str(), "https://example.com/api/some%20comments");
    /// assert_eq!(url.path(), "/api/some%20comments");
    ///
    /// // `set_path` will not double percent-encode the string if it's already percent-encoded.
    /// let mut url = Url::parse("https://example.com")?;
    /// url.set_path("api/some%20comments");
    /// assert_eq!(url.as_str(), "https://example.com/api/some%20comments");
    /// assert_eq!(url.path(), "/api/some%20comments");
    ///
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn set_path(&mut self, mut path: &str) {
        let after_path = self.take_after_path();
        let old_after_path_pos = to_u32(self.serialization.len()).unwrap();
        let cannot_be_a_base = self.cannot_be_a_base();
        let scheme_type = SchemeType::from(self.scheme());
        let path_start = self
            .no_authority_path_marker_start()
            .unwrap_or(self.path_start);
        self.serialization.truncate(path_start as usize);
        self.path_start = path_start;
        self.mutate(|parser| {
            if cannot_be_a_base {
                if path.starts_with('/') {
                    parser.serialization.push_str("%2F");
                    path = &path[1..];
                }
                parser.parse_cannot_be_a_base_path(parser::Input::new(path));
            } else {

shell

sed -n '1870,1945p' url/src/lib.rs

output

Chunk ID: 7bbe50
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 776
Output:
    /// let mut url = Url::parse("mailto:rms@example.net")?;
    ///
    /// let result = url.set_host(Some("rust-lang.org"));
    /// assert!(result.is_err());
    /// assert_eq!(url.as_str(), "mailto:rms@example.net");
    ///
    /// let result = url.set_host(None);
    /// assert!(result.is_err());
    /// assert_eq!(url.as_str(), "mailto:rms@example.net");
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// # Errors
    ///
    /// If this URL is cannot-be-a-base or there is an error parsing the given `host`,
    /// a [`ParseError`] variant will be returned.
    ///
    /// [`ParseError`]: enum.ParseError.html
    pub fn set_host(&mut self, host: Option<&str>) -> Result<(), ParseError> {
        if self.cannot_be_a_base() {
            return Err(ParseError::SetHostOnCannotBeABaseUrl);
        }

        let scheme_type = SchemeType::from(self.scheme());

        if let Some(host) = host {
            if host.is_empty() && scheme_type.is_special() && !scheme_type.is_file() {
                return Err(ParseError::EmptyHost);
            }
            let mut host_substr = host;
            // Otherwise, if c is U+003A (:) and the [] flag is unset, then
            if !host.starts_with('[') || !host.ends_with(']') {
                match host.find(':') {
                    Some(0) => {
                        // If buffer is the empty string, validation error, return failure.
                        return Err(ParseError::InvalidDomainCharacter);
                    }
                    // Let host be the result of host parsing buffer
                    Some(colon_index) => {
                        host_substr = &host[..colon_index];
                    }
                    None => {}
                }
            }
            if SchemeType::from(self.scheme()).is_special() {
                self.set_host_internal(Host::parse(host_substr)?, None);
            } else {
                self.set_host_internal(Host::parse_opaque(host_substr)?, None);
            }
        } else if self.has_host() {
            if scheme_type.is_special() && !scheme_type.is_file() {
                return Err(ParseError::EmptyHost);
            } else if self.serialization.len() == self.path_start as usize {
                self.serialization.push('/');
            }
            debug_assert!(self.byte_at(self.scheme_end) == b':');
            debug_assert!(self.byte_at(self.path_start) == b'/');

            let new_path_start = if scheme_type.is_file() {
                self.scheme_end + 3
            } else {
                self.scheme_end + 1
            };

            self.serialization
                .drain(new_path_start as usize..self.path_start as usize);
            let offset = self.path_start - new_path_start;
            self.path_start = new_path_start;
            self.username_end = new_path_start;
            self.host_start = new_path_start;
            self.host_end = new_path_start;
            self.port = None;
            if let Some(ref mut index) = self.query_start {
                *index -= offset

shell

sed -n '1945,1975p' url/src/lib.rs

output

Chunk ID: aa3ab2
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 315
Output:
                *index -= offset
            }
            if let Some(ref mut index) = self.fragment_start {
                *index -= offset
            }
        }
        self.recompute_no_authority_path_marker();
        Ok(())
    }

    /// opt_new_port: None means leave unchanged, Some(None) means remove any port number.
    fn set_host_internal(&mut self, host: Host<String>, opt_new_port: Option<Option<u16>>) {
        let old_suffix_pos = if opt_new_port.is_some() {
            self.path_start
        } else if self.no_authority_path_marker_start().is_some() {
            self.path_start
        } else {
            self.host_end
        };
        let suffix = self.slice(old_suffix_pos..).to_owned();
        self.serialization.truncate(self.host_start as usize);
        if !self.has_authority() {
            debug_assert!(self.slice(self.scheme_end..self.host_start) == ":");
            debug_assert!(self.username_end == self.host_start);
            self.serialization.push('/');
            self.serialization.push('/');
            self.username_end += 2;
            self.host_start += 2;
        }
        write!(&mut self.serialization, "{}", host).unwrap();
        self.host_end = to_u32(self.serialization.len()).unwrap();

shell

sed -n '2560,2635p' url/src/lib.rs

output

Chunk ID: 6d873a
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 793
Output:
    /// `file:` URLs may have a non-local host),
    /// or if `Path::new_opt()` returns `None`.
    /// (That is, if the percent-decoded path contains a NUL byte or,
    /// for a Windows path, is not UTF-8.)
    #[inline]
    #[cfg(any(unix, windows, target_os = "redox", target_os = "wasi"))]
    #[allow(clippy::result_unit_err)]
    pub fn to_file_path(&self) -> Result<PathBuf, ()> {
        if let Some(segments) = self.path_segments() {
            let host = match self.host() {
                None | Some(Host::Domain("localhost")) => None,
                Some(_) if cfg!(windows) && self.scheme() == "file" => {
                    Some(&self.serialization[self.host_start as usize..self.host_end as usize])
                }
                _ => return Err(()),
            };

            return file_url_segments_to_pathbuf(host, segments);
        }
        Err(())
    }

    // Private helper methods:

    pub(crate) fn no_authority_path_marker_start(&self) -> Option<u32> {
        let after_port = self.scheme_end + 1;
        if SchemeType::from(self.scheme()) == SchemeType::NotSpecial
            && self.username_end == after_port
            && self.host_start == after_port
            && self.host_end == after_port
            && matches!(self.host, HostInternal::None)
            && self.port.is_none()
            && self.path_start == after_port + "/.".len() as u32
            && self.slice(after_port..self.path_start) == "/."
        {
            Some(after_port)
        } else {
            None
        }
    }

    fn recompute_no_authority_path_marker(&mut self) {
        let after_port = self.scheme_end + 1;
        let marker_present = self.no_authority_path_marker_start().is_some();
        if SchemeType::from(self.scheme()) != SchemeType::NotSpecial
            || self.username_end != after_port
            || self.host_start != after_port
            || self.host_end != after_port
            || !matches!(self.host, HostInternal::None)
            || self.port.is_some()
            || !(self.path_start == after_port
                || self.path_start == after_port + "/.".len() as u32)
        {
            return;
        }

        let after_path = match (self.query_start, self.fragment_start) {
            (Some(i), _) | (None, Some(i)) => i as usize,
            (None, None) => self.serialization.len(),
        };
        let path_starts_with_double_slash =
            self.serialization[self.path_start as usize..after_path].starts_with("//");
        if path_starts_with_double_slash && !marker_present {
            self.serialization
                .insert_str(self.path_start as usize, "/.");
            self.path_start += "/.".len() as u32;
            if let Some(ref mut index) = self.query_start {
                *index += "/.".len() as u32;
            }
            if let Some(ref mut index) = self.fragment_start {
                *index += "/.".len() as u32;
            }
        } else if !path_starts_with_double_slash && marker_present {
            self.serialization
                .drain(after_port as usize..self.path_start as usize);
            self.path_start = after_port;

shell

cargo build --locked

output

Chunk ID: 6bffc0
Wall time: 0.1987 seconds
Process exited with code 0
Original token count: 764
Output:
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> percent_encoding/src/lib.rs:462:35
    |
462 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
462 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
462 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `percent-encoding` (lib) generated 1 warning
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> form_urlencoded/src/lib.rs:403:35
    |
403 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
403 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
403 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: field `0` is never read
 --> data-url/src/forgiving_base64.rs:4:26
  |
4 | pub struct InvalidBase64(InvalidBase64Details);
  |            ------------- ^^^^^^^^^^^^^^^^^^^^
  |            |
  |            field in this struct
  |
  = help: consider removing this field
  = note: `InvalidBase64` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
  = note: `#[warn(dead_code)]` on by default

warning: field `0` is never read
 --> data-url/src/forgiving_base64.rs:8:22
  |
8 |     UnexpectedSymbol(u8),
  |     ---------------- ^^
  |     |
  |     field in this variant
  |
  = note: `InvalidBase64Details` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
help: consider changing the field to be of unit type to suppress this warning while preserving the field numbering, or remove the field
  |
8 |     UnexpectedSymbol(()),
  |                      ~~

warning: `form_urlencoded` (lib) generated 1 warning
warning: `data-url` (lib) generated 2 warnings
   Compiling url v2.3.1 (/app/url)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.33s

`cargo build --locked` already compiles with the new internals, aside from pre-existing warnings in other crates. I still need to wire `Position::AfterPort` to the marker start and lock the behavior down with tests.

apply_patch

*** Begin Patch
*** Update File: /app/url/src/slicing.rs
@@
-            Position::AfterPort => self.path_start as usize,
+            Position::AfterPort => self
+                .no_authority_path_marker_start()
+                .unwrap_or(self.path_start) as usize,
*** End Patch


Exit code: 0
Wall time: 0 seconds
Output:
Success. Updated the following files:
M /app/url/src/slicing.rs

I’m adding regression tests around the exact contract: parse round-trip, marker slicing, relative joins that keep/remove the marker, query/fragment joins, and unaffected host-bearing/special URLs.

apply_patch

*** Begin Patch
*** Update File: /app/url/tests/unit.rs
@@
-use url::{form_urlencoded, Host, Origin, Url};
+use url::{form_urlencoded, Host, Origin, Position, Url};
@@
 fn test_non_special_path3() {
     let mut db_url = url::Url::parse("postgres://postgres@localhost/").unwrap();
     assert_eq!(db_url.as_str(), "postgres://postgres@localhost/");
     db_url.set_path("/");
     assert_eq!(db_url.as_str(), "postgres://postgres@localhost/");
@@
     assert_eq!(db_url.as_str(), "postgres://postgres@localhost/foo");
     assert_eq!(db_url.path(), "/foo");
 }
+
+#[test]
+fn test_non_special_no_authority_double_slash_path_marker() {
+    let url = Url::parse("foo:/a/..//bar?x#y").unwrap();
+    assert_eq!(url.as_str(), "foo:/.//bar?x#y");
+    assert_eq!(url.host(), None);
+    assert!(!url.has_authority());
+    assert_eq!(url.path(), "//bar");
+    assert_eq!(&url[Position::AfterPort..Position::BeforePath], "/.");
+    assert_eq!(&url[Position::BeforePath..Position::AfterPath], "//bar");
+
+    let reparsed = Url::parse(url.as_str()).unwrap();
+    assert_eq!(reparsed.as_str(), url.as_str());
+    assert_eq!(reparsed.path(), url.path());
+    assert_eq!(
+        &reparsed[Position::AfterPort..Position::BeforePath],
+        "/."
+    );
+}
+
+#[test]
+fn test_non_special_no_authority_double_slash_path_marker_join() {
+    let base = Url::parse("foo:/.//a/b").unwrap();
+
+    let joined = base.join("c").unwrap();
+    assert_eq!(joined.as_str(), "foo:/.//a/c");
+    assert_eq!(joined.path(), "//a/c");
+    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "/.");
+
+    let joined = base.join("../../c").unwrap();
+    assert_eq!(joined.as_str(), "foo:/c");
+    assert_eq!(joined.path(), "/c");
+    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "");
+
+    let joined = base.join("?q").unwrap();
+    assert_eq!(joined.as_str(), "foo:/.//a/b?q");
+    assert_eq!(joined.path(), "//a/b");
+    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "/.");
+
+    let joined = base.join("#f").unwrap();
+    assert_eq!(joined.as_str(), "foo:/.//a/b#f");
+    assert_eq!(joined.path(), "//a/b");
+    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "/.");
+}
+
+#[test]
+fn test_double_slash_path_marker_not_used_with_host_or_special_scheme() {
+    let url = Url::parse("foo://host//bar").unwrap();
+    assert_eq!(url.as_str(), "foo://host//bar");
+    assert_eq!(url.path(), "//bar");
+    assert_eq!(&url[Position::AfterPort..Position::BeforePath], "");
+
+    let url = Url::parse("http://host//bar").unwrap();
+    assert_eq!(url.as_str(), "http://host//bar");
+    assert_eq!(url.path(), "//bar");
+    assert_eq!(&url[Position::AfterPort..Position::BeforePath], "");
+}
 
 #[test]
 fn test_set_scheme_to_file_with_host() {
     let mut url: Url = "http://localhost:6767/foo/bar".parse().unwrap();
*** End Patch


Exit code: 0
Wall time: 0 seconds
Output:
Success. Updated the following files:
M /app/url/tests/unit.rs

shell

cargo test -p url test_non_special_no_authority_double_slash_path_marker -- --nocapture

output

Chunk ID: fab33c
Wall time: 1.9544 seconds
Process exited with code 0
Original token count: 714
Output:
   Compiling proc-macro2 v1.0.106
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> percent_encoding/src/lib.rs:462:35
    |
462 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
462 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
462 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `percent-encoding` (lib) generated 1 warning
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> form_urlencoded/src/lib.rs:403:35
    |
403 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
403 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
403 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `form_urlencoded` (lib) generated 1 warning
   Compiling url v2.3.1 (/app/url)
   Compiling quote v1.0.45
   Compiling syn v1.0.109
   Compiling debugger_test v0.1.5
    Finished `test` profile [unoptimized + debuginfo] target(s) in 2.08s
     Running unittests src/lib.rs (target/debug/deps/url-2559718008fa8f63)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/data.rs (target/debug/deps/data-2c0f19163cfb41ae)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out; finished in 0.00s

     Running tests/unit.rs (target/debug/deps/unit-a494890561398094)

running 2 tests
test test_non_special_no_authority_double_slash_path_marker ... ok
test test_non_special_no_authority_double_slash_path_marker_join ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 59 filtered out; finished in 0.00s

shell

cargo test -p url double_slash_path_marker -- --nocapture

output

Chunk ID: 2c71a4
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 694
Output:
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> percent_encoding/src/lib.rs:462:35
    |
462 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
462 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
462 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `percent-encoding` (lib) generated 1 warning
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> form_urlencoded/src/lib.rs:403:35
    |
403 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
403 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
403 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `form_urlencoded` (lib) generated 1 warning
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.01s
     Running unittests src/lib.rs (target/debug/deps/url-2559718008fa8f63)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/data.rs (target/debug/deps/data-2c0f19163cfb41ae)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out; finished in 0.00s

     Running tests/unit.rs (target/debug/deps/unit-a494890561398094)

running 3 tests
test test_non_special_no_authority_double_slash_path_marker ... ok
test test_double_slash_path_marker_not_used_with_host_or_special_scheme ... ok
test test_non_special_no_authority_double_slash_path_marker_join ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 58 filtered out; finished in 0.00s

The targeted marker tests pass. I’m checking for any formatting drift and then I’ll run the requested locked build one final time.

shell

rg "set_host_internal" -n url/src/lib.rs

output

Chunk ID: b3ee6d
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 79
Output:
1917:                self.set_host_internal(Host::parse(host_substr)?, None);
1919:                self.set_host_internal(Host::parse_opaque(host_substr)?, None);
1956:    fn set_host_internal(&mut self, host: Host<String>, opt_new_port: Option<Option<u16>>) {
2047:        self.set_host_internal(address, None);

shell

cargo fmt --check

output

Chunk ID: 1bb359
Wall time: 0.1794 seconds
Process exited with code 1
Original token count: 35
Output:
error: 'cargo-fmt' is not installed for the toolchain '1.85.1-aarch64-unknown-linux-gnu'.
To install, run `rustup component add rustfmt`

`cargo fmt --check` can’t run because `rustfmt` is not installed in this toolchain, so I’m doing the small formatting cleanup manually and leaving that limitation noted.

apply_patch

*** Begin Patch
*** Update File: /app/url/src/parser.rs
@@
-        let (path_start, remaining) =
-            if let Some(input) = input.split_prefix("/.").filter(|input| input.starts_with("//")) {
-                self.serialization.push_str("/.");
-                let path_start = to_u32(self.serialization.len())?;
-                (
-                    path_start,
-                    self.parse_path(scheme_type, &mut false, path_start as usize, input),
-                )
+        let (path_start, remaining) = if let Some(input) =
+            input.split_prefix("/.").filter(|input| input.starts_with("//"))
+        {
+            self.serialization.push_str("/.");
+            let path_start = to_u32(self.serialization.len())?;
+            (
+                path_start,
+                self.parse_path(scheme_type, &mut false, path_start as usize, input),
+            )
         } else if let Some(input) = input.split_prefix('/') {
             let path_start = self.serialization.len();
             self.serialization.push('/');
             (
                 after_port,
@@
-            (
-                after_port,
-                self.parse_cannot_be_a_base_path(input),
-            )
+            (after_port, self.parse_cannot_be_a_base_path(input))
         };
*** End Patch


Exit code: 0
Wall time: 0 seconds
Output:
Success. Updated the following files:
M /app/url/src/parser.rs

The code is cleaned up. I’m running the full `url` crate tests now because this touches parser and slicing invariants, then I’ll rerun the requested workspace build.

shell

cargo test -p url

output

Chunk ID: 5114af
Wall time: 3.6661 seconds
Process exited with code 0
Original token count: 2168
Output:
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> percent_encoding/src/lib.rs:462:35
    |
462 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
462 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
462 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `percent-encoding` (lib) generated 1 warning
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> form_urlencoded/src/lib.rs:403:35
    |
403 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
403 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
403 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `form_urlencoded` (lib) generated 1 warning
   Compiling url v2.3.1 (/app/url)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.36s
     Running unittests src/lib.rs (target/debug/deps/url-2559718008fa8f63)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/data.rs (target/debug/deps/data-2c0f19163cfb41ae)

running 2 tests
test setters_tests ... ok
test urltestdata ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s

     Running tests/unit.rs (target/debug/deps/unit-a494890561398094)

running 61 tests
test append_empty_segment_then_mutate ... ok
test append_trailing_slash ... ok
test extend_query_pairs_then_mutate ... ok
test form_urlencoded_encoding_override ... ok
test from_str ... ok
test host ... ok
test host_serialization ... ok
test issue_197 ... ok
test issue_124 ... ok
test issue_241 ... ok
test issue_61 ... ok
test new_directory_paths ... ok
test new_file_paths ... ok
test new_path_bad_utf8 ... ok
test new_path_windows_fun ... ok
test no_panic ... ok
test parse_with_params ... ok
test path_backslash_fun ... ok
test pop_if_empty_in_bounds ... ok
test size ... ok
test test_domain ... ok
test test_authority ... ok
test test_double_slash_path_marker_not_used_with_host_or_special_scheme ... ok
test test_domain_encoding_quirks ... ok
test test_equality ... ok
test test_form_urlencoded ... ok
test test_form_serialize ... ok
test test_fragment ... ok
test test_has_authority ... ok
test test_idna ... ok
test test_leading_dots ... ok
test test_no_base_url ... ok
test test_non_special_no_authority_double_slash_path_marker ... ok
test test_make_relative ... ok
test test_non_special_path ... ok
test test_non_special_no_authority_double_slash_path_marker_join ... ok
test test_non_special_path2 ... ok
test test_non_special_path3 ... ok
test test_options_reuse ... ok
test test_origin_blob_equality ... ok
test test_origin_opaque ... ok
test test_origin_hash ... ok
test test_query ... ok
test test_origin_unicode_serialization ... ok
test test_relative ... ok
test test_relative_empty ... ok
test test_serialization ... ok
test test_set_empty_host ... ok
test test_set_empty_hostname ... ok
test test_set_host ... ok
test test_set_href ... ok
test test_set_scheme_to_file_with_host ... ok
test test_set_ip_host ... ok
test test_slicing ... ok
test test_strip_trailing_spaces_from_opaque_path ... ok
test test_syntax_violation_callback ... ok
test test_syntax_violation_callback_lifetimes ... ok
test test_syntax_violation_callback_types ... ok
test test_socket_addrs ... ok
test test_url_from_file_path ... ok
test test_windows_unc_path ... ok

test result: ok. 61 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests url

running 66 tests
test url/src/lib.rs - (line 18) ... ok
test url/src/lib.rs - (line 26) ... ok
test url/src/lib.rs - (line 57) ... ok
test url/src/lib.rs - (line 89) ... ok
test url/src/lib.rs - (line 97) ... ok
test url/src/lib.rs - ParseOptions<'a>::syntax_violation_callback (line 222) ... ok
test url/src/lib.rs - Url::authority (line 871) ... ok
test url/src/lib.rs - Url::as_str (line 555) ... ok
test url/src/lib.rs - Url::domain (line 1110) ... ok
test url/src/lib.rs - Url::cannot_be_a_base (line 907) ... ok
test url/src/lib.rs - Url::from_file_path (line 2393) ... ok
test url/src/lib.rs - Url::fragment (line 1408) ... ok
test url/src/lib.rs - Url::has_authority (line 835) ... ok
test url/src/lib.rs - Url::has_host (line 1002) ... ok
test url/src/lib.rs - Url::host (line 1075) ... ok
test url/src/lib.rs - Url::host_str (line 1036) ... ok
test url/src/lib.rs - Url::into_string (line 578) ... ok
test url/src/lib.rs - Url::join (line 361) ... ok
test url/src/lib.rs - Url::make_relative (line 396) ... ok
test url/src/lib.rs - Url::options (line 528) ... ok
test url/src/lib.rs - Url::origin (line 755) ... ok
test url/src/lib.rs - Url::origin (line 738) ... ok
test url/src/lib.rs - Url::origin (line 789) ... ok
test url/src/lib.rs - Url::origin (line 772) ... ok
test url/src/lib.rs - Url::parse (line 261) ... ok
test url/src/lib.rs - Url::parse_with_params (line 289) ... ok
test url/src/lib.rs - Url::password (line 964) ... ok
test url/src/lib.rs - Url::path (line 1257) ... ok
test url/src/lib.rs - Url::port (line 1141) ... ok
test url/src/lib.rs - Url::path_segments (line 1293) ... ok
test url/src/lib.rs - Url::query (line 1329) ... ok
test url/src/lib.rs - Url::port_or_known_default (line 1173) ... ok
test url/src/lib.rs - Url::query_pairs_mut (line 1550) ... ok
test url/src/lib.rs - Url::query_pairs (line 1368) ... ok
test url/src/lib.rs - Url::scheme (line 809) ... ok
test url/src/lib.rs - Url::set_fragment (line 1442) ... ok
test url/src/lib.rs - Url::set_host (line 1833) ... ok
test url/src/lib.rs - Url::set_host (line 1817) ... ok
test url/src/lib.rs - Url::set_host (line 1865) ... ok
test url/src/lib.rs - Url::set_host (line 1849) ... ok
test url/src/lib.rs - Url::set_ip_host (line 2023) ... ok
test url/src/lib.rs - Url::set_ip_host (line 2008) ... ok
test url/src/lib.rs - Url::set_password (line 2057) ... ok
test url/src/lib.rs - Url::set_path (line 1612) ... ok
test url/src/lib.rs - Url::set_port (line 1705) ... ok
test url/src/lib.rs - Url::set_port (line 1724) ... ok
test url/src/lib.rs - Url::set_port (line 1740) ... ok
test url/src/lib.rs - Url::set_query (line 1500) ... ok
test url/src/lib.rs - Url::set_scheme (line 2257) ... ok
test url/src/lib.rs - Url::set_scheme (line 2242) ... ok
test url/src/lib.rs - Url::set_scheme (line 2273) ... ok
test url/src/lib.rs - Url::set_scheme (line 2289) ... ok
test url/src/lib.rs - Url::set_scheme (line 2304) ... ok
test url/src/lib.rs - Url::set_scheme (line 2319) ... ok
test url/src/lib.rs - Url::set_username (line 2142) ... ok
test url/src/lib.rs - Url::set_username (line 2157) ... ok
test url/src/lib.rs - Url::socket_addrs (line 1206) - compile ... ok
test url/src/lib.rs - Url::socket_addrs (line 1213) ... ok
test url/src/lib.rs - Url::to_file_path (line 2553) ... ok
test url/src/lib.rs - Url::username (line 934) ... ok
test url/src/path_segments.rs - path_segments::PathSegmentsMut (line 20) ... ok
test url/src/path_segments.rs - path_segments::PathSegmentsMut<'a>::clear (line 79) ... ok
test url/src/path_segments.rs - path_segments::PathSegmentsMut<'a>::extend (line 182) ... ok
test url/src/path_segments.rs - path_segments::PathSegmentsMut<'a>::extend (line 202) ... ok
test url/src/slicing.rs - slicing::Position (line 44) ... ok
test url/src/path_segments.rs - path_segments::PathSegmentsMut<'a>::pop_if_empty (line 107) ... ok

test result: ok. 66 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 3.34s

The full `url` crate test suite passes, including doc tests. I’m running the exact requested `cargo build --locked` now as the final verification.

shell

cargo build --locked

output

Chunk ID: d4bbd2
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 755
Output:
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> percent_encoding/src/lib.rs:462:35
    |
462 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
462 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
462 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `percent-encoding` (lib) generated 1 warning
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> form_urlencoded/src/lib.rs:403:35
    |
403 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
403 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
403 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `form_urlencoded` (lib) generated 1 warning
warning: field `0` is never read
 --> data-url/src/forgiving_base64.rs:4:26
  |
4 | pub struct InvalidBase64(InvalidBase64Details);
  |            ------------- ^^^^^^^^^^^^^^^^^^^^
  |            |
  |            field in this struct
  |
  = help: consider removing this field
  = note: `InvalidBase64` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
  = note: `#[warn(dead_code)]` on by default

warning: field `0` is never read
 --> data-url/src/forgiving_base64.rs:8:22
  |
8 |     UnexpectedSymbol(u8),
  |     ---------------- ^^
  |     |
  |     field in this variant
  |
  = note: `InvalidBase64Details` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
help: consider changing the field to be of unit type to suppress this warning while preserving the field numbering, or remove the field
  |
8 |     UnexpectedSymbol(()),
  |                      ~~

warning: `data-url` (lib) generated 2 warnings
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.01s

The locked workspace build passes. I’m doing one final changed-file review so I can summarize precisely what moved and note the existing warnings separately from this change.

shell

sed -n '459,515p' url/src/parser.rs

output

Chunk ID: fa1061
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 471
Output:
    fn parse_non_special(
        mut self,
        input: Input<'_>,
        scheme_type: SchemeType,
        scheme_end: u32,
    ) -> ParseResult<Url> {
        // path or authority state (
        if let Some(input) = input.split_prefix("//") {
            return self.after_double_slash(input, scheme_type, scheme_end);
        }
        // Anarchist URL (no authority)
        let after_port = to_u32(self.serialization.len())?;
        let username_end = after_port;
        let host_start = after_port;
        let host_end = after_port;
        let host = HostInternal::None;
        let port = None;
        let (path_start, remaining) = if let Some(input) =
            input.split_prefix("/.").filter(|input| input.starts_with("//"))
        {
            self.serialization.push_str("/.");
            let path_start = to_u32(self.serialization.len())?;
            (
                path_start,
                self.parse_path(scheme_type, &mut false, path_start as usize, input),
            )
        } else if let Some(input) = input.split_prefix('/') {
            let path_start = self.serialization.len();
            self.serialization.push('/');
            (
                after_port,
                self.parse_path(scheme_type, &mut false, path_start, input),
            )
        } else {
            (after_port, self.parse_cannot_be_a_base_path(input))
        };
        self.with_query_and_fragment(
            scheme_type,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            remaining,
        )
    }

    fn parse_file(
        mut self,
        input: Input<'_>,
        scheme_type: SchemeType,
        base_file_url: Option<&Url>,
    ) -> ParseResult<Url> {
        use crate::SyntaxViolation::Backslash;
        // file state

shell

sed -n '1350,1435p' url/src/parser.rs

output

Chunk ID: 942b91
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 648
Output:
                    self.check_url_code_point(c, &input);
                    self.serialization
                        .extend(utf8_percent_encode(utf8_c, CONTROLS));
                }
                None => return input,
            }
        }
    }

    #[allow(clippy::too_many_arguments)]
    fn with_query_and_fragment(
        mut self,
        scheme_type: SchemeType,
        scheme_end: u32,
        username_end: u32,
        host_start: u32,
        host_end: u32,
        host: HostInternal,
        port: Option<u16>,
        path_start: u32,
        remaining: Input<'_>,
    ) -> ParseResult<Url> {
        let path_start = self.apply_no_authority_path_marker(
            scheme_type,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
        )?;
        let (query_start, fragment_start) =
            self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;
        Ok(Url {
            serialization: self.serialization,
            scheme_end,
            username_end,
            host_start,
            host_end,
            host,
            port,
            path_start,
            query_start,
            fragment_start,
        })
    }

    #[allow(clippy::too_many_arguments)]
    fn apply_no_authority_path_marker(
        &mut self,
        scheme_type: SchemeType,
        scheme_end: u32,
        username_end: u32,
        host_start: u32,
        host_end: u32,
        host: HostInternal,
        port: Option<u16>,
        mut path_start: u32,
    ) -> ParseResult<u32> {
        let after_port = scheme_end + 1;
        if scheme_type != SchemeType::NotSpecial
            || username_end != after_port
            || host_start != after_port
            || host_end != after_port
            || !matches!(host, HostInternal::None)
            || port.is_some()
        {
            return Ok(path_start);
        }

        let marker_present = path_start == after_port + "/.".len() as u32
            && self.serialization[after_port as usize..path_start as usize] == *"/.";
        if self.serialization[path_start as usize..].starts_with("//") {
            if !marker_present {
                self.serialization.insert_str(path_start as usize, "/.");
                path_start += "/.".len() as u32;
            }
        } else if marker_present {
            self.serialization
                .drain(after_port as usize..path_start as usize);
            path_start = after_port;
        }

        Ok(path_start)
    }

shell

sed -n '420,470p' url/src/lib.rs && sed -n '1628,1660p' url/src/lib.rs && sed -n '2568,2638p' url/src/lib.rs

output

Chunk ID: 531e41
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 1531
Output:
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    ///
    /// # Errors
    ///
    /// If this URL can't be a base for the given URL, `None` is returned.
    /// This is for example the case if the scheme, host or port are not the same.
    ///
    /// [`join`]: #method.join
    pub fn make_relative(&self, url: &Url) -> Option<String> {
        if self.cannot_be_a_base() {
            return None;
        }

        // Scheme, host and port need to be the same
        if self.scheme() != url.scheme() || self.host() != url.host() || self.port() != url.port() {
            return None;
        }

        // We ignore username/password at this point

        // The path has to be transformed
        let mut relative = String::new();

        // Extract the filename of both URIs, these need to be handled separately
        fn extract_path_filename(s: &str) -> (&str, &str) {
            let last_slash_idx = s.rfind('/').unwrap_or(0);
            let (path, filename) = s.split_at(last_slash_idx);
            if filename.is_empty() {
                (path, "")
            } else {
                (path, &filename[1..])
            }
        }

        let (base_path, base_filename) = extract_path_filename(self.path());
        let (url_path, url_filename) = extract_path_filename(url.path());

        let mut base_path = base_path.split('/').peekable();
        let mut url_path = url_path.split('/').peekable();

        // Skip over the common prefix
        while base_path.peek().is_some() && base_path.peek() == url_path.peek() {
            base_path.next();
            url_path.next();
        }

        // Add `..` segments for the remainder of the base path
        for base_path_segment in base_path {
    /// let mut url = Url::parse("https://example.com")?;
    /// url.set_path("api/some comments");
    /// assert_eq!(url.as_str(), "https://example.com/api/some%20comments");
    /// assert_eq!(url.path(), "/api/some%20comments");
    ///
    /// // `set_path` will not double percent-encode the string if it's already percent-encoded.
    /// let mut url = Url::parse("https://example.com")?;
    /// url.set_path("api/some%20comments");
    /// assert_eq!(url.as_str(), "https://example.com/api/some%20comments");
    /// assert_eq!(url.path(), "/api/some%20comments");
    ///
    /// # Ok(())
    /// # }
    /// # run().unwrap();
    /// ```
    pub fn set_path(&mut self, mut path: &str) {
        let after_path = self.take_after_path();
        let old_after_path_pos = to_u32(self.serialization.len()).unwrap();
        let cannot_be_a_base = self.cannot_be_a_base();
        let scheme_type = SchemeType::from(self.scheme());
        let path_start = self
            .no_authority_path_marker_start()
            .unwrap_or(self.path_start);
        self.serialization.truncate(path_start as usize);
        self.path_start = path_start;
        self.mutate(|parser| {
            if cannot_be_a_base {
                if path.starts_with('/') {
                    parser.serialization.push_str("%2F");
                    path = &path[1..];
                }
                parser.parse_cannot_be_a_base_path(parser::Input::new(path));
            } else {
        if let Some(segments) = self.path_segments() {
            let host = match self.host() {
                None | Some(Host::Domain("localhost")) => None,
                Some(_) if cfg!(windows) && self.scheme() == "file" => {
                    Some(&self.serialization[self.host_start as usize..self.host_end as usize])
                }
                _ => return Err(()),
            };

            return file_url_segments_to_pathbuf(host, segments);
        }
        Err(())
    }

    // Private helper methods:

    pub(crate) fn no_authority_path_marker_start(&self) -> Option<u32> {
        let after_port = self.scheme_end + 1;
        if SchemeType::from(self.scheme()) == SchemeType::NotSpecial
            && self.username_end == after_port
            && self.host_start == after_port
            && self.host_end == after_port
            && matches!(self.host, HostInternal::None)
            && self.port.is_none()
            && self.path_start == after_port + "/.".len() as u32
            && self.slice(after_port..self.path_start) == "/."
        {
            Some(after_port)
        } else {
            None
        }
    }

    fn recompute_no_authority_path_marker(&mut self) {
        let after_port = self.scheme_end + 1;
        let marker_present = self.no_authority_path_marker_start().is_some();
        if SchemeType::from(self.scheme()) != SchemeType::NotSpecial
            || self.username_end != after_port
            || self.host_start != after_port
            || self.host_end != after_port
            || !matches!(self.host, HostInternal::None)
            || self.port.is_some()
            || !(self.path_start == after_port
                || self.path_start == after_port + "/.".len() as u32)
        {
            return;
        }

        let after_path = match (self.query_start, self.fragment_start) {
            (Some(i), _) | (None, Some(i)) => i as usize,
            (None, None) => self.serialization.len(),
        };
        let path_starts_with_double_slash =
            self.serialization[self.path_start as usize..after_path].starts_with("//");
        if path_starts_with_double_slash && !marker_present {
            self.serialization
                .insert_str(self.path_start as usize, "/.");
            self.path_start += "/.".len() as u32;
            if let Some(ref mut index) = self.query_start {
                *index += "/.".len() as u32;
            }
            if let Some(ref mut index) = self.fragment_start {
                *index += "/.".len() as u32;
            }
        } else if !path_starts_with_double_slash && marker_present {
            self.serialization
                .drain(after_port as usize..self.path_start as usize);
            self.path_start = after_port;
            if let Some(ref mut index) = self.query_start {
                *index -= "/.".len() as u32;
            }

shell

sed -n '148,158p' url/src/slicing.rs && sed -n '925,995p' url/tests/unit.rs

output

Chunk ID: e6c6ce
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 765
Output:
                    self.host_end as usize
                }
            }

            Position::AfterPort => self
                .no_authority_path_marker_start()
                .unwrap_or(self.path_start) as usize,

            Position::BeforePath => self.path_start as usize,

            Position::AfterPath => match (self.query_start, self.fragment_start) {
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/foo");
    db_url.set_path("/bar");
    assert_eq!(db_url.path(), "/bar");
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/bar");
}

#[test]
fn test_non_special_path3() {
    let mut db_url = url::Url::parse("postgres://postgres@localhost/").unwrap();
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/");
    db_url.set_path("/");
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/");
    assert_eq!(db_url.path(), "/");
    db_url.set_path("/foo");
    assert_eq!(db_url.as_str(), "postgres://postgres@localhost/foo");
    assert_eq!(db_url.path(), "/foo");
}

#[test]
fn test_non_special_no_authority_double_slash_path_marker() {
    let url = Url::parse("foo:/a/..//bar?x#y").unwrap();
    assert_eq!(url.as_str(), "foo:/.//bar?x#y");
    assert_eq!(url.host(), None);
    assert!(!url.has_authority());
    assert_eq!(url.path(), "//bar");
    assert_eq!(&url[Position::AfterPort..Position::BeforePath], "/.");
    assert_eq!(&url[Position::BeforePath..Position::AfterPath], "//bar");

    let reparsed = Url::parse(url.as_str()).unwrap();
    assert_eq!(reparsed.as_str(), url.as_str());
    assert_eq!(reparsed.path(), url.path());
    assert_eq!(
        &reparsed[Position::AfterPort..Position::BeforePath],
        "/."
    );
}

#[test]
fn test_non_special_no_authority_double_slash_path_marker_join() {
    let base = Url::parse("foo:/.//a/b").unwrap();

    let joined = base.join("c").unwrap();
    assert_eq!(joined.as_str(), "foo:/.//a/c");
    assert_eq!(joined.path(), "//a/c");
    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "/.");

    let joined = base.join("../../c").unwrap();
    assert_eq!(joined.as_str(), "foo:/c");
    assert_eq!(joined.path(), "/c");
    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "");

    let joined = base.join("?q").unwrap();
    assert_eq!(joined.as_str(), "foo:/.//a/b?q");
    assert_eq!(joined.path(), "//a/b");
    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "/.");

    let joined = base.join("#f").unwrap();
    assert_eq!(joined.as_str(), "foo:/.//a/b#f");
    assert_eq!(joined.path(), "//a/b");
    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "/.");
}

#[test]
fn test_double_slash_path_marker_not_used_with_host_or_special_scheme() {
    let url = Url::parse("foo://host//bar").unwrap();
    assert_eq!(url.as_str(), "foo://host//bar");
    assert_eq!(url.path(), "//bar");
    assert_eq!(&url[Position::AfterPort..Position::BeforePath], "");

    let url = Url::parse("http://host//bar").unwrap();
    assert_eq!(url.as_str(), "http://host//bar");

apply_patch

*** Begin Patch
*** Update File: /app/url/src/parser.rs
@@
-        let marker_present = path_start == after_port + "/.".len() as u32
-            && self.serialization[after_port as usize..path_start as usize] == *"/.";
+        let marker_present = path_start == after_port + "/.".len() as u32
+            && &self.serialization[after_port as usize..path_start as usize] == "/.";
*** End Patch


Exit code: 0
Wall time: 0 seconds
Output:
Success. Updated the following files:
M /app/url/src/parser.rs

I made one readability-only cleanup in the marker check. Since that touched compiled code, I’m rerunning the requested locked build once more.

shell

cargo build --locked

output

Chunk ID: 830fcc
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 764
Output:
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> percent_encoding/src/lib.rs:462:35
    |
462 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
462 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
462 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `percent-encoding` (lib) generated 1 warning
warning: ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
   --> form_urlencoded/src/lib.rs:403:35
    |
403 |                     debug_assert!(raw_utf8 == &*bytes as *const [u8]);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(ambiguous_wide_pointer_comparisons)]` on by default
help: use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
    |
403 |                     debug_assert!(std::ptr::addr_eq(raw_utf8, &*bytes as *const [u8]));
    |                                   ++++++++++++++++++        ~                       +
help: use explicit `std::ptr::eq` method to compare metadata and addresses
    |
403 |                     debug_assert!(std::ptr::eq(raw_utf8, &*bytes as *const [u8]));
    |                                   +++++++++++++        ~                       +

warning: `form_urlencoded` (lib) generated 1 warning
   Compiling url v2.3.1 (/app/url)
warning: field `0` is never read
 --> data-url/src/forgiving_base64.rs:4:26
  |
4 | pub struct InvalidBase64(InvalidBase64Details);
  |            ------------- ^^^^^^^^^^^^^^^^^^^^
  |            |
  |            field in this struct
  |
  = help: consider removing this field
  = note: `InvalidBase64` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
  = note: `#[warn(dead_code)]` on by default

warning: field `0` is never read
 --> data-url/src/forgiving_base64.rs:8:22
  |
8 |     UnexpectedSymbol(u8),
  |     ---------------- ^^
  |     |
  |     field in this variant
  |
  = note: `InvalidBase64Details` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
help: consider changing the field to be of unit type to suppress this warning while preserving the field numbering, or remove the field
  |
8 |     UnexpectedSymbol(()),
  |                      ~~

warning: `data-url` (lib) generated 2 warnings
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.10s

shell

rg -n "apply_no_authority_path_marker|no_authority_path_marker_start|recompute_no_authority_path_marker|Position::AfterPort|test_non_special_no_authority_double_slash_path_marker" url/src/parser.rs url/src/lib.rs url/src/slicing.rs url/tests/unit.rs

output

Chunk ID: b816cf
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 491
Output:
url/src/parser.rs:1372:        let path_start = self.apply_no_authority_path_marker(
url/src/parser.rs:1399:    fn apply_no_authority_path_marker(
url/src/slicing.rs:49:/// let authority: &str = &some_url[Position::BeforeUsername..Position::AfterPort];
url/src/slicing.rs:152:            Position::AfterPort => self
url/src/slicing.rs:153:                .no_authority_path_marker_start()
url/src/lib.rs:689:            if let Some(marker_start) = self.no_authority_path_marker_start() {
url/src/lib.rs:1649:            .no_authority_path_marker_start()
url/src/lib.rs:1666:        self.recompute_no_authority_path_marker();
url/src/lib.rs:1951:        self.recompute_no_authority_path_marker();
url/src/lib.rs:1959:        } else if self.no_authority_path_marker_start().is_some() {
url/src/lib.rs:2584:    pub(crate) fn no_authority_path_marker_start(&self) -> Option<u32> {
url/src/lib.rs:2601:    fn recompute_no_authority_path_marker(&mut self) {
url/src/lib.rs:2603:        let marker_present = self.no_authority_path_marker_start().is_some();
url/tests/unit.rs:944:fn test_non_special_no_authority_double_slash_path_marker() {
url/tests/unit.rs:950:    assert_eq!(&url[Position::AfterPort..Position::BeforePath], "/.");
url/tests/unit.rs:957:        &reparsed[Position::AfterPort..Position::BeforePath],
url/tests/unit.rs:963:fn test_non_special_no_authority_double_slash_path_marker_join() {
url/tests/unit.rs:969:    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "/.");
url/tests/unit.rs:974:    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "");
url/tests/unit.rs:979:    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "/.");
url/tests/unit.rs:984:    assert_eq!(&joined[Position::AfterPort..Position::BeforePath], "/.");
url/tests/unit.rs:992:    assert_eq!(&url[Position::AfterPort..Position::BeforePath], "");
url/tests/unit.rs:997:    assert_eq!(&url[Position::AfterPort..Position::BeforePath], "");

shell

rg -n "set_path\(|set_host_internal|recompute_no_authority_path_marker\(\);" url/src/lib.rs

output

Chunk ID: a406cd
Wall time: 0.0000 seconds
Process exited with code 0
Original token count: 167
Output:
1618:    /// url.set_path("api/comments");
1623:    /// url.set_path("data/report.csv");
1629:    /// url.set_path("api/some comments");
1635:    /// url.set_path("api/some%20comments");
1643:    pub fn set_path(&mut self, mut path: &str) {
1666:        self.recompute_no_authority_path_marker();
1917:                self.set_host_internal(Host::parse(host_substr)?, None);
1919:                self.set_host_internal(Host::parse_opaque(host_substr)?, None);
1951:        self.recompute_no_authority_path_marker();
1956:    fn set_host_internal(&mut self, host: Host<String>, opt_new_port: Option<Option<u16>>) {
2047:        self.set_host_internal(address, None);

Implemented the non-special no-authority `//` path marker. Changed: - Parser now recognizes serialized `/.` markers and applies/removes them after path normalization: [parser.rs](/app/url/src/parser.rs:1372) - URL internals now keep `path()` logical while preserving marker-aware offsets and setters: [lib.rs](/app/url/src/lib.rs:2584) - `Position::AfterPort` now points before the marker while `BeforePath` points after it: [slicing.rs](/app/url/src/slicing.rs:152) - Added regression tests for parsing, reparsing, slicing, joins, query/fragment joins, and unaffected host/special URLs: [unit.rs](/app/url/tests/unit.rs:944) Verification: - `cargo test -p url` passed - `cargo build --locked` passed Note: `cargo fmt --check` could not run because `rustfmt` is not installed for the current toolchain. The build still succeeds.

Final diff , what the agent changed

No file changes, the agent left the workspace untouched.

Verifier output , the proof behind the reward

tests/test.sh

============================= test session starts ==============================
platform linux -- Python 3.11.2, pytest-8.3.3, pluggy-1.6.0 -- /opt/test-venv/bin/python3
cachedir: .pytest_cache
rootdir: /tests
collecting ... collected 4 items

../tests/test_outputs.py::test_url_roundtrip_suite_passes PASSED         [ 25%]
../tests/test_outputs.py::test_existing_url_unit_tests_still_pass PASSED [ 50%]
../tests/test_outputs.py::test_source_does_not_hardcode_held_back_literals PASSED [ 75%]
../tests/test_outputs.py::test_vendored_url_data_does_not_leak_hidden_rows PASSED [100%]

==================================== PASSES ====================================
=========================== short test summary info ============================
PASSED ../tests/test_outputs.py::test_url_roundtrip_suite_passes
PASSED ../tests/test_outputs.py::test_existing_url_unit_tests_still_pass
PASSED ../tests/test_outputs.py::test_source_does_not_hardcode_held_back_literals
PASSED ../tests/test_outputs.py::test_vendored_url_data_does_not_leak_hidden_rows
============================== 4 passed in 0.29s ===============================

Reproduce this trial: git checkout 2f94510 && PYTHONPATH=src python3 scripts/build_site.py , then open trial/trial_4501a05d9dd84070. Re-running the agent live requires EVAL_PLATFORM_ENABLE_OAUTH_SMOKE=1 and is non-deterministic.

Trial trial_4501a05d9dd84070 · verifier authoritative; classifier explanatory.