From 09ec1bb9ae92557f50becbb31c003643a1bb8862 Mon Sep 17 00:00:00 2001 From: Sheetal Nandi Date: Fri, 18 Jul 2014 18:07:38 -0700 Subject: [PATCH] Report error on Class/Interface heritage clause if it cant be accessed Fixes #78 and #83 --- .../diagnosticInformationMap.generated.ts | 6 + src/compiler/diagnosticMessages.json | 24 ++ src/compiler/emitter.ts | 48 +++ src/harness/harness.ts | 8 +- ...ivacyClassExtendsClauseDeclFile.errors.txt | 106 ++++++ .../privacyClassExtendsClauseDeclFile.js | 351 ++++++++++++++++++ ...cyClassImplementsClauseDeclFile.errors.txt | 105 ++++++ .../privacyClassImplementsClauseDeclFile.js | 239 ++++++++++++ ...yInterfaceExtendsClauseDeclFile.errors.txt | 105 ++++++ .../privacyInterfaceExtendsClauseDeclFile.js | 98 +++++ .../privacyClassExtendsClauseDeclFile.ts | 97 +++++ .../privacyClassImplementsClauseDeclFile.ts | 94 +++++ .../privacyInterfaceExtendsClauseDeclFile.ts | 94 +++++ 13 files changed, 1371 insertions(+), 4 deletions(-) create mode 100644 tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt create mode 100644 tests/baselines/reference/privacyClassExtendsClauseDeclFile.js create mode 100644 tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt create mode 100644 tests/baselines/reference/privacyClassImplementsClauseDeclFile.js create mode 100644 tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt create mode 100644 tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js create mode 100644 tests/cases/compiler/privacyClassExtendsClauseDeclFile.ts create mode 100644 tests/cases/compiler/privacyClassImplementsClauseDeclFile.ts create mode 100644 tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile.ts diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index d9e35f29086..80bf686c8ae 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -99,6 +99,12 @@ module ts { A_constructor_implementation_cannot_be_declared_in_an_ambient_context: { code: 1111, category: DiagnosticCategory.Error, key: "A constructor implementation cannot be declared in an ambient context." }, A_class_member_cannot_be_declared_optional: { code: 1112, category: DiagnosticCategory.Error, key: "A class member cannot be declared optional." }, Duplicate_identifier_0: { code: 2000, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, + Extends_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 2018, category: DiagnosticCategory.Error, key: "Extends clause of exported class '{0}' has or is using private name '{1}'." }, + Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 2019, category: DiagnosticCategory.Error, key: "Implements clause of exported class '{0}' has or is using private name '{1}'." }, + Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: { code: 2020, category: DiagnosticCategory.Error, key: "Extends clause of exported interface '{0}' has or is using private name '{1}'." }, + Extends_clause_of_exported_class_0_has_or_is_using_name_1_from_private_module_2: { code: 2021, category: DiagnosticCategory.Error, key: "Extends clause of exported class '{0}' has or is using name '{1}' from private module '{2}'." }, + Implements_clause_of_exported_class_0_has_or_is_using_name_1_from_private_module_2: { code: 2022, category: DiagnosticCategory.Error, key: "Implements clause of exported class '{0}' has or is using name '{1}' from private module '{2}'." }, + Extends_clause_of_exported_interface_0_has_or_is_using_name_1_from_private_module_2: { code: 2023, category: DiagnosticCategory.Error, key: "Extends clause of exported interface '{0}' has or is using name '{1}' from private module '{2}'." }, new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: { code: 2068, category: DiagnosticCategory.Error, key: "'new T[]' cannot be used to create an array. Use 'new Array()' instead." }, Multiple_constructor_implementations_are_not_allowed: { code: 2070, category: DiagnosticCategory.Error, key: "Multiple constructor implementations are not allowed." }, A_class_may_only_implement_another_class_or_interface: { code: 2074, category: DiagnosticCategory.Error, key: "A class may only implement another class or interface." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 92b8d1a3e0e..362f4cd6129 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -390,6 +390,30 @@ "category": "Error", "code": 2000 }, + "Extends clause of exported class '{0}' has or is using private name '{1}'.": { + "category": "Error", + "code": 2018 + }, + "Implements clause of exported class '{0}' has or is using private name '{1}'.": { + "category": "Error", + "code": 2019 + }, + "Extends clause of exported interface '{0}' has or is using private name '{1}'.": { + "category": "Error", + "code": 2020 + }, + "Extends clause of exported class '{0}' has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2021 + }, + "Implements clause of exported class '{0}' has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2022 + }, + "Extends clause of exported interface '{0}' has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2023 + }, "'new T[]' cannot be used to create an array. Use 'new Array()' instead.": { "category": "Error", "code": 2068 diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index bf6f8c7fff9..5de70cbc318 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2027,6 +2027,54 @@ module ts { function emitHeritageClause(typeReferences: TypeReferenceNode[], isImplementsList: boolean) { function emitTypeOfTypeReference(node: Node) { + function getHeritageClauseVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult) { + var diagnosticMessage: DiagnosticMessage; + if (node.parent.kind === SyntaxKind.ClassDeclaration) { + // Class + if (symbolAccesibilityResult.accessibility == SymbolAccessibility.NotAccessible) { + if (symbolAccesibilityResult.errorModuleName) { + // Module is inaccessible + diagnosticMessage = isImplementsList ? + Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_name_1_from_private_module_2 : + Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_name_1_from_private_module_2; + } + else { + // Class or Interface implemented/extended is inaccessible + diagnosticMessage = isImplementsList ? + Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : + Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1; + } + } + else { + // CannotBeNamed + // TODO(shkamat): CannotBeNamed error needs to be handled + } + } + else { + // Interface + if (symbolAccesibilityResult.accessibility == SymbolAccessibility.NotAccessible) { + if (symbolAccesibilityResult.errorModuleName) { + // Module is inaccessible + diagnosticMessage = Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_name_1_from_private_module_2; + } + else { + // interface is inaccessible + diagnosticMessage = Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1; + } + } + else { + // CannotBeNamed + // TODO(shkamat): CannotBeNamed error needs to be handled + } + } + + return { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: (node.parent).name + } + } + getSymbolVisibilityDiagnosticMessage = getHeritageClauseVisibilityError; resolver.writeTypeAtLocation(node, enclosingDeclaration, TypeFormatFlags.WriteArrayAsGenericType, writer); } diff --git a/src/harness/harness.ts b/src/harness/harness.ts index c35ba97df3a..b68c27712fc 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -736,13 +736,13 @@ module Harness { checker.checkProgram(); // only emit if there weren't parse errors - var sourceMapData: ts.SourceMapData[]; + var emitResult: ts.EmitResult; if (!hadParseErrors) { - sourceMapData = checker.emitFiles().sourceMaps; + emitResult = checker.emitFiles(); } var errors: MinimalDiagnostic[] = []; - program.getDiagnostics().concat(checker.getDiagnostics()).forEach(err => { + program.getDiagnostics().concat(checker.getDiagnostics()).concat(emitResult ? emitResult.errors : []).forEach(err => { // TODO: new compiler formats errors after this point to add . and newlines so we'll just do it manually for now errors.push({ filename: err.file && err.file.filename, start: err.start, end: err.start + err.length, line: 0, character: 0, message: err.messageText }); }); @@ -750,7 +750,7 @@ module Harness { var result = new CompilerResult(fileOutputs, errors, []); // Covert the source Map data into the baseline - result.updateSourceMapRecord(program, sourceMapData); + result.updateSourceMapRecord(program, emitResult ? emitResult.sourceMaps : undefined); onComplete(result); return options; } diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt new file mode 100644 index 00000000000..598dead5154 --- /dev/null +++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.errors.txt @@ -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 { + } + \ No newline at end of file diff --git a/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js new file mode 100644 index 00000000000..77adca24aa6 --- /dev/null +++ b/tests/baselines/reference/privacyClassExtendsClauseDeclFile.js @@ -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); diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt new file mode 100644 index 00000000000..61b5e199b07 --- /dev/null +++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.errors.txt @@ -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 { + } + \ No newline at end of file diff --git a/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js new file mode 100644 index 00000000000..d4a1ffafd53 --- /dev/null +++ b/tests/baselines/reference/privacyClassImplementsClauseDeclFile.js @@ -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; +})(); diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt new file mode 100644 index 00000000000..24fccd203bc --- /dev/null +++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.errors.txt @@ -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 { + } + \ No newline at end of file diff --git a/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js new file mode 100644 index 00000000000..65f0a2af420 --- /dev/null +++ b/tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.js @@ -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] diff --git a/tests/cases/compiler/privacyClassExtendsClauseDeclFile.ts b/tests/cases/compiler/privacyClassExtendsClauseDeclFile.ts new file mode 100644 index 00000000000..4feb4a691b7 --- /dev/null +++ b/tests/cases/compiler/privacyClassExtendsClauseDeclFile.ts @@ -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 { +} diff --git a/tests/cases/compiler/privacyClassImplementsClauseDeclFile.ts b/tests/cases/compiler/privacyClassImplementsClauseDeclFile.ts new file mode 100644 index 00000000000..17791e49f86 --- /dev/null +++ b/tests/cases/compiler/privacyClassImplementsClauseDeclFile.ts @@ -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 { +} diff --git a/tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile.ts b/tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile.ts new file mode 100644 index 00000000000..d1c73724bb9 --- /dev/null +++ b/tests/cases/compiler/privacyInterfaceExtendsClauseDeclFile.ts @@ -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 { +}