Update tests and baselines

2018-02-09 16:20:44 -08:00 · 2018-02-09 16:20:44 -08:00 · 03d155f622
parent 15554d7ea5
commit 03d155f622
6 changed files with 134 additions and 121 deletions
--- a/tests/baselines/reference/typeFromPropertyAssignment8.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment8.symbols
@ -70,6 +70,3 @@ min.app.Application()
 >app : Symbol(app, Decl(b.js, 0, 27))
 >Application : Symbol(Application, Decl(b.js, 1, 24))

-// TODO: Make sure to include github.com/chadbr/vscodeTestJS
-// (though extracted to 4 js files instead of 2 js files and an html)
-
--- a/tests/baselines/reference/typeFromPropertyAssignment8.types
+++ b/tests/baselines/reference/typeFromPropertyAssignment8.types
@ -94,6 +94,3 @@ min.app.Application()
 >app : { [x: string]: any; Application: () => void; }
 >Application : () => void

-// TODO: Make sure to include github.com/chadbr/vscodeTestJS
-// (though extracted to 4 js files instead of 2 js files and an html)
-
--- a/tests/baselines/reference/typeFromPropertyAssignment9.symbols
+++ b/tests/baselines/reference/typeFromPropertyAssignment9.symbols
@ -1,39 +1,41 @@
 === tests/cases/conformance/salsa/a.js ===
-// TODO: JSDoc would provide a contextual type, so ... I should test that
 var my = my || {};
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))

-my.method = function() {
->my.method : Symbol(method, Decl(a.js, 1, 18))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->method : Symbol(method, Decl(a.js, 1, 18))
+/** @param {number} n */
+my.method = function(n) {
+>my.method : Symbol(method, Decl(a.js, 0, 18))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>method : Symbol(method, Decl(a.js, 0, 18))
+>n : Symbol(n, Decl(a.js, 2, 21))

-    return 1;
+    return n + 1;
+>n : Symbol(n, Decl(a.js, 2, 21))
 }
 my.number = 1;
 >my.number : Symbol(number, Decl(a.js, 4, 1))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
 >number : Symbol(number, Decl(a.js, 4, 1))

 my.object = {};
 >my.object : Symbol(object, Decl(a.js, 5, 14))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
 >object : Symbol(object, Decl(a.js, 5, 14))

 my.predicate = my.predicate || {};
->my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
+>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))

 my.predicate.query = function () {
 >my.predicate.query : Symbol(query, Decl(a.js, 7, 34))
->my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
+>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
 >query : Symbol(query, Decl(a.js, 7, 34))

    var me = this;
@ -47,67 +49,73 @@ my.predicate.query = function () {
 var q = new my.predicate.query();
 >q : Symbol(q, Decl(a.js, 12, 3))
 >my.predicate.query : Symbol(query, Decl(a.js, 7, 34))
->my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
+>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
 >query : Symbol(query, Decl(a.js, 7, 34))

 my.predicate.query.result = 'none'
 >my.predicate.query.result : Symbol((Anonymous function).result, Decl(a.js, 12, 33))
 >my.predicate.query : Symbol(query, Decl(a.js, 7, 34))
->my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
+>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
 >query : Symbol(query, Decl(a.js, 7, 34))
 >result : Symbol((Anonymous function).result, Decl(a.js, 12, 33))

+/** @param {number} first
+ *  @param {number} second
+ */
 my.predicate.sort = my.predicate.sort || function (first, second) {
 >my.predicate.sort : Symbol(sort, Decl(a.js, 13, 34))
->my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
+>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
 >sort : Symbol(sort, Decl(a.js, 13, 34))
 >my.predicate.sort : Symbol(sort, Decl(a.js, 13, 34))
->my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
+>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
 >sort : Symbol(sort, Decl(a.js, 13, 34))
->first : Symbol(first, Decl(a.js, 14, 51))
->second : Symbol(second, Decl(a.js, 14, 57))
+>first : Symbol(first, Decl(a.js, 17, 51))
+>second : Symbol(second, Decl(a.js, 17, 57))

-    return first;
->first : Symbol(first, Decl(a.js, 14, 51))
+    return first > second ? first : second;
+>first : Symbol(first, Decl(a.js, 17, 51))
+>second : Symbol(second, Decl(a.js, 17, 57))
+>first : Symbol(first, Decl(a.js, 17, 51))
+>second : Symbol(second, Decl(a.js, 17, 57))
 }
 my.predicate.type = class {
->my.predicate.type : Symbol(type, Decl(a.js, 16, 1))
->my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->my : Symbol(my, Decl(a.js, 1, 3), Decl(a.js, 1, 18))
->predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 16, 1))
->type : Symbol(type, Decl(a.js, 16, 1))
+>my.predicate.type : Symbol(type, Decl(a.js, 19, 1))
+>my.predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>my : Symbol(my, Decl(a.js, 0, 3), Decl(a.js, 0, 18))
+>predicate : Symbol(predicate, Decl(a.js, 6, 15), Decl(a.js, 7, 34), Decl(a.js, 19, 1))
+>type : Symbol(type, Decl(a.js, 19, 1))

    m() { return 101; }
->m : Symbol((Anonymous class).m, Decl(a.js, 17, 27))
+>m : Symbol((Anonymous class).m, Decl(a.js, 20, 27))
 }


 // global-ish prefixes
 var min = window.min || {};
