Skip to content

Commit 5fa0fb4

Browse files
ahejlsbergahejlsberg
committed
Accept new baselines
1 parent f29d7df commit 5fa0fb4

5 files changed

+1435
-0
lines changed

‎tests/baselines/reference/inferFromGenericFunctionReturnTypes1.errors.txt

Lines changed: 77 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,77 @@
1+
tests/cases/compiler/inferFromGenericFunctionReturnTypes1.ts(68,16): error TS2339: Property 'toUpperCase' does not exist on type 'number'.
2+
3+
4+
==== tests/cases/compiler/inferFromGenericFunctionReturnTypes1.ts (1 errors) ====
5+
// Repro from #15680
6+
7+
// This is a contrived class. We could do the same thing with Observables, etc.
8+
class SetOf<A> {
9+
_store: A[];
10+
11+
add(a: A) {
12+
this._store.push(a);
13+
}
14+
15+
transform<B>(transformer: (a: SetOf<A>) => SetOf<B>): SetOf<B> {
16+
return transformer(this);
17+
}
18+
19+
forEach(fn: (a: A, index: number) => void) {
20+
this._store.forEach((a, i) => fn(a, i));
21+
}
22+
}
23+
24+
function compose<A, B, C, D, E>(
25+
fnA: (a: SetOf<A>) => SetOf<B>,
26+
fnB: (b: SetOf<B>) => SetOf<C>,
27+
fnC: (c: SetOf<C>) => SetOf<D>,
28+
fnD: (c: SetOf<D>) => SetOf<E>,
29+
):(x: SetOf<A>) => SetOf<E>;
30+
/* ... etc ... */
31+
function compose<T>(...fns: ((x: T) => T)[]): (x: T) => T {
32+
return (x: T) => fns.reduce((prev, fn) => fn(prev), x);
33+
}
34+
35+
function map<A, B>(fn: (a: A) => B): (s: SetOf<A>) => SetOf<B> {
36+
return (a: SetOf<A>) => {
37+
const b: SetOf<B> = new SetOf();
38+
a.forEach(x => b.add(fn(x)));
39+
return b;
40+
}
41+
}
42+
43+
function filter<A>(predicate: (a: A) => boolean): (s: SetOf<A>) => SetOf<A> {
44+
return (a: SetOf<A>) => {
45+
const result = new SetOf<A>();
46+
a.forEach(x => {
47+
if (predicate(x)) result.add(x);
48+
});
49+
return result;
50+
}
51+
}
52+
53+
const testSet = new SetOf<number>();
54+
testSet.add(1);
55+
testSet.add(2);
56+
testSet.add(3);
57+
58+
testSet.transform(
59+
compose(
60+
filter(x => x % 1 === 0),
61+
map(x => x + x),
62+
map(x => x + '!!!'),
63+
map(x => x.toUpperCase())
64+
)
65+
)
66+
67+
testSet.transform(
68+
compose(
69+
filter(x => x % 1 === 0),
70+
map(x => x + x),
71+
map(x => 123), // Whoops a bug
72+
map(x => x.toUpperCase()) // causes an error!
73+
~~~~~~~~~~~
74+
!!! error TS2339: Property 'toUpperCase' does not exist on type 'number'.
75+
)
76+
)
77+

‎tests/baselines/reference/inferFromGenericFunctionReturnTypes1.js

