mirror of
https://github.com/microsoft/TypeScript.git
synced 2025-11-18 17:21:48 +00:00
Merge branch 'master' into bom
Conflicts: src/compiler/commandLineParser.ts src/compiler/emitter.ts
This commit is contained in:
Mohamed Hegazy
@@ -0,0 +1,106 @@
|
||||
==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_externalModule.ts (4 errors) ====
|
||||
|
||||
export module publicModule {
|
||||
export class publicClassInPublicModule {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'.
|
||||
}
|
||||
|
||||
class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'.
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
export class publicClassInPrivateModule {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClassInModule extends publicClassInPrivateModule {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingPublicClassInModule extends publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingPrivateClassInModule extends privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClass extends publicClass {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClass {
|
||||
}
|
||||
export class publicClassExtendingPublicClass extends publicClass {
|
||||
}
|
||||
export class publicClassExtendingPrivateClass extends privateClass { // Should error
|
||||
~~~~~~~~~~~~
|
||||
!!! Extends clause of exported class 'publicClassExtendingPrivateClass' has or is using private name 'privateClass'.
|
||||
}
|
||||
|
||||
class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported class 'publicClassExtendingFromPrivateModuleClass' has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'.
|
||||
}
|
||||
|
||||
==== tests/cases/compiler/privacyClassExtendsClauseDeclFile_GlobalFile.ts (1 errors) ====
|
||||
module publicModuleInGlobal {
|
||||
export class publicClassInPublicModule {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported class 'publicClassExtendingPrivateClassInModule' has or is using private name 'privateClassInPublicModule'.
|
||||
}
|
||||
}
|
||||
class publicClassInGlobal {
|
||||
}
|
||||
class publicClassExtendingPublicClassInGlobal extends publicClassInGlobal {
|
||||
}
|
||||
|
||||
@@ -0,0 +1,351 @@
|
||||
//// [tests/cases/compiler/privacyClassExtendsClauseDeclFile.ts] ////
|
||||
|
||||
//// [privacyClassExtendsClauseDeclFile_externalModule.ts]
|
||||
|
||||
export module publicModule {
|
||||
export class publicClassInPublicModule {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
|
||||
}
|
||||
|
||||
class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
export class publicClassInPrivateModule {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClassInModule extends publicClassInPrivateModule {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingPublicClassInModule extends publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingPrivateClassInModule extends privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClass extends publicClass {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClass {
|
||||
}
|
||||
export class publicClassExtendingPublicClass extends publicClass {
|
||||
}
|
||||
export class publicClassExtendingPrivateClass extends privateClass { // Should error
|
||||
}
|
||||
|
||||
class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
//// [privacyClassExtendsClauseDeclFile_GlobalFile.ts]
|
||||
module publicModuleInGlobal {
|
||||
export class publicClassInPublicModule {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
class publicClassInGlobal {
|
||||
}
|
||||
class publicClassExtendingPublicClassInGlobal extends publicClassInGlobal {
|
||||
}
|
||||
|
||||
|
||||
//// [privacyClassExtendsClauseDeclFile_externalModule.js]
|
||||
var __extends = this.__extends || function (d, b) {
|
||||
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
|
||||
function __() { this.constructor = d; }
|
||||
__.prototype = b.prototype;
|
||||
d.prototype = new __();
|
||||
};
|
||||
(function (publicModule) {
|
||||
var publicClassInPublicModule = (function () {
|
||||
function publicClassInPublicModule() {
|
||||
}
|
||||
publicClassInPublicModule.prototype.f1 = function () {
|
||||
};
|
||||
return publicClassInPublicModule;
|
||||
})();
|
||||
publicModule.publicClassInPublicModule = publicClassInPublicModule;
|
||||
var privateClassInPublicModule = (function () {
|
||||
function privateClassInPublicModule() {
|
||||
}
|
||||
return privateClassInPublicModule;
|
||||
})();
|
||||
var privateClassExtendingPublicClassInModule = (function (_super) {
|
||||
__extends(privateClassExtendingPublicClassInModule, _super);
|
||||
function privateClassExtendingPublicClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingPublicClassInModule;
|
||||
})(publicClassInPublicModule);
|
||||
var privateClassExtendingPrivateClassInModule = (function (_super) {
|
||||
__extends(privateClassExtendingPrivateClassInModule, _super);
|
||||
function privateClassExtendingPrivateClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingPrivateClassInModule;
|
||||
})(privateClassInPublicModule);
|
||||
var publicClassExtendingPublicClassInModule = (function (_super) {
|
||||
__extends(publicClassExtendingPublicClassInModule, _super);
|
||||
function publicClassExtendingPublicClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingPublicClassInModule;
|
||||
})(publicClassInPublicModule);
|
||||
publicModule.publicClassExtendingPublicClassInModule = publicClassExtendingPublicClassInModule;
|
||||
var publicClassExtendingPrivateClassInModule = (function (_super) {
|
||||
__extends(publicClassExtendingPrivateClassInModule, _super);
|
||||
function publicClassExtendingPrivateClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingPrivateClassInModule;
|
||||
})(privateClassInPublicModule);
|
||||
publicModule.publicClassExtendingPrivateClassInModule = publicClassExtendingPrivateClassInModule;
|
||||
var privateClassExtendingFromPrivateModuleClass = (function (_super) {
|
||||
__extends(privateClassExtendingFromPrivateModuleClass, _super);
|
||||
function privateClassExtendingFromPrivateModuleClass() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingFromPrivateModuleClass;
|
||||
})(privateModule.publicClassInPrivateModule);
|
||||
var publicClassExtendingFromPrivateModuleClass = (function (_super) {
|
||||
__extends(publicClassExtendingFromPrivateModuleClass, _super);
|
||||
function publicClassExtendingFromPrivateModuleClass() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingFromPrivateModuleClass;
|
||||
})(privateModule.publicClassInPrivateModule);
|
||||
publicModule.publicClassExtendingFromPrivateModuleClass = publicClassExtendingFromPrivateModuleClass;
|
||||
})(exports.publicModule || (exports.publicModule = {}));
|
||||
var publicModule = exports.publicModule;
|
||||
var privateModule;
|
||||
(function (privateModule) {
|
||||
var publicClassInPrivateModule = (function () {
|
||||
function publicClassInPrivateModule() {
|
||||
}
|
||||
publicClassInPrivateModule.prototype.f1 = function () {
|
||||
};
|
||||
return publicClassInPrivateModule;
|
||||
})();
|
||||
privateModule.publicClassInPrivateModule = publicClassInPrivateModule;
|
||||
var privateClassInPrivateModule = (function () {
|
||||
function privateClassInPrivateModule() {
|
||||
}
|
||||
return privateClassInPrivateModule;
|
||||
})();
|
||||
var privateClassExtendingPublicClassInModule = (function (_super) {
|
||||
__extends(privateClassExtendingPublicClassInModule, _super);
|
||||
function privateClassExtendingPublicClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingPublicClassInModule;
|
||||
})(publicClassInPrivateModule);
|
||||
var privateClassExtendingPrivateClassInModule = (function (_super) {
|
||||
__extends(privateClassExtendingPrivateClassInModule, _super);
|
||||
function privateClassExtendingPrivateClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingPrivateClassInModule;
|
||||
})(privateClassInPrivateModule);
|
||||
var publicClassExtendingPublicClassInModule = (function (_super) {
|
||||
__extends(publicClassExtendingPublicClassInModule, _super);
|
||||
function publicClassExtendingPublicClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingPublicClassInModule;
|
||||
})(publicClassInPrivateModule);
|
||||
privateModule.publicClassExtendingPublicClassInModule = publicClassExtendingPublicClassInModule;
|
||||
var publicClassExtendingPrivateClassInModule = (function (_super) {
|
||||
__extends(publicClassExtendingPrivateClassInModule, _super);
|
||||
function publicClassExtendingPrivateClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingPrivateClassInModule;
|
||||
})(privateClassInPrivateModule);
|
||||
privateModule.publicClassExtendingPrivateClassInModule = publicClassExtendingPrivateClassInModule;
|
||||
var privateClassExtendingFromPrivateModuleClass = (function (_super) {
|
||||
__extends(privateClassExtendingFromPrivateModuleClass, _super);
|
||||
function privateClassExtendingFromPrivateModuleClass() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingFromPrivateModuleClass;
|
||||
})(privateModule.publicClassInPrivateModule);
|
||||
var publicClassExtendingFromPrivateModuleClass = (function (_super) {
|
||||
__extends(publicClassExtendingFromPrivateModuleClass, _super);
|
||||
function publicClassExtendingFromPrivateModuleClass() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingFromPrivateModuleClass;
|
||||
})(privateModule.publicClassInPrivateModule);
|
||||
privateModule.publicClassExtendingFromPrivateModuleClass = publicClassExtendingFromPrivateModuleClass;
|
||||
})(privateModule || (privateModule = {}));
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
publicClass.prototype.f1 = function () {
|
||||
};
|
||||
return publicClass;
|
||||
})();
|
||||
exports.publicClass = publicClass;
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var privateClassExtendingPublicClass = (function (_super) {
|
||||
__extends(privateClassExtendingPublicClass, _super);
|
||||
function privateClassExtendingPublicClass() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingPublicClass;
|
||||
})(publicClass);
|
||||
var privateClassExtendingPrivateClassInModule = (function (_super) {
|
||||
__extends(privateClassExtendingPrivateClassInModule, _super);
|
||||
function privateClassExtendingPrivateClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingPrivateClassInModule;
|
||||
})(privateClass);
|
||||
var publicClassExtendingPublicClass = (function (_super) {
|
||||
__extends(publicClassExtendingPublicClass, _super);
|
||||
function publicClassExtendingPublicClass() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingPublicClass;
|
||||
})(publicClass);
|
||||
exports.publicClassExtendingPublicClass = publicClassExtendingPublicClass;
|
||||
var publicClassExtendingPrivateClass = (function (_super) {
|
||||
__extends(publicClassExtendingPrivateClass, _super);
|
||||
function publicClassExtendingPrivateClass() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingPrivateClass;
|
||||
})(privateClass);
|
||||
exports.publicClassExtendingPrivateClass = publicClassExtendingPrivateClass;
|
||||
var privateClassExtendingFromPrivateModuleClass = (function (_super) {
|
||||
__extends(privateClassExtendingFromPrivateModuleClass, _super);
|
||||
function privateClassExtendingFromPrivateModuleClass() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingFromPrivateModuleClass;
|
||||
})(privateModule.publicClassInPrivateModule);
|
||||
var publicClassExtendingFromPrivateModuleClass = (function (_super) {
|
||||
__extends(publicClassExtendingFromPrivateModuleClass, _super);
|
||||
function publicClassExtendingFromPrivateModuleClass() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingFromPrivateModuleClass;
|
||||
})(privateModule.publicClassInPrivateModule);
|
||||
exports.publicClassExtendingFromPrivateModuleClass = publicClassExtendingFromPrivateModuleClass;
|
||||
//// [privacyClassExtendsClauseDeclFile_GlobalFile.js]
|
||||
var __extends = this.__extends || function (d, b) {
|
||||
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
|
||||
function __() { this.constructor = d; }
|
||||
__.prototype = b.prototype;
|
||||
d.prototype = new __();
|
||||
};
|
||||
var publicModuleInGlobal;
|
||||
(function (publicModuleInGlobal) {
|
||||
var publicClassInPublicModule = (function () {
|
||||
function publicClassInPublicModule() {
|
||||
}
|
||||
publicClassInPublicModule.prototype.f1 = function () {
|
||||
};
|
||||
return publicClassInPublicModule;
|
||||
})();
|
||||
publicModuleInGlobal.publicClassInPublicModule = publicClassInPublicModule;
|
||||
var privateClassInPublicModule = (function () {
|
||||
function privateClassInPublicModule() {
|
||||
}
|
||||
return privateClassInPublicModule;
|
||||
})();
|
||||
var privateClassExtendingPublicClassInModule = (function (_super) {
|
||||
__extends(privateClassExtendingPublicClassInModule, _super);
|
||||
function privateClassExtendingPublicClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingPublicClassInModule;
|
||||
})(publicClassInPublicModule);
|
||||
var privateClassExtendingPrivateClassInModule = (function (_super) {
|
||||
__extends(privateClassExtendingPrivateClassInModule, _super);
|
||||
function privateClassExtendingPrivateClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return privateClassExtendingPrivateClassInModule;
|
||||
})(privateClassInPublicModule);
|
||||
var publicClassExtendingPublicClassInModule = (function (_super) {
|
||||
__extends(publicClassExtendingPublicClassInModule, _super);
|
||||
function publicClassExtendingPublicClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingPublicClassInModule;
|
||||
})(publicClassInPublicModule);
|
||||
publicModuleInGlobal.publicClassExtendingPublicClassInModule = publicClassExtendingPublicClassInModule;
|
||||
var publicClassExtendingPrivateClassInModule = (function (_super) {
|
||||
__extends(publicClassExtendingPrivateClassInModule, _super);
|
||||
function publicClassExtendingPrivateClassInModule() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingPrivateClassInModule;
|
||||
})(privateClassInPublicModule);
|
||||
publicModuleInGlobal.publicClassExtendingPrivateClassInModule = publicClassExtendingPrivateClassInModule;
|
||||
})(publicModuleInGlobal || (publicModuleInGlobal = {}));
|
||||
var publicClassInGlobal = (function () {
|
||||
function publicClassInGlobal() {
|
||||
}
|
||||
return publicClassInGlobal;
|
||||
})();
|
||||
var publicClassExtendingPublicClassInGlobal = (function (_super) {
|
||||
__extends(publicClassExtendingPublicClassInGlobal, _super);
|
||||
function publicClassExtendingPublicClassInGlobal() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return publicClassExtendingPublicClassInGlobal;
|
||||
})(publicClassInGlobal);
|
||||
@@ -0,0 +1,105 @@
|
||||
==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_externalModule.ts (5 errors) ====
|
||||
|
||||
export module publicModule {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
|
||||
}
|
||||
|
||||
class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using name 'privateModule.publicInterfaceInPrivateModule' from private module 'privateModule'.
|
||||
}
|
||||
|
||||
export class publicClassImplementingPrivateAndPublicInterface implements privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Implements clause of exported class 'publicClassImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'.
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
export interface publicInterfaceInPrivateModule {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
}
|
||||
|
||||
export interface publicInterface {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterface {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterface implements publicInterface {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterface {
|
||||
}
|
||||
export class publicClassImplementingPublicInterface implements publicInterface {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterface implements privateInterface { // Should error
|
||||
~~~~~~~~~~~~~~~~
|
||||
!!! Implements clause of exported class 'publicClassImplementingPrivateInterface' has or is using private name 'privateInterface'.
|
||||
}
|
||||
|
||||
class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Implements clause of exported class 'publicClassImplementingFromPrivateModuleInterface' has or is using name 'privateModule.publicInterfaceInPrivateModule' from private module 'privateModule'.
|
||||
}
|
||||
|
||||
==== tests/cases/compiler/privacyClassImplementsClauseDeclFile_GlobalFile.ts (1 errors) ====
|
||||
module publicModuleInGlobal {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Implements clause of exported class 'publicClassImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
|
||||
}
|
||||
}
|
||||
interface publicInterfaceInGlobal {
|
||||
}
|
||||
class publicClassImplementingPublicInterfaceInGlobal implements publicInterfaceInGlobal {
|
||||
}
|
||||
|
||||
@@ -0,0 +1,239 @@
|
||||
//// [tests/cases/compiler/privacyClassImplementsClauseDeclFile.ts] ////
|
||||
|
||||
//// [privacyClassImplementsClauseDeclFile_externalModule.ts]
|
||||
|
||||
export module publicModule {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
|
||||
}
|
||||
|
||||
class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
export class publicClassImplementingPrivateAndPublicInterface implements privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
export interface publicInterfaceInPrivateModule {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
}
|
||||
|
||||
export interface publicInterface {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterface {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterface implements publicInterface {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterface {
|
||||
}
|
||||
export class publicClassImplementingPublicInterface implements publicInterface {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterface implements privateInterface { // Should error
|
||||
}
|
||||
|
||||
class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
//// [privacyClassImplementsClauseDeclFile_GlobalFile.ts]
|
||||
module publicModuleInGlobal {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
interface publicInterfaceInGlobal {
|
||||
}
|
||||
class publicClassImplementingPublicInterfaceInGlobal implements publicInterfaceInGlobal {
|
||||
}
|
||||
|
||||
|
||||
//// [privacyClassImplementsClauseDeclFile_externalModule.js]
|
||||
(function (publicModule) {
|
||||
var privateClassImplementingPublicInterfaceInModule = (function () {
|
||||
function privateClassImplementingPublicInterfaceInModule() {
|
||||
}
|
||||
return privateClassImplementingPublicInterfaceInModule;
|
||||
})();
|
||||
var privateClassImplementingPrivateInterfaceInModule = (function () {
|
||||
function privateClassImplementingPrivateInterfaceInModule() {
|
||||
}
|
||||
return privateClassImplementingPrivateInterfaceInModule;
|
||||
})();
|
||||
var publicClassImplementingPublicInterfaceInModule = (function () {
|
||||
function publicClassImplementingPublicInterfaceInModule() {
|
||||
}
|
||||
return publicClassImplementingPublicInterfaceInModule;
|
||||
})();
|
||||
publicModule.publicClassImplementingPublicInterfaceInModule = publicClassImplementingPublicInterfaceInModule;
|
||||
var publicClassImplementingPrivateInterfaceInModule = (function () {
|
||||
function publicClassImplementingPrivateInterfaceInModule() {
|
||||
}
|
||||
return publicClassImplementingPrivateInterfaceInModule;
|
||||
})();
|
||||
publicModule.publicClassImplementingPrivateInterfaceInModule = publicClassImplementingPrivateInterfaceInModule;
|
||||
var privateClassImplementingFromPrivateModuleInterface = (function () {
|
||||
function privateClassImplementingFromPrivateModuleInterface() {
|
||||
}
|
||||
return privateClassImplementingFromPrivateModuleInterface;
|
||||
})();
|
||||
var publicClassImplementingFromPrivateModuleInterface = (function () {
|
||||
function publicClassImplementingFromPrivateModuleInterface() {
|
||||
}
|
||||
return publicClassImplementingFromPrivateModuleInterface;
|
||||
})();
|
||||
publicModule.publicClassImplementingFromPrivateModuleInterface = publicClassImplementingFromPrivateModuleInterface;
|
||||
var publicClassImplementingPrivateAndPublicInterface = (function () {
|
||||
function publicClassImplementingPrivateAndPublicInterface() {
|
||||
}
|
||||
return publicClassImplementingPrivateAndPublicInterface;
|
||||
})();
|
||||
publicModule.publicClassImplementingPrivateAndPublicInterface = publicClassImplementingPrivateAndPublicInterface;
|
||||
})(exports.publicModule || (exports.publicModule = {}));
|
||||
var publicModule = exports.publicModule;
|
||||
var privateModule;
|
||||
(function (privateModule) {
|
||||
var privateClassImplementingPublicInterfaceInModule = (function () {
|
||||
function privateClassImplementingPublicInterfaceInModule() {
|
||||
}
|
||||
return privateClassImplementingPublicInterfaceInModule;
|
||||
})();
|
||||
var privateClassImplementingPrivateInterfaceInModule = (function () {
|
||||
function privateClassImplementingPrivateInterfaceInModule() {
|
||||
}
|
||||
return privateClassImplementingPrivateInterfaceInModule;
|
||||
})();
|
||||
var publicClassImplementingPublicInterfaceInModule = (function () {
|
||||
function publicClassImplementingPublicInterfaceInModule() {
|
||||
}
|
||||
return publicClassImplementingPublicInterfaceInModule;
|
||||
})();
|
||||
privateModule.publicClassImplementingPublicInterfaceInModule = publicClassImplementingPublicInterfaceInModule;
|
||||
var publicClassImplementingPrivateInterfaceInModule = (function () {
|
||||
function publicClassImplementingPrivateInterfaceInModule() {
|
||||
}
|
||||
return publicClassImplementingPrivateInterfaceInModule;
|
||||
})();
|
||||
privateModule.publicClassImplementingPrivateInterfaceInModule = publicClassImplementingPrivateInterfaceInModule;
|
||||
var privateClassImplementingFromPrivateModuleInterface = (function () {
|
||||
function privateClassImplementingFromPrivateModuleInterface() {
|
||||
}
|
||||
return privateClassImplementingFromPrivateModuleInterface;
|
||||
})();
|
||||
var publicClassImplementingFromPrivateModuleInterface = (function () {
|
||||
function publicClassImplementingFromPrivateModuleInterface() {
|
||||
}
|
||||
return publicClassImplementingFromPrivateModuleInterface;
|
||||
})();
|
||||
privateModule.publicClassImplementingFromPrivateModuleInterface = publicClassImplementingFromPrivateModuleInterface;
|
||||
})(privateModule || (privateModule = {}));
|
||||
var privateClassImplementingPublicInterface = (function () {
|
||||
function privateClassImplementingPublicInterface() {
|
||||
}
|
||||
return privateClassImplementingPublicInterface;
|
||||
})();
|
||||
var privateClassImplementingPrivateInterfaceInModule = (function () {
|
||||
function privateClassImplementingPrivateInterfaceInModule() {
|
||||
}
|
||||
return privateClassImplementingPrivateInterfaceInModule;
|
||||
})();
|
||||
var publicClassImplementingPublicInterface = (function () {
|
||||
function publicClassImplementingPublicInterface() {
|
||||
}
|
||||
return publicClassImplementingPublicInterface;
|
||||
})();
|
||||
exports.publicClassImplementingPublicInterface = publicClassImplementingPublicInterface;
|
||||
var publicClassImplementingPrivateInterface = (function () {
|
||||
function publicClassImplementingPrivateInterface() {
|
||||
}
|
||||
return publicClassImplementingPrivateInterface;
|
||||
})();
|
||||
exports.publicClassImplementingPrivateInterface = publicClassImplementingPrivateInterface;
|
||||
var privateClassImplementingFromPrivateModuleInterface = (function () {
|
||||
function privateClassImplementingFromPrivateModuleInterface() {
|
||||
}
|
||||
return privateClassImplementingFromPrivateModuleInterface;
|
||||
})();
|
||||
var publicClassImplementingFromPrivateModuleInterface = (function () {
|
||||
function publicClassImplementingFromPrivateModuleInterface() {
|
||||
}
|
||||
return publicClassImplementingFromPrivateModuleInterface;
|
||||
})();
|
||||
exports.publicClassImplementingFromPrivateModuleInterface = publicClassImplementingFromPrivateModuleInterface;
|
||||
//// [privacyClassImplementsClauseDeclFile_GlobalFile.js]
|
||||
var publicModuleInGlobal;
|
||||
(function (publicModuleInGlobal) {
|
||||
var privateClassImplementingPublicInterfaceInModule = (function () {
|
||||
function privateClassImplementingPublicInterfaceInModule() {
|
||||
}
|
||||
return privateClassImplementingPublicInterfaceInModule;
|
||||
})();
|
||||
var privateClassImplementingPrivateInterfaceInModule = (function () {
|
||||
function privateClassImplementingPrivateInterfaceInModule() {
|
||||
}
|
||||
return privateClassImplementingPrivateInterfaceInModule;
|
||||
})();
|
||||
var publicClassImplementingPublicInterfaceInModule = (function () {
|
||||
function publicClassImplementingPublicInterfaceInModule() {
|
||||
}
|
||||
return publicClassImplementingPublicInterfaceInModule;
|
||||
})();
|
||||
publicModuleInGlobal.publicClassImplementingPublicInterfaceInModule = publicClassImplementingPublicInterfaceInModule;
|
||||
var publicClassImplementingPrivateInterfaceInModule = (function () {
|
||||
function publicClassImplementingPrivateInterfaceInModule() {
|
||||
}
|
||||
return publicClassImplementingPrivateInterfaceInModule;
|
||||
})();
|
||||
publicModuleInGlobal.publicClassImplementingPrivateInterfaceInModule = publicClassImplementingPrivateInterfaceInModule;
|
||||
})(publicModuleInGlobal || (publicModuleInGlobal = {}));
|
||||
var publicClassImplementingPublicInterfaceInGlobal = (function () {
|
||||
function publicClassImplementingPublicInterfaceInGlobal() {
|
||||
}
|
||||
return publicClassImplementingPublicInterfaceInGlobal;
|
||||
})();
|
||||
@@ -0,0 +1,105 @@
|
||||
==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_externalModule.ts (5 errors) ====
|
||||
|
||||
export module publicModule {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using name 'privateModule.publicInterfaceInPrivateModule' from private module 'privateModule'.
|
||||
}
|
||||
|
||||
export interface publicInterfaceImplementingPrivateAndPublicInterface extends privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported interface 'publicInterfaceImplementingPrivateAndPublicInterface' has or is using private name 'privateInterfaceInPublicModule'.
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
export interface publicInterfaceInPrivateModule {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
}
|
||||
|
||||
export interface publicInterface {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterface {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterface extends publicInterface {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterface {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterface extends publicInterface {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterface extends privateInterface { // Should error
|
||||
~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported interface 'publicInterfaceImplementingPrivateInterface' has or is using private name 'privateInterface'.
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported interface 'publicInterfaceImplementingFromPrivateModuleInterface' has or is using name 'privateModule.publicInterfaceInPrivateModule' from private module 'privateModule'.
|
||||
}
|
||||
|
||||
==== tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts (1 errors) ====
|
||||
module publicModuleInGlobal {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Extends clause of exported interface 'publicInterfaceImplementingPrivateInterfaceInModule' has or is using private name 'privateInterfaceInPublicModule'.
|
||||
}
|
||||
}
|
||||
interface publicInterfaceInGlobal {
|
||||
}
|
||||
interface publicInterfaceImplementingPublicInterfaceInGlobal extends publicInterfaceInGlobal {
|
||||
}
|
||||
|
||||
@@ -0,0 +1,98 @@
|
||||
//// [tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile.ts] ////
|
||||
|
||||
//// [privacyInterfaceExtendsClauseDeclFile_externalModule.ts]
|
||||
|
||||
export module publicModule {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
export interface publicInterfaceImplementingPrivateAndPublicInterface extends privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
export interface publicInterfaceInPrivateModule {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
}
|
||||
|
||||
export interface publicInterface {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterface {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterface extends publicInterface {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterface {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterface extends publicInterface {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterface extends privateInterface { // Should error
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
//// [privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts]
|
||||
module publicModuleInGlobal {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
interface publicInterfaceInGlobal {
|
||||
}
|
||||
interface publicInterfaceImplementingPublicInterfaceInGlobal extends publicInterfaceInGlobal {
|
||||
}
|
||||
|
||||
|
||||
//// [privacyInterfaceExtendsClauseDeclFile_externalModule.js]
|
||||
//// [privacyInterfaceExtendsClauseDeclFile_GlobalFile.js]
|
||||
@@ -1,135 +0,0 @@
|
||||
==== tests/cases/compiler/privacyTypeParameterOfFunction.ts (1 errors) ====
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
~~~~~~~~~~~
|
||||
!!! Cannot compile external modules unless the '--module' flag is provided.
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
// TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1
|
||||
new <T extends privateClass>(): privateClass;
|
||||
|
||||
// TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1
|
||||
<T extends privateClass>(): privateClass;
|
||||
|
||||
// TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
// TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() { // No error
|
||||
}
|
||||
// TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() { // No error
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() { // No error
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() { // No error
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
// TypeParameter_0_of_exported_function_has_or_is_using_private_type_1
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
@@ -0,0 +1,242 @@
|
||||
//// [privacyTypeParameterOfFunction.ts]
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
// TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1
|
||||
new <T extends privateClass>(): privateClass;
|
||||
|
||||
// TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1
|
||||
<T extends privateClass>(): privateClass;
|
||||
|
||||
// TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
// TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() { // No error
|
||||
}
|
||||
// TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() { // No error
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() { // No error
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() { // No error
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
// TypeParameter_0_of_exported_function_has_or_is_using_private_type_1
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
//// [privacyTypeParameterOfFunction.js]
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
return publicClass;
|
||||
})();
|
||||
exports.publicClass = publicClass;
|
||||
var publicClassWithWithPrivateTypeParameters = (function () {
|
||||
function publicClassWithWithPrivateTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPrivateTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPrivateTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithWithPrivateTypeParameters = publicClassWithWithPrivateTypeParameters;
|
||||
var publicClassWithWithPublicTypeParameters = (function () {
|
||||
function publicClassWithWithPublicTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPublicTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPublicTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithWithPublicTypeParameters = publicClassWithWithPublicTypeParameters;
|
||||
var privateClassWithWithPrivateTypeParameters = (function () {
|
||||
function privateClassWithWithPrivateTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPrivateTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPrivateTypeParameters;
|
||||
})();
|
||||
var privateClassWithWithPublicTypeParameters = (function () {
|
||||
function privateClassWithWithPublicTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPublicTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPublicTypeParameters;
|
||||
})();
|
||||
function publicFunctionWithPrivateTypeParameters() {
|
||||
}
|
||||
exports.publicFunctionWithPrivateTypeParameters = publicFunctionWithPrivateTypeParameters;
|
||||
function publicFunctionWithPublicTypeParameters() {
|
||||
}
|
||||
exports.publicFunctionWithPublicTypeParameters = publicFunctionWithPublicTypeParameters;
|
||||
function privateFunctionWithPrivateTypeParameters() {
|
||||
}
|
||||
function privateFunctionWithPublicTypeParameters() {
|
||||
}
|
||||
var publicClassWithWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function publicClassWithWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
exports.publicClassWithWithPublicTypeParametersWithoutExtends = publicClassWithWithPublicTypeParametersWithoutExtends;
|
||||
var privateClassWithWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function privateClassWithWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
function publicFunctionWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
exports.publicFunctionWithPublicTypeParametersWithoutExtends = publicFunctionWithPublicTypeParametersWithoutExtends;
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
@@ -0,0 +1,487 @@
|
||||
==== tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts (24 errors) ====
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateClass'.
|
||||
<T extends privateClass>(): privateClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of call signature from exported interface has or is using private name 'privateClass'.
|
||||
myMethod<T extends privateClass>(): privateClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of method from exported interface has or is using private name 'privateClass'.
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of public static method from exported class has or is using private name 'privateClass'.
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of public method from exported class has or is using private name 'privateClass'.
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported function has or is using private name 'privateClass'.
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of constructor signature from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of call signature from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of method from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
}
|
||||
export class publicClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
}
|
||||
}
|
||||
export function publicFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
}
|
||||
|
||||
|
||||
interface privateInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
}
|
||||
class privateClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
}
|
||||
function privateFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() {
|
||||
}
|
||||
|
||||
|
||||
export module publicModule {
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of constructor signature from exported interface has or is using private name 'privateClass'.
|
||||
<T extends privateClass>(): privateClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of call signature from exported interface has or is using private name 'privateClass'.
|
||||
myMethod<T extends privateClass>(): privateClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of method from exported interface has or is using private name 'privateClass'.
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of public static method from exported class has or is using private name 'privateClass'.
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of public method from exported class has or is using private name 'privateClass'.
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported function has or is using private name 'privateClass'.
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of constructor signature from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of call signature from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of method from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
}
|
||||
export class publicClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
}
|
||||
}
|
||||
export function publicFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'.
|
||||
}
|
||||
|
||||
|
||||
interface privateInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
}
|
||||
class privateClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
}
|
||||
function privateFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() {
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,816 @@
|
||||
//// [privacyTypeParameterOfFunctionDeclFile.ts]
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass; // Error
|
||||
<T extends privateClass>(): privateClass; // Error
|
||||
myMethod<T extends privateClass>(): privateClass; // Error
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() { // Error
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() { // Error
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() { // Error
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
}
|
||||
export class publicClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
}
|
||||
export function publicFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
|
||||
|
||||
interface privateInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
}
|
||||
class privateClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
}
|
||||
function privateFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() {
|
||||
}
|
||||
|
||||
|
||||
export module publicModule {
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass; // Error
|
||||
<T extends privateClass>(): privateClass; // Error
|
||||
myMethod<T extends privateClass>(): privateClass; // Error
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() { // Error
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() { // Error
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() { // Error
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
}
|
||||
export class publicClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
}
|
||||
export function publicFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
|
||||
|
||||
interface privateInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
}
|
||||
class privateClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
}
|
||||
function privateFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() {
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
//// [privacyTypeParameterOfFunctionDeclFile.js]
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
return publicClass;
|
||||
})();
|
||||
exports.publicClass = publicClass;
|
||||
var publicClassWithWithPrivateTypeParameters = (function () {
|
||||
function publicClassWithWithPrivateTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPrivateTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPrivateTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithWithPrivateTypeParameters = publicClassWithWithPrivateTypeParameters;
|
||||
var publicClassWithWithPublicTypeParameters = (function () {
|
||||
function publicClassWithWithPublicTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPublicTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPublicTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithWithPublicTypeParameters = publicClassWithWithPublicTypeParameters;
|
||||
var privateClassWithWithPrivateTypeParameters = (function () {
|
||||
function privateClassWithWithPrivateTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPrivateTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPrivateTypeParameters;
|
||||
})();
|
||||
var privateClassWithWithPublicTypeParameters = (function () {
|
||||
function privateClassWithWithPublicTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPublicTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPublicTypeParameters;
|
||||
})();
|
||||
function publicFunctionWithPrivateTypeParameters() {
|
||||
}
|
||||
exports.publicFunctionWithPrivateTypeParameters = publicFunctionWithPrivateTypeParameters;
|
||||
function publicFunctionWithPublicTypeParameters() {
|
||||
}
|
||||
exports.publicFunctionWithPublicTypeParameters = publicFunctionWithPublicTypeParameters;
|
||||
function privateFunctionWithPrivateTypeParameters() {
|
||||
}
|
||||
function privateFunctionWithPublicTypeParameters() {
|
||||
}
|
||||
var publicClassWithWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function publicClassWithWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
exports.publicClassWithWithPublicTypeParametersWithoutExtends = publicClassWithWithPublicTypeParametersWithoutExtends;
|
||||
var privateClassWithWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function privateClassWithWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
function publicFunctionWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
exports.publicFunctionWithPublicTypeParametersWithoutExtends = publicFunctionWithPublicTypeParametersWithoutExtends;
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
var publicClassWithWithPrivateModuleTypeParameters = (function () {
|
||||
function publicClassWithWithPrivateModuleTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPrivateModuleTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateModuleTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPrivateModuleTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithWithPrivateModuleTypeParameters = publicClassWithWithPrivateModuleTypeParameters;
|
||||
function publicFunctionWithPrivateMopduleTypeParameters() {
|
||||
}
|
||||
exports.publicFunctionWithPrivateMopduleTypeParameters = publicFunctionWithPrivateMopduleTypeParameters;
|
||||
var privateClassWithWithPrivateModuleTypeParameters = (function () {
|
||||
function privateClassWithWithPrivateModuleTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPrivateModuleTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateModuleTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPrivateModuleTypeParameters;
|
||||
})();
|
||||
function privateFunctionWithPrivateMopduleTypeParameters() {
|
||||
}
|
||||
(function (publicModule) {
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
return publicClass;
|
||||
})();
|
||||
publicModule.publicClass = publicClass;
|
||||
var publicClassWithWithPrivateTypeParameters = (function () {
|
||||
function publicClassWithWithPrivateTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPrivateTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPrivateTypeParameters;
|
||||
})();
|
||||
publicModule.publicClassWithWithPrivateTypeParameters = publicClassWithWithPrivateTypeParameters;
|
||||
var publicClassWithWithPublicTypeParameters = (function () {
|
||||
function publicClassWithWithPublicTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPublicTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPublicTypeParameters;
|
||||
})();
|
||||
publicModule.publicClassWithWithPublicTypeParameters = publicClassWithWithPublicTypeParameters;
|
||||
var privateClassWithWithPrivateTypeParameters = (function () {
|
||||
function privateClassWithWithPrivateTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPrivateTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPrivateTypeParameters;
|
||||
})();
|
||||
var privateClassWithWithPublicTypeParameters = (function () {
|
||||
function privateClassWithWithPublicTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPublicTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPublicTypeParameters;
|
||||
})();
|
||||
function publicFunctionWithPrivateTypeParameters() {
|
||||
}
|
||||
publicModule.publicFunctionWithPrivateTypeParameters = publicFunctionWithPrivateTypeParameters;
|
||||
function publicFunctionWithPublicTypeParameters() {
|
||||
}
|
||||
publicModule.publicFunctionWithPublicTypeParameters = publicFunctionWithPublicTypeParameters;
|
||||
function privateFunctionWithPrivateTypeParameters() {
|
||||
}
|
||||
function privateFunctionWithPublicTypeParameters() {
|
||||
}
|
||||
var publicClassWithWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function publicClassWithWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
publicModule.publicClassWithWithPublicTypeParametersWithoutExtends = publicClassWithWithPublicTypeParametersWithoutExtends;
|
||||
var privateClassWithWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function privateClassWithWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
function publicFunctionWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
publicModule.publicFunctionWithPublicTypeParametersWithoutExtends = publicFunctionWithPublicTypeParametersWithoutExtends;
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
var publicClassWithWithPrivateModuleTypeParameters = (function () {
|
||||
function publicClassWithWithPrivateModuleTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPrivateModuleTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateModuleTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPrivateModuleTypeParameters;
|
||||
})();
|
||||
publicModule.publicClassWithWithPrivateModuleTypeParameters = publicClassWithWithPrivateModuleTypeParameters;
|
||||
function publicFunctionWithPrivateMopduleTypeParameters() {
|
||||
}
|
||||
publicModule.publicFunctionWithPrivateMopduleTypeParameters = publicFunctionWithPrivateMopduleTypeParameters;
|
||||
var privateClassWithWithPrivateModuleTypeParameters = (function () {
|
||||
function privateClassWithWithPrivateModuleTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPrivateModuleTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateModuleTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPrivateModuleTypeParameters;
|
||||
})();
|
||||
function privateFunctionWithPrivateMopduleTypeParameters() {
|
||||
}
|
||||
})(exports.publicModule || (exports.publicModule = {}));
|
||||
var publicModule = exports.publicModule;
|
||||
var privateModule;
|
||||
(function (privateModule) {
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
return publicClass;
|
||||
})();
|
||||
privateModule.publicClass = publicClass;
|
||||
var publicClassWithWithPrivateTypeParameters = (function () {
|
||||
function publicClassWithWithPrivateTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPrivateTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPrivateTypeParameters;
|
||||
})();
|
||||
privateModule.publicClassWithWithPrivateTypeParameters = publicClassWithWithPrivateTypeParameters;
|
||||
var publicClassWithWithPublicTypeParameters = (function () {
|
||||
function publicClassWithWithPublicTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPublicTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPublicTypeParameters;
|
||||
})();
|
||||
privateModule.publicClassWithWithPublicTypeParameters = publicClassWithWithPublicTypeParameters;
|
||||
var privateClassWithWithPrivateTypeParameters = (function () {
|
||||
function privateClassWithWithPrivateTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPrivateTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPrivateTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPrivateTypeParameters;
|
||||
})();
|
||||
var privateClassWithWithPublicTypeParameters = (function () {
|
||||
function privateClassWithWithPublicTypeParameters() {
|
||||
}
|
||||
privateClassWithWithPublicTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParameters.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPublicTypeParameters;
|
||||
})();
|
||||
function publicFunctionWithPrivateTypeParameters() {
|
||||
}
|
||||
privateModule.publicFunctionWithPrivateTypeParameters = publicFunctionWithPrivateTypeParameters;
|
||||
function publicFunctionWithPublicTypeParameters() {
|
||||
}
|
||||
privateModule.publicFunctionWithPublicTypeParameters = publicFunctionWithPublicTypeParameters;
|
||||
function privateFunctionWithPrivateTypeParameters() {
|
||||
}
|
||||
function privateFunctionWithPublicTypeParameters() {
|
||||
}
|
||||
var publicClassWithWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function publicClassWithWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.myPrivateStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.prototype.myPublicMethod = function () {
|
||||
};
|
||||
publicClassWithWithPublicTypeParametersWithoutExtends.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
privateModule.publicClassWithWithPublicTypeParametersWithoutExtends = publicClassWithWithPublicTypeParametersWithoutExtends;
|
||||
var privateClassWithWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function privateClassWithWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.myPublicStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.myPrivateStaticMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.prototype.myPublicMethod = function () {
|
||||
};
|
||||
privateClassWithWithPublicTypeParametersWithoutExtends.prototype.myPrivateMethod = function () {
|
||||
};
|
||||
return privateClassWithWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
function publicFunctionWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
privateModule.publicFunctionWithPublicTypeParametersWithoutExtends = publicFunctionWithPublicTypeParametersWithoutExtends;
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
})(privateModule || (privateModule = {}));
|
||||
@@ -1,46 +0,0 @@
|
||||
==== tests/cases/compiler/privacyTypeParametersOfClass.ts (1 errors) ====
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
~~~~~~~~~~~
|
||||
!!! Cannot compile external modules unless the '--module' flag is provided.
|
||||
}
|
||||
|
||||
// TypeParameter_0_of_exported_class_1_has_or_is_using_private_type_2
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T { // Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,108 @@
|
||||
//// [privacyTypeParametersOfClass.ts]
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
// TypeParameter_0_of_exported_class_1_has_or_is_using_private_type_2
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T { // Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T { // No Error
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//// [privacyTypeParametersOfClass.js]
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
return publicClass;
|
||||
})();
|
||||
exports.publicClass = publicClass;
|
||||
var publicClassWithPrivateTypeParameters = (function () {
|
||||
function publicClassWithPrivateTypeParameters() {
|
||||
}
|
||||
publicClassWithPrivateTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPrivateTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithPrivateTypeParameters = publicClassWithPrivateTypeParameters;
|
||||
var publicClassWithPublicTypeParameters = (function () {
|
||||
function publicClassWithPublicTypeParameters() {
|
||||
}
|
||||
publicClassWithPublicTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPublicTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithPublicTypeParameters = publicClassWithPublicTypeParameters;
|
||||
var privateClassWithPrivateTypeParameters = (function () {
|
||||
function privateClassWithPrivateTypeParameters() {
|
||||
}
|
||||
privateClassWithPrivateTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPrivateTypeParameters;
|
||||
})();
|
||||
var privateClassWithPublicTypeParameters = (function () {
|
||||
function privateClassWithPublicTypeParameters() {
|
||||
}
|
||||
privateClassWithPublicTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPublicTypeParameters;
|
||||
})();
|
||||
var publicClassWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function publicClassWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
publicClassWithPublicTypeParametersWithoutExtends.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
exports.publicClassWithPublicTypeParametersWithoutExtends = publicClassWithPublicTypeParametersWithoutExtends;
|
||||
var privateClassWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function privateClassWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
privateClassWithPublicTypeParametersWithoutExtends.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
@@ -0,0 +1,163 @@
|
||||
==== tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts (4 errors) ====
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClass> { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported class has or is using private name 'privateClass'.
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported class has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'.
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export module publicModule {
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
export class publicClassInPublicModule {
|
||||
}
|
||||
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClassInPublicModule> { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported class has or is using private name 'privateClassInPublicModule'.
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClassInPublicModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported class has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'.
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
class privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
export class publicClassInPrivateModule {
|
||||
}
|
||||
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,383 @@
|
||||
//// [privacyTypeParametersOfClassDeclFile.ts]
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClass> { // Error
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export module publicModule {
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
export class publicClassInPublicModule {
|
||||
}
|
||||
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClassInPublicModule> { // Error
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClassInPublicModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
class privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
export class publicClassInPrivateModule {
|
||||
}
|
||||
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//// [privacyTypeParametersOfClassDeclFile.js]
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
return publicClass;
|
||||
})();
|
||||
exports.publicClass = publicClass;
|
||||
var publicClassWithPrivateTypeParameters = (function () {
|
||||
function publicClassWithPrivateTypeParameters() {
|
||||
}
|
||||
publicClassWithPrivateTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPrivateTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithPrivateTypeParameters = publicClassWithPrivateTypeParameters;
|
||||
var publicClassWithPublicTypeParameters = (function () {
|
||||
function publicClassWithPublicTypeParameters() {
|
||||
}
|
||||
publicClassWithPublicTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPublicTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithPublicTypeParameters = publicClassWithPublicTypeParameters;
|
||||
var privateClassWithPrivateTypeParameters = (function () {
|
||||
function privateClassWithPrivateTypeParameters() {
|
||||
}
|
||||
privateClassWithPrivateTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPrivateTypeParameters;
|
||||
})();
|
||||
var privateClassWithPublicTypeParameters = (function () {
|
||||
function privateClassWithPublicTypeParameters() {
|
||||
}
|
||||
privateClassWithPublicTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPublicTypeParameters;
|
||||
})();
|
||||
var publicClassWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function publicClassWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
publicClassWithPublicTypeParametersWithoutExtends.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
exports.publicClassWithPublicTypeParametersWithoutExtends = publicClassWithPublicTypeParametersWithoutExtends;
|
||||
var privateClassWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function privateClassWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
privateClassWithPublicTypeParametersWithoutExtends.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
var publicClassWithTypeParametersFromPrivateModule = (function () {
|
||||
function publicClassWithTypeParametersFromPrivateModule() {
|
||||
}
|
||||
publicClassWithTypeParametersFromPrivateModule.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithTypeParametersFromPrivateModule;
|
||||
})();
|
||||
exports.publicClassWithTypeParametersFromPrivateModule = publicClassWithTypeParametersFromPrivateModule;
|
||||
var privateClassWithTypeParametersFromPrivateModule = (function () {
|
||||
function privateClassWithTypeParametersFromPrivateModule() {
|
||||
}
|
||||
privateClassWithTypeParametersFromPrivateModule.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithTypeParametersFromPrivateModule;
|
||||
})();
|
||||
(function (publicModule) {
|
||||
var privateClassInPublicModule = (function () {
|
||||
function privateClassInPublicModule() {
|
||||
}
|
||||
return privateClassInPublicModule;
|
||||
})();
|
||||
var publicClassInPublicModule = (function () {
|
||||
function publicClassInPublicModule() {
|
||||
}
|
||||
return publicClassInPublicModule;
|
||||
})();
|
||||
publicModule.publicClassInPublicModule = publicClassInPublicModule;
|
||||
var publicClassWithPrivateTypeParameters = (function () {
|
||||
function publicClassWithPrivateTypeParameters() {
|
||||
}
|
||||
publicClassWithPrivateTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPrivateTypeParameters;
|
||||
})();
|
||||
publicModule.publicClassWithPrivateTypeParameters = publicClassWithPrivateTypeParameters;
|
||||
var publicClassWithPublicTypeParameters = (function () {
|
||||
function publicClassWithPublicTypeParameters() {
|
||||
}
|
||||
publicClassWithPublicTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPublicTypeParameters;
|
||||
})();
|
||||
publicModule.publicClassWithPublicTypeParameters = publicClassWithPublicTypeParameters;
|
||||
var privateClassWithPrivateTypeParameters = (function () {
|
||||
function privateClassWithPrivateTypeParameters() {
|
||||
}
|
||||
privateClassWithPrivateTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPrivateTypeParameters;
|
||||
})();
|
||||
var privateClassWithPublicTypeParameters = (function () {
|
||||
function privateClassWithPublicTypeParameters() {
|
||||
}
|
||||
privateClassWithPublicTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPublicTypeParameters;
|
||||
})();
|
||||
var publicClassWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function publicClassWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
publicClassWithPublicTypeParametersWithoutExtends.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
publicModule.publicClassWithPublicTypeParametersWithoutExtends = publicClassWithPublicTypeParametersWithoutExtends;
|
||||
var privateClassWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function privateClassWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
privateClassWithPublicTypeParametersWithoutExtends.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
var publicClassWithTypeParametersFromPrivateModule = (function () {
|
||||
function publicClassWithTypeParametersFromPrivateModule() {
|
||||
}
|
||||
publicClassWithTypeParametersFromPrivateModule.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithTypeParametersFromPrivateModule;
|
||||
})();
|
||||
publicModule.publicClassWithTypeParametersFromPrivateModule = publicClassWithTypeParametersFromPrivateModule;
|
||||
var privateClassWithTypeParametersFromPrivateModule = (function () {
|
||||
function privateClassWithTypeParametersFromPrivateModule() {
|
||||
}
|
||||
privateClassWithTypeParametersFromPrivateModule.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithTypeParametersFromPrivateModule;
|
||||
})();
|
||||
})(exports.publicModule || (exports.publicModule = {}));
|
||||
var publicModule = exports.publicModule;
|
||||
var privateModule;
|
||||
(function (privateModule) {
|
||||
var privateClassInPrivateModule = (function () {
|
||||
function privateClassInPrivateModule() {
|
||||
}
|
||||
return privateClassInPrivateModule;
|
||||
})();
|
||||
var publicClassInPrivateModule = (function () {
|
||||
function publicClassInPrivateModule() {
|
||||
}
|
||||
return publicClassInPrivateModule;
|
||||
})();
|
||||
privateModule.publicClassInPrivateModule = publicClassInPrivateModule;
|
||||
var publicClassWithPrivateTypeParameters = (function () {
|
||||
function publicClassWithPrivateTypeParameters() {
|
||||
}
|
||||
publicClassWithPrivateTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPrivateTypeParameters;
|
||||
})();
|
||||
privateModule.publicClassWithPrivateTypeParameters = publicClassWithPrivateTypeParameters;
|
||||
var publicClassWithPublicTypeParameters = (function () {
|
||||
function publicClassWithPublicTypeParameters() {
|
||||
}
|
||||
publicClassWithPublicTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPublicTypeParameters;
|
||||
})();
|
||||
privateModule.publicClassWithPublicTypeParameters = publicClassWithPublicTypeParameters;
|
||||
var privateClassWithPrivateTypeParameters = (function () {
|
||||
function privateClassWithPrivateTypeParameters() {
|
||||
}
|
||||
privateClassWithPrivateTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPrivateTypeParameters;
|
||||
})();
|
||||
var privateClassWithPublicTypeParameters = (function () {
|
||||
function privateClassWithPublicTypeParameters() {
|
||||
}
|
||||
privateClassWithPublicTypeParameters.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPublicTypeParameters;
|
||||
})();
|
||||
var publicClassWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function publicClassWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
publicClassWithPublicTypeParametersWithoutExtends.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return publicClassWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
privateModule.publicClassWithPublicTypeParametersWithoutExtends = publicClassWithPublicTypeParametersWithoutExtends;
|
||||
var privateClassWithPublicTypeParametersWithoutExtends = (function () {
|
||||
function privateClassWithPublicTypeParametersWithoutExtends() {
|
||||
}
|
||||
privateClassWithPublicTypeParametersWithoutExtends.prototype.myMethod = function (val) {
|
||||
return val;
|
||||
};
|
||||
return privateClassWithPublicTypeParametersWithoutExtends;
|
||||
})();
|
||||
})(privateModule || (privateModule = {}));
|
||||
@@ -1,61 +0,0 @@
|
||||
==== tests/cases/compiler/privacyTypeParametersOfInterface.ts (1 errors) ====
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
~~~~~~~~~~~
|
||||
!!! Cannot compile external modules unless the '--module' flag is provided.
|
||||
}
|
||||
|
||||
class privateClassT<T> {
|
||||
}
|
||||
|
||||
export class publicClassT<T> {
|
||||
}
|
||||
|
||||
// TypeParameter_0_of_exported_interface_1_has_or_is_using_private_type_2
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T; // Error
|
||||
myMethod0(): publicClassT<T>; // error
|
||||
myMethod1(): privateClassT<privateClass>; // error
|
||||
myMethod2(): privateClassT<publicClass>; // error
|
||||
myMethod3(): publicClassT<privateClass>; //error
|
||||
myMethod4(): publicClassT<publicClass>; // no error
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
myMethod1(): privateClassT<privateClass>; // error
|
||||
myMethod2(): privateClassT<publicClass>; // error
|
||||
myMethod3(): publicClassT<privateClass>; //error
|
||||
myMethod4(): publicClassT<publicClass>; // no error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
myMethod1(): privateClassT<privateClass>; // No error
|
||||
myMethod2(): privateClassT<publicClass>; // No error
|
||||
myMethod3(): publicClassT<privateClass>; //No error
|
||||
myMethod4(): publicClassT<publicClass>; // no error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
myMethod1(): privateClassT<privateClass>; // No error
|
||||
myMethod2(): privateClassT<publicClass>; // No error
|
||||
myMethod3(): publicClassT<privateClass>; //No error
|
||||
myMethod4(): publicClassT<publicClass>; // no error
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
//// [privacyTypeParametersOfInterface.ts]
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
class privateClassT<T> {
|
||||
}
|
||||
|
||||
export class publicClassT<T> {
|
||||
}
|
||||
|
||||
// TypeParameter_0_of_exported_interface_1_has_or_is_using_private_type_2
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T; // Error
|
||||
myMethod0(): publicClassT<T>; // error
|
||||
myMethod1(): privateClassT<privateClass>; // error
|
||||
myMethod2(): privateClassT<publicClass>; // error
|
||||
myMethod3(): publicClassT<privateClass>; //error
|
||||
myMethod4(): publicClassT<publicClass>; // no error
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
myMethod1(): privateClassT<privateClass>; // error
|
||||
myMethod2(): privateClassT<publicClass>; // error
|
||||
myMethod3(): publicClassT<privateClass>; //error
|
||||
myMethod4(): publicClassT<publicClass>; // no error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
myMethod1(): privateClassT<privateClass>; // No error
|
||||
myMethod2(): privateClassT<publicClass>; // No error
|
||||
myMethod3(): publicClassT<privateClass>; //No error
|
||||
myMethod4(): publicClassT<publicClass>; // no error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
myMethod1(): privateClassT<privateClass>; // No error
|
||||
myMethod2(): privateClassT<publicClass>; // No error
|
||||
myMethod3(): publicClassT<privateClass>; //No error
|
||||
myMethod4(): publicClassT<publicClass>; // no error
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T; // No Error
|
||||
myMethod0(): publicClassT<T>; // No error
|
||||
}
|
||||
|
||||
//// [privacyTypeParametersOfInterface.js]
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
return publicClass;
|
||||
})();
|
||||
exports.publicClass = publicClass;
|
||||
var privateClassT = (function () {
|
||||
function privateClassT() {
|
||||
}
|
||||
return privateClassT;
|
||||
})();
|
||||
var publicClassT = (function () {
|
||||
function publicClassT() {
|
||||
}
|
||||
return publicClassT;
|
||||
})();
|
||||
exports.publicClassT = publicClassT;
|
||||
@@ -0,0 +1,199 @@
|
||||
==== tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts (4 errors) ====
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
class privateClassT<T> {
|
||||
}
|
||||
|
||||
export class publicClassT<T> {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClass> { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported interface has or is using private name 'privateClass'.
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
}
|
||||
|
||||
|
||||
export interface publicInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported interface has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'.
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
|
||||
export module publicModule {
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
export class publicClassInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassInPublicModuleT<T> {
|
||||
}
|
||||
|
||||
export class publicClassInPublicModuleT<T> {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClassInPublicModule> { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported interface has or is using private name 'privateClassInPublicModule'.
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClassInPublicModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! Type parameter 'T' of exported interface has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'.
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
class privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
export class publicClassInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassInPrivateModuleT<T> {
|
||||
}
|
||||
|
||||
export class publicClassInPrivateModuleT<T> {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,265 @@
|
||||
//// [privacyTypeParametersOfInterfaceDeclFile.ts]
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
class privateClassT<T> {
|
||||
}
|
||||
|
||||
export class publicClassT<T> {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClass> { // Error
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
}
|
||||
|
||||
|
||||
export interface publicInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
|
||||
export module publicModule {
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
export class publicClassInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassInPublicModuleT<T> {
|
||||
}
|
||||
|
||||
export class publicClassInPublicModuleT<T> {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClassInPublicModule> { // Error
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClassInPublicModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
class privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
export class publicClassInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassInPrivateModuleT<T> {
|
||||
}
|
||||
|
||||
export class publicClassInPrivateModuleT<T> {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
}
|
||||
}
|
||||
|
||||
//// [privacyTypeParametersOfInterfaceDeclFile.js]
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
return publicClass;
|
||||
})();
|
||||
exports.publicClass = publicClass;
|
||||
var privateClassT = (function () {
|
||||
function privateClassT() {
|
||||
}
|
||||
return privateClassT;
|
||||
})();
|
||||
var publicClassT = (function () {
|
||||
function publicClassT() {
|
||||
}
|
||||
return publicClassT;
|
||||
})();
|
||||
exports.publicClassT = publicClassT;
|
||||
(function (publicModule) {
|
||||
var privateClassInPublicModule = (function () {
|
||||
function privateClassInPublicModule() {
|
||||
}
|
||||
return privateClassInPublicModule;
|
||||
})();
|
||||
var publicClassInPublicModule = (function () {
|
||||
function publicClassInPublicModule() {
|
||||
}
|
||||
return publicClassInPublicModule;
|
||||
})();
|
||||
publicModule.publicClassInPublicModule = publicClassInPublicModule;
|
||||
var privateClassInPublicModuleT = (function () {
|
||||
function privateClassInPublicModuleT() {
|
||||
}
|
||||
return privateClassInPublicModuleT;
|
||||
})();
|
||||
var publicClassInPublicModuleT = (function () {
|
||||
function publicClassInPublicModuleT() {
|
||||
}
|
||||
return publicClassInPublicModuleT;
|
||||
})();
|
||||
publicModule.publicClassInPublicModuleT = publicClassInPublicModuleT;
|
||||
})(exports.publicModule || (exports.publicModule = {}));
|
||||
var publicModule = exports.publicModule;
|
||||
var privateModule;
|
||||
(function (privateModule) {
|
||||
var privateClassInPrivateModule = (function () {
|
||||
function privateClassInPrivateModule() {
|
||||
}
|
||||
return privateClassInPrivateModule;
|
||||
})();
|
||||
var publicClassInPrivateModule = (function () {
|
||||
function publicClassInPrivateModule() {
|
||||
}
|
||||
return publicClassInPrivateModule;
|
||||
})();
|
||||
privateModule.publicClassInPrivateModule = publicClassInPrivateModule;
|
||||
var privateClassInPrivateModuleT = (function () {
|
||||
function privateClassInPrivateModuleT() {
|
||||
}
|
||||
return privateClassInPrivateModuleT;
|
||||
})();
|
||||
var publicClassInPrivateModuleT = (function () {
|
||||
function publicClassInPrivateModuleT() {
|
||||
}
|
||||
return publicClassInPrivateModuleT;
|
||||
})();
|
||||
privateModule.publicClassInPrivateModuleT = publicClassInPrivateModuleT;
|
||||
})(privateModule || (privateModule = {}));
|
||||
@@ -0,0 +1,66 @@
|
||||
//// [staticMethodWithTypeParameterExtendsClauseDeclFile.ts]
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
private static myPrivateStaticMethod1<T extends privateClass>() { // do not emit extends clause
|
||||
}
|
||||
private myPrivateMethod1<T extends privateClass>() { // do not emit extends clause
|
||||
}
|
||||
private static myPrivateStaticMethod2<T extends publicClass>() { // do not emit extends clause
|
||||
}
|
||||
private myPrivateMethod2<T extends publicClass>() { // do not emit extends clause
|
||||
}
|
||||
public static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
public myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//// [staticMethodWithTypeParameterExtendsClauseDeclFile.js]
|
||||
var privateClass = (function () {
|
||||
function privateClass() {
|
||||
}
|
||||
return privateClass;
|
||||
})();
|
||||
var publicClass = (function () {
|
||||
function publicClass() {
|
||||
}
|
||||
return publicClass;
|
||||
})();
|
||||
exports.publicClass = publicClass;
|
||||
var publicClassWithWithPrivateTypeParameters = (function () {
|
||||
function publicClassWithWithPrivateTypeParameters() {
|
||||
}
|
||||
publicClassWithWithPrivateTypeParameters.myPrivateStaticMethod1 = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPrivateMethod1 = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.myPrivateStaticMethod2 = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPrivateMethod2 = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.myPublicStaticMethod = function () {
|
||||
};
|
||||
publicClassWithWithPrivateTypeParameters.prototype.myPublicMethod = function () {
|
||||
};
|
||||
return publicClassWithWithPrivateTypeParameters;
|
||||
})();
|
||||
exports.publicClassWithWithPrivateTypeParameters = publicClassWithWithPrivateTypeParameters;
|
||||
|
||||
|
||||
//// [staticMethodWithTypeParameterExtendsClauseDeclFile.d.ts]
|
||||
export declare class publicClass {
|
||||
}
|
||||
export declare class publicClassWithWithPrivateTypeParameters {
|
||||
private static myPrivateStaticMethod1<T>();
|
||||
private myPrivateMethod1<T>();
|
||||
private static myPrivateStaticMethod2<T>();
|
||||
private myPrivateMethod2<T>();
|
||||
static myPublicStaticMethod<T extends publicClass>(): void;
|
||||
myPublicMethod<T extends publicClass>(): void;
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
// @module: commonjs
|
||||
// @declaration: true
|
||||
|
||||
// @Filename: privacyClassExtendsClauseDeclFile_externalModule.ts
|
||||
export module publicModule {
|
||||
export class publicClassInPublicModule {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
|
||||
}
|
||||
|
||||
class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
export class publicClassInPrivateModule {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClassInModule extends publicClassInPrivateModule {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingPublicClassInModule extends publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingPrivateClassInModule extends privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClass extends publicClass {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClass {
|
||||
}
|
||||
export class publicClassExtendingPublicClass extends publicClass {
|
||||
}
|
||||
export class publicClassExtendingPrivateClass extends privateClass { // Should error
|
||||
}
|
||||
|
||||
class privateClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule {
|
||||
}
|
||||
export class publicClassExtendingFromPrivateModuleClass extends privateModule.publicClassInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
// @Filename: privacyClassExtendsClauseDeclFile_GlobalFile.ts
|
||||
module publicModuleInGlobal {
|
||||
export class publicClassInPublicModule {
|
||||
private f1() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
class privateClassExtendingPrivateClassInModule extends privateClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPublicClassInModule extends publicClassInPublicModule {
|
||||
}
|
||||
export class publicClassExtendingPrivateClassInModule extends privateClassInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
class publicClassInGlobal {
|
||||
}
|
||||
class publicClassExtendingPublicClassInGlobal extends publicClassInGlobal {
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
// @module: commonjs
|
||||
// @declaration: true
|
||||
|
||||
// @Filename: privacyClassImplementsClauseDeclFile_externalModule.ts
|
||||
export module publicModule {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
|
||||
}
|
||||
|
||||
class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
export class publicClassImplementingPrivateAndPublicInterface implements privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
export interface publicInterfaceInPrivateModule {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
}
|
||||
|
||||
export interface publicInterface {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterface {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterface implements publicInterface {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterface {
|
||||
}
|
||||
export class publicClassImplementingPublicInterface implements publicInterface {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterface implements privateInterface { // Should error
|
||||
}
|
||||
|
||||
class privateClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export class publicClassImplementingFromPrivateModuleInterface implements privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
// @Filename: privacyClassImplementsClauseDeclFile_GlobalFile.ts
|
||||
module publicModuleInGlobal {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
class privateClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPublicInterfaceInModule implements publicInterfaceInPublicModule {
|
||||
}
|
||||
export class publicClassImplementingPrivateInterfaceInModule implements privateInterfaceInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
interface publicInterfaceInGlobal {
|
||||
}
|
||||
class publicClassImplementingPublicInterfaceInGlobal implements publicInterfaceInGlobal {
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
// @module: commonjs
|
||||
// @declaration: true
|
||||
|
||||
// @Filename: privacyInterfaceExtendsClauseDeclFile_externalModule.ts
|
||||
export module publicModule {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
export interface publicInterfaceImplementingPrivateAndPublicInterface extends privateInterfaceInPublicModule, publicInterfaceInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
export interface publicInterfaceInPrivateModule {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPrivateModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
}
|
||||
|
||||
export interface publicInterface {
|
||||
|
||||
}
|
||||
|
||||
interface privateInterface {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterface extends publicInterface {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterface {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterface extends publicInterface {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterface extends privateInterface { // Should error
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingFromPrivateModuleInterface extends privateModule.publicInterfaceInPrivateModule { // Should error
|
||||
}
|
||||
|
||||
// @Filename: privacyInterfaceExtendsClauseDeclFile_GlobalFile.ts
|
||||
module publicModuleInGlobal {
|
||||
export interface publicInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceInPublicModule {
|
||||
}
|
||||
|
||||
interface privateInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
interface privateInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPublicInterfaceInModule extends publicInterfaceInPublicModule {
|
||||
}
|
||||
export interface publicInterfaceImplementingPrivateInterfaceInModule extends privateInterfaceInPublicModule { // Should error
|
||||
}
|
||||
}
|
||||
interface publicInterfaceInGlobal {
|
||||
}
|
||||
interface publicInterfaceImplementingPublicInterfaceInGlobal extends publicInterfaceInGlobal {
|
||||
}
|
||||
@@ -1,3 +1,4 @@
|
||||
// @module: commonjs
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,440 @@
|
||||
// @module: commonjs
|
||||
// @declaration: true
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass; // Error
|
||||
<T extends privateClass>(): privateClass; // Error
|
||||
myMethod<T extends privateClass>(): privateClass; // Error
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() { // Error
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() { // Error
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() { // Error
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
}
|
||||
export class publicClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
}
|
||||
export function publicFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
|
||||
|
||||
interface privateInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
}
|
||||
class privateClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
}
|
||||
function privateFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() {
|
||||
}
|
||||
|
||||
|
||||
export module publicModule {
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass; // Error
|
||||
<T extends privateClass>(): privateClass; // Error
|
||||
myMethod<T extends privateClass>(): privateClass; // Error
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() { // Error
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() { // Error
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() { // Error
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass; // Error
|
||||
}
|
||||
export class publicClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
}
|
||||
export function publicFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() { // Error
|
||||
}
|
||||
|
||||
|
||||
interface privateInterfaceWithPrivatModuleTypeParameters {
|
||||
new <T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
myMethod<T extends privateModule.publicClass>(): privateModule.publicClass;
|
||||
}
|
||||
class privateClassWithWithPrivateModuleTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateModule.publicClass>() {
|
||||
}
|
||||
}
|
||||
function privateFunctionWithPrivateMopduleTypeParameters<T extends privateModule.publicClass>() {
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters {
|
||||
new <T extends privateClass>(): privateClass;
|
||||
<T extends privateClass>(): privateClass;
|
||||
myMethod<T extends privateClass>(): privateClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters {
|
||||
new <T extends publicClass>(): publicClass;
|
||||
<T extends publicClass>(): publicClass;
|
||||
myMethod<T extends publicClass>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPrivateTypeParameters {
|
||||
static myPublicStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends privateClass>() {
|
||||
}
|
||||
myPublicMethod<T extends privateClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends privateClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithWithPublicTypeParameters {
|
||||
static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
private myPrivateMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPrivateTypeParameters<T extends privateClass>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParameters<T extends publicClass>() {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends {
|
||||
new <T>(): publicClass;
|
||||
<T>(): publicClass;
|
||||
myMethod<T>(): publicClass;
|
||||
}
|
||||
|
||||
export class publicClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
class privateClassWithWithPublicTypeParametersWithoutExtends {
|
||||
static myPublicStaticMethod<T>() {
|
||||
}
|
||||
private static myPrivateStaticMethod<T>() {
|
||||
}
|
||||
myPublicMethod<T>() {
|
||||
}
|
||||
private myPrivateMethod<T>() {
|
||||
}
|
||||
}
|
||||
|
||||
export function publicFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
|
||||
function privateFunctionWithPublicTypeParametersWithoutExtends<T>() {
|
||||
}
|
||||
}
|
||||
@@ -1,3 +1,4 @@
|
||||
// @module: commonjs
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
// @module: commonjs
|
||||
// @declaration: true
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClass> { // Error
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export module publicModule {
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
export class publicClassInPublicModule {
|
||||
}
|
||||
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClassInPublicModule> { // Error
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClassInPublicModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithTypeParametersFromPrivateModule<T extends privateModule.publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
class privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
export class publicClassInPrivateModule {
|
||||
}
|
||||
|
||||
export class publicClassWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
export class publicClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
class privateClassWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,3 +1,4 @@
|
||||
// @module: commonjs
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
// @module: commonjs
|
||||
// @declaration: true
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
class privateClassT<T> {
|
||||
}
|
||||
|
||||
export class publicClassT<T> {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClass> { // Error
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClass> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClass> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
myMethod1(): privateClassT<privateClass>;
|
||||
myMethod2(): privateClassT<publicClass>;
|
||||
myMethod3(): publicClassT<privateClass>;
|
||||
myMethod4(): publicClassT<publicClass>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassT<T>;
|
||||
}
|
||||
|
||||
|
||||
export interface publicInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
|
||||
export module publicModule {
|
||||
class privateClassInPublicModule {
|
||||
}
|
||||
|
||||
export class publicClassInPublicModule {
|
||||
}
|
||||
|
||||
class privateClassInPublicModuleT<T> {
|
||||
}
|
||||
|
||||
export class publicClassInPublicModuleT<T> {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClassInPublicModule> { // Error
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClassInPublicModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClassInPublicModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
myMethod1(): privateClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod2(): privateClassInPublicModuleT<publicClassInPublicModule>;
|
||||
myMethod3(): publicClassInPublicModuleT<privateClassInPublicModule>;
|
||||
myMethod4(): publicClassInPublicModuleT<publicClassInPublicModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPublicModuleT<T>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateModuleTypeParameterConstraints<T extends privateModule.publicClassInPrivateModule> { // Error
|
||||
}
|
||||
}
|
||||
|
||||
module privateModule {
|
||||
class privateClassInPrivateModule {
|
||||
}
|
||||
|
||||
export class publicClassInPrivateModule {
|
||||
}
|
||||
|
||||
class privateClassInPrivateModuleT<T> {
|
||||
}
|
||||
|
||||
export class publicClassInPrivateModuleT<T> {
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPrivateTypeParameters<T extends privateClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParameters<T extends publicClassInPrivateModule> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
myMethod1(): privateClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod2(): privateClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
myMethod3(): publicClassInPrivateModuleT<privateClassInPrivateModule>;
|
||||
myMethod4(): publicClassInPrivateModuleT<publicClassInPrivateModule>;
|
||||
}
|
||||
|
||||
export interface publicInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
}
|
||||
|
||||
interface privateInterfaceWithPublicTypeParametersWithoutExtends<T> {
|
||||
myMethod(val: T): T;
|
||||
myMethod0(): publicClassInPrivateModuleT<T>;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
// @module: commonjs
|
||||
// @declaration: true
|
||||
class privateClass {
|
||||
}
|
||||
|
||||
export class publicClass {
|
||||
}
|
||||
|
||||
export class publicClassWithWithPrivateTypeParameters {
|
||||
private static myPrivateStaticMethod1<T extends privateClass>() { // do not emit extends clause
|
||||
}
|
||||
private myPrivateMethod1<T extends privateClass>() { // do not emit extends clause
|
||||
}
|
||||
private static myPrivateStaticMethod2<T extends publicClass>() { // do not emit extends clause
|
||||
}
|
||||
private myPrivateMethod2<T extends publicClass>() { // do not emit extends clause
|
||||
}
|
||||
public static myPublicStaticMethod<T extends publicClass>() {
|
||||
}
|
||||
public myPublicMethod<T extends publicClass>() {
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user