support for ContractSpecifiers

Author: Janther

src/slang-comments/handlers/handle-contract-definition-comments.ts

@@ -23,10 +23,10 @@ export default function handleContractDefinitionComments({
     locEnd(comment)
   );
 
-  // Everything before the InheritanceSpecifier is pushed onto the beginning of
+  // Everything before the ContractSpecifiers is pushed onto the beginning of
   // the ContractDefinition.
   if (
-    followingNode?.kind === NonterminalKind.InheritanceSpecifier ||
+    followingNode?.kind === NonterminalKind.ContractSpecifiers ||
     (followingNode?.kind === NonterminalKind.ContractMembers &&
       nextCharacter !== '{')
   ) {
@@ -42,16 +42,25 @@ export default function handleContractDefinitionComments({
 
   // The last comments before the body.
   if (nextCharacter === '{') {
-    // If there's an InheritanceSpecifier, the comment is appended to the last
-    // InheritanceType.
-    if (
-      precedingNode?.kind === NonterminalKind.InheritanceSpecifier &&
-      precedingNode.types.items.length > 0
-    ) {
-      addTrailingComment(
-        precedingNode.types.items[precedingNode.types.items.length - 1],
-        comment
-      );
+    if (precedingNode?.kind === NonterminalKind.ContractSpecifiers) {
+      if (precedingNode.items.length === 0) {
+        addTrailingComment(precedingNode, comment);
+        return true;
+      }
+      const lastContractSpecifier =
+        precedingNode.items[precedingNode.items.length - 1].variant;
+      // If the last ContractSpecifier's an InheritanceSpecifier, the comment
+      // is appended to the last InheritanceType.
+      if (lastContractSpecifier.kind === NonterminalKind.InheritanceSpecifier) {
+        addTrailingComment(
+          lastContractSpecifier.types.items[
+            lastContractSpecifier.types.items.length - 1
+          ],
+          comment
+        );
+        return true;
+      }
+      addTrailingComment(lastContractSpecifier, comment);
       return true;
     }
   }

src/slang-nodes/ContractDefinition.ts

@@ -3,7 +3,7 @@ import { coerce, satisfies } from 'semver';
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
 import { Identifier } from './Identifier.js';
-import { InheritanceSpecifier } from './InheritanceSpecifier.js';
+import { ContractSpecifiers } from './ContractSpecifiers.js';
 import { ContractMembers } from './ContractMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
@@ -24,7 +24,7 @@ export class ContractDefinition implements SlangNode {
 
   name: Identifier;
 
-  inheritance?: InheritanceSpecifier;
+  specifiers: ContractSpecifiers;
 
   members: ContractMembers;
 
@@ -33,12 +33,10 @@ export class ContractDefinition implements SlangNode {
 
     this.abstractKeyword = ast.abstractKeyword?.unparse();
     this.name = new Identifier(ast.name);
-    if (ast.inheritance) {
-      this.inheritance = new InheritanceSpecifier(ast.inheritance, options);
-    }
+    this.specifiers = new ContractSpecifiers(ast.specifiers, options);
     this.members = new ContractMembers(ast.members, options);
 
-    metadata = updateMetadata(metadata, [this.inheritance, this.members]);
+    metadata = updateMetadata(metadata, [this.specifiers, this.members]);
 
     this.comments = metadata.comments;
     this.loc = metadata.loc;
@@ -68,7 +66,8 @@ export class ContractDefinition implements SlangNode {
         this.abstractKeyword ? 'abstract ' : '',
         'contract ',
         path.call(print, 'name'),
-        this.inheritance ? [' ', path.call(print, 'inheritance')] : line,
+        path.call(print, 'specifiers'),
+        this.specifiers.items.length > 0 ? '' : line,
         '{'
       ]),
       path.call(print, 'members'),

src/slang-nodes/ContractSpecifier.ts

@@ -0,0 +1,48 @@
+import { NonterminalKind } from '@nomicfoundation/slang/cst';
+import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { InheritanceSpecifier } from './InheritanceSpecifier.js';
+import { StorageLayoutSpecifier } from './StorageLayoutSpecifier.js';
+
+import type * as ast from '@nomicfoundation/slang/ast';
+import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { AstNode } from './types.js';
+import type { PrintFunction, SlangNode } from '../types.js';
+
+export class ContractSpecifier implements SlangNode {
+  readonly kind = NonterminalKind.ContractSpecifier;
+
+  comments;
+
+  loc;
+
+  variant: InheritanceSpecifier | StorageLayoutSpecifier;
+
+  constructor(ast: ast.ContractSpecifier, options: ParserOptions<AstNode>) {
+    let metadata = getNodeMetadata(ast);
+
+    switch (ast.variant.cst.kind) {
+      case NonterminalKind.InheritanceSpecifier:
+        this.variant = new InheritanceSpecifier(
+          ast.variant as ast.InheritanceSpecifier,
+          options
+        );
+        break;
+      case NonterminalKind.StorageLayoutSpecifier:
+        this.variant = new StorageLayoutSpecifier(
+          ast.variant as ast.StorageLayoutSpecifier,
+          options
+        );
+        break;
+      default:
+        throw new Error(`Unexpected variant: ${ast.variant.cst.kind}`);
+    }
+    metadata = updateMetadata(metadata, [this.variant]);
+
+    this.comments = metadata.comments;
+    this.loc = metadata.loc;
+  }
+
+  print(path: AstPath<ContractSpecifier>, print: PrintFunction): Doc {
+    return path.call(print, 'variant');
+  }
+}

src/slang-nodes/ContractSpecifiers.ts

@@ -0,0 +1,52 @@
+import { doc } from 'prettier';
+import { NonterminalKind } from '@nomicfoundation/slang/cst';
+import { sortContractSpecifiers } from '../slang-utils/sort-contract-specifiers.js';
+import { printSeparatedList } from '../slang-printers/print-separated-list.js';
+import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { ContractSpecifier } from './ContractSpecifier.js';
+
+import type * as ast from '@nomicfoundation/slang/ast';
+import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { AstNode } from './types.js';
+import type { PrintFunction, SlangNode } from '../types.js';
+
+const { group, ifBreak, line, softline } = doc.builders;
+
+export class ContractSpecifiers implements SlangNode {
+  readonly kind = NonterminalKind.ContractSpecifiers;
+
+  comments;
+
+  loc;
+
+  items: ContractSpecifier[];
+
+  constructor(ast: ast.ContractSpecifiers, options: ParserOptions<AstNode>) {
+    let metadata = getNodeMetadata(ast, true);
+
+    this.items = ast.items.map((item) => new ContractSpecifier(item, options));
+
+    metadata = updateMetadata(metadata, [this.items]);
+
+    this.comments = metadata.comments;
+    this.loc = metadata.loc;
+
+    this.items = this.items.sort(sortContractSpecifiers);
+  }
+
+  print(path: AstPath<ContractSpecifiers>, print: PrintFunction): Doc {
+    if (this.items.length === 0) return '';
+
+    const [specifier1, specifier2] = path.map(print, 'items');
+    if (typeof specifier2 === 'undefined') return [' ', specifier1];
+
+    const groupId = Symbol('Slang.ContractSpecifiers.inheritance');
+    return printSeparatedList(
+      [group(specifier1, { id: groupId }), specifier2],
+      {
+        firstSeparator: line,
+        separator: ifBreak('', softline, { groupId })
+      }
+    );
+  }
+}

src/slang-nodes/StorageLayoutSpecifier.ts

@@ -0,0 +1,45 @@
+import { doc } from 'prettier';
+import { NonterminalKind } from '@nomicfoundation/slang/cst';
+import { printSeparatedItem } from '../slang-printers/print-separated-item.js';
+import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { Expression } from './Expression.js';
+
+import type * as ast from '@nomicfoundation/slang/ast';
+import type { AstPath, Doc, ParserOptions } from 'prettier';
+import type { AstNode } from './types.js';
+import type { PrintFunction, SlangNode } from '../types.js';
+
+const { line } = doc.builders;
+
+export class StorageLayoutSpecifier implements SlangNode {
+  readonly kind = NonterminalKind.StorageLayoutSpecifier;
+
+  comments;
+
+  loc;
+
+  expression: Expression;
+
+  constructor(
+    ast: ast.StorageLayoutSpecifier,
+    options: ParserOptions<AstNode>
+  ) {
+    let metadata = getNodeMetadata(ast);
+
+    this.expression = new Expression(ast.expression, options);
+
+    metadata = updateMetadata(metadata, [this.expression]);
+
+    this.comments = metadata.comments;
+    this.loc = metadata.loc;
+  }
+
+  print(path: AstPath<StorageLayoutSpecifier>, print: PrintFunction): Doc {
+    return [
+      'layout at',
+      printSeparatedItem(path.call(print, 'expression'), {
+        firstSeparator: line
+      })
+    ];
+  }
+}

src/slang-nodes/types.d.ts

@@ -29,6 +29,8 @@ import type { ContinueStatement } from './ContinueStatement.ts';
 import type { ContractDefinition } from './ContractDefinition.ts';
 import type { ContractMember } from './ContractMember.ts';
 import type { ContractMembers } from './ContractMembers.ts';
+import type { ContractSpecifier } from './ContractSpecifier.ts';
+import type { ContractSpecifiers } from './ContractSpecifiers.ts';
 import type { DecimalNumberExpression } from './DecimalNumberExpression.ts';
 import type { DoWhileStatement } from './DoWhileStatement.ts';
 import type { ElementaryType } from './ElementaryType.ts';
@@ -139,6 +141,7 @@ import type { StateVariableAttribute } from './StateVariableAttribute.ts';
 import type { StateVariableAttributes } from './StateVariableAttributes.ts';
 import type { StateVariableDefinition } from './StateVariableDefinition.ts';
 import type { StateVariableDefinitionValue } from './StateVariableDefinitionValue.ts';
+import type { StorageLayoutSpecifier } from './StorageLayoutSpecifier.ts';
 import type { StorageLocation } from './StorageLocation.ts';
 import type { StringExpression } from './StringExpression.ts';
 import type { StringLiteral } from './StringLiteral.ts';
@@ -257,6 +260,7 @@ export type StrictAstNode =
   | ContractDefinition
   | InheritanceSpecifier
   | InheritanceType
+  | StorageLayoutSpecifier
   | InterfaceDefinition
   | LibraryDefinition
   | StructDefinition
@@ -411,6 +415,8 @@ export type StrictAstNode =
   | YulLiteral
   | SourceUnitMembers
   | VersionExpressionSet
+  | ContractSpecifier
+  | ContractSpecifiers
   | ContractMembers
   | InterfaceMembers
   | LibraryMembers

src/slang-utils/sort-contract-specifiers.ts

@@ -0,0 +1,25 @@
+import { NonterminalKind } from '@nomicfoundation/slang/cst';
+
+import type { ContractSpecifier } from '../slang-nodes/ContractSpecifier.js';
+
+export function sortContractSpecifiers(
+  a: ContractSpecifier,
+  b: ContractSpecifier
+): number {
+  const aVariant = a.variant;
+  const bVariant = b.variant;
+
+  // OverrideSpecifiers before ModifierInvocation
+  if (
+    aVariant.kind === NonterminalKind.InheritanceSpecifier &&
+    bVariant.kind === NonterminalKind.StorageLayoutSpecifier
+  )
+    return -1;
+  if (
+    bVariant.kind === NonterminalKind.InheritanceSpecifier &&
+    aVariant.kind === NonterminalKind.StorageLayoutSpecifier
+  )
+    return 1;
+
+  return 0;
+}