Separate use statement from other statements

nois.bnf

@@ -1,6 +1,6 @@
-module              ::= statement*
+module              ::= use-stmt* statement*
                     ;
-statement           ::= use-stmt | var-def | fn-def | kind-def | impl-def | type-def | return-stmt | expr
+statement           ::= var-def | fn-def | kind-def | impl-def | type-def | return-stmt | expr
                     ;
   use-stmt          ::= USE-KEYWORD use-expr
                     ;

src/ast/index.ts

@@ -1,4 +1,4 @@
-import { buildStatement, Statement } from './statement'
+import { buildStatement, buildUseExpr, Statement, UseExpr } from './statement'
 import { buildPattern, Pattern } from './match'
 import { NodeKind, ParseNode, ParseTree, treeKinds } from '../parser'
 import { lexerDynamicKinds } from '../lexer/lexer'
@@ -96,15 +96,14 @@ export const compactAstNode = (node: AstNode<any>): any => {
 }
 
 export interface Module extends AstNode<'module'> {
+    useExprs: UseExpr[]
     statements: Statement[]
 }
 
 export const buildModule = (node: ParseNode): Module => {
-    return {
-        kind: 'module',
-        parseNode: node,
-        statements: filterNonAstNodes(node).filter(n => n.kind === 'statement').map(n => buildStatement(n))
-    }
+    const useExprs = filterNonAstNodes(node).filter(n => n.kind === 'use-stmt').map(buildUseExpr)
+    const statements = filterNonAstNodes(node).filter(n => n.kind === 'statement').map(buildStatement)
+    return { kind: 'module', parseNode: node, useExprs, statements }
 }
 
 export interface Type extends AstNode<'type'> {

src/ast/statement.ts

@@ -5,13 +5,11 @@ import { buildPattern, Pattern } from './match'
 import { buildName, Identifier, Name } from './operand'
 import { ParseNode, ParseTree } from '../parser'
 
-export type Statement = UseExpr | VarDef | FnDef | KindDef | ImplDef | TypeDef | ReturnStmt | Expr
+export type Statement = VarDef | FnDef | KindDef | ImplDef | TypeDef | ReturnStmt | Expr
 
 export const buildStatement = (node: ParseNode): Statement => {
     const n = (<ParseTree>node).nodes[0]
     switch (n.kind) {
-        case 'use-stmt':
-            return buildUseExpr(n)
         case 'var-def':
             return buildVarDef(n)
         case 'fn-def':

src/parser/fns/index.ts

@@ -1,7 +1,7 @@
 import { TokenKind } from '../../lexer/lexer'
 import { Parser } from '../parser'
 import { parseExpr, parseIdentifier, parseTypeExpr } from './expr'
-import { parseBlock, parseStatement } from './statement'
+import { parseBlock, parseStatement, parseUseStmt } from './statement'
 import { parsePattern } from './match'
 
 export const prefixOpFirstTokens: TokenKind[] = ['excl', 'minus', 'period', 'plus']
@@ -14,10 +14,13 @@ export const paramFirstTokens: TokenKind[] = ['name']
 export const useExprFirstTokens: TokenKind[] = ['name', 'asterisk', 'o-brace']
 
 /**
- * module ::= statement*
+ * module ::= use-stmt* statement*
  */
 export const parseModule = (parser: Parser): void => {
     const mark = parser.open()
+    while (parser.at('use-keyword') && !parser.eof()) {
+        parseUseStmt(parser)
+    }
     while (!parser.eof()) {
         parseStatement(parser)
     }

src/parser/fns/statement.ts

@@ -5,14 +5,12 @@ import { parseExpr, parseTypeExpr } from './expr'
 import { parsePattern } from './match'
 
 /**
- * statement ::= use-stmt | var-def | fn-def | kind-def | impl-def | type-def | return-stmt | expr
+ * statement ::= var-def | fn-def | kind-def | impl-def | type-def | return-stmt | expr
  */
 export const parseStatement = (parser: Parser): void => {
     const mark = parser.open()
 
-    if (parser.at('use-keyword')) {
-        parseUseStmt(parser)
-    } else if (parser.at('let-keyword')) {
+    if (parser.at('let-keyword')) {
         parseVarDef(parser)
     } else if (parser.at('fn-keyword')) {
         parseFnDef(parser)