Readonly type literal members

Arthur Ozga · Arthur Ozga · commit 55388d16b4c9 · 2017-04-19T10:36:40.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -2602,14 +2602,17 @@ namespace ts {
                             }
                         }
                         else {
-
                             // TODO(aozgaa): should we create a node with explicit or implict any?
                             const propertyTypeNode = propertyType ? typeToTypeNodeHelper(propertyType, context) : createKeywordTypeNode(SyntaxKind.AnyKeyword);
-                            typeElements.push(createPropertySignature(
+
+                            const modifiers = isReadonlySymbol(propertySymbol) ? [createToken(SyntaxKind.ReadonlyKeyword)] : undefined;
+                            const propertySignature = createPropertySignature(
+                                modifiers,
                                 propertyName,
                                 optionalToken,
                                 propertyTypeNode,
-                               /*initializer*/undefined));
+                               /*initializer*/undefined);
+                            typeElements.push(propertySignature);
                         }
                     }
                     return typeElements.length ? typeElements : undefined;
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
@@ -480,21 +480,23 @@ namespace ts {
 
     // Signature elements
 
-    export function createPropertySignature(name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertySignature {
+    export function createPropertySignature(modifiers: Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertySignature {
         const propertySignature = createSynthesizedNode(SyntaxKind.PropertySignature) as PropertySignature;
+        propertySignature.modifiers = asNodeArray(modifiers);
         propertySignature.name = asName(name);
         propertySignature.questionToken = questionToken;
         propertySignature.type = type;
         propertySignature.initializer = initializer;
         return propertySignature;
     }
 
-    export function updatePropertySignature(node: PropertySignature, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) {
-        return node.name !== name
+    export function updatePropertySignature(node: PropertySignature, modifiers: Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) {
+        return node.modifiers !== modifiers
+            || node.name !== name
             || node.questionToken !== questionToken
             || node.type !== type
             || node.initializer !== initializer
-            ? updateNode(createPropertySignature(name, questionToken, type, initializer), node)
+            ? updateNode(createPropertySignature(modifiers, name, questionToken, type, initializer), node)
             : node;
     }
 
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
@@ -355,6 +355,8 @@ namespace ts {
 
             case SyntaxKind.PropertySignature:
                 return updatePropertySignature((<PropertySignature>node),
+                    // TODO: tokenVisitor or visitor for a nodearray of tokens?
+                    nodesVisitor((<PropertySignature>node).modifiers, visitor, isToken),
                     visitNode((<PropertySignature>node).name, visitor, isPropertyName),
                     visitNode((<PropertySignature>node).questionToken, tokenVisitor, isToken),
                     visitNode((<PropertySignature>node).type, visitor, isTypeNode),

Original file line number	Diff line number	Diff line change
`@@ -2602,14 +2602,17 @@ namespace ts {`
`2602`	`2602`	`}`
`2603`	`2603`	`}`
`2604`	`2604`	`else {`
`2605`		`-`
`2606`	`2605`	`// TODO(aozgaa): should we create a node with explicit or implict any?`
`2607`	`2606`	`const propertyTypeNode = propertyType ? typeToTypeNodeHelper(propertyType, context) : createKeywordTypeNode(SyntaxKind.AnyKeyword);`
`2608`		`- typeElements.push(createPropertySignature(`
	`2607`	`+`
	`2608`	`+ const modifiers = isReadonlySymbol(propertySymbol) ? [createToken(SyntaxKind.ReadonlyKeyword)] : undefined;`
	`2609`	`+ const propertySignature = createPropertySignature(`
	`2610`	`+ modifiers,`
`2609`	`2611`	`propertyName,`
`2610`	`2612`	`optionalToken,`
`2611`	`2613`	`propertyTypeNode,`
`2612`		`- /initializer/undefined));`
	`2614`	`+ /initializer/undefined);`
	`2615`	`+ typeElements.push(propertySignature);`
`2613`	`2616`	`}`
`2614`	`2617`	`}`
`2615`	`2618`	`return typeElements.length ? typeElements : undefined;`