Merge pull request #6 from jeasonstudio/feat-modify-g4-support-using-…

…aliases

feat: support using aliases

.gitignore

@@ -129,3 +129,5 @@ dist
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+
+grammar/.antlr/*

grammar/SolidityParser.g4

@@ -337,7 +337,14 @@ userDefinableOperator:
  * Using directive to attach library functions and free functions to types.
  * Can occur within contracts and libraries and at the file level.
  */
-usingDirective: Using (identifierPath | (LBrace identifierPath (As userDefinableOperator)? (Comma identifierPath (As userDefinableOperator)?)* RBrace)) For (Mul | typeName) Global? Semicolon;
+usingDirective:
+  Using (
+    identifierPath
+    | (LBrace usingAliases (Comma usingAliases)* RBrace)
+  ) For (Mul | typeName) Global? Semicolon;
+
+usingAliases: identifierPath (As userDefinableOperator)?;
+
 /**
  * A type name can be an elementary type, a function type, a mapping type, a user-defined type
  * (e.g. a contract or struct) or an array type.

src/antlr4/SolidityParserListener.ts

@@ -41,6 +41,7 @@ import { ErrorParameterContext } from "./SolidityParser.js";
 import { ErrorDefinitionContext } from "./SolidityParser.js";
 import { UserDefinableOperatorContext } from "./SolidityParser.js";
 import { UsingDirectiveContext } from "./SolidityParser.js";
+import { UsingAliasesContext } from "./SolidityParser.js";
 import { TypeNameContext } from "./SolidityParser.js";
 import { ElementaryTypeNameContext } from "./SolidityParser.js";
 import { FunctionTypeNameContext } from "./SolidityParser.js";
@@ -507,6 +508,16 @@ export class SolidityParserListener implements ParseTreeListener {
      * @param ctx the parse tree
      */
     exitUsingDirective?: (ctx: UsingDirectiveContext) => void;
+    /**
+     * Enter a parse tree produced by `SolidityParser.usingAliases`.
+     * @param ctx the parse tree
+     */
+    enterUsingAliases?: (ctx: UsingAliasesContext) => void;
+    /**
+     * Exit a parse tree produced by `SolidityParser.usingAliases`.
+     * @param ctx the parse tree
+     */
+    exitUsingAliases?: (ctx: UsingAliasesContext) => void;
     /**
      * Enter a parse tree produced by `SolidityParser.typeName`.
      * @param ctx the parse tree

src/antlr4/SolidityParserVisitor.ts

@@ -41,6 +41,7 @@ import { ErrorParameterContext } from "./SolidityParser.js";
 import { ErrorDefinitionContext } from "./SolidityParser.js";
 import { UserDefinableOperatorContext } from "./SolidityParser.js";
 import { UsingDirectiveContext } from "./SolidityParser.js";
+import { UsingAliasesContext } from "./SolidityParser.js";
 import { TypeNameContext } from "./SolidityParser.js";
 import { ElementaryTypeNameContext } from "./SolidityParser.js";
 import { FunctionTypeNameContext } from "./SolidityParser.js";
@@ -358,6 +359,12 @@ export class SolidityParserVisitor<Result> extends AbstractParseTreeVisitor<Resu
      * @return the visitor result
      */
     visitUsingDirective?: (ctx: UsingDirectiveContext) => Result;
