This is the "export using" statement and actually much easier to implement than I thought.

What about using {...} for MyType attached; or something like that?

This is ready for review, the name of the keyword is still up for debate.

Idea for test:
file A: define type X, function f and using... global
file B: import X from A and define a function g that returns X
file C: import only g from B and use g().f().

It should work even though neither f nor X are available in C by name.

Maybe

==== Source: A ====
using {f} for S global;
using {g} for S;
struct S { uint x; }
function gen() pure returns (S memory) {}
function f(S memory _x) pure { _x.g(); }
function g(S memory _x) pure { }
==== Source: B ====
import "A";
function test() pure
{
    gen().f(); // fine
    gen().g(); // some error
}

or something similar to check global and non-global using together?

In general this looks good, but may need a few more tests.

If I see it correctly, the global thing still needs to be exported to and imported from the json AST.

AST Json tests need updating. Looking at the rest regardless.

Just for the sake of completeness, it could have some tests for global as identifier or type name and type global is uint; using { f } for global; using { g } for global global; - but on the other hand all that should work just fine...

Added the test.

I'm mainly wondering if we need more tests at this point...
But even weirdest stuff like this should just work:

==== Source: A ====
import {T as U} from "A";
import "A" as X;

type T is uint;
function f(T) pure {}
using { f } for X.X.U global;
using { f } for T global;

function g() pure {
        U t;
        t.f();
}

So maybe coverage is already fine...

Added another semantic test and squashed.