Support 'readonly' type modifier on array and tuple types

ahejlsberg · ahejlsberg · commit bb8378fddf04 · 2019-01-15T09:43:39.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -3592,14 +3592,15 @@ namespace ts {
 
                 function typeReferenceToTypeNode(type: TypeReference) {
                     const typeArguments: ReadonlyArray<Type> = type.typeArguments || emptyArray;
-                    if (type.target === globalArrayType) {
+                    if (type.target === globalArrayType || type.target === globalReadonlyArrayType) {
                         if (context.flags & NodeBuilderFlags.WriteArrayAsGenericType) {
                             const typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context);
-                            return createTypeReferenceNode("Array", [typeArgumentNode]);
+                            return createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]);
                         }
 
                         const elementType = typeToTypeNodeHelper(typeArguments[0], context);
-                        return createArrayTypeNode(elementType);
+                        const arrayType = createArrayTypeNode(elementType);
+                        return type.target === globalArrayType ? arrayType : createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, arrayType);
                     }
                     else if (type.target.objectFlags & ObjectFlags.Tuple) {
                         if (typeArguments.length > 0) {
@@ -3613,11 +3614,12 @@ namespace ts {
                                         createOptionalTypeNode(tupleConstituentNodes[i]);
                                 }
                                 const tupleTypeNode = createTupleTypeNode(tupleConstituentNodes);
-                                return (<TupleType>type.target).readonly ? createTypeReferenceNode("Readonly", [tupleTypeNode]) : tupleTypeNode;
+                                return (<TupleType>type.target).readonly ? createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, tupleTypeNode) : tupleTypeNode;
                             }
                         }
                         if (context.encounteredError || (context.flags & NodeBuilderFlags.AllowEmptyTuple)) {
-                            return createTupleTypeNode([]);
+                            const tupleTypeNode = createTupleTypeNode([]);
+                            return (<TupleType>type.target).readonly ? createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, tupleTypeNode) : tupleTypeNode;
                         }
                         context.encounteredError = true;
                         return undefined!; // TODO: GH#18217
@@ -9030,11 +9032,15 @@ namespace ts {
         function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type {
             const links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType));
+                links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType), isReadonlyTypeOperator(node.parent));
             }
             return links.resolvedType;
         }
 
+        function isReadonlyTypeOperator(node: Node) {
+            return isTypeOperatorNode(node) && node.operator === SyntaxKind.ReadonlyKeyword;
+        }
+
         // We represent tuple types as type references to synthesized generic interface types created by
         // this function. The types are of the form:
         //
@@ -9114,7 +9120,7 @@ namespace ts {
                     const type = getTypeFromTypeNode(n);
                     return n === restElement && getIndexTypeOfType(type, IndexKind.Number) || type;
                 });
-                links.resolvedType = createTupleType(elementTypes, minLength, !!restElement);
+                links.resolvedType = createTupleType(elementTypes, minLength, !!restElement, isReadonlyTypeOperator(node.parent));
             }
             return links.resolvedType;
         }
@@ -9667,6 +9673,9 @@ namespace ts {
                             ? getESSymbolLikeTypeForNode(walkUpParenthesizedTypes(node.parent))
                             : errorType;
                         break;
+                    case SyntaxKind.ReadonlyKeyword:
+                        links.resolvedType = getTypeFromTypeNode(node.type);
+                        break;
                 }
             }
             return links.resolvedType!; // TODO: GH#18217
@@ -30513,6 +30522,11 @@ namespace ts {
                         return grammarErrorOnNode(node, Diagnostics.unique_symbol_types_are_not_allowed_here);
                 }
             }
+            else if (node.operator === SyntaxKind.ReadonlyKeyword) {
+                if (node.type.kind !== SyntaxKind.ArrayType && node.type.kind !== SyntaxKind.TupleType) {
+                    return grammarErrorOnFirstToken(node, Diagnostics.readonly_type_modifier_is_only_permitted_on_array_and_typle_types, tokenToString(SyntaxKind.SymbolKeyword));
+                }
+            }
         }
 
         function checkGrammarForInvalidDynamicName(node: DeclarationName, message: DiagnosticMessage) {
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -1023,6 +1023,10 @@
         "category": "Error",
         "code": 1353
     },
