Remove unused code

Author: schmidt-sebastian

packages/firestore/src/core/snapshot_version.ts

@@ -24,14 +24,6 @@ import { Timestamp } from '../api/timestamp';
 export class SnapshotVersion {
   static readonly MIN = new SnapshotVersion(new Timestamp(0, 0));
 
-  // TODO(b/34176344): Once we no longer need to use the old alpha protos,
-  // delete this constructor and use a timestamp-backed version everywhere.
-  static fromMicroseconds(value: number): SnapshotVersion {
-    const seconds = Math.floor(value / 1e6);
-    const nanos = (value % 1e6) * 1e3;
-    return new SnapshotVersion(new Timestamp(seconds, nanos));
-  }
-
   static fromTimestamp(value: Timestamp): SnapshotVersion {
     return new SnapshotVersion(value);
   }

packages/firestore/src/local/encoded_resource_path.ts

@@ -175,25 +175,3 @@ export function decode(path: EncodedResourcePath): ResourcePath {
 
   return new ResourcePath(segments);
 }
-
-/**
- * Computes the prefix successor of the given path, computed by encode above.
- * A prefix successor is the first key that cannot be prefixed by the given
- * path. It's useful for defining the end of a prefix scan such that all keys
- * in the scan have the same prefix.
- *
- * Note that this is not a general prefix successor implementation, which is
- * tricky to get right with Strings, given that they encode down to UTF-8.
- * Instead this relies on the fact that all paths encoded by this class are
- * always terminated with a separator, and so a successor can always be
- * cheaply computed by incrementing the last character of the path.
- */
-export function prefixSuccessor(
-  path: EncodedResourcePath
-): EncodedResourcePath {
-  const c = path.charCodeAt(path.length - 1);
-  // TODO(mcg): this really should be a general thing, but not worth it right
-  // now
-  assert(c === 1, 'successor may only operate on paths generated by encode');
-  return path.substring(0, path.length - 1) + String.fromCharCode(c + 1);
-}

packages/firestore/src/local/local_serializer.ts

@@ -29,10 +29,7 @@ import * as api from '../protos/firestore_proto_api';
 import { JsonProtoSerializer } from '../remote/serializer';
 import { assert, fail } from '../util/assert';
 import { ByteString } from '../util/byte_string';
-
-import { documentKeySet, DocumentKeySet } from '../model/collections';
 import { Target } from '../core/target';
-import { decode, encode, EncodedResourcePath } from './encoded_resource_path';
 import {
   DbMutationBatch,
   DbNoDocument,
@@ -174,30 +171,6 @@ export class LocalSerializer {
     );
   }
 
-  /*
-   * Encodes a set of document keys into an array of EncodedResourcePaths.
-   */
-  toDbResourcePaths(keys: DocumentKeySet): EncodedResourcePath[] {
-    const encodedKeys: EncodedResourcePath[] = [];
-
-    keys.forEach(key => {
-      encodedKeys.push(encode(key.path));
-    });
-
-    return encodedKeys;
-  }
-
-  /** Decodes an array of EncodedResourcePaths into a set of document keys. */
-  fromDbResourcePaths(encodedPaths: EncodedResourcePath[]): DocumentKeySet {
-    let keys = documentKeySet();
-
-    for (const documentKey of encodedPaths) {
-      keys = keys.add(new DocumentKey(decode(documentKey)));
-    }
-
-    return keys;
-  }
-
   /** Decodes a DbTarget into TargetData */
   fromDbTarget(dbTarget: DbTarget): TargetData {
     const version = this.fromDbTimestamp(dbTarget.readTime);

packages/firestore/src/local/reference_set.ts

@@ -43,11 +43,6 @@ export class ReferenceSet {
   // A set of outstanding references to a document sorted by target id.
   private refsByTarget = new SortedSet(DocReference.compareByTargetId);
 
-  /** Returns true if the reference set contains no references. */
-  isEmpty(): boolean {
-    return this.refsByKey.isEmpty();
-  }
-
   /** Adds a reference to the given document key for the given ID. */
   addReference(key: DocumentKey, id: TargetId | BatchId): void {
     const ref = new DocReference(key, id);

packages/firestore/src/local/target_data.ts

@@ -118,18 +118,4 @@ export class TargetData {
       this.resumeToken
     );
   }
-
-  isEqual(other: TargetData): boolean {
-    return (
-      this.targetId === other.targetId &&
-      this.purpose === other.purpose &&
-      this.sequenceNumber === other.sequenceNumber &&
-      this.snapshotVersion.isEqual(other.snapshotVersion) &&
-      this.lastLimboFreeSnapshotVersion.isEqual(
-        other.lastLimboFreeSnapshotVersion
-      ) &&
-      this.resumeToken.isEqual(other.resumeToken) &&
-      this.target.isEqual(other.target)
-    );
-  }
 }

packages/firestore/src/remote/existence_filter.ts

@@ -18,8 +18,4 @@
 export class ExistenceFilter {
   // TODO(b/33078163): just use simplest form of existence filter for now
   constructor(public count: number) {}
-
-  isEqual(other: ExistenceFilter): boolean {
-    return other && other.count === this.count;
-  }
 }

packages/firestore/src/util/async_queue.ts

@@ -289,15 +289,6 @@ export class AsyncQueue {
           const message = error.stack || error.message || '';
           logError('INTERNAL UNHANDLED ERROR: ', message);
 
-          // Escape the promise chain and throw the error globally so that
-          // e.g. any global crash reporting library detects and reports it.
-          // (but not for simulated errors in our tests since this breaks mocha)
-          if (message.indexOf('Firestore Test Simulated Error') < 0) {
-            setTimeout(() => {
-              throw error;
-            }, 0);
-          }
-
           // Re-throw the error so that this.tail becomes a rejected Promise and
           // all further attempts to chain (via .then) will just short-circuit
           // and return the rejected Promise.

packages/firestore/src/util/sorted_set.ts

@@ -31,18 +31,6 @@ export class SortedSet<T> {
     this.data = new SortedMap<T, boolean>(this.comparator);
   }
 
-  /**
-   * Creates a SortedSet from the keys of the map.
-   * This is currently implemented as an O(n) copy.
-   */
-  static fromMapKeys<K, V>(map: SortedMap<K, V>): SortedSet<K> {
-    let keys = new SortedSet<K>(map.comparator);
-    map.forEach(key => {
-      keys = keys.add(key);
-    });
-    return keys;
-  }
-
   has(elem: T): boolean {
     return this.data.get(elem) !== null;
   }

packages/firestore/test/unit/local/encoded_resource_path.test.ts

@@ -124,25 +124,8 @@ describe('EncodedResourcePath', () => {
       path('food')
     ]);
   });
-
-  it('prefixes successors correctly', async () => {
-    assertPrefixSuccessorEquals('\u0001\u0002', ResourcePath.EMPTY_PATH);
-    assertPrefixSuccessorEquals(
-      'foo' + sep + 'bar\u0001\u0002',
-      path('foo/bar')
-    );
-  });
 });
 
