feat(using-for): add support for Using-For at root level

lib/antlr/visitors/exportVisitor.ts

@@ -16,6 +16,7 @@ import {
   SourceUnitContext,
   StructDefinitionContext,
   UserDefinedValueTypeDefinitionContext,
+  UsingDirectiveContext,
 } from '../generated/SolidityParser';
 import { ExportVisitResult, VisitCallback } from './types';
 
@@ -426,4 +427,28 @@ class ExportVisitor implements SolidityParserListener {
       name: name.text,
     });
   }
+
+  enterUsingDirective(ctx: UsingDirectiveContext): void {
+    if (!(ctx.parent instanceof SourceUnitContext)) {
+      return;
+    }
+
+    if (!ctx.stop) {
+      return;
+    }
+
+    const start = ctx.start.startIndex;
+    const end = ctx.stop.stopIndex;
+    const names = ctx.identifierPath();
+
+    const name =
+      names.map((n) => n.text).join(',') + `$${ExportType.usingDirective}`;
+
+    this.#onVisit({
+      type: ExportType.usingDirective,
+      start,
+      end,
+      name,
+    });
+  }
 }

lib/antlr/visitors/types.ts

@@ -20,7 +20,8 @@ export type ExportVisitResult =
   | ExportVisitResultContractLike
   | ExportVisitResultConstant
   | ExportVisitResultFunction
-  | ExportVisitResultUserDefinedValueType;
+  | ExportVisitResultUserDefinedValueType
+  | ExportVisitResultUsingDirective;
 
 export interface ExportVisitResultContractLike extends RangeVisitResult {
   abstract: boolean;
@@ -48,4 +49,9 @@ export interface ExportVisitResultUserDefinedValueType
   name: string;
 }
 
+export interface ExportVisitResultUsingDirective extends RangeVisitResult {
+  type: ExportType.usingDirective;
+  name: string;
+}
+
 export type VisitCallback<T extends RangeVisitResult> = (v: T) => void;

lib/exportsAnalyzer.ts

@@ -4,6 +4,7 @@ import {
   ExportVisitResultConstant,
   ExportVisitResultFunction,
   ExportVisitResultUserDefinedValueType,
+  ExportVisitResultUsingDirective,
 } from './antlr/visitors/types';
 import { ContractLikeExportType, ExportType } from './types';
 
@@ -13,7 +14,8 @@ export type ExportsAnalyzerResult =
   | ExportsAnalyzerResultContractLike
   | ExportsAnalyzerResultConstant
   | ExportsAnalyzerResultFunction
