; -*- coding: utf-8 -*-

; ------------------------------------------------------------------------------------------------

; Copyright © 2022, stack-graphs authors.

; Licensed under either of Apache License, Version 2.0, or MIT license, at your option.

; Please see the LICENSE-APACHE or LICENSE-MIT files in this distribution for license details.

; ------------------------------------------------------------------------------------------------

; ########################################################################################

;

; ######## ## ## ######## ######## ###### ###### ######## #### ######## ########

; ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##

; ## #### ## ## ## ## ## ## ## ## ## ## ##

; ## ## ######## ###### ###### ## ######## ## ######## ##

; ## ## ## ## ## ## ## ## ## ## ##

; ## ## ## ## ## ## ## ## ## ## ## ## ##

; ## ## ## ######## ###### ###### ## ## #### ## ##

;

; ########################################################################################

; Global Variables

; ^^^^^^^^^^^^^^^^

global FILE_PATH ; project relative path of this file

global PROJECT_NAME = "" ; project name, used to isolate different projects in the same stack graph

global JUMP_TO_SCOPE_NODE

global ROOT_NODE

; Attribute Shorthands

; ^^^^^^^^^^^^^^^^^^^^

attribute node_definition = node => type = "pop_symbol", node_symbol = node, is_definition

attribute node_reference = node => type = "push_symbol", node_symbol = node, is_reference

attribute pop_node = node => type = "pop_symbol", node_symbol = node

attribute pop_scoped_node = node => type = "pop_scoped_symbol", node_symbol = node

attribute pop_scoped_symbol = symbol => type = "pop_scoped_symbol", symbol = symbol

attribute pop_symbol = symbol => type = "pop_symbol", symbol = symbol

attribute push_node = node => type = "push_symbol", node_symbol = node

attribute push_scoped_node = node => type = "push_scoped_symbol", node_symbol = node

attribute push_scoped_symbol = symbol => type = "push_scoped_symbol", symbol = symbol

attribute push_symbol = symbol => type = "push_symbol", symbol = symbol

attribute scoped_node_definition = node => type = "pop_scoped_symbol", node_symbol = node, is_definition

attribute scoped_node_reference = node => type = "push_scoped_symbol", node_symbol = node, is_reference

attribute symbol_definition = symbol => type = "pop_symbol", symbol = symbol, is_definition

attribute symbol_reference = symbol => type = "push_symbol", symbol = symbol, is_reference

attribute node_symbol = node => symbol = (source-text node), source_node = node

; Node Name & Symbol Conventions

; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

;

; @node.{expr,type,mod}_def = STRING

; A definition node, pop node with a name value.

;

; @node.{expr,type,mod}_ref = STRING

; A reference node, a push node with a name value.

;

; @node.{expr,type,mod}_{def,ref}.ns = "%T" | "%E" | "%M"

; Internal symbol indicating the namespace of an identifier.

;

; @node.{expr,type,ns}_{def,ref}.typeof = ":"

; Internal symbol indicating the type of an identifier.

;

; @node.callable = "->"

; Internal symbol indicating a callable.

;

; @node.member = "."

; Internal symbol indicating a named member (e.g., a field or method).

;

; @node.ctor = "<new>"

; Internal symbol indicating a constructor.

;

; @node.type_{abs,app} = "<>"

; Internal scoped symbol indicating type parameters & arguments.

;

; @node.indexable = "[]"

; Internal symbol indicating an indexable (i.e., array access).

;

; @node.{type,expr}_export = "%T" | "%E"

; Internal node for namespace guards for default and = exports.

; comments can appear almost everywhere, so we simply make sure all

; possible nodes are defined on comments

