Allow defined tables without exact rows

package.json

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

src/powerquery-parser/language/type/type.ts

@@ -307,7 +307,7 @@ export type DefinedTable = IExtendedType &
     FieldSpecificationList<OrderedFields> & {
         readonly kind: TypeKind.Table;
         readonly extendedKind: ExtendedTypeKind.DefinedTable;
-        readonly rows: ReadonlyArray<UnorderedFields>;
+        readonly rows?: ReadonlyArray<UnorderedFields>;
     };
 
 export type FunctionType = IExtendedType &

src/powerquery-parser/language/type/typeUtils/factories.ts

@@ -97,19 +97,20 @@ export function definedRecord(
 }
 
 /**
- * Creates a defined table with exact rows.
+ * Creates a defined table with known fields and optional exact rows.
  *
- * Each row is asserted to contain exactly the declared fields and field types compatible with the table definition.
+ * Omitted rows indicate that the table's rows are unknown, while an empty array represents an exact empty table.
+ * Each supplied row is asserted to contain exactly the declared fields and field types compatible with the table definition.
  * @throws CommonError.InvariantError if a row does not satisfy those requirements.
  */
 export function definedTable(
     isNullable: boolean,
     fields: Type.OrderedFields,
-    rows: ReadonlyArray<Type.UnorderedFields>,
+    rows?: ReadonlyArray<Type.UnorderedFields>,
 ): Type.DefinedTable {
     const fieldNames: ReadonlyArray<string> = [...fields.keys()];
 
-    for (const [rowIndex, row] of rows.entries()) {
+    for (const [rowIndex, row] of rows?.entries() ?? []) {
         Assert.isTrue(
             MapUtils.hasKeys(row, fieldNames) && row.size === fields.size,
             `row fields do not match table fields`,

src/powerquery-parser/language/type/typeUtils/isEqualType.ts

@@ -183,12 +183,12 @@ export function isEqualDefinedTable(left: Type.DefinedTable, right: Type.Defined
 }
 
 function isEqualDefinedTableRows(
-    left: ReadonlyArray<Type.UnorderedFields>,
-    right: ReadonlyArray<Type.UnorderedFields>,
+    left: ReadonlyArray<Type.UnorderedFields> | undefined,
+    right: ReadonlyArray<Type.UnorderedFields> | undefined,
 ): boolean {
     if (left === right) {
         return true;
-    } else if (left.length !== right.length) {
+    } else if (left === undefined || right === undefined || left.length !== right.length) {
         return false;
     }
 

src/test/libraryTest/language/typeUtils/isEqualType.test.ts

@@ -99,5 +99,21 @@ describe(`TypeUtils.isEqualType`, () => {
                 expected: false,
             });
         });
+
+        it(`unknown rows equal unknown rows`, () => {
+            runTest({
+                left: TypeUtils.definedTable(false, fields),
+                right: TypeUtils.definedTable(false, fields),
+                expected: true,
+            });
+        });
+
+        it(`unknown rows differ from exact empty rows`, () => {
+            runTest({
+                left: TypeUtils.definedTable(false, fields),
+                right: TypeUtils.definedTable(false, fields, []),
+                expected: false,
+            });
+        });
     });
 });

src/test/libraryTest/language/typeUtils/typeUtils.test.ts

@@ -247,6 +247,12 @@ describe(`TypeUtils`, () => {
             expect(type.rows).to.equal(rows);
         });
 
+        it(`allows unknown rows`, () => {
+            const type: Type.DefinedTable = TypeUtils.definedTable(false, fields);
+
+            expect(type.rows).to.be.undefined;
+        });
+
         it(`accepts null for a nullable column`, () => {
             const nullableFields: Type.OrderedFields = new OrderedMap([["Value", Type.NullableNumberInstance]]);