Namespaces for types don't work

[vgrichina]

See https://studio.nearprotocol.com/?f=XfZ2mUv for working example.

Basically if you have:

namespace Outer {
  export class Inner {

  }
}

it doesn't look that any references to Inner actually work.

E.g. none of these compile so far:

let cannotDeclareVariable: Outer.Inner = null;

function cannotReturn(): Outer.Inner {
}

function cannotTakeAargument(arg: Outer.Inner): void {
}

Do you have any suggestion on how to fix this?

[vgrichina]

Note that if I have a type in separate module and try to do:

import * as Outer from "./outer";

I also get compilation problem when I try to use Outer.Inner.

[vgrichina]

@dcodeIO looks like first issue is gone, but issue remains with:

import * as Outer from "./outer";

[dcodeIO]

What's the complete code there? Asking because the Outer namespace isn't exported in your example, and it should look somewhat like this to work:

// a.ts
export namespace Outer {
  export class Inner {
  }
}

// b.ts
import * as A from "./a";

A.Outer.Inner; // ?

[vgrichina]

@dcodeIO sorry, here's working example:

https://studio.nearprotocol.com/?f=utg1efv31

[dcodeIO]

Thanks, I see now. Doesn't seem that there's a super easy fix for this. The elements map only contains the filespace, but there are no (recursive) aliases of its children which could be looked up by a simple string search. What we'd need instead is a multi-level map to be able to resolve symbols at specific points in the tree without having to rely on a global map, hmm...

[vgrichina]

@dcodeIO what does happen when I have, say:

import { Inner } from "./outer";

and then use Inner anywhere. How is Inner resolved?

[vgrichina]

@dcodeIO BTW, looks like this only fails for variable declaration, but works for usage in function types and params.

These seem to compile fine:

function cannotReturn(): Outer.Inner {
}

function cannotTakeAargument(arg: Outer.Inner): void {
}

but this fails:

let cannotDeclareVariable: Outer.Inner = null;

EDIT: Looks they actually also fail once you try calling functions.

[vgrichina]

Importing and renaming individual classes works apparently, see:
https://studio.nearprotocol.com/?f=sfi79r9in

So basically for now just gonna do stuff like:

import {Inner as Outer_Inner} from "./outer";

However I feel that it's better to just give compiler error on:

import * as whatever from "./module";

Then it'll be clearly marked as unsupported feature, cause right now it's not clear what's going on – it only works for some isolated cases.

[dcodeIO]

Will keep this in mind while switching to symbol tables in #424. Going to implement proper tree-based lookups there.

[vgrichina]

@dcodeIO this one actually also looks related:
#429