TypeScript/tests/cases/conformance/types/uniqueSymbol/uniqueSymbolsErrors.ts
Titian Cernicova-Dragomir 2484210a00
Gh 41788 incorrect output for esprivate with nested class in esnext (#42663)
* If target:esnext,then useDefineForClassFields: true will now be the default.

* Added error if a private identifier is used in a static a initializer if target:ESNext and useDefineForClassFields:false.

* Added test for new useDefineForClassFields default and error message.

* Fixed tests after changing the default of useDefineForClassFields to true for target esnext

* Fixed code review suggestions.

* Updated error message.

* Added missing static check for the containing property. Fixed other code review issues.
2021-04-07 08:23:16 -07:00

90 lines
3.9 KiB
TypeScript

// @target: esnext
// @useDefineForClassFields: false
// declarations
declare const invalidUniqueType: unique number;
declare const {}: unique symbol;
declare let invalidLetType: unique symbol;
declare var invalidVarType: unique symbol;
// function arguments and return types
declare function invalidArgType(arg: unique symbol): void;
declare function invalidRestArgType(...arg: (unique symbol)[]): void;
declare function invalidReturnType(): unique symbol;
declare function invalidThisType(this: unique symbol): void;
declare function invalidTypePredicate(n: any): n is unique symbol;
declare function invalidTypeParameterConstraint<T extends unique symbol>(): void;
declare function invalidTypeParameterDefault<T = unique symbol>(): void;
// classes
class InvalidClass {
constructor(invalidConstructorArgType: unique symbol) {}
readonly invalidReadonlyPropertyType: unique symbol;
invalidPropertyType: unique symbol;
invalidArgType(arg: unique symbol): void { return; }
invalidRestArgType(...args: (unique symbol)[]): void { return; }
invalidReturnType(): unique symbol { return; }
invalidThisType(this: unique symbol): void { return; }
invalidTypePredicate(n: any): n is unique symbol { return; }
invalidTypeParameterConstraint<T extends unique symbol>(): void { return; }
invalidTypeParameterDefault<T = unique symbol>(): void { return; }
get invalidGetter(): unique symbol { return; }
set invalidSetter(arg: unique symbol) { return; }
static invalidStaticPropertyType: unique symbol;
static invalidStaticArgType(arg: unique symbol): void { return; }
static invalidStaticRestArgType(...args: (unique symbol)[]): void { return; }
static invalidStaticReturnType(): unique symbol { return; }
static invalidStaticThisType(this: unique symbol): void { return; }
static invalidStaticTypePredicate(n: any): n is unique symbol { return; }
static invalidStaticTypeParameterConstraint<T extends unique symbol>(): void { return; }
static invalidStaticTypeParameterDefault<T = unique symbol>(): void { return; }
static get invalidStaticGetter(): unique symbol { return; }
static set invalidStaticSetter(arg: unique symbol) { return; }
}
// interfaces
interface InvalidInterface {
invalidPropertyType: unique symbol;
invalidArgType(arg: unique symbol): void;
invalidRestArgType(...args: (unique symbol)[]): void;
invalidReturnType(): unique symbol;
invalidThisType(this: unique symbol);
invalidTypePredicate(n: any): n is unique symbol
invalidTypeParameterConstraint<T extends unique symbol>(): void;
invalidTypeParameterDefault<T = unique symbol>(): void;
}
// type literals
type InvalidTypeLiteral = {
invalidPropertyType: unique symbol;
invalidArgType(arg: unique symbol): void;
invalidRestArgType(...args: (unique symbol)[]): void;
invalidReturnType(): unique symbol;
invalidThisType(this: unique symbol);
invalidTypePredicate(n: any): n is unique symbol
invalidTypeParameterConstraint<T extends unique symbol>(): void;
invalidTypeParameterDefault<T = unique symbol>(): void;
};
// type alias
type InvalidAlias = unique symbol;
type InvalidAliasTypeParameterConstraint<T extends unique symbol> = never;
type InvalidAliasTypeParameterDefault<T extends unique symbol> = never;
// type references
declare const invalidTypeArgument: Promise<unique symbol>;
declare const invalidArrayType: (unique symbol)[];
declare const invalidTupleType: [unique symbol];
// mapped types
declare const invalidMappedType: { [P in string]: unique symbol };
// unions/intersection
declare const invalidUnion: unique symbol | unique symbol;
declare const invalidIntersection: unique symbol | unique symbol;
// initializer assignability
// https://github.com/Microsoft/TypeScript/issues/21584
const shouldNotBeAssignable: string = Symbol();