c3d41bbb73
* First attempt at aliases for require * test+initial support for const x=require * 1st round of baseline improvements * 2nd round of baseline updates * support property access after require * check @type tag on require * forbid expando missing namespaces on aliases taken from #39558 as soon as it was created * accept error baselines that are good, actually * Scribbling on d.ts emit code * use getSpecifierForModuleSymbol * hideous hack for module.exports of aliases * Fix module.exports.x --> export list emit * fix isLocalImport predicate * require only creates aliases in JS * re-handle json imports * update fourslash baseline * Cleanup in the checker 1. Simplify alias resolution. 2. Simplify variable-like checking. 3. Make binding skip require calls with type tags -- they fall back to the old require-call code and then check from there. I haven't started on the declaration emit code since I don't know what is going on there nearly as well. * Function for getting module name from require call * First round of cleanup plus a new test Found one missing feature, not sure it's worth adding. * more small cleanup * more cleanup, including lint * use trackSymbol, not serializeTypeForDeclaration * Code review comments, plus remove unneeded code Ad-hoc type reference resolution for `require` isn't needed anymore. * find all refs works * remove old ad-hoc code * make it clear that old behaviour is not that correct * update api baselines * remove outdated comment * PR feedback 1. Fix indentation 2. Add comment for exported JSON emit 3. Add test case for nested-namespace exports. * add a fail-case test (which passes!)
108 lines
2.3 KiB
Plaintext
108 lines
2.3 KiB
Plaintext
=== tests/cases/conformance/salsa/use.js ===
|
|
/// <reference path='./types.d.ts'/>
|
|
var mod = require('./mod');
|
|
>mod : typeof mod
|
|
>require('./mod') : typeof mod
|
|
>require : (name: string) => any
|
|
>'./mod' : "./mod"
|
|
|
|
var a = new mod.A()
|
|
>a : A
|
|
>new mod.A() : A
|
|
>mod.A : typeof A
|
|
>mod : typeof mod
|
|
>A : typeof A
|
|
|
|
var b = new mod.B()
|
|
>b : B
|
|
>new mod.B() : B
|
|
>mod.B : typeof B
|
|
>mod : typeof mod
|
|
>B : typeof B
|
|
|
|
a.m('nope')
|
|
>a.m('nope') : number
|
|
>a.m : (n: number) => number
|
|
>a : A
|
|
>m : (n: number) => number
|
|
>'nope' : "nope"
|
|
|
|
b.m('not really')
|
|
>b.m('not really') : number
|
|
>b.m : (n: number) => number
|
|
>b : B
|
|
>m : (n: number) => number
|
|
>'not really' : "not really"
|
|
|
|
=== tests/cases/conformance/salsa/types.d.ts ===
|
|
declare function require(name: string): any;
|
|
>require : (name: string) => any
|
|
>name : string
|
|
|
|
declare var exports: any;
|
|
>exports : any
|
|
|
|
=== tests/cases/conformance/salsa/mod.js ===
|
|
/// <reference path='./types.d.ts'/>
|
|
var A = function A() {
|
|
>A : typeof A
|
|
>function A() { this.a = 1} : typeof A
|
|
>A : typeof A
|
|
|
|
this.a = 1
|
|
>this.a = 1 : 1
|
|
>this.a : any
|
|
>this : this
|
|
>a : any
|
|
>1 : 1
|
|
}
|
|
var B = function B() {
|
|
>B : typeof B
|
|
>function B() { this.b = 2} : typeof B
|
|
>B : typeof B
|
|
|
|
this.b = 2
|
|
>this.b = 2 : 2
|
|
>this.b : any
|
|
>this : this
|
|
>b : any
|
|
>2 : 2
|
|
}
|
|
exports.A = A
|
|
>exports.A = A : typeof A
|
|
>exports.A : typeof A
|
|
>exports : typeof import("tests/cases/conformance/salsa/mod")
|
|
>A : typeof A
|
|
>A : typeof A
|
|
|
|
exports.B = B
|
|
>exports.B = B : typeof B
|
|
>exports.B : typeof B
|
|
>exports : typeof import("tests/cases/conformance/salsa/mod")
|
|
>B : typeof B
|
|
>B : typeof B
|
|
|
|
A.prototype = B.prototype = {
|
|
>A.prototype = B.prototype = { /** @param {number} n */ m(n) { return n + 1 }} : { m(n: number): number; }
|
|
>A.prototype : { m(n: number): number; }
|
|
>A : typeof A
|
|
>prototype : { m(n: number): number; }
|
|
>B.prototype = { /** @param {number} n */ m(n) { return n + 1 }} : { m(n: number): number; }
|
|
>B.prototype : { m(n: number): number; }
|
|
>B : typeof B
|
|
>prototype : { m(n: number): number; }
|
|
>{ /** @param {number} n */ m(n) { return n + 1 }} : { m(n: number): number; }
|
|
|
|
/** @param {number} n */
|
|
m(n) {
|
|
>m : (n: number) => number
|
|
>n : number
|
|
|
|
return n + 1
|
|
>n + 1 : number
|
|
>n : number
|
|
>1 : 1
|
|
}
|
|
}
|
|
|