(comment)@comment {

node @comment.alias_type

node @comment.aliased_type

node @comment.applied_type

node @comment.arg

node @comment.args

node @comment.async_type

node @comment.await_type

node @comment.callable

node @comment.coargs

node @comment.cocallable

node @comment.coparam

node @comment.coparams

node @comment.cotype

node @comment.default_export

node @comment.defs

node @comment.exports

node @comment.expr_def

node @comment.expr_def__ns

node @comment.expr_ref

node @comment.expr_ref__ns

node @comment.global_defs

node @comment.lexical_defs

node @comment.lexical_scope

node @comment.member

node @comment.mod_def

node @comment.mod_def__ns

node @comment.mod_ref

node @comment.param

node @comment.params

node @comment.return_type

node @comment.static_members

node @comment.static_type

node @comment.type

node @comment.type_def

node @comment.type_def__ns

node @comment.type_members

node @comment.type_ref

node @comment.type_ref__ns

node @comment.var_defs

}

; # #

; ## ## #### ##### # # # ###### ####

; # # # # # # # # # # # # #

; # # # # # # # # # # ##### ####

; # # # # # # # # # # #

; # # # # # # # # # # # #

; # # #### ##### #### ###### ###### ####

;

; #################################################

; Projects are defined using a "%Proj" PROJECT_NAME definition in the root scope. Each module defines

; its own project scope, which is joined with all other project scopes by both exposing a project

; definition and importing a project reference. The module itself is defined with a "%M" NAME* definition,

; based in its FILE_PATH.

;

; For example, a module `src/core/MyModule.ts` in a project `MyProject` is defined as follows:

;

; ROOT_NODE -> ↑"%Proj" -> ↑"MyProject" -> proj_scope

; proj_scope -> ↑"%M" -> ↑"src" -> ↑"core" -> ↑"MyModule" -> @prog.defs

;

; For any module in the project `MyProject` ensures the composition with other modules in the same project:

;

; proj_scope -> ↓"MyProject" -> -> ↓"%Proj" -> ROOT_NODE

; @prog.lexical_scope -> proj_scope

;

; Module imports are either relative or non-relative. Relative imports are relative either to the current file,

; or to the `rootDirs` in `tsconfig.json`. Relative imports use a NAME* "%RelM" reference (which may include `..`

; components!). Each module defines a "%RelM" definition, which is linked to a NAME* references based on its own

; path, as well as ".." definitions that can skip components. (References are normalized to ensure `..` components

; only appear at the beginning of the path.)

;

; For example, an import of `../OtherModule`:

;

; importing_scope -> ↓"OtherModule" -> ↓"%RelM" -> @node.lexical_scope

;

; And, the module `src/core/MyModule.ts` would have the following definition to convert it to a proper module reference:

;

; @prog.lexical_scope -> ↑"%RelM" -> ↓"core" -> ↓"src" -> ↓"%M" -> proj_scope

; \ \ / /

; --- ↑".." --\-----> /

; --- ↑".." ---->

;

; The root dirs defined in `tsconfig.json` introduce definitions to convert relative imports to proper module paths.

;

; For example, `rootDirs: ["./src/util"]` would give:

;

; proj_scope -> ↑"%RelM" -> ↓"util" -> ↓"src" -> ↓"%M" -> proj_scope

;

; Non-relative imports appear as "%NonRelM" NAME* definitions in either a project scope, or the global scope.

;

; Non-relative definitions in a project scope are the result of path mappings in `tsconfig.json`.

;

; For example, given `paths: { "util": ["./my_util"] }` with base URL `./src`, we get:

;

; proj_scope -> ↑"%NonRelM" -> ↑"%util" -> ↓"my_util" -> ↓"src" -> ↓"%M"

;

; The global definition rewrites the package name to a projects root dir, via a "%PkgM" node.

; The "%PkgM" node maps to source files in the root directory. A "%NonRelM" NAME* definition in

; the global scope maps non-relative module paths starting with the package name to the "%PkgM" node.

;

; For example, a package `@my/pkg` defined in project `MyProject` with source directory `src` would appear as:

;

; ROOT_NODE -> ↑"%NonRelM" -> ↑"@my" -> ↑"pkg" -> ↓"%PkgM" -> proj_scope

; proj_scope -> ↑"%PkgM" -> ↓"src" -> ↓"%M"

;

; The various references and definitions for `tsconfig.json` are not created by this TSG file, but

