Normalize include paths before source-cache lookup

[0pendev]

PR: Normalize include paths before source-cache lookup

Summary

• Fix duplicate source loading when the same header is reached via different relative ../ paths (e.g. common/shared.h vs handler/../common/shared.h).
• Normalize include paths with std.fs.path.resolvePosix before keying into the source cache, so that logically identical files map to a single cache entry.
• Store the normalized path in the cache so all subsequent lookups (regardless of the original include spelling) hit the same entry.

Problem

The source cache in Compilation.addSourceFromPathExtra was keyed on the raw include-path string as provided by the preprocessor. When the same physical header file was included from different directories, each directory produced a different relative path containing ../ segments that were never collapsed.

For example, given this layout:

project/
├── common/
│   └── shared.h          (#pragma once, defines shared_t)
├── handler/
│   └── handler_types.h   (#include "../common/shared.h")
└── main.c                (#include "common/shared.h"
                            #include "handler/handler_types.h")

When the preprocessor processes these includes, the cache sees two different keys for the same file:

Include site	Path passed to source cache
main.c	common/shared.h
handler/handler_types.h	handler/../common/shared.h

Because these two strings differ, the cache treated them as two distinct sources, even though they refer to the same file on disk. This caused:

1. #pragma once failures — the guard is per-source-ID, so the second load didn't recognize the file as already included, leading to duplicate type definitions or, in pathological ./-loop cases, infinite self-include recursion.
2. Redundant preprocessing — the same header was lexed and preprocessed multiple times, wasting work proportional to the number of distinct path spellings.

Reproducer

Create the following file tree:

common/shared.h

#pragma once

typedef struct {
    int id;
    int value;
} shared_t;

handler/handler_types.h

#pragma once
#include "../common/shared.h"

typedef struct {
    shared_t state;
    int flags;
} handler_info_t;

main.c

#include "common/shared.h"
#include "handler/handler_types.h"

shared_t global_state;
handler_info_t handler_info;

Without the fix, compiling main.c with arocc produces a duplicate definition error for shared_t because #pragma once fails to deduplicate the two source-cache entries for common/shared.h.

Fix

In src/aro/Compilation.zig, inside addSourceFromPathExtra:

1. After the initial raw-path cache lookup, normalize the path using std.fs.path.resolvePosix to collapse /./" and X/../ segments.
2. If the normalized path differs from the raw path, perform a second cache lookup with the normalized form.
3. When inserting a new source into the cache, use the normalized path as the key so future lookups (from any spelling) converge on the same entry.

fn addSourceFromPathExtra(comp: *Compilation, path: []const u8, kind: Source.Kind) !Source {
    if (comp.sources.get(path)) |some| return some;

    // Normalize the path by collapsing "/./" and "X/../" segments so that
    // different relative paths to the same file resolve to one cache entry.
    // This prevents #pragma once failures and redundant preprocessing.
    const normalized = try std.fs.path.resolvePosix(comp.gpa, &.{path});
    defer comp.gpa.free(normalized);
    if (!mem.eql(u8, normalized, path)) {
        if (comp.sources.get(normalized)) |some| return some;
    }

    if (mem.indexOfScalar(u8, path, 0) != null) {
        return error.FileNotFound;
    }

    const file = try comp.cwd.openFile(comp.io, path, .{});
    defer file.close(comp.io);
    return comp.addSourceFromFile(file, normalized, kind);
}

[Vexu]

Could you also make addSourceFromOwnedBuffer take a []u8 for path so that it doesn't need to be duped twice? And a test would be nice.

[0pendev]

Could you also make addSourceFromOwnedBuffer take a []u8 for path so that it doesn't need to be duped twice? And a test would be nice.

How do want me to add the test case ? Is it okay to add a subdirectory for the includes needed for the test?

[Vexu]

There is already a directory for includes, you could look at test/cases/pragma once.c for an example of a test that uses includes.

[0pendev]

Hey @Vexu
I added the tests as we discussed.
Fixed a regression I did not see.

My last commit is the refactor you suggested, I feel like it makes the function harder to call and would love a review on it 🙏

[Vexu]

Looking at FindInclude more I think replacing the allocPrint in check with a resolve would make it unnecessary to resolve the path in addSourceFromPathExtra avoiding having to modify addSourceFromOwnedBuffer.

[0pendev]

• Fix duplicate source loading when the same header is reached via different relative ../ paths (e.g. common/shared.h vs handler/../common/shared.h).
• Normalize include paths with std.fs.path.resolvePosix before keying into the source cache, so that logically identical files map to a single cache entry.
• Store the normalized path in the cache so all subsequent lookups (regardless of the original include spelling) hit the same entry.

Applied this refactoring and dropped previous attempts at fixes.
Tests were kept and all integration tests are passing.

[Vexu]

This looks redundant.

[0pendev]

From the tests I did The resolve is needed for #include_next support.