rdf-js: immutable methods cannot return this (#45720)

* rdf-js: immutable methods cannot return this * add tests
DefinitelyTyped · Jul 10, 2020 · 98ee4c5 · 98ee4c5
1 parent 4c83502
commit 98ee4c5
Show file tree

Hide file tree

Showing 4 changed files with 131 additions and 7 deletions.
diff --git a/types/rdf-dataset-indexed/dataset.d.ts b/types/rdf-dataset-indexed/dataset.d.ts
@@ -21,6 +21,7 @@ declare namespace DatasetIndexed {
         some(predicate: (quad: Q) => boolean): boolean;
         toArray(): Q[];
         toStream(): Stream<Q> & Readable;
+        match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): DatasetIndexed<Q, InQuad>;
     }
 }
 

diff --git a/types/rdf-js/index.d.ts b/types/rdf-js/index.d.ts
@@ -450,7 +450,7 @@ export interface DatasetCore<OutQuad extends BaseQuad = Quad, InQuad extends Bas
      * @param object    The optional exact object to match.
      * @param graph     The optional exact graph to match.
      */
-    match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): this;
+    match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): DatasetCore<OutQuad, InQuad>;
 
     [Symbol.iterator](): Iterator<OutQuad>;
 }
@@ -495,7 +495,7 @@ export interface Dataset<OutQuad extends BaseQuad = Quad, InQuad extends BaseQua
     /**
      * Returns a new dataset that contains all quads from the current dataset, not included in the given dataset.
      */
-    difference(other: Dataset<InQuad>): this;
+    difference(other: Dataset<InQuad>): Dataset<OutQuad, InQuad>;
 
     /**
      * Returns true if the current instance contains the same graph structure as the given dataset.
@@ -521,7 +521,7 @@ export interface Dataset<OutQuad extends BaseQuad = Quad, InQuad extends BaseQua
      *
      * This method is aligned with Array.prototype.filter() in ECMAScript-262.
      */
-    filter(iteratee: QuadFilterIteratee<OutQuad>['test']): this;
+    filter(iteratee: QuadFilterIteratee<OutQuad>['test']): Dataset<OutQuad, InQuad>;
 
     /**
      * Executes the provided `iteratee` once on each quad in the dataset.
@@ -545,7 +545,7 @@ export interface Dataset<OutQuad extends BaseQuad = Quad, InQuad extends BaseQua
     /**
      * Returns a new dataset containing all quads returned by applying `iteratee` to each quad in the current dataset.
      */
-    map(iteratee: QuadMapIteratee<OutQuad>['map']): this;
+    map(iteratee: QuadMapIteratee<OutQuad>['map']): Dataset<OutQuad, InQuad>;
 
     /**
      * This method calls the `iteratee` on each `quad` of the `Dataset`. The first time the `iteratee` is called, the
@@ -598,7 +598,9 @@ export interface Dataset<OutQuad extends BaseQuad = Quad, InQuad extends BaseQua
     /**
      * Returns a new `Dataset` that is a concatenation of this dataset and the quads given as an argument.
      */
-    union(quads: Dataset<InQuad>): this;
+    union(quads: Dataset<InQuad>): Dataset<OutQuad, InQuad>;
+
+    match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Dataset<OutQuad, InQuad>;
 }
 
 export interface DatasetFactory<OutQuad extends BaseQuad = Quad, InQuad extends BaseQuad = OutQuad, D extends Dataset<OutQuad, InQuad> = Dataset<OutQuad, InQuad>>

diff --git a/types/rdf-js/rdf-js-tests.ts b/types/rdf-js/rdf-js-tests.ts
@@ -325,3 +325,123 @@ async function test_dataset_covariance(): Promise<Dataset> {
     datasetExt.union(dataset);
     return datasetExt.import(stream);
 }
+
+class DatasetCoreExt implements DatasetCore {
+    size: number;
+
+    add(): this {
+        throw new Error("Method not implemented.");
+    }
+
+    delete(): this {
+        throw new Error("Method not implemented.");
+    }
+
+    has(): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    match(): DatasetCore<Quad, Quad> {
+        const newInstance: DatasetCoreExt = <any> {};
+        return newInstance;
+    }
+
+    [Symbol.iterator](): Iterator<Quad> {
+        throw new Error("Method not implemented.");
+    }
+}
+
+class DatasetExt extends DatasetCoreExt implements Dataset {
+    addAll(): this {
+        throw new Error("Method not implemented.");
+    }
+
+    contains(): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    deleteMatches(): this {
+        throw new Error("Method not implemented.");
+    }
+
+    difference(): Dataset<Quad, Quad> {
+        const newInstance: DatasetExt = <any> {};
+        return newInstance;
+    }
+
+    equals(): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    every(): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    filter(): Dataset<Quad, Quad> {
+        const newInstance: DatasetExt = <any> {};
+        return newInstance;
+    }
+
+    forEach(): void {
+        throw new Error("Method not implemented.");
+    }
+
+    import(): Promise<this> {
+        throw new Error("Method not implemented.");
+    }
+
+    intersection(): this {
+        throw new Error("Method not implemented.");
+    }
+
+    map(): Dataset<Quad, Quad> {
+        const newInstance: DatasetExt = <any> {};
+        return newInstance;
+    }
+
+    match(): Dataset<Quad, Quad> {
+        const newInstance: DatasetExt = <any> {};
+        return newInstance;
+    }
+
+    reduce(): any {
+        throw new Error("Method not implemented.");
+    }
+
+    some(): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    toArray(): Quad[] {
+        throw new Error("Method not implemented.");
+    }
+
+    toCanonical(): string {
+        throw new Error("Method not implemented.");
+    }
+
+    toStream(): Stream {
+        throw new Error("Method not implemented.");
+    }
+
+    toString(): string {
+        throw new Error("Method not implemented.");
+    }
+
+    union(): Dataset<Quad, Quad> {
+        const newInstance: DatasetExt = <any> {};
+        return newInstance;
+    }
+}
+
+function testInheritance() {
+    const datasetCoreExt: DatasetCoreExt = new DatasetCoreExt();
+    const datasetCoreMatch: DatasetCore = datasetCoreExt.match();
+
+    const datasetExt: DatasetExt = new DatasetExt();
+    const datasetMatch: Dataset = datasetExt.match();
+    const datasetMap: Dataset = datasetExt.map();
+    const datasetUnion: Dataset = datasetExt.union();
+    const datasetFilter: Dataset = datasetExt.filter();
+    const datasetDifference: Dataset = datasetExt.difference();
+}
diff --git a/types/rdfjs__dataset/DatasetCore.d.ts b/types/rdfjs__dataset/DatasetCore.d.ts
@@ -1,7 +1,8 @@
 import * as RDF from 'rdf-js';
 
-// tslint:disable-next-line no-empty-interface
-interface DatasetCore<InQuad extends RDF.BaseQuad = RDF.Quad> extends RDF.DatasetCore<RDF.Quad, InQuad> {}
+interface DatasetCore<InQuad extends RDF.BaseQuad = RDF.Quad> extends RDF.DatasetCore<RDF.Quad, InQuad> {
+    match(subject?: RDF.Term | null, predicate?: RDF.Term | null, object?: RDF.Term | null, graph?: RDF.Term | null): DatasetCore<InQuad>;
+}
 
 // tslint:disable-next-line no-unnecessary-class
 declare class DatasetCore<InQuad> {