; by the `TsConfigAnalyzer` defined in `rust/tsconfig.rs`. The global package definition is created

; by the `NpmPackageAnalyzer` in `rust/npm_package.rs`.

; ######

; # # ##### #### #### ##### ## # # ####

; # # # # # # # # # # # # ## ## #

; ###### # # # # # # # # # # ## # ####

; # ##### # # # ### ##### ###### # # #

; # # # # # # # # # # # # # # #

; # # # #### #### # # # # # # ####

;

; ########################################################

;; Attributes defined on programs

;

; out .lexical_scope

; Lexical scope.

;

; in .defs

; Lexical and variable definitions.

;

; in .exports

; Exported definitions.

;

; out .mod_def

; Module definition

;; Nodes

(program)@prog {

node @prog.defs

node @prog.exports

node @prog.globals

node @prog.lexical_scope

}

(program)@prog {

; expose definitions

edge @prog.lexical_scope -> @prog.defs

; import builtins

node builtins_ref__ns

attr (builtins_ref__ns) push_symbol = "%Proj"

edge builtins_ref__ns -> ROOT_NODE

;

node builtins_ref

attr (builtins_ref) push_symbol = "<builtins>"

edge builtins_ref -> builtins_ref__ns

;

edge @prog.lexical_scope -> builtins_ref

}

;; Project and module definitions

(program [(import_statement) (export_statement)]* @imexs)@prog {

var proj_scope = ROOT_NODE

if (not (eq PROJECT_NAME "")) {

; project definition

node proj_def__ns

attr (proj_def__ns) pop_symbol = "%Proj"

edge proj_scope -> proj_def__ns

;

node proj_def

attr (proj_def) pop_symbol = PROJECT_NAME

edge proj_def__ns -> proj_def

;

set proj_scope = proj_def

}

; expose globals

edge proj_scope -> @prog.globals

var mod_scope = proj_scope

if (not (is-empty @imexs)) {

; module definition

let mod_name = (path-filestem FILE_PATH)

let mod_path = (path-normalize (path-join (path-dir FILE_PATH) mod_name))

;

node mod_def__ns

attr (mod_def__ns) pop_symbol = "%M"

edge mod_scope -> mod_def__ns

set mod_scope = mod_def__ns

;

scan mod_path {

"index$" {

; skip last component for index files

}

"([^/]+)/?" {

node mod_def

attr (mod_def) pop_symbol = $1

edge mod_scope -> mod_def

set mod_scope = mod_def

}

}

; make the last one a definition

attr (mod_scope) is_definition, source_node = @prog, empty_source_span

; expose exports via module definition

edge mod_scope -> @prog.exports

} else {

; expose definitions via project scope

edge mod_scope -> @prog.defs

}

}

;; Project and module reference

(program [(import_statement) (export_statement)]* @imexs)@prog {

var proj_scope = ROOT_NODE

if (not (eq PROJECT_NAME "")) {

; project reference

node proj_ref__ns

attr (proj_ref__ns) push_symbol = "%Proj"

edge proj_ref__ns -> proj_scope

;

node proj_ref

attr (proj_ref) push_symbol = PROJECT_NAME

edge proj_ref -> proj_ref__ns

;

set proj_scope = proj_ref

}

; compose all project files by adding edge to the project reference

edge @prog.lexical_scope -> proj_scope

var mod_scope = proj_scope

if (not (is-empty @imexs)) {

; module reference

node mod_ref__ns

attr (mod_ref__ns) push_symbol = "%M"

edge mod_ref__ns -> mod_scope

set mod_scope = mod_ref__ns

;

let mod_dir = (path-normalize (path-dir FILE_PATH))

scan mod_dir {

"([^/]+)/?" {

node mod_ref

attr (mod_ref) push_symbol = $1

edge mod_ref -> mod_scope

node mod_node

edge mod_node -> mod_ref

node parent_def

attr (parent_def) pop_symbol = ".."

edge parent_def -> mod_scope

edge mod_node -> parent_def

attr (mod_node -> parent_def) precedence = 1 ; consume dots eagerly

set mod_scope = mod_node

}

}

; relative import definition

node rel_def

attr (rel_def) pop_symbol = "%RelM"

edge rel_def -> mod_scope

; expose reference in lexical scope

edge @prog.lexical_scope -> rel_def

}

}

