diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 80bf686c8ae..2f5daae7ed4 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -105,6 +105,22 @@ module ts { 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}'." }, + TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 2208, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." }, + TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 2209, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of call signature from exported interface has or is using private name '{1}'." }, + TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 2210, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of public static method from exported class has or is using private name '{1}'." }, + TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 2211, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of public method from exported class has or is using private name '{1}'." }, + TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 2212, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of method from exported interface has or is using private name '{1}'." }, + TypeParameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 2213, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of exported function has or is using private name '{1}'." }, + TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 2214, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'." }, + TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 2215, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'." }, + TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 2216, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'." }, + TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 2217, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'." }, + TypeParameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 2218, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'." }, + TypeParameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: { code: 2219, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of exported function has or is using name '{1}' from private module '{2}'." }, + TypeParameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 2220, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of exported class has or is using private name '{1}'." }, + TypeParameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 2221, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of exported interface has or is using private name '{1}'." }, + TypeParameter_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 2222, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of exported class has or is using name '{1}' from private module '{2}'." }, + TypeParameter_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 2223, category: DiagnosticCategory.Error, key: "TypeParameter '{0}' of exported interface 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 362f4cd6129..1b1ccff36fd 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -414,6 +414,70 @@ "category": "Error", "code": 2023 }, + "TypeParameter '{0}' of constructor signature from exported interface has or is using private name '{1}'.": { + "category": "Error", + "code": 2208 + }, + "TypeParameter '{0}' of call signature from exported interface has or is using private name '{1}'.": { + "category": "Error", + "code": 2209 + }, + "TypeParameter '{0}' of public static method from exported class has or is using private name '{1}'.": { + "category": "Error", + "code": 2210 + }, + "TypeParameter '{0}' of public method from exported class has or is using private name '{1}'.": { + "category": "Error", + "code": 2211 + }, + "TypeParameter '{0}' of method from exported interface has or is using private name '{1}'.": { + "category": "Error", + "code": 2212 + }, + "TypeParameter '{0}' of exported function has or is using private name '{1}'.": { + "category": "Error", + "code": 2213 + }, + "TypeParameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2214 + }, + "TypeParameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2215 + }, + "TypeParameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2216 + }, + "TypeParameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2217 + }, + "TypeParameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2218 + }, + "TypeParameter '{0}' of exported function has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2219 + }, + "TypeParameter '{0}' of exported class has or is using private name '{1}'.": { + "category": "Error", + "code": 2220 + }, + "TypeParameter '{0}' of exported interface has or is using private name '{1}'.": { + "category": "Error", + "code": 2221 + }, + "TypeParameter '{0}' of exported class has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2222 + }, + "TypeParameter '{0}' of exported interface has or is using name '{1}' from private module '{2}'.": { + "category": "Error", + "code": 2223 + }, "'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 5de70cbc318..4169d48e0b1 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2011,10 +2011,76 @@ module ts { function emitTypeParameters(typeParameters: TypeParameterDeclaration[]) { function emitTypeParameter(node: TypeParameterDeclaration) { + function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult) { + // TODO(shkamat) Cannot access name errors + var diagnosticMessage: DiagnosticMessage; + switch (node.parent.kind) { + case SyntaxKind.ClassDeclaration: + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? + Diagnostics.TypeParameter_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + Diagnostics.TypeParameter_0_of_exported_class_has_or_is_using_private_name_1; + break; + + case SyntaxKind.InterfaceDeclaration: + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? + Diagnostics.TypeParameter_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : + Diagnostics.TypeParameter_0_of_exported_interface_has_or_is_using_private_name_1; + break; + + case SyntaxKind.ConstructSignature: + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? + Diagnostics.TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + Diagnostics.TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + + case SyntaxKind.CallSignature: + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? + Diagnostics.TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + Diagnostics.TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + + case SyntaxKind.Method: + if (node.parent.flags & NodeFlags.Static) { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? + Diagnostics.TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + Diagnostics.TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? + Diagnostics.TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + Diagnostics.TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? + Diagnostics.TypeParameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + Diagnostics.TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; + } + break; + + case SyntaxKind.FunctionDeclaration: + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? + Diagnostics.TypeParameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : + Diagnostics.TypeParameter_0_of_exported_function_has_or_is_using_private_name_1; + break; + + default: + Debug.fail("This is unknown parent for type parameter: " + SyntaxKind[node.parent.kind]); + } + + return { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } + } + emitSourceTextOfNode(node.name); if (node.constraint) { write(" extends "); + getSymbolVisibilityDiagnosticMessage = getTypeParameterConstraintVisibilityError; resolver.writeTypeAtLocation(node.constraint, enclosingDeclaration, TypeFormatFlags.None, writer); + // TODO(shkamat) This is just till we get rest of the error reporting up + getSymbolVisibilityDiagnosticMessage = undefined; } } @@ -2076,6 +2142,8 @@ module ts { } getSymbolVisibilityDiagnosticMessage = getHeritageClauseVisibilityError; resolver.writeTypeAtLocation(node, enclosingDeclaration, TypeFormatFlags.WriteArrayAsGenericType, writer); + // TODO(shkamat) This is just till we get rest of the error reporting up + getSymbolVisibilityDiagnosticMessage = undefined; } if (typeReferences) { diff --git a/tests/baselines/reference/privacyTypeParameterOfFunction.errors.txt b/tests/baselines/reference/privacyTypeParameterOfFunction.errors.txt deleted file mode 100644 index a48f291d507..00000000000 --- a/tests/baselines/reference/privacyTypeParameterOfFunction.errors.txt +++ /dev/null @@ -1,136 +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 (): privateClass; - - // TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1 - (): privateClass; - - // TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1 - myMethod(): privateClass; - } - - export interface publicInterfaceWithPublicTypeParameters { - new (): publicClass; - (): publicClass; - myMethod(): publicClass; - } - - interface privateInterfaceWithPrivateTypeParameters { - new (): privateClass; - (): privateClass; - myMethod(): privateClass; - } - - interface privateInterfaceWithPublicTypeParameters { - new (): publicClass; - (): publicClass; - myMethod(): publicClass; - } - - export class publicClassWithWithPrivateTypeParameters { - // TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1 - static myPublicStaticMethod() { - } - private static myPrivateStaticMethod() { // No error - } - // TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1 - myPublicMethod() { - } - private myPrivateMethod() { // No error - } - } - - export class publicClassWithWithPublicTypeParameters { - static myPublicStaticMethod() { - } - private static myPrivateStaticMethod() { - } - myPublicMethod() { - } - private myPrivateMethod() { - } - } - - class privateClassWithWithPrivateTypeParameters { - static myPublicStaticMethod() { - } - private static myPrivateStaticMethod() { // No error - } - myPublicMethod() { - } - private myPrivateMethod() { // No error - } - } - - class privateClassWithWithPublicTypeParameters { - static myPublicStaticMethod() { - } - private static myPrivateStaticMethod() { - } - myPublicMethod() { - } - private myPrivateMethod() { - } - } - - // TypeParameter_0_of_exported_function_has_or_is_using_private_type_1 - export function publicFunctionWithPrivateTypeParameters() { - } - - export function publicFunctionWithPublicTypeParameters() { - } - - function privateFunctionWithPrivateTypeParameters() { - } - - function privateFunctionWithPublicTypeParameters() { - } - - export interface publicInterfaceWithPublicTypeParametersWithoutExtends { - new (): publicClass; - (): publicClass; - myMethod(): publicClass; - } - - interface privateInterfaceWithPublicTypeParametersWithoutExtends { - new (): publicClass; - (): publicClass; - myMethod(): publicClass; - } - - export class publicClassWithWithPublicTypeParametersWithoutExtends { - static myPublicStaticMethod() { - } - private static myPrivateStaticMethod() { - } - myPublicMethod() { - } - private myPrivateMethod() { - } - } - class privateClassWithWithPublicTypeParametersWithoutExtends { - static myPublicStaticMethod() { - } - private static myPrivateStaticMethod() { - } - myPublicMethod() { - } - private myPrivateMethod() { - } - } - - export function publicFunctionWithPublicTypeParametersWithoutExtends() { - } - - function privateFunctionWithPublicTypeParametersWithoutExtends() { - } \ No newline at end of file diff --git a/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt b/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt new file mode 100644 index 00000000000..ccb7be1e181 --- /dev/null +++ b/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.errors.txt @@ -0,0 +1,495 @@ +==== tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts (28 errors) ==== + class privateClass { + } + + export class publicClass { + } + + export interface publicInterfaceWithPrivateTypeParameters { + new (): privateClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of constructor signature from exported interface has or is using private name 'privateClass'. + (): privateClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of call signature from exported interface has or is using private name 'privateClass'. + myMethod(): privateClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of method from exported interface has or is using private name 'privateClass'. + } + + export interface publicInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + interface privateInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public static method from exported class has or is using private name 'privateClass'. + } + private static myPrivateStaticMethod() { + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public static method from exported class has or is using private name 'privateClass'. + } + myPublicMethod() { // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public method from exported class has or is using private name 'privateClass'. + } + private myPrivateMethod() { + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public method from exported class has or is using private name 'privateClass'. + } + } + + export class publicClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPrivateTypeParameters() { // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported function has or is using private name 'privateClass'. + } + + export function publicFunctionWithPublicTypeParameters() { + } + + function privateFunctionWithPrivateTypeParameters() { + } + + function privateFunctionWithPublicTypeParameters() { + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + class privateClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPublicTypeParametersWithoutExtends() { + } + + function privateFunctionWithPublicTypeParametersWithoutExtends() { + } + + export interface publicInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of constructor signature from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'. + (): privateModule.publicClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of call signature from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'. + myMethod(): privateModule.publicClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of method from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'. + } + export class publicClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. + } + myPublicMethod() { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. + } + } + export function publicFunctionWithPrivateMopduleTypeParameters() { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. + } + + + interface privateInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; + (): privateModule.publicClass; + myMethod(): privateModule.publicClass; + } + class privateClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { + } + myPublicMethod() { + } + } + function privateFunctionWithPrivateMopduleTypeParameters() { + } + + + export module publicModule { + class privateClass { + } + + export class publicClass { + } + + export interface publicInterfaceWithPrivateTypeParameters { + new (): privateClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of constructor signature from exported interface has or is using private name 'privateClass'. + (): privateClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of call signature from exported interface has or is using private name 'privateClass'. + myMethod(): privateClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of method from exported interface has or is using private name 'privateClass'. + } + + export interface publicInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + interface privateInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public static method from exported class has or is using private name 'privateClass'. + } + private static myPrivateStaticMethod() { + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public static method from exported class has or is using private name 'privateClass'. + } + myPublicMethod() { // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public method from exported class has or is using private name 'privateClass'. + } + private myPrivateMethod() { + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public method from exported class has or is using private name 'privateClass'. + } + } + + export class publicClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPrivateTypeParameters() { // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported function has or is using private name 'privateClass'. + } + + export function publicFunctionWithPublicTypeParameters() { + } + + function privateFunctionWithPrivateTypeParameters() { + } + + function privateFunctionWithPublicTypeParameters() { + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + class privateClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPublicTypeParametersWithoutExtends() { + } + + function privateFunctionWithPublicTypeParametersWithoutExtends() { + } + + export interface publicInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of constructor signature from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'. + (): privateModule.publicClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of call signature from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'. + myMethod(): privateModule.publicClass; // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of method from exported interface has or is using name 'privateModule.publicClass' from private module 'privateModule'. + } + export class publicClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public static method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. + } + myPublicMethod() { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of public method from exported class has or is using name 'privateModule.publicClass' from private module 'privateModule'. + } + } + export function publicFunctionWithPrivateMopduleTypeParameters() { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported function has or is using name 'privateModule.publicClass' from private module 'privateModule'. + } + + + interface privateInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; + (): privateModule.publicClass; + myMethod(): privateModule.publicClass; + } + class privateClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { + } + myPublicMethod() { + } + } + function privateFunctionWithPrivateMopduleTypeParameters() { + } + + } + + module privateModule { + class privateClass { + } + + export class publicClass { + } + + export interface publicInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + export interface publicInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + interface privateInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export class publicClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPrivateTypeParameters() { + } + + export function publicFunctionWithPublicTypeParameters() { + } + + function privateFunctionWithPrivateTypeParameters() { + } + + function privateFunctionWithPublicTypeParameters() { + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + class privateClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPublicTypeParametersWithoutExtends() { + } + + function privateFunctionWithPublicTypeParametersWithoutExtends() { + } + } \ No newline at end of file diff --git a/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.js b/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.js new file mode 100644 index 00000000000..173b48b8049 --- /dev/null +++ b/tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.js @@ -0,0 +1,816 @@ +//// [privacyTypeParameterOfFunctionDeclFile.ts] +class privateClass { +} + +export class publicClass { +} + +export interface publicInterfaceWithPrivateTypeParameters { + new (): privateClass; // Error + (): privateClass; // Error + myMethod(): privateClass; // Error +} + +export interface publicInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; +} + +interface privateInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; +} + +interface privateInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; +} + +export class publicClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { // Error + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { // Error + } + private myPrivateMethod() { + } +} + +export class publicClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} + +class privateClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} + +class privateClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} + +export function publicFunctionWithPrivateTypeParameters() { // Error +} + +export function publicFunctionWithPublicTypeParameters() { +} + +function privateFunctionWithPrivateTypeParameters() { +} + +function privateFunctionWithPublicTypeParameters() { +} + +export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; +} + +interface privateInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; +} + +export class publicClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} +class privateClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} + +export function publicFunctionWithPublicTypeParametersWithoutExtends() { +} + +function privateFunctionWithPublicTypeParametersWithoutExtends() { +} + +export interface publicInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; // Error + (): privateModule.publicClass; // Error + myMethod(): privateModule.publicClass; // Error +} +export class publicClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { // Error + } + myPublicMethod() { // Error + } +} +export function publicFunctionWithPrivateMopduleTypeParameters() { // Error +} + + +interface privateInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; + (): privateModule.publicClass; + myMethod(): privateModule.publicClass; +} +class privateClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { + } + myPublicMethod() { + } +} +function privateFunctionWithPrivateMopduleTypeParameters() { +} + + +export module publicModule { + class privateClass { + } + + export class publicClass { + } + + export interface publicInterfaceWithPrivateTypeParameters { + new (): privateClass; // Error + (): privateClass; // Error + myMethod(): privateClass; // Error + } + + export interface publicInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + interface privateInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { // Error + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { // Error + } + private myPrivateMethod() { + } + } + + export class publicClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPrivateTypeParameters() { // Error + } + + export function publicFunctionWithPublicTypeParameters() { + } + + function privateFunctionWithPrivateTypeParameters() { + } + + function privateFunctionWithPublicTypeParameters() { + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + class privateClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPublicTypeParametersWithoutExtends() { + } + + function privateFunctionWithPublicTypeParametersWithoutExtends() { + } + + export interface publicInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; // Error + (): privateModule.publicClass; // Error + myMethod(): privateModule.publicClass; // Error + } + export class publicClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { // Error + } + myPublicMethod() { // Error + } + } + export function publicFunctionWithPrivateMopduleTypeParameters() { // Error + } + + + interface privateInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; + (): privateModule.publicClass; + myMethod(): privateModule.publicClass; + } + class privateClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { + } + myPublicMethod() { + } + } + function privateFunctionWithPrivateMopduleTypeParameters() { + } + +} + +module privateModule { + class privateClass { + } + + export class publicClass { + } + + export interface publicInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + export interface publicInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + interface privateInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export class publicClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPrivateTypeParameters() { + } + + export function publicFunctionWithPublicTypeParameters() { + } + + function privateFunctionWithPrivateTypeParameters() { + } + + function privateFunctionWithPublicTypeParameters() { + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + class privateClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPublicTypeParametersWithoutExtends() { + } + + function privateFunctionWithPublicTypeParametersWithoutExtends() { + } +} + +//// [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 = {})); diff --git a/tests/baselines/reference/privacyTypeParametersOfClass.errors.txt b/tests/baselines/reference/privacyTypeParametersOfClass.errors.txt deleted file mode 100644 index ad9ed70998f..00000000000 --- a/tests/baselines/reference/privacyTypeParametersOfClass.errors.txt +++ /dev/null @@ -1,47 +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 { - myMethod(val: T): T { // Error - return val; - } - } - - export class publicClassWithPublicTypeParameters { - myMethod(val: T): T { // No Error - return val; - } - } - - class privateClassWithPrivateTypeParameters { - myMethod(val: T): T { // No Error - return val; - } - } - - class privateClassWithPublicTypeParameters { - myMethod(val: T): T { // No Error - return val; - } - } - - export class publicClassWithPublicTypeParametersWithoutExtends { - myMethod(val: T): T { // No Error - return val; - } - } - - class privateClassWithPublicTypeParametersWithoutExtends { - myMethod(val: T): T { // No Error - return val; - } - } - \ No newline at end of file diff --git a/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt b/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt new file mode 100644 index 00000000000..fd9386f9b13 --- /dev/null +++ b/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.errors.txt @@ -0,0 +1,163 @@ +==== tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts (4 errors) ==== + class privateClass { + } + + export class publicClass { + } + + export class publicClassWithPrivateTypeParameters { // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported class has or is using private name 'privateClass'. + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithTypeParametersFromPrivateModule { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported class has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'. + myMethod(val: T): T { + return val; + } + } + + class privateClassWithTypeParametersFromPrivateModule { + myMethod(val: T): T { + return val; + } + } + + export module publicModule { + class privateClassInPublicModule { + } + + export class publicClassInPublicModule { + } + + export class publicClassWithPrivateTypeParameters { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported class has or is using private name 'privateClassInPublicModule'. + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithTypeParametersFromPrivateModule { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported class has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'. + myMethod(val: T): T { + return val; + } + } + + class privateClassWithTypeParametersFromPrivateModule { + myMethod(val: T): T { + return val; + } + } + } + + module privateModule { + class privateClassInPrivateModule { + } + + export class publicClassInPrivateModule { + } + + export class publicClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.js b/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.js new file mode 100644 index 00000000000..ae829f5ab8a --- /dev/null +++ b/tests/baselines/reference/privacyTypeParametersOfClassDeclFile.js @@ -0,0 +1,383 @@ +//// [privacyTypeParametersOfClassDeclFile.ts] +class privateClass { +} + +export class publicClass { +} + +export class publicClassWithPrivateTypeParameters { // Error + myMethod(val: T): T { + return val; + } +} + +export class publicClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } +} + +class privateClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } +} + +class privateClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } +} + +export class publicClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } +} + +class privateClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } +} + +export class publicClassWithTypeParametersFromPrivateModule { // Error + myMethod(val: T): T { + return val; + } +} + +class privateClassWithTypeParametersFromPrivateModule { + myMethod(val: T): T { + return val; + } +} + +export module publicModule { + class privateClassInPublicModule { + } + + export class publicClassInPublicModule { + } + + export class publicClassWithPrivateTypeParameters { // Error + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithTypeParametersFromPrivateModule { // Error + myMethod(val: T): T { + return val; + } + } + + class privateClassWithTypeParametersFromPrivateModule { + myMethod(val: T): T { + return val; + } + } +} + +module privateModule { + class privateClassInPrivateModule { + } + + export class publicClassInPrivateModule { + } + + export class publicClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParametersWithoutExtends { + 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 = {})); diff --git a/tests/baselines/reference/privacyTypeParametersOfInterface.errors.txt b/tests/baselines/reference/privacyTypeParametersOfInterface.errors.txt deleted file mode 100644 index 42eb13995c8..00000000000 --- a/tests/baselines/reference/privacyTypeParametersOfInterface.errors.txt +++ /dev/null @@ -1,62 +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 { - } - - export class publicClassT { - } - - // TypeParameter_0_of_exported_interface_1_has_or_is_using_private_type_2 - export interface publicInterfaceWithPrivateTypeParameters { - myMethod(val: T): T; // Error - myMethod0(): publicClassT; // error - myMethod1(): privateClassT; // error - myMethod2(): privateClassT; // error - myMethod3(): publicClassT; //error - myMethod4(): publicClassT; // no error - } - - export interface publicInterfaceWithPublicTypeParameters { - myMethod(val: T): T; // No Error - myMethod0(): publicClassT; // No error - myMethod1(): privateClassT; // error - myMethod2(): privateClassT; // error - myMethod3(): publicClassT; //error - myMethod4(): publicClassT; // no error - } - - interface privateInterfaceWithPrivateTypeParameters { - myMethod(val: T): T; // No Error - myMethod0(): publicClassT; // No error - myMethod1(): privateClassT; // No error - myMethod2(): privateClassT; // No error - myMethod3(): publicClassT; //No error - myMethod4(): publicClassT; // no error - } - - interface privateInterfaceWithPublicTypeParameters { - myMethod(val: T): T; // No Error - myMethod0(): publicClassT; // No error - myMethod1(): privateClassT; // No error - myMethod2(): privateClassT; // No error - myMethod3(): publicClassT; //No error - myMethod4(): publicClassT; // no error - } - - export interface publicInterfaceWithPublicTypeParametersWithoutExtends { - myMethod(val: T): T; // No Error - myMethod0(): publicClassT; // No error - } - - interface privateInterfaceWithPublicTypeParametersWithoutExtends { - myMethod(val: T): T; // No Error - myMethod0(): publicClassT; // No error - } \ No newline at end of file diff --git a/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt b/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt new file mode 100644 index 00000000000..090ca91836d --- /dev/null +++ b/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.errors.txt @@ -0,0 +1,199 @@ +==== tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts (4 errors) ==== + class privateClass { + } + + export class publicClass { + } + + class privateClassT { + } + + export class publicClassT { + } + + export interface publicInterfaceWithPrivateTypeParameters { // Error + ~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported interface has or is using private name 'privateClass'. + myMethod(val: T): T; + myMethod0(): publicClassT; + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; + } + + export interface publicInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassT + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; + } + + interface privateInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassT; + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; + } + + interface privateInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassT; + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassT; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassT; + } + + + export interface publicInterfaceWithPrivateModuleTypeParameterConstraints { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported interface has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'. + } + + interface privateInterfaceWithPrivateModuleTypeParameterConstraints { // Error + } + + export module publicModule { + class privateClassInPublicModule { + } + + export class publicClassInPublicModule { + } + + class privateClassInPublicModuleT { + } + + export class publicClassInPublicModuleT { + } + + export interface publicInterfaceWithPrivateTypeParameters { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported interface has or is using private name 'privateClassInPublicModule'. + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + export interface publicInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + interface privateInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + interface privateInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + } + + export interface publicInterfaceWithPrivateModuleTypeParameterConstraints { // Error + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! TypeParameter 'T' of exported interface has or is using name 'privateModule.publicClassInPrivateModule' from private module 'privateModule'. + } + + interface privateInterfaceWithPrivateModuleTypeParameterConstraints { // Error + } + } + + module privateModule { + class privateClassInPrivateModule { + } + + export class publicClassInPrivateModule { + } + + class privateClassInPrivateModuleT { + } + + export class publicClassInPrivateModuleT { + } + + export interface publicInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + export interface publicInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + interface privateInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + interface privateInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.js b/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.js new file mode 100644 index 00000000000..2ae5488dd3c --- /dev/null +++ b/tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.js @@ -0,0 +1,265 @@ +//// [privacyTypeParametersOfInterfaceDeclFile.ts] +class privateClass { +} + +export class publicClass { +} + +class privateClassT { +} + +export class publicClassT { +} + +export interface publicInterfaceWithPrivateTypeParameters { // Error + myMethod(val: T): T; + myMethod0(): publicClassT; + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; +} + +export interface publicInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassT + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; +} + +interface privateInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassT; + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; +} + +interface privateInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassT; + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; +} + +export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassT; +} + +interface privateInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassT; +} + + +export interface publicInterfaceWithPrivateModuleTypeParameterConstraints { // Error +} + +interface privateInterfaceWithPrivateModuleTypeParameterConstraints { // Error +} + +export module publicModule { + class privateClassInPublicModule { + } + + export class publicClassInPublicModule { + } + + class privateClassInPublicModuleT { + } + + export class publicClassInPublicModuleT { + } + + export interface publicInterfaceWithPrivateTypeParameters { // Error + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + export interface publicInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + interface privateInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + interface privateInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + } + + export interface publicInterfaceWithPrivateModuleTypeParameterConstraints { // Error + } + + interface privateInterfaceWithPrivateModuleTypeParameterConstraints { // Error + } +} + +module privateModule { + class privateClassInPrivateModule { + } + + export class publicClassInPrivateModule { + } + + class privateClassInPrivateModuleT { + } + + export class publicClassInPrivateModuleT { + } + + export interface publicInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + export interface publicInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + interface privateInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + interface privateInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + } +} + +//// [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 = {})); diff --git a/tests/cases/compiler/privacyTypeParameterOfFunction.ts b/tests/cases/compiler/privacyTypeParameterOfFunction.ts index 2b22b5321bb..dfbecc24bf3 100644 --- a/tests/cases/compiler/privacyTypeParameterOfFunction.ts +++ b/tests/cases/compiler/privacyTypeParameterOfFunction.ts @@ -1,3 +1,4 @@ +// @module: commonjs class privateClass { } diff --git a/tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts b/tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts new file mode 100644 index 00000000000..7ea908e9cfb --- /dev/null +++ b/tests/cases/compiler/privacyTypeParameterOfFunctionDeclFile.ts @@ -0,0 +1,440 @@ +// @module: commonjs +// @declaration: true +class privateClass { +} + +export class publicClass { +} + +export interface publicInterfaceWithPrivateTypeParameters { + new (): privateClass; // Error + (): privateClass; // Error + myMethod(): privateClass; // Error +} + +export interface publicInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; +} + +interface privateInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; +} + +interface privateInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; +} + +export class publicClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { // Error + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { // Error + } + private myPrivateMethod() { + } +} + +export class publicClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} + +class privateClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} + +class privateClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} + +export function publicFunctionWithPrivateTypeParameters() { // Error +} + +export function publicFunctionWithPublicTypeParameters() { +} + +function privateFunctionWithPrivateTypeParameters() { +} + +function privateFunctionWithPublicTypeParameters() { +} + +export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; +} + +interface privateInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; +} + +export class publicClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} +class privateClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } +} + +export function publicFunctionWithPublicTypeParametersWithoutExtends() { +} + +function privateFunctionWithPublicTypeParametersWithoutExtends() { +} + +export interface publicInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; // Error + (): privateModule.publicClass; // Error + myMethod(): privateModule.publicClass; // Error +} +export class publicClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { // Error + } + myPublicMethod() { // Error + } +} +export function publicFunctionWithPrivateMopduleTypeParameters() { // Error +} + + +interface privateInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; + (): privateModule.publicClass; + myMethod(): privateModule.publicClass; +} +class privateClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { + } + myPublicMethod() { + } +} +function privateFunctionWithPrivateMopduleTypeParameters() { +} + + +export module publicModule { + class privateClass { + } + + export class publicClass { + } + + export interface publicInterfaceWithPrivateTypeParameters { + new (): privateClass; // Error + (): privateClass; // Error + myMethod(): privateClass; // Error + } + + export interface publicInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + interface privateInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { // Error + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { // Error + } + private myPrivateMethod() { + } + } + + export class publicClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPrivateTypeParameters() { // Error + } + + export function publicFunctionWithPublicTypeParameters() { + } + + function privateFunctionWithPrivateTypeParameters() { + } + + function privateFunctionWithPublicTypeParameters() { + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + class privateClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPublicTypeParametersWithoutExtends() { + } + + function privateFunctionWithPublicTypeParametersWithoutExtends() { + } + + export interface publicInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; // Error + (): privateModule.publicClass; // Error + myMethod(): privateModule.publicClass; // Error + } + export class publicClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { // Error + } + myPublicMethod() { // Error + } + } + export function publicFunctionWithPrivateMopduleTypeParameters() { // Error + } + + + interface privateInterfaceWithPrivatModuleTypeParameters { + new (): privateModule.publicClass; + (): privateModule.publicClass; + myMethod(): privateModule.publicClass; + } + class privateClassWithWithPrivateModuleTypeParameters { + static myPublicStaticMethod() { + } + myPublicMethod() { + } + } + function privateFunctionWithPrivateMopduleTypeParameters() { + } + +} + +module privateModule { + class privateClass { + } + + export class publicClass { + } + + export interface publicInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + export interface publicInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPrivateTypeParameters { + new (): privateClass; + (): privateClass; + myMethod(): privateClass; + } + + interface privateInterfaceWithPublicTypeParameters { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export class publicClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPrivateTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + class privateClassWithWithPublicTypeParameters { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPrivateTypeParameters() { + } + + export function publicFunctionWithPublicTypeParameters() { + } + + function privateFunctionWithPrivateTypeParameters() { + } + + function privateFunctionWithPublicTypeParameters() { + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + new (): publicClass; + (): publicClass; + myMethod(): publicClass; + } + + export class publicClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + class privateClassWithWithPublicTypeParametersWithoutExtends { + static myPublicStaticMethod() { + } + private static myPrivateStaticMethod() { + } + myPublicMethod() { + } + private myPrivateMethod() { + } + } + + export function publicFunctionWithPublicTypeParametersWithoutExtends() { + } + + function privateFunctionWithPublicTypeParametersWithoutExtends() { + } +} \ No newline at end of file diff --git a/tests/cases/compiler/privacyTypeParametersOfClass.ts b/tests/cases/compiler/privacyTypeParametersOfClass.ts index 59f771ef718..e7b520e58ca 100644 --- a/tests/cases/compiler/privacyTypeParametersOfClass.ts +++ b/tests/cases/compiler/privacyTypeParametersOfClass.ts @@ -1,3 +1,4 @@ +// @module: commonjs class privateClass { } diff --git a/tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts b/tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts new file mode 100644 index 00000000000..dcc21ca362a --- /dev/null +++ b/tests/cases/compiler/privacyTypeParametersOfClassDeclFile.ts @@ -0,0 +1,155 @@ +// @module: commonjs +// @declaration: true +class privateClass { +} + +export class publicClass { +} + +export class publicClassWithPrivateTypeParameters { // Error + myMethod(val: T): T { + return val; + } +} + +export class publicClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } +} + +class privateClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } +} + +class privateClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } +} + +export class publicClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } +} + +class privateClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } +} + +export class publicClassWithTypeParametersFromPrivateModule { // Error + myMethod(val: T): T { + return val; + } +} + +class privateClassWithTypeParametersFromPrivateModule { + myMethod(val: T): T { + return val; + } +} + +export module publicModule { + class privateClassInPublicModule { + } + + export class publicClassInPublicModule { + } + + export class publicClassWithPrivateTypeParameters { // Error + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithTypeParametersFromPrivateModule { // Error + myMethod(val: T): T { + return val; + } + } + + class privateClassWithTypeParametersFromPrivateModule { + myMethod(val: T): T { + return val; + } + } +} + +module privateModule { + class privateClassInPrivateModule { + } + + export class publicClassInPrivateModule { + } + + export class publicClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPrivateTypeParameters { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParameters { + myMethod(val: T): T { + return val; + } + } + + export class publicClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } + + class privateClassWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T { + return val; + } + } +} diff --git a/tests/cases/compiler/privacyTypeParametersOfInterface.ts b/tests/cases/compiler/privacyTypeParametersOfInterface.ts index fedb16be766..c61174a37c0 100644 --- a/tests/cases/compiler/privacyTypeParametersOfInterface.ts +++ b/tests/cases/compiler/privacyTypeParametersOfInterface.ts @@ -1,3 +1,4 @@ +// @module: commonjs class privateClass { } diff --git a/tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts b/tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts new file mode 100644 index 00000000000..55984b46ccb --- /dev/null +++ b/tests/cases/compiler/privacyTypeParametersOfInterfaceDeclFile.ts @@ -0,0 +1,192 @@ +// @module: commonjs +// @declaration: true +class privateClass { +} + +export class publicClass { +} + +class privateClassT { +} + +export class publicClassT { +} + +export interface publicInterfaceWithPrivateTypeParameters { // Error + myMethod(val: T): T; + myMethod0(): publicClassT; + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; +} + +export interface publicInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassT + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; +} + +interface privateInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassT; + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; +} + +interface privateInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassT; + myMethod1(): privateClassT; + myMethod2(): privateClassT; + myMethod3(): publicClassT; + myMethod4(): publicClassT; +} + +export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassT; +} + +interface privateInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassT; +} + + +export interface publicInterfaceWithPrivateModuleTypeParameterConstraints { // Error +} + +interface privateInterfaceWithPrivateModuleTypeParameterConstraints { // Error +} + +export module publicModule { + class privateClassInPublicModule { + } + + export class publicClassInPublicModule { + } + + class privateClassInPublicModuleT { + } + + export class publicClassInPublicModuleT { + } + + export interface publicInterfaceWithPrivateTypeParameters { // Error + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + export interface publicInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + interface privateInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + interface privateInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + myMethod1(): privateClassInPublicModuleT; + myMethod2(): privateClassInPublicModuleT; + myMethod3(): publicClassInPublicModuleT; + myMethod4(): publicClassInPublicModuleT; + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPublicModuleT; + } + + export interface publicInterfaceWithPrivateModuleTypeParameterConstraints { // Error + } + + interface privateInterfaceWithPrivateModuleTypeParameterConstraints { // Error + } +} + +module privateModule { + class privateClassInPrivateModule { + } + + export class publicClassInPrivateModule { + } + + class privateClassInPrivateModuleT { + } + + export class publicClassInPrivateModuleT { + } + + export interface publicInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + export interface publicInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + interface privateInterfaceWithPrivateTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + interface privateInterfaceWithPublicTypeParameters { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + myMethod1(): privateClassInPrivateModuleT; + myMethod2(): privateClassInPrivateModuleT; + myMethod3(): publicClassInPrivateModuleT; + myMethod4(): publicClassInPrivateModuleT; + } + + export interface publicInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + } + + interface privateInterfaceWithPublicTypeParametersWithoutExtends { + myMethod(val: T): T; + myMethod0(): publicClassInPrivateModuleT; + } +} \ No newline at end of file