Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Exact types - [WIP] #28749

Closed
wants to merge 10 commits into from
Closed

Exact types - [WIP] #28749

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
85ca53d
WIP
jack-williams Nov 27, 2018
a254022
Dump of first 'working' version
jack-williams Nov 29, 2018
ac13155
Fix linting
jack-williams Nov 29, 2018
2f4799c
Add more cases
jack-williams Nov 30, 2018
7f67308
every -> some
jack-williams Dec 9, 2018
a7542d4
Delete whitespace
jack-williams Dec 9, 2018
3a05d6e
Tidy up conditions
jack-williams Dec 9, 2018
ced0cec
Tidy exact mapped types
jack-williams Dec 9, 2018
5e32420
Improve error messages
jack-williams Dec 15, 2018
8912ff8
Merge branch 'master' into exact-types
jack-williams Dec 15, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
73 changes: 63 additions & 10 deletions src/compiler/checker.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3468,7 +3468,7 @@ namespace ts {
}
const typeParameterNode = typeParameterToDeclarationWithConstraint(getTypeParameterFromMappedType(type), context, appropriateConstraintTypeNode);
const templateTypeNode = typeToTypeNodeHelper(getTemplateTypeFromMappedType(type), context);
const mappedTypeNode = createMappedTypeNode(readonlyToken, typeParameterNode, questionToken, templateTypeNode);
const mappedTypeNode = createMappedTypeNode(readonlyToken, typeParameterNode, questionToken, templateTypeNode, type.declaration.isExact);
context.approximateLength += 10;
return setEmitFlags(mappedTypeNode, EmitFlags.SingleLine);
}
Expand Down Expand Up @@ -3552,7 +3552,7 @@ namespace ts {
if (!resolved.properties.length && !resolved.stringIndexInfo && !resolved.numberIndexInfo) {
if (!resolved.callSignatures.length && !resolved.constructSignatures.length) {
context.approximateLength += 2;
return setEmitFlags(createTypeLiteralNode(/*members*/ undefined), EmitFlags.SingleLine);
return setEmitFlags(createTypeLiteralNode(/*members*/ undefined, !!(type.objectFlags & ObjectFlags.Exact)), EmitFlags.SingleLine);
}

if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
Expand All @@ -3573,7 +3573,7 @@ namespace ts {
context.flags |= NodeBuilderFlags.InObjectTypeLiteral;
const members = createTypeNodesFromResolvedType(resolved);
context.flags = savedFlags;
const typeLiteralNode = createTypeLiteralNode(members);
const typeLiteralNode = createTypeLiteralNode(members, !!(type.objectFlags & ObjectFlags.Exact));
context.approximateLength += 2;
return setEmitFlags(typeLiteralNode, (context.flags & NodeBuilderFlags.MultilineObjectLiterals) ? 0 : EmitFlags.SingleLine);
}
Expand Down Expand Up @@ -9762,7 +9762,11 @@ namespace ts {
function getTypeFromMappedTypeNode(node: MappedTypeNode): Type {
const links = getNodeLinks(node);
if (!links.resolvedType) {
const type = <MappedType>createObjectType(ObjectFlags.Mapped, node.symbol);
let flags = ObjectFlags.Mapped;
if (node.isExact) {
flags |= ObjectFlags.Exact;
}
const type = <MappedType>createObjectType(flags, node.symbol);
type.declaration = node;
type.aliasSymbol = getAliasSymbolForTypeNode(node);
type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(type.aliasSymbol);
Expand Down Expand Up @@ -9994,7 +9998,11 @@ namespace ts {
links.resolvedType = emptyTypeLiteralType;
}
else {
let type = createObjectType(ObjectFlags.Anonymous, node.symbol);
let flags = ObjectFlags.Anonymous;
if (isTypeLiteralNode(node) && node.isExact) {
flags |= ObjectFlags.Exact;
}
let type = createObjectType(flags, node.symbol);
type.aliasSymbol = aliasSymbol;
type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
if (isJSDocTypeLiteral(node) && node.isArrayType) {
Expand Down Expand Up @@ -11527,6 +11535,7 @@ namespace ts {
let expandingFlags = ExpandingFlags.None;
let overflow = false;
let suppressNextError = false;
let inExactContext = false;

Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");

Expand Down Expand Up @@ -11662,6 +11671,11 @@ namespace ts {
target = getSimplifiedType(target);
}

// Are we in a context that uses exact types? If so we
// disable excess property checking and just use exact
// type rules.
inExactContext = inExactContext || someType(target, t => (getObjectFlags(t) & ObjectFlags.Exact) !== 0);

// Try to see if we're relating something like `Foo` -> `Bar | null | undefined`.
// If so, reporting the `null` and `undefined` in the type is hardly useful.
// First, see if we're even relating an object type to a union.
Expand Down Expand Up @@ -11689,8 +11703,19 @@ namespace ts {
if (relation === comparableRelation && !(target.flags & TypeFlags.Never) && isSimpleTypeRelatedTo(target, source, relation) ||
isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined)) return Ternary.True;

if ((getObjectFlags(target) & ObjectFlags.Exact) && !(getObjectFlags(source) & (ObjectFlags.Exact | ObjectFlags.FreshLiteral))) {
if (reportErrors) {
reportRelationError(Diagnostics.Non_exact_types_are_not_assignable_to_exact_types, source, target);
}
return Ternary.False;
}

const isComparingJsxAttributes = !!(getObjectFlags(source) & ObjectFlags.JsxAttributes);
if (isObjectLiteralType(source) && getObjectFlags(source) & ObjectFlags.FreshLiteral) {

// if we are in an exact context, we should not drop freshness.
// we should only check excess if this is a literal
const shouldCheckExcess = !inExactContext || (getObjectFlags(target) & ObjectFlags.Exact);
if (shouldCheckExcess && isObjectLiteralType(source) && getObjectFlags(source) & ObjectFlags.FreshLiteral) {
const discriminantType = target.flags & TypeFlags.Union ? findMatchingDiscriminantType(source, target as UnionType) : undefined;
if (hasExcessProperties(<FreshObjectLiteralType>source, target, discriminantType, reportErrors)) {
if (reportErrors) {
Expand All @@ -11702,7 +11727,10 @@ namespace ts {
// and intersection types are further deconstructed on the target side, we don't want to
// make the check again (as it might fail for a partial target type). Therefore we obtain
// the regular source type and proceed with that.
if (isUnionOrIntersectionTypeWithoutNullableConstituents(target) && !discriminantType) {
//
// Note that if we are in an exact context we do not drop freshness incase we encounter a nested
// exact type and we need to know the source is a literal.
if (!inExactContext && isUnionOrIntersectionTypeWithoutNullableConstituents(target) && !discriminantType) {
source = getRegularTypeOfObjectLiteral(source);
}
}
Expand Down Expand Up @@ -11881,7 +11909,9 @@ namespace ts {
symbolToString(prop), typeToString(errorTarget), suggestion);
}
else {
reportError(Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
reportError(getObjectFlags(target) & ObjectFlags.Exact ?
Diagnostics.Object_literal_may_only_specify_known_properties_when_assigned_to_exact_type_and_0_does_not_exist_in_type_1 :
Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
symbolToString(prop), typeToString(errorTarget));
}
}
Expand Down Expand Up @@ -12457,6 +12487,18 @@ namespace ts {
getCombinedMappedTypeOptionality(source) <= getCombinedMappedTypeOptionality(target));
if (modifiersRelated) {
let result: Ternary;
if (getObjectFlags(target) & ObjectFlags.Exact) {
// TODO: Not sure if identical is right here and need Better errors here.
if (isTypeIdenticalTo(getConstraintTypeFromMappedType(target), getConstraintTypeFromMappedType(source))) {
const mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]);
return isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), reportErrors);
}
if (reportErrors) {
// Invariant. source must be exact.
reportError(Diagnostics.Exact_mapped_types_0_and_1_do_not_have_identical_key_constraints, typeToString(source), typeToString(target));
}
return Ternary.False;
}
if (result = isRelatedTo(getConstraintTypeFromMappedType(target), getConstraintTypeFromMappedType(source), reportErrors)) {
const mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]);
return result & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), reportErrors);
Expand Down Expand Up @@ -12494,13 +12536,15 @@ namespace ts {
}
return Ternary.False;
}
if (isObjectLiteralType(target)) {
if (isObjectLiteralType(target) || (getObjectFlags(target) & ObjectFlags.Exact)) {
for (const sourceProp of getPropertiesOfType(source)) {
if (!getPropertyOfObjectType(target, sourceProp.escapedName)) {
const sourceType = getTypeOfSymbol(sourceProp);
if (!(sourceType === undefinedType || sourceType === undefinedWideningType)) {
if (reportErrors) {
reportError(Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target));
reportError(getObjectFlags(target) & ObjectFlags.Exact ?
Diagnostics.Exact_types_may_only_include_specified_properties_and_0_does_not_exist_on_type_1 :
Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target));
}
return Ternary.False;
}
Expand Down Expand Up @@ -15102,6 +15146,10 @@ namespace ts {
return type.flags & TypeFlags.Union ? every((<UnionType>type).types, f) : f(type);
}

function someType(type: Type, f: (t: Type) => boolean): boolean {
return type.flags & TypeFlags.UnionOrIntersection ? some((<UnionOrIntersectionType>type).types, f) : f(type);
}

function filterType(type: Type, f: (t: Type) => boolean): Type {
if (type.flags & TypeFlags.Union) {
const types = (<UnionType>type).types;
Expand Down Expand Up @@ -21797,6 +21845,11 @@ namespace ts {
error(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference);
return booleanType;
}
const expression = (<PropertyAccessExpression>expr).expression;
const type = getTypeOfExpression(expression);
if (someType(type, t => (getObjectFlags(t) & ObjectFlags.Exact) !== 0)) {
error(expression, Diagnostics.Properties_on_exact_types_cannot_be_deleted);
}
const links = getNodeLinks(expr);
const symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol);
if (symbol && isReadonlySymbol(symbol)) {
Expand Down
21 changes: 20 additions & 1 deletion src/compiler/diagnosticMessages.json
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4137,7 +4137,26 @@
"category": "Error",
"code": 7051
},

"Non-exact types are not assignable to exact types.": {
"category": "Error",
"code": 7052
},
"Properties on exact types cannot be deleted.": {
"category": "Error",
"code": 7053
},
"Exact mapped types {0} and {1} do not have identical key constraints.": {
"category": "Error",
"code": 7054
},
"Object literal may only specify known properties when assigned to exact type, and '{0}' does not exist in type '{1}'.": {
"category": "Error",
"code": 7055
},
"Exact types may only include specified properties, and '{0}' does not exist on type '{1}'.": {
"category": "Error",
"code": 7056
},
"You cannot rename this element.": {
"category": "Error",
"code": 8000
Expand Down
12 changes: 12 additions & 0 deletions src/compiler/emitter.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1451,8 +1451,14 @@ namespace ts {

function emitTypeLiteral(node: TypeLiteralNode) {
writePunctuation("{");
if (node.isExact) {
writePunctuation("|");
}
const flags = getEmitFlags(node) & EmitFlags.SingleLine ? ListFormat.SingleLineTypeLiteralMembers : ListFormat.MultiLineTypeLiteralMembers;
emitList(node, node.members, flags | ListFormat.NoSpaceIfEmpty);
if (node.isExact) {
writePunctuation("|");
}
writePunctuation("}");
}

Expand Down Expand Up @@ -1534,6 +1540,9 @@ namespace ts {
function emitMappedType(node: MappedTypeNode) {
const emitFlags = getEmitFlags(node);
writePunctuation("{");
if (node.isExact) {
writePunctuation("|");
}
if (emitFlags & EmitFlags.SingleLine) {
writeSpace();
}
Expand Down Expand Up @@ -1571,6 +1580,9 @@ namespace ts {
writeLine();
decreaseIndent();
}
if (node.isExact) {
writePunctuation("|");
}
writePunctuation("}");
}

Expand Down
12 changes: 7 additions & 5 deletions src/compiler/factory.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -723,15 +723,16 @@ namespace ts {
: node;
}

export function createTypeLiteralNode(members: ReadonlyArray<TypeElement> | undefined) {
export function createTypeLiteralNode(members: ReadonlyArray<TypeElement> | undefined, isExact = false) {
const node = createSynthesizedNode(SyntaxKind.TypeLiteral) as TypeLiteralNode;
node.isExact = isExact;
node.members = createNodeArray(members);
return node;
}

export function updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray<TypeElement>) {
return node.members !== members
? updateNode(createTypeLiteralNode(members), node)
? updateNode(createTypeLiteralNode(members, node.isExact), node)
: node;
}

Expand Down Expand Up @@ -902,21 +903,22 @@ namespace ts {
: node;
}

export function createMappedTypeNode(readonlyToken: ReadonlyToken | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined): MappedTypeNode {
export function createMappedTypeNode(readonlyToken: ReadonlyToken | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined, isExact: boolean): MappedTypeNode {
const node = createSynthesizedNode(SyntaxKind.MappedType) as MappedTypeNode;
node.isExact = isExact;
node.readonlyToken = readonlyToken;
node.typeParameter = typeParameter;
node.questionToken = questionToken;
node.type = type;
return node;
}

export function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyToken | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined): MappedTypeNode {
export function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyToken | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined, isExact: boolean): MappedTypeNode {
return node.readonlyToken !== readonlyToken
|| node.typeParameter !== typeParameter
|| node.questionToken !== questionToken
|| node.type !== type
? updateNode(createMappedTypeNode(readonlyToken, typeParameter, questionToken, type), node)
? updateNode(createMappedTypeNode(readonlyToken, typeParameter, questionToken, type, isExact), node)
: node;
}

Expand Down
Loading