(program

(_)@stmt

)@prog {

; propagate lexical scope

edge @stmt.lexical_scope -> @prog.lexical_scope

; expose lexical and variable declarations

edge @prog.defs -> @stmt.lexical_defs

edge @prog.defs -> @stmt.var_defs

; exports are visible via module definition

edge @prog.exports -> @stmt.exports

; globals are visible in the project scope

edge @prog.globals -> @stmt.global_defs

}

;; hashbang

(hash_bang_line) {

}

;; Comments

(comment) {

}

; #####

; # # ##### ## ##### ###### # # ###### # # ##### ####

; # # # # # # ## ## # ## # # #

; ##### # # # # ##### # ## # ##### # # # # ####

; # # ###### # # # # # # # # # #

; # # # # # # # # # # # ## # # #

; ##### # # # # ###### # # ###### # # # ####

;

; ###################################################################

;; Attributes defined on statements

;

; in .lexical_scope

; Lexical scope.

;

; out .lexical_defs

; Lexical definitions, that are block scoped

;

; out .var_defs

; Variable definitions, that are function scoped

;

; out .exports

; Exported definitions.

;

; out .default_export

; Nameless (but namespaced) exports for use in default and = exports.

;

; out .return_type

; Type of contained return statement.

[

(abstract_class_declaration)

(ambient_declaration)

(break_statement)

(catch_clause)

(class_declaration)

(continue_statement)

(debugger_statement)

(do_statement)

(else_clause)

(empty_statement)

(enum_declaration)

(export_statement)

(expression_statement)

(finally_clause)

(for_in_statement)

(for_statement)

(function_declaration)

(function_signature)

(generator_function_declaration)

(hash_bang_line)

(if_statement)

(import_alias)

(import_statement)

(interface_declaration)

(internal_module)

(labeled_statement)

(lexical_declaration)

(module)

(return_statement)

(statement_block)

(switch_body)

(switch_case)

(switch_default)

(switch_statement)

(throw_statement)

(try_statement)

(type_alias_declaration)

(variable_declaration)

(while_statement)

(with_statement)

]@stmt {

node @stmt.default_export

node @stmt.exports

node @stmt.global_defs

node @stmt.lexical_defs

node @stmt.lexical_scope

node @stmt.return_type

node @stmt.var_defs

}

;; Imports & Exports (The Many Faced God)

;

; TypeScript has many import / export forms. Below is a condensed presentation that can be used as a reference

; for the sections below where the actual rules are defined. One has to be careful with the queries to ensure

; that cases do not overlap, even if their syntactic forms (partially) do. This must be done by adding negative

; matches to some queries. This overview should make it easier to spot where negative are required.

;

;;;; Exports

;

; export_statement :=

; (export_statement "*" source:(_)@from) ; export * from MODULE ; re-export everything from MODULE

; | (export_statement (namespace_export (identifier)@ns) source:(_)@from) ; export * as NAMESPACE from MODULE ; re-export MODULE as NAMESPACE

; | (export_statement "default" value:(_)@value) ; export default EXPRESSION ; export EXPRESSION as default

; | (export_statement "default" declaration:(_)@decl) ; export default DECLARATION ; export DECLARATION as default

; | (export_statement ^"default" declaration:(_)@decl) ; export DECL ; export DECLARATION

; | (export_statement "type"? (export_clause)@clause source:(_)@from) ; export (type) CLAUSE from MODULE ; re-export (type) identifiers from MODULE

; | (export_statement "type"? (export_clause)@clause !source ) ; export (type) CLAUSE ; export (type) identifiers

; | (export_statement "=" . (expression)@value) ; export = EXPRESSION ; export EXPRESSION as exports object

