Udate remaining logic

  - using provided `asNonterminalNode` method instead of manually casting the tree.
  - using Parser instead of Language
  - some accessors became methods and some methods became accessors
  - using isNodeTerminal() since Node.type was removed
  - cst.children used to return Node[], now it returns Edge[]

Author: Janther

src/index.ts

@@ -16,7 +16,7 @@ import type {
   RequiredOptions,
   SupportLanguage
 } from 'prettier';
-import type { AstNode } from './slang-nodes';
+import type { AstNode } from './slang-nodes/index.d.ts';
 
 const slangParserId = 'slang-solidity';
 const antlrParserId = 'solidity-parse';

src/slang-utils/infer-language.ts

@@ -1,7 +1,6 @@
-import { VersionExpressionSets as SlangVersionExpressionSets } from '@nomicfoundation/slang/ast/index.js';
-import { NonterminalKind } from '@nomicfoundation/slang/kinds/index.js';
-import { Language } from '@nomicfoundation/slang/language/index.js';
-import { Query } from '@nomicfoundation/slang/query/index.js';
+import { VersionExpressionSets as SlangVersionExpressionSets } from '@nomicfoundation/slang/ast';
+import { NonterminalKind, Query } from '@nomicfoundation/slang/cst';
+import { Parser } from '@nomicfoundation/slang/parser';
 import {
   maxSatisfying,
   minSatisfying,
@@ -12,9 +11,7 @@ import {
 } from 'semver';
 import { VersionExpressionSets } from '../slang-nodes/VersionExpressionSets.js';
 
-import type { NonterminalNode } from '@nomicfoundation/slang/cst';
-
-const supportedVersions = Language.supportedVersions();
+const supportedVersions = Parser.supportedVersions();
 
 const milestoneVersions = Array.from(
   supportedVersions.reduce((minorRanges, version) => {
@@ -29,7 +26,7 @@ const milestoneVersions = Array.from(
     return versions;
   }, []);
 
-export function inferLanguage(text: string): Language {
+export function inferLanguage(text: string): Parser {
   let inferredRange = '';
 
   for (const version of milestoneVersions) {
@@ -48,12 +45,12 @@ export function inferLanguage(text: string): Language {
   const maxSatisfyingVersion = maxSatisfying(supportedVersions, inferredRange);
 
   return maxSatisfyingVersion
-    ? new Language(maxSatisfyingVersion)
-    : new Language(supportedVersions[supportedVersions.length - 1]);
+    ? Parser.create(maxSatisfyingVersion)
+    : Parser.create(supportedVersions[supportedVersions.length - 1]);
 }
 
 function tryToCollectPragmas(text: string, version: string): string {
-  const language = new Language(version);
+  const language = Parser.create(version);
   const parseOutput = language.parse(NonterminalKind.SourceUnit, text);
   const query = Query.parse(
     '[VersionPragma @versionRanges [VersionExpressionSets]]'
@@ -64,7 +61,7 @@ function tryToCollectPragmas(text: string, version: string): string {
   let match;
   while ((match = matches.next())) {
     const versionRange = new SlangVersionExpressionSets(
-      match.captures.versionRanges[0].node() as NonterminalNode
+      match.captures.versionRanges[0].node.asNonterminalNode()!
     );
     ranges.push(
       // Replace all comments that could be in the expression with whitespace
@@ -78,7 +75,7 @@ function tryToCollectPragmas(text: string, version: string): string {
   // Check if we found pragmas.
   if (ranges.length === 0) {
     // If we didn't find pragmas but succeeded parsing the source we keep it.
-    if (parseOutput.isValid) {
+    if (parseOutput.isValid()) {
       return version;
     }
     // Otherwise we throw.

src/slang-utils/metadata.ts

@@ -1,14 +1,13 @@
-import { TerminalKind } from '@nomicfoundation/slang/kinds/index.js';
-import { NodeType } from '@nomicfoundation/slang/cst/index.js';
+import { TerminalKind } from '@nomicfoundation/slang/cst';
 import { createKindCheckFunction } from './create-kind-check-function.js';
 import { MultiLineComment } from '../slang-nodes/MultiLineComment.js';
 import { MultiLineNatSpecComment } from '../slang-nodes/MultiLineNatSpecComment.js';
 import { SingleLineComment } from '../slang-nodes/SingleLineComment.js';
 import { SingleLineNatSpecComment } from '../slang-nodes/SingleLineNatSpecComment.js';
 
 import type { Node } from '@nomicfoundation/slang/cst';
-import type { Comment, StrictAstNode } from '../slang-nodes';
-import type { Metadata, SlangAstNode } from '../types';
+import type { Comment, StrictAstNode } from '../slang-nodes/index.d.ts';
+import type { Metadata, SlangAstNode } from '../types.d.ts';
 
 const isCommentOrWhiteSpace = createKindCheckFunction([
   TerminalKind.MultiLineComment,
@@ -22,7 +21,7 @@ const isCommentOrWhiteSpace = createKindCheckFunction([
 function getLeadingOffset(children: Node[]): number {
   let offset = 0;
   for (const child of children) {
-    if (child.type === NodeType.Nonterminal) {
+    if (child.isNonterminalNode()) {
       // The node's content starts when we find the first non-terminal token.
       return offset;
     } else if (!isCommentOrWhiteSpace(child)) {
@@ -44,14 +43,16 @@ export function getNodeMetadata(
     throw new Error("Can't initiate metadata with an undefined initialOffset");
   }
 
-  const children = ast.cst.children();
+  const children = ast.cst.children.map((child) => {
+    return child.node;
+  });
 
   let offset = initialOffset;
 
   const comments: Comment[] = [];
 
   const offsets = children.reduce((offsetsArray: number[], child) => {
-    if (child.type === NodeType.Nonterminal) {
+    if (child.isNonterminalNode()) {
       offsetsArray.push(offset);
     } else {
       switch (child.kind) {

src/slangPrinter.ts

@@ -3,8 +3,8 @@ import { isBlockComment } from './slang-utils/is-comment.js';
 import { locEnd, locStart } from './slang-utils/loc.js';
 
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { AstNode, StrictAstNode } from './slang-nodes';
-import type { PrintFunction } from './types';
+import type { AstNode, StrictAstNode } from './slang-nodes/index.d.ts';
+import type { PrintFunction } from './types.d.ts';
 
 function once<T>(factory: () => T): () => T {
   let value: T;

src/slangSolidityParser.ts

@@ -1,28 +1,27 @@
 // https://prettier.io/docs/en/plugins.html#parsers
-import { Language } from '@nomicfoundation/slang/language/index.js';
-import { NonterminalKind } from '@nomicfoundation/slang/kinds/index.js';
-import { SourceUnit as SlangSourceUnit } from '@nomicfoundation/slang/ast/index.js';
+import { Parser } from '@nomicfoundation/slang/parser';
+import { NonterminalKind } from '@nomicfoundation/slang/cst';
+import { SourceUnit as SlangSourceUnit } from '@nomicfoundation/slang/ast';
 import { maxSatisfying } from 'semver';
 import { inferLanguage } from './slang-utils/infer-language.js';
 import { printWarning } from './slang-utils/print-warning.js';
 import { SourceUnit } from './slang-nodes/SourceUnit.js';
 
-import type { NonterminalNode } from '@nomicfoundation/slang/cst';
-import type { Parser, ParserOptions } from 'prettier';
-import type { AstNode } from './slang-nodes/index.js';
+import type { Parser as PrettierParser, ParserOptions } from 'prettier';
+import type { AstNode } from './slang-nodes/index.d.ts';
 
-const supportedVersions = Language.supportedVersions();
+const supportedVersions = Parser.supportedVersions();
 
 export default function parse(
   text: string,
-  _parsers: Parser[] | ParserOptions<AstNode>,
+  _parsers: PrettierParser[] | ParserOptions<AstNode>,
   options = _parsers as ParserOptions<AstNode>
 ): AstNode {
   const compiler = maxSatisfying(supportedVersions, options.compiler);
 
   const language =
     compiler && supportedVersions.includes(compiler)
-      ? new Language(compiler)
+      ? Parser.create(compiler)
       : inferLanguage(text);
 
   const parseOutput = language.parse(NonterminalKind.SourceUnit, text);
@@ -32,14 +31,14 @@ export default function parse(
       : `Inferred version ${language.version} based on the pragma statements in the code.`
   );
 
-  if (parseOutput.isValid) {
+  if (parseOutput.isValid()) {
     // We update the compiler version by the inferred one.
     options.compiler = language.version;
     return new SourceUnit(
-      new SlangSourceUnit(parseOutput.tree() as NonterminalNode),
+      new SlangSourceUnit(parseOutput.tree.asNonterminalNode()!),
       0,
       options
     );
   }
-  throw new Error(parseOutput.errors()[0].message());
+  throw new Error(parseOutput.errors[0].message);
 }