+    /**
+     * Visit a parse tree produced by `SolidityParser.usingAliases`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitUsingAliases?: (ctx: UsingAliasesContext) => Result;
     /**
      * Visit a parse tree produced by `SolidityParser.typeName`.
      * @param ctx the parse tree

src/ast/builder.ts

@@ -59,6 +59,7 @@ export class SolidityASTBuilder extends parser.SolidityParserVisitor<ast.SyntaxN
   visitErrorDefinition = (ctx: parser.ErrorDefinitionContext) => new ast.ErrorDefinition(ctx, this);
   visitUserDefinableOperator = (ctx: parser.UserDefinableOperatorContext) =>
     new ast.UserDefinableOperator(ctx, this);
+  visitUsingAliases = (ctx: parser.UsingAliasesContext) => new ast.UsingAliases(ctx, this);
   visitUsingDirective = (ctx: parser.UsingDirectiveContext) => new ast.UsingDirective(ctx, this);
   visitTypeName = (ctx: parser.TypeNameContext) => new ast.TypeName(ctx, this);
   visitElementaryTypeName = (ctx: parser.ElementaryTypeNameContext) =>

src/ast/meta/index.node.ts

@@ -7,6 +7,7 @@ import { ModifierInvocation } from './modifier-invocation';
 import { Path } from './path';
 import { PragmaDirective } from './pragma-directive';
 import { SourceUnit } from './source-unit';
+import { UsingAliases } from './using-aliases';
 import { UsingDirective } from './using-directive';
 
 export {
@@ -19,5 +20,6 @@ export {
   Path,
   PragmaDirective,
   SourceUnit,
+  UsingAliases,
   UsingDirective,
 };

src/ast/meta/index.ts

@@ -18,4 +18,5 @@ export * from './path';
 export * from './pragma-directive';
 export * from './source-unit';
 export * from './symbol-aliases';
+export * from './using-aliases';
 export * from './using-directive';

src/ast/meta/using-aliases.ts

@@ -0,0 +1,15 @@
+import { BaseNode } from '../base';
+import { UsingAliasesContext, SolidityParserVisitor } from '../../antlr4';
+import { IdentifierPath } from './identifier-path';
+import { UserDefinableOperator } from '../expression';
+
+export class UsingAliases extends BaseNode {
+  type = 'UsingAliases' as const;
+  name: IdentifierPath;
+  operator: UserDefinableOperator | null = null;
+  constructor(ctx: UsingAliasesContext, visitor: SolidityParserVisitor<any>) {
+    super(ctx, visitor);
+    this.name = ctx.identifierPath().accept(visitor);
+    this.operator = ctx.userDefinableOperator()?.accept(visitor) ?? null;
+  }
+}

src/ast/meta/using-directive.ts

@@ -3,31 +3,23 @@ import { UsingDirectiveContext, SolidityParserVisitor } from '../../antlr4';
 import { UserDefinedValueTypeDefinition } from '../declaration';
 import { IdentifierPath } from './identifier-path';
 import { TypeName } from '../type';
-import { UserDefinableOperator } from '../expression';
+import { UsingAliases } from './using-aliases';
 
 export class UsingDirective extends BaseNode {
   type = 'UsingDirective' as const;
   global: boolean;
   libraryName: UserDefinedValueTypeDefinition | IdentifierPath | null = null;
-  definitions: IdentifierPath[] | null = null;
-  operators: (UserDefinableOperator | null)[] | null = null;
+  usingAliases: UsingAliases[] | null = null;
   typeName: TypeName | '*';
   constructor(ctx: UsingDirectiveContext, visitor: SolidityParserVisitor<any>) {
     super(ctx, visitor);
     this.global = !!ctx.Global();
     this.typeName = !!ctx.Mul() ? '*' : ctx.typeName()?.accept(visitor);
 
-    const isObjectUsing = !!ctx.LBrace() && !!ctx.RBrace();
-    if (!isObjectUsing) {
-      this.libraryName = ctx.identifierPath(0)?.accept(visitor) ?? null;
+    if (ctx.identifierPath() && !ctx.usingAliases().length) {
+      this.libraryName = ctx.identifierPath()!.accept(visitor);
     } else {
-      this.operators = [];
-      this.definitions = [];
-      ctx.identifierPath().forEach((p, index) => {
-        this.definitions![index] = p.accept(visitor);
-        // TODO@jeason: How to relate operator and definition together
-        this.operators![index] = null;
-      });
+      this.usingAliases = ctx.usingAliases().map((usingAlias) => usingAlias.accept(visitor));
     }
   }
 }

src/tests/meta.test.ts

@@ -30,16 +30,12 @@ test('usingDirective', () => {
     global: true,
   });
   expect(createParse((p) => p.usingDirective())(`using { A, C.D } for B;`)).toMatchObject({
-    definitions: ['A', 'C.D'],
+    usingAliases: [{ name: 'A' }, { name: 'C.D' }],
     typeName: 'B',
     global: false,
   });
   expect(createParse((p) => p.usingDirective())(`using { B, add as + } for B;`)).toMatchObject({
-    definitions: [
-      'B',
-      'add',
-      // operator: '+', // TODO
-    ],
+    usingAliases: [{ name: 'B' }, { name: 'add', operator: '+' }],
     typeName: 'B',
     global: false,
   });