; | (export_statement "as" "namespace" . (_)@ns) ; export as namespace NAMESPACE ; export this module as global NAMESPACE

;

; export_clause :=

; (export_clause (export_specifier)*) ; { EXPORT_SPECIFIER* }

;

; export_specifier :=

; (export_specifier name:(_) alias:(_)) ; NAME

; | (export_specifier name:(_) !alias ) ; NAME as ALIAS

;

;;;; Imports

;

; import_statement :=

; ; note that the first case overlaps with the two after it, but the behaviour is orthogonal

; (import_statement "type"? (import_clause (identifier)@name ) source:(_)@from) ; import (type) NAME from MODULE ; import default (type) from MODULE as NAME

; | (import_statement "type"? (import_clause (namespace_import (identifier)@ns)) source:(_)@from) ; import (type) * as NAMESPACE from MODULE ; import all (type) identifiers from MODULE in NAMESPACE

; | (import_statement "type"? (import_clause (named_imports)@named_imports ) source:(_)@from) ; import (type) NAMED_IMPORTS from MODULE ; import named (type) identifiers from MODULE

; | (import_statement "type"? ^(import_clause) source:(_)@from) ; import (type) MODULE ; do not import any identifiers from MODULE

; | (import_statement "type"? (import_require_clause (identifier)@name source:(_)@from)) ; import (type) NAME = require(MODULE) ; import exports object (type) as NAME from MODULE

;

; named_imports :=

; (named_imports (import_specifier)*) ; { IMPORT_SPECIFIER* }

;

; import_specifier :=

; (import_specifier name:(_) alias:(_)) ; NAME

; (import_specifier name:(_) !alias ) ; NAME as ALIAS

;

; Note that the grammar productions for imports and exports are factored slightly

; different. The statements above are inlined such that corresponding import and

; export statements all live in the top-level list. Be mindful that (export_clause)

; corresponds to (import_clause (named_imports)) and not to (import_cluase)!

;

; The presence of a "type" modifier does not fundamentally change the way a certain

; export/import variant works, only which identifiers are included in the import/export.

; Therefore, we do not handle that as different export/export variants, but deal with that

; in the rules for the various clauses, which already determine the identifiers involved.

;; Module References

[

(export_statement source:(_)@from )

(import_statement source:(_)@from )

(import_statement (import_require_clause source:(_)@from))

]@import_stmt {

let mod_path = (replace (source-text @from) "[\"\']" "")

; relative or non-relative import specific

node mod_ref__ns

edge mod_ref__ns -> @import_stmt.lexical_scope

scan mod_path {

"^\\..*$" { ; relative imports

attr (mod_ref__ns) push_symbol = "%RelM"

}

"^.+$" { ; non-relative imports

attr (mod_ref__ns) push_symbol = "%NonRelM"

}

}

; module reference

var mod_scope = mod_ref__ns

; normalize path and remove the extension as we want to match 'foo', 'foo.js', 'foo.ts', etc.

scan (path-normalize (replace mod_path "\.(js|ts|jsx|tsx)$" "")) {

"([^/]+)/?" {

node mod_ref

attr (mod_ref) push_symbol = $1

edge mod_ref -> mod_scope

;

set mod_scope = mod_ref

}

}

; make the last one a reference

attr (mod_scope) is_reference, source_node = @from

; expose mod_ref

let @from.mod_ref = mod_scope

}

;; Named Clauses

[

(export_statement "type"? (export_clause )@clause)

(import_statement "type"? (import_clause (named_imports)@clause))

] {

node @clause.defs

node @clause.exports

node @clause.lexical_defs

node @clause.lexical_scope

}

;;;; Types

[

(export_statement "type"? (export_clause (export_specifier name:(_)@name))@clause)

(import_statement "type"? (import_clause (named_imports (import_specifier name:(_)@name))@clause))

] {

node @name.type_def

node @name.type_def__ns

node @name.type_ref

node @name.type_ref__ns

; type reference

attr (@name.type_ref) node_reference = @name

edge @name.type_ref -> @name.type_ref__ns

;

attr (@name.type_ref__ns) push_symbol = "%T"

edge @name.type_ref__ns -> @clause.lexical_scope

}