Lines changed: 123 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
1+
//// [inferFromGenericFunctionReturnTypes1.ts]
2+
// Repro from #15680
3+
4+
// This is a contrived class. We could do the same thing with Observables, etc.
5+
class SetOf<A> {
6+
_store: A[];
7+
8+
add(a: A) {
9+
this._store.push(a);
10+
}
11+
12+
transform<B>(transformer: (a: SetOf<A>) => SetOf<B>): SetOf<B> {
13+
return transformer(this);
14+
}
15+
16+
forEach(fn: (a: A, index: number) => void) {
17+
this._store.forEach((a, i) => fn(a, i));
18+
}
19+
}
20+
21+
function compose<A, B, C, D, E>(
22+
fnA: (a: SetOf<A>) => SetOf<B>,
23+
fnB: (b: SetOf<B>) => SetOf<C>,
24+
fnC: (c: SetOf<C>) => SetOf<D>,
25+
fnD: (c: SetOf<D>) => SetOf<E>,
26+
):(x: SetOf<A>) => SetOf<E>;
27+
/* ... etc ... */
28+
function compose<T>(...fns: ((x: T) => T)[]): (x: T) => T {
29+
return (x: T) => fns.reduce((prev, fn) => fn(prev), x);
30+
}
31+
32+
function map<A, B>(fn: (a: A) => B): (s: SetOf<A>) => SetOf<B> {
33+
return (a: SetOf<A>) => {
34+
const b: SetOf<B> = new SetOf();
35+
a.forEach(x => b.add(fn(x)));
36+
return b;
37+
}
38+
}
39+
40+
function filter<A>(predicate: (a: A) => boolean): (s: SetOf<A>) => SetOf<A> {
41+
return (a: SetOf<A>) => {
42+
const result = new SetOf<A>();
43+
a.forEach(x => {
44+
if (predicate(x)) result.add(x);
45+
});
46+
return result;
47+
}
48+
}
49+
50+
const testSet = new SetOf<number>();
51+
testSet.add(1);
52+
testSet.add(2);
53+
testSet.add(3);
54+
55+
testSet.transform(
56+
compose(
57+
filter(x => x % 1 === 0),
58+
map(x => x + x),
59+
map(x => x + '!!!'),
60+
map(x => x.toUpperCase())
61+
)
62+
)
63+
64+
testSet.transform(
65+
compose(
66+
filter(x => x % 1 === 0),
67+
map(x => x + x),
68+
map(x => 123), // Whoops a bug
69+
map(x => x.toUpperCase()) // causes an error!
70+
)
71+
)
72+
73+
74+
//// [inferFromGenericFunctionReturnTypes1.js]
75+
// Repro from #15680
76+
// This is a contrived class. We could do the same thing with Observables, etc.
77+
var SetOf = (function () {
78+
function SetOf() {
79+
}
80+
SetOf.prototype.add = function (a) {
81+
this._store.push(a);
82+
};
83+
SetOf.prototype.transform = function (transformer) {
84+
return transformer(this);
85+
};
86+
SetOf.prototype.forEach = function (fn) {
87+
this._store.forEach(function (a, i) { return fn(a, i); });
88+
};
89+
return SetOf;
90+
}());
91+
/* ... etc ... */
92+
function compose() {
93+
var fns = [];
94+
for (var _i = 0; _i < arguments.length; _i++) {
95+
fns[_i] = arguments[_i];
96+
}
97+
return function (x) { return fns.reduce(function (prev, fn) { return fn(prev); }, x); };
98+
}
99+
function map(fn) {
100+
return function (a) {
101+
var b = new SetOf();
102+
a.forEach(function (x) { return b.add(fn(x)); });
103+
return b;
104+
};
105+
}
106+
function filter(predicate) {
107+
return function (a) {
108+
var result = new SetOf();
109+
a.forEach(function (x) {
110+
if (predicate(x))
111+
result.add(x);
112+
});
113+
return result;
114+
};
115+
}
116+
var testSet = new SetOf();
117+
testSet.add(1);
118+
testSet.add(2);
119+
testSet.add(3);
120+
testSet.transform(compose(filter(function (x) { return x % 1 === 0; }), map(function (x) { return x + x; }), map(function (x) { return x + '!!!'; }), map(function (x) { return x.toUpperCase(); })));
121+
testSet.transform(compose(filter(function (x) { return x % 1 === 0; }), map(function (x) { return x + x; }), map(function (x) { return 123; }), // Whoops a bug
122+
map(function (x) { return x.toUpperCase(); }) // causes an error!
123+
));

‎tests/baselines/reference/inferFromGenericFunctionReturnTypes2.js

