A mixin has its own scope, even if a declaration is overridden by the enclosing one:

        int x = 4;

    template Foo()
    {
        int x = 5;
        int bar() { return x; }
    }

    mixin Foo;

    void test()
    {
        printf("x = %d\n", x);        // prints 4
        printf("bar() = %d\n", bar());    // prints 5
    }

E>>>Зря он так предполагает

E>Да, я тоже хотел об этом сказать. Но поскольку в исходном сообщении ЗХ не было упомянута директива #line, то решил об этом не говорить. К тому же, при желании, кодогенераторы могут сами подсчитывать номера строк в генерируемом коде Хоть это и геморройно.

Special Tokens
These tokens are replaced with other tokens according to the following table:
Special Token Replaced with...
__FILE__ string literal containing source file name
__LINE__ integer literal of the current source line number
__DATE__ string literal of the date of compilation "mmm dd yyyy"
__TIME__ string literal of the time of compilation "hh:mm:ss"
__TIMESTAMP__ string literal of the date and time of compilation "www mmm dd hh:mm:ss yyyy"

           #include <stddef> 
           struct Foo { int x; int y; }; 

           off = offsetof(Foo, y); 

The D Way
An offset is just another property:

           struct Foo { int x; int y; } 

           off = Foo.y.offset;

foreach (int x; my_integers) ;

off = Foo.y.offsetof;

off = meta(Foo.y).offsetof;

meta(x+y*z).type t = x+y*z;

[serializeble]
struct Foo 
{ 
    int x; 
    int y; 
    [non_serializeble]
    int tmp; 
} 
template<class T>
void serialize(T const& val, stream& st)
{
    static assert(meta(T).attributes.contains(meta(serializeble)));
    foreach(meta field in meta(T).fields)
        if(!field.attributes.contains(meta(non_serializeble)))
            st.serialize(field.const_ref(val), field.name);
}

MS>"Все кому не лень" делают это по одной простой причине — в языках имеется тип "строка". В C++ такого типа не существует. Следовательно, switch/case по строке невозможен по причине отсутствия самой строки.

MS>class Key
MS>{
MS>   Key(int i, string s);
MS>   . . .
MS>   bool operator < (const Key&) ...
MS>};


MS>. . .

MS>switch(Key(i, s))
MS>{
MS>   case Key(1, "123"):
MS>   case Key(1, "124"):
MS>   . . .
MS>}
MS>

class Key : IComparable
{
  Key(int i, string s);
  . . .
  override GetHashCode()...
    IComparable.CompareTo(...)...
};

Dictionary<Key, Handler> _map = Dictionary<Key, Handler>();

void Init()
{
    _map[new Key(1, "124")] = delegate { ... };
    _map[new Key(1, "123")] = delegate { ... };
}

void Test(Key key)
{
    _map[key]();
}

Date d(2005,05,05);
label qn[] = { q1=0, q2=1, q3=2, q4=2 };
swtitch(d.quarter(), qn)
{
   default: . . .
   q1: . . .
   q2: . . .
   q3: . . .
   q4: . . .
};

Кё>foreach (int x; my_integers) ;
Кё>

Кё>Для читабельности это плюс, но не в случае, если контейнер определён строкой выше

foreach (int x; my_integers) sum += x;
foreach (inout int x; my_integers) x = 12;

MS>Date d(2005,05,05);
MS>label qn[] = { q1=0, q2=1, q3=2, q4=2 };
MS>swtitch(d.quarter(), qn)
MS>{
MS>   default: . . .
MS>   q1: . . .
MS>   q2: . . .
MS>   q3: . . .
MS>   q4: . . .
MS>};
MS>

MS>Фактически, switch это и есть вычисляемый goto, но только кастрированный и неспособный к развитию И при этом — не гарантирующий какую-либо оптимизацию. Все, что можно гарантировать — это O(N) и не более того. В то время, как вычисляемый goto железно обеспечивает O(1).

switch( d.quarter() ) 
 {
  case 1 : ... break;
  case 2 : ... break;
  ...
  default: ...
 }