[

(export_statement "type"? (export_clause (export_specifier name:(_)@name !alias))@clause)

(import_statement "type"? (import_clause (named_imports (import_specifier name:(_)@name !alias))@clause))

] {

; type definition

edge @clause.defs -> @name.type_def__ns ; FIXME defs, lexical_defs?

;

attr (@name.type_def__ns) pop_symbol = "%T"

edge @name.type_def__ns -> @name.type_def

;

attr (@name.type_def) node_definition = @name

edge @name.type_def -> @name.type_ref

}

[

(export_statement "type"? (export_clause (export_specifier name:(_)@name alias:(_)@alias))@clause)

(import_statement "type"? (import_clause (named_imports (import_specifier name:(_)@name alias:(_)@alias))@clause))

] {

node @alias.type_def

node @alias.type_def__ns

node @alias.type_ref

; type definition

edge @clause.defs -> @alias.type_def__ns

;

attr (@alias.type_def__ns) pop_symbol = "%T"

edge @alias.type_def__ns -> @alias.type_def

;

attr (@alias.type_def) node_definition = @alias

edge @alias.type_def -> @name.type_ref

}

;;;; Expressions

[

(export_statement "type"?@is_type (export_clause (export_specifier name:(_)@name))@clause)

(import_statement "type"?@is_type (import_clause (named_imports (import_specifier name:(_)@name))@clause))

] {

if none @is_type {

edge @name.expr_ref__ns -> @clause.lexical_scope

}

}

[

(export_statement "type"?@is_type (export_clause (export_specifier name:(_)@name !alias))@clause)

(import_statement "type"?@is_type (import_clause (named_imports (import_specifier name:(_)@name !alias))@clause))

] {

if none @is_type {

node @name.expr_def

node @name.expr_def__ns

; expr definition

edge @clause.defs -> @name.expr_def__ns ; FIXME defs, lexical_defs?

;

attr (@name.expr_def__ns) pop_symbol = "%E"

edge @name.expr_def__ns -> @name.expr_def

;

attr (@name.expr_def) node_definition = @name

edge @name.expr_def -> @name.expr_ref

}

}

[

(export_statement "type"?@is_type (export_clause (export_specifier name:(_)@name alias:(_)@alias))@clause)

(import_statement "type"?@is_type (import_clause (named_imports (import_specifier name:(_)@name alias:(_)@alias))@clause))

] {

if none @is_type {

node @alias.expr_def

node @alias.expr_def__ns

; expr definition

edge @clause.defs -> @alias.expr_def__ns

;

attr (@alias.expr_def__ns) pop_symbol = "%E"

edge @alias.expr_def__ns -> @alias.expr_def

;

attr (@alias.expr_def) node_definition = @alias

edge @alias.expr_def -> @name.expr_ref

}

}

;; Exports

; export * from from MODULE

;

; (export_statement

; "*" source:(string)@name

; )@export_stmt

(export_statement

"*" source:(_)@name

)@export_stmt {

node expr_pop

node expr_push

attr (expr_pop) pop_symbol = "%E"

attr (expr_push) push_symbol = "%E"

edge expr_pop -> expr_push

node type_pop

node type_push

attr (type_pop) pop_symbol = "%E"

attr (type_push) push_symbol = "%E"

edge type_pop -> type_push

; export all expressions from source module

edge @export_stmt.exports -> expr_pop

edge expr_push -> @name.mod_ref

; export all types from source module

edge @export_stmt.exports -> type_pop

edge type_push -> @name.mod_ref

}

; export CLAUSE from MODULE

; export type CLAUSE from MODULE

;

; (export_statement

; "type"? (export_clause)@clause source:(_)@name

; )@export_stmt

(export_statement

"type"? (export_clause)@clause source:(_)@name

)@export_stmt {

; propagate lexical scope

edge @clause.lexical_scope -> @name.mod_ref

; propagate exports

edge @export_stmt.exports -> @clause.defs

}