->min : Symbol(min, Decl(a.js, 23, 3))
+>min : Symbol(min, Decl(a.js, 26, 3))

 min.nest = this.min.nest || function () { };
->min.nest : Symbol(nest, Decl(a.js, 23, 27))
->min : Symbol(min, Decl(a.js, 23, 3))
->nest : Symbol(nest, Decl(a.js, 23, 27))
+>min.nest : Symbol(nest, Decl(a.js, 26, 27))
+>min : Symbol(min, Decl(a.js, 26, 3))
+>nest : Symbol(nest, Decl(a.js, 26, 27))

 min.nest.other = self.min.nest.other || class { };
->min.nest.other : Symbol((Anonymous function).other, Decl(a.js, 24, 44))
->min.nest : Symbol(nest, Decl(a.js, 23, 27))
->min : Symbol(min, Decl(a.js, 23, 3))
->nest : Symbol(nest, Decl(a.js, 23, 27))
->other : Symbol((Anonymous function).other, Decl(a.js, 24, 44))
+>min.nest.other : Symbol((Anonymous function).other, Decl(a.js, 27, 44))
+>min.nest : Symbol(nest, Decl(a.js, 26, 27))
+>min : Symbol(min, Decl(a.js, 26, 3))
+>nest : Symbol(nest, Decl(a.js, 26, 27))
+>other : Symbol((Anonymous function).other, Decl(a.js, 27, 44))

 min.property = global.min.property || {};
->min.property : Symbol(property, Decl(a.js, 25, 50))
->min : Symbol(min, Decl(a.js, 23, 3))
->property : Symbol(property, Decl(a.js, 25, 50))
+>min.property : Symbol(property, Decl(a.js, 28, 50))
+>min : Symbol(min, Decl(a.js, 26, 3))
+>property : Symbol(property, Decl(a.js, 28, 50))

--- a/tests/baselines/reference/typeFromPropertyAssignment9.types
+++ b/tests/baselines/reference/typeFromPropertyAssignment9.types
@ -1,63 +1,66 @@
 === tests/cases/conformance/salsa/a.js ===
-// TODO: JSDoc would provide a contextual type, so ... I should test that
 var my = my || {};
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->my || {} : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->{} : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>my || {} : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>{} : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }

-my.method = function() {
->my.method = function() {    return 1;} : () => number
->my.method : () => number
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->method : () => number
->function() {    return 1;} : () => number
+/** @param {number} n */
+my.method = function(n) {
+>my.method = function(n) {    return n + 1;} : (n: number) => number
+>my.method : (n: number) => number
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>method : (n: number) => number
+>function(n) {    return n + 1;} : (n: number) => number
+>n : number

-    return 1;
+    return n + 1;
+>n + 1 : number
+>n : number
 >1 : 1
 }
 my.number = 1;
 >my.number = 1 : 1
 >my.number : number
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
 >number : number
 >1 : 1

 my.object = {};
 >my.object = {} : { [x: string]: any; }
 >my.object : { [x: string]: any; }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
 >object : { [x: string]: any; }
 >{} : { [x: string]: any; }

 my.predicate = my.predicate || {};
->my.predicate = my.predicate || {} : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my.predicate || {} : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->{} : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
+>my.predicate = my.predicate || {} : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my.predicate || {} : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>{} : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }

 my.predicate.query = function () {
 >my.predicate.query = function () {    var me = this;    me.property = false;} : { (): void; result: string; }
 >my.predicate.query : { (): void; result: string; }
->my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
+>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
 >query : { (): void; result: string; }
 >function () {    var me = this;    me.property = false;} : { (): void; result: string; }

    var me = this;
->me : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->this : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
+>me : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>this : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }

    me.property = false;
 >me.property = false : false
 >me.property : any
