баг msvc, или компиляторы право имеют? (отбрасывание const для возвращаемого типа приводит к ошибке ODR)

// header
void foo();

// cpp
#include <iostream>
const void foo() { std::cout << "hello\n"; }

int main()
{
    using f = const void();
}

#include <iostream>
 
template<class t> struct view;
    
template<class r, class... args> struct view<r(args...)>
{
    view()
    {
        std::cout << std::is_const<r>::value << '\n';
    }
};
 
int main()
{
    using f1 = void();
    using f2 = const void();
    
    std::cout << "is_same ? " << std::is_same<f1, f2>::value << '\n';
 
    view<f2>();    
    view<f1>();    
}

    view<f1>();    
    view<f2>();

#include <iostream>
 
const int foo() { return 0; }
 
int main()
{
    using type = decltype(foo());
    const bool is = ::std::is_same<type, const int>::value;
    if(!is)
        std::cout << "discard const\n";
}

#include <iostream>
 
template<class t> struct view;
    
template<class... args> struct view<void(args...)>
{
    view()
    {
        std::cout << "void\n";
    }
};
 
template<class... args> struct view<const void(args...)>
{
    view()
    {
        std::cout << "const void\n";
    }
};
 
int main()
{
}

void const f() {}
 
int main() {
  void (*fptr)() = f;
}

#include <iostream>
 
int foo()
{
    std::cout << __FUNCDNAME__ << '\n';
    return 0;
}
 
int main()
{
    foo();
}

#include <iostream>
 
template<class t> struct view;
    
template<class r, class... args> struct view<r(args...)>
{
    #ifdef _MSC_VER // Visual Studio`s compiler
    static_assert(
        ! ::std::is_same<r, const void>::value,
        "'const void' as return type is not supported"
    );
    #endif
 
    view(){}
};
 
int main()
{
    using f2 = const void();
    using f1 = void();
 
    view<f1>();    
 
    // error C2338: 'const void' as return type is not supported
    // view<f2>();   
}

// foo1.cpp
int foo() { return 0; }
 
// foo2.cpp
void foo() { }

// могут быть определены как в одной, так и в различных ед. трансляции
template<class T> int foo(T)
    { return 0; }
 
template<class T> bool foo(T)
    { return false; }

// foo1.cpp
#include <iostream>
int foo() { std::cout << "int foo()\n"; return 0; }
 
void work1() { foo(); }

// foo2.cpp
#include <iostream>
void foo() { std::cout << "void foo()\n"; }
 
void work2() { foo();  }

// foo.h
 
#pragma once
void work1();
void work2();

// main.cpp
#include "foo.h"
int main()
{
    work1();
    work2();
}