; export CLAUSE

; export type CLAUSE

;

; (export_statement

; "type"?

; (export_clause)@clause

; )@export_stmt

(export_statement

"type"?

(export_clause)@clause

!source

)@export_stmt {

; propagate lexical scope

edge @clause.lexical_scope -> @export_stmt.lexical_scope

; propagate exports

edge @export_stmt.exports -> @clause.defs

}

; export DECL

;

; (export_statement

; ^"default"

; declaration:(_)@decl

; )@export_stmt

(export_statement

"default"?@is_default

declaration:(_)@decl

)@export_stmt {

if none @is_default {

; propagate lexical scope

edge @decl.lexical_scope -> @export_stmt.lexical_scope

; expose lexical definitions

edge @export_stmt.lexical_defs -> @decl.lexical_defs

; expose variable definitions

edge @export_stmt.var_defs -> @decl.var_defs

; export the definitions

edge @export_stmt.exports -> @decl.lexical_defs

edge @export_stmt.exports -> @decl.var_defs

}

}

; export default DECL

;

; (export_statement

; "default"

; declaration:(_)@decl

; )@export_stmt

; export default EXPR

;

; (export_statement

; "default"

; value:(_)@expr

; )@export_stmt

; export = NAME

;

; (export_statement

; "="

; (expression)@expr

; )@export_stmt

; NOTE Default exports are modeled as variables named "default", because the grammar

; treats "default" as a regular identifier instead of a keyword. This approach

; ensures renaming imports such as `import { default as X } from ...` work correctly.

;

; Default exports are generally expressions. However, if the export is specified as

; an identifier, the type with that name is also exported.

(export_statement

["default" "="]

)@export_stmt {

node @export_stmt.default_def

node @export_stmt.default_expr_def

node @export_stmt.default_expr_def__ns_pop

node @export_stmt.default_expr_def__ns_push

node @export_stmt.default_type_def

node @export_stmt.default_type_def__ns_pop

node @export_stmt.default_type_def__ns_push

; export as default expr

edge @export_stmt.exports -> @export_stmt.default_expr_def__ns_pop

;

attr (@export_stmt.default_expr_def__ns_pop) pop_symbol = "%E"

edge @export_stmt.default_expr_def__ns_pop -> @export_stmt.default_expr_def

;

;; @export_stmt.default_expr_def pop_symbol set below for "default" and "="

edge @export_stmt.default_expr_def -> @export_stmt.default_expr_def__ns_push

;

attr (@export_stmt.default_expr_def__ns_push) push_symbol = "%E"

edge @export_stmt.default_expr_def__ns_push -> @export_stmt.default_def

; export as default type

edge @export_stmt.exports -> @export_stmt.default_type_def__ns_pop

;

attr (@export_stmt.default_type_def__ns_pop) pop_symbol = "%T"

edge @export_stmt.default_type_def__ns_pop -> @export_stmt.default_type_def

;

;; @export_stmt.default_expr_def pop_symbol set below for "default" and "="

edge @export_stmt.default_type_def -> @export_stmt.default_type_def__ns_push

;

attr (@export_stmt.default_type_def__ns_push) push_symbol = "%T"

edge @export_stmt.default_type_def__ns_push -> @export_stmt.default_def

}

(export_statement

"default"

)@export_stmt {

attr (@export_stmt.default_expr_def) symbol_definition = "default", source_node = @export_stmt

attr (@export_stmt.default_type_def) symbol_definition = "default", source_node = @export_stmt

}

(export_statement

"="

)@export_stmt {

attr (@export_stmt.default_expr_def) symbol_definition = "<exports>", source_node = @export_stmt

attr (@export_stmt.default_type_def) symbol_definition = "<exports>", source_node = @export_stmt

}

(export_statement

"default"

declaration:(_)@decl

)@export_stmt {

; propagate lexical scope

edge @decl.lexical_scope -> @export_stmt.lexical_scope

; expose lexical definitions

edge @export_stmt.lexical_defs -> @decl.lexical_defs

; expose variable definitions

edge @export_stmt.var_defs -> @decl.var_defs

; export as default

edge @export_stmt.default_def -> @decl.default_export

}

