How to use a macro to generate compile-time unique integers?

You could compute a compile-time hash using the module path (which contains the crate and modules leading up to the file), the file name, column and line number of the macro invocation like this:

pub const fn hash(module_path: &'static str, file: &'static str, line: u32, column: u32) -> u64 {
    let mut hash = 0xcbf29ce484222325;
    let prime = 0x00000100000001B3;

    let mut bytes = module_path.as_bytes();
    let mut i = 0;

    while i < bytes.len() {
        hash ^= bytes[i] as u64;
        hash = hash.wrapping_mul(prime);
        i += 1;
    }

    bytes = file.as_bytes();
    i = 0;
    while i < bytes.len() {
        hash ^= bytes[i] as u64;
        hash = hash.wrapping_mul(prime);
        i += 1;
    }

    hash ^= line as u64;
    hash = hash.wrapping_mul(prime);
    hash ^= column as u64;
    hash = hash.wrapping_mul(prime);
    hash
}

macro_rules! unique_number {
    () => {{
        const UNIQ: u64 = crate::hash(module_path!(), file!(), line!(), column!());
        UNIQ
    }};
}

fn foo() -> u64 {
    unique_number!()
}

fn bar() -> u64 {
    unique_number!()
}

fn main() {
    println!("{} {}", foo(), bar()); // 2098219922142993841 2094402417770602149 on the playground
}

(playground)

This has the benefit of consistent results, when compared to the top answer that can return different values depending on the order of invocation, and this is also entirely computed in compile time, which remove the runtime overhead of maintaining a counter.

The only downside to this is that you could get hash value collisions. But the chance is low. If you want, you could try implementing an algorithm that computes perfect hash values. The example shown uses the FNV algorithm which should be decent but not perfect.

No, you can not use a regular macro for this. However, you might be able to find a procedural macro crate which might give this functionality.

That being said...

This does not count as safe rust, but if we are okay with throwing safety out the window then this should do the trick.

macro_rules! unique_u64 {
    () => {{
        struct PlaceHolder;
        let id = ::std::any::TypeId::of::<PlaceHolder>();
        unsafe { ::std::mem::transmute::<_, u64>(id) }
    }};
}

This is probably undefined behavior, but since we know that every type should have a unique TypeId it would have the desired effect. The only reason I know that this is even possible is because I have looked at the structure of TypeId and know it contains a single u64 to distinguish types. However, there are currently plans to change TypeId from being a u64 to something more stable and less prone to this kind of unsafe code. We have no guarantees on what the contents of TypeId might change to and when it does change it might silently fail if it still has the same size as a u64.

Alternatively,

We can achieve a similar result in safe rust by hashing the TypeId. Now, it slightly breaks the rules since we do not have any guarantee that it will always produce a unique result. However, it seems highly unlikely that 2 different TypeIds would hash to the same value. Plus this stays within safe rust and is unlikely to break for future releases of Rust.

macro_rules! unique_u64 {
    () => {{
        use ::std::hash::{Hash, Hasher};
        
        struct PlaceHolder;
        let id = ::std::any::TypeId::of::<PlaceHolder>();
        let mut hasher = ::std::collections::hash_map::DefaultHasher::new();
        id.hash(&mut hasher);
        hasher.finish()
    }};
}

Not exactly a macro but anyway it's a proposition:

#[repr(u64)]
enum Unique {
    Foo,
    Bar,
}

pub fn foo() -> u64 {
    Unique::Foo as u64
}

pub fn bar() -> u64 {
    Unique::Bar as u64
}

Compiler should warn you if you don't use a variant.

It's possible to do something like this with once_cell, using a static atomic variable as a counter:

use core::sync::atomic::{Ordering, AtomicU64};
use once_cell::sync::Lazy;

static COUNTER: AtomicU64 = AtomicU64::new(0);

fn foo() -> u64 {
    static LOCAL_COUNTER: Lazy<u64> = Lazy::new(|| COUNTER.fetch_add(1, Ordering::Relaxed));
    *LOCAL_COUNTER
}

fn bar() -> u64 {
    static LOCAL_COUNTER: Lazy<u64> = Lazy::new(|| COUNTER.fetch_add(1, Ordering::Relaxed));
    *LOCAL_COUNTER
}

fn main() {
    dbg!(foo()); // 0
    dbg!(foo()); // still 0
    dbg!(bar()); // 1
    dbg!(foo()); // unchanged - 0
    dbg!(bar()); // unchanged - 1
}

Playground

And, yes, the repeating code can be, as usual, wrapped in macro:

macro_rules! unique_integer {
    () => {{
        static LOCAL_COUNTER: Lazy<u64> = Lazy::new(|| COUNTER.fetch_add(1, Ordering::Relaxed));
        *LOCAL_COUNTER
    }}
}

fn foo() -> u64 {
    unique_integer!()
}

fn bar() -> u64 {
    unique_integer!()
}