Ported all tests, plus some bug fixes

Author: wu-hui

packages/firestore/src/core/expressions.ts

@@ -172,6 +172,8 @@ export function toEvaluable<T>(expr: T): EvaluableExpr {
     return new CoreArrayElement(expr);
   } else if (expr instanceof EqAny) {
     return new CoreEqAny(expr);
+  } else if (expr instanceof NotEqAny) {
+    return new CoreNotEqAny(expr);
   } else if (expr instanceof IsNan) {
     return new CoreIsNan(expr);
   } else if (expr instanceof Exists) {
@@ -398,7 +400,11 @@ abstract class BigIntOrDoubleArithmetics<
 }
 
 function valueEquals(left: Value, right: Value): boolean {
-  return valueEqualsWithOptions(left, right, { nanEqual: false, mixIntegerDouble: true, semanticsEqual: true });
+  return valueEqualsWithOptions(left, right, {
+    nanEqual: false,
+    mixIntegerDouble: true,
+    semanticsEqual: true
+  });
 }
 
 export class CoreAdd extends BigIntOrDoubleArithmetics<Add> {
@@ -768,6 +774,29 @@ export class CoreEqAny implements EvaluableExpr {
   }
 }
 
+export class CoreNotEqAny implements EvaluableExpr {
+  constructor(private expr: NotEqAny) {}
+
+  evaluate(
+    context: EvaluationContext,
+    input: PipelineInputOutput
+  ): Value | undefined {
+    const inverse = new CoreEqAny(new EqAny(this.expr.left, this.expr.others));
+    const result = inverse.evaluate(context, input);
+    if (result === undefined) {
+      return undefined;
+    }
+    return { booleanValue: !result.booleanValue };
+  }
+
+  static fromProtoToApiObj(value: ProtoFunction): EqAny {
+    return new EqAny(
+      exprFromProto(value.args![0]),
+      value.args!.slice(1).map(exprFromProto)
+    );
+  }
+}
+
 export class CoreIsNan implements EvaluableExpr {
   constructor(private expr: IsNan) {}
 

packages/firestore/src/core/pipeline_run.ts

@@ -19,6 +19,7 @@ import {
   DocumentsSource,
   Exists,
   Field,
+  FirestoreError,
   Limit,
   Offset,
   Ordering,
@@ -39,6 +40,7 @@ import { Query, queryMatches, queryMatchesAllDocuments } from './query';
 import { isPipeline, QueryOrPipeline } from './pipeline-util';
 import { DOCUMENT_KEY_NAME } from '../model/path';
 import { JsonProtoSerializer } from '../remote/serializer';
+import { Code } from '../util/error';
 
 export class CorePipeline {
   constructor(
@@ -233,6 +235,22 @@ function evaluateDocuments(
   stage: DocumentsSource,
   input: Array<PipelineInputOutput>
 ): Array<PipelineInputOutput> {
+  if (stage.docPaths.length === 0) {
+    throw new FirestoreError(
+      Code.INVALID_ARGUMENT,
+      'Empty document paths are not allowed in DocumentsSource'
+    );
+  }
+  if (stage.docPaths) {
+    const uniqueDocPaths = new Set(stage.docPaths);
+    if (uniqueDocPaths.size !== stage.docPaths.length) {
+      throw new FirestoreError(
+        Code.INVALID_ARGUMENT,
+        'Duplicate document paths are not allowed in DocumentsSource'
+      );
+    }
+  }
+
   return input.filter(input => {
     return (
       input.isFoundDocument() &&

packages/firestore/src/lite-api/expressions.ts

@@ -2056,7 +2056,10 @@ export class Constant extends Expr {
 
   private _protoValue?: ProtoValue;
 
-  private constructor(readonly value: any, readonly options?: {preferIntegers: boolean}) {
+  private constructor(
+    readonly value: any,
+    readonly options?: { preferIntegers: boolean }
+  ) {
     super();
   }
 
@@ -2068,7 +2071,7 @@ export class Constant extends Expr {
    */
   static of(value: number): Constant;
 
-  static of(value: number, options?: {preferIntegers: boolean}): Constant;
+  static of(value: number, options?: { preferIntegers: boolean }): Constant;
 
   /**
    * Creates a `Constant` instance for a string value.
@@ -2176,7 +2179,7 @@ export class Constant extends Expr {
    */
   static of(value: VectorValue): Constant;
 
-  static of(value: any, options?: {preferIntegers: boolean}): Constant {
+  static of(value: any, options?: { preferIntegers: boolean }): Constant {
     return new Constant(value, options);
   }
 
@@ -2555,7 +2558,7 @@ export class EqAny extends FirestoreFunction implements FilterCondition {
  * @beta
  */
 export class NotEqAny extends FirestoreFunction implements FilterCondition {
-  constructor(private left: Expr, private others: Expr[]) {
+  constructor(readonly left: Expr, readonly others: Expr[]) {
     super('not_eq_any', [left, new ListOfExprs(others)]);
   }
   filterable = true as const;

packages/firestore/src/model/values.ts

@@ -102,9 +102,9 @@ export function typeOrder(value: Value): TypeOrder {
 }
 
 export interface EqualOptions {
-  nanEqual: boolean,
-  mixIntegerDouble: boolean,
-  semanticsEqual: boolean
+  nanEqual: boolean;
+  mixIntegerDouble: boolean;
+  semanticsEqual: boolean;
 }
 
 /** Tests `left` and `right` for equality based on the backend semantics. */
@@ -202,23 +202,25 @@ export function numberEquals(
     );
   }
 
-    let n1:number, n2:number;
-    if ('doubleValue' in left && 'doubleValue' in right) {
-      n1 = normalizeNumber(left.doubleValue!);
-      n2 = normalizeNumber(right.doubleValue!);
-    } else if(options?.mixIntegerDouble) {
-      n1 = normalizeNumber(left.integerValue ?? left.doubleValue);
-      n2 = normalizeNumber(right.integerValue ?? right.doubleValue);
-    } else {
-      return false;
-    }
+  let n1: number, n2: number;
+  if ('doubleValue' in left && 'doubleValue' in right) {
+    n1 = normalizeNumber(left.doubleValue!);
+    n2 = normalizeNumber(right.doubleValue!);
+  } else if (options?.mixIntegerDouble) {
+    n1 = normalizeNumber(left.integerValue ?? left.doubleValue);
+    n2 = normalizeNumber(right.integerValue ?? right.doubleValue);
+  } else {
+    return false;
+  }
 
-    if (n1 === n2) {
-      return options?.semanticsEqual ? true : isNegativeZero(n1) === isNegativeZero(n2);
-    } else {
-      const nanEqual = options === undefined ? true : options.nanEqual;
-      return nanEqual ? isNaN(n1) && isNaN(n2) : false;
-    }
+  if (n1 === n2) {
+    return options?.semanticsEqual
+      ? true
+      : isNegativeZero(n1) === isNegativeZero(n2);
+  } else {
+    const nanEqual = options === undefined ? true : options.nanEqual;
+    return nanEqual ? isNaN(n1) && isNaN(n2) : false;
+  }
 }
 
 function objectEquals(