-  | ExportsAnalyzerResultUserDefinedValueType;
+  | ExportsAnalyzerResultUserDefinedValueType
+  | ExportsAnalyzerResultUsingDirective;
 
 export interface ExportsAnalyzerResultContractLike {
   abstract: boolean;
@@ -42,6 +44,12 @@ export interface ExportsAnalyzerResultUserDefinedValueType {
   body: string;
 }
 
+export interface ExportsAnalyzerResultUsingDirective {
+  type: ExportType.usingDirective;
+  name: string;
+  body: string;
+}
+
 export class ExportsAnalyzer {
   constructor(private contents: string) {}
 
@@ -78,6 +86,11 @@ export class ExportsAnalyzer {
           results.push(userDefinedValueTypeExport);
           return;
         }
+        if (e.type === ExportType.usingDirective) {
+          const usingDirectiveExport = this.analyzeUsingDirective(e);
+          results.push(usingDirectiveExport);
+          return;
+        }
         results.push({
           abstract: e.abstract,
           type: e.type,
@@ -125,4 +138,14 @@ export class ExportsAnalyzer {
       type: ExportType.userDefinedValueType,
     };
   }
+
+  private analyzeUsingDirective(
+    e: ExportVisitResultUsingDirective,
+  ): ExportsAnalyzerResultUsingDirective {
+    return {
+      body: this.contents.substring(e.start, e.end + 1),
+      name: e.name,
+      type: ExportType.usingDirective,
+    };
+  }
 }

lib/fileAnalyzer.ts

@@ -32,6 +32,10 @@ export class FileAnalyzer {
       return e.body;
     }
 
+    if (e.type === ExportType.usingDirective) {
+      return e.body;
+    }
+
     let is = e.is;
     if (is) {
       globalRenames.forEach((i) => {

lib/types.ts

@@ -11,11 +11,15 @@ export enum ExportType {
   constant = 'constant',
   function = 'function',
   userDefinedValueType = 'userDefinedValueType',
+  usingDirective = 'usingDirective',
 }
 
 export type ContractLikeExportType = Exclude<
   ExportType,
-  ExportType.constant | ExportType.function | ExportType.userDefinedValueType
+  | ExportType.constant
+  | ExportType.function
+  | ExportType.userDefinedValueType
+  | ExportType.usingDirective
 >;
 
 export interface ExportPluginProcessor {

test/compiled/UsingDirectiveContract.sol

@@ -0,0 +1,51 @@
+pragma solidity ^0.8.13;
+
+
+struct Data { mapping(uint => bool) flags; }
+
+// Now we attach functions to the type.
+// The attached functions can be used throughout the rest of the module.
+// If you import the module, you have to
+// repeat the using directive there, for example as
+//   import "flags.sol" as Flags;
+//   using {Flags.insert, Flags.remove, Flags.contains}
+//     for Flags.Data;
+using {insert, remove, contains} for Data;
+
+function insert(Data storage self, uint value)
+    returns (bool)
+{
+    if (self.flags[value])
+        return false; // already there
+    self.flags[value] = true;
+    return true;
+}
+
+function remove(Data storage self, uint value)
+    returns (bool)
+{
+    if (!self.flags[value])
+        return false; // not there
+    self.flags[value] = false;
+    return true;
+}
+
+function contains(Data storage self, uint value)
+    public
+    view
+    returns (bool)
+{
+    return self.flags[value];
+}
+
+contract C {
+    Data knownValues;
+
+    function register(uint value) public {
+        // Here, all variables of type Data have
+        // corresponding member functions.
+        // The following function call is identical to
+        // `Set.insert(knownValues, value)`
+        require(knownValues.insert(value));
+    }
+}

test/contracts/UsingDirectiveContract.sol

@@ -0,0 +1,50 @@
+pragma solidity ^0.8.13;
+
+struct Data { mapping(uint => bool) flags; }
+// Now we attach functions to the type.
+// The attached functions can be used throughout the rest of the module.
+// If you import the module, you have to
+// repeat the using directive there, for example as
+//   import "flags.sol" as Flags;
+//   using {Flags.insert, Flags.remove, Flags.contains}
+//     for Flags.Data;
+using {insert, remove, contains} for Data;
+
+function insert(Data storage self, uint value)
+    returns (bool)
+{
+    if (self.flags[value])
+        return false; // already there
+    self.flags[value] = true;
+    return true;
+}
+
+function remove(Data storage self, uint value)
+    returns (bool)
+{
+    if (!self.flags[value])
+        return false; // not there
+    self.flags[value] = false;
+    return true;
+}
+
+function contains(Data storage self, uint value)
+    public
+    view
+    returns (bool)
+{
+    return self.flags[value];
+}
+
+
+contract C {
+    Data knownValues;
+
+    function register(uint value) public {
+        // Here, all variables of type Data have
+        // corresponding member functions.
+        // The following function call is identical to
+        // `Set.insert(knownValues, value)`
+        require(knownValues.insert(value));
+    }
+}

test/index.spec.ts

@@ -132,4 +132,8 @@ describe('Solidity Merger', () => {
   it('should compile file with user defined types at root level (0.8 support)', async () => {
     await testFile('ContractWithUserDefinitionType');
   });
+
+  it('should compile file with using directive at root level (0.8.13 support)', async () => {
+    await testFile('UsingDirectiveContract');
+  });
 });