-function assertPrefixSuccessorEquals(
-  expected: string,
-  path: ResourcePath
-): void {
-  expect(
-    EncodedResourcePath.prefixSuccessor(EncodedResourcePath.encode(path))
-  ).to.deep.equal(expected);
-}
-
 function assertEncoded(expected: string, path: ResourcePath): Promise<void> {
   const encoded = EncodedResourcePath.encode(path);
   expect(encoded).to.deep.equal(expected);

packages/firestore/test/unit/local/lru_garbage_collector.test.ts

@@ -20,7 +20,6 @@ import { Timestamp } from '../../../src/api/timestamp';
 import { User } from '../../../src/auth/user';
 import { ListenSequence } from '../../../src/core/listen_sequence';
 import { Query } from '../../../src/core/query';
-import { SnapshotVersion } from '../../../src/core/snapshot_version';
 import { ListenSequenceNumber, TargetId } from '../../../src/core/types';
 import { IndexedDbPersistence } from '../../../src/local/indexeddb_persistence';
 import {
@@ -49,7 +48,7 @@ import {
   SetMutation
 } from '../../../src/model/mutation';
 import { AsyncQueue } from '../../../src/util/async_queue';
-import { key, path, wrapObject } from '../../util/helpers';
+import { key, path, version, wrapObject } from '../../util/helpers';
 import { SortedMap } from '../../../src/util/sorted_map';
 import * as PersistenceTestHelpers from './persistence_test_helpers';
 import { primitiveComparator } from '../../../src/util/misc';
@@ -246,7 +245,7 @@ function genericLruGarbageCollectorTests(
     const key = nextTestDocumentKey();
     return new Document(
       key,
-      SnapshotVersion.fromMicroseconds(1000),
+      version(1000),
       wrapObject({
         foo: 3,
         bar: false
@@ -784,7 +783,7 @@ function genericLruGarbageCollectorTests(
       txn => {
         const doc = new Document(
           middleDocToUpdate,
-          SnapshotVersion.fromMicroseconds(2000),
+          version(2000),
           wrapObject({
             foo: 4,
             bar: true

packages/firestore/test/unit/local/reference_set.test.ts

@@ -24,10 +24,8 @@ describe('ReferenceSet', () => {
     const documentKey = key('foo/bar');
 
     const refSet = new ReferenceSet();
-    expect(refSet.isEmpty()).to.be.true;
     expect(refSet.containsKey(documentKey)).to.be.false;
     refSet.addReference(documentKey, 1);
-    expect(refSet.isEmpty()).to.be.false;
     expect(refSet.containsKey(documentKey)).to.be.true;
     refSet.addReference(documentKey, 2);
     expect(refSet.containsKey(documentKey)).to.be.true;
@@ -37,7 +35,6 @@ describe('ReferenceSet', () => {
     expect(refSet.containsKey(documentKey)).to.be.true;
     refSet.removeReference(documentKey, 2);
     expect(refSet.containsKey(documentKey)).to.be.false;
-    expect(refSet.isEmpty()).to.be.true;
   });
 
   it('can remove all references for a target ID', () => {
@@ -49,17 +46,14 @@ describe('ReferenceSet', () => {
     refSet.addReference(key1, 1);
     refSet.addReference(key2, 1);
     refSet.addReference(key3, 2);
-    expect(refSet.isEmpty()).to.be.false;
     expect(refSet.containsKey(key1)).to.be.true;
     expect(refSet.containsKey(key2)).to.be.true;
     expect(refSet.containsKey(key3)).to.be.true;
     refSet.removeReferencesForId(1);
-    expect(refSet.isEmpty()).to.be.false;
     expect(refSet.containsKey(key1)).to.be.false;
     expect(refSet.containsKey(key2)).to.be.false;
     expect(refSet.containsKey(key3)).to.be.true;
     refSet.removeReferencesForId(2);
-    expect(refSet.isEmpty()).to.be.true;
     expect(refSet.containsKey(key1)).to.be.false;
     expect(refSet.containsKey(key2)).to.be.false;
     expect(refSet.containsKey(key3)).to.be.false;

packages/firestore/test/unit/local/target_cache.test.ts

@@ -92,13 +92,8 @@ describe('IndexedDbTargetCache', () => {
       originalSequenceNumber
     );
     const actualTargetData = await targetCache2.getTargetData(target);
-
-    if (process.env.USE_MOCK_PERSISTENCE !== 'YES') {
-      // TODO(b/140573486): This fails on Node with persistence since the
-      // resume token is read back as a string.
-      expect(targetData.isEqual(actualTargetData!)).to.be.true;
-    }
-
+    expect(targetData).to.deep.equal(actualTargetData);
+    
     const actualSnapshotVersion = await targetCache2.getLastRemoteSnapshotVersion();
     expect(snapshotVersion.isEqual(actualSnapshotVersion)).to.be.true;
     await db2.shutdown();
@@ -127,12 +122,12 @@ function genericTargetCacheTests(
   function testTargetData(
     target: Target,
     targetId: TargetId,
-    version?: number
+    testVersion?: number
   ): TargetData {
-    if (version === undefined) {
-      version = 0;
+    if (testVersion === undefined) {
+      testVersion = 0;
     }
-    const snapshotVersion = SnapshotVersion.fromMicroseconds(version);
+    const snapshotVersion = version(testVersion);
     const resumeToken = resumeTokenForSnapshot(snapshotVersion);
     return new TargetData(
       target,

packages/firestore/test/unit/remote/serializer.test.ts

@@ -1420,7 +1420,7 @@ describe('Serializer', () => {
           document: {
             name: s.toName(key('coll/1')),
             fields: wrap({ foo: 'bar' }).mapValue!.fields,
-            updateTime: s.toVersion(SnapshotVersion.fromMicroseconds(5))
+            updateTime: s.toVersion(version(5))
           },
           targetIds: [1, 2]
         }
@@ -1440,7 +1440,7 @@ describe('Serializer', () => {
           document: {
             name: s.toName(key('coll/1')),
             fields: wrap({ foo: 'bar' }).mapValue!.fields,
-            updateTime: s.toVersion(SnapshotVersion.fromMicroseconds(5))
+            updateTime: s.toVersion(version(5))
           },
           targetIds: [2],
           removedTargetIds: [1]
@@ -1459,7 +1459,7 @@ describe('Serializer', () => {
       const actual = s.fromWatchChange({
         documentDelete: {
           document: s.toName(key('coll/1')),
-          readTime: s.toVersion(SnapshotVersion.fromMicroseconds(5)),
+          readTime: s.toVersion(version(5)),
           removedTargetIds: [1, 2]
         }
       });

packages/firestore/test/unit/util/sorted_set.test.ts

@@ -17,7 +17,6 @@
 
 import { expect } from 'chai';
 import { primitiveComparator } from '../../../src/util/misc';
-import { SortedMap } from '../../../src/util/sorted_map';
 import { SortedSet } from '../../../src/util/sorted_set';
 
 import { expectSetToEqual } from '../../util/helpers';
@@ -161,21 +160,6 @@ describe('SortedSet', () => {
     expect(set.unionWith(set2)).to.deep.equal(expected);
   });
 
-  it('can build set from map keys.', () => {
-    const empty = new SortedSet<number>(primitiveComparator);
-    const map = new SortedMap<number, string>(primitiveComparator)
-      .insert(0, 'zero')
-      .insert(2, 'two')
-      .insert(4, 'four');
-    const set = SortedSet.fromMapKeys(map);
-    expect(set).to.deep.equal(
-      empty
-        .add(0)
-        .add(2)
-        .add(4)
-    );
-  });
-
   it('returns indexes of elements', () => {
     const set = new SortedSet<number>(primitiveComparator)
       .add(-1)

packages/firestore/test/util/helpers.ts

@@ -91,6 +91,7 @@ import { query } from './api_helpers';
 import { ByteString } from '../../src/util/byte_string';
 import { PlatformSupport } from '../../src/platform/platform';
 import { JsonProtoSerializer } from '../../src/remote/serializer';
+import { Timestamp } from '../../src/api/timestamp';
 
 export type TestSnapshotVersion = number;
 
@@ -126,7 +127,9 @@ export function testUserDataReader(useProto3Json?: boolean): UserDataReader {
 }
 
 export function version(v: TestSnapshotVersion): SnapshotVersion {
-  return SnapshotVersion.fromMicroseconds(v);
+  const seconds = Math.floor(v / 1e6);
+  const nanos = (v % 1e6) * 1e3;
+  return SnapshotVersion.fromTimestamp(new Timestamp(seconds, nanos));
 }
 
 export function ref(