using createParser to infer the correct Language Version

Author: Janther

src/constants.ts

@@ -0,0 +1,5 @@
+export const slangParserId = 'slang';
+export const slangYulParserId = 'slang-yul';
+export const antlrParserId = 'antlr';
+export const slangAstId = 'slang-ast';
+export const antlrAstId = 'antlr-ast';

src/index.ts

@@ -10,6 +10,13 @@ import yulParse from './slangYulParser.js';
 import slangPrint from './slangPrinter.js';
 import { isBlockComment, isComment } from './slang-utils/is-comment.js';
 import { locEnd, locStart } from './slang-utils/loc.js';
+import {
+  slangParserId,
+  slangYulParserId,
+  antlrParserId,
+  slangAstId,
+  antlrAstId
+} from './constants.js';
 
 import type {
   Parser,
@@ -19,12 +26,6 @@ import type {
 } from 'prettier';
 import type { AstNode } from './slang-nodes/types.d.ts';
 
-const slangParserId = 'slang';
-const slangYulParserId = 'slang-yul';
-const antlrParserId = 'antlr';
-const slangAstId = 'slang-ast';
-const antlrAstId = 'antlr-ast';
-
 // https://prettier.io/docs/en/plugins.html#languages
 // https://github.com/github-linguist/linguist/blob/master/lib/linguist/languages.yml
 const languages: SupportLanguage[] = [

src/slang-utils/create-parser.ts

@@ -2,6 +2,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { Parser } from '@nomicfoundation/slang/parser';
 import { LanguageFacts } from '@nomicfoundation/slang/utils';
 import { maxSatisfying } from 'semver';
+import { slangParserId, slangYulParserId } from '../constants.js';
 
 import type { ParseOutput } from '@nomicfoundation/slang/parser';
 import type { ParserOptions } from 'prettier';
@@ -12,13 +13,25 @@ const supportedLength = supportedVersions.length;
 
 function parserAndOutput(
   text: string,
-  version: string
+  version: string,
+  { parser: optionsParser }: ParserOptions<AstNode>
 ): { parser: Parser; parseOutput: ParseOutput } {
+  let rootKind;
+  switch (optionsParser) {
+    case slangParserId:
+      rootKind = NonterminalKind.SourceUnit;
+      break;
+    case slangYulParserId:
+      rootKind = NonterminalKind.YulBlock;
+      break;
+    default:
+      throw new Error(
+        `Parser '${optionsParser as string}' is not supported for Language Inference.`
+      );
+  }
+
   const parser = Parser.create(version);
-  return {
-    parser,
-    parseOutput: parser.parseNonterminal(NonterminalKind.SourceUnit, text)
-  };
+  return { parser, parseOutput: parser.parseNonterminal(rootKind, text) };
 }
 
 function createError(
@@ -36,7 +49,7 @@ export function createParser(
 ): { parser: Parser; parseOutput: ParseOutput } {
   const compiler = maxSatisfying(supportedVersions, options.compiler);
   if (compiler) {
-    const result = parserAndOutput(text, compiler);
+    const result = parserAndOutput(text, compiler, options);
 
     if (!result.parseOutput.isValid())
       throw createError(
@@ -55,7 +68,8 @@ export function createParser(
   if (inferredLength === 0 || inferredLength === supportedLength) {
     const result = parserAndOutput(
       text,
-      supportedVersions[supportedLength - 1]
+      supportedVersions[supportedLength - 1],
+      options
     );
 
     if (!result.parseOutput.isValid())
@@ -70,7 +84,8 @@ export function createParser(
 
   const result = parserAndOutput(
     text,
-    inferredRanges[inferredRanges.length - 1]
+    inferredRanges[inferredLength - 1],
+    options
   );
 
   if (!result.parseOutput.isValid())

src/slangYulParser.ts

@@ -1,10 +1,7 @@
 // https://prettier.io/docs/en/plugins.html#parsers
 import { YulBlock as SlangYulBlock } from '@nomicfoundation/slang/ast';
-import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { Parser } from '@nomicfoundation/slang/parser';
-import { LanguageFacts } from '@nomicfoundation/slang/utils';
-import { coerce } from 'semver';
-import { clearOffsets } from './slang-utils/metadata.js';
+import { clearOffsets } from './slang-nodes/SlangNode.js';
+import { createParser } from './slang-utils/create-parser.js';
 import { YulBlock } from './slang-nodes/YulBlock.js';
 
 import type { ParserOptions } from 'prettier';
@@ -14,27 +11,14 @@ export default function parse(
   text: string,
   options: ParserOptions<AstNode>
 ): AstNode {
-  // const [parser, parseOutput] = createParser(text, options);
-  const compiler = coerce(options.compiler);
-  const supportedVersions = LanguageFacts.allVersions();
+  const { parser, parseOutput } = createParser(text, options);
 
-  const parser = Parser.create(
-    compiler && supportedVersions.includes(compiler.version)
-      ? compiler.version
-      : supportedVersions[supportedVersions.length - 1]
+  // We update the compiler version by the inferred one.
+  options.compiler = parser.languageVersion;
+  const parsed = new YulBlock(
+    new SlangYulBlock(parseOutput.tree.asNonterminalNode()),
+    options
   );
-
-  const parseOutput = parser.parseNonterminal(NonterminalKind.YulBlock, text);
-
-  if (parseOutput.isValid()) {
-    // We update the compiler version by the inferred one.
-    options.compiler = parser.languageVersion;
-    const parsed = new YulBlock(
-      new SlangYulBlock(parseOutput.tree.asNonterminalNode()),
-      options
-    );
-    clearOffsets();
-    return parsed;
-  }
-  throw new Error(parseOutput.errors()[0].message);
+  clearOffsets();
+  return parsed;
 }

tests/format/Yul/__snapshots__/format.test.js.snap

@@ -1,4 +1,4 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
 exports[`example1.yul format 1`] = `
 ====================================options=====================================

tests/unit/slang-utils/create-parser.test.js

@@ -1,9 +1,10 @@
 import { LanguageFacts } from '@nomicfoundation/slang/utils';
 import { createParser } from '../../../src/slang-utils/create-parser.js';
+import { slangParserId } from '../../../src/constants.js';
 
 describe('inferLanguage', function () {
   const latestSupportedVersion = LanguageFacts.latestVersion();
-  const options = { filepath: 'test.sol' };
+  const options = { parser: slangParserId };
 
   const fixtures = [
     {
@@ -97,22 +98,27 @@ describe('inferLanguage', function () {
 
   test('should use compiler option if given', function () {
     let { parser } = createParser(`pragma solidity ^0.8.0;`, {
+      ...options,
       compiler: '0.8.20'
     });
     expect(parser.languageVersion).toEqual('0.8.20');
 
     ({ parser } = createParser(`pragma solidity ^0.8.0;`, {
+      ...options,
       compiler: '0.8.2'
     }));
     expect(parser.languageVersion).toEqual('0.8.2');
 
-    ({ parser } = createParser(`pragma solidity ^0.7.0;`, {}));
+    ({ parser } = createParser(`pragma solidity ^0.7.0;`, options));
     expect(parser.languageVersion).toEqual('0.7.6');
   });
 
   test('should throw if compiler option does not match the syntax', function () {
     expect(() =>
-      createParser(`contract Foo {byte bar;}`, { compiler: '0.8.0' })
+      createParser(`contract Foo {byte bar;}`, {
+        ...options,
+        compiler: '0.8.0'
+      })
     ).toThrow(
       'Based on the compiler option provided, we inferred your code to be using Solidity version'
     );