microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-09 16:39:46 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Add TupleBase with unusable mutating Array methods

Browse Source
This commit is contained in:
Nathan Shively-Sanders
2017-11-06 10:35:53 -08:00
parent a980d61f86
commit 4385444c44
2 changed files with 20 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/compiler/checker.ts
View File

@@ -327,6 +327,7 @@ namespace ts {
let globalFunctionType: ObjectType;
let globalArrayType: GenericType;
let globalReadonlyArrayType: GenericType;
let globalTupleBaseType: GenericType;
let globalStringType: ObjectType;
let globalNumberType: ObjectType;
let globalBooleanType: ObjectType;
@@ -775,7 +776,7 @@ namespace ts {
* @param parameterName a name of the parameter to get the symbols for.
* @return a tuple of two symbols
*/
function getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: __String): [Symbol, Symbol] {
function getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: __String): Symbol[] {
const constructorDeclaration = parameter.parent;
const classDeclaration = parameter.parent.parent;
@@ -4996,7 +4997,7 @@ namespace ts {
function getBaseTypes(type: InterfaceType): BaseType[] {
if (!type.resolvedBaseTypes) {
if (type.objectFlags & ObjectFlags.Tuple) {
type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters))];
type.resolvedBaseTypes = [createTypeFromGenericGlobalType(globalTupleBaseType, [getUnionType(type.typeParameters)])];
}
else if (type.symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
if (type.symbol.flags & SymbolFlags.Class) {
@@ -9992,7 +9993,7 @@ namespace ts {
const typeParameters = type.typeParameters || emptyArray;
let variances = type.variances;
if (!variances) {
if (type === globalArrayType || type === globalReadonlyArrayType) {
if (type === globalArrayType || type === globalReadonlyArrayType || type === globalTupleBaseType) {
// Arrays are known to be covariant, no need to spend time computing this
variances = [Variance.Covariant];
}
@@ -10321,7 +10322,7 @@ namespace ts {
function isArrayLikeType(type: Type): boolean {
// A type is array-like if it is a reference to the global Array or global ReadonlyArray type,
// or if it is not the undefined or null type and if it is assignable to ReadonlyArray<any>
return getObjectFlags(type) & ObjectFlags.Reference && ((<TypeReference>type).target === globalArrayType || (<TypeReference>type).target === globalReadonlyArrayType) ||
return getObjectFlags(type) & ObjectFlags.Reference && ((<TypeReference>type).target === globalArrayType || (<TypeReference>type).target === globalReadonlyArrayType || (type as TypeReference).target === globalTupleBaseType) ||
!(type.flags & TypeFlags.Nullable) && isTypeAssignableTo(type, anyReadonlyArrayType);
}
@@ -24509,7 +24510,9 @@ namespace ts {
anyArrayType = createArrayType(anyType);
autoArrayType = createArrayType(autoType);
globalReadonlyArrayType = <GenericType>getGlobalTypeOrUndefined("ReadonlyArray" as __String, /*arity*/ 1);
// TODO: ReadonlyArray and TupleBase should always be available, but haven't been required previously
globalReadonlyArrayType = <GenericType>getGlobalType("ReadonlyArray" as __String, /*arity*/ 1, /*reportErrors*/ true);
globalTupleBaseType = <GenericType>getGlobalType("TupleBase" as __String, /*arity*/ 1, /*reportErrors*/ true);
anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;
globalThisType = <GenericType>getGlobalTypeOrUndefined("ThisType" as __String, /*arity*/ 1);
}

12
src/lib/es5.d.ts vendored
View File

@@ -1240,6 +1240,18 @@ interface ArrayConstructor {
declare const Array: ArrayConstructor;
interface TupleBase<T> extends Array<T> {
// TODO: Add jsdoc here warning not to call this
push(...items: never[]): never;
pop(): never | undefined;
reverse(): never[];
sort(compareFn?: (a: never, b: never) => number): never;
shift(): never | undefined;
unshift(...items: never[]): never;
splice(start: number, deleteCount?: number): never[];
splice(start: number, deleteCount: number, ...items: never[]): never[];
}
interface TypedPropertyDescriptor<T> {
enumerable?: boolean;
configurable?: boolean;