returning an object instead of an array for clarity

Author: Janther

src/slang-utils/create-parser.ts

@@ -48,32 +48,38 @@ const milestoneVersions = [
 export function createParser(
   text: string,
   options: ParserOptions<AstNode>
-): [Parser, ParseOutput] {
-  let parser: Parser;
+): { parser: Parser; parseOutput: ParseOutput } {
   const compiler = maxSatisfying(supportedVersions, options.compiler);
   if (compiler) {
-    parser = Parser.create(compiler);
-    return [parser, parser.parseNonterminal(NonterminalKind.SourceUnit, text)];
+    const parser = Parser.create(compiler);
+    return {
+      parser,
+      parseOutput: parser.parseNonterminal(NonterminalKind.SourceUnit, text)
+    };
   }
 
-  let parseOutput;
-
   const inferredRanges: string[] = LanguageFacts.inferLanguageVersions(text);
-  parser = Parser.create(inferredRanges[inferredRanges.length - 1]);
-  parseOutput = parser.parseNonterminal(NonterminalKind.SourceUnit, text);
+  const parser = Parser.create(inferredRanges[inferredRanges.length - 1]);
+  const result = {
+    parser,
+    parseOutput: parser.parseNonterminal(NonterminalKind.SourceUnit, text)
+  };
 
-  if (parseOutput.isValid()) return [parser, parseOutput];
+  if (result.parseOutput.isValid()) return result;
 
   const inferredMilestones = milestoneVersions.filter((milestone) =>
     inferredRanges.includes(milestone)
   );
 
   for (let i = inferredMilestones.length - 1; i > 0; i -= 1) {
     const version = inferredMilestones[i];
-    parser = Parser.create(version);
-    parseOutput = parser.parseNonterminal(NonterminalKind.SourceUnit, text);
-    if (parseOutput.isValid()) break;
+    result.parser = Parser.create(version);
+    result.parseOutput = result.parser.parseNonterminal(
+      NonterminalKind.SourceUnit,
+      text
+    );
+    if (result.parseOutput.isValid()) break;
   }
 
-  return [parser, parseOutput];
+  return result;
 }

src/slangSolidityParser.ts

@@ -11,7 +11,7 @@ export default function parse(
   text: string,
   options: ParserOptions<AstNode>
 ): AstNode {
-  const [parser, parseOutput] = createParser(text, options);
+  const { parser, parseOutput } = createParser(text, options);
 
   if (parseOutput.isValid()) {
     // We update the compiler version by the inferred one.

tests/config/run-format-test.js

@@ -334,7 +334,7 @@ async function runTest({
       // same for ANTLR unless it was already given as an option.
       compiler:
         formatOptions.compiler ||
-        createParser(code, formatOptions)[0].languageVersion,
+        createParser(code, formatOptions).parser.languageVersion,
       parser: "antlr",
       plugins: await getPlugins(),
     });

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

@@ -90,38 +90,34 @@ describe('inferLanguage', function () {
 
   for (const { description, source, version, skip } of fixtures) {
     (skip ? test.skip : test)(description, function () {
-      const [parser] = createParser(source, options);
+      const { parser } = createParser(source, options);
       expect(parser.languageVersion).toEqual(version);
     });
   }
 
   test('should use the latest successful version if the source has no pragmas', function () {
-    // This is to create in memory the latest parser and review the behaviour
-    createParser(`pragma solidity ${latestSupportedVersion};`, options);
-    let [parser] = createParser(`contract Foo {}`, options);
+    let { parser } = createParser(`contract Foo {}`, options);
     expect(parser.languageVersion).toEqual(latestSupportedVersion);
 
-    // This is to create in memory an old parser and review the behaviour
-    createParser(`pragma solidity 0.8.2;`, options);
-    [parser] = createParser(`contract Foo {}`, options);
+    ({ parser } = createParser(`contract Foo {}`, options));
     expect(parser.languageVersion).toEqual(latestSupportedVersion);
 
-    [parser] = createParser(`contract Foo {byte bar;}`, options);
+    ({ parser } = createParser(`contract Foo {byte bar;}`, options));
     expect(parser.languageVersion).toEqual('0.7.6');
   });
 
   test('should use compiler option if given', function () {
-    let [parser] = createParser(`pragma solidity ^0.8.0;`, {
+    let { parser } = createParser(`pragma solidity ^0.8.0;`, {
       compiler: '0.8.20'
     });
     expect(parser.languageVersion).toEqual('0.8.20');
 
-    [parser] = createParser(`pragma solidity ^0.8.0;`, {
+    ({ parser } = createParser(`pragma solidity ^0.8.0;`, {
       compiler: '0.8.2'
-    });
+    }));
     expect(parser.languageVersion).toEqual('0.8.2');
 
-    [parser] = createParser(`pragma solidity ^0.8.0;`, {});
+    ({ parser } = createParser(`pragma solidity ^0.8.0;`, {}));
     expect(parser.languageVersion).toEqual(latestSupportedVersion);
   });