Add AstUtils.getIdentifierLiteral (#392)

* initial commit

* few more tests

* updating package version

Author: JordanBoltonMN

package-lock.json

@@ -1,6 +1,6 @@
 {
     "name": "@microsoft/powerquery-parser",
-    "version": "0.16.0",
+    "version": "0.16.1",
     "description": "A parser for the Power Query/M formula language.",
     "author": "Microsoft",
     "license": "MIT",

package.json

@@ -30,6 +30,19 @@ export function assertIsTNullablePrimitiveType(node: Ast.TNode): asserts node is
     }
 }
 
+export function getIdentifierLiteral(node: Ast.Identifier | Ast.IdentifierExpression): string {
+    switch (node.kind) {
+        case Ast.NodeKind.Identifier:
+            return node.literal;
+
+        case Ast.NodeKind.IdentifierExpression:
+            return node.inclusiveConstant ? `@${node.identifier.literal}` : node.identifier.literal;
+
+        default:
+            throw Assert.isNever(node);
+    }
+}
+
 export function isTAnyLiteral(node: Ast.TNode): node is Ast.TAnyLiteral {
     return Ast.NodeKindsForTAnyLiteral.has(node.kind);
 }

src/powerquery-parser/language/ast/astUtils/astUtils.ts

@@ -6,7 +6,7 @@ import { expect } from "chai";
 
 import { IdentifierUtils } from "../../powerquery-parser/language";
 
-describe("TextUtils", () => {
+describe("IdentifierUtils", () => {
     describe(`isRegularIdentifier`, () => {
         describe(`valid`, () => {
             it(`foo`, () => expect(IdentifierUtils.isRegularIdentifier("foo", false), "should be true").to.be.true);

src/test/libraryTest/identifierUtils.test.ts

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import "mocha";
+import { expect } from "chai";
+
+import { Ast, AstUtils } from "../../../powerquery-parser/language";
+import { AssertTestUtils } from "../../testUtils";
+import { DefaultSettings } from "../../../powerquery-parser";
+import { ParseOk } from "../../../powerquery-parser/parser";
+
+describe(`AstUtils`, () => {
+    describe(`getIdentifierLiteral`, () => {
+        async function runTest(params: {
+            readonly text: string;
+            readonly expectedIdentifierLiteral: string;
+            readonly expectedIdentifierExpressionLiteral: string;
+        }): Promise<void> {
+            const parseOk: ParseOk = await AssertTestUtils.assertGetParseOk(DefaultSettings, params.text);
+
+            // First, ensure the root node is an IdentifierExpression.
+            const rootAsIdentifierExpression: Ast.IdentifierExpression =
+                AstUtils.assertAsNodeKind<Ast.IdentifierExpression>(parseOk.root, Ast.NodeKind.IdentifierExpression);
+
+            // Second, grab our actual literals.
+            const actualIdentifierExpressionLiteral: string = AstUtils.getIdentifierLiteral(rootAsIdentifierExpression);
+
+            const actualIdentifierLiteral: string = AstUtils.getIdentifierLiteral(
+                rootAsIdentifierExpression.identifier,
+            );
+
+            expect(
+                actualIdentifierExpressionLiteral,
+                `expected identifier expression literal to be ${params.expectedIdentifierExpressionLiteral}`,
+            ).to.equal(params.expectedIdentifierExpressionLiteral);
+
+            // Finally, assert that our actual literals match the expected literals.
+            expect(
+                actualIdentifierLiteral,
+                `expected identifier literal to be ${params.expectedIdentifierLiteral}`,
+            ).to.equal(params.expectedIdentifierLiteral);
+        }
+
+        it(`foo`, async () => {
+            await runTest({
+                text: "foo",
+                expectedIdentifierLiteral: "foo",
+                expectedIdentifierExpressionLiteral: "foo",
+            });
+        });
+
+        it(`@foo`, async () => {
+            await runTest({
+                text: "@foo",
+                expectedIdentifierExpressionLiteral: "@foo",
+                expectedIdentifierLiteral: "foo",
+            });
+        });
+    });
+});

src/test/libraryTest/language/astUtils.test.ts

@@ -257,7 +257,7 @@ describe(`nodeIdMapUtils`, () => {
             );
 
             expect(invokeExpressionNodeIds.size).to.equal(1);
-            const invokeExpressionNodeId: number = invokeExpressionNodeIds.values().next().value;
+            const invokeExpressionNodeId: number = Assert.asDefined(invokeExpressionNodeIds.values().next().value);
 
             const invokeExpressionIdentifier: XorNode<Ast.IdentifierExpression> = Assert.asDefined(
                 NodeIdMapUtils.invokeExpressionIdentifier(nodeIdMapCollection, invokeExpressionNodeId),
@@ -282,7 +282,7 @@ describe(`nodeIdMapUtils`, () => {
             );
 
             expect(invokeExpressionNodeIds.size).to.equal(1);
-            const invokeExpressionNodeId: number = invokeExpressionNodeIds.values().next().value;
+            const invokeExpressionNodeId: number = Assert.asDefined(invokeExpressionNodeIds.values().next().value);
 
             const invokeExpressionIdentifier: XorNode<Ast.IdentifierExpression> = Assert.asDefined(
                 NodeIdMapUtils.invokeExpressionIdentifier(nodeIdMapCollection, invokeExpressionNodeId),
@@ -304,7 +304,7 @@ describe(`nodeIdMapUtils`, () => {
             );
 
             expect(recordExpressionNodeIds.size).to.equal(1);
-            const recordExpressionNodeId: number = recordExpressionNodeIds.values().next().value;
+            const recordExpressionNodeId: number = Assert.asDefined(recordExpressionNodeIds.values().next().value);
 
             XorNodeUtils.assertAstChecked(
                 Assert.asDefined(NodeIdMapUtils.wrappedContentXor(nodeIdMapCollection, recordExpressionNodeId)),
@@ -327,7 +327,7 @@ describe(`nodeIdMapUtils`, () => {
             );
 
             expect(recordExpressionNodeIds.size).to.equal(1);
-            const recordExpressionNodeId: number = recordExpressionNodeIds.values().next().value;
+            const recordExpressionNodeId: number = Assert.asDefined(recordExpressionNodeIds.values().next().value);
 
             XorNodeUtils.assertAstChecked(
                 Assert.asDefined(NodeIdMapUtils.wrappedContentXor(nodeIdMapCollection, recordExpressionNodeId)),