->me : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
+>me : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
 >property : any
 >false : false

@ -66,48 +69,56 @@ var q = new my.predicate.query();
 >q : any
 >new my.predicate.query() : any
 >my.predicate.query : { (): void; result: string; }
->my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
+>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
 >query : { (): void; result: string; }

 my.predicate.query.result = 'none'
 >my.predicate.query.result = 'none' : "none"
 >my.predicate.query.result : string
 >my.predicate.query : { (): void; result: string; }
->my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
+>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
 >query : { (): void; result: string; }
 >result : string
 >'none' : "none"

+/** @param {number} first
+ *  @param {number} second
+ */
 my.predicate.sort = my.predicate.sort || function (first, second) {
->my.predicate.sort = my.predicate.sort || function (first, second) {    return first;} : (first: any, second: any) => any
->my.predicate.sort : (first: any, second: any) => any
->my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->sort : (first: any, second: any) => any
->my.predicate.sort || function (first, second) {    return first;} : (first: any, second: any) => any
->my.predicate.sort : (first: any, second: any) => any
->my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->sort : (first: any, second: any) => any
->function (first, second) {    return first;} : (first: any, second: any) => any
->first : any
->second : any
+>my.predicate.sort = my.predicate.sort || function (first, second) {    return first > second ? first : second;} : (first: number, second: number) => number
+>my.predicate.sort : (first: number, second: number) => number
+>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>sort : (first: number, second: number) => number
+>my.predicate.sort || function (first, second) {    return first > second ? first : second;} : (first: number, second: number) => number
+>my.predicate.sort : (first: number, second: number) => number
+>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>sort : (first: number, second: number) => number
+>function (first, second) {    return first > second ? first : second;} : (first: number, second: number) => number
+>first : number
+>second : number

-    return first;
->first : any
+    return first > second ? first : second;
+>first > second ? first : second : number
+>first > second : boolean
+>first : number
+>second : number
+>first : number
+>second : number
 }
 my.predicate.type = class {
 >my.predicate.type = class {    m() { return 101; }} : typeof (Anonymous class)
 >my.predicate.type : typeof (Anonymous class)
->my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
->my : { [x: string]: any; method: () => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }; }
->predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: any, second: any) => any; type: typeof (Anonymous class); }
+>my.predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
+>my : { [x: string]: any; method: (n: number) => number; number: number; object: { [x: string]: any; }; predicate: { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }; }
+>predicate : { [x: string]: any; query: { (): void; result: string; }; sort: (first: number, second: number) => number; type: typeof (Anonymous class); }
 >type : typeof (Anonymous class)
 >class {    m() { return 101; }} : typeof (Anonymous class)

--- a/tests/cases/conformance/salsa/typeFromPropertyAssignment8.ts
+++ b/tests/cases/conformance/salsa/typeFromPropertyAssignment8.ts
@ -26,6 +26,3 @@ var Application = function () {
 return Application;
 })();
 min.app.Application()
-
-// TODO: Make sure to include github.com/chadbr/vscodeTestJS
-// (though extracted to 4 js files instead of 2 js files and an html)
--- a/tests/cases/conformance/salsa/typeFromPropertyAssignment9.ts
+++ b/tests/cases/conformance/salsa/typeFromPropertyAssignment9.ts
@ -4,10 +4,10 @@
 // @target: es6
 // @Filename: a.js

-// TODO: JSDoc would provide a contextual type, so ... I should test that
 var my = my || {};
-my.method = function() {
-    return 1;
+/** @param {number} n */
+my.method = function(n) {
+    return n + 1;
 }
 my.number = 1;
 my.object = {};
@ -18,8 +18,11 @@ my.predicate.query = function () {
 };
 var q = new my.predicate.query();
 my.predicate.query.result = 'none'
+/** @param {number} first
+ *  @param {number} second
+ */
 my.predicate.sort = my.predicate.sort || function (first, second) {
-    return first;
+    return first > second ? first : second;
 }
 my.predicate.type = class {
    m() { return 101; }