Using global

[chriseth]

The alternative syntax for this is

struct X { ... } using {f, mul as *};
type MyFloat is uint using {f};

The disadvantage is that you can only have one using statement per type and you cannot "mix" e.g. multiple modules, i.e. you cannot do export using Modulename for MyFloat; export using {f, g, h} for MyFloat;

We can of course change the using statement so that using {f, M} for MyFloat; is equivalent to using f for MyFloat; using M for MyFloat - currently modules and libraries cannot be used inside the braces.

[chriseth]

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

[chriseth]

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

[chriseth]

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

[chriseth]

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.

[ekpyron]

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.

[ekpyron]

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

[ekpyron]

Looks good in general apart from the missing json ast part - but I also need another look after a rebase.

[ekpyron]

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

[ekpyron]

Suggested change

	_node.isMember("global") && _node["global"].asBool()
	_node.isMember("global") && memberAsBool(_node, "global")

?
Or only memberAsBool or is the idea to default to false instead of raising an error?

[chriseth]

The idea is to default to false.

[ekpyron]

_node.isMember("global") && memberAsBool(_node, "global") would still be more graceful I guess, if global is there and not a boolean, but yeah, fine either way.

[ekpyron]

Now it won't default to false anymore, though, will it :-)? But yeah, it also doesn't have to, so also fine.

[ekpyron]

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...

[chriseth]

Added the test.

[ekpyron]

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...

[ekpyron]

Looks good to me - should be squashed before merging, though.

[chriseth]

Added another semantic test and squashed.