fix(parser): Create AST for modules

Author: robertoraggi

Diff for: packages/cxx-frontend/src/AST.ts

@@ -425,6 +425,105 @@ export class TypeConstraintAST extends AST {
     }
 }
 
+export class GlobalModuleFragmentAST extends AST {
+    accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
+        return visitor.visitGlobalModuleFragment(this, context);
+    }
+    getModuleToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+    }
+    getSemicolonToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+    }
+    *getDeclarationList(): Generator<DeclarationAST | undefined> {
+        for (let it = cxx.getASTSlot(this.getHandle(), 2); it; it = cxx.getListNext(it)) {
+            yield AST.from<DeclarationAST>(cxx.getListValue(it), this.parser);
+        }
+    }
+}
+
+export class PrivateModuleFragmentAST extends AST {
+    accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
+        return visitor.visitPrivateModuleFragment(this, context);
+    }
+    getModuleToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+    }
+    getColonToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+    }
+    getPrivateToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 2), this.parser);
+    }
+    getSemicolonToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 3), this.parser);
+    }
+    *getDeclarationList(): Generator<DeclarationAST | undefined> {
+        for (let it = cxx.getASTSlot(this.getHandle(), 4); it; it = cxx.getListNext(it)) {
+            yield AST.from<DeclarationAST>(cxx.getListValue(it), this.parser);
+        }
+    }
+}
+
+export class ModuleDeclarationAST extends AST {
+    accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
+        return visitor.visitModuleDeclaration(this, context);
+    }
+    getExportToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+    }
+    getModuleToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+    }
+    getModuleName(): ModuleNameAST | undefined {
+        return AST.from<ModuleNameAST>(cxx.getASTSlot(this.getHandle(), 2), this.parser);
+    }
+    getModulePartition(): ModulePartitionAST | undefined {
+        return AST.from<ModulePartitionAST>(cxx.getASTSlot(this.getHandle(), 3), this.parser);
+    }
+    *getAttributeList(): Generator<AttributeAST | undefined> {
+        for (let it = cxx.getASTSlot(this.getHandle(), 4); it; it = cxx.getListNext(it)) {
+            yield AST.from<AttributeAST>(cxx.getListValue(it), this.parser);
+        }
+    }
+    getSemicolonToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 5), this.parser);
+    }
+}
+
+export class ModuleNameAST extends AST {
+    accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
+        return visitor.visitModuleName(this, context);
+    }
+}
+
+export class ImportNameAST extends AST {
+    accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
+        return visitor.visitImportName(this, context);
+    }
+    getHeaderToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+    }
+    getModulePartition(): ModulePartitionAST | undefined {
+        return AST.from<ModulePartitionAST>(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+    }
+    getModuleName(): ModuleNameAST | undefined {
+        return AST.from<ModuleNameAST>(cxx.getASTSlot(this.getHandle(), 2), this.parser);
+    }
+}
+
+export class ModulePartitionAST extends AST {
+    accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
+        return visitor.visitModulePartition(this, context);
+    }
+    getColonToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+    }
+    getModuleName(): ModuleNameAST | undefined {
+        return AST.from<ModuleNameAST>(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+    }
+}
+
 export class SimpleRequirementAST extends RequirementAST {
     accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
         return visitor.visitSimpleRequirement(this, context);
@@ -814,6 +913,20 @@ export class ModuleUnitAST extends UnitAST {
     accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
         return visitor.visitModuleUnit(this, context);
     }
+    getGlobalModuleFragment(): GlobalModuleFragmentAST | undefined {
+        return AST.from<GlobalModuleFragmentAST>(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+    }
+    getModuleDeclaration(): ModuleDeclarationAST | undefined {
+        return AST.from<ModuleDeclarationAST>(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+    }
+    *getDeclarationList(): Generator<DeclarationAST | undefined> {
+        for (let it = cxx.getASTSlot(this.getHandle(), 2); it; it = cxx.getListNext(it)) {
+            yield AST.from<DeclarationAST>(cxx.getListValue(it), this.parser);
+        }
+    }
+    getPrivateModuleFragmentAST(): PrivateModuleFragmentAST | undefined {
+        return AST.from<PrivateModuleFragmentAST>(cxx.getASTSlot(this.getHandle(), 3), this.parser);
+    }
 }
 
 export class ThisExpressionAST extends ExpressionAST {
@@ -2065,12 +2178,52 @@ export class ExportDeclarationAST extends DeclarationAST {
     accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
         return visitor.visitExportDeclaration(this, context);
     }
+    getExportToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+    }
+    getDeclaration(): DeclarationAST | undefined {
+        return AST.from<DeclarationAST>(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+    }
+}
+
+export class ExportCompoundDeclarationAST extends DeclarationAST {
+    accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
+        return visitor.visitExportCompoundDeclaration(this, context);
+    }
+    getExportToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+    }
+    getLbraceToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+    }
+    *getDeclarationList(): Generator<DeclarationAST | undefined> {
+        for (let it = cxx.getASTSlot(this.getHandle(), 2); it; it = cxx.getListNext(it)) {
+            yield AST.from<DeclarationAST>(cxx.getListValue(it), this.parser);
+        }
+    }
+    getRbraceToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 3), this.parser);
+    }
 }
 
 export class ModuleImportDeclarationAST extends DeclarationAST {
     accept<Context, Result>(visitor: ASTVisitor<Context, Result>, context: Context): Result {
         return visitor.visitModuleImportDeclaration(this, context);
     }
+    getImportToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 0), this.parser);
+    }
+    getImportName(): ImportNameAST | undefined {
+        return AST.from<ImportNameAST>(cxx.getASTSlot(this.getHandle(), 1), this.parser);
+    }
+    *getAttributeList(): Generator<AttributeAST | undefined> {
+        for (let it = cxx.getASTSlot(this.getHandle(), 2); it; it = cxx.getListNext(it)) {
+            yield AST.from<AttributeAST>(cxx.getListValue(it), this.parser);
+        }
+    }
+    getSemicolonToken(): Token | undefined {
+        return Token.from(cxx.getASTSlot(this.getHandle(), 3), this.parser);
+    }
 }
 
 export class TemplateDeclarationAST extends DeclarationAST {
@@ -2906,6 +3059,12 @@ const AST_CONSTRUCTORS: Array<new (handle: number, kind: ASTKind, parser: Parser
     CtorInitializerAST,
     RequirementBodyAST,
     TypeConstraintAST,
+    GlobalModuleFragmentAST,
+    PrivateModuleFragmentAST,
+    ModuleDeclarationAST,
+    ModuleNameAST,
+    ImportNameAST,
+    ModulePartitionAST,
     SimpleRequirementAST,
     CompoundRequirementAST,
     TypeRequirementAST,
@@ -3006,6 +3165,7 @@ const AST_CONSTRUCTORS: Array<new (handle: number, kind: ASTKind, parser: Parser
     UsingDeclarationAST,
     AsmDeclarationAST,
     ExportDeclarationAST,
+    ExportCompoundDeclarationAST,
     ModuleImportDeclarationAST,
     TemplateDeclarationAST,
     TypenameTypeParameterAST,

Diff for: packages/cxx-frontend/src/ASTKind.ts

@@ -41,6 +41,12 @@ export enum ASTKind {
     CtorInitializer,
     RequirementBody,
     TypeConstraint,
+    GlobalModuleFragment,
+    PrivateModuleFragment,
+    ModuleDeclaration,
+    ModuleName,
+    ImportName,
+    ModulePartition,
 
     // RequirementAST
     SimpleRequirement,
@@ -165,6 +171,7 @@ export enum ASTKind {
     UsingDeclaration,
     AsmDeclaration,
     ExportDeclaration,
+    ExportCompoundDeclaration,
     ModuleImportDeclaration,
     TemplateDeclaration,
     TypenameTypeParameter,

Diff for: packages/cxx-frontend/src/ASTVisitor.ts

@@ -45,6 +45,12 @@ export abstract class ASTVisitor<Context, Result> {
     abstract visitCtorInitializer(node: ast.CtorInitializerAST, context: Context): Result;
     abstract visitRequirementBody(node: ast.RequirementBodyAST, context: Context): Result;
     abstract visitTypeConstraint(node: ast.TypeConstraintAST, context: Context): Result;
+    abstract visitGlobalModuleFragment(node: ast.GlobalModuleFragmentAST, context: Context): Result;
+    abstract visitPrivateModuleFragment(node: ast.PrivateModuleFragmentAST, context: Context): Result;
+    abstract visitModuleDeclaration(node: ast.ModuleDeclarationAST, context: Context): Result;
+    abstract visitModuleName(node: ast.ModuleNameAST, context: Context): Result;
+    abstract visitImportName(node: ast.ImportNameAST, context: Context): Result;
+    abstract visitModulePartition(node: ast.ModulePartitionAST, context: Context): Result;
 
     // RequirementAST
     abstract visitSimpleRequirement(node: ast.SimpleRequirementAST, context: Context): Result;
@@ -169,6 +175,7 @@ export abstract class ASTVisitor<Context, Result> {
     abstract visitUsingDeclaration(node: ast.UsingDeclarationAST, context: Context): Result;
     abstract visitAsmDeclaration(node: ast.AsmDeclarationAST, context: Context): Result;
     abstract visitExportDeclaration(node: ast.ExportDeclarationAST, context: Context): Result;
+    abstract visitExportCompoundDeclaration(node: ast.ExportCompoundDeclarationAST, context: Context): Result;
     abstract visitModuleImportDeclaration(node: ast.ModuleImportDeclarationAST, context: Context): Result;
     abstract visitTemplateDeclaration(node: ast.TemplateDeclarationAST, context: Context): Result;
     abstract visitTypenameTypeParameter(node: ast.TypenameTypeParameterAST, context: Context): Result;

Diff for: packages/cxx-frontend/src/RecursiveASTVisitor.ts

@@ -161,6 +161,38 @@ export class RecursiveASTVisitor<Context> extends ASTVisitor<Context, void> {
         this.accept(node.getName(), context);
     }
 
+    visitGlobalModuleFragment(node: ast.GlobalModuleFragmentAST, context: Context): void {
+        for (const element of node.getDeclarationList()) {
+            this.accept(element, context);
+        }
+    }
+
+    visitPrivateModuleFragment(node: ast.PrivateModuleFragmentAST, context: Context): void {
+        for (const element of node.getDeclarationList()) {
+            this.accept(element, context);
+        }
+    }
+
+    visitModuleDeclaration(node: ast.ModuleDeclarationAST, context: Context): void {
+        this.accept(node.getModuleName(), context);
+        this.accept(node.getModulePartition(), context);
+        for (const element of node.getAttributeList()) {
+            this.accept(element, context);
+        }
+    }
+
+    visitModuleName(node: ast.ModuleNameAST, context: Context): void {
+    }
+
+    visitImportName(node: ast.ImportNameAST, context: Context): void {
+        this.accept(node.getModulePartition(), context);
+        this.accept(node.getModuleName(), context);
+    }
+
+    visitModulePartition(node: ast.ModulePartitionAST, context: Context): void {
+        this.accept(node.getModuleName(), context);
+    }
+
     visitSimpleRequirement(node: ast.SimpleRequirementAST, context: Context): void {
         this.accept(node.getExpression(), context);
     }
@@ -284,6 +316,12 @@ export class RecursiveASTVisitor<Context> extends ASTVisitor<Context, void> {
     }
 
     visitModuleUnit(node: ast.ModuleUnitAST, context: Context): void {
+        this.accept(node.getGlobalModuleFragment(), context);
+        this.accept(node.getModuleDeclaration(), context);
+        for (const element of node.getDeclarationList()) {
+            this.accept(element, context);
+        }
+        this.accept(node.getPrivateModuleFragmentAST(), context);
     }
 
     visitThisExpression(node: ast.ThisExpressionAST, context: Context): void {
@@ -644,9 +682,20 @@ export class RecursiveASTVisitor<Context> extends ASTVisitor<Context, void> {
     }
 
     visitExportDeclaration(node: ast.ExportDeclarationAST, context: Context): void {
+        this.accept(node.getDeclaration(), context);
+    }
+
+    visitExportCompoundDeclaration(node: ast.ExportCompoundDeclarationAST, context: Context): void {
+        for (const element of node.getDeclarationList()) {
+            this.accept(element, context);
+        }
     }
 
     visitModuleImportDeclaration(node: ast.ModuleImportDeclarationAST, context: Context): void {
+        this.accept(node.getImportName(), context);
+        for (const element of node.getAttributeList()) {
+            this.accept(element, context);
+        }
     }
 
     visitTemplateDeclaration(node: ast.TemplateDeclarationAST, context: Context): void {