[

(export_statement "default" value:(_)@expr)@export_stmt

(export_statement "=" . (_)@expr)@export_stmt

] {

node @export_stmt.default_expr__ns

node @export_stmt.default_expr__typeof

; propagate lexical scope

edge @expr.lexical_scope -> @export_stmt.lexical_scope

; expose lexical definitions

edge @export_stmt.lexical_defs -> @expr.lexical_defs

; expose variable definitions

edge @export_stmt.var_defs -> @expr.var_defs

; export expression as default

edge @export_stmt.default_def -> @export_stmt.default_expr__ns

;

attr (@export_stmt.default_expr__ns) pop_symbol = "%E"

edge @export_stmt.default_expr__ns -> @export_stmt.default_expr__typeof

;

attr (@export_stmt.default_expr__typeof) pop_symbol = ":"

edge @export_stmt.default_expr__typeof -> @expr.type

}

; NOTE an identifier in a default export can also be a type reference

[

(export_statement "default" value:(identifier)@name)@export_stmt

(export_statement "=" . (identifier)@name)@export_stmt

] {

node @export_stmt.default_type__ns

node @name.type_ref

node @name.type_ref__ns

; export type as default

edge @export_stmt.default_def -> @export_stmt.default_type__ns

;

attr (@export_stmt.default_type__ns) pop_symbol = "%T"

edge @export_stmt.default_type__ns -> @name.type_ref

;

attr (@name.type_ref) node_reference = @name

edge @name.type_ref -> @name.type_ref__ns

;

attr (@name.type_ref__ns) push_symbol = "%T"

edge @name.type_ref__ns -> @export_stmt.lexical_scope

}

; export * as namespace NAME

; (export_statement

; (namespace_export (identifier)@ns)

; source:(_)@from

; )

(export_statement

(namespace_export (identifier)@name)

source:(_)@from

)@export_stmt {

; namespace definitions are specified together with (module) and (internal_module)

; export expression definition

node expr_ns_pop

attr (expr_ns_pop) pop_symbol = "%E"

;

edge @export_stmt.exports -> expr_ns_pop

edge expr_ns_pop -> @name.expr_def

; export type definition

node type_ns_pop

attr (type_ns_pop) pop_symbol = "%T"

;

edge @export_stmt.exports -> type_ns_pop

edge type_ns_pop -> @name.type_def

; connect expression definition to exports

node expr_ns_push

attr (expr_ns_push) push_symbol = "%E"

;

edge @name.expr_def_member -> expr_ns_push

edge expr_ns_push -> @from.mod_ref

; connect type definition to exports

node type_ns_push

attr (type_ns_push) push_symbol = "%T"

;

edge @name.type_def_member -> type_ns_push

edge type_ns_push -> @from.mod_ref

}

; export as namespace NAME

;

; (export_statement

; "as"

; "namespace"

; (identifier)@name

; )@export_stmt

(program (export_statement

"as" "namespace" . (_)@name

))@prog {

; namespace definitions are specified together with (module) and (internal_module)

; make expression definition global

node expr_ns_pop

attr (expr_ns_pop) pop_symbol = "%E"

;

edge @prog.globals -> expr_ns_pop

edge expr_ns_pop -> @name.expr_def

; make type definition global

node type_ns_pop

attr (type_ns_pop) pop_symbol = "%T"

;

edge @prog.globals -> type_ns_pop

edge type_ns_pop -> @name.type_def

; connect expression definition to exports

node expr_ns_push

attr (expr_ns_push) push_symbol = "%E"

;

edge @name.expr_def_member -> expr_ns_push

edge expr_ns_push -> @prog.exports

; connect type definition to exports

node type_ns_push

attr (type_ns_push) push_symbol = "%T"

;

edge @name.type_def_member -> type_ns_push

edge type_ns_push -> @prog.exports

}

;; Imports

; import MODULE

;

; (import_statement

; ^(import_clause)