Merge branch 'master' into incrementalBuildInfo
This commit is contained in:
Sheetal Nandi
commit
a881391dc9
|
|
@ -55,7 +55,7 @@ The TypeScript repository is relatively large. To save some time, you might want
|
|||
|
||||
### Using local builds
|
||||
|
||||
Run `gulp build` to build a version of the compiler/language service that reflects changes you've made. You can then run `node <repo-root>/built/local/tsc.js` in place of `tsc` in your project. For example, to run `tsc --watch` from within the root of the repository on a file called `test.ts`, you can run `node ./built/local/tsc.js --watch test.ts`.
|
||||
Run `gulp` to build a version of the compiler/language service that reflects changes you've made. You can then run `node <repo-root>/built/local/tsc.js` in place of `tsc` in your project. For example, to run `tsc --watch` from within the root of the repository on a file called `test.ts`, you can run `node ./built/local/tsc.js --watch test.ts`.
|
||||
|
||||
## Contributing bug fixes
|
||||
|
||||
|
|
|
|||
|
|
@ -46,6 +46,7 @@
|
|||
"@types/minimist": "latest",
|
||||
"@types/mkdirp": "latest",
|
||||
"@types/mocha": "latest",
|
||||
"@types/ms": "latest",
|
||||
"@types/node": "8.5.5",
|
||||
"@types/q": "latest",
|
||||
"@types/source-map-support": "latest",
|
||||
|
|
@ -68,12 +69,13 @@
|
|||
"gulp-sourcemaps": "latest",
|
||||
"istanbul": "latest",
|
||||
"jake": "latest",
|
||||
"lodash": "4.17.10",
|
||||
"lodash": "^4.17.11",
|
||||
"merge2": "latest",
|
||||
"minimist": "latest",
|
||||
"mkdirp": "latest",
|
||||
"mocha": "latest",
|
||||
"mocha-fivemat-progress-reporter": "latest",
|
||||
"ms": "latest",
|
||||
"plugin-error": "latest",
|
||||
"pretty-hrtime": "^1.0.3",
|
||||
"prex": "^0.4.3",
|
||||
|
|
|
|||
|
|
@ -390,10 +390,10 @@ namespace ts {
|
|||
const wildcardType = createIntrinsicType(TypeFlags.Any, "any");
|
||||
const errorType = createIntrinsicType(TypeFlags.Any, "error");
|
||||
const unknownType = createIntrinsicType(TypeFlags.Unknown, "unknown");
|
||||
const undefinedType = createIntrinsicType(TypeFlags.Undefined, "undefined");
|
||||
const undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(TypeFlags.Undefined | TypeFlags.ContainsWideningType, "undefined");
|
||||
const nullType = createIntrinsicType(TypeFlags.Null, "null");
|
||||
const nullWideningType = strictNullChecks ? nullType : createIntrinsicType(TypeFlags.Null | TypeFlags.ContainsWideningType, "null");
|
||||
const undefinedType = createNullableType(TypeFlags.Undefined, "undefined", 0);
|
||||
const undefinedWideningType = strictNullChecks ? undefinedType : createNullableType(TypeFlags.Undefined, "undefined", ObjectFlags.ContainsWideningType);
|
||||
const nullType = createNullableType(TypeFlags.Null, "null", 0);
|
||||
const nullWideningType = strictNullChecks ? nullType : createNullableType(TypeFlags.Null, "null", ObjectFlags.ContainsWideningType);
|
||||
const stringType = createIntrinsicType(TypeFlags.String, "string");
|
||||
const numberType = createIntrinsicType(TypeFlags.Number, "number");
|
||||
const bigintType = createIntrinsicType(TypeFlags.BigInt, "bigint");
|
||||
|
|
@ -439,7 +439,7 @@ namespace ts {
|
|||
const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
|
||||
// The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated
|
||||
// in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.
|
||||
anyFunctionType.flags |= TypeFlags.ContainsAnyFunctionType;
|
||||
anyFunctionType.objectFlags |= ObjectFlags.ContainsAnyFunctionType;
|
||||
|
||||
const noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
|
||||
const circularConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
|
||||
|
|
@ -1518,7 +1518,8 @@ namespace ts {
|
|||
!checkAndReportErrorForExtendingInterface(errorLocation) &&
|
||||
!checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
|
||||
!checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) &&
|
||||
!checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning)) {
|
||||
!checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
|
||||
!checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
|
||||
let suggestion: Symbol | undefined;
|
||||
if (suggestedNameNotFoundMessage && suggestionCount < maximumSuggestionCount) {
|
||||
suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
|
||||
|
|
@ -1708,6 +1709,17 @@ namespace ts {
|
|||
return false;
|
||||
}
|
||||
|
||||
function checkAndReportErrorForUsingValueAsType(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean {
|
||||
if (meaning & (SymbolFlags.Type & ~SymbolFlags.Namespace)) {
|
||||
const symbol = resolveSymbol(resolveName(errorLocation, name, ~SymbolFlags.Type & SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined, /*isUse*/ false));
|
||||
if (symbol && !(symbol.flags & SymbolFlags.Namespace)) {
|
||||
error(errorLocation, Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here, unescapeLeadingUnderscores(name));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function checkAndReportErrorForUsingTypeAsValue(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean {
|
||||
if (meaning & (SymbolFlags.Value & ~SymbolFlags.NamespaceModule)) {
|
||||
if (name === "any" || name === "string" || name === "number" || name === "boolean" || name === "never") {
|
||||
|
|
@ -2741,6 +2753,12 @@ namespace ts {
|
|||
return type;
|
||||
}
|
||||
|
||||
function createNullableType(kind: TypeFlags, intrinsicName: string, objectFlags: ObjectFlags): NullableType {
|
||||
const type = createIntrinsicType(kind, intrinsicName);
|
||||
type.objectFlags = objectFlags;
|
||||
return type;
|
||||
}
|
||||
|
||||
function createBooleanType(trueFalseTypes: ReadonlyArray<Type>): IntrinsicType & UnionType {
|
||||
const type = <IntrinsicType & UnionType>getUnionType(trueFalseTypes);
|
||||
type.flags |= TypeFlags.Boolean;
|
||||
|
|
@ -5128,7 +5146,7 @@ namespace ts {
|
|||
definedInConstructor = true;
|
||||
}
|
||||
}
|
||||
const sourceTypes = some(constructorTypes, t => !!(t.flags & ~(TypeFlags.Nullable | TypeFlags.ContainsWideningType))) ? constructorTypes : types; // TODO: GH#18217
|
||||
const sourceTypes = some(constructorTypes, t => !!(t.flags & ~TypeFlags.Nullable)) ? constructorTypes : types; // TODO: GH#18217
|
||||
type = getUnionType(sourceTypes!, UnionReduction.Subtype);
|
||||
}
|
||||
const widened = getWidenedType(addOptionality(type, definedInMethod && !definedInConstructor));
|
||||
|
|
@ -5293,7 +5311,7 @@ namespace ts {
|
|||
function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
|
||||
const members = createSymbolTable();
|
||||
let stringIndexInfo: IndexInfo | undefined;
|
||||
let objectFlags = ObjectFlags.ObjectLiteral;
|
||||
let objectFlags = ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectLiteral;
|
||||
forEach(pattern.elements, e => {
|
||||
const name = e.propertyName || <Identifier>e.name;
|
||||
if (e.dotDotDotToken) {
|
||||
|
|
@ -5315,7 +5333,6 @@ namespace ts {
|
|||
members.set(symbol.escapedName, symbol);
|
||||
});
|
||||
const result = createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, undefined);
|
||||
result.flags |= TypeFlags.ContainsObjectLiteral;
|
||||
result.objectFlags |= objectFlags;
|
||||
if (includePatternInType) {
|
||||
result.pattern = pattern;
|
||||
|
|
@ -5408,7 +5425,16 @@ namespace ts {
|
|||
|
||||
function getTypeOfVariableOrParameterOrProperty(symbol: Symbol): Type {
|
||||
const links = getSymbolLinks(symbol);
|
||||
return links.type || (links.type = getTypeOfVariableOrParameterOrPropertyWorker(symbol));
|
||||
if (!links.type) {
|
||||
const type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
|
||||
// For a contextually typed parameter it is possible that a type has already
|
||||
// been assigned (in assignTypeToParameterAndFixTypeParameters), and we want
|
||||
// to preserve this type.
|
||||
if (!links.type) {
|
||||
links.type = type;
|
||||
}
|
||||
}
|
||||
return links.type;
|
||||
}
|
||||
|
||||
function getTypeOfVariableOrParameterOrPropertyWorker(symbol: Symbol) {
|
||||
|
|
@ -5452,7 +5478,7 @@ namespace ts {
|
|||
if (symbol.flags & SymbolFlags.ValueModule) {
|
||||
return getTypeOfFuncClassEnumModule(symbol);
|
||||
}
|
||||
return errorType;
|
||||
return reportCircularityError(symbol);
|
||||
}
|
||||
let type: Type | undefined;
|
||||
if (isInJSFile(declaration) &&
|
||||
|
|
@ -5511,7 +5537,7 @@ namespace ts {
|
|||
if (symbol.flags & SymbolFlags.ValueModule) {
|
||||
return getTypeOfFuncClassEnumModule(symbol);
|
||||
}
|
||||
type = reportCircularityError(symbol);
|
||||
return reportCircularityError(symbol);
|
||||
}
|
||||
return type;
|
||||
}
|
||||
|
|
@ -8540,14 +8566,14 @@ namespace ts {
|
|||
// It is only necessary to do so if a constituent type might be the undefined type, the null type, the type
|
||||
// of an object literal or the anyFunctionType. This is because there are operations in the type checker
|
||||
// that care about the presence of such types at arbitrary depth in a containing type.
|
||||
function getPropagatingFlagsOfTypes(types: ReadonlyArray<Type>, excludeKinds: TypeFlags): TypeFlags {
|
||||
let result: TypeFlags = 0;
|
||||
function getPropagatingFlagsOfTypes(types: ReadonlyArray<Type>, excludeKinds: TypeFlags): ObjectFlags {
|
||||
let result: ObjectFlags = 0;
|
||||
for (const type of types) {
|
||||
if (!(type.flags & excludeKinds)) {
|
||||
result |= type.flags;
|
||||
result |= getObjectFlags(type);
|
||||
}
|
||||
}
|
||||
return result & TypeFlags.PropagatingFlags;
|
||||
return result & ObjectFlags.PropagatingFlags;
|
||||
}
|
||||
|
||||
function createTypeReference(target: GenericType, typeArguments: ReadonlyArray<Type> | undefined): TypeReference {
|
||||
|
|
@ -8556,7 +8582,7 @@ namespace ts {
|
|||
if (!type) {
|
||||
type = <TypeReference>createObjectType(ObjectFlags.Reference, target.symbol);
|
||||
target.instantiations.set(id, type);
|
||||
type.flags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, /*excludeKinds*/ 0) : 0;
|
||||
type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments, /*excludeKinds*/ 0) : 0;
|
||||
type.target = target;
|
||||
type.typeArguments = typeArguments;
|
||||
}
|
||||
|
|
@ -9235,10 +9261,11 @@ namespace ts {
|
|||
// intersections of unit types into 'never' upon construction, but deferring the reduction makes it
|
||||
// easier to reason about their origin.
|
||||
if (!(flags & TypeFlags.Never || flags & TypeFlags.Intersection && isEmptyIntersectionType(<IntersectionType>type))) {
|
||||
includes |= flags & ~TypeFlags.ConstructionFlags;
|
||||
if (type === wildcardType) includes |= TypeFlags.Wildcard;
|
||||
includes |= flags & TypeFlags.IncludesMask;
|
||||
if (flags & TypeFlags.StructuredOrInstantiable) includes |= TypeFlags.IncludesStructuredOrInstantiable;
|
||||
if (type === wildcardType) includes |= TypeFlags.IncludesWildcard;
|
||||
if (!strictNullChecks && flags & TypeFlags.Nullable) {
|
||||
if (!(flags & TypeFlags.ContainsWideningType)) includes |= TypeFlags.NonWideningType;
|
||||
if (!(getObjectFlags(type) & ObjectFlags.ContainsWideningType)) includes |= TypeFlags.IncludesNonWideningType;
|
||||
}
|
||||
else {
|
||||
const len = typeSet.length;
|
||||
|
|
@ -9349,27 +9376,27 @@ namespace ts {
|
|||
const includes = addTypesToUnion(typeSet, 0, types);
|
||||
if (unionReduction !== UnionReduction.None) {
|
||||
if (includes & TypeFlags.AnyOrUnknown) {
|
||||
return includes & TypeFlags.Any ? includes & TypeFlags.Wildcard ? wildcardType : anyType : unknownType;
|
||||
return includes & TypeFlags.Any ? includes & TypeFlags.IncludesWildcard ? wildcardType : anyType : unknownType;
|
||||
}
|
||||
switch (unionReduction) {
|
||||
case UnionReduction.Literal:
|
||||
if (includes & TypeFlags.StringOrNumberLiteralOrUnique | TypeFlags.BooleanLiteral) {
|
||||
if (includes & (TypeFlags.Literal | TypeFlags.UniqueESSymbol)) {
|
||||
removeRedundantLiteralTypes(typeSet, includes);
|
||||
}
|
||||
break;
|
||||
case UnionReduction.Subtype:
|
||||
if (!removeSubtypes(typeSet, !(includes & TypeFlags.StructuredOrInstantiable))) {
|
||||
if (!removeSubtypes(typeSet, !(includes & TypeFlags.IncludesStructuredOrInstantiable))) {
|
||||
return errorType;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (typeSet.length === 0) {
|
||||
return includes & TypeFlags.Null ? includes & TypeFlags.NonWideningType ? nullType : nullWideningType :
|
||||
includes & TypeFlags.Undefined ? includes & TypeFlags.NonWideningType ? undefinedType : undefinedWideningType :
|
||||
return includes & TypeFlags.Null ? includes & TypeFlags.IncludesNonWideningType ? nullType : nullWideningType :
|
||||
includes & TypeFlags.Undefined ? includes & TypeFlags.IncludesNonWideningType ? undefinedType : undefinedWideningType :
|
||||
neverType;
|
||||
}
|
||||
}
|
||||
return getUnionTypeFromSortedList(typeSet, !(includes & TypeFlags.NotPrimitiveUnion), aliasSymbol, aliasTypeArguments);
|
||||
return getUnionTypeFromSortedList(typeSet, includes & TypeFlags.NotPrimitiveUnion ? 0 : ObjectFlags.PrimitiveUnion, aliasSymbol, aliasTypeArguments);
|
||||
}
|
||||
|
||||
function getUnionTypePredicate(signatures: ReadonlyArray<Signature>): TypePredicate | undefined {
|
||||
|
|
@ -9409,7 +9436,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
// This function assumes the constituent type list is sorted and deduplicated.
|
||||
function getUnionTypeFromSortedList(types: Type[], primitiveTypesOnly: boolean, aliasSymbol?: Symbol, aliasTypeArguments?: ReadonlyArray<Type>): Type {
|
||||
function getUnionTypeFromSortedList(types: Type[], objectFlags: ObjectFlags, aliasSymbol?: Symbol, aliasTypeArguments?: ReadonlyArray<Type>): Type {
|
||||
if (types.length === 0) {
|
||||
return neverType;
|
||||
}
|
||||
|
|
@ -9419,11 +9446,10 @@ namespace ts {
|
|||
const id = getTypeListId(types);
|
||||
let type = unionTypes.get(id);
|
||||
if (!type) {
|
||||
const propagatedFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
|
||||
type = <UnionType>createType(TypeFlags.Union | propagatedFlags);
|
||||
type = <UnionType>createType(TypeFlags.Union);
|
||||
unionTypes.set(id, type);
|
||||
type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
|
||||
type.types = types;
|
||||
type.primitiveTypesOnly = primitiveTypesOnly;
|
||||
/*
|
||||
Note: This is the alias symbol (or lack thereof) that we see when we first encounter this union type.
|
||||
For aliases of identical unions, eg `type T = A | B; type U = A | B`, the symbol of the first alias encountered is the aliasSymbol.
|
||||
|
|
@ -9452,15 +9478,15 @@ namespace ts {
|
|||
return addTypesToIntersection(typeSet, includes, (<IntersectionType>type).types);
|
||||
}
|
||||
if (isEmptyAnonymousObjectType(type)) {
|
||||
if (!(includes & TypeFlags.EmptyObject)) {
|
||||
includes |= TypeFlags.EmptyObject;
|
||||
if (!(includes & TypeFlags.IncludesEmptyObject)) {
|
||||
includes |= TypeFlags.IncludesEmptyObject;
|
||||
typeSet.push(type);
|
||||
}
|
||||
}
|
||||
else {
|
||||
includes |= flags & ~TypeFlags.ConstructionFlags;
|
||||
includes |= flags & TypeFlags.IncludesMask;
|
||||
if (flags & TypeFlags.AnyOrUnknown) {
|
||||
if (type === wildcardType) includes |= TypeFlags.Wildcard;
|
||||
if (type === wildcardType) includes |= TypeFlags.IncludesWildcard;
|
||||
}
|
||||
else if ((strictNullChecks || !(flags & TypeFlags.Nullable)) && !contains(typeSet, type)) {
|
||||
typeSet.push(type);
|
||||
|
|
@ -9518,7 +9544,7 @@ namespace ts {
|
|||
// other unions and return true. Otherwise, do nothing and return false.
|
||||
function intersectUnionsOfPrimitiveTypes(types: Type[]) {
|
||||
let unionTypes: UnionType[] | undefined;
|
||||
const index = findIndex(types, t => !!(t.flags & TypeFlags.Union) && (<UnionType>t).primitiveTypesOnly);
|
||||
const index = findIndex(types, t => !!(getObjectFlags(t) & ObjectFlags.PrimitiveUnion));
|
||||
if (index < 0) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -9527,7 +9553,7 @@ namespace ts {
|
|||
// the unionTypes array.
|
||||
while (i < types.length) {
|
||||
const t = types[i];
|
||||
if (t.flags & TypeFlags.Union && (<UnionType>t).primitiveTypesOnly) {
|
||||
if (getObjectFlags(t) & ObjectFlags.PrimitiveUnion) {
|
||||
(unionTypes || (unionTypes = [<UnionType>types[index]])).push(<UnionType>t);
|
||||
orderedRemoveItemAt(types, i);
|
||||
}
|
||||
|
|
@ -9554,7 +9580,7 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
// Finally replace the first union with the result
|
||||
types[index] = getUnionTypeFromSortedList(result, /*primitiveTypesOnly*/ true);
|
||||
types[index] = getUnionTypeFromSortedList(result, ObjectFlags.PrimitiveUnion);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -9575,7 +9601,7 @@ namespace ts {
|
|||
return neverType;
|
||||
}
|
||||
if (includes & TypeFlags.Any) {
|
||||
return includes & TypeFlags.Wildcard ? wildcardType : anyType;
|
||||
return includes & TypeFlags.IncludesWildcard ? wildcardType : anyType;
|
||||
}
|
||||
if (!strictNullChecks && includes & TypeFlags.Nullable) {
|
||||
return includes & TypeFlags.Undefined ? undefinedType : nullType;
|
||||
|
|
@ -9586,7 +9612,7 @@ namespace ts {
|
|||
includes & TypeFlags.ESSymbol && includes & TypeFlags.UniqueESSymbol) {
|
||||
removeRedundantPrimitiveTypes(typeSet, includes);
|
||||
}
|
||||
if (includes & TypeFlags.EmptyObject && includes & TypeFlags.Object) {
|
||||
if (includes & TypeFlags.IncludesEmptyObject && includes & TypeFlags.Object) {
|
||||
orderedRemoveItemAt(typeSet, findIndex(typeSet, isEmptyAnonymousObjectType));
|
||||
}
|
||||
if (typeSet.length === 0) {
|
||||
|
|
@ -9612,9 +9638,9 @@ namespace ts {
|
|||
const id = getTypeListId(typeSet);
|
||||
let type = intersectionTypes.get(id);
|
||||
if (!type) {
|
||||
const propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ TypeFlags.Nullable);
|
||||
type = <IntersectionType>createType(TypeFlags.Intersection | propagatedFlags);
|
||||
type = <IntersectionType>createType(TypeFlags.Intersection);
|
||||
intersectionTypes.set(id, type);
|
||||
type.objectFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ TypeFlags.Nullable);
|
||||
type.types = typeSet;
|
||||
type.aliasSymbol = aliasSymbol; // See comment in `getUnionTypeFromSortedList`.
|
||||
type.aliasTypeArguments = aliasTypeArguments;
|
||||
|
|
@ -10273,7 +10299,7 @@ namespace ts {
|
|||
* this function should be called in a left folding style, with left = previous result of getSpreadType
|
||||
* and right = the new element to be spread.
|
||||
*/
|
||||
function getSpreadType(left: Type, right: Type, symbol: Symbol | undefined, typeFlags: TypeFlags, objectFlags: ObjectFlags, readonly: boolean): Type {
|
||||
function getSpreadType(left: Type, right: Type, symbol: Symbol | undefined, objectFlags: ObjectFlags, readonly: boolean): Type {
|
||||
if (left.flags & TypeFlags.Any || right.flags & TypeFlags.Any) {
|
||||
return anyType;
|
||||
}
|
||||
|
|
@ -10287,10 +10313,10 @@ namespace ts {
|
|||
return left;
|
||||
}
|
||||
if (left.flags & TypeFlags.Union) {
|
||||
return mapType(left, t => getSpreadType(t, right, symbol, typeFlags, objectFlags, readonly));
|
||||
return mapType(left, t => getSpreadType(t, right, symbol, objectFlags, readonly));
|
||||
}
|
||||
if (right.flags & TypeFlags.Union) {
|
||||
return mapType(right, t => getSpreadType(left, t, symbol, typeFlags, objectFlags, readonly));
|
||||
return mapType(right, t => getSpreadType(left, t, symbol, objectFlags, readonly));
|
||||
}
|
||||
if (right.flags & (TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.BigIntLike | TypeFlags.StringLike | TypeFlags.EnumLike | TypeFlags.NonPrimitive | TypeFlags.Index)) {
|
||||
return left;
|
||||
|
|
@ -10307,7 +10333,7 @@ namespace ts {
|
|||
const types = (<IntersectionType>left).types;
|
||||
const lastLeft = types[types.length - 1];
|
||||
if (isNonGenericObjectType(lastLeft) && isNonGenericObjectType(right)) {
|
||||
return getIntersectionType(concatenate(types.slice(0, types.length - 1), [getSpreadType(lastLeft, right, symbol, typeFlags, objectFlags, readonly)]));
|
||||
return getIntersectionType(concatenate(types.slice(0, types.length - 1), [getSpreadType(lastLeft, right, symbol, objectFlags, readonly)]));
|
||||
}
|
||||
}
|
||||
return getIntersectionType([left, right]);
|
||||
|
|
@ -10367,8 +10393,7 @@ namespace ts {
|
|||
emptyArray,
|
||||
getIndexInfoWithReadonly(stringIndexInfo, readonly),
|
||||
getIndexInfoWithReadonly(numberIndexInfo, readonly));
|
||||
spread.flags |= TypeFlags.ContainsObjectLiteral | typeFlags;
|
||||
spread.objectFlags |= ObjectFlags.ObjectLiteral | ObjectFlags.ContainsSpread | objectFlags;
|
||||
spread.objectFlags |= ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectLiteral | ObjectFlags.ContainsSpread | objectFlags;
|
||||
return spread;
|
||||
}
|
||||
|
||||
|
|
@ -12570,6 +12595,7 @@ namespace ts {
|
|||
|
||||
let result: Ternary;
|
||||
let originalErrorInfo: DiagnosticMessageChain | undefined;
|
||||
let varianceCheckFailed = false;
|
||||
const saveErrorInfo = errorInfo;
|
||||
|
||||
// We limit alias variance probing to only object and conditional types since their alias behavior
|
||||
|
|
@ -12579,11 +12605,10 @@ namespace ts {
|
|||
source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol &&
|
||||
!(source.aliasTypeArgumentsContainsMarker || target.aliasTypeArgumentsContainsMarker)) {
|
||||
const variances = getAliasVariances(source.aliasSymbol);
|
||||
if (result = typeArgumentsRelatedTo(source.aliasTypeArguments, target.aliasTypeArguments, variances, reportErrors)) {
|
||||
return result;
|
||||
const varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances);
|
||||
if (varianceResult !== undefined) {
|
||||
return varianceResult;
|
||||
}
|
||||
originalErrorInfo = errorInfo;
|
||||
errorInfo = saveErrorInfo;
|
||||
}
|
||||
|
||||
if (target.flags & TypeFlags.TypeParameter) {
|
||||
|
|
@ -12748,31 +12773,9 @@ namespace ts {
|
|||
// type references (which are intended by be compared structurally). Obtain the variance
|
||||
// information for the type parameters and relate the type arguments accordingly.
|
||||
const variances = getVariances((<TypeReference>source).target);
|
||||
if (result = typeArgumentsRelatedTo((<TypeReference>source).typeArguments, (<TypeReference>target).typeArguments, variances, reportErrors)) {
|
||||
return result;
|
||||
}
|
||||
// The type arguments did not relate appropriately, but it may be because we have no variance
|
||||
// information (in which case typeArgumentsRelatedTo defaulted to covariance for all type
|
||||
// arguments). It might also be the case that the target type has a 'void' type argument for
|
||||
// a covariant type parameter that is only used in return positions within the generic type
|
||||
// (in which case any type argument is permitted on the source side). In those cases we proceed
|
||||
// with a structural comparison. Otherwise, we know for certain the instantiations aren't
|
||||
// related and we can return here.
|
||||
if (variances !== emptyArray && !hasCovariantVoidArgument(<TypeReference>target, variances)) {
|
||||
// In some cases generic types that are covariant in regular type checking mode become
|
||||
// invariant in --strictFunctionTypes mode because one or more type parameters are used in
|
||||
// both co- and contravariant positions. In order to make it easier to diagnose *why* such
|
||||
// types are invariant, if any of the type parameters are invariant we reset the reported
|
||||
// errors and instead force a structural comparison (which will include elaborations that
|
||||
// reveal the reason).
|
||||
if (!(reportErrors && some(variances, v => v === Variance.Invariant))) {
|
||||
return Ternary.False;
|
||||
}
|
||||
// We remember the original error information so we can restore it in case the structural
|
||||
// comparison unexpectedly succeeds. This can happen when the structural comparison result
|
||||
// is a Ternary.Maybe for example caused by the recursion depth limiter.
|
||||
originalErrorInfo = errorInfo;
|
||||
errorInfo = saveErrorInfo;
|
||||
const varianceResult = relateVariances((<TypeReference>source).typeArguments, (<TypeReference>target).typeArguments, variances);
|
||||
if (varianceResult !== undefined) {
|
||||
return varianceResult;
|
||||
}
|
||||
}
|
||||
else if (isReadonlyArrayType(target) ? isArrayType(source) || isTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) {
|
||||
|
|
@ -12799,16 +12802,48 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
}
|
||||
if (result) {
|
||||
if (!originalErrorInfo) {
|
||||
errorInfo = saveErrorInfo;
|
||||
return result;
|
||||
}
|
||||
errorInfo = originalErrorInfo;
|
||||
if (varianceCheckFailed && result) {
|
||||
errorInfo = originalErrorInfo || errorInfo || saveErrorInfo; // Use variance error (there is no structural one) and return false
|
||||
}
|
||||
else if (result) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
return Ternary.False;
|
||||
|
||||
function relateVariances(sourceTypeArguments: ReadonlyArray<Type> | undefined, targetTypeArguments: ReadonlyArray<Type> | undefined, variances: Variance[]) {
|
||||
if (result = typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, variances, reportErrors)) {
|
||||
return result;
|
||||
}
|
||||
const isCovariantVoid = targetTypeArguments && hasCovariantVoidArgument(targetTypeArguments, variances);
|
||||
varianceCheckFailed = !isCovariantVoid;
|
||||
// The type arguments did not relate appropriately, but it may be because we have no variance
|
||||
// information (in which case typeArgumentsRelatedTo defaulted to covariance for all type
|
||||
// arguments). It might also be the case that the target type has a 'void' type argument for
|
||||
// a covariant type parameter that is only used in return positions within the generic type
|
||||
// (in which case any type argument is permitted on the source side). In those cases we proceed
|
||||
// with a structural comparison. Otherwise, we know for certain the instantiations aren't
|
||||
// related and we can return here.
|
||||
if (variances !== emptyArray && !isCovariantVoid) {
|
||||
// In some cases generic types that are covariant in regular type checking mode become
|
||||
// invariant in --strictFunctionTypes mode because one or more type parameters are used in
|
||||
// both co- and contravariant positions. In order to make it easier to diagnose *why* such
|
||||
// types are invariant, if any of the type parameters are invariant we reset the reported
|
||||
// errors and instead force a structural comparison (which will include elaborations that
|
||||
// reveal the reason).
|
||||
// We can switch on `reportErrors` here, since varianceCheckFailed guarantees we return `False`,
|
||||
// we can return `False` early here to skip calculating the structural error message we don't need.
|
||||
if (varianceCheckFailed && !(reportErrors && some(variances, v => v === Variance.Invariant))) {
|
||||
return Ternary.False;
|
||||
}
|
||||
// We remember the original error information so we can restore it in case the structural
|
||||
// comparison unexpectedly succeeds. This can happen when the structural comparison result
|
||||
// is a Ternary.Maybe for example caused by the recursion depth limiter.
|
||||
originalErrorInfo = errorInfo;
|
||||
errorInfo = saveErrorInfo;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// A type [P in S]: X is related to a type [Q in T]: Y if T is related to S and X' is
|
||||
|
|
@ -13317,7 +13352,7 @@ namespace ts {
|
|||
|
||||
function getVariances(type: GenericType): Variance[] {
|
||||
// Arrays and tuples are known to be covariant, no need to spend time computing this (emptyArray implies covariance for all parameters)
|
||||
if (!strictFunctionTypes || type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & ObjectFlags.Tuple) {
|
||||
if (type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & ObjectFlags.Tuple) {
|
||||
return emptyArray;
|
||||
}
|
||||
return getVariancesWorker(type.typeParameters, type, getMarkerTypeReference);
|
||||
|
|
@ -13325,9 +13360,9 @@ namespace ts {
|
|||
|
||||
// Return true if the given type reference has a 'void' type argument for a covariant type parameter.
|
||||
// See comment at call in recursiveTypeRelatedTo for when this case matters.
|
||||
function hasCovariantVoidArgument(type: TypeReference, variances: Variance[]): boolean {
|
||||
function hasCovariantVoidArgument(typeArguments: ReadonlyArray<Type>, variances: Variance[]): boolean {
|
||||
for (let i = 0; i < variances.length; i++) {
|
||||
if (variances[i] === Variance.Covariant && type.typeArguments![i].flags & TypeFlags.Void) {
|
||||
if (variances[i] === Variance.Covariant && typeArguments[i].flags & TypeFlags.Void) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -13853,7 +13888,7 @@ namespace ts {
|
|||
resolved.stringIndexInfo,
|
||||
resolved.numberIndexInfo);
|
||||
regularNew.flags = resolved.flags;
|
||||
regularNew.objectFlags |= ObjectFlags.ObjectLiteral | (getObjectFlags(resolved) & ObjectFlags.JSLiteral);
|
||||
regularNew.objectFlags |= resolved.objectFlags & ~ObjectFlags.FreshLiteral;
|
||||
(<FreshObjectLiteralType>type).regularType = regularNew;
|
||||
return regularNew;
|
||||
}
|
||||
|
|
@ -13944,7 +13979,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function getWidenedTypeWithContext(type: Type, context: WideningContext | undefined): Type {
|
||||
if (type.flags & TypeFlags.RequiresWidening) {
|
||||
if (getObjectFlags(type) & ObjectFlags.RequiresWidening) {
|
||||
if (type.flags & TypeFlags.Nullable) {
|
||||
return anyType;
|
||||
}
|
||||
|
|
@ -13982,7 +14017,7 @@ namespace ts {
|
|||
*/
|
||||
function reportWideningErrorsInType(type: Type): boolean {
|
||||
let errorReported = false;
|
||||
if (type.flags & TypeFlags.ContainsWideningType) {
|
||||
if (getObjectFlags(type) & ObjectFlags.ContainsWideningType) {
|
||||
if (type.flags & TypeFlags.Union) {
|
||||
if (some((<UnionType>type).types, isEmptyObjectType)) {
|
||||
errorReported = true;
|
||||
|
|
@ -14005,7 +14040,7 @@ namespace ts {
|
|||
if (isObjectLiteralType(type)) {
|
||||
for (const p of getPropertiesOfObjectType(type)) {
|
||||
const t = getTypeOfSymbol(p);
|
||||
if (t.flags & TypeFlags.ContainsWideningType) {
|
||||
if (getObjectFlags(t) & ObjectFlags.ContainsWideningType) {
|
||||
if (!reportWideningErrorsInType(t)) {
|
||||
error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, symbolToString(p), typeToString(getWidenedType(t)));
|
||||
}
|
||||
|
|
@ -14080,7 +14115,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function reportErrorsFromWidening(declaration: Declaration, type: Type) {
|
||||
if (produceDiagnostics && noImplicitAny && type.flags & TypeFlags.ContainsWideningType) {
|
||||
if (produceDiagnostics && noImplicitAny && getObjectFlags(type) & ObjectFlags.ContainsWideningType) {
|
||||
// Report implicit any error within type if possible, otherwise report error on declaration
|
||||
if (!reportWideningErrorsInType(type)) {
|
||||
reportImplicitAny(declaration, type);
|
||||
|
|
@ -14225,7 +14260,7 @@ namespace ts {
|
|||
// If any property contains context sensitive functions that have been skipped, the source type
|
||||
// is incomplete and we can't infer a meaningful input type.
|
||||
for (const prop of properties) {
|
||||
if (getTypeOfSymbol(prop).flags & TypeFlags.ContainsAnyFunctionType) {
|
||||
if (getObjectFlags(getTypeOfSymbol(prop)) & ObjectFlags.ContainsAnyFunctionType) {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
|
@ -14383,7 +14418,7 @@ namespace ts {
|
|||
// not contain anyFunctionType when we come back to this argument for its second round
|
||||
// of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard
|
||||
// when constructing types from type parameters that had no inference candidates).
|
||||
if (source.flags & TypeFlags.ContainsAnyFunctionType || source === silentNeverType || (priority & InferencePriority.ReturnType && (source === autoType || source === autoArrayType))) {
|
||||
if (getObjectFlags(source) & ObjectFlags.ContainsAnyFunctionType || source === silentNeverType || (priority & InferencePriority.ReturnType && (source === autoType || source === autoArrayType))) {
|
||||
return;
|
||||
}
|
||||
const inference = getInferenceInfoForType(target);
|
||||
|
|
@ -14686,7 +14721,7 @@ namespace ts {
|
|||
const sourceLen = sourceSignatures.length;
|
||||
const targetLen = targetSignatures.length;
|
||||
const len = sourceLen < targetLen ? sourceLen : targetLen;
|
||||
const skipParameters = !!(source.flags & TypeFlags.ContainsAnyFunctionType);
|
||||
const skipParameters = !!(getObjectFlags(source) & ObjectFlags.ContainsAnyFunctionType);
|
||||
for (let i = 0; i < len; i++) {
|
||||
inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getBaseSignature(targetSignatures[targetLen - len + i]), skipParameters);
|
||||
}
|
||||
|
|
@ -15444,7 +15479,7 @@ namespace ts {
|
|||
if (type.flags & TypeFlags.Union) {
|
||||
const types = (<UnionType>type).types;
|
||||
const filtered = filter(types, f);
|
||||
return filtered === types ? type : getUnionTypeFromSortedList(filtered, (<UnionType>type).primitiveTypesOnly);
|
||||
return filtered === types ? type : getUnionTypeFromSortedList(filtered, (<UnionType>type).objectFlags);
|
||||
}
|
||||
return f(type) ? type : neverType;
|
||||
}
|
||||
|
|
@ -18350,7 +18385,6 @@ namespace ts {
|
|||
let propertiesTable: SymbolTable;
|
||||
let propertiesArray: Symbol[] = [];
|
||||
let spread: Type = emptyObjectType;
|
||||
let propagatedFlags: TypeFlags = 0;
|
||||
|
||||
const contextualType = getApparentTypeOfContextualType(node);
|
||||
const contextualTypeHasPattern = contextualType && contextualType.pattern &&
|
||||
|
|
@ -18360,7 +18394,7 @@ namespace ts {
|
|||
const isInJavascript = isInJSFile(node) && !isInJsonFile(node);
|
||||
const enumTag = getJSDocEnumTag(node);
|
||||
const isJSObjectLiteral = !contextualType && isInJavascript && !enumTag;
|
||||
let typeFlags: TypeFlags = 0;
|
||||
let objectFlags: ObjectFlags = freshObjectLiteralFlag;
|
||||
let patternWithComputedProperties = false;
|
||||
let hasComputedStringProperty = false;
|
||||
let hasComputedNumberProperty = false;
|
||||
|
|
@ -18388,7 +18422,7 @@ namespace ts {
|
|||
checkTypeAssignableTo(type, getTypeFromTypeNode(enumTag.typeExpression), memberDecl);
|
||||
}
|
||||
}
|
||||
typeFlags |= type.flags;
|
||||
objectFlags |= getObjectFlags(type) & ObjectFlags.PropagatingFlags;
|
||||
const nameType = computedNameType && isTypeUsableAsPropertyName(computedNameType) ? computedNameType : undefined;
|
||||
const prop = nameType ?
|
||||
createSymbol(SymbolFlags.Property | member.flags, getPropertyNameFromType(nameType), checkFlags | CheckFlags.Late) :
|
||||
|
|
@ -18436,19 +18470,18 @@ namespace ts {
|
|||
checkExternalEmitHelpers(memberDecl, ExternalEmitHelpers.Assign);
|
||||
}
|
||||
if (propertiesArray.length > 0) {
|
||||
spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags, ObjectFlags.FreshLiteral, inConstContext);
|
||||
spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext);
|
||||
propertiesArray = [];
|
||||
propertiesTable = createSymbolTable();
|
||||
hasComputedStringProperty = false;
|
||||
hasComputedNumberProperty = false;
|
||||
typeFlags = 0;
|
||||
}
|
||||
const type = checkExpression(memberDecl.expression);
|
||||
if (!isValidSpreadType(type)) {
|
||||
error(memberDecl, Diagnostics.Spread_types_may_only_be_created_from_object_types);
|
||||
return errorType;
|
||||
}
|
||||
spread = getSpreadType(spread, type, node.symbol, propagatedFlags, ObjectFlags.FreshLiteral, inConstContext);
|
||||
spread = getSpreadType(spread, type, node.symbol, objectFlags, inConstContext);
|
||||
offset = i + 1;
|
||||
continue;
|
||||
}
|
||||
|
|
@ -18498,7 +18531,7 @@ namespace ts {
|
|||
|
||||
if (spread !== emptyObjectType) {
|
||||
if (propertiesArray.length > 0) {
|
||||
spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, propagatedFlags, ObjectFlags.FreshLiteral, inConstContext);
|
||||
spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext);
|
||||
}
|
||||
return spread;
|
||||
}
|
||||
|
|
@ -18509,8 +18542,7 @@ namespace ts {
|
|||
const stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, IndexKind.String) : undefined;
|
||||
const numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, IndexKind.Number) : undefined;
|
||||
const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);
|
||||
result.flags |= TypeFlags.ContainsObjectLiteral | typeFlags & TypeFlags.PropagatingFlags;
|
||||
result.objectFlags |= ObjectFlags.ObjectLiteral | freshObjectLiteralFlag;
|
||||
result.objectFlags |= objectFlags | ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectLiteral;
|
||||
if (isJSObjectLiteral) {
|
||||
result.objectFlags |= ObjectFlags.JSLiteral;
|
||||
}
|
||||
|
|
@ -18520,7 +18552,6 @@ namespace ts {
|
|||
if (inDestructuringPattern) {
|
||||
result.pattern = node;
|
||||
}
|
||||
propagatedFlags |= result.flags & TypeFlags.PropagatingFlags;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
|
@ -18611,7 +18642,6 @@ namespace ts {
|
|||
let hasSpreadAnyType = false;
|
||||
let typeToIntersect: Type | undefined;
|
||||
let explicitlySpecifyChildrenAttribute = false;
|
||||
let typeFlags: TypeFlags = 0;
|
||||
let objectFlags: ObjectFlags = ObjectFlags.JsxAttributes;
|
||||
const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement));
|
||||
|
||||
|
|
@ -18619,7 +18649,7 @@ namespace ts {
|
|||
const member = attributeDecl.symbol;
|
||||
if (isJsxAttribute(attributeDecl)) {
|
||||
const exprType = checkJsxAttribute(attributeDecl, checkMode);
|
||||
typeFlags |= exprType.flags & TypeFlags.PropagatingFlags;
|
||||
objectFlags |= getObjectFlags(exprType) & ObjectFlags.PropagatingFlags;
|
||||
|
||||
const attributeSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.escapedName);
|
||||
attributeSymbol.declarations = member.declarations;
|
||||
|
|
@ -18637,7 +18667,7 @@ namespace ts {
|
|||
else {
|
||||
Debug.assert(attributeDecl.kind === SyntaxKind.JsxSpreadAttribute);
|
||||
if (attributesTable.size > 0) {
|
||||
spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, typeFlags, objectFlags, /*readonly*/ false);
|
||||
spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, /*readonly*/ false);
|
||||
attributesTable = createSymbolTable();
|
||||
}
|
||||
const exprType = checkExpressionCached(attributeDecl.expression, checkMode);
|
||||
|
|
@ -18645,7 +18675,7 @@ namespace ts {
|
|||
hasSpreadAnyType = true;
|
||||
}
|
||||
if (isValidSpreadType(exprType)) {
|
||||
spread = getSpreadType(spread, exprType, attributes.symbol, typeFlags, objectFlags, /*readonly*/ false);
|
||||
spread = getSpreadType(spread, exprType, attributes.symbol, objectFlags, /*readonly*/ false);
|
||||
}
|
||||
else {
|
||||
typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;
|
||||
|
|
@ -18655,7 +18685,7 @@ namespace ts {
|
|||
|
||||
if (!hasSpreadAnyType) {
|
||||
if (attributesTable.size > 0) {
|
||||
spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, typeFlags, objectFlags, /*readonly*/ false);
|
||||
spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, /*readonly*/ false);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -18687,7 +18717,7 @@ namespace ts {
|
|||
const childPropMap = createSymbolTable();
|
||||
childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol);
|
||||
spread = getSpreadType(spread, createAnonymousType(attributes.symbol, childPropMap, emptyArray, emptyArray, /*stringIndexInfo*/ undefined, /*numberIndexInfo*/ undefined),
|
||||
attributes.symbol, typeFlags, objectFlags, /*readonly*/ false);
|
||||
attributes.symbol, objectFlags, /*readonly*/ false);
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -18708,8 +18738,7 @@ namespace ts {
|
|||
function createJsxAttributesType() {
|
||||
objectFlags |= freshObjectLiteralFlag;
|
||||
const result = createAnonymousType(attributes.symbol, attributesTable, emptyArray, emptyArray, /*stringIndexInfo*/ undefined, /*numberIndexInfo*/ undefined);
|
||||
result.flags |= TypeFlags.ContainsObjectLiteral | typeFlags;
|
||||
result.objectFlags |= ObjectFlags.ObjectLiteral | objectFlags;
|
||||
result.objectFlags |= objectFlags | ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectLiteral;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
|
@ -21374,7 +21403,7 @@ namespace ts {
|
|||
const anonymousSymbol = createSymbol(SymbolFlags.TypeLiteral, InternalSymbolName.Type);
|
||||
const defaultContainingObject = createAnonymousType(anonymousSymbol, memberTable, emptyArray, emptyArray, /*stringIndexInfo*/ undefined, /*numberIndexInfo*/ undefined);
|
||||
anonymousSymbol.type = defaultContainingObject;
|
||||
synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, /*typeFLags*/ 0, /*objectFlags*/ 0, /*readonly*/ false) : defaultContainingObject;
|
||||
synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, /*objectFlags*/ 0, /*readonly*/ false) : defaultContainingObject;
|
||||
}
|
||||
else {
|
||||
synthType.syntheticType = type;
|
||||
|
|
@ -22052,7 +22081,7 @@ namespace ts {
|
|||
const returnType = getReturnTypeFromBody(node, checkMode);
|
||||
const returnOnlySignature = createSignature(undefined, undefined, undefined, emptyArray, returnType, /*resolvedTypePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);
|
||||
const returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], emptyArray, undefined, undefined);
|
||||
returnOnlyType.flags |= TypeFlags.ContainsAnyFunctionType;
|
||||
returnOnlyType.objectFlags |= ObjectFlags.ContainsAnyFunctionType;
|
||||
return links.contextFreeType = returnOnlyType;
|
||||
}
|
||||
return anyFunctionType;
|
||||
|
|
|
|||
|
|
@ -2581,6 +2581,10 @@
|
|||
"category": "Error",
|
||||
"code": 2748
|
||||
},
|
||||
"'{0}' refers to a value, but is being used as a type here.": {
|
||||
"category": "Error",
|
||||
"code": 2749
|
||||
},
|
||||
|
||||
"Import declaration '{0}' is using private name '{1}'.": {
|
||||
"category": "Error",
|
||||
|
|
|
|||
|
|
@ -632,7 +632,7 @@ namespace ts {
|
|||
getModifiedTime,
|
||||
setModifiedTime,
|
||||
deleteFile,
|
||||
createHash: _crypto ? createMD5HashUsingNativeCrypto : generateDjb2Hash,
|
||||
createHash: _crypto ? createSHA256Hash : generateDjb2Hash,
|
||||
createSHA256Hash: _crypto ? createSHA256Hash : undefined,
|
||||
getMemoryUsage() {
|
||||
if (global.gc) {
|
||||
|
|
@ -1125,12 +1125,6 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
function createMD5HashUsingNativeCrypto(data: string): string {
|
||||
const hash = _crypto!.createHash("md5");
|
||||
hash.update(data);
|
||||
return hash.digest("hex");
|
||||
}
|
||||
|
||||
function createSHA256Hash(data: string): string {
|
||||
const hash = _crypto!.createHash("sha256");
|
||||
hash.update(data);
|
||||
|
|
|
|||
|
|
@ -3881,39 +3881,33 @@ namespace ts {
|
|||
}
|
||||
|
||||
export const enum TypeFlags {
|
||||
Any = 1 << 0,
|
||||
Unknown = 1 << 1,
|
||||
String = 1 << 2,
|
||||
Number = 1 << 3,
|
||||
Boolean = 1 << 4,
|
||||
Enum = 1 << 5,
|
||||
BigInt = 1 << 6,
|
||||
StringLiteral = 1 << 7,
|
||||
NumberLiteral = 1 << 8,
|
||||
BooleanLiteral = 1 << 9,
|
||||
EnumLiteral = 1 << 10, // Always combined with StringLiteral, NumberLiteral, or Union
|
||||
BigIntLiteral = 1 << 11,
|
||||
ESSymbol = 1 << 12, // Type of symbol primitive introduced in ES6
|
||||
UniqueESSymbol = 1 << 13, // unique symbol
|
||||
Void = 1 << 14,
|
||||
Undefined = 1 << 15,
|
||||
Null = 1 << 16,
|
||||
Never = 1 << 17, // Never type
|
||||
TypeParameter = 1 << 18, // Type parameter
|
||||
Object = 1 << 19, // Object type
|
||||
Union = 1 << 20, // Union (T | U)
|
||||
Intersection = 1 << 21, // Intersection (T & U)
|
||||
Index = 1 << 22, // keyof T
|
||||
IndexedAccess = 1 << 23, // T[K]
|
||||
Conditional = 1 << 24, // T extends U ? X : Y
|
||||
Substitution = 1 << 25, // Type parameter substitution
|
||||
NonPrimitive = 1 << 26, // intrinsic object type
|
||||
/* @internal */
|
||||
ContainsWideningType = 1 << 27, // Type is or contains undefined or null widening type
|
||||
/* @internal */
|
||||
ContainsObjectLiteral = 1 << 28, // Type is or contains object literal type
|
||||
/* @internal */
|
||||
ContainsAnyFunctionType = 1 << 29, // Type is or contains the anyFunctionType
|
||||
Any = 1 << 0,
|
||||
Unknown = 1 << 1,
|
||||
String = 1 << 2,
|
||||
Number = 1 << 3,
|
||||
Boolean = 1 << 4,
|
||||
Enum = 1 << 5,
|
||||
BigInt = 1 << 6,
|
||||
StringLiteral = 1 << 7,
|
||||
NumberLiteral = 1 << 8,
|
||||
BooleanLiteral = 1 << 9,
|
||||
EnumLiteral = 1 << 10, // Always combined with StringLiteral, NumberLiteral, or Union
|
||||
BigIntLiteral = 1 << 11,
|
||||
ESSymbol = 1 << 12, // Type of symbol primitive introduced in ES6
|
||||
UniqueESSymbol = 1 << 13, // unique symbol
|
||||
Void = 1 << 14,
|
||||
Undefined = 1 << 15,
|
||||
Null = 1 << 16,
|
||||
Never = 1 << 17, // Never type
|
||||
TypeParameter = 1 << 18, // Type parameter
|
||||
Object = 1 << 19, // Object type
|
||||
Union = 1 << 20, // Union (T | U)
|
||||
Intersection = 1 << 21, // Intersection (T & U)
|
||||
Index = 1 << 22, // keyof T
|
||||
IndexedAccess = 1 << 23, // T[K]
|
||||
Conditional = 1 << 24, // T extends U ? X : Y
|
||||
Substitution = 1 << 25, // Type parameter substitution
|
||||
NonPrimitive = 1 << 26, // intrinsic object type
|
||||
|
||||
/* @internal */
|
||||
AnyOrUnknown = Any | Unknown,
|
||||
|
|
@ -3947,29 +3941,29 @@ namespace ts {
|
|||
InstantiablePrimitive = Index,
|
||||
Instantiable = InstantiableNonPrimitive | InstantiablePrimitive,
|
||||
StructuredOrInstantiable = StructuredType | Instantiable,
|
||||
|
||||
/* @internal */
|
||||
ObjectFlagsType = Nullable | Object | Union | Intersection,
|
||||
// 'Narrowable' types are types where narrowing actually narrows.
|
||||
// This *should* be every type other than null, undefined, void, and never
|
||||
Narrowable = Any | Unknown | StructuredOrInstantiable | StringLike | NumberLike | BigIntLike | BooleanLike | ESSymbol | UniqueESSymbol | NonPrimitive,
|
||||
NotUnionOrUnit = Any | Unknown | ESSymbol | Object | NonPrimitive,
|
||||
/* @internal */
|
||||
NotPrimitiveUnion = Any | Unknown | Enum | Void | Never | StructuredOrInstantiable,
|
||||
// The following flags are aggregated during union and intersection type construction
|
||||
/* @internal */
|
||||
RequiresWidening = ContainsWideningType | ContainsObjectLiteral,
|
||||
/* @internal */
|
||||
PropagatingFlags = ContainsWideningType | ContainsObjectLiteral | ContainsAnyFunctionType,
|
||||
IncludesMask = Any | Unknown | Primitive | Never | Object | Union,
|
||||
// The following flags are used for different purposes during union and intersection type construction
|
||||
/* @internal */
|
||||
NonWideningType = ContainsWideningType,
|
||||
IncludesStructuredOrInstantiable = TypeParameter,
|
||||
/* @internal */
|
||||
Wildcard = ContainsObjectLiteral,
|
||||
IncludesNonWideningType = Intersection,
|
||||
/* @internal */
|
||||
EmptyObject = ContainsAnyFunctionType,
|
||||
IncludesWildcard = Index,
|
||||
/* @internal */
|
||||
ConstructionFlags = NonWideningType | Wildcard | EmptyObject,
|
||||
IncludesEmptyObject = IndexedAccess,
|
||||
// The following flag is used for different purposes by maybeTypeOfKind
|
||||
/* @internal */
|
||||
GenericMappedType = ContainsWideningType
|
||||
GenericMappedType = Never,
|
||||
}
|
||||
|
||||
export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
|
||||
|
|
@ -3996,6 +3990,12 @@ namespace ts {
|
|||
// Intrinsic types (TypeFlags.Intrinsic)
|
||||
export interface IntrinsicType extends Type {
|
||||
intrinsicName: string; // Name of intrinsic type
|
||||
objectFlags: ObjectFlags;
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export interface NullableType extends IntrinsicType {
|
||||
objectFlags: ObjectFlags;
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
|
|
@ -4055,9 +4055,24 @@ namespace ts {
|
|||
MarkerType = 1 << 13, // Marker type used for variance probing
|
||||
JSLiteral = 1 << 14, // Object type declared in JS - disables errors on read/write of nonexisting members
|
||||
FreshLiteral = 1 << 15, // Fresh object literal
|
||||
ClassOrInterface = Class | Interface
|
||||
/* @internal */
|
||||
PrimitiveUnion = 1 << 16, // Union of only primitive types
|
||||
/* @internal */
|
||||
ContainsWideningType = 1 << 17, // Type is or contains undefined or null widening type
|
||||
/* @internal */
|
||||
ContainsObjectLiteral = 1 << 18, // Type is or contains object literal type
|
||||
/* @internal */
|
||||
ContainsAnyFunctionType = 1 << 19, // Type is or contains the anyFunctionType
|
||||
ClassOrInterface = Class | Interface,
|
||||
/* @internal */
|
||||
RequiresWidening = ContainsWideningType | ContainsObjectLiteral,
|
||||
/* @internal */
|
||||
PropagatingFlags = ContainsWideningType | ContainsObjectLiteral | ContainsAnyFunctionType
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export type ObjectFlagsType = NullableType | ObjectType | UnionType | IntersectionType;
|
||||
|
||||
// Object types (TypeFlags.ObjectType)
|
||||
export interface ObjectType extends Type {
|
||||
objectFlags: ObjectFlags;
|
||||
|
|
@ -4138,6 +4153,8 @@ namespace ts {
|
|||
export interface UnionOrIntersectionType extends Type {
|
||||
types: Type[]; // Constituent types
|
||||
/* @internal */
|
||||
objectFlags: ObjectFlags;
|
||||
/* @internal */
|
||||
propertyCache: SymbolTable; // Cache of resolved properties
|
||||
/* @internal */
|
||||
resolvedProperties: Symbol[];
|
||||
|
|
@ -4152,8 +4169,6 @@ namespace ts {
|
|||
}
|
||||
|
||||
export interface UnionType extends UnionOrIntersectionType {
|
||||
/* @internal */
|
||||
primitiveTypesOnly: boolean;
|
||||
}
|
||||
|
||||
export interface IntersectionType extends UnionOrIntersectionType {
|
||||
|
|
|
|||
|
|
@ -4520,7 +4520,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
export function getObjectFlags(type: Type): ObjectFlags {
|
||||
return type.flags & TypeFlags.Object ? (<ObjectType>type).objectFlags : 0;
|
||||
return type.flags & TypeFlags.ObjectFlagsType ? (<ObjectFlagsType>type).objectFlags : 0;
|
||||
}
|
||||
|
||||
export function typeHasCallOrConstructSignatures(type: Type, checker: TypeChecker) {
|
||||
|
|
|
|||
|
|
@ -361,9 +361,9 @@ namespace ts {
|
|||
function getWatchFactoryWith<X, Y = undefined>(watchLogLevel: WatchLogLevel, log: (s: string) => void, getDetailWatchInfo: GetDetailWatchInfo<X, Y> | undefined,
|
||||
watchFile: (host: WatchFileHost, file: string, callback: FileWatcherCallback, watchPriority: PollingInterval) => FileWatcher,
|
||||
watchDirectory: (host: WatchDirectoryHost, directory: string, callback: DirectoryWatcherCallback, flags: WatchDirectoryFlags) => FileWatcher): WatchFactory<X, Y> {
|
||||
const createFileWatcher: CreateFileWatcher<WatchFileHost, PollingInterval, FileWatcherEventKind, undefined, X, Y> = getCreateFileWatcher(watchLogLevel, watchFile);
|
||||
const createFileWatcher: CreateFileWatcher<WatchFileHost, PollingInterval, FileWatcherEventKind, never, X, Y> = getCreateFileWatcher(watchLogLevel, watchFile);
|
||||
const createFilePathWatcher: CreateFileWatcher<WatchFileHost, PollingInterval, FileWatcherEventKind, Path, X, Y> = watchLogLevel === WatchLogLevel.None ? watchFilePath : createFileWatcher;
|
||||
const createDirectoryWatcher: CreateFileWatcher<WatchDirectoryHost, WatchDirectoryFlags, undefined, undefined, X, Y> = getCreateFileWatcher(watchLogLevel, watchDirectory);
|
||||
const createDirectoryWatcher: CreateFileWatcher<WatchDirectoryHost, WatchDirectoryFlags, undefined, never, X, Y> = getCreateFileWatcher(watchLogLevel, watchDirectory);
|
||||
return {
|
||||
watchFile: (host, file, callback, pollingInterval, detailInfo1, detailInfo2) =>
|
||||
createFileWatcher(host, file, callback, pollingInterval, /*passThrough*/ undefined, detailInfo1, detailInfo2, watchFile, log, "FileWatcher", getDetailWatchInfo),
|
||||
|
|
@ -402,7 +402,7 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
function createFileWatcherWithLogging<H, T, U, V, X, Y>(host: H, file: string, cb: WatchCallback<U, V>, flags: T, passThrough: V | undefined, detailInfo1: X | undefined, detailInfo2: Y | undefined, addWatch: AddWatch<H, T, U, undefined>, log: (s: string) => void, watchCaption: string, getDetailWatchInfo: GetDetailWatchInfo<X, Y> | undefined): FileWatcher {
|
||||
function createFileWatcherWithLogging<H, T, U, V, X, Y>(host: H, file: string, cb: WatchCallback<U, V>, flags: T, passThrough: V | undefined, detailInfo1: X | undefined, detailInfo2: Y | undefined, addWatch: AddWatch<H, T, U, V>, log: (s: string) => void, watchCaption: string, getDetailWatchInfo: GetDetailWatchInfo<X, Y> | undefined): FileWatcher {
|
||||
log(`${watchCaption}:: Added:: ${getWatchInfo(file, flags, detailInfo1, detailInfo2, getDetailWatchInfo)}`);
|
||||
const watcher = createFileWatcherWithTriggerLogging(host, file, cb, flags, passThrough, detailInfo1, detailInfo2, addWatch, log, watchCaption, getDetailWatchInfo);
|
||||
return {
|
||||
|
|
@ -413,7 +413,7 @@ namespace ts {
|
|||
};
|
||||
}
|
||||
|
||||
function createDirectoryWatcherWithLogging<H, T, U, V, X, Y>(host: H, file: string, cb: WatchCallback<U, V>, flags: T, passThrough: V | undefined, detailInfo1: X | undefined, detailInfo2: Y | undefined, addWatch: AddWatch<H, T, U, undefined>, log: (s: string) => void, watchCaption: string, getDetailWatchInfo: GetDetailWatchInfo<X, Y> | undefined): FileWatcher {
|
||||
function createDirectoryWatcherWithLogging<H, T, U, V, X, Y>(host: H, file: string, cb: WatchCallback<U, V>, flags: T, passThrough: V | undefined, detailInfo1: X | undefined, detailInfo2: Y | undefined, addWatch: AddWatch<H, T, U, V>, log: (s: string) => void, watchCaption: string, getDetailWatchInfo: GetDetailWatchInfo<X, Y> | undefined): FileWatcher {
|
||||
const watchInfo = `${watchCaption}:: Added:: ${getWatchInfo(file, flags, detailInfo1, detailInfo2, getDetailWatchInfo)}`;
|
||||
log(watchInfo);
|
||||
const start = timestamp();
|
||||
|
|
@ -432,7 +432,7 @@ namespace ts {
|
|||
};
|
||||
}
|
||||
|
||||
function createFileWatcherWithTriggerLogging<H, T, U, V, X, Y>(host: H, file: string, cb: WatchCallback<U, V>, flags: T, passThrough: V | undefined, detailInfo1: X | undefined, detailInfo2: Y | undefined, addWatch: AddWatch<H, T, U, undefined>, log: (s: string) => void, watchCaption: string, getDetailWatchInfo: GetDetailWatchInfo<X, Y> | undefined): FileWatcher {
|
||||
function createFileWatcherWithTriggerLogging<H, T, U, V, X, Y>(host: H, file: string, cb: WatchCallback<U, V>, flags: T, passThrough: V | undefined, detailInfo1: X | undefined, detailInfo2: Y | undefined, addWatch: AddWatch<H, T, U, V>, log: (s: string) => void, watchCaption: string, getDetailWatchInfo: GetDetailWatchInfo<X, Y> | undefined): FileWatcher {
|
||||
return addWatch(host, file, (fileName, cbOptional) => {
|
||||
const triggerredInfo = `${watchCaption}:: Triggered with ${fileName} ${cbOptional !== undefined ? cbOptional : ""}:: ${getWatchInfo(file, flags, detailInfo1, detailInfo2, getDetailWatchInfo)}`;
|
||||
log(triggerredInfo);
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace Harness.Parallel.Host {
|
|||
const Base = Mocha.reporters.Base;
|
||||
const color = Base.color;
|
||||
const cursor = Base.cursor;
|
||||
const ms = require("mocha/lib/ms") as typeof import("mocha/lib/ms");
|
||||
const ms = require("ms") as typeof import("ms");
|
||||
const readline = require("readline") as typeof import("readline");
|
||||
const os = require("os") as typeof import("os");
|
||||
const tty = require("tty") as typeof import("tty");
|
||||
|
|
@ -530,6 +530,8 @@ namespace Harness.Parallel.Host {
|
|||
|
||||
const replayRunner = new Mocha.Runner(new Mocha.Suite(""), /*delay*/ false);
|
||||
replayRunner.started = true;
|
||||
const createStatsCollector = require("mocha/lib/stats-collector");
|
||||
createStatsCollector(replayRunner); // manually init stats collector like mocha.run would
|
||||
|
||||
const consoleReporter = new Base(replayRunner);
|
||||
patchStats(consoleReporter.stats);
|
||||
|
|
|
|||
|
|
@ -1684,9 +1684,9 @@ namespace ts.projectSystem {
|
|||
TI.getNpmCommandForInstallation(npmPath, tsVersion, packageNames, packageNames.length - Math.ceil(packageNames.length / 2)).command
|
||||
];
|
||||
it("works when the command is too long to install all packages at once", () => {
|
||||
const commands: string[] = [];
|
||||
const hasError = TI.installNpmPackages(npmPath, tsVersion, packageNames, command => {
|
||||
commands.push(command);
|
||||
const commands: [string, string[]][] = [];
|
||||
const hasError = TI.installNpmPackages(npmPath, tsVersion, packageNames, (file, args) => {
|
||||
commands.push([file, args]);
|
||||
return false;
|
||||
});
|
||||
assert.isFalse(hasError);
|
||||
|
|
@ -1694,9 +1694,9 @@ namespace ts.projectSystem {
|
|||
});
|
||||
|
||||
it("installs remaining packages when one of the partial command fails", () => {
|
||||
const commands: string[] = [];
|
||||
const hasError = TI.installNpmPackages(npmPath, tsVersion, packageNames, command => {
|
||||
commands.push(command);
|
||||
const commands: [string, string[]][] = [];
|
||||
const hasError = TI.installNpmPackages(npmPath, tsVersion, packageNames, (file, args) => {
|
||||
commands.push([file, args]);
|
||||
return commands.length === 1;
|
||||
});
|
||||
assert.isTrue(hasError);
|
||||
|
|
|
|||
|
|
@ -70,10 +70,10 @@ namespace ts.server.typingsInstaller {
|
|||
cwd: string;
|
||||
encoding: "utf-8";
|
||||
}
|
||||
type ExecSync = (command: string, options: ExecSyncOptions) => string;
|
||||
type ExecFileSync = (file: string, args: string[], options: ExecSyncOptions) => string;
|
||||
|
||||
export class NodeTypingsInstaller extends TypingsInstaller {
|
||||
private readonly nodeExecSync: ExecSync;
|
||||
private readonly nodeExecFileSync: ExecFileSync;
|
||||
private readonly npmPath: string;
|
||||
readonly typesRegistry: Map<MapLike<string>>;
|
||||
|
||||
|
|
@ -97,7 +97,7 @@ namespace ts.server.typingsInstaller {
|
|||
this.log.writeLine(`Process id: ${process.pid}`);
|
||||
this.log.writeLine(`NPM location: ${this.npmPath} (explicit '${Arguments.NpmLocation}' ${npmLocation === undefined ? "not " : ""} provided)`);
|
||||
}
|
||||
({ execSync: this.nodeExecSync } = require("child_process"));
|
||||
({ execFileSync: this.nodeExecFileSync } = require("child_process"));
|
||||
|
||||
this.ensurePackageDirectoryExists(globalTypingsCacheLocation);
|
||||
|
||||
|
|
@ -105,7 +105,7 @@ namespace ts.server.typingsInstaller {
|
|||
if (this.log.isEnabled()) {
|
||||
this.log.writeLine(`Updating ${typesRegistryPackageName} npm package...`);
|
||||
}
|
||||
this.execSyncAndLog(`${this.npmPath} install --ignore-scripts ${typesRegistryPackageName}@${this.latestDistTag}`, { cwd: globalTypingsCacheLocation });
|
||||
this.execFileSyncAndLog(this.npmPath, ["install", "--ignore-scripts", `${typesRegistryPackageName}@${this.latestDistTag}`], { cwd: globalTypingsCacheLocation });
|
||||
if (this.log.isEnabled()) {
|
||||
this.log.writeLine(`Updated ${typesRegistryPackageName} npm package`);
|
||||
}
|
||||
|
|
@ -189,7 +189,7 @@ namespace ts.server.typingsInstaller {
|
|||
this.log.writeLine(`#${requestId} with arguments'${JSON.stringify(packageNames)}'.`);
|
||||
}
|
||||
const start = Date.now();
|
||||
const hasError = installNpmPackages(this.npmPath, version, packageNames, command => this.execSyncAndLog(command, { cwd }));
|
||||
const hasError = installNpmPackages(this.npmPath, version, packageNames, (file, args) => this.execFileSyncAndLog(file, args, { cwd }));
|
||||
if (this.log.isEnabled()) {
|
||||
this.log.writeLine(`npm install #${requestId} took: ${Date.now() - start} ms`);
|
||||
}
|
||||
|
|
@ -197,12 +197,12 @@ namespace ts.server.typingsInstaller {
|
|||
}
|
||||
|
||||
/** Returns 'true' in case of error. */
|
||||
private execSyncAndLog(command: string, options: Pick<ExecSyncOptions, "cwd">): boolean {
|
||||
private execFileSyncAndLog(file: string, args: string[], options: Pick<ExecSyncOptions, "cwd">): boolean {
|
||||
if (this.log.isEnabled()) {
|
||||
this.log.writeLine(`Exec: ${command}`);
|
||||
this.log.writeLine(`Exec: ${file} ${args.join(" ")}`);
|
||||
}
|
||||
try {
|
||||
const stdout = this.nodeExecSync(command, { ...options, encoding: "utf-8" });
|
||||
const stdout = this.nodeExecFileSync(file, args, { ...options, encoding: "utf-8" });
|
||||
if (this.log.isEnabled()) {
|
||||
this.log.writeLine(` Succeeded. stdout:${indent(sys.newLine, stdout)}`);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,28 +31,35 @@ namespace ts.server.typingsInstaller {
|
|||
}
|
||||
|
||||
/*@internal*/
|
||||
export function installNpmPackages(npmPath: string, tsVersion: string, packageNames: string[], install: (command: string) => boolean) {
|
||||
export function installNpmPackages(npmPath: string, tsVersion: string, packageNames: string[], install: (file: string, args: string[]) => boolean) {
|
||||
let hasError = false;
|
||||
for (let remaining = packageNames.length; remaining > 0;) {
|
||||
const result = getNpmCommandForInstallation(npmPath, tsVersion, packageNames, remaining);
|
||||
remaining = result.remaining;
|
||||
hasError = install(result.command) || hasError;
|
||||
hasError = install(result.command[0], result.command[1]) || hasError;
|
||||
}
|
||||
return hasError;
|
||||
}
|
||||
|
||||
function getUserAgent(tsVersion: string) {
|
||||
return `--user-agent="typesInstaller/${tsVersion}"`;
|
||||
}
|
||||
const npmInstall = "install", ignoreScripts = "--ignore-scripts", saveDev = "--save-dev";
|
||||
const commandBaseLength = npmInstall.length + ignoreScripts.length + saveDev.length + getUserAgent("").length + 5;
|
||||
/*@internal*/
|
||||
export function getNpmCommandForInstallation(npmPath: string, tsVersion: string, packageNames: string[], remaining: number) {
|
||||
const sliceStart = packageNames.length - remaining;
|
||||
let command: string, toSlice = remaining;
|
||||
let packages: string[], toSlice = remaining;
|
||||
while (true) {
|
||||
command = `${npmPath} install --ignore-scripts ${(toSlice === packageNames.length ? packageNames : packageNames.slice(sliceStart, sliceStart + toSlice)).join(" ")} --save-dev --user-agent="typesInstaller/${tsVersion}"`;
|
||||
if (command.length < 8000) {
|
||||
packages = toSlice === packageNames.length ? packageNames : packageNames.slice(sliceStart, sliceStart + toSlice);
|
||||
const commandLength = npmPath.length + commandBaseLength + packages.join(" ").length + tsVersion.length;
|
||||
if (commandLength < 8000) {
|
||||
break;
|
||||
}
|
||||
|
||||
toSlice = toSlice - Math.floor(toSlice / 2);
|
||||
}
|
||||
const command: [string, string[]] = [npmPath, [npmInstall, ignoreScripts, ...packages, saveDev, getUserAgent(tsVersion)]];
|
||||
return { command, remaining: remaining - toSlice };
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
tests/cases/compiler/index.ts(4,1): error TS2693: 'zzz' only refers to a type, but is being used as a value here.
|
||||
tests/cases/compiler/index.ts(9,10): error TS2304: Cannot find name 'originalZZZ'.
|
||||
tests/cases/compiler/index.ts(9,10): error TS2749: 'originalZZZ' refers to a value, but is being used as a type here.
|
||||
|
||||
|
||||
==== tests/cases/compiler/b.ts (0 errors) ====
|
||||
|
|
@ -31,4 +31,4 @@ tests/cases/compiler/index.ts(9,10): error TS2304: Cannot find name 'originalZZZ
|
|||
|
||||
const y: originalZZZ = x;
|
||||
~~~~~~~~~~~
|
||||
!!! error TS2304: Cannot find name 'originalZZZ'.
|
||||
!!! error TS2749: 'originalZZZ' refers to a value, but is being used as a type here.
|
||||
|
|
@ -1,8 +1,8 @@
|
|||
tests/cases/compiler/callOverloads3.ts(1,10): error TS2300: Duplicate identifier 'Foo'.
|
||||
tests/cases/compiler/callOverloads3.ts(1,16): error TS2304: Cannot find name 'Foo'.
|
||||
tests/cases/compiler/callOverloads3.ts(1,16): error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/callOverloads3.ts(2,10): error TS2300: Duplicate identifier 'Foo'.
|
||||
tests/cases/compiler/callOverloads3.ts(2,10): error TS2391: Function implementation is missing or not immediately following the declaration.
|
||||
tests/cases/compiler/callOverloads3.ts(2,24): error TS2304: Cannot find name 'Foo'.
|
||||
tests/cases/compiler/callOverloads3.ts(2,24): error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/callOverloads3.ts(3,7): error TS2300: Duplicate identifier 'Foo'.
|
||||
tests/cases/compiler/callOverloads3.ts(11,10): error TS2350: Only a void function can be called with the 'new' keyword.
|
||||
|
||||
|
|
@ -12,14 +12,14 @@ tests/cases/compiler/callOverloads3.ts(11,10): error TS2350: Only a void functio
|
|||
~~~
|
||||
!!! error TS2300: Duplicate identifier 'Foo'.
|
||||
~~~
|
||||
!!! error TS2304: Cannot find name 'Foo'.
|
||||
!!! error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
function Foo(s:string):Foo; // error
|
||||
~~~
|
||||
!!! error TS2300: Duplicate identifier 'Foo'.
|
||||
~~~
|
||||
!!! error TS2391: Function implementation is missing or not immediately following the declaration.
|
||||
~~~
|
||||
!!! error TS2304: Cannot find name 'Foo'.
|
||||
!!! error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
class Foo { // error
|
||||
~~~
|
||||
!!! error TS2300: Duplicate identifier 'Foo'.
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
tests/cases/compiler/callOverloads4.ts(1,10): error TS2300: Duplicate identifier 'Foo'.
|
||||
tests/cases/compiler/callOverloads4.ts(1,16): error TS2304: Cannot find name 'Foo'.
|
||||
tests/cases/compiler/callOverloads4.ts(1,16): error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/callOverloads4.ts(2,10): error TS2300: Duplicate identifier 'Foo'.
|
||||
tests/cases/compiler/callOverloads4.ts(2,10): error TS2391: Function implementation is missing or not immediately following the declaration.
|
||||
tests/cases/compiler/callOverloads4.ts(2,24): error TS2304: Cannot find name 'Foo'.
|
||||
tests/cases/compiler/callOverloads4.ts(2,24): error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/callOverloads4.ts(3,7): error TS2300: Duplicate identifier 'Foo'.
|
||||
tests/cases/compiler/callOverloads4.ts(11,10): error TS2350: Only a void function can be called with the 'new' keyword.
|
||||
|
||||
|
|
@ -12,14 +12,14 @@ tests/cases/compiler/callOverloads4.ts(11,10): error TS2350: Only a void functio
|
|||
~~~
|
||||
!!! error TS2300: Duplicate identifier 'Foo'.
|
||||
~~~
|
||||
!!! error TS2304: Cannot find name 'Foo'.
|
||||
!!! error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
function Foo(s:string):Foo; // error
|
||||
~~~
|
||||
!!! error TS2300: Duplicate identifier 'Foo'.
|
||||
~~~
|
||||
!!! error TS2391: Function implementation is missing or not immediately following the declaration.
|
||||
~~~
|
||||
!!! error TS2304: Cannot find name 'Foo'.
|
||||
!!! error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
class Foo { // error
|
||||
~~~
|
||||
!!! error TS2300: Duplicate identifier 'Foo'.
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
tests/cases/compiler/callOverloads5.ts(1,10): error TS2300: Duplicate identifier 'Foo'.
|
||||
tests/cases/compiler/callOverloads5.ts(1,16): error TS2304: Cannot find name 'Foo'.
|
||||
tests/cases/compiler/callOverloads5.ts(1,16): error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/callOverloads5.ts(2,10): error TS2300: Duplicate identifier 'Foo'.
|
||||
tests/cases/compiler/callOverloads5.ts(2,10): error TS2391: Function implementation is missing or not immediately following the declaration.
|
||||
tests/cases/compiler/callOverloads5.ts(2,24): error TS2304: Cannot find name 'Foo'.
|
||||
tests/cases/compiler/callOverloads5.ts(2,24): error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/callOverloads5.ts(3,7): error TS2300: Duplicate identifier 'Foo'.
|
||||
tests/cases/compiler/callOverloads5.ts(13,10): error TS2350: Only a void function can be called with the 'new' keyword.
|
||||
|
||||
|
|
@ -12,14 +12,14 @@ tests/cases/compiler/callOverloads5.ts(13,10): error TS2350: Only a void functio
|
|||
~~~
|
||||
!!! error TS2300: Duplicate identifier 'Foo'.
|
||||
~~~
|
||||
!!! error TS2304: Cannot find name 'Foo'.
|
||||
!!! error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
function Foo(s:string):Foo; // error
|
||||
~~~
|
||||
!!! error TS2300: Duplicate identifier 'Foo'.
|
||||
~~~
|
||||
!!! error TS2391: Function implementation is missing or not immediately following the declaration.
|
||||
~~~
|
||||
!!! error TS2304: Cannot find name 'Foo'.
|
||||
!!! error TS2749: 'Foo' refers to a value, but is being used as a type here.
|
||||
class Foo { // error
|
||||
~~~
|
||||
!!! error TS2300: Duplicate identifier 'Foo'.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,32 @@
|
|||
tests/cases/compiler/checkInfiniteExpansionTermination.ts(16,1): error TS2322: Type 'ISubject<Bar>' is not assignable to type 'IObservable<Foo>'.
|
||||
Types of property 'n' are incompatible.
|
||||
Type 'IObservable<Bar[]>' is not assignable to type 'IObservable<Foo[]>'.
|
||||
Type 'Bar[]' is not assignable to type 'Foo[]'.
|
||||
Property 'x' is missing in type 'Bar' but required in type 'Foo'.
|
||||
|
||||
|
||||
==== tests/cases/compiler/checkInfiniteExpansionTermination.ts (1 errors) ====
|
||||
// Regression test for #1002
|
||||
// Before fix this code would cause infinite loop
|
||||
|
||||
interface IObservable<T> {
|
||||
n: IObservable<T[]>; // Needed, must be T[]
|
||||
}
|
||||
|
||||
// Needed
|
||||
interface ISubject<T> extends IObservable<T> { }
|
||||
|
||||
interface Foo { x }
|
||||
interface Bar { y }
|
||||
|
||||
var values: IObservable<Foo>;
|
||||
var values2: ISubject<Bar>;
|
||||
values = values2;
|
||||
~~~~~~
|
||||
!!! error TS2322: Type 'ISubject<Bar>' is not assignable to type 'IObservable<Foo>'.
|
||||
!!! error TS2322: Types of property 'n' are incompatible.
|
||||
!!! error TS2322: Type 'IObservable<Bar[]>' is not assignable to type 'IObservable<Foo[]>'.
|
||||
!!! error TS2322: Type 'Bar[]' is not assignable to type 'Foo[]'.
|
||||
!!! error TS2322: Property 'x' is missing in type 'Bar' but required in type 'Foo'.
|
||||
!!! related TS2728 tests/cases/compiler/checkInfiniteExpansionTermination.ts:11:17: 'x' is declared here.
|
||||
|
||||
|
|
@ -1137,7 +1137,7 @@ declare module Immutable {
|
|||
>Seq : typeof Seq
|
||||
|
||||
function isSeq(maybeSeq: any): maybeSeq is Seq.Indexed<any> | Seq.Keyed<any, any>;
|
||||
>isSeq : (maybeSeq: any) => maybeSeq is Keyed<any, any> | Indexed<any>
|
||||
>isSeq : (maybeSeq: any) => maybeSeq is Indexed<any> | Keyed<any, any>
|
||||
>maybeSeq : any
|
||||
>Seq : any
|
||||
>Seq : any
|
||||
|
|
|
|||
|
|
@ -17,8 +17,12 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(103,5): error TS2
|
|||
tests/cases/conformance/types/conditional/conditionalTypes1.ts(104,5): error TS2322: Type 'Pick<T, { [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]>' is not assignable to type 'T'.
|
||||
tests/cases/conformance/types/conditional/conditionalTypes1.ts(106,5): error TS2322: Type 'Pick<T, { [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]>' is not assignable to type 'Pick<T, { [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]>'.
|
||||
Type 'T[keyof T] extends Function ? keyof T : never' is not assignable to type 'T[keyof T] extends Function ? never : keyof T'.
|
||||
Type 'keyof T' is not assignable to type 'never'.
|
||||
Type 'string | number | symbol' is not assignable to type 'never'.
|
||||
Type 'string' is not assignable to type 'never'.
|
||||
tests/cases/conformance/types/conditional/conditionalTypes1.ts(108,5): error TS2322: Type 'Pick<T, { [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]>' is not assignable to type 'Pick<T, { [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]>'.
|
||||
Type 'T[keyof T] extends Function ? never : keyof T' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'.
|
||||
Type 'keyof T' is not assignable to type 'never'.
|
||||
tests/cases/conformance/types/conditional/conditionalTypes1.ts(114,5): error TS2322: Type 'keyof T' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'.
|
||||
Type 'string | number | symbol' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'.
|
||||
Type 'string' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'.
|
||||
|
|
@ -183,11 +187,15 @@ tests/cases/conformance/types/conditional/conditionalTypes1.ts(288,43): error TS
|
|||
~
|
||||
!!! error TS2322: Type 'Pick<T, { [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]>' is not assignable to type 'Pick<T, { [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]>'.
|
||||
!!! error TS2322: Type 'T[keyof T] extends Function ? keyof T : never' is not assignable to type 'T[keyof T] extends Function ? never : keyof T'.
|
||||
!!! error TS2322: Type 'keyof T' is not assignable to type 'never'.
|
||||
!!! error TS2322: Type 'string | number | symbol' is not assignable to type 'never'.
|
||||
!!! error TS2322: Type 'string' is not assignable to type 'never'.
|
||||
z = x;
|
||||
z = y; // Error
|
||||
~
|
||||
!!! error TS2322: Type 'Pick<T, { [K in keyof T]: T[K] extends Function ? K : never; }[keyof T]>' is not assignable to type 'Pick<T, { [K in keyof T]: T[K] extends Function ? never : K; }[keyof T]>'.
|
||||
!!! error TS2322: Type 'T[keyof T] extends Function ? never : keyof T' is not assignable to type 'T[keyof T] extends Function ? keyof T : never'.
|
||||
!!! error TS2322: Type 'keyof T' is not assignable to type 'never'.
|
||||
}
|
||||
|
||||
function f8<T>(x: keyof T, y: FunctionPropertyNames<T>, z: NonFunctionPropertyNames<T>) {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
tests/cases/compiler/constructorOverloads7.ts(1,15): error TS2300: Duplicate identifier 'Point'.
|
||||
tests/cases/compiler/constructorOverloads7.ts(7,35): error TS2304: Cannot find name 'Point'.
|
||||
tests/cases/compiler/constructorOverloads7.ts(8,14): error TS2304: Cannot find name 'Point'.
|
||||
tests/cases/compiler/constructorOverloads7.ts(7,35): error TS2749: 'Point' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/constructorOverloads7.ts(8,14): error TS2749: 'Point' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/constructorOverloads7.ts(15,10): error TS2300: Duplicate identifier 'Point'.
|
||||
tests/cases/compiler/constructorOverloads7.ts(22,18): error TS2384: Overload signatures must all be ambient or non-ambient.
|
||||
|
||||
|
|
@ -16,10 +16,10 @@ tests/cases/compiler/constructorOverloads7.ts(22,18): error TS2384: Overload sig
|
|||
|
||||
add(dx: number, dy: number): Point;
|
||||
~~~~~
|
||||
!!! error TS2304: Cannot find name 'Point'.
|
||||
!!! error TS2749: 'Point' refers to a value, but is being used as a type here.
|
||||
origin: Point;
|
||||
~~~~~
|
||||
!!! error TS2304: Cannot find name 'Point'.
|
||||
!!! error TS2749: 'Point' refers to a value, but is being used as a type here.
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
tests/cases/compiler/intrinsics.ts(1,21): error TS2304: Cannot find name 'hasOwnProperty'.
|
||||
tests/cases/compiler/intrinsics.ts(1,21): error TS2749: 'hasOwnProperty' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/intrinsics.ts(1,21): error TS4025: Exported variable 'hasOwnProperty' has or is using private name 'hasOwnProperty'.
|
||||
tests/cases/compiler/intrinsics.ts(10,1): error TS2304: Cannot find name '__proto__'.
|
||||
|
||||
|
|
@ -6,7 +6,7 @@ tests/cases/compiler/intrinsics.ts(10,1): error TS2304: Cannot find name '__prot
|
|||
==== tests/cases/compiler/intrinsics.ts (3 errors) ====
|
||||
var hasOwnProperty: hasOwnProperty; // Error
|
||||
~~~~~~~~~~~~~~
|
||||
!!! error TS2304: Cannot find name 'hasOwnProperty'.
|
||||
!!! error TS2749: 'hasOwnProperty' refers to a value, but is being used as a type here.
|
||||
~~~~~~~~~~~~~~
|
||||
!!! error TS4025: Exported variable 'hasOwnProperty' has or is using private name 'hasOwnProperty'.
|
||||
|
||||
|
|
|
|||
|
|
@ -4,11 +4,11 @@ export class StackOverflowTest {
|
|||
|
||||
constructor () {
|
||||
this.testStackOverflow = this.testStackOverflow.bind(this)
|
||||
>this.testStackOverflow = this.testStackOverflow.bind(this) : error
|
||||
>this.testStackOverflow = this.testStackOverflow.bind(this) : any
|
||||
>this.testStackOverflow : any
|
||||
>this : this
|
||||
>testStackOverflow : any
|
||||
>this.testStackOverflow.bind(this) : error
|
||||
>this.testStackOverflow.bind(this) : any
|
||||
>this.testStackOverflow.bind : any
|
||||
>this.testStackOverflow : any
|
||||
>this : this
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ tests/cases/compiler/index4.js(2,19): error TS2315: Type 'Function' is not gener
|
|||
tests/cases/compiler/index5.js(2,19): error TS2315: Type 'String' is not generic.
|
||||
tests/cases/compiler/index6.js(2,19): error TS2315: Type 'Number' is not generic.
|
||||
tests/cases/compiler/index7.js(2,19): error TS2315: Type 'Object' is not generic.
|
||||
tests/cases/compiler/index8.js(4,12): error TS2304: Cannot find name 'fn'.
|
||||
tests/cases/compiler/index8.js(4,12): error TS2749: 'fn' refers to a value, but is being used as a type here.
|
||||
tests/cases/compiler/index8.js(4,15): error TS2304: Cannot find name 'T'.
|
||||
|
||||
|
||||
|
|
@ -90,7 +90,7 @@ tests/cases/compiler/index8.js(4,15): error TS2304: Cannot find name 'T'.
|
|||
/**
|
||||
* @param {fn<T>} somebody
|
||||
~~
|
||||
!!! error TS2304: Cannot find name 'fn'.
|
||||
!!! error TS2749: 'fn' refers to a value, but is being used as a type here.
|
||||
~
|
||||
!!! error TS2304: Cannot find name 'T'.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -34,7 +34,9 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(66,5): error TS2
|
|||
tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(66,5): error TS2542: Index signature in type 'Readonly<U>' only permits reading.
|
||||
tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(72,5): error TS2322: Type 'Partial<T>' is not assignable to type 'T'.
|
||||
tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(78,5): error TS2322: Type 'Partial<Thing>' is not assignable to type 'Partial<T>'.
|
||||
Type 'Thing' is not assignable to type 'T'.
|
||||
tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(88,5): error TS2322: Type 'Readonly<Thing>' is not assignable to type 'Readonly<T>'.
|
||||
Type 'Thing' is not assignable to type 'T'.
|
||||
tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(127,5): error TS2322: Type 'Partial<U>' is not assignable to type 'Identity<U>'.
|
||||
tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(143,5): error TS2322: Type '{ [P in keyof T]: T[P]; }' is not assignable to type '{ [P in keyof T]: U[P]; }'.
|
||||
Type 'T[P]' is not assignable to type 'U[P]'.
|
||||
|
|
@ -197,6 +199,7 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(168,5): error TS
|
|||
y = x; // Error
|
||||
~
|
||||
!!! error TS2322: Type 'Partial<Thing>' is not assignable to type 'Partial<T>'.
|
||||
!!! error TS2322: Type 'Thing' is not assignable to type 'T'.
|
||||
}
|
||||
|
||||
function f40<T>(x: T, y: Readonly<T>) {
|
||||
|
|
@ -209,6 +212,7 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(168,5): error TS
|
|||
y = x; // Error
|
||||
~
|
||||
!!! error TS2322: Type 'Readonly<Thing>' is not assignable to type 'Readonly<T>'.
|
||||
!!! error TS2322: Type 'Thing' is not assignable to type 'T'.
|
||||
}
|
||||
|
||||
type Item = {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
tests/cases/conformance/types/mapped/mappedTypes5.ts(6,9): error TS2322: Type 'Partial<T>' is not assignable to type 'Readonly<T>'.
|
||||
tests/cases/conformance/types/mapped/mappedTypes5.ts(8,9): error TS2322: Type 'Partial<Readonly<T>>' is not assignable to type 'Readonly<T>'.
|
||||
tests/cases/conformance/types/mapped/mappedTypes5.ts(9,9): error TS2322: Type 'Readonly<Partial<T>>' is not assignable to type 'Readonly<T>'.
|
||||
Type 'Partial<T>' is not assignable to type 'T'.
|
||||
|
||||
|
||||
==== tests/cases/conformance/types/mapped/mappedTypes5.ts (3 errors) ====
|
||||
|
|
@ -19,6 +20,7 @@ tests/cases/conformance/types/mapped/mappedTypes5.ts(9,9): error TS2322: Type 'R
|
|||
let b4: Readonly<T> = rp; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Readonly<Partial<T>>' is not assignable to type 'Readonly<T>'.
|
||||
!!! error TS2322: Type 'Partial<T>' is not assignable to type 'T'.
|
||||
let c1: Partial<Readonly<T>> = p;
|
||||
let c2: Partial<Readonly<T>> = r;
|
||||
let c3: Partial<Readonly<T>> = pr;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguityWithBinaryOperator4.ts(3,9): error TS2347: Untyped function calls may not accept type arguments.
|
||||
tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguityWithBinaryOperator4.ts(3,11): error TS2304: Cannot find name 'b'.
|
||||
tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguityWithBinaryOperator4.ts(3,14): error TS2304: Cannot find name 'b'.
|
||||
tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguityWithBinaryOperator4.ts(3,11): error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguityWithBinaryOperator4.ts(3,14): error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
|
||||
|
||||
==== tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguityWithBinaryOperator4.ts (3 errors) ====
|
||||
|
|
@ -10,7 +10,7 @@ tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguityWithBinaryOpe
|
|||
~~~~~~~~~~~~~~
|
||||
!!! error TS2347: Untyped function calls may not accept type arguments.
|
||||
~
|
||||
!!! error TS2304: Cannot find name 'b'.
|
||||
!!! error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
~
|
||||
!!! error TS2304: Cannot find name 'b'.
|
||||
!!! error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
}
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
=== tests/cases/conformance/parser/ecmascript5/Statements/parserES5ForOfStatement18.ts ===
|
||||
for (var of of of) { }
|
||||
>of : any
|
||||
>of : error
|
||||
>of : any
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
=== tests/cases/conformance/parser/ecmascript5/Statements/parserES5ForOfStatement19.ts ===
|
||||
for (var of in of) { }
|
||||
>of : any
|
||||
>of : error
|
||||
>of : any
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
=== tests/cases/conformance/parser/ecmascript6/Iterators/parserForOfStatement18.ts ===
|
||||
for (var of of of) { }
|
||||
>of : any
|
||||
>of : error
|
||||
>of : any
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
=== tests/cases/conformance/parser/ecmascript6/Iterators/parserForOfStatement19.ts ===
|
||||
for (var of in of) { }
|
||||
>of : any
|
||||
>of : error
|
||||
>of : any
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ salt.pepper = function() {}
|
|||
|
||||
var cobalt = new cobalt.pitch();
|
||||
>cobalt : any
|
||||
>new cobalt.pitch() : error
|
||||
>new cobalt.pitch() : any
|
||||
>cobalt.pitch : any
|
||||
>cobalt : any
|
||||
>pitch : any
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ import self = require("recursiveExportAssignmentAndFindAliasedType7_moduleD");
|
|||
|
||||
var selfVar = self;
|
||||
>selfVar : any
|
||||
>self : error
|
||||
>self : any
|
||||
|
||||
export = selfVar;
|
||||
>selfVar : any
|
||||
|
|
|
|||
27
tests/baselines/reference/recursiveTypeComparison.errors.txt
Normal file
27
tests/baselines/reference/recursiveTypeComparison.errors.txt
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
tests/cases/compiler/recursiveTypeComparison.ts(14,5): error TS2322: Type 'Observable<{}>' is not assignable to type 'Property<number>'.
|
||||
Types of property 'needThisOne' are incompatible.
|
||||
Type 'Observable<{}>' is not assignable to type 'Observable<number>'.
|
||||
Type '{}' is not assignable to type 'number'.
|
||||
|
||||
|
||||
==== tests/cases/compiler/recursiveTypeComparison.ts (1 errors) ====
|
||||
// Before fix this would take an exceeding long time to complete (#1170)
|
||||
|
||||
interface Observable<T> {
|
||||
// This member can't be of type T, Property<T>, or Observable<anything but T>
|
||||
needThisOne: Observable<T>;
|
||||
// Add more to make it slower
|
||||
expo1: Property<T[]>; // 0.31 seconds in check
|
||||
expo2: Property<T[]>; // 3.11 seconds
|
||||
expo3: Property<T[]>; // 82.28 seconds
|
||||
}
|
||||
interface Property<T> extends Observable<T> { }
|
||||
|
||||
var p: Observable<{}>;
|
||||
var stuck: Property<number> = p;
|
||||
~~~~~
|
||||
!!! error TS2322: Type 'Observable<{}>' is not assignable to type 'Property<number>'.
|
||||
!!! error TS2322: Types of property 'needThisOne' are incompatible.
|
||||
!!! error TS2322: Type 'Observable<{}>' is not assignable to type 'Observable<number>'.
|
||||
!!! error TS2322: Type '{}' is not assignable to type 'number'.
|
||||
|
||||
|
|
@ -17,19 +17,15 @@ tests/cases/compiler/strictFunctionTypesErrors.ts(21,1): error TS2322: Type '(x:
|
|||
tests/cases/compiler/strictFunctionTypesErrors.ts(23,1): error TS2322: Type '(x: string) => Object' is not assignable to type '(x: string) => string'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(33,1): error TS2322: Type 'Func<string, Object>' is not assignable to type 'Func<Object, Object>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(34,1): error TS2322: Type 'Func<string, string>' is not assignable to type 'Func<Object, Object>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(36,1): error TS2322: Type 'Func<Object, Object>' is not assignable to type 'Func<Object, string>'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(37,1): error TS2322: Type 'Func<string, Object>' is not assignable to type 'Func<Object, string>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(38,1): error TS2322: Type 'Func<string, string>' is not assignable to type 'Func<Object, string>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(44,1): error TS2322: Type 'Func<Object, Object>' is not assignable to type 'Func<string, string>'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(46,1): error TS2322: Type 'Func<string, Object>' is not assignable to type 'Func<string, string>'.
|
||||
|
|
@ -39,37 +35,26 @@ tests/cases/compiler/strictFunctionTypesErrors.ts(57,1): error TS2322: Type 'Fun
|
|||
tests/cases/compiler/strictFunctionTypesErrors.ts(58,1): error TS2322: Type 'Func<Func<string, void>, Object>' is not assignable to type 'Func<Func<Object, void>, string>'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(61,1): error TS2322: Type 'Func<Func<Object, void>, Object>' is not assignable to type 'Func<Func<string, void>, Object>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(62,1): error TS2322: Type 'Func<Func<Object, void>, string>' is not assignable to type 'Func<Func<string, void>, Object>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(65,1): error TS2322: Type 'Func<Func<Object, void>, Object>' is not assignable to type 'Func<Func<string, void>, string>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(66,1): error TS2322: Type 'Func<Func<Object, void>, string>' is not assignable to type 'Func<Func<string, void>, string>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(67,1): error TS2322: Type 'Func<Func<string, void>, Object>' is not assignable to type 'Func<Func<string, void>, string>'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(74,1): error TS2322: Type 'Func<Object, Func<string, void>>' is not assignable to type 'Func<Object, Func<Object, void>>'.
|
||||
Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(75,1): error TS2322: Type 'Func<string, Func<Object, void>>' is not assignable to type 'Func<Object, Func<Object, void>>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(76,1): error TS2322: Type 'Func<string, Func<string, void>>' is not assignable to type 'Func<Object, Func<Object, void>>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(79,1): error TS2322: Type 'Func<string, Func<Object, void>>' is not assignable to type 'Func<Object, Func<string, void>>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(80,1): error TS2322: Type 'Func<string, Func<string, void>>' is not assignable to type 'Func<Object, Func<string, void>>'.
|
||||
Types of parameters 'x' and 'x' are incompatible.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
Type 'Object' is not assignable to type 'string'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(83,1): error TS2322: Type 'Func<Object, Func<string, void>>' is not assignable to type 'Func<string, Func<Object, void>>'.
|
||||
Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
tests/cases/compiler/strictFunctionTypesErrors.ts(84,1): error TS2322: Type 'Func<string, Func<string, void>>' is not assignable to type 'Func<string, Func<Object, void>>'.
|
||||
|
|
@ -162,13 +147,11 @@ tests/cases/compiler/strictFunctionTypesErrors.ts(155,5): error TS2322: Type '(c
|
|||
g1 = g3; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<string, Object>' is not assignable to type 'Func<Object, Object>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
g1 = g4; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<string, string>' is not assignable to type 'Func<Object, Object>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
|
||||
g2 = g1; // Error
|
||||
~~
|
||||
|
|
@ -177,13 +160,11 @@ tests/cases/compiler/strictFunctionTypesErrors.ts(155,5): error TS2322: Type '(c
|
|||
g2 = g3; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<string, Object>' is not assignable to type 'Func<Object, string>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
g2 = g4; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<string, string>' is not assignable to type 'Func<Object, string>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
|
||||
g3 = g1; // Ok
|
||||
g3 = g2; // Ok
|
||||
|
|
@ -221,29 +202,22 @@ tests/cases/compiler/strictFunctionTypesErrors.ts(155,5): error TS2322: Type '(c
|
|||
h3 = h1; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<Func<Object, void>, Object>' is not assignable to type 'Func<Func<string, void>, Object>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
h3 = h2; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<Func<Object, void>, string>' is not assignable to type 'Func<Func<string, void>, Object>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
h3 = h4; // Ok
|
||||
|
||||
h4 = h1; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<Func<Object, void>, Object>' is not assignable to type 'Func<Func<string, void>, string>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
h4 = h2; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<Func<Object, void>, string>' is not assignable to type 'Func<Func<string, void>, string>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Func<string, void>' is not assignable to type 'Func<Object, void>'.
|
||||
h4 = h3; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<Func<string, void>, Object>' is not assignable to type 'Func<Func<string, void>, string>'.
|
||||
|
|
@ -261,25 +235,21 @@ tests/cases/compiler/strictFunctionTypesErrors.ts(155,5): error TS2322: Type '(c
|
|||
i1 = i3; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<string, Func<Object, void>>' is not assignable to type 'Func<Object, Func<Object, void>>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
i1 = i4; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<string, Func<string, void>>' is not assignable to type 'Func<Object, Func<Object, void>>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
|
||||
i2 = i1; // Ok
|
||||
i2 = i3; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<string, Func<Object, void>>' is not assignable to type 'Func<Object, Func<string, void>>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
i2 = i4; // Error
|
||||
~~
|
||||
!!! error TS2322: Type 'Func<string, Func<string, void>>' is not assignable to type 'Func<Object, Func<string, void>>'.
|
||||
!!! error TS2322: Types of parameters 'x' and 'x' are incompatible.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
!!! error TS2322: Type 'Object' is not assignable to type 'string'.
|
||||
|
||||
i3 = i1; // Ok
|
||||
i3 = i2; // Error
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(37,13): err
|
|||
Property 'q' is missing in type 'SomeDerived' but required in type 'SomeOther'.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(38,13): error TS2352: Conversion of type 'SomeBase' to type 'SomeOther' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.
|
||||
Property 'q' is missing in type 'SomeBase' but required in type 'SomeOther'.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(44,5): error TS2304: Cannot find name 'numOrStr'.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(44,5): error TS2749: 'numOrStr' refers to a value, but is being used as a type here.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(44,14): error TS1005: '>' expected.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(44,14): error TS2304: Cannot find name 'is'.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(44,17): error TS1005: ')' expected.
|
||||
|
|
@ -15,7 +15,7 @@ tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(44,17): err
|
|||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(44,48): error TS1005: ';' expected.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(45,2): error TS2322: Type 'string | number' is not assignable to type 'string'.
|
||||
Type 'number' is not assignable to type 'string'.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(48,32): error TS2304: Cannot find name 'numOrStr'.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(48,32): error TS2749: 'numOrStr' refers to a value, but is being used as a type here.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(48,41): error TS1005: ')' expected.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(48,41): error TS2304: Cannot find name 'is'.
|
||||
tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(48,44): error TS1005: ';' expected.
|
||||
|
|
@ -86,7 +86,7 @@ tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(48,50): err
|
|||
var str: string;
|
||||
if(<numOrStr is string>(numOrStr === undefined)) { // Error
|
||||
~~~~~~~~
|
||||
!!! error TS2304: Cannot find name 'numOrStr'.
|
||||
!!! error TS2749: 'numOrStr' refers to a value, but is being used as a type here.
|
||||
~~
|
||||
!!! error TS1005: '>' expected.
|
||||
~~
|
||||
|
|
@ -105,7 +105,7 @@ tests/cases/conformance/expressions/typeAssertions/typeAssertions.ts(48,50): err
|
|||
|
||||
if((numOrStr === undefined) as numOrStr is string) { // Error
|
||||
~~~~~~~~
|
||||
!!! error TS2304: Cannot find name 'numOrStr'.
|
||||
!!! error TS2749: 'numOrStr' refers to a value, but is being used as a type here.
|
||||
~~
|
||||
!!! error TS1005: ')' expected.
|
||||
~~
|
||||
|
|
|
|||
|
|
@ -1,10 +1,10 @@
|
|||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(1,7): error TS2300: Duplicate identifier 'A'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(14,5): error TS2322: Type '""' is not assignable to type 'boolean'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(17,55): error TS2304: Cannot find name 'x'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(17,55): error TS2749: 'x' refers to a value, but is being used as a type here.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(17,57): error TS1144: '{' or ';' expected.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(17,60): error TS1005: ';' expected.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(17,62): error TS1005: ';' expected.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(21,33): error TS2304: Cannot find name 'x'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(21,33): error TS2749: 'x' refers to a value, but is being used as a type here.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(25,33): error TS1225: Cannot find parameter 'x'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(29,10): error TS2391: Function implementation is missing or not immediately following the declaration.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(30,5): error TS1131: Property or signature expected.
|
||||
|
|
@ -28,14 +28,14 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(84,1):
|
|||
Type predicate 'p2 is A' is not assignable to 'p1 is A'.
|
||||
Parameter 'p2' is not in the same position as parameter 'p1'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(90,1): error TS2322: Type '(p1: any, p2: any, p3: any) => p1 is A' is not assignable to type '(p1: any, p2: any) => p1 is A'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(95,9): error TS2304: Cannot find name 'b'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(95,9): error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(95,11): error TS1005: ',' expected.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(95,14): error TS1005: ',' expected.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(95,14): error TS2300: Duplicate identifier 'A'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(96,16): error TS2304: Cannot find name 'b'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(96,16): error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(96,18): error TS1005: ',' expected.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(96,21): error TS1005: ',' expected.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(97,20): error TS2304: Cannot find name 'b'.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(97,20): error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(97,22): error TS1144: '{' or ';' expected.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(97,25): error TS1005: ';' expected.
|
||||
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(97,27): error TS1005: ';' expected.
|
||||
|
|
@ -91,7 +91,7 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(166,54
|
|||
|
||||
function hasTypeGuardTypeInsideTypeGuardType(x): x is x is A {
|
||||
~
|
||||
!!! error TS2304: Cannot find name 'x'.
|
||||
!!! error TS2749: 'x' refers to a value, but is being used as a type here.
|
||||
~~
|
||||
!!! error TS1144: '{' or ';' expected.
|
||||
~
|
||||
|
|
@ -103,7 +103,7 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(166,54
|
|||
|
||||
function hasMissingIsKeyword(): x {
|
||||
~
|
||||
!!! error TS2304: Cannot find name 'x'.
|
||||
!!! error TS2749: 'x' refers to a value, but is being used as a type here.
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -222,7 +222,7 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(166,54
|
|||
// Type predicates in non-return type positions
|
||||
var b1: b is A;
|
||||
~
|
||||
!!! error TS2304: Cannot find name 'b'.
|
||||
!!! error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
~~
|
||||
!!! error TS1005: ',' expected.
|
||||
~
|
||||
|
|
@ -231,14 +231,14 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(166,54
|
|||
!!! error TS2300: Duplicate identifier 'A'.
|
||||
function b2(a: b is A) {};
|
||||
~
|
||||
!!! error TS2304: Cannot find name 'b'.
|
||||
!!! error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
~~
|
||||
!!! error TS1005: ',' expected.
|
||||
~
|
||||
!!! error TS1005: ',' expected.
|
||||
function b3(): A | b is A {
|
||||
~
|
||||
!!! error TS2304: Cannot find name 'b'.
|
||||
!!! error TS2749: 'b' refers to a value, but is being used as a type here.
|
||||
~~
|
||||
!!! error TS1144: '{' or ';' expected.
|
||||
~
|
||||
|
|
|
|||
|
|
@ -9,16 +9,13 @@ tests/cases/compiler/unionTypeErrorMessageTypeRefs01.ts(27,1): error TS2322: Typ
|
|||
Property 'kwah' is missing in type 'Foo' but required in type 'Kwah'.
|
||||
tests/cases/compiler/unionTypeErrorMessageTypeRefs01.ts(48,1): error TS2322: Type 'X<Foo>' is not assignable to type 'X<Bar> | Y<Baz> | Z<Kwah>'.
|
||||
Type 'X<Foo>' is not assignable to type 'X<Bar>'.
|
||||
Types of property 'xProp' are incompatible.
|
||||
Type 'Foo' is not assignable to type 'Bar'.
|
||||
Type 'Foo' is not assignable to type 'Bar'.
|
||||
tests/cases/compiler/unionTypeErrorMessageTypeRefs01.ts(49,1): error TS2322: Type 'Y<Foo>' is not assignable to type 'X<Bar> | Y<Baz> | Z<Kwah>'.
|
||||
Type 'Y<Foo>' is not assignable to type 'Y<Baz>'.
|
||||
Types of property 'yProp' are incompatible.
|
||||
Type 'Foo' is not assignable to type 'Baz'.
|
||||
Type 'Foo' is not assignable to type 'Baz'.
|
||||
tests/cases/compiler/unionTypeErrorMessageTypeRefs01.ts(50,1): error TS2322: Type 'Z<Foo>' is not assignable to type 'X<Bar> | Y<Baz> | Z<Kwah>'.
|
||||
Type 'Z<Foo>' is not assignable to type 'Z<Kwah>'.
|
||||
Types of property 'zProp' are incompatible.
|
||||
Type 'Foo' is not assignable to type 'Kwah'.
|
||||
Type 'Foo' is not assignable to type 'Kwah'.
|
||||
|
||||
|
||||
==== tests/cases/compiler/unionTypeErrorMessageTypeRefs01.ts (6 errors) ====
|
||||
|
|
@ -88,17 +85,14 @@ tests/cases/compiler/unionTypeErrorMessageTypeRefs01.ts(50,1): error TS2322: Typ
|
|||
~~~~~~~~~~~~~~~~~~
|
||||
!!! error TS2322: Type 'X<Foo>' is not assignable to type 'X<Bar> | Y<Baz> | Z<Kwah>'.
|
||||
!!! error TS2322: Type 'X<Foo>' is not assignable to type 'X<Bar>'.
|
||||
!!! error TS2322: Types of property 'xProp' are incompatible.
|
||||
!!! error TS2322: Type 'Foo' is not assignable to type 'Bar'.
|
||||
!!! error TS2322: Type 'Foo' is not assignable to type 'Bar'.
|
||||
thingOfTypeAliases = y;
|
||||
~~~~~~~~~~~~~~~~~~
|
||||
!!! error TS2322: Type 'Y<Foo>' is not assignable to type 'X<Bar> | Y<Baz> | Z<Kwah>'.
|
||||
!!! error TS2322: Type 'Y<Foo>' is not assignable to type 'Y<Baz>'.
|
||||
!!! error TS2322: Types of property 'yProp' are incompatible.
|
||||
!!! error TS2322: Type 'Foo' is not assignable to type 'Baz'.
|
||||
!!! error TS2322: Type 'Foo' is not assignable to type 'Baz'.
|
||||
thingOfTypeAliases = z;
|
||||
~~~~~~~~~~~~~~~~~~
|
||||
!!! error TS2322: Type 'Z<Foo>' is not assignable to type 'X<Bar> | Y<Baz> | Z<Kwah>'.
|
||||
!!! error TS2322: Type 'Z<Foo>' is not assignable to type 'Z<Kwah>'.
|
||||
!!! error TS2322: Types of property 'zProp' are incompatible.
|
||||
!!! error TS2322: Type 'Foo' is not assignable to type 'Kwah'.
|
||||
!!! error TS2322: Type 'Foo' is not assignable to type 'Kwah'.
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts(63,6): error TS2345: Argument of type 'NeededInfo<ToB<{ initialize: any; }>>' is not assignable to parameter of type 'NeededInfo<{}>'.
|
||||
Types of property 'ASchema' are incompatible.
|
||||
Type 'ToA<ToB<{ initialize: any; }>>' is not assignable to type 'ToA<{}>'.
|
||||
Type '{}' is not assignable to type 'ToB<{ initialize: any; }>'.
|
||||
tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts(66,38): error TS2344: Type 'NeededInfo<ToB<{ initialize: any; }>>' does not satisfy the constraint 'NeededInfo<{}>'.
|
||||
|
||||
|
||||
==== tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts (2 errors) ====
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
|
||||
class Left<L, A> {
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: L) {}
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return this as any
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: A) {}
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return new Right(f(this.value))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any;
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
readonly _A!: A;
|
||||
readonly _O!: O;
|
||||
readonly _I!: I;
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ??
|
||||
~~~~
|
||||
!!! error TS2345: Argument of type 'NeededInfo<ToB<{ initialize: any; }>>' is not assignable to parameter of type 'NeededInfo<{}>'.
|
||||
!!! error TS2345: Types of property 'ASchema' are incompatible.
|
||||
!!! error TS2345: Type 'ToA<ToB<{ initialize: any; }>>' is not assignable to type 'ToA<{}>'.
|
||||
!!! error TS2345: Type '{}' is not assignable to type 'ToB<{ initialize: any; }>'.
|
||||
!!! related TS2728 tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts:59:39: 'initialize' is declared here.
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
~~~~~~
|
||||
!!! error TS2344: Type 'NeededInfo<ToB<{ initialize: any; }>>' does not satisfy the constraint 'NeededInfo<{}>'.
|
||||
|
|
@ -0,0 +1,146 @@
|
|||
//// [varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts]
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
|
||||
class Left<L, A> {
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: L) {}
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return this as any
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: A) {}
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return new Right(f(this.value))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any;
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
readonly _A!: A;
|
||||
readonly _O!: O;
|
||||
readonly _I!: I;
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ??
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
|
||||
//// [varianceProblingAndZeroOrderIndexSignatureRelationsAlign.js]
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
exports.__esModule = true;
|
||||
var Left = /** @class */ (function () {
|
||||
function Left(value) {
|
||||
this.value = value;
|
||||
this._tag = 'Left';
|
||||
}
|
||||
/** The given function is applied if this is a `Right` */
|
||||
Left.prototype.map = function (f) {
|
||||
return this;
|
||||
};
|
||||
Left.prototype.ap = function (fab) {
|
||||
return null;
|
||||
};
|
||||
return Left;
|
||||
}());
|
||||
var Right = /** @class */ (function () {
|
||||
function Right(value) {
|
||||
this.value = value;
|
||||
this._tag = 'Right';
|
||||
}
|
||||
Right.prototype.map = function (f) {
|
||||
return new Right(f(this.value));
|
||||
};
|
||||
Right.prototype.ap = function (fab) {
|
||||
return null;
|
||||
};
|
||||
return Right;
|
||||
}());
|
||||
var Type = /** @class */ (function () {
|
||||
function Type(
|
||||
/** a unique name for this codec */
|
||||
name,
|
||||
/** a custom type guard */
|
||||
is,
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
validate,
|
||||
/** converts a value of type A to a value of type O */
|
||||
encode) {
|
||||
this.name = name;
|
||||
this.is = is;
|
||||
this.validate = validate;
|
||||
this.encode = encode;
|
||||
}
|
||||
/** a version of `validate` with a default context */
|
||||
Type.prototype.decode = function (i) { return null; };
|
||||
return Type;
|
||||
}());
|
||||
var tmp1 = null;
|
||||
function tmp2(n) { }
|
||||
tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ??
|
||||
var Server = /** @class */ (function () {
|
||||
function Server() {
|
||||
}
|
||||
return Server;
|
||||
}());
|
||||
var MyServer = /** @class */ (function (_super) {
|
||||
__extends(MyServer, _super);
|
||||
function MyServer() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
return MyServer;
|
||||
}(Server)); // not assignable error at `MyInfo`
|
||||
exports.MyServer = MyServer;
|
||||
|
|
@ -0,0 +1,246 @@
|
|||
=== tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts ===
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 12))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 14))
|
||||
>Left : Symbol(Left, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 45))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 12))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 14))
|
||||
>Right : Symbol(Right, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 14, 1))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 12))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 14))
|
||||
|
||||
class Left<L, A> {
|
||||
>Left : Symbol(Left, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 45))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 11))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 13))
|
||||
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
>_tag : Symbol(Left._tag, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 18))
|
||||
|
||||
readonly _A!: A
|
||||
>_A : Symbol(Left._A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 3, 34))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 13))
|
||||
|
||||
readonly _L!: L
|
||||
>_L : Symbol(Left._L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 4, 19))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 11))
|
||||
|
||||
constructor(readonly value: L) {}
|
||||
>value : Symbol(Left.value, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 6, 16))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 11))
|
||||
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
>map : Symbol(Left.map, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 6, 37))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 8, 8))
|
||||
>f : Symbol(f, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 8, 11))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 8, 15))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 13))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 8, 8))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 11))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 8, 8))
|
||||
|
||||
return this as any
|
||||
>this : Symbol(Left, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 45))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
>ap : Symbol(Left.ap, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 10, 5))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 11, 7))
|
||||
>fab : Symbol(fab, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 11, 10))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 11))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 11, 26))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 13))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 11, 7))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 2, 11))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 11, 7))
|
||||
|
||||
return null as any
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
>Right : Symbol(Right, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 14, 1))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 12))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 14))
|
||||
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
>_tag : Symbol(Right._tag, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 19))
|
||||
|
||||
readonly _A!: A
|
||||
>_A : Symbol(Right._A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 17, 36))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 14))
|
||||
|
||||
readonly _L!: L
|
||||
>_L : Symbol(Right._L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 18, 19))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 12))
|
||||
|
||||
constructor(readonly value: A) {}
|
||||
>value : Symbol(Right.value, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 20, 16))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 14))
|
||||
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
>map : Symbol(Right.map, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 20, 37))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 21, 8))
|
||||
>f : Symbol(f, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 21, 11))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 21, 15))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 14))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 21, 8))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 12))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 21, 8))
|
||||
|
||||
return new Right(f(this.value))
|
||||
>Right : Symbol(Right, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 14, 1))
|
||||
>f : Symbol(f, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 21, 11))
|
||||
>this.value : Symbol(Right.value, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 20, 16))
|
||||
>this : Symbol(Right, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 14, 1))
|
||||
>value : Symbol(Right.value, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 20, 16))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
>ap : Symbol(Right.ap, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 23, 5))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 24, 7))
|
||||
>fab : Symbol(fab, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 24, 10))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 12))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 24, 26))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 14))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 24, 7))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 16, 12))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 24, 7))
|
||||
|
||||
return null as any;
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
>Type : Symbol(Type, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 27, 1))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 11))
|
||||
>O : Symbol(O, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 13))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 11))
|
||||
>I : Symbol(I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 20))
|
||||
|
||||
readonly _A!: A;
|
||||
>_A : Symbol(Type._A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 35))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 11))
|
||||
|
||||
readonly _O!: O;
|
||||
>_O : Symbol(Type._O, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 30, 18))
|
||||
>O : Symbol(O, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 13))
|
||||
|
||||
readonly _I!: I;
|
||||
>_I : Symbol(Type._I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 31, 18))
|
||||
>I : Symbol(I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 20))
|
||||
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
>name : Symbol(Type.name, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 33, 14))
|
||||
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
>is : Symbol(Type.is, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 35, 26))
|
||||
>u : Symbol(u, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 37, 18))
|
||||
>u : Symbol(u, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 37, 18))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 11))
|
||||
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
>validate : Symbol(Type.validate, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 37, 40))
|
||||
>input : Symbol(input, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 39, 24))
|
||||
>I : Symbol(I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 20))
|
||||
>context : Symbol(context, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 39, 33))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 0))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 11))
|
||||
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
>encode : Symbol(Type.encode, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 39, 68))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 41, 22))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 11))
|
||||
>O : Symbol(O, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 13))
|
||||
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
>decode : Symbol(Type.decode, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 42, 6))
|
||||
>i : Symbol(i, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 44, 9))
|
||||
>I : Symbol(I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 20))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 0, 0))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 29, 11))
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
>Any : Symbol(Any, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 45, 1))
|
||||
>Type : Symbol(Type, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 27, 1))
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
>TypeOf : Symbol(TypeOf, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 47, 44))
|
||||
>C : Symbol(C, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 49, 12))
|
||||
>Any : Symbol(Any, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 45, 1))
|
||||
>C : Symbol(C, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 49, 12))
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
>ToB : Symbol(ToB, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 49, 37))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 51, 9))
|
||||
>k : Symbol(k, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 51, 29))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 51, 9))
|
||||
>TypeOf : Symbol(TypeOf, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 47, 44))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 51, 9))
|
||||
>k : Symbol(k, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 51, 29))
|
||||
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
>ToA : Symbol(ToA, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 51, 59))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 52, 9))
|
||||
>k : Symbol(k, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 52, 17))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 52, 9))
|
||||
>Type : Symbol(Type, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 27, 1))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 52, 9))
|
||||
>k : Symbol(k, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 52, 17))
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
>NeededInfo : Symbol(NeededInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 52, 45))
|
||||
>MyNamespaceSchema : Symbol(MyNamespaceSchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 54, 16))
|
||||
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
>ASchema : Symbol(ASchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 54, 43))
|
||||
>ToA : Symbol(ToA, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 51, 59))
|
||||
>MyNamespaceSchema : Symbol(MyNamespaceSchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 54, 16))
|
||||
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
>MyInfo : Symbol(MyInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 56, 2))
|
||||
>NeededInfo : Symbol(NeededInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 52, 45))
|
||||
>ToB : Symbol(ToB, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 49, 37))
|
||||
>initialize : Symbol(initialize, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 58, 37))
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
>tmp1 : Symbol(tmp1, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 60, 5))
|
||||
>MyInfo : Symbol(MyInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 56, 2))
|
||||
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
>tmp2 : Symbol(tmp2, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 60, 27))
|
||||
>N : Symbol(N, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 61, 14))
|
||||
>NeededInfo : Symbol(NeededInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 52, 45))
|
||||
>n : Symbol(n, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 61, 36))
|
||||
>N : Symbol(N, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 61, 14))
|
||||
|
||||
tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ??
|
||||
>tmp2 : Symbol(tmp2, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 60, 27))
|
||||
>tmp1 : Symbol(tmp1, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 60, 5))
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
>Server : Symbol(Server, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 62, 11))
|
||||
>X : Symbol(X, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 64, 13))
|
||||
>NeededInfo : Symbol(NeededInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 52, 45))
|
||||
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
>MyServer : Symbol(MyServer, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 64, 37))
|
||||
>Server : Symbol(Server, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 62, 11))
|
||||
>MyInfo : Symbol(MyInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts, 56, 2))
|
||||
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
=== tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign.ts ===
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
>Either : Either<L, A>
|
||||
|
||||
class Left<L, A> {
|
||||
>Left : Left<L, A>
|
||||
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
>_tag : "Left"
|
||||
>'Left' : "Left"
|
||||
|
||||
readonly _A!: A
|
||||
>_A : A
|
||||
|
||||
readonly _L!: L
|
||||
>_L : L
|
||||
|
||||
constructor(readonly value: L) {}
|
||||
>value : L
|
||||
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
>map : <B>(f: (a: A) => B) => Either<L, B>
|
||||
>f : (a: A) => B
|
||||
>a : A
|
||||
|
||||
return this as any
|
||||
>this as any : any
|
||||
>this : this
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
>ap : <B>(fab: Either<L, (a: A) => B>) => Either<L, B>
|
||||
>fab : Either<L, (a: A) => B>
|
||||
>a : A
|
||||
|
||||
return null as any
|
||||
>null as any : any
|
||||
>null : null
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
>Right : Right<L, A>
|
||||
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
>_tag : "Right"
|
||||
>'Right' : "Right"
|
||||
|
||||
readonly _A!: A
|
||||
>_A : A
|
||||
|
||||
readonly _L!: L
|
||||
>_L : L
|
||||
|
||||
constructor(readonly value: A) {}
|
||||
>value : A
|
||||
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
>map : <B>(f: (a: A) => B) => Either<L, B>
|
||||
>f : (a: A) => B
|
||||
>a : A
|
||||
|
||||
return new Right(f(this.value))
|
||||
>new Right(f(this.value)) : Right<L, B>
|
||||
>Right : typeof Right
|
||||
>f(this.value) : B
|
||||
>f : (a: A) => B
|
||||
>this.value : A
|
||||
>this : this
|
||||
>value : A
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
>ap : <B>(fab: Either<L, (a: A) => B>) => Either<L, B>
|
||||
>fab : Either<L, (a: A) => B>
|
||||
>a : A
|
||||
|
||||
return null as any;
|
||||
>null as any : any
|
||||
>null : null
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
>Type : Type<A, O, I>
|
||||
|
||||
readonly _A!: A;
|
||||
>_A : A
|
||||
|
||||
readonly _O!: O;
|
||||
>_O : O
|
||||
|
||||
readonly _I!: I;
|
||||
>_I : I
|
||||
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
>name : string
|
||||
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
>is : (u: unknown) => u is A
|
||||
>u : unknown
|
||||
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
>validate : (input: I, context: {}[]) => Either<{}[], A>
|
||||
>input : I
|
||||
>context : {}[]
|
||||
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
>encode : (a: A) => O
|
||||
>a : A
|
||||
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
>decode : (i: I) => Either<{}[], A>
|
||||
>i : I
|
||||
>null as any : any
|
||||
>null : null
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
>TypeOf : C["_A"]
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
>ToB : ToB<S>
|
||||
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
>ToA : ToA<S>
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
>NeededInfo : NeededInfo<MyNamespaceSchema>
|
||||
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
>ASchema : ToA<MyNamespaceSchema>
|
||||
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
>MyInfo : NeededInfo<ToB<{ initialize: any; }>>
|
||||
>initialize : any
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
>tmp1 : NeededInfo<ToB<{ initialize: any; }>>
|
||||
>null! : never
|
||||
>null : null
|
||||
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
>tmp2 : <N extends NeededInfo<{}>>(n: N) => void
|
||||
>n : N
|
||||
|
||||
tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ??
|
||||
>tmp2(tmp1) : any
|
||||
>tmp2 : <N extends NeededInfo<{}>>(n: N) => void
|
||||
>tmp1 : NeededInfo<ToB<{ initialize: any; }>>
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
>Server : Server<X>
|
||||
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
>MyServer : MyServer
|
||||
>Server : Server<NeededInfo<ToB<{ initialize: any; }>>>
|
||||
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts(66,38): error TS2344: Type 'NeededInfo<ToB<{ initialize: any; }>>' does not satisfy the constraint 'NeededInfo<{}>'.
|
||||
Types of property 'ASchema' are incompatible.
|
||||
Type 'ToA<ToB<{ initialize: any; }>>' is not assignable to type 'ToA<{}>'.
|
||||
Type '{}' is not assignable to type 'ToB<{ initialize: any; }>'.
|
||||
|
||||
|
||||
==== tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts (1 errors) ====
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
|
||||
class Left<L, A> {
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: L) {}
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return this as any
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: A) {}
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return new Right(f(this.value))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any;
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
readonly _A!: A;
|
||||
readonly _O!: O;
|
||||
readonly _I!: I;
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
// tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ?? (see test 1, needs to behave the same)
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
~~~~~~
|
||||
!!! error TS2344: Type 'NeededInfo<ToB<{ initialize: any; }>>' does not satisfy the constraint 'NeededInfo<{}>'.
|
||||
!!! error TS2344: Types of property 'ASchema' are incompatible.
|
||||
!!! error TS2344: Type 'ToA<ToB<{ initialize: any; }>>' is not assignable to type 'ToA<{}>'.
|
||||
!!! error TS2344: Type '{}' is not assignable to type 'ToB<{ initialize: any; }>'.
|
||||
!!! related TS2728 tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts:59:39: 'initialize' is declared here.
|
||||
|
|
@ -0,0 +1,146 @@
|
|||
//// [varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts]
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
|
||||
class Left<L, A> {
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: L) {}
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return this as any
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: A) {}
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return new Right(f(this.value))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any;
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
readonly _A!: A;
|
||||
readonly _O!: O;
|
||||
readonly _I!: I;
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
// tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ?? (see test 1, needs to behave the same)
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
|
||||
//// [varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.js]
|
||||
"use strict";
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
exports.__esModule = true;
|
||||
var Left = /** @class */ (function () {
|
||||
function Left(value) {
|
||||
this.value = value;
|
||||
this._tag = 'Left';
|
||||
}
|
||||
/** The given function is applied if this is a `Right` */
|
||||
Left.prototype.map = function (f) {
|
||||
return this;
|
||||
};
|
||||
Left.prototype.ap = function (fab) {
|
||||
return null;
|
||||
};
|
||||
return Left;
|
||||
}());
|
||||
var Right = /** @class */ (function () {
|
||||
function Right(value) {
|
||||
this.value = value;
|
||||
this._tag = 'Right';
|
||||
}
|
||||
Right.prototype.map = function (f) {
|
||||
return new Right(f(this.value));
|
||||
};
|
||||
Right.prototype.ap = function (fab) {
|
||||
return null;
|
||||
};
|
||||
return Right;
|
||||
}());
|
||||
var Type = /** @class */ (function () {
|
||||
function Type(
|
||||
/** a unique name for this codec */
|
||||
name,
|
||||
/** a custom type guard */
|
||||
is,
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
validate,
|
||||
/** converts a value of type A to a value of type O */
|
||||
encode) {
|
||||
this.name = name;
|
||||
this.is = is;
|
||||
this.validate = validate;
|
||||
this.encode = encode;
|
||||
}
|
||||
/** a version of `validate` with a default context */
|
||||
Type.prototype.decode = function (i) { return null; };
|
||||
return Type;
|
||||
}());
|
||||
var tmp1 = null;
|
||||
function tmp2(n) { }
|
||||
// tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ?? (see test 1, needs to behave the same)
|
||||
var Server = /** @class */ (function () {
|
||||
function Server() {
|
||||
}
|
||||
return Server;
|
||||
}());
|
||||
var MyServer = /** @class */ (function (_super) {
|
||||
__extends(MyServer, _super);
|
||||
function MyServer() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
return MyServer;
|
||||
}(Server)); // not assignable error at `MyInfo`
|
||||
exports.MyServer = MyServer;
|
||||
|
|
@ -0,0 +1,244 @@
|
|||
=== tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts ===
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 12))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 14))
|
||||
>Left : Symbol(Left, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 45))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 12))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 14))
|
||||
>Right : Symbol(Right, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 14, 1))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 12))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 14))
|
||||
|
||||
class Left<L, A> {
|
||||
>Left : Symbol(Left, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 45))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 11))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 13))
|
||||
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
>_tag : Symbol(Left._tag, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 18))
|
||||
|
||||
readonly _A!: A
|
||||
>_A : Symbol(Left._A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 3, 34))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 13))
|
||||
|
||||
readonly _L!: L
|
||||
>_L : Symbol(Left._L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 4, 19))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 11))
|
||||
|
||||
constructor(readonly value: L) {}
|
||||
>value : Symbol(Left.value, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 6, 16))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 11))
|
||||
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
>map : Symbol(Left.map, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 6, 37))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 8, 8))
|
||||
>f : Symbol(f, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 8, 11))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 8, 15))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 13))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 8, 8))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 11))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 8, 8))
|
||||
|
||||
return this as any
|
||||
>this : Symbol(Left, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 45))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
>ap : Symbol(Left.ap, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 10, 5))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 11, 7))
|
||||
>fab : Symbol(fab, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 11, 10))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 11))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 11, 26))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 13))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 11, 7))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 2, 11))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 11, 7))
|
||||
|
||||
return null as any
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
>Right : Symbol(Right, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 14, 1))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 12))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 14))
|
||||
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
>_tag : Symbol(Right._tag, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 19))
|
||||
|
||||
readonly _A!: A
|
||||
>_A : Symbol(Right._A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 17, 36))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 14))
|
||||
|
||||
readonly _L!: L
|
||||
>_L : Symbol(Right._L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 18, 19))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 12))
|
||||
|
||||
constructor(readonly value: A) {}
|
||||
>value : Symbol(Right.value, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 20, 16))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 14))
|
||||
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
>map : Symbol(Right.map, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 20, 37))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 21, 8))
|
||||
>f : Symbol(f, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 21, 11))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 21, 15))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 14))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 21, 8))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 12))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 21, 8))
|
||||
|
||||
return new Right(f(this.value))
|
||||
>Right : Symbol(Right, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 14, 1))
|
||||
>f : Symbol(f, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 21, 11))
|
||||
>this.value : Symbol(Right.value, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 20, 16))
|
||||
>this : Symbol(Right, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 14, 1))
|
||||
>value : Symbol(Right.value, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 20, 16))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
>ap : Symbol(Right.ap, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 23, 5))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 24, 7))
|
||||
>fab : Symbol(fab, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 24, 10))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 12))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 24, 26))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 14))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 24, 7))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 0))
|
||||
>L : Symbol(L, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 16, 12))
|
||||
>B : Symbol(B, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 24, 7))
|
||||
|
||||
return null as any;
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
>Type : Symbol(Type, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 27, 1))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 11))
|
||||
>O : Symbol(O, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 13))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 11))
|
||||
>I : Symbol(I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 20))
|
||||
|
||||
readonly _A!: A;
|
||||
>_A : Symbol(Type._A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 35))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 11))
|
||||
|
||||
readonly _O!: O;
|
||||
>_O : Symbol(Type._O, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 30, 18))
|
||||
>O : Symbol(O, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 13))
|
||||
|
||||
readonly _I!: I;
|
||||
>_I : Symbol(Type._I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 31, 18))
|
||||
>I : Symbol(I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 20))
|
||||
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
>name : Symbol(Type.name, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 33, 14))
|
||||
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
>is : Symbol(Type.is, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 35, 26))
|
||||
>u : Symbol(u, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 37, 18))
|
||||
>u : Symbol(u, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 37, 18))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 11))
|
||||
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
>validate : Symbol(Type.validate, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 37, 40))
|
||||
>input : Symbol(input, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 39, 24))
|
||||
>I : Symbol(I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 20))
|
||||
>context : Symbol(context, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 39, 33))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 0))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 11))
|
||||
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
>encode : Symbol(Type.encode, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 39, 68))
|
||||
>a : Symbol(a, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 41, 22))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 11))
|
||||
>O : Symbol(O, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 13))
|
||||
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
>decode : Symbol(Type.decode, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 42, 6))
|
||||
>i : Symbol(i, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 44, 9))
|
||||
>I : Symbol(I, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 20))
|
||||
>Either : Symbol(Either, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 0, 0))
|
||||
>A : Symbol(A, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 29, 11))
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
>Any : Symbol(Any, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 45, 1))
|
||||
>Type : Symbol(Type, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 27, 1))
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
>TypeOf : Symbol(TypeOf, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 47, 44))
|
||||
>C : Symbol(C, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 49, 12))
|
||||
>Any : Symbol(Any, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 45, 1))
|
||||
>C : Symbol(C, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 49, 12))
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
>ToB : Symbol(ToB, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 49, 37))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 51, 9))
|
||||
>k : Symbol(k, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 51, 29))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 51, 9))
|
||||
>TypeOf : Symbol(TypeOf, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 47, 44))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 51, 9))
|
||||
>k : Symbol(k, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 51, 29))
|
||||
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
>ToA : Symbol(ToA, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 51, 59))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 52, 9))
|
||||
>k : Symbol(k, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 52, 17))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 52, 9))
|
||||
>Type : Symbol(Type, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 27, 1))
|
||||
>S : Symbol(S, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 52, 9))
|
||||
>k : Symbol(k, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 52, 17))
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
>NeededInfo : Symbol(NeededInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 52, 45))
|
||||
>MyNamespaceSchema : Symbol(MyNamespaceSchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 54, 16))
|
||||
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
>ASchema : Symbol(ASchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 54, 43))
|
||||
>ToA : Symbol(ToA, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 51, 59))
|
||||
>MyNamespaceSchema : Symbol(MyNamespaceSchema, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 54, 16))
|
||||
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
>MyInfo : Symbol(MyInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 56, 2))
|
||||
>NeededInfo : Symbol(NeededInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 52, 45))
|
||||
>ToB : Symbol(ToB, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 49, 37))
|
||||
>initialize : Symbol(initialize, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 58, 37))
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
>tmp1 : Symbol(tmp1, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 60, 5))
|
||||
>MyInfo : Symbol(MyInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 56, 2))
|
||||
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
>tmp2 : Symbol(tmp2, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 60, 27))
|
||||
>N : Symbol(N, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 61, 14))
|
||||
>NeededInfo : Symbol(NeededInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 52, 45))
|
||||
>n : Symbol(n, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 61, 36))
|
||||
>N : Symbol(N, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 61, 14))
|
||||
|
||||
// tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ?? (see test 1, needs to behave the same)
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
>Server : Symbol(Server, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 61, 44))
|
||||
>X : Symbol(X, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 64, 13))
|
||||
>NeededInfo : Symbol(NeededInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 52, 45))
|
||||
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
>MyServer : Symbol(MyServer, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 64, 37))
|
||||
>Server : Symbol(Server, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 61, 44))
|
||||
>MyInfo : Symbol(MyInfo, Decl(varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts, 56, 2))
|
||||
|
||||
|
|
@ -0,0 +1,165 @@
|
|||
=== tests/cases/compiler/varianceProblingAndZeroOrderIndexSignatureRelationsAlign2.ts ===
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
>Either : Either<L, A>
|
||||
|
||||
class Left<L, A> {
|
||||
>Left : Left<L, A>
|
||||
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
>_tag : "Left"
|
||||
>'Left' : "Left"
|
||||
|
||||
readonly _A!: A
|
||||
>_A : A
|
||||
|
||||
readonly _L!: L
|
||||
>_L : L
|
||||
|
||||
constructor(readonly value: L) {}
|
||||
>value : L
|
||||
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
>map : <B>(f: (a: A) => B) => Either<L, B>
|
||||
>f : (a: A) => B
|
||||
>a : A
|
||||
|
||||
return this as any
|
||||
>this as any : any
|
||||
>this : this
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
>ap : <B>(fab: Either<L, (a: A) => B>) => Either<L, B>
|
||||
>fab : Either<L, (a: A) => B>
|
||||
>a : A
|
||||
|
||||
return null as any
|
||||
>null as any : any
|
||||
>null : null
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
>Right : Right<L, A>
|
||||
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
>_tag : "Right"
|
||||
>'Right' : "Right"
|
||||
|
||||
readonly _A!: A
|
||||
>_A : A
|
||||
|
||||
readonly _L!: L
|
||||
>_L : L
|
||||
|
||||
constructor(readonly value: A) {}
|
||||
>value : A
|
||||
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
>map : <B>(f: (a: A) => B) => Either<L, B>
|
||||
>f : (a: A) => B
|
||||
>a : A
|
||||
|
||||
return new Right(f(this.value))
|
||||
>new Right(f(this.value)) : Right<L, B>
|
||||
>Right : typeof Right
|
||||
>f(this.value) : B
|
||||
>f : (a: A) => B
|
||||
>this.value : A
|
||||
>this : this
|
||||
>value : A
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
>ap : <B>(fab: Either<L, (a: A) => B>) => Either<L, B>
|
||||
>fab : Either<L, (a: A) => B>
|
||||
>a : A
|
||||
|
||||
return null as any;
|
||||
>null as any : any
|
||||
>null : null
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
>Type : Type<A, O, I>
|
||||
|
||||
readonly _A!: A;
|
||||
>_A : A
|
||||
|
||||
readonly _O!: O;
|
||||
>_O : O
|
||||
|
||||
readonly _I!: I;
|
||||
>_I : I
|
||||
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
>name : string
|
||||
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
>is : (u: unknown) => u is A
|
||||
>u : unknown
|
||||
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
>validate : (input: I, context: {}[]) => Either<{}[], A>
|
||||
>input : I
|
||||
>context : {}[]
|
||||
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
>encode : (a: A) => O
|
||||
>a : A
|
||||
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
>decode : (i: I) => Either<{}[], A>
|
||||
>i : I
|
||||
>null as any : any
|
||||
>null : null
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
>TypeOf : C["_A"]
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
>ToB : ToB<S>
|
||||
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
>ToA : ToA<S>
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
>NeededInfo : NeededInfo<MyNamespaceSchema>
|
||||
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
>ASchema : ToA<MyNamespaceSchema>
|
||||
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
>MyInfo : NeededInfo<ToB<{ initialize: any; }>>
|
||||
>initialize : any
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
>tmp1 : NeededInfo<ToB<{ initialize: any; }>>
|
||||
>null! : never
|
||||
>null : null
|
||||
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
>tmp2 : <N extends NeededInfo<{}>>(n: N) => void
|
||||
>n : N
|
||||
|
||||
// tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ?? (see test 1, needs to behave the same)
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
>Server : Server<X>
|
||||
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
>MyServer : MyServer
|
||||
>Server : Server<NeededInfo<ToB<{ initialize: any; }>>>
|
||||
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
// @strict: true
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
|
||||
class Left<L, A> {
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: L) {}
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return this as any
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: A) {}
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return new Right(f(this.value))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any;
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
readonly _A!: A;
|
||||
readonly _O!: O;
|
||||
readonly _I!: I;
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ??
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
// @strict: true
|
||||
type Either<L, A> = Left<L, A> | Right<L, A>;
|
||||
|
||||
class Left<L, A> {
|
||||
readonly _tag: 'Left' = 'Left'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: L) {}
|
||||
/** The given function is applied if this is a `Right` */
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return this as any
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any
|
||||
}
|
||||
}
|
||||
|
||||
class Right<L, A> {
|
||||
readonly _tag: 'Right' = 'Right'
|
||||
readonly _A!: A
|
||||
readonly _L!: L
|
||||
constructor(readonly value: A) {}
|
||||
map<B>(f: (a: A) => B): Either<L, B> {
|
||||
return new Right(f(this.value))
|
||||
}
|
||||
ap<B>(fab: Either<L, (a: A) => B>): Either<L, B> {
|
||||
return null as any;
|
||||
}
|
||||
}
|
||||
|
||||
class Type<A, O = A, I = unknown> {
|
||||
readonly _A!: A;
|
||||
readonly _O!: O;
|
||||
readonly _I!: I;
|
||||
constructor(
|
||||
/** a unique name for this codec */
|
||||
readonly name: string,
|
||||
/** a custom type guard */
|
||||
readonly is: (u: unknown) => u is A,
|
||||
/** succeeds if a value of type I can be decoded to a value of type A */
|
||||
readonly validate: (input: I, context: {}[]) => Either<{}[], A>,
|
||||
/** converts a value of type A to a value of type O */
|
||||
readonly encode: (a: A) => O
|
||||
) {}
|
||||
/** a version of `validate` with a default context */
|
||||
decode(i: I): Either<{}[], A> { return null as any; }
|
||||
}
|
||||
|
||||
interface Any extends Type<any, any, any> {}
|
||||
|
||||
type TypeOf<C extends Any> = C["_A"];
|
||||
|
||||
type ToB<S extends any> = { [k in keyof S]: TypeOf<S[k]> };
|
||||
type ToA<S> = { [k in keyof S]: Type<S[k]> };
|
||||
|
||||
type NeededInfo<MyNamespaceSchema = {}> = {
|
||||
ASchema: ToA<MyNamespaceSchema>;
|
||||
};
|
||||
|
||||
export type MyInfo = NeededInfo<ToB<{ initialize: any }>>;
|
||||
|
||||
const tmp1: MyInfo = null!;
|
||||
function tmp2<N extends NeededInfo>(n: N) {}
|
||||
// tmp2(tmp1); // uncommenting this line removes a type error from a completely unrelated line ?? (see test 1, needs to behave the same)
|
||||
|
||||
class Server<X extends NeededInfo> {}
|
||||
export class MyServer extends Server<MyInfo> {} // not assignable error at `MyInfo`
|
||||
Loading…
Reference in a new issue