Lines changed: 155 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,155 @@
1+
//// [inferFromGenericFunctionReturnTypes2.ts]
2+
type Mapper<T, U> = (x: T) => U;
3+
4+
declare function wrap<T, U>(cb: Mapper<T, U>): Mapper<T, U>;
5+
6+
declare function arrayize<T, U>(cb: Mapper<T, U>): Mapper<T, U[]>;
7+
8+
declare function combine<A, B, C>(f: (x: A) => B, g: (x: B) => C): (x: A) => C;
9+
10+
declare function foo(f: Mapper<string, number>): void;
11+
12+
let f1: Mapper<string, number> = s => s.length;
13+
let f2: Mapper<string, number> = wrap(s => s.length);
14+
let f3: Mapper<string, number[]> = arrayize(wrap(s => s.length));
15+
let f4: Mapper<string, boolean> = combine(wrap(s => s.length), wrap(n => n >= 10));
16+
17+
foo(wrap(s => s.length));
18+
19+
let a1 = ["a", "b"].map(s => s.length);
20+
let a2 = ["a", "b"].map(wrap(s => s.length));
21+
let a3 = ["a", "b"].map(wrap(arrayize(s => s.length)));
22+
let a4 = ["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10)));
23+
let a5 = ["a", "b"].map(combine(identity, wrap(s => s.length)));
24+
let a6 = ["a", "b"].map(combine(wrap(s => s.length), identity));
25+
26+
// This is a contrived class. We could do the same thing with Observables, etc.
27+
class SetOf<A> {
28+
_store: A[];
29+
30+
add(a: A) {
31+
this._store.push(a);
32+
}
33+
34+
transform<B>(transformer: (a: SetOf<A>) => SetOf<B>): SetOf<B> {
35+
return transformer(this);
36+
}
37+
38+
forEach(fn: (a: A, index: number) => void) {
39+
this._store.forEach((a, i) => fn(a, i));
40+
}
41+
}
42+
43+
function compose<A, B, C, D, E>(
44+
fnA: (a: SetOf<A>) => SetOf<B>,
45+
fnB: (b: SetOf<B>) => SetOf<C>,
46+
fnC: (c: SetOf<C>) => SetOf<D>,
47+
fnD: (c: SetOf<D>) => SetOf<E>,
48+
):(x: SetOf<A>) => SetOf<E>;
49+
/* ... etc ... */
50+
function compose<T>(...fns: ((x: T) => T)[]): (x: T) => T {
51+
return (x: T) => fns.reduce((prev, fn) => fn(prev), x);
52+
}
53+
54+
function map<A, B>(fn: (a: A) => B): (s: SetOf<A>) => SetOf<B> {
55+
return (a: SetOf<A>) => {
56+
const b: SetOf<B> = new SetOf();
57+
a.forEach(x => b.add(fn(x)));
58+
return b;
59+
}
60+
}
61+
62+
function filter<A>(predicate: (a: A) => boolean): (s: SetOf<A>) => SetOf<A> {
63+
return (a: SetOf<A>) => {
64+
const result = new SetOf<A>();
65+
a.forEach(x => {
66+
if (predicate(x)) result.add(x);
67+
});
68+
return result;
69+
}
70+
}
71+
72+
const testSet = new SetOf<number>();
73+
testSet.add(1);
74+
testSet.add(2);
75+
testSet.add(3);
76+
77+
const t1 = testSet.transform(
78+
compose(
79+
filter(x => x % 1 === 0),
80+
map(x => x + x),
81+
map(x => x + '!!!'),
82+
map(x => x.toUpperCase())
83+
)
84+
)
85+
86+
declare function identity<T>(x: T): T;
87+
88+
const t2 = testSet.transform(
89+
compose(
90+
filter(x => x % 1 === 0),
91+
identity,
92+
map(x => x + '!!!'),
93+
map(x => x.toUpperCase())
94+
)
95+
)
96+
97+
98+
//// [inferFromGenericFunctionReturnTypes2.js]
99+
var f1 = function (s) { return s.length; };
100+
var f2 = wrap(function (s) { return s.length; });
101+
var f3 = arrayize(wrap(function (s) { return s.length; }));
102+
var f4 = combine(wrap(function (s) { return s.length; }), wrap(function (n) { return n >= 10; }));
103+
foo(wrap(function (s) { return s.length; }));
104+
var a1 = ["a", "b"].map(function (s) { return s.length; });
105+
var a2 = ["a", "b"].map(wrap(function (s) { return s.length; }));
106+
var a3 = ["a", "b"].map(wrap(arrayize(function (s) { return s.length; })));
107+
var a4 = ["a", "b"].map(combine(wrap(function (s) { return s.length; }), wrap(function (n) { return n > 10; })));
108+
var a5 = ["a", "b"].map(combine(identity, wrap(function (s) { return s.length; })));
109+
var a6 = ["a", "b"].map(combine(wrap(function (s) { return s.length; }), identity));
110+
// This is a contrived class. We could do the same thing with Observables, etc.
111+
var SetOf = (function () {
112+
function SetOf() {
113+
}
114+
SetOf.prototype.add = function (a) {
115+
this._store.push(a);
116+
};
117+
SetOf.prototype.transform = function (transformer) {
118+
return transformer(this);
119+
};
120+
SetOf.prototype.forEach = function (fn) {
121+
this._store.forEach(function (a, i) { return fn(a, i); });
122+
};
123+
return SetOf;
124+
}());
125+
/* ... etc ... */
126+
function compose() {
127+
var fns = [];
128+
for (var _i = 0; _i < arguments.length; _i++) {
129+
fns[_i] = arguments[_i];
130+
}
131+
return function (x) { return fns.reduce(function (prev, fn) { return fn(prev); }, x); };
132+
}
133+
function map(fn) {
134+
return function (a) {
135+
var b = new SetOf();
136+
a.forEach(function (x) { return b.add(fn(x)); });
137+
return b;
138+
};
139+
}
140+
function filter(predicate) {
141+
return function (a) {
142+
var result = new SetOf();
143+
a.forEach(function (x) {
144+
if (predicate(x))
145+
result.add(x);
146+
});
147+
return result;
148+
};
149+
}
150+
var testSet = new SetOf();
151+
testSet.add(1);
152+
testSet.add(2);
153+
testSet.add(3);
154+
var t1 = testSet.transform(compose(filter(function (x) { return x % 1 === 0; }), map(function (x) { return x + x; }), map(function (x) { return x + '!!!'; }), map(function (x) { return x.toUpperCase(); })));
155+
var t2 = testSet.transform(compose(filter(function (x) { return x % 1 === 0; }), identity, map(function (x) { return x + '!!!'; }), map(function (x) { return x.toUpperCase(); })));

0 commit comments

Comments
 (0)