+    "'readonly' type modifier is only permitted on array and typle types.": {
+        "category": "Error",
+        "code": 1354
+    },
 
     "Duplicate identifier '{0}'.": {
         "category": "Error",
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
@@ -876,8 +876,8 @@ namespace ts {
     }
 
     export function createTypeOperatorNode(type: TypeNode): TypeOperatorNode;
-    export function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword, type: TypeNode): TypeOperatorNode;
-    export function createTypeOperatorNode(operatorOrType: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | TypeNode, type?: TypeNode) {
+    export function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
+    export function createTypeOperatorNode(operatorOrType: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword | TypeNode, type?: TypeNode) {
         const node = createSynthesizedNode(SyntaxKind.TypeOperator) as TypeOperatorNode;
         node.operator = typeof operatorOrType === "number" ? operatorOrType : SyntaxKind.KeyOfKeyword;
         node.type = parenthesizeElementTypeMember(typeof operatorOrType === "number" ? type! : operatorOrType);
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -2962,6 +2962,7 @@ namespace ts {
                 case SyntaxKind.NumberKeyword:
                 case SyntaxKind.BigIntKeyword:
                 case SyntaxKind.BooleanKeyword:
+                case SyntaxKind.ReadonlyKeyword:
                 case SyntaxKind.SymbolKeyword:
                 case SyntaxKind.UniqueKeyword:
                 case SyntaxKind.VoidKeyword:
@@ -3051,7 +3052,7 @@ namespace ts {
             return finishNode(postfix);
         }
 
-        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword) {
+        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
             const node = <TypeOperatorNode>createNode(SyntaxKind.TypeOperator);
             parseExpected(operator);
             node.operator = operator;
@@ -3073,6 +3074,7 @@ namespace ts {
             switch (operator) {
                 case SyntaxKind.KeyOfKeyword:
                 case SyntaxKind.UniqueKeyword:
+                case SyntaxKind.ReadonlyKeyword:
                     return parseTypeOperator(operator);
                 case SyntaxKind.InferKeyword:
                     return parseInferType();
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -1233,7 +1233,7 @@ namespace ts {
 
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
         type: TypeNode;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -3592,14 +3592,15 @@ namespace ts {`
`3592`	`3592`
`3593`	`3593`	`function typeReferenceToTypeNode(type: TypeReference) {`
`3594`	`3594`	`const typeArguments: ReadonlyArray<Type> = type.typeArguments \|\| emptyArray;`
`3595`		`- if (type.target === globalArrayType) {`
	`3595`	`+ if (type.target === globalArrayType \|\| type.target === globalReadonlyArrayType) {`
`3596`	`3596`	`if (context.flags & NodeBuilderFlags.WriteArrayAsGenericType) {`
`3597`	`3597`	`const typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context);`
`3598`		`- return createTypeReferenceNode("Array", [typeArgumentNode]);`
	`3598`	`+ return createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]);`
`3599`	`3599`	`}`
`3600`	`3600`
`3601`	`3601`	`const elementType = typeToTypeNodeHelper(typeArguments[0], context);`
`3602`		`- return createArrayTypeNode(elementType);`
	`3602`	`+ const arrayType = createArrayTypeNode(elementType);`
	`3603`	`+ return type.target === globalArrayType ? arrayType : createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, arrayType);`
`3603`	`3604`	`}`
`3604`	`3605`	`else if (type.target.objectFlags & ObjectFlags.Tuple) {`
`3605`	`3606`	`if (typeArguments.length > 0) {`
`@@ -3613,11 +3614,12 @@ namespace ts {`
`3613`	`3614`	`createOptionalTypeNode(tupleConstituentNodes[i]);`
`3614`	`3615`	`}`
`3615`	`3616`	`const tupleTypeNode = createTupleTypeNode(tupleConstituentNodes);`
`3616`		`- return (<TupleType>type.target).readonly ? createTypeReferenceNode("Readonly", [tupleTypeNode]) : tupleTypeNode;`
	`3617`	`+ return (<TupleType>type.target).readonly ? createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, tupleTypeNode) : tupleTypeNode;`
`3617`	`3618`	`}`
`3618`	`3619`	`}`
`3619`	`3620`	`if (context.encounteredError \|\| (context.flags & NodeBuilderFlags.AllowEmptyTuple)) {`
`3620`		`- return createTupleTypeNode([]);`
	`3621`	`+ const tupleTypeNode = createTupleTypeNode([]);`
	`3622`	`+ return (<TupleType>type.target).readonly ? createTypeOperatorNode(SyntaxKind.ReadonlyKeyword, tupleTypeNode) : tupleTypeNode;`
`3621`	`3623`	`}`
`3622`	`3624`	`context.encounteredError = true;`
`3623`	`3625`	`return undefined!; // TODO: GH#18217`
`@@ -9030,11 +9032,15 @@ namespace ts {`
`9030`	`9032`	`function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type {`
`9031`	`9033`	`const links = getNodeLinks(node);`
`9032`	`9034`	`if (!links.resolvedType) {`
`9033`		`- links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType));`
	`9035`	`+ links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType), isReadonlyTypeOperator(node.parent));`
`9034`	`9036`	`}`
`9035`	`9037`	`return links.resolvedType;`
`9036`	`9038`	`}`
`9037`	`9039`
	`9040`	`+ function isReadonlyTypeOperator(node: Node) {`
	`9041`	`+ return isTypeOperatorNode(node) && node.operator === SyntaxKind.ReadonlyKeyword;`
	`9042`	`+ }`
	`9043`	`+`
`9038`	`9044`	`// We represent tuple types as type references to synthesized generic interface types created by`
`9039`	`9045`	`// this function. The types are of the form:`
`9040`	`9046`	`//`
`@@ -9114,7 +9120,7 @@ namespace ts {`
`9114`	`9120`	`const type = getTypeFromTypeNode(n);`
`9115`	`9121`	`return n === restElement && getIndexTypeOfType(type, IndexKind.Number) \|\| type;`
`9116`	`9122`	`});`
`9117`		`- links.resolvedType = createTupleType(elementTypes, minLength, !!restElement);`
	`9123`	`+ links.resolvedType = createTupleType(elementTypes, minLength, !!restElement, isReadonlyTypeOperator(node.parent));`
`9118`	`9124`	`}`
`9119`	`9125`	`return links.resolvedType;`
`9120`	`9126`	`}`
`@@ -9667,6 +9673,9 @@ namespace ts {`
`9667`	`9673`	`? getESSymbolLikeTypeForNode(walkUpParenthesizedTypes(node.parent))`
`9668`	`9674`	`: errorType;`
`9669`	`9675`	`break;`
	`9676`	`+ case SyntaxKind.ReadonlyKeyword:`
	`9677`	`+ links.resolvedType = getTypeFromTypeNode(node.type);`
	`9678`	`+ break;`
`9670`	`9679`	`}`
`9671`	`9680`	`}`
`9672`	`9681`	`return links.resolvedType!; // TODO: GH#18217`
`@@ -30513,6 +30522,11 @@ namespace ts {`
`30513`	`30522`	`return grammarErrorOnNode(node, Diagnostics.unique_symbol_types_are_not_allowed_here);`
`30514`	`30523`	`}`
`30515`	`30524`	`}`
	`30525`	`+ else if (node.operator === SyntaxKind.ReadonlyKeyword) {`
	`30526`	`+ if (node.type.kind !== SyntaxKind.ArrayType && node.type.kind !== SyntaxKind.TupleType) {`
	`30527`	`+ return grammarErrorOnFirstToken(node, Diagnostics.readonly_type_modifier_is_only_permitted_on_array_and_typle_types, tokenToString(SyntaxKind.SymbolKeyword));`
	`30528`	`+ }`
	`30529`	`+ }`
`30516`	`30530`	`}`
`30517`	`30531`
`30518`	`30532`	`function checkGrammarForInvalidDynamicName(node: DeclarationName, message: DiagnosticMessage) {`
Original file line number	Diff line number	Diff line change
`@@ -1233,7 +1233,7 @@ namespace ts {`
`1233`	`1233`
`1234`	`1234`	`export interface TypeOperatorNode extends TypeNode {`
`1235`	`1235`	`kind: SyntaxKind.TypeOperator;`
`1236`		`- operator: SyntaxKind.KeyOfKeyword \| SyntaxKind.UniqueKeyword;`
	`1236`	`+ operator: SyntaxKind.KeyOfKeyword \| SyntaxKind.UniqueKeyword \| SyntaxKind.ReadonlyKeyword;`
`1237`	`1237`	`type: TypeNode;`
`1238`	`1238`	